LeetCode题解——树(二)

最新推荐文章于 2022-10-10 22:52:42 发布
最新推荐文章于 2022-10-10 22:52:42 发布
阅读量273 收藏
点赞数 1
分类专栏： LeetCode题解 文章标签： leetcode 算法 java 树 层序遍历
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wardseptember/article/details/106590826
版权

文章目录

递归

二叉树的最小深度

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明: 叶子节点是指没有子节点的节点。

示例:

给定二叉树 [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7
返回它的最小深度  2.

递归解法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int minDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int left = minDepth(root.left);
        int right = minDepth(root.right);
        if (left == 0 || right == 0) {
            return left + right + 1;
        }
        return Math.min(left, right) + 1;
    }
}

对称二叉树

给定一个二叉树，检查它是否是镜像对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

    1
   / \
  2   2
 / \ / \
3  4 4  3
 

但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

    1
   / \
  2   2
   \   \
   3    3
 

进阶：

你可以运用递归和迭代两种方法解决这个问题吗？

递归解法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {
        if (root == null) {
            return true;
        }
        return isSymmetric(root.left, root.right);
    }
    public boolean isSymmetric(TreeNode t1, TreeNode t2) {
        if (t1 == null && t2 == null) {
            return true;
        }
        if (t1 == null || t2 == null) {
            return false;
        }
        if (t1.val != t2.val) {
            return false;
        }
        return isSymmetric(t1.left, t2.right) && isSymmetric(t1.right, t2.left);
    }
}

迭代解法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {
        if (root == null) {
            return true;
        }
        return isSymmetric(root.left, root.right);
    }
    public boolean isSymmetric(TreeNode t1, TreeNode t2) {
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(t1);
        queue.offer(t2);
        while (!queue.isEmpty()) {
            t1 = queue.poll();
            t2 = queue.poll();
            if (t1 == null && t2 == null) {
                continue;
            }
            if (t1 == null || t2 == null || t1.val != t2.val) {
                return false;
            }
            queue.offer(t1.left);
            queue.offer(t2.right);
            queue.offer(t1.right);
            queue.offer(t2.left);
        }
        return true;
    }
}

左叶子之和

计算给定二叉树的所有左叶子之和。

示例：

    3
   / \
  9  20
    /  \
   15   7

在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24

递归解法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        if (root == null) {
            return 0;
        }
        if (isLeaf(root.left)) {
            return root.left.val + sumOfLeftLeaves(root.right);
        }
        return sumOfLeftLeaves(root.left) + sumOfLeftLeaves(root.right);
    }
    private boolean isLeaf(TreeNode node) {
        if (node == null) {
            return false;
        }
        return node.left == null && node.right == null;
    }
}

最长同值路径

给定一个二叉树，找到最长的路径，这个路径中的每个节点具有相同值。 这条路径可以经过也可以不经过根节点。

注意：两个节点之间的路径长度由它们之间的边数表示。

示例 1:

输入:

              5
             / \
            4   5
           / \   \
          1   1   5
输出:

2
示例 2:

输入:

              1
             / \
            4   5
           / \   \
          4   4   5
输出:

2
注意: 给定的二叉树不超过10000个结点。 树的高度不超过1000。

递归解法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    private int path = 0;
    public int longestUnivaluePath(TreeNode root) {
        dfs(root);
        return path;
    }
    private int dfs(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int left = dfs(root.left);
        int right = dfs(root.right);
        int leftDepth = root.left != null && root.val == root.left.val ? left + 1 : 0;
        int rightDepth = root.right != null && root.val == root.right.val ? right + 1 : 0;
        path = Math.max(path, leftDepth + rightDepth);
        return Math.max(leftDepth, rightDepth);
    }
}

打家劫舍 III

在上次打劫完一条街道之后和一圈房屋后，小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为“根”。 除了“根”之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。

计算在不触动警报的情况下，小偷一晚能够盗取的最高金额。

示例 1:

输入: [3,2,3,null,3,null,1]

     3
    / \
   2   3
    \   \ 
     3   1

输出: 7 
解释: 小偷一晚能够盗取的最高金额 = 3 + 3 + 1 = 7.
示例 2:

输入: [3,4,5,1,3,null,1]

     3
    / \
   4   5
  / \   \ 
 1   3   1

输出: 9
解释: 小偷一晚能够盗取的最高金额 = 4 + 5 = 9.

递归解法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int rob(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int val1 = root.val;
        if (root.left != null) {
            val1 += rob(root.left.left) + rob(root.left.right);
        }
        if (root.right != null) {
            val1 += rob(root.right.left) + rob(root.right.right);
        }
        int val2 = rob(root.left) + rob(root.right);
        return Math.max(val1, val2);
    }
}

动态规划

以上递归解法，子树最优值有的计算多遍，下面提供一种动态规划解法。教程详见https://leetcode-cn.com/problems/house-robber-iii/solution/san-chong-fang-fa-jie-jue-shu-xing-dong-tai-gui-hu/

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int rob(TreeNode root) {
        int[] result = robInternal(root);
        return Math.max(result[0], result[1]);
    }
    private int[] robInternal(TreeNode root) {
        if (root == null) {
            return new int[2];
        }
        int[] result = new int[2];
        int[] left = robInternal(root.left);
        int[] right = robInternal(root.right);
        result[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
        result[1] = left[0] + right[0] + root.val;
        return result;
    }
}

二叉树中第二小的节点

给定一个非空特殊的二叉树，每个节点都是正数，并且每个节点的子节点数量只能为 2 或 0。如果一个节点有两个子节点的话，那么这个节点的值不大于它的子节点的值。

给出这样的一个二叉树，你需要输出所有节点中的第二小的值。如果第二小的值不存在的话，输出 -1 。

示例 1:

输入: 
    2
   / \
  2   5
     / \
    5   7

输出: 5
说明: 最小的值是 2 ，第二小的值是 5 。
示例 2:

输入: 
    2
   / \
  2   2

输出: -1
说明: 最小的值是 2, 但是不存在第二小的值。

递归解法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int findSecondMinimumValue(TreeNode root) {
        if (root == null || (root.left == null && root.right == null)) {
            return -1;
        }
        int leftVal = root.left.val;
        int rightVal = root.right.val;
        if (leftVal == root.val) {
            leftVal = findSecondMinimumValue(root.left);
        }
        if (rightVal == root.val) {
            rightVal = findSecondMinimumValue(root.right);
        }
        if (rightVal != -1 && leftVal != -1) {
            return Math.min(rightVal, leftVal);
        }
        if (rightVal == -1) {
            return leftVal;
        }
        return rightVal;
    }
}

层序遍历

二叉树的层平均值

给定一个非空二叉树, 返回一个由每层节点平均值组成的数组.

示例 1:

输入:
    3
   / \
  9  20
    /  \
   15   7
输出: [3, 14.5, 11]
解释:
第0层的平均值是 3,  第1层是 14.5, 第2层是 11. 因此返回 [3, 14.5, 11].
注意：

节点值的范围在32位有符号整数范围内。

层序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> ret = new ArrayList<>();
        if (root == null) {
            return ret;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            double sum = 0;
            int size = queue.size();
            for (int i = 0; i < size; ++i) {
                TreeNode node = queue.poll();
                sum += node.val;
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
            ret.add(sum / size);
        }
        return ret;
    }
}

DFS

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> ret = new ArrayList<>();
        if (root == null) {
            return ret;
        }
        List<Integer> count = new ArrayList<>();
        dfs(root, 0, ret, count);
        for (int i = 0; i < ret.size(); ++i) {
            ret.set(i, ret.get(i) / count.get(i));
        }
        return ret;
    }
    private void dfs(TreeNode t, int i, List<Double> sum, List<Integer> count) {
        if (t == null) {
            return;
        }
        if (i < sum.size()) {
            sum.set(i, sum.get(i) + t.val);
            count.set(i, count.get(i) + 1);
        } else {
            sum.add(i, 1.0 * t.val);
            count.add(1);
        }
        dfs(t.left, i + 1, sum, count);
        dfs(t.right, i + 1, sum, count);
    }
}

找树左下角的值

给定一个二叉树，在树的最后一行找到最左边的值。

示例 1:

输入:

    2
   / \
  1   3

输出:
1
 

示例 2:

输入:

        1
       / \
      2   3
     /   / \
    4   5   6
       /
      7

输出:
7
 

注意: 您可以假设树（即给定的根节点）不为 NULL。

层序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int findBottomLeftValue(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        int result = 0;
        while(!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; ++i) {
                TreeNode node = queue.poll();
                if (i == 0) {
                    result = node.val;
                }
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
        }
        return result;
    }
}

DFS

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    int max = -1;
    int result = 0;
    public int findBottomLeftValue(TreeNode root) {
        dfs(root, 0);
        return result;
    }
    private void dfs(TreeNode node, int hight) {
        if (node == null) {
            return;
        }
        if (hight > max) { // 第一次大于max，就代表进入了新一层，当前结点就是最左结点
            max = hight;
            result = node.val;
        }
        dfs(node.left, hight + 1);
        dfs(node.right, hight + 1);
    }
}
推荐阅读

wardseptember
关注
专栏目录
python/c++ Leetcode题解——2744. 最大字符串配对数目
weixin_68756152的博客
01-17 190
我们可以直接使用二重循环，枚举给定的数组 words 中的 words[i] 和 words[j] 是否可以匹配。由于题目规定了数组 words 中包含的字符串互不相同，因此在枚举时，只要保证 i
LeetCode题解——与数组中元素的最大异或值
yxh_1_的博客
05-23 418
LeetCode题解——与数组中元素的最大异或值 题目介绍 解题思路 这题的解题思路路和LeetCode题解——数组中两个数的最大异或值_yxh_1_的博客-CSDN博客基本一致，区别在于多了限制值，找到的值要小于limit 第一种暴力解法，双重循环时间复杂度O(n*m)，但是可能会超时 第二种字典树，我们先要知道一点，异或就是相同为0，否则为1，那么我们随机给出一个数nums[i]怎么让它的异或结果最大呢，是不是要选择一个和num[i]二进制位数基本相反的，就是你是1，那我就选0 比如nums
leetcode 树（java）
GreenHand_D的博客
08-03 809
@[TOP](leetcode 树) 前中后序遍历 前序遍历：父节点 -> 左子节点 -> 右子节点 中序遍历：左子节点 -> 父节点 -> 右子节点 后序遍历：左子节点 -> 右子节点 -> 父节点 leetcode144 非递归实现二叉树的前序遍历（Medium） https://leetcode-cn.com/problems/binary-tree-preorder-traversal/ 输入: [1,null,2,3] 1 \ 2 / 3 输出: [1,2,3
LeetCode 776. 拆分二叉搜索树（DFS）*
Michael是个半路程序员
07-22 1145
文章目录1. 题目2. 解题 1. 题目 给你一棵二叉搜索树（BST）、它的根结点 root 以及目标值 V。 请将该树按要求拆分为两个子树：其中一个子树结点的值都必须小于等于给定的目标值 V；另一个子树结点的值都必须大于目标值 V；树中并非一定要存在值为 V 的结点。 除此之外，树中大部分结构都需要保留，也就是说原始树中父节点 P 的任意子节点 C，假如拆分后它们仍在同一个子树中，那么结点 P 应仍为 C 的子结点。 你需要返回拆分后两个子树的根结点 TreeNode，顺序随意。 示例： 输入：root
663 均匀树划分
weixin_44171872的博客
10-10 1939
题目描述： 给定一棵有 n 个结点的二叉树，你的任务是检查是否可以通过去掉树上的一条边将树分成两棵，且这两棵树结点之和相等。 样例 1: 输入: 输出: True 解释: 和: 15 和: 15 样例 2: 输入: 输出: False 解释: 无法通过移除一条树边将这棵树划分成结点之和相等的两棵子树。 注释 : 树上结点的权值范围 [-100000, 100000]。 1 <= n <= 10000 方法1： 主要思路： （1）先计算出各个结点作为根节点的时，对应的子树的和，并统计出原来
树分治
追风蹑影
10-18 613
参考：《分治算法在树的路径问题中的应用》漆子超 一、概述 树被定义为没有圈的联通图，具有以下几个性质： 1、在树中去掉一条边后所得的图是不连通的 2、在树中添加一条边后所得的图一定存在圈 3、树的每一顶点 u 和 v 之间有且仅有一条路径 分治算法在树结构上的运用，称之为树的分治算法 二、树的分治算法 1、基于点的分治 首先选取一个点将无根树转为有根树，再递归处理
树型算法题解
asd804171023的博客
03-26 1291
树结构如下 public class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) { val = x; } } 1. 获取给定二叉树最小深度 思路：通过广度优先遍历能更快找到最优解。深度优先搜索也可以找到最优解，但是需要找到所有解后 广度优先搜索,一层一...
leetcode题解——hot100easy题
最新发布
ukhgg的博客
10-10 254
动态规划、递归
LeetCode题解——打家劫舍
yxh_1_的博客
05-05 182
LeetCode题解——打家劫舍 题目介绍 解题思路 这题的解题思路其实和LeetCode题解——删除并获得点数_yxh_1_的博客-CSDN博客一样都是动态规划 假设我现在需要偷窃最后一间房子也就是nums[3],现在要考虑一点到底要不要偷，因为相连两间房，偷了相连的一间就会发生警报。 第一种偷窃nums[3]：也就是偷窃倒数第三间的总金额dp(n-2)加上nums[3]的最后总金额要大于等于偷窃倒数第二次nums[2]的最大总金额dp(n-1)。 第二种不偷窃：和第一种情况相反，偷窃倒数第二
LeetCode题解——删除并获得点数
yxh_1_的博客
05-05 297
LeetCode题解——删除并获得点数 题目介绍 解题思路 这是一类动态规划的题目，假设nums = [2,2,3,3,3,4]，我们进行一次映射转换sum[0,0,4,9,4],第一行是sum下标也是nums的值，第二行是sum值，那题目的意思可以转换为sum数组，相连的两个数不能同时取，求sum里面元素怎么相加才能最大。 0 1 2 3 4 0 0 2*2 = 4 3*3 = 9 1*4 = 4 那么最后一次相加求和，对于要不要加上s.
树 递归法 leetcode题目
jtt_328513的博客
07-26 421
二叉树的最大深度104 给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明:叶子节点是指没有子节点的节点。 1.必须从根节点开始，到叶子节点截至，返回最多节点数目（最长路径数+1） 2.后序遍历 public class 二叉树的最大深度 { // Definition for a binary tree node. ​ public int maxDepth(TreeNode root) { ...
LeetCode题解——树(一)
wardseptember的博客
06-05 1646
文章目录递归二叉树的最大深度递归解法非递归解法平衡二叉树解法二叉树的直径解法翻转二叉树递归解法合并二叉树递归解法路径总和递归解法路径总和 III解法另一个树的子树递归解法推荐阅读 递归 二叉树的最大深度 给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有子节点的节点。 示例： 给定二叉树 [3,9,20,null,null,15,7]， 3 / \ 9 20 / \ 15 7 返回它的最大深度 3 。
c语言中dfs用pos做参数,LeetCode算法练习——深度优先搜索 DFS(2)
weixin_32816821的博客
05-21 205
更多干货就在我的个人博客 BlackBlog.tech 欢迎关注！也可以关注我的csdn博客：黑哥的博客谢谢大家！我们继续LeetCode之旅.做了一段时间的LeetCode，感觉还是不错的。算法很基础，没有特别难的(至少我看在做的)，很适合考试，面试，就业之前的训练。对提升基本功很有帮助，我觉得如果有时间的话，每天都做上几道，日积月累，代码能力必然有提高。这一篇继续进行DFS的练习，预计还会有十...
LeetCode 663. 均匀树划分（树形DP）
Michael是个半路程序员
07-06 4571
文章目录1. 题目2. 解题 1. 题目 给定一棵有 n 个结点的二叉树，你的任务是检查是否可以通过去掉树上的一条边将树分成两棵，且这两棵树结点之和相等。 样例 1: 输入: 5 / \ 10 10 / \ 2 3 输出: True 解释: 5 / 10 和: 15 10 / \ 2 3 和: 15 样例 2: 输入: 1 / \ 2 10 / \
B-tree、B+tree详解（一）概念与查找
韩某的博客
08-15 2969
前言 B+树索引是B+树在数据库中的一种实现，是最常见也是数据库中使用最为频繁的一种索引。因为B+树是从最早的平衡二叉树演化而来的。在讲B+树之前必须先了解二叉查找树、平衡二叉树（AVLTree）和平衡多路查找树（B-Tree），B+树即由这些树逐步优化而来。 详情请查看上一篇文章（二叉查找树与平衡二叉树）！ 概念 B-tree（多路搜索树，平衡多路查找树，并不是二叉的）：是一种常见的数据结构。相对于二叉，B-tree的每个内结点有多个分支，即多叉。 B+tree：与B-tree的树结构类似，是在B-
数据结构(3)：树与二叉树（上）-二叉树
kodoshinichi的博客
06-26 567
一.树的概念 (一)树的基本概念 树的定义 树是n个节点的有限集合（n≥0），当n=0的时候称为空树，在任意一棵非空树中： ①有且仅有一个特定的称为根的节点 ②当n＞1的时候，其余节点可分为m个互不相交的有限集合T1，…,Tm，每个 集合本身也是一棵树，并且这些集合称为根节点的子树。 特点： ①树的根节点没有前驱节点，除了根节点以外，所有节点有且只有一个前驱节点 ②树中所有节点都可以有0个或多个后继节点 ③在具有n个节点的树中具有n-1条边 基本术语 族谱关系（可以在树中找到连接两个
字符串面试题总结（终极版）
wardseptember的博客
11-24 2562
文章目录有效的字母异位词解法最长回文串解法同构字符串解法回文子串解法回文数解法计数二进制子串解法剑指 Offer 58 - I. 翻转单词顺序解法剑指 Offer 58 - II. 左旋转字符串解法剑指 Offer 67. 把字符串转换成整数解法 有效的字母异位词 242. 有效的字母异位词 给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。 示例 1: 输入: s = "anagram", t = "nagaram" 输出: true 示例 2: 输入: s = "rat
LeetCode题解——二分查找
wardseptember的博客
10-15 1422
69. x 的平方根 实现 int sqrt(int x) 函数。 计算并返回 x 的平方根，其中 x 是非负整数。 由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。 示例 1: 输入: 4 输出: 2 示例 2: 输入: 8 输出: 2 说明: 8 的平方根是 2.82842..., 由于返回类型是整数，小数部分将被舍去。 二分法 class Solution { ...
LeetCode题解——数组(一)
wardseptember的博客
07-07 1338
文章目录移动零解法重塑矩阵解法最大连续1的个数解法搜索二维矩阵 II解法有序矩阵中第K小的元素二分查找法堆排序错误的集合解法寻找重复数双指针推荐阅读 移动零 给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。 示例: 输入: [0,1,0,3,12] 输出: [1,3,12,0,0] 说明: 必须在原数组上操作，不能拷贝额外的数组。 尽量减少操作次数。 解法 class Solution { public void moveZeroes(int[] num
LeetCode题解：揭秘epoll在服务器开发中的关键应用
本文档主要围绕LeetCode题目进行了整理和分享，重点集中在Linux下的高性能网络编程技术——epoll，这是服务器端开发中的关键技术，被广泛应用于如Nginx、Redis、Skynet以及许多游戏服务器中，因为它提供了多路复用的...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值