python/TangDou/CSP-J/J-2023/bus.md

#### [$P9751$ [$CSP-J$ $2023$] 旅游巴士](https://www.luogu.com.cn/problem/P9751)

### 零：前导知识
https://www.bilibili.com/video/BV1ha4y1T7om/?vd_source=13b33731bb79a73783e9f2c0e11857ae

###  办法一：魔改$Dijkstra$

![](https://dsideal.obs.cn-north-1.myhuaweicloud.com/HuangHai/BlogImages/202311080814008.png)

按测试用例进行分析题意：

$1->2->5$是走$2$步，不满足终点是$3$的倍数条件，而我们可以调整的余地也不大，只能是在起点时多等待$3*m$个时间后出发，在路径上其它点都不能进行等待。

那么，走到$5$号节点，原来是$2$，现在就是$2+3*m$的时间点，根据我们已有数学知识知道，这是不可能$\%3=0$的！

$1->3->4->5$是走$3$步，也就是$\%3=0$,那么，不就行了吗？不行！为什么呢？因为你看$4$号节点，如果从$1$节点在$0$时间出发，到达$3$号节点时是时间$1$，那么，$4$号节点要求时间$2$才能开放，你过不去啊！

怎么办？你只能是多等一个时间周期，也就是在节点$1$出发时不在$0$时刻出发，而是在$0+3$时间出发！这样，你在走$4$号节点时，就满足了$3>2$,就可以走了啊！

那问题来了，如果某个节点的时间要求不是数字$2$,而是$x$该怎么办呢？
其实我们需要保证到$u$号节点后，时间应该是$t>=x$的，如果现在$t$不是这样，那么需要一点点增大

```cpp {.line-numbers}
while(t<x) t+=3;
```
也就是说，这才是符合条件的最小的限制条件$t$,不能再大了，因为再大就表示时间更长，人家要找的是最早的时间，当然越小越合适~

有了限制条件，那理想最短路径算法$Dijkstra$也不对了。

为什么呢？你想啊，理想的最短路，是在没有任何时间限制下的，我才不管你是不是允许通过，我看到路线就要通过，就能通过，现在不行了。 

那该怎么办呢？还是以节点$4$为例,要求到达它,必须$3$需要保证到达时间为$4$, $1$肯定是不行了，因为小于$2$嘛。

原来$Dijkstra$，进入队列的是一个二元结构体，一般喜欢用$PII$(因为小顶堆时可以不用写$cmp$方法，总结起来就是懒)，而现在这么干肯定不行啊，因为现在需要一个三元的结构

① 节点编号
② 到达的最短路径 (到达的时间),需要满足大于下一步要走路径的开放时间
③ 目标点需要满足路径长度$\%3=0$,那么，前序节点需要满足$\%3=1$,再前序需要满足$\%3=2$,....

这是原始版本的
```cpp {.line-numbers}
//迪杰斯特拉
void dijkstra(int start) {
    memset(d, 0x3f, sizeof d);                        //初始化距离为无穷大
    memset(st, 0, sizeof st);                         //初始化为未出队列过
    priority_queue<PII, vector<PII>, greater<PII>> q; //小顶堆
    q.push({0,start});                               //出发点入队列
    d[start] = 0;                                     //出发点距离0
    while (q.size()) {
        auto t = q.top();
        q.pop();
        int u = t.second;
        if (st[u]) continue;
        st[u] = true;
        for (int i = h[u]; ~i; i = ne[i]) {
            int j = e[i];
            if (d[j] > d[u] + w[i]) {
                d[j] = d[u] + w[i];
                q.push({d[j], j});
            }
        }
    }
}
```

那就整一个三元组吧：

```cpp {.line-numbers}
struct Node {
    int u, r, d; // u节点编号，r状态，d最短到达时间
    // 重载 < ，优先队列，默认使用大顶堆，我们需要小顶堆，所以，需要重载小于号，描述两个Node对比，
    // 距离大的反而小，由于是大顶堆，所以距离小的在上
    bool operator<(const Node t) const {
        return d > t.d;
    }
};
```

其它的就是一个$Dijkstra$模板了。对了，还有最重要的一个问题：

这个距离$d$，在原始版本中代表的是到达某个节点的最短距离，现在的题目中是
- 最短距离
- 到达某个节点+节点的`%3`状态
比如现在倒数第二个节点最短距离是$8$,是通过$1$步过来的，记为$d(u,1)=8$

那么它对于终点就是没用的，不如最短距离是$9$,通过频数是$2$的，也就是$d(u,2)=9$
因为人家再走一步，就到终点了，你那个$8$使不上！

```cpp {.line-numbers}
#include <bits/stdc++.h>
using namespace std;
const int N = 10010, M = N << 1, K = 110; // 节点个数上限，边数上限，发车间隔时长上限
const int INF = 0x3f3f3f3f;               // Dijsktra专用正无穷

struct Node {
    int u, r, d; // u节点编号，r状态，d最短到达时间
    // 重载 < ，优先队列，默认使用大顶堆，我们需要小顶堆，所以，需要重载小于号，描述两个Node对比，
    // 距离大的反而小，由于是大顶堆，所以距离小的在上
    bool operator<(const Node t) const {
        return d > t.d;
    }
};

// 链式前向星
int e[M], h[N], idx, w[M], ne[M];
void add(int a, int b, int c = 0) {
    e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
}
/*
dis[u][i]表示到达第u处地点，并且到达时间mod k = i的情况下的最短距离
*/
int dis[N][K], st[N][K];
int main() {
    memset(h, -1, sizeof h);

    int n, m, k;
    cin >> n >> m >> k;
    for (int i = 0; i < m; i++) {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c); // 从a到b建一条边，c权值为开放时间
    }

    // 初始状态，1号点在状态0时最短距离为0，其它点的最短距离为无穷大
    memset(dis, 0x3f, sizeof dis); // dis是一个二维结果数组，一维是节点号，二维是此节点在不同状态下可以到达的最短路径
    dis[1][0] = 0;                 // 所谓状态，是指到达时间（对于1号节点而言就是出发时间）%k的余数值
    // 因为题目中说到，1号点和n号点都必须是%k=0的时间，所以，dis[1][0]=0
    // 描述1号节点，在状态0下出发，距离出发点的距离是0

    // 堆优化版Dijkstra求最短路，注意默认大顶堆，自定义比较规则
    priority_queue<Node> q;
    // 初始状态加入优先队列，{点，状态，最短到达时间}
    q.push({1, 0, dis[1][0]}); // 节点号，%k的值，已经走过的距离
    // 每个进队列的节点，都有3个属性：节点号，%k的值，已经走过的距离

    while (q.size()) {     // 从1号点开始宽搜
        int u = q.top().u; // 节点编号u
        int r = q.top().r; // 节点状态r
        q.pop();

        if (st[u][r]) continue; //  该状态已经加入到集合中,也就是已经被搜索过
        // 先被搜索过在队列宽搜中意味着已经取得了最短路径
        st[u][r] = 1;

        for (int i = h[u]; ~i; i = ne[i]) { // 枚举邻接点v和连接到v节点道路的开放时间
            int v = e[i];                   // v节点，也就是下一个节点
            int t = w[i];                   // v节点的开放时间
            int d = dis[u][r];              // 到达(u,p)这个状态时的最短距离d
            int j = (r + 1) % k;            // v节点的状态应该是u节点的状态+1后再模k

            // 如果到达时间小于开放时间，则将到达时间向后延长若干个k的整数倍(向上取整)
            while (d < t) d += k;

            // 如果可以松弛到v点的时间
            if (dis[v][j] > d + 1) { // 下一个节点v的j状态，可以通过(u,i)进行转移，那么可以用t+1更尝试更新掉dis[v][j]
                dis[v][j] = d + 1;
                q.push({v, j, dis[v][j]}); // 再用(v,j)入队列去更新其它节点数据，标准的Dijkstra算法
            }
        }
    }
    if (dis[n][0] == INF) // 如果终点的模k=0状态存在数字，那么就是说可以获取到最短路径,否则就是无法到达为个状态
        cout << -1 << endl;
    else
        cout << dis[n][0] << endl;
    return 0;
}

```

### 办法二：二分+宽搜

![](https://dsideal.obs.cn-north-1.myhuaweicloud.com/HuangHai/BlogImages/202311071051699.png)

疑问与解答：
#### $Q$:为什么要建反图？
答：举个栗子，比如从$1$出发有如下路径


```cpp {.line-numbers}
#include <bits/stdc++.h>
using namespace std;
const int N = 10010, M = N << 1, K = 110;

// 链式前向星
int e[M], h[N], idx, w[M], ne[M];
void add(int a, int b, int c = 0) {
    e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
}

// 入队列的结构体
struct Node {
    int id; // 节点号
    int r;  // %k的余数
};

int dis[N][K]; // 最短路径
int n, m, k;   // n个节点，m条边，时间是k的整数倍，即 %k=0

bool bfs(int mid) {
    memset(dis, -1, sizeof dis);
    queue<Node> q;
    dis[n][0] = mid * k;
    q.push({n, 0});

    while (q.size()) {
        int u = q.front().id;
        int r = q.front().r;
        q.pop();

        if (dis[u][r] == 0) continue; // 反着走，距离为0，就不需要继续走了,剪枝

        for (int i = h[u]; ~i; i = ne[i]) {
            int v = e[i];                       // 前序节点
            int p = (r - 1 + k) % k;            // 前序节点合法状态
            if (~dis[v][p]) continue;           // 如果前序点的合法状态不等于-1，表示已经被宽搜走过了，根据宽搜的理论，就是已经取得了最短距离，不需要再走
            if (dis[u][r] - 1 < w[i]) continue; // 现在的最短距离是dis[u][r],那么前序的距离应该是dis[u][r]-1,那么，如果dis[u][r]-1<w[i],就是表示到达时，开放时间未到，无法能行
            // 修改合法前序点距离，为当前最小距离减1
            dis[v][p] = dis[u][r] - 1;
            // 入队列继续扩展
            q.push({v, p});
        }
    }

    if (dis[1][0] == -1)
        return false;
    else
        return true;
}
int main() {
    memset(h, -1, sizeof h);

    cin >> n >> m >> k;

    while (m--) {
        int a, b, c;
        cin >> a >> b >> c;
        add(b, a, c);
    }

    int l = 0, r = (1e6 + 1e4) / k, ans = -1;
    while (l < r) {
        int mid = l + r >> 1;
        if (bfs(mid)) {
            ans = mid * k;
            r = mid;
        } else
            l = mid + 1;
    }
    cout << ans << endl;
    return 0;
}
```