历年CSP-J复赛真题解析 | 2023年T4 旅游巴士

欢迎大家订阅我的专栏：算法题解：C++与Python实现！
本专栏旨在帮助大家从基础到进阶 ，逐步提升编程能力，助力信息学竞赛备战！

专栏特色
1.经典算法练习：根据信息学竞赛大纲，精心挑选经典算法题目，提供清晰的代码实现与详细指导，帮助您夯实算法基础。
2.系统化学习路径：按照算法类别和难度分级，从基础到进阶，循序渐进，帮助您全面提升编程能力与算法思维。

适合人群：

• 准备参加蓝桥杯、GESP、CSP-J、CSP-S等信息学竞赛的学生
• 希望系统学习C++/Python编程的初学者
• 想要提升算法与编程能力的编程爱好者

附上汇总贴：历年CSP-J复赛真题解析 | 汇总_热爱编程的通信人的博客-CSDN博客

---

【题目来源】

洛谷：P9751 [CSP-J 2023] 旅游巴士 - 洛谷 (luogu.com.cn)

【题目描述】

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

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

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

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

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

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

【输入】

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

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

【输出】

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

【输入样例】

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

【输出样例】

6

【解题思路】

​

​

​

【算法标签】

《洛谷 P9751 旅游巴士》 CSP-J入门级​ 2023​ O2优化​

【代码详解】

#include <bits/stdc++.h>
using namespace std;
const int N=10005, K=105;
int n, m, k;
vector<int> e[N], t[N];  // e用来保存邻接关系表，t用来保存每条路径的开放时间
struct node {
    int x, k;  // x为第i个结点，k为对k取余数的值
};
int dis[N][K];  // 定义dis，保存到达某个点的时间，如果其为0，说明是k的倍数（分层图思想）
bool bfs(int mid)
{
    memset(dis, -1, sizeof(dis));
    queue<node> q;
    dis[n][0] = mid*k;  // 开始倒推，从mid*k时刻递减去判断，每过一个节点减1。0表示起点n为k的倍数。（分层图思想）
    q.push(node{n,0});  // 将n这个结点加入队列中
    while (!q.empty()) {
        int x = q.front().x, b = q.front().k;  // 取出队首，获得其节点编号，以及k
        q.pop();  //弹出队首
        if (dis[x][b]==0) continue;  // 如果走到某个点时间已经为0，说明已经找到
        for (int i=0; i<e[x].size(); i++) {  // 在x的邻接点中进行查找
            if (t[x][i]>=dis[x][b]) continue;  // 如果该条链路的开放时间大于到达该点的时刻，就退出该次循环（无法通行的）
            int y = e[x][i], p = (b+k-1) % k;  // 邻接点y，p为减1后的时刻，注意需要+k并对k取余
            if (dis[y][p]!=-1) continue;  // 如果这个点搜索过，则继续
            dis[y][p] = dis[x][b] - 1;  // 如果这个点没有搜索过，则时间在前一个点的时间上减1
            q.push(node{y, p});  // 把这个点加入队列中
        }
    }
    if (dis[1][0] == -1 ) return false;  // 判断dis[1][0]是否可达，不可达返回false。0表示达到1号点时时间为k的倍数（分层图思想）
    else return true;  //可达返回true
}
int main()
{
    cin >> n >> m >> k;  // 输入n、m和k
    for (int i=1; i<=m; i++) {  // for循环遍历m条路径
        int u, v, a;
        cin >> u >> v >> a;  // 输入u、v和a
        e[v].push_back(u);  // 从终点倒推保存，保存每个节点的邻接点
        t[v].push_back(a);  // 从终点倒推保存，保存每条路径的开放时间
    }
    int l = 0, r = 2e6;  // 定义二分搜索的左右边界
    while (l<r) {  // 使用二分法判断
        int mid = (l+r)/2;  // 二分中间点
        if (bfs(mid)) r = mid;  // 如果可以找到路径，就去找更少的时间
        else l = mid+1;  // 否则，就找更大的时间
        // cout << "mid: " << mid << endl;
    }
    if (r==2e6) cout << "-1";  // 如果最大时间都没有找到路径，那就输出-1
    else cout << l*k << endl;  // l和r是k的倍数，所以最后时间还需要*k（最后mid==l）
    // cout << "l: " << l << endl;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

// 定义全局变量
int n, m, k;  // n:节点数，m:边数，k:周期参数
vector<pair<int, int>> g[10005];  // 邻接表存储图，pair<目标节点, 边权>
int dis[10005][105];  // dis[i][j]表示到达节点i时剩余能量为j*k时的最大剩余步数

// BFS函数：检查给定初始能量mid*k是否能到达终点
bool bfs(int mid) {
    memset(dis, -1, sizeof(dis));  // 初始化距离数组为-1
    queue<pair<int, int>> q;  // BFS队列，存储<节点, 剩余能量模k>
    dis[n][0] = mid * k;  // 初始状态：在节点n，剩余能量为mid*k
    q.push({n, 0});
  
    while (!q.empty()) {
        pair<int, int> u = q.front();
        int x = u.first;  // 当前节点
        int b = u.second; // 剩余能量模k
        q.pop();
      
        if (dis[x][b] == 0) continue;  // 能量耗尽，跳过
      
        // 遍历当前节点的所有邻接边
        for (int i = 0; i < g[x].size(); i++) {
            pair<int, int> pr = g[x][i];
            int y = pr.first;   // 邻接节点
            int a = pr.second;  // 边权
          
            // 检查剩余能量是否足够通过这条边
            if (dis[x][b] - 1 < a) continue;
          
            int p = (b + k - 1) % k;  // 计算新的剩余能量模k
            if (dis[y][p] != -1) continue;  // 已访问过，跳过
          
            dis[y][p] = dis[x][b] - 1;  // 更新剩余步数
            q.push({y, p});
        }
    }
  
    // 检查是否能到达节点1且剩余能量模k为0
    return dis[1][0] != -1;
}

int main() {
    // 输入数据
    cin >> n >> m >> k;
    for (int i = 1; i <= m; i++) {
        int u, v, a;
        cin >> u >> v >> a;
        g[v].push_back({u, a});  // 构建反向图
    }
  
    // 二分查找最小初始能量
    int l = 0, r = 2000000 / k, ans = -1;
    while (l < r) {
        int mid = (l + r) / 2;
        if (bfs(mid)) {  // 检查mid*k能量是否足够
            ans = mid * k;
            r = mid;  // 尝试更小的能量
        } else {
            l = mid + 1;  // 需要更大的能量
        }
    }
  
    // 输出结果
    cout << ans << endl;
  
    return 0;
}

【运行结果】

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