【最短路】洛谷1119 灾后重建（floyd的DP本质分析）

题目

洛谷P1119

思路

暴力算法即每次询问情况做一次dijktra。
AC算法，本题考虑floyd的DP本质。

首先谈谈Floyed算法：Floyd算法的本质是动态规划，其转移方程 为：f[k][i][j] = min( f[k-1][i][j], f([k-1][i] [k])+f[k-1][k][j] )。
f[k][i][j]表示路径除开起点i与终点j，只经过前k个点中的某些 点，从i到j的最小值。计算这个值只需要考虑两种情况：最短路经 过k，和最短路不经过k（那么就经过前k-1个点中的某些点）。由于 k要从k-1转移而来，自然k为最外层的循环。而经过滚动（类似于背 包问题）后，就变成了我们熟悉的f[i][j]=min(f[i][j],f[i] [k]+f[k][j])了。

改变思路：看中转点k每一次自增能解决什么问题，能回答问题就输出,可以从$O(n^3 * q)$的复杂度变为 $O(n^3+q)$的复杂度，这样还是可以接受的。

代码

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <iostream>
#define _for(i,a,b) for(int i = a; i<b; i++)
#define _rep(i,a,b) for(int i = a; i<=b; i++)
using namespace std;

const int INF = 500000000;
const int maxn = 200 + 10;
int n, m, d[maxn][maxn], t[maxn];

int main() {
    scanf("%d%d", &n, &m);
    _for(i, 0, n) _for(j, 0, n) if (i != j) d[i][j] = INF;
    _for(i, 0, n) scanf("%d", &t[i]);
    int u, v, w;
    _for(i, 0, m) {
        scanf("%d%d%d", &u, &v, &w);
        d[u][v] = d[v][u] = w;
    }
    int q, tt, k = 0;
    scanf("%d", &q);
    _for(o, 0, q) {
        scanf("%d%d%d", &u, &v, &tt);
        while (t[k] <= tt && k < n) {
            _for(i, 0, n) _for(j, 0, n) d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
            k++;
        }
        if (d[u][v] == INF || t[u] > tt || t[v] > tt)
            printf("-1\n");
        else
            printf("%d\n", d[u][v]);
    }

    return 0;
}

暴力算法（50）

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <queue>
#define _for(i,a,b) for(int i = a; i<b; i++)
#define _rep(i,a,b) for(int i = a; i<=b; i++)
using namespace std;

const int INF = 100000000;
const int maxn = 200+5;
int n, m, Q, G[maxn][maxn], d[maxn], t[maxn];
int u,v,tt;
bool done[maxn];

struct HeapNode{
    int u,d;
    bool operator < (const struct HeapNode& rhs) const {
        return d > rhs.d;
    }
    HeapNode(int u, int d):u(u),d(d) {};
};

void dijkstra(int s){
    _for(i,0,n) d[i] = INF;
    d[s] = 0;
    memset(done, 0, sizeof(done));
    priority_queue<HeapNode> q;
    q.push((HeapNode){s, 0});
    while(!q.empty()){
        HeapNode now = q.top(); q.pop();
        int from = now.u;
        if (done[from] || tt < t[from]) continue;
        done[from] = true;
        _for(to, 0, n) if(!done[to] && G[from][to] && tt >= t[to]){
            if (d[to] > d[from] + G[from][to]){
                d[to] = d[from] + G[from][to];
                q.push((HeapNode){to, d[to]});
            }
        }
        if (from == v) return;
    }
}

int main(){
    scanf("%d%d",&n,&m);
    _for(i,0,n) scanf("%d",&t[i]);
    int w;
    _for(i,0,m){
        scanf("%d%d%d",&u,&v,&w);
        G[u][v] = G[v][u] = w;
    }
    scanf("%d",&Q);
    _for(i,0,Q){
        scanf("%d%d%d",&u,&v,&tt);
        dijkstra(u);
        if (d[v] == INF) printf("-1\n");
        else printf("%d\n",d[v]);
    }

    return 0;
}