题解：洛谷 P2910 Clear And Present Danger

【题目来源】

洛谷：P2910 [USACO08OPEN] Clear And Present Danger S - 洛谷

【题目描述】

农夫约翰正驾驶一条小艇在牛勒比海上航行。

海上有 \(N(1\leq N\leq 100)\) 个岛屿，用 \(1\) 到 \(N\) 编号。约翰从 \(1\) 号小岛出发，最后到达 \(N\) 号小岛。

一张藏宝图上说，如果他的路程上经过的小岛依次出现了 \(A_1,A_2,\dots ,A_M(2\leq M\leq 10000)\) 这样的序列（不一定相邻），那他最终就能找到古老的宝藏。但是，由于牛勒比海有海盗出没，约翰知道任意两个岛屿之间的航线上海盗出没的概率，他用一个危险指数 \(D_{i,j}(0\leq D_{i,j}\leq 100000)\) 来描述。他希望他的寻宝活动经过的航线危险指数之和最小。那么，在找到宝藏的前提下，这个最小的危险指数是多少呢？

【输入】

第一行：两个用空格隔开的正整数 \(N\) 和 \(M\)。

第二到第 \(M+1\) 行：第 \(i+1\) 行用一个整数 \(A_i\) 表示 FJ 必须经过的第 \(i\) 个岛屿。保证 \(A_1=1,A_M=N\)。

第 \(M+2\) 到第 \(N+M+1\) 行：第 \(i+M+1\) 行包含 \(N\) 个用空格隔开的非负整数分别表示 \(i\) 号小岛到第 \(1\dots N\) 号小岛的航线各自的危险指数。保证第 \(i\) 个数是 \(0\)。

【输出】

第一行：FJ 在找到宝藏的前提下经过的航线的危险指数之和的最小值。

【输入样例】

【输出样例】

【核心思想】

问题分析：给定 \(N\) 个岛屿和必须经过的岛屿序列 \(A_1, A_2, \dots, A_M\)（\(A_1=1, A_M=N\)），以及每对岛屿间的危险指数 \(D_{i,j}\)。求按顺序经过 \(A_i\) 时，相邻必经岛屿间走最短路径的总危险指数最小值。本质上是Floyd 全源最短路 + 路径累加问题：先求任意两点间的最短路，再按必经顺序累加相邻点的最短距离。
算法选择：
- Floyd-Warshall：\(N \leq 100\)，用 \(O(N^3)\) 的 Floyd 求所有点对最短路
- 路径累加：按必经序列顺序，累加相邻必经点间的最短距离
关键步骤：
- 读取数据：读入 \(N, M\)，必经序列 \(a[1..M]\)，以及 \(N \times N\) 的危险指数矩阵 \(d\)
- Floyd 最短路：
  - 枚举中转点 \(k = 1\) 到 \(N\)
  - 枚举起点 \(i = 1\) 到 \(N\)
  - 枚举终点 \(j = 1\) 到 \(N\)
  - \(d[i][j] = \min(d[i][j], d[i][k] + d[k][j])\)
- 累加答案（\(i = 1\) 到 \(M-1\)）：
  - \(ans \leftarrow ans + d[a[i]][a[i+1]]\)
- 输出 \(ans\)
时间/空间复杂度：
- 时间复杂度：\(O(N^3 + M)\)，Floyd \(O(N^3)\)，路径累加 \(O(M)\)
- 空间复杂度：\(O(N^2)\)，邻接矩阵
Floyd + 路径累加的核心思想：
- 必经序列的约束：FJ 必须按 \(A_1 \to A_2 \to \dots \to A_M\) 的顺序访问，但相邻必经点之间可以经过其他岛屿
- 最短路的独立性：相邻必经点 \(A_i\) 到 \(A_{i+1}\) 的最短路与路径上其他段无关，可独立计算后累加
- Floyd 的适用性：\(N \leq 100\) 使得 \(O(N^3)\) 完全可接受，一次预处理即可回答所有点对查询
- 与 Dijkstra 的对比：若 \(N\) 较大而查询对数少，可对每段必经路径单独 Dijkstra；但本题 \(N\) 小，Floyd 更简洁
- 适用于全源最短路、必经路径、分段累加类问题

【解题思路】

【算法标签】

普及 #Floyd

【代码详解】

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

const int N = 105;           // 最大顶点数
int a[10005];                // 存储路径序列
int d[N][N];                 // 邻接矩阵，存储最短路径
int n, m, ans;               // n: 顶点数, m: 路径序列长度, ans: 总距离

/**
 * Floyd-Warshall算法
 * 计算所有顶点对之间的最短路径
 * 通过动态规划更新距离矩阵
 */
void floyd()
{
    // 三重循环，k为中转点
    for (int k = 1; k <= n; k++)
    {
        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= n; j++)
            {
                // 状态转移：通过顶点k是否能使i到j的路径更短
                d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
            }
        }
    }
}

int main()
{
    // 输入顶点数和路径序列长度
    cin >> n >> m;

    // 输入路径序列
    for (int i = 1; i <= m; i++)
    {
        cin >> a[i];
    }

    // 输入邻接矩阵
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            cin >> d[i][j];
        }
    }

    // 执行Floyd算法计算所有顶点对的最短路径
    floyd();

    // 计算路径序列的总距离
    for (int i = 1; i < m; i++)
    {
        ans += d[a[i]][a[i + 1]];  // 累加相邻顶点间的最短距离
    }

    // 输出总距离
    cout << ans << endl;

    return 0;
}

【运行结果】

posted @ 2026-08-17 09:47 团爸讲算法阅读(14) 评论(0) 收藏举报

刷新页面返回顶部

题解：洛谷 P2910 Clear And Present Danger

普及 #Floyd

公告