网络流 P2770 航空路线问题

#include <cstdio>
#include <cstdlib>
#include <map>
#include <queue>
#include <algorithm>
#include <string>
#include <iostream>
#include <cstring>
#include <vector>
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
const int maxn = 1e5;
struct edge
{
    int u, v, c, f, cost;
    edge(int u, int v, int c, int f, int cost) :u(u), v(v), c(c), f(f), cost(cost) {}
};
vector<edge>e;
vector<int>G[maxn];
int a[maxn];//找增广路每个点的水流量
int p[maxn];//每次找增广路反向记录路径
int d[maxn];//SPFA算法的最短路
int inq[maxn];//SPFA算法是否在队列中
int s,t;
void init(int n)
{
    for (int i = ; i <= n; i++)G[i].clear();
    e.clear();
}
void add(int u, int v, int c, int cost)
{
    e.push_back(edge(u, v, c, , cost));
    e.push_back(edge(v, u, , , -cost));
    int m = e.size();
    G[u].push_back(m - );
    G[v].push_back(m - );
    // printf("%d %d %d %d %d\n", m - 2, u, v, c, cost);
    // printf("%d %d %d %d %d\n", m - 1, u, v, c, cost);
}
bool bellman(int s, int t, int& flow, long long & cost)
{
    memset(d, 0xef, sizeof(d));
    memset(inq, , sizeof(inq));
    d[s] = ; inq[s] = ;//源点s的距离设为0，标记入队
    p[s] = ; a[s] = inf;//源点流量为INF（和之前的最大流算法是一样的）

    queue<int>q;//Bellman算法和增广路算法同步进行，沿着最短路拓展增广路，得出的解一定是最小费用最大流
    q.push(s);
    while (!q.empty())
    {
        int u = q.front();
        q.pop();
        inq[u] = ;//入队列标记删除
        for (int i = ; i < G[u].size(); i++)
        {
            edge & now = e[G[u][i]];
            //printf("%d %d %d %d %d %d\n", u, now.u, now.v, now.c, now.f, now.cost);
            int v = now.v;
            if (now.c > now.f && d[v] < d[u] + now.cost)
                //now.c > now.f表示这条路还未流满（和最大流一样）
                //d[v] > d[u] + e.cost Bellman 算法中边的松弛
            {
                // printf("d[%d]=%d d[%d]=%d %d d[%d]=%d\n", v,d[v],u, d[u], now.cost,v,d[u]+now.cost);
                // printf("%d %d %d %d %d %d\n", u, now.u, now.v, now.c, now.f, now.cost);
                d[v] = d[u] + now.cost;//Bellman 算法边的松弛
                p[v] = G[u][i];//反向记录边的编号
                a[v] = min(a[u], now.c - now.f);//到达v点的水量取决于边剩余的容量和u点的水量
                if (!inq[v]) { q.push(v); inq[v] = ; }//Bellman 算法入队
            }
        }
    }
    if (d[t] < )return false;//找不到增广路
    flow += a[t];//最大流的值，此函数引用flow这个值，最后可以直接求出flow
    cost += (long long)d[t] * (long long)a[t];//距离乘上到达汇点的流量就是费用
    for (int u = t; u != s; u = e[p[u]].u)//逆向存边
    {
        e[p[u]].f += a[t];//正向边加上流量
        e[p[u] ^ ].f -= a[t];//反向边减去流量 （和增广路算法一样）
        //printf("e[%d]=%d e[%d]=%d\n", p[u], e[p[u]].f, p[u] ^ 1, e[p[u] ^ 1].f);
    }
    //cout << endl;
    return true;
}
int Maxflow(int s, int t, long long & cost)
{
    cost = ;
    int flow = ;
    while (bellman(s, t, flow, cost));//由于Bellman函数用的是引用，所以只要一直调用就可以求出flow和cost
    return flow;//返回最大流，cost引用可以直接返回最小费用
}
map<string, int>mp;
string r[maxn];

void dfs1(int u,int n)
{
    if (u >  && u <= n) cout << r[u] << endl;
    for(int i=;i<G[u].size();i++)
    {
        //printf("e[%d]=%d\n", G[u][i], e[G[u][i]].f);
        if(!inq[G[u][i]]&&e[G[u][i]].f>=)
        {
            if (e[G[u][i]].v !=  && e[G[u][i]].v !=  + n) inq[G[u][i]] = ;
            dfs1(e[G[u][i]].v, n);
            break;
        }
    }
}
void dfs2(int u,int n)
{
    for(int i=;i<G[u].size();i++)
    {
        //printf("e[%d]=%d\n", G[u][i], e[G[u][i]].f);
        int v = G[u][i];
        if(!inq[v]&&e[v].f>=)
        {
            dfs2(e[G[u][i]].v, n);
            break;
        }
    }
    if (u >  && u < n) cout << r[u] << endl;
}

int main()
{
    int n, m;
    cin >> n >> m;
    s = , t =  * n + ;
    for (int i = ; i <= n; i++)
    {
        cin >> r[i];
        mp[r[i]] = i;
        add(i, i + n, , );
    }
    add(s, , , );
    add(n + n, t, , );
    add(, n + , , );
    add(n, n + n, , );
    int check = ;
    for (int i = ; i <= m; i++)
    {
        string qw, qe;
        cin >> qw >> qe;
        int u = mp[qw], v = mp[qe];
        if (u > v) swap(u, v);
        if (u ==  && v == n) check = ;
        add(u + n, v, , );
    }
    ll cost = ;
    int ans = Maxflow(s, t, cost);
    if (ans == ||ans==&&check==)
    {
        printf("No Solution!\n");
        return ;
    }
    if(ans==&&check==)
    {
        printf("%d\n", );
        cout << r[] << endl;
        cout << r[n] << endl;
        cout << r[] << endl;
        return ;
    }
    memset(inq, , sizeof(inq));
    printf("%lld\n", cost /  - );
    dfs1(s,n);
    dfs2(s,n);
    return ;
}

题目描述

给定一张航空图，图中顶点代表城市，边代表 2 城市间的直通航线。现要求找出一条满足下述限制条件的且途经城市最多的旅行路线。

(1)从最西端城市出发，单向从西向东途经若干城市到达最东端城市，然后再单向从东向西飞回起点(可途经若干城市)。

(2)除起点城市外，任何城市只能访问 1 次。

对于给定的航空图，试设计一个算法找出一条满足要求的最佳航空旅行路线。

输入输出格式

输入格式：

第 1 行有 2 个正整数 N 和 V，N 表示城市数，N<100，V 表示直飞航线数。

接下来的 N 行中每一行是一个城市名，可乘飞机访问这些城市。城市名出现的顺序是从西向东。也就是说，设 i,j 是城市表列中城市出现的顺序，当 i>j 时，表示城市 i 在城市 j 的东边，而且不会有 2 个城市在同一条经线上。城市名是一个长度不超过15 的字符串，串中的字符可以是字母或阿拉伯数字。例如，AGR34 或 BEL4。

再接下来的 V 行中，每行有 2 个城市名，中间用空格隔开，如 city1 city2 表示 city1到 city2 有一条直通航线，从 city2 到 city1 也有一条直通航线。

输出格式：

件第 1 行是旅行路线中所访问的城市总数 M。 接下来的 M＋1 行是旅行路线的城市名，每行写 1 个城市名。首先是出发城市名，然后按访问顺序列出其它城市名。 注意，最后 1 行（终点城市）的城市名必然是出发城市名。如果问题无解，则输出“No Solution!”。

输入输出样例

输入样例#1： 复制

8 9
Vancouver
Yellowknife
Edmonton
Calgary
Winnipeg
Toronto
Montreal
Halifax
Vancouver Edmonton
Vancouver Calgary
Calgary Winnipeg
Winnipeg Toronto
Toronto Halifax
Montreal Halifax
Edmonton Montreal
Edmonton Yellowknife
Edmonton Calgary

输出样例#1： 复制

7
Vancouver
Edmonton
Montreal
Halifax
Toronto
Winnipeg
Calgary
Vancouver 

说明

感谢 @FlierKing 提供spj

这个题目，写了蛮久，但是呢，又不是一个难题，所以还是挺郁闷的。

这个就是一个费用流的思想，不过这个让你求最长的路径，就是相当于求最大费用，因为一个数字只能用一次，所以要拆分。

为什么要拆分呢？原因很简单，因为给你的是一个点，所以就必须拆开，

不然比如果 a->b->c 这个时候经过一次b了，

没有拆开那么，d->b->h,这个时候又会经过一次b，而且和之前的并没有冲突。

所以b会经过很多次，与题意矛盾，所以就必须进行拆分来限制b经过的次数。

做这个题目建议自己把图画一下，然后画一下自己的建图方式，用一点点最短路的思想，然后就差不多可以写出来了，

这个很多人把路径设置为-1，我其实有点不太明白为什么可以这样子做。

这个建完图之后就是一个模板，然后就是两个dfs来输出路径，这个我觉得和前序中序后序遍历有点像。