poj 2135 (最小费用最大流)

题意：给定一个无向图，要从1点到n点再返回1点，每条边最多走一次，问最短需要走多远。

分析：最小费用最大流，把题意看成是要找两条无交集的从1到n的路线，使距离和最小。图中的点和边就是网络流图中的点和边。设置一个源，接到1点，设置一个汇，从n点接到汇。为保证无交集，我们把每条边的流量设置为1，而源发出的流量和汇接收的流量均为2。所以要求最大流为2的结果，同时把那条最小费用的可行流找出来 。每条边的费用就是该边在原图中的权值。

注意：有重边，所以要用邻接表。因为是无向图，所以要在加边时，原图中的一条边要变成网络流图中的两条边（如果把反向负权费用边也算上就总共4条边）。

由于最短路算法是最小费用最大流算法的子算法，所以有些最短路的题可能要用到最小费用最大流

1 #include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
using namespace std;
int sumFlow;
const int MAXN = 1010;
const int MAXM = 1000200;
const int INF = 1000000000;
struct Edge
{
    int u;
    int v;
    int cap;           //流量
    int cost;         //费用
    int next;
}edge[MAXM<<2];
int NE;
int head[MAXN], dist[MAXN], pp[MAXN];
bool vis[MAXN];
void init()
{
    NE=0;
    memset(head,-1,sizeof(head));
}
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].u=v;edge[NE].v=u;edge[NE].cap=0;edge[NE].cost=-cost;
    edge[NE].next=head[v];head[v]=NE++;
}
bool SPFA(int s,int t,int n)               //spfa求残留网络的最短路
{
    int i,u,v;
    queue<int>qu;
    memset(vis,false,sizeof(vis));
    memset(pp,-1,sizeof(pp));
    for(i=0;i<=n;i++)                   
        dist[i]=INF;                            //初始化到i点的距离为INF
    vis[s]=true;
    dist[s]=0;
    qu.push(s);
    while(!qu.empty())
    {
        u=qu.front();
        qu.pop();
        vis[u]=false;
        for(i=head[u];i!=-1;i=edge[i].next)
        {
            v=edge[i].v;
            if(edge[i].cap&&dist[v]>dist[u]+edge[i].cost)      //流量要大于0，因为要找从s->t的一条路，

            {                                                                             //   流量小于，就选到了反向的边    

                dist[v]=dist[u]+edge[i].cost;
                pp[v]=i;                                //v点是这条最短路中的点，且对应的边为edge[i]. 即edge[i].v=v ;
                if(!vis[v])                                //没访问则加入队列
                {
                    qu.push(v);
                    vis[v]=true;
                }
            }
        }
    }
    if(dist[t]==INF)                  //若找不到最短路 ；
        return false;
    return true;
}
int MCMF(int s,int t,int n)              //修改调整网络
{
    int flow=0; // 总流量
    int i,minflow,mincost;
    mincost=0;
    while(SPFA(s,t,n))
    {
        minflow=INF+1;
        for(i=pp[t];i!=-1;i=pp[edge[i].u])     //从汇点沿着最短路反向回头调整网络   --------------------( 1 )
            if(edge[i].cap<minflow)
                minflow=edge[i].cap;
        flow+=minflow;
        for(i=pp[t];i!=-1;i=pp[edge[i].u])       //  反向回头时修改流量----------------------------------(2)
        {
            edge[i].cap-=minflow;            //反向回头的边都是反向边，所以，流量减minflow
            edge[i^1].cap+=minflow;       // i^1 ，（奇数，减1，偶数加1）；找对应的正向边，流量加minflow ;
        }
        mincost+=dist[t]*minflow;    //最小费用,也可以放在（2）步骤中，则写为 ：mincost+=edge[i].cost ;
    }
    sumFlow=flow;                 // 最大流  ,只是顺便求，这题不需要。
    return mincost;
}
int main()
{
    int n,m;
    int u,v,c;
    while(~scanf("%d%d",&n,&m))
    {
        init();
        int S=0;                         //加源点，汇点
        int T=n+1;
        while(m--)
        {
            scanf("%d%d%d",&u,&v,&c);
            addedge(u,v,1,c);           //建图
            addedge(v,u,1,c);
        }
        addedge(S,1,2,0);
        addedge(n,T,2,0);
        int ans=MCMF(S,T,T+1);
        printf("%d\n",ans);
    }
    return 0;
}
112