题解：洛谷 P1902 刺杀大使

【题目来源】

洛谷：P1902 刺杀大使 - 洛谷

【题目描述】

某组织正在策划一起对某大使的刺杀行动。他们来到了使馆，准备完成此次刺杀，要进入使馆首先必须通过使馆前的防御迷阵。

迷阵由 \(n\times m\) 个相同的小房间组成，每个房间与相邻四个房间之间有门可通行。在第 \(n\) 行的 \(m\) 个房间里有 \(m\) 个机关，这些机关必须全部打开才可以进入大使馆。而第 \(1\) 行的 \(m\) 个房间有 \(m\) 扇向外打开的门，是迷阵的入口。除了第 \(1\) 行和第 \(n\) 行的房间外，每个房间都被使馆的安保人员安装了激光杀伤装置，将会对进入房间的人造成一定的伤害。第 \(i\) 行第 \(j\) 列 造成的伤害值为 \(p_{i,j}\)（第 \(1\) 行和第 \(n\) 行的 \(p\) 值全部为 \(0\)）。

现在某组织打算以最小伤害代价进入迷阵，打开全部机关，显然，他们可以选择任意多的人从任意的门进入，但必须到达第 \(n\) 行的每个房间。一个士兵受到的伤害值为他到达某个机关的路径上所有房间的伤害值中的最大值，整个部队受到的伤害值为所有士兵的伤害值中的最大值。现在，这个恐怖组织掌握了迷阵的情况，他们需要提前知道怎么安排士兵的行进路线可以使得整个部队的伤害值最小。

【输入】

第一行有两个整数 \(n,m\)，表示迷阵的大小。

接下来 \(n\) 行，每行 \(m\) 个数，第 \(i\) 行第 \(j\) 列的数表示 \(p_{i,j}\)。

【输出】

输出一个数，表示最小伤害代价。

【输入样例】

4 2
0 0
3 5
2 4
0 0

【输出样例】

3

【核心思想】

  1. 问题分析：给定一个 \(n \times m\) 的网格，每个格子有一个伤害值 \(p_{i,j}\)，第一行和最后一行伤害值为 0。士兵可以从第一行任意门进入，在网格中四方向移动，最终必须到达最后一行的每一个房间。一名士兵受到的伤害等于其路径上所有格子伤害的最大值，整个部队的伤害是所有士兵伤害的最大值。目标是安排士兵路线，使得整个部队的伤害最小。由于士兵数量不限且可分别从第一行不同列进入，问题等价于：找到一个最小的阈值 \(P\)，使得在仅允许经过伤害值 \(\le P\) 的格子的条件下，从第一行（任意列）出发能够到达最后一行的每一个格子。这是一个典型的最小化最大边权连通性问题，可以通过二分答案 + 连通性检查解决。

  2. 算法选择：

    • 二分答案：伤害值 \(P\) 的取值范围为 \([0, \max p_{i,j}]\)，且单调性成立：若 \(P\) 可行，则任意 \(P' > P\) 也可行；若 \(P\) 不可行，则任意 \(P' < P\) 也不可行。因此可以二分查找最小的可行 \(P\)。
    • 连通性检查（BFS/DFS）：对于给定的 \(P\)，从第一行任意格子（如 \((1,1)\)）出发，进行 BFS 或 DFS，只经过伤害值 \(\le P\) 的格子，标记所有可达格子。由于第一行所有格子伤害值为 0，它们互相连通，因此从 \((1,1)\) 出发即可到达第一行所有列。最后检查最后一行的所有格子是否都被标记。若全部标记，则 \(P\) 可行；否则不可行。
    • 复杂度：每次检查 \(O(n \times m)\)，二分次数 \(O(\log \max p)\)，总复杂度 \(O(n \times m \log \max p)\)，对于 \(n, m \le 1000\) 是可接受的。

  3. 关键步骤：

    • 读入与预处理：读取 \(n, m\) 和伤害矩阵 \(p[1..n][1..m]\)，记录最大伤害值 \(maxP\)。
    • 定义检查函数 check(P)：
      • 初始化访问标记数组 vis 全为 false。
      • 使用队列（BFS）或栈（DFS）从起点 \((1,1)\) 开始搜索，搜索规则：只能移动到相邻格子且伤害值 \(\le P\)，且未访问。
      • 搜索结束后，遍历最后一行的每个格子 \(j\)（\(1 \le j \le m\)），若存在 vis[n][j] == false，则返回 false；否则返回 true。
    • 二分查找：左边界 \(l = 0\)，右边界 \(r = maxP\)。当 \(l < r\) 时，取 \(mid = \lfloor (l+r)/2 \rfloor\)，若 check(mid) 为真，则 \(r = mid\)；否则 \(l = mid+1\)。最终 \(l\) 即为最小伤害值。
    • 输出：输出 \(l\)。

  4. 时间/空间复杂度：

    • 时间复杂度：\(O(n \times m \log \max p)\)，其中 \(\max p \le 1000\)，二分约 10 次，每次 BFS/DFS 遍历所有格子。
    • 空间复杂度：\(O(n \times m)\)，用于存储地图和访问标记。

  5. 整数二分 + 连通性检查的核心思想：

    • 单调性转化：将“最小化最大伤害”转化为判定性问题——给定阈值 \(P\)，是否存在路径方案。利用二分答案将优化问题转化为多次判定，简化了问题结构。
    • 连通性建模：网格移动视为四连通图，每个格子是节点，边权为相邻格子的最大伤害（或仅以节点伤害值作为限制）。判定 \(P\) 是否可行等价于判断从第一行到最后一行的所有节点是否都在同一个由 \(\le P\) 节点构成的连通块中。
    • 起点选择：由于第一行所有格子伤害为 0 且互相连通，从任意第一行格子出发即可代表所有第一行入口，无需枚举多个起点。
    • 覆盖最后一行的所有格子：必须确保最后一行每个格子都能到达，因此检查时需验证整行是否全部被访问，而非仅判断是否存在一条路径。
    • 适用于“最小化路径上的最大值”类问题，常见于网格图、二分答案 + 搜索的经典组合。

【算法标签】

普及 #整数二分

【代码详解】

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

const int N = 1005;          // 定义地图最大尺寸
int n, m;                     // n: 行数, m: 列数
int p[N][N];                  // 存储每个格子的高度
bool vis[N][N];               // 标记数组，记录是否访问过
int dx[4] = {-1, 0, 1, 0};    // 方向数组：上、右、下、左
int dy[4] = {0, 1, 0, -1};    // 方向数组：上、右、下、左

// 深度优先搜索：判断是否能在不超过P的高度下到达底部
bool dfs(int x, int y, int P)
{
    if (x == n)               // 如果到达最后一行
        return true;

    vis[x][y] = true;         // 标记当前位置已访问

    // 尝试四个方向
    for (int i = 0; i < 4; i++)
    {
        int xx = x + dx[i];
        int yy = y + dy[i];

        // 检查新位置是否合法且未被访问且高度不超过P
        if (xx >= 1 && xx <= n && yy >= 1 && yy <= m && !vis[xx][yy] && p[xx][yy] <= P)
        {
            if (dfs(xx, yy, P))  // 递归搜索
                return true;
        }
    }
    return false;
}

// 二分查找最小可行高度
int find()
{
    int l = -1, r = 1001;     // 初始化二分范围

    while (l + 1 < r)
    {
        int mid = (l + r) / 2;
        memset(vis, 0, sizeof(vis));  // 重置访问标记

        if (dfs(1, 1, mid))    // 尝试中间值
            r = mid;           // 可以则尝试更小的高度
        else
            l = mid;           // 否则尝试更大的高度
    }
    return r;                  // 返回最小可行高度
}

int main()
{
    // 输入地图尺寸
    cin >> n >> m;

    // 输入每个格子的高度
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)
            cin >> p[i][j];

    // 计算并输出最小可行高度
    cout << find();

    return 0;
}

// 使用acwing模板二刷
#include <bits/stdc++.h>
using namespace std;

const int N = 1005;          // 定义地图最大尺寸
int n, m;                     // n: 行数, m: 列数
int p[N][N];                  // 存储每个格子的高度
bool vis[N][N];               // 标记数组，记录是否访问过
int dx[4] = {-1, 0, 1, 0};    // 方向数组：上、右、下、左
int dy[4] = {0, 1, 0, -1};    // 方向数组：上、右、下、左

// 检查函数：判断是否能在不超过P的高度下到达底部
bool check(int x, int y, int P)
{
    if (x == n)               // 如果到达最后一行
        return true;

    vis[x][y] = true;         // 标记当前位置已访问

    // 尝试四个方向
    for (int i = 0; i < 4; i++)
    {
        int xx = x + dx[i];
        int yy = y + dy[i];

        // 检查新位置是否合法且未被访问且高度不超过P
        if (xx >= 1 && xx <= n && yy >= 1 && yy <= m && !vis[xx][yy] && p[xx][yy] <= P)
        {
            if (check(xx, yy, P))  // 递归检查
                return true;
        }
    }
    return false;
}

// 二分查找最小可行高度
int find()
{
    int l = 0, r = 1000;      // 初始化二分范围

    while (l < r)
    {
        int mid = (l + r) >> 1;  // 计算中间值
        memset(vis, 0, sizeof(vis));  // 重置访问标记

        if (check(1, 1, mid))    // 尝试中间值
            r = mid;             // 可以则尝试更小的高度
        else
            l = mid + 1;         // 否则尝试更大的高度
    }
    return l;                   // 返回最小可行高度
}

int main()
{
    // 输入地图尺寸
    cin >> n >> m;

    // 输入每个格子的高度
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)
            cin >> p[i][j];

    // 计算并输出最小可行高度
    cout << find();

    return 0;
}

【运行结果】

4 2
0 0
3 5
2 4
0 0
3
posted @ 2026-09-02 21:40  团爸讲算法  阅读(11)  评论(0)    收藏  举报