zoj 3642 Just Another Information Sharing Problem【最大流||多重匹配】

大意：

有n个熊孩子，，每个熊孩子有a个秘密，他最少愿意分享b个秘密， 最多愿意分享c个秘密， 接下来a个数表示这个熊孩子有的a个秘密的id

最后给一个熊孩子的编号m， 询问编号m最多能够知道多少个秘密

分析：

最大流， 但是询问的那个孩子的秘密就不用封印了，哈哈

也可以用二分图多重匹配， 而且时间快了一倍

 

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
#include <map>
using namespace std;

const int maxn = 500 * 250 + 10;
const int INF = 1000000000;

struct Edge {
    int from, to, cap, flow;
};

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

    void ClearAll(int n) {
        for(int i = 0; i <= n; i++) {
            G[i].clear();
        }
        edges.clear();
    }

    void AddEdge(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()
    {
        memset(vis, 0, sizeof(vis) );
        queue<int> Q;
        Q.push(s);
        vis[s] = 1;
        d[s] = 0;
        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] = 1;
                    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[x] + 1 == d[e.to] && (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 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;
    }
};

Dinic g;

map<int, int> mp;
int a[maxn], b[maxn], c[maxn];
int A[55][205];

int n, m, num, tot;
int s, t;

int main() {
    while(EOF != scanf("%d",&n) ) {
        for(int i = 1; i <= n; i++) {
            scanf("%d %d %d",&a[i], &b[i], &c[i]);
            for(int j = 1; j <= a[i]; j++) {
                scanf("%d",&A[i][j]);
            }
        }
        scanf("%d",&m);
        mp.clear();
        g.ClearAll(n * (n + 200) );
        s = 0; t = n + 200 + 1;
        int tot = n + 1;
        for(int i = 1; i <= n; i++) {
            if(i != m) {
                g.AddEdge(s, i, c[i]);
            } else {
                g.AddEdge(s, i, a[i]);
            }
            for(int j = 1; j <= a[i]; j++) {
                num = A[i][j];
                if(!mp[num]) mp[num] = tot++;
                g.AddEdge(i, mp[num], 1);
            }
        }
        for(int i = n + 1; i < tot; i++) {
            g.AddEdge(i, t, 1);
        }
        printf("%d\n", g.MaxFlow(s, t));
    }
    return 0;
}

 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <map>
using namespace std;

const int maxn = 205;

int cap[maxn];
int Link[maxn][maxn];
int vLink[maxn];
int mat[maxn][maxn];
int vis[maxn];
int n, m;

bool Find(int u) {
    for(int i = 1; i <= m; i++) {
        if(!vis[i] && mat[u][i]) {
            int v = i;
            vis[v] = 1;
            if(vLink[v] < cap[v]) {
                Link[v][vLink[v]++] = u;
                return true;
            }
            for(int j = 0; j < vLink[v]; j++) {
                if(Find(Link[v][j])) {
                    Link[v][j] = u;
                    return true;
                }
            }
        }
    }
    return false;
}

int solve() {
    int cnt = 0;
    memset(Link, 0, sizeof(Link));
    memset(vLink, 0, sizeof(vLink));
    for(int i = 1; i <= n; i++) {
        memset(vis, 0, sizeof(vis));
        if(Find(i) ) cnt ++;
    }
    return cnt;
}

int a[maxn], b[maxn], c[maxn];
int A[maxn][maxn];
map<int, int> mp;

int main() {
    int x, y;
    while(EOF != scanf("%d",&x) ) {
        for(int i = 1; i <= x; i++) {
            scanf("%d %d %d", &a[i], &b[i], &c[i]);
            for(int j = 1; j <= a[i]; j++) {
                scanf("%d",&A[i][j]);
            }
        }
        scanf("%d",&y);
        mp.clear();
        memset(mat, 0, sizeof(mat));
        int tot = 1;
        for(int i = 1; i <= x; i++) {
            cap[i] = c[i];
            for(int j = 1; j <= a[i]; j++) {
                int num = A[i][j];
                if(!mp[num]) mp[num] = tot++;
                mat[mp[num]][i] = 1;
            }
        }
        cap[y] = a[y];
        n = tot - 1; m = x;
        printf("%d\n", solve());
    }
    return 0;
}