【算法学习】递归、回溯、分治学习+例题练习

递归、回溯、分治算法学习

预备知识

递归

把一个大型复杂问题层层转化为一个与原问题规模更小的问题，问题被拆解成子问题后，递归调用继续进行，直到子问题无需进一步递归就可以解决的地步为止。

递归问题首先肯定是可以分解的，同时其结果可以表示为f(n) = F(g(n), f(n-1))，其中，f(n)表示当前问题的解，f(n-1)表示子问题的解，g(n)表示对当前层的操作，F()表示之间的函数关系。

举个例子：求n!，因为n! = n * (n-1)!，所以我们如果知道(n-1)!，即f(n-1)，同时这里g(n)=n，即不做任何操作，我们就可以计算出结果f(n)。

可以看到，递归有两个比较重要的组成部分：1）递归关系；2）终止条件

回溯法（暴力枚举，一般复杂度很高，可以进行剪枝）

当探索到某一步时，发现原先选择达不到目标，就退回一步重新选择，这种走不通就退回再走的技术称为回溯法

回溯本身也是递归，但是回溯有个特点：探索到某一步时，可以选择选或不选当前元素进行递归，有一种分支的感觉

回溯和递归一样，有两个重要组成部分：1）终止条件；2）递归过程

递归过程你一般会看到以下代码：

item.push_back(nums[i]);
backtracing(i+1, nums, item, result);
item.pop_back();
backtracing(i+1, nums, item, result);

分治算法

将一个规模为N的问题分解为K个规模较小的子问题，这些子问题相互独立且与原问题性质相同。求出子问题的解后进行合并，就可得到原问题的解，比较常见的是二分

特点：相互独立 且 性质相同

注意事项： 递归、回溯问题不可以深层嵌套，容易栈溢出

问题实践

求子集（medium）

题目说明

已知一组数（无重复元素），求这组数可以组成的所有子集。结果中无重复的子集

方法1：回溯法

代码解读：

遍历数组中的数，每个数可以取、可以不取

class Solution {
public:
    vector<vector<int>> subsets(vector<int>& nums){
        vector<vector<int>> result;
        vector<int> item;
        result.push_back(item);
        generate(0, nums, item, result);
        return result;
    }
private:
    void generate(int i, vector<int>& nums, vector<int>& item, vector<vector<int>>& result){
        if (i >= nums.size()){
            return;
        }
        item.push_back(nums[i]);
        result.push_back(item);
        generate(i+1, nums, item, result);
        item.pop_back();
        generate(i+1, nums, item, result);
    }
};

方法2：位运算法

代码解读：

数组长度为2时，共有2^2=4种情况，即【00，01，10，11】，对应【都不取，只取nums[0]，只取nums[1]，都取】，其他类似

class Solution {
public:
    vector<vector<int>> subsets(vector<int>& nums){
        vector<vector<int>> result;
        int all_set = 1 << nums.size();
        for (int i = 0; i < all_set; i++){
            vector<int> item;
            for (int j = 0; j < nums.size(); j++){
                if (i & (1<<j)){
                    item.push_back(nums[j]);
                }
            }
            result.push_back(item);
        }
        return result;
    }
};

求子集2（medium）（回溯法）

题目说明

已知一组数（其中有重复元素），求这组数可以组成的所有子集。结果中无重复的子集

举例

input：【2，1，2，2】
output：【【】，【1，2】，【1，2，2】，【1，2，2，2】，【2】，【2，2】，【2，2，2】】

代码解读：

数组长度为2时，共有2^2=4种情况，即【00，01，10，11】，对应【都不取，只取nums[0]，只取nums[1]，都取】，其他类似

方法1：回溯+set集合去重

同上

class Solution {
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums){
        vector<vector<int>> result;
        vector<int> item;
        set<vector<int>> res_set;
        sort(nums.begin(), nums.end());
        result.push_back(item);
        generate(0, nums, result, item, res_set);
        return result;
    }
private:
    void generate(int i, vector<int>& nums, vector<vector<int>>& result, vector<int>& item, set<vector<int>>& res_set){
        if (i >= nums.size()){
            return;
        }
        item.push_back(nums[i]);
        if (res_set.find(item) == res_set.end()){
            result.push_back(item);
            res_set.insert(item);
        }
        generate(i+1, nums, result, item, res_set);
        item.pop_back();
        generate(i+1, nums, result, item, res_set);
    }
};

方法2：递归

举个例子：input: [1,2,2], 对于这个问题，我们可以先将[2,2]的所有可能列举出来，即[[],[2],[2,2]]，然后对于这个集合，我们可以给每个元素 加 或 不加 1（这貌似听起来更像回溯），构成解。当然，这里最关键的是如何去重。

代码解读：

因为存在重复数字，需要先对数组排序。

cur > 0 && nums[cur - 1] == nums[cur]：保证不使用值相同但序号不同的值

choosePre：用于屏蔽上述操作　（这一变量有点妙，反正我是肯定想不出来）

具体运行可模拟运行[2,2]

class Solution {
public:
    vector<int> t;
    vector<vector<int>> ans;

    void dfs(bool choosePre, int cur, vector<int> &nums) {
        if (cur == nums.size()) {
            ans.push_back(t);
            return;
        }
        dfs(false, cur + 1, nums);
        if (!choosePre && cur > 0 && nums[cur - 1] == nums[cur]) {
            return;
        }
        t.push_back(nums[cur]);
        dfs(true, cur + 1, nums);
        t.pop_back();
    }

    vector<vector<int>> subsetsWithDup(vector<int> &nums) {
        sort(nums.begin(), nums.end());
        dfs(false, 0, nums);
        return ans;
    }
};

作者：力扣官方题解
链接：https://leetcode.cn/problems/subsets-ii/solutions/690549/zi-ji-ii-by-leetcode-solution-7inq/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

组合数之和2（medium）（回溯法、剪枝）

题目说明

已知一组正数（其中有重复元素），求这组数可以组成的所有子集中，子集中的各元素和为整数target的子集，结果中无重复的子集。

说明

可以使用上方讲到的方法先获得子集集合，然后再去验证和是否为target，但是这样时间复杂度会很高；面对这种情况，我们就需要尝试使用回溯法中一个比较重要的手段——剪枝
首先，给定的为正数集合，这样我们回溯过程如果发现现有的子集和已经超过了target的话，就没有必要再继续了。

class Solution {
public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target){
        vector<vector<int>> result;
        vector<int> item;
        set<vector<int>> res_set;
        sort(candidates.begin(), candidates.end());
        generate(0, candidates, result, item, res_set, 0, target);
        return result;
    }
private:
    void generate(int i, vector<int>& nums, vector<vector<int>>& result, vector<int>& item, set<vector<int>>& res_set, int sum, int target){
        if (i >= nums.size() || sum > target){
            return;
        }
        sum += nums[i];
        item.push_back(nums[i]);
        if (sum == target && res_set.find(item) == res_set.end()){
            result.push_back(item);
            res_set.insert(item);
        }
        generate(i + 1, nums, result, item, res_set, sum, target);
        sum -= nums[i];
        item.pop_back();
        generate(i + 1, nums, result, item, res_set, sum, target);
    }
};

生成括号（medium）（递归设计）

题目说明

已知整数n，生成n组括号所有的合法的组合可能

class Solution {
public:
    vector<string> generateParenthesis(int n){
        vector<string> result;
        generate("", n, n, result);
        return result;
    }
private:
    void generate(string item, int left, int right, vector<string>& result){
        if (left == 0 && right == 0){
            result.push_back(item);
            return;
        }
        if(left > 0){
            generate(item + '(', left - 1, right, result);
        }
        if (right > left){
            generate(item + ')', left, right - 1, result);
        }
    }
};

N皇后（hard）（回溯法）

题目说明

将N个皇后摆放在N*N的棋盘中，互相不可攻击，有多少种摆放方式，每种摆放方式具体是怎么样的？

经典中的经典

思路

遍历行位置，递归列位置

class Solution {
public:
    int totalNQueens(int n) {
        vector<vector<bool>> canditate(n, vector<bool>(n, false));
        backtracing(canditate, 0, n);
        return ans;
    }
private:
    int ans = 0;
    void backtracing(vector<vector<bool>>& canditate, int index, int n){
        if (index == n){
            ans += 1;
            return;
        }
        else{
            for (int i = 0; i < n; ++i) {
                if(is_ans(canditate, index, i)){
                    canditate[index][i] = true;
                    backtracing(canditate, index+1, n);
                    canditate[index][i] = false;
                }
            }
        }
    }
    bool is_ans(vector<vector<bool>>& canditate, int index, int i){
        int n = canditate.size();
        for (int j = 0; j < n; ++j) {
            if (canditate[j][i])
                return false;
        }
        for (int j = index, k = i; j >= 0 && k >= 0; --j, --k) {
            if (canditate[j][k])
                return false;
        }
        for (int j = index, k = i; j >= 0 && k < n; --j, ++k) {
            if (canditate[j][k])
                return false;
        }
        return true;
    }
};

逆序数（hard）（分治法、归并排序应用）

题目说明

已知数组nums，求新数组count，count[i]代表了在nums[i]右侧且比nums[i]小的元素个数。

举例：

nums=[5,2,6,1] count=[2,1,1,0]

代码思路：

nums=[5,2,6,1] 创建vec = [[5,0],[2,1],[6,2],[1,3]]，将数组值与index绑定，因为后边
数组顺序会改变。
将vec递归不断分为两组，直至只剩一或两组

用merge_sort_two_vec将子问题的解合并，如【5】【2】 返回【2，5】，同时将5的count+另一子集的长度或者部分长度；【6】【1】返回【1，6】，同时6的count+另一子集的长度或者部分长度；【2，5】【1，6】返回【1，2，5，6】。

这里需要注意，每一返回的vec都是按照从小到大顺序排序的，所以如果左子集某数大于右边某数，那他同样小于右边某数左边的数

class Solution {
public:
    vector<int> countSmaller(vector<int>& nums){
        vector<pair<int, int>> vec;
        vector<int> count(nums.size, 0);
        for (int i = 0; i < nums.size(); i++){
            vec.push_back(make_pair(nums[i], i));
        }
        merge_sort(vec, count);
        return count;
    }
private:
    void merge_sort(vector<pair<int, int>>& sub_vec, vector<int>& count){
        if (vec.size() < 2) return;
        int mid = vec.size >> 1;
        vector<pair<int, int>>& sub_vec1;
        vector<pair<int, int>>& sub_vec2;
        for (int i = 0; i < mid; i++){
            sub_vec1.push_back(vec[i]);
        }
        for (int i = mid; i < vec.size(); i++){
            sub_vec2.push_back(vec[i]);
        }
        merge_sort(sub_vec1, count);
        merge_sort(sub_vec2, count);
        vec.clear();
        merge_sort_two_vec(sub_vec1, sub_vec2, vec, count);
    }
    void merge_sort_two_vec(vector<pair<int, int>>& sub_vec1, vector<pair<int, int>>& sub_vec2, vector<pair<int, int>>& sub_vec, vector<int>& count){
        int i = 0, j = 0;
        while (i < sub_vec1.size() && j < sub_vec2.size()){
            if (sub_vec1[i].first <= sub_vec2[j].first){
                count[sub_vec1[i].second] += j;
                vec.push_back(sub_vec1[i]);
                i++;
            }
            else{
                vec.push_back(sub_vec2[j]);
                j++;
            }
        }
        for (; i < sub_vec1.size(); i++){
            count[sub_vec1[i].second] += j;
            vec.push_back(sub_vec1[i]);
        }
        for (; j < sub_vec2.size(); j++){
            vec.push_back(sub_vec2[j]);
        }
    }
};