回溯（backtrack）描述

夜悊

已于 2023-04-14 16:56:51 修改

阅读量813

点赞数

分类专栏：算法文章标签：算法深度优先图搜索算法剪枝 leetcode

于 2023-02-13 15:28:33 首次发布

本文链接：https://blog.csdn.net/m0_62083249/article/details/128846268

版权

算法专栏收录该内容

2 篇文章 0 订阅

订阅专栏

前言

回溯描述。

一、核心概念

在深度优先搜索（DFS）的递归过程中回溯：回溯问题可抽象为树形结构，递归向下处理和获取结果，回溯向上撤销结果
相对于暴力算法，是一种间接/有技巧（使用递归代替多重循环）的暴力搜索/穷举，不高效

二、典型问题

分类依据：代码随想录 (programmercarl.com)和力扣

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

三、算法步骤

将回溯问题抽象为树形结构

问题规模为树的宽度
递归深度为树的深度

确定回溯函数的参数和返回值

可依据逻辑需要后补充参数

可能的参数：
候选集合
问题规模为树的宽度width
递归深度为树的深度depth
当前结点问题规模的起始索引start_index
标记集合中元素是否已选取的数组
结果集合res和results

返回值一般为空（void）

确定回溯函数的终止条件和获取结果逻辑

在树的叶子结点获取结果
在树的叶子结点结束当前层递归，并回溯撤销结果

注意：子集问题，在树的每结点获取结果

确定回溯函数的遍历和处理结果逻辑

横向遍历当前树层各结点的问题规模
纵向递归处理结果

四、模板

// 0. 将回溯问题抽象为树形结构
// 1. 确定回溯函数的参数和返回值
void backtrack(参数) 
{
	// 2. 确定回溯函数的终止条件和获取结果逻辑
    if (终止条件) 
    {
        获取结果;
        
        return;
    }

	// 3. 确定回溯函数的遍历和处理结果逻辑
    for (当前树层，各结点的问题规模) 
    {
        处理结果;
        
        backtrack(参数); // 递归
        
        撤销结果; // 回溯
    }
}

五、模板示例

77.组合 - 力扣（LeetCode）——中等的题解：

class Solution
{
private:
    // 0. 将回溯问题抽象为树形结构
    vector<int> res;
    vector<vector<int>> results;

    // 1. 确定回溯函数的参数和返回值
    void backtrack(int width, int depth, int start_index)
    {
        // 2. 确定回溯函数的终止条件和获取结果逻辑
        if (res.size() == depth)
        {
            results.push_back(res);

            return;
        }

        // 3. 确定回溯函数的遍历和处理结果逻辑
        for (int i = start_index; i <= width; ++i)
        {
            res.push_back(i);       // 处理结果

            backtrack(width, depth, i + 1); // 递归

            res.pop_back(); // 撤销结果  回溯
        }
    }

public:
    vector<vector<int>> combine(int n, int k)
    {
        backtrack(n, k, 1);

        return results;
    }
};

六、性能分析

时间复杂度：指数级

组合问题：

时间复杂度：一般为：组合规模 × 每组合判断并加入结果集的时间

如： $O(\complement^n_m × n)$ 。从m规模中取n规模，有 $\complement^n_m$ 种组合；每组合判断并加入结果集的时间需要O(n)

如： $O(2^n × n)$ 。从n规模中取或不取，有 $2^n$ 种组合；每组合判断并加入结果集的时间需要O(n)

空间复杂度：一般为：递归栈规模 + 结果集规模： $O (n)$ 。n为数据规模

切割和子集问题：类似组合问题

排列问题：全排列

时间复杂度：一般为：全排列规模 × 每排列判断并加入结果集的时间： $O (n! \times n)$ 。n为数据规模

参见：
回溯算法入门级详解 + 练习（持续更新） - 全排列 - 力扣（LeetCode）
本周小结！（回溯算法系列三） | 代码随想录 (programmercarl.com)

空间复杂度：类似组合问题

图和棋盘问题：具体问题具体分析

七、优化方法

1. 剪枝

作用：降低时间复杂度

描述：

不符合条件的问题
不再继续处理并获取结果

形式：

横向剪枝：缩小当前树层各结点的问题规模：修改for()循环
纵向剪枝：增加终止条件

模板示例：216.组合总和 III - 力扣（LeetCode）——中等的题解：

class Solution
{
private:
    // 0. 将回溯问题抽象为树形结构
    vector<int> res;
    vector<vector<int>> results;

    // 1. 确定回溯函数的参数和返回值
    // width：[1,9]
    void backtrack(int depth, int target_sum, int start_index, int sum)
    {
        // 2. 确定回溯函数的终止条件和获取结果逻辑
        if (sum > target_sum) // 纵向剪枝
        {
            return;
        }

        if (res.size() == depth)
        {
            if (sum == target_sum)
            {
                results.push_back(res);

                return;
            }

            return;
        }

        // 3. 确定回溯函数的遍历和处理结果逻辑
        for (int i = start_index; i <= 9 - (depth - res.size()) + 1; ++i) // 横向剪枝
        {
            sum += i;
            res.push_back(i); // 处理结果

            backtrack(depth, target_sum, i + 1, sum); // 递归

            sum -= i;
            res.pop_back(); // 撤销结果  回溯
        }
    }

public:
    vector<vector<int>> combinationSum3(int k, int n)
    {
        backtrack(k, n, 1, 0);

        return results;
    }
};