LeetCode——图

最新推荐文章于 2022-08-22 08:09:55 发布
最新推荐文章于 2022-08-22 08:09:55 发布
阅读量538 收藏
点赞数
文章标签： 队列 算法 数据结构 dfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/arashi_5/article/details/115589481
版权

图

200. 岛屿数量

给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。

岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。

此外，你可以假设该网格的四条边均被水包围。
在这里插入图片描述

方法一：深度优先搜索

  • 将二维网格看成一个无向图，竖直或水平相邻的1之间有边相连。
  • 扫描整个二维网格，遍历每个元素。
  • 如果该位置为1，就将它作为起始节点开始深度优先搜索，并将其置为0，然后考察该节点的上下左右结点，看是否属于岛屿部分
  • 经过上一步骤的深度优先搜索，将属于同一岛屿内的元素都置为了0，遍历网格再遇到的1属于新的岛屿，岛屿数加一
  • 最终的岛屿数就是进行深度优先搜索的次数
    在这里插入图片描述
    代码
class Solution {
private:
    void dfs(vector<vector<char>>& grid, int r, int c) {
        //深度优先搜索
        int nr = grid.size();   //获得数组的行数
        int nc = grid[0].size();//列数

        //将当前格的值设为0，表示已经遍历过了
        grid[r][c] = '0';
        //遍历上下左右四个
        if (r - 1 >= 0 && grid[r-1][c] == '1') dfs(grid, r - 1, c);
        if (r + 1 < nr && grid[r+1][c] == '1') dfs(grid, r + 1, c);
        if (c - 1 >= 0 && grid[r][c-1] == '1') dfs(grid, r, c - 1);
        if (c + 1 < nc && grid[r][c+1] == '1') dfs(grid, r, c + 1);
    }

public:
    int numIslands(vector<vector<char>>& grid) {
        int nr = grid.size();
        if (!nr) return 0;
        int nc = grid[0].size();

        //岛屿数计数
        int num_islands = 0;
        //遍历每个数组元素，如果值为1，就调用dfs函数进行深度优先搜索
        //深度优先搜索的过程中会将属于同一岛屿（上下左右相邻的1）的元素置为0，即下次再遇到1时说明遇到了新的岛屿，岛屿数加一
        for (int r = 0; r < nr; ++r) {
            for (int c = 0; c < nc; ++c) {
                if (grid[r][c] == '1') {
                    ++num_islands;
                    dfs(grid, r, c);
                }
            }
        }
        return num_islands;
    }
};

方法二：广度优先搜索

深度优先搜索利用递归实现，广度优先搜索利用队列实现。

  • 同样 扫描整个网格，如果一个位置为1，就将它加入队列，然后开始广度优先搜索
  • 广度优先搜索的过程中，每个搜索到的1都会被置为0，直到队列为空，搜索结束。
  • 最终岛屿的数量就是我们进行广度优先搜索的次数。

代码

class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
        int nr = grid.size();
        if (!nr) return 0;
        int nc = grid[0].size();

        int num_islands = 0;
        for (int r = 0; r < nr; ++r) {
            for (int c = 0; c < nc; ++c) {
                if (grid[r][c] == '1') {
                    ++num_islands;
                    grid[r][c] = '0';
                    queue<pair<int, int>> neighbors;
                    //加入队列
                    neighbors.push({r, c});
                    //广度优先搜索
                    while (!neighbors.empty()) {
                        auto rc = neighbors.front();
                        neighbors.pop();
                        int row = rc.first, col = rc.second;
                        //考察当前结点的上下左右是否为1，为1就加入队列，然后将其置为0，代表已经遍历过了
                        if (row - 1 >= 0 && grid[row-1][col] == '1') {
                            neighbors.push({row-1, col});
                            grid[row-1][col] = '0';
                        }
                        if (row + 1 < nr && grid[row+1][col] == '1') {
                            neighbors.push({row+1, col});
                            grid[row+1][col] = '0';
                        }
                        if (col - 1 >= 0 && grid[row][col-1] == '1') {
                            neighbors.push({row, col-1});
                            grid[row][col-1] = '0';
                        }
                        if (col + 1 < nc && grid[row][col+1] == '1') {
                            neighbors.push({row, col+1});
                            grid[row][col+1] = '0';
                        }
                    }
                }
            }
        }
        return num_islands;
    }
};

733. 图像渲染（遍历邻接点，队列）

一个图像（二维数组），每个元素的数值在0到65535之间，给定坐标(sr,sc)，表示图像渲染开始的位置，以及一个新的颜色值newColor，如果该位置原本的值就等于新颜色值，那就不进行渲染，直接返回image
渲染从初始坐标开始，考察它的上下左右四个方向的值，如果等于初始坐标的值，就对他进行渲染，然后再看它的邻接点，返回经过上色渲染后的图像
在这里插入图片描述

思路

利用广度优先遍历

  • 用一个辅助队列来保存没有访问过并且值等于初始坐标值的点
  • 官方题解对于访问邻接点有个很好的方法，先定义两个数组
const int dx[4] = {1, 0, 0, -1};
const int dy[4] = {0, 1, -1, 0};
  • 然后只需要在中心坐标的基础上加数组元素，就能实现上下左右四个邻接点的遍历
for (int i = 0; i < 4; i++) {
                int mx = x + dx[i], my = y + dy[i];
                if (mx >= 0 && mx < n && my >= 0 && my < m && image[mx][my] == currColor) {
                    que.emplace(mx, my);
                    image[mx][my] = newColor;
                }
            }

代码

class Solution {
public:
    //用于访问邻接点
    const int dx[4] = {1, 0, 0, -1};
    const int dy[4] = {0, 1, -1, 0};
    vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int newColor) {
        int currColor = image[sr][sc];
        if (currColor == newColor) return image;
        int n = image.size(), m = image[0].size();
        //辅助队列
        queue<pair<int, int>> que;
        //初始点入队
        que.emplace(sr, sc);
        //渲染初始点
        image[sr][sc] = newColor;
        while (!que.empty()) {
            int x = que.front().first, y = que.front().second;
            que.pop();
            for (int i = 0; i < 4; i++) {
            	//考察当前位置的上下左右坐标
                int mx = x + dx[i], my = y + dy[i];
                //满足条件的结点入队
                if (mx >= 0 && mx < n && my >= 0 && my < m && image[mx][my] == currColor) {
                    que.emplace(mx, my);
                    image[mx][my] = newColor;
                }
            }
        }
        return image;
    }
};

深度优先遍历
一条路走到黑
代码

class Solution {
public:
    //上下左右坐标
    int x[4]={1,0,0,-1};
    int y[4]={0,1,-1,0};
    //深度优先遍历
    void DFS(vector<vector<int>>& image,int sr, int sc, int newColor,int old,int r,int c)
    {
        image[sr][sc]=newColor;
        for(int i=0;i<4;i++)
        {
            int m_x=sr+x[i];
            int m_y=sc+y[i];
            if(m_x<r&&m_x>=0&&m_y<c&&m_y>=0)
            {
                if(image[m_x][m_y]==old)
                {
                    DFS(image,m_x,m_y,newColor,old,r,c);
                }
            }
        }
    }
    vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int newColor) {
        //深度优先，一条路走到黑
        if(image[sr][sc]==newColor)
        return image;
        int m=image.size();
        int n=image[0].size();
        int oldcolor=image[sr][sc];

        //启动深度优先遍历
        DFS(image,sr,sc,newColor,oldcolor,m,n);

        return image;
    }
};

542. 01 矩阵（队列）

给定一个由 0 和 1 组成的矩阵 mat ，请输出一个大小相同的矩阵，其中每一个格子是 mat 中对应位置元素到最近的 0 的距离。
两个相邻元素间的距离为 1
示例

思路

  • 参照官方题解
  • 题目要求是对于每个1，找到离他最近的0
  • 题目中可能存在多个0，为了找到离1最近的那个0，可以从0的位置开始进行广度优先搜索
  • 广度优先搜索可以找到从起点到其余所有点的 最短距离，因此如果我们从 0 开始搜索，每次搜索到一个 1，就可以得到 0 到这个 11 的最短距离
  • 对于多个0，将这些0全部加入队列中，并且作为已访问过的点
    算法

代码

class Solution {
public:
    int dx[4]={1,0,0,-1};
    int dy[4]={0,1,-1,0};
    vector<vector<int>> updateMatrix(vector<vector<int>>& mat) {
        //对矩阵中的每个1开启广度优先搜索，一层一层地向外扩张找0
        //开启的搜索次数是该1到最近的0的距离
        int r=mat.size();
        int c=mat[0].size();
        
        //结果矩阵
        vector<vector<int>>res(r,vector<int>(c,0));
        //已访问的结点
        vector<vector<int>>V(r,vector<int>(c,0));
        //辅助队列
        queue<pair<int,int>>Q;
        //遍历原矩阵的每个元素，将0加入队列
        for(int i=0;i<r;i++)
        {
            for(int j=0;j<c;j++)
            {
                if(mat[i][j]==0)
                {
                    Q.emplace(i,j);
                    V[i][j]=1;
                }
            }
        }
        
        while(!Q.empty())
        {
            int x=Q.front().first;
            int y=Q.front().second;
            Q.pop();
            for(int i=0;i<4;i++)
            {
                int mx=x+dx[i];
                int my=y+dy[i];
                //遇到没访问过得非0点
                if(mx>=0 && mx<r && my>=0 && my<c && !V[mx][my])
                {
                    res[mx][my]=res[x][y]+1;
                    Q.emplace(mx,my);
                    V[mx][my]=1;
                }
            }
        }
        return res;
    }
    //广度优先搜索，找0
    int BFS(vector<vector<int>>& mat,vector<vector<int>>& V,int nr,int nc)
    {
        int r=mat.size();
        int c=mat[0].size();
        //辅助队列
        queue<pair<int,int>>Q;
        Q.emplace(nr,nc);
        V[nr][nc]=1;
        int n=1;
        while(!Q.empty())
        {
            int x=Q.front().first;
            int y=Q.front().second;
            Q.pop();
            for(int i=0;i<4;i++)
            {
                int mx=x+dx[i];
                int my=y+dy[i];
                if(mx>=0 && mx<r && my>=0 && my<c && !V[mx][my])
                {
                    if(mat[mx][my]==1)
                    {
                        Q.emplace(mx,my);
                        V[mx][my]=1;
                    }
                    else if(mat[mx][my]==0)
                    return n;
                }
            }
            n++;
        }
        return 0;
    }
};

994. 腐烂的橘子

在给定的网格中，每个单元格可以有以下三个值之一：

值 0 代表空单元格；
值 1 代表新鲜橘子；
值 2 代表腐烂的橘子。

每分钟，任何与腐烂的橘子（在 4 个正方向上）相邻的新鲜橘子都会腐烂。
返回直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 -1。
示例
思路

  • 类似上一道01矩阵，利用多源广度优先搜索来解决问题，先将所有腐烂橘子加入队列，如果一开始就没有腐烂橘子，返回0
  • 每次出队时，看它周围有没有新鲜橘子（1），有的话，将它也腐蚀掉，置为2，并将这个橘子也加入队列
  • 每一轮中出队的橘子是属于同一层的，每一轮结束后计数器会加1
  • 一轮一轮地向外腐蚀扩张，直到再也找不到新鲜橘子可以加入队列，跳出循环
  • 跳出后，检查是否还存在没有被腐蚀的新鲜橘子，如果有的话，返回-1
  • 计数的时候有点小问题，我设置的是每一轮出队结束后+1，但是最后一轮出队时，腐烂橘子周围已经没有新鲜橘子可以腐蚀了，没有腐蚀的过程，多加了一个1，要减去

代码

class Solution {
public:
    int dx[4]={1,0,0,-1};
    int dy[4]={0,1,-1,0};
    int orangesRotting(vector<vector<int>>& grid) {
        //类似01矩阵那道题
        int m=grid.size();
        int n=grid[0].size();
        int ans=0;
        queue<pair<int,int>>Q;
        //将腐烂橘子加入队列
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(grid[i][j]==2)
                Q.emplace(i,j);
            }
        }
        while(!Q.empty())
        {
            //每次出队的是同一轮中被腐蚀的橘子
            int size=Q.size();
            for(int k=0;k<size;k++)
            {
                int mx=Q.front().first;
                int my=Q.front().second;
                Q.pop();
                for(int i=0;i<4;i++)
                {
                    int x=mx+dx[i];
                    int y=my+dy[i];
                    if(x>=0 && x<m && y>=0 && y<n && grid[x][y]==1)
                    {
                        Q.emplace(x,y);
                        grid[x][y]=2;
                    }
                }
            }
            ans++;
        }
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(grid[i][j]==1)
                return -1;
            }
        }
        //最后一轮出队时，没有找到新鲜橘子，次数上多加了一次
        if(ans)
        return ans-1;

        return ans;
    }
};

复杂度

  • 时间O(m×n)
  • 空间O(m×n），队列中存放的元素最多m×n个

695. 岛屿的最大面积

给定一个包含了一些 0 和 1 的非空二维数组 grid。
一个 岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在水平或者竖直方向上相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。
找到给定的二维数组中最大的岛屿面积。(如果没有岛屿，则返回面积为0。)
示例
思路：

  • 遍历图像每个元素，遇到1就启动广度优先搜索，看他周围有多少1
  • 广度优先遍历中，将当前元素加入队列，计数+1
  • 然后看他上下左右四个数，如果是1的话，就再加入队列
  • 队列中非空时，出队，然后继续向周围扩散
  • 访问过的元素都要标记为0

代码

class Solution {
public:
    int x[4]={1,0,0,-1};
    int y[4]={0,1,-1,0};

    //广度优先
    int BFS(vector<vector<int>>& grid,int sr,int sc,int s,int c)
    {
        int n=1;
        //辅助队列
        queue<pair<int,int>>Q;
        Q.emplace(sr,sc);
        grid[sr][sc]=0;
        while(!Q.empty())
        {
            int i=Q.front().first;
            int j=Q.front().second;
            Q.pop();
            for(int k=0;k<4;k++)
            {
                int m_x=i+x[k];
                int m_y=j+y[k];
                if(m_x>=0&&m_x<s&&m_y>=0&&m_y<c)
                {
                    if(grid[m_x][m_y])
                    {
                        n++;
                        Q.emplace(m_x,m_y);
                        grid[m_x][m_y]=0;
                    }
                }
            }
        }
        return n;
    }
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        int m=grid.size();
        int n=grid[0].size();
        //广度优先遍历
        int ans=0;
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                //遇到岛屿，开启广度优先搜索，看这个岛屿有多少1
                if(grid[i][j]==1)
                {
                    int tmp=BFS(grid,i,j,m,n);
                    ans=max(ans,tmp);
                }
            }
        }
        return ans;
    }
};

复杂度

  • 时间O(n*m)，n是网格行数，m是网格列数，每个网格只返问一次
  • 空间O(n*m)，队列中最多会存放所有的土地
ninomiya33
关注
leetcode 经典 图相关题目(思路、方法、code)
Ding 的博客
05-10 2884
图的问题基本就是 BFS和DFS，还有拓扑排序、最短路、最小生成树，有时也会用并查集进行分类，还要注意节点的入度出度等特征。 文章目录[207. 课程表](https://leetcode-cn.com/problems/course-schedule/)[210. 课程表 II](https://leetcode-cn.com/problems/course-schedule-ii/)[684. 冗余连接](https://leetcode-cn.com/problems/redundant-connec
LeetCode——移除元素
12-22
【LeetCode——移除元素】这个问题是LeetCode中的一道经典算法题，要求在原地修改数组，移除所有等于给定值`val`的元素，并返回移除后的数组长度。题目强调不允许使用额外的数组空间，且需保证在O(1)额外空间复杂度...
LeetCode总结 -- 图篇
热门推荐
Code Ganker
09-18 2万+
图的算法跟树一样是准备面试中必不可少的一块，不过图的方法很容易概括，面试中考核的无非就是两种搜索算法：深度优先搜索和广度优先搜索。LeetCode中关于图的问题有以下几个：Clone GraphWord LadderWord Ladder IILongest Consecutive SequenceWord SearchSurrounded Regions先来看看最基础的Clone Graph，很
leetcode-图
weixin_42127177的博客
04-05 719
797-所有可能的路径 给你一个有 n 个节点的 有向无环图（DAG），请你找出所有从节点 0 到节点 n-1 的路径并输出（不要求按特定顺序） graph[i] 是一个从节点 i 可以访问的所有节点的列表（即从节点 i 到节点 graph[i][j]存在一条有向边）。 方法一：图的深度优先搜索 我们可以使用深度优先搜索的方式求出所有可能的路径。具体地，我们从 0号点出发，使用栈记录路径上的点。每次我们遍历到点 n−1，就将栈中记录的路径加入到答案中。 特别地，因为本题中的图为有向无环图（DAG），搜索过
leetcode图
Molly
05-07 1012
leetcode图的相关题目解析： 对图的遍历就是两个经典的方法DFS和BFS。BFS经常用Queue实现，DFS经常用递归实现（可改为栈实现）。1、Clone Graph 题意：给定图中一个节点，克隆图 思路：用HashMap，key存lable值，value存新clone的node，用BFS方法遍历帮助拷贝neighbors的值。给定给一个节点，若lable在map中有，则表示已经clon
LeetCode基础-图
gnimgnot
11-05 377
图的定义： 由一组顶点（Vertex）和一组能够连接做任意两个顶点的边（Edge）的集合组成。图的应用： 地图：比如两点之间的最短路径。 网页信息：比如多个页面之间的引用关系。 电路：元件之间的连接关系。 任务调度：比如最少的时间完成有依赖关系的工序调度。 商业交易：比如表示现金和商品在买卖双方之间的转移，以理解对市场的理解。 配对：学生与各种社团之间的关系。一个学生可能参与多个社团。 计算机网络
LeetCode——两数之和
01-20
一.个人探索 二.网上优秀编程 三....一....1.暴力解法 答题思路：两个循环来遍历列表中的所有组合可能来获取答案值。...优点：简单易懂，比较容易想到的一种嵌套循环进行遍历的思想。...缺点：使用嵌套循环遍历整个数据，耗费...
LeetCode——001 Two Sum
01-07
Description Given an array of integers, return indices of the two numbers such that they add up to a specific target. You may assume that each input would have exactly one solution, and you may not ...
LeetCode——–接雨水python
12-21
在LeetCode的“接雨水”问题中，我们面临一个经典的二维数组处理挑战。该问题的目标是计算在一个由整数组成的数组（代表地形）中，能够接住多少单位的雨水。数组中的每个元素代表一块地面的高度，雨水会在高度较低的...
leetcode_图
powerful_ren的博客
05-09 267
文章目录785. 判断二分图207. 课程表 785. 判断二分图 给定一个无向图graph，当这个图为二分图时返回true。 如果我们能将一个图的节点集合分割成两个独立的子集A和B，并使图中的每一条边的两个节点一个来自A集合，一个来自B集合，我们就将这个图称为二分图。 graph将会以邻接表方式给出，graph[i]表示图中与节点i相连的所有节点。每个节点都是一个在0到graph.length...
LeetCode—图
weixin_42589774的博客
06-17 264
LeetCode—图 二分图（可以将图中的所有顶点分成两个不想交的集合，使得同一个集合的顶点不相连） 如果可以用两种颜色对图中的节点进行着色，并且保证相邻的节点颜色不同，那么这个图就是二分图。 1、判断是否为二分图 T785. Is Graph Bipartite? (Medium) class Solution { public: bool isBipartite(vector<vector<int>>& graph) { vector<in
LeetCode | 图
qq_40933711的博客
06-24 406
LeetCode图类题目合集
leetcode题型分析《图》
陌上烟雨遥的博客
08-22 369
图 1)图的搜索 广度优先搜索和深度优先搜索 剑指offer II 105:最大岛屿面积 step1 找出图的节点和边，将为1的岛屿视为图的节点，上下左右相邻格子为1的节点之间有条边。 step 2 逐一扫描每一个节点，当遇到节点为1，且不在已知岛屿表明到达一个新的岛屿并重新计算岛屿面积。定义一个visited二维数组，存到被访问过的节点。 step 3比较所有岛屿面积，求出面积最大那个。 广度优先搜索具体实现：定义一个queue，首先将起始节点加入队列中，然后取出队列中节点并访问其相邻节点，
LeetCode 图相关知识
Robin_812656252的博客
08-07 236
图论知识点众多，LeetCode最常涉及的便是有向图与无向图的遍历算法。 例如下有向图，使用 邻接矩阵 与 邻接表 存储。 邻接矩阵 使用N*N的二维数组存储，a[i][j] = 1意思着 i -> j存在连接，也可以用来存权。 邻接表 使用N个元素的一维数组分别存储一个列表，列表中存储与第i个元素相连的所有元素。 构造邻接矩阵与邻接表 构造邻接矩阵 public int[][] assemMap(){ ...
LeetCode：图
sfklyqh的博客
01-14 247
207：你这个学期必须选修 numCourses 门课程，记为 0 到 numCourses - 1 。 在选修某些课程之前需要一些先修课程。 先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] ，表示如果要学习课程 ai 则 必须 先学习课程 bi 。 例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。 请你判断是否可能完成所有课程的学习？如果可以，返回 true ；否则，返回 false 。 class S.
LeetCode常见题型——图
贫道绝缘子的博客
08-22 553
图是树的升级版。图通常分为有向（directed）或无向（undirected），有循环（cyclic）或无循环（acyclic），所有节点相连（connected）或不相连（disconnected）。
Leetcode - 图（一）
xuanshuang的博客
07-06 859
997. 找到小镇的法官 https://leetcode-cn.com/problems/find-the-town-judge/ 在一个小镇里，按从 1 到 N 标记了N 个人。传言称，这些人中有一个是小镇上的秘密法官。如果小镇的法官真的存在，那么： 小镇的法官不相信任何人。 每个人（除了小镇法官外）都信任小镇的法官。 只有一个人同时满足属性 1 和属性 2 。 给定数组trust，该数组由信任对 trust[i] = [a, b]组成，表示标记为 a 的人信任标记为 b 的人。如果小镇...
Leetcode - 图（二）
xuanshuang的博客
07-11 259
743. 网络延迟时间 https://leetcode-cn.com/problems/network-delay-time/ 有N个网络节点，标记为1到N。给定一个列表times，表示信号经过有向边的传递时间。times[i] = (u, v, w)，其中u是源节点，v是目标节点， w是一个信号从源节点传递到目标节点的时间。现在，我们从某个节点K发出一个信号。需要多久才能使所有节点都收到信号？如果不能使所有节点收到信号，返回-1。 注意:N的范围在[1, ...
LeetCode基础-图-BFS
gnimgnot
11-06 477
BFS：Breadth First Search，广度优先搜索。 当有这样一个问题：计算图中两点之间的最短距离时，需要广度优先搜索，BFS 也是很多图算法的基石。要找到顶点 s 到 顶点 v 的最短路径，从 s 开始，在所有距离 s 一条边的顶点中寻找 v，如果找不到，就继续在与 s 距离一条边的顶点中寻找 v，如此下去，走到找到 v。深度优先搜索就好像是一个人在走迷宫，而广度优先搜索就像是一组人
苏大Python复试上机：LeetCode高频题集——英语字母顺序挑战
在苏州大学的Python复试上机环节，学生可能会被要求解决一系列来自LeetCode的编程问题，以检验他们的编程能力和对Python的理解。这些题目涵盖了多个主题，包括但不限于字符串处理、数组操作、哈希表应用、数学算法、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值