57.【必备】洪水填充

于 2025-05-06 10:00:00 发布
阅读量1.6k 收藏 21
点赞数 50
分类专栏： 数据结构与算法 文章标签： 深度优先 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XY_StarField/article/details/147312547
版权

本文的网课内容学习自B站左程云老师的算法详解课程，旨在对其中的知识进行整理和分享~

网课链接：算法讲解058【必备】洪水填充_哔哩哔哩_bilibili

一.岛屿数量 

题目：岛屿数量

算法原理

  • 算法原理概述
    • 这个算法主要是基于深度优先搜索（DFS）来计算岛屿的数量。
    • 思路是遍历整个二维网格，如果遇到一个陆地（'1'），就将岛屿数量加1，然后对这个陆地进行深度优先搜索，把与它相连的所有陆地都标记为已访问（在这个算法中通过将'1'变为'0'来标记），这样就可以把一个岛屿的所有陆地都标记完。
  • 具体步骤
    • 遍历网格
      • 在numIslands方法中，首先获取网格的行数n和列数m。
      • 然后使用两层嵌套的for循环遍历整个二维网格。
    • 发现岛屿
      • 当遇到board[i][j]=='1'时，说明发现了一个新的岛屿，此时将岛屿数量islands加1。
      • 接着调用dfs方法对这个岛屿进行深度优先搜索。
    • 深度优先搜索（dfs方法）
      • 在dfs方法中，首先进行边界条件判断。如果当前坐标(i, j)超出了网格范围（i < 0或者i == n或者j < 0或者j == m）或者当前位置不是陆地（board[i][j]!= '1'），就直接返回。
      • 然后将当前位置的陆地标记为已访问（board[i][j]=0）。
      • 接着递归地对上下左右四个相邻位置进行深度优先搜索，即调用dfs(board, n, m, i - 1, j)（上）、dfs(board, n, m, i+1, j)（下）、dfs(board, n, m, i, j - 1)（左）和dfs(board, n, m, i, j+1)（右）。这样就可以把与当前陆地相连的所有陆地都标记为已访问，从而确定了一个完整的岛屿。

代码实现 

// 岛屿数量
// 给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量
// 岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成
// 此外，你可以假设该网格的四条边均被水包围
// 测试链接 : https://leetcode.cn/problems/number-of-islands/
public class Code01_NumberOfIslands {

    // 洪水填充的做法
    // board : n * m
    // O(n*m)最优解！
    public static int numIslands(char[][] board) {
        int n = board.length;
        int m = board[0].length;
        int islands = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (board[i][j] == '1') {
                    islands++;
                    dfs(board, n, m, i, j);
                }
            }
        }
        return islands;
    }

    public static void dfs(char[][] board, int n, int m, int i, int j) {
        if (i < 0 || i == n || j < 0 || j == m || board[i][j] != '1') {
            return;
        }
        // board[i][j] = '1'
        board[i][j] = 0;
        dfs(board, n, m, i - 1, j);
        dfs(board, n, m, i + 1, j);
        dfs(board, n, m, i, j - 1);
        dfs(board, n, m, i, j + 1);
    }

}

二.被围绕的区域

题目：被围绕的区域

算法原理

  • 算法原理概述
    • 此算法的核心思想是先标记那些不被围绕的'O'区域，然后将剩余的'O'区域转换为'X'。通过深度优先搜索（DFS）来实现对区域的标记。
  • 具体步骤
    • 边界'O'的处理
      • 在solve方法中，首先获取矩阵的行数n和列数m。
      • 然后分别对矩阵的上下边界和左右边界进行处理。对于上边界（i = 0）和下边界（i=n - 1），遍历每一列j，如果遇到'O'，就调用dfs方法进行深度优先搜索。同样，对于左边界（j = 0，除了上下角的情况）和右边界（j = m - 1，除了上下角的情况），遍历每一行i，如果遇到'O'，也调用dfs方法。
    • 深度优先搜索（dfs方法）
      • 在dfs方法中，首先进行边界条件判断。如果当前坐标(i, j)超出了矩阵范围（i < 0或者i == n或者j < 0或者j == m）或者当前位置不是'O'（board[i][j]!= 'O'），就直接返回。
      • 然后将当前位置标记为'F'（这里'F'是一个临时标记，表示这个'O'是不被围绕的）。
      • 接着递归地对上下左右四个相邻位置进行深度优先搜索，即调用dfs(board, n, m, i + 1, j)（下）、dfs(board, n, m, i - 1, j)（上）、dfs(board, n, m, i, j + 1)（右）和dfs(board, n, m, i, j - 1)（左）。
    • 最终处理
      • 在solve方法的最后部分，再次遍历整个矩阵。对于每个位置(i, j)，如果是'O'，就将其转换为'X'，因为这些'O'是被围绕的；如果是'F'，就将其转换回'O'，因为这些'O'是不被围绕的。

代码实现

// 被围绕的区域
// 给你一个 m x n 的矩阵 board ，由若干字符 'X' 和 'O' ，找到所有被 'X' 围绕的区域
// 并将这些区域里所有的 'O' 用 'X' 填充。
// 测试链接 : https://leetcode.cn/problems/surrounded-regions/
public class Code02_SurroundedRegions {

    public static void solve(char[][] board) {
        int n = board.length;
        int m = board[0].length;
        for (int j = 0; j < m; j++) {
            if (board[0][j] == 'O') {
                dfs(board, n, m, 0, j);
            }
            if (board[n - 1][j] == 'O') {
                dfs(board, n, m, n - 1, j);
            }
        }
        for (int i = 1; i < n - 1; i++) {
            if (board[i][0] == 'O') {
                dfs(board, n, m, i, 0);
            }
            if (board[i][m - 1] == 'O') {
                dfs(board, n, m, i, m - 1);
            }
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (board[i][j] == 'O') {
                    board[i][j] = 'X';
                }
                if (board[i][j] == 'F') {
                    board[i][j] = 'O';
                }
            }
        }
    }

    public static void dfs(char[][] board, int n, int m, int i, int j) {
        if (i < 0 || i == n || j < 0 || j == m || board[i][j] != 'O') {
            return;
        }
        board[i][j] = 'F';
        dfs(board, n, m, i + 1, j);
        dfs(board, n, m, i - 1, j);
        dfs(board, n, m, i, j + 1);
        dfs(board, n, m, i, j - 1);
    }

}

三.最大人工岛

题目：最大人工岛

算法原理

  • 算法原理概述
    • 这个算法主要分为两个部分。第一部分是通过深度优先搜索（DFS）标记不同的岛屿并计算它们的面积；第二部分是遍历所有的0单元格，考虑将每个0变成1后对岛屿面积的影响，从而找到最大的岛屿面积。
  • 具体步骤
    • 标记岛屿并计算面积（第一部分）
      • 在largestIsland方法中，首先获取矩阵的大小n（这里n=m，因为是n * n的矩阵）。
      • 然后使用双层for循环遍历矩阵。当遇到grid[i][j] == 1时，使用dfs方法对这个岛屿进行深度优先搜索，并为这个岛屿分配一个唯一的id（从2开始，1可能用于表示原始的1单元格）。
      • 在dfs方法中，首先进行边界条件判断。如果当前坐标(i, j)超出了矩阵范围（i < 0或者i == n或者j < 0或者j == m）或者当前位置不是1（grid[i][j]!= 1），就直接返回。否则，将当前单元格标记为id，然后递归地对上下左右四个相邻位置进行深度优先搜索，即调用dfs(grid, n, m, i - 1, j, id)（上）、dfs(grid, n, m, i+1, j, id)（下）、dfs(grid, n, m, i, j - 1, id)（左）和dfs(grid, n, m, i, j+1, id)（右）。
      • 回到largestIsland方法，创建一个大小为id的数组sizes来存储每个岛屿的面积。再次遍历矩阵，当遇到grid[i][j]>1时（表示属于某个已标记的岛屿），将对应岛屿的面积sizes[grid[i][j]]加1，并更新最大岛屿面积ans。
    • 考虑将0变成1后的面积变化（第二部分）
      • 创建一个布尔数组visited来标记某个岛屿是否已经被合并计算过。
      • 再次使用双层for循环遍历矩阵，当遇到grid[i][j] == 0时，考虑将这个0变成1后的情况。分别获取这个0单元格上下左右相邻单元格的岛屿id（如果存在的话），对于上相邻单元格up = i > 0?grid[i - 1][j]:0，下相邻单元格down = i + 1 < n?grid[i + 1][j]:0，左相邻单元格left = j > 0?grid[i][j - 1]:0，右相邻单元格right = j + 1 < m?grid[i][j + 1]:0。
      • 首先将up对应的岛屿标记为已访问（visited[up]=true），计算合并后的面积merge = 1 + sizes[up]（这里的1是因为将当前的0变成了1）。然后如果down对应的岛屿还没有被访问过（!visited[down]），则将其面积加入merge并标记为已访问。同样的操作对left和right进行。最后更新最大岛屿面积ans = Math.max(ans, merge)，并将所有的visited标记恢复为false，以便处理下一个0单元格。

代码实现 

// 最大人工岛
// 给你一个大小为 n * n 二进制矩阵 grid 。最多 只能将一格 0 变成 1 。
// 返回执行此操作后，grid 中最大的岛屿面积是多少？
// 岛屿 由一组上、下、左、右四个方向相连的 1 形成
// 测试链接 : https://leetcode.cn/problems/making-a-large-island/
public class Code03_MakingLargeIsland {

    public static int largestIsland(int[][] grid) {
        int n = grid.length;
        int m = grid[0].length;
        int id = 2;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == 1) {
                    dfs(grid, n, m, i, j, id++);
                }
            }
        }
        int[] sizes = new int[id];
        int ans = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] > 1) {
                    ans = Math.max(ans, ++sizes[grid[i][j]]);
                }
            }
        }
        // 讨论所有的0，变成1，能带来的最大岛的大小
        boolean[] visited = new boolean[id];
        int up, down, left, right, merge;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == 0) {
                    up = i > 0 ? grid[i - 1][j] : 0;
                    down = i + 1 < n ? grid[i + 1][j] : 0;
                    left = j > 0 ? grid[i][j - 1] : 0;
                    right = j + 1 < m ? grid[i][j + 1] : 0;
                    visited[up] = true;
                    merge = 1 + sizes[up];
                    if (!visited[down]) {
                        merge += sizes[down];
                        visited[down] = true;
                    }
                    if (!visited[left]) {
                        merge += sizes[left];
                        visited[left] = true;
                    }
                    if (!visited[right]) {
                        merge += sizes[right];
                        visited[right] = true;
                    }
                    ans = Math.max(ans, merge);
                    visited[up] = false;
                    visited[down] = false;
                    visited[left] = false;
                    visited[right] = false;
                }
            }
        }
        return ans;
    }


    public static void dfs(int[][] grid, int n, int m, int i, int j, int id) {
        if (i < 0 || i == n || j < 0 || j == m || grid[i][j] != 1) {
            return;
        }
        //  grid[i][j] == 1
        grid[i][j] = id;
        dfs(grid, n, m, i - 1, j, id);
        dfs(grid, n, m, i + 1, j, id);
        dfs(grid, n, m, i, j - 1, id);
        dfs(grid, n, m, i, j + 1, id);
    }

}

四.打砖块

题目：打砖块

算法原理

  • 算法原理概述
    • 这个算法的核心思路是先处理所有要打击的砖块位置，将对应砖块移除（通过减1操作），然后从顶部开始进行深度优先搜索（DFS）标记稳定的砖块。之后再反向处理打击操作，将移除的砖块加回来，对于每个加回的砖块，如果它是值得掉落（即与稳定砖块相连）的，就通过DFS计算因为这个砖块加入而掉落的砖块数量。
  • 具体步骤
    • 初始处理
      • 在hitBricks方法中，首先保存原始网格g到grid，获取网格的行数n和列数m，创建结果数组ans来存储每次打击操作掉落的砖块数量。
      • 如果网格只有一行（n == 1），直接返回空结果数组，因为在这种情况下没有砖块会掉落。
      • 然后遍历打击位置数组h，对于每个打击位置hit，将对应网格位置的砖块值减1（模拟移除砖块）。
    • 标记稳定砖块
      • 接着，通过一个for循环对网格的第一行（i = 0）的每个列j调用dfs方法。这个dfs方法从给定的位置(i, j)开始，如果当前位置在网格范围内且是砖块（grid[i][j] == 1），就将这个砖块标记为稳定（标记为2），并递归地对上下左右四个相邻位置进行深度优先搜索（dfs(i + 1, j)、dfs(i, j + 1)、dfs(i - 1, j)和dfs(i, j - 1)），同时返回感染（标记为2）的砖块数量。这样就标记出了初始状态下所有稳定的砖块。
    • 反向处理打击操作并计算掉落砖块数量
      • 然后从后向前遍历打击位置数组h（for (int i = h.length - 1; i >= 0; i--)）。对于每个打击位置h[i]，先将对应的网格位置砖块值加1（恢复被移除的砖块）。
      • 调用worth方法判断这个恢复的砖块是否值得掉落。如果值得掉落（worth方法返回true），就调用dfs方法从这个恢复的砖块位置开始，计算因为这个砖块加入而新感染（标记为2）的砖块数量，然后将结果减1（因为要计算掉落的砖块数量，不包括自身），并将这个值赋给ans[i]。
    • worth方法原理
      • 在worth方法中，首先判断当前位置(i, j)是否是砖块（grid[i][j] == 1），并且这个砖块是否与稳定砖块相连。如果砖块在第一行（i == 0），它是稳定的；或者它的上下左右相邻位置有稳定砖块（grid[i - 1][j] == 2、grid[i + 1][j] == 2、grid[i][j - 1] == 2或者grid[i][j + 1] == 2），那么这个砖块就是值得掉落的，方法返回true，否则返回false。

代码实现

// 打砖块
// 有一个 m * n 的二元网格 grid ，其中 1 表示砖块，0 表示空白
// 砖块 稳定（不会掉落）的前提是：
// 一块砖直接连接到网格的顶部，或者
// 至少有一块相邻（4 个方向之一）砖块 稳定 不会掉落时
// 给你一个数组 hits ，这是需要依次消除砖块的位置
// 每当消除 hits[i] = (rowi, coli) 位置上的砖块时，对应位置的砖块（若存在）会消失
// 然后其他的砖块可能因为这一消除操作而 掉落
// 一旦砖块掉落，它会 立即 从网格 grid 中消失（即，它不会落在其他稳定的砖块上）
// 返回一个数组 result ，其中 result[i] 表示第 i 次消除操作对应掉落的砖块数目。
// 注意，消除可能指向是没有砖块的空白位置，如果发生这种情况，则没有砖块掉落。
// 测试链接 : https://leetcode.cn/problems/bricks-falling-when-hit/
public class Code04_BricksFallingWhenHit {

    public static int n, m;

    public static int[][] grid;

    public static int[] hitBricks(int[][] g, int[][] h) {
        grid = g;
        n = g.length;
        m = g[0].length;
        int[] ans = new int[h.length];
        if (n == 1) {
            return ans;
        }
        for (int[] hit : h) {
            grid[hit[0]][hit[1]]--;
        }
        for (int i = 0; i < m; i++) {
            dfs(0, i);
        }
        for (int i = h.length - 1, row, col; i >= 0; i--) {
            row = h[i][0];
            col = h[i][1];
            grid[row][col]++;
            if (worth(row, col)) {
                ans[i] = dfs(row, col) - 1;
            }
        }
        return ans;
    }

    // 从(i,j)格子出发，遇到1就感染成2
    // 统计新增了几个2！
    public static int dfs(int i, int j) {
        if (i < 0 || i == n || j < 0 || j == m || grid[i][j] != 1) {
            return 0;
        }
        grid[i][j] = 2;
        return 1 + dfs(i + 1, j) + dfs(i, j + 1) + dfs(i - 1, j) + dfs(i, j - 1);
    }

    public static boolean worth(int i, int j) {
        return grid[i][j] == 1
                &&
                (i == 0
                        || (i > 0 && grid[i - 1][j] == 2)
                        || (i < n - 1 && grid[i + 1][j] == 2)
                        || (j > 0 && grid[i][j - 1] == 2)
                        || (j < m - 1 && grid[i][j + 1] == 2));
    }

}

五.总结

洪水填充是一种很简单的技巧，设置路径信息进行剪枝和统计，类似感染的过程。路径信息不撤销，来保证每一片的感染过程可以得到区分。看似是暴力递归过程，其实时间复杂度非常好，遍历次数和样本数量的规模一致！

盘点一款黑客必备的强大网络工具集——netwox
pyjishu的博客
04-09 7285
今天给大家分享一个网络工具netwox。 前言 netwox 是由 lauconstantin 开发的一款网络工具集，适用群体为网络管理员和网络黑客，它可以创造任意的 TCP、UDP 和 IP 数据报文，以实现网络欺骗，并且可以在 Linux 和 Windows 系统中运行。 可以说，对平时我们用来测试网络的性能和网站压力测试很有帮助了。它不仅仅只是一个工具包，而是很多个工具集的集中体现，所以，有了它，基本你可以少下载很多软件了。 具体用法 下面就来具体说说它的用法： 首先我们现在netw.
算法讲解058【必备】洪水填充.pptx
08-27
算法讲解058【必备】洪水填充
（左程云）算法讲解058【必备】洪水填充
哀莫大于心死
05-05 371
洪水填充是一种很简单的技巧，设置路径信息进行剪枝和统计，类似感染的过程路径信息不撤销，来保证每一片的感染过程可以得到区分看似是暴力递归过程，其实时间复杂度非常好，遍历次数和样本数量的规模一致。
【CV学习笔记】ROI与泛洪填充
zenRRan的博客
11-03 462
关注“深度学习冲鸭”，一起学习一起冲鸭！设为星标，第一时间获取更多干货作者：云时之间来源：知乎链接：https://zhuanlan.zhihu.com/p/104644924编辑：王萌...
左神算法题单（入门、必备）
2302_78561430的博客
03-21 169
算法题单
（左程云）算法讲解056【必备】并查集-上
最新发布
哀莫大于心死
05-05 529
前置知识 : 无并查集的使用是如下的场景1）一开始每个元素都拥有自己的集合，在自己的集合里只有这个元素自己2）find(i)：查找i所在集合的代表元素，代表元素来代表i所在的集合3）boolean isSameSet(a, b)：判断a和b在不在一个集合里4）void union(a, b)：a所在集合所有元素 与 b所在集合所有元素 合并成一个集合5）各种操作单次调用的均摊时间复杂度为O(1)并查集原理图解注意：带权并查集的内容是大厂笔试面试冷门内容，会在【挺难】课程里讲述。
常见30种网络攻击类型大盘点：守护网络安全的必备指南
A1_3_9_7的博客
03-03 931
近年来，网络攻击事件层出不穷，各种攻击手段也日益复杂和隐蔽，严重威胁着我们的个人隐私、企业机密和国家安全。据Gartner预测，。这一数字的背后，是网络安全形势的严峻性和紧迫性。本文我们盘点了当前，并对其产生的影响进行简要分析，同时给出相应的防范提示，以帮助企业提升信息安全能力。**1、DoS和DDoS攻击：**DoS（Denial of Service，拒绝服务）攻击和 DDoS（Distributed Denial of Service，分布式拒绝服务）攻击是网络世界中的“洪水猛兽”。
Offer必备算法24_BFS解决FloodFill_四道力扣题详解（由易到难）
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
04-12 1444
Offer必备算法24_BFS解决FloodFill_四道力扣题详解（BFS解决FloodFill简介+①力扣733. 图像渲染+②力扣200. 岛屿数量+③力扣695. 岛屿的最大面积+④力扣130. 被围绕的区域）
[数据分析自学帮手]数据分析必备的统计学知识大梳理，还不赶紧收藏？
热心的布丁-有计划的自学编程才会成功
05-14 256
嘿，亲爱的小伙伴, 众所周知现当今是个数据化的时代，你们猜猜什么职业最受欢迎呢？没错，就是数据分析师啦！数据是一种珍贵的、极具价值的资源，数据分析师就像淘金者一样，能够最大程度地开采这一资源，将数据转换为真正的价值。你是不是很想知道为什么数据分析师这个职业这么火？其实很简单啦！现在巨量数据如洪水般涌入各行各业，企业需要数据分析师们来帮忙分析和解读这些数据，找出它们背后隐藏的规律。有了这些规律，企业就可以制定更准确、更高效的商业决策，提高市场竞争力。
四月份新增开源项目：撩萌妹子必备软萌颜文字生成工具
weixin_34106122的博客
05-01 371
2019独角兽企业重金招聘Python工程师标准>>> ...
资料员必备文档系列-6-1-6 工程场地平整.doc
05-05
1. **场地设计标高**：选择合适的场地平整高度，考虑工艺要求、土方平衡和洪水位影响等因素。最常用的是“挖填土方量平衡法”。 2. **计算设计标高**：通过划分方格网，计算每个角点的标高，然后应用公式（6-5）求解...
水利工程模拟试题及答案.docx
09-30
**3/4**：正确，这是为了确保混凝土能够充分填充到钢筋之间，保证结构的整体性和耐久性。 4. **工程质量事故处理流程** - 对于施工过程中出现的质量缺陷，监理工程师应采取什么措施？ - **选项分析**： - A. **...
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5304
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
34.多点求均值的模拟信号抗干扰算法使用注意事项
lc160809的博客
05-04 456
（3）服从正态分布和均匀分布的干扰信号适合用多点求均值滤波抗干扰。通过产品电路噪声分析或者电流钳配合示波器FFT得出。（3)连续采样的多个点数至少要覆盖一个噪声周期。可以通过产品功能分析得出，干扰频段f。（1）多点求均值滤波属于低通滤波器。至少要大于5倍的有用信号频率f。（2）实际每次采样要采样n个点。（2）有用信号的频率f。
C++基础算法9：Dijkstra
ccrr7的博客
05-04 611
Dijkstra求解路径最短问题
算法题（138）：在排序数组中查找元素的第一个和最后一个位置
2301_79954395的博客
05-04 454
若left等于right可以作为循环进行条件，那么我们要么会导致left>right，要么就陷入死循环（一直让right更新为mid，相当于没变），而陷入死循环是绝对不允许的。这里我们的right和left的差为3，为奇数，所以我们加一之后得到的索引为2，不加得到的索引为1，这就是前面说的，加一会让mid偏右一位，不加会偏左一位。当mid索引处的值大于等于target时，说明mid右边区域的值都可以从最小左边界中排除，让right指向mid索引的位置。不过他的时间复杂度就是O（n），不符合题目的要求。
关于离散化算法的看法与感悟
2301_81848095的博客
05-04 907
离散化本质上是一种数据压缩技术，它：将无限或大范围的连续数据映射到有限的小范围离散值保持原始数据的相对顺序关系减少数据的复杂度同时保留关键信息。
LeetCode 1128.等价多米诺骨牌对的数量：计数
<font color="Pink">Tisfy的博客</font>
05-04 1199
LeetCode 1128.等价多米诺骨牌对的数量：计数 给你一组多米诺骨牌 dominoes 。 形式上，dominoes[i] = [a, b] 与 dominoes[j] = [c, d] 等价 当且仅当 (a == c 且 b == d) 或者 (a == d 且 b == c) 。即一张骨牌可以通过旋转 0 度或 180 度得到另一张多米诺骨牌。 在 0 <= i < j
STL之vector容器
Laydya的博客
05-02 1253
1.vector是可变大小数组的容器2.像数组一样，采用连续的空间存储，也就意味着可以通过下标去访问，但它的大小可以动态改变3.每次的插入都要开空间吗？开空间就要意味着先开临时空间，然后在拷贝旧的到新的上面，在释放原来的，就时间而言，这是一个相对代价很高的任务；显然这是不行的，vector的分配策略：会分配一些而外的空间以适应可能的增长，例如我们平时说的以1.5或者2倍的方式增容，不同的库选择不同的策略权衡空间的使用和重新分配，以至于在插入一个元素时能在常数时间内插入；
emgu.cv 泛洪水填充
07-27
Em.CV 是一个基于 OpenCV 的 C# 图像处理库，它提供了许多图像处理和计算机视觉的功能。其中，泛洪水填充（Flood Fill）是一种图像处理算法，用于填充一个封闭区域的像素。 在 Emgu.CV 中，你可以使用 `CvInvoke.FloodFill` 方法来进行泛洪水填充操作。该方法可以接受一个源图像、填充起始点、填充颜色、填充范围等参数。 下面是一个示例代码，演示如何使用 Emgu.CV 进行泛洪水填充： ```csharp using Emgu.CV; using Emgu.CV.Structure; // 加载图像 Image<Bgr, byte> image = new Image<Bgr, byte>("input.jpg"); // 定义填充起始点 int startX = 100; int startY = 100; // 定义填充颜色 MCvScalar fillColor = new MCvScalar(0, 0, 255); // 红色 // 定义填充范围 MCvConnectedComp connectedComponent = new MCvConnectedComp(); MCvScalar lowerDiff = new MCvScalar(20, 20, 20); // 填充颜色的下限差异 MCvScalar upperDiff = new MCvScalar(20, 20, 20); // 填充颜色的上限差异 // 进行泛洪水填充 CvInvoke.FloodFill(image, null, new System.Drawing.Point(startX, startY), fillColor, out connectedComponent, lowerDiff, upperDiff); // 显示结果图像 CvInvoke.Imshow("Flood Fill Result", image); CvInvoke.WaitKey(0); ``` 在这个示例中，我们首先加载了一个图像，然后定义了填充起始点、填充颜色以及填充范围。最后，调用 `CvInvoke.FloodFill` 方法进行填充操作，并显示结果图像。 请注意，这只是一个简单的示例，你可以根据自己的需求进行调整和扩展。另外，记得在使用 Emgu.CV 之前，你需要先安装 Emgu.CV 库并添加到你的项目引用中。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值