(最小费用) POJ 2135 Farm Tour

Farm Tour

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 3424		Accepted: 1065

Description

When FJ's friends visit him on the farm, he likes to show them around. His farm comprises N (1 <= N <= 1000) fields numbered 1..N, the first of which contains his house and the Nth of which contains the big barn. A total M (1 <= M <= 10000) paths that connect the fields in various ways. Each path connects two different fields and has a nonzero length smaller than 35,000.

To show off his farm in the best way, he walks a tour that starts at his house, potentially travels through some fields, and ends at the barn. Later, he returns (potentially through some fields) back to his house again.

He wants his tour to be as short as possible, however he doesn't want to walk on any given path more than once. Calculate the shortest tour possible. FJ is sure that some tour exists for any given farm.

Input

* Line 1: Two space-separated integers: N and M.

* Lines 2..M+1: Three space-separated integers that define a path: The starting field, the end field, and the path's length.

Output

A single line containing the length of the shortest tour.

Sample Input

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

Sample Output

6
/*
题目大意：求你n个点（n <= 1000）和m条边（m <= 10000），现在从点1出发经过一些边后到点n，然后再经过一些边回到点1，
		：每一条边只能走一次，每条边花费的时间不同。求最小路径。

解题思路：最小费用最大流。加一个源点S和一个汇点T，源点S与点1连一条容量为2费用为0点边，点n与汇点T也连一条容量为2费用为0的边，
		：对于题目给定的那些边。每条边的容量为1，费用为每条边花费的时间。注意这是双向边。然后求最小费用。
ps：从起点到终点的最短路和从终点到起点的最短路是一样的，所以可以看成从源点拉两条路到汇点，所以流入汇点和流出源点的容量都是2.(网上思路)
  ：因为此题是无向图，所以建边的时候如果建两条费用都是正的边的话，退流时无法修正费用。

Source Code

Problem: 2135  User: wawadimu 
Memory: 976K  Time: 63MS 
Language: C++  Result: Accepted 

Source Code
*/ 
#include<iostream>
#include<queue>
using namespace std;

#define maxm 10010
#define maxn 1010
#define inf INT_MAX
struct edge
{
	int u,v,c,f;
}w[4*maxm];//注意大小

int head[maxn];//顶点出发的第一条边
int next[4*maxm];//下一条边
int d[maxn],p[maxn];//距离和路径
bool vis[maxn];//标记数组
int n,m;
int cnt;//边数
bool Bellman_ford(int S ,int T)
{
	int i,j,k;
	int u,v,e;
	int dis;
	memset(p,-1,sizeof(p));
	memset(vis,0,sizeof(vis));
	for(i=0;i<=T;i++) d[i]=inf;
	queue<int> q;    q.push(S);   vis[S]=true;   d[S]=0;
	while(!q.empty())
	{
		u=q.front(); q.pop();
		vis[u]=false;
		for(e=head[u]; e!=-1; e=next[e])
		{
			v=w[e].v;
			dis=w[e].c;
			//cout<<v<<endl;
			if(w[e].f &&  d[v] > d[u] + dis)
			{
				//cout<<e<<"  ";
				p[v]=e;//这里记录边数，而不是顶点
				d[v] = d[u] + dis;
				if(!vis[v])
				{
					vis[v]=true;
					q.push(v);
				}
			}
		}
	}
	if(d[T]!=inf) return true;
	else return false;
}
int min_fee_max_flow(int S,int T)
{
	int ans=0;
	int px;
	while(Bellman_ford(S,T))
	{
		
		ans+=d[T];
		for(int u=p[T];u!=-1;u=p[w[u].u])
		{
			//cout<<u<<w[u].v<<endl;
			px=u;
			w[px].f--;//正向边
			w[px^1].f++;//反向边
		}
	}
	return ans;
}
void add_edge(int u,int v,int f,int c)
{
	next[cnt]=head[u];	head[u]=cnt;
	w[cnt].u=u;         w[cnt].v=v;        w[cnt].c=c;         w[cnt].f=f;       cnt++;
	next[cnt]=head[v];  head[v]=cnt;
	w[cnt].u=v;         w[cnt].v=u;        w[cnt].c=-c;	       w[cnt].f=0;       cnt++;
	
}
int main()
{
	freopen("2135.txt","r",stdin);
	int i,j,k;
	int u,v,c;
	while(scanf("%d%d",&n,&m)!=EOF)
	{
		memset(head,-1,sizeof(head));
		cnt=0;
		for(i=1;i<=m;i++)
		{
			scanf("%d%d%d",&u,&v,&c);
			add_edge(u,v,1,c);
			add_edge(v,u,1,c);
		}
		add_edge(0,1,2,0);//源点0
		add_edge(n,n+1,2,0);//汇点N+1
		int ans=min_fee_max_flow(0,n+1);
		printf("%d/n",ans);
	}
	return 0;
}