编程之美2014年资格赛第三题——格格取数（已过大数据）

题目3 :格格取数

时间限制:2000ms

单点时限:1000ms

内存限制:256MB

描述

给你一个m x n (1 <=m, n <= 100)的矩阵A (0<=a_ij<=10000)，要求在矩阵中选择一些数，要求每一行，每一列都至少选到了一个数，使得选出的数的和尽量的小。

 

输入

多组测试数据。首先是数据组数T

对于每组测试数据，第1行是两个正整数m, n，分别表示矩阵的行数和列数。

接下来的m行，每行n个整数，之间用一个空格分隔，表示矩阵A的元素。

 

输出

每组数据输出一行，表示选出的数的和的最小值。

 

数据范围

小数据：1 <= m, n<= 5

大数据：1 <= m, n<= 100

 

 

样例输入

2

3 3

1 2 3

3 1 2

2 3 1

5 5

1 2 3 4 5

5 1 2 3 4

4 5 1 2 3

3 4 5 1 2

2 3 4 5 1

样例输出

Case 1: 3

Case 2: 5

题目要求使得每一行、每一列都至少有一个数被取出，并使得取出的和最小。开始就觉得是每行、每列都去一个这样是最小的。网上流传很广的一组样例：

4  4

1  1  100

100  100 1

100  100 1

能够很轻松的否定掉这个思路。开始按照这个思路写的最小费用最大流，是因为最大流为max(n,m)。但是，显然不是这个样子的。真正的流量是不能够确定的。所以，直接用最小费用最大流就不行了。

那么，这里我们可以进行一些处理。让没有必要的流量直接从源点流向汇点。这样一来，总流量就一定是n*m了。而对于要通过行点和列点的流量是多少呢？经过分析可以发现。如果第i行和第j列都已经取出了一个数（不是a[i][j]时），那么a[i][j]必然是不会被取出的。

现在要解决的问题就是如何保证行点和列点至少流过一次，且不会存在两个已经流过的点在被同时流一次。将行点和列点进行拆分。共2*m个行点和2*n个列点。那么就是源点到m个行点的流量为1，费用为负无穷，n个列点到汇点的流量为1，费用为负无穷。剩下的m个行点的流量为n，费用为0，n个列点的流量为m，费用为0.源点到汇点的流量为n*m,费用为0.同时，我们需要建立一个超级源点，保证总流量一定是n*m。即超级源点到源点的流量是n*m。这样就能保证得到的费用是最小值了，最后的结果就是得到的费用加上(n+m)*负无穷。

可以看出来，如果某个行点和某个列点已经被选择，那么如果存在一个流流过这两个点，那么代价必然是a[i][j]，显然不如直接从源点流向汇点。所以，就避免出现第i行和第j列都已经取出了一个数且不是a[i][j]时，取出了a[i][j]这种多余情况。同时，可以得到，负无穷只要能使最大边权+负无穷小于0即可。

 

#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cstring>
#define INF 99999999
#define MAXN 20000
using namespace std;
const int M = 100010;//边
const int N = 500;

struct Node//边，点f到点t，流量为c，费用为w
{
	int st, ed;
	int flow, cost;
	int next;
}edge[M];

int head[N], dis[N], q[N], pre[N], cnt;//cnt为已添加的边数，head为邻接表,dis为花费，pre为父亲节点
bool vis[M];
int n, m, s ,t;
int graph[110][110];

void init()
{
	memset(head, -1, sizeof(head));
	cnt = 0;
}

void add_edge(int f, int t, int d1, int d2, int w)
{//f到t的一条边，流量为d1,反向流量d2,花费w,反向边花费-w（可以反悔)
	edge[cnt].st = f;
	edge[cnt].ed = t;
	edge[cnt].flow = d1;
	edge[cnt].cost = w;
	edge[cnt].next = head[f];
	head[f] = cnt++;

	edge[cnt].st = t;
	edge[cnt].ed = f;
	edge[cnt].flow = d2;
	edge[cnt].cost = -w;
	edge[cnt].next = head[t];
	head[t] = cnt++;
}

bool spfa(int s, int t, int n)
{
	int i, tmp, l, r;
	memset(pre, -1, sizeof(pre));
	for(i = 0; i < n; ++i)
    {
        dis[i] = INF;
    }
	dis[s] = 0;
	q[0] = s;
	l = 0, r = 1;
	vis[s] = true;
	while(l != r)
    {
		tmp = q[l];
		l = (l + 1) % (n + 1);
		vis[tmp] = false;
		for(i = head[tmp]; i!=-1; i = edge[i].next)
		{
			if(edge[i].flow && dis[edge[i].ed] > dis[tmp] + edge[i].cost)
			{
				dis[edge[i].ed] = dis[tmp] + edge[i].cost;
				pre[edge[i].ed] = i;
				if(!vis[edge[i].ed])
				{
					vis[edge[i].ed] = true;
					q[r] = edge[i].ed;
					r = (r + 1) % (n + 1);
				}
			}
		}
	}
	if(pre[t] == -1)
	{
	    return false;
	}
	return true;
}

void MCMF(int s, int t, int n, int &flow, int &cost)
{//起点s，终点t，点数n，最大流flow，最小花费cost
	int tmp, arg;
	flow = cost = 0;
	while(spfa(s, t, n))
    {
		arg = INF;
		tmp = t;
		while(tmp != s)
		{
			arg = min(arg, edge[pre[tmp]].flow);
			tmp = edge[pre[tmp]].st;
		}
		tmp = t;
		while(tmp != s)
		{
			edge[pre[tmp]].flow -= arg;
			edge[pre[tmp] ^ 1].flow += arg;
			tmp = edge[pre[tmp]].st;
		}
		flow += arg;
		cost += arg * dis[t];
	}
}

int main()
{
	int x;
	scanf("%d",&x);
	for(int r = 1;r <= x;r++)
	{
		init();
		scanf("%d%d",&m,&n);
		for(int i = 1;i <= m;i++)
		{
			for(int j = 1;j <= n;j++)
			{
				scanf("%d",&graph[i][j]);
				add_edge(i,2*m+j,1,0,graph[i][j]);
				add_edge(i,2*m+n+j,1,0,graph[i][j]);
				add_edge(i+m,2*m+n+j,1,0,graph[i][j]);
				add_edge(i+m,2*m+j,1,0,graph[i][j]);
			}
		}
		for(int i = 1;i <= m;i++)
		{
			add_edge(0,i,1,0,-MAXN);
			add_edge(0,i+m,n,0,0);
		}
		t = 2 * m + 2 * n + 1;
		for(int i = 1;i <= n;i++)
		{
			add_edge(i+2*m,t,1,0,-MAXN);
			add_edge(2*m+n+i,t,m,0,0);
		}
		s = t + 1;
		add_edge(s,0,n*m,0,0);
		add_edge(0,t,n*m,0,0);
		int flow ,cost;
		MCMF(s,t,t+2,flow,cost);
		printf("Case %d: %d\n",r,cost+(m+n)*MAXN);
	}
	return 0;
}