紫书 习题 11-8 UVa 1663 （最大流求二分图最大基数匹配）

很奇怪， 看到网上用的都是匈牙利算法求最大基数匹配

紫书上压根没讲这个算法， 而是用最大流求的。

难道是因为第一个人用匈牙利算法然后其他所有的博客都是看这个博客的吗？

很有可能……

回归正题。

题目中只差一个数字的时候可以匹配， 然后求最少模板数。

那么肯定匹配的越多就越少， 也就是求最多匹配多少。

这个时候我就想到了二分图最大基数匹配。

那么很容易想到可以匹配的一组之间就连一条弧。

但问题是怎么分成两类？？分类的目的是让同一类之间没有弧， 这样才是二分图。

后来发现因为匹配的一组只有一个数字不一样， 所以肯定1的个数不同（或者0）

那么我们就可以根据1的个数的奇偶分两类， 这样才能构造出二分图。

然后我就这么交了， 然后WA。

后来发现貌似模板可能会重复， 因为是集合， 满足互异性， 所以这些重复的肯定是要去掉的。

这是个大坑……

所以加模板的时候要判断有没有加过。

然后最大流求最大基数匹配就ok了！

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

const int MAXN = 2123;
struct Edge { int from, to, cap, flow; };
vector<Edge> edges;
vector<int> g[MAXN];
vector<string> num;
int cur[MAXN], h[MAXN], s, t, n, m;

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;
	memset(h, 0, sizeof(h));
	q.push(s);
	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(e.cap - e.flow, a))) > 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 sum(string s) //模板中1的个数 
{
	int ret = 0;
	REP(i, 0, s.length()) ret += (s[i] == '1');
	return ret & 1;
}

bool judge(string s) //记住集合中不能有重复元素 
{
	REP(i, 0, num.size())
		if(s == num[i])
			return false;
	return true;
}

int main()
{
	while(~scanf("%d%d", &n, &m) && n && m)
	{
		num.clear(); 
		REP(i, 0, MAXN) g[i].clear();
		edges.clear();
		
		while(m--)
		{
			string s;
			cin >> s;
			if(s.find('*') == -1) { if(judge(s)) num.push_back(s); }
			else
			{
				int p; for(p = 0; s[p] != '*'; p++); //拆成两个模板 
				s[p] = '0'; if(judge(s)) num.push_back(s);
				s[p] = '1'; if(judge(s)) num.push_back(s);
			} 
		}
		s = num.size(); t = s + 1; //源点和汇点 
		
		REP(i, 0, num.size())
		{
			if(sum(num[i])) AddEdge(s, i, 1); //如果这个点是奇的， 那么从源点到奇数点连一条弧 
			else AddEdge(i, t, 1); // 偶的则从这个点到汇点连一条弧 
			REP(j, i + 1, num.size())
			{
				int cnt = 0;
				REP(k, 0, n)
				{
					if(num[i][k] != num[j][k]) cnt++;
					if(cnt > 1) break;
				}
				if(cnt == 1) 
				{
					if(sum(num[i])) AddEdge(i, j, 1); //注意这里奇数点在左侧， 偶数点在右侧， 弧的方向不能错 
					else AddEdge(j, i, 1);
				}
			}
		}
		
		printf("%d\n", num.size() - maxflow()); //总的模板数减去匹配数即是答案 
	}
	
	return 0;	
}