ZOJ-3642-Just Another Information SharingProblem

ZOJ-3642-Just Another Information SharingProblem

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3642

有若干个人，每个人几有条信息，他至少共享a条，至多共享b条，问里面的某个人最多能获得多少消息

最大流，建立源点和汇点，源点向人建边，容量为该人至多共享的信息数，人向信息节点建边，容量为1，信息节点向汇点建边，容量也为1，注意这个人自己知道的信息不需要共享，源点到该人的容量为无穷，建立信息节点时注意要离散化

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
using namespace std;
const int maxn = 500;
const int maxm = 500000;
const int INF=1<<30;
int idx,k;
int cur[maxn], pre[maxn];
int dis[maxn], gap[maxn];
int aug[maxn], head[maxn];
int map[250][250];
int out[250];
int match[250];
struct Node
{
	int u, v, w;
	int next;
}edge[maxm];
void addEdge(int u, int v, int w)
{
    edge[idx].u = u;
    edge[idx].v = v;
    edge[idx].w = w;
    edge[idx].next = head[u];
	head[u] = idx++;
    edge[idx].u = v;
    edge[idx].v = u;
    edge[idx].w = 0;
    edge[idx].next = head[v];
    head[v] = idx++;
}
int sol(int cur)
{
	int i;
    if(k==0)
	{
		k=1;
		match[1]=cur;
		return 1;
	}
	for(i=1;i<=k;i++)
	if(match[i]==cur)
	return i;
	k++;
	match[k]=cur;
	return k;
}
int SAP(int s, int e, int n)
{
	int max_flow = 0, v, u = s;
    int id, mindis;
    aug[s] =INF;
    pre[s] = -1;
    memset(dis, 0, sizeof(dis));
    memset(gap, 0, sizeof(gap));
    gap[0] = n; // 我觉得这一句要不要都行，因为dis[e]始终为0
    for (int i = 0; i <= n; ++i)   // 初始化当前弧为第一条弧
    cur[i] = head[i];
    while (dis[s] < n)
    {
        bool flag = false;
        if (u == e)
        {
            max_flow += aug[e];
            for (v = pre[e]; v != -1; v = pre[v]) // 路径回溯更新残留网络
            {
                id = cur[v];
                edge[id].w -= aug[e];
                edge[id^1].w += aug[e];
                aug[v] -= aug[e]; // 修改可增广量，以后会用到
                if (edge[id].w == 0) u = v; // 不回退到源点，仅回退到容量为0的弧的弧尾
            }
        }
        for (id = cur[u]; id != -1; id = edge[id].next)
        {   // 从当前弧开始查找允许弧
            v = edge[id].v;
            if (edge[id].w > 0 && dis[u] == dis[v] + 1) // 找到允许弧
            {
                flag = true;
                pre[v] = u;
                cur[u] = id;
                aug[v] = min(aug[u], edge[id].w);
                u = v;
                break;
            }
        }
        if (flag == false)
        {
            if (--gap[dis[u]] == 0) break; /* gap优化，层次树出现断层则结束算法 */
            mindis = n;
            cur[u] = head[u];
            for (id = head[u]; id != -1; id = edge[id].next)
            {
                v = edge[id].v;
                if (edge[id].w > 0 && dis[v] < mindis)
                {
                    mindis = dis[v];
                    cur[u] = id; // 修改标号的同时修改当前弧
                }
            }
            dis[u] = mindis + 1;
            gap[dis[u]]++;
            if (u != s) u = pre[u]; // 回溯继续寻找允许弧
        }
    }
    return max_flow;
}
int main()
{
    int i,j,n,cur,x;
	int st,ed,temp;
    while(scanf("%d",&n)!=EOF)
	{
		k=0;
		for(i=1;i<=n;i++)
		{
			scanf("%d",&map[i][0]);
			scanf("%d%d",&temp,&out[i]);
			for(j=1;j<=map[i][0];j++)
			{
				scanf("%d",&cur);
				map[i][j]=sol(cur);
			}
		}
		scanf("%d",&x);
		idx=0;
		memset(head,-1,sizeof(head));
		st=0;
		ed=n+k+1;
		for(i=1;i<=n;i++)
		{
			addEdge(st,i,i==x?INF:out[i]);   //源点向人建边,自己这个人本来就知道的信息不需要让别人来共享了
			for(j=1;j<=map[i][0];j++)
			addEdge(i,n+map[i][j],1);  //人向信息建边
		}
		for(i=1;i<=k;i++)  //信息向汇点建边
		addEdge(n+i,ed,1);
		printf("%d\n",SAP(st,ed,n+k+2));
	}
	return 0;
}