回溯算法的题型介绍与区别总结

RockLis

已于 2022-03-15 17:04:23 修改

阅读量599

点赞数

分类专栏：算法文章标签：算法 java 数据结构

于 2022-03-15 16:54:01 首次发布

本文链接：https://blog.csdn.net/rocklis/article/details/123506589

版权

算法专栏收录该内容

3 篇文章 0 订阅

订阅专栏

回溯算法的总结

参考链接：https://labuladong.github.io/algo/4/30/111/
学习了东哥的文章之后，为了自我理解与记忆，特地总结了一下

Table of Contents generated with DocToc

回溯算法的总结

首先当你细节逻辑不够清晰的时候，不妨画出回溯树，很多的细节问题都可发现

题型的分类

元素无重不可复选
- 子集/组合
- 排列
元素可重不可复选
- 子集/组合
- 排列
元素无重可复选
- 子集/组合
- 排列

子集/组合与排列的区别

回溯树上

这里我们按照第一种题型举例

子集/组合
1. 每个节点不能遍历该节点之前的节点
2. 是对每一个节点进行操作的（组合有时候是对每一层操作的）

排列
1. 每个节点可以遍历该节点之前的节点
2. 我们是对叶子节点进行操作的

由于这两个区别，造成了代码的不同操作：

代码上

注意两点：

添加结果的位置
子集/组合为了防止添加重复结果，多加了一个下标的限制

子集/组合

// 回溯算法核心函数，遍历子集问题的回溯树
void backtrack(int[] nums, int start) {   // *** 区别二 *** 

    // 前序位置，每个节点的值都是一个子集
    res.add(new LinkedList<>(track));   // ***区别一***
    
    // 回溯算法标准框架
    for (int i = start; i < nums.length; i++) {
        // 做选择
        track.addLast(nums[i]);
        // 通过 start 参数控制树枝的遍历，避免产生重复的子集
        backtrack(nums, i + 1);
        // 撤销选择
        track.removeLast();
    }
}

排列

// 回溯算法核心函数
void backtrack(int[] nums) {   //   *** 区别二 *** 
    // base case，到达叶子节点
    if (track.size() == nums.length) {   // *** 区别一 *** 
        // 收集叶子节点上的值
        res.add(new LinkedList(track));
        return;
    }

    // 回溯算法标准框架
    for (int i = 0; i < nums.length; i++) {  //   *** 区别二 ***
        // 已经存在 track 中的元素，不能重复选择
        if (used[i]) {
            continue;
        }
        // 做选择
        used[i] = true;
        track.addLast(nums[i]);
        // 进入下一层回溯树
        backtrack(nums);
        // 取消选择
        track.removeLast();
        used[i] = false;
    }
}

三种题型的区别

元素无重不可复选

最基础的类型，正常解题

元素可重不可复选

由于可选择的元素有重复的，但是结果中不要求相同形式的结果

我们需要剪枝

子集/组合

保证遇到相同的元素，将后面的元素剪掉，所以我们的操作是：排序+剪枝

// *******
public List<List<Integer>> subsetsWithDup(int[] nums) {
    Arrays.sort(nums);    // 排序
    backtrack(nums, 0);
    return res;
}
void backtrack(int[] nums, int start) {
   	// *******
    for (int i = start; i < nums.length; i++) {
        // 剪枝逻辑，值相同的相邻树枝，只遍历第一条
        if (i > start && nums[i] == nums[i - 1]) {
            continue;
        }
    	// *******
    }
}

排列

由于排列与子集/组合的区别遍历选择的区别，排列要求更加严格，我们需要先排序，然后我们需要保证相同的元素以一种固定顺序进行访问，所以我们的操作是：排序+剪枝（剪枝要求不一样）

// *******
public List<List<Integer>> permuteUnique(int[] nums) {
    Arrays.sort(nums);   // 先排序，让相同的元素靠在一起
    used = new boolean[nums.length];
    backtrack(nums, track);
    return res;
}
void backtrack(int[] nums) {
	// *******
    for (int i = 0; i < nums.length; i++) {
        if (used[i]) {
            continue;
        }
        // 新添加的剪枝逻辑，固定相同的元素在排列中的相对位置
        if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) {
            continue;
        }
	// *******
    }
}