Codeforces Gym 100825F Transportation Delegation (最大流)

题目大意：

就是现在有s个州, 每个州要么有工厂要么有原材料供应商或者什么都没有, 有的话只有一家

现在有t个运输公司分别提供运输服务

要求一个工厂只能匹配一个供应商，一个供应商只能供应一个工厂，且要满足一个运输公司只为其中一个匹配对服务(可以通过多个运输公司一起来传递来配对一个工厂和供应商)

问最大匹配对数

大致思路：

EC-final前最后一个题.....打完之后训练就结束了呢= =

表示这个题真是让我见识到了什么叫网络流不知道可不可以，先来一发T了再说...简直暴力出奇迹

可以考虑这么建图：

所有工厂和源点连一条容量为1的边, 然后供应商和汇点连一条容量为1的边

对于每一个运输公司，抽象出两个点p1, p2，连一条容量为1的边来控制公司只用一次

对于每一个该运输公司可以服务的点与p1连一条容量1的边, 与p2连一条容量1的边

于是跑一遍最大流就是答案了

这个图最坏情况下应该是1000*2+600+2个点

600*2*1000+1000+600条无向边(120W...)

然而网络流单组数据只跑了159ms.....好强大...

代码如下：

Result  :  Accepted     Memory  :  37712 KB     Time  :  156 ms

/*
* Author: Gatevin
* Created Time:  2015/12/11 0:11:10
* File Name: Yukinoshita_Yukino.cpp
*/
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#include<iomanip>
using namespace std;
const double eps(1e-8);
typedef long long lint;

#define maxn 2700

#define maxm 1202000

struct Edge
{
int u, v, nex, cap;
Edge(){}
Edge(int _u, int _v, int _nex, int _cap)
{
u = _u, v = _v, nex = _nex, cap = _cap;
}
};

Edge edge[maxm << 1];
int E;
int head[maxn];

void add_Edge(int u, int v, int c)
{
edge[++E] = Edge(u, v, head[u], c);
head[u] = E;
edge[++E] = Edge(v, u, head[v], 0);
head[v] = E;
}

int dep[maxn];

bool bfs(int start, int end)
{
int Q[maxn];
int l, r;
l = r = 0;
memset(dep, -1, sizeof(dep));
Q[r++] = start;
dep[start] = 0;
while(l != r)
{
int u = Q[l++];
if(l == maxn) l = 0;
for(int i = head[u]; i + 1; i = edge[i].nex)
{
int v = edge[i].v;
if(edge[i].cap > 0 && dep[v] == -1)
{
dep[v] = dep[u] + 1;
Q[r++] = v;
if(r >= maxn) r = 0;
if(v == end) return 1;
}
}
}
return 0;
}

int dinic(int start, int end)
{
int res = 0;
int top;
int cur[maxn];
int stack[maxn];
while(bfs(start, end))
{
memcpy(cur, head, sizeof(head));
int u = start;
top = 0;
while(1)
{
if(u == end)
{
int min = 1e9;
int loc;
for(int i = 0; i < top; i++)
if(min > edge[stack[i]].cap)
{
min = edge[stack[i]].cap;
loc = i;
}
for(int i = 0; i < top; i++)
{
edge[stack[i]].cap -= min;
edge[stack[i] ^ 1].cap += min;
}
res += min;
top = loc;
u = edge[stack[top]].u;
}
for(int i = cur[u]; i + 1; cur[u] = i = edge[i].nex)
if(edge[i].cap != 0 && dep[u] + 1 == dep[edge[i].v])
break;
if(cur[u] != -1)
{
stack[top++] = cur[u];
u = edge[cur[u]].v;
}
else
{
if(top == 0) break;
dep[u] = -1;
u = edge[stack[--top]].u;
}
}
}
return res;
}

map<string, int> M;

int main()
{
ios::sync_with_stdio(0);
E = -1;
memset(head, -1, sizeof(head));
int s, r, f, t;
cin>>s>>r>>f>>t;
string name;
int S = 0, T = s + 2*t + 1;
int cnt = 0;
for(int i = 0; i < r; i++)
{
cin>>name;
if(M.count(name) == 0)
{
M[name] = ++cnt;
add_Edge(S, cnt, 1);
}
}
for(int i = r + 1; i <= r + f; i++)
{
cin>>name;
if(M.count(name) == 0)
{
M[name] = ++cnt;
add_Edge(cnt, T, 1);
}
}
for(int i = 1; i <= t; i++)
{
int x;
cin>>x;
int point1 = ++cnt, point2 = ++cnt;
add_Edge(point1, point2, 1);
while(x--)
{
cin>>name;
if(M.count(name) == 0)
M[name] = ++cnt;
int num = M[name];
add_Edge(num, point1, 1);
add_Edge(point2, num, 1);
}
}
cout<<dinic(S, T)<<endl;
return 0;
}