poj 3422 Kaka's Matrix Travels（最小费用最大流）

http://poj.org/problem?id=3422

题目大意：

n*n的矩阵，每个点上面有一个非负整数。

从左上角走到右下角，只能走向下或者向右走；

sum=0；走到一个位置就位置上的数字加到sum里面，并且把位置整数变为0；

要求求出最k次能使sum最大为多少。

思路：

最小费用最大流的问题：

觉得建图很难理解，是看了别人思路才知道怎么建图的，要拆点，亮点之间要建一条前边和退边；

当第一次走过的时候走前边，数值改为0；再走过的时候就通过退边；

因为只能向右和向下，所以要分别向右向下连边；

最后连源点汇点；

#include<iostream>
#include<queue>
using namespace std;

const int inf=1<<30;

class Edge
{
public:
	int u;
	int v;
	int cost;
	int flow;
	int next;
}edge[50010];

int s,t;
int n,k;
int map[55][55];
int pre[5010];
int dist[5010];
bool vis[5010];
int head[5010];
int max_flow;
int edge_num;

void addedge(int u,int v,int cost,int flow)
{
	edge[edge_num].u=u;
	edge[edge_num].v=v;
	edge[edge_num].flow=flow;
	edge[edge_num].cost=cost;
	edge[edge_num].next=head[u];
	head[u]=edge_num++;
	
	edge[edge_num].u=v;
	edge[edge_num].v=u;
	edge[edge_num].flow=0;
	edge[edge_num].cost=-cost;
	edge[edge_num].next=head[v];
	head[v]=edge_num++;
	return ;
}

bool spfa()
{
	queue <int> que;

	/*Initial*/
	memset(pre,-1,sizeof(pre));
	memset(vis,false,sizeof(vis));
	
	for(int j=0;j<=t;j++)
		dist[j]=inf;
	dist[s]=0;
	vis[s]=true;

	que.push(s);

	/*¶Ô·ÑÓÃÇó×î¶Ì*/
	while(!que.empty())
	{
		int x=que.front();
		que.pop();
		int y;
		for(int i=head[x];i!=-1;i=edge[i].next)
		{
			y=edge[i].v;
			if(edge[i].flow>0 && dist[y]>dist[x]+edge[i].cost)
			{
				dist[y]=dist[x]+edge[i].cost;
				pre[y]=i;

				if(!vis[y])
				{
					vis[y]=true;
					que.push(y);
				}
			}
		}
		vis[x]=false;
	}
	if(dist[t]==inf)
		return false;
	return true;
}

void argument_flow()
{
	int min_flow=inf;
	int v; 
	for(v=pre[t];edge[v].u!=s;v=pre[ edge[v].u ])
	{
		if(min_flow>edge[v].flow)
			min_flow=edge[v].flow;
	}
	for(v=pre[t];edge[v].u!=s;v=pre[ edge[v].u ])
	{
		edge[v].flow -= min_flow;
		edge[v^1].flow += min_flow;
		max_flow += min_flow*edge[v].cost;
	}
}

int main(int i,int j)
{
	while(~scanf("%d %d",&n,&k))
	{
		/*Initial*/
		s=2*n*n;
		t=s+1;
		max_flow=0;
		edge_num=0;

		memset(head,-1,sizeof(head));

		/*Input*/
		for(i=1;i<=n;i++)
		{
			for(j=1;j<=n;++j)
				scanf("%d",&map[i][j]);
		}
		int temp;

		/*Structure Graph*/
		for(i=1;i<=n;i++)
		{
			for(j=1;j<=n;++j)
			{
				temp=n*(i-1)+j-1;
				addedge(temp*2,temp*2+1,-map[i][j],1);    //前边
				addedge(temp*2,temp*2+1,0,k-1);		  //退边
			}
		}
		for(i=1;i<=n;i++)
		{
			for(j=1;j<n;j++)
			{
				temp=n*(i-1)+j-1;
				addedge(temp*2+1,2*(temp+1),0,k);         //向右
			}
		}
		for(i=1;i<n;++i)
		{
			for(j=1;j<=n;++j)
			{
				temp=n*(i-1)+j-1;
				addedge(temp*2+1,2*(temp+n),0,k);         //向左
			}
		}
		addedge(s,0,0,k);
		addedge(2*n*n-1,t,0,k);

		while(spfa()) 
			argument_flow();

		printf("%d\n",-max_flow);
	}
	return 0;
}