分配问题（费用流 or KM算法）

Description

有n件工作要分配给n个人做。第i 个人做第j 件工作产生的效益为ij c 。试设计一个将n件工作分配给n个人做的分配方案，使产生的总效益最大。
对于给定的n件工作和n个人，计算最优分配方案和最差分配方案。

Input

多组数据输入.
每组输入第1 行有1 个正整数n<=50，表示有n件工作要分配给n 个人做。接下来的n 行中，每行有n 个整数Cij，1≤i≤n，1≤j≤n，表示第i 个人做第j件工作产生的效益为Cij 。

Output

每组输出的最小总效益和最大总效益。

Sample Input

5
2 2 2 1 2
2 3 1 2 4
2 0 1 1 1
2 3 4 3 3
3 2 1 2 1

Sample Output

5
14

题目来自nefu485

方法一（不推荐，比较慢）：由于题目要同时求最小收益和最大收益，很容易想到费用流，所以直接建立源点汇点，所有边的流量限制设成1，源点和汇点分别连接的点费用0，其余的费用用对应的分配方案数值就好。

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include<string.h>
#include<algorithm>
#include<math.h>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
const   int oo=1e9;
const   int mm=11111111;
const   int mn=888888;
int node,src,dest,edge;
int ver[mm],flow[mm],cost[mm],nex[mm];
int head[mn],dis[mn],p[mn],q[mn],vis[mn];
/**这些变量基本与最大流相同，增加了cost 表示边的费用，p记录可行流上节点对应的反向边*/
void prepare(int _node,int _src,int _dest)
{
node=_node,src=_src,dest=_dest;
for(int i=0; i<node; i++)head[i]=-1,vis[i]=0;
edge=0;
}
void addedge(int u,int v,int f,int c)///起点，终点，流量，费用
{
ver[edge]=v,flow[edge]=f,cost[edge]=c,nex[edge]=head[u],head[u]=edge++;
ver[edge]=u,flow[edge]=0,cost[edge]=-c,nex[edge]=head[v],head[v]=edge++;
}
bool spfa()/**spfa 求最短路，并用 p 记录最短路上的边*/
{
int i,u,v,l,r=0,tmp;
for(i=0; i<node; ++i)dis[i]=oo;
dis[q[r++]=src]=0;
p[src]=p[dest]=-1;
for(l=0; l!=r; (++l>=mn)?l=0:l)
for(i=head[u=q[l]],vis[u]=0; i>=0; i=nex[i])
if(flow[i]&&dis[v=ver[i]]>(tmp=dis[u]+cost[i]))
{
dis[v]=tmp;
p[v]=i^1;
if(vis[v]) continue;
vis[q[r++]=v]=1;
if(r>=mn)r=0;
}
return p[dest]>-1;
}
int SpfaFlow()/**源点到汇点的一条最短路即可行流，不断的找这样的可行流*/
{
int i,ret=0,delta;
while(spfa())
{
for(i=p[dest],delta=oo; i>=0; i=p[ver[i]])
if(flow[i^1]<delta)delta=flow[i^1];
for(i=p[dest]; i>=0; i=p[ver[i]])
flow[i]+=delta,flow[i^1]-=delta;
ret+=delta*dis[dest];
}
return ret;
}
int a[55][55];
int main()
{
int n;
while(~scanf("%d",&n))
{
prepare(2*n+2,0,2*n+1);
for(int i=1; i<=n; i++)
addedge(0,i,1,0),addedge(i+n,n*2+1,1,0);
for(int i=1; i<=n; i++)
for(int j=1; j<=n; j++)
{
scanf("%d",&a[i][j]);
addedge(i,j+n,1,a[i][j]);
}
printf("%d\n",SpfaFlow());
prepare(2*n+2,0,2*n+1);
for(int i=1; i<=n; i++)
addedge(0,i,1,0),addedge(i+n,n*2+1,1,0);
for(int i=1; i<=n; i++)
for(int j=1; j<=n; j++)
addedge(i,j+n,1,-a[i][j]);
printf("%d\n",-SpfaFlow());
}
return 0;
}

方法二：这题由于只是一个带权值的匹配问题，那么又很容易想到的是KM算法，用最佳匹配的思路来完成匹配就OK，只不过这题最佳匹配和最差匹配都要求，不用担心~KM算法也有自己的优势之处，只要把所有边权值取相反数，得到的最佳匹配就是最差匹配的相反数，所以这题也就可以直接一个KM算法的模板就过了，值得注意的是KM算法跑完的时间比费用流快，只用了8ms，费用流跑了34ms，所以KM算法的效率还是比较高的咯~~~

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include<string.h>
#include<algorithm>
#include<math.h>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
const int maxn=55,inf=1e9;
int m,n,tu[maxn][maxn],match1[maxn],match2[maxn];
int KM()
{
int s[maxn],t[maxn],l1[maxn],l2[maxn],p,q,ret=0,i,j,k;
///l1为左边的匹配分量，l2是右边的匹配分量
for(i=0; i<m; i++)
{
for(l1[i]=-inf,j=0; j<n; j++)
l1[i]=tu[i][j]>l1[i]?tu[i][j]:l1[i];
if(l1[i]==-inf)
return -1;
}
for(i=0; i<n; l2[i++]=0);
memset(match1,-1,sizeof(int)*n);
memset(match2,-1,sizeof(int)*n);
for(i=0; i<m; i++)
{
memset(t,-1,sizeof(int)*n);
for(s[p=q=0]=i; p<=q&&match1[i]<0; p++)
{
for(k=s[p],j=0; j<n&&match1[i]<0; j++)
if(l1[k]+l2[j]==tu[k][j]&&t[j]<0)
{
s[++q]=match2[j],t[j]=k;
if(s[q]<0)
for(p=j; p>=0; j=p)
match2[j]=k=t[j],p=match1[k],match1[k]=j;
}
}
if(match1[i]<0)
{
for(i--,p=inf,k=0; k<=q; k++)
for(j=0; j<n; j++)
if(t[j]<0&&l1[s[k]]+l2[j]-tu[s[k]][j]<p)
p=l1[s[k]]+l2[j]-tu[s[k]][j];
for(j=0; j<n; l2[j]+=t[j]<0?0:p,j++);
for(k=0; k<=q; l1[s[k++]]-=p);
}
}
for(i=0; i<m; i++)
ret+=tu[i][match1[i]];
return ret;
}

int main()
{
while(~scanf("%d",&n))
{
m=n;
for(int i=0; i<n; i++)
for(int j=0; j<n; j++)
scanf("%d",&tu[i][j]),tu[i][j]=-tu[i][j];
printf("%d\n",-KM());
for(int i=0; i<n; i++)
for(int j=0; j<n; j++)
tu[i][j]=-tu[i][j];
printf("%d\n",KM());
}
return 0;
}