hdu 3572 Task Schedule（网络流最大流）

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


建图：把每个任务和每一天都看做一个点，添加源点和汇点。
源点与每个任务之间连一条边，容量为完成该任务所需处理次数。
若第i个任务可以在Si至Ei天处理，则由该任务向这些天分别连一条边，容量为1，表示此任务每天只能被处理一次。
最后，从每一天连一条到汇点的边，容量为机器数M，表示每天可以处理M个任务。
若求出的最大流等于所有任务需要处理的次数之和，说明能完成任务；否则，不能完成任务。
*/
# include<stdio.h>
# include<algorithm>
# include<stack>
#include<queue>
# include<string.h>
using namespace std;
#define inf 0x3fffff
#define N 1010
#define M 600010
//N为点数 M为边数
struct Edge
{
    int from, to, cap, nex;
} edge[M*2]; //双向边，注意RE 注意这个模版是 相同起末点的边 同时有效而不是去重
int head[N],tot;//2个要初始化-1和0
void add(int u, int v, int cap) //网络流要加反向弧，即u->v 为10 则 v->u为 -10
{
    Edge E = {u, v, cap, head[u]};
    edge[ tot ] = E;
    head[ u ] = tot++;

    Edge E2 = {v, u, 0,  head[v]}; //如果是无向边则rw的参数值和cap相同（即 add(u,v,cap,cap) ），若是有向边则rw不写（即 add(u,v,cap); ）
    edge[ tot ] = E2;
    head[ v ] = tot++;
}
int dis[N], cur[N];//dis[i]表示i点距离起点的距离 cur[i]表示i点所连接的边中 正在考虑的边 优化不再考虑已经用过的点 初始化为head
bool vis[N];
bool BFS(int Start,int End) //跑一遍最短路
{
    memset(vis,0,sizeof(vis));
    memset(dis,-1,sizeof(dis));

    queue<int>Q;
    Q.push(Start);
    dis[Start]=0;
    vis[Start]=1;
    while(!Q.empty())
    {
        int u = Q.front();
        Q.pop();
        for(int i = head[u]; i != -1; i = edge[i].nex)
        {
            Edge E = edge[i];
            if( !vis[E.to] && E.cap > 0)
            {
                vis[ E.to ] = true;
                dis[ E.to ] = dis[ u ] + 1;
                if(E.to == End)
                    return true;
                Q.push( E.to );
            }
        }
    }
    return false;
}
int DFS(int x, int a,int End) //当前 流入x 的流量是a   流量a 是所有流过边中 边权的最小值
{
    if( x == End || a == 0)return a;
    int flow = 0, f; //flow表示从x点流到下面所有点，最大的流量
    for(int& i = cur[x]; i != -1; i = edge[i].nex)
    {
        Edge& E = edge[i];
        if(dis[x] + 1 == dis[E.to] && (f = DFS(E.to , min(a, E.cap), End))>0 )
        {
            E.cap -= f;
            edge[ i^1 ].cap += f;//反向边要减掉
            flow += f;
            a -= f;
            if(a==0)break;
        }
    }
    return flow;
}
int Dinic(int Start,int End)
{
    int flow=0;
    while(BFS(Start,End))  //当存在源点到汇点的路径时
    {
        memcpy(cur,head,sizeof(head));//把head的数组复制过去
        flow += DFS(Start, inf, End);
        //  printf("%d\n",flow);
    }
    return flow;
}
void init()
{
    memset(head, -1, sizeof head);
    tot = 0;
}
int main()
{
    int t,m,n,i,j,p,s,e;
    while(~scanf("%d",&t))
    {
        int cas=0;
        while(t--)
        {
            init();
            scanf("%d%d",&n,&m);
            int sum=0;
            int maxx=0;
            for(i=1; i<=n; i++)
            {
                scanf("%d%d%d",&p,&s,&e);
                add(0,i,p);
                maxx=max(maxx,e);
                sum+=p;
                for(j=s; j<=e; j++)
                    add(i,j+n,1);
            }
            int sink=maxx+n+1;
            for(i=1; i<=maxx; i++)
                add(n+i,sink,m);
            if(Dinic(0,sink)==sum)
                printf("Case %d: Yes\n\n",++cas);
            else
                printf("Case %d: No\n\n",++cas);
        }
    }
    return 0;
}