uva 3353 Optimal Bus Route Design(费用流)

题目大意：无向图，从点1到点n，再从n回到1，边不能重复访问，求最小距离。

分析：

由于是无向图，因此，从n到1，可看作从1到n。一开始想到求两次最短路，然后发现是行不通的。因为第一次求出最短路之后需要将最短路上的边去掉，然而去掉之后可能会造成不再存在1到n的路径了，而实际上原图中是存在两条由1到n的边不重复的最短路的。比如一个有一条对角线的矩形，起点和终点分别为非对角线上的两个点，第一次求出的最短路包含对角线，将最短路中的边都去掉后就再也找不到路径了。

联想求边不重复的最短路条数的问题的做法，可以得出以下解法：

1、新建立一个源点0，与点1连一条边，容量为2，花费为0

2、输入的边的容量为1，花费即为两点的距离。

3、新建立一个汇点n+1，点n到该点连一条边，容量为2，花费为0.

4、求最小费用流，即为答案。

这样，如果最后求出来最大流等于2，则说明至少存在两条边不重复的最短路，当然题目中已经保证有解了，这里就无需判断了。

关于费用流的算法如下：

#include<iostream>
#include<cstdio>
#include<cmath>
#include<map>
#include<set>
#include<algorithm>
#include<queue>
#include<stack>
#include<cstdlib>
#include<cstring>
#include<vector>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
typedef long long LL;
typedef unsigned long long uLL;
typedef unsigned int uI;
typedef double db;
#define inf 0x3f3f3f3f
#define maxn 1005
#define maxq 2000
#define maxm 40005
struct Edge{
    int to,next,cap,cost;
}edge[maxm];

int n,m,head[maxn],cnt,Q[maxq],qhead,qtail;
int cur[maxn],f[maxn],mcmf_cost,mcmf_flow;

inline void add(int u,int v,int cap,int cost)
{
    edge[cnt].to=v;
    edge[cnt].cap=cap;
    edge[cnt].cost=cost;
    edge[cnt].next=head[u];
    head[u]=cnt++;
    edge[cnt].to=u;
    edge[cnt].cap=0;
    edge[cnt].cost=-cost;
    edge[cnt].next=head[v];
    head[v]=cnt++;
}

int d[maxn];
bool vis[maxn];

inline bool spfa(int s,int e)
{
    int i;
    qhead=qtail=0;
    for(i=0;i<=n+1;++i)
    {
        d[i]=inf;
        vis[i]=0;
    }
    d[s]=0;
    Q[qtail++]=s;
    cur[s]=-1;
    f[s]=inf;
    vis[s]=1;
    while(qtail>qhead)
    {
        int u=Q[qhead++];
        vis[u]=0;
        for(i=head[u];~i;i=edge[i].next)
        {
            int v=edge[i].to;
            if(edge[i].cap&&d[v]>d[u]+edge[i].cost)
            {
                d[v]=d[u]+edge[i].cost;
                f[v]=min(f[u],edge[i].cap);
                cur[v]=i;
                if(!vis[v])
                {
                    vis[v]=1;
                    Q[qtail++]=v;
                }
            }
        }
    }
    if(d[e]==inf) return 0;
    mcmf_flow+=f[e];
    for(i=cur[e];~i;i=cur[edge[i^1].to])
    {
        edge[i].cap-=f[e];
        edge[i^1].cap+=f[e];
        mcmf_cost+=f[e]*edge[i].cost;
    }
    return 1;
}

int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        cnt=0;
        memset(head,-1,sizeof(head));
        mcmf_cost=mcmf_flow=0;
        for(int i=1;i<=m;++i)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            add(a,b,1,c);
            add(b,a,1,c);
        }
        add(0,1,2,0);
        add(n,n+1,2,0);
        while(spfa(0,n+1));
        printf("%d\n",mcmf_cost);
    }
    return 0;
}