【代码随想录——图论——小岛问题】

于 2024-07-15 10:57:00 发布
阅读量247 收藏 1
点赞数 7
文章标签： 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45467608/article/details/140271880
版权

1.水流问题

在这里插入图片描述
使用两个visited数组即可。

1.1 DFS版

package main

import "fmt"

var direction = [][]int{{0, 1}, {0, -1}, {1, 0}, {-1, 0}}

func main() {
	var M, N int
	fmt.Scanln(&N, &M)
	sea := make([][]int, N)
	one_visited := make([][]bool, N)
	two_visited := make([][]bool, N)
	for i := 0; i < N; i++ {
		sea[i] = make([]int, M)
		one_visited[i] = make([]bool, M)
		two_visited[i] = make([]bool, M)
	}

	for i := 0; i < N; i++ {
		for j := 0; j < M; j++ {
			fmt.Scan(&sea[i][j])
		}
	}

	for i := 0; i < N; i++ {
		dfs(i, 0, N, M, &sea, &one_visited)
		dfs(i, M-1, N, M, &sea, &two_visited)
	}

	for j := 0; j < M; j++ {
		dfs(0, j, N, M, &sea, &one_visited)
		dfs(N-1, j, N, M, &sea, &two_visited)
	}

	for i := 0; i < N; i++ {
		for j := 0; j < M; j++ {
			if one_visited[i][j] && two_visited[i][j] {
				fmt.Printf("%d %d\n", i, j)
			}
		}
	}

}

func dfs(x, y, N, M int, sea *[][]int, visited *[][]bool) {
	if (*visited)[x][y] {
		return
	}
	(*visited)[x][y] = true

	for i := 0; i < 4; i++ {
		newX := x + direction[i][0]
		newY := y + direction[i][1]
		if newX < 0 || newX >= N || newY < 0 || newY >= M {
			continue
		}
		if (*sea)[newX][newY] > (*sea)[x][y] && !(*visited)[newX][newY] {
			dfs(newX, newY, N, M, sea, visited)
		}
	}
}

1.2 BFS版

package main

import "fmt"

var direction = [][]int{{0, 1}, {0, -1}, {1, 0}, {-1, 0}}

func main() {
	var M, N int
	fmt.Scanln(&N, &M)
	sea := make([][]int, N)
	one_visited := make([][]bool, N)
	two_visited := make([][]bool, N)
	for i := 0; i < N; i++ {
		sea[i] = make([]int, M)
		one_visited[i] = make([]bool, M)
		two_visited[i] = make([]bool, M)
	}

	for i := 0; i < N; i++ {
		for j := 0; j < M; j++ {
			fmt.Scan(&sea[i][j])
		}
	}

	for i := 0; i < N; i++ {
		bfs(i, 0, N, M, &sea, &one_visited)
		bfs(i, M-1, N, M, &sea, &two_visited)
	}

	for j := 0; j < M; j++ {
		bfs(0, j, N, M, &sea, &one_visited)
		bfs(N-1, j, N, M, &sea, &two_visited)
	}

	for i := 0; i < N; i++ {
		for j := 0; j < M; j++ {
			if one_visited[i][j] && two_visited[i][j] {
				fmt.Printf("%d %d\n", i, j)
			}
		}
	}

}
func bfs(x, y, N, M int, sea *[][]int, visited *[][]bool) int {
	if (*visited)[x][y] {
		return 0
	}
	queue := make([][2]int, 0)
	queue = append(queue, [2]int{x, y})
	(*visited)[x][y] = true
	area := 0
	for len(queue) != 0 {
		pos := queue[0]
		queue = queue[1:]
		area += 1
		for i := 0; i < 4; i++ {
			newX := pos[0] + direction[i][0]
			newY := pos[1] + direction[i][1]
			if newX < 0 || newX >= N || newY < 0 || newY >= M {
				continue
			}
			if (*sea)[newX][newY] > (*sea)[pos[0]][pos[1]] && !(*visited)[newX][newY] {
				queue = append(queue, [2]int{newX, newY})
				(*visited)[newX][newY] = true
			}
		}
	}
	return area
}

2.建造最大岛屿

在这里插入图片描述

package main

import "fmt"

var direction = [][]int{{0, 1}, {0, -1}, {1, 0}, {-1, 0}}
var M, N int

func main() {

	fmt.Scanln(&N, &M)
	sea := make([][]int, N)
	visited := make([][]bool, N)
	island := make(map[int]int, 0)
	for i := 0; i < N; i++ {
		sea[i] = make([]int, M)
		visited[i] = make([]bool, M)
	}

	for i := 0; i < N; i++ {
		for j := 0; j < M; j++ {
			fmt.Scan(&sea[i][j])
		}
	}

	isLandIndex := 1
	for i := 0; i < N; i++ {
		for j := 0; j < M; j++ {
			if sea[i][j] == 1 && !visited[i][j] {
				area := 0
				dfs(i, j, isLandIndex, &sea, &visited, &area)
				island[isLandIndex] = area
				isLandIndex += 1
			}
		}
	}
	maxArea := 1
	for _, area := range island {
		if area > maxArea {
			maxArea = area
		}
	}
	for i := 0; i < N; i++ {
		for j := 0; j < M; j++ {
			if sea[i][j] == 0 {
				//尝试在这里建造小岛
				area := 1
				connIsland := make([]int, 0)
				for k := 0; k < 4; k++ {
					newX := i + direction[k][0]
					newY := j + direction[k][1]
					if newX < 0 || newX >= N || newY < 0 || newY >= M {
						continue
					}
					if sea[newX][newY] != 0 && !isInList(sea[newX][newY], connIsland) {
						area += island[sea[newX][newY]]
						connIsland = append(connIsland, sea[newX][newY])
					}
				}
				if area > maxArea {
					maxArea = area
				}
			}
		}
	}
	//for key, value := range island {
	//	fmt.Printf("小岛编号：%d,小岛面积：%d \n", key, value)
	//}
	fmt.Println(maxArea)
}

func isInList(isLandIndex int, isLands []int) bool {
	for i := 0; i < len(isLands); i++ {
		if isLandIndex == isLands[i] {
			return true
		}
	}
	return false
}

func dfs(x, y, seaIndex int, sea *[][]int, visited *[][]bool, area *int) {
	(*visited)[x][y] = true
	(*sea)[x][y] = seaIndex
	*area = (*area) + 1
	for i := 0; i < 4; i++ {
		newX := x + direction[i][0]
		newY := y + direction[i][1]
		if newX < 0 || newX >= N || newY < 0 || newY >= M {
			continue
		}
		if (*sea)[newX][newY] == 1 && !(*visited)[newX][newY] {
			dfs(newX, newY, seaIndex, sea, visited, area)
		}
	}
}

3.字符串接龙

在这里插入图片描述

package main

import "fmt"

var N int
var beginStr, endStr string

func main() {
	fmt.Scanln(&N)
	fmt.Scanf("%s %s", &beginStr, &endStr)
	strList := make([]string, 0)
	strMap := make(map[string]int)
	strMap[beginStr] = 0
	strMap[endStr] = 1
	strList = append(strList, beginStr)
	strList = append(strList, endStr)
	strIndex := 2
	for i := 0; i < N; i++ {
		var tempStr string
		fmt.Scanln(&tempStr)
		strMap[tempStr] = strIndex
		strList = append(strList, tempStr)
		strIndex++
	}
	if beginStr == endStr {
		fmt.Println(0)
		return
	}
	m := make([][]int, N+2)
	for i := 0; i < N+2; i++ {
		m[i] = make([]int, N+2)
	}
	for i := 0; i < N+2; i++ {
		for j := i; j < N+2; j++ {
			if canTransfer(strList[i], strList[j]) {
				m[i][j] = 1
				m[j][i] = 1
			}
		}
	}

	//printMatrix(m)
	// 开启bfs
	step := bfs(0, 1, &m)
	fmt.Println(step)
}

func canTransfer(str1, str2 string) bool {
	diff := 0
	for i := 0; i < len(str1); i++ {
		if str1[i] != str2[i] {
			diff++
		}
	}
	return diff == 1
}

func bfs(beginIndex, endIndex int, m *[][]int) int {
	queue := make([]int, 0)
	tempQueue := make([]int, 0)
	queue = append(queue, beginIndex)
	strSet := make(map[int]struct{})
	strSet[beginIndex] = struct{}{}
	step := 1
	for len(queue) != 0 {
		nowIndex := queue[0]
		if nowIndex == endIndex {
			return step
		}
		queue = queue[1:]
		for i := 0; i < N+2; i++ {
			_, ok := strSet[i]
			if ok {
				continue
			}
			if (*m)[nowIndex][i] == 1 {
				tempQueue = append(tempQueue, i)
				//表示已经在队列中
				strSet[i] = struct{}{}
			}
		}
		if len(queue) == 0 {
			for i := 0; i < len(tempQueue); i++ {
				queue = append(queue, tempQueue[i])
			}
			tempQueue = make([]int, 0)
			step++
		}
	}
	return 0
}

4.有向图的完全可达性

在这里插入图片描述

package main

import "fmt"

var directions = [4][2]int{
	{0, 1},
	{0, -1},
	{1, 0},
	{-1, 0},
}
var N, M int

func main() {
	fmt.Scanln(&N, &M)
	m := make([][]int, N+1)
	visited := make([]bool, N+1)
	for i := 0; i < N+1; i++ {
		m[i] = make([]int, N+1)
	}
	for i := 0; i < M; i++ {
		var start, end int
		fmt.Scanln(&start, &end)
		m[start][end] = 1
	}
	//bfs
	reachCount := bfs(1, &visited, &m)
	if reachCount == N {
		fmt.Println(1)
	} else {
		fmt.Println(-1)
	}
}

func bfs(start int, visited *[]bool, m *[][]int) int {
	queue := make([]int, 0)
	queue = append(queue, start)
	(*visited)[start] = true
	reachCount := 1
	for len(queue) != 0 {
		now := queue[0]
		queue = queue[1:]
		for i := 1; i < N+1; i++ {
			if !(*visited)[i] && (*m)[now][i] == 1 {
				queue = append(queue, i)
				(*visited)[i] = true
				reachCount++
			}
		}
	}
	return reachCount
}

5.岛屿的周长

在这里插入图片描述

package main

import "fmt"

var directions = [4][2]int{
	{0, 1},
	{0, -1},
	{1, 0},
	{-1, 0},
}
var N, M int

func main() {
	fmt.Scanln(&N, &M)
	m := make([][]int, N)
	for i := 0; i < N; i++ {
		m[i] = make([]int, M)
	}
	for i := 0; i < N; i++ {
		for j := 0; j < M; j++ {
			fmt.Scan(&m[i][j])
		}
	}
	//遍历map并向四方探索
	result := 0
	for i := 0; i < N; i++ {
		for j := 0; j < M; j++ {
			if m[i][j] == 1 {
				result += getEdgeNum(i, j, &m)
			}
		}
	}
	fmt.Println(result)
}

func getEdgeNum(x, y int, m *[][]int) int {
	edge := 4
	for i := 0; i < 4; i++ {
		newX := x + directions[i][0]
		newY := y + directions[i][1]
		if newX < 0 || newX >= N || newY < 0 || newY >= M{
			continue
		}
		if (*m)[newX][newY] == 1{
			edge--
		}
	}
	return edge
}
我就是菜鸡1229
关注
  • 7
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
小岛问题
juewu1993的博客
11-18 2138
问题描述：比如给一个岛， 1 1 1 1 1 1 1 1     只有0的左右，上下都有1包围的时候才能算做小岛，所以这个图的小岛就是10，即中间封闭的0的格式，而两边的0都是没有封闭的，                                                  1 0 0 0 0 0 1 1      不可计数。                            
每天一道算法练习题--Day22&& 第一章 --算法专题 --- ----------小岛问题
Wzideng@qq.com
05-06 59
LeetCode 上有很多小岛题，虽然官方没有这个标签， 但是在我这里都差不多。不管是思路还是套路都比较类似，大家可以结合起来练习。不严谨地讲，小岛问题是 DFS 的子专题。
小岛问题以及优化思想
熊伟
12-05 632
岛问题 一个矩阵中只有0和1两种值，每个位置都可以和自己的上、下、左、右四个位置相连，如果有一片1连在一起，这个部分叫做一个岛，求一个矩阵中有多少个岛？ 举例： 0 0 1 0 1 0 1 1 1 0 1 0 1 0 0 1 0 0 0 0 0 0 0 0 这个矩阵中有三个岛。 public static int countIslands(int[][] m) { if (m == null ||...
算法学习（九）之“宽度优先搜索”
依剑行走天下的博客
11-11 636
什么是宽度优先搜索？ 面试题： 小岛问题 题目： 给你一个由 ‘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
代码随想录算法PDF.rar
08-06
《代码随想录》是一本深受程序员喜爱的算法学习书籍，尤其对于初学者来说，它提供了深入浅出的讲解和实战演练。这本书的核心是通过实际编程来帮助读者理解和掌握算法，提升编程技能，特别是C++语言的应用。在C++这个...
代码随想录-八股文 pdf
04-25
代码随想录-八股文 PDF 代码随想录-八股文 PDF 是一个涵盖了程序员学习必备的内容的知识星球精华，总结了包括 C++、Java、Go 在内的多种编程语言，数据结构和算法、操作系统、数据库、计算机网络、设计模式、Linux ...
代码随想录知识算法讲解PDF
10-26
代码随想录贪心算法知识，非常管用
代码随想录知识星球精华 最强⼋股⽂
04-28
代码随想录知识星球精华（最强⼋股⽂） 这份PDF总结了 代码随想录知识星球 的全部精华内容，覆盖了⼏乎程序员学习必备的内容。 知识星球⾥很多录友拿到了⼤⼚offer，包括科班 和 ⾮科班的，⽽他们的每⽇学习总结都是...
代码随想录 面试大厂必备八股文
07-03
《代码随想录》是众多程序员面试准备的重要参考资料，尤其对于目标是大厂的开发者来说，这本书中的“面试大厂必备八股文”更是不容忽视的内容。这里的“八股文”并非传统意义上的文学形式，而是指在编程面试中经常被...
岛屿问题
cy1046090768的博客
03-27 1463
给一个01矩阵，求不同的岛屿的个数。0代表海，1代表岛，如果两个1相邻，那么这两个1属于同一个岛。我们只考虑上下左右为相邻。在矩阵：[ [1, 1, 0, 0, 0], [0, 1, 0, 0, 1], [0, 0, 0, 1, 1], [0, 0, 0, 0, 0], [0, 0, 0, 0, 1] ] 中有 3 个岛.思路: 递归解决package wangyi
常见面试题：小岛问题
最新发布
qq_70799748的博客
05-13 181
思路：2.广度遍历，建立一个存顶点类型的队列，从二维数组中的一个顶点开始入队，1表示有邻接顶点，0表示没有，将这个顶点进行标记为1表示用过，用front存对头，队列不为空则出队，找这个顶点的左右和上下是否存在邻接顶点，有几个图就有几个小岛。思路：1.深度遍历：从二维数组中一个顶点开始，1表示有邻接顶点，0表示没有，深度遍历上下左右深度去找有几个图就有几个小岛。用二维数组来表示地图，其中0表示水域，1表示土地，垂直方向和水平方向的1相连。组成一个小岛，计算给定的地图中有几个小岛。
小岛问题最多可达点
wang785994599的博客
08-05 342
广度优先搜索，Python代码如下，搞清楚二维数组里的横纵坐标，这类题很简单： class Queue(object): def __init__(self): self.items = [] self.head = 0 self.tail = 0 def append(self,node): self.ite...
【深度优先遍历】经典岛屿问题汇总
qq_41959920的博客
05-10 1956
岛屿系列算法问题是经典的面试高频题，岛屿系列题目的核心考点就是用 DFS/BFS 算法遍历二维数组。如何在二维矩阵中使用 DFS 搜索呢？ 我们可以把二维矩阵中的每个点看做一个节点，这个节点的上下左右四个位置就是相邻节点，那么整个矩阵就可以抽象成一幅网状的「图」结构，二维矩阵的搜索问题就变成了从某个点出发，向上下左右四个方向进行深度搜索的问题。
算法--岛屿问题(DFS/BFS/UF)
大魔王
07-14 5346
与岛屿有关的问题 1.岛屿数量 https://leetcode-cn.com/problems/number-of-islands/ 2.岛屿的最大面积 https://leetcode-cn.com/problems/max-area-of-island/ 3.岛屿周长 https://leetcode-cn.com/problems/island-perimeter/ 4.不同岛屿的数量 https://leetcode-cn.com/problems/number-of-distin
poj1328题（雷达覆盖小岛问题）
sinat_37848482的博客
03-24 1376
Radar Installation Time Limit: 1000MS Memory Limit: 10000K Total Submissions: 34841 Accepted: 7737 Description Assume the coasting is an infinite straight line. Land is in one side of c
岛屿问题总结
yay1994的博客
05-19 1606
题目来自牛客： https://www.nowcoder.com/practice/4ce64fe976c548f5beacfe47faf666b0?tpId=90&tqId=30924&tPage=8&rp=8&ru=/ta/2018test&qru=/ta/2018test/question-ranking 递归解法： import java.uti...
岛屿问题系列
jinghe的知识屋
04-17 2786
4. 岛屿问题一：岛屿数量 给你一个由1（陆地）和0（水）组成的二维网格，请你计算网格中岛屿的数量 岛屿总是被水包围，并且每座岛屿只能由水平方向和、或竖直方向上相邻的陆地连接而形成。 此外，你可以假设该网格的四条边均被水包围。 思路：深度优先搜索 二叉树DFS 我们先理解二叉树上的DFS遍历方法，再类比写出网格结构上的DFS遍历。 void traverse(TreeNode* root) { if (root == nullptr) { return ; } // 访问那两个相邻节点：左子节点
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值