poj 2135(最小费用最大流)

最新推荐文章于 2019-03-26 19:59:01 发布

iHge2k

最新推荐文章于 2019-03-26 19:59:01 发布

阅读量473

点赞数

分类专栏：图论-最小费用最大流

本文链接：https://blog.csdn.net/zjsyhjh/article/details/27101509

版权

图论-最小费用最大流专栏收录该内容

10 篇文章 0 订阅

订阅专栏

题目链接：http://poj.org/problem?id=2135

思路：把路长看作费用，然后如果u,v之间有边，就连u->v,v->u,边容量为1,表示每条边只能走一次，最后就是源点与1连边，容量为2，费用为0，n与汇点连边，容量为2，费用为0，表示增广2次。这样就转化为为最小费用最大流问题来求解了。

  1 #include<iostream>
  2 #include<cstdio>
  3 #include<cstring>
  4 #include<algorithm>
  5 #include<queue>
  6 using namespace std;
  7 #define MAXN 1010
  8 #define MAXM 88888
  9 #define inf 1<<30
 10 
 11 struct Edge{
 12     int v,cap,cost,next;
 13 }edge[MAXM];
 14 
 15 int n,m,NE,vs,vt;
 16 int head[MAXN];
 17 
 18 void Insert(int u,int v,int cap,int cost)
 19 {
 20     edge[NE].v=v;
 21     edge[NE].cap=cap;
 22     edge[NE].cost=cost;
 23     edge[NE].next=head[u];
 24     head[u]=NE++;
 25 
 26     edge[NE].v=u;
 27     edge[NE].cap=0;
 28     edge[NE].cost=-cost;
 29     edge[NE].next=head[v];
 30     head[v]=NE++;
 31 }
 32 
 33 bool mark[MAXN];
 34 int dist[MAXN];
 35 int pre[MAXN],cur[MAXN];
 36 
 37 
 38 bool spfa(int vs,int vt)
 39 {
 40     memset(mark,false,sizeof(mark));
 41     fill(dist,dist+vt+1,inf);
 42     memset(pre,-1,sizeof(pre));
 43     queue<int>que;
 44     que.push(vs);
 45     mark[vs]=true;
 46     dist[vs]=0;
 47     while(!que.empty()){
 48         int u=que.front();
 49         que.pop();
 50         mark[u]=false;
 51         for(int i=head[u];i!=-1;i=edge[i].next){
 52             int v=edge[i].v,cost=edge[i].cost;
 53             if(edge[i].cap>0&&dist[u]+cost<dist[v]){
 54                 dist[v]=dist[u]+cost;
 55                 pre[v]=u;
 56                 cur[v]=i;
 57                 if(!mark[v]){
 58                     mark[v]=true;
 59                     que.push(v);
 60                 }
 61             }
 62         }
 63     }
 64     return dist[vt]<inf;
 65 }
 66 
 67 
 68 int MinCostFlow(int vs,int vt)
 69 {
 70     int cost=0,flow=0;
 71     while(spfa(vs,vt)){
 72         int aug=inf;
 73         for(int u=vt;u!=vs;u=pre[u]){
 74             aug=min(aug,edge[cur[u]].cap);
 75         }
 76         flow+=aug,cost+=dist[vt]*aug;
 77         for(int u=vt;u!=vs;u=pre[u]){
 78             edge[cur[u]].cap-=aug;
 79             edge[cur[u]^1].cap+=aug;
 80         }
 81     }
 82     return cost;
 83 }
 84 
 85 
 86 int main()
 87 {
 88     int u,v,cost;
 89     while(~scanf("%d%d",&n,&m)){
 90         NE=0;
 91         memset(head,-1,sizeof(head));
 92         vs=0,vt=n+1;
 93         while(m--){
 94             scanf("%d%d%d",&u,&v,&cost);
 95             Insert(u,v,1,cost);
 96             Insert(v,u,1,cost);
 97         }
 98         Insert(vs,1,2,0);
 99         Insert(n,vt,2,0);
100         int ans=MinCostFlow(vs,vt);
101         printf("%d\n",ans);
102     }
103     return 0;
104 }