ZOJ 3642 多重匹配 离散化.cpp

题意：

已知一些小孩所拥有的信息和他最多共享信息量和最少共享信息量 问其中某一个小孩最多得到的信息量

给出n表示有n个小孩

接下来n行有 a b c a1 a2 a3 a4 ... ai   表示该小孩有信息a条 最少共享 b 条 最多共享 c 条 其中a1 a2 a3~ai为小孩拥有信息id号

给出一个m 问的是小孩m最多得到的信息量

 

思路：

鉴于这道题中信息id号从 0 ~ 200 但是每个小孩最初最多知道10条信息..

所以为了防止遍历的时候太浪费时间 应该把题目id号变成连续的..

 

然后可以用多重匹配或者最大流来做..

Tips：

多重匹配的建图方法：

 以信息为 集合X  孩子为 集合Y

然后 limit 为 Y 集合的最大容量 即孩子的最大共享量   但是孩子 m 的容量为INF

 

最大流的建图方法：

一个超级源点..连接孩子 除了第m个孩子之外..

别的孩子都连线..容量为最大分享量..而第m个孩子的容量为INF 表示可以接受无穷多的信息

然后每个孩子和对应的信息连线 容量为1

每个信息又与超级汇点连线 容量为1

求超级源点到超级汇点的最大流既是答案

Code：

 

#include <stdio.h>
#include <cstring>
#include <algorithm>
using namespace std;
#define clr(x) memset(x, 0xff, sizeof(x))
#define min(a,b)(a)<(b)?(a):(b)

const int INF = 0x1f1f1f1f;
const int maxn = 410;
const int maxm = 200010;

struct Info
{
    int m;
    int id[210];
    int cap;
}info[210];

struct Edge
{
    int from;
    int to;
    int next;
    int w;
}edge[maxm];
int tot;
int head[maxn];

int num[1000010];

void add(int s, int u, int f1, int f2)
{
    edge[tot].from = s;
    edge[tot].to = u;
    edge[tot].w = f1;
    edge[tot].next = head[s];
    head[s] = tot++;
    edge[tot].from = u;
    edge[tot].to = s;
    edge[tot].w = f2;
    edge[tot].next = head[u];
    head[u] = tot++;
}

int q[maxn];
int cnt[maxn];
int d[maxn];
int low[maxn];
int cur[maxn];

int maxflow(int s, int t, int n)
{
    int *front = q, *rear = q;
    for(int i = 0; i <= n; ++i) {
        d[i] = n;
        cnt[i] = 0;
    }
    cnt[n] = n-1;
    cnt[0]++;
    d[t] = 0;
    *rear++ = t;
    while(front < rear) {
        int v = *front++;
        for(int i = head[v]; i != -1; i = edge[i].next) {
            if(d[edge[i].to] == n && edge[i^1].w > 0) {
                d[edge[i].to] = d[v] + 1;
                cnt[n]--;
                cnt[d[edge[i].to]]++;
                *rear++ = edge[i].to;
            }
        }
    }

    int flow = 0, u = s, top = 0;
    low[0] = INF;
    for(int i = 0; i <= n; ++i) {
        cur[i] = head[i];
    }
    while(d[s] < n) {
        int &i = cur[u];
        for(; i != -1; i = edge[i].next) {
            if(edge[i].w > 0 && d[u] == d[edge[i].to]+1) {
                low[top+1] = min(low[top], edge[i].w);
                q[++top] = i;
                u = edge[i].to;
                break;
            }
        }
        if(i != -1) {
            if(u == t) {
                int minf = low[top];
                for(int p = 1, i; p <= top; ++p) {
                    i = q[p];
                    edge[i].w -= minf;
                    edge[i^1].w += minf;
                }
                flow += minf;
                u = s;
                low[0] = INF;
                top = 0;
            }
        }
        else {
            int old_du = d[u];
            cnt[old_du]--;
            d[u] = n-1;
            for(int i = head[u]; i != -1; i = edge[i].next)
                if(edge[i].w > 0 && d[u] > d[edge[i].to]) {
                    d[u] = d[edge[i].to];
                }
                cnt[++d[u]]++;
                if(d[u]<n)
                    cur[u] = head[u];
                if(u != s) {
                    u = edge[q[top]].from;
                    --top;
                }
                if(cnt[old_du] == 0) break;
        }
    }
    return flow;
}

int main()
{
    int i, j, k;
    int n, tmp, tt, m;
    while(scanf("%d", &n) != EOF)
    {
        clr(head), tot = 0, tt = n+1;
        memset(num, 0, sizeof(num));

        for(i = 1; i <= n; ++i) {
            scanf("%d%*d%d", &info[i].m, &info[i].cap);
            for(j = 0; j < info[i].m; ++j){
                scanf("%d", &tmp);
                if(num[tmp] == 0) num[tmp] = tt++;
                info[i].id[j] = num[tmp];
            }
        }

        scanf("%d", &m);

        for(i = 1; i <= n; ++i) {
            if(i != m)
                add(0, i, info[i].cap, 0);
            else
                add(0, i, INF, 0);
            for(j = 0; j < info[i].m; ++j)
                add(i, info[i].id[j], 1, 0);
        }

        for(i = n+1; i < tt; ++i)
        add(i, tt, 1, 0);

        int ans = maxflow(0, tt, tt+1);

        printf("%d\n", ans);
    }
    return 0;
}

 

 

 

#include <stdio.h>
#include <cstring>
#include <algorithm>
using namespace std;
#define clr(x) memset(x, 0, sizeof(x))
const int INF = 0x1f1f1f1f;

bool G[410][210];
int limit[410];
bool vis[410];
int v1, v2, sum;
int v[410];
int vv[210][410];
int num[1000010];

bool find(int u)
{
    int i, j, k;
    for(i = 0; i < v2; ++i) {
        if(G[u][i] && !vis[i]) {
            vis[i] = true;
            if(v[i] < limit[i]) {
                vv[i][v[i]++] = u;
                return true;
            }

            for(j = 0; j < v[i]; ++j) {
                if(find(vv[i][j])) {
                    vv[i][j] = u;
                    return true;
                }
            }
        }
    }
    return false;
}

void solve()
{
    clr(vis);
    sum = 0;
    for(int i = 1; i <= v1; ++i) {
        clr(vis);
        if(find(i)) {
            sum++;
        }
    }
}

int main()
{
    int i, j, k;
    int n, m, tmp, tt;
    while(scanf("%d", &n) != EOF)
    {
        clr(G), clr(num);
        tt = 1;

        for(i = 0; i < n; ++i) {
            scanf("%d%*d%d", &m, &limit[i]);
            while(m--) {
                scanf("%d", &tmp);
                if(num[tmp] == 0) num[tmp] = tt++;
                G[num[tmp]][i] = true;
            }
        }

        v1 = tt-1;
        v2 = n;
        scanf("%d", &m);

        limit[m-1] = INF;
        solve();

        printf("%d\n", sum);
    }
    return 0;
}

 

 

 

题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=4810