紫书 习题 11-10 UVa 12264 （二分答案+最大流）

书上写的是UVa 12011， 实际上是 12264

参考了https://blog.csdn.net/xl2015190026/article/details/51902823

这道题就是求出一种最优的移动士兵的方式， 使得与敌方相邻的阵营中最少的士兵最多

因为只能在我方的阵营中移动士兵， 所以建模的时候不用加入地方阵营的点。

首先因为士兵只能移动一次， 所以把点拆成两个点， 入点和出点。

设阵营士兵的人数为k[i]

那么源点到入点连一条弧， 容量为k[i]， 然后入点和出点再连

一条弧， 容量为k[i]

然后因为士兵可以移动， 所以相邻的阵营之间， 如i与j， 那么i的入点

和j的出点连一条弧， 容量为最多可以给的士兵的数量， 可以设为k[i]

实际上不可能给k[i]那么多个，因为每个阵营少留下一个人。

但是容量多了没事， 反正多了也流不过来。这里设为无穷大效果也是一样的

这类弧表示相邻的阵营之间可以有士兵移动

然后现在要从出点到汇点连一条弧， 这条弧的流量表示最终这个阵营的人数

中间入点和出点的弧有流量， 就是表示士兵是在原来的阵营还是去其他阵营

流到最后每个阵营流出去的流量就是最后这个阵营的人数。

然后容量为多少呢？

首先要使最少的尽量多， 那么如果这个阵营不与敌方阵营相邻， 那么也就是说

这个阵营只要满足人数大于1就可以了。那么显然， 为了给那些与敌方阵营相邻

的阵营更多的人数， 那么这类阵营的人数干脆就为1了。

所以容量为1。如果与地方阵营相邻， 要使最少的最多， 那么在肯定是平均分最好。

那么这个平均的值是不确定的， 所以我们要二分

也就是说二分答案， 二分的这个值就是弧的容量。

最后如果满载的话说明满足条件， 那么就符合。

#include<cstdio>
#include<vector>
#include<cstring>
#include<queue>
#include<algorithm>
#define REP(i, a, b) for(int i = (a); i < (b); i++)
using namespace std;

const int MAXN = 212;
struct Edge{ int from, to, cap, flow; };
vector<Edge> edges;
vector<int> g[MAXN];
int cur[MAXN], h[MAXN], k[MAXN], f[MAXN];
int n, m, s, t;
char map[MAXN][MAXN];

void AddEdge(int from, int to, int cap)
{
	edges.push_back(Edge{from, to, cap, 0});
	edges.push_back(Edge{to, from, 0, 0});
	g[from].push_back(edges.size() - 2);
	g[to].push_back(edges.size() - 1);
}

bool bfs()
{
	queue<int> q;
	q.push(s);
	memset(h, 0, sizeof(h));
	h[s] = 1;

	while(!q.empty())
	{
		int x = q.front(); q.pop();
		REP(i, 0, g[x].size())
		{
			Edge& e = edges[g[x][i]];
			if(e.cap > e.flow && !h[e.to])
			{
				h[e.to] = h[x] + 1;
				q.push(e.to);
			}
		}
	}

	return h[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(h[x] + 1 == h[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;
			if((a -= f) == 0) break;
		}
	}
	return flow;
}

int maxflow()
{
	int flow = 0;
	while(bfs())
	{
		memset(cur, 0, sizeof(cur));
		flow += dfs(s, 1e9);
	}
	return flow;
}

int make_edges(int cap)
{
	edges.clear();
	REP(i, 0, MAXN) g[i].clear();
	memset(f, false, sizeof(f));

	REP(i, 0, n)
	{
		if(!k[i]) continue;
		AddEdge(s, i, k[i]);
		AddEdge(i, i + n, k[i]);
		REP(j, 0, n)
			if(map[i][j] == 'Y')
			{
				if(k[j]) AddEdge(i, j + n, k[i]);
				else f[i] = true;
			}
	}

	int ret = 0;
	REP(i, 0, n)
		if(k[i])
		{
			if(f[i]) AddEdge(i + n, t, cap), ret += cap;
			else AddEdge(i + n, t, 1), ret++;
		}
	return ret;
}

int main()
{
	int T;
	scanf("%d", &T);

	while(T--)
	{
		scanf("%d", &n);
		REP(i, 0, n) scanf("%d", &k[i]);
		REP(i, 0, n) scanf("%s", map[i]);
		s = 2 * n; t = s + 1;

		int l = 0, r = MAXN * MAXN;
		while(l + 1 < r)
		{
			int mid = (l + r) >> 1;
			if(make_edges(mid) == maxflow()) l = mid;
			else r = mid;
		}
		printf("%d\n", l);
	}

	return 0;
}