洛谷 P1119 灾后重建 （Floyd最短路）

题意

图上有$N(N\le 200)$个节点和$M$条带权无向边，每个节点都有一个时间$t_i$，表示这个节点在时间$t_i$才会出现。现在给出$(Q\le 5\times 10^4)$个查询，求在时间$t$的时候$x$，$y$两个节点之间的最短路。

解题思路

查询任意两个节点是最短路的算法肯定非Floyd莫属了，但是Floyd算法的时间复杂度很高$O(N^3)$。一开始我也没什么想法，直到看到

接下来QQ行，每行33个非负整数x, y, tx,y,t，询问在第tt天，从村庄xx到村庄yy的最短路径长度为多少，数据保证了$t$是不下降的。

才明白是怎么回事。因为$t$是不下降的，所以每次查询图上的节点都是单调递增的，这时候就可以利用Floyd算法的性质来动态求出两点之间最短路的改变了。
为什么可以动态的改变最短路呢？这就要讲到Floyd算法的性质了，很多人只知道Floyd算法怎么写，不知道Floyd算法的原理到底是什么，这样就没法做出这道题了。我们先从Floyd算法的代码入手：

for (int k = 0; k < n; k++) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            G[i][j] = min(G[i][j], G[i][k] + G[k][j]);
        }
    }
}

观察可以发现，$k$其实对于节点$i$，$j$来说，想到于一个中间点，如果两个节点的路径要经过$k$点，那么可以有最短路公式$dist=min(dist,dist(i,k)+dist(k,j))$。通过不断的更新每两个节点路径中中间节点的最小值，最终可以求出任意两点的最短路径。
那么不难想到，别看有5万次查询，其实只有$N$个节点是新加进去的，那么根据刚才的结论，新加的节点其实就相当于$k$，那么我们只需要更新新加节点与其他节点的关系就行了，这样5万次查询就能均摊这$O(N^3)$的复杂度，问题就这么解决了。

时间复杂度

$O(Q+N^3)$

代码

#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
typedef long long ll;

const int INF = 2147483647;
const int INF2 = 0x3f3f3f3f;
const ll INF64 = 1e18;
const double INFD = 1e30;
const double EPS = 1e-6;
const double PI = 3.1415926;
const ll MOD = 1e9;
// 读入优化
inline int read() {
    int X = 0, w = 0;
    char ch = 0;
    while (!isdigit(ch)) {
        w |= ch == '-';
        ch = getchar();
    }
    while (isdigit(ch)) X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
    return w ? -X : X;
}

int n, m, k;
int CASE;
const int MAXN = 205;
int G[MAXN][MAXN];
int timing[MAXN];
bool vis[MAXN];
int main() {
#ifdef LOCALLL
    freopen("in", "r", stdin);
    freopen("out", "w", stdout);
#endif

    scanf("%d %d", &n, &m);
    for (int i = 0; i < n; i++) {
        int t;
        scanf("%d", &t);
        // 数据保证t_i是递增的所以可以直接用
        timing[i] = t;
    }
    memset(G, 0x3f, sizeof(G));
    for (int i = 0; i < m; i++) {
        int u = read(), v = read(), w = read();
        G[u][v] = G[v][u] = w;
    }
    for (int i = 0; i < n; i++) G[i][i] = 0;
    int Q;
    scanf("%d", &Q);
    auto last = 0;
    for (int i = 0; i < Q; i++) {
        int x = read(), y = read(), t = read();
        // 获取新增的节点
        while (last < n && timing[last] <= t) {
            for (int j = 0; j < n; j++) {
                for (int k = 0; k < n; k++) {
                    G[j][k] = min(G[j][k], G[j][last] + G[last][k]);
                }
            }
            vis[last] = true;
            last++;
        }
        // 如果节点无法联通或者并没有出现
        if (!vis[x] || !vis[y] || G[x][y] == INF2) {
            printf("-1\n");
        } else {
            printf("%d\n", G[x][y]);
        }
    }
    return 0;
}