算法竞赛备考冲刺必刷题（C++） | 洛谷 P5683 道路拆除

原创于 2025-08-18 08:10:40 发布 · 647 阅读

CC 4.0 BY-SA版权

文章标签：

本文分享的必刷题目是从蓝桥云课、洛谷、AcWing等知名刷题平台精心挑选而来，并结合各平台提供的算法标签和难度等级进行了系统分类。题目涵盖了从基础到进阶的多种算法和数据结构，旨在为不同阶段的编程学习者提供一条清晰、平稳的学习提升路径。

欢迎大家订阅我的专栏：算法题解：C++与Python实现！

附上汇总贴：算法竞赛备考冲刺必刷题（C++） | 汇总

【题目来源】

洛谷：P5683 [CSP-J2019 江西] 道路拆除 - 洛谷

【题目描述】

A 国有 $n$ 座城市，从 $1 \sim n$ 编号。 $1$ 号城市是 A 国的首都。城市间由 $m$ 条双向道路连通，通过每一条道路所花费的时间均为 $1$ 单位时间。

现在 A 国打算拆除一些不实用的道路以减小维护的开支，但 A 国也需要保证主要线路不受影响。因此 A 国希望道路拆除完毕后，利用剩余未被拆除的道路，从 A 国首都出发，能到达 $s_1$ 号与 $s_2$ 号城市，且所要花费的最短时间分别不超过 $t_1$ 与 $t_2$ （注意这是两个独立的条件，互相之间没有关联，即不需要先到 $s_1$ 再到 $s_2$ ）。

A 国想请你帮他们算算，在满足上述条件的情况下，他们最多能拆除多少条道路。若上述条件永远无法满足，则输出 $- 1$ 。

【输入】

第一行两个正整数 $n, m$ ，表示城市数与道路数。

接下来 $m$ 行，每行两个正整数 $x, y$ ，表示一条连接 $x$ 号点与 $y$ 号点的道路。

最后一行四个整数，分别为 $s_1,t_1,s_2,t_2$ 。

【输出】

仅一行一个整数，表示答案。

【输入样例】

【输出样例】

【算法标签】

《洛谷 P5683 道路拆除》 #最短路# #CSP-J入门级# #2019#

【代码详解】

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

int n, m, u, v, s_1, t_1, s_2, t_2;  // 输入参数
int dist[3005], ans, sum;              // 距离数组和结果变量
vector<int> ve[3005];                  // 图的邻接表表示

// 路径节点结构体
struct Node
{
    int len;               // 路径长度
    vector<int> router;    // 路径节点序列
};

queue<Node> qu;                      // BFS队列
vector<Node> router_1, router_2;     // 存储两条路径的所有可能
bool vis_1[3005][3005], vis_2[3005][3005];  // 访问标记数组

// BFS搜索从起点到终点的所有可能路径
vector<Node> bfs(int x, int y)
{
    vector<Node> res = {};           // 存储结果路径
    memset(dist, 0x3f, sizeof(dist)); // 初始化距离为无穷大
    dist[1] = 0;                     // 起点距离为0
    
    Node sn = {};                    // 初始节点
    sn.len = 1;
    sn.router.push_back(1);
    qu.push(sn);

    while (qu.size())
    {
        sn = qu.front();
        qu.pop();
        u = sn.router[sn.len-1];     // 当前路径的最后一个节点
        
        // 如果到达目标节点且路径长度满足条件
        if (u == x && sn.len-1 <= y)
        {
            res.push_back(sn);
            continue;
        }
        
        // 遍历当前节点的所有邻居
        for (int i = 0; i < ve[u].size(); i++)
        {
            v = ve[u][i];
            // 如果找到更短的路径
            if (dist[v] >= sn.len)
            {
                dist[v] = sn.len;
                Node tmp = {};
                tmp.len = sn.len + 1;
                tmp.router = sn.router;
                tmp.router.push_back(v);
                qu.push(tmp);
            }
        }
    }
    return res;    
}

int main() 
{
    cin >> n >> m;  // 输入节点数和边数
    
    // 构建图的邻接表
    for (int i = 1; i <= m; i++)
    {
        cin >> u >> v;
        ve[u].push_back(v);
        ve[v].push_back(u);
    }
    
    cin >> s_1 >> t_1 >> s_2 >> t_2;  // 输入两条路径的参数
    
    // 搜索两条路径的所有可能
    router_1 = bfs(s_1, t_1);
    router_2 = bfs(s_2, t_2);
    
    // 如果任意一条路径不存在可行解
    if (!router_1.size() || !router_2.size())
    {
        cout << "-1";
        return 0;
    }
    
    ans = m;  // 初始化结果为边数
    
    // 遍历第一条路径的所有可能
    for (int i = 0; i < router_1.size(); i++)
    {
        Node sn_1 = router_1[i];
        if (sn_1.len-1 >= ans) continue;  // 剪枝
        
        memset(vis_1, 0, sizeof(vis_1));  // 重置访问标记
        sum = 0;
        
        // 标记第一条路径的所有边
        for (int j = 1; j < sn_1.len; j++)
        {
            vis_1[sn_1.router[j-1]][sn_1.router[j]] = 1;
            vis_1[sn_1.router[j]][sn_1.router[j-1]] = 1;
        }
        
        // 遍历第二条路径的所有可能
        for (int j = 0; j < router_2.size(); j++)
        {
            Node sn_2 = router_2[j];
            if (sn_2.len-1 >= ans) continue;  // 剪枝
            
            sum = sn_1.len - 1;               // 第一条路径的边数
            memcpy(vis_2, vis_1, sizeof(vis_2));  // 复制访问标记
            
            // 统计第二条路径的新增边数
            for (int k = 1; k < sn_2.len; k++)
            {
                if (!vis_2[sn_2.router[k-1]][sn_2.router[k]])
                {
                    vis_2[sn_2.router[k-1]][sn_2.router[k]] = 1;
                    vis_2[sn_2.router[k]][sn_2.router[k-1]] = 1;
                    sum++;
                }
            }
            
            ans = min(ans, sum);  // 更新最小边数
        }
    }
    
    cout << m - ans << endl;  // 输出结果（总边数减去最小共用边数）
    return 0;
}