CSP-J系列【2023】P9751 [CSP-J 2023] 旅游巴士题解

题目描述

小 Z 打算在国庆假期期间搭乘旅游巴士去一处他向往已久的景点旅游。

旅游景点的地图共有 n 处地点，在这些地点之间连有 m 条道路。其中 1 号地点为景区入口，n 号地点为景区出口。我们把一天当中景区开门营业的时间记为 0 时刻，则从 0 时刻起，每间隔 k 单位时间便有一辆旅游巴士到达景区入口，同时有一辆旅游巴士从景区出口驶离景区。

所有道路均只能单向通行。对于每条道路，游客步行通过的用时均为恰好 1 单位时间。

小 Z 希望乘坐旅游巴士到达景区入口，并沿着自己选择的任意路径走到景区出口，再乘坐旅游巴士离开，这意味着他到达和离开景区的时间都必须是 k 的非负整数倍。由于节假日客流众多，小 Z 在旅游巴士离开景区前只想一直沿着景区道路移动，而不想在任何地点（包括景区入口和出口）或者道路上停留。

出发前，小 Z 忽然得知：景区采取了限制客流的方法，对于每条道路均设置了一个 “开放时间”ai​，游客只有不早于 ai​ 时刻才能通过这条道路。

请帮助小 Z 设计一个旅游方案，使得他乘坐旅游巴士离开景区的时间尽量地早。

输入格式

输入的第一行包含 3 个正整数 n,m,k，表示旅游景点的地点数、道路数，以及旅游巴士的发车间隔。

输入的接下来 m 行，每行包含 3 个非负整数 ui​,vi​,ai​，表示第 i 条道路从地点 ui​ 出发，到达地点 vi​，道路的“开放时间”为 ai​。

输出格式

输出一行，仅包含一个整数，表示小 Z 最早乘坐旅游巴士离开景区的时刻。如果不存在符合要求的旅游方案，输出 -1。

输入输出样例

输入 #1复制

5 5 3
1 2 0
2 5 1
1 3 0
3 4 3
4 5 1

输出 #1复制

6

说明/提示

【样例 #1 解释】

小 Z 可以在 3 时刻到达景区入口，沿 1→3→4→5 的顺序走到景区出口，并在 6 时刻离开。

【样例 #2】

见附件中的 bus/bus2.in 与 bus/bus2.ans。

【数据范围】

对于所有测试数据有：2≤n≤104，1≤m≤2×104，1≤k≤100，1≤ui​,vi​≤n，0≤ai​≤106。

测试点编号	n≤	m≤	k≤	特殊性质
1∼2	10	15	100	ai​=0
3∼5	10	15	100	无
6∼7	104	2×104	1	ai​=0
8∼10	104	2×104	1	无
11∼13	104	2×104	100	ai​=0
14∼15	104	2×104	100	ui​≤vi​
16∼20	104	2×104	100	无

 

题目概述与分析

旅游巴士问题描述了一个由n个景点组成的旅游路线，景点之间通过单向道路连接。每条道路有固定的发车间隔k分钟，巴士会在每个整k倍数的时刻发车。题目要求计算从景点1到景点n的最短旅行时间。

这个问题可以建模为带时间约束的最短路径问题，需要考虑发车时间的限制条件。我们需要找到既满足路径连通性，又满足时间约束的最优解。

解法一：分层图+BFS算法

算法思路

1. 构建分层图，每层表示不同的时间状态
2. 使用BFS遍历所有可能的路径和时间组合
3. 记录到达每个景点在不同时间状态下的最短时间
4. 时间复杂度O(nk)，空间复杂度O(nk)

#include <iostream>
#include <vector>
#include <queue>
#include <climits>
using namespace std;

struct State {
    int node;
    int time;
    State(int n, int t) : node(n), time(t) {}
};

int main() {
    int n, m, k;
    cin >> n >> m >> k;
    
    vector<vector<pair<int, int>>> graph(n+1);
    for(int i=0; i<m; i++) {
        int u, v, w;
        cin >> u >> v >> w;
        graph[u].emplace_back(v, w);
    }
    
    vector<vector<int>> dist(n+1, vector<int>(k, INT_MAX));
    queue<State> q;
    q.emplace(1, 0);
    dist[1][0] = 0;
    
    while(!q.empty()) {
        State curr = q.front();
        q.pop();
        
        for(auto &edge : graph[curr.node]) {
            int next_node = edge.first;
            int cost = edge.second;
            int next_time = (dist[curr.node][curr.time % k] + cost + k - 1) / k * k;
            
            if(next_time < dist[next_node][next_time % k]) {
                dist[next_node][next_time % k] = next_time;
                q.emplace(next_node, next_time % k);
            }
        }
    }
    
    int result = *min_element(dist[n].begin(), dist[n].end());
    cout << (result == INT_MAX ? -1 : result) << endl;
    return 0;
}

分层图BFS解法通过状态扩展处理时间约束，确保找到满足发车时间的最短路径。

解法二：Dijkstra算法优化

算法思路

1. 使用优先队列优化的Dijkstra算法
2. 状态包含节点和到达时间的模k值
3. 根据发车间隔计算等待时间
4. 时间复杂度O(m log(nk))，空间复杂度O(nk)

#include <vector>
#include <queue>
#include <climits>
using namespace std;

struct State {
    int node;
    int mod;
    int time;
    State(int n, int m, int t) : node(n), mod(m), time(t) {}
    bool operator>(const State &other) const {
        return time > other.time;
    }
};

int main() {
    int n, m, k;
    cin >> n >> m >> k;
    
    vector<vector<pair<int, int>>> graph(n+1);
    for(int i=0; i<m; i++) {
        int u, v, w;
        cin >> u >> v >> w;
        graph[u].emplace_back(v, w);
    }
    
    vector<vector<int>> dist(n+1, vector<int>(k, INT_MAX));
    priority_queue<State, vector<State>, greater<State>> pq;
    pq.emplace(1, 0, 0);
    dist[1][0] = 0;
    
    while(!pq.empty()) {
        State curr = pq.top();
        pq.pop();
        
        if(curr.time > dist[curr.node][curr.mod]) continue;
        
        for(auto &edge : graph[curr.node]) {
            int next_node = edge.first;
            int cost = edge.second;
            int arrival_time = curr.time + cost;
            int wait_time = (k - (arrival_time % k)) % k;
            int next_time = arrival_time + wait_time;
            int next_mod = next_time % k;
            
            if(next_time < dist[next_node][next_mod]) {
                dist[next_node][next_mod] = next_time;
                pq.emplace(next_node, next_mod, next_time);
            }
        }
    }
    
    int result = *min_element(dist[n].begin(), dist[n].end());
    cout << (result == INT_MAX ? -1 : result) << endl;
    return 0;
}

Dijkstra优化解法利用优先队列高效处理带时间约束的最短路径问题，适合稀疏图场景。

算法对比分析

方法	时间复杂度	空间复杂度	适用场景
分层图+BFS	O(nk)	O(nk)	稠密图，k较小的情况
Dijkstra优化	O(m log(nk))	O(nk)	稀疏图，k较大的情况

关键问题详解

时间约束处理

1. 计算到达时间后需要等待到下一个发车时刻
2. 通过模运算记录时间状态
3. 确保转移时满足发车间隔条件

状态设计

1. 节点编号和到达时间的模k值共同构成状态
2. 避免重复处理相同状态
3. 保证状态转移的正确性

性能优化建议

1. ‌优先队列优化‌：Dijkstra算法使用优先队列提高效率
2. ‌状态剪枝‌：忽略不可能改善当前最优解的状态
3. ‌输入优化‌：使用快速输入方法处理大规模数据
4. ‌内存优化‌：根据问题规模选择合适的存储结构

边界情况测试

测试时应考虑以下特殊情况：

1. 起点和终点相同的情况
2. 没有可行路径的情况
3. 发车间隔k为1的最简情况
4. 道路权重恰好是k的倍数的情况
5. 大规模数据下的性能测试

实际应用价值

这类带时间约束的最短路径问题在现实中有广泛应用：

1. 公共交通系统规划
2. 物流配送路线优化
3. 网络数据传输调度
4. 生产流水线排程

学习建议

1. 先理解基础的最短路径算法
2. 掌握状态设计和转移的技巧
3. 从简单案例入手逐步增加复杂度
4. 比较不同解法的优劣和适用场景

扩展思考

1. 如果发车间隔不是固定的如何处理？
2. 如果允许错过某些班车但需要额外等待时间？
3. 如果道路权重随时间变化？
4. 如何扩展到多交通工具换乘的场景？

掌握这类问题的解法不仅能提升算法竞赛能力，也对解决实际工程问题有很大帮助。建议先实现分层图BFS解法理解基本思路，再尝试Dijkstra优化解法提高效率。