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 = 15000+10;
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=0;i<n;i++) G[i].clear();
    }
    void AddEdge(int u,int v,int cap) {
        es.push_back((Edge){u,v,cap,0});
        es.push_back((Edge){v,u,0,0});
        m=es.size();
        G[u].push_back(m-2);
        G[v].push_back(m-1);
    }
    
    bool BFS() {
        queue<int> q;
        memset(vis,0,sizeof(vis));
        q.push(s); vis[s]=1; d[s]=0;
        while(!q.empty()) {
            int u=q.front(); q.pop();
            for(int i=0;i<G[u].size();i++) {
                Edge& e=es[G[u][i]];
                int v=e.v;
                if(!vis[v] && e.cap>e.flow) {
                    vis[v]=1;
                    d[v]=d[u]+1;
                    q.push(v);
                }
            }
        }
        return vis[t];
    }
    int DFS(int u,int a) {
        if(u==t || a==0) return a;
        int flow=0,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]+1 && (f=DFS(v,min(a,e.cap-e.flow)))>0 ) {
                e.flow+=f;
                es[G[u][i]^1].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=0;
        while(BFS()) {
            memset(cur,0,sizeof(cur));
            flow+=DFS(s,INF);
        }
        return flow;
    }
} dc;

int n,m;

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