FloodFill算法及其应用

已于 2024-05-12 19:15:03 修改
阅读量707 收藏 12
点赞数 23
文章标签： 算法 数据结构 深度优先
于 2024-05-11 22:12:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Doctor_Anonymous/article/details/138731834
版权

floodfill算法+题目

简介

给定一个地形图，浅色表示洼地，深色表示高地。向这个图中的一个格子注水，随后询问这个格子的四个方向上的格子，显然，只有浅色的格子才可以被洪水覆盖，高低不会被覆盖。

这个算法可以在线性复杂度内找到某个点所在的连通块。

image-20240511202156760

题目

1. 200. 岛屿数量 - 力扣（LeetCode）

给定一个图。其中1表示陆地，0表示水。求由1构成的连通块的数量，显然是floodfill算法。

此为最经典的模板。以下题目都要用到类似的写法。

image-20240511203516078

class Solution {
public:
    vector<vector<char>> g;
    int dx[4] = {0, 1, 0, -1};
    int dy[4] = {1, 0, -1, 0};
    int numIslands(vector<vector<char>>& grid) {
        g = grid;
        int cnt = 0;
        for(int i = 0; i < g.size(); i++){
            for(int j = 0; j < g[i].size(); j++){
                if(g[i][j] == '1'){
                    dfs(i, j);
                    cnt++;
                }
            }
        }
        return cnt;
    }
    void dfs(int x, int y){
        g[x][y] = '0';
        for(int i = 0; i < 4; i++){
            int a = x + dx[i];
            int b = y + dy[i];
            if(a >= 0 && a < g.size() && b >= 0 && b < g[a].size() && g[a][b] == '1'){
                dfs(a, b);
            }
        }
    }
};

遍历整个图，遇到1就遍历这个块的上下左右四个方向，并统计cnt。

在遍历上下左右四个方向时，可以用向量来表示。即：

int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};

在dfs函数中，需要将已经询问过的格子标记，以免再被询问。即：

g[x][y] = '0';

之后则是遍历四个方向，并进行边界判断。若不超出边界，则接着询问它的四个方向的格子。即：

 for(int i = 0; i < 4; i++){
            int a = x + dx[i];
            int b = y + dy[i];
            if(a >= 0 && a < g.size() && b >= 0 && b < g[a].size() && g[a][b] == '1'){
                dfs(a, b);
            }
        }

整个算法模板较为清晰。

2. 695. 岛屿的最大面积 - 力扣（LeetCode）

给定一个图，1表示陆地，0表示水。求1所形成的连通块的最大值。显然为floodfill算法。上题为统计所有连通块的数目，此题为统计连通块的面积，较为类似。

image-20240511204403853

class Solution {
public:
    int dx[4] = {0, 1, 0, -1};
    int dy[4] = {-1, 0, 1, 0};
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        int row = grid.size();
        int col = grid[0].size();
        int res = 0;
        for(int i = 0; i < row; i++){
            for(int j = 0; j < col; j++){
                if(grid[i][j] == 1){
                    res = max(res, dfs(grid, i, j));
                }
            }
        }
        return res;
    }
    
    int dfs(vector<vector<int>>& grid, int x, int y){
        grid[x][y] = 0;
        int res = 1;
        int row = grid.size(), col = grid[0].size();
        for(int i = 0; i < 4; i++){
            int a = x + dx[i];
            int b = y + dy[i];
            if(a >= 0 && a < row && b >= 0 && b < col && grid[a][b] == 1){
                res += dfs(grid, a, b);
            }
        }
        return res;
    }
};

大体模板较为相似。即：还是定义向量，遍历四个方向。在dfs函数中标记已经遍历过的格子，并在边界判断下搜索其余格子。

不同之处在于这里统计连通块的面积。做法如下：

if(a >= 0 && a < row && b >= 0 && b < col && grid[a][b] == 1){
                res += dfs(grid, a, b);
            }
3. 130. 被围绕的区域 - 力扣（LeetCode）

给定一个图，求被X围绕的区域，并将其用0填充。如果0的连通块能到达图的边界，则其不被围绕。所以我们从矩阵最外侧的四个边开始向内搜索。

image-20240511205559829

class Solution {
public:
    int dx[4] = {-1, 0, 1, 0};
    int dy[4] = {0, 1, 0, -1};
    vector<vector<char>> g;
    int row, col;
    void solve(vector<vector<char>>& board) {
        g = board;
        row = board.size(), col = board[0].size();
        for(int i = 0; i < row; i++){
            if(g[i][0] == 'O'){
                dfs(i, 0);
            }
            if(g[i][col - 1] == 'O'){
                dfs(i, col - 1);
            }
        }
        for(int j = 0; j < col; j++){
            if(g[0][j] == 'O'){
                dfs(0, j);
            }
            if(g[row - 1][j] == 'O'){
                dfs(row - 1, j);
            }
        }
        for(int i = 0; i < row; i++){
            for(int j = 0; j < col; j++){
                if(g[i][j] == '#'){
                    g[i][j] = 'O';
                }else{
                    g[i][j] = 'X';
                }
            }
        }
        board = g;
    }
    void dfs(int x, int y){
            g[x][y] = '#';
            for(int i = 0; i < 4; i++){
                int a = x + dx[i];
                int b = y + dy[i];
                if(a >= 0 && a < row && b >= 0 && b < col && g[a][b] == 'O'){
                    dfs(a, b);
                }
            }
        }
};

大致写法类似，此题为从矩阵的最外侧四条边开始向内扩展搜索，将遇到的0全部标记为#。矩阵中所有被标记为#的方格即为不被包围的方格，将其更改为0。随后将剩下的填为X。

4. P1506 拯救oibh总部 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

这道题需要求被围墙*包围的0的连通块的个数。这些连通块无法被洪水覆盖。

这道题也用到了类似的思想，也是从最外侧四条边向内搜索。

image-20240511210442000

#include <iostream>
#include <vector>

using namespace std;

int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
int row, col;
vector<vector<char>> map;

void dfs(int x, int y){
	map[x][y] = '*';
	for(int k = 0; k < 4; k++){
		int a = x + dx[k], b = y + dy[k];
		if(a >= 0 && a < row && b >= 0 && b < col && map[a][b] == '0'){
			dfs(a, b);
		}
	}
}

int main()
{
	cin >> row >> col;
	map = vector<vector<char>>(row, vector<char>(col));
	for(int i = 0; i < row; i++){
		for(int j = 0; j < col; j++){
			cin >> map[i][j];
		}
	}
	for(int i = 0; i < row; i++){
		if(map[i][0] == '0')dfs(i, 0);
	}
	for(int j = 0; j < col; j++){
		if(map[0][j] == '0')dfs(0, j);
	}
	for(int i = 0; i < row; i++){
		if(map[i][col - 1] == '0')dfs(i, col - 1);
	}
	for(int j = 0; j < col; j++){
		if(map[row - 1][j] == '0')dfs(row - 1, j);
	}
	int res = 0;
	for(int i = 0; i < row; i++){
		for(int j = 0; j < col; j++){
			if(map[i][j] == '0'){
				res++;
			}
		}
	}
	cout << res << endl;
	return 0;
}
5. 417. 太平洋大西洋水流问题 - 力扣（LeetCode）

给定一个岛屿，这个岛屿的上面和左面是太平洋。岛屿的右面和下面是大西洋。

方格中的数字代表高度。水只能从高处往低处流，即：只能从数字大的格子向数字小的格子流。现在要求哪些格子的水既能流到太平洋，也能流到大西洋。

此题用到了类似的思想，即从外围向内搜索。将太平洋能达到的格子标记，将大西洋能到达的格子标记（这里的到达应为反过来，即：数字递增）。一个格子中同时标记了两个的即为答案。

image-20240511210940416

class Solution {
public:
    int dx[4] = {0, 1, 0, -1}, dy[4] = {-1, 0, 1, 0};
    int row, col;
    vector<vector<int>> g;
    vector<vector<int>> st;
    vector<vector<int>> pacificAtlantic(vector<vector<int>>& heights) {
        g = heights;
        row = heights.size();
        col = heights[0].size();
        st = vector<vector<int>>(row, vector<int>(col));
        for(int i = 0; i < row; i++){
            dfs(i, 0, 1);
        }
        for(int j = 0; j < col; j++){
            dfs(0, j, 1);
        }
        for(int i = 0; i < row; i++){
            dfs(i, col - 1, 2);
        }
        for(int j = 0; j < col; j++){
            dfs(row - 1, j, 2);
        }
        vector<vector<int>> res;
        for(int i = 0; i < row; i++){
            for(int j = 0; j < col; j++){
                if(st[i][j] == 3){
                    res.push_back({i, j});
                }
            }
        }
        return res;
    }
    void dfs(int x, int y, int t){
        if(st[x][y] & t){
            return;
        }
        st[x][y] |= t;
        for(int i = 0; i < 4; i++){
            int a = x + dx[i], b = y + dy[i];
            if(a >= 0 && a < row && b >= 0 && b < col && g[a][b] >= g[x][y]){
                dfs(a, b, t);
            }
        }
    }
};

在这里，我用的标记方法是二进制的标记法。假设有一个两位的二进制数。如过这两位为00，则代表太平洋和大西洋都不能到达的格子。01代表太平洋能到达的格子但大西洋不能到达的格子。10代表太平洋不能到达格子但大西洋能到达的格子。11代表太平洋和大西洋同时可以到达的格子，即为答案。

具体实现如下：

void dfs(int x, int y, int t)

这里参数t的作用就是标记。仅考虑两位，0的二进制数为00，1的二进制数为01，2的二进制数为10，3的二进制数为11。

6. 827. 最大人工岛 - 力扣（LeetCode）

给定一个矩阵，最多可将矩阵中的一个格子的0变成1。求经过此变换后最大的岛屿面积。（岛屿是1所形成的连通块）。

此题我是用并查集维护的。关于并查集：并查集的作用、原理与实现-CSDN博客

并查集的作用有：

1. 询问两个元素是否属于同一个集合。
1. 将两个集合合并为一个集合。

将0改为1后使得两个岛屿连通。即并查集的作用：将两个集合合并为一个集合。

而在合并时，我们需要询问这两个岛屿是否属于一个岛屿，如果本来就属于一个岛屿，那么就无需将两个集合合并成一个集合。这里用了并查集的询问。

所以此处使用并查集最为贴切。

image-20240511212316451

class Solution {
public:
    vector<int> p, sz;
    int row, col;
    int dx[4] = {0, 1, 0, -1}, dy[4] = {-1, 0, 1, 0};
    int find(int x){
        if(p[x] != x){
            p[x] = find(p[x]);
        }
        return p[x];
    }
    int get(int x, int y){
        return x * col + y;
    }
    int largestIsland(vector<vector<int>>& grid) {
        row = grid.size(), col = grid[0].size();
        for(int i = 0; i < row * col; i++){
            p.push_back(i);
            sz.push_back(1);
        }
        int res = 0;
        for(int i = 0; i < row; i++){
            for(int j = 0; j < col; j++){
                if(grid[i][j]){
                    int a = get(i, j);
                    for(int k = 0; k < 4; k++){
                        int x = i + dx[k], y = j + dy[k];
                        if(x >= 0 && x < row && y >= 0 && y < col && grid[x][y]){
                            int b = get(x, y);
                            if(find(a) != find(b)){
                                sz[find(a)] += sz[find(b)];
                                p[find(b)] = find(a);
                            }
                        }
                    }
                    res = max(res, sz[find(a)]);
                }
            }
        }
        for(int i = 0; i < row; i++){
            for(int j = 0; j < col; j++){
                if(!grid[i][j]){
                    map<int, int> hash;
                    for(int k = 0; k < 4; k++){
                        int x = i + dx[k], y = j + dy[k];
                        if(x >= 0 && x < row && y >= 0 && y < col && grid[x][y]){
                            int a = get(x, y);
                            hash[find(a)] = sz[find(a)];
                        }
                    }
                    int s = 1;
                    for(auto [k, v] : hash){
                        s += v;
                    }
                    res = max(res, s);
                }
            }
        }
        return res;
    }
};

并查集的定义，find函数和初始化：

sz数组用来维护每个集合数量的问题。

vector<int> p, sz;
int find(int x){
        if(p[x] != x){
            p[x] = find(p[x]);
        }
        return p[x];
}
for(int i = 0; i < row * col; i++){
            p.push_back(i);
            sz.push_back(1);
}

将二位下标转为一维下标：

int get(int x, int y){
        return x * col + y;
}

这里就是遍历数组，当格子数字为1时，遍历它四个方向上的格子。如果它的四个方向上的格子有是1的，就先询问两个元素是否属于同一个岛屿（集合），若不属于，就将两个岛屿（集合）合并为一个岛屿（集合），并更新这个集合的大小。最开始初始化并查集时，我们将每个数字为1的方格看成是独立的集合。

res暂时为这些岛屿中最大的。

for(int i = 0; i < row; i++){
            for(int j = 0; j < col; j++){
                if(grid[i][j]){
                    int a = get(i, j);
                    for(int k = 0; k < 4; k++){
                        int x = i + dx[k], y = j + dy[k];
                        if(x >= 0 && x < row && y >= 0 && y < col && grid[x][y]){
                            int b = get(x, y);
                            if(find(a) != find(b)){
                                sz[find(a)] += sz[find(b)];
                                p[find(b)] = find(a);
                            }
                        }
                    }
                    res = max(res, sz[find(a)]);
                }
            }
        }

遍历数字为0的格子，询问它四个方向上的格子。开哈希表去记录上下左右四个方向上的岛屿的面积。这里使用哈希表还可以避免重复操作。

如果不使用哈希表，当多个相邻的1属于同一个岛屿时，我们可能会多次计算同一个岛屿的面积。

哈希表以岛屿的根节点作为键，岛屿的大小作为值。通过检查并更新哈希表，我们可以确保即使多个相邻的1属于同一个岛屿，该岛屿的面积也只被计算并加入总和一次。

随后返回res。

 for(int i = 0; i < row; i++){
            for(int j = 0; j < col; j++){
                if(!grid[i][j]){
                    map<int, int> hash;
                    for(int k = 0; k < 4; k++){
                        int x = i + dx[k], y = j + dy[k];
                        if(x >= 0 && x < row && y >= 0 && y < col && grid[x][y]){
                            int a = get(x, y);
                            hash[find(a)] = sz[find(a)];
                        }
                    }
                    int s = 1;
                    for(auto [k, v] : hash){
                        s += v;
                    }
                    res = max(res, s);
                }
            }
        }
        return res;
7. 463. 岛屿的周长 - 力扣（LeetCode）

给定岛屿，求岛屿的周长。此题只需简单对每个格子四个方向遍历即可解决。

image-20240511215751647

class Solution {
public:
    int dx[4] = {0, 1, 0, -1}, dy[4] = {-1, 0, 1, 0};
    int islandPerimeter(vector<vector<int>>& grid) {
        int row = grid.size(), col = grid[0].size();
        int res = 0;
        for(int i = 0; i < row; i++){
            for(int j = 0; j < col; j++){
                if(grid[i][j]){
                    for(int k = 0; k < 4; k++){
                        int a = i + dx[k], b = j + dy[k];
                        if(a < 0 || a == row || b < 0 || b == col || grid[a][b] == 0){
                            res++;
                        }
                    }
                }
            }
        }
        return res;
    }
};
8. 841. 钥匙和房间 - 力扣（LeetCode）

此题相当于直接给定图的邻接表，直接遍历即可。

image-20240511220026567

class Solution {
public:
    vector<vector<int>> g;
    vector<bool> st;
    int n;
    void dfs(int u){
        st[u] = true;
        for(auto v : g[u]){
            if(st[v] == false){
                dfs(v);
            }
        }
    }
    bool canVisitAllRooms(vector<vector<int>>& rooms) {
        g = rooms;
        n = g.size();
        st = vector<bool>(n);
        dfs(0);
        for(int i = 0; i < n; i++){
            if(st[i] == false){
                return false;
            }
        }
        return true;
    }
};
Doctor_Anonymous
关注
  • 23
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
floodFill.cpp
06-21
此程序有不少按键功能，用鼠标对窗口的图形进行多次单击就可以实现类似PhotoShop中魔棒的效果*/ 按键功能：1：切换彩色/灰度模式 2：显示/隐藏掩膜窗口 3：恢复原始图像 4：使用空范围的漫水填充 ...
floodfill 区域生长法 opencv
11-24
基于vs2010与opencv采用区域生长法实现的图像分割法，经调试可用，一个挺简单的源程序，可供初学者参考
FloodFill算法---DFS
2301_80035594的博客
04-25 1664
floodfill算法是一种图像处理算法，用于填充连通区域。它的作用是将指定的像素点及其相邻的相同颜色的像素点都填充为指定的颜色，从而形成一个封闭的区域。 该算法常用于图像编辑软件中的涂色功能，也可以用于图像分割、边缘检测等应用。通过floodfill算法，可以快速、自动地填充图像中的特定区域，提高图像处理的效率和准确性。 floodfill算法的基本思想是通过递归或者栈来实现。 本文章详细介绍了floodfill算法的基本用法及模板，通过经典例题帮助友友快速掌握，希望可以帮到您。
漫水填充算法原理及其实现
时间流浪者
09-22 2002
一 漫水填充算法描述 1..1 、种子填充算法 种子填充算法是从多边形区域内部的一点开始，由此出发找到区域内的所有像素。 种子填充算法采用的边界定义是区域边界上所有像素具有某个特定的颜色值，区域内部所有像素均不取这一特定颜色，而边界外的像素则可具有与边界相同的颜色值。 具体算法步骤：（1）标记种子（x,y）的像素
OpenCV中泛洪填充算法解析与应用
小白学视觉
04-04 1657
点击上方“小白学视觉”，选择加"星标"或“置顶”重磅干货，第一时间送达 本文转自：opencv学堂泛洪填充(Flood Fill)很多时候国内的开发者称它为漫水填充，该算...
目录_算法_ACwing
qq_44988404的博客
09-11 257
仅目录 文章目录算法基础课第一章 基础算法1. 基础算法（1）排序二分快速排序1.基础算法（2）高精度（C++）1.基础算法（3）2.数据结构（1）2.数据结构（2）3.搜索与图论（1）3.搜索与图论（2）3.搜索与图论（3）4.数学知识（1）4.数学知识（2）4.数学知识（3）4.数学知识（4）5.动态规划（1）5.动态规划（2）5.动态规划（3）6.贪心算法（1）6.贪心算法（2）7.时空复杂度习题课（1）（2）（3）（4）（7）（8）第二章 算法提高课AcWing算法课<一>数学三角形模型
halcon中的分水岭算法讲解以及作用和实例
weixin_44490080的博客
09-17 4739
分水岭，顾名思义由地貌中的视觉形态演变而来。我们用一种场景来说明，想象一个干涩得裂开的农田赶上下雨，最终淹没到只看得见稻苗。它的整个过程先是灌满地势低的土地裂缝然后慢慢淹没整块土地只剩看得到稻苗。 将上面的思想引入到图像区域的分割上，我们就很容易实现一种以“侵泡”式的图像分割，其基本思想是把图像看作测地学上的拓扑地貌，图像中的每一点像素的灰度值表示该点的海拔高度，高灰度值代表山脉，低灰度值代表盆...
ACM算法相关资料
鲍礼彬的CSDN博客 ~_~
09-26 1966
ACM算法相关资料 一：知识点 数据结构： 1，单，双链表及循环链表 2，树的表示与存储，二叉树（概念，遍历）二叉树的 应用（二叉排序树，判定树，博弈树，解答树等） 3，文件操作（从文本文件中读入数据并输出到文本文 件中） 4，图（基本概念，存储结构，图的运算） 数学知识 1，离散数学知识的应用（如排列组合、简单的图论，数理逻辑） 2，数论知识 3，线性代数 4，组合
种子生长相关算法实现
此人小白一枚的博客
09-07 3207
下文提到的种子点生长算法，包括泛洪法，扫描线法，区段法三种。文本先从最简单的泛洪法入手介绍种子点生长算法的相关概念。之后进一步讨论了扫描线法和区段法，同时提供了实验数据验证其中的一些结论。本文按照如下的结构来介绍： 泛洪法扫描线法区段法算法分析对比以及实验 一、泛洪法 　　1.简介 　　泛洪法，又叫Floodfill算法，属于图像处理算法，是从图像中寻找连通区域的经典算法。
算法竞赛入门经典（第2版）—第六章（数据结构基础）
Accept1234的博客
07-26 1469
文章目录零碎知识点整理题目514 - Rails442 - Matrix Chain Multiplication11988 - Broken Keyboard (a.k.a. Beiju Text) 零碎知识点整理 题目 514 - Rails 题目链接：514 - Rails 题目大意：火车按序进栈，给定火车出栈的顺序，问火车能否按照这个顺序出栈。 思路：简单的栈应用，序号每次入栈后,均需要...
动画学信奥 漫画学算法 CSP-J入门级 （三）、算法（依据「NOI大纲」）
青少年趣味编程
03-23 2250
3. 基础算法 贪心法 学不懂算法很烦恼? 快来看动画，学习贪心算法，LeetCode 分糖果 https://www.ixigua.com/6906764305388012035 学不懂算法很烦恼? 快来看动画，轻松学算法，贪心算法，LeetCode 455 分糖果 学不懂算法很烦恼? 快来看动画，轻松学算法，贪心算法，LeetCode 455 分糖果_哔哩哔哩_bilibili 程序员大厂面试必会算法 贪心算法中的经典题目 跳跃游戏 (LeetCode 55) 程序员大厂面试必
FloodFill算法详解及应用.md
11-17
FloodFill算法详解及应用.md
50_floodFill2_漫水填充算法_
10-03
漫水填充算法实例，代码质量较高，而且中文注释较多，在各个关键地方都有相应注释
洪水填充算法（floodfill)--2021.09.06(E).pdf
09-06
洪水填充算法是一种常用的图像处理算法，具有广泛的应用前景。该算法可以用来填充图像中的区域，实现图像的编辑和处理。但是，该算法也存在一些缺点，如算法的复杂度较高，需要大量的计算资源。
力扣LCP 08.剧情触发时间
Pisasama的博客
06-12 427
【代码】力扣LCP 08.剧情触发时间。
【代码随想录】【算法训练营】【第35天】[134]加油站 [135]分发糖果 [860]柠檬水找零 [406]根据身高重建队列
weixin_54954007的博客
06-11 287
思路及算法思维，指路。题目来自。day 35，连休两天~
力扣416 分割等和子集 Java版本
最新发布
m0_47066863的博客
06-14 421
然后就可以考虑用0-1背包的思路来解决这个问题，这里元素的值就是当前元素的价值和重量，背包的容量就是子集元素和的一半，最终需要确定这个背包里是否能够正好装进价值为子集和一半的时候。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。找出两个子集，让这两个子集的和相等可以转化思路为：找到一个子集，这个子集的和是子集中所有元素和的一半。解释：数组可以分割成 [1, 5, 5] 和 [11]。输入：nums = [1,5,11,5]输入：nums = [1,2,3,5]
指针和数组
2301_77634163的博客
06-10 430
有3个指针，中间是一个数组arr，有个指针指向中间,其他两个指向两边，一个指向前面，一个人指向后面。虽然简化好，但是我们C语言要求是不允许这样写的,虽然大部分编译器是可以允许我这样写的。下面那个用数组名也是可以用的，因为他也表示一个地址，加1就会找后面那个元素的地址。我们C语言编译器中说指针允许往后比较大小，但不允许往前比面的指针比较大小。地址向后移，指针相比较，指针减减就是减去一个整数。同一指针相减的绝对值得到的是之间元素的个数。数组和指针的地址是一样的，说明是可以的。地址加地址，指针加指针没有意义。
FLOODFill算法和Dijkstra算法的比较
04-18
FloodFill算法和Dijkstra算法都是常用的图算法，但是它们的应用场景和实现方式不同。 FloodFill算法主要用于填充图像或区域，它从给定的起点开始，将其周围相邻的像素按照特定的条件逐个填充，直到将整个区域或或...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值