hdu-3572 Task Schedule---最大流判断满流+dinic算法

题目链接：

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

题目大意：

给N个任务，M台机器。每个任务有最早才能开始做的时间S，deadline E，和持续工作的时间P。每个任务可以分段进行,但是在同一时刻,一台机器最多只能执行一个任务. 问存不存在可行的工作时间。

解题思路：

由于时间<=500且每个任务都能断断续续的执行,那么我们把每一天时间作为一个节点来用网络流解决该题.

建图: 源点s(编号0), 时间1-500天编号为1到500, N个任务编号为500+1 到500+N, 汇点t(编号501+N).

源点s到每个任务i有边(s, i, Pi)

每一天到汇点有边(j, t, M) (其实这里的每一天不一定真要从1到500,只需要取那些被每个任务覆盖的每一天即可)

如果任务i能在第j天进行,那么有边(i, j, 1) 注意由于一个任务在一天最多只有1台机器执行,所以该边容量为1,不能为INF或M哦.

最后看最大流是否 == 所有任务所需要的总天数.

用增广路最大流会超时，得用dinic算法优化找增广路

（图论的题目难在如何建图，而不是算法的使用）

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long ll;
 const int maxn =  + ;
 const int INF = 1e9;
 struct edge
 {
     int u, v, c, f;
     edge(){}
     edge(int u, int v, int c, int f):u(u), v(v), c(c), f(f){}
 };
 vector<edge>e;
 vector<int>G[maxn];
 int level[maxn];//BFS分层
 int iter[maxn];//当前弧优化
 int n, m;
 void init()
 {
     for(int i = ; i < maxn; i++)G[i].clear();
     e.clear();
 }
 void addedge(int u, int v, int c)
 {
     e.push_back(edge(u, v, c, ));
     e.push_back(edge(v, u, , ));
     int m = e.size();
     G[u].push_back(m - );
     G[v].push_back(m - );
 }
 void BFS(int s)
 {
     memset(level, -, sizeof(level));
     queue<int>q;
     level[s] = ;
     q.push(s);
     while(!q.empty())
     {
         int u = q.front();
         q.pop();
         for(int i = ; i < G[u].size(); i++)
         {
             edge& now = e[G[u][i]];
             int v = now.v;
             if(now.c > now.f && level[v] < )
             {
                 level[v] = level[u] + ;
                 q.push(v);
             }
         }
     }
 }
 int dfs(int u, int t, int f)//u为当前点，t为终点，f为当前流量
 {
     if(u == t)return f;
     for(int& i = iter[u]; i < G[u].size(); i++)//当前弧优化
     {
         edge& now = e[G[u][i]];
         int v = now.v;
         if(now.c > now.f && level[u] < level[v])
         {
             int d = dfs(v, t, min(f, now.c - now.f));
             if(d > )
             {
                 now.f += d;
                 e[G[u][i] ^ ].f -= d;
                 return d;
             }
         }
     }
     return ;
 }
 int Maxflow(int s, int t)
 {
     int flow = ;
     for(;;)
     {
         BFS(s);
         if(level[t] < )return flow;
         memset(iter, , sizeof(iter));
         int f;
         while((f = dfs(s, t, INF)) > )flow += f;
     }
     return flow;
 }
 int main()
 {
     int T, cases = ;
     scanf("%d", &T);
     while(T--)
     {
         scanf("%d%d", &n, &m);
         int maxday = ;
         int sumday = ;
         init();
         int p, s, e;
         for(int i = ; i <= n; i++)
         {
             scanf("%d%d%d", &p, &s, &e);
             addedge(,  + i, p);
             for(int j = s; j <= e; j++)
                 addedge(i + , j, );
             maxday = max(maxday, e);
             sumday += p;
         }
         for(int i = ; i <= maxday; i++)
             addedge(i,  + n, m);
         if(Maxflow(,  + n) == sumday)
             printf("Case %d: Yes\n\n", ++cases);
         else printf("Case %d: No\n\n", ++cases);
     }
     return ;
 }