POJ 2135 Farm Tour

这道题做的相当纠结，不过有了一点进步总是好的，从这道题中我这个菜鸟学到了一些最基本的东西，总结一下

最小费用最大流是在最大流的基础上求最小费用，对于这种题来说我以前都习惯写邻接矩阵，不过这题是无向图又可能有重边，所以最后只能放弃改成了邻接表的方法，以前只会写邻接链表，用指针构造，比较挫，这次学习了比较通用的方法：

基本上模版如下：

struct 
{
int next;
int m,n,cost,cap;
}edge[50005];
int head[1005];//表头
void addedge(int m,int n,int cap,int cost)
{
edge[cnt].m=m;
edge[cnt].n=n;
edge[cnt].cost=cost;
edge[cnt].cap=cap;
edge[cnt].next=head[m];
head[m]=cnt;
cnt++;
}

这里cnt是一个全局变量，唯一标识当前待插入的边表。注意表头head的更新操作，有点像指针链表的前插

然后，就是算法的核心部分：对残存网络的维护上，这次又犯了几个错误：初始时反向边应该为0，我一不小心写错了，然后是最后对cost的操作直接叠加就可以了，因为每次spfa后dist的值已经考虑过修改原流的那部分了（就是cost有加有减）

还有就是碰到tle，把cin改成scanf都不行了时想想是不是循环退不出去了，别急着搜报告，检查一下循环体里的逻辑，这次是因为把更新fa和qe的操作if里了导致的错误

最后贴一下挫代码吧，大牛们别看了

#include <iostream>
#include <memory.h>
#include <cstdio>
#include <algorithm>
using namespace std;
int fieldnum,pathnum;//农场数和路径数
int fa[1005];
bool vis[1005];
int dist[1005];
int cnt;
int mq[1010];
int qe[1005];
const int inf = 0x7fffffff;  
struct 
{
	int next;
	int m,n,cost,cap;
}edge[50005];
int head[1005];//表头
void addedge(int m,int n,int cap,int cost)
{
	edge[cnt].m=m;
	edge[cnt].n=n;
	edge[cnt].cost=cost;
	edge[cnt].cap=cap;
	edge[cnt].next=head[m];
	head[m]=cnt;
	cnt++;
}
bool spfa()
{
	for(int i=1;i<=fieldnum;i++)
		dist[i]=inf;
	dist[0]=0;
	memset(vis,false,sizeof(vis));
	memset(fa,-1,sizeof(fa));
	//memset(qe,0,sizeof(qe));
	//queue <int> mq;
	fa[0]=0;
	qe[0]=0;
	mq[0]=0;
	int f=0,r=1;
	//mq.push(0);
	vis[0]=true;
	int cur;
	while(f!=r)
	{
		cur=mq[f];
		f++;
		if(f==1010)
			f=0;
		
		for(int i=head[cur];i!=-1;i=edge[i].next)
		{
			if(edge[i].cap!=0&&dist[edge[i].n]>dist[cur]+edge[i].cost)
			{
				dist[edge[i].n]=dist[cur]+edge[i].cost;
				if(vis[edge[i].n]==false)
				{
					mq[r]=edge[i].n;
					r++;
					if(r==1010)
						r=0;
					vis[edge[i].n]=true;
				}
				fa[edge[i].n]=cur;//保存节点
				qe[edge[i].n]=i;//保存和这个节点相关联的边号
				
			}		
		}
		vis[cur]=false;
	}
	if(dist[fieldnum]==inf)
		return false;
	else
		return true;
}
int fordfulkerson()
{
	//增加一个超级源点，其标号为0
	//残存网络remain，若两点之间有路，则remain[i][j]=remain[j][i]=1
	addedge(0,1,2,0);
	addedge(1,0,0,0);
	int totalcost=0;
	while(spfa()!=false)
	{
		//如果找到了增广路径，则根据fa，求改路径上点的remain，并更新cost
	
		for(int i = fieldnum; i!= 0; i=fa[i])  
		{  
			edge[qe[i]].cap -= 1;  
			edge[qe[i]^1].cap += 1;  //表示其反向边
		}
		totalcost=totalcost+dist[fieldnum];
	}
	return totalcost;
	

}
int main()
{
	cin>>fieldnum>>pathnum;
	
	int m,n,c;
	for(int i=0;i<=fieldnum;i++)
		head[i]=-1;//初始化表头
	for(int i=1;i<=pathnum;i++)
	{
		scanf("%d%d%d",&m,&n,&c);
		//cost[m][n]=cost[n][m]=c;
		addedge(m,n,1,c);
		addedge(n,m,0,-c);
		addedge(n,m,1,c);
		addedge(m,n,0,-c);
	}
	
	//构造一个最小费用最大流模型
	//题目中说是往返，这里模拟成一次走两个人，只走一次，每条路经的流量只为1，表示只能承受 最多一个人
	//为此，增加一个超级源点，其到处发点farm的流量为2
	//最后检查到达barn的流量，若为2，则表示路径可以到达
	//在fordfulkerson算法中使用spfa找到cost最小的增广路
	int result=fordfulkerson();
	cout<<result<<endl;
	return 0;
}