tyvj P1431 [Tyvj Jan]分配任务（最大流）

　　　　　　　　　　　　　　　　　　　　　　　　　　　P1431 [Tyvj Jan]分配任务

　　　　　　　　　　　　　　　　　　　　　　时间: 1000ms / 空间: 131072KiB / Java类名: Main

描述

     随着tyvj发展越来越大，管理员的任务越来越重，如何合理的分配任务，成为了一个可研究的命题。Tyvj当前一共有M个需要做的任务，和N位 管理员。每一个管理员的上线时间并不是固定的，每一个人有d[i]单位的上线时间，每一位管理员一个单位的时间可以完成一个任务，且一个任务只能由一个管 理员来完成（如果更多的管理员参与进来，可能会造成混乱）。每一位管理员的能力有所不同，所以能完成的任务集合可能不相同。最终让所有未完成的任务数量最 少。

输入格式

输入文件第一有两个正整数，分别是N和M
   下面面N行，每一行表示一位管理员的信息，第一个正整数为d[i]，第二个正整数为tot，后面有tot个数，表示第i位管理员可以完成的任务集合。

输出格式

输出文件仅有一个数，所有未完成任务的最少值。

测试样例1

输入

3 3

2 2 1 2

0 3 1 2 3

1 1 2

输出

1

备注

数据范围约定：
20%的数据 n<=10 M<=10 且D[i]=1
60%的数据 n<=50 M<=300 且D[i]<=30
100%的数据 n<=3000 M<=10000 且d[i]<=100
admin TYVJ首届月赛第三道

【思路】

最大流。裸题。

Dinic算法的时间复杂度为O(nm)。

【代码】

 #include<cstdio>
 #include<cstring>
 #include<queue>
 #include<vector>
 #define FOR(a,b,c) for(int a=(b);a<(c);a++)
 using namespace std;

 const int maxn = +;
 const int INF = 1e9;

 struct Edge{
     int u,v,cap,flow;
 };
 struct Dinic {
     int n,m,s,t;
     bool vis[maxn];
     int d[maxn],cur[maxn];
     vector<int> G[maxn];
     vector<Edge> es;

     void init(int n) {
         this->n=n;
         es.clear();
         for(int i=;i<n;i++) G[i].clear();
     }
     void AddEdge(int u,int v,int cap) {
         es.push_back((Edge){u,v,cap,});
         es.push_back((Edge){v,u,,});
         m=es.size();
         G[u].push_back(m-);
         G[v].push_back(m-);
     }

     bool BFS() {
         queue<int> q;
         memset(vis,,sizeof(vis));
         q.push(s); vis[s]=; d[s]=;
         while(!q.empty()) {
             int u=q.front(); q.pop();
             for(int i=;i<G[u].size();i++) {
                 Edge& e=es[G[u][i]];
                 int v=e.v;
                 if(!vis[v] && e.cap>e.flow) {
                     vis[v]=;
                     d[v]=d[u]+;
                     q.push(v);
                 }
             }
         }
         return vis[t];
     }
     int DFS(int u,int a) {
         if(u==t || a==) return a;
         int flow=,f;
         for(int& i=cur[u];i<G[u].size();i++){
             Edge& e=es[G[u][i]];
             int v=e.v;
             if( d[v]==d[u]+ && (f=DFS(v,min(a,e.cap-e.flow)))> ) {
                 e.flow+=f;
                 es[G[u][i]^].flow-=f;
                 flow+=f,a-=f;
                 if(!a) break;
             }
         }
         return flow;
     }
     int Maxflow(int s,int t) {
         this->s=s , this->t=t;
         int flow=;
         while(BFS()) {
             memset(cur,,sizeof(cur));
             flow+=DFS(s,INF);
         }
         return flow;
     }
 } dc;

 int n,m;

 int main() {
     scanf("%d%d",&n,&m);
     dc.init(n+m+);
     int s=n+m,t=s+;
     int x,a,b;
     FOR(i,,n) {
         scanf("%d",&x);
         dc.AddEdge(s,i,x);
         scanf("%d",&a);
         while(a--) {
             scanf("%d",&b); b--;
             dc.AddEdge(i,n+b,);
         }
     }
     FOR(i,,m) dc.AddEdge(n+i,t,);
     int flow=dc.Maxflow(s,t);
     printf("%d\n",m-flow);
     return ;
 }