数据结构与算法之图: LeetCode 417. 太平洋大西洋水流问题 (Ts, Py, Go版)

太平洋大西洋水流问题

• https://leetcode.cn/problems/pacific-atlantic-water-flow/description/

描述

• 有一个 m × n 的矩形岛屿，与 太平洋 和 大西洋 相邻。 “太平洋” 处于大陆的左边界和上边界，而 “大西洋” 处于大陆的右边界和下边界。

• 这个岛被分割成一个由若干方形单元格组成的网格。给定一个 m x n 的整数矩阵 heights ， heights[r][c] 表示坐标 (r, c) 上单元格 高于海平面的高度 。

• 岛上雨水较多，如果相邻单元格的高度 小于或等于 当前单元格的高度，雨水可以直接向北、南、东、西流向相邻单元格。水可以从海洋附近的任何单元格流入海洋。

• 返回网格坐标 result 的 2D 列表 ，其中 result[i] = [ri, ci] 表示雨水从单元格 (ri, ci) 流动 既可流向太平洋也可流向大西洋 。

示例 1

输入: heights = [[1,2,2,3,5],[3,2,3,4,4],[2,4,5,3,1],[6,7,1,4,5],[5,1,1,2,4]]
输出: [[0,4],[1,3],[1,4],[2,2],[3,0],[3,1],[4,0]]

示例 2

输入: heights = [[2,1],[1,2]]
输出: [[0,0],[0,1],[1,0],[1,1]]

提示

• m == heights.length
• n == heights[r].length
• 1 <= m, n <= 200
• 0 <= heights[r][c] <= $10^5$

Typescript 版算法实现

1 ）基于深度优先遍历递归实现

function pacificAtlantic(matrix: number[][]): number[][] {
    if(!matrix || !matrix[0]?.length) {return [];}
    const m = matrix.length;
    const n = matrix[0].length;
    // 两个矩阵
    const flow1 = Array.from({length: m}, ()=> new Array(n).fill(false)); // 大西洋
    const flow2 = Array.from({length: m}, ()=> new Array(n).fill(false)); // 太平洋
    // 深度优先遍历 r行，c列，r,c 是当前节点坐标的意思，flow 矩阵
    const dfs = (r: number, c: number, flow: boolean[][]) => {
        flow[r][c] = true; // 边界和符合条件的是已经确定了的，可直接填充
        // 遍历这个节点的相邻节点，上下左右节点
        const current = [[r-1, c], [r+1, c], [r, c-1], [r, c+1]];
        current.forEach(([nr, nc]) => {
            // 保证在矩阵中, 防止死循环, 不在之前的矩阵中 保证逆流而上, 下个节点的值要 >= 上个节点的值
            const flag = nr >=0 && nr < m && nc >= 0 && nc < n && !flow[nr][nc] && matrix[nr][nc] >= matrix[r][c];
            flag && dfs(nr, nc, flow);
        })
    }
    // 从海岸线多管齐下，对太平洋来说是第一行和第一列；对大西洋来说是第一列和最后一行
    // 第一列和最后一列
    for(let r = 0; r < m; r++) {
        dfs(r, 0, flow1);
        dfs(r, n-1, flow2);
    }
    // 第一行和最后一行
    for(let c = 0; c < n; c++) {
        dfs(0, c, flow1);
        dfs(m-1, c, flow2);
    }
    // 收集能留到两个大洋的坐标
    const res = [];
    for(let r = 0; r < m; r++) {
        for(let c = 0; c < n; c++) {
            if(flow1[r][c] && flow2[r][c]) {
                res.push([r,c])
            }
        }
    }
    return res;
}

• 整体思路
  • 准备两个矩阵用于存储大西洋和太平洋符合条件的点位
  • 从第一列，最后一列，第一行，最后一行开始, 这些都是确认可直接填充true的位置
  • 使用深度优先遍历, 找到每个节点的有效邻居，匹配符合条件的点位
  • 最后对两个矩阵取相同位置，即为最终结果
• 时间复杂度 O(m*n)
  • 大量嵌套for循环，遍历m*n的格子
• 空间复杂度 O(m*n)
  • 用到两个变量flow1, flow2
  • 矩阵尺寸 m*n

Python3 版算法实现

1 ) 方案1

from typing import List

class Solution:
    def pacificAtlantic(self, matrix: List[List[int]]) -> List[List[int]]:
        if not matrix or not matrix[0]:
            return []

        m, n = len(matrix), len(matrix[0])

        # 两个矩阵
        flow1 = [[False] * n for _ in range(m)]  # 大西洋
        flow2 = [[False] * n for _ in range(m)]  # 太平洋

        # 深度优先遍历
        def dfs(r: int, c: int, flow: List[List[bool]]):
            flow[r][c] = True
            directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]
            for dr, dc in directions:
                nr, nc = r + dr, c + dc
                if 0 <= nr < m and 0 <= nc < n and not flow[nr][nc] and matrix[nr][nc] >= matrix[r][c]:
                    dfs(nr, nc, flow)

        # 从海岸线多管齐下
        for r in range(m):
            dfs(r, 0, flow1)
            dfs(r, n - 1, flow2)
        for c in range(n):
            dfs(0, c, flow1)
            dfs(m - 1, c, flow2)

        # 收集能流到两个大洋的坐标
        res = []
        for r in range(m):
            for c in range(n):
                if flow1[r][c] and flow2[r][c]:
                    res.append([r, c])

        return res

Golang 版算法实现

1 ) 方案1

func pacificAtlantic(matrix [][]int) [][]int {
	if matrix == nil || len(matrix) == 0 || len(matrix[0]) == 0 {
		return [][]int{}
	}
	m, n := len(matrix), len(matrix[0])

	// 两个矩阵
	flow1 := make([][]bool, m)
	flow2 := make([][]bool, m)
	for i := range flow1 {
		flow1[i] = make([]bool, n)
		flow2[i] = make([]bool, n)
	}

	// 深度优先遍历
	var dfs func(r, c int, flow [][]bool)
	dfs = func(r, c int, flow [][]bool) {
		flow[r][c] = true
		directions := [][2]int{{-1, 0}, {1, 0}, {0, -1}, {0, 1}}
		for _, dir := range directions {
			nr, nc := r+dir[0], c+dir[1]
			if nr >= 0 && nr < m && nc >= 0 && nc < n && !flow[nr][nc] && matrix[nr][nc] >= matrix[r][c] {
				dfs(nr, nc, flow)
			}
		}
	}

	// 从海岸线多管齐下
	for r := 0; r < m; r++ {
		dfs(r, 0, flow1)
		dfs(r, n-1, flow2)
	}
	for c := 0; c < n; c++ {
		dfs(0, c, flow1)
		dfs(m-1, c, flow2)
	}

	// 收集能流到两个大洋的坐标
	var res [][]int
	for r := 0; r < m; r++ {
		for c := 0; c < n; c++ {
			if flow1[r][c] && flow2[r][c] {
				res = append(res, []int{r, c})
			}
		}
	}
	return res
}