【华为机试】2024年真题C卷（java）-亲子游戏

【华为机试】2024年真题C卷汇总（java）

 一、题目

题目描述：

宝宝和妈妈参加亲子游戏，在一个二维矩阵（N*N）的格子地图上，宝宝和妈妈抽签决定各自的位置，地图上每个格子有不同的糖果数量，部分格子有障碍物。
游戏规则是妈妈必须在最短的时间（每个单位时间只能走一步）到达宝宝的位置，路上的所有糖果都可以拿走，不能走障碍物的格子，只能上下左右走。
请问妈妈在最短到达宝宝位置的时间内最多拿到多少糖果（优先考虑最短时间到达的情况下尽可能多拿糖果）。

二、输入输出

输入描述：
第一行输入为N，N标识二维矩阵的大小
之后N行，每行有N个值，表格矩阵每个位置的值
其中：
-3：妈妈
-2：宝宝
-1：障碍
>=0：糖果数(0表示没有糖果，但是可以走)
输出描述：
输出妈妈在最短到达宝宝位置的时间内最多拿到多少糖果，行末无多余空格
备注：
地图最大50*50

三、示例

示例1：
输入：
4
3 2 1 -3
1 -1 1 1
1 1 -1 2
-2 1 2 3
输出：
9
说明：
此地图有两条最短路径可到宝宝位置，都是最短路径6步，但先向下再向左可以拿到9个糖果
示例2：
输入：
4
3 2 1 -3
-1 -1 1 1
1 1 -1 2
-2 1 -1 3
输出：
-1
说明：
此地图妈妈无法到达宝宝位置

四、解题思路

BFS问题

        1、第一轮BFS：从起点开始，按照上、下、左、右的顺序遍历相邻的格子，将可达的格子加入队列，并记录访问时间。

        2、如果终点不可达，输出-1并结束程序。

        3、第二轮BFS：从起点开始，按照上、下、左、右的顺序遍历相邻的格子，更新每个格子的最大糖果数。

        4、输出终点格子的最大糖果数。

五、参考代码

/*
 * @#coding: utf-8
 * @Author: mgc
 * @Date: 2024-02-02 17:47:00
 * @LastEditors: Do not edit
 * @LastEditTime: 2024-02-02 17:48:55
 */

// import java.util.*;
// import java.util.HashMap;
// import java.util.Scanner;
// import java.util.regex.Matcher;
// import java.util.stream.Stream;
// import java.util.regex.Pattern;
// import java.util.stream.Collectors;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[][] directions = {{0, 1}, {1, 0}, {-1, 0}, {0, -1}};
        int[][] matrix = new int[n][n];
        Cell start = new Cell(0, 0);
        Cell end = new Cell(0, 0);

        // 读取输入矩阵并找到起点和终点
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                matrix[i][j] = in.nextInt();
                if (matrix[i][j] == -3) {
                    start.x = i;
                    start.y = j;
                }
                if (matrix[i][j] == -2) {
                    end.x = i;
                    end.y = j;
                }
            }
        }

        int[][] visited = new int[n][n];
        int[][] candies = new int[n][n];

        // 初始化visited和candies数组
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                visited[i][j] = 0;
                candies[i][j] = -1;
            }
        }

        // 第一轮BFS找到最短时间
        Queue queue = new LinkedList<>();
        queue.offer(start);
        int time = 0;
        int flag = 0;
        while (true) {
            if (queue.isEmpty()) {
                break;
            } else {
                int size = queue.size();
                for (int k = 0; k < size; k++) {
                    Cell cur = queue.poll();
                    if (cur.x == end.x && cur.y == end.y) {
                        flag = 1;
                        break;
                    }

                    for (int i = 0; i < 4; i++) {
                        int xx = cur.x + directions[i][0];
                        int yy = cur.y + directions[i][1];

                        if (xx >= 0 && xx < n && yy >= 0 && yy < n
                                && visited[xx][yy] == 0 && matrix[xx][yy] != -1) {
                            visited[xx][yy] = 1;
                            Cell temp = new Cell(xx, yy);
                            queue.offer(temp);
                        }
                    }
                }
                if (flag == 1) {
                    break;
                }
                time += 1;
            }
        }

        if (flag == 0) {
            System.out.println(-1);
            return;
        }

        // 第二轮BFS找到最大糖果数
        Queue candyQueue = new LinkedList<>();
        candyQueue.offer(start);
        candies[start.x][start.y] = 0;
        while (true) {
            if (time < 0) {
                break;
            } else {
                int size = candyQueue.size();
                for (int k = 0; k < size; k++) {
                    Cell cur = candyQueue.poll();
                    for (int i = 0; i < 4; i++) {
                        int xx = cur.x + directions[i][0];
                        int yy = cur.y + directions[i][1];
                        if (xx >= 0 && xx < n && yy >= 0 && yy < n
                                && matrix[xx][yy] != -1) {
                            if (candies[xx][yy] == -1) {
                                Cell temp = new Cell(xx, yy);
                                candyQueue.offer(temp);
                            }
                            if (matrix[xx][yy] != -2) {
                                if (candies[cur.x][cur.y] + matrix[xx][yy] > candies[xx][yy]) {
                                    candies[xx][yy] = candies[cur.x][cur.y] + matrix[xx][yy];
                                }
                            } else {
                                if (candies[cur.x][cur.y] > candies[xx][yy]) {
                                    candies[xx][yy] = candies[cur.x][cur.y];
                                }
                            }
                        }
                    }
                }
            }
            time -= 1;
        }

        System.out.println(candies[end.x][end.y]);
    }

    public static class Cell {
        int x;
        int y;

        public Cell(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
}