leetcode回溯算法总结

最新推荐文章于 2023-05-09 14:07:49 发布
最新推荐文章于 2023-05-09 14:07:49 发布
阅读量265 收藏
点赞数
分类专栏： 编程题 文章标签： 算法 java leetcode 回溯
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52212721/article/details/115440483
版权

17. 电话号码的字母组合
46. 全排列
47. 全排列 II
39. 组合总和
40. 组合总和 II
491. 递增子序列
77. 组合
78. 子集
90. 子集 II
60. 排列序列
784. 字母大小写全排列
22. 括号生成
51. N 皇后
491. 递增子序列
93. 复原 IP 地址
回溯算法入门级详解 + 练习（持续更新）

文章目录

17. 电话号码的字母组合

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

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

class Solution {
    public List<String> letterCombinations(String digits) {
        List<String> list=new ArrayList<>();
        StringBuffer strbf=new StringBuffer();
        if(digits==null||digits.length()<=0)
        return list;
        Map<Character,String> map=new HashMap<>();
        map.put('2',"abc");map.put('3',"def");map.put('4',"ghi");
        map.put('5',"jkl");map.put('6',"mno");map.put('7',"pqrs");
        map.put('8',"tuv");map.put('9',"wxyz");
        backTrack(list,digits,map,strbf,0);
        return list;
    }
    private void backTrack(List<String> list,String digits,Map<Character,String> map,StringBuffer strbf,int index){
        if(index==digits.length()){
            list.add(strbf.toString());
            return;
        }
        String str=map.get(digits.charAt(index));
        for(int i=0;i<str.length();i++){
            strbf.append(str.charAt(i));
            backTrack(list,digits,map,strbf,index+1);
            strbf.deleteCharAt(index);
        }
    }
}

46. 全排列

给定一个 没有重复 数字的序列，返回其所有可能的全排列。

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<Integer> list = new ArrayList<>();
        List<List<Integer>> res=new ArrayList<>();
        int n=nums.length;
        boolean[] isused=new boolean[n];
        backTrack(nums,list,res,0,n,isused);
        return res;
    }
    private void backTrack(int[] nums,List<Integer>list,List<List<Integer>> res,int index,int n,boolean[] isused){
        if(index==n){
            res.add(new ArrayList<>(list));
            return;
        }
        for(int i=0;i<n;i++){
            if(isused[i]==false){
                isused[i]=true;
                list.add(nums[i]);
                backTrack(nums,list,res,index+1,n,isused);
                isused[i]=false;
                list.remove(list.size()-1);
            }
        }
    }
}

47. 全排列 II

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。
差解：用了一个Set判断

class Solution {
    public List<List<Integer>> permuteUnique(int[] nums) {
        List<Integer> list = new ArrayList<>();
        List<List<Integer>> res=new ArrayList<>();
        Set<List<Integer>> set=new HashSet<>();
        int n=nums.length;
        boolean[] isused=new boolean[n];
        backTrack(nums,list,set,0,n,isused);
        return new ArrayList(set);
    }
    private void backTrack(int[] nums,List<Integer>list,Set<List<Integer>> res,int index,int n,boolean[] isused){
        if(index==n){
            res.add(new ArrayList<>(list));
            return;
        }
        for(int i=0;i<n;i++){
            if(isused[i]==false){
                isused[i]=true;
                list.add(nums[i]);
                backTrack(nums,list,res,index+1,n,isused);
                isused[i]=false;
                list.remove(list.size()-1);
            }
        }
    }
}

优解：

class Solution {
    public List<List<Integer>> permuteUnique(int[] nums) {
        List<Integer> list = new ArrayList<>();
        List<List<Integer>> res=new ArrayList<>();  
        Arrays.sort(nums);
        int n=nums.length;
        boolean[] isused=new boolean[n];//这个是说当前位置的元素是否被使用过
        backTrack(nums,list,res,0,n,isused);
        return res;
    }
    private void backTrack(int[] nums,List<Integer>list,List<List<Integer>> res,int index,int n,boolean[] isused){
        if(index==n){
            res.add(new ArrayList<>(list));
            return;
        }
        for(int i=0;i<n;i++){
            if(isused[i]||(i>0&&nums[i]==nums[i-1]&&!isused[i-1]))//可能会疑惑这里为什么要加isused[i-1}
            continue;
            isused[i]=true;
            list.add(nums[i]);
            backTrack(nums,list,res,index+1,n,isused);
            isused[i]=false;
            list.remove(list.size()-1);
            
        }
    }
}

!isused[i-1]

当看了下面的组合总和II后可能会疑惑为什么要加这一句话。
这是因为我们这里的插入空隙的选择是从0开始的，而下面的题是从index开始的。
即区别以下两种状况：
—— —— ——
1.1(第一个一) 1.2 2
1.2(第二个一) 1.1 2
当从下标0开始选择，选择1.1，然后进入下一个位置(第二个位置)进行选择，而如果不写上isused[i-1]这句话的话，则会无法选择1.2
而(i>0&&nums[i]==nums[i-1)这句话的作用，就是为了让第一个位置无法选择1.2.
意思是，前一句是为了让第一个位置无法选择1.2，后一句是为了让第二个位置可以选择1.2.可以与组合综合II对比一下。

39. 组合总和

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的数字可以无限制重复被选取。

说明：

所有数字（包括 target）都是正整数。
解集不能包含重复的组合。

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

}

40. 组合总和 II

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

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

说明：

所有数字（包括目标数）都是正整数。
解集不能包含重复的组合。
出现重复解：

class Solution {
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        List<Integer> list=new ArrayList<>();
        List<List<Integer>> res=new ArrayList<>();
        backTack(candidates,target,list,res,0,0);
        return res;
    }
    private void backTack(int[] candidates,int target,List<Integer>list,List<List<Integer>> res,int sum,int index){
        if(sum==target){
            res.add(new ArrayList<>(list));
            return;
        }
        if(sum>target||index==candidates.length){
            return;
        }
        for(int i=index;i<candidates.length;i++){
            list.add(candidates[i]);
            backTack(candidates,target,list,res,sum+candidates[i],i+1);
            list.remove(list.size()-1);
        }
    }
}

无重复解：

class Solution {
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        List<Integer> list=new ArrayList<>();
        List<List<Integer>> res=new ArrayList<>();
        Arrays.sort(candidates);//排序
        backTack(candidates,target,list,res,0,0);
        return res;
    }
    private void backTack(int[] candidates,int target,List<Integer>list,List<List<Integer>> res,int sum,int index){
        if(sum==target){
            res.add(new ArrayList<>(list));
            return;
        }
        if(sum>target||index==candidates.length){
            return;
        }
        for(int i=index;i<candidates.length;i++){
            if(i>index&&candidates[i]==candidates[i-1])//判断
            continue;
            list.add(candidates[i]);
            backTack(candidates,target,list,res,sum+candidates[i],i+1);//当index=i+1时，是不允许当前元素再次使用的，而当index=i时，是允许当前元素再次使用的
            list.remove(list.size()-1);
        }
    }
}

 if(i>index&&candidates[i]==candidates[i-1])//判断
 continue;

可以将这一句理解为：
插入当前位置的时候，只能插一次

因为回溯算法和空白位置插入是差不多的。
如： —— —— —— (1,2,2)在这三个位置上进行计算求和
第一个位置可以是1，第二个位置可以是2.1(第一个二),也可以是2.2(第二个二）
在这种情况下就会产生：
1，2.1，2.2
1，2.2，2.1
这样的重复，但，加入我们在第二个位置加上限定：不允许插入和前一个元素相同的元素，那么，2.2就无法插入到第二个位置了。
就只会有1，2.1，2.2这一种选择。

77. 组合

给定两个整数 n 和 k，返回 1 … n 中所有可能的 k 个数的组合。

class Solution {
    public List<List<Integer>> combine(int n, int k) {
        List<Integer> list=new ArrayList<>();
        List<List<Integer>> res=new ArrayList<>();
        backTack(n,k,list,res,1,0);
        return res;
    }
    private void backTack(int n,int k,List<Integer> list, List<List<Integer>> res,int begin,int len){
        if(len==k){
            res.add(new ArrayList<>(list));
            return;
        }
        for(int i=begin;i<=n;i++){
            list.add(i);
            backTack(n,k,list,res,i+1,len+1);
            list.remove(list.size()-1);
        }
    }
}

78. 子集

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

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

class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        List<Integer> list=new ArrayList<>();
        List<List<Integer>> res=new ArrayList<>();
        backTack(nums,0,0,list,res);
        return res;
    }
    private void backTack(int[] nums,int index,int len,List<Integer> list,List<List<Integer>> res){
        if(len>nums.length)
        return;
        res.add(new ArrayList<>(list));
        for(int i=index;i<nums.length;i++){
            list.add(nums[i]);
            backTack(nums,i+1,len+1,list,res);
            list.remove(list.size()-1);
        }
        
    }
}

90. 子集 II

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

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

class Solution {
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        List<Integer> list=new ArrayList<>();
        List<List<Integer>> res=new ArrayList<>();
        boolean[] isused=new boolean[nums.length];
        Arrays.sort(nums);
        backTack(nums,list,res,0,0,isused);
        return res;
    }
    private void backTack(int[] nums,List<Integer> list, List<List<Integer>> res,int index,int len,boolean[] isused){
        if(len>nums.length)
        return;
        res.add(new ArrayList<>(list));
        for(int i=index;i<nums.length;i++){
            if(i>0&&nums[i]==nums[i-1]&&!isused[i-1])
            continue;
            isused[i]=true;
            list.add(nums[i]);
            backTack(nums,list,res,i+1,len+1,isused);
            list.remove(list.size()-1);
            isused[i]=false;
        }
    }
}

60. 排列序列

给出集合 [1,2,3,…,n]，其所有元素共有 n! 种排列。

按大小顺序列出所有排列情况，并一一标记，当 n = 3 时, 所有排列如下：

“123”
“132”
“213”
“231”
“312”
“321”
给定 n 和 k，返回第 k 个排列。

class Solution {
    String str;
    int sum=0;
    public String getPermutation(int n, int k) {
        boolean[] isused=new boolean[n];
        backTrack(n,k,0,isused,new StringBuffer());
        return str;
    }
    private void backTrack(int n,int k,int index,boolean[] isused,StringBuffer sb){
        if(sum==k)
        return;
        if(index==n){
            sum++;
            if(sum==k){
                str=sb.toString();
                return;
            }
        }
        for(int i=0;i<n;i++){
            if(isused[i])
            continue;
            isused[i]=true;
            sb.append(Integer.toString(i+1));
            backTrack(n,k,index+1,isused,sb);
            sb.deleteCharAt(sb.length()-1);
            isused[i]=false;
        }

    }
}

784. 字母大小写全排列

给定一个字符串S，通过将字符串S中的每个字母转变大小写，我们可以获得一个新的字符串。返回所有可能得到的字符串集合。

示例：
输入：S = “a1b2”
输出：[“a1b2”, “a1B2”, “A1b2”, “A1B2”]

输入：S = “3z4”
输出：[“3z4”, “3Z4”]

输入：S = “12345”
输出：[“12345”]

class Solution {
    public List<String> letterCasePermutation(String S) {
        List<String> list=new ArrayList<>();
        backTrack(S,0,new StringBuffer(),list);
        return list;

    }
    private void backTrack(String s,int index,StringBuffer sb,List<String> list){
        if(index==s.length()){
            list.add(sb.toString());
            return;
        }
        if(s.charAt(index)>='0'&&s.charAt(index)<='9'){
            sb.append(s.charAt(index));
            backTrack(s,index+1,sb,list);
            sb.deleteCharAt(sb.length()-1);
            return;
        }

        char c=helper(s.charAt(index));
        sb.append(c);
        backTrack(s,index+1,sb,list);
        sb.deleteCharAt(sb.length()-1);

        sb.append(s.charAt(index));
        backTrack(s,index+1,sb,list);
        sb.deleteCharAt(sb.length()-1);
    }
    private char helper(char c){
        if(c>='A'&&c<='Z')
        return Character.toLowerCase(c);
        else
        return Character.toUpperCase(c);
    }
}

22. 括号生成

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。

示例 1：

输入：n = 3
输出：["((()))","(()())","(())()","()(())","()()()"]
示例 2：

输入：n = 1
输出：["()"]

class Solution {
    public List<String> generateParenthesis(int n) {
        List<String> list=new ArrayList<>();
        backTrack(n,new StringBuffer(),list,0,0);
        return list;
    }
    private void backTrack(int n,StringBuffer sb,List<String> list,int left,int right){
        if(left>n||right>n||left<right)
        return;
        if(left==n&&right==n){
            list.add(sb.toString());
            return;
        }
        sb.append("(");
        backTrack(n,sb,list,left+1,right);
        sb.deleteCharAt(sb.length()-1);
        sb.append(")");
        backTrack(n,sb,list,left,right+1);
        sb.deleteCharAt(sb.length()-1);
    }
}

51. N 皇后

n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。

给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。

每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。

491. 递增子序列

给定一个整型数组, 你的任务是找到所有该数组的递增子序列，递增子序列的长度至少是 2 。

示例：

输入：[4, 6, 7, 7]
输出：[[4, 6], [4, 7], [4, 6, 7], [4, 6, 7, 7], [6, 7], [6, 7, 7], [7,7], [4,7,7]]

93. 复原 IP 地址

给定一个只包含数字的字符串，用以表示一个 IP 地址，返回所有可能从 s 获得的 有效 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 地址。

粉丝头子的故事
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode回溯算法
xylitolz的博客
03-05 469
文章目录回溯算法 vs 深度优先遍历回溯算法 vs 动态规划共同点不同点LeetCode 22. 括号生成题目回溯LeetCode 39. 组合总和题目回溯LeetCode 46. 全排列题目回溯Reference 回溯算法 vs 深度优先遍历 维基百科中「回溯算法」和「深度优先遍历」的定义: 回溯法 采用试错的思想，它尝试分步的去解决一个问题。在分步解决问题的过程中，当它通过尝试发现现有的分步答案不能得到有效的正确的解答的时候，它将取消上一步甚至是上几步的计算，再通过其它的可能的分步解答再次尝试寻找问题
leetcode之回溯算法
can_chen的博客
02-01 671
目录一 组合问题1. leetcode 77.组合2. leetcode 39.组合总和3. leetcode 40.组合总和II4. leetcode 216.组合总和III5. leetcode 377.组合总和IV6. leetcode 17.电话号码的字母组合二 排列问题1. leetcode 46.全排列2. leetcode 47.全排列II 一 组合问题 1. leetcode 77.组合 leetcode 77.组合 题目描述： 给定两个整数 n 和 k，返回 1 … n 中所有可能的 k
leetcode回溯算法
u010412301的博客
04-28 311
LeetCode--回溯法心得 ​ 武汉大学 软件工程硕士在读 ​关注他 206 人赞同了该文章 这两天在刷LeetCode37题解数独时，被这个回溯法折腾的不要不要的，于是我疼定思疼发誓一定要找个能解决这类回溯法的套路出来，方便以后快速解决此类题目。于是我在网上找了两个很经典的回溯法题目--八皇后问题和迷宫问题，认真总结了一番，发现其中还真的有一些共同之处，我会...
【LeetCode】-回溯算法
银尘博客
03-22 2224
文章目录前言一、组合 前言 初识LeetCode与算法，将在此系列文章里面，记录自己的算法学习经历，前期主要是监督自己学习打卡，后期我会将自己对知识的理解，慢慢补充到文章当中，希望大家能在阅读我的文章中，有所收获。该系列文章的刷题顺序以代码随想录为线索。 一、组合 题目： 给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。 你可以按 任何顺序 返回答案。 示例 1： 输入：n = 4, k = 2 输出： [ [2,4], [3,4], [2,3], [1,2], [1,3],
LeetCode解题总结
10-09
LeetCode解题总结 1. 数组 1.1 从有序数组中删除重复元素 1.2 在排序数组被旋转后进行查找 1.3 寻找两个排序数组的中位数 1.4 最长连续序列 1.5 累加和 1.6 移除数组中指定值 1.7 下一个排列 1.8 第n个全排列 1.9 ...
leetcode中文版-leetcode:算法笔记总结。包括《剑指offer》《程序员笔试面试指南》《Leetcode》相关题目
06-29
第四部分：《算法题型分类总结》，更新中。 关于学习笔记总结部分，请移步另一项目： 剑指offer: LeetCode: LeetCode专题训练 回溯法： 链表 ： 动态规划： 排序专题： 程序员代码面试指南 : chapter2 : 链表部分...
玩转算法面试 leetcode
01-13
1 算法面试到底是什么鬼？ 2 面试中的复杂度分析 3 数组中的问题其实最常见 4 查找表相关问题 5 在链表中穿针引线 6 栈、队列、优先队列 7 二叉树和递归 8 递归和回溯法 9 动态规划基础 ...11 课程总结
[持续更新]leetcode按算法与数据结构类型总结+java面试知识+互联网公司JAVA笔试题总结.zip
最新发布
01-14
算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...
leetcode中文版-LeetCode:算法练习：LeetCode问题、LeetCode每周竞赛等
06-29
LeetCode总结 所有的题目总结均在每一个package的README中 目录 搜索(回溯、BFS、DFS): 回溯：数独、N皇后、37、51、79、93、[212、301] BFS：矩阵、单词变换 排列、组合、分割、子集：四大类问题，常用回溯、DFS...
LeetCode算法之----回溯
程序大视界
01-07 889
回溯算法
Leetcode回溯法
baidu_41553551的博客
04-03 725
回溯法是复杂度很高的暴力搜索算法，实现简单且有固定模板，常被用于搜索排列组合问题的所有可行解。不同于普通的暴力搜索，回溯法会在每一步判断状态是否合法，而不是等到状态全部生成后再进行确认。当某一步状态非法时，它将回退到上一步中正确的位置，然后继续搜索。前进和后退是回溯法关键的动作。 回溯的本质就是暴力枚举所有可能。要注意的是，由于回溯通常结果集都记录在回溯树的路径上，因此如果不进行撤销操作， 则可能在回溯后状态不正确导致结果有差异， 因此需要在递归到底部往上冒泡的时候进行撤销状态。 如果你每次递归的过
Leetcode学习之回溯算法
frighting_ing的博客
11-14 4407
1. 回溯算法理论基础 什么是回溯法 回溯法也可以叫做回溯搜索法，它是一种搜索的方式。 在二叉树系列中，我们已经不止一次，提到了回溯，例如二叉树：以为使用了递归，其实还隐藏着回溯。 回溯是递归的副产品，只要有递归就会有回溯。 所以回溯函数也就是递归函数，指的都是一个函数。 回溯法的效率 回溯法的性能如何呢，必须强调的是，虽然回溯法很难，很不好理解，但是回溯法并不是什么高效的算法。 **因为回溯的本质是穷举，穷举所有可能，然后选出我们想要的答案，**如果想让回溯法高效一些，可以加一些剪枝的操作，但也改不了回
LeetCode：回溯算法
猪猪
08-04 250
（1）电话号码的字母组合 给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。 给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。 示例: 输入："23" 输出：["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf&quo
LeetCode 回溯法
abyss_miracle的博客
09-21 308
LeetCode78.子集全排列 大意：给一个数组如[1,2,3]，求出全部的排列情况： { [], [1], [1,2], [1,2,3], [1,3], [2], [2,3] [3] } 有两种回溯思路来做： 1.双递归：（转自力扣，笨猪爆破组） 单看每个元素，都有两种选择：选入子集中，或不选入子集中。 比如[1,2,3]，先考察 1，选或不选，不管选没选 1，都再考察 2，选或不选，以此类推。 画出递归树如下（解的空间树）： 一个子树是一个递归调用，考察当前枚举的数，选它，是一个分支，不选它，又是一
leetcode—回溯算法(easy)—4/15
zyt的博客
04-15 157
1.二进制手表 二进制手表顶部有4个LED代表小时（0-11），底部有6个LED代表分钟（0-59）。 每个LED代表一个0或1，最低位在右侧。 给定一个非负整数n代表当前LED亮着的数量，返回所有可能的时间。 思路： 对于给定的亮的灯个数num进行分解，分成小时灯个数hoursCnt、分钟灯个数minsCnt 对于小时灯个数hoursCnt小时的情况进行构造 对于分钟灯个数minsCnt分钟的...
LeetCode算法总结-回溯法与深度优先搜索
qq_45770532的博客
06-26 466
S
LeetCode之回溯算法
ji_meng的博客
05-09 702
（如果要问为什么还需要startIndex，因为这还是组合问题啊，也就是不能走回头路，比如[1,2,3]，目标和是4，你可以选[1,1,2]，如果没有startIndex，当你到2的时候，又会有[2,1,1]的可能！首先需要建立一个映射，从字符2-9映射到字母，可以hash可以数组。输入：nums = [1,2,2] 输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
leetcode 回溯
08-22
在LeetCode上，有许多使用回溯算法的题目。 回溯算法的基本思想是通过深度优先搜索，不断地尝试下一个可能的解，如果当前解不符合要求，则回退到上一个状态，继续尝试其他可能的解。这种方式有点类似于穷举法，但是...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值