[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[1001], 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, 0, sizeof(vis));
    memset(pre, -1, sizeof(pre));
    memset(dis, 127 / 3, sizeof(dis));
    q.push(s);
    dis[s] = 0;
    while(!q.empty())
    {
        u = q.front(), q.pop();
        vis[u] = 0;
        for(i = head[u]; i ^ -1; 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] = 1;
                }
            }
        }
    }
    return pre[t] ^ -1;
}

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