华为OD面试手撕真题-岛屿数量[超高频]（C++ | Java | Python3 | Js | Go）实现

于 2024-08-25 00:21:49 发布
阅读量4 收藏
点赞数
分类专栏： 华为OD面试手撕真题 文章标签： 华为od
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42433507/article/details/141499729
版权

题目来源：力扣200

给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。

岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。

此外，你可以假设该网格的四条边均被水包围。

示例 1：

输入：grid = [
  ["1","1","1","1","0"],
  ["1","1","0","1","0"],
  ["1","1","0","0","0"],
  ["0","0","0","0","0"]
]
输出：1

示例 2：

输入：grid = [
  ["1","1","0","0","0"],
  ["1","1","0","0","0"],
  ["0","0","1","0","0"],
  ["0","0","0","1","1"]
]
输出：3

提示：

  • m == grid.length
  • n == grid[i].length
  • 1 <= m, n <= 300
  • grid[i][j] 的值为 '0' 或 '1'

思路：将二维网格看成一个无向图，竖直或水平相邻的 1 之间有边相连。为了求出岛屿的数量，我们可以扫描整个二维网格。如果一个位置为 1，则以其为起始节点开始进行深度优先搜索。在深度优先搜索的过程中，每个搜索到的 1 都会被重新标记为 0。最终岛屿的数量就是进行深度优先搜索的次数。

解析：

  1. DFS 函数 dfs

    • 参数：grid 代表二维网格，i 和 j 代表当前网格位置的行列索引。
    • 检查当前索引是否超出边界：如果 i 或 j 小于 0，或者大于等于网格的大小，则直接返回。
    • 检查当前位置是否为水（'0'）：如果是，则直接返回。
    • 将当前位置标记为已访问（变为 '0'）。
    • 递归调用 dfs 函数，分别访问上下左右四个相邻的位置。

  2. 计算岛屿的数量函数 numIslands

    • 参数：grid 代表二维网格。
    • 初始化岛屿计数器 c 为 0。
    • 使用双层循环遍历网格的每个位置。
    • 如果找到一个新的土地（'1'），调用 dfs 函数进行标记，并将岛屿计数器 c 加 1。
    • 返回岛屿的总数 c。

  3. 主函数 main

    • 声明并初始化两个示例网格 grid1 和 grid2。
    • 分别调用 numIslands 函数计算两个网格中的岛屿数量，并输出结果。

C++

#include<bits/stdc++.h>
using namespace std;

// 深度优先搜索 (DFS) 算法
void dfs(vector<vector<char>>& grid, int i, int j) {
    // 如果索引超出网格范围，则返回
    if (i < 0 || j < 0) {
        return;
    }
    if (i >= grid.size() || j >= grid[0].size()) {
        return;
    }

    // 如果当前位置是水 ('0')，则返回
    if (grid[i][j] == '0') {
        return;
    }

    // 将当前土地标记为已访问过（变为 '0'）
    grid[i][j] = '0';

    // 递归地访问四个方向的相邻土地
    dfs(grid, i + 1, j); // 向下
    dfs(grid, i, j + 1); // 向右
    dfs(grid, i - 1, j); // 向上
    dfs(grid, i, j - 1); // 向左
}

// 计算岛屿的数量
int numIslands(vector<vector<char>>& grid) {
    int c = 0; // 岛屿计数器
    // 遍历网格中的每个元素
    for (int i = 0; i < grid.size(); i++) {
        for (int j = 0; j < grid[0].size(); j++) {
            // 如果找到一个新的岛屿（未访问过的土地 '1'）
            if (grid[i][j] == '1') {
                dfs(grid, i, j); // 使用DFS将整个岛屿标记为已访问
                c++; // 岛屿计数 +1
            }
        }
    }
    return c; // 返回岛屿的总数
}

int main() {
    // 示例网格 1
    vector<vector<char>> grid1 = {
        {'1', '1', '1', '1', '0'},
        {'1', '1', '1', '1', '0'},
        {'1', '1', '0', '0', '0'},
        {'0', '0', '0', '0', '0'}
    };
    
    // 计算并输出网格 1 中的岛屿数量
    int res1 = numIslands(grid1);
    cout << res1 << endl;

    // 示例网格 2
    vector<vector<char>> grid2 = {
        {'1', '1', '0', '0', '0'},
        {'1', '1', '0', '0', '0'},
        {'0', '0', '1', '0', '0'},
        {'0', '0', '0', '1', '1'}
    };

    // 计算并输出网格 2 中的岛屿数量
    int res2 = numIslands(grid2);
    cout << res2 << endl;

    return 0; // 程序结束
}

Java 

import java.util.*;

public class Main {

    // 深度优先搜索 (DFS) 算法
    public static void dfs(char[][] grid, int i, int j) {
        // 如果索引超出网格范围，则返回
        if (i < 0 || j < 0 || i >= grid.length || j >= grid[0].length) {
            return;
        }

        // 如果当前位置是水 ('0')，则返回
        if (grid[i][j] == '0') {
            return;
        }

        // 将当前土地标记为已访问过（变为 '0'）
        grid[i][j] = '0';

        // 递归地访问四个方向的相邻土地
        dfs(grid, i + 1, j); // 向下
        dfs(grid, i, j + 1); // 向右
        dfs(grid, i - 1, j); // 向上
        dfs(grid, i, j - 1); // 向左
    }

    // 计算岛屿的数量
    public static int numIslands(char[][] grid) {
        int c = 0; // 岛屿计数器
        // 遍历网格中的每个元素
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                // 如果找到一个新的岛屿（未访问过的土地 '1'）
                if (grid[i][j] == '1') {
                    dfs(grid, i, j); // 使用DFS将整个岛屿标记为已访问
                    c++; // 岛屿计数 +1
                }
            }
        }
        return c; // 返回岛屿的总数
    }

    // 主函数
    public static void main(String[] args) {
        // 示例网格 1
        char[][] grid1 = {
            {'1', '1', '1', '1', '0'},
            {'1', '1', '1', '1', '0'},
            {'1', '1', '0', '0', '0'},
            {'0', '0', '0', '0', '0'}
        };

        // 计算并输出网格 1 中的岛屿数量
        int res1 = numIslands(grid1);
        System.out.println(res1);

        // 示例网格 2
        char[][] grid2 = {
            {'1', '1', '0', '0', '0'},
            {'1', '1', '0', '0', '0'},
            {'0', '0', '1', '0', '0'},
            {'0', '0', '0', '1', '1'}
        };

        // 计算并输出网格 2 中的岛屿数量
        int res2 = numIslands(grid2);
        System.out.println(res2);
    }
}

Python3

def dfs(grid, i, j):
    """
    深度优先搜索 (DFS) 算法
    :param grid: 二维网格
    :param i: 当前行索引
    :param j: 当前列索引
    """
    # 如果索引超出网格范围，则返回
    if i < 0 or j < 0 or i >= len(grid) or j >= len(grid[0]):
        return

    # 如果当前位置是水 ('0')，则返回
    if grid[i][j] == "0":
        return

    # 将当前土地标记为已访问过（变为 '0'）
    grid[i][j] = "0"

    # 递归地访问四个方向的相邻土地
    dfs(grid, i + 1, j)  # 向下
    dfs(grid, i, j + 1)  # 向右
    dfs(grid, i - 1, j)  # 向上
    dfs(grid, i, j - 1)  # 向左


def numIslands(grid):
    """
    计算岛屿的数量
    :param grid: 二维网格
    :return: 岛屿的数量
    """
    c = 0  # 岛屿计数器
    # 遍历网格中的每个元素
    for i in range(len(grid)):
        for j in range(len(grid[0])):
            # 如果找到一个新的岛屿（未访问过的土地 '1'）
            if grid[i][j] == "1":
                dfs(grid, i, j)  # 使用DFS将整个岛屿标记为已访问
                c += 1  # 岛屿计数 +1
    return c  # 返回岛屿的总数


# 主函数
if __name__ == "__main__":
    # 示例网格 1
    grid1 = [
        ["1", "1", "1", "1", "0"],
        ["1", "1", "1", "1", "0"],
        ["1", "1", "0", "0", "0"],
        ["0", "0", "0", "0", "0"],
    ]

    # 计算并输出网格 1 中的岛屿数量
    res1 = numIslands(grid1)
    print(res1)

    # 示例网格 2
    grid2 = [
        ["1", "1", "0", "0", "0"],
        ["1", "1", "0", "0", "0"],
        ["0", "0", "1", "0", "0"],
        ["0", "0", "0", "1", "1"],
    ]

    # 计算并输出网格 2 中的岛屿数量
    res2 = numIslands(grid2)
    print(res2)

JsNode 

function dfs(grid, i, j) {
    // 如果索引超出网格范围，则返回
    if (i < 0 || j < 0 || i >= grid.length || j >= grid[0].length) {
        return;
    }

    // 如果当前位置是水 ('0')，则返回
    if (grid[i][j] === '0') {
        return;
    }

    // 将当前土地标记为已访问过（变为 '0'）
    grid[i][j] = '0';

    // 递归地访问四个方向的相邻土地
    dfs(grid, i + 1, j); // 向下
    dfs(grid, i, j + 1); // 向右
    dfs(grid, i - 1, j); // 向上
    dfs(grid, i, j - 1); // 向左
}

function numIslands(grid) {
    let c = 0; // 岛屿计数器
    // 遍历网格中的每个元素
    for (let i = 0; i < grid.length; i++) {
        for (let j = 0; j < grid[0].length; j++) {
            // 如果找到一个新的岛屿（未访问过的土地 '1'）
            if (grid[i][j] === '1') {
                dfs(grid, i, j); // 使用DFS将整个岛屿标记为已访问
                c++; // 岛屿计数 +1
            }
        }
    }
    return c; // 返回岛屿的总数
}

// 示例网格 1
let grid1 = [
    ['1', '1', '1', '1', '0'],
    ['1', '1', '1', '1', '0'],
    ['1', '1', '0', '0', '0'],
    ['0', '0', '0', '0', '0']
];

// 计算并输出网格 1 中的岛屿数量
let res1 = numIslands(grid1);
console.log(res1);

// 示例网格 2
let grid2 = [
    ['1', '1', '0', '0', '0'],
    ['1', '1', '0', '0', '0'],
    ['0', '0', '1', '0', '0'],
    ['0', '0', '0', '1', '1']
];

// 计算并输出网格 2 中的岛屿数量
let res2 = numIslands(grid2);
console.log(res2);

Go

package main

import (
	"fmt"
)

// 深度优先搜索 (DFS) 算法
func dfs(grid [][]byte, i, j int) {
	// 如果索引超出网格范围，则返回
	if i < 0 || j < 0 || i >= len(grid) || j >= len(grid[0]) {
		return
	}

	// 如果当前位置是水 ('0')，则返回
	if grid[i][j] == '0' {
		return
	}

	// 将当前土地标记为已访问过（变为 '0'）
	grid[i][j] = '0'

	// 递归地访问四个方向的相邻土地
	dfs(grid, i+1, j) // 向下
	dfs(grid, i, j+1) // 向右
	dfs(grid, i-1, j) // 向上
	dfs(grid, i, j-1) // 向左
}

// 计算岛屿的数量
func numIslands(grid [][]byte) int {
	c := 0 // 岛屿计数器
	// 遍历网格中的每个元素
	for i := 0; i < len(grid); i++ {
		for j := 0; j < len(grid[0]); j++ {
			// 如果找到一个新的岛屿（未访问过的土地 '1'）
			if grid[i][j] == '1' {
				dfs(grid, i, j) // 使用DFS将整个岛屿标记为已访问
				c++             // 岛屿计数 +1
			}
		}
	}
	return c // 返回岛屿的总数
}

func main() {
	// 示例网格 1
	grid1 := [][]byte{
		{'1', '1', '1', '1', '0'},
		{'1', '1', '1', '1', '0'},
		{'1', '1', '0', '0', '0'},
		{'0', '0', '0', '0', '0'},
	}

	// 计算并输出网格 1 中的岛屿数量
	res1 := numIslands(grid1)
	fmt.Println(res1)

	// 示例网格 2
	grid2 := [][]byte{
		{'1', '1', '0', '0', '0'},
		{'1', '1', '0', '0', '0'},
		{'0', '0', '1', '0', '0'},
		{'0', '0', '0', '1', '1'},
	}

	// 计算并输出网格 2 中的岛屿数量
	res2 := numIslands(grid2)
	fmt.Println(res2)
}

梅花C
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
题解 | #nginx日志分析5-统计爬虫抓取404的次数#
华鑫的专栏
03-02 877
现实，确是这样的无情，计算机行业尤其是互联网企业，曾经的金饭碗、香饽饽，随便可以。今天做了vivo的暑期实习测评，进去一看这不就是考公的行测么，难点在于每个题都是限时的，感觉这种要是没练过考公的不好做呀，我就说咋去年一堆人吐槽测评，今年当应届。想问下，我三次投递momenta，一面coding都过了，面试官评价都很好，二面问的都是项目回答的也很好，为什么都挂了，最后一次我忍不住问hr，hr说也不知道为。今天更一下前天（2.29）面的一家公司的面经，然后昨天是接到offer了，不包吃住，早9晚5。
华为OD机考-统一考试机试-含ABCD卷-含java、c++、JavaScript、python-题目
01-18
这个压缩包包含了四个部分，分别标记为ABCD卷，涵盖了四种编程语言：Java、C++、JavaScript和Python。这些语言在现代软件开发中扮演着重要角色，尤其在后端开发、前端开发以及数据分析等领域。 首先，Java是一种...
题解 | #二叉树的镜像#原来&amp；&amp；改成||就能对
han_xue_feng的博客
03-14 920
合肥双非一本，大学做的比赛项目都是C++纯软件的，拿了几个国一省一的奖，也想找这方面。这个岗位值得去吗，有没有发展前景，来学校直招的，投的Java被调剂了，面试也挺基础的，不知道要不要去但薪资比秋招拿的offer高，新大陆平台也大引流：#新大陆#作为一名前程序员，在快手干了4年，深感大厂底层劳动人民的无力和麻木，于是在去年底告别了这个行业。#简历# #实习# 题主成绩不好，在有推免优惠政策的情况下靠着竞赛加分才差不多能保研，大学前三年从不会想以后要干什么，去哪里读研，出来就业选什么方向，去哪里工作。
基于Python的华为OD算法面试题-Huawei-OD-Python-master
05-24
基于Python的华为OD算法面试题——Huawei-OD-Python-master。 本项目主要基于Python语言，使用很多Python语言的标准库，希望大家能通过题目，更好地熟悉Python语法，并灵活运用语法特性。 在推荐资料部分，给出了...
华为OD机试C卷- 模拟数据序列化传输（Java & JS & Python & C & C++）.md-私信看全套
06-09
题目中提到的编程语言包括 Java、JavaScript、Python、C 和 C++。这里将主要介绍 Java 和 Python 的实现方案。 #### 解决方案 ##### Java 实现 下面展示了 Java 语言下的编码和解码实现。 ```java import java....
华为OD机试C卷- 数字排列（Java & JS & Python & C & C++）.md-私信看全套OD代码及
06-09
### 华为OD机试C卷 - 数字排列（多语言实现） #### 题目背景 本题目属于华为OD机试中的一道经典题目，旨在考察应聘者对递归算法的理解及其应用能力，同时也涉及到了字符串处理和数据结构的应用。 #### 题目概述 ...
华为OD机试C卷- 伐木工（Java & JS & Python & C & C++）.md-私信看全套OD代码及解析
06-09
### 华为OD机试C卷 - 伐木工题目详解与实现 #### 题目背景 在软件开发行业中，特别是在技术岗位的面试中，动态规划问题是常考的难点之一。华为作为全球领先的信息与通信技术解决方案提供商，其招聘过程中会设计一...
人力安排（华为od机考题）
qq_57223586的博客
08-20 1003
部门在进行需求开发时需要进行人力安排。当前部门需要完成N个需求，需求用requirements[]表示，requirements[i]表示第i个需求的工作量大小，单位：人/月。这部分需求需要在M个月内完成开发，进行人力安排后每个月的人力是固定的。目前要求每个月最多有2个需求开发，并且每个月需要完成的需求不能超过部门人力。请帮部门评估在满足需求开发进度的情况下，每个月需要的最小人力是多少？
华为OD题目 csv格式的数据 字符串 用C没写出来
weixin_39257775的博客
08-21 355
第一个单元中有对B单元的引用，B单元格的值为1，替换时，将第二个数据单元的内容替代<B>的位置，并和其他内容合并。第二个单元中有对A单元的引用，A单元格的值为1，替换时，将A单元的内容替代<A>的位置，并和其他内容合并。2. 每个单元格的内容包含字母和数字，以及使用<>分隔的单元格引用，例如：<A>表示引用第一个单元的值。将一个csv格式的数据文件中包含有单元格引用的内容替换为对应单元格内容的实际值。5. 引用单元格的位置不受限制，运行排在后面的单元格被排在前面的单元格引用。A单元格：aCd<B>8u。
跳马（华为od机考题）
qq_57223586的博客
08-24 377
马是象棋(包括中国象棋和国际象棋)中的棋子，走法是每步直一格再斜一格，即先横着或直着走一格，然后再斜着走一个对角线，可进可退，可越过河界，俗称“马走‘日’字。给顶m行n列的棋盘（网格图），棋盘上只有有棋子象棋中的棋子“马”，并且每个棋子有等级之分，等级为k的马可以跳1~k步（走的方式与象棋中“马”的规则一样，不可以超出棋盘位置），问是否能将所有马跳到同一位置，如果存在，输出最少需要的总步数（每匹马的步数相加），不存在则输出-1。
华为od（D卷） 堆内存申请
Json_Steve的博客
08-21 323
堆中已使用的两块内存是偏移从0开始的1字节和偏移从3开始的2字节，空闲的两块内存是偏移从1开始2个字节和偏移从5开始95字节根据分配原则，新申请的内存应从1开始分配1个字节，所以输出偏移为1。有一个总空间为100字节的堆，现要从中新申请一块内存，内存分配原则为:优先分配紧接着前一块已使用的内存，分配空间足够时分配最接近申请大小的空闲内存。表示0偏移地址开始的1个字节和3偏移地址开始的2个字节已被分配，其余内存空闲。第1行是1个整数，表示期望申请的内存字节数。若申请成功，输出申请到内存的偏移。
华为od（D卷） 用连续自然数之和来表达整数
Json_Steve的博客
08-20 386
在每个测试数据结束时，输出一行”Result:X”，其中X是最终的表达式个数。给定一个整数，计算该整数有几种连续自然数之和的表达式，且打印出每种表达式。该整数的所有表达式和表达式的个数。每个表达式中按自然数递增的顺序输出，具体的格式参见样例。一个目标整数T (1 <=T<= 1000)一个整数可以由连续的自然数之和来表示。自然数个数最少的表达式优先输出。
华为od（D卷）火星文计算
Json_Steve的博客
08-20 283
火星人字符串表达式(结尾不带回车换行)输入的字符串说明: 字符串为仅由无符号整数和操作符 (#、$)组成的计算表达式例如: 123#4S5#67$78。3.火星人公式中，$的优先级高于#，相同的运算符，按从左到右的顺序计算。4.保证输入的字符串为合法的求值报文，例如: 123#4$5#67$78。12345678987654321$54321 //32 位整数计算溢出。3+4-5*6/7 //有其它操作符。#4$5 //缺少操作数。4$5# //缺少操作数。4#$5 //缺少操作数。4 $5 //有空格。
源代码-成语在线 ASP (生成html).zip
08-24
源代码-成语在线 ASP (生成html).zip 源代码-成语在线 ASP (生成html).zip 源代码-成语在线 ASP (生成html).zip 源代码-成语在线 ASP (生成html).zip 源代码-成语在线 ASP (生成html).zip 源代码-成语在线 ASP (生成html).zip 源代码-成语在线 ASP (生成html).zip
资源OpenCV3图像分割视频教程开发视频+文档+源码
最新发布
08-24
资源OpenCV3图像分割视频教程开发视频+文档+源码资源大小2G提取方式是百度网盘分享地址
申报书模板(1).zip
08-24
申报书模板(1).zip
新装windows系统各类安装维护组件
08-24
新装windows系统各类安装维护组件
网络爬虫+数据可视化_art_art_httpsdataxujing.github.i_IncomeAnalysis.zip
08-24
网络爬虫+数据可视化_art_art_httpsdataxujing.github.i_IncomeAnalysis
华为od机试真题-服务中心的最佳位置【2023q2】【java、python、c++】
12-25
首先，在选择服务中心的最佳位置时，我们需要考虑各种因素，包括人口密度、交通便利性、基础设施和竞争对手等。对于华为OD项目来说，我会推荐选址在人口密度相对较高的城市中心地带。这样可以确保服务中心能够覆盖到更多的用户群体，提高服务的便利性和覆盖面。 其次，交通便利性也是选择最佳位置的重要考量因素。一个位于交通枢纽地带的服务中心可以更容易地接触到周围城市的用户，减少用户的前往成本和时间。同时，也方便快速调度和配送产品，提高服务的效率和时效性。 此外，基础设施的完善也是一个重要的考虑因素。一个服务中心应该有稳定的电力、通讯和网络设施，以保证服务的持续性和稳定性。另外，周边商业设施和生活设施的配套也能吸引更多的顾客和员工，提高服务中心的吸引力和竞争力。 最后，对竞争对手的考虑也至关重要。在选择服务中心的位置时，需要做好竞争对手的地域分析，避免选择在竞争对手的聚集地带，同时也要考虑如何在竞争对手密集的区域提供更优质的服务和更吸引人的特色，以获得竞争优势。 综上所述，选择服务中心最佳位置需要全面考虑各种因素，包括人口密度、交通便利性、基础设施和竞争对手，这样才能确保服务中心能够更好地为用户提供服务，同时也能提高企业的竞争力和影响力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值