全组合（SubSets）全排列（Permutation）全组合和（Combination Sum）解题技巧

最新推荐文章于 2022-11-09 22:52:57 发布
最新推荐文章于 2022-11-09 22:52:57 发布
阅读量1.7k 收藏 8
点赞数 4
分类专栏： 数据结构与算法分析 LeetCode算法编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiakexiaohu/article/details/119721618
版权

1.1 全组合(无重复)

  • 题目：给定一个数组（不存在重复），输出所有可能的组合，不限定顺序（LeetCode 78）。
  • 样例：[1,2,3]=>[[],[1],[2],[3],[1,2],[1,3],[2,3],[1,2,3]]
  • 技巧：因为是不存在重复的，典型的采用递归即可，即每次取定第一个开始的节点，然后从该节点后面开始放数据和出数据
  • 代码：
class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        // 思路：经典的排列组合问题
        if(nums==null||nums.length==0){
            return new ArrayList<>();
        }
        
        // 如果不需要去重，则不需要排序
        List<List<Integer>> list=new ArrayList<>();
        backtrack(nums,list,new ArrayList<>(),0);
        return list;
    }
    
    private void backtrack(int [] nums,List<List<Integer>> list,List<Integer> subList,int index){
        if(index>nums.length){
            return;
        }
        
        list.add(new ArrayList<>(subList));
        for(int i=index;i<nums.length;i++){
            subList.add(nums[i]);
            backtrack(nums,list,subList,i+1);
            subList.remove(subList.size()-1);
        }
    }
}

1.2 全组合(重复)

  • 题目：同上，但是存在重复(LeetCode 90)。
  • 样例：[1,2,2]=>[[],[1],[1,2],[1,2,2],[2],[2,2]]
  • 技巧：因为存在重复，所以我们必然得先排序，然后每次选定一个开始的节点，考虑到会存在重复，所以我们在访问完第一个重复的节点后，需要跳过重复的节点来选其为第一个节点。最后，就是递归重复1.1的放数据和出数据了。
  • 代码:
class Solution {
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        // 思路:需要对数字进行排序，第一个交换字符在后续递归过程中需要去重（第一次的话则不需要）。
        // 思路2:使用Set<List<Integer>> 可对数据进行去重。
        // 以上两个思路都需要对字符串进行排序后处理。
        if(nums==null||nums.length==0){
            return new ArrayList<>();
        }
        Arrays.sort(nums);
        List<List<Integer>> list=new ArrayList<>();
        backtrack(nums,list,new ArrayList<>(),0);
        return list;
    }
    
    private void backtrack(int []nums,List<List<Integer>> list,List<Integer> subList,int index){
        if(index>nums.length){
            return;
        }
        
        list.add(new ArrayList<>(subList));
        for(int i=index;i<nums.length;i++){
            if(i>index&&nums[i]==nums[i-1]){
                // 进行重复的第一个字符进行去重
                continue;
            }
            
            subList.add(nums[i]);
            backtrack(nums,list,subList,i+1);
            subList.remove(subList.size()-1);
        }
    }
}

1.3 全排列（无重复）

  • 题目：给定数组，其中不包含重复数据，需要输出所有可能的全排列，不限定顺序（LeetCode 46）。
  • 样例：[1,2,3]=>[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]
  • 技巧：
    • 解法1:考虑到无重复数据，我们只需每次选定一个数作为最开始的节点，然后for循环的选择第2个节点，但是我们需要用一个标识位数组来记录已经访问过的节点（即这些节点已经在前面放进去了）。然后递归的就是放数据和改标识位。
    • 解法2:考虑到无重复数据，最初，我们可以选定下标为0的为第一部分的第一个节点数据，然后选择后面的每一个节点跟其交换，从而形成一个排列。同理，这样后面部分同理采用递归的方式来选择当前部分第一个节点，依旧选择后面一个节点跟其交换。
    • 对比：
      • 解法1：简单，且容易理解和写出来。
      • 解法2：速度更快，因为通过交换的方式减少了数据的放入和放出。
  • 代码：
  • 解法1:
class Solution {
    public List<List<Integer>> permute(int[] nums) {
        // 思路：暴力解法，采用递归遍历的方式，采用一个数组记录已经访问的节点
        if(nums==null||nums.length==0){
            return new ArrayList<>();
        }
        
        List<List<Integer>> list=new ArrayList<>();
        backtrack(nums,list,new ArrayList<>(),new boolean [nums.length]);
        return list;
    }
    
    private void backtrack(int [] nums,List<List<Integer>> list,List<Integer> subList,boolean [] visited){
        if(subList.size()==nums.length){
            list.add(new ArrayList<>(subList));
        }else{
            for(int i=0;i<nums.length;i++){
                if(visited[i]){
                    continue;
                }
                
                visited[i]=true;
                subList.add(nums[i]);
                backtrack(nums,list,subList,visited);
                subList.remove(subList.size()-1);
                visited[i]=false;
            }
        }
    }
}
  • 解法2:
class Solution {
    public List<List<Integer>> permute(int[] nums) {
        // 思路：使用剑指offer的方式，每次交换第一个位置，然后递归后续的数据
        if(nums==null||nums.length==0){
            return new ArrayList<>();
        }
        
        List<List<Integer>> list=new ArrayList<>();
        backtrack(nums,list,0);
        return list;
    }
    
    private void backtrack(int [] nums,List<List<Integer>> list,int index){
        if(index==nums.length){
            // 已经到末尾了
            list.add(getList(nums));
        }else{
            for(int i=index;i<nums.length;i++){
                // 当前index位置和后面的每个都进行一次交换
                swap(nums,index,i);
                // 对index后面部分递归调用backtrack，即保证交换第一个位置后面的部分也按照第一个交换的规律进行交换
                backtrack(nums,list,index+1);
                swap(nums,i,index);
            }
        }
    }
    
    private List<Integer> getList(int [] nums){
        List<Integer> list=new ArrayList<>();
        for(int num:nums){
            list.add(num);
        }
        return list;
    }
    
    private void swap(int [] nums,int i,int j){
        int tmp=nums[i];
        nums[i]=nums[j];
        nums[j]=tmp;
    }
}

1.4 全排列（重复）

  • 题目：同上，但是存在重复数据（LeetCode 47）。
  • 样例：[1,1,2]=>[[1,1,2],[1,2,1],[2,1,1]]
  • 技巧：
    • 解法1：同1.3的解法1，因为存在重复数据，我们需要对数据进行排序，然后每次选定第一个没有访问的过重复作为第一个节点。最后，就是按照上面解法1的做法了（如果同前面一样，并且前面没有访问过的话，说明该节点为重复的，则不能选择）。
    • 解法2：同1.3的解法2，我们需要每次都跳过同第一个节点一样的来进行交换（因为后面节点跟第一个节点一样，两者交换的排列一样的）。
  • 代码：
  • 解法1：
class Solution {
    public List<List<Integer>> permuteUnique(int[] nums) {
        // 思路：采用最简单的暴力解法试下，由于存在重复，所以必须先排序，且我们需要采用一个数组来记录已经访问的节点
        if(nums==null||nums.length==0){
            return new ArrayList<>();
        }
        
        Arrays.sort(nums);
        List<List<Integer>> list=new ArrayList<>();
        backtrack(nums,list,new ArrayList<>(),new boolean[nums.length]);
        return list;
    }
    
    private void backtrack(int [] nums,List<List<Integer>> list,List<Integer> subList,boolean [] visited){
        if(subList.size()==nums.length){
            list.add(new ArrayList<>(subList));
        }else{
            for(int i=0;i<nums.length;i++){
                if(visited[i]||(i>0&&nums[i]==nums[i-1]&&!visited[i-1])){
                    // 若已经访问过了或者同前面一样并且前面的还没有被访问过，说明前面一直是重复节点，不能选该节点放下去
                    continue;
                }
                
                subList.add(nums[i]);
                visited[i]=true;
                backtrack(nums,list,subList,visited);
                visited[i]=false;
                subList.remove(subList.size()-1);
            }
        }
    }
}
  • 解法2:
class Solution {
    public List<List<Integer>> permuteUnique(int[] nums) {
       // 思路：采用第一个位置作为交换位置，因为可能存在重复，所以需要对数组进行排序，然后去掉第一个交换位置和当前相同的情况，即第一个位置没必要使用相同的
        if(nums==null||nums.length==0){
            return new ArrayList<>();
        }
        
        List<List<Integer>> list=new ArrayList<>();
        backtrack(nums,list,0);
        return list;
    }
    
    private void backtrack(int []nums,List<List<Integer>> list,int index){
        if(index==nums.length){
            list.add(new ArrayList<>(asList(nums)));
        }else{
            for(int i=index;i<nums.length;i++){
                if(!needSwap(nums,index,i)){
                    continue;
                }
                swap(nums,index,i);
                backtrack(nums,list,index+1);
                swap(nums,i,index);
            }
        }
    }
    
    private boolean needSwap(int []nums,int index,int i){
        for(int start=index;start<i;start++){
            // 说明第一个节点到i这段中间存在和i一样的，所以不需要更换，因为重复的节点交换没有意义
            if(nums[start]==nums[i]){
                return false;
            }
        }
        return true;
    }
    
    private List<Integer> asList(int [] nums){
        List<Integer> list=new ArrayList<>();
        for(int num:nums){
            list.add(num);
        }
        return list;
    }
    
    private void swap(int [] nums,int i,int j){
        int tmp=nums[i];
        nums[i]=nums[j];
        nums[j]=tmp;
    }
}

1.5 全组合和（无重复）

  • 题目：给定数组和target，我们需要找出满足子数组和等于target的所有满足条件的子数组，且不限定顺序，其中每个数字可以重复使用多次（LeetCode 39）。
  • 样例：[2,3,6,7],target=7 => [[2,2,3],[7]]
  • 说明：每个数字>=0，数组长度<=30，无重复数字。
  • 技巧：同上面解题思路类似，只是这里我们可以对每个数组使用多次，我们每次递归需要把当前剩余的差值（target-nums[i]）作为target当作参数传入。
  • 代码：
class Solution {
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        // 思路：典型的递归求组合和
        if(candidates==null||candidates.length==0||target==0){
            return new ArrayList<>();
        }
        
        List<List<Integer>> list=new ArrayList<>();
        backtrack(candidates,list,new ArrayList<>(),target,0);
        return list;
    }
    
    public void backtrack(int [] candidates,List<List<Integer>> list,List<Integer> subList,int remain,int index){
        if(remain<0){
            // 因为都是正数，所以不可能得到remain为负数的情况
            return;
        }
        
        if(remain==0){
            list.add(new ArrayList<>(subList));
        }else{
            for(int i=index;i<candidates.length;i++){
                subList.add(candidates[i]);
                // 因为每个数字可以使用多次，即下一次还是可以以该下标作为开始节点
                backtrack(candidates,list,subList,remain-candidates[i],i);
                subList.remove(subList.size()-1);
            }
        }
    }
}

1.6 全组合（重复）

  • 题目：同上，但是数组中的每个数字我们只能使用一次。
  • 样例：[10,1,2,7,6,1,5],target=8 => [[1,1,6],[1,2,5],[1,7],[2,6]]
  • 技巧：因为存在重复，而且每个数我们只能用一次，所以我们需要
    排序，并且跳过重复数作为第一个选定的节点，然后就是递归进行同样的步骤即可。
  • 代码：
class Solution {
    public List<List<Integer>> combinationSum2(int[] nums, int target) {
        // 思路：因为不能用重复元素，所以需要排序，然后对不是第一次出现重复的数进行跳过
        if(nums==null||nums.length==0){
            return new ArrayList<>();
        }
        
        Arrays.sort(nums);
        List<List<Integer>> list=new ArrayList<>();
        backtrack(nums,list,new ArrayList<>(),target,0);
        return list;
    }
    
    private void backtrack(int [] nums,List<List<Integer>> list,List<Integer> subList,int remain,int index){
        if(remain<0){
            return ;
        }
        
        if(remain==0){
            list.add(new ArrayList<>(subList));
        }else{
            for(int i=index;i<nums.length;i++){
                // 去掉已经第一个元素为已经用过的组合
                if(i>index&&nums[i]==nums[i-1]){
                    continue;
                }
                
                subList.add(nums[i]);
                // 不能使用重复的元素，必须往后走
                backtrack(nums,list,subList,remain-nums[i],i+1);
                subList.remove(subList.size()-1);
            }
        }
    }
}

1.7 所有回文组合

  • 题目：给定字符串，我们需要找出所有满足回文（正反对称的）的子字符串。
  • 样例：“aab”=>[[“a”,“a”,“b”],[“aa”,“b”]]
  • 技巧：同1.1的全组合类型，我们需要选定开始的第一个节点，然后分别追加判断是否满足回文。同理，接着递归进行数据放入和放出。
  • 代码：
class Solution {
    public List<List<String>> partition(String s) {
        // 思路：典型的全组合问题，但是我们需要判断组合后的字符是否满足回文，如果不满足，则直接中断本次递归。
        if(s==null||s.length()==0){
            return new ArrayList<>();
        }
        
        List<List<String>> list=new ArrayList<>();
        backtrack(s.toCharArray(),list,new ArrayList<>(),0);
        return list;
    }
    
    private void backtrack(char [] chs,List<List<String>> list,List<String> subList,int index){
        if(index==chs.length){
            list.add(new ArrayList<>(subList));
        }else{
            for(int i=index;i<chs.length;i++){
                if(isPalindrome(chs,index,i)){
                    subList.add(getString(chs,index,i));
                    // 因为是组合，所以需要选当前下标i的后面一个作为开始节点
                    backtrack(chs,list,subList,i+1);
                    subList.remove(subList.size()-1);
                }
            }
        }
    }
    
    private boolean isPalindrome(char[] chs,int start,int end){
        while(start<end){
            if(chs[start++]!=chs[end--]){
                return false;
            }
        }
        return true;
    }
    
    private String getString(char[] chs,int start,int end){
        StringBuilder str=new StringBuilder();
        for(int i=start;i<=end;i++){
            str.append(chs[i]);
        }
        return str.toString();
    }
}

2.小结

  • 针对全排列：如果第一时间想不到交换的方式，可以采用从0->length的全排列探测法来放入数据，同时采用visited标识位数组来记录已经访问过的节点。
  • 针对全组合：每次递归的下标即当前访问节点的i的下一个i+1（因为是从当前节点的后面开始选节点），所以不能使用第一个index（index仅表示当前递归部分的第一个节点，这种是在全排列交换数据的时候使用的）。

3.参考地址

xiakexiaohu
关注
  • 4
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
常见算法之全排列 全组合
wangduoxong的专栏
04-09 1054
全排列算法是一种比较常考的算法，他的做法也比较多样。 首先我们来看看最符合我们直观思考的，思路是这样的：假如没有重复元素时，传入一个数组A，并插入到另外一个数组B中，假如B中已经包含这个元素，则跳过，否则插入数组B。我们来看看具体代码： public static void permutation1(final String str, String buffer){ if (s
java 全组合 与全排列
weixin_30360497的博客
07-30 148
一、全组合 public static void Combination( ) { /*基本思路：求全组合，则假设原有元素n个，则最终组合结果是2^n个。原因是： * 用位操作方法：假设元素原本有：a,b,c三个，则1表示取该元素，0表示不取。故去a则是001，取ab则是011. * 所以一共三位，每个位上有两个选择...
全排列和全组合
qq_45712954的博客
10-15 123
全排列算法：这里用到了dfs深度优先搜索的方法 代码： #include<iostream> #include<cstdio> #include<cstring> #include<algorithm> #include<queue> #include<map> #define maxn 10 using namespace std; int a[10]; int fl[maxn]; int n,t; void dfs(int k) {
算法22--全组合
大魔王
11-13 2300
给定一个数组，输出其全组合  例如 123   输出  1，2，3，12，13，23，123 解法一： 对于N位数据，考虑每一位对于组合结果的影响，对于每一位可以选择取或者不取。一共有power(2,n)中取法，当全部不取时，对于最后结果没有意义，因此最终取法共有power(2,n)-1.可以利用二进制数字从1变为N，刚好变化过程中的二进制01分别对应每一位的取值情况，输出每一种情况即可。 ...
SubSetSum_return_求最小子集和_
10-01
Use an approximate algorithm to find the sum of subsets. S is a set of positive integers. Find a subset of S whose sum should be as large as possible but cannot exceed t
Combinatorial-Algorithms---Subsets-of-a-string:组合算法 - 字符串的子集
06-29
基本上，在这段代码中，我维护了一个数组，其中包含 0 和 1 的所有可能组合。 并且数组的长度等于字符串的长度。 现在，考虑到对于子集，要么选择字母，要么不选择字母。 如果 0 表示未选择，1 表示已选择，则基于 ...
用python实现回溯算法 适用于课程设计 所有组合 所有排列 所有子序列 着色等问题
05-19
python实现基本算法 所有组合 所有排列 所有子序列 ... Combination Sum Hamiltonian Cycle Knight Tour Minimax Minmax N Queens N Queens Math Rat In Maze Sudoku Sum Of Subsets Word Search
FSSgam:使用GA（M）M进行全子集模型拟合的代码
05-10
由两个功能组成：full.subsets.gam和check.correlations 需要：doSNOW，MuMIn，gamm4，mgcv，nnet最近使用R版本3.4.3测试 概括 全子集信息理论方法正成为一种越来越流行的工具，用于探索预测能力和变量重要性，...
subsets:https
05-06
var subsets = require ( 'subsets' ) ; var checks = 0 ; var sets = subsets ( [ 1 , 10 , 4 , 25 , 26 , 6 ] , function ( a , b ) { checks ++ ; return Math . abs ( a - b ) <= 3 ; } ) ; console . log ...
全组合的递归实现JAVA
03-27
全排列的非递归实现。输入1,2,3 得到 [1],[2],[3],[1,2],[1,3],[2,3],[1,2,3]六种组合
排列、组合、全排列、全组合——Java实现
ElizabethLing
09-10 3294
排列、组合、全排列、全组合——Java实现 排列的定义： 从n个不同元素中任取m（m≤n）个元素，按照一定的顺序排列起来，叫做从n个不同元素中取出m个元素的一个排列。当m=n时所有的排列情况叫全排列。 公式：全排列数f(n)=n!(定义0!=1) 组合的定义：从n个不同元素中，任取m(m≤n）个元素并成一组，叫做从n个不同元素中取出m个元素的一个组合；从n个不同元素中取出m(m≤n）个元素的...
java求集合的所有子集、所有子序列、全排列全组合问题
qq_28140917的博客
12-27 3866
1.求集合的所有子集（又称全组合） 求一个集合的所有组合，例如集合{A,B,C}的所有子集为：{},{A,B,C},{A,B},{A,C},{B,C},{A},{B},{C}。 思路 对于任意集合A，元素个数为n（空集n=0），则所有子集的个数为2^n个 如集合A={a,b,c},其子集个数为8；对于任意一个元素，在每个子集中， 要么存在，要么不存在，对应关系是： a=1或a=0，b=...
#经典面试题--全组合问题
流年梦里风起舞
05-04 380
给定一个非重复数数列，求该数列的全组合。例如，{1，2，3}的全组合为{1},{2},{3},{1,2},{1,3},{2,3},{1,2,3}。 这是一道非常经典的笔试题，可以通过递归来求解。这里我们可以利用上面已知的二进制方法来求解，我们可以将组合数中的每一个数标记为”1”,0表示未击中该组合数的任何数字，例如，110表示击中了该组合数的前两个数字，这样我们可以通过数组来取出这两个数字，从得到...
排列组合之——全组合（c语言）
m0_74820906的博客
11-09 1818
因此，我们选择的策略是：选择一个数放在第一位，然后选择这个数之后的一个数据放在第二位，然后再选第二个数之后的一个数放在第三位，以此类推，通过循环依次选择数据，我们可以实现不重复地列出所有组合。
全排列和全组合实现
南方以北
08-21 3780
全排列 所谓全排列，就是打印出字符串中所有字符的所有排列。例如输入字符串abc，则打印出 a、b、c 所能排列出来的所有字符串abc、acb、bac、bca、cab和cba。 一般最先想到的方法是暴力循环法，即对于每一位，遍历集合中可能的元素，如果在这一位之前出现过了该元素，跳过该元素。例如对于abc，第一位可以是 a 或 b 或 c 。当第一位为 a 时，第二位再遍历集合，发现...
高效全组合算法实现
Growth Diary
02-28 6893
昨天晚上，一个在当当实现的同学回来，说遇到了一个算法没看明白，仔细一看，还挺有意思，现在给大家分享一下。 算法说明：当n大于2时，n个数的全组合一共有(2^n)-1种。 当对n个元素进行全组合的时候，可以用一个n位的二进制数表示取法。 1表示在该位取，0表示不取。 例如，对ABC三个元素进行全组合，用二进制表示如下   001表示取C，      001=1 010表示取B
全组合
zrh_CSDN的博客
07-15 285
假设原有元素 n 个，则最终组合结果是2^n-1个。 用位操作方法：假设元素原本有：a,b,c 三个，则 1 表示取该元素，0 表示不取。故取a则是001，取ab则是011,取abc是111； 这些结果的位图值都是 1,2…2^n-1。所以从值 1 到值2^n-1  依次输出结果： 001,010,011,100,101,110,111 。对应输出组合结果为：a,b,ab,c,ac,bc,a...
js怎么用全排列组合求集合的子集合
最新发布
07-04
可以使用递归算法来实现全排列组合求集合的子集合。以下是一个使用JavaScript实现的示例代码： ```javascript function getSubsets(set) { // 初始化结果数组 let subsets = [[]]; for (let i = 0; i ; i++) { ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值