网络流：HDU 3572

HDU 3572

hdu 3572

题意：你有一个工厂，工厂有M台机器，可以同时运作，然后给你N个任务，每个人有三个参数Pi，Si，Ei，Pi表示这个任务机器工作Pi个小时才能完成，然后你只能在[Si，Pi]这个闭区间的时间内去做这个任务，你可以分隔几个时间段来完成这个任务，就是说可以用一段不连续的时间来做这个任务。一台机器在一个时刻只能做一个任务，每个任务在一个时刻只能由一个机器来进行工作，问你能否在他给定的限制下完成任务，可以输出Yes，不行输出No。

解题思路：因为他说可以不连续的时间下来完成一个任务，那就相当于一个时刻完成一份工作量，对于一个任务需要Pi个工作量，M台机器相当于在一个时刻可以同时完成m个工作量，想到这里我们就可以用最大流来做这道题了。

sp=0,tp=n+500+1 //我们对把每个时间作为一个点，然后n个任务n个点。
addedge(sp,i,Pi) //起点向每个任务点建边，流量为总工作量Pi。
addedge(sp,n+[Si,Ei],1) //每个任务点，向允许的时间段的每个点建流量为1的边，唯一性。
addedge(n+[Si,Ei]{i∈[1,n]},tp,m) //每个时刻向终点建一条流量为m的边，表示这个时刻可以最多完成m个任务的单位工作量。
然后我们就跑最大流看看最后有没有完成所有任务的总工作量和就可以了。
注意边的范围，最多有500*500+500*2条边。

完整代码：

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <queue>
using namespace std;
const int maxn=520;
const int inf=0x3f3f3f3f;
struct Edge{
    int u,v,c;
    int next;
}edge[maxn*maxn];
int n,m;
int edn;//边数
int head[maxn*maxn],dis[maxn*maxn];
int sp,tp;//原点，汇点

void addedge(int u,int v,int c)
{
    edge[edn].u=u; edge[edn].v=v; edge[edn].c=c;
    edge[edn].next=head[u]; head[u]=edn++;

    edge[edn].u=v; edge[edn].v=u; edge[edn].c=0;
    edge[edn].next=head[v]; head[v]=edn++;
}
int bfs()
{
    queue <int> q;
    memset(dis,-1,sizeof(dis));
    dis[sp]=0;
    q.push(sp);
    while(!q.empty())
    {
        int cur=q.front();
        q.pop();
        for(int i=head[cur];i!=-1;i=edge[i].next)
        {
            int u=edge[i].v;
            if(dis[u]==-1 && edge[i].c>0)
            {
                dis[u]=dis[cur]+1;
                q.push(u);
            }
        }
    }
    return dis[tp] != -1;
}
int dfs(int a,int b)
{
    int r=0;
    if(a==tp)return b;
    for(int i=head[a];i!=-1 && r<b;i=edge[i].next)
    {
        int u=edge[i].v;
        if(edge[i].c>0 && dis[u]==dis[a]+1)
        {
            int x=min(edge[i].c,b-r);
            x=dfs(u,x);
            r+=x;
            edge[i].c-=x;
            edge[i^1].c+=x;
        }
    }
    if(!r)dis[a]=-2;
    return r;
}

int dinic(int sp,int tp)
{
    int total=0,t;
    while(bfs())
    {
        while(t=dfs(sp,inf))
        total+=t;
    }
    return total;
}
int mark[505];
int main()
{
    int T;
    scanf("%d",&T);
    int S=T;
    while(T--)
    {
        scanf("%d%d",&n,&m);
        edn=0;//初始化
        memset(head,-1,sizeof(head));
        memset(mark,0,sizeof(mark));
        // sp=1;tp=n;
        sp=0,tp=n+500+1;
        int sum=0;
        for(int i=1;i<=n;i++)
        {
            int p,s,e;
            scanf("%d%d%d",&p,&s,&e);
            sum+=p;
            addedge(sp,i,p);
            for(int j=s;j<=e;j++)
            {
                addedge(i,n+j,1);
                mark[j]=1;
            }
        }
        for(int i=1;i<=500;i++)
        {
            if(mark[i])
                addedge(n+i,tp,m);
        }
        int ans=dinic(sp,tp);
        printf("Case %d: ",S-T);
        if(sum==ans)
            printf("Yes\n");
        else
            printf("No\n");
        printf("\n");
    }
    return 0;
}