hdu3572 Task Schedule 网络流（Dinic）

最近终于开始真正学习网络流了，发现这其实是个有趣的东西。现在看起来，EK，Dinic也不像以前那么难了

题目大意：工厂有m台机器，需要做n个任务。对于一个任务i，你需要花费一个机器Pi天，而且，开始做这个任务的时间要>=Si，完成这个任务的时间<=Ei。对于一个任务，只能由一个机器来完成，一个机器同一时间只能做一个任务。但是，一个任务可以分成几段不连续的时间来完成。问，能否做完全部任务。

首先，“对于一个任务，只能由一个机器来完成”这个条件，其实可以忽略，问题不变。

那么，把每一天和每个任务看做点。由源点到每一天，建容量为m的边。每一天到每个任务，若是可以在这天做任务，建一条容量为1的边，最后，把每个任务到汇点再建一条边。图就建好了。

Dinic代码抄白书，白书真是好东西！

//#pragma comment(linker, "/STACK:102400000,102400000")
#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<cmath>
#include<cctype>
#include<string>
#include<algorithm>
#include<iostream>
#include<ctime>
#include<map>
#include<set>
using namespace std;
#define MP(x,y) make_pair((x),(y))
#define PB(x) push_back(x)
typedef long long LL;
//typedef unsigned __int64 ULL;
/* ****************** */
const int INF=-1u>>1;
const double INFF=1e200;
const double eps=1e-8;
const LL mod=1000000007;
const int NN=1100;
const int MM=600010;
/* ****************** */

struct G
{
    int v,cap,next;
}E[MM];
int p[NN],T,d[NN],temp_p[NN];
int qw[NN];

void add(int u,int v,int cap)
{
    E[T].v=v;
    E[T].cap=cap;
    E[T].next=p[u];
    p[u]=T++;

    E[T].v=u;
    E[T].cap=0;
    E[T].next=p[v];
    p[v]=T++;
}

bool find_path(int st,int en,int n)
{
    int i,u,v,head,tail;
    for(i=0;i<=n;i++)
        d[i]=-1;
    head=tail=0;
    d[st]=0;
    qw[tail]=st;
    while(head<=tail)
    {
        u=qw[head++];
        for(i=p[u];i+1;i=E[i].next)
        {
            v=E[i].v;
            if(d[v]==-1 && E[i].cap>0)
            {
                d[v]=d[u]+1;
                qw[++tail]=v;
            }
        }
    }
    return (d[en]!=-1);
}

int dfs_flow(int u,int& en,int f)
{
    if(u==en || f==0)
        return f;
    int flow=0,temp;
    for( ; temp_p[u]+1 ; temp_p[u]=E[ temp_p[u] ].next )
    {
        G& e=E[temp_p[u]];
        if(d[u]+1==d[e.v])
        {
            temp=dfs_flow( e.v , en , min(f,e.cap) );
            if(temp>0)
            {
                e.cap-=temp;
                E[ temp_p[u]^1 ].cap+=temp;
                flow+=temp;
                f-=temp;
                if(f==0)
                    break;
            }
        }
    }
    return flow;
}

int dinic(int st,int en,int n)
{
    int i,ans=0;
    while( find_path(st,en,n) )
    {
        for(i=0;i<=n;i++)
            temp_p[i]=p[i];

        ans+=dfs_flow(st,en,INF);
    }
    return ans;
}

int main()
{
    int cas,ee=0;
    int n,m,i,j,c,s,e;
    int sum,st,en;
    scanf("%d",&cas);
    while(cas--)
    {
        memset(p,-1,sizeof(p));
        T=0;
        scanf("%d%d",&n,&m);
        sum=0;
        st=n+500+1;
        en=n+500+2;
        for(i=1;i<=n;i++)
        {
            scanf("%d%d%d",&c,&s,&e);
            sum+=c;
            for(j=s;j<=e;j++)
            {
                add(j,i+500,1);
            }
            add(i+500,en,c);
        }
        for(i=1;i<=500;i++)
        {
            add(st,i,m);
        }
        c=dinic(st,en,en);
     //   printf("flow==%d\n",c);
        printf("Case %d: ",++ee);
        if(c>=sum)
            puts("Yes\n");
        else
            puts("No\n");
    }
    return 0;
}