[luoguP2770] 航空路线问题（最小费用最大流）

传送门

模型

求最长两条不相交路径，用最大费用最大流解决。

实现

为了限制经过次数,将每个点i拆成xi,yi.

1、从xi向yi连一条容量为1,费用为1的有向边(1<i<N),

2、从x1向y1连一条容量为2,费用为1的有向边,

3、从xN向yN连一条容量为2,费用为1的有向边,

4、如果存在边(i,j)(i<j)从yi向xj连一条容量为1,费用为0的有向边.

如果存在边(i,j)(i>j)，那么交换i，j，再连边，因为原题是过去再回来，我们要转换成网络流的图，只求起点到终点的最大费用流。

如果存在边(i,j)(i==1 && j==n) 那么要连一条容量为2，费用为0的边。

因为原题要求最大费用流，所以我们需要将费用取反，求出费用后再取反回来。

求x1到yN的最大费用最大流.若(x1,y1)满流,则有解,答案为最大费用最大流-2;否则,无解.

分析

每条航线都是自西向东，本题可以转化为求航线图中从1到N两条不相交的路径，使得路径长度之和最大。转化为网络流模型，就是找两条最长的增广路。由于每个城市只能访问一次，要把城市

拆成两个点，之间连接一条容量为1的边，费用设为1。因为要找两条路径，所以起始点和终点内部的边容量要设为2。那么费用流值-2就是两条路径长度之和，为什么减2，因为有两条容量为2

的边多算了1的费用。求最大费用最大流后，如果(<1.a>,<1.b>)不是满流，那么我们找到的路径不够2条（可能是1条，也可能0条），所以无解。

——代码

 #include <map>
 #include <queue>
 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #define N 10001
 #define M 1000001
 #define min(x, y) ((x) < (y) ? (x) : (y))

 int n, m, cnt, flow, ans, s, t;
 std::string str[], s1, s2;
 std::map <std::string, int> p;
 int head[N], to[M], val[M], cost[M], next[M], dis[N], pre[N];
 bool vis[N];

 inline void add(int x, int y, int z, int c)
 {
     to[cnt] = y;
     val[cnt] = z;
     cost[cnt] = c;
     next[cnt] = head[x];
     head[x] = cnt++;
 }

 inline bool spfa()
 {
     int i, u, v;
     std::queue <int> q;
     memset(vis, , sizeof(vis));
     memset(pre, -, sizeof(pre));
     memset(dis,  / , sizeof(dis));
     q.push(s);
     dis[s] = ;
     while(!q.empty())
     {
         u = q.front(), q.pop();
         vis[u] = ;
         for(i = head[u]; i ^ -; i = next[i])
         {
             v = to[i];
             if(val[i] && dis[v] > dis[u] + cost[i])
             {
                 dis[v] = dis[u] + cost[i];
                 pre[v] = i;
                 if(!vis[v])
                 {
                     q.push(v);
                     vis[v] = ;
                 }
             }
         }
     }
     return pre[t] ^ -;
 }

 int main()
 {
     int i, j, d, now;
     scanf("%d %d", &n, &m);
     s = , t = n << ;
     memset(head, -, sizeof(head));
     for(i = ; i <= n; i++)
     {
         std::cin >> str[i];
         p[str[i]] = i;
         if(i ^  && i ^ n)
             add(i, i + n, , -), add(i + n, i, , );
         else
             add(i, i + n, , -), add(i + n, i, , );
     }
     for(i = ; i <= m; i++)
     {
         std::cin >> s1 >> s2;
         if(p[s1] > p[s2]) std::swap(s1, s2);
         if(p[s1] ==  && p[s2] == n)
             add(p[s1] + n, p[s2], , ), add(p[s2], p[s1] + n, , );
         else
             add(p[s1] + n, p[s2], , ), add(p[s2], p[s1] + n, , );
     }
     while(spfa())
     {
         d = 1e9;
         for(i = pre[t]; i ^ -; i = pre[to[i ^ ]]) d = min(d, val[i]);
         for(i = pre[t]; i ^ -; i = pre[to[i ^ ]])
         {
             val[i] -= d;
             val[i ^ ] += d;
         }
         flow += d;
         ans += dis[t] * d;
     }
     if(flow ^ )
     {
         printf("No Solution!");
         return ;
     }
     printf("%d\n", -ans - );
     memset(vis, , sizeof(vis));
     vis[] = vis[] = ;
     std::cout << str[] << std::endl;
     for(i = head[s + n]; i ^ -; i = next[i])
         if(!val[i] && !vis[to[i]])
         {
             now = to[i];
             while(!vis[now])
             {
                 vis[now] = ;
                 std::cout << str[now] << std::endl;
                 for(j = head[now + n]; j ^ -; j = next[j])
                     if(!val[j] && !vis[to[j]])
                     {
                         now = to[j];
                         break;
                     }
             }
             break;
         }
     for(i = head[n]; i ^ -; i = next[i])
         if(!val[i ^ ] && !vis[to[i] - n])
         {
             now = to[i] - n;
             while(!vis[now])
             {
                 vis[now] = ;
                 std::cout << str[now] << std::endl;
                 for(j = head[now]; j ^ -; j = next[j])
                     if(!val[j ^ ] && !vis[to[j] - n])
                     {
                         now = to[j] - n;
                         break;
                     }
             }
             break;
         }
     std::cout << str[] << std::endl;
     return ;
 }