[已解决]洛谷刺杀大使20分求改

广东范戴克

题目是洛谷的p1902刺杀大使
这个账号没权限发链接
只能过两个测试点，其他的都是TLE,有没有彦祖看一下错在哪

某组织正在策划一起对某大使的刺杀行动。他们来到了使馆，准备完成此次刺杀，要进入使馆首先必须通过使馆前的防御迷阵。
迷阵由 n×m 个相同的小房间组成，每个房间与相邻四个房间之间有门可通行。在第 n 行的 m 个房间里有 m个机关，这些机关必须全部打开才可以进入大使馆。而第 1 行的 m 个房间有 m 扇向外打开的门，是迷阵的入口。除了第 1 行和第 n 行的房间外，每个房间都被使馆的安保人员安装了激光杀伤装置，将会对进入房间的人造成一定的伤害。第 i 行第 j 列 造成的伤害值为 pi,j （第 1 行和第 n 行的 p 值全部为 0）。
现在某组织打算以最小伤害代价进入迷阵，打开全部机关，显然，他们可以选 择任意多的人从任意的门进入，但必须到达第 n 行的每个房间。一个士兵受到的伤害值为他到达某个机关的路径上所有房间的伤害值中的最大值，整个部队受到的伤害值为所有士兵的伤害值中的最大值。现在，这个恐怖组织掌握了迷阵的情况，他们需要提前知道怎么安排士兵的行进路线可以使得整个部队的伤害值最小。
输入格式
第一行有两个整数 n,m，表示迷阵的大小。
接下来 n 行，每行 m 个数，第 i 行第 j 列的数表示 pi,j。
输出格式
输出一个数，表示最小伤害代价。
说明/提示
50% 的数据，n,m≤100;
100%的数据，n,m≤1000;
pi,j≤1000

1. #include<iostream>
   
2. #include<cstring>
   
3. #include<math.h>
   
4. #include<algorithm>
   
5. using namespace std;
   
6. int d[4][2] = { {0,1},{1,0},{0,-1},{-1,0} };
   
7. int ans = 1000;
   
8. int n, m, temp, my_max = 0, my_min = 1000;
   
9. short book[1003][1003];
   
10. short p[1003][1003];
    
11. bool flag = false,r;
    
12. int main() {
    
13.         bool check(int x, int y, int num);
    
14.         cin >> n >> m;
    
15.         for (int i = 1; i <= n; i++)
    
16.                 for (int j = 1; j <= m; j++) {
    
17.                         cin >> temp;
    
18.                         p[i][j] = temp;
    
19.                         if (temp > my_max)
    
20.                                 my_max = temp;
    
21.                         if (temp < my_min)
    
22.                                 my_min = temp;
    
23.                 }
    
24.         int mid;
    
25.         while (my_min <= my_max) {
    
26.                 mid = (my_min + my_max) / 2;
    
27.                 flag = false;
    
28.                 memset(book, 0, sizeof(book));
    
29.                 if (check(1, 1, mid)) {
    
30.                         ans = mid;
    
31.                         my_max = mid-1;
    
32.                 }
    
33.                 else
    
34.                         my_min = mid+1;
    
35.         }
    
36.         cout << ans;
    
37. }
    
38. bool check(int x,int y,int num)
    
39. {
    
40.         int tx, ty;
    
41.         if (x == n||flag) {
    
42.                 flag = true;
    
43.                 r = true;
    
44.                 return r;
    
45.         }
    
46.         for (int i = 0; i < 4; i++) {
    
47.                 tx = x + d[i][0];
    
48.                 ty = y + d[i][1];
    
49.                 if (book[tx][ty] == 1 || p[tx][ty] > num||tx>n||ty>m||tx<1||ty<1)
    
50.                         continue;
    
51.                 book[tx][ty] = 1;
    
52.                 check(tx, ty, num);       
    
53.                 book[tx][ty] = 0;
    
54.                 if (flag)
    
55.                         return flag;
    
56.         }
    
57.         return flag;
    
58. }

复制代码

最佳答案

月排行榜 / 总排行榜

FishC

2024-10-8 16:23:55

广东范戴克 发表于 2024-10-08 16:23
输入格式
第一行有两个整数&#160;n,m，表示迷阵的大 ...

对于洛谷的这道题目，你需要在一个网格中寻找路径，这个路径要穿越从左上到右下，但代价最小。为了优化你的代码，从而让它通过更大规模的测试点，需要一些技巧。

基于你提供的信息和常见的路径优化问题，建议你优化算法如下：

1. **二分+判断可行性**:
    - 使用二分搜索来尝试所有可能的最大高度差。
    - 每次二分后，通过广度优先搜索（BFS）或深度优先搜索（DFS）来判断当前高度差是否可行。

2. **广度优先搜索（BFS）**:
    - 使用BFS更合适在这种最短路径相关的问题中，因为它可以在早期阶段就找到可行路径并及时跳出。
  
具体步骤如下：

1. #include <iostream>
   
2. #include <vector>
   
3. #include <queue>
   
4. #include <algorithm>
   
5. using namespace std;
   
6. 
   
7. int n, m;
   
8. vector<vector<int>> grid;
   
9. vector<vector<bool>> visited;
   
10. 
    
11. bool canReachWithMaxDiff(int maxDiff) {
    
12.     visited.assign(n, vector<bool>(m, false));
    
13.     queue<pair<int, int>> q;
    
14.     q.push({0, 0});
    
15.     visited[0][0] = true;
    
16.    
    
17.     vector<pair<int, int>> directions = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    
18.    
    
19.     while (!q.empty()) {
    
20.         auto [x, y] = q.front();
    
21.         q.pop();
    
22.         
    
23.         if (x == n - 1 && y == m - 1) {
    
24.             return true;
    
25.         }
    
26.         
    
27.         for (auto [dx, dy] : directions) {
    
28.             int nx = x + dx, ny = y + dy;
    
29.             if (nx >= 0 && nx < n && ny >= 0 && ny < m && !visited[nx][ny] &&
    
30.                 abs(grid[nx][ny] - grid[x][y]) <= maxDiff) {
    
31.                 visited[nx][ny] = true;
    
32.                 q.push({nx, ny});
    
33.             }
    
34.         }
    
35.     }
    
36.     return false;
    
37. }
    
38. 
    
39. int main() {
    
40.     cin >> n >> m;
    
41.     grid.resize(n, vector<int>(m));
    
42. 
    
43.     for (int i = 0; i < n; ++i) {
    
44.         for (int j = 0; j < m; ++j) {
    
45.             cin >> grid[i][j];
    
46.         }
    
47.     }
    
48.    
    
49.     int left = 0, right = 1000, ans = 1000;
    
50.     while (left <= right) {
    
51.         int mid = left + (right - left) / 2;
    
52.         if (canReachWithMaxDiff(mid)) {
    
53.             ans = mid;
    
54.             right = mid - 1;
    
55.         } else {
    
56.             left = mid + 1;
    
57.         }
    
58.     }
    
59. 
    
60.     cout << ans << endl;
    
61.     return 0;
    
62. }

复制代码

### 解释：

- **二分搜索**：我们以高度差作为指标进行二分，寻找瓶颈的最小值。
- **BFS 判断可行性**：对每个中间值，通过 BFS 检查从起点到终点是否有连通路径，且路径中相邻点的差值不超过该中间值。
- **复杂度**：这结合了二分搜索和 BFS 的复杂度，总体可以处理较大的输入规模。

通过这种方法，大部分在 `n, m ≤ 1000` 时都可以正常运行在时间限制内。记得理解算法的基本思路，针对具体问题需求可以进一步调整。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

跳转到最佳答案楼层

FishC

你遇到了超时问题（TLE），通常是因为算法复杂度过高或有不必要的重复计算。根据你提供的代码片段，无法完整评估整个算法，不过我可以给出一些建议来优化代码。

1. **使用更高效的数据结构**：
   你可以考虑使用二维数组或向量来存储输入数据及常用的状态信息，以便于快速访问和更新。

2. **减少不必要的计算**：
   - 确保在搜索时（例如深度优先搜索 DFS）系统地检查每一步是否是必要的。
   - 预处理数据以避免重复计算，例如记录访问过的状态避免重复访问。

3. **利用更快的I/O操作**：
   - 如果输入规模较大，使用`scanf`和`printf`可能比`cin`和`cout`更快。

4. **优化你的算法思路**：
   - 考虑其他方法，如动态规划、二分查找等优化搜索算法。

这里有一个可能的算法结构建议：

1. #include <iostream>
   
2. #include <vector>
   
3. #include <algorithm>
   
4. using namespace std;
   
5. 
   
6. // 用于表示一个位置
   
7. struct Point {
   
8.     int x, y;
   
9. };
   
10. 
    
11. int n, m;
    
12. vector<vector<int>> grid;
    
13. vector<vector<bool>> visited;
    
14. 
    
15. // 四个方向移动
    
16. vector<Point> directions = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    
17. 
    
18. // 验证是否在界内
    
19. inline bool isInBounds(int x, int y) {
    
20.     return x >= 0 && x < n && y >= 0 && y < m;
    
21. }
    
22. 
    
23. // 递归搜索
    
24. void dfs(int x, int y, int& ans) {
    
25.     for (const auto& dir : directions) {
    
26.         int nx = x + dir.x, ny = y + dir.y;
    
27.         if (isInBounds(nx, ny) && !visited[nx][ny]) {
    
28.             visited[nx][ny] = true;
    
29.             // 可以在这里判断是否是更优的路径或更新ans
    
30.             dfs(nx, ny, ans);
    
31.             visited[nx][ny] = false;
    
32.         }
    
33.     }
    
34. }
    
35. 
    
36. int main() {
    
37.     cin >> n >> m;
    
38.     grid.assign(n, vector<int>(m));
    
39.     visited.assign(n, vector<bool>(m, false));
    
40.     int my_max = 0, my_min = 1000;
    
41. 
    
42.     // 获取输入和初始化界限
    
43.     for (int i = 0; i < n; i++) {
    
44.         for (int j = 0; j < m; j++) {
    
45.             cin >> grid[i][j];
    
46.             my_max = max(my_max, grid[i][j]);
    
47.             my_min = min(my_min, grid[i][j]);
    
48.         }
    
49.     }
    
50. 
    
51.     // 主逻辑
    
52.     int ans = 1000;  // 假设这是目标结果的初始值
    
53.     // 调用dfs等函数，结合判断条件逐步逼近答案
    
54. 
    
55.     cout << ans << endl;
    
56.     return 0;
    
57. }

复制代码

请根据你的实际情况调整细节。这些只是常见的优化思路，具体的效率取决于对问题的深刻理解和针对性优化。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

广东范戴克

输入格式
第一行有两个整数&#160;n,m，表示迷阵的大小。
接下来&#160;n&#160;行，每行&#160;m&#160;个数，第&#160;i&#160;行第&#160;j&#160;列的数表示&#160;pi,j。
输出格式
输出一个数，表示最小伤害代价。
说明/提示
50%&#160;的数据，n,m≤100;
100%的数据，n,m≤1000;
pi,j≤1000

FishC

广东范戴克 发表于 2024-10-08 16:23
输入格式
第一行有两个整数&#160;n,m，表示迷阵的大 ...

对于洛谷的这道题目，你需要在一个网格中寻找路径，这个路径要穿越从左上到右下，但代价最小。为了优化你的代码，从而让它通过更大规模的测试点，需要一些技巧。

基于你提供的信息和常见的路径优化问题，建议你优化算法如下：

1. **二分+判断可行性**:
    - 使用二分搜索来尝试所有可能的最大高度差。
    - 每次二分后，通过广度优先搜索（BFS）或深度优先搜索（DFS）来判断当前高度差是否可行。

2. **广度优先搜索（BFS）**:
    - 使用BFS更合适在这种最短路径相关的问题中，因为它可以在早期阶段就找到可行路径并及时跳出。
  
具体步骤如下：

1. #include <iostream>
   
2. #include <vector>
   
3. #include <queue>
   
4. #include <algorithm>
   
5. using namespace std;
   
6. 
   
7. int n, m;
   
8. vector<vector<int>> grid;
   
9. vector<vector<bool>> visited;
   
10. 
    
11. bool canReachWithMaxDiff(int maxDiff) {
    
12.     visited.assign(n, vector<bool>(m, false));
    
13.     queue<pair<int, int>> q;
    
14.     q.push({0, 0});
    
15.     visited[0][0] = true;
    
16.    
    
17.     vector<pair<int, int>> directions = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    
18.    
    
19.     while (!q.empty()) {
    
20.         auto [x, y] = q.front();
    
21.         q.pop();
    
22.         
    
23.         if (x == n - 1 && y == m - 1) {
    
24.             return true;
    
25.         }
    
26.         
    
27.         for (auto [dx, dy] : directions) {
    
28.             int nx = x + dx, ny = y + dy;
    
29.             if (nx >= 0 && nx < n && ny >= 0 && ny < m && !visited[nx][ny] &&
    
30.                 abs(grid[nx][ny] - grid[x][y]) <= maxDiff) {
    
31.                 visited[nx][ny] = true;
    
32.                 q.push({nx, ny});
    
33.             }
    
34.         }
    
35.     }
    
36.     return false;
    
37. }
    
38. 
    
39. int main() {
    
40.     cin >> n >> m;
    
41.     grid.resize(n, vector<int>(m));
    
42. 
    
43.     for (int i = 0; i < n; ++i) {
    
44.         for (int j = 0; j < m; ++j) {
    
45.             cin >> grid[i][j];
    
46.         }
    
47.     }
    
48.    
    
49.     int left = 0, right = 1000, ans = 1000;
    
50.     while (left <= right) {
    
51.         int mid = left + (right - left) / 2;
    
52.         if (canReachWithMaxDiff(mid)) {
    
53.             ans = mid;
    
54.             right = mid - 1;
    
55.         } else {
    
56.             left = mid + 1;
    
57.         }
    
58.     }
    
59. 
    
60.     cout << ans << endl;
    
61.     return 0;
    
62. }

复制代码

### 解释：

- **二分搜索**：我们以高度差作为指标进行二分，寻找瓶颈的最小值。
- **BFS 判断可行性**：对每个中间值，通过 BFS 检查从起点到终点是否有连通路径，且路径中相邻点的差值不超过该中间值。
- **复杂度**：这结合了二分搜索和 BFS 的复杂度，总体可以处理较大的输入规模。

通过这种方法，大部分在 `n, m ≤ 1000` 时都可以正常运行在时间限制内。记得理解算法的基本思路，针对具体问题需求可以进一步调整。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

广东范戴克

#include<iostream>
#include<math.h>
#include<algorithm>
#include<queue>
typedef pair<int, int>point;

using namespace std;
int d[4][2] = { {0,1},{1,0},{0,-1},{-1,0} };
int ans = 1000;
int n, m, temp, my_max = 0, my_min = 1000;
short book[1003][1003];
short p[1003][1003];
bool flag = false,r;
int main() {
        bool check(int x, int y, int num);
        cin >> n >> m;
        for (int i = 1; i <= n; i++)
                for (int j = 1; j <= m; j++) {
                        cin >> temp;
                        p[i][j] = temp;
                        if (temp > my_max)
                                my_max = temp;
                        if (temp < my_min)
                                my_min = temp;
                }
        int mid;
        while (my_min <= my_max) {
                mid = (my_min + my_max) / 2;
                flag = false;
                memset(book, 0, sizeof(short)*1003*1003);
                if (check(1, 1, mid)) {
                        ans = mid;
                        my_max = mid-1;
                }
                else
                        my_min = mid+1;
        }
        cout << ans;
}
bool check(int x,int y,int num)
{
        int tx, ty;
        queue<point>q;
        point a(1, 1);
        q.push(a);
        book[1][1] = 1;
        while (!q.empty()) {
                point top = q.front();
                for (int i = 0; i < 4; i++) {
                        point next;
                        tx = top.first + d[i][0];
                        ty = top.second + d[i][1];
                        if (book[tx][ty] == 1 || p[tx][ty] > num || tx > n || ty > m || tx < 1 || ty < 1)
                                continue;
                        book[tx][ty] = 1;
                        next.first = tx;
                        next.second = ty;
                        q.push(next);
                        if (tx == n)
                                return true;
                }
                q.pop();
        }
        return false;
}
以上代码为什么编译失败呀

FishC

广东范戴克 发表于 2024-10-09 17:04
#include
#include
#include
#include
typedef pa ...

你的代码在编译时出现了几个问题，我们把它们一一解决：

1. **缺少头文件和语法错误：**
   - `#include`后缺少头文件名称。例如：`#include <iostream>`等。
   - `typedef pairpoint;`是错误的，应该是`typedef pair<int, int> point;`

2. **数组定义和类型错误：**
   - `int d = {{0,1},{1,0},{0,-1},{-1,0}};`应该是`int d[4][2] = {{0,1},{1,0},{0,-1},{-1,0}};`

3. **变量定义错误：**
   - `short book;`和`short p;`并未正确初始化为数组。应该定义为二维数组，比如`short book[1005][1005];` 和 `short p[1005][1005];`

4. **`main`函数中的函数定义问题：**
   - `bool check(int x, int y, int num);`应在`main`函数外部，并定义为一个完整的函数。

5. **读取数据时的错误：**
   - 缺乏读取方式。应该用`cin >> p[i][j];`类似地进行读取。

结合这些修改，下面是一个简化和修正后的版本框架：

1. #include <iostream>
   
2. #include <queue>
   
3. #include <utility>
   
4. 
   
5. using namespace std;
   
6. typedef pair<int, int> point;
   
7. 
   
8. int d[4][2] = {{0,1},{1,0},{0,-1},{-1,0}};
   
9. int n, m, my_max = 0, my_min = 1000;
   
10. short book[1005][1005] = {0};
    
11. short p[1005][1005];
    
12. 
    
13. bool check(int x, int y, int num);
    
14. 
    
15. int main() {
    
16.     cin >> n >> m;
    
17.     for (int i = 1; i <= n; ++i) {
    
18.         for (int j = 1; j <= m; ++j) {
    
19.             cin >> p[i][j];
    
20.             if (p[i][j] > my_max) my_max = p[i][j];
    
21.             if (p[i][j] < my_min) my_min = p[i][j];
    
22.         }
    
23.     }
    
24. 
    
25.     // 示例逻辑，可以根据实际需求调整和完善
    
26.     int mid;
    
27.     while (my_min < my_max) {
    
28.         mid = (my_min + my_max) / 2;
    
29.         if (check(1, 1, mid)) {
    
30.             my_max = mid;
    
31.         } else {
    
32.             my_min = mid + 1;
    
33.         }
    
34.     }
    
35.     cout << my_min << endl;
    
36.     return 0;
    
37. }
    
38. 
    
39. bool check(int x, int y, int num) {
    
40.     queue<point> q;
    
41.     q.push({x, y});
    
42.     book[x][y] = 1;
    
43. 
    
44.     while (!q.empty()) {
    
45.         point cur = q.front();
    
46.         for (int i = 0; i < 4; ++i) {
    
47.             int tx = cur.first + d[i][0];
    
48.             int ty = cur.second + d[i][1];
    
49. 
    
50.             if (tx < 1 || ty < 1 || tx > n || ty > m || book[tx][ty] || p[tx][ty] > num) continue;
    
51. 
    
52.             book[tx][ty] = 1;
    
53.             q.push({tx, ty});
    
54.             if (tx == n) return true;
    
55.         }
    
56.         q.pop();
    
57.     }
    
58.     return false;
    
59. }

复制代码

以上代码为你提供了一个更正后的结构框架，可以通过这个框架进行进一步调试和完善。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。