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

最新推荐文章于 2025-02-24 19:47:40 发布
最新推荐文章于 2025-02-24 19:47:40 发布
阅读量2.2k 收藏 8
点赞数 4
分类专栏： 数据结构与算法分析 LeetCode算法编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiakexiaohu/article/details/119721618
版权
本文解析了LeetCode中涉及全组合、全排列以及特殊情况如重复元素、回文子串等问题的解题策略。通过递归和排序技巧，探讨了不同场景下的算法实现，包括无重复、允许重复、回文子串检测等，适合初学者理解递归和组合问题的解决方案。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

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.参考地址

写给零基础的前端算法入门指南，acmer带女友刷80+【递归与回溯篇】｜牛气冲天新年征文
超逸の学习技术博客
02-16 3427
前言 各位小伙伴们新年好呀，时隔一周，俺又回来更新文章啦！在上一篇发出去之后，虽然没有得到很多的阅读量，但是后面几篇文章还是得要更新出来，我想总能够帮助一小部分人咯~ 现在和大家分享一下我们是如何准备算法这一块的，春招即将开启，还能最后准备一下，希望对大家有所帮助。 原本打算通过一篇文章介绍一下，推荐一下自己的刷题方式和刷题路线，得到一些伙伴的反馈：最好还是更加详细，面向零基础，小白这些，还有github访问速度也是一方面问题，可能图片都加载不出来。 因此，我打算分模块出几期文章，这样你只用通过首发在.
Leetcode 解题报告
热门推荐
勿忘初衷
06-20 1万+
据说刷完leetcode是准备编程面试的第一步。想到明年可能就要开始找工作了，先准备着吧。 计划今年11月份前做完，大概平均每天2-3题，难度应该不大，贵在坚持！ 代码放在github上，地址：https://github.com/xingjian-f/Leetcode-solution 简略解题报告 1 Two Sum 三种解法： 1 暴力枚举所有的两两组合，检查它们的和是否等于
常见算法之全排列 全组合
wangduoxong的专栏
04-09 1137
全排列算法是一种比较常考的算法，他的做法也比较多样。 首先我们来看看最符合我们直观思考的，思路是这样的：假如没有重复元素时，传入一个数组A，并插入到另外一个数组B中，假如B中已经包含这个元素，则跳过，否则插入数组B。我们来看看具体代码： public static void permutation1(final String str, String buffer){ if (s
全排列和全组合实现
u012861978的专栏
07-17 853
全排列 所谓全排列，就是打印出字符串中所有字符的所有排列。例如输入字符串abc，则打印出 a、b、c 所能排列出来的所有字符串 abc、acb、bac、bca、cab 和 cba 。 一般最先想到的方法是暴力循环法，即对于每一位，遍历集合中可能的元素，如果在这一位之前出现过了该元素，跳过该元素。例如对于abc，第一位可以是 a 或 b 或 c 。当第一位为 a 时，第二位再遍历集合，发现 a
对全排列求和问题的解决方法
最新发布
Sleepyshoggoth的博客
02-24 349
一开始我以为这就是个求有限个数的子集全排列加和的问题，很容易让人想把问题拆解成对应的子问题，但在尝试过后发现代码的逻辑过于复杂，并且存在递归层数过多导致的性能问题。这天小 Z 遇到了一家水果加工厂商，这家厂商可以用任意组合的水果各一个制作甜品，制作出的甜品的甜蜜值为这些水果甜蜜值之和。但是，这家厂商有一个规定，同一位客户不可以制作完全相同的两个甜品，小 Z 想知道，他能够获得的甜蜜值之和最多有多少？小 Z 有 n 种水果，每种水果有无限个，第 i 种水果的甜蜜值为 ai​。
java 全组合 与全排列
weixin_30360497的博客
07-30 205
一、全组合 public static void Combination( ) { /*基本思路：求全组合，则假设原有元素n个，则最终组合结果是2^n个。原因是： * 用位操作方法：假设元素原本有：a,b,c三个，则1表示取该元素，0表示不取。故去a则是001，取ab则是011. * 所以一共三位，每个位上有两个选择...
全排列和全组合
weixin_42282999的博客
09-16 1158
1、全排列 题目 输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则按字典序打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。 分析 1、把整个字符串视为第一个字符和后来的字符的组合 2、每次确定一个元素，和后面的元素依次兑换 https://zhuanlan.zhihu.com/p/34114529 代码 class Solution { public: vector<string> result; v
全排列算法与全组合算法
weixin_33955681的博客
05-28 140
转载自董的博客：http://dongxicheng.org/structure/permutation-combination/ 1. 前言 本文介绍了经常使用的排列组合算法，包含全排列算法，全组合算法，m个数选n个组合算法等。 2. 排列算法 常见的排列算法有： (A)字典序法 (B)递增进位制数法 (C)递减进位制...
Leetcode分类解析：组合算法
西代零零发
07-04 8186
Leetcode分类解析：组合算法所谓组合算法就是指：在解决一些算法问题时，需要产生输入数据的各种组合、排列、子集、分区等等，然后逐一确认每种是不是我们要的解。从广义上来说，组合算法可以包罗万象，甚至排序、各种搜索算法都可以算进去。最近读《The Algorithm Design Manual》时了解到这种归类，上网一查，甚至有专门的书籍讲解，而且Knuth的巨著TAOCP的第四卷就叫组合算法，看来
九章算法题解记录【一】入门与排列组合模板
Ach_orite的博客
07-19 743
九章算法第一课解题记录
Java算法实现大全：从基础到LeetCode经典案例
40. 组合总和II问题（Combination Sum II）: 与组合总和类似，但同一数字不能重复使用。 41. 缺失的第一个正数问题（First Missing Positive）: 要求找出最小的正整数，该整数未出现在给定的数组中。 42. 接雨水...
全组合
qq_26498709的博客
10-10 252
public class 全组合 {public static void main(String[] args) { char[] s = {'a','b','c'}; Combaine(s); } public static void Combaine(char []s){ int len = s.length; int n = 1<<len; f
全排列，组合问题
weixin_34283445的博客
07-16 105
包括了排列，组合，子集问题，子集带重复问题，基本全了，就差在看看leetcode以前怎么写的了 1 //全排列的两种方法 2 #include <iostream> 3 #include <vector> 4 #include <algorithm> 5 using namespace std; 6 7 //方法一...
组合问题：全组合和C(n,m)
HelloCooper的博客
09-29 857
问题： 1.数组a[1~n]，生成数组中所有元素的组合。 2.生成C(n,m)组合问题一：全组合思想: 数组长度为4，用4位2进制：0000～1111，二进制位为1表示选取该位元素，0表示不选。 代码：//nums数组长度为n，mask为n位二进制掩码，二进制位为0，则选取该对应元素 vector<int> getCombByMask(vector<int> nums,int mask,int
全排列和全组合问题
一个吃水不忘挖井人的博客。希望能帮助到你
03-25 1490
排列问题求这4个球的所有排列方式暴力枚举方式。public static void main(String[] args) { char[] cc = {'A','B','C','D'}; int count = 0; for(int i=0;i&lt;4;i++){ for(int j=0;j&lt;4;j++){ if(i==...
js怎么用全排列组合求集合的子集合
07-04
可以使用递归算法来实现全排列组合求集合的子集合。以下是一个使用JavaScript实现的示例代码： ```javascript function getSubsets(set) { // 初始化结果数组 let subsets = [[]]; for (let i = 0; i < set.length; i++) { // 获取当前元素 const currentElement = set[i]; // 复制现有子集 const existingSubsets = subsets.slice(); // 将当前元素添加到现有子集中 for (let j = 0; j < existingSubsets.length; j++) { existingSubsets[j] = existingSubsets[j].concat(currentElement); } // 将现有子集与结果数组合并 subsets = subsets.concat(existingSubsets); } return subsets; } // 示例用法 const set = [1, 2, 3]; const subsets = getSubsets(set); console.log(subsets); ``` 这段代码中，我们定义了一个名为`getSubsets`的函数，它接受一个数组作为参数，并返回该数组的所有子集合。 在函数内部，我们首先初始化一个包含空数组的结果数组`subsets`，表示空集合的子集合。 然后，我们遍历集合中的每个元素。对于每个元素，我们复制现有的子集合，并将当前元素添加到复制的子集合中。 最后，我们将复制的子集合与结果数组合并，得到更新后的结果数组。 在示例用法中，我们将数组`[1, 2, 3]`传递给`getSubsets`函数，并将结果打印到控制台上。输出将是该集合的所有子集合。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值