【算法】树形DP ② 打家劫舍Ⅲ（树上最大独立集）

已于 2023-07-04 13:37:16 修改
阅读量283 收藏
点赞数
分类专栏： 算法 文章标签： 算法 树形DP 打家劫舍Ⅲ DFS 动态规划 树
于 2023-07-04 13:29:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43406895/article/details/131465732
版权

文章目录

前期知识

最大独立集 需要从图中选择尽量多的点，使得这些点互不相邻。

在这里插入图片描述

例题

337. 打家劫舍 III

337. 打家劫舍 III

在这里插入图片描述
用一个数组 int[] = {a, b} 来接收每个节点返回的结果。返回值{a,b} a表示没选当前节点的最大值,b表示选了当前节点的最大值。

使用后序遍历dfs。 （发现树形 DP 基本都是后序 dfs）

在这里插入图片描述

class Solution {
    public int rob(TreeNode root) {
        int[] res = dfs(root);
        return Math.max(res[0], res[1]);
    }

    public int[] dfs(TreeNode root) {
        // 返回值{a,b} a表示没选当前节点的最大值,b表示选了当前节点的最大值
        if (root == null) return new int[]{0, 0};
        int[] l = dfs(root.left), r = dfs(root.right);
        int a = Math.max(l[0], l[1]) + Math.max(r[0], r[1]), b = root.val + l[0] + r[0];
        return new int[]{a, b};
    }
}

相关练习题目

没有上司的舞会 https://www.luogu.com.cn/problem/P1352

P1352 没有上司的舞会

在这里插入图片描述
这道题目相当于每个节点可能会有若干个子节点的 337. 打家劫舍 III 。

因为是 ACM 模式，所以代码处理输入很冗长。

AC代码如下：

import java.util.*;

public class Main {
    static List<Integer>[] childs;	// 记录每个节点的子节点列表
    static int[] r;					// 记录每个节点的快乐指数

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        r = new int[n + 1];
        for (int i = 1; i <= n; ++i) r[i] = scanner.nextInt();
        childs = new ArrayList[n + 1];
        Arrays.setAll(childs, e -> new ArrayList());
        Set<Integer> s = new HashSet<>();	// 记录哪些节点没有父节点，把他们统一放在0节点之下
        for (int i = 1; i <= n; ++i) s.add(i);
        for (int i = 2; i <= n; ++i) {
            int l = scanner.nextInt(), k = scanner.nextInt();
            childs[k].add(l);
            s.remove(l);
        }
        for (int v: s) childs[0].add(v);    // 所有没有父节点的节点放在0节点之下
        int[] res = dfs(0);
        System.out.println(Math.max(res[0], res[1]));
        return;
    }

    public static int[] dfs(int rootId) {
        int a = 0, b = r[rootId];		// a表示不选当前节点，b表示选当前节点
        for (int i: childs[rootId]) {   // 枚举所有子节点
            int[] res = dfs(i);
            a += Math.max(res[0], res[1]);	// 不选当前节点，所以子节点选不选都可以
            b += res[0];					// 选当前节点，所以子节点只能不选
        }
        return new int[]{a, b};
    }
}

从代码模板来看，这里使用 for 循环来枚举当前节点的所有子节点。

1377. T 秒后青蛙的位置 https://leetcode.cn/problems/frog-position-after-t-seconds/⭐⭐⭐

1377. T 秒后青蛙的位置

在这里插入图片描述

解法1：BFS

从题意来看，每次青蛙都会往下走一层，很像层序遍历，所以可以是用 bfs 来模拟整个过程。

在 bfs 的过程中，如果当前节点的概率为 p，他有 k 个子节点，那么它的所有子节点的概率就是 p / k，即在分母上乘了 k。
在这个过程中，我们可以记录各个节点的概率分母。

如果当前节点没有子节点，那么它的概率不变，再重新加入队列中。

class Solution {
    public double frogPosition(int n, int[][] edges, int t, int target) {
        // 建树
        List<Integer>[] g = new ArrayList[n + 1];
        Arrays.setAll(g, e -> new ArrayList());
        for (int[] edge: edges) {
            int x = edge[0], y = edge[1];
            g[x].add(y);
            g[y].add(x);
        }
        boolean[] st = new boolean[n + 1];
        // 由于某些样例在计算概率分母时会溢出int，因此使用long
        Queue<long[]> q = new LinkedList();
        q.offer(new long[]{1, 1});   // 将第一个节点放入队列
        st[1] = true;
        for (int i = 0; i <= t; ++i) {
            int sz = q.size();
            for (int j = 0; j < sz; ++j) {
                long[] cur = q.poll();
                // 如果达到了目标位置且时间正确，返回答案
                if (cur[0] == target && i == t) return 1.0 / cur[1];
                List<Integer> children = g[(int)cur[0]];
                boolean f = false;          // 记录它是否有子节点
                int cnt = 0;                // 记录它有几个子节点
                for (int child: children) {
                    if (!st[child]) ++cnt;
                }
                for (int child: children) {
                    if (!st[child]) {
                        q.offer(new long[]{child, cur[1] * cnt});    // 将子节点加入队列，概率的分母更新为cnt[1]*cnt
                        st[child] = true;
                        f = true;           // 说明有子节点
                    }
                }
                // 如果当前节点没有子节点，那么它还会待在当前位置
                if (!f) q.offer(cur);
            }
        }
        return 0;
    }
}
优化代码

优化的点包括：

  • 修改了 return 结果的判断条件
  • 删去了 cnt 统计每个节点的子节点个数，因为子节点数目就是g[x].size() - 1
  • 给起始节点1增加一个父节点0，可以避免写多余判断
class Solution {
    public double frogPosition(int n, int[][] edges, int t, int target) {
        // 建树
        List<Integer>[] g = new ArrayList[n + 1];
        Arrays.setAll(g, e -> new ArrayList());
        g[1].add(0);		// 小技巧
        for (int[] edge: edges) {
            int x = edge[0], y = edge[1];
            g[x].add(y);
            g[y].add(x);
        }
        boolean[] st = new boolean[n + 1];
        // 由于某些样例在计算概率分母时会溢出int，因此使用long
        Queue<long[]> q = new LinkedList();
        q.offer(new long[]{1, 1});   // 将第一个节点放入队列
        st[1] = true;
        for (int i = 0; i <= t; ++i) {
            int sz = q.size();
            for (int j = 0; j < sz; ++j) {
                long[] cur = q.poll();
                // 如果达到了目标位置且时间正确，返回答案
                if (cur[0] == target) {
                    if (i == t || g[(int)cur[0]].size() == 1) return 1.0 / cur[1];
                    return 0;
                }
                List<Integer> children = g[(int)cur[0]];
                int cnt = children.size() - 1;                      // 记录它有几个子节点
                for (int child: children) {
                    if (!st[child]) {
                        q.offer(new long[]{child, cur[1] * cnt});    // 将子节点加入队列，概率的分母更新为cnt[1]*cnt
                        st[child] = true;
                    }
                }
            }
        }
        return 0;
    }
}

解法2——自顶向下dfs

整体思路与 bfs 类似。

class Solution {
    double ans;

    public double frogPosition(int n, int[][] edges, int t, int target) {
        // 建树
        List<Integer>[] g = new ArrayList[n + 1];
        Arrays.setAll(g, e -> new ArrayList());
        g[1].add(0);        	// 常用技巧：为了减少额外判断,给1加个父节点0
        for (int[] edge: edges) {
            int x = edge[0], y = edge[1];
            g[x].add(y);
            g[y].add(x);
        }
        dfs(g, target, 1, 0, t, 1);
        return ans;
    }

    public boolean dfs(List<Integer>[] g, int target, int x, int father, int leftTime, long prod) {
        // 如果x == target 且 （正好在t秒或处在叶子节点上）
        if (x == target && (leftTime == 0 || g[x].size() == 1)) {
            ans = 1.0 / prod;
            return true;
        }
        if (x == target || leftTime == 0) return false;
        for (int y: g[x]) {     // 遍历x的儿子y
            if (y != father && dfs(g, target, y, x, leftTime - 1, prod * (g[x].size() - 1))) {
                return true;    // 找到了就不再递归了
            }
        }
        return false;
    }
}

这里学到的重要技巧：

  • 每个节点只会有一个父节点，因此它的子节点数量就是 g[x].size() - 1，不需要单独计算了。
  • g[1].add(0); // 常用技巧：为了减少额外判断,给1加个父节点0
  • dfs 返回 boolean 值，在 if () 中进行 dfs。

解法3——自底向上dfs

class Solution {
    double ans;

    public double frogPosition(int n, int[][] edges, int t, int target) {
        // 建树
        List<Integer>[] g = new ArrayList[n + 1];
        Arrays.setAll(g, e -> new ArrayList());
        g[1].add(0);        // 为了减少额外判断,给1加个父节点0
        for (int[] edge: edges) {
            int x = edge[0], y = edge[1];
            g[x].add(y);
            g[y].add(x);
        }
        long prod = dfs(g, target, 1, 0, t);
        return prod == 0? prod: 1.0 / prod;
    }

    public long dfs(List<Integer>[] g, int target, int x, int father, int leftTime) {
        // 找到结果的两种情况
        if (leftTime == 0) return x == target? 1: 0;
        if (x == target) return g[x].size() == 1? 1: 0;
        // 遍历 x 的儿子 y
        for (int y: g[x]) {
            if (y != father) {
                long prod = dfs(g, target, y, x, leftTime - 1);
                if (prod != 0) return prod * (g[x].size() - 1);
            }
        }
        return 0;
    }
}

自底向上的优点在于，只有找到了 target 之后才会做乘法计算 prod。

2646. 最小化旅行的价格总和 https://leetcode.cn/problems/minimize-the-total-price-of-the-trips/solution/lei-si-da-jia-jie-she-iii-pythonjavacgo-4k3wq/⭐⭐⭐⭐⭐

2646. 最小化旅行的价格总和

在这里插入图片描述

解法1——暴力dfs每条路径

在这里插入图片描述

核心思路是遍历每条路径，修改 price 数组，然后将问题转换成 337. 打家劫舍 III 。

class Solution {
    List<Integer>[] g;
    int[] price, cnt;
    int end;

    public int minimumTotalPrice(int n, int[][] edges, int[] price, int[][] trips) {
        g = new ArrayList[n];
        Arrays.setAll(g, e -> new ArrayList());
        for (int[] edge: edges) {
            int x = edge[0], y = edge[1];
            g[x].add(y);
            g[y].add(x);
        }
        this.price = price;
        cnt = new int[n];       // 记录每个节点在路径中出现的次数
        for (int[] trip: trips) {
            end = trip[1];
            op(trip[0], -1);    // 用dfs找到这个trip路径上的点   
        }

        int[] p = dfs(0, -1);
        return Math.min(p[0], p[1]);
    }

    public boolean op(int x, int father) {
        if (x == end) {     // 找到了end
            ++cnt[x];
            return true;
        }
        for (int y: g[x]) {
            if (y != father && op(y, x)) {
                ++cnt[x];
                return true;
            }
        }
        return false;       // 没找到
    }

    // 返回值 ：[不减半，减半]
    public int[] dfs(int x, int father) {
        int notHalve = price[x] * cnt[x], halve = notHalve / 2;
        for (int y: g[x]) {
            if (y != father) {
                int[] p = dfs(y, x);
                notHalve += Math.min(p[0], p[1]);   // 当前不减半，那前面的节点随意
                halve += p[0];      // 当前减半，那前面的节点只能不减半
            }
        }
        return new int[]{notHalve, halve};
    }
}

解法2——Tarjan 离线 LCA + 树上差分

TODO
https://leetcode.cn/problems/minimize-the-total-price-of-the-trips/solution/lei-si-da-jia-jie-she-iii-pythonjavacgo-4k3wq/

补充题目：2467. 树上最大得分和路径⭐⭐⭐

2467. 树上最大得分和路径

在这里插入图片描述
这道题目更多的是练习树的 dfs 技巧，与 dp 关系不大。

使用两个 dfs ，
第一个 dfs 用于计算 bob 达到各点的时间，为计算 alice 路径上的价值做准备。
第二个 dfs 用于枚举 alice 到达各个叶子节点的路径，在达到叶子节点时更新答案。

class Solution {
    List<Integer>[] g;
    int[] bobTime, amount;
    int ans = Integer.MIN_VALUE;

    public int mostProfitablePath(int[][] edges, int bob, int[] amount) {
        int n = edges.length + 1;
        g = new ArrayList[n];
        Arrays.setAll(g, e -> new ArrayList());
        for (int[] edge: edges) {
            int x = edge[0], y =edge[1];
            g[x].add(y);
            g[y].add(x);
        }
        g[0].add(-1);   // 常用技巧，给0节点加一个父节点-1，可以少写多余判断

        this.amount = amount;
        bobTime = new int[n];           // 记录bob到达该节点的时间
        Arrays.fill(bobTime, Integer.MAX_VALUE);    // 初始化为bob都到不了
        dfsBob(bob, 0, -1);
        dfsAlice(0, 0, -1, 0);
        return ans;
    }

    // 当前节点、当前节点的时间、当前节点的父节点
    public boolean dfsBob(int x, int time, int father) {
        // 只有到达了目的地才设置时间
        if (x == 0) {
            bobTime[x] = time;
            return true;
        }
        for (int y: g[x]) {
            if (y != father && dfsBob(y, time + 1, x)) {
                bobTime[x] = time;
                return true;
            }
        }
        return false;
    }

    public void dfsAlice(int x, int time, int father, int score) {
        // 计算当前节点的值
        int curVal = 0;
        if (time == bobTime[x]) curVal = amount[x] / 2;
        else if (time < bobTime[x]) curVal = amount[x];     // a早到
        // 到达了叶子节点，使用该条路径的值更新答案
        if (g[x].size() == 1) {
            ans = Math.max(ans, score + curVal);
            return;
        }
        // dfs过程
        for (int y: g[x]) {
            if (y != father) {
                dfsAlice(y, time + 1, x, score + curVal);
            }
        }
        return;
    }
}

注意：！
在 bob dfs 的过程中，不是经过的所有节点都需要被设置时间的，而是只有达到了 0 节点路径上的节点才需要被设置时间。
因此一个常用技巧是让 dfs 返回一个 boolean 值来记录是否达到了 target 。

Wei *
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
树的最大独立集（dp）
NSSWTT的博客
01-27 808
树的最大独立集合：对于一颗无根树，选出尽量多的点使得任何两个结点均不相邻   问题分析：   选择一个结点作为根节点。d(i)表示以i节点为根结点的子树的子树的最大独立子集。每个结点只有选择与不选择两种状态。     d(i,1)表示以i结点为根且选择i结点的子树的最大独立集。   d(i,0)表示以i结点为根且不选择i结点的子树的最大独立集。   结果就是选取一个点i作
动态规划算法详解（打家劫舍、买卖股票、单词拆分、爬楼梯等经典问题）
04-13
详细介绍动态规划算法，包括动态规划五部曲。使用动态规划解决经典问题，例如爬楼梯、打家劫舍问题、单词拆分问题、买卖股票问题等 动态规划是一种算法设计技术，它通过将问题分解为重叠的子问题并利用已经解决的子问题的结果来解决更大的问题。 通常用于解决具有重叠子问题和最优子结构的优化问题，即问题可以被分解为许多相同的子问题。 动态规划还可以用于解决背包问题： 使用一个二维数组来存储每个子问题的解，并使用两个嵌套循环来遍历所有可能的物品和容量组合，并计算出最优解。 单词拆分问题 可以将此问题简化为背包问题，单词就是物品，字符串s就是背包，单词能否组成字符串s,就是问物品能不能把背包装满。拆分时可以重复使用字典中的单词，说明就是一个`完全背包`。
11.动态规划：树形DP问题、树上最大独立集、树上最小支配集、换根DP、树上倍增（LCA）【灵神基础精讲】
最新发布
qq_42958831的博客
06-05 1724
来源0x3f：https://space.bilibili.com/206214
(树形DP)最大独立集、最小点覆盖、最小支配集
messywind的博客
06-02 367
1.最大独立集\large1.最大独立集1.最大独立集 选出最多的点,使得所有点都是不相邻的 状态表示：dpi,jdp_{i,j}dpi,j​表示以iii为根的树，如果jjj为000，表示不选这个点，如果jjj为111，表示选这个点 属性：Max\text{Max}Max 状态计算： 如果当前点iii不选，那么子节点jjj可以被选或不被选： dpi,0=∑k=1nmax⁡(dpjk,0,dpjk,1)dp_{i,0}=\sum_{k=1}^{n}\max (dp_{j_k,0},dp_{j_k,1})dpi
[树上DP] 树的最大独立子集
OI - IceCab
07-09 647
题目 思路 考虑状态表示，最直接的表示方法是，d(i)，根结点为i的数的最大独立子集。但是本题给的是无根树，没关系，边的方向不会影响最大独立子集，所有我们随便选一个结点作为根，建立一个有向树就可以。 而对于结点i，只有两个决策： 1.不选结点i，选上它的儿子们。 2.选结点i，选上它的孙子们。 1.状态定义：d(i,)，根结点为i的数的最大独立子集元素个数。 2.初状态：所有...
树形DP（动态规划）.pptx
01-12
树形动态规划（Tree Dynamic Programming, 简称树形DP）是一种在树结构上进行优化决策的方法，常用于解决与树形结构相关的最优化问题。在这个特定的问题中，我们面临的是一个聚会组织的问题，目标是找到使得幽默系数...
算法进阶02.zip 树形dp问题
06-20
树形动态规划（Tree Dynamic Programming, 简称树DP）是动态规划在树结构问题上的应用，是一种解决复杂问题的有效方法。在这个压缩包“算法进阶02.zip”中，我们很可能找到了关于树形DP的深入讲解和实例。树DP通常...
树形DP和单链表算法题目PPT课件——Java
12-15
【树形DP与单链表算法】在计算机科学中，特别是算法设计与分析领域，树形动态规划（Tree Dynamic Programming, 简称树形DP）和链表操作是两个重要的话题。本PPT课件深入浅出地探讨了这两个主题，并结合Java编程语言...
树形 DP 算法 文档
12-04
树形 DP 算法 文档~~· 自己看吧 全英版的，要看中文的就自己翻译吧·
基于二次独立集的数据融合调度算法
01-15
首先构建以最大独立集为基础的树型结构，并根据能量消耗预测进行调整形成最终的数据融合平衡树；然后通过优化调度对象集合，利用近似最大加权独立集为允许通信的链路分配传输时隙。实验结果表明，该算法能够在降低...
【HDU1520】Anniversary Party-树形DP求树的最大权值独立集
Maxwei_wzj的OI世界
05-04 575
【HDU1520】Anniversary Party-树形DP求树的最大权值独立集
树的最大独立集
L.
02-06 4387
树的最大独立集合：对于一颗无根树，选出尽量多的点使得任何两个结点均不相邻。 用d(i)表示以i为根结点的子树的最大独立集大小。 对于结点i，只有两种选择，选或者不选，若选，则问题转化为求出i的孙子的d值之，若不选则转化为求i的儿子的d值之和。 状态转移方程:d(i) = max(1 + gs[i], s[i]);#include <iostream> #include <vector> #in
树形dp-打家劫舍 III
11
03-27 66
之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为。小偷一晚能够盗取的最高金额 3 + 3 + 1 = 7。小偷一晚能够盗取的最高金额 4 + 5 = 9。，小偷能够盗取的最高金额。
leetcode *337. 打家劫舍 III（树形-动态规划）（2020.8.5）
Sophia_fez的博客
03-24 243
【题目】 在上次打劫完一条街道之后和一圈房屋后，小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为“根”。 除了“根”之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。 计算在不触动警报的情况下，小偷一晚能够盗取的最高金额。 示例 1 输入: [3,2...
树的最大独立集——树形dp
爱拼才会赢
02-22 5081
树的最大独立集：对于一颗n个节点的无根树，给出n-1条遍，选出尽量多的节点，使得任何两个节点均不相邻。输出一个最大独立集 分析：     d[i]：表示以i为节点的子树的最大独立集大小。     那么对于每个节点j. 取或者不取。 取j则j的孩子不能取,不取j则j的孩子可以取；     那么问题转化成了：取节点j，求出j的所有孙子的d值之和再+1。 不取j，求出j的所有儿子的d值之
树的最大独立集 (算法经典入门）
Achiberx
03-13 3075
思考：看过算法经典入门再看看网上的这个程序就是一种享受啊！禁不住转载，我还在树上的动态规划入门阶段。。。加油！ #include #include #include #include using namespace std; const int MAXN=100; vector G[MAXN]; //无根树 int l[MAXN]; //结点层次 int p[MAXN]; //根树 i
树形动态规划之树的最大独立集
RoundYuan
02-03 2046
树的最大独立集 对于一颗n个结点的无根树，选出尽量多的的结点，使得任何两个结点均不相邻（称为最大独立集），然后输入n-1条无向边，输出一个最大独立集（如果有多解，则任意输出一组）。 分析： 用d（i）表示以i为根结点的子树的最大独立集的大小。此时需要注意的是，本题的树是无根的：没有所谓的父子关系，而只是一些无向边。没关系，只要任选一个跟r，无根树就变成了有根树，上述状态的定义也就有意义了。
动态规划----树型DP----树的最大独立集
cqbzcsq的博客
04-24 3726
一、树型DP的概念 树型DP即在树上进行DP。 树是无环图，顺序可以是从叶子到根节点，也可以从根到叶子节点。 一般树型DP的特征很明显，即状态可以表示为树中的节点，每个节点的状态可以由其子节点状态转移而来（从叶子到根的顺序），或是由其父亲节点转移而来（从根到叶节点的顺序），也可是两者结合。 找出状态和状态转移方程仍然是树型DP的关键。 二、题目描述 树的最大独立集
给定树T = (V,E)，用C++的贪心算法求树的最大独立集。
05-28
树的最大独立集的贪心算法如下： 1. 选取根节点作为起点，从根节点开始进行遍历。 2. 对于每个节点，分为选取和不选取两种情况，分别计算出子树中的最大独立集。 3. 如果选择当前节点，则不能选择其子节点，所以需要计算出其子节点的子树中的最大独立集之和。 4. 如果不选择当前节点，则可以选择其子节点，所以需要计算出其子节点子树中的最大独立集之和。 5. 比较两种情况的最大值，取较大值作为当前节点的最大独立集。 6. 递归处理子节点，直到所有节点都被处理完毕。 7. 最后返回根节点的最大独立集作为整个树的最大独立集。 C++代码如下： ```cpp #include <iostream> #include <vector> using namespace std; const int MAXN = 10010; vector<int> G[MAXN]; int f[MAXN][2]; void dfs(int u, int fa) { f[u][0] = 0; f[u][1] = 1; for (int i = 0; i < G[u].size(); i++) { int v = G[u][i]; if (v == fa) continue; dfs(v, u); f[u][0] += max(f[v][0], f[v][1]); f[u][1] += f[v][0]; } } int main() { int n, u, v; cin >> n; for (int i = 1; i < n; i++) { cin >> u >> v; G[u].push_back(v); G[v].push_back(u); } dfs(1, 0); cout << max(f[1][0], f[1][1]) << endl; return 0; } ``` 其中，f[u][0]表示不选取节点u的最大独立集，f[u][1]表示选取节点u的最大独立集。最终的结果是根节点1的最大独立集。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Wei *

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值