[leetcode]回溯框架TypeScript版本

最新推荐文章于 2023-02-08 13:17:26 发布
最新推荐文章于 2023-02-08 13:17:26 发布
阅读量181 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： leetcode typescript 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41996454/article/details/124801187
版权

回溯框架

TypeScript | JavaScript | 回溯框架

排列组合子集
无重复 + 不可复选467778
可重复 + 不可复选479090
无重复 + 可复选全排列(元素无重可复选)3939

无论是排列、组合还是子集问题，简单说无非就是让你从序列 nums 中以给定规则取若干元素，主要有以下几种变体：

形式一、元素无重不可复选，即 nums 中的元素都是唯一的，每个元素最多只能被使用一次，这也是最基本的形式。

以组合为例，如果输入 nums = [2,3,6,7]，和为 7 的组合应该只有 [7]。

形式二、元素可重不可复选，即 nums 中的元素可以存在重复，每个元素最多只能被使用一次。

以组合为例，如果输入 nums = [2,5,2,1,2]，和为 7 的组合应该有两种 [2,2,2,1] 和 [5,2]。

形式三、元素无重可复选，即 nums 中的元素都是唯一的，每个元素可以被使用若干次。

以组合为例，如果输入 nums = [2,3,6,7]，和为 7 的组合应该有两种 [2,2,3] 和 [7]。

当然，也可以说有第四种形式，即元素可重可复选。但既然元素可复选，那又何必存在重复元素呢？元素去重之后就等同于形式三，所以这种情况不用考虑。

上面用组合问题举的例子，但排列、组合、子集问题都可以有这三种基本形式，所以共有 9 种变化。

除此之外，题目也可以再添加各种限制条件，比如让你求和为 target 且元素个数为 k 的组合，那这么一来又可以衍生出一堆变体，怪不得面试笔试中经常考到排列组合这种基本题型。

但无论形式怎么变化，其本质就是穷举所有解，而这些解呈现树形结构，所以合理使用回溯算法框架，稍改代码框架即可把这些问题一网打尽。

子集（元素无重不可复选）

78. 子集

78. 子集

给你输入一个无重复元素的数组 nums，其中每个元素最多使用一次，请你返回 nums 的所有子集。

function subsets(nums: number[]): number[][] {
    // 设置结果集    
    const res: number[][] = [];

    // 记录回溯算法的递归路径
    const track: number[] = [];

    // 回溯算法核心函数，遍历子集问题的回溯树
    const helper = (nums: number[], start: number) => {
        // 前序位置，每个节点的值都是一个子集
        res.push(track.concat());

        // 回溯算法标准框架
        for (let i = start; i < nums.length; i++) {
            // 做出选择
            track.push(nums[i]);

            // 通过 start 参数控制树枝的遍历，避免产生重复的子集
            helper(nums, i + 1);

            // 撤销选择
            track.pop();
        }
    }

    // 开始主函数
    helper(nums, 0)

    // 返回结果
    return res;
};

组合（元素无重不可复选）

77. 组合

77. 组合

function combine(n: number, k: number): number[][] {
    // 设置结果集    
    const res: number[][] = [];

    // 记录回溯算法的递归路径
    const track: number[] = [];

    // 回溯算法核心函数，遍历子集问题的回溯树
    const helper = (start: number, n: number, k: number) => {
        // base case
        if (k == track.length) {
            // 遍历到了第 k 层，收集当前节点的值
            res.push(track.concat());
            return;
        }

        // 回溯算法标准框架
        for (let i = start; i <= n; i++) {
            // 做出选择
            track.push(i)

            // 通过 start 参数控制树枝的遍历，避免产生重复的子集
            helper(i + 1, n, k);

            // 撤销选择
            track.pop();
        }
    }

    // 开始主函数
    helper(1, n, k)

    // 返回结果
    return res;
};

子集/组合（元素可重不可复选）

90. 子集 II

90. 子集 II

子集/组合（元素可重不可复选）

给你一个整数数组 nums，其中可能包含重复元素，每个元素只能被选择一次，请你返回该数组所有可能的子集。

function subsetsWithDup(nums: number[]): number[][] {
    // 设置结果集    
    const res: number[][] = [];

    // 记录回溯算法的递归路径
    const track: number[] = [];

    // 回溯算法核心函数，遍历子集问题的回溯树
    const helper = (nums: number[], start: number) => {
        // 前序位置，每个节点的值都是一个子集
        res.push(track.concat());

        // 回溯算法标准框架
        for (let i = start; i < nums.length; i++) {
            // 剪枝逻辑，值相同的相邻树枝，只遍历第一条
            if (i > start && nums[i] == nums[i - 1]) {
                continue;
            }

            track.push(nums[i]);
            helper(nums, i + 1);
            track.pop();
        }
    }

    // 开始主函数
    // 先排序，让相同的元素靠在一起
    nums.sort()
    helper(nums, 0)

    // 返回结果
    return res;
};

子集/组合（元素无重可复选）

39. 组合总和

39. 组合总和

给你一个无重复元素的整数数组 candidates 和一个目标和 target，找出 candidates 中可以使数字和为目标数 target 的所有组合。candidates 中的每个数字可以无限制重复被选取。

function combinationSum(candidates: number[], target: number): number[][] {
    // 设置结果集    
    const res: number[][] = [];

    // 记录回溯算法的递归路径
    const track: number[] = [];

    // 记录 track 中的路径和
    let trackSum = 0;

    // 回溯算法核心函数，遍历子集问题的回溯树
    const helper = (nums: number[], start: number, target: number) => {
        // base case，找到目标和，记录结果
        if (trackSum == target) {
            res.push(track.concat());
            return;
        }

        // base case，超过目标和，停止向下遍历
        if (trackSum > target) {
            return;
        }

        // 回溯算法标准框架
        for (let i = start; i < nums.length; i++) {
            // 选择 nums[i]
            trackSum += nums[i];
            track.push(nums[i]);

            // 递归遍历下一层回溯树
            // 同一元素可重复使用，注意参数
            helper(nums, i, target);

            // 撤销选择 nums[i]
            trackSum -= nums[i];
            track.pop();
        }
    }

    // -----------------开始主函数-------------

    if (candidates.length == 0) {
        return res;
    }
    helper(candidates, 0, target);
    return res;
};

排列（元素无重不可复选）

46. 全排列

46. 全排列

function permute(nums: number[]): number[][] {
    // 1. 设置结果集
    const result: number[][] = [];

    // 2. 回溯
    const recursion = (path, set) => {
        // 2.1 设置回溯终止条件
        if (path.length === nums.length) {

            // 2.1.1 推入结果集
            result.push(path.concat());

            // 2.1.2 终止递归
            return;
        }

        // 2.2 遍历数组
        for (let i = 0; i < nums.length; i++) {

            // 2.2.1 必须是不存在 set 中的坐标
            if (!set.has(i)) {

                // 2.2.2 本地递归条件（用完记得删除）
                path.push(nums[i]);
                set.add(i);

                // 2.2.3 进一步递归
                recursion(path, set);

                // 2.2.4 回溯：撤回 2.2.2 的操作
                path.pop();
                set.delete(i);
            }
        }
    };
    recursion([], new Set());

    // 3. 返回结果
    return result;
};

排列（元素可重不可复选）

47. 全排列 II

47. 全排列 II

function permuteUnique(nums: number[]): number[][] {
    // 设置结果集    
    const res: number[][] = [];

    // 记录回溯算法的递归路径
    const track: number[] = [];

    // 已经使用的
    const used: boolean[] = new Array(nums.length).fill(false);

    // 回溯算法核心函数，遍历子集问题的回溯树
    const helper = (nums: number[]) => {
        // base case
        if (track.length == nums.length) {
            res.push(track.concat());
            return;
        }

        // 回溯算法标准框架
        for (let i = 0; i < nums.length; i++) {
            if (used[i]) {
                continue;
            }
            // 新添加的剪枝逻辑，固定相同的元素在排列中的相对位置
            if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) {
                continue;
            }

            // 做出选择
            track.push(nums[i]);
            used[i] = true;


            helper(nums);

            // 撤销选择
            track.pop();
            used[i] = false;
        }
    }

    // 开始主函数
    // 先排序，让相同的元素靠在一起
    nums.sort()
    helper(nums)

    // 返回结果
    return res;
};

排列（元素无重可复选）

全排列(元素无重可复选)

还是全排列问题，这一次在nums 数组中的元素无重复且可复选的情况下，会有哪些排列？

比如输入 nums = [1,2,3]，那么这种条件下的全排列共有 3^3 = 27 种：

[
  [1,1,1],[1,1,2],[1,1,3],[1,2,1],[1,2,2],[1,2,3],[1,3,1],[1,3,2],[1,3,3],
  [2,1,1],[2,1,2],[2,1,3],[2,2,1],[2,2,2],[2,2,3],[2,3,1],[2,3,2],[2,3,3],
  [3,1,1],[3,1,2],[3,1,3],[3,2,1],[3,2,2],[3,2,3],[3,3,1],[3,3,2],[3,3,3]
]

标准的全排列算法利用 used 数组进行剪枝，避免重复使用同一个元素。如果允许重复使用元素的话，直接放飞自我，去除所有 used 数组的剪枝逻辑就行了。

function permuteRepeat(nums: number[]): number[][] {
    // 设置结果集    
    const res: number[][] = [];

    // 记录回溯算法的递归路径
    const track: number[] = [];

    // 回溯算法核心函数，遍历子集问题的回溯树
    const helper = (nums: number[]) => {
        // base case 到达叶子节点
        if (track.length == nums.length) {
            res.push(track.concat());
            return;
        }

        // 回溯算法标准框架
        for (let i = 0; i < nums.length; i++) {
            // 做出选择
            track.push(nums[i]);

            // 进入下一层回溯树
            helper(nums);

            // 撤销选择
            track.pop();
        }
    }

    // 开始主函数
    helper(nums)

    // 返回结果
    return res;
};

40. 组合总和 II

40. 组合总和 II

function combinationSum2(candidates: number[], target: number): number[][] {
    // 设置结果集    
    const res: number[][] = [];

    // 记录回溯算法的递归路径
    const track: number[] = [];

    // 记录 track 中的路径和
    let trackSum = 0;

    // 回溯算法核心函数，遍历子集问题的回溯树
    const helper = (nums: number[], start: number, target: number) => {
        // base case，找到目标和，记录结果
        if (trackSum == target) {
            res.push(track.concat());
            return;
        }

        // base case，超过目标和，停止向下遍历
        if (trackSum > target) {
            return;
        }

        // 回溯算法标准框架
        for (let i = start; i < nums.length; i++) {
            // 剪枝逻辑，值相同的树枝，只遍历第一条
            if (i > start && nums[i] == nums[i - 1]) {
                continue;
            }

            // 做选择
            trackSum += nums[i];
            track.push(nums[i]);

            // 递归遍历下一层回溯树
            // 同一元素不可重复使用，注意参数
            helper(nums, i + 1, target);

            // 撤销选择 nums[i]
            trackSum -= nums[i];
            track.pop();
        }
    }

    // -----------------开始主函数-------------

    if (candidates.length == 0) {
        return res;
    }

    // 先排序，让相同的元素靠在一起
    candidates.sort()
    helper(candidates, 0, target);
    return res;
};

216. 组合总和 III

216. 组合总和 III

function combinationSum3(k: number, n: number): number[][] {
    // 设置结果集    
    const res: number[][] = [];

    // 记录回溯算法的递归路径
    const track: number[] = [];

    // 记录 track 中的路径和
    let trackSum: number = 0;

    // 回溯算法核心函数，遍历子集问题的回溯树
    const helper = (start: number, n: number, k: number) => {
        // base case，找到目标和，记录结果
        if (k == track.length && trackSum == n) {
            // 遍历到了第 k 层，trackSun == n，收集
            res.push(track.concat());
            return;
        }

        // base case，超过目标和，停止向下遍历
        if (trackSum > n) {
            return;
        }

        // 回溯算法标准框架
        for (let i = start; i <= 9; i++) {
            // 选择  
            trackSum += i;
            track.push(i);

            // 递归遍历下一层回溯树
            helper(i + 1, n, k);

            // 撤销选择 nums[i]
            trackSum -= i;
            track.pop();
        }
    }

    // -----------------开始主函数-------------
    helper(1, n, k);
    return res;
};

小结

形式一

元素无重不可复选，即 nums 中的元素都是唯一的，每个元素最多只能被使用一次，backtrack 核心代码如下：

/* 组合/子集问题回溯算法框架 */
function backtrack( nums,  start) {
    // 回溯算法标准框架
    for (let i = start; i < nums.length; i++) {
        // 做选择
        track.push(nums[i]);
        // 注意参数
        backtrack(nums, i + 1);
        // 撤销选择
        track.removeLast();
    }
}

/* 排列问题回溯算法框架 */
function backtrack( nums) {
    for (let i = 0; i < nums.length; i++) {
        // 剪枝逻辑
        if (used[i]) {
            continue;
        }
        // 做选择
        used[i] = true;
        track.push(nums[i]);

        backtrack(nums);
        // 撤销选择
        track.removeLast();
        used[i] = false;
    }
}

形式二

元素可重不可复选，即 nums 中的元素可以存在重复，每个元素最多只能被使用一次，其关键在于排序和剪枝，backtrack 核心代码如下：

nums.sort();
/* 组合/子集问题回溯算法框架 */
function backtrack( nums, let start) {
    // 回溯算法标准框架
    for (let i = start; i < nums.length; i++) {
        // 剪枝逻辑，跳过值相同的相邻树枝
        if (i > start && nums[i] == nums[i - 1]) {
            continue;
        }
        // 做选择
        track.push(nums[i]);
        // 注意参数
        backtrack(nums, i + 1);
        // 撤销选择
        track.removeLast();
    }
}


nums.sort();
/* 排列问题回溯算法框架 */
function backtrack( nums) {
    for (let i = 0; i < nums.length; i++) {
        // 剪枝逻辑
        if (used[i]) {
            continue;
        }
        // 剪枝逻辑，固定相同的元素在排列中的相对位置
        if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) {
            continue;
        }
        // 做选择
        used[i] = true;
        track.push(nums[i]);

        backtrack(nums);
        // 撤销选择
        track.removeLast();
        used[i] = false;
    }
}

形式三

元素无重可复选，即 nums 中的元素都是唯一的，每个元素可以被使用若干次，只要删掉去重逻辑即可，backtrack 核心代码如下：

/* 组合/子集问题回溯算法框架 */
function backtrack( nums, let start) {
    // 回溯算法标准框架
    for (let i = start; i < nums.length; i++) {
        // 做选择
        track.push(nums[i]);
        // 注意参数
        backtrack(nums, i);
        // 撤销选择
        track.removeLast();
    }
}


/* 排列问题回溯算法框架 */
function backtrack( nums) {
    for (let i = 0; i < nums.length; i++) {
        // 做选择
        track.push(nums[i]);
        backtrack(nums);
        // 撤销选择
        track.removeLast();
    }
}
豆子前端
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【leetCode】——多数元素
m0_50785976的博客
09-19 468
多数元素
解决vue3中 import type { FormInstance } from ‘element-plus‘出现报错
weixin_52075774的博客
06-05 4374
解决vue3中使用element-plus的form组件出现import type { FormInstance } from 'element-plus'错误
TypeScript Downleveling - 什么是 TypeScript 的降级行为
SAP 资深技术专家 Jerry Wang 的技术分享
06-24 1100
下列 TypeScript 代码： function greet(person: string, date: Date) { console.log(`Hello ${person}, today is ${date.toDateString()}!`); } greet("Maddison", new Date()); 使用 tsc 编译器编译之后生成的 JavaScript 代码： function greet(person, date) { console.log("Hello " +
VScode如何切换TypeScript版本
weixin_44051293的博客
02-08 4185
VScode如何切换Typesc版本
【TypeScript教程】02—设置TypeScript
web前端开发
03-21 313
教程|https://www.typescripttutorial.net翻译 | 杨小爱在今天的教程中，我们将一起来学习如何设置 TypeScript 开发环境。使用 TypeScr...
leetcode javascript_typescript实现.zip
最新发布
02-28
leetcode javascript_typescript实现.zip
leetcode删除账号-typescript-leetcode:用Typescript刷一遍leetcode笔试面试高频题。尽量持续更新吧
06-30
typescript-leetcode 用Typescript刷一遍leetcode面试高频题。缓慢持续更新。 已解题目：（基本都没有发上来） 前端高频的-数组 原地哈希 剑指Offer03-找出数组中重复的数字 26.删除排序数组中的重复项 136.只出现一...
leetcode530-leetcode:由TypeScript和@golang实现的Leetcode解决方案
06-30
leetcode 530 leetcode leetcode 解答。 How to run specific unit-test ...在处理数组项删除问题时，尽量避免直接...的框架实现探测最小深度，当某层某节点为叶子元素时，返回当前深度 递归（迭代）遍历二叉树度 据题，
在VSCode中解决LeetCode问题_TypeScript_下载.zip
04-30
在VSCode中解决LeetCode问题_TypeScript_下载.zip
vscode安装leetcode后配置-leetcode:Leetcode题解TypeScript版
06-30
vscode安装leetcode后配置 leetcode 算法题解 项目中每段代码都可以正常运行 git clone https://github.com/Yechuanjie/leetcode.git cd algorithm yarn install .vscode 中已配置好 launch.json，安装依赖后，任意...
vscode提交leetcode-typescript-leetcode:打字稿-leetcode
06-30
vscode提交leetcode 打字稿 Leetcode 用打字稿解决leetcode问题 步 用于在注释中生成包含问题描述的初始 js 文件 生成初始 ts 文件 $ cp js/1.two-sum.js ts/1.two-sum.ts 解决 ts 文件中的问题 将 ts 文件编译到 js 一 $ npm run tsc 用于将编译后的 js 文件提交到 leetcode 问题解决 指南 理解问题 探索例子 分解 解决 重构 图案 频率计数器 多个指针 滑动窗口 分而治之 算法 复杂城市 算法 最好的时间 平均时间 最坏时间 空间 线性搜索 O(1) 上） 上） 二分查找 O(1) O(log n) O(log n) 冒泡排序 上） O(n^2) O(n^2) O(1) 插入排序 上） O(n^2) O(n^2) O(1) 选择排序 O(n^2) O(n^2) O(n^2) O(1) 归并排序 O(n log n) O(n log n) O(n log n) 上） 快速排序 O(n log n) O(n log n) O(n^2) O(log n) 基数排序 O(nk) O(nk)
meta：leetcode javascripttypescript实现
02-05
leetcode题解 相关链接 目录 指数 标题 码 困难 0001 两次和 简单 0002 加两个数字 中 0003 最长子串，无重复字符 中 0004 两个排序数组的中位数 硬 0005 最长回文子串 中 0006 之字形转换 中 0007 反整数 简单 0008 字符串到整数（atoi） 中 0009 回文数 简单 0010 正则表达式匹配 硬 0011 装满水的容器 中 0012 整数到罗马 中 0013 罗马到整数 简单 0014 最长的公共前缀 简单 0015 3和 中 0016 3Sum最近 中 0017 电话号码
JS如何捆绑TypeScript声明文件
pwc1996的博客
09-02 1万+
前话 TypeScript是JavaScript类型的超集 这是TypeScript的文档介绍的一句话，那么他们存在联系呢？我的理解是，TypeScript在JavaScript基础上引入强类型语言的特性。开发者使用TypeScript语法进行编程开发，最终通过转换工具将TypeScript转换成JavaScript。使用TypeScript能够避免在原生JavaScript上开发所带来的弱类型
TypeScript踩坑记录
热门推荐
lihefei_coder的博客
12-25 4万+
TypeScript踩坑记录
升级typescript版本
大强博客
08-30 9638
错误信息： @angular/[email protected] requires typescript@'&gt;=2.4.2 &lt;2.7.0' but 2.4.0 was found instead. Using this version can result in undefined behaviour and difficult to debug problems. Pleas...
如何全局安装和卸载typescript？typescript常用命令
南北极之间
06-08 5242
如何全局安装和卸载typescript？typescript常用命令
TypeScript4 大版本更新，到底有哪些新特性！
前端下午茶
12-03 2582
1 引言随着 Typescript 4 Beta 的发布，又带来了许多新功能，其中 Variadic Tuple Types 解决了大量重载模版代码的顽疾，使得这次更新非常有意义。2 简...
如何查看typescript版本，安装指定typescript版本，卸载typescript
q1ngqingsky的博客
05-13 4181
WARNING: You are currently running a version of TypeScript which is not officially supported by typescript-estree. You may find that it works just fine, or you may not. SUPPORTED TYPESCRIPT VERSIONS: >=3.2.1 <3.6.0 YOUR TYPESCRIPT VERSION: 3.9....
typescript版本问题导致项目启动后，内部页面报错
qq_42619099的博客
03-07 2480
记一次项目中，由于type script版本过高导致的问题。 问题描述：项目能正常跑起来，但是由于typescript版本问题导致tsx文件解析有问题，进而导致了控制台报了一些react的方法问题的错。且当时终端无任何错误提示，只有一闪而过的typescript版本过高的提示，最后根据这条提示降低了typescript版本，运行就正常了。 感想：所以报react xx方法有问题，不一定是代码写错了，也可能是由于编程环境导致代码解析出错了。 解决方案：1，修改package.json中的typescript版
leetcode 回溯
08-22
在LeetCode上，有许多使用回溯算法的题目。 回溯算法的基本思想是通过深度优先搜索，不断地尝试下一个可能的解，如果当前解不符合要求，则回退到上一个状态，继续尝试其他可能的解。这种方式有点类似于穷举法，但是...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值