笔试-回溯算法突破

最新推荐文章于 2024-08-22 21:24:01 发布

NickDeCodes

最新推荐文章于 2024-08-22 21:24:01 发布

阅读量861

点赞数 25

分类专栏：笔试面试突破文章标签：算法回溯

本文链接：https://blog.csdn.net/nickdecodes/article/details/137968890

版权

笔试面试突破专栏收录该内容

7 篇文章 0 订阅

订阅专栏

本文详细介绍了回溯算法的概念、递归实现、适用场景（如组合、切割、子集、排列和棋盘问题），以及其实现中的关键点，包括终止条件、剪枝优化和递归调用。通过LeetCode实例演示了如何在不同问题中应用回溯算法。

摘要由CSDN通过智能技术生成

笔试-回溯算法突破

代码随想录/回溯算法理论基础

回溯算法是一种通过试错的方法来解决问题的算法，其思想类似于穷举搜索，也称为深度优先搜索（DFS）。在回溯算法中，你将逐步尝试解决一个问题，如果发现当前的解决方案不行时，则取消上一步甚至是上几步的计算，再尝试其他的可能。

回溯算法通常使用递归来解决问题，它尝试分步去解决一个问题。在每一步，它尝试所有可能的选择。如果选择当前步骤的一个选项不产生解决方案，则回溯算法将取消这一步骤的选择（即回溯），并尝试下一个选项。

回溯法解决的问题

回溯法，一般可以解决如下几种问题：

组合问题：N个数里面按一定规则找出k个数的集合
切割问题：一个字符串按一定规则有几种切割方式
子集问题：一个N个数的集合里有多少符合条件的子集
排列问题：N个数按一定规则全排列，有几种排列方式
棋盘问题：N皇后，解数独等等

回溯算法的特点

非常适合用递归方法实现。
在解决问题的过程中，解决方案通常是一个动态变化的序列。每次尝试一个新的选项，如果这个选项不行，就回溯，尝试另一个选项。
有高效剪枝的需求。在适当的时候停止继续尝试，可以显著减少计算的时间。

回溯三部曲

回溯法解决的问题都可以抽象为树形结构，是的，我指的是所有回溯法的问题都可以抽象为树形结构！

因为回溯法解决的都是在集合中递归查找子集，集合的大小就构成了树的宽度，递归的深度就构成了树的深度。

递归就要有终止条件，所以必然是一棵高度有限的树（N叉树）。

回溯函数模板返回值以及参数

void backtracking(参数) // 参数需要根据不同的问题去考虑，通常是不需要返回值的，特殊情况例外

回溯函数终止条件

if (终止条件) {
    存放结果;
    return;
}

回溯搜索的遍历过程

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

回溯算法模板框架如下：

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

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

组合问题

leetcode

给定两个整数 n 和 k，返回 1 … n 中所有可能的 k 个数的组合。

c++代码示例：

class Solution {
private:
    vector<vector<int>> result; // 存放符合条件结果的集合
    vector<int> path; // 用来存放符合条件结果
    void backtracking(int n, int k, int startIndex) {
        if (path.size() == k) {
            result.push_back(path);
            return;
        }
        // for (int i = startIndex; i <= n; i++) {
        for (int i = startIndex; i <= n - (k - path.size()) + 1; i++) { // 剪枝优化
            path.push_back(i); // 处理节点
            backtracking(n, k, i + 1); // 递归
            path.pop_back(); // 回溯，撤销处理的节点
        }
    }
public:
    vector<vector<int>> combine(int n, int k) {
        result.clear(); // 可以不写
        path.clear();   // 可以不写
        backtracking(n, k, 1);
        return result;
    }
};

切割问题

leetcode

给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。

返回 s 所有可能的分割方案。

c++代码示例：

class Solution {
private:
    vector<vector<string>> result;
    vector<string> path; // 放已经回文的子串
    void backtracking (const string& s, int startIndex) {
        // 如果起始位置已经大于s的大小，说明已经找到了一组分割方案了
        if (startIndex >= s.size()) {
            result.push_back(path);
            return;
        }
        for (int i = startIndex; i < s.size(); i++) {
            if (isPalindrome(s, startIndex, i)) {   // 是回文子串
                // 获取[startIndex,i]在s中的子串
                string str = s.substr(startIndex, i - startIndex + 1);
                path.push_back(str);
            } else {                                // 不是回文，跳过
                continue;
            }
            backtracking(s, i + 1); // 寻找i+1为起始位置的子串
            path.pop_back(); // 回溯过程，弹出本次已经添加的子串
        }
    }
    bool isPalindrome(const string& s, int start, int end) {
        for (int i = start, j = end; i < j; i++, j--) {
            if (s[i] != s[j]) {
                return false;
            }
        }
        return true;
    }
public:
    vector<vector<string>> partition(string s) {
        result.clear();
        path.clear();
        backtracking(s, 0);
        return result;
    }
};

子集问题

leetcode

给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。

说明：解集不能包含重复的子集。

c++代码示例：

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, int startIndex) {
        result.push_back(path); // 收集子集，要放在终止添加的上面，否则会漏掉自己
        if (startIndex >= nums.size()) { // 终止条件可以不加
            return;
        }
        for (int i = startIndex; i < nums.size(); i++) {
            path.push_back(nums[i]);
            backtracking(nums, i + 1);
            path.pop_back();
        }
    }
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        result.clear();
        path.clear();
        backtracking(nums, 0);
        return result;
    }
};

排列问题

leetcode

给定一个没有重复数字的序列，返回其所有可能的全排列。

c++代码示例：

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;
    }
};

棋盘问题

leetcode

n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。

给你一个整数 n ，返回所有不同的 n 皇后问题的解决方案。

每一种解法包含一个不同的 n 皇后问题的棋子放置方案，该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。

c++代码示例：

class Solution {
private:
vector<vector<string>> result;
// n 为输入的棋盘大小
// row 是当前递归到棋盘的第几行了
void backtracking(int n, int row, vector<string>& chessboard) {
    if (row == n) {
        result.push_back(chessboard);
        return;
    }
    for (int col = 0; col < n; col++) {
        if (isValid(row, col, chessboard, n)) { // 验证合法就可以放
            chessboard[row][col] = 'Q'; // 放置皇后
            backtracking(n, row + 1, chessboard);
            chessboard[row][col] = '.'; // 回溯，撤销皇后
        }
    }
}
bool isValid(int row, int col, vector<string>& chessboard, int n) {
    // 检查列
    for (int i = 0; i < row; i++) { // 这是一个剪枝
        if (chessboard[i][col] == 'Q') {
            return false;
        }
    }
    // 检查 45度角是否有皇后
    for (int i = row - 1, j = col - 1; i >=0 && j >= 0; i--, j--) {
        if (chessboard[i][j] == 'Q') {
            return false;
        }
    }
    // 检查 135度角是否有皇后
    for(int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
        if (chessboard[i][j] == 'Q') {
            return false;
        }
    }
    return true;
}
public:
    vector<vector<string>> solveNQueens(int n) {
        result.clear();
        std::vector<std::string> chessboard(n, std::string(n, '.'));
        backtracking(n, 0, chessboard);
        return result;
    }
};

总结

组合问题：元素不重复取，backtracking(…, i + 1)
切割问题：元素不重复取，backtracking(…, i + 1)
子集问题：元素不重复取，backtracking(…, i + 1)
排列问题：元素判重，需要使用used数组标记
棋盘问题：二维矩阵回溯

NickDeCodes

关注

25
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
笔试-回溯算法突破

组合问题：元素不重复取，backtracking(…, i + 1)切割问题：元素不重复取，backtracking(…, i + 1)子集问题：元素不重复取，backtracking(…, i + 1)排列问题：元素判重，需要使用used数组标记棋盘问题：二维矩阵回溯。
复制链接

扫一扫

专栏目录