poj 2135 简单费用流

/*
题意：给定一个无向图，要从1点到n点再返回1点，每条边最多走一次，问最短需要走多远。
分析：最小费用最大流，把题意看成是要找两条无交集的从1到n的路线，使距离和最小。
图中的点和边就是网络流图中的点和边。设置一个源，接到1点，设置一个汇，从n点接到汇。
为保证无交集，我们把每条边的流量设置为1，而源发出的流量和汇接收的流量均为2。
每条边的费用就是该边在原图中的权值。
由于最短路算法是最小费用最大流算法的子算法，所以有些最短路的题可能要用到最小费用最大流。
*/
#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
#include<cstdio>
using namespace std;
const int M=2202;
const int MAXN=400002;
const int inf=0x3fffffff;
int pre[M];          // pre[v] = k：在增广路上，到达点v的边的编号为k
int dis[M];          // dis[u] = d：从起点s到点u的路径长为d
int vis[M];         // inq[u]：点u是否在队列中
int path[M];
int head[M];
int n,m,NE,sink,tot,ans,max_flow;
struct node
{
    int u,v,cap,cost,next;
} Edge[MAXN];
void addEdge(int u,int v,int cap,int cost)
{
    Edge[NE].u=u;
    Edge[NE].v=v;
    Edge[NE].cap=cap;
    Edge[NE].cost=cost;
    Edge[NE].next=head[u];
    head[u]=NE++;
    Edge[NE].v=u;
    Edge[NE].u=v;
    Edge[NE].cap=0;
    Edge[NE].cost=-cost;
    Edge[NE].next=head[v];
    head[v]=NE++;
}
bool SPFA(int s,int t)                   //  源点为0，汇点为sink。
{
    int i;
    for(i=0; i<=n+1; i++) dis[i]=inf;
    memset(vis,0,sizeof(vis));
    memset(pre,-1,sizeof(pre));
    dis[s] = 0;
    queue<int>q;
    q.push(s);
    vis[s] =1;
    while(!q.empty())        //  这里最好用队列，有广搜的意思，堆栈像深搜。
    {
        int u =q.front();
        q.pop();
        for(i = head[u]; i != -1; i = Edge[i].next)
        {
            int v = Edge[i].v;
            if(Edge[i].cap >0&& dis[v] > dis[u] + Edge[i].cost)
            {
                dis[v] = dis[u] + Edge[i].cost;
                pre[v] = u;
                path[v]=i;
                if(!vis[v])
                {
                    vis[v] =1;
                    q.push(v);
                }
            }
        }
        vis[u] =0;
    }
    if(pre[t]==-1)
        return false;
    return true;
}
void end(int s,int t)
{
    int u, p,sum = inf;
    for(u=t; u!=s; u=pre[u])
    {
        sum = min(sum,Edge[path[u]].cap);
    }
    max_flow+=sum;
    for(u = t; u != s; u=pre[u])
    {
        Edge[path[u]].cap -= sum;
        Edge[path[u]^1].cap += sum;
        ans += sum*Edge[path[u]].cost;     //  cost记录的为单位流量费用，必须得乘以流量。
    }
}
int main()
{
    int i,a,b,w;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        NE=max_flow=ans=0;
        int S=0,T=n+1;
        memset(head,-1,sizeof(head));
        for(i=1; i<=m; i++)
        {
            scanf("%d%d%d",&a,&b,&w);
            addEdge(a,b,1,w);
            addEdge(b,a,1,w);
        }
        addEdge(S,1,2,0);
        addEdge(n,T,2,0);
        while(SPFA(S,T))
        {
            end(S,T);
        }
        printf("%d\n",ans);
    }
    return 0;
}
/*
4 5
1 2 1
2 3 1
3 4 1
1 3 2
2 4 2
*/