回溯剪枝的 “减法艺术”:化解超时危机的 “救命稻草”(二)

专栏:算法的魔法世界

个人主页:手握风云

目录

一、例题讲解

[1.1. 电话号码的字母组合](#1.1. 电话号码的字母组合)

[1.2. 括号生成](#1.2. 括号生成)

[1.3. 组合](#1.3. 组合)

[1.4. 目标和](#1.4. 目标和)


一、例题讲解

1.1. 电话号码的字母组合

仅包含数字2---9的字符串,返回该数字字符串能表示的所有字母组合,组合顺序可任意。

我们先利用字符串数组映射出数字和字母之间的关系。然后画出决策树,我们只需对决策树进行深度优先遍历,收集叶子节点的值。递归方法的设计,我们需要递归处理电话号码对应的字符串以及字符串的下标。当把字符串的最后一个字符添加进路径中的字符串后,回溯。递归的出口,遍历完字符串的最后一个位置。

完整代码实现:

java 复制代码
class Solution {
    public String[] hash = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
    public StringBuffer path; // 储存当前路径的字符串
    public List<String> ret; // 储存最终结果
    public List<String> letterCombinations(String digits) {
        path = new StringBuffer();
        ret = new ArrayList<>();

        // 字符串为空,直接返回空列表
        if (digits.length() == 0) {
            return ret;
        }
        dfs(digits, 0); // 深搜
        return ret;
    }

    private void dfs(String digits, int pos) {
        // 到达字符串末尾,递归出口
        if (pos == digits.length()) {
            ret.add(path.toString());
            return;
        }
        String index = hash[digits.charAt(pos) - '0'];
        for (int i = 0; i < index.length(); i++) {
            path.append(index.charAt(i));
            // 递归处理下一个数字
            dfs(digits, pos + 1);
            // 回溯
            path.deleteCharAt(path.length() - 1);
        }
    }
}

1.2. 括号生成

返回一个字符串列表,包含所有可能且有效的括号组合;括号组合需满足 "有效"------ 即左括号与右括号数量均为n,且任意前缀中左括号数量不小于右括号数量。

通过下图的决策树,我们很容易发现剪枝的策略:当左括号数量>=m时;右括号数量大于左括号数量时。递归方法不用传参数,只需要对决策树往下递归并添加左括号或者右括号即可。当遍历到叶子节点时,同时这里也是递归出口,回溯时,只需把字符串的最后一个字符删掉即可。

完整代码实现:

java 复制代码
class Solution {
    // 左括号和右括号数量
    int left, right, m;
    StringBuffer path;
    List<String> ret;

    public List<String> generateParenthesis(int n) {
        m = n;
        path = new StringBuffer();
        ret = new ArrayList<>();
        dfs();
        return ret;
    }

    public void dfs() {
        // 当右括号数量等于m时,表示已经完成了一个合法的组合
        if (right == m) {
            ret.add(path.toString());
            return;
        }

        // 如果左括号数量小于m,添加左括号
        if (left < m) {
            path.append('(');
            left++;
            dfs();
            // 回溯
            path.deleteCharAt(path.length() - 1);
            left--;
        }

        // 如果右括号数量小于左括号数量,可以添加右括号
        if (right < left) {
            path.append(')');
            right++;
            dfs();
            // 回溯
            path.deleteCharAt(path.length() - 1);
            right--;
        }
    }
}

1.3. 组合

给定两个整数n和k,返回范围[1, n]中所有由k个不同数组成的组合,组合内元素顺序不影响。

通过下图的决策树可以看出:当选到重复数字时;因为返回顺序可任意,所以123、213是同一种情况,可以剪枝。这里我们不需要全局变量进行剪枝,当我们选出第一个数字i时,只需要枚举[i, n]之间的数字即可。递归函数传入一个起始位置start,当收集到的结果的长度=k时,就是到达了叶子结点,此时将叶子结点的结果添加到结果集中。

java 复制代码
class Solution {
    int m, j;
    List<Integer> path;
    List<List<Integer>> ret;

    public List<List<Integer>> combine(int n, int k) {
        // 初始化
        m = n;
        j = k;
        path = new ArrayList<>();
        ret = new ArrayList<>();

        dfs(1);
        return ret;
    }

    private void dfs(int start) {
        // 如果当前路径长度等于j,将目前路径添加到结果集中
        if (path.size() == j) {
            ret.add(new ArrayList<>(path));
            return;
        }

        // 遍历所有可能的数字
        for (int i = start; i <= m; i++) {
            path.add(i);
            // 递归处理下一个元素
            dfs(i + 1);
            // 回溯
            path.remove(path.size() - 1);
        }
    }
}

1.4. 目标和

给定一个非负整数数组nums,以及一个整target;给nums中的每个整数前分别添加 '+'或'-',再将所有整数串联,构造出一个表达式。统计并返回运算结果等于target的不同表达式的数目。

当我们把决策树画出来之后,这道题起始就是二叉树的深搜,就是寻找叶子节点的值是否等于target。

java 复制代码
class Solution {
    int path, ret, aim;
    public int findTargetSumWays(int[] nums, int target) {
        aim = target;
        dfs(nums, 0);
        return ret;
    }

    private void dfs(int[] nums, int pos) {
        // 处理完数组所有元素
        if (pos == nums.length) {
            // 如果当前路径和等于目标值,则计数加一
            if (path == aim) {
                ret++;
            }
            return;
        }

        // 加上当前数字
        path += nums[pos];
        // 递归处理下一个数字
        dfs(nums, pos + 1);
        // 回溯
        path -= nums[pos];

        // 减去当前数字
        path -= nums[pos];
        // 递归处理下一个数字
        dfs(nums, pos + 1);
        // 回溯
        path += nums[pos];
    }
}
相关推荐
Mingze031414 小时前
考研408之栈与队列学习
开发语言·c++·学习·考研·算法
艾醒14 小时前
探索大语言模型(LLM):大模型微调方式全解析
人工智能·算法
小许学java16 小时前
七大排序算法的基本原理
数据结构·算法·排序算法
艾醒16 小时前
大模型面试题剖析:深入解析 Transformer 与 MoE 架构
人工智能·算法
计算机源码社17 小时前
基于Hadoop的车辆二氧化碳排放量分析与可视化系统|基于Spark的车辆排放量实时监控与预测系统|基于数据挖掘的汽车排放源识别与减排策略系统
大数据·hadoop·机器学习·数据挖掘·spark·毕业设计·课程设计
艾醒17 小时前
探索大语言模型(LLM):一文读懂通用大模型的定义、特点与分类
算法
Godspeed Zhao17 小时前
自动驾驶中的传感器技术64——Navigation(1)
人工智能·机器学习·自动驾驶
Godspeed Zhao17 小时前
自动驾驶中的传感器技术56——USS(2)
人工智能·机器学习·自动驾驶
格林威17 小时前
短波红外相机在工业视觉检测中的应用
人工智能·深度学习·数码相机·算法·计算机视觉·视觉检测
_dindong18 小时前
动规:01背包
数据结构·笔记·学习·算法·leetcode·动态规划·力扣