uva1658 Admiral 最小费用最大流

题意：一个带权有向图，求起点到终点的两条路径权值之和最小，且两条路径没有公共点（除起点，终点）；

分析：拆点法，将u拆成u和u'，u-u'容量为1，费用为0，这样就能保证每个点只用一次，起点s-s'容量为2，终点t-t'容量为2保证最大流会求出两条路径，若输入u-v,权为c，则增加边u'-v，容量为1，费用为c.

#include<iostream>
#include<string>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<iomanip>
#include<map>
#include<algorithm>
#include<queue>
#include<set>
#define inf 10000000
#define pi acos(-1.0)
#define eps 1e-8
#define seed 131
using namespace std;
typedef pair<int,int> pii;
typedef unsigned long long ULL;
typedef long long LL;
const int maxn=100005;
struct Edge
{
    int from,to,cap,flow,cost;
    Edge(){};
    Edge(int a,int b,int c,int d,int e):from(a),to(b),cap(c),flow(d),cost(e){}
}edge[maxn];
int e;
int o;
int head[2005];
int next[maxn];
int n,m;
int gg[1005];
void addEdge(int a,int b,int c)
{
    edge[e]=Edge(a,b,1,0,c);
    next[e]=head[a];
    head[a]=e++;
    edge[e]=Edge(b,a,0,0,-c);
    next[e]=head[b];
    head[b]=e++;
}
bool minCostmaxFlow(int s,int t,int& flow,int& cost);
int main()
{
    int a,b,c;
    while(~scanf("%d%d",&n,&m))
    {
        e=0;
        memset(head,-1,sizeof(head));
        for(int i=1;i<=n;i++)
            gg[i]=n+i;
        for(int i=0;i<m;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            addEdge(gg[a],b,c);
        }
        a=1;b=gg[a];
        edge[e]=Edge(a,b,2,0,0);
        next[e]=head[a];
        head[a]=e++;
        edge[e]=Edge(b,a,0,0,0);
        next[e]=head[b];
        head[b]=e++;
        a=n;b=gg[n];
        edge[e]=Edge(a,b,2,0,0);
        next[e]=head[a];
        head[a]=e++;
        edge[e]=Edge(b,a,0,0,0);
        next[e]=head[b];
        head[b]=e++;
        for(int i=2;i<n;i++)
            addEdge(i,gg[i],0);
        int flow=0,cost=0;
        while(minCostmaxFlow(1,gg[n],flow,cost));
        printf("%d\n",cost);
    }
    return 0;
}
bool minCostmaxFlow(int s,int t,int& flow,int& cost)
{
    bool vis[2005];
    int pre[2005];
    int d[2005];
    int a[2005];
    for(int i=1;i<=2*n;i++)
        d[i]=inf;
    memset(vis,0,sizeof(vis));
    queue<int>que;
    que.push(s);
    vis[s]=1;
    d[s]=0;
    a[s]=inf;
    while(!que.empty())
    {
        int u=que.front();
        que.pop();
        vis[u]=0;
        for(int i=head[u];i!=-1;i=next[i])
        {
            if(edge[i].cap>edge[i].flow&&d[edge[i].to]>d[u]+edge[i].cost)
            {
                d[edge[i].to]=d[u]+edge[i].cost;
                a[edge[i].to]=min(a[u],edge[i].cap-edge[i].flow);
                pre[edge[i].to]=i;
                if(vis[edge[i].to]==0)
                {
                    que.push(edge[i].to);
                    vis[edge[i].to]=1;
                }
            }
        }
    }
    if(d[t]==inf)
        return false;
    flow+=a[t];
    cost+=a[t]*d[t];
    for(int i=t;i!=s;i=edge[pre[i]].from)
    {
        edge[pre[i]].flow+=a[t];
        edge[pre[i]^1].flow-=a[t];
    }
    return true;
}