【笔记】分层图最短路学习笔记

第一次看到这个名词是在 P4568 里，有了前一次最短路的经验，分层图的学习就顺利多啦！

分层图比想象中的简单多。它可以用来解决图上的决策问题。

前置知识：常见最短路算法 (Floyd, Dijkstra, Bellman-Ford 三件套总会吧)，可以看我的博文：最短路。

例题#

我也是从题目中认识分层图的。

[JLOI2011] 飞行路线#

题目描述

Alice 和 Bob 现在要乘飞机旅行，他们选择了一家相对便宜的航空公司。该航空公司一共在 $n$ 个城市设有业务，设这些城市分别标记为 $0$ 到 $n-1$，一共有 $m$ 种航线，每种航线连接两个城市，并且航线有一定的价格。

Alice 和 Bob 现在要从一个城市沿着航线到达另一个城市，途中可以进行转机。航空公司对他们这次旅行也推出优惠，他们可以免费在最多 $k$ 种航线上搭乘飞机。那么 Alice 和 Bob 这次出行最少花费多少？

输入格式

第一行三个整数 $n,m,k$，分别表示城市数，航线数和免费乘坐次数。

接下来一行两个整数 $s,t$，分别表示他们出行的起点城市编号和终点城市编号。

接下来 $m$ 行，每行三个整数 $a,b,c$，表示存在一种航线，能从城市 $a$ 到达城市 $b$，或从城市 $b$ 到达城市 $a$，价格为 $c$。

输出格式

输出一行一个整数，为最少花费。

样例 #1

样例输入 #1

5 6 1
0 4
0 1 5
1 2 5
2 3 5
3 4 5
2 3 3
0 2 100

样例输出 #1

8

提示

数据规模与约定

对于 $30\%$ 的数据，$2 \le n \le 50$，$1 \le m \le 300$，$k=0$。

对于 $50\%$ 的数据，$2 \le n \le 600$，$1 \le m \le 6\times10^3$，$0 \le k \le 1$。

对于 $100\%$ 的数据，$2 \le n \le 10^4$，$1 \le m \le 5\times 10^4$，$0 \le k \le 10$，$0\le s,t,a,b < n$，$a\ne b$，$0\le c\le 10^3$。

另外存在一组 hack 数据。

解法#

其实就是最短路，但是与传统的最短路有有些不同——它多了一个选项，就是免费航线。因此对于这样一个图，每条路径出现了两种选择：免费或者付费。

如果我们把每个图的所有结点都复制 $k$ 份，每个对应点之间连线。这些对应边的边权为 $0$，这就代表了免费航线。这就是分层图。复制的每一份都是一层。

其实大家能猜到，在路过一个点的时候就要做决策，是往下一层，还是继续待在这一层？所以分层图的精髓在决策，和动态规划有异曲同工之妙。 所以很多人这道题也是用 dp 写的。

分层的思路很简单，每加一条边，就把这条边复制 $k$ 份，怎么复制呢？因为有 $n$ 个点，所以新边的就是 $(u+(i-1)n,v+in,0)$ ，注意无向图要在原来的边上再复制一份，另一条边就是 $(v+(i-1)n,u+in,0)$ 。不仅是分层图的不同层之间要连线，同层的不同点之间也要连，所以还有两条边是 $(u+in,v+in,w)$ 和 $(v+in,u+in,w)$。

建完图后，图上跑一次最短路，数据限制我选择了优先队列优化的 Dijkstra，实现方法可以看我博客。完整代码如下：

#include <bits/stdc++.h>
#define rty printf("Yes\n");
#define RTY printf("YES\n");
#define rtn printf("No\n");
#define RTN printf("NO\n");
#define rep(v,b,e) for(int v=b;v<=e;v++)
#define repq(v,b,e) for(int v=b;v<e;v++)
#define rrep(v,e,b) for(int v=b;v>=e;v--)
#define rrepq(v,e,b) for(int v=b;v>e;v--)
#define stg string
#define vct vector
using namespace std;

typedef long long ll;
typedef unsigned long long ull;

void solve() {
	
}

const int N = 1e6 + 5, M = 5e6 + 5;
int n, m, k, s, t, vis[N], head[N], cnt, dis[N];
struct edge {
  int u, v, w, next;
}E[M];
struct node {
  int w, now;
  bool operator < (const node& x) const {
    return w > x.w;
  }
};
void add(int u, int v, int w) {
  E[++cnt] = {u, v, w, head[u]};
  head[u] = cnt;
}
void input() {
  cin >> n >> m >> k >> s >> t;
  rep(i, 1, m) {
    int u, v, w;
    cin >> u >> v >> w;
    add(u, v, w);
    add(v, u, w);
    rep(j, 1, k) {
      add(u + (j - 1) * n, v + j * n, 0);
      add(v + (j - 1) * n, u + j * n, 0);
      add(u + j * n, v + j * n, w);
      add(v + j * n, u + j * n, w);
    }
  }
  rep(i, 1, k) {
    add(t + (i - 1) * n, t + i * n, 0);
  }
}

const int INF = 1234567890;

void dijkstra() {
  priority_queue<node> q;
  memset(dis, 127, sizeof dis);
  dis[s] = 0;
  q.push({0, s});
  while (q.size()) {
    int u = q.top().now; q.pop();
    if (vis[u]) {
      continue;
    }
    vis[u] = 1;
    for (int i = head[u]; i; i = E[i].next) {
      int v = E[i].v;
      if (dis[v] > E[i].w + dis[u]) {
        dis[v] = E[i].w + dis[u];
        q.push({dis[v], v});
      }
    }
  }
}

main() {
//	int t; cin >> t; while (t--) solve();
  input();
  dijkstra();
  cout << dis[t + k * n];
	return 0;
}