P9370 APIO2023 赛博乐园 / cyberland
P9370 APIO2023 赛博乐园 / cyberland。
题目就是让我们求一个有各种优惠政策的单源点 \(0\)，单汇点 \(H\) 的最短路。优惠政策是：
- 到达能力为 \(2\) 的点，可以让之前走过的距离除以 \(2\)。
- 到达能力为 \(0\) 的点，可以让之前走过的距离直接变成 \(0\)。
有限制：不能经过 \(H\) 多次。那其实也就是说，\(H\) 只能作为答案路径的终点，不能作为路径的途经点。
优惠政策最短路，再加上 97 分中 \(K\) 的限制为 \(K \le 30\)，优惠政策能使用的次数很低。
上面加粗的两句正是分层图最短路的两条重要特征。于是想到建立 \(K\) 层的分层图，来解决“除以 \(2\)”这个优惠政策。
这里默认读者已经学会分层图，若不会，请先学习并完成分层图模板：JLOI2011 飞行路线。这里还有分层图题单，供读者练习。
原图为第 \(0\) 层图，总共建立 \(K +1\) 层图（编号 \(0 \sim K\)），第 \(p\) 层的点 \(u\) 代表之前使用优惠恰好 \(p\) 次，到达点 \(u\) 的状态。我们记其为 \((p, u)\)。设它的最短路为 \(\mathrm{dis}(p, u)\)。
最短路算法必须使用 dijkstra，用 spfa 虽然可以通过原题的数据，但复杂度是错的，讨论区中有 hack 数据。
定义 \(w(u, v)\) 为原图上 \(u\) 和 \(v\) 两点之间的边权。如果 \(u\)，\(v\) 两点之间没相连接的边则 \(w(u, v)\) 未定义。
思路一
首先想一下，到达能力为 \(0\) 的点可以清空最短路，那其实就相当于从这个点开始走。
因此，我们将所有能从 \(0\) 出发，不途径 \(H\) 到达的，能力同时为 \(0\) 的点看做源点，跑多源最短路即可。
那么能力为 \(0\) 就解决了，现在只需要解决能力 \(2\)。
考虑在 dijkstra 枚举出边时进行如下松弛：
- 尝试用 \(\mathrm{dis}(p, u) + w(u, v)\) 更新 \(\mathrm{dis}(p, v)\)。代表不使用优惠政策。
- 尝试用 \(\dfrac{\mathrm{dis}(p, u) + w(u, v)}2\) 更新 \(\mathrm{dis}(p + 1, v)\)。代表使用优惠政策。
同时注意 \(H\) 不能是途经点，因此 \(\mathrm{dis}(p, H)\) 强制不松弛其它点即可。
跑一个源点为 \((0, 0)\) 的单源最短路，然后取 \(\mathrm{dis}(0, H)\)，\(\mathrm{dis}(1, H)\)，\(\mathrm{dis}(2,H)\)……中的最小值，作为答案即可。
然而这种思路的问题在于，上面的第二种松弛并不是平凡的最短路松弛，违背了 dijkstra 的正确性。
但是只要进行一步修改，上面的思路就是正确的了：
考虑朴素的 dijkstra 的优先队列，我们会优先取出 \(\mathrm{dis}\) 最小的 \((p, u)\)。而这里我们修改成：
- 对于 不同层 的两个点 \((p, u)\) 和 \((q, v)\)，不妨令 \(p <q\)，则 \((p, u)\) 更优先，不管最短路；
- 对于 同层 的两个点 \((p, u)\) 和 \((p, v)\)，则取 \(\mathrm{dis}\) 更小的更优先。
每次取最优先的开始松弛就一定没有问题。解释一下原因：
分层图是单向导通的，高层点的最短路一定不会影响低层点。
观察全局上优先队列取出的过程，大体上是优先低层，然后再优先低距离。
也就是说，在第 \(0\) 层图上，只有从点 \(0\) 出发能到达（中途不经过 \(H\)）的所有点，都当过一次队头，并松弛一遍其它点之后，才会开始处理第 \(1\) 层图的点。
我们称 dijkstra 的过程中，层号为 \(p\) 的点充当队头的阶段为第 \(p\) 阶段。那么整个 dijkstra 过程就是 \(k + 1\) 个阶段的综合：第 \(0\) 阶段，第 \(1\) 阶段，……，第 \(k\) 阶段。
那么在第 \(0\) 阶段之后，第 \(0\) 层的所有点的最短路都已经被计算好，并且已经为真实值了（原因就是高层最短路不会影响低层）。此时，目前第 \(1\) 层的点 \((1, u)\) 最短路的值是：只途径 \(0\) 层的所有点，到达 \((1, u)\) 这个点的距离的一半。
先不进行第 \(1\) 阶段，来看第 \(1\) 阶段之前，我们只看第 \(1\) 层的点，会发现只有这个变化：
一般的单源最短路，在初始时，都是源点距离为 \(0\)，而其它点距离为 \(+\infty\)。
而这里的单源最短路，若干点的距离已知，而其它点的距离为 \(+\infty\)。
会发现这种变化是不影响 dijkstra 的。可以联想一下，将这些距离已知的点 \((1, u)\)，新建一个虚点，对虚点向 \((1, u)\) 连一条权值为 \(\mathrm{dis}(1, u)\) 的边。然后对虚点为源点，跑单源最短路，那么第一步松弛的结果就是目前第 \(1\) 层点的状态。
显然 dijkstra 经过一次松弛之后仍然是正确的，所以该算法是没问题的。
上面我们阐述了从第 \(0\) 阶段到第 \(1\) 阶段的正确性，事实上，在第 \(p\) 个阶段结束后，前 \(p\) 层的最短路都已经确定，而第 \(p + 1\) 层的最短路可以看作若干个点的距离已经已知的最短路，所以第 \(p +1\) 个阶段仍然是正确的。
因此所有阶段都是正确的，算法正确。
这里设边数为小写 \(m\)，复杂度为 \(\Theta(mK \log mK)\)。
100 分做法
上面的做法是 97 分的，\(K \le 30\)。考虑 100 分的 \(K \le 10^6\)。
我们发现，事实上用一些次优惠政策之后，最短路会变的很低，远远低于精度。
具体来说，本题中最短路最大不超过边数乘边权最大值，即 \(10^{14}\)。只需让这个数除以 \(70\) 次 \(2\) 就可以掉到 \(10^{-7}\) 以下（\(8 \times 10^{-8}\)）。
也就意味着使用 \(70\) 次优惠政策之后，再优惠只可能会让最短路再少个 \(10^{-7}\) 以下。
而题目要求精度 \(10^{-6}\) 就够了，所以求出的最短路比真实最短路多个 \(10^{-7}\) 以下是可以接受的。
因此，令 \(k = \min(K, 70)\)，然后再按照 97 分做法做即可。复杂度 \(\Theta(mk \log mk)\)。
当然，如果你当心上面的 \(10^{-7}\) 误差能多次累计，以至于影响答案（虽然笔者感觉应该是不会的），把阈值设的高一点也没问题。
#include <bits/stdc++.h>
const int N = (int)1e5 + 5;
const int K = 75;
typedef std :: pair <int, int> pii;
struct node {
int p;
int u;
double dis;
bool operator < (const node b) const {
if (this -> p != b.p)
return this -> p > b.p;
return this -> dis > b.dis;
}
};
std :: vector <pii> G[N];
double dis[K][N];
std :: bitset <N> vis[K];
std :: bitset <N> con;
inline void init(int n, int k) {
con.reset();
for (int u = 0; u < n; ++u)
G[u].clear();
for (int p = 0; p <= k; ++p)
vis[p].reset();
for (int p = 0; p <= k; ++p)
for (int u = 0; u < n; ++u)
dis[p][u] = 1e17;
}
void dfs(int u, int t) {
con.set(u);
for (pii e : G[u]) {
int v = e.first;
if (!con[v] && v != t)
dfs(v, t);
}
}
double solve(int n, int m, int k, int t, std :: vector <int> us, std :: vector <int> vs, std :: vector <int> wei, std :: vector <int> a) {
if (k > 70)
k = 70;
init(n, k);
for (int i = 0; i < m; ++i) {
int u = us[i], v = vs[i], w = wei[i];
G[u].push_back({v, w});
G[v].push_back({u, w});
}
dfs(0, t);
std :: priority_queue <node> q;
for (int u = 0; u < n; ++u) {
if (con[u] && (a[u] == 0 || u == 0)) {
dis[0][u] = 0;
q.push({0, u, 0});
}
}
while (!q.empty()) {
node now = q.top();
q.pop();
int u = now.u, p = now.p;
if (vis[p][u] || u == t)
continue;
vis[p].set(u);
for (pii e : G[u]) {
int v = e.first, w = e.second;
if (dis[p][v] > dis[p][u] + w) {
dis[p][v] = dis[p][u] + w;
if (!vis[p][v])
q.push({p, v, dis[p][v]});
}
if (a[v] == 2 && p < k) {
if (dis[p + 1][v] > (dis[p][u] + w) / 2) {
dis[p + 1][v] = (dis[p][u] + w) / 2;
if (!vis[p + 1][v])
q.push({p + 1, v, dis[p + 1][v]});
}
}
}
}
double ans = DBL_MAX;
for (int p = 0; p <= k; ++p)
ans = std :: min(ans, dis[p][t]);
if (ans > 1e15)
return -1;
return ans;
}
思路二
如果你想不到修改堆排序方式，还有一种思路，我们只需要对原题进行转化并进行合理地分层之后，套一个裸 dijkstra 就可以解决。
考虑建立反图（虽然无向图的反图和原图是一样的），观察反的最短路径上，优惠政策的含义：
- 原先遇到能力为 \(0\) 的点，会把当前距离设置为 \(0\)；
- 那么现在遇到能力为 \(0\) 的点，相当于让之后走过的所有边权都变成 \(0\)。
- 原先遇到能力为 \(2\) 的点，会把当前距离减半；
- 那么现在遇到能力为 \(2\) 的点，相当于让之后走过的所有边权都变成原来的一半。
我们发现，直接让第 \(p\) 层上 \(u\) 和 \(v\) 之间的边权为原图上 \(u\) 和 \(v\) 之间边权的 \(\dfrac{1}{2^p}\)，就能满足能力为 \(2\) 的点；至于能力为 \(0\) 的点，我们可以新建一层 \(K + 1\) 层，让这一层内 \(u\) 和 \(v\) 之间的边权都改成 \(0\)。然后让所有 \(a[v] = 0\) 的 \((p, v)\) 直接单向导通到 \(K + 1\) 层即可。
这样以来，裸的 dijkstra 就可以解决问题。此时汇点是 \(H\)，源点是 \(0\)。
同时注意一下不能途径 \(H\) 的问题。思路一中，我们是允许某个点松弛 \((p, H)\) 的，只是不允许 \((p, H)\) 松弛别人而已；思路二中我们是从 \(H\) 出发，这里我们不能允许任意一个点松弛 \((p, H)\)。
#include <bits/stdc++.h>
const int N = (int)1e5 + 5;
const int K = 75;
typedef std :: pair <int, int> pii;
struct node {
int p;
int u;
double dis;
bool operator < (const node b) const {
return this -> dis > b.dis;
}
};
std :: vector <pii> G[N];
double dis[K][N];
std :: bitset <N> vis[K];
double val[K];
inline void init(int n, int k) {
val[0] = 1;
for (int i = 1; i <= k; ++i)
val[i] = val[i - 1] / 2;
val[k + 1] = 0;
for (int u = 0; u < n; ++u)
G[u].clear();
for (int p = 0; p <= k + 1; ++p)
vis[p].reset();
for (int p = 0; p <= k + 1; ++p)
for (int u = 0; u < n; ++u)
dis[p][u] = 1e17;
}
double solve(int n, int m, int k, int t, std :: vector <int> us, std :: vector <int> vs, std :: vector <int> wei, std :: vector <int> a) {
if (k > 70)
k = 70;
init(n, k);
for (int i = 0; i < m; ++i) {
int u = us[i], v = vs[i], w = wei[i];
G[u].push_back({v, w});
G[v].push_back({u, w});
}
std :: priority_queue <node> q;
dis[0][t] = 0;
q.push({0, t, 0});
while (!q.empty()) {
node now = q.top();
q.pop();
int u = now.u, p = now.p;
if (vis[p][u])
continue;
vis[p].set(u);
for (pii e : G[u]) {
int v = e.first, w = e.second;
if (v == t)
continue;// 这里阻止松弛的方式和思路一不同，原理已经解释
if (a[v] == 0) {
if (dis[k + 1][v] > dis[p][u] + w * val[p]) {
dis[k + 1][v] = dis[p][u] + w * val[p];
if (!vis[k + 1][v])
q.push({k + 1, v, dis[k + 1][v]});
}
continue;
}
if (dis[p][v] > dis[p][u] + w * val[p]) {
dis[p][v] = dis[p][u] + w * val[p];
if (!vis[p][v])
q.push({p, v, dis[p][v]});
}
if (a[v] == 2 && p < k) {
if (dis[p + 1][v] > dis[p][u] + w * val[p]) {
dis[p + 1][v] = dis[p][u] + w * val[p];
if (!vis[p + 1][v])
q.push({p + 1, v, dis[p + 1][v]});
}
}
}
}
double ans = DBL_MAX;
for (int p = 0; p <= k + 1; ++p)
ans = std :: min(ans, dis[p][0]);
if (ans > 1e15)
return -1;
return ans;
}
