Uva 10806 来回最短路，不重复，MCMF

题目链接：https://uva.onlinejudge.org/external/108/10806.pdf

题意：无向图，从1到n来回的最短路，不走重复路。

分析：可以考虑为1到n的流量为2时的最小花费；

建图： 一个点到一个点的容量为1，费用为距离。

 #include <cstring>
 #include <cstdio>
 #include <vector>
 #include <queue>
 #include <algorithm>
 #include <iostream>
 using namespace std;

 const int maxn =  + , INF = ;

 struct Edge
 {
     int from, to, cap, flow, cost;
 };

 struct MCMF
 {
     int n, m;
     vector<Edge> edges;
     vector<int> G[maxn];
     bool inq[maxn];         // 是否在队列中
     int d[maxn];           // Bellman-Ford
     int p[maxn];           // 上一条弧
     int a[maxn];           // 可改进量

     void init(int n)
     {
         this->n = n;
         for(int i = ; i < n; i++) G[i].clear();
         edges.clear();
     }

     void AddEdge(int from, int to, int cap, int cost)
     {
         edges.push_back((Edge)
         {
             from, to, cap, , cost
         });
         edges.push_back((Edge)
         {
             to, from, , , -cost
         });
         m = edges.size();
         G[from].push_back(m-);
         G[to].push_back(m-);
     }

     bool BellmanFord(int s, int t, int &flow, long long& cost)
     {
         memset(inq,,sizeof(inq));
         for(int i=;i<n;i++)
             d[i] = INF;
         d[s] = ;
         inq[s] = true;
         p[s] = ;
         a[s] = INF;

         queue<int> Q;
         Q.push(s);
         while(!Q.empty())
         {
             int u = Q.front();
             Q.pop();
             inq[u] = false;
             for(int i = ; i < G[u].size(); i++)
             {
                 Edge& e = edges[G[u][i]];
                 if(e.cap > e.flow && d[e.to] > d[u] + e.cost)
                 {
                     d[e.to] = d[u] + e.cost;
                     p[e.to] = G[u][i];
                     a[e.to] = min(a[u], e.cap - e.flow);
                     if(!inq[e.to])
                     {
                         Q.push(e.to);
                         inq[e.to] = true;
                     }
                 }
             }
         }
         if(d[t] == INF) return false; //s-t 不连通，失败退出
         flow += a[t];
         cost += (long long)d[t] * (long long)a[t];
         int u = t;
         while(u != s)
         {
             edges[p[u]].flow += a[t];
             edges[p[u]^].flow -= a[t];
             u = edges[p[u]].from;
         }
         return true;
     }

      pair<long long,int>Mincost(int s, int t)
     {
         long long cost = ;
         int flow = ;
         while(BellmanFord(s, t, flow, cost));
         return pair<long long ,int>{cost,flow};
     }
 };

 MCMF solver;
 int n;

 int main()
 {
     while(true)
     {
         scanf("%d", &n);
         if(n == ) break;
         solver.init(n + );
         int m, from, to, cost;
         scanf("%d", &m);
         for(int i = ; i < m; i++)
         {
             scanf("%d%d%d", &from, &to, &cost);
             solver.AddEdge(from, to, , cost);
             solver.AddEdge(to, from, , cost);
         }
         solver.AddEdge(, , , );

         pair<long long,int> ans = solver.Mincost(, n);
         int flow = ans.second;

         if(flow != )
             puts("Back to jail");
         else
             printf("%lld\n", ans.first);
     }
     return ;
 }