Leetcode算法入门第十一天（递归 / 回溯）

77. 组合

题目描述

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

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

样例

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

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

思路

回溯法：把这一组合问题抽象成树形结构，每次从集合中取得一个数，取过的数不再重复取，所以不断缩减集合中可选的元素的范围，如果单个组合中的元素个数已经满足条件，就返回，这也是递归结束的条件。否则每次把当前元素压入单个组合中，然后调用下一个元素的搜索，最后回溯，弹出当前元素，即不选择当前元素，继续调用递归函数。

参考代码

class Solution {
public:
    vector<vector<int>> res;//满足条件的所有组合的集合
    vector<int> path;//符合条件的单个组合
    
    //用回溯法
    void backtracking(int n,int k,int index)
    {
        //递归终点：当单个组合path中元素满足k个，就可以终止
        if(path.size()==k)
        {
            res.push_back(path);
            return;
        }
        //处理单层递归逻辑
        //开始遍历递归树：
        for(int i=index;i<=n;i++)
        {
            //存入当前下标所指的元素，确定这一组合的第一个元素
            path.push_back(i);

            //调用自身：缩小搜索规模，寻找
            backtracking(n,k,i+1);
            //回溯:
            path.pop_back();
        }

    }
    vector<vector<int>> combine(int n, int k) {
        backtracking(n,k,1);
        return res;
    }
};

46. 全排列

题目描述

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

样例

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

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

思路

回溯法:全排列讲究顺序，所以每次都要从头开始搜索，使用标志数组标志在当前的单个排列结果中已经用过的元素，用过了就不能再用，即一个排列里一个元素只能使用一次。

参考代码

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    //used数组：标志已经保存过的元素
    void backtracking(vector<int>& nums,vector<bool>& used)
    {
        //递归终点：满足条件的排列
        if(path.size()==nums.size())
        {
            //存放当前排列
            res.push_back(path);
            return;
        }
        for(int i=0;i<nums.size();i++)
        {
            if(used[i]==true) continue;
            //保存当前节点
            path.push_back(nums[i]);
            used[i]=true;
            //递归调用
            backtracking(nums,used);
            //回溯:
            //弹出刚才压入的元素，并调整标志
            path.pop_back();
            used[i]=false;
        }

    }
    vector<vector<int>> permute(vector<int>& nums) {
        vector<bool> used(nums.size(),false);
        backtracking(nums,used);
        return res;

    }
};

784. 字母大小写全排列

题目描述

给定一个字符串 s ，通过将字符串 s 中的每个字母转变大小写，我们可以获得一个新的字符串。

返回 所有可能得到的字符串集合 。以 任意顺序 返回输出。

注：s 由小写英文字母、大写英文字母和数字组成

样例

输入：s = "a1b2"
输出：["a1b2", "a1B2", "A1b2", "A1B2"]

输入: s = "3z4"
输出: ["3z4","3Z4"]

思路

回溯法：其实就是递归，因为我们每次需要把当前所在的字符进行判断，所以递归的参数需要一个下标，表示当前到哪个字符了。递归的终止条件就是下标到达字符串的长度就结束了。单层递归逻辑：每次先判断当前字符是不是数字，如果是数字，直接跳过当前字符，直接进入下一次递归；如果是字母的话，先把当前字符变为小写字母，然后进入下一次递归（即进行下一个字符的判断），之后进行回溯，即把当前字符重新变成大写，再进行下一次递归。这样就保证了最后的结果里有所有字母大小写的全排列。

参考代码

class Solution {
public:
    vector<string> res;//所有满足的字符串集合
    void backtracking(string&s,int index)
    {
        //如果字母的下标
        if(index==s.size())
        {
            res.push_back(s);
            return;
        }
        //如果是数字，就跳过当前的字符，递归：调整下一个字母
        if(s[index]>='0'&&s[index]<='9')
        {
            backtracking(s,index+1);
        }
        else//是字母
        {   
            //把当前字母改成小写
            s[index]=tolower(s[index]);
            backtracking(s,index+1);
            //回溯：
            //把当前字母改成大写
            s[index]=toupper(s[index]);
            backtracking(s,index+1);

        }
        
    }
    vector<string> letterCasePermutation(string s) {
        backtracking(s,0);
        return res;
    }
};