算法整理之并查集

已于 2024-03-15 16:35:41 修改
阅读量1.3k 收藏 54
点赞数 39
文章标签： 算法 java leetcode
于 2024-03-15 16:34:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44591233/article/details/136743631
版权

并查集

主要解决图论中的连通性问题

基本模板：
在这里插入图片描述
关键步骤：

  • 初始化将所有节点的父节点都指向自己
  • 需要路径压缩降低查询父节点的复杂度
class UnionFind{
    int[] parent; // 记录每个节点的父节点(但这个父节点不一定是顶级父节点)

    public UnionFind(int n){
        this.parent = new int[n];

        for(int i=0; i<n; i++){
            parent[i] = i; // 初始化每个节点的父亲就是自己
        }
    }

    // 查询节点x的顶级父节点
    public int find(int x){
        if(parent[x] == x) return x; // 当前节点的父节点就是自己，则当前节点就是顶级父节点
        else{
            // 路径压缩：当前节点父节点parent[x] = 当前节点父节点parent[x]的顶级父节点
            //         从而将路径上的所有节点都统一指向了顶级父节点
            parent[x] = find(parent[x]);
        }

        return parent[x];
    }

    // 合并两节点
    public void unite(int x, int y){
        int x_father = find(x); // x 的顶级父节点
        int y_father = find(y); // y 的顶级父节点

        // 建立连接关系
        parent[x_father] = y_father;
    }

    // 判断两个节点是否相连（等价于判读两个节点的顶级父节点是否相同）
    public boolean isConnected(int x, int y){
        int x_father = find(x);
        int y_father = find(y);
        return x_father == y_father;
    }
}

优化模板：

class UnionFind{
    int[] parent; // 记录每个节点的父节点(但这个父节点不一定是顶级父节点)
    int[] size;   // 记录每个节点对应的连通分量中的节点总数
    int n;        // 记录总节点数目
    int setCount; // 当前独立的连通分量数目 (初始化n个节点，有n个独立的连通分量)

    public UnionFind(int n){
        this.parent = new int[n];
        this.size = new int[n];
        this.n = n;
        this.setCount = n; // 初始化还没有任何连通关系，每个节点对应一个独立的连通分量.(一共n个连通分量)

        Arrays.fill(size, 1);
        for(int i=0; i<n; i++){
            parent[i] = i; // 初始化每个节点的父亲就是自己
        }
    }

    // 查询节点x的顶级父节点
    public int find(int x){
        if(parent[x] == x) return x; // 当前节点的父节点就是自己，则当前节点就是顶级父节点
        else{
            // 路径压缩：当前节点父节点parent[x] = 当前节点父节点parent[x]的顶级父节点
            //         从而将路径上的所有节点都统一指向了顶级父节点
            parent[x] = find(parent[x]);
        }

        return parent[x];
    }

    // 合并两节点 (返回是否合并成功)
    public boolean unite(int x, int y){
        int x_father = find(x); // x 的顶级父节点
        int y_father = find(y); // y 的顶级父节点

        if(x_father==y_father) return false;

        // 建立连接关系（路径压缩）
        if(size[x_father] < size[y_father]){ // y对应的连通分量大
            parent[x_father] = y_father; // x_parent父节点设置为y_parent：小集合合并到大集合中
            size[y_father] += size[x_father]; // 只需要维护顶级父节点的size即可
        }else{
            parent[y_father] = x_father; // y_parent父节点设置为x_parent
            size[x_father] += size[y_father];
        }

        setCount--; // 连通分量总数减一
        return true;
    }

    // 判断两个节点是否相连（等价于判读两个节点的顶级父节点是否相同）
    public boolean isConnected(int x, int y){
        int x_father = find(x);
        int y_father = find(y);
        return x_father == y_father;
    }
}

经典例题：

  1. LeeCode1631. 最小体力消耗路径

    • 答案

      // 并查集
class Solution {
    public int minimumEffortPath(int[][] heights) {
        int m = heights.length;
        int n = heights[0].length;
        // 构建图中的连接关系 (int[] = {节点1的id, 节点2的id, 节点1和节点2的高度差})
        List<int[]> edges = new ArrayList<>();
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                int id = i * n + j; // 顺序给每个节点确定id
                if(i>0){ // 竖边
                    edges.add(new int[]{id, id-n, Math.abs(heights[i][j] - heights[i-1][j])});
                }

                if(j>0){ // 横边
                    edges.add(new int[]{id, id-1, Math.abs(heights[i][j] - heights[i][j-1])});
                }
            }
        }

        // 按照高度差将edges从小到大排序
        Collections.sort(edges, (a, b) -> { 
	                return a[2] - b[2];
        });

        // 建立连通性
        UnionFind uf = new UnionFind(m * n); // 一共m*n个节点
        int ans = 0;
        for(int[] edge: edges){ // 遍历每条边(最先遍历高度差小的边)
            int x = edge[0], y = edge[1], v = edge[2];
            uf.unite(x, y); // 连接edge对应的两个节点
            if(uf.isConnected(0, m*n-1)){ // 判断起点和终点是否已经连通
                ans = v; // 当前的v就是目前遇到的最大高度差
                return ans;
            }
        }
        return ans;
    }
}

class UnionFind{
    int[] parent; // 记录每个节点的父节点(但这个父节点不一定是顶级父节点)
    int[] size;   // 记录每个节点对应的连通分量中的节点总数
    int n;        // 记录总节点数目
    int setCount; // 当前独立的连通分量数目 (初始化n个节点，有n个独立的连通分量)

    public UnionFind(int n){
        this.parent = new int[n];
        this.size = new int[n];
        this.n = n;
        this.setCount = n; // 初始化还没有任何连通关系，每个节点对应一个独立的连通分量.(一共n个连通分量)

        Arrays.fill(size, 1);
        for(int i=0; i<n; i++){
            parent[i] = i; // 初始化每个节点的父亲就是自己
        }
    }

    // 查询节点x的顶级父节点
    public int find(int x){
        if(parent[x] == x) return x; // 当前节点的父节点就是自己，则当前节点就是顶级父节点
        else{
            // 路径压缩：当前节点父节点parent[x] = 当前节点父节点parent[x]的顶级父节点
            //         从而将路径上的所有节点都统一指向了顶级父节点
            parent[x] = find(parent[x]);
        }

        return parent[x];
    }

    // 合并两节点 (返回是否合并成功)
    public boolean unite(int x, int y){
        int x_father = find(x); // x 的顶级父节点
        int y_father = find(y); // y 的顶级父节点

        if(x_father==y_father) return false;

        // 建立连接关系（路径压缩）
        if(size[x_father] < size[y_father]){ // y对应的连通分量大
            parent[x_father] = y_father; // x_parent父节点设置为y_parent：小集合合并到大集合中
            size[y_father] += size[x_father]; // 只需要维护顶级父节点的size即可
        }else{
            parent[y_father] = x_father; // y_parent父节点设置为x_parent
            size[x_father] += size[y_father];
        }

        setCount--; // 连通分量总数减一
        return true;
    }

    // 判断两个节点是否相连（等价于判读两个节点的顶级父节点是否相同）
    public boolean isConnected(int x, int y){
        int x_father = find(x);
        int y_father = find(y);
        return x_father == y_father;
    }
}

  2. LeeCode765. 情侣牵手

    • 答案

      // 关键点1: (0,1)为一对情侣，(2,3)为一对情侣。为了方便确定情侣编号，使用人的ID/2表示一对情侣的编号。
//         (0,1)/2 = (0,0)表示ID为0和1的情侣属于第0对情侣；(2,3)/2 = (1,1)表示ID为2和3的情侣属于第1对情侣。以此类推
// 关键点2: 某一对情侣(a,b)被拆散了，那么其中一个人一定会被安排到其他的组合，其他组合也一定会安排一个新的人到这个组合中。
// 关键点3: 把一对情侣看作一个节点，假设把一个组合中的人安排到其他组合中，就认为两个组合之间存在一条边。
//         那么很显然，如果某一对情侣被拆散，那么这个节点一定会与其他节点存在边的关系。存在下面两种情况：
//             1. 节点1中的一个人安排到了节点2中，节点2中的一个人被安排到节点1中，所以节点1和节点2之间只会存在一条边，且与其他节点之间没有边；
//             2. 节点1中的一个人安排到了节点2中，节点2中的一个人被安排到另一个节点中......, 以此往复，直到某一个节点中的一个人被安排到节点1中。此时这些节点就会组成一个环。
//         综上所述，根据上面这个模型，n对情侣(节点)可能会组成多个环、两个节点组成的节点对、以及单个节点(代表没有被拆分的情侣)
// 关键点4: 包含m个节点的节点环需要进行m-1次交换，才能让环中的所有情侣牵手；
//         包含2个节点的节点对需要进行1次交换，才能让节点对中的所有情侣牵手；
//         单个节点不需要交换就可以直接牵手。
// 关键点5: 将n个节点使用并查集建立连接关系，求解每个连通分量上的节点数k，(k-1)就是这个连通分量上所有节点成功牵手需要交换的次数。
class Solution {
    public int minSwapsCouples(int[] row) {
        // 建立连接关系
        UnionFind uf = new UnionFind(row.length/2); // n表示情侣对数
        for(int i=0; i<row.length; i=i+2){
            uf.unite(row[i]/2, row[i+1]/2); // 人的ID/2表示情侣(节点)的编号
        }
        
        // 存放每个连通分量上的顶级父节点
        HashSet<Integer> finalFather = new HashSet<>();
        for(int i=0; i<row.length/2; i=i+1){
            finalFather.add(uf.find(i)); // uf.find(i)查找第i对情侣的顶级父节点
        }

        // 计算交换次数
        int result = 0;
        for(int param: finalFather){ // param表示当前连通分量的顶级父节点
            result += uf.size[param] - 1; // uf.size[param]表示当前连通分量上节点总数
        }

        return result;
    }
}

class UnionFind{
    int[] parent; // 记录每个节点的父节点(但这个父节点不一定是顶级父节点)
    int[] size;   // 记录每个节点对应的连通分量中的节点总数
    int n;        // 记录总节点数目
    int setCount; // 当前独立的连通分量数目 (初始化n个节点，有n个独立的连通分量)

    public UnionFind(int n){
        this.parent = new int[n];
        this.size = new int[n];
        this.n = n;
        this.setCount = n; // 初始化还没有任何连通关系，每个节点对应一个独立的连通分量.(一共n个连通分量)

        Arrays.fill(size, 1);
        for(int i=0; i<n; i++){
            parent[i] = i; // 初始化每个节点的父亲就是自己
        }
    }

    // 查询节点x的顶级父节点
    public int find(int x){
        if(parent[x] == x) return x; // 当前节点的父节点就是自己，则当前节点就是顶级父节点
        else{
            // 路径压缩：当前节点父节点parent[x] = 当前节点父节点parent[x]的顶级父节点
            //         从而将路径上的所有节点都统一指向了顶级父节点
            parent[x] = find(parent[x]);
        }

        return parent[x];
    }

    // 合并两节点 (返回是否合并成功)
    public boolean unite(int x, int y){
        int x_father = find(x); // x 的顶级父节点
        int y_father = find(y); // y 的顶级父节点

        if(x_father==y_father) return false;

        // 建立连接关系（路径压缩）
        if(size[x_father] < size[y_father]){ // y对应的连通分量大
            parent[x_father] = y_father; // x_parent父节点设置为y_parent：小集合合并到大集合中
            size[y_father] += size[x_father]; // 只需要维护顶级父节点的size即可
        }else{
            parent[y_father] = x_father; // y_parent父节点设置为x_parent
            size[x_father] += size[y_father];
        }

        setCount--; // 连通分量总数减一
        return true;
    }

    // 判断两个节点是否相连（等价于判读两个节点的顶级父节点是否相同）
    public boolean isConnected(int x, int y){
        int x_father = find(x);
        int y_father = find(y);
        return x_father == y_father;
    }
}

  3. LeeCode2867. 统计树中的合法路径数目

    • 答案

      // 1. 质数节点连接两个非质数集合，集合数目分别为s1，s2。则质数节点对应的合法路径数=s1+s2+s1*s2
//    质数节点连接1个非质数集合，另一端连接质数或者null，非质数集合数目为s1。则质数节点对应的合法路径数=s1
//    质数节点连接0个非质数集合，两端连接质数或者null。则质数节点对应的合法路径数=0
/** 使用并查集解决
for(遍历每一个连接关系[a,b]){
    if(a非质数){
        if(b非质数) 合并集合
        else 不合并集合，记录b连接的非质数节点a，之后通过a找到a对应的非质数集合
    }else{ // a为质数 
        if(b为质数) 不合并集合
        else(b为非质数) 不合并集合，记录a连接的非质数节点b，之后通过b找到b对应的非质数集合
    }
}
*/
class Solution {
    private static final int N = 100001;
    private static boolean[] isPrime = new boolean[N];
    static {
        Arrays.fill(isPrime, true);
        isPrime[1] = false;
        for (int i = 2; i * i < N; i++) {
            if (isPrime[i]) {
                for (int j = i * i; j < N; j += i) {
                    isPrime[j] = false;
                }
            }
        }
    }

    public long countPaths(int n, int[][] edges) {
        HashMap<Integer,ArrayList<Integer>> recordPrimeConnect = new HashMap<>(); // 记录所有质数节点连接的非质数节点集合
        UnionFind uf = new UnionFind(n+1);

        for(int[] edge: edges){
            int a = edge[0], b = edge[1];
             if(!isPrime[a]){
                if(!isPrime[b]) uf.unite(a, b);
                else{
                    // 不合并集合，记录b连接的非质数节点a，之后通过a找到a对应的非质数集合
                    ArrayList<Integer> connected = recordPrimeConnect.getOrDefault(b, new ArrayList<Integer>());
                    connected.add(a);
                    recordPrimeConnect.put(b, connected);
                }
            }else{ // a为质数 
                if(isPrime[b]) continue;
                else{
                    // (b为非质数) 不合并集合，记录a连接的非质数节点b，之后通过b找到b对应的非质数集合
                    ArrayList<Integer> connected = recordPrimeConnect.getOrDefault(a, new ArrayList<Integer>());
                    connected.add(b);
                    recordPrimeConnect.put(a, connected);
                }
            }
        }

        // 统计有效路径数目
        // 1. 质数节点连接两个非质数集合，集合数目分别为s1，s2。则质数节点对应的合法路径数=s1+s2+s1*s2
        //    质数节点连接1个非质数集合，另一端连接质数或者null，非质数集合数目为s1。则质数节点对应的合法路径数=s1
        //    质数节点连接0个非质数集合，两端连接质数或者null。则质数节点对应的合法路径数=0
        long result = 0;
        for(Map.Entry<Integer,ArrayList<Integer>> entry: recordPrimeConnect.entrySet()){
            // System.out.println(""+ entry.getKey() + "value:"+ entry.getValue());
            ArrayList<Integer> connectNotPrime = entry.getValue(); // 记录当前质数节点连接的非质数节点
            if(connectNotPrime.size()==0) continue;
            else if(connectNotPrime.size()>=1){
                for(int i=0; i<connectNotPrime.size(); i++){
                    result += (long)uf.size[uf.find(connectNotPrime.get(i))];
                    for(int j=i+1; j<connectNotPrime.size(); j++){
                        long s1 = (long)uf.size[uf.find(connectNotPrime.get(i))];
                        long s2 = (long)uf.size[uf.find(connectNotPrime.get(j))];
                        result += s1*s2;
                    }
                }
            }
        }

        return result;
    }
}

class UnionFind{
    int[] parent; // 记录每个节点的父节点(但这个父节点不一定是顶级父节点)
    int[] size;   // 记录每个节点对应的连通分量中的节点总数
    int n;        // 记录总节点数目
    int setCount; // 当前独立的连通分量数目 (初始化n个节点，有n个独立的连通分量)

    public UnionFind(int n){
        this.parent = new int[n];
        this.size = new int[n];
        this.n = n;
        this.setCount = n; // 初始化还没有任何连通关系，每个节点对应一个独立的连通分量.(一共n个连通分量)

        Arrays.fill(size, 1);
        for(int i=0; i<n; i++){
            parent[i] = i; // 初始化每个节点的父亲就是自己
        }
    }

    // 查询节点x的顶级父节点
    public int find(int x){
        if(parent[x] == x) return x; // 当前节点的父节点就是自己，则当前节点就是顶级父节点
        else{
            // 路径压缩：当前节点父节点parent[x] = 当前节点父节点parent[x]的顶级父节点
            //         从而将路径上的所有节点都统一指向了顶级父节点
            parent[x] = find(parent[x]);
        }

        return parent[x];
    }

    // 合并两节点 (返回是否合并成功)
    public boolean unite(int x, int y){
        int x_father = find(x); // x 的顶级父节点
        int y_father = find(y); // y 的顶级父节点

        if(x_father==y_father) return false;

        // 建立连接关系（路径压缩）
        if(size[x_father] < size[y_father]){ // y对应的连通分量大
            parent[x_father] = y_father; // x_parent父节点设置为y_parent：小集合合并到大集合中
            size[y_father] += size[x_father]; // 只需要维护顶级父节点的size即可
        }else{
            parent[y_father] = x_father; // y_parent父节点设置为x_parent
            size[x_father] += size[y_father];
        }

        setCount--; // 连通分量总数减一
        return true;
    }

    // 判断两个节点是否相连（等价于判读两个节点的顶级父节点是否相同）
    public boolean isConnected(int x, int y){
        int x_father = find(x);
        int y_father = find(y);
        return x_father == y_father;
    }
}
小鱼干不写作业
关注
  • 39
    点赞
  • 踩
  • 54
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
并查集Python版
小小博客
10-12 1931
整理之前python版的并查集资料
并查集模板超详细整理
林深不见鹿 的博客
05-13 4240
并查集被很多OIer认为是最简洁而优雅的数据结构之一，主要用于解决一些元素分组的问题。它管理一系列不相交的集合，并支持两种操作： ·合并（Union）：把两个不相交的集合合并为一个集合。 ·查询（Find）：查询两个元素是否在同一个集合中。 假如有编号为1, 2, 3, …, n的n个元素，我们用一个数组fa[]来存储每个元素的父节点（因为每个元素有且只有一个父节点，所以这是可行的）。一开始，我们先将它们的父节点设为自己。 查询 int find(int x) { if(fa[x] == x)
并查集（判断环路）
qq_35513792的博客
09-11 5614
并查集是非常常用的一种数据结构，用于把数据按照规则整理成集合，集合最终呈现为树状结构，以根节点作为不同集合的区分标志，实现方面主要涉及查找和合并，代码如下 //查找 int find(int x) { int r=x; while(pre[r]!=r) r=pre[r];//找到他的前导结点 int i=x,j; while(i!=r)//路径压缩算法 ...
浅谈并查集算法
Hawo11的博客
07-02 461
概述并查集
并查集算法
lxk9409的博客
10-23 290
描述并查集是一种树型的数据结构，用于处理一些不相交集合（Disjoint Sets）的合并及查询问题。常常在使用中以森林来表示。让每个元素构成一个单元素的集合，也就是按一定顺序将属于同一组的元素所在的集合合并。基本操作1、makeSet（s）：创建一个新的并查集，包含s个单元素集合。 2、union（x,y）：把x、y存在的集合合并，若x、y属于同一集合则不合并。 3、find（x）：查找元素x
并查集学习整理 初学者必备
06-19
并查集是一种在图论和数据结构中广泛使用的算法，主要应用于处理不相交集合的合并与查询。在ACM（国际大学生程序设计竞赛）中，掌握并查集的运用对于解决某些特定类型的问题至关重要。这个压缩包包含了全面的并查集...
并查集 分析与代码整理
12-12
并查集是一种数据结构，主要用于处理一些不相交集合的合并与查询问题。它由多个不相交的集合构成，每个集合内部的元素相互连接，而不同集合的元素之间不直接相连。并查集的主要操作有三个：初始化、查找和合并。 1....
acm并查集资料整理
03-31
并查集是一种在图论和数据结构中广泛使用的算法，主要应用于处理不相交集合的合并与查询问题。在ACM（国际大学生程序设计竞赛）中，它常常被用来解决有关连通性的问题，例如判断两个节点是否属于同一个连通分量、...
kruskal算法整理
09-24
综上所述，Kruskal算法是解决最小生成树问题的一种重要方法，它的核心在于贪心策略和并查集数据结构。理解并熟练掌握这一算法对于学习图论和算法设计至关重要。在实际应用中，根据具体情况选择合适的优化策略，可以...
ApacheCN 数据结构与算法译文集.zip
01-04
这个集合由ApacheCN社区翻译并整理，旨在为中文读者提供高质量的数据结构和算法学习材料。下面，我们将深入探讨其中涉及的主要知识点。 1. **数据结构**： - **数组**：基础的数据结构，用于存储同类型元素的有序...
算法训练营第47天|1143.最长公共子序列|1035.不相交的线|53. 最大子序和|392.判断子序列
bless_______的博客
07-24 241
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;未想到特殊情况，即s或t为空串的情况，因为返回的是数组值，但是如果是空串就不会建立数组。
2.6基本算法之动态规划6045:开餐馆
Andy_SCP001的博客
07-24 257
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
2.6基本算法之动态规划2989:糖果
Andy_SCP001的博客
07-24 442
糖果公司的N件产品每件都包含数量不同的糖果。Dzx希望他选择的产品包含的糖果总数是K的整数倍，这样他才能平均地将糖果分给帮助他维护世界和平的伙伴们。/*边界条件:dp[i][j]初始化为负无穷,int dp[1005][1005];//dp[i][j]:从i种糖果中选,组成糖果总数量k的倍数。dp[0][0]=0;//dp[0][0]边界条件:0种糖果组成糖果总数量0的倍数是0。另外,必须保证所有的状态是由dp[0][0]转移过来的*/除了dp[0][0]为0,因为我们这里求的是最大值,
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
danaaaa的博客
07-24 1066
二叉搜索树向左或向右指明方向，不用遍历整个树。
Python鲁汶意外莱顿复杂图拓扑分解算法
跨学科知识视角展现
07-24 1104
:dart:算法池化和最佳分区搜索：:pen:网格搜索 | :pen:发现算法池 | :pen:返回指定图的最佳划分 | :pen:返回指定图的最佳分区 | :dart:适应度和聚类比较功能：:pen:图的划分 | :pen:节点度 | :pen:给定算法检测到社群总数 | :pen:图密度 | :pen:社群顶点的度数之和 | :pen:解之间的预期一致 | :pen:联合熵 | :pen:平均内部度、所有可能的节点对的平均路径长度 | :pen:节点指向社群外的边平均比例 | :pen:现有边距离社群比
LeetCode-day25-2844. 生成特殊数字的最少操作
最新发布
小李的便利店
07-25 432
2844. 生成特殊数字的最少操作
【算法】分割回文串
时清云的博客
07-24 396
难度：中等。
力扣题解（最大数）
yyssas的博客
07-24 354
因此按照上述做法得出的序列是x1,x2,x3.....,最优解是y1,y2,y3.....,假设前i-1个一样，则xi！=yi，假设xi==yj，则必有yiyj<yjyi，且对于处于i到j之间的数字组合z，yizyj<yjzyi，因此换i，j位置会大于等于未换位置的最优解，但是最优解是最大值，因此换后仍是最大值。正确性：若ab>ba,则acb>bca，保证了将任何数放ab之间，不改变大小关系。排序规则：对于数组中的数a和数b，若ab>ba，则a在前，b在后。对数组重新排列，使得按照题目所要求的顺序输出。
【常微分方程】
qq_74285286的博客
07-24 384
常微分方程笔记
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值