POJ 2135(费用流基础题)

POJ 2135

题目大意

有N个点M条双向边的图，求从起点1到终点N的两条边不相交的路径，要求这两条路径长度的总和最小，输出最小长度

分析

肯定不能通过贪心的方法先求一条再求一条。

我们可以换一种方式来描述问题：有两个人要从节点1走到节点2，要求他们不能走同一条道路，问他们走的总路程的最小值是多少。

费用流问题(MCMF)是解决每条边有容量限制，每条边上有单位流量的花费，求在一定流量下的最小花费的问题。

通过重述问题后，我们可以看出这个问题和费用流问题有点像。可以通过一点转化将问题变为费用流问题：人数是两人也就是说流量为2，不能走同一条道路也就是每条边的容量为1，这里路径长度就是花费。

新建一个节点流向源点为2.

ps:这道题数据有点问题，点数和边数需要开大一倍

代码

#include<cstdio>
#include<iostream>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<queue>
#include<map>
#include<algorithm>
#include<set>
using namespace std;
const int INF=0x7fffffff;
const int MAXN=2005;
const int MAXM=20005;
int n,m;
struct Edge
{
      int u;
      int v;
      int cap;
      int cost;
      int next;
}edge[MAXM*2];
int edgecount;//下标从0开始
int head[MAXN];
int dis[MAXN];
int vis[MAXN];
int pre[MAXM*2];
void Add_edge(int u,int v,int cap,int cost)
{
     edge[edgecount].u=u;edge[edgecount].v=v;edge[edgecount].cap=cap;
     edge[edgecount].cost=cost;edge[edgecount].next=head[u];
     head[u]=(edgecount++);
     edge[edgecount].u=v;edge[edgecount].v=u;edge[edgecount].cap=0;
     edge[edgecount].cost=-cost;edge[edgecount].next=head[v];
     head[v]=(edgecount++);
}
void Init()
{
      memset(head,-1,sizeof(head));
      edgecount=0;
}
bool  Spfa(int s,int t,int n)//返回0表示没找到,题目保证无环
{
      for(int i=0;i<=n;i++)
      {
            dis[i]=INF;
            vis[i]=0;
      }
      memset(pre,-1,sizeof(pre));//pre[v]表示连向v的边
      dis[s]=0;
      vis[s]=1;
      queue<int>Q;
      Q.push(s);
      while(!Q.empty())
      {
            int u=Q.front();
            Q.pop();
            vis[u]=0;
            for(int k=head[u];k!=-1;k=edge[k].next)
            {
                  int v=edge[k].v;
                  int w=edge[k].cost;
                  if(edge[k].cap && dis[v]>dis[u]+w)
                  {
                        dis[v]=dis[u]+w;
                        pre[v]=k;
                        if(!vis[v])
                        {
                              vis[v]=1;
                              Q.push(v);
                        }
                  }
            }
      }
      if(dis[t]==INF)return 0;
      return 1;
}
void MCMF(int s,int t,int n)//源点s到汇点t，总点数为n
{
      int mincost=0;
      int minflow=INF;
      while(Spfa(0,t,n)==1)
      {
            for(int k=pre[t];k!=-1;k=pre[edge[k].u])
            {
                  minflow=min(minflow,edge[k].cap);
            }
            for(int k=pre[t];k!=-1;k=pre[edge[k].u])
            {
                  edge[k].cap-=minflow;
                  edge[k^1].cap+=minflow;
            }
            mincost+=dis[t]*minflow;
      }
      cout<<mincost<<endl;
}
int main()
{
    int a,b,c;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
          Init();
          for(int i=1;i<=m;i++)
          {
                scanf("%d%d%d",&a,&b,&c);
                Add_edge(a,b,1,c);
                Add_edge(b,a,1,c);
          }
          Add_edge(0,1,2,0);
          //Add_edge(n,n+1,2,0);
          MCMF(0,n,n+1);
    }
    return 0;
}