P1266 速度限制（分层图思想，图上dp）

洛谷：速度限制

分享下某大佬的分层图讲解（虽然这题涉及较浅，更多是dp维护）

此题更多考察的是信息的维护，一维信息不够存，扩大转二维（数据较小也允许）

剩下的就是类似dp的状态转移

对图论算法的dp性质理解不够深

#include<bits/stdc++.h>
#include<unordered_set>
#include<unordered_map>
#define _CRT_SECURE_NO_WARNINGS
#define mem(a,b) memset(a,b,sizeof a)
#define cinios (ios::sync_with_stdio(false),cin.tie(0),cout.tie(0))
#define sca scanf
#define pri printf
#define ul u << 1
#define ur u << 1 | 1
//#pragma GCC optimize(2)
//[博客地址](https://blog.csdn.net/weixin_51797626?t=1) 
using namespace std;

typedef long long ll;
typedef pair<double, pair<int, int>> PII;
typedef pair<int, int> PI;

const int N = 210, M = 510, MM = 100010;//此题边数没写限制，但实际要开到十万
int INF = 0x3f3f3f3f, mod = 100003;
ll LNF = 0x3f3f3f3f3f3f3f3f;
int n, m, k, T, S;
int h[N], ne[MM], e[MM], w[MM], v[MM], idx;//w和v分别为路径上的长度和速度限制
//bug —— 把边上的速度限制放到点上了，开了个 v[N]
//如果有多条路通向一个点就会丢失信息了
double dist[N][M]; 
//一维信息存储不够，处理不了限速未知的路径，所以扩大到可以维护更多信息
//dist[i][j] 代表 (从 0 点 70) 速度 (走到 i 点 j 速度) 的最小时间花费(double)
bool st[N][M];
//同样二维含义的标记
PI f[N][M];//存储路径

void add(int a, int b, int x, int c) {
    e[idx] = b, ne[idx] = h[a], w[idx] = x, v[idx] = c, h[a] = idx++;
}

void find(int x, int y) { //递归输出路径，
    if (x == -1)return;
    find(f[x][y].first, f[x][y].second);
    cout << x << ' ';
}

void dj() {
    mem(st, 0);
    for (int i = 0; i < n; i++)
        for (int j = 0; j <= 500; j++)//初始化极值
            dist[i][j] = 1e16;

    dist[0][70] = 0;//起点

    priority_queue<PII, vector<PII>, greater<PII>> q;
    q.push({ 0,{0,70} });//点编号的和当前速度的信息都要存入

    while (q.size())
    {
        PII t = q.top();
        q.pop();

        int ver = t.second.first, v_old = t.second.second;//原来的速度

        if (st[ver][v_old])continue;//一样用过就不需要再用了
        st[ver][v_old] = true;

        for (int i = h[ver]; ~i; i = ne[i]) {
            int j = e[i], v_now = v[i];//现有的速度（限制）

            if (v_now == 0)v_now = v_old;//一旦未知就用以前的速度走

            double tim = (double)w[i] / v_now;

            if (dist[j][v_now] > dist[ver][v_old] + tim) {

                dist[j][v_now] = dist[ver][v_old] + tim;
                f[j][v_now] = { ver,v_old };//记录

                q.push({ dist[j][v_now], {j, v_now} });
            }
        }
    }
}

int main() {
    cinios;
    
    cin >> n >> m >> S;
    mem(h, -1);
    while (m--)
    {
        int a, b, vv, l;
        cin >> a >> b >> vv >> l;
        add(a, b, l, vv);
    }

    dj();

    double mi = 1e16;
    PI idv;
    for (int j = 0; j <= 500; j++) {
        f[0][j] = { -1,0 };//边界处理

        if (dist[S][j] < mi) { //找到最快到达终点的状态
            mi = dist[S][j];
            idv = { S,j };
        }
    }

    find(idv.first, idv.second);//从这状态往回找

    return 0;
}