【回溯算法】Leetcode算法题刷题心得

本文为个人学习总结，无任何商业用途，若涉及侵权，联系删除。

---

一、回溯法基础知识

• 回溯法一般是在集合中递归搜索，集合的大小构成了树的宽度，递归的深度构成的树的深度。
• 回溯的本质是穷举，主要思想是用递归控制for循环嵌套的数量。
• for循环横向遍历，递归纵向遍历，回溯不断调整结果集。
• 回溯法模板：

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
        处理节点;
        backtracking(路径，选择列表); // 递归
        回溯，撤销处理结果
    }
}

二、组合问题

例题：组合

• 数组元素可被重复选取时，例题：39.组合总和

backtracking(candidates, target, sum, i); // 不用i+1了，表示可以重复读取当前的数

• 剪枝操作： 如果下一层的sum（就是本层的 sum + candidates[i]）已经大于target，就可以结束本轮for循环的遍历。例题：39.组合总和

for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {

• 组合内元素有重复的去重思路：定义一个used数组，used[i - 1] == true，说明同一树枝candidates[i - 1]使用过，used[i - 1] == false，说明同一树层candidates[i - 1]使用过。例题：40. 组合总和

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& candidates, int target, int sum, int startIndex, vector<bool>& used) {
        if (sum == target) {
            result.push_back(path);
            return;
        }
        for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {
        //剪枝操作： 如果下一层的sum（就是本层的 sum + candidates[i]）已经大于target，就可以结束本轮for循环的遍历。
            // used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
            // used[i - 1] == false，说明同一树层candidates[i - 1]使用过
            // 要对同一树层使用过的元素进行跳过
            if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) {
                continue;
            }
            sum += candidates[i];
            path.push_back(candidates[i]);
            used[i] = true;
            backtracking(candidates, target, sum, i + 1, used); //i+1，每个数字在每个组合中只能使用一次
            used[i] = false;
            sum -= candidates[i];
            path.pop_back();
        }
    }

public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        vector<bool> used(candidates.size(), false);
        path.clear();
        result.clear();
        // 首先把给candidates排序，让其相同的元素都挨在一起。！！！在求和问题中，排序之后加剪枝是常见的套路！
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, target, 0, 0, used);
        return result;
    }
};

三、字符串切割问题

• 字符串切割问题其实就是组合问题。
• 例题：131.分割回文串、93.复原IP地址

四、子集问题

• 组合问题和分割问题都是收集树的叶子节点，而子集问题是找树的所有节点。
• 求取子集问题，不需要任何剪枝！因为子集就是要遍历整棵树。
• 去重问题：注意去重需要先对集合排序，之后定义一个used数组，false表示同一数层使用过，需要跳过，true表示同一树枝使用过，不需要调过。例题：90.子集II

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, int startIndex, vector<bool>& used) {
        result.push_back(path);
        for (int i = startIndex; i < nums.size(); i++) {
            // used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
            // used[i - 1] == false，说明同一树层candidates[i - 1]使用过
            // 而我们要对同一树层使用过的元素进行跳过
            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
                continue;
            }
            path.push_back(nums[i]);
            used[i] = true;
            backtracking(nums, i + 1, used);
            used[i] = false;
            path.pop_back();
        }
    }

public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        result.clear();
        path.clear();
        vector<bool> used(nums.size(), false);
        sort(nums.begin(), nums.end()); // 去重需要排序
        backtracking(nums, 0, used);
        return result;
    }
};

五、排列问题

• 排列是有序的，也就是说 [1,2] 和 [2,1] 是两个集合，所以处理排列问题每层都是从0开始搜索而不是startIndex。排列问题需要一个used数组，标记已经选择的元素。例题：46.全排列

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking (vector<int>& nums, vector<bool>& used) {
        // 此时说明找到了一组
        if (path.size() == nums.size()) {
            result.push_back(path);
            return;
        }
        for (int i = 0; i < nums.size(); i++) {
            if (used[i] == true) continue; // path里已经收录的元素，直接跳过
            used[i] = true;
            path.push_back(nums[i]);
            backtracking(nums, used);
            path.pop_back();
            used[i] = false;
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        result.clear();
        path.clear();
        vector<bool> used(nums.size(), false);
        backtracking(nums, used);
        return result;
    }
};

• 含有重复数字的排列去重问题：首先去重一定要对元素进行排序，之后用used数组进行去重。

// used[i - 1] == true，说明同一树枝nums[i - 1]使用过
// used[i - 1] == false，说明同一树层nums[i - 1]使用过
// 如果同一树层nums[i - 1]使用过则直接跳过
if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
    continue;
}

六、二维矩阵的n皇后、解数独等问题

n皇后为遍历行，列做递归的回溯算法，例题：51题. N皇后
解数独为遍历行与列，数字做递归的回溯算法，例题：37. 解数独

复杂度分析

子集问题分析：
时间复杂度：$O(n^2)$, 因为每一个元素的状态无外乎取与不取，所以时间复杂度为$O(n^2)$
空间复杂度：$O(n)$，递归深度为n，所以系统栈所用空间为$O(n)$，每一层递归所用的空间都是常数级别，注意代码里的result和path都是全局变量，就算是放在参数里，传的也是引用，并不会新申请内存空间，最终空间复杂度为$O(n)$。

排列问题分析：
时间复杂度：$O(n!)$，这个可以从排列的树形图中很明显发现，每一层节点为n，第二层每一个分支都延伸了n-1个分支，再往下又是n-2个分支，所以一直到叶子节点一共就是n * n-1 * n-2 * … 1 = n!。
空间复杂度：$O(n)$，和子集问题同理。

组合问题分析：
时间复杂度：$O(2^n)$，组合问题其实就是一种子集的问题，所以组合问题最坏的情况，也不会超过子集问题的时间复杂度。
空间复杂度：$O(n)$，和子集问题同理。

N皇后问题分析：
时间复杂度：$O(n!)$，其实如果看树形图的话，直觉上是O(n^n)，但皇后之间不能见面所以在搜索的过程中是有剪枝的，最差也就是$O(n!)$，n!表示n *(n-1) * … * 1。
空间复杂度：$O(n)$，和子集问题同理。

解数独问题分析：
时间复杂度：$O(9^m)$ , m是’.'的数目。
空间复杂度：$O(n^2)$，$n^2$是递归的深度