【FloodFill】太平洋大西洋水流问题-CSDN博客

本文链接：https://blog.csdn.net/Y_1215/article/details/142891238

🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇

⭐FloodFill⭐

🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇

前言

Flood Fill算法，也被称为种子填充算法，是一种在计算机图形学和图像处理中广泛使用的算法。它的主要用途是从一个给定的起始点（称为“种子”）开始，填充与该点颜色相同且相连的区域。这个过程类似于洪水从一个点开始蔓延到周围的连通区域，直到遇到边界或不同的颜色。

1. 工作原理

选择起始点：用户选择一个起始点（通常是图像中的一个像素），作为填充操作的起点。
检查当前点：算法会检查当前点的颜色是否符合填充条件（比如，是否是目标颜色）。
改变颜色：如果符合条件，则将当前点的颜色更改为新的指定颜色。
递归或迭代扩展：接着，算法会检查当前点周围相邻的点，并重复步骤2和3。这个过程可以递归地进行，也可以使用队列或栈来迭代实现。
停止条件：当所有符合条件的相邻点都被处理过后，算法就会停止。

2. 实现方式

Flood Fill算法通常有两种实现方法：

深度优先搜索 (DFS): 使用递归或显式堆栈来进行填充。每次找到一个符合条件的点时，就立即深入探索其邻居。
广度优先搜索 (BFS): 使用队列来实现。先处理起始点，然后依次处理它所有的直接邻居，再处理这些邻居的邻居，以此类推。

3. 应用场景

图像编辑软件：如Photoshop等软件中的油漆桶工具。

游戏开发：例如扫雷游戏中点击空白处展开相邻格子的功能。

地图着色：在地图上标记特定区域。

数据可视化：热力图、地形渲染等。

计算机视觉：图像分割、边缘检测等。

4. 示例代码模板

下面是一个简单的Flood Fill算法示例，使用了深度优先搜索(DFS)来实现：

public class FloodFill {
    private static final int[] dx = {0, 0, -1, 1};
    private static final int[] dy = {-1, 1, 0, 0};

    public void floodFill(char[][] grid, int x, int y, char oldColor, char newColor) {
        // 检查坐标是否越界
        if (x < 0 || y < 0 || x >= grid.length || y >= grid[0].length) return;
        // 如果不是旧颜色或者已经是新颜色，不需要填充
        if (grid[x][y] != oldColor || grid[x][y] == newColor) return;

        // 更改当前点的颜色
        grid[x][y] = newColor;

        // 对当前点的四个方向递归调用floodFill
        for (int i = 0; i < 4; i++) {
            floodFill(grid, x + dx[i], y + dy[i], oldColor, newColor);
        }
    }
}

这段代码定义了一个floodFill方法，接受一个二维字符数组grid表示图像，以及两个坐标x和y作为起始点，还有需要替换的旧颜色oldColor和新颜色newColor。通过递归的方式，它会把从起始点开始的所有连续的oldColor都替换成newColor。

5: 太平洋⼤西洋⽔流问题（medium）

题⽬链接：417. 太平洋大西洋水流问题 - 力扣（LeetCode）

算法思路

这个问题是经典的图搜索问题，目标是找到矩阵中所有可以同时流向太平洋和大西洋的点。这里的“流向”意味着从一个点出发，只能移动到高度不低于当前点的高度的相邻点（上下左右四个方向）。我们可以通过深度优先搜索（DFS）来解决这个问题。

算法步骤

初始化：

获取矩阵的尺寸 m 和 n。
初始化两个布尔型二维数组 vis1 和 vis2，用于记录哪些位置可以从太平洋和大西洋到达。初始时，所有位置都标记为未访问（false）。

边界搜索：

从太平洋（左边界和上边界）开始，使用DFS遍历所有可以从这些边界到达的位置，并在 vis1 中标记这些位置。
从大西洋（右边界和下边界）开始，使用DFS遍历所有可以从这些边界到达的位置，并在 vis2 中标记这些位置。

查找交集：

遍历整个矩阵，找出那些在 vis1 和 vis2 中都被标记为可到达的位置。这些位置就是可以同时流向太平洋和大西洋的位置。

结果收集：

将满足条件的位置坐标加入结果列表 ret 中，并返回这个列表。

DFS函数逻辑

dfs(int[][] board, int i, int j, boolean[][] vis) 函数负责从给定的位置 (i, j) 开始进行DFS搜索。
如果当前位置还没有被访问过，则将其标记为已访问。
对于当前位置的每个邻居（上下左右），如果邻居没有被访问过且邻居的高度大于或等于当前位置的高度，则递归地对邻居执行DFS。

算法正确性

通过从边界开始进行DFS，我们可以确保只考虑那些可以从边界到达的位置。
由于我们在四个方向上检查邻居，因此可以保证搜索过程中的连通性。
只有当一个位置既可以从太平洋到达也可以从大西洋到达时，它才会被加入最终的结果列表。

复杂度分析

时间复杂度：最坏情况下，每个单元格都需要被访问两次（一次从太平洋边界，一次从大西洋边界），因此时间复杂度为 O(m * n)。
空间复杂度：我们需要两个额外的 m x n 的布尔数组来存储访问状态，所以空间复杂度也是 O(m * n)。

这种方法能够有效地解决问题，避免了重复计算，同时也保持了较低的空间开销。

代码实现

class Solution {
    int m,n;
    int[] dx = new int[]{1,0,-1,0};
    int[] dy = new int[]{0,-1,0,1};
    boolean[][] vis1;
    boolean[][] vis2;
    public List<List<Integer>> pacificAtlantic(int[][] board) {
       m = board.length;
       n = board[0].length;
       vis1 = new boolean[m][n];
       vis2 = new boolean[m][n];
       for(int i =0;i<m;i++){
           //太平洋竖边界
           if(!vis1[i][0]){
             dfs(board,i,0,vis1);
           }
           //大西洋竖边界
           if(!vis2[i][n-1]){
             dfs(board,i,n-1,vis2);
           }
       }
       for(int i =0;i<n;i++){
           //太平洋横边界
           if(!vis1[0][i]){
             dfs(board,0,i,vis1);
           }
           //大西洋横边界
           if(!vis2[m-1][i]){
             dfs(board,m-1,i,vis2);
           }
        }
    List<List<Integer>> ret = new ArrayList<>();

    for(int i =0;i<m;i++){
        for(int j =0;j<n;j++){
            if(vis1[i][j]&&vis2[i][j]){
                List<Integer> index = new ArrayList<>();
                index.add(i);
                index.add(j);
                ret.add(index);
            }
        }
    }  
    return ret;
}

    public void dfs(int[][] board,int i ,int j,boolean[][] vis){
        vis[i][j] = true;
        //往右下走
        for(int k =0;k<4;k++){
            int x = i+dx[k];
            int y = j+dy[k];
            if(x>=0&&x<m&&y>=0&&y<n&&!vis[x][y]&&board[x][y]>=board[i][j]){
                dfs(board,x,y,vis);
            }
        }
    }
  
}