LeetCode通关:连刷十四题,回溯算法完全攻略

Posted 三分恶

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了LeetCode通关:连刷十四题,回溯算法完全攻略相关的知识,希望对你有一定的参考价值。

刷题路线:https://github.com/youngyangyang04/leetcode-master

大家好,我是被算法题虐到泪流满面的老三,只能靠发发文章给自己打气!

这一节,我们来看看回溯算法。

回溯算法理论基础

什么是回溯

在二叉树的路径问题里,其实我们已经接触到了回溯这种算法。

例如我们在查找二叉树所有路径的时候,查找完一个路径之后,还需要回退,接着找下一个路径。

回溯其实可以说是我们熟悉的DFS,本质上是一种暴力穷举算法,把所有的可能都列举出来,所以回溯并不高效。

这个可能比较抽象,我们举一个例子吧,[1,2,3]三个数可以构成多少种组合呢?

我们的办法就是把所有结果都穷举出来,那怎么穷举呢?可以第一位选1,第二位从[2,3]里选2,第三位从[3]里选3;第二个组合可以第一位选2……

我们把这个选择抽象成一棵树,初步有个印象,这是全排列的问题,后面会刷到。

回溯算法模板

回溯算法,可以看作一个树的遍历过程,建议可以去看一下N叉树的遍历,和这个非常类似。

递归有三要素,类似的,回溯同样需要关注三要素:

  • 返回值和参数

回溯算法中函数返回值一般为void。

回溯方法的参数得结合实际问题,但是一般需要一个类似栈的结构来存储每个路径(结果),因为我们一次递归结束之后,节点要回溯到上一个位置。

回溯方法伪代码如下:

void backtrack(参数)
  • 回溯函数终止条件

和递归一样,回溯同样也要有结束条件。

什么时候达到了终止条件,从树的角度来讲,一般来说搜到叶子节点了,对回溯而言,就是找到了满足条件的一个结果。

所以回溯函数终止条件伪代码如下:

if (终止条件) {
    存放结果;
    return;
}
  • 回溯搜索的遍历过程

回溯法一般是在一个序列里做选择,序列的大小构成了树的宽度,递归的深度构成的树的深度。

回溯函数遍历过程伪代码如下:

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

for循环就是遍历序列,可以理解一个节点有多少个孩子,这个for循环就执行多少次。可以理解为横向的遍历。

backtrack就是自己调用自己,可以理解为纵向的遍历。

同时递归之后,我们还要撤销之前做的选择。

所以回溯算法模板框架如下:

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

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

回溯能解决哪些问题

回溯法,一般可以解决如下几种问题:

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

可能到这对回溯还比较迷茫,没有关系,回溯是比较套路化的一种算法,多做几道题就明白了。

组合问题

LeetCode77. 组合

☕ 题目:77. 组合 (https://leetcode-cn.com/problems/combinations/)

❓ 难度:中等

📕 描述:

给定两个整数 nk,返回范围 [1, n] 中所有可能的 k 个数的组合你可以按 任何顺序 返回答案。

示例 1:

输入:n = 4, k = 2
输出:
[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

示例 2:

输入:n = 1, k = 1
输出:[[1]]

💡 思路:

这道题是回溯算法的经典题目。

我们来看一下这道题的抽象树形结构:

按照我们的回溯模板,看看这道题应该怎么写:

  • 返回值、参数

首先方法里是一定要区间的数据,[start,n]。

计数的k也不可缺少。

最后的结果集合result,还有每条路径的结果path,可以定义全局变量,来提升可读性。

  • 终止条件

什么时候终止,就是什么时候到叶子节点了呢?结果parh的大小等于k,说明到了叶子节点,一次递归结束。

  • 单层逻辑

在单层逻辑里面,我们要做两件事:

  1. 遍历序列
  2. 递归,遍历节点

🖊 代码:

class Solution {
    //结果集合
    List<List<Integer>> result;
    //符合条件的结果
    LinkedList<Integer> path;

    public List<List<Integer>> combine(int n, int k) {
        result = new ArrayList<>();
        path = new LinkedList<>();
        backstack(n, k, 1);
        return result;
    }

    //回溯
    public void backstack(int n, int k, int start) {
        //结束条件
        if (path.size() == k) {
            result.add(new LinkedList<>(path));
            return;
        }
        for (int i = start; i <= n; i++) {
            path.addLast(i);
            //递归
            backstack(n, k, i + 1);
            //回溯,撤销已经处理的节点
            path.removeLast();
        }
    }
}

⚡ 剪枝优化

回溯中,提高性能的一大妙招就是剪枝。

剪枝见名知义,就是在把我们的树的一些树枝给它剪掉。

例如n = 4,k = 4

我们可以看到,有些路径,其实一定是不满足我们的要求,如果我们把这些不可能的路径剪断,那我们不就可以少遍历一些节点吗?

所以我们看看这道题怎么来剪这个枝:

如果for循环选择的起始位置之后的元素个数 已经不足 我们需要的元素个数了,那么就没有必要搜索

  1. 已经选择的元素个数:path.size();
  2. 还需要的元素个数为: k - path.size();
  3. 所以起始位置 : n - (k - path.size()) + 1之后的肯定不符合要求

所以优化之后的代码如下:

class Solution{
      //结果集合
    List<List<Integer>> result;
    //符合条件的结果
    LinkedList<Integer> path;

    public List<List<Integer>> combine(int n, int k) {
        result = new ArrayList<>();
        path = new LinkedList<>();
        backstack(n, k, 1);
        return result;
    }

    //回溯
    public void backstack(int n, int k, int start) {
        //结束条件
        if (path.size() == k) {
            result.add(new LinkedList<>(path));
            return;
        }
        for (int i = start; i <= n-(k-path.size())+1; i++) {
            path.addLast(i);
            //递归
            backstack(n, k, i + 1);
            //回溯,撤销已经处理的节点
            path.removeLast();
        }
    }
}

LeetCode216. 组合总和 III

☕ 题目:77. 组合 (https://leetcode-cn.com/problems/combinations/)

❓ 难度:中等

📕 描述:

找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数,并且每种组合中不存在重复的数字。

说明:

  • 所有数字都是正整数。
  • 解集不能包含重复的组合。

示例 1:

输入: k = 3, n = 7
输出: [[1,2,4]]

示例 2:

输入: k = 3, n = 9
输出: [[1,2,6], [1,3,5], [2,3,4]]

💡 思路:

我们先把这道题抽象成树:

接着套模板。

  • 终止条件

到叶子节点(path大小等于k)终止。

  • 返回值,参数

参数稍微有变化,序列是固定的,这里的n是目标和;需要一个参数pathSum来记录路径上的数总和,我们直接全局变量。

  • 单层逻辑

逻辑差别不大,回溯的时候需要把pathSum也回溯一下。

🖊 代码:

class Solution {
   //结果集合
    List<List<Integer>> result;
    //结果
    LinkedList<Integer> path;
    //结果综合
    int pathSum;

    public List<List<Integer>> combinationSum3(int k, int n) {
        result = new ArrayList<>();
        path = new LinkedList<>();
        backtrack(n, k, 1);
        return result;
    }
    
    //回溯
    public void backtrack(int n, int k, int start) {
        //结束
        if (path.size() == k) {
            if (pathSum == n) {
                result.add(new LinkedList<>(path));
            }
            return;
        }
        //遍历序列
        for (int i = start; i <= 9; i++) {
            path.push(i);
            pathSum += i;
            //递归
            backtrack(n, k, i + 1);
            //回溯,撤销操作
            pathSum -= path.pop();
        }
    }
}

⚡ 剪枝优化

同样也可以进行剪枝优化,也很好想,如果pathNum>n ,那就没必要再遍历了。

class Solution {
   //结果集合
    List<List<Integer>> result;
    //结果
    LinkedList<Integer> path;
    //结果综合
    int pathSum;

    public List<List<Integer>> combinationSum3(int k, int n) {
        result = new ArrayList<>();
        path = new LinkedList<>();
        backtrack(n, k, 1);
        return result;
    }
    
    //回溯
    public void backtrack(int n, int k, int start) {
        //剪枝优化
        if (pathSum > n) {
            return;
        }
        //结束
        if (path.size() == k) {
            if (pathSum == n) {
                result.add(new LinkedList<>(path));
            }
            return;
        }
        //遍历序列
        for (int i = start; i <= 9; i++) {
            path.push(i);
            pathSum += i;
            //递归
            backtrack(n, k, i + 1);
            //回溯,撤销操作
            pathSum -= path.pop();
        }
    }
}

LeetCode39. 组合总和

☕ 题目:39. 组合总和 (https://leetcode-cn.com/problems/combination-sum/)

❓ 难度:中等

📕 描述:

给定一个无重复元素的正整数数组 candidates 和一个正整数 target ,找出 candidates 中所有可以使数字和为目标数 target 的唯一组合。

candidates 中的数字可以无限制重复被选取。如果至少一个所选数字数量不同,则两种组合是唯一的。

对于给定的输入,保证和为 target 的唯一组合数少于 150 个。

示例 1:

输入: candidates = [2,3,6,7], target = 7
输出: [[7],[2,2,3]]

示例 2:

输入: candidates = [2,3,5], target = 8
输出: [[2,2,2,2],[2,3,3],[3,5]]

示例 3:

输入: candidates = [2], target = 1
输出: []

示例 4:

输入: candidates = [1], target = 1
输出: [[1]]

示例 5:

输入: candidates = [1], target = 2
输出: [[1,1]]

提示:

  • 1 <= candidates.length <= 30
  • 1 <= candidates[i] <= 200
  • candidate 中的每个元素都是独一无二的。
  • 1 <= target <= 500

💡 思路:

这道题和我们上面的有什么区别呢?

它没有数量要求,可以无限重复,但是有总和的限制。

这里有两个关键点:

  • 元素可以重复使用
  • 组合不可重复

我们看看如何通过回溯三要素来carry:

  • 返回值&参数

参数里需要start标明起点,为什么呢?因为要求组合不重复,所以需要限制下次搜索的起点,是基于本次选择,这样就不会选到本次选择同层左边的数。

  • 终止条件

这道题没有限制数的个数,所以我们要根据pathSum>target(当前组合不满足)和pathSum==target(当前组合满足)来终止递归。

  • 单层逻辑

单层仍然从start开始,搜索 candidates。

🖊 代码:

class Solution {
   //结果结合
    List<List<Integer>> result;
    //结果路径
    LinkedList<Integer> path;
    //结果路径值的和
    int pathSum;

    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        result = new ArrayList<>();
        path = new LinkedList<>();
        pathSum = 0;
        backtrack(candidates, target, 0);
        return result;
    }

    public void backtrack(int[] candidates, int target, int start) {
        //终止条件
        if (pathSum > target) return;
        if (pathSum == target) {
            result.add(new LinkedList<>(path));
        }
        for (int i = start; i < candidates.length; i++) {
            pathSum += candidates[i];
            path.push(candidates[i]);
            //注意,i不用加1,表示当前数可以重复读取
            backtrack(candidates, target, i);
            //回溯
            pathSum -= path.pop();
        }
    }
}

⚡ 剪枝优化

又到了剪枝优化时间,在本层循环,如果发现下一层的pathSum(本层pathSum+candidates[i]),那么就可以结束本层循环,注意要先把candidates拍一下序。

class Solution {
    //结果结合
    List<List<Integer>> result;
    //结果路径
    LinkedList<Integer> path;
    //结果路径值的和
    int pathSum;

    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        result = new ArrayList<>();
        path = new LinkedList<>();
        pathSum = 0;
        //剪枝优化,先排序
        Arrays.sort(candidates);
        backtrack(candidates, target, 0);
        return result;
    }

    public void backtrack(int[] candidates, int target, int start) {
        //终止条件
        if (pathSum > target) return;
        if (pathSum == target) {
            result.add(new LinkedList<>(path));
        }
       //剪枝优化,判断循环之后的pathSum是否会超过target
        for (int i = start; i < candidates.length && pathSum + candidates[i] <= target; i++) {
            pathSum += candidates[i];
            path.push(candidates[i]);
            //注意,i不用加1,表示当前数可以重复读取
            backtrack(candidates, target, i);
            //回溯
            pathSum -= path.pop();
        }
    }
}

LeetCode40. 组合总和 II

☕ 题目:40. 组合总和 II (https://leetcode-cn.com/problems/combination-sum-ii/)

❓ 难度:中等

📕 描述:

给定一个数组 candidates 和一个目标数 target ,找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用一次。

注意:解集不能包含重复的组合。

示例 1:

输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]

示例 2:

输入: candidates = [2,5,2,1,2], target = 5,
输出:
[
[1,2,2],
[5]
]

提示:

  • 1 <= candidates.length <= 100
  • 1 <= candidates[i] <= 50
  • 1 <= target <= 30

💡 思路:

这道题和上一道题有啥区别呢?

  • candidates里每个数字在每个组合里只能使用一次
  • candidates里的元素是有重复的

所以这道题的关键在于:集合(数组candidates)有重复元素,但还不能有重复的组合

关于这个去重,有什么思路呢?

  • 利用HashSet的特性去重,但是容易超时

  • 还有一种办法,先把数组排序[1,3,1] --> [1,1,3],我们比较一下相邻的元素,重复的就跳过

我们把模拟树画一下:

三要素走起:

  • 返回值&参数

和上一道基本一致。

  • 终止条件
    • pathSum>target和pathSum==target。
    • 我们这次直接剪枝,提前判断下次pathSum是否大于target,所以pathSum>target可以省略

🖊 代码:

class Solution {
      //结果集合
    List<List<Integer>> result;
    //结果路径
    LinkedList<Integer> path;
    //结果路径值总和
    int pathSum;

    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        //排序condidates,去重前提
        Arrays.sort(candidates);
        //初始化相关变量
        result = new ArrayList<>();
        path = new LinkedList<>();
        pathSum = 0;
        backtrack(candidates, target, 0);
        return result;
    }

    public void backtrack(int[] candidates, int target, int start) {
        //终止条件
        if (pathSum == target) {
            result.add(new LinkedList<>(path));
            return;
        }
        //剪枝操作
        for (int i = start; i < candidates.length && candidates[i] + pathSum <= target; i++) {
            //同一层使用过的元素跳过
            if (i > start && candidates[i] == candidates[i - 1]) {
                continue;
            }
            pathSum += candidates[i];
            path.push(candidates[i]);
            //每个数字在每个组合中只能用一次,所以i++
            backtrack(candidates, target, i + 1);
            //回溯
            pathSum -= path.pop();
        }
    }以上是关于LeetCode通关:连刷十四题,回溯算法完全攻略的主要内容,如果未能解决你的问题,请参考以下文章

LeetCode通关:连刷三十九道二叉树,刷疯了!⭐四万字长文搞定二叉树,建议收藏!⭐

LeetCode通关:连刷三十九道二叉树,刷疯了!⭐四万字长文搞定二叉树,建议收藏!⭐

动态规划:leetcode题库第四十四题

leetcode算法题基础(四十四) 回溯算法总结

LeetCode第三十四题-寻找数组中对应目标值的首尾索引

万字长文|十大基本排序,一次搞定!