HDU 3572 — Task Schedule

原题：http://acm.hdu.edu.cn/showproblem.php?pid=3572

题意：有n个任务，m个机器；

    每个任务有需要的天数（P），开始时间（S），截止时间（E）；

    每个任务都可以分段进行，但同一时刻同一台机器只能做一个任务；

    问能否完成所有任务；

思路：我们可以把每个任务以及每一天作为节点；

    建图 — — 源点s（编号0）， 时间（编号1到500），任务（编号500+1到500+n）， 汇点t（编号500+n+1）；

    源点s到任务节点的边为（s, i, P），任务节点到相关的时间节点的边为（i, j, 1），相关的时间节点到汇点的边为（j, t, m）；

    最后，如果最大流 = 所需要的总天数则yes；

#include<stdio.h>
#include<string.h>
#include<queue>
#include<iostream>
#include<algorithm>
#include<vector>


using namespace std;
#define inf 1e9
const int maxn = 1100;
struct Edge
{
    int from, to, cap, flow;
    Edge(){}
    Edge(int f,int t,int c,int fl):from(f),to(t),cap(c),flow(fl){}
};


int head[maxn], edgenum;
struct Dinic
{
    int n, m, s, t;
    vector<Edge>edges;
    vector<int>G[maxn];
    bool vis[maxn];
    int cur[maxn];
    int d[maxn];


    void init(int n, int s, int t)
    {
        this->n = n, this->s = s, this->t = t;
        edges.clear();
        for(int i = 0;i<n;i++) 
G[i].clear();
    }


    void add(int from, int to, int cap)
    {
        edges.push_back( Edge(from, to, cap, 0) );
        edges.push_back( Edge(to, from, 0, 0) );
        m = edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }


    bool BFS()
    {
        queue<int>q;
        memset(vis, false, sizeof(vis));
        vis[s] = true;
        d[s] = 0;
        q.push(s);
        while(!q.empty())
        {
            int x = q.front(); q.pop();
            for(int i = 0;i<G[x].size();i++)
            {
                Edge& e = edges[G[x][i]];
                if(!vis[e.to] && e.cap>e.flow)
                {
                    vis[e.to] = true;
                    d[e.to] = d[x]+1;
                    q.push(e.to);
                }
            }
        }
        return vis[t];
    }


    int DFS(int x, int a)
    {
        if(x==t || a==0) return a;
        int flow = 0, f;
        for(int &i = cur[x];i<G[x].size();i++)
        {
            Edge &e = edges[G[x][i]];
            if(d[e.to] == d[x]+1 && (f = DFS(e.to,min(a,e.cap-e.flow)))>0)
            {
                e.flow+=f;
                edges[G[x][i]^1].flow-=f;
                flow+=f;
                a-=f;
                if(a == 0) break;
            }
        }
        return flow;
    }


    int maxflow()
    {
        int ans = 0;
        while(BFS())
        {
            memset(cur, 0, sizeof(cur));
            ans+=DFS(s, inf);
        }
        return ans;
    }
}DC;


int main()
{
int cas;
int T = 0;
scanf("%d", &cas);
while(cas--)
{
int n, m;
scanf("%d%d", &n, &m);
memset(head, -1, sizeof(head));
edgenum = 0;
int s = 0, t = 500+n+1;
int day = 0;
DC.init(500+n+2, s, t);
bool vis[maxn];
memset(vis, false, sizeof(vis));
for(int i = 1;i<=n;i++)
{
int P, S, E;
scanf("%d%d%d", &P, &S, &E);
DC.add(s, 500+i, P);
day+=P;
for(int j = S;j<=E;j++)
{
DC.add(500+i, j, 1);
vis[j] = true;
}
}
for(int i = 1;i<=500;i++)
{
if(vis[i])
DC.add(i, t, m);
}
if(DC.maxflow() == day)
printf("Case %d: Yes\n\n", ++T);
else
printf("Case %d: No\n\n", ++T);
}
return 0;
}