POJ 2135 Farm Tour（最小费用最大流，变形）

题意：给一个无向图，FJ要从1号点出发到达n号点，再返回到1号点，但是路一旦走过了就会销毁（即回去不能经过），每条路长度不同，那么完成这趟旅行要走多长的路？（注：会有重边，点号无序，无向图！）

思路：

　　有重边，要用邻接表。所给的每条边都要变成4条有向边！否则可能一开始就到达不了终点了。最后要再加上一个源点和汇点，容量cap（源点，1）=2，指定只能走两次，再规定其他所给的边的容量是1就行了，当边被走过了，就自动增加了流，也就走不了了。

　　解释看代码更清晰。

  1 //#pragma comment(linker,"/STACK:102400000,102400000")
  2 #include <iostream>
  3 #include <stdio.h>
  4 #include <string.h>
  5 #include <vector>
  6 #include <stack>
  7 #include <algorithm>
  8 #include <map>
  9 //#include <bits/stdc++.h>
 10 #define LL long long
 11 #define pii pair<int,int>
 12 #define INF 0x7f7f7f7f
 13 using namespace std;
 14 const int N=10000+5;
 15 vector<int> vect[N];
 16 struct node
 17 {
 18     int from;
 19     int to;
 20     int cost;
 21     int cap;
 22     int flow;
 23 }edge[N*4];     //边数是4*M的大小
 24
 25 int edge_num;   //边的上限
 26 int f[N];       //流
 27 int path[N];    //记录路径
 28 int c[N];       //记录费用
 29 bool in[N];     //是否在queue中
 30
 31 void add_node(int a, int b, int c, int ca, int fl)
 32 {
 33     edge[edge_num].from=a;
 34     edge[edge_num].to=b;
 35     edge[edge_num].cost=c;
 36     edge[edge_num].cap=ca;
 37     edge[edge_num].flow=fl;
 38     vect[a].push_back(edge_num++);
 39 }
 40
 41
 42 LL spfa(int s,int e)
 43 {
 44     deque<int> que;
 45     que.push_back(s);
 46     c[s]=0;
 47     f[s]=INF;
 48     in[s]=1;
 49     while(!que.empty())
 50     {
 51         int x=que.front();
 52         que.pop_front();
 53         in[x]=0;
 54         for(int i=0; i<vect[x].size(); i++)
 55         {
 56             node t=edge[vect[x][i]];
 57             if(t.cap>t.flow && c[t.to]>c[t.from]+t.cost)  //能流过,且费用更小即可更新。
 58             {
 59                 path[t.to]=vect[x][i];          //记边号，方便更新flow
 60                 c[t.to]=c[t.from]+t.cost;       //更新cost，相当于距离
 61                 f[t.to]=min(f[t.from], t.cap-t.flow);
 62                 if(!in[t.to])
 63                 {
 64                     que.push_back(t.to);
 65                     in[t.to]=1;
 66                 }
 67             }
 68         }
 69     }
 70     return c[e];
 71 }
 72
 73 int m;
 74
 75 int mcmf(int s, int e)
 76 {
 77     LL ans=0;
 78     while(1)
 79     {
 80         memset(f, 0, sizeof(f));
 81         memset(c, 0x7f, sizeof(c));
 82         memset(in, 0, sizeof(in));
 83         memset(path, 0, sizeof(path));
 84
 85         int tmp=spfa(s, e);
 86         if(tmp==INF)    return ans;
 87         ans+=tmp*f[e];   //这是最小费用。注：每次的流可能不是1。
 88
 89         int ed=e;
 90         while(ed!=s)
 91         {
 92             int en=path[ed];
 93             edge[en].flow+=f[e];
 94             edge[en^1].flow-=f[e];
 95             ed=edge[en].from;
 96             //cout<<edge[en].from<<"-"<<edge[en].to<<endl;
 97         }
 98     }
 99 }
100
101
102
103
104
105 int main()
106 {
107     freopen("input.txt", "r", stdin);
108     int  n, a, b, c;
109     while(~scanf("%d%d", &n, &m))
110     {
111         for(int i=n*2; i>=0; i--)   vect[i].clear();
112         edge_num=0;
113         for(int i=0; i<m; i++)
114         {
115             scanf("%d%d%d",&a,&b,&c);
116             add_node(a,b,c,1,0);    //4条有向边。
117             add_node(b,a,-c,0,0);
118
119             add_node(b,a,c,1,0);
120             add_node(a,b,-c,0,0);
121         }
122         add_node(0,1,0,2,0);        //加多2条边
123         add_node(1,0,0,0,0);        //加这条无意义，但是更新flow时更方便
124         add_node(n,n+1,0,2,0);
125         add_node(n+1,n,0,0,0);
126
127         printf("%lld\n",mcmf(0, n+1));
128     }
129
130
131     return 0;
132 }

AC代码