backTrack Mock

已于 2024-05-11 19:30:33 修改
阅读量769 收藏 15
点赞数 13
文章标签： 深度优先 算法
于 2024-04-14 07:59:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65279006/article/details/137733940
版权

1.简而言之，一个集合里求组合就要用startIndex。

2.startIndex本身保证了组合的不同，需要求不同组合就要用startIndex；但从 i 开始还是从 i + 1 开始决定了组合元素能不能重复选。（39）

3.组内既不能重复选，也不能有重复组合，数组中还有重复元素，就要sort（40）

4.startIndex就是取了后面的不能取前面的所以保证不同的组合，但是排列不存在这个问题所以不用startIndex

5.切割就是组合

6.子集是收集路径的组合

112，113，257

combination 77，39，40，216，17

partitioning 131，93

subsets 78，90

permutations 46，47

51，37

491，332

112. 路径总和
简单

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。

叶子节点 是指没有子节点的节点。

class Solution {
    public boolean hasPathSum(TreeNode root, int targetSum) {
        if(root == null){
            return false;
        }
        if(root.left == null && root.right == null){
            return root.val == targetSum;
        }
        boolean left = hasPathSum(root.left,targetSum - root.val);
        boolean right = hasPathSum(root.right,targetSum - root.val);
        return left || right;
    }
}

113. 路径总和 II

中等

给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。

叶子节点 是指没有子节点的节点。

class Solution {
    List<List<Integer>> ans = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
        dfs(root, targetSum);
        return ans;
    }
    private void dfs(TreeNode root , int targetSum){
        if(root == null){
            return;
        }
        path.add(root.val);
        if(root.left == null && root.right == null){
            if(root.val == targetSum){
                ans.add(new ArrayList(path));
            }
        }
        dfs(root.left , targetSum - root.val);
        dfs(root.right , targetSum - root.val);
        path.remove(path.size()-1);
    }
}
class Solution {
    List<List<Integer>> ans = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
        dfs(root, targetSum);
        return ans;
    }
    private void dfs(TreeNode root , int targetSum){
        if(root == null){
            return;
        }
        path.add(root.val);
        if(root.left == null && root.right == null){
            if(root.val == targetSum){
                ans.add(new ArrayList(path));
            }
        }
        if(root.left != null){
            dfs(root.left , targetSum - root.val);
            path.remove(path.size()-1);
        }
        if(root.right != null){
            dfs(root.right , targetSum - root.val);
            path.remove(path.size()-1);
        }
    }
}


257. 二叉树的所有路径
简单
给你一个二叉树的根节点 root ，按 任意顺序 ，返回所有从根节点到叶子节点的路径。

叶子节点 是指没有子节点的节点。

class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> res = new ArrayList<>();// 存最终的结果
        if (root == null) {
            return res;
        }
        List<Integer> paths = new ArrayList<>();// 作为结果中的路径
        traversal(root, paths, res);
        return res;
    }

    private void traversal(TreeNode root, List<Integer> paths, List<String> res) {
        paths.add(root.val);// 前序遍历，中
        // 遇到叶子结点
        if (root.left == null && root.right == null) {
            // 输出
            StringBuilder sb = new StringBuilder();// StringBuilder用来拼接字符串，速度更快
            for (int i = 0; i < paths.size() - 1; i++) {
                sb.append(paths.get(i)).append("->");
            }
            sb.append(paths.get(paths.size() - 1));// 记录最后一个节点
            res.add(sb.toString());// 收集一个路径
            return;
        }
        // 递归和回溯是同时进行，所以要放在同一个花括号里
        if (root.left != null) { // 左
            traversal(root.left, paths, res);
            paths.remove(paths.size() - 1);// 回溯
        }
        if (root.right != null) { // 右
            traversal(root.right, paths, res);
            paths.remove(paths.size() - 1);// 回溯
        }
    }

}
class Solution {
    List<String> ans = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    public List<String> binaryTreePaths(TreeNode root) {
        dfs(root);
        return ans;
    }
    private void dfs(TreeNode root){
        if(root == null){
            return;
        }
        path.add(root.val);
        if(root.left == null && root.right ==null){
            StringBuilder sb = new StringBuilder();// StringBuilder用来拼接字符串，速度更快
            for (int i = 0; i < path.size() - 1; i++) {
                sb.append(path.get(i)).append("->");
            }
            sb.append(path.get(path.size() - 1));// 记录最后一个节点
            ans.add(sb.toString());// 收集一个路径
        }
        dfs(root.left);
        dfs(root.right);
        path.remove(path.size()-1);
    }
}

77. 组合
中等

给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

你可以按 任何顺序 返回答案。

示例 1：

输入：n = 4, k = 2
输出：
[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]
class Solution {
    List<List<Integer>> ans = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    public List<List<Integer>> combine(int n, int k) {
        backTrack(n, k, 1);
        return ans;
    }
    private void backTrack(int n, int k, int startIndex){
        if(path.size() == k){
            ans.add(new ArrayList(path));
            return;
        }
        for(int i = startIndex; i <= n; i++){
            path.add(i);
            backTrack(n, k, i + 1);
            path.remove(path.size()-1);
        }
    }
}

39. 组合总和

中等

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。 

对于给定的输入，保证和为 target 的不同组合数少于 150 个。

示例 1：

输入：candidates = [2,3,6,7], target = 7
输出：[[2,2,3],[7]]
解释：
2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
7 也是一个候选， 7 = 7 。
仅有这两种组合。

class Solution {
    List<List<Integer>> ans = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        backTrack(candidates, target, 0);
        return ans;
    }
    private void backTrack(int[] candidates, int target, int startIndex){
        if(target < 0 ){
            return;
        }
        if(target == 0){
            ans.add(new ArrayList(path));
        }
        for(int i = startIndex; i < candidates.length; i++){
            path.add(candidates[i]);
            backTrack(candidates, target-candidates[i], i);
            path.remove(path.size()-1);
        }
    }
}

40. 组合总和 II

中等

给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用 一次 。

注意：解集不能包含重复的组合。 

示例 1:

输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]
class Solution {
    List<List<Integer>> ans = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        Arrays.sort(candidates);
        backTrack(candidates,target,0);
        return ans;
    }
    private void backTrack(int[] candidates, int target, int startIndex){
        if(target == 0){
            ans.add(new ArrayList(path));
            return;
        }
        for(int i = startIndex; i < candidates.length; i++){
            if(target < 0){
                break;
            }
            if(i > startIndex && candidates[i] == candidates[i-1]){
                continue;
            }
            path.add(candidates[i]);
            backTrack(candidates, target - candidates[i], i + 1);
            path.remove(path.size()-1);
        }
    }
}

216. 组合总和 III

中等

找出所有相加之和为 n 的 k 个数的组合，且满足下列条件：

  • 只使用数字1到9
  • 每个数字 最多使用一次 

返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次，组合可以以任何顺序返回。

示例 1:

输入: k = 3, n = 7
输出: [[1,2,4]]
解释:
1 + 2 + 4 = 7
没有其他符合的组合了。
class Solution {
    List<List<Integer>> ans = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    public List<List<Integer>> combinationSum3(int k, int n) {
        backTrack(k, n, 1, 0);
        return ans;
    }
    private void backTrack(int k, int n, int startIndex, int sum){
        if(path.size() == k){
            if(sum == n){
                ans.add(new ArrayList(path));
            }
            return;
        }
        for(int i = startIndex; i <= 9; i++){
            path.add(i);
            backTrack(k, n, i + 1, sum + i);
            path.remove(path.size()-1);
        }
    }
}

17. 电话号码的字母组合

中等

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

示例 1：

输入：digits = "23"
输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]

示例 2：

输入：digits = ""
输出：[]

示例 3：

输入：digits = "2"
输出：["a","b","c"]

提示：

  • 0 <= digits.length <= 4
  • digits[i] 是范围 ['2', '9'] 的一个数字。
class Solution {
    List<String> ans = new ArrayList<>();
    StringBuilder path = new StringBuilder();
    public List<String> letterCombinations(String digits) {
        if (digits == null || digits.length() == 0) {
            return ans;
        }
        Map<Character, String> phoneMap = new HashMap<Character, String>() {{
            put('2', "abc");
            put('3', "def");
            put('4', "ghi");
            put('5', "jkl");
            put('6', "mno");
            put('7', "pqrs");
            put('8', "tuv");
            put('9', "wxyz");
        }};
        backTrack(digits, phoneMap, 0);
        return ans;
    }

 
    private void backTrack(String digits, Map<Character, String> phoneMap, int num) {
        if (num == digits.length()) {
            ans.add(path.toString());
            return;
        }
        char ch = digits.charAt(num);
        String str = phoneMap.get(ch);
        for (int i = 0; i < str.length(); i++) {
            path.append(str.charAt(i));
            backTrack(digits, phoneMap, num + 1);
            path.deleteCharAt(path.length() - 1);
        }
    }
}

131. 分割回文串

中等

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 

回文串

 。返回 s 所有可能的分割方案。

示例 1：

输入：s = "aab"
输出：[["a","a","b"],["aa","b"]]

class Solution {
    List<List<String>> ans = new ArrayList<>();
    List<String> path = new ArrayList<>();
    public List<List<String>> partition(String s) {
        backTrack(s, 0);
        return ans;
    }
    private void backTrack(String s , int startIndex){
        if(startIndex == s.length()){
            ans.add(new ArrayList(path));
            return;
        }
        for(int i = startIndex; i < s.length(); i++){
            String str = s.substring(startIndex, i + 1);
            if(isPalindrome(s, startIndex,i)){
                path.add(str);
            }else{
                continue;
            }
            backTrack(s, i + 1);
            path.remove(path.size() - 1);
        }
    }
    private boolean isPalindrome(String s, int startIndex, int endIndex){
        while(startIndex <= endIndex){
            if(s.charAt(startIndex) != s.charAt(endIndex)){
                return false;
            }
            startIndex++;
            endIndex--;
        }
        return true;
    }
}

93. 复原 IP 地址

中等

有效 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 '.' 分隔。

  • 例如："0.1.2.201" 和 "192.168.1.1" 是 有效 IP 地址，但是 "0.011.255.245"、"192.168.1.312" 和 "192.168@1.1" 是 无效 IP 地址。

给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址，这些地址可以通过在 s 中插入 '.' 来形成。你 不能 重新排序或删除 s 中的任何数字。你可以按 任何 顺序返回答案。

示例 1：

输入：s = "25525511135"
输出：["255.255.11.135","255.255.111.35"]


class Solution {
    List<String> ans = new ArrayList<>();
    StringBuilder path = new StringBuilder();
    public List<String> restoreIpAddresses(String s) {
        backTrack(s, 0 , 0);
        return ans;
    }
    private void backTrack(String s , int startIndex ,int count){
        if(count == 4 && startIndex == s.length()){
            ans.add(path.deleteCharAt(path.length() - 1).toString());
            return;
        }
        if(count > 4){
            return;
        }
        for(int i = startIndex; i < s.length() && i < startIndex + 3;i++){
            String str = s.substring(startIndex,i + 1);
            if(isTrue(str)){
                int len = path.length();
                path.append(str).append(".");
                backTrack(s, i + 1 , count + 1);
                path.setLength(len);
            }
        }
    }
    private boolean isTrue(String s){
        if(s.length() > 1 && s.charAt(0) == '0'){
            return false;
        }
        int a = Integer.parseInt(s);
        if(a > 255 || a < 0){
            return false;
        }
        return true;
    }
}

78. 子集
中等

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

示例 1：

输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
class Solution {
    List<List<Integer>> ans = new ArrayList<>();
    List<Integer> path = new ArrayList<>();

    public List<List<Integer>> subsets(int[] nums) {
        backTrack(nums, 0);
        return ans;
    }

    private void backTrack(int[] nums, int startIndex) {
        ans.add(new ArrayList<>(path));
        if (startIndex == nums.length) {
            return;
        }
        for (int i = startIndex; i < nums.length; i++) {
            path.add(nums[i]);
            backTrack(nums, i + 1);
            path.remove(path.size() - 1);
        }
    }
}

90. 子集 II

相关标签

相关企业

给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的 

子集

（幂集）。

解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。

示例 1：

输入：nums = [1,2,2]
输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]
class Solution {
    List<List<Integer>> ans = new ArrayList<>();
    List<Integer> path = new ArrayList<>();

    public List<List<Integer>> subsetsWithDup(int[] nums) {
        Arrays.sort(nums);
        backTrack(nums,0);
        return ans;
    }

    private void backTrack(int[] nums, int startIndex) {
        ans.add(new ArrayList<>(path));
        if (startIndex == nums.length) {
            return;
        }
        for (int i = startIndex; i < nums.length; i++) {
            if (i > startIndex && nums[i] == nums[i - 1]) {
                continue;
            }
            path.add(nums[i]);
            backTrack(nums, i + 1);
            path.remove(path.size() - 1);
        }
    }
}

46. 全排列

中等

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

示例 1：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

class Solution {
    List<List<Integer>> ans = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    boolean[] used;

    public List<List<Integer>> permute(int[] nums) {
        used = new boolean[nums.length];
        backTrack(nums);
        return ans;
    }

    private void backTrack(int[] nums) {
        if (path.size() == nums.length) {
            ans.add(new ArrayList<>(path));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            if (used[i] == false) {
                path.add(nums[i]);
                used[i] = true;
                backTrack(nums);
                path.remove(path.size() - 1);
                used[i] = false;
            }
        }
    }
}

47. 全排列 II

中等

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

示例 1：

输入：nums = [1,1,2]
输出：
[[1,1,2],
 [1,2,1],
 [2,1,1]]
class Solution {
    List<List<Integer>> ans = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    boolean[] used;

    public List<List<Integer>> permuteUnique(int[] nums) {
        used = new boolean[nums.length];
        Arrays.sort(nums);
        backTrack(nums);
        return ans;
    }

    private void backTrack(int[] nums) {
        if (path.size() == nums.length) {
            ans.add(new ArrayList<>(path));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {//注意条件
                continue;
            }
            if (used[i] == false) {
                path.add(nums[i]);
                used[i] = true;
                backTrack(nums);
                used[i] = false;
                path.remove(path.size() - 1);
            }
        }
    }
}

陈风凌
关注
  • 13
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
backtrack5汉化
03-19
backtrack5汉化命令和所需资源下载地址
backtrack5r3
11-16
记录了一下自己backtrack5r3的安装的流程，方便使用记忆，方便以后安装
backtrack3
06-13
可破解无线路由。 不鼓励、不赞成非法入侵他人计算机、通信设备。论坛仅作为Backtrack-linux计算机操作系统技术交流用途；实验学习请用自己的设备进行，有可能带来的问题需要您自己负责。
BackTrack 定制手册
06-12
BackTrack 定制手册
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5141
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
代码随想录算法训练营第七天（一）| 454.四数相加II 383. 赎金信
xiaowutongxue666的博客
08-06 439
给你四个整数数组nums1nums2nums3和nums4，数组长度都是n，请你计算有多少个元组2两个元组如下：1。
P1145 约瑟夫
zty20120913的博客
08-06 255
n个人站成一圈，从某个人开始数数，每次数到m的人就被杀掉，然后下一个人重新开始数，直到最后只剩一个人。现在有一圈人，k个好人站在一起，k个坏人站在一起。从第一个好人开始数数。你要确定一个最小的m，使得在第一个好人被杀死前，k个坏人先被杀死。
5力扣：最长回文子串
m0_75015083的博客
08-02 293
从后到前遍历是为了让每一次遍历时所需用到的子串提前被计算过。
C++初学者指南-5.标准库(第二部分)--数值运算算法
silencestarsky的博客
08-06 558
本文介绍了C++标准库中数值运算的相关算法，重点包括iota、reduce和各种扫描操作（scans），阐述了这些算法的用途、用法及其实现示例，并对并行执行的支持进行了说明。此外，文章还提到了一些遗留操作及其使用场景，为初学者理解C++标准库提供了实用的参考。
VRF 算法流程及代码实现
smilejiasmile的博客
08-03 124
Verifiable Random Functions (VRFs) 是一种密码学原语，能够为给定输入生成一个随机输出，并提供一个可以验证的证明，证明输出是由特定输入生成的。VRFs 具有许多应用，包括区块链、分布式系统和安全协议。使用secp256k1曲线可以产生确定性签名，适用于 VRF 实现。通过使用 HMAC-SHA256 生成确定性随机数k，可以确保签名过程对相同的输入始终产生相同的结果，从而满足 VRF 的要求。
算法第十七天：leetcode242.有效的字母异位词
m0_75068978的博客
08-02 520
如下表所示，您可以直接复制下面网址进入力扣学习，在观看下面的内容之前您一定要先做一遍哦，以便让你印象更加深刻！
day021二叉树最后章节
m0_62956971的博客
08-06 412
思路: 二叉搜索树的中序遍历就是有序升序数组，所以想要将它在转换成二叉树，我想到的方法就是通过递归来做，通过中间节点找到二叉搜索树的根节点，然后根据left和right双指针逐层递归构造左右子树。思路:最开始没有判断当当前节点小于最小值时，当前节点的右侧节点的情况，和当前节点大于最大值时，当前节点的左节点的情况，所以出错了，因此要在代码中判断一下这两种情况。思路: 累加树 由题意可知，在二叉搜索树中的递归顺序是右中左的顺序，创建一个新的函数，进行右中左的遍历，在遍历中要将节点的值记录下来，用来做累加。
CSP - J day7
2301_81608637的博客
08-06 83
答案具有单调性：对于正确答案 ans ，小于 ans 的都一定符合条件，大于 ans 的一定不符合条件，因此可以二分答案。先dfs到叶节点，再逐步递归出来，过程中节点数增加，一旦达到 mid ，ans 加一，同时向上贡献节点数变为零。
Java编码算法
最新发布
Stringzhua的博客
08-06 581
编码算法
埃拉托斯特尼筛法，厄拉多塞筛算法，C#实现
GoodCooking的博客
08-06 139
埃拉托斯特尼筛法，厄拉多塞筛算法，C#实现
备战秋招60天算法挑战，Day13
溜达虎的博客
08-06 382
在我们刷题的时候，适当的借助现有的数据结构往往会起到事半功倍的效果，今天我们讨论一下栈的使用。栈的特点是先进后出，利用栈的这个特点可以巧妙的解决很多问题，借助下面这道题我们进一步来体会一下栈的妙用。给定一个只包括 ，，，，， 的字符串 ，判断字符串是否有效。有效字符串需满足：举个例子： 视频题解 有效的括号 思路来源 思路来源 思路解析 首先要理解题意，什么才是题目中描述的有效括号，比如, 如下图，把同类型的括号单独按顺序拆出来，每种类型的括号都是能闭合的，但是并不是合法的。因为最先和闭合的是，违背了
代码随想录算法训练营第三十三天 | 动态规划理论基础、509. 斐波那契数、70. 爬楼梯、746. 使用最小花费爬楼梯
weixin_43581681的博客
08-01 318
1. 动态规划基础；2. 背包问题；3. 打家劫舍；4. 股票问题；5. 子序列问题。1. 确定 dp[ i ] 数组及下标含义；2. 确定递推公式；3.确定dp数组如何初始化；4. 确定遍历顺序（背包问题中很重要）；5. 举例推导dp数组。
TypeScript 及算法准备
qq_25416827的博客
08-02 875
typescript复制代码function mergeSortedArrays(arr1: number[], arr2: number[]): number[] {typescript复制代码function flattenArray(arr: any[]): any[] {typescript复制代码function flattenArray(arr: any[]): any[] {typescript复制代码function flattenArray(arr: any[]): any[] {
BackTrack5中文使用手册
"BackTrack5中文指南v5是神经元信息安全多元团队编写的关于BackTrack5的详细使用手册，旨在帮助用户了解和掌握这个著名的网络安全分析操作系统。该指南覆盖了从文档管理、系统简介、下载方法到安装和使用等多个方面...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值