2024华为OD试题及答案-A020-机器人

题目描述

现有一个机器人，可放置于 M × N 的网格中任意位置，每个网格包含一个非负整数编号，当相邻网格的数字编号差值的绝对值小于等于 1 时，机器人可以在网格间移动。

问题： 求机器人可活动的最大范围对应的网格点数目。
说明：网格左上角坐标为 (0,0) ,右下角坐标为(m−1,n−1)，机器人只能在相邻网格间上下左右移动

输入描述

第 1 行输入为 M 和 N ， M 表示网格的行数 N 表示网格的列数
之后 M 行表示网格数值，每行 N 个数值（数值大小用 k 表示），
数值间用单个空格分隔，行首行尾无多余空格。
M、 N、 k 均为整数，且 1 ≤ M,N ≤ 150, 0 ≤ k ≤ 50

输出描述

输出 1 行，包含 1 个数字，表示最大活动区域的网格点数目，
行首行尾无多余空格。

用例

输入	4 4 1 2 5 2 2 4 4 5 3 5 7 1 4 6 2 4
输出	6
说明	图中绿色区域，相邻网格差值绝对值都小于等于 1 ，且为最大区域，对应网格点数目为 6。

题目解析

问题描述

有一个机器人，可以放置于 M×NM \times NM×N 的网格中的任意位置，每个网格包含一个非负整数编号。当相邻网格的数字编号的绝对值差值小于等于1时，机器人可以在网格间移动。我们需要求出机器人可活动的最大范围对应的网格点数目。

输入描述

1. 第一行输入为两个整数 MMM 和 NNN，表示网格的行数和列数。
2. 接下来是 MMM 行，每行包含 NNN 个整数，表示网格的值。数值间用单个空格分隔。

输出描述

输出一个整数，表示最大活动区域的网格点数目。

示例

输入：

4 4
1 2 5 2
2 4 4 5
3 5 7 1
4 6 2 4

输出：

6

解释： 图中绿色区域，相邻网格差值绝对值小于等于1，为最大区域，包含6个网格点。

解题思路

1. 深度优先搜索 (DFS)：遍历网格中的每个点，以每个点为起点进行DFS，记录可以达到的最大区域的网格数。
2. 标记访问：使用一个辅助矩阵记录已经访问过的点，避免重复计算。
3. 比较更新：不断比较每次DFS的结果，记录其中最大的网格数。

C++代码实现

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int M, N;
vector<vector<int>> grid;
vector<vector<bool>> visited;
int directions[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

bool isValid(int x, int y, int prevValue) {
    return x >= 0 && x < M && y >= 0 && y < N && !visited[x][y] && abs(grid[x][y] - prevValue) <= 1;
}

int dfs(int x, int y) {
    visited[x][y] = true;
    int count = 1;
    
    for (auto &dir : directions) {
        int newX = x + dir[0];
        int newY = y + dir[1];
        
        if (isValid(newX, newY, grid[x][y])) {
            count += dfs(newX, newY);
        }
    }
    
    return count;
}

int main() {
    cin >> M >> N;
    grid.resize(M, vector<int>(N));
    visited.resize(M, vector<bool>(N, false));
    
    for (int i = 0; i < M; ++i) {
        for (int j = 0; j < N; ++j) {
            cin >> grid[i][j];
        }
    }

    int maxArea = 0;
    
    for (int i = 0; i < M; ++i) {
        for (int j = 0; j < N; ++j) {
            if (!visited[i][j]) {
                maxArea = max(maxArea, dfs(i, j));
            }
        }
    }
    
    cout << maxArea << endl;
    return 0;
}

代码说明

1. isValid函数：检查当前点是否在网格范围内，且未访问过，并且与前一个点的值差绝对值小于等于1。
2. dfs函数：深度优先搜索，统计从当前点出发可以达到的最大网格数，并标记已访问的点。
3. 主函数：读取输入，初始化网格和访问矩阵，对每个点进行DFS，找到最大活动区域的网格数目。

这个程序能够计算出机器人在给定网格中可以活动的最大区域的网格数目。

python代码实现

def is_valid(x, y, prev_value, M, N, grid, visited):
    return 0 <= x < M and 0 <= y < N and not visited[x][y] and abs(grid[x][y] - prev_value) <= 1

def dfs(x, y, M, N, grid, visited):
    directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]
    visited[x][y] = True
    count = 1

    for dir in directions:
        new_x, new_y = x + dir[0], y + dir[1]
        if is_valid(new_x, new_y, grid[x][y], M, N, grid, visited):
            count += dfs(new_x, new_y, M, N, grid, visited)

    return count

def max_area(M, N, grid):
    visited = [[False for _ in range(N)] for _ in range(M)]
    max_area = 0

    for i in range(M):
        for j in range(N):
            if not visited[i][j]:
                max_area = max(max_area, dfs(i, j, M, N, grid, visited))

    return max_area

# 读取输入
M, N = map(int, input().split())
grid = [list(map(int, input().split())) for _ in range(M)]

# 计算并输出最大活动区域的网格数目
print(max_area(M, N, grid))

代码说明

1. is_valid函数：检查当前点是否在网格范围内，且未访问过，并且与前一个点的值差绝对值小于等于1。
2. dfs函数：深度优先搜索，统计从当前点出发可以达到的最大网格数，并标记已访问的点。
3. max_area函数：初始化访问矩阵，对每个点进行DFS，找到最大活动区域的网格数目。
4. 读取输入：读取网格的行数和列数，以及网格的值。
5. 输出结果：计算并输出最大活动区域的网格数目。

这个Python程序可以计算出机器人在给定网格中可以活动的最大区域的网格数目。你可以在Python环境中运行这个程序来解决题目中的问题。