算法入门第11天-递归/回溯(中等3个)-排列组合题

最新推荐文章于 2023-02-25 17:11:28 发布

cjn1997

最新推荐文章于 2023-02-25 17:11:28 发布

阅读量201

点赞数

分类专栏：算法入门

本文链接：https://blog.csdn.net/cjn1997/article/details/119539295

版权

算法入门专栏收录该内容

12 篇文章 0 订阅

订阅专栏

1. leetcode 46 - 全排列(中等)

1.1 题目描述

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

示例 1：

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

示例 2：

输入：nums = [0,1]
输出：[[0,1],[1,0]]

示例 3：

输入：nums = [1]
输出：[[1]]

提示：

1 <= nums.length <= 6
-10 <= nums[i] <= 10
nums 中的所有整数互不相同

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/permutations
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

1.2 代码实现

全排列，经典的回溯问题。
回溯算法：使用一个状态变量path去遍历全部的状态空间；对于每个节点，都需要判断是否在当前状态中，不在就加入当前状态，递归进入下一状态，直至该状态变量的大小符合条件，然后去除状态里的最后一个节点，回溯至上一状态。

class Solution {

    List<List<Integer>> res = new ArrayList<>();

    public List<List<Integer>> permute(int[] nums) {
        List<Integer> path = new ArrayList<>();
        backtrack(path, nums);
        return res;
    }

    public void backtrack(List<Integer> path, int[] nums){
        if(path.size() == nums.length){
            //由于回溯是使用一个状态变量path遍历全部状态空间，因此这里需要浅拷贝path的值，而path最终回归根节点，变成[]
            res.add(new ArrayList<>(path));
            return;
        }

        //使用循环来遍历同一个状态下不同的分支
        for(int i = 0; i < nums.length; i++){
            if(path.contains(nums[i])){
                continue;
            }
            //当前状态做出选择
            path.add(nums[i]);
            //递归处理下一状态
            backtrack(path, nums);
            //撤销选择，回溯到上一节点
            path.remove(path.size()-1);
        }
    } 
}

时间复杂度：O(n*n!)， n个数的全排列；
空间复杂度：O(n)，递归深度为n。

2. leetcode 77 - 组合(中等)

2.1 题目描述

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

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

示例 1：

输入：n = 4, k = 2
输出：
[
[2,4],
[3,4],
[2,3],
[1,2],
[1,3],
[1,4],
]

示例 2：

输入：n = 1, k = 1
输出：[[1]]

提示：

1 <= n <= 20
1 <= k <= n

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/combinations
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2.2 代码实现

n个数选k个数，组合型问题。

class Solution {

    List<List<Integer>> res = new ArrayList<>();

    public List<List<Integer>> combine(int n, int k) {
        List<Integer> list = new ArrayList<>();
        backtrack(list, n, k, 1);
        return res;
    }

    public void backtrack(List<Integer> list, int n, int k, int curr){
    	//剪枝：将不能构成组合的情况剪掉
        if(list.size() + n-curr+1 < k){
            return;
        }
        if(list.size() == k){
        	//对list进行浅拷贝，如果直接add(list)，当list变化时，res会随之变化；
            res.add(new ArrayList(list));
            return;
        }
        //选择当前数字
        list.add(curr);
        //递归到下一状态
        backtrack(list, n, k, curr+1);
        //不选当前数字
        list.remove(list.get(list.size()-1));   
        //递归到下一状态
        backtrack(list, n, k, curr+1);
    }
}

时间：O(C(n,k) * k)；
空间：O(n)，递归栈空间。

3. leetcode 784 - 字母大小写全排列(中等)

2.1 题目描述

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

示例：

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

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

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

提示：

S 的长度不超过12。
S 仅由数字和字母组成。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/letter-case-permutation
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2.2 代码实现

参考官答：
思路：遍历字符串，对于每个字符，有2种情况：

当前字符是数字，则无需处理，直接加到结果列表里的每个字符串尾部；
当前字符是字母，在结果列表将现有所有字符串复制一遍依次加到结果列表里，然后每次取出2个相同的字符串，在字符串尾部分别加上该字符的小写和大写。

class Solution {
    public List<String> letterCasePermutation(String s) {
        List<StringBuilder> res = new ArrayList<>();
        res.add(new StringBuilder());

        for(int i = 0; i < s.length(); i++){
            char curr = s.charAt(i);
            int len = res.size();
            if(Character.isLetter(curr)){
                //当前字符是字母
                for(int j = 0; j < len; j++){
                    //复制一份加到结果链表尾部
                    res.add(new StringBuilder(res.get(j)));
                    //对两个字符串尾部分别添加小写和大写
                    res.get(j).append(Character.toLowerCase(curr));
                    res.get(j+len).append(Character.toUpperCase(curr));
                }
            }else{
                //当前字符是数字
                for(int j = 0; j < len; j++){
                    //所有字符串尾部添加该数字
                    res.get(j).append(curr);
                }
            }
        }
		//StringBuilder转String,返回结果
        List<String> resList = new ArrayList<>();
        for(StringBuilder str: res){
            resList.add(str.toString());
        }
        return resList;
    }
}