A Plug for UNIX UVA - 753（方法一）

题目考察的是最大流的问题，将插座和设备抽象为顶点，利用转换器的信息以及floyd算法来判断哪些类型的设备能够转换为哪些类型的插座，然后建立相应的图，注意这时候图的每条边上的容量是不限，也就是满足题目中的转换器的个数可以为任意个，然后建立一个起点和一个终点，从起点到各个设备建立相应的边，每条边上的容量为1表示我们要考虑的每种类型的设备个数仅仅为1个，再建立从插座到终点的相应的边，每条边的容量为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;
};

class Solve{
public:
	int n, m, k, amount;
	vector<string> name;
	int source[405],target[405];
	int record[405][405];
	vector<Edge> edge;
	vector<int> G[405];
	int getID(string t){
		for (int i = 0; i < name.size(); i++){
			if (name[i] == t) return i;
		}
		name.push_back(t);
		return name.size() - 1;
	}

	void addEdge(int id1,int id2,int cap,int flow){
		Edge temp;
		temp.from = id1, temp.to = id2, temp.cap = cap, temp.flow = flow;
		edge.push_back(temp);
		Edge temp2;
		temp2.from = id2, temp2.to = id1, temp2.cap = 0, temp2.flow = 0;
		edge.push_back(temp2);
		int total = edge.size();
		G[id1].push_back(total - 2);
		G[id2].push_back(total - 1);
	}

	void Init(){
		name.clear();
		for (int i = 0; i < 405; i++) G[i].clear();
		edge.clear();
		memset(record,0,sizeof(record));
		cin >> n;//插座
		for (int i = 0; i < n; i++){
			string temp;
			cin >> temp;
			target[i] = getID(temp);
		}
		cin >> m;//设备
		for (int i = 0; i < m; i++){
			string temp1,temp2;
			cin >> temp1 >> temp2;
			int id = getID(temp2);
			source[i] = id;
		}
		cin >> k;//转换器
		for (int i = 0; i < k; i++){
			string name1, name2;
			cin >> name1 >> name2;
			int id1, id2;
			id1 = getID(name1);
			id2 = getID(name2);
			record[id1][id2] = 1;
		}
		amount = name.size();
		for (int b = 0; b < amount; b++){
			for (int a = 0; a < amount; a++){
				for (int c = 0; c < amount; c++){
					record[a][c] = record[a][c] | (record[a][b] && record[b][c]);
				}
			}
		}
		for (int i = 0; i < m; i++){
			for (int j = 0; j < n; j++){
				if (record[source[i]][target[j]]){
					addEdge(source[i], target[j], Inf, 0);
				}
			}
		}
		int ind = amount;
		for (int i = 0; i < m; i++){
			int id = source[i];
			addEdge(ind, id, 1, 0);
		}
		ind = amount + 1;
		for (int i = 0; i < n; i++){
			int id = target[i];
			addEdge(id, ind, 1, 0);
		}
	}

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

	void Deal(){
		Init();
		int ans = MaxFlow(amount,amount+1);
		cout << m - ans << endl;
	}
};

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