【备战秋招】每日一题:2023.05-B卷-华为OD机试 - 宜居星球改造计划

最新推荐文章于 2024-06-20 21:00:00 发布
最新推荐文章于 2024-06-20 21:00:00 发布
阅读量72 收藏
点赞数 1
文章标签： 华为od 算法 链表 数据结构 编辑器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73659489/article/details/131749061
版权

为了更好的阅读体检，可以查看我的算法学习网
本题在线评测链接:P1358

题目描述

2 X X X 2XXX 2XXX年，人类通过对火星的大气进行宜居改造分析，使得火星已在理论上具备人类宜居的条件;

由于技术原因，无法一次性将火星大气全部改造，只能通过局部处理形式;

假设将火星待改造的区域为 r o w ∗ c o l u m n row*column row∗column的网格，每个网格有 3 3 3个值，宜居区、可改造区、死亡区，使用 Y E S YES YES、 N O NO NO、 N A NA NA代替， Y E S YES YES表示该网格已经完成大气改造， N O NO NO表示该网格未进行改造，后期可进行改造， N A NA NA表示死亡区，不作为判断是否改造完的宜居，无法穿过;

初始化下，该区域可能存在多个宜居区，并目每个宜居区能同时在每个大阳日单位向上下左右四个方向的相邻格子进行扩散，自动将 4 4 4个方向相邻的真空区改造成宜居区:

请计算这个待改造区域的网格中，可改造区是否能全部成宜居区，如果可以，则返回改造的大阳日天教，不可以则返回 − 1 -1 −1

输入描述

输入 r o w ∗ c o l u m n row*column row∗column个网格数据，每个网格值枚举值如下: Y E S YES YES， N O NO NO， N A NA NA;

样例:

Y E S YES YES Y E S YES YES N O NO NO

N O NO NO N O NO NO N O NO NO

N A NA NA N O NO NO Y E S YES YES

输出描述

可改造区是否能全部变成宜居区，如果可以，则返回改造的太阳日天数，不可以则返回 − 1 -1 −1。

备注

g r i d grid grid [ i ] [i] [i] [ j ] [j] [j]只有 3 3 3种情况， Y E S YES YES、 N O NO NO、 N A NA NA

- r o w row row g r i d . l e n g t h grid.length grid.length
- c o l u m n column column g r i d [ i ] . l e n g t h grid[i].length grid[i].length
- 1 ≤ 1 \leq 1≤ r o w row row, c o l u m n ≤ 8 column \leq 8 column≤8

样例

输入

YES YES NO
NO NO NO
YES NO NO

输出

2

说明

进过2个太阳日，完成宜居改造。

输入

YES NO NO NO
NO NO NO NO
NO NO NO NO
NO NO NO NO

输出

6

说明

经过 6 6 6个太阳日，可完成改造。

输入

NO NA

输出

-1

说明

无改造初始条件，无法进行改造。

输入

YES NO NO YES
NO NO YES NO
NO YES NA NA
YES NO NA NO

输出

-1

说明

− 1 -1 −1//右下角的区域，被周边三个死亡区挡住，无法实现改造。

思路

我们发现题目要求改造所有可改造区最小的日期。

因此题目可以分为两个问题：一、找到所有的可改造区。二、宜居区距离目标改造区的最短距离。

问题一解决方法：

很明显，题目可以抽象为给定 n ∗ m n*m n∗m的地图，以及多个起点，问能否通过起点找到所有可改造的区域。对于二维地图，给定特定起点，目标为找到指定点一类的问题，都可以使用 B F S BFS BFS或者 D F S DFS DFS。因为这两个搜索的主要目的就是找到所有可以搜查到的地方。那么这道题所谓的可以搜查到的地方便是可改造区，而不可搜查地方便是死亡区，我们遇到死亡区就直接跳过不搜索即可。

问题二解决方法：

我们首先了解到问题的解决方法便是 B F S BFS BFS或者 D F S DFS DFS。

其次，我们将问题二转化一下变为：给定二维地图，给定起始点和终点，找到起始点到终点的最短距离。对于这一类的最短路题目，由于点与点之间的距离为1（宜居区到相邻可改造区域只需要一天），因此，可以直接使用 B F S BFS BFS去找到最短路。

类似题目推荐

代码

C++

#include <iostream>
#include <vector>
#include <queue>
#include <sstream>

using namespace std;

int getResult(vector<vector<string>>& matrix) {
    int row = matrix.size();
    int col = matrix[0].size();

    // 记录宜居取坐标位置
    queue<pair<int, int>> que;
    // 记录可改造区数量
    int need = 0;

    for (int i = 0; i < row; i++) {
        for (int j = 0; j < col; j++) {
            if (matrix[i][j] == "YES") {
                que.push({i, j});
            } else if (matrix[i][j] == "NO") {
                need += 1;
            }
        }
    }

    // 如果没有宜居区，则无法改造，直接返回-1
    if (que.empty()) {
        return -1;
    }
    // 如果全是宜居区，则无需改造，直接返回0
    else if (que.size() == row * col) {
        return 0;
    }

    // 记录花费的天数
    int day = 0;
    // 上，下，左，右四个方向的偏移量
    vector<pair<int, int>> offsets = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

    // 图的多源BFS模板
    while (!que.empty() && need > 0) {
        queue<pair<int, int>> newQueue;

        while (!que.empty()) {
            pair<int, int> coordinates = que.front();
            que.pop();

            int x = coordinates.first;
            int y = coordinates.second;

            for (auto& offset : offsets) {
                // 上，下，左，右四个方向扩散
                int newX = x + offset.first;
                int newY = y + offset.second;

                // 如果新位置没有越界，且为NO，则可以被改造
                if (newX >= 0 && newX < row && newY >= 0 && newY < col && matrix[newX][newY] == "NO") {
                    matrix[newX][newY] = "YES";
                    newQueue.push({newX, newY});
                    need -= 1;
                }
            }
        }

        day += 1;
        que = newQueue;
    }

    if (need == 0) {
        return day;
    } else {
        return -1;
    }
}

int main() {
    vector<vector<string>> matrix;

    string line;
    while (getline(cin, line)) {
        istringstream iss(line);
        vector<string> row;
        string value;
        while (iss >> value) {
            row.push_back(value);
        }
        matrix.push_back(row);
    }

    cout << getResult(matrix) << endl;

    return 0;
}

python

# 算法入口
def getResult(matrix):
    row = len(matrix)
    col = len(matrix[0])

    # 记录宜居取坐标位置
    queue = []
    # 记录可改造区数量
    need = 0

    for i in range(row):
        for j in range(col):
            if matrix[i][j] == "YES":
                queue.append([i, j])
            elif matrix[i][j] == "NO":
                need += 1

    # 如果没有宜居区，则无法改造，直接返回-1
    if len(queue) == 0:
        return -1
    # 如果全是宜居区，则无需改造，直接返回0
    elif len(queue) == row * col:
        return 0

    # 记录花费的天数
    day = 0
    # 上，下，左，右四个方向的偏移量
    offsets = ((-1, 0), (1, 0), (0, -1), (0, 1))

    # 图的多源BFS模板
    while len(queue) > 0 and need > 0:
        newQueue = []

        for x, y in queue:
            for offsetX, offsetY in offsets:
                # 上，下，左，右四个方向扩散
                newX = x + offsetX
                newY = y + offsetY

                # 如果新位置没有越界，且为NO，则可以被改造
                if row > newX >= 0 and col > newY >= 0 and matrix[newX][newY] == "NO":
                    matrix[newX][newY] = "YES"
                    newQueue.append([newX, newY])
                    need -= 1

        day += 1
        queue = newQueue

    if need == 0:
        return day
    else:
        return -1


# 输入获取
matrix = []
while True:
    try:
        line = input()
        matrix.append(line.split())
    except:
        break
print(getResult(matrix), end = "\n")

Java

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

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        ArrayList<ArrayList<String>> matrix = new ArrayList<>();

        while (scanner.hasNextLine()) {
            String line = scanner.nextLine();
            String[] row = line.split(" ");
            ArrayList<String> rowList = new ArrayList<>();
            for (String value : row) {
                rowList.add(value);
            }
            matrix.add(rowList);
        }

        System.out.println(getResult(matrix));
    }

    public static int getResult(ArrayList<ArrayList<String>> matrix) {
        int row = matrix.size();
        int col = matrix.get(0).size();

        // 记录宜居取坐标位置
        Queue<int[]> queue = new LinkedList<>();
        // 记录可改造区数量
        int need = 0;

        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                if (matrix.get(i).get(j).equals("YES")) {
                    queue.add(new int[]{i, j});
                } else if (matrix.get(i).get(j).equals("NO")) {
                    need += 1;
                }
            }
        }

        // 如果没有宜居区，则无法改造，直接返回-1
        if (queue.isEmpty()) {
            return -1;
        }
        // 如果全是宜居区，则无需改造，直接返回0
        else if (queue.size() == row * col) {
            return 0;
        }

        // 记录花费的天数
        int day = 0;
        // 上，下，左，右四个方向的偏移量
        int[][] offsets = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

        // 图的多源BFS模板
        while (!queue.isEmpty() && need > 0) {
            Queue<int[]> newQueue = new LinkedList<>();

            for (int[] coordinates : queue) {
                int x = coordinates[0];
                int y = coordinates[1];

                for (int[] offset : offsets) {
                    // 上，下，左，右四个方向扩散
                    int newX = x + offset[0];
                    int newY = y + offset[1];

                    // 如果新位置没有越界，且为NO，则可以被改造
                    if (newX >= 0 && newX < row && newY >= 0 && newY < col && matrix.get(newX).get(newY).equals("NO")) {
                        matrix.get(newX).set(newY, "YES");
                        newQueue.add(new int[]{newX, newY});
                        need -= 1;
                    }
                }
            }

            day += 1;
            queue = newQueue;
        }

        if (need == 0) {
            return day;
        } else {
            return -1;
        }
    }
}

Go

package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
)

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	matrix := [][]string{}

	for scanner.Scan() {
		line := scanner.Text()
		row := strings.Split(line, " ")
		matrixRow := []string{}
		for _, value := range row {
			matrixRow = append(matrixRow, value)
		}
		matrix = append(matrix, matrixRow)
	}

	fmt.Println(getResult(matrix))
}

func getResult(matrix [][]string) int {
	row := len(matrix)
	col := len(matrix[0])

	// 记录宜居取坐标位置
	queue := [][]int{}
	// 记录可改造区数量
	need := 0

	for i := 0; i < row; i++ {
		for j := 0; j < col; j++ {
			if matrix[i][j] == "YES" {
				queue = append(queue, []int{i, j})
			} else if matrix[i][j] == "NO" {
				need += 1
			}
		}
	}

	// 如果没有宜居区，则无法改造，直接返回-1
	if len(queue) == 0 {
		return -1
	}
	// 如果全是宜居区，则无需改造，直接返回0
	if len(queue) == row*col {
		return 0
	}

	// 记录花费的天数
	day := 0
	// 上，下，左，右四个方向的偏移量
	offsets := [][]int{{-1, 0}, {1, 0}, {0, -1}, {0, 1}}

	// 图的多源BFS模板
	for len(queue) > 0 && need > 0 {
		newQueue := [][]int{}

		for _, coordinates := range queue {
			x := coordinates[0]
			y := coordinates[1]

			for _, offset := range offsets {
				// 上，下，左，右四个方向扩散
				newX := x + offset[0]
				newY := y + offset[1]

				// 如果新位置没有越界，且为NO，则可以被改造
				if newX >= 0 && newX < row && newY >= 0 && newY < col && matrix[newX][newY] == "NO" {
					matrix[newX][newY] = "YES"
					newQueue = append(newQueue, []int{newX, newY})
					need -= 1
				}
			}
		}

		day += 1
		queue = newQueue
	}

	if need == 0 {
		return day
	} else {
		return -1
	}
}

Js

function getResult(matrix) {
    let row = matrix.length;
    let col = matrix[0].length;

    // 记录宜居取坐标位置
    let queue = [];
    // 记录可改造区数量
    let need = 0;

    for (let i = 0; i < row; i++) {
        for (let j = 0; j < col; j++) {
            if (matrix[i][j] === "YES") {
                queue.push([i, j]);
            } else if (matrix[i][j] === "NO") {
                need += 1;
            }
        }
    }

    // 如果没有宜居区，则无法改造，直接返回-1
    if (queue.length === 0) {
        return -1;
    }
    // 如果全是宜居区，则无需改造，直接返回0
    else if (queue.length === row * col) {
        return 0;
    }

    // 记录花费的天数
    let day = 0;
    // 上，下，左，右四个方向的偏移量
    let offsets = [[-1, 0], [1, 0], [0, -1], [0, 1]];

    // 图的多源BFS模板
    while (queue.length > 0 && need > 0) {
        let newQueue = [];

        for (let [x, y] of queue) {
            for (let [offsetX, offsetY] of offsets) {
                // 上，下，左，右四个方向扩散
                let newX = x + offsetX;
                let newY = y + offsetY;

                // 如果新位置没有越界，且为NO，则可以被改造
                if (newX >= 0 && newX < row && newY >= 0 && newY < col && matrix[newX][newY] === "NO") {
                    matrix[newX][newY] = "YES";
                    newQueue.push([newX, newY]);
                    need -= 1;
                }
            }
        }

        day += 1;
        queue = newQueue;
    }

    if (need === 0) {
        return day;
    } else {
        return -1;
    }
}

let readline = require('readline');
let rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

let matrix = [];
rl.on('line', function (line) {
    let row = line.split(" ");
    matrix.push(row);
});

rl.on('close', function () {
    console.log(getResult(matrix));
});
塔子哥学算法
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【备战秋招】每日一题:2023.05-B卷-华为OD机试 - 矩阵稀疏扫描
m0_73659489的博客
06-19 1010
为了更好的阅读体检，可以查看我的算法学习博客。
【备战秋招】每日一题:2023.05-B卷-华为OD机试 - 通过软盘拷贝文件
m0_73659489的博客
07-14 167
为了更好的阅读体检，可以查看我的算法。
【备战秋招】每日一题:2023.05-B卷-华为OD机试 - 经典屏保
m0_73659489的博客
06-19 554
为了更好的阅读体检，可以查看我的算法学习博客。
【备战秋招】每日一题:2023.05-B卷-华为OD机试 - 告警抑制
m0_73659489的博客
06-16 350
2023大厂笔试模拟练习网站（含题解）最近我们一直在将收集到的各种大厂笔试的解题思路还原成题目并制作数据，挂载到我们的OJ上，供大家学习交流，体会笔试难度。现已录入200+道互联网大厂模拟练习题，还在极速更新中。欢迎关注公众号“塔子哥学算法”获取最新消息。提交链接:为了更好的阅读体检，可以查看OJ上的题解。进入提交链接，点击右边菜单栏的"查看塔子哥的题解"
【备战秋招】每日一题:2023.05-B卷-华为OD机试 - 模拟消息队列
m0_73659489的博客
06-20 405
为了更好的阅读体检，可以查看我的算法学习博客。
电子测量中的东方集成测试仪器携手华为备战W-CDMA
11-22
一个可以作为佐证的事实是，华为公司日前储备了近400台的手机生产测试仪器，备战W-CDMA项目。据华为在测试仪器领域的合作伙伴东方集成透露，华为为新的手机项目准备600台到800台手机综测仪，其中一半将由中国测试...
2010-2013华为历年笔试题大汇总-31.pdf
06-08
"华为历年笔试题大汇总-31" 本资源汇总了华为历年来的笔试题目，涵盖了多种类型的岗位和...该资源汇总了华为历年来的笔试题，涵盖了多种类型的岗位和领域，能够帮助考生更好地备战华为笔试，提高自己的知识和技能。
H12-111-ENU HCIA-IoT考题.docx
10-22
HCIA-IoT是由华为公司提供的一种认证考试，旨在评估考生的ICT技术知识和技能，特别是在物联网领域。该考试涵盖了物联网技术的各个方面，包括5G、NB-IoT、物联网架构、数据处理和分析等。 二、HCIA-IoT考试大纲 ...
竞赛资料源码-备战2021“华为杯”研究生数学建模竞赛.zip
01-25
教育部认可的大学生竞赛备赛资料代码，源码，竞赛总结，所有源码均经过严格测试，可以直接运行，可以放心下载使用。有任何使用问题欢迎随时与博主沟通 数学建模、全国电子设计大赛、全国大学生智能汽车竞赛、蓝桥杯...
竞赛资料源码-备战2020第十一届蓝桥杯大赛.zip
01-25
教育部认可的大学生竞赛备赛资料代码，源码，竞赛总结，所有源码均经过严格测试，可以直接运行，可以放心下载使用。有任何使用问题欢迎随时与博主沟通 全国电子设计大赛、全国大学生智能汽车竞赛、蓝桥杯、集成电路...
华为OD机考题HJ1 字符串最后一个单词的长度
磐门的博客
06-13 419
计算字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000。（注：字符串末尾不以空格为结尾）
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 停车场车位统计(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-15 108
K小姐经营着一个特定大小的停车场，停车场可以看成一个数组 $cars[]$，其中 $1$ 表示有车，$0$ 表示没车。现在停车场内停放着大小不一的车辆，其中小车占一个车位(长度 $1$)，货车占两个车位(长度 $2$)，卡车占三个车位(长度 $3$)。 K小姐想知道，按照当前停车场的停放情况，最少有多少辆车停在停车场内。你能帮帮她吗？ ### 输入描述 输入一个由 $0$ 和 $1$ 组成的字符串，以逗号分隔，表示停车场的车位情况。其中 $1$ 表示有车，$0$ 表示没车，字符串长度不超过 $1000
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 目录管理器(200分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-15 94
🍭 大家好这里是，一枚热爱算法的程序员✨ 本系列打算持续跟新的三语言AC题解💻 ACM银牌🥈| 多次AK大厂笔试 ｜ 编程一对一辅导。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 生成哈夫曼树(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-15 222
LYA 是一名计算机专业的学生,最近她学习了哈夫曼编码。为了巩固知识,她决定写一个程序来生成哈夫曼树。 给定一个长度为 $n$ 的正整数数组,每个数字代表二叉树叶子节点的权值。请你帮助 LYA 生成一棵哈夫曼树,并将其按中序遍历的顺序输出。 为了保证输出的哈夫曼树唯一,需要满足以下条件: 1. 树中每个非叶子节点的权值等于其左右子节点权值之和。 2. 对于权值相同的两个节点,左子树的高度应小于等于右子树的高度。 3. 在满足上述条件的前提下,左子节点的权值应小于等于右子节点的权值。 ### 输
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 启动多任务排序(200分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-15 175
卢小姐在开发一个应用程序，启动时需要执行多个初始化任务。这些任务之间可能存在依赖关系，例如任务 𝐴 A 依赖任务 𝐵 B，那么必须在任务 𝐵 B 执行完成之后，才能开始执行任务 𝐴 A。现在给出多条任务依赖关系的规则，请输出任务的执行顺序。规则采用贪心策略，即如果一个任务没有依赖的任务，则立即开始执行；如果同时有多个任务可以执行，则按照任务名称的字母顺序排序。 例如，如果任务 𝐵 B 依赖任务 𝐴 A，任务 𝐶 C 依赖任务 𝐴 A，任务 𝐷 D 依赖任务 𝐵 B
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 特惠寿司(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-15 286
LYA 去一家寿司店吃饭，店里正在举办优惠活动。转盘上有 $n$ 盘寿司，第 $i$ 盘寿司的价格为 $prices[i]$。如果 LYA 选择第 $i$ 盘寿司，店家会免费赠送距离第 $i$ 盘寿司最近的下一盘价格更低的寿司 $j$（即 $prices[j] < prices[i]$）。如果不存在这样的寿司 $j$，则不赠送。每种价格的寿司数量无限。请问 LYA 选择每盘寿司，最终实际得到的寿司总价格分别是多少？ ### 输入格式 输入一行，包含 $n$ 个空格分隔的正整数，表示 $n$ 盘寿司的价格
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] URL拼接(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-16 147
### 问题描述 给定一个 $url$ 的前缀和后缀，需要将它们拼接成一个完整的 $url$。拼接规则如下： 1. 如果前缀的结尾和后缀的开头都没有 `'/'`，需要自动在中间补上 `'/'` 连接符。 2. 如果前缀的结尾和后缀的开头都为 `'/'`，需要自动去重，即只保留一个 `'/'`。 Tips: 不用考虑前后缀 $url$ 不合法的情况。 ### 输入格式 输入一行，包含两个字符串，表示 $url$ 的前缀和后缀，两个字符串之间用英文逗号 `','` 分隔。 ### 输出格式 输出一
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 连续字母长度(100分) - 三语言AC题解(Python/Java/Cpp)
最新发布
清隆学长的博客
06-20 455
### 问题描述 K小姐有一个只包含大写字母的字符串，她想知道在所有包含同一字母的子串中，长度第 $k$ 大的子串的长度是多少。注意，对于相同字母，只考虑最长的那个子串。 ### 输入格式 第一行输入一个字符串 $s$，字符串长度满足 $1 < |s| \le 10^5$，且只包含大写字母。 第二行输入一个整数 $k$，表示要求的子串长度的排名。 ### 输出格式 输出一个整数，表示第 $k$ 长的子串的长度。如果不存在第 $k$ 长的子串，则输出 $-1$。 ###
【代码随想录】【算法训练营】【第39天】 [62]不同路径 [63]不同路径II [343]整数拆分 [96]不同的二叉搜索树
weixin_54954007的博客
06-15 795
思路及算法思维，指路。题目来自。day 39，周六，坚持不住了~
华为od机试 数大雁
08-01
华为OD机试 数大雁是华为公司招聘流程中的其中一项测试环节，用于考察应聘者在编程方面的能力。该笔试主要考察的是计算机基础知识和编程实战能力。 华为OD机试题目通常由一系列算法编程题组成，其中涵盖了数据结构...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

塔子哥学算法

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值