Risk UVA - 12264

利用网络流算法进行二分查找，对于那些我方的节点，建立开始点到我方节点的边，同时边的容量设置为对应的人数，同时将节点分为两个，建立从一个节点到另外一个节点的边，容量还是为对应的人数，同时对于能够转移的相邻节点建立边，边的容量为无穷，同时对于我方节点要建立到最终节点的边，如果我方节点没有和敌方节点接壤，那么对应的容量为1，否则为我们要试探的值，具体实现见如下代码：

#include<iostream>
#include<vector>
#include<string>
#include<set>
#include<stack>
#include<queue>
#include<map>
#include<algorithm>
#include<cmath>
#include<iomanip>
#include<cstring>
#include<sstream>
#include<cstdio>
#include<deque>
#include<functional>
using namespace std;

const int Inf = 1 << 30;

class Edge{
public:
	int from, to, cap, flow;
	Edge(int fr = 0, int t = 0, int ca = 0, int fl = 0) :from(fr), to(t), cap(ca), flow(fl){}
};

class Solve{
public:
	vector<Edge> edge;
	vector<int> G[250];
	int n;
	int Amount[250];
	vector<string> area;
	bool flag[250];

	void addEdge(int from, int to, int cap){
		edge.push_back(Edge(from, to, cap, 0));
		edge.push_back(Edge(to,from,0,0));
		int m = edge.size();
		G[from].push_back(m-2);
		G[to].push_back(m - 1);
	}

	void Init(){
		area.clear();//下标的变化
		cin >> n;
		for (int i = 1; i <= n; i++){
			cin >> Amount[i];
		}
		for (int i = 0; i < n; i++){
			string s;
			cin >> s;
			area.push_back(s);
		}
	}

	int Construct(int mid){
		for (int i = 0; i < 250; i++) G[i].clear();
		edge.clear();
		memset(flag, 0, sizeof(flag));
		for (int i = 1; i <= n; i++){
			if (Amount[i]){
				addEdge(0, i, Amount[i]);
				addEdge(i, i + n, Amount[i]);
			}
		}
		for (int i = 0; i < n; i++){
			if (!Amount[i+1]) continue;
			for (int j = 0; j < n; j++){
				if (area[i][j] == 'Y'){
					if (!Amount[j + 1]) flag[i + 1] = true;
					else addEdge(i + 1, j + 1 + n, Inf);
				}
			}
		}
		int record = 0;
		for (int i = 1; i <= n; i++){
			if (flag[i]){
				addEdge(i+n, 2 * n + 1, mid);
				record += mid;
			}
			else if(Amount[i]){
				addEdge(i+n, 2 * n + 1, 1);
				record++;
			}
		}
		return record;
	}

	int MaxFlow(int start,int end){
		int flow = 0;
		while (true){
			int Flow[250];
			memset(Flow, 0, sizeof(Flow));
			Flow[start] = Inf;
			queue<int> q;
			q.push(start);
			int parent[250];
			while (!q.empty()){
				int id = q.front();
				q.pop();
				for (int i = 0; i < G[id].size(); i++){
					int ide = G[id][i];
					int from = edge[ide].from;
					int to = edge[ide].to;
					if (!Flow[to] && edge[ide].cap>edge[ide].flow){
						Flow[to] = min(Flow[from], edge[ide].cap - edge[ide].flow);
						parent[to] = ide;
						q.push(to);
					}
				}
				if (Flow[end]) break;
			}
			if (!Flow[end]) break;
			flow += Flow[end];
			for (int i = end; i != start; i = edge[parent[i]].from){
				edge[parent[i]].flow += Flow[end];
				edge[parent[i] ^ 1].flow -= Flow[end];
			}
 		}
		return flow;
	}

	void Deal(){
		Init();
		int ans=-1;
		int left = 0, right = 10010;
		while (left < right){
			int mid = (left + right)>>1;
			int a = Construct(mid);
			int b = MaxFlow(0, 2 * n + 1); 
			if (a == b){
				left = mid + 1;
				ans = mid;
			}
			else{
				right = mid;
			}
		}
		cout << ans << endl;
	}
};

int main(){
	int Case;
	cin >> Case;
	Solve a;
	while (Case--){
		a.Deal();
	}
	return 0;
}