【备战秋招】每日一题:2023.05-B卷-华为OD机试 - 寻找最大价值的矿堆

最新推荐文章于 2024-03-13 01:21:21 发布

塔子哥学算法

最新推荐文章于 2024-03-13 01:21:21 发布

阅读量260

点赞数

文章标签：华为od 深度优先算法华为编辑器 struts

本文链接：https://blog.csdn.net/m0_73659489/article/details/131743225

版权

22/23华为最新真题专栏专栏收录该内容

29 篇文章 3 订阅

订阅专栏

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

题目描述

给你一个由’ $0$ ’(空地)、‘ $1$ ’(银矿)、' $2$ ’金矿)组成的的地图，矿堆只能由上下左右相邻的金矿或银矿连接形成。超出地图范围可以认为是空地。

假设银矿价值 $1$ ，金矿价值 $2$ ，请你找出地图中最大价值的矿堆并输出该矿堆的价值.

输入描述

地图元素信息如:

地图范围最大 $300 * 300$
- $\leq 地图元素 \leq 2$

输出描述

矿堆的最大价值

样例

输入

输出

说明

无

输入

输出

说明

无

输入

输出

说明

无

思路

首先，我们发现题目的意思就是求所有矿堆的最大权值，然后我们发现矿堆这一个概念和图论中的联通块概念一样。因此这道题本质就是去求一张图中权值最大的联通块。而所谓的图便是题目给的包含012三个矿石的无向图（因为任意相邻两点都可以相互到达，所以是无向图）。

如何建图：

我们可以把0权值的点当作不可到达的点，即任何点都不存在与0权值节点的边。其他权值的点由于存在上下左右四个方向，因此，对于四个方向权值非0的点连接一条边。最后，按照这个建图方式即可建立一整张图。然而我们发现，题目给的数据其实我们已经可以认为建图完成了，只要后续遍历遇到权值为0的点跳过即可。

无向图求联通块思路：

无向图求联通块我们可以使用 $df s$ 。我们可以想象一下，对于无向图，一次 $df s$ 其实就正好遍历完一个联通块，因此，为了求得所有的联通块权值，我们就需要对所有联通块进行 $df s$ 。

在 $df s$ 的过程中，如何求得联通块的权值？很明显，我们只要知道遍历了哪些点，然后统计总权值即可。因此，dfs的目的只是在于遍历联通块所有的点。然而，图上 $df s$ 存在一个问题，就是一个点可能被多次 $df s$ 到(比如点 $(x, y)$ 可以 $df s$ 到 $(x + 1, y)$ ,点 $(x + 2, y)$ 也可以 $df s$ 到 $(x + 1, y)$ )，因此，我们需要改善我们的搜索策略，对于已经遍历过的点直接跳过(比如点 $(x, y)$ 可以 $df s$ 到 $(x + 1, y)$ 过后,下次点 $(x + 2, y)$ 也 $df s$ 到 $(x + 1, y)$ 时直接 $re t u r n$ )，这样，我们可以保证一张连通图的所有点都只会被遍历一次，与此同时，由于只遍历一次，我们求总权值就可以直接将所有的权值加起来即可。

类似题目推荐

代码

C++

#include <iostream>
#include <vector>
using namespace std;

vector<vector<int>> arr;
int n, m;

int dfs(int x, int y) {
    if (arr[x][y] == 0) {//如果遇到走不通的路，就跳过
        return 0;
    }
    int ans = arr[x][y];//记录一个联通块的所有权值和
    arr[x][y] = 0;//通过这个操作，并结合上面的return，可以使得一个联通块的有权值的点只会被统计一次
    vector<pair<int, int>> dir = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};//四个方向
    for (auto d : dir) {
        int fx = d.first, fy = d.second;
        int xx = fx + x, yy = fy + y;//目标点(xx,yy)
        if (0 <= xx && xx < n && 0 <= yy && yy < m) {//合法
            ans += dfs(xx, yy);//就进行dfs，统计点(xx,yy)的权值，我们发现，如果(xx,yy)的权值已经被记录到ans里，那么dfs(xx,yy)的值等于0，这配合return就可以实现ans=sum(联通块)
        }
    }
    return ans;
}

int main() {
    string line;
    while(cin >> line){
        vector<int> ls;
        for (char c : line) {
            ls.push_back(c - '0');
        }
        arr.push_back(ls);
    }//二维矩阵建图，图里存的都是整数0，1，2

    n = arr.size();
    m = arr[0].size();
    int res = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            res = max(res, dfs(i, j));//找联通块，并且查找最大值
        }
    }

    cout << res << endl;
    return 0;
}

python

import sys
sys.setrecursionlimit(10000)

def dfs(x, y):
    if arr[x][y] == 0:#如果遇到走不通的路，就跳过
        return 0
    ans = arr[x][y]#记录一个联通块的所有权值和
    arr[x][y] = 0#通过这个操作，并结合上面的return，可以使得一个联通块的有权值的点只会被统计一次
    dir = [[1, 0], [0, 1], [-1, 0], [0, -1]]#四个方向
    for fx, fy in dir:
        xx, yy = fx + x, fy + y#目标点(xx,yy)
        if 0 <= xx < n and 0 <= yy < m:#合法
            ans += dfs(xx, yy)#就进行dfs，统计点(xx,yy)的权值，我们发现，如果(xx,yy)的权值已经被记录到ans里，那么dfs(xx,yy)的值等于0，这配合return就可以实现ans=sum(联通块)
    return ans


arr = []
for line in sys.stdin:
    ls = list(line.strip())
    if len(ls) != 0: arr.append(ls)

n = len(arr)
m = len(arr[0])
for i in range(n):
    for j in range(m):
        arr[i][j] = int(arr[i][j])#二维矩阵建图，图里存的都是整数0，1，2

res = 0
for i in range(n):
    for j in range(m):
        res = max(res, dfs(i, j))#找联通块，并且查找最大值

print(res)

Java

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {
    static List<List<Integer>> arr;
    static int n, m;

    static int dfs(int x, int y) {
        if (arr.get(x).get(y) == 0) {//如果遇到走不通的路，就跳过
            return 0;
        }
        int ans = arr.get(x).get(y);//记录一个联通块的所有权值和
        arr.get(x).set(y, 0);//通过这个操作，并结合上面的return，可以使得一个联通块的有权值的点只会被统计一次
        int[][] dir = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};//四个方向
        for (int[] d : dir) {
            int fx = d[0], fy = d[1];
            int xx = fx + x, yy = fy + y;//目标点(xx,yy)
            if (0 <= xx && xx < n && 0 <= yy && yy < m) {//合法
                ans += dfs(xx, yy);//就进行dfs，统计点(xx,yy)的权值，我们发现，如果(xx,yy)的权值已经被记录到ans里，那么dfs(xx,yy)的值等于0，这配合return就可以实现ans=sum(联通块)
            }
        }
        return ans;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        arr = new ArrayList<>();
        while (scanner.hasNextLine()) {
            String line = scanner.nextLine().trim();
            if (line.length() == 0) {
                continue;
            }
            List<Integer> ls = new ArrayList<>();
            for (char c : line.toCharArray()) {
                ls.add(c - '0');
            }
            arr.add(ls);//二维矩阵建图，图里存的都是整数0，1，2
        }

        n = arr.size();
        m = arr.get(0).size();
        int res = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                res = Math.max(res, dfs(i, j));//找联通块，并且查找最大值
            }
        }

        System.out.println(res);
    }
}

Go

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

var arr [][]int
var n, m int

func dfs(x, y int) int {
	if arr[x][y] == 0 {//如果遇到走不通的路，就跳过
		return 0
	}
	ans := arr[x][y]//记录一个联通块的所有权值和
	arr[x][y] = 0//通过这个操作，并结合上面的return，可以使得一个联通块的有权值的点只会被统计一次
	dir := [4][2]int{{1, 0}, {0, 1}, {-1, 0}, {0, -1}}//四个方向
	for _, d := range dir {
		fx, fy := d[0], d[1]
		xx, yy := fx+x, fy+y//目标点(xx,yy)
		if 0 <= xx && xx < n && 0 <= yy && yy < m {//合法
			ans += dfs(xx, yy)//就进行dfs，统计点(xx,yy)的权值，我们发现，如果(xx,yy)的权值已经被记录到ans里，那么dfs(xx,yy)的值等于0，这配合return就可以实现ans=sum(联通块)
		}
	}
	return ans
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	for scanner.Scan() {
		line := scanner.Text()
		if len(line) == 0 {
			continue
		}
		ls := make([]int, len(line))
		for i, c := range line {
			ls[i], _ = strconv.Atoi(string(c))
		}
		arr = append(arr, ls)//二维矩阵建图，图里存的都是整数0，1，2
	}

	n = len(arr)
	m = len(arr[0])
	res := 0
	for i := 0; i < n; i++ {
		for j := 0; j < m; j++ {
			res = max(res, dfs(i, j))//找联通块，并且查找最大值
		}
	}

	fmt.Println(res)
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

Js

/* JavaScript Node ACM模式 控制台输入获取 */
const readline = require("readline");
 
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});
 
const lines = [];
// 地图矩阵
let matrix;
rl.on("line", (line) => {
  lines.push(line);
 
  // 由于本题没有说明输入截止条件，因此使用空行作为输入截止条件
  if (line == "") {
    matrix = lines.map((s) => [...s].map(Number));
    console.log(getResult(matrix));
    lines.length = 0;
  }
});
 
// 记录地图矩阵的行数row，列数col
let row, col;
 
function getResult(matrix) {
  // 记录地图矩阵的行数row
  row = matrix.length;
  if (row == 0) return 0;
 
  // 记录地图矩阵的列数col
  col = matrix[0].length;
 
  // 记录最大矿堆价值
  let ans = 0;
 
  // 遍历矩阵元素
  for (let i = 0; i < row; i++) {
    for (let j = 0; j < col; j++) {
      if (matrix[i][j] > 0) {
        ans = Math.max(ans, dfs(i, j));
      }
    }
  }
 
  return ans;
}
 
// 上下左右，四个方向的偏移量
const offsets = [
  [-1, 0],
  [1, 0],
  [0, -1],
  [0, 1],
];
 
function dfs(x, y) {
  const stack = [[x, y]];
  let sum = 0;
 
  while (stack.length > 0) {
    const [x, y] = stack.pop();
 
    sum += matrix[x][y];
    matrix[x][y] = 0;
 
    for (let offset of offsets) {
      const newX = x + offset[0];
      const newY = y + offset[1];
 
      if (
        newX >= 0 &&
        newX < row &&
        newY >= 0 &&
        newY < col &&
        matrix[newX][newY] > 0
      ) {
        stack.push([newX, newY]);
      }
    }
  }
 
  return sum;
}