😀
2025.5.8 其实之前已经做了一些内容了，只是没系统整理，这里理论知识实际上都过了一遍，现在要系统性地刷题了，打算从力扣hot100和代码随想录入手，之后如果有时间再刷刷洛谷的
理论内容数组专题二分搜索移除元素有序数组的平方长度最小的子数组螺旋矩阵II链表专题移除链表元素设计链表反转链表两两交换链表中的节点删除链表的倒数第 N 个结点链表相交环形链表 II哈希表专题有效的字母异位词两个数组的交集快乐数两数之和四数相加 II赎金信三数之和四数之和字符串专题反转字符串反转字符串 II替换数字反转字符串中的单词右旋字符串找出字符串中第一个匹配项的下标(KMP)重复的子字符串(KMP)栈与队列专题用栈实现队列用队列实现栈有效的括号删除字符串中的所有相邻重复项逆波兰表达式求值滑动窗口最大值(单调队列)前 K 个高频元素(优先级队列)树与二叉树专题二叉树的递归遍历与迭代遍历二叉树层序遍历翻转二叉树对称二叉树完全二叉树的节点个数平衡二叉树二叉树的所有路径左叶子之和找树左下角的值路径总和从中序与后序遍历序列构造二叉树最大二叉树合并二叉树二叉搜索树中的搜索验证二叉搜索树二叉搜索树的最小绝对差二叉搜索树中的众数二叉树的最近公共祖先二叉搜索树的最近公共祖先二叉搜索树中的插入操作删除二叉搜索树中的节点修剪二叉搜索树将有序数组转换为二叉搜索树把二叉搜索树转换为累加树回溯专题组合组合总和 III电话号码的字母组合组合总和组合总和 II分割回文串复原 IP 地址子集子集 II非递减子序列全排列全排列 IIN皇后问题解数独贪心算法分发饼干摆动序列最大子数组和买卖股票的最佳时机 II跳跃游戏跳跃游戏 IIK 次取反后最大化的数组和加油站分发糖果柠檬水找零根据身高重建队列用最少数量的箭引爆气球无重叠区间划分字母区间合并区间单调递增的数字监控二叉树动态规划斐波那契数爬楼梯使用最小花费爬楼梯不同路径不同路径 II整数拆分不同的二叉搜索树0-1 背包问题分割等和子集最后一块石头的重量 II目标和一和零携带研究材料零钱兑换 II组合总和 Ⅳ爬楼梯(进阶版)零钱兑换完全平方数单词拆分打家劫舍打家劫舍 II打家劫舍 III买卖股票的最佳时机买卖股票的最佳时机 II买卖股票的最佳时机 III买卖股票的最佳时机 IV买卖股票的最佳时机含冷冻期买卖股票的最佳时机含手续费最长递增子序列最长递增子序列最长连续递增序列最长重复子数组最长公共子序列不相交的线最大子数组和判断子序列不同的子序列两个字符串的删除操作编辑距离回文子串最长回文子序列单调栈每日温度下一个更大元素 I下一个更大元素 II接雨水柱状图中最大的矩形图论所有可达路径所有可能的路径岛屿数量岛屿的最大面积孤岛的总面积沉没孤岛水流问题建造最大岛屿岛屿的周长单词接龙有向图的完全联通并查集类定义寻找图中是否存在路径冗余连接冗余连接 II寻宝软件构建参加科学大会城市间货物运输 I小明逛公园A*搜索算法

理论内容

我的Acwing笔记：
代码随想录：代码随想录
 
 

数组专题

二分搜索

常见易错点：
1.while内左右循环变量是否要加=
2.缩小区间时right=middle-1或者middle
解决方案：注意常见区间时左闭右闭还是左闭右开
左闭右闭：right=nums.size-1,while循环内加=，right=middle-1,left=middle+1
左闭右开：right=nums.size,while循环内left < right, right=middle, left=middle+1
704. 二分查找 - 力扣（LeetCode）
704. 二分查找 - 给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target  ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。 示例 1: 输入: nums = [-1,0,3,5,9,12], target = 9 输出: 4 解释: 9 出现在 nums 中并且下标为 4 示例 2: 输入: nums = [-1,0,3,5,9,12], target = 2 输出: -1 解释: 2 不存在 nums 中因此返回 -1   提示： 1. 你可以假设 nums 中的所有元素是不重复的。 2. n 将在 [1, 10000]之间。 3. nums 的每个元素都将在 [-9999, 9999]之间。
704. 二分查找 - 力扣（LeetCode）
https://leetcode.cn/problems/binary-search/description/
704. 二分查找 - 力扣（LeetCode）
 

移除元素

27. 移除元素 - 力扣（LeetCode）
27. 移除元素 - 给你一个数组 nums 和一个值 val，你需要 原地 [https://baike.baidu.com/item/%E5%8E%9F%E5%9C%B0%E7%AE%97%E6%B3%95] 移除所有数值等于 val 的元素。元素的顺序可能发生改变。然后返回 nums 中与 val 不同的元素的数量。 假设 nums 中不等于 val 的元素数量为 k，要通过此题，您需要执行以下操作： * 更改 nums 数组，使 nums 的前 k 个元素包含不等于 val 的元素。nums 的其余元素和 nums 的大小并不重要。 * 返回 k。 用户评测： 评测机将使用以下代码测试您的解决方案： int[] nums = [...]; // 输入数组 int val = ...; // 要移除的值 int[] expectedNums = [...]; // 长度正确的预期答案。 // 它以不等于 val 的值排序。 int k = removeElement(nums, val); // 调用你的实现 assert k == expectedNums.length; sort(nums, 0, k); // 排序 nums 的前 k 个元素 for (int i = 0; i < actualLength; i++) { assert nums[i] == expectedNums[i]; } 如果所有的断言都通过，你的解决方案将会 通过。   示例 1： 输入：nums = [3,2,2,3], val = 3 输出：2, nums = [2,2,_,_] 解释：你的函数函数应该返回 k = 2, 并且 nums 中的前两个元素均为 2。 你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。 示例 2： 输入：nums = [0,1,2,2,3,0,4,2], val = 2 输出：5, nums = [0,1,4,0,3,_,_,_] 解释：你的函数应该返回 k = 5，并且 nums 中的前五个元素为 0,0,1,3,4。 注意这五个元素可以任意顺序返回。 你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。   提示： * 0 <= nums.length <= 100 * 0 <= nums[i] <= 50 * 0 <= val <= 100
27. 移除元素 - 力扣（LeetCode）
https://leetcode.cn/problems/remove-element/
27. 移除元素 - 力扣（LeetCode）
 

有序数组的平方

977. 有序数组的平方 - 力扣（LeetCode）
977. 有序数组的平方 - 给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。   示例 1： 输入：nums = [-4,-1,0,3,10] 输出：[0,1,9,16,100] 解释：平方后，数组变为 [16,1,0,9,100] 排序后，数组变为 [0,1,9,16,100] 示例 2： 输入：nums = [-7,-3,2,3,11] 输出：[4,9,9,49,121]   提示： * 1 <= nums.length <= 104 * -104 <= nums[i] <= 104 * nums 已按 非递减顺序 排序   进阶： * 请你设计时间复杂度为 O(n) 的算法解决本问题
977. 有序数组的平方 - 力扣（LeetCode）
https://leetcode.cn/problems/squares-of-a-sorted-array/description/
977. 有序数组的平方 - 力扣（LeetCode）
 

长度最小的子数组

209. 长度最小的子数组 - 力扣（LeetCode）
209. 长度最小的子数组 - 给定一个含有 n 个正整数的数组和一个正整数 target 。 找出该数组中满足其总和大于等于 target 的长度最小的 子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。   示例 1： 输入：target = 7, nums = [2,3,1,2,4,3] 输出：2 解释：子数组 [4,3] 是该条件下的长度最小的子数组。 示例 2： 输入：target = 4, nums = [1,4,4] 输出：1 示例 3： 输入：target = 11, nums = [1,1,1,1,1,1,1,1] 输出：0   提示： * 1 <= target <= 109 * 1 <= nums.length <= 105 * 1 <= nums[i] <= 104   进阶： * 如果你已经实现 O(n) 时间复杂度的解法, 请尝试设计一个 O(n log(n)) 时间复杂度的解法。
209. 长度最小的子数组 - 力扣（LeetCode）
https://leetcode.cn/problems/minimum-size-subarray-sum/description/
209. 长度最小的子数组 - 力扣（LeetCode）
 

螺旋矩阵II

59. 螺旋矩阵 II - 力扣（LeetCode）
59. 螺旋矩阵 II - 给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。   示例 1： [https://assets.leetcode.com/uploads/2020/11/13/spiraln.jpg] 输入：n = 3 输出：[[1,2,3],[8,9,4],[7,6,5]] 示例 2： 输入：n = 1 输出：[[1]]   提示： * 1 <= n <= 20
59. 螺旋矩阵 II - 力扣（LeetCode）
https://leetcode.cn/problems/spiral-matrix-ii/description/
59. 螺旋矩阵 II - 力扣（LeetCode）
 

链表专题

移除链表元素

203. 移除链表元素 - 力扣（LeetCode）
203. 移除链表元素 - 给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。   示例 1： [https://assets.leetcode.com/uploads/2021/03/06/removelinked-list.jpg] 输入：head = [1,2,6,3,4,5,6], val = 6 输出：[1,2,3,4,5] 示例 2： 输入：head = [], val = 1 输出：[] 示例 3： 输入：head = [7,7,7,7], val = 7 输出：[]   提示： * 列表中的节点数目在范围 [0, 104] 内 * 1 <= Node.val <= 50 * 0 <= val <= 50
203. 移除链表元素 - 力扣（LeetCode）
https://leetcode.cn/problems/remove-linked-list-elements/description/
203. 移除链表元素 - 力扣（LeetCode）
 

设计链表

707. 设计链表 - 力扣（LeetCode）
707. 设计链表 - 你可以选择使用单链表或者双链表，设计并实现自己的链表。 单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。 如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。 实现 MyLinkedList 类： * MyLinkedList() 初始化 MyLinkedList 对象。 * int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。 * void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。 * void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。 * void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。 * void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。   示例： 输入 ["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"] [[], [1], [3], [1, 2], [1], [1], [1]] 输出 [null, null, null, null, 2, null, 3] 解释 MyLinkedList myLinkedList = new MyLinkedList(); myLinkedList.addAtHead(1); myLinkedList.addAtTail(3); myLinkedList.addAtIndex(1, 2); // 链表变为 1->2->3 myLinkedList.get(1); // 返回 2 myLinkedList.deleteAtIndex(1); // 现在，链表变为 1->3 myLinkedList.get(1); // 返回 3   提示： * 0 <= index, val <= 1000 * 请不要使用内置的 LinkedList 库。 * 调用 get、addAtHead、addAtTail、addAtIndex 和 deleteAtIndex 的次数不超过 2000 。
707. 设计链表 - 力扣（LeetCode）
https://leetcode.cn/problems/design-linked-list/description/
707. 设计链表 - 力扣（LeetCode）
 

反转链表

206. 反转链表 - 力扣（LeetCode）
206. 反转链表 - 给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。   示例 1： [https://assets.leetcode.com/uploads/2021/02/19/rev1ex1.jpg] 输入：head = [1,2,3,4,5] 输出：[5,4,3,2,1] 示例 2： [https://assets.leetcode.com/uploads/2021/02/19/rev1ex2.jpg] 输入：head = [1,2] 输出：[2,1] 示例 3： 输入：head = [] 输出：[]   提示： * 链表中节点的数目范围是 [0, 5000] * -5000 <= Node.val <= 5000   进阶：链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？
206. 反转链表 - 力扣（LeetCode）
https://leetcode.cn/problems/reverse-linked-list/description/
206. 反转链表 - 力扣（LeetCode）
 

两两交换链表中的节点

24. 两两交换链表中的节点 - 力扣（LeetCode）
24. 两两交换链表中的节点 - 给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。   示例 1： [https://assets.leetcode.com/uploads/2020/10/03/swap_ex1.jpg] 输入：head = [1,2,3,4] 输出：[2,1,4,3] 示例 2： 输入：head = [] 输出：[] 示例 3： 输入：head = [1] 输出：[1]   提示： * 链表中节点的数目在范围 [0, 100] 内 * 0 <= Node.val <= 100
24. 两两交换链表中的节点 - 力扣（LeetCode）
https://leetcode.cn/problems/swap-nodes-in-pairs/description/
24. 两两交换链表中的节点 - 力扣（LeetCode）
 

删除链表的倒数第 N 个结点

19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode）
19. 删除链表的倒数第 N 个结点 - 给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。   示例 1： [https://assets.leetcode.com/uploads/2020/10/03/remove_ex1.jpg] 输入：head = [1,2,3,4,5], n = 2 输出：[1,2,3,5] 示例 2： 输入：head = [1], n = 1 输出：[] 示例 3： 输入：head = [1,2], n = 1 输出：[1]   提示： * 链表中结点的数目为 sz * 1 <= sz <= 30 * 0 <= Node.val <= 100 * 1 <= n <= sz   进阶：你能尝试使用一趟扫描实现吗？
19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode）
https://leetcode.cn/problems/remove-nth-node-from-end-of-list/description/
19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode）
 

链表相交

面试题 02.07. 链表相交 - 力扣（LeetCode）
面试题 02.07. 链表相交 - 给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。 图示两个链表在节点 c1 开始相交： [https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/14/160_statement.png] [https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/14/160_statement.png] 题目数据 保证 整个链式结构中不存在环。 注意，函数返回结果后，链表必须 保持其原始结构 。   示例 1： [https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/14/160_example_1.png] [https://assets.leetcode.com/uploads/2018/12/13/160_example_1.png] 输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3 输出：Intersected at '8' 解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。 从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。 在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。 示例 2： [https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/14/160_example_2.png] [https://assets.leetcode.com/uploads/2018/12/13/160_example_2.png] 输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1 输出：Intersected at '2' 解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。 从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。 在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。 示例 3： [https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/14/160_example_3.png] [https://assets.leetcode.com/uploads/2018/12/13/160_example_3.png] 输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2 输出：null 解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。 由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。 这两个链表不相交，因此返回 null 。   提示： * listA 中节点数目为 m * listB 中节点数目为 n * 0 <= m, n <= 3 * 104 * 1 <= Node.val <= 105 * 0 <= skipA <= m * 0 <= skipB <= n * 如果 listA 和 listB 没有交点，intersectVal 为 0 * 如果 listA 和 listB 有交点，intersectVal == listA[skipA + 1] == listB[skipB + 1]   进阶：你能否设计一个时间复杂度 O(n) 、仅用 O(1) 内存的解决方案？
面试题 02.07. 链表相交 - 力扣（LeetCode）
https://leetcode.cn/problems/intersection-of-two-linked-lists-lcci/description/
面试题 02.07. 链表相交 - 力扣（LeetCode）
 

环形链表 II

142. 环形链表 II - 力扣（LeetCode）
142. 环形链表 II - 给定一个链表的头节点  head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。 如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。 不允许修改 链表。   示例 1： [https://assets.leetcode.com/uploads/2018/12/07/circularlinkedlist.png] 输入：head = [3,2,0,-4], pos = 1 输出：返回索引为 1 的链表节点 解释：链表中有一个环，其尾部连接到第二个节点。 示例 2： [https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/07/circularlinkedlist_test2.png] 输入：head = [1,2], pos = 0 输出：返回索引为 0 的链表节点 解释：链表中有一个环，其尾部连接到第一个节点。 示例 3： [https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/07/circularlinkedlist_test3.png] 输入：head = [1], pos = -1 输出：返回 null 解释：链表中没有环。   提示： * 链表中节点的数目范围在范围 [0, 104] 内 * -105 <= Node.val <= 105 * pos 的值为 -1 或者链表中的一个有效索引   进阶：你是否可以使用 O(1) 空间解决此题？
142. 环形链表 II - 力扣（LeetCode）
https://leetcode.cn/problems/linked-list-cycle-ii/description/
142. 环形链表 II - 力扣（LeetCode）
 

哈希表专题

有效的字母异位词

242. 有效的字母异位词 - 力扣（LeetCode）
242. 有效的字母异位词 - 给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的 字母异位词。   示例 1: 输入: s = "anagram", t = "nagaram" 输出: true 示例 2: 输入: s = "rat", t = "car" 输出: false   提示: * 1 <= s.length, t.length <= 5 * 104 * s 和 t 仅包含小写字母   进阶: 如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？
242. 有效的字母异位词 - 力扣（LeetCode）
https://leetcode.cn/problems/valid-anagram/description/
242. 有效的字母异位词 - 力扣（LeetCode）
 

两个数组的交集

349. 两个数组的交集 - 力扣（LeetCode）
349. 两个数组的交集 - 给定两个数组 nums1 和 nums2 ，返回 它们的 交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。   示例 1： 输入：nums1 = [1,2,2,1], nums2 = [2,2] 输出：[2] 示例 2： 输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4] 输出：[9,4] 解释：[4,9] 也是可通过的   提示： * 1 <= nums1.length, nums2.length <= 1000 * 0 <= nums1[i], nums2[i] <= 1000
349. 两个数组的交集 - 力扣（LeetCode）
https://leetcode.cn/problems/intersection-of-two-arrays/description/
349. 两个数组的交集 - 力扣（LeetCode）
 

快乐数

202. 快乐数 - 力扣（LeetCode）
202. 快乐数 - 编写一个算法来判断一个数 n 是不是快乐数。 「快乐数」 定义为： * 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。 * 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。 * 如果这个过程 结果为 1，那么这个数就是快乐数。 如果 n 是 快乐数 就返回 true ；不是，则返回 false 。   示例 1： 输入：n = 19 输出：true 解释： 12 + 92 = 82 82 + 22 = 68 62 + 82 = 100 12 + 02 + 02 = 1 示例 2： 输入：n = 2 输出：false   提示： * 1 <= n <= 231 - 1
202. 快乐数 - 力扣（LeetCode）
https://leetcode.cn/problems/happy-number/description/
202. 快乐数 - 力扣（LeetCode）
 

两数之和

1. 两数之和 - 力扣（LeetCode）
1. 两数之和 - 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。 你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。 你可以按任意顺序返回答案。   示例 1： 输入：nums = [2,7,11,15], target = 9 输出：[0,1] 解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。 示例 2： 输入：nums = [3,2,4], target = 6 输出：[1,2] 示例 3： 输入：nums = [3,3], target = 6 输出：[0,1]   提示： * 2 <= nums.length <= 104 * -109 <= nums[i] <= 109 * -109 <= target <= 109 * 只会存在一个有效答案   进阶：你可以想出一个时间复杂度小于 O(n2) 的算法吗？
1. 两数之和 - 力扣（LeetCode）
https://leetcode.cn/problems/two-sum/description/
1. 两数之和 - 力扣（LeetCode）
 

四数相加 II

454. 四数相加 II - 力扣（LeetCode）
454. 四数相加 II - 给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足： * 0 <= i, j, k, l < n * nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0   示例 1： 输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2] 输出：2 解释： 两个元组如下： 1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0 2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0 示例 2： 输入：nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0] 输出：1     提示： * n == nums1.length * n == nums2.length * n == nums3.length * n == nums4.length * 1 <= n <= 200 * -228 <= nums1[i], nums2[i], nums3[i], nums4[i] <= 228
454. 四数相加 II - 力扣（LeetCode）
https://leetcode.cn/problems/4sum-ii/description/
454. 四数相加 II - 力扣（LeetCode）
 

赎金信

383. 赎金信 - 力扣（LeetCode）
383. 赎金信 - 给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。 如果可以，返回 true ；否则返回 false 。 magazine 中的每个字符只能在 ransomNote 中使用一次。   示例 1： 输入：ransomNote = "a", magazine = "b" 输出：false 示例 2： 输入：ransomNote = "aa", magazine = "ab" 输出：false 示例 3： 输入：ransomNote = "aa", magazine = "aab" 输出：true   提示： * 1 <= ransomNote.length, magazine.length <= 105 * ransomNote 和 magazine 由小写英文字母组成
383. 赎金信 - 力扣（LeetCode）
https://leetcode.cn/problems/ransom-note/description/
383. 赎金信 - 力扣（LeetCode）
 

三数之和

15. 三数之和 - 力扣（LeetCode）
15. 三数之和 - 给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。 注意：答案中不可以包含重复的三元组。     示例 1： 输入：nums = [-1,0,1,2,-1,-4] 输出：[[-1,-1,2],[-1,0,1]] 解释： nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。 nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。 nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。 不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。 注意，输出的顺序和三元组的顺序并不重要。 示例 2： 输入：nums = [0,1,1] 输出：[] 解释：唯一可能的三元组和不为 0 。 示例 3： 输入：nums = [0,0,0] 输出：[[0,0,0]] 解释：唯一可能的三元组和为 0 。   提示： * 3 <= nums.length <= 3000 * -105 <= nums[i] <= 105
15. 三数之和 - 力扣（LeetCode）
https://leetcode.cn/problems/3sum/description/
15. 三数之和 - 力扣（LeetCode）
 

四数之和

18. 四数之和 - 力扣（LeetCode）
18. 四数之和 - 给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）： * 0 <= a, b, c, d < n * a、b、c 和 d 互不相同 * nums[a] + nums[b] + nums[c] + nums[d] == target 你可以按 任意顺序 返回答案 。   示例 1： 输入：nums = [1,0,-1,0,-2,2], target = 0 输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]] 示例 2： 输入：nums = [2,2,2,2,2], target = 8 输出：[[2,2,2,2]]   提示： * 1 <= nums.length <= 200 * -109 <= nums[i] <= 109 * -109 <= target <= 109
18. 四数之和 - 力扣（LeetCode）
https://leetcode.cn/problems/4sum/description/
18. 四数之和 - 力扣（LeetCode）
 

字符串专题

反转字符串

344. 反转字符串 - 力扣（LeetCode）
344. 反转字符串 - 编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。 不要给另外的数组分配额外的空间，你必须原地 [https://baike.baidu.com/item/原地算法]修改输入数组、使用 O(1) 的额外空间解决这一问题。   示例 1： 输入：s = ["h","e","l","l","o"] 输出：["o","l","l","e","h"] 示例 2： 输入：s = ["H","a","n","n","a","h"] 输出：["h","a","n","n","a","H"]   提示： * 1 <= s.length <= 105 * s[i] 都是 ASCII [https://baike.baidu.com/item/ASCII] 码表中的可打印字符
344. 反转字符串 - 力扣（LeetCode）
https://leetcode.cn/problems/reverse-string/description/
344. 反转字符串 - 力扣（LeetCode）
 

反转字符串 II

541. 反转字符串 II - 力扣（LeetCode）
541. 反转字符串 II - 给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。 * 如果剩余字符少于 k 个，则将剩余字符全部反转。 * 如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。   示例 1： 输入：s = "abcdefg", k = 2 输出："bacdfeg" 示例 2： 输入：s = "abcd", k = 2 输出："bacd"   提示： * 1 <= s.length <= 104 * s 仅由小写英文组成 * 1 <= k <= 104
541. 反转字符串 II - 力扣（LeetCode）
https://leetcode.cn/problems/reverse-string-ii/description/
541. 反转字符串 II - 力扣（LeetCode）
 

替换数字

54. 替换数字（第八期模拟笔试）
54. 替换数字（第八期模拟笔试）
https://kamacoder.com/problempage.php?pid=1064
 

反转字符串中的单词

151. 反转字符串中的单词 - 力扣（LeetCode）
151. 反转字符串中的单词 - 给你一个字符串 s ，请你反转字符串中 单词 的顺序。 单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。 返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。 注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。   示例 1： 输入：s = "the sky is blue" 输出："blue is sky the" 示例 2： 输入：s = "  hello world  " 输出："world hello" 解释：反转后的字符串中不能存在前导空格和尾随空格。 示例 3： 输入：s = "a good   example" 输出："example good a" 解释：如果两个单词间有多余的空格，反转后的字符串需要将单词间的空格减少到仅有一个。   提示： * 1 <= s.length <= 104 * s 包含英文大小写字母、数字和空格 ' ' * s 中 至少存在一个 单词   进阶：如果字符串在你使用的编程语言中是一种可变数据类型，请尝试使用 O(1) 额外空间复杂度的 原地 解法。
151. 反转字符串中的单词 - 力扣（LeetCode）
https://leetcode.cn/problems/reverse-words-in-a-string/description/
151. 反转字符串中的单词 - 力扣（LeetCode）
 

右旋字符串

55. 右旋字符串（第八期模拟笔试）
字符串的右旋转操作是把字符串尾部的若干个字符转移到字符串的前面。给定一个字符串 s 和一个正整数 k，请编写一个函数，将字符串中的后面 k 个字符移到字符串的前面，实现字符串的右旋转操作。
55. 右旋字符串（第八期模拟笔试）
https://kamacoder.com/problempage.php?pid=1065
 

找出字符串中第一个匹配项的下标(KMP)

28. 找出字符串中第一个匹配项的下标 - 力扣（LeetCode）
28. 找出字符串中第一个匹配项的下标 - 给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回  -1 。   示例 1： 输入：haystack = "sadbutsad", needle = "sad" 输出：0 解释："sad" 在下标 0 和 6 处匹配。 第一个匹配项的下标是 0 ，所以返回 0 。 示例 2： 输入：haystack = "leetcode", needle = "leeto" 输出：-1 解释："leeto" 没有在 "leetcode" 中出现，所以返回 -1 。   提示： * 1 <= haystack.length, needle.length <= 104 * haystack 和 needle 仅由小写英文字符组成
28. 找出字符串中第一个匹配项的下标 - 力扣（LeetCode）
https://leetcode.cn/problems/find-the-index-of-the-first-occurrence-in-a-string/description/
28. 找出字符串中第一个匹配项的下标 - 力扣（LeetCode）
 

重复的子字符串(KMP)

459. 重复的子字符串 - 力扣（LeetCode）
459. 重复的子字符串 - 给定一个非空的字符串 s ，检查是否可以通过由它的一个子串重复多次构成。   示例 1: 输入: s = "abab" 输出: true 解释: 可由子串 "ab" 重复两次构成。 示例 2: 输入: s = "aba" 输出: false 示例 3: 输入: s = "abcabcabcabc" 输出: true 解释: 可由子串 "abc" 重复四次构成。 (或子串 "abcabc" 重复两次构成。)   提示： * 1 <= s.length <= 104 * s 由小写英文字母组成
459. 重复的子字符串 - 力扣（LeetCode）
https://leetcode.cn/problems/repeated-substring-pattern/description/
459. 重复的子字符串 - 力扣（LeetCode）
 

栈与队列专题

用栈实现队列

232. 用栈实现队列 - 力扣（LeetCode）
232. 用栈实现队列 - 请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）： 实现 MyQueue 类： * void push(int x) 将元素 x 推到队列的末尾 * int pop() 从队列的开头移除并返回元素 * int peek() 返回队列开头的元素 * boolean empty() 如果队列为空，返回 true ；否则，返回 false 说明： * 你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。 * 你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。   示例 1： 输入： ["MyQueue", "push", "push", "peek", "pop", "empty"] [[], [1], [2], [], [], []] 输出： [null, null, null, 1, 1, false] 解释： MyQueue myQueue = new MyQueue(); myQueue.push(1); // queue is: [1] myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue) myQueue.peek(); // return 1 myQueue.pop(); // return 1, queue is [2] myQueue.empty(); // return false   提示： * 1 <= x <= 9 * 最多调用 100 次 push、pop、peek 和 empty * 假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）   进阶： * 你能否实现每个操作均摊时间复杂度为 O(1) 的队列？换句话说，执行 n 个操作的总时间复杂度为 O(n) ，即使其中一个操作可能花费较长时间。
232. 用栈实现队列 - 力扣（LeetCode）
https://leetcode.cn/problems/implement-queue-using-stacks/description/
232. 用栈实现队列 - 力扣（LeetCode）
 

用队列实现栈

225. 用队列实现栈 - 力扣（LeetCode）
225. 用队列实现栈 - 请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。 实现 MyStack 类： * void push(int x) 将元素 x 压入栈顶。 * int pop() 移除并返回栈顶元素。 * int top() 返回栈顶元素。 * boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。   注意： * 你只能使用队列的标准操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。 * 你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。   示例： 输入： ["MyStack", "push", "push", "top", "pop", "empty"] [[], [1], [2], [], [], []] 输出： [null, null, null, 2, 2, false] 解释： MyStack myStack = new MyStack(); myStack.push(1); myStack.push(2); myStack.top(); // 返回 2 myStack.pop(); // 返回 2 myStack.empty(); // 返回 False   提示： * 1 <= x <= 9 * 最多调用100 次 push、pop、top 和 empty * 每次调用 pop 和 top 都保证栈不为空   进阶：你能否仅用一个队列来实现栈。
225. 用队列实现栈 - 力扣（LeetCode）
https://leetcode.cn/problems/implement-stack-using-queues/description/
225. 用队列实现栈 - 力扣（LeetCode）
 

有效的括号

20. 有效的括号 - 力扣（LeetCode）
20. 有效的括号 - 给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。 有效字符串需满足： 1. 左括号必须用相同类型的右括号闭合。 2. 左括号必须以正确的顺序闭合。 3. 每个右括号都有一个对应的相同类型的左括号。   示例 1： 输入：s = "()" 输出：true 示例 2： 输入：s = "()[]{}" 输出：true 示例 3： 输入：s = "(]" 输出：false 示例 4： 输入：s = "([])" 输出：true   提示： * 1 <= s.length <= 104 * s 仅由括号 '()[]{}' 组成
20. 有效的括号 - 力扣（LeetCode）
https://leetcode.cn/problems/valid-parentheses/description/
20. 有效的括号 - 力扣（LeetCode）
 

删除字符串中的所有相邻重复项

1047. 删除字符串中的所有相邻重复项 - 力扣（LeetCode）
1047. 删除字符串中的所有相邻重复项 - 给出由小写字母组成的字符串 s，重复项删除操作会选择两个相邻且相同的字母，并删除它们。 在 s 上反复执行重复项删除操作，直到无法继续删除。 在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。   示例： 输入："abbaca" 输出："ca" 解释： 例如，在 "abbaca" 中，我们可以删除 "bb" 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 "aaca"，其中又只有 "aa" 可以执行重复项删除操作，所以最后的字符串为 "ca"。   提示： 1. 1 <= s.length <= 105 2. s 仅由小写英文字母组成。
1047. 删除字符串中的所有相邻重复项 - 力扣（LeetCode）
https://leetcode.cn/problems/remove-all-adjacent-duplicates-in-string/description/
1047. 删除字符串中的所有相邻重复项 - 力扣（LeetCode）
 

逆波兰表达式求值

150. 逆波兰表达式求值 - 力扣（LeetCode）
150. 逆波兰表达式求值 - 给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 [https://baike.baidu.com/item/%E9%80%86%E6%B3%A2%E5%85%B0%E5%BC%8F/128437] 表示的算术表达式。 请你计算该表达式。返回一个表示表达式值的整数。 注意： * 有效的算符为 '+'、'-'、'*' 和 '/' 。 * 每个操作数（运算对象）都可以是一个整数或者另一个表达式。 * 两个整数之间的除法总是 向零截断 。 * 表达式中不含除零运算。 * 输入是一个根据逆波兰表示法表示的算术表达式。 * 答案及所有中间计算结果可以用 32 位 整数表示。   示例 1： 输入：tokens = ["2","1","+","3","*"] 输出：9 解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9 示例 2： 输入：tokens = ["4","13","5","/","+"] 输出：6 解释：该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6 示例 3： 输入：tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"] 输出：22 解释：该算式转化为常见的中缀算术表达式为： ((10 * (6 / ((9 + 3) * -11))) + 17) + 5 = ((10 * (6 / (12 * -11))) + 17) + 5 = ((10 * (6 / -132)) + 17) + 5 = ((10 * 0) + 17) + 5 = (0 + 17) + 5 = 17 + 5 = 22   提示： * 1 <= tokens.length <= 104 * tokens[i] 是一个算符（"+"、"-"、"*" 或 "/"），或是在范围 [-200, 200] 内的一个整数   逆波兰表达式： 逆波兰表达式是一种后缀表达式，所谓后缀就是指算符写在后面。 * 平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。 * 该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。 逆波兰表达式主要有以下两个优点： * 去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。 * 适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中
150. 逆波兰表达式求值 - 力扣（LeetCode）
https://leetcode.cn/problems/evaluate-reverse-polish-notation/description/
150. 逆波兰表达式求值 - 力扣（LeetCode）
 

滑动窗口最大值(单调队列)

239. 滑动窗口最大值 - 力扣（LeetCode）
239. 滑动窗口最大值 - 给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。 返回 滑动窗口中的最大值 。   示例 1： 输入：nums = [1,3,-1,-3,5,3,6,7], k = 3 输出：[3,3,5,5,6,7] 解释： 滑动窗口的位置 最大值 --------------- ----- [1 3 -1] -3 5 3 6 7 3 1 [3 -1 -3] 5 3 6 7 3 1 3 [-1 -3 5] 3 6 7 5 1 3 -1 [-3 5 3] 6 7 5 1 3 -1 -3 [5 3 6] 7 6 1 3 -1 -3 5 [3 6 7] 7 示例 2： 输入：nums = [1], k = 1 输出：[1]   提示： * 1 <= nums.length <= 105 * -104 <= nums[i] <= 104 * 1 <= k <= nums.length
239. 滑动窗口最大值 - 力扣（LeetCode）
https://leetcode.cn/problems/sliding-window-maximum/description/
239. 滑动窗口最大值 - 力扣（LeetCode）
 

前 K 个高频元素(优先级队列)

347. 前 K 个高频元素 - 力扣（LeetCode）
347. 前 K 个高频元素 - 给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。   示例 1: 输入: nums = [1,1,1,2,2,3], k = 2 输出: [1,2] 示例 2: 输入: nums = [1], k = 1 输出: [1]   提示： * 1 <= nums.length <= 105 * k 的取值范围是 [1, 数组中不相同的元素的个数] * 题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的   进阶：你所设计算法的时间复杂度 必须 优于 O(n log n) ，其中 n 是数组大小。
347. 前 K 个高频元素 - 力扣（LeetCode）
https://leetcode.cn/problems/top-k-frequent-elements/description/
347. 前 K 个高频元素 - 力扣（LeetCode）
 

树与二叉树专题

二叉树的递归遍历与迭代遍历

144. 二叉树的前序遍历 - 力扣（LeetCode）
144. 二叉树的前序遍历 - 给你二叉树的根节点 root ，返回它节点值的 前序 遍历。   示例 1： 输入：root = [1,null,2,3] 输出：[1,2,3] 解释： [https://assets.leetcode.com/uploads/2024/08/29/screenshot-2024-08-29-202743.png] 示例 2： 输入：root = [1,2,3,4,5,null,8,null,null,6,7,9] 输出：[1,2,4,5,6,7,3,8,9] 解释： [https://assets.leetcode.com/uploads/2024/08/29/tree_2.png] 示例 3： 输入：root = [] 输出：[] 示例 4： 输入：root = [1] 输出：[1]   提示： * 树中节点数目在范围 [0, 100] 内 * -100 <= Node.val <= 100   进阶：递归算法很简单，你可以通过迭代算法完成吗？
144. 二叉树的前序遍历 - 力扣（LeetCode）
https://leetcode.cn/problems/binary-tree-preorder-traversal/submissions/629483093/
144. 二叉树的前序遍历 - 力扣（LeetCode）
94. 二叉树的中序遍历 - 力扣（LeetCode）
94. 二叉树的中序遍历 - 给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。   示例 1： [https://assets.leetcode.com/uploads/2020/09/15/inorder_1.jpg] 输入：root = [1,null,2,3] 输出：[1,3,2] 示例 2： 输入：root = [] 输出：[] 示例 3： 输入：root = [1] 输出：[1]   提示： * 树中节点数目在范围 [0, 100] 内 * -100 <= Node.val <= 100   进阶: 递归算法很简单，你可以通过迭代算法完成吗？
94. 二叉树的中序遍历 - 力扣（LeetCode）
https://leetcode.cn/problems/binary-tree-inorder-traversal/description/
94. 二叉树的中序遍历 - 力扣（LeetCode）
145. 二叉树的后序遍历 - 力扣（LeetCode）
145. 二叉树的后序遍历 - 给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。   示例 1： 输入：root = [1,null,2,3] 输出：[3,2,1] 解释： [https://assets.leetcode.com/uploads/2024/08/29/screenshot-2024-08-29-202743.png] 示例 2： 输入：root = [1,2,3,4,5,null,8,null,null,6,7,9] 输出：[4,6,7,5,2,9,8,3,1] 解释： [https://assets.leetcode.com/uploads/2024/08/29/tree_2.png] 示例 3： 输入：root = [] 输出：[] 示例 4： 输入：root = [1] 输出：[1]   提示： * 树中节点的数目在范围 [0, 100] 内 * -100 <= Node.val <= 100   进阶：递归算法很简单，你可以通过迭代算法完成吗？
145. 二叉树的后序遍历 - 力扣（LeetCode）
https://leetcode.cn/problems/binary-tree-postorder-traversal/description/
145. 二叉树的后序遍历 - 力扣（LeetCode）
 
 
 

二叉树层序遍历

102. 二叉树的层序遍历 - 力扣（LeetCode）
102. 二叉树的层序遍历 - 给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。   示例 1： [https://assets.leetcode.com/uploads/2021/02/19/tree1.jpg] 输入：root = [3,9,20,null,null,15,7] 输出：[[3],[9,20],[15,7]] 示例 2： 输入：root = [1] 输出：[[1]] 示例 3： 输入：root = [] 输出：[]   提示： * 树中节点数目在范围 [0, 2000] 内 * -1000 <= Node.val <= 1000
102. 二叉树的层序遍历 - 力扣（LeetCode）
https://leetcode.cn/problems/binary-tree-level-order-traversal/
102. 二叉树的层序遍历 - 力扣（LeetCode）
 
107. 二叉树的层序遍历 II - 力扣（LeetCode）
107. 二叉树的层序遍历 II - 给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）   示例 1： [https://assets.leetcode.com/uploads/2021/02/19/tree1.jpg] 输入：root = [3,9,20,null,null,15,7] 输出：[[15,7],[9,20],[3]] 示例 2： 输入：root = [1] 输出：[[1]] 示例 3： 输入：root = [] 输出：[]   提示： * 树中节点数目在范围 [0, 2000] 内 * -1000 <= Node.val <= 1000
107. 二叉树的层序遍历 II - 力扣（LeetCode）
https://leetcode.cn/problems/binary-tree-level-order-traversal-ii/description/
107. 二叉树的层序遍历 II - 力扣（LeetCode）
 
199. 二叉树的右视图 - 力扣（LeetCode）
199. 二叉树的右视图 - 给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。   示例 1： 输入：root = [1,2,3,null,5,null,4] 输出：[1,3,4] 解释： [https://assets.leetcode.com/uploads/2024/11/24/tmpd5jn43fs-1.png] 示例 2： 输入：root = [1,2,3,4,null,null,null,5] 输出：[1,3,4,5] 解释： [https://assets.leetcode.com/uploads/2024/11/24/tmpkpe40xeh-1.png] 示例 3： 输入：root = [1,null,3] 输出：[1,3] 示例 4： 输入：root = [] 输出：[]   提示: * 二叉树的节点个数的范围是 [0,100] * -100 <= Node.val <= 100
199. 二叉树的右视图 - 力扣（LeetCode）
https://leetcode.cn/problems/binary-tree-right-side-view/description/
199. 二叉树的右视图 - 力扣（LeetCode）
 
637. 二叉树的层平均值 - 力扣（LeetCode）
637. 二叉树的层平均值 - 给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。   示例 1： [https://assets.leetcode.com/uploads/2021/03/09/avg1-tree.jpg] 输入：root = [3,9,20,null,null,15,7] 输出：[3.00000,14.50000,11.00000] 解释：第 0 层的平均值为 3,第 1 层的平均值为 14.5,第 2 层的平均值为 11 。 因此返回 [3, 14.5, 11] 。 示例 2: [https://assets.leetcode.com/uploads/2021/03/09/avg2-tree.jpg] 输入：root = [3,9,20,15,7] 输出：[3.00000,14.50000,11.00000]   提示： * 树中节点数量在 [1, 104] 范围内 * -231 <= Node.val <= 231 - 1
637. 二叉树的层平均值 - 力扣（LeetCode）
https://leetcode.cn/problems/average-of-levels-in-binary-tree/description/
637. 二叉树的层平均值 - 力扣（LeetCode）
 
429. N 叉树的层序遍历 - 力扣（LeetCode）
429. N 叉树的层序遍历 - 给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。 树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。   示例 1： [https://assets.leetcode.com/uploads/2018/10/12/narytreeexample.png] 输入：root = [1,null,3,2,4,null,5,6] 输出：[[1],[3,2,4],[5,6]] 示例 2： [https://assets.leetcode.com/uploads/2019/11/08/sample_4_964.png] 输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14] 输出：[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]   提示： * 树的高度不会超过 1000 * 树的节点总数在 [0, 104] 之间
429. N 叉树的层序遍历 - 力扣（LeetCode）
https://leetcode.cn/problems/n-ary-tree-level-order-traversal/description/
429. N 叉树的层序遍历 - 力扣（LeetCode）
 
515. 在每个树行中找最大值 - 力扣（LeetCode）
515. 在每个树行中找最大值 - 给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。   示例1： [https://assets.leetcode.com/uploads/2020/08/21/largest_e1.jpg] 输入: root = [1,3,2,5,3,null,9] 输出: [1,3,9] 示例2： 输入: root = [1,2,3] 输出: [1,3]   提示： * 二叉树的节点个数的范围是 [0,104] * -231 <= Node.val <= 231 - 1
515. 在每个树行中找最大值 - 力扣（LeetCode）
https://leetcode.cn/problems/find-largest-value-in-each-tree-row/description/
515. 在每个树行中找最大值 - 力扣（LeetCode）
 
116. 填充每个节点的下一个右侧节点指针 - 力扣（LeetCode）
116. 填充每个节点的下一个右侧节点指针 - 给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下： struct Node { int val; Node *left; Node *right; Node *next; } 填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。 初始状态下，所有 next 指针都被设置为 NULL。   示例 1： [https://assets.leetcode.com/uploads/2019/02/14/116_sample.png] 输入：root = [1,2,3,4,5,6,7] 输出：[1,#,2,3,#,4,5,6,7,#] 解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，'#' 标志着每一层的结束。 示例 2: 输入：root = [] 输出：[]   提示： * 树中节点的数量在 [0, 212 - 1] 范围内 * -1000 <= node.val <= 1000   进阶： * 你只能使用常量级额外空间。 * 使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。
116. 填充每个节点的下一个右侧节点指针 - 力扣（LeetCode）
https://leetcode.cn/problems/populating-next-right-pointers-in-each-node/description/
116. 填充每个节点的下一个右侧节点指针 - 力扣（LeetCode）
117. 填充每个节点的下一个右侧节点指针 II - 力扣（LeetCode）
117. 填充每个节点的下一个右侧节点指针 II - 给定一个二叉树： struct Node { int val; Node *left; Node *right; Node *next; } 填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL 。 初始状态下，所有 next 指针都被设置为 NULL 。   示例 1： [https://assets.leetcode.com/uploads/2019/02/15/117_sample.png] 输入：root = [1,2,3,4,5,null,7] 输出：[1,#,2,3,#,4,5,7,#] 解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化输出按层序遍历顺序（由 next 指针连接），'#' 表示每层的末尾。 示例 2： 输入：root = [] 输出：[]   提示： * 树中的节点数在范围 [0, 6000] 内 * -100 <= Node.val <= 100 进阶： * 你只能使用常量级额外空间。 * 使用递归解题也符合要求，本题中递归程序的隐式栈空间不计入额外空间复杂度。
117. 填充每个节点的下一个右侧节点指针 II - 力扣（LeetCode）
https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii/description/
117. 填充每个节点的下一个右侧节点指针 II - 力扣（LeetCode）
 
104. 二叉树的最大深度 - 力扣（LeetCode）
104. 二叉树的最大深度 - 给定一个二叉树 root ，返回其最大深度。 二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。   示例 1： [https://assets.leetcode.com/uploads/2020/11/26/tmp-tree.jpg]   输入：root = [3,9,20,null,null,15,7] 输出：3 示例 2： 输入：root = [1,null,2] 输出：2   提示： * 树中节点的数量在 [0, 104] 区间内。 * -100 <= Node.val <= 100
104. 二叉树的最大深度 - 力扣（LeetCode）
https://leetcode.cn/problems/maximum-depth-of-binary-tree/description/
104. 二叉树的最大深度 - 力扣（LeetCode）
 
 
111. 二叉树的最小深度 - 力扣（LeetCode）
111. 二叉树的最小深度 - 给定一个二叉树，找出其最小深度。 最小深度是从根节点到最近叶子节点的最短路径上的节点数量。 说明：叶子节点是指没有子节点的节点。   示例 1： [https://assets.leetcode.com/uploads/2020/10/12/ex_depth.jpg] 输入：root = [3,9,20,null,null,15,7] 输出：2 示例 2： 输入：root = [2,null,3,null,4,null,5,null,6] 输出：5   提示： * 树中节点数的范围在 [0, 105] 内 * -1000 <= Node.val <= 1000
111. 二叉树的最小深度 - 力扣（LeetCode）
https://leetcode.cn/problems/minimum-depth-of-binary-tree/description/
111. 二叉树的最小深度 - 力扣（LeetCode）
 

翻转二叉树

226. 翻转二叉树 - 力扣（LeetCode）
226. 翻转二叉树 - 给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。   示例 1： [https://assets.leetcode.com/uploads/2021/03/14/invert1-tree.jpg] 输入：root = [4,2,7,1,3,6,9] 输出：[4,7,2,9,6,3,1] 示例 2： [https://assets.leetcode.com/uploads/2021/03/14/invert2-tree.jpg] 输入：root = [2,1,3] 输出：[2,3,1] 示例 3： 输入：root = [] 输出：[]   提示： * 树中节点数目范围在 [0, 100] 内 * -100 <= Node.val <= 100
226. 翻转二叉树 - 力扣（LeetCode）
https://leetcode.cn/problems/invert-binary-tree/description/
226. 翻转二叉树 - 力扣（LeetCode）
 

对称二叉树

101. 对称二叉树 - 力扣（LeetCode）
101. 对称二叉树 - 给你一个二叉树的根节点 root ， 检查它是否轴对称。   示例 1： [https://pic.leetcode.cn/1698026966-JDYPDU-image.png] 输入：root = [1,2,2,3,4,4,3] 输出：true 示例 2： [https://pic.leetcode.cn/1698027008-nPFLbM-image.png] 输入：root = [1,2,2,null,3,null,3] 输出：false   提示： * 树中节点数目在范围 [1, 1000] 内 * -100 <= Node.val <= 100   进阶：你可以运用递归和迭代两种方法解决这个问题吗？
101. 对称二叉树 - 力扣（LeetCode）
https://leetcode.cn/problems/symmetric-tree/description/
101. 对称二叉树 - 力扣（LeetCode）
 

完全二叉树的节点个数

222. 完全二叉树的节点个数 - 力扣（LeetCode）
222. 完全二叉树的节点个数 - 给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。 完全二叉树 [https://baike.baidu.com/item/%E5%AE%8C%E5%85%A8%E4%BA%8C%E5%8F%89%E6%A0%91/7773232?fr=aladdin] 的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层（从第 0 层开始），则该层包含 1~ 2h 个节点。   示例 1： [https://assets.leetcode.com/uploads/2021/01/14/complete.jpg] 输入：root = [1,2,3,4,5,6] 输出：6 示例 2： 输入：root = [] 输出：0 示例 3： 输入：root = [1] 输出：1   提示： * 树中节点的数目范围是[0, 5 * 104] * 0 <= Node.val <= 5 * 104 * 题目数据保证输入的树是 完全二叉树   进阶：遍历树来统计节点是一种时间复杂度为 O(n) 的简单解决方案。你可以设计一个更快的算法吗？
222. 完全二叉树的节点个数 - 力扣（LeetCode）
https://leetcode.cn/problems/count-complete-tree-nodes/description/
222. 完全二叉树的节点个数 - 力扣（LeetCode）
 

平衡二叉树

110. 平衡二叉树 - 力扣（LeetCode）
110. 平衡二叉树 - 给定一个二叉树，判断它是否是 平衡二叉树     示例 1： [https://assets.leetcode.com/uploads/2020/10/06/balance_1.jpg] 输入：root = [3,9,20,null,null,15,7] 输出：true 示例 2： [https://assets.leetcode.com/uploads/2020/10/06/balance_2.jpg] 输入：root = [1,2,2,3,3,null,null,4,4] 输出：false 示例 3： 输入：root = [] 输出：true   提示： * 树中的节点数在范围 [0, 5000] 内 * -104 <= Node.val <= 104
110. 平衡二叉树 - 力扣（LeetCode）
https://leetcode.cn/problems/balanced-binary-tree/description/
110. 平衡二叉树 - 力扣（LeetCode）
 

二叉树的所有路径

257. 二叉树的所有路径 - 力扣（LeetCode）
257. 二叉树的所有路径 - 给你一个二叉树的根节点 root ，按 任意顺序 ，返回所有从根节点到叶子节点的路径。 叶子节点 是指没有子节点的节点。   示例 1： [https://assets.leetcode.com/uploads/2021/03/12/paths-tree.jpg] 输入：root = [1,2,3,null,5] 输出：["1->2->5","1->3"] 示例 2： 输入：root = [1] 输出：["1"]   提示： * 树中节点的数目在范围 [1, 100] 内 * -100 <= Node.val <= 100
257. 二叉树的所有路径 - 力扣（LeetCode）
https://leetcode.cn/problems/binary-tree-paths/
257. 二叉树的所有路径 - 力扣（LeetCode）
 

左叶子之和

404. 左叶子之和 - 力扣（LeetCode）
404. 左叶子之和 - 给定二叉树的根节点 root ，返回所有左叶子之和。   示例 1： [https://assets.leetcode.com/uploads/2021/04/08/leftsum-tree.jpg] 输入: root = [3,9,20,null,null,15,7] 输出: 24 解释: 在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24 示例 2: 输入: root = [1] 输出: 0   提示: * 节点数在 [1, 1000] 范围内 * -1000 <= Node.val <= 1000
404. 左叶子之和 - 力扣（LeetCode）
https://leetcode.cn/problems/sum-of-left-leaves/description/
404. 左叶子之和 - 力扣（LeetCode）
 

找树左下角的值

513. 找树左下角的值 - 力扣（LeetCode）
513. 找树左下角的值 - 给定一个二叉树的 根节点 root，请找出该二叉树的 最底层 最左边 节点的值。 假设二叉树中至少有一个节点。   示例 1: [https://assets.leetcode.com/uploads/2020/12/14/tree1.jpg] 输入: root = [2,1,3] 输出: 1 示例 2: [https://assets.leetcode.com/uploads/2020/12/14/tree2.jpg] 输入: [1,2,3,4,null,5,6,null,null,7] 输出: 7   提示: * 二叉树的节点个数的范围是 [1,104] * -231 <= Node.val <= 231 - 1
513. 找树左下角的值 - 力扣（LeetCode）
https://leetcode.cn/problems/find-bottom-left-tree-value/description/
513. 找树左下角的值 - 力扣（LeetCode）
 

路径总和

112. 路径总和 - 力扣（LeetCode）
112. 路径总和 - 给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。 叶子节点 是指没有子节点的节点。   示例 1： [https://assets.leetcode.com/uploads/2021/01/18/pathsum1.jpg] 输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22 输出：true 解释：等于目标和的根节点到叶节点路径如上图所示。 示例 2： [https://assets.leetcode.com/uploads/2021/01/18/pathsum2.jpg] 输入：root = [1,2,3], targetSum = 5 输出：false 解释：树中存在两条根节点到叶子节点的路径： (1 --> 2): 和为 3 (1 --> 3): 和为 4 不存在 sum = 5 的根节点到叶子节点的路径。 示例 3： 输入：root = [], targetSum = 0 输出：false 解释：由于树是空的，所以不存在根节点到叶子节点的路径。   提示： * 树中节点的数目在范围 [0, 5000] 内 * -1000 <= Node.val <= 1000 * -1000 <= targetSum <= 1000
112. 路径总和 - 力扣（LeetCode）
https://leetcode.cn/problems/path-sum/description/
112. 路径总和 - 力扣（LeetCode）
 

从中序与后序遍历序列构造二叉树

106. 从中序与后序遍历序列构造二叉树 - 力扣（LeetCode）
106. 从中序与后序遍历序列构造二叉树 - 给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树 。   示例 1: [https://assets.leetcode.com/uploads/2021/02/19/tree.jpg] 输入：inorder = [9,3,15,20,7], postorder = [9,15,7,20,3] 输出：[3,9,20,null,null,15,7] 示例 2: 输入：inorder = [-1], postorder = [-1] 输出：[-1]   提示: * 1 <= inorder.length <= 3000 * postorder.length == inorder.length * -3000 <= inorder[i], postorder[i] <= 3000 * inorder 和 postorder 都由 不同 的值组成 * postorder 中每一个值都在 inorder 中 * inorder 保证是树的中序遍历 * postorder 保证是树的后序遍历
106. 从中序与后序遍历序列构造二叉树 - 力扣（LeetCode）
https://leetcode.cn/problems/construct-binary-tree-from-inorder-and-postorder-traversal/description/
106. 从中序与后序遍历序列构造二叉树 - 力扣（LeetCode）
 

最大二叉树

654. 最大二叉树 - 力扣（LeetCode）
654. 最大二叉树 - 给定一个不重复的整数数组 nums 。 最大二叉树 可以用下面的算法从 nums 递归地构建: 1. 创建一个根节点，其值为 nums 中的最大值。 2. 递归地在最大值 左边 的 子数组前缀上 构建左子树。 3. 递归地在最大值 右边 的 子数组后缀上 构建右子树。 返回 nums 构建的 最大二叉树 。   示例 1： [https://assets.leetcode.com/uploads/2020/12/24/tree1.jpg] 输入：nums = [3,2,1,6,0,5] 输出：[6,3,5,null,2,0,null,null,1] 解释：递归调用如下所示： - [3,2,1,6,0,5] 中的最大值是 6 ，左边部分是 [3,2,1] ，右边部分是 [0,5] 。 - [3,2,1] 中的最大值是 3 ，左边部分是 [] ，右边部分是 [2,1] 。 - 空数组，无子节点。 - [2,1] 中的最大值是 2 ，左边部分是 [] ，右边部分是 [1] 。 - 空数组，无子节点。 - 只有一个元素，所以子节点是一个值为 1 的节点。 - [0,5] 中的最大值是 5 ，左边部分是 [0] ，右边部分是 [] 。 - 只有一个元素，所以子节点是一个值为 0 的节点。 - 空数组，无子节点。 示例 2： [https://assets.leetcode.com/uploads/2020/12/24/tree2.jpg] 输入：nums = [3,2,1] 输出：[3,null,2,null,1]   提示： * 1 <= nums.length <= 1000 * 0 <= nums[i] <= 1000 * nums 中的所有整数 互不相同
654. 最大二叉树 - 力扣（LeetCode）
https://leetcode.cn/problems/maximum-binary-tree/description/
654. 最大二叉树 - 力扣（LeetCode）
 

合并二叉树

617. 合并二叉树 - 力扣（LeetCode）
617. 合并二叉树 - 给你两棵二叉树： root1 和 root2 。 想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。 返回合并后的二叉树。 注意: 合并过程必须从两个树的根节点开始。   示例 1： [https://assets.leetcode.com/uploads/2021/02/05/merge.jpg] 输入：root1 = [1,3,2,5], root2 = [2,1,3,null,4,null,7] 输出：[3,4,5,5,4,null,7] 示例 2： 输入：root1 = [1], root2 = [1,2] 输出：[2,2]   提示： * 两棵树中的节点数目在范围 [0, 2000] 内 * -104 <= Node.val <= 104
617. 合并二叉树 - 力扣（LeetCode）
https://leetcode.cn/problems/merge-two-binary-trees/description/
617. 合并二叉树 - 力扣（LeetCode）
 

二叉搜索树中的搜索

700. 二叉搜索树中的搜索 - 力扣（LeetCode）
700. 二叉搜索树中的搜索 - 给定二叉搜索树（BST）的根节点 root 和一个整数值 val。 你需要在 BST 中找到节点值等于 val 的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 null 。   示例 1: [https://assets.leetcode.com/uploads/2021/01/12/tree1.jpg] 输入：root = [4,2,7,1,3], val = 2 输出：[2,1,3] 示例 2: [https://assets.leetcode.com/uploads/2021/01/12/tree2.jpg] 输入：root = [4,2,7,1,3], val = 5 输出：[]   提示： * 树中节点数在 [1, 5000] 范围内 * 1 <= Node.val <= 107 * root 是二叉搜索树 * 1 <= val <= 107
700. 二叉搜索树中的搜索 - 力扣（LeetCode）
https://leetcode.cn/problems/search-in-a-binary-search-tree/description/
700. 二叉搜索树中的搜索 - 力扣（LeetCode）
 

验证二叉搜索树

98. 验证二叉搜索树 - 力扣（LeetCode）
98. 验证二叉搜索树 - 给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。 有效 二叉搜索树定义如下： * 节点的左子树只包含 小于 当前节点的数。 * 节点的右子树只包含 大于 当前节点的数。 * 所有左子树和右子树自身必须也是二叉搜索树。   示例 1： [https://assets.leetcode.com/uploads/2020/12/01/tree1.jpg] 输入：root = [2,1,3] 输出：true 示例 2： [https://assets.leetcode.com/uploads/2020/12/01/tree2.jpg] 输入：root = [5,1,4,null,null,3,6] 输出：false 解释：根节点的值是 5 ，但是右子节点的值是 4 。   提示： * 树中节点数目范围在[1, 104] 内 * -231 <= Node.val <= 231 - 1
98. 验证二叉搜索树 - 力扣（LeetCode）
https://leetcode.cn/problems/validate-binary-search-tree/description/
98. 验证二叉搜索树 - 力扣（LeetCode）
 

二叉搜索树的最小绝对差

530. 二叉搜索树的最小绝对差 - 力扣（LeetCode）
530. 二叉搜索树的最小绝对差 - 给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值 。 差值是一个正数，其数值等于两值之差的绝对值。   示例 1： [https://assets.leetcode.com/uploads/2021/02/05/bst1.jpg] 输入：root = [4,2,6,1,3] 输出：1 示例 2： [https://assets.leetcode.com/uploads/2021/02/05/bst2.jpg] 输入：root = [1,0,48,null,null,12,49] 输出：1   提示： * 树中节点的数目范围是 [2, 104] * 0 <= Node.val <= 105   注意：本题与 783 https://leetcode-cn.com/problems/minimum-distance-between-bst-nodes/ [https://leetcode-cn.com/problems/minimum-distance-between-bst-nodes/] 相同
530. 二叉搜索树的最小绝对差 - 力扣（LeetCode）
https://leetcode.cn/problems/minimum-absolute-difference-in-bst/description/
530. 二叉搜索树的最小绝对差 - 力扣（LeetCode）
 

二叉搜索树中的众数

501. 二叉搜索树中的众数 - 力扣（LeetCode）
501. 二叉搜索树中的众数 - 给你一个含重复值的二叉搜索树（BST）的根节点 root ，找出并返回 BST 中的所有 众数 [https://baike.baidu.com/item/%E4%BC%97%E6%95%B0/44796]（即，出现频率最高的元素）。 如果树中有不止一个众数，可以按 任意顺序 返回。 假定 BST 满足如下定义： * 结点左子树中所含节点的值 小于等于 当前节点的值 * 结点右子树中所含节点的值 大于等于 当前节点的值 * 左子树和右子树都是二叉搜索树   示例 1： [https://assets.leetcode.com/uploads/2021/03/11/mode-tree.jpg] 输入：root = [1,null,2,2] 输出：[2] 示例 2： 输入：root = [0] 输出：[0]   提示： * 树中节点的数目在范围 [1, 104] 内 * -105 <= Node.val <= 105   进阶：你可以不使用额外的空间吗？（假设由递归产生的隐式调用栈的开销不被计算在内）
501. 二叉搜索树中的众数 - 力扣（LeetCode）
https://leetcode.cn/problems/find-mode-in-binary-search-tree/description/
501. 二叉搜索树中的众数 - 力扣（LeetCode）
 

二叉树的最近公共祖先

236. 二叉树的最近公共祖先 - 力扣（LeetCode）
236. 二叉树的最近公共祖先 - 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。 百度百科 [https://baike.baidu.com/item/%E6%9C%80%E8%BF%91%E5%85%AC%E5%85%B1%E7%A5%96%E5%85%88/8918834?fr=aladdin]中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”   示例 1： [https://assets.leetcode.com/uploads/2018/12/14/binarytree.png] 输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 输出：3 解释：节点 5 和节点 1 的最近公共祖先是节点 3 。 示例 2： [https://assets.leetcode.com/uploads/2018/12/14/binarytree.png] 输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 输出：5 解释：节点 5 和节点 4 的最近公共祖先是节点 5 。因为根据定义最近公共祖先节点可以为节点本身。 示例 3： 输入：root = [1,2], p = 1, q = 2 输出：1   提示： * 树中节点数目在范围 [2, 105] 内。 * -109 <= Node.val <= 109 * 所有 Node.val 互不相同 。 * p != q * p 和 q 均存在于给定的二叉树中。
236. 二叉树的最近公共祖先 - 力扣（LeetCode）
https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree/description/
236. 二叉树的最近公共祖先 - 力扣（LeetCode）
 

二叉搜索树的最近公共祖先

235. 二叉搜索树的最近公共祖先 - 力扣（LeetCode）
235. 二叉搜索树的最近公共祖先 - 给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。 百度百科 [https://baike.baidu.com/item/%E6%9C%80%E8%BF%91%E5%85%AC%E5%85%B1%E7%A5%96%E5%85%88/8918834?fr=aladdin]中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。” 例如，给定如下二叉搜索树:  root = [6,2,8,0,4,7,9,null,null,3,5] [https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/14/binarysearchtree_improved.png]   示例 1: 输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 输出: 6 解释: 节点 2 和节点 8 的最近公共祖先是 6。 示例 2: 输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 输出: 2 解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。   说明: * 所有节点的值都是唯一的。 * p、q 为不同节点且均存在于给定的二叉搜索树中。
235. 二叉搜索树的最近公共祖先 - 力扣（LeetCode）
https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-search-tree/description/
235. 二叉搜索树的最近公共祖先 - 力扣（LeetCode）
 

二叉搜索树中的插入操作

701. 二叉搜索树中的插入操作 - 力扣（LeetCode）
701. 二叉搜索树中的插入操作 - 给定二叉搜索树（BST）的根节点 root 和要插入树中的值 value ，将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。 输入数据 保证 ，新值和原始二叉搜索树中的任意节点值都不同。 注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。 你可以返回 任意有效的结果 。   示例 1： [https://assets.leetcode.com/uploads/2020/10/05/insertbst.jpg] 输入：root = [4,2,7,1,3], val = 5 输出：[4,2,7,1,3,5] 解释：另一个满足题目要求可以通过的树是： [https://assets.leetcode.com/uploads/2020/10/05/bst.jpg] 示例 2： 输入：root = [40,20,60,10,30,50,70], val = 25 输出：[40,20,60,10,30,50,70,null,null,25] 示例 3： 输入：root = [4,2,7,1,3,null,null,null,null,null,null], val = 5 输出：[4,2,7,1,3,5]   提示： * 树中的节点数将在 [0, 104]的范围内。 * -108 <= Node.val <= 108 * 所有值 Node.val 是 独一无二 的。 * -108 <= val <= 108 * 保证 val 在原始BST中不存在。
701. 二叉搜索树中的插入操作 - 力扣（LeetCode）
https://leetcode.cn/problems/insert-into-a-binary-search-tree/description/
701. 二叉搜索树中的插入操作 - 力扣（LeetCode）
 

删除二叉搜索树中的节点

450. 删除二叉搜索树中的节点 - 力扣（LeetCode）
450. 删除二叉搜索树中的节点 - 给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。 一般来说，删除节点可分为两个步骤： 1. 首先找到需要删除的节点； 2. 如果找到了，删除它。   示例 1: [https://assets.leetcode.com/uploads/2020/09/04/del_node_1.jpg] 输入：root = [5,3,6,2,4,null,7], key = 3 输出：[5,4,6,2,null,null,7] 解释：给定需要删除的节点值是 3，所以我们首先找到 3 这个节点，然后删除它。 一个正确的答案是 [5,4,6,2,null,null,7], 如下图所示。 另一个正确答案是 [5,2,6,null,4,null,7]。 [https://assets.leetcode.com/uploads/2020/09/04/del_node_supp.jpg] 示例 2: 输入: root = [5,3,6,2,4,null,7], key = 0 输出: [5,3,6,2,4,null,7] 解释: 二叉树不包含值为 0 的节点 示例 3: 输入: root = [], key = 0 输出: []   提示: * 节点数的范围 [0, 104]. * -105 <= Node.val <= 105 * 节点值唯一 * root 是合法的二叉搜索树 * -105 <= key <= 105   进阶： 要求算法时间复杂度为 O(h)，h 为树的高度。
450. 删除二叉搜索树中的节点 - 力扣（LeetCode）
https://leetcode.cn/problems/delete-node-in-a-bst/description/
450. 删除二叉搜索树中的节点 - 力扣（LeetCode）
 

修剪二叉搜索树

669. 修剪二叉搜索树 - 力扣（LeetCode）
669. 修剪二叉搜索树 - 给你二叉搜索树的根节点 root ，同时给定最小边界low 和最大边界 high。通过修剪二叉搜索树，使得所有节点的值在[low, high]中。修剪树 不应该 改变保留在树中的元素的相对结构 (即，如果没有被移除，原有的父代子代关系都应当保留)。 可以证明，存在 唯一的答案 。 所以结果应当返回修剪好的二叉搜索树的新的根节点。注意，根节点可能会根据给定的边界发生改变。   示例 1： [https://assets.leetcode.com/uploads/2020/09/09/trim1.jpg] 输入：root = [1,0,2], low = 1, high = 2 输出：[1,null,2] 示例 2： [https://assets.leetcode.com/uploads/2020/09/09/trim2.jpg] 输入：root = [3,0,4,null,2,null,null,1], low = 1, high = 3 输出：[3,2,null,1]   提示： * 树中节点数在范围 [1, 104] 内 * 0 <= Node.val <= 104 * 树中每个节点的值都是 唯一 的 * 题目数据保证输入是一棵有效的二叉搜索树 * 0 <= low <= high <= 104
669. 修剪二叉搜索树 - 力扣（LeetCode）
https://leetcode.cn/problems/trim-a-binary-search-tree/description/
669. 修剪二叉搜索树 - 力扣（LeetCode）
 

将有序数组转换为二叉搜索树

108. 将有序数组转换为二叉搜索树 - 力扣（LeetCode）
108. 将有序数组转换为二叉搜索树 - 给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 平衡 二叉搜索树。   示例 1： [https://assets.leetcode.com/uploads/2021/02/18/btree1.jpg] 输入：nums = [-10,-3,0,5,9] 输出：[0,-3,9,-10,null,5] 解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案： [https://assets.leetcode.com/uploads/2021/02/18/btree2.jpg] 示例 2： [https://assets.leetcode.com/uploads/2021/02/18/btree.jpg] 输入：nums = [1,3] 输出：[3,1] 解释：[1,null,3] 和 [3,1] 都是高度平衡二叉搜索树。   提示： * 1 <= nums.length <= 104 * -104 <= nums[i] <= 104 * nums 按 严格递增 顺序排列
108. 将有序数组转换为二叉搜索树 - 力扣（LeetCode）
https://leetcode.cn/problems/convert-sorted-array-to-binary-search-tree/description/
108. 将有序数组转换为二叉搜索树 - 力扣（LeetCode）
 

把二叉搜索树转换为累加树

538. 把二叉搜索树转换为累加树 - 力扣（LeetCode）
538. 把二叉搜索树转换为累加树 - 给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。 提醒一下，二叉搜索树满足下列约束条件： * 节点的左子树仅包含键 小于 节点键的节点。 * 节点的右子树仅包含键 大于 节点键的节点。 * 左右子树也必须是二叉搜索树。 注意：本题和 1038: https://leetcode-cn.com/problems/binary-search-tree-to-greater-sum-tree/ [https://leetcode-cn.com/problems/binary-search-tree-to-greater-sum-tree/] 相同   示例 1： [https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/05/03/tree.png] 输入：[4,1,6,0,2,5,7,null,null,null,3,null,null,null,8] 输出：[30,36,21,36,35,26,15,null,null,null,33,null,null,null,8] 示例 2： 输入：root = [0,null,1] 输出：[1,null,1] 示例 3： 输入：root = [1,0,2] 输出：[3,3,2] 示例 4： 输入：root = [3,2,4,1] 输出：[7,9,4,10]   提示： * 树中的节点数介于 0 和 104 之间。 * 每个节点的值介于 -104 和 104 之间。 * 树中的所有值 互不相同 。 * 给定的树为二叉搜索树。
538. 把二叉搜索树转换为累加树 - 力扣（LeetCode）
https://leetcode.cn/problems/convert-bst-to-greater-tree/description/
538. 把二叉搜索树转换为累加树 - 力扣（LeetCode）
 

回溯专题

组合

77. 组合 - 力扣（LeetCode）
77. 组合 - 给定两个整数 n 和 k，返回范围 [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]]   提示： * 1 <= n <= 20 * 1 <= k <= n
77. 组合 - 力扣（LeetCode）
https://leetcode.cn/problems/combinations/description/
77. 组合 - 力扣（LeetCode）
 

组合总和 III

216. 组合总和 III - 力扣（LeetCode）
216. 组合总和 III - 找出所有相加之和为 n 的 k 个数的组合，且满足下列条件： * 只使用数字1到9 * 每个数字 最多使用一次  返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次，组合可以以任何顺序返回。   示例 1: 输入: k = 3, n = 7 输出: [[1,2,4]] 解释: 1 + 2 + 4 = 7 没有其他符合的组合了。 示例 2: 输入: k = 3, n = 9 输出: [[1,2,6], [1,3,5], [2,3,4]] 解释: 1 + 2 + 6 = 9 1 + 3 + 5 = 9 2 + 3 + 4 = 9 没有其他符合的组合了。 示例 3: 输入: k = 4, n = 1 输出: [] 解释: 不存在有效的组合。 在[1,9]范围内使用4个不同的数字，我们可以得到的最小和是1+2+3+4 = 10，因为10 > 1，没有有效的组合。   提示: * 2 <= k <= 9 * 1 <= n <= 60
216. 组合总和 III - 力扣（LeetCode）
https://leetcode.cn/problems/combination-sum-iii/description/
216. 组合总和 III - 力扣（LeetCode）
 

电话号码的字母组合

17. 电话号码的字母组合 - 力扣（LeetCode）
17. 电话号码的字母组合 - 给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。 给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。 [https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2021/11/09/200px-telephone-keypad2svg.png]   示例 1： 输入：digits = "23" 输出：["ad","ae","af","bd","be","bf","cd","ce","cf"] 示例 2： 输入：digits = "" 输出：[] 示例 3： 输入：digits = "2" 输出：["a","b","c"]   提示： * 0 <= digits.length <= 4 * digits[i] 是范围 ['2', '9'] 的一个数字。
17. 电话号码的字母组合 - 力扣（LeetCode）
https://leetcode.cn/problems/letter-combinations-of-a-phone-number/description/
17. 电话号码的字母组合 - 力扣（LeetCode）
 

组合总和

39. 组合总和 - 力扣（LeetCode）
39. 组合总和 - 给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。 candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。  对于给定的输入，保证和为 target 的不同组合数少于 150 个。   示例 1： 输入：candidates = [2,3,6,7], target = 7 输出：[[2,2,3],[7]] 解释： 2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。 7 也是一个候选， 7 = 7 。 仅有这两种组合。 示例 2： 输入: candidates = [2,3,5], target = 8 输出: [[2,2,2,2],[2,3,3],[3,5]] 示例 3： 输入: candidates = [2], target = 1 输出: []   提示： * 1 <= candidates.length <= 30 * 2 <= candidates[i] <= 40 * candidates 的所有元素 互不相同 * 1 <= target <= 40
39. 组合总和 - 力扣（LeetCode）
https://leetcode.cn/problems/combination-sum/description/
39. 组合总和 - 力扣（LeetCode）
 

组合总和 II

40. 组合总和 II - 力扣（LeetCode）
40. 组合总和 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
40. 组合总和 II - 力扣（LeetCode）
https://leetcode.cn/problems/combination-sum-ii/description/
40. 组合总和 II - 力扣（LeetCode）
 

分割回文串

131. 分割回文串 - 力扣（LeetCode）
131. 分割回文串 - 给你一个字符串 s，请你将 s 分割成一些 子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。   示例 1： 输入：s = "aab" 输出：[["a","a","b"],["aa","b"]] 示例 2： 输入：s = "a" 输出：[["a"]]   提示： * 1 <= s.length <= 16 * s 仅由小写英文字母组成
131. 分割回文串 - 力扣（LeetCode）
https://leetcode.cn/problems/palindrome-partitioning/description/
131. 分割回文串 - 力扣（LeetCode）
 

复原 IP 地址

93. 复原 IP 地址 - 力扣（LeetCode）
93. 复原 IP 地址 - 有效 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 '.' 分隔。 * 例如："0.1.2.201" 和 "192.168.1.1" 是 有效 IP 地址，但是 "0.011.255.245"、"192.168.1.312" 和 "192.168@1.1" 是 无效 IP 地址。 给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址，这些地址可以通过在 s 中插入 '.' 来形成。你 不能 重新排序或删除 s 中的任何数字。你可以按 任何 顺序返回答案。   示例 1： 输入：s = "25525511135" 输出：["255.255.11.135","255.255.111.35"] 示例 2： 输入：s = "0000" 输出：["0.0.0.0"] 示例 3： 输入：s = "101023" 输出：["1.0.10.23","1.0.102.3","10.1.0.23","10.10.2.3","101.0.2.3"]   提示： * 1 <= s.length <= 20 * s 仅由数字组成
93. 复原 IP 地址 - 力扣（LeetCode）
https://leetcode.cn/problems/restore-ip-addresses/description/
93. 复原 IP 地址 - 力扣（LeetCode）
 

子集

78. 子集 - 力扣（LeetCode）
78. 子集 - 给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。 解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。   示例 1： 输入：nums = [1,2,3] 输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]] 示例 2： 输入：nums = [0] 输出：[[],[0]]   提示： * 1 <= nums.length <= 10 * -10 <= nums[i] <= 10 * nums 中的所有元素 互不相同
78. 子集 - 力扣（LeetCode）
https://leetcode.cn/problems/subsets/description/
78. 子集 - 力扣（LeetCode）
 

子集 II

90. 子集 II - 力扣（LeetCode）
90. 子集 II - 给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的 子集（幂集）。 解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。   示例 1： 输入：nums = [1,2,2] 输出：[[],[1],[1,2],[1,2,2],[2],[2,2]] 示例 2： 输入：nums = [0] 输出：[[],[0]]   提示： * 1 <= nums.length <= 10 * -10 <= nums[i] <= 10
90. 子集 II - 力扣（LeetCode）
https://leetcode.cn/problems/subsets-ii/description/
90. 子集 II - 力扣（LeetCode）
 

非递减子序列

491. 非递减子序列 - 力扣（LeetCode）
491. 非递减子序列 - 给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。 数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。   示例 1： 输入：nums = [4,6,7,7] 输出：[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]] 示例 2： 输入：nums = [4,4,3,2,1] 输出：[[4,4]]   提示： * 1 <= nums.length <= 15 * -100 <= nums[i] <= 100
491. 非递减子序列 - 力扣（LeetCode）
https://leetcode.cn/problems/non-decreasing-subsequences/description/
491. 非递减子序列 - 力扣（LeetCode）
 

全排列

46. 全排列 - 力扣（LeetCode）
46. 全排列 - 给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。   示例 1： 输入：nums = [1,2,3] 输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]] 示例 2： 输入：nums = [0,1] 输出：[[0,1],[1,0]] 示例 3： 输入：nums = [1] 输出：[[1]]   提示： * 1 <= nums.length <= 6 * -10 <= nums[i] <= 10 * nums 中的所有整数 互不相同
46. 全排列 - 力扣（LeetCode）
https://leetcode.cn/problems/permutations/description/
46. 全排列 - 力扣（LeetCode）
 

全排列 II

47. 全排列 II - 力扣（LeetCode）
47. 全排列 II - 给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。   示例 1： 输入：nums = [1,1,2] 输出： [[1,1,2], [1,2,1], [2,1,1]] 示例 2： 输入：nums = [1,2,3] 输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]   提示： * 1 <= nums.length <= 8 * -10 <= nums[i] <= 10
47. 全排列 II - 力扣（LeetCode）
https://leetcode.cn/problems/permutations-ii/description/
47. 全排列 II - 力扣（LeetCode）
 

N皇后问题

51. N 皇后 - 力扣（LeetCode）
51. N 皇后 - 按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。 n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。 给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。 每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。   示例 1： [https://assets.leetcode.com/uploads/2020/11/13/queens.jpg] 输入：n = 4 输出：[[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]] 解释：如上图所示，4 皇后问题存在两个不同的解法。 示例 2： 输入：n = 1 输出：[["Q"]]   提示： * 1 <= n <= 9
51. N 皇后 - 力扣（LeetCode）
https://leetcode.cn/problems/n-queens/description/
51. N 皇后 - 力扣（LeetCode）
 

解数独

37. 解数独 - 力扣（LeetCode）
37. 解数独 - 编写一个程序，通过填充空格来解决数独问题。 数独的解法需 遵循如下规则： 1. 数字 1-9 在每一行只能出现一次。 2. 数字 1-9 在每一列只能出现一次。 3. 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图） 数独部分空格内已填入了数字，空白格用 '.' 表示。   示例 1： [https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2021/04/12/250px-sudoku-by-l2g-20050714svg.png] 输入：board = [["5","3",".",".","7",".",".",".","."],["6",".",".","1","9","5",".",".","."],[".","9","8",".",".",".",".","6","."],["8",".",".",".","6",".",".",".","3"],["4",".",".","8",".","3",".",".","1"],["7",".",".",".","2",".",".",".","6"],[".","6",".",".",".",".","2","8","."],[".",".",".","4","1","9",".",".","5"],[".",".",".",".","8",".",".","7","9"]] 输出：[["5","3","4","6","7","8","9","1","2"],["6","7","2","1","9","5","3","4","8"],["1","9","8","3","4","2","5","6","7"],["8","5","9","7","6","1","4","2","3"],["4","2","6","8","5","3","7","9","1"],["7","1","3","9","2","4","8","5","6"],["9","6","1","5","3","7","2","8","4"],["2","8","7","4","1","9","6","3","5"],["3","4","5","2","8","6","1","7","9"]] 解释：输入的数独如上图所示，唯一有效的解决方案如下所示： [ https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2021/04/12/250px-sudoku-by-l2g-20050714_solutionsvg.png]   提示： * board.length == 9 * board[i].length == 9 * board[i][j] 是一位数字或者 '.' * 题目数据 保证 输入数独仅有一个解
37. 解数独 - 力扣（LeetCode）
https://leetcode.cn/problems/sudoku-solver/description/
37. 解数独 - 力扣（LeetCode）
 

贪心算法

分发饼干

455. 分发饼干 - 力扣（LeetCode）
455. 分发饼干 - 假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。 对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是满足尽可能多的孩子，并输出这个最大数值。   示例 1: 输入: g = [1,2,3], s = [1,1] 输出: 1 解释: 你有三个孩子和两块小饼干，3 个孩子的胃口值分别是：1,2,3。 虽然你有两块小饼干，由于他们的尺寸都是 1，你只能让胃口值是 1 的孩子满足。 所以你应该输出 1。 示例 2: 输入: g = [1,2], s = [1,2,3] 输出: 2 解释: 你有两个孩子和三块小饼干，2 个孩子的胃口值分别是 1,2。 你拥有的饼干数量和尺寸都足以让所有孩子满足。 所以你应该输出 2。   提示： * 1 <= g.length <= 3 * 104 * 0 <= s.length <= 3 * 104 * 1 <= g[i], s[j] <= 231 - 1   注意：本题与 2410. 运动员和训练师的最大匹配数 [https://leetcode.cn/problems/maximum-matching-of-players-with-trainers/] 题相同。
455. 分发饼干 - 力扣（LeetCode）
https://leetcode.cn/problems/assign-cookies/description/
455. 分发饼干 - 力扣（LeetCode）
 

摆动序列

376. 摆动序列 - 力扣（LeetCode）
376. 摆动序列 - 如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为 摆动序列 。第一个差（如果存在的话）可能是正数或负数。仅有一个元素或者含两个不等元素的序列也视作摆动序列。 * 例如， [1, 7, 4, 9, 2, 5] 是一个 摆动序列 ，因为差值 (6, -3, 5, -7, 3) 是正负交替出现的。 * 相反，[1, 4, 7, 2, 5] 和 [1, 7, 4, 5, 5] 不是摆动序列，第一个序列是因为它的前两个差值都是正数，第二个序列是因为它的最后一个差值为零。 子序列 可以通过从原始序列中删除一些（也可以不删除）元素来获得，剩下的元素保持其原始顺序。 给你一个整数数组 nums ，返回 nums 中作为 摆动序列 的 最长子序列的长度 。   示例 1： 输入：nums = [1,7,4,9,2,5] 输出：6 解释：整个序列均为摆动序列，各元素之间的差值为 (6, -3, 5, -7, 3) 。 示例 2： 输入：nums = [1,17,5,10,13,15,10,5,16,8] 输出：7 解释：这个序列包含几个长度为 7 摆动序列。 其中一个是 [1, 17, 10, 13, 10, 16, 8] ，各元素之间的差值为 (16, -7, 3, -3, 6, -8) 。 示例 3： 输入：nums = [1,2,3,4,5,6,7,8,9] 输出：2   提示： * 1 <= nums.length <= 1000 * 0 <= nums[i] <= 1000   进阶：你能否用 O(n) 时间复杂度完成此题?
376. 摆动序列 - 力扣（LeetCode）
https://leetcode.cn/problems/wiggle-subsequence/description/
376. 摆动序列 - 力扣（LeetCode）
 

最大子数组和

53. 最大子数组和 - 力扣（LeetCode）
53. 最大子数组和 - 给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。 子数组 是数组中的一个连续部分。   示例 1： 输入：nums = [-2,1,-3,4,-1,2,1,-5,4] 输出：6 解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。 示例 2： 输入：nums = [1] 输出：1 示例 3： 输入：nums = [5,4,-1,7,8] 输出：23   提示： * 1 <= nums.length <= 105 * -104 <= nums[i] <= 104   进阶：如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的 分治法 求解。
53. 最大子数组和 - 力扣（LeetCode）
https://leetcode.cn/problems/maximum-subarray/description/
53. 最大子数组和 - 力扣（LeetCode）
 

买卖股票的最佳时机 II

122. 买卖股票的最佳时机 II - 力扣（LeetCode）
122. 买卖股票的最佳时机 II - 给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。 在每一天，你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。 返回 你能获得的 最大 利润 。   示例 1： 输入：prices = [7,1,5,3,6,4] 输出：7 解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。 随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3。 最大总利润为 4 + 3 = 7 。 示例 2： 输入：prices = [1,2,3,4,5] 输出：4 解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。 最大总利润为 4 。 示例 3： 输入：prices = [7,6,4,3,1] 输出：0 解释：在这种情况下, 交易无法获得正利润，所以不参与交易可以获得最大利润，最大利润为 0。   提示： * 1 <= prices.length <= 3 * 104 * 0 <= prices[i] <= 104
122. 买卖股票的最佳时机 II - 力扣（LeetCode）
https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii/description/
122. 买卖股票的最佳时机 II - 力扣（LeetCode）
 

跳跃游戏

55. 跳跃游戏 - 力扣（LeetCode）
55. 跳跃游戏 - 给你一个非负整数数组 nums ，你最初位于数组的 第一个下标 。数组中的每个元素代表你在该位置可以跳跃的最大长度。 判断你是否能够到达最后一个下标，如果可以，返回 true ；否则，返回 false 。   示例 1： 输入：nums = [2,3,1,1,4] 输出：true 解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。 示例 2： 输入：nums = [3,2,1,0,4] 输出：false 解释：无论怎样，总会到达下标为 3 的位置。但该下标的最大跳跃长度是 0 ， 所以永远不可能到达最后一个下标。   提示： * 1 <= nums.length <= 104 * 0 <= nums[i] <= 105
55. 跳跃游戏 - 力扣（LeetCode）
https://leetcode.cn/problems/jump-game/description/
55. 跳跃游戏 - 力扣（LeetCode）
 

跳跃游戏 II

45. 跳跃游戏 II - 力扣（LeetCode）
45. 跳跃游戏 II - 给定一个长度为 n 的 0 索引整数数组 nums。初始位置为 nums[0]。 每个元素 nums[i] 表示从索引 i 向后跳转的最大长度。换句话说，如果你在 nums[i] 处，你可以跳转到任意 nums[i + j] 处: * 0 <= j <= nums[i]  * i + j < n 返回到达 nums[n - 1] 的最小跳跃次数。生成的测试用例可以到达 nums[n - 1]。   示例 1: 输入: nums = [2,3,1,1,4] 输出: 2 解释: 跳到最后一个位置的最小跳跃数是 2。   从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。 示例 2: 输入: nums = [2,3,0,1,4] 输出: 2   提示: * 1 <= nums.length <= 104 * 0 <= nums[i] <= 1000 * 题目保证可以到达 nums[n-1]
45. 跳跃游戏 II - 力扣（LeetCode）
https://leetcode.cn/problems/jump-game-ii/description/
45. 跳跃游戏 II - 力扣（LeetCode）
 

K 次取反后最大化的数组和

1005. K 次取反后最大化的数组和 - 力扣（LeetCode）
1005. K 次取反后最大化的数组和 - 给你一个整数数组 nums 和一个整数 k ，按以下方法修改该数组： * 选择某个下标 i 并将 nums[i] 替换为 -nums[i] 。 重复这个过程恰好 k 次。可以多次选择同一个下标 i 。 以这种方式修改数组后，返回数组 可能的最大和 。   示例 1： 输入：nums = [4,2,3], k = 1 输出：5 解释：选择下标 1 ，nums 变为 [4,-2,3] 。 示例 2： 输入：nums = [3,-1,0,2], k = 3 输出：6 解释：选择下标 (1, 2, 2) ，nums 变为 [3,1,0,2] 。 示例 3： 输入：nums = [2,-3,-1,5,-4], k = 2 输出：13 解释：选择下标 (1, 4) ，nums 变为 [2,3,-1,5,4] 。   提示： * 1 <= nums.length <= 104 * -100 <= nums[i] <= 100 * 1 <= k <= 104
1005. K 次取反后最大化的数组和 - 力扣（LeetCode）
https://leetcode.cn/problems/maximize-sum-of-array-after-k-negations/description/
1005. K 次取反后最大化的数组和 - 力扣（LeetCode）
 

加油站

134. 加油站 - 力扣（LeetCode）
134. 加油站 - 在一条环路上有 n 个加油站，其中第 i 个加油站有汽油 gas[i] 升。 你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发，开始时油箱为空。 给定两个整数数组 gas 和 cost ，如果你可以按顺序绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1 。如果存在解，则 保证 它是 唯一 的。   示例 1: 输入: gas = [1,2,3,4,5], cost = [3,4,5,1,2] 输出: 3 解释: 从 3 号加油站(索引为 3 处)出发，可获得 4 升汽油。此时油箱有 = 0 + 4 = 4 升汽油 开往 4 号加油站，此时油箱有 4 - 1 + 5 = 8 升汽油 开往 0 号加油站，此时油箱有 8 - 2 + 1 = 7 升汽油 开往 1 号加油站，此时油箱有 7 - 3 + 2 = 6 升汽油 开往 2 号加油站，此时油箱有 6 - 4 + 3 = 5 升汽油 开往 3 号加油站，你需要消耗 5 升汽油，正好足够你返回到 3 号加油站。 因此，3 可为起始索引。 示例 2: 输入: gas = [2,3,4], cost = [3,4,3] 输出: -1 解释: 你不能从 0 号或 1 号加油站出发，因为没有足够的汽油可以让你行驶到下一个加油站。 我们从 2 号加油站出发，可以获得 4 升汽油。 此时油箱有 = 0 + 4 = 4 升汽油 开往 0 号加油站，此时油箱有 4 - 3 + 2 = 3 升汽油 开往 1 号加油站，此时油箱有 3 - 3 + 3 = 3 升汽油 你无法返回 2 号加油站，因为返程需要消耗 4 升汽油，但是你的油箱只有 3 升汽油。 因此，无论怎样，你都不可能绕环路行驶一周。   提示: * gas.length == n * cost.length == n * 1 <= n <= 105 * 0 <= gas[i], cost[i] <= 104
134. 加油站 - 力扣（LeetCode）
https://leetcode.cn/problems/gas-station/
134. 加油站 - 力扣（LeetCode）
 

分发糖果

135. 分发糖果 - 力扣（LeetCode）
135. 分发糖果 - n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的评分。 你需要按照以下要求，给这些孩子分发糖果： * 每个孩子至少分配到 1 个糖果。 * 相邻两个孩子评分更高的孩子会获得更多的糖果。 请你给每个孩子分发糖果，计算并返回需要准备的 最少糖果数目 。   示例 1： 输入：ratings = [1,0,2] 输出：5 解释：你可以分别给第一个、第二个、第三个孩子分发 2、1、2 颗糖果。 示例 2： 输入：ratings = [1,2,2] 输出：4 解释：你可以分别给第一个、第二个、第三个孩子分发 1、2、1 颗糖果。 第三个孩子只得到 1 颗糖果，这满足题面中的两个条件。   提示： * n == ratings.length * 1 <= n <= 2 * 104 * 0 <= ratings[i] <= 2 * 104
135. 分发糖果 - 力扣（LeetCode）
https://leetcode.cn/problems/candy/description/
135. 分发糖果 - 力扣（LeetCode）
 

柠檬水找零

860. 柠檬水找零 - 力扣（LeetCode）
860. 柠檬水找零 - 在柠檬水摊上，每一杯柠檬水的售价为 5 美元。顾客排队购买你的产品，（按账单 bills 支付的顺序）一次购买一杯。 每位顾客只买一杯柠檬水，然后向你付 5 美元、10 美元或 20 美元。你必须给每个顾客正确找零，也就是说净交易是每位顾客向你支付 5 美元。 注意，一开始你手头没有任何零钱。 给你一个整数数组 bills ，其中 bills[i] 是第 i 位顾客付的账。如果你能给每位顾客正确找零，返回 true ，否则返回 false 。   示例 1： 输入：bills = [5,5,5,10,20] 输出：true 解释： 前 3 位顾客那里，我们按顺序收取 3 张 5 美元的钞票。 第 4 位顾客那里，我们收取一张 10 美元的钞票，并返还 5 美元。 第 5 位顾客那里，我们找还一张 10 美元的钞票和一张 5 美元的钞票。 由于所有客户都得到了正确的找零，所以我们输出 true。 示例 2： 输入：bills = [5,5,10,10,20] 输出：false 解释： 前 2 位顾客那里，我们按顺序收取 2 张 5 美元的钞票。 对于接下来的 2 位顾客，我们收取一张 10 美元的钞票，然后返还 5 美元。 对于最后一位顾客，我们无法退回 15 美元，因为我们现在只有两张 10 美元的钞票。 由于不是每位顾客都得到了正确的找零，所以答案是 false。   提示： * 1 <= bills.length <= 105 * bills[i] 不是 5 就是 10 或是 20
860. 柠檬水找零 - 力扣（LeetCode）
https://leetcode.cn/problems/lemonade-change/
860. 柠檬水找零 - 力扣（LeetCode）
 

根据身高重建队列

406. 根据身高重建队列 - 力扣（LeetCode）
406. 根据身高重建队列 - 假设有打乱顺序的一群人站成一个队列，数组 people 表示队列中一些人的属性（不一定按顺序）。每个 people[i] = [hi, ki] 表示第 i 个人的身高为 hi ，前面 正好 有 ki 个身高大于或等于 hi 的人。 请你重新构造并返回输入数组 people 所表示的队列。返回的队列应该格式化为数组 queue ，其中 queue[j] = [hj, kj] 是队列中第 j 个人的属性（queue[0] 是排在队列前面的人）。   示例 1： 输入：people = [[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]] 输出：[[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]] 解释： 编号为 0 的人身高为 5 ，没有身高更高或者相同的人排在他前面。 编号为 1 的人身高为 7 ，没有身高更高或者相同的人排在他前面。 编号为 2 的人身高为 5 ，有 2 个身高更高或者相同的人排在他前面，即编号为 0 和 1 的人。 编号为 3 的人身高为 6 ，有 1 个身高更高或者相同的人排在他前面，即编号为 1 的人。 编号为 4 的人身高为 4 ，有 4 个身高更高或者相同的人排在他前面，即编号为 0、1、2、3 的人。 编号为 5 的人身高为 7 ，有 1 个身高更高或者相同的人排在他前面，即编号为 1 的人。 因此 [[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]] 是重新构造后的队列。 示例 2： 输入：people = [[6,0],[5,0],[4,0],[3,2],[2,2],[1,4]] 输出：[[4,0],[5,0],[2,2],[3,2],[1,4],[6,0]]   提示： * 1 <= people.length <= 2000 * 0 <= hi <= 106 * 0 <= ki < people.length * 题目数据确保队列可以被重建
406. 根据身高重建队列 - 力扣（LeetCode）
https://leetcode.cn/problems/queue-reconstruction-by-height/description/
406. 根据身高重建队列 - 力扣（LeetCode）
 

用最少数量的箭引爆气球

452. 用最少数量的箭引爆气球 - 力扣（LeetCode）
452. 用最少数量的箭引爆气球 - 有一些球形气球贴在一堵用 XY 平面表示的墙面上。墙面上的气球记录在整数数组 points ，其中points[i] = [xstart, xend] 表示水平直径在 xstart 和 xend之间的气球。你不知道气球的确切 y 坐标。 一支弓箭可以沿着 x 轴从不同点 完全垂直 地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend， 且满足  xstart ≤ x ≤ xend，则该气球会被 引爆 。可以射出的弓箭的数量 没有限制 。 弓箭一旦被射出之后，可以无限地前进。 给你一个数组 points ，返回引爆所有气球所必须射出的 最小 弓箭数 。   示例 1： 输入：points = [[10,16],[2,8],[1,6],[7,12]] 输出：2 解释：气球可以用2支箭来爆破: -在x = 6处射出箭，击破气球[2,8]和[1,6]。 -在x = 11处发射箭，击破气球[10,16]和[7,12]。 示例 2： 输入：points = [[1,2],[3,4],[5,6],[7,8]] 输出：4 解释：每个气球需要射出一支箭，总共需要4支箭。 示例 3： 输入：points = [[1,2],[2,3],[3,4],[4,5]] 输出：2 解释：气球可以用2支箭来爆破: - 在x = 2处发射箭，击破气球[1,2]和[2,3]。 - 在x = 4处射出箭，击破气球[3,4]和[4,5]。   提示: * 1 <= points.length <= 105 * points[i].length == 2 * -231 <= xstart < xend <= 231 - 1
452. 用最少数量的箭引爆气球 - 力扣（LeetCode）
https://leetcode.cn/problems/minimum-number-of-arrows-to-burst-balloons/description/
452. 用最少数量的箭引爆气球 - 力扣（LeetCode）
 

无重叠区间

435. 无重叠区间 - 力扣（LeetCode）
435. 无重叠区间 - 给定一个区间的集合 intervals ，其中 intervals[i] = [starti, endi] 。返回 需要移除区间的最小数量，使剩余区间互不重叠 。 注意 只在一点上接触的区间是 不重叠的。例如 [1, 2] 和 [2, 3] 是不重叠的。   示例 1: 输入: intervals = [[1,2],[2,3],[3,4],[1,3]] 输出: 1 解释: 移除 [1,3] 后，剩下的区间没有重叠。 示例 2: 输入: intervals = [ [1,2], [1,2], [1,2] ] 输出: 2 解释: 你需要移除两个 [1,2] 来使剩下的区间没有重叠。 示例 3: 输入: intervals = [ [1,2], [2,3] ] 输出: 0 解释: 你不需要移除任何区间，因为它们已经是无重叠的了。   提示: * 1 <= intervals.length <= 105 * intervals[i].length == 2 * -5 * 104 <= starti < endi <= 5 * 104
435. 无重叠区间 - 力扣（LeetCode）
https://leetcode.cn/problems/non-overlapping-intervals/description/
435. 无重叠区间 - 力扣（LeetCode）
 

划分字母区间

763. 划分字母区间 - 力扣（LeetCode）
763. 划分字母区间 - 给你一个字符串 s 。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。例如，字符串 "ababcc" 能够被分为 ["abab", "cc"]，但类似 ["aba", "bcc"] 或 ["ab", "ab", "cc"] 的划分是非法的。 注意，划分结果需要满足：将所有划分结果按顺序连接，得到的字符串仍然是 s 。 返回一个表示每个字符串片段的长度的列表。   示例 1： 输入：s = "ababcbacadefegdehijhklij" 输出：[9,7,8] 解释： 划分结果为 "ababcbaca"、"defegde"、"hijhklij" 。 每个字母最多出现在一个片段中。 像 "ababcbacadefegde", "hijhklij" 这样的划分是错误的，因为划分的片段数较少。 示例 2： 输入：s = "eccbbbbdec" 输出：[10]   提示： * 1 <= s.length <= 500 * s 仅由小写英文字母组成
763. 划分字母区间 - 力扣（LeetCode）
https://leetcode.cn/problems/partition-labels/description/
763. 划分字母区间 - 力扣（LeetCode）
 

合并区间

56. 合并区间 - 力扣（LeetCode）
56. 合并区间 - 以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。   示例 1： 输入：intervals = [[1,3],[2,6],[8,10],[15,18]] 输出：[[1,6],[8,10],[15,18]] 解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6]. 示例 2： 输入：intervals = [[1,4],[4,5]] 输出：[[1,5]] 解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。   提示： * 1 <= intervals.length <= 104 * intervals[i].length == 2 * 0 <= starti <= endi <= 104
56. 合并区间 - 力扣（LeetCode）
https://leetcode.cn/problems/merge-intervals/description/
56. 合并区间 - 力扣（LeetCode）
 

单调递增的数字

738. 单调递增的数字 - 力扣（LeetCode）
738. 单调递增的数字 - 当且仅当每个相邻位数上的数字 x 和 y 满足 x <= y 时，我们称这个整数是单调递增的。 给定一个整数 n ，返回 小于或等于 n 的最大数字，且数字呈 单调递增 。   示例 1: 输入: n = 10 输出: 9 示例 2: 输入: n = 1234 输出: 1234 示例 3: 输入: n = 332 输出: 299   提示: * 0 <= n <= 109
738. 单调递增的数字 - 力扣（LeetCode）
https://leetcode.cn/problems/monotone-increasing-digits/description/
738. 单调递增的数字 - 力扣（LeetCode）
 

监控二叉树

968. 监控二叉树 - 力扣（LeetCode）
968. 监控二叉树 - 给定一个二叉树，我们在树的节点上安装摄像头。 节点上的每个摄影头都可以监视其父对象、自身及其直接子对象。 计算监控树的所有节点所需的最小摄像头数量。   示例 1： [https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/29/bst_cameras_01.png] 输入：[0,0,null,0,0] 输出：1 解释：如图所示，一台摄像头足以监控所有节点。 示例 2： [https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/12/29/bst_cameras_02.png] 输入：[0,0,null,0,null,0,null,null,0] 输出：2 解释：需要至少两个摄像头来监视树的所有节点。 上图显示了摄像头放置的有效位置之一。 提示： 1. 给定树的节点数的范围是 [1, 1000]。 2. 每个节点的值都是 0。
968. 监控二叉树 - 力扣（LeetCode）
https://leetcode.cn/problems/binary-tree-cameras/description/
968. 监控二叉树 - 力扣（LeetCode）
 

动态规划

斐波那契数

509. 斐波那契数 - 力扣（LeetCode）
509. 斐波那契数 - 斐波那契数 （通常用 F(n) 表示）形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是： F(0) = 0，F(1) = 1 F(n) = F(n - 1) + F(n - 2)，其中 n > 1 给定 n ，请计算 F(n) 。   示例 1： 输入：n = 2 输出：1 解释：F(2) = F(1) + F(0) = 1 + 0 = 1 示例 2： 输入：n = 3 输出：2 解释：F(3) = F(2) + F(1) = 1 + 1 = 2 示例 3： 输入：n = 4 输出：3 解释：F(4) = F(3) + F(2) = 2 + 1 = 3   提示： * 0 <= n <= 30
509. 斐波那契数 - 力扣（LeetCode）
https://leetcode.cn/problems/fibonacci-number/description/
509. 斐波那契数 - 力扣（LeetCode）
 

爬楼梯

70. 爬楼梯 - 力扣（LeetCode）
70. 爬楼梯 - 假设你正在爬楼梯。需要 n 阶你才能到达楼顶。 每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？   示例 1： 输入：n = 2 输出：2 解释：有两种方法可以爬到楼顶。 1. 1 阶 + 1 阶 2. 2 阶 示例 2： 输入：n = 3 输出：3 解释：有三种方法可以爬到楼顶。 1. 1 阶 + 1 阶 + 1 阶 2. 1 阶 + 2 阶 3. 2 阶 + 1 阶   提示： * 1 <= n <= 45
70. 爬楼梯 - 力扣（LeetCode）
https://leetcode.cn/problems/climbing-stairs/description/
70. 爬楼梯 - 力扣（LeetCode）
 

使用最小花费爬楼梯

746. 使用最小花费爬楼梯 - 力扣（LeetCode）
746. 使用最小花费爬楼梯 - 给你一个整数数组 cost ，其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。 你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。 请你计算并返回达到楼梯顶部的最低花费。   示例 1： 输入：cost = [10,15,20] 输出：15 解释：你将从下标为 1 的台阶开始。 - 支付 15 ，向上爬两个台阶，到达楼梯顶部。 总花费为 15 。 示例 2： 输入：cost = [1,100,1,1,1,100,1,1,100,1] 输出：6 解释：你将从下标为 0 的台阶开始。 - 支付 1 ，向上爬两个台阶，到达下标为 2 的台阶。 - 支付 1 ，向上爬两个台阶，到达下标为 4 的台阶。 - 支付 1 ，向上爬两个台阶，到达下标为 6 的台阶。 - 支付 1 ，向上爬一个台阶，到达下标为 7 的台阶。 - 支付 1 ，向上爬两个台阶，到达下标为 9 的台阶。 - 支付 1 ，向上爬一个台阶，到达楼梯顶部。 总花费为 6 。   提示： * 2 <= cost.length <= 1000 * 0 <= cost[i] <= 999
746. 使用最小花费爬楼梯 - 力扣（LeetCode）
https://leetcode.cn/problems/min-cost-climbing-stairs/description/
746. 使用最小花费爬楼梯 - 力扣（LeetCode）
 

不同路径

62. 不同路径 - 力扣（LeetCode）
62. 不同路径 - 一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。 机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。 问总共有多少条不同的路径？   示例 1： [https://pic.leetcode.cn/1697422740-adxmsI-image.png] 输入：m = 3, n = 7 输出：28 示例 2： 输入：m = 3, n = 2 输出：3 解释： 从左上角开始，总共有 3 条路径可以到达右下角。 1. 向右 -> 向下 -> 向下 2. 向下 -> 向下 -> 向右 3. 向下 -> 向右 -> 向下 示例 3： 输入：m = 7, n = 3 输出：28 示例 4： 输入：m = 3, n = 3 输出：6   提示： * 1 <= m, n <= 100 * 题目数据保证答案小于等于 2 * 109
62. 不同路径 - 力扣（LeetCode）
https://leetcode.cn/problems/unique-paths/description/
62. 不同路径 - 力扣（LeetCode）
 

不同路径 II

63. 不同路径 II - 力扣（LeetCode）
63. 不同路径 II - 给定一个 m x n 的整数数组 grid。一个机器人初始位于 左上角（即 grid[0][0]）。机器人尝试移动到 右下角（即 grid[m - 1][n - 1]）。机器人每次只能向下或者向右移动一步。 网格中的障碍物和空位置分别用 1 和 0 来表示。机器人的移动路径中不能包含 任何 有障碍物的方格。 返回机器人能够到达右下角的不同路径数量。 测试用例保证答案小于等于 2 * 109。   示例 1： [https://assets.leetcode.com/uploads/2020/11/04/robot1.jpg] 输入：obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]] 输出：2 解释：3x3 网格的正中间有一个障碍物。 从左上角到右下角一共有 2 条不同的路径： 1. 向右 -> 向右 -> 向下 -> 向下 2. 向下 -> 向下 -> 向右 -> 向右 示例 2： [https://assets.leetcode.com/uploads/2020/11/04/robot2.jpg] 输入：obstacleGrid = [[0,1],[0,0]] 输出：1   提示： * m == obstacleGrid.length * n == obstacleGrid[i].length * 1 <= m, n <= 100 * obstacleGrid[i][j] 为 0 或 1
63. 不同路径 II - 力扣（LeetCode）
https://leetcode.cn/problems/unique-paths-ii/description/
63. 不同路径 II - 力扣（LeetCode）
 

整数拆分

343. 整数拆分 - 力扣（LeetCode）
343. 整数拆分 - 给定一个正整数 n ，将其拆分为 k 个 正整数 的和（ k >= 2 ），并使这些整数的乘积最大化。 返回 你可以获得的最大乘积 。   示例 1: 输入: n = 2 输出: 1 解释: 2 = 1 + 1, 1 × 1 = 1。 示例 2: 输入: n = 10 输出: 36 解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36。   提示: * 2 <= n <= 58
343. 整数拆分 - 力扣（LeetCode）
https://leetcode.cn/problems/integer-break/description/
343. 整数拆分 - 力扣（LeetCode）
 

不同的二叉搜索树

96. 不同的二叉搜索树 - 力扣（LeetCode）
96. 不同的二叉搜索树 - 给你一个整数 n ，求恰由 n 个节点组成且节点值从 1 到 n 互不相同的 二叉搜索树 有多少种？返回满足题意的二叉搜索树的种数。   示例 1： [https://assets.leetcode.com/uploads/2021/01/18/uniquebstn3.jpg] 输入：n = 3 输出：5 示例 2： 输入：n = 1 输出：1   提示： * 1 <= n <= 19
96. 不同的二叉搜索树 - 力扣（LeetCode）
https://leetcode.cn/problems/unique-binary-search-trees/description/
96. 不同的二叉搜索树 - 力扣（LeetCode）
 

0-1 背包问题

46. 携带研究材料（第六期模拟笔试）
小明是一位科学家，他需要参加一场重要的国际科学大会，以展示自己的最新研究成果。他需要带一些研究材料，但是他的行李箱空间有限。这些研究材料包括实验设备、文献资料和实验样本等等，它们各自占据不同的空间，并且具有不同的价值。
46. 携带研究材料（第六期模拟笔试）
https://kamacoder.com/problempage.php?pid=1046
 

分割等和子集

416. 分割等和子集 - 力扣（LeetCode）
416. 分割等和子集 - 给你一个 只包含正整数 的 非空 数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。   示例 1： 输入：nums = [1,5,11,5] 输出：true 解释：数组可以分割成 [1, 5, 5] 和 [11] 。 示例 2： 输入：nums = [1,2,3,5] 输出：false 解释：数组不能分割成两个元素和相等的子集。   提示： * 1 <= nums.length <= 200 * 1 <= nums[i] <= 100
416. 分割等和子集 - 力扣（LeetCode）
https://leetcode.cn/problems/partition-equal-subset-sum/description/
416. 分割等和子集 - 力扣（LeetCode）
 

最后一块石头的重量 II

1049. 最后一块石头的重量 II - 力扣（LeetCode）
1049. 最后一块石头的重量 II - 有一堆石头，用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。 每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下： * 如果 x == y，那么两块石头都会被完全粉碎； * 如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。 最后，最多只会剩下一块 石头。返回此石头 最小的可能重量 。如果没有石头剩下，就返回 0。   示例 1： 输入：stones = [2,7,4,1,8,1] 输出：1 解释： 组合 2 和 4，得到 2，所以数组转化为 [2,7,1,8,1]， 组合 7 和 8，得到 1，所以数组转化为 [2,1,1,1]， 组合 2 和 1，得到 1，所以数组转化为 [1,1,1]， 组合 1 和 1，得到 0，所以数组转化为 [1]，这就是最优值。 示例 2： 输入：stones = [31,26,33,21,40] 输出：5   提示： * 1 <= stones.length <= 30 * 1 <= stones[i] <= 100
1049. 最后一块石头的重量 II - 力扣（LeetCode）
https://leetcode.cn/problems/last-stone-weight-ii/description/
1049. 最后一块石头的重量 II - 力扣（LeetCode）
 

目标和

494. 目标和 - 力扣（LeetCode）
494. 目标和 - 给你一个非负整数数组 nums 和一个整数 target 。 向数组中的每个整数前添加 '+' 或 '-' ，然后串联起所有整数，可以构造一个 表达式 ： * 例如，nums = [2, 1] ，可以在 2 之前添加 '+' ，在 1 之前添加 '-' ，然后串联起来得到表达式 "+2-1" 。 返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。   示例 1： 输入：nums = [1,1,1,1,1], target = 3 输出：5 解释：一共有 5 种方法让最终目标和为 3 。 -1 + 1 + 1 + 1 + 1 = 3 +1 - 1 + 1 + 1 + 1 = 3 +1 + 1 - 1 + 1 + 1 = 3 +1 + 1 + 1 - 1 + 1 = 3 +1 + 1 + 1 + 1 - 1 = 3 示例 2： 输入：nums = [1], target = 1 输出：1   提示： * 1 <= nums.length <= 20 * 0 <= nums[i] <= 1000 * 0 <= sum(nums[i]) <= 1000 * -1000 <= target <= 1000
494. 目标和 - 力扣（LeetCode）
https://leetcode.cn/problems/target-sum/description/
494. 目标和 - 力扣（LeetCode）
 

一和零

474. 一和零 - 力扣（LeetCode）
474. 一和零 - 给你一个二进制字符串数组 strs 和两个整数 m 和 n 。 请你找出并返回 strs 的最大子集的长度，该子集中 最多 有 m 个 0 和 n 个 1 。 如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的 子集 。   示例 1： 输入：strs = ["10", "0001", "111001", "1", "0"], m = 5, n = 3 输出：4 解释：最多有 5 个 0 和 3 个 1 的最大子集是 {"10","0001","1","0"} ，因此答案是 4 。 其他满足题意但较小的子集包括 {"0001","1"} 和 {"10","1","0"} 。{"111001"} 不满足题意，因为它含 4 个 1 ，大于 n 的值 3 。 示例 2： 输入：strs = ["10", "0", "1"], m = 1, n = 1 输出：2 解释：最大的子集是 {"0", "1"} ，所以答案是 2 。   提示： * 1 <= strs.length <= 600 * 1 <= strs[i].length <= 100 * strs[i] 仅由 '0' 和 '1' 组成 * 1 <= m, n <= 100
474. 一和零 - 力扣（LeetCode）
https://leetcode.cn/problems/ones-and-zeroes/description/
474. 一和零 - 力扣（LeetCode）
 

携带研究材料

52. 携带研究材料（第七期模拟笔试）
小明是一位科学家，他需要参加一场重要的国际科学大会，以展示自己的最新研究成果。他需要带一些研究材料，但是他的行李箱空间有限。这些研究材料包括实验设备、文献资料和实验样本等等，它们各自占据不同的重量，并且具有不同的价值。
52. 携带研究材料（第七期模拟笔试）
https://kamacoder.com/problempage.php?pid=1052
 

零钱兑换 II

518. 零钱兑换 II - 力扣（LeetCode）
518. 零钱兑换 II - 给你一个整数数组 coins 表示不同面额的硬币，另给一个整数 amount 表示总金额。 请你计算并返回可以凑成总金额的硬币组合数。如果任何硬币组合都无法凑出总金额，返回 0 。 假设每一种面额的硬币有无限个。  题目数据保证结果符合 32 位带符号整数。   示例 1： 输入：amount = 5, coins = [1, 2, 5] 输出：4 解释：有四种方式可以凑成总金额： 5=5 5=2+2+1 5=2+1+1+1 5=1+1+1+1+1 示例 2： 输入：amount = 3, coins = [2] 输出：0 解释：只用面额 2 的硬币不能凑成总金额 3 。 示例 3： 输入：amount = 10, coins = [10] 输出：1   提示： * 1 <= coins.length <= 300 * 1 <= coins[i] <= 5000 * coins 中的所有值 互不相同 * 0 <= amount <= 5000
518. 零钱兑换 II - 力扣（LeetCode）
https://leetcode.cn/problems/coin-change-ii/description/
518. 零钱兑换 II - 力扣（LeetCode）
 

组合总和 Ⅳ

377. 组合总和 Ⅳ - 力扣（LeetCode）
377. 组合总和 Ⅳ - 给你一个由 不同 整数组成的数组 nums ，和一个目标整数 target 。请你从 nums 中找出并返回总和为 target 的元素组合的个数。 题目数据保证答案符合 32 位整数范围。   示例 1： 输入：nums = [1,2,3], target = 4 输出：7 解释： 所有可能的组合为： (1, 1, 1, 1) (1, 1, 2) (1, 2, 1) (1, 3) (2, 1, 1) (2, 2) (3, 1) 请注意，顺序不同的序列被视作不同的组合。 示例 2： 输入：nums = [9], target = 3 输出：0   提示： * 1 <= nums.length <= 200 * 1 <= nums[i] <= 1000 * nums 中的所有元素 互不相同 * 1 <= target <= 1000   进阶：如果给定的数组中含有负数会发生什么？问题会产生何种变化？如果允许负数出现，需要向题目中添加哪些限制条件？
377. 组合总和 Ⅳ - 力扣（LeetCode）
https://leetcode.cn/problems/combination-sum-iv/description/
377. 组合总和 Ⅳ - 力扣（LeetCode）
 

爬楼梯(进阶版)

57. 爬楼梯（第八期模拟笔试）
57. 爬楼梯（第八期模拟笔试）
https://kamacoder.com/problempage.php?pid=1067
 

零钱兑换

322. 零钱兑换 - 力扣（LeetCode）
322. 零钱兑换 - 给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。 计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回 -1 。 你可以认为每种硬币的数量是无限的。   示例 1： 输入：coins = [1, 2, 5], amount = 11 输出：3 解释：11 = 5 + 5 + 1 示例 2： 输入：coins = [2], amount = 3 输出：-1 示例 3： 输入：coins = [1], amount = 0 输出：0   提示： * 1 <= coins.length <= 12 * 1 <= coins[i] <= 231 - 1 * 0 <= amount <= 104
322. 零钱兑换 - 力扣（LeetCode）
https://leetcode.cn/problems/coin-change/description/
322. 零钱兑换 - 力扣（LeetCode）
 

完全平方数

279. 完全平方数 - 力扣（LeetCode）
279. 完全平方数 - 给你一个整数 n ，返回 和为 n 的完全平方数的最少数量 。 完全平方数 是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9 和 16 都是完全平方数，而 3 和 11 不是。   示例 1： 输入：n = 12 输出：3 解释：12 = 4 + 4 + 4 示例 2： 输入：n = 13 输出：2 解释：13 = 4 + 9   提示： * 1 <= n <= 104
279. 完全平方数 - 力扣（LeetCode）
https://leetcode.cn/problems/perfect-squares/description/
279. 完全平方数 - 力扣（LeetCode）
 

单词拆分

139. 单词拆分 - 力扣（LeetCode）
139. 单词拆分 - 给你一个字符串 s 和一个字符串列表 wordDict 作为字典。如果可以利用字典中出现的一个或多个单词拼接出 s 则返回 true。 注意：不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。   示例 1： 输入: s = "leetcode", wordDict = ["leet", "code"] 输出: true 解释: 返回 true 因为 "leetcode" 可以由 "leet" 和 "code" 拼接成。 示例 2： 输入: s = "applepenapple", wordDict = ["apple", "pen"] 输出: true 解释: 返回 true 因为 "applepenapple" 可以由 "apple" "pen" "apple" 拼接成。   注意，你可以重复使用字典中的单词。 示例 3： 输入: s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"] 输出: false   提示： * 1 <= s.length <= 300 * 1 <= wordDict.length <= 1000 * 1 <= wordDict[i].length <= 20 * s 和 wordDict[i] 仅由小写英文字母组成 * wordDict 中的所有字符串 互不相同
139. 单词拆分 - 力扣（LeetCode）
https://leetcode.cn/problems/word-break/description/
139. 单词拆分 - 力扣（LeetCode）
 

打家劫舍

198. 打家劫舍 - 力扣（LeetCode）
198. 打家劫舍 - 你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。 给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。   示例 1： 输入：[1,2,3,1] 输出：4 解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。   偷窃到的最高金额 = 1 + 3 = 4 。 示例 2： 输入：[2,7,9,3,1] 输出：12 解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。   偷窃到的最高金额 = 2 + 9 + 1 = 12 。   提示： * 1 <= nums.length <= 100 * 0 <= nums[i] <= 400
198. 打家劫舍 - 力扣（LeetCode）
https://leetcode.cn/problems/house-robber/description/
198. 打家劫舍 - 力扣（LeetCode）
 

打家劫舍 II

213. 打家劫舍 II - 力扣（LeetCode）
213. 打家劫舍 II - 你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。 给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。   示例 1： 输入：nums = [2,3,2] 输出：3 解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。 示例 2： 输入：nums = [1,2,3,1] 输出：4 解释：你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。   偷窃到的最高金额 = 1 + 3 = 4 。 示例 3： 输入：nums = [1,2,3] 输出：3   提示： * 1 <= nums.length <= 100 * 0 <= nums[i] <= 1000
213. 打家劫舍 II - 力扣（LeetCode）
https://leetcode.cn/problems/house-robber-ii/description/
213. 打家劫舍 II - 力扣（LeetCode）
 

打家劫舍 III

337. 打家劫舍 III - 力扣（LeetCode）
337. 打家劫舍 III - 小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为 root 。 除了 root 之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果 两个直接相连的房子在同一天晚上被打劫 ，房屋将自动报警。 给定二叉树的 root 。返回 在不触动警报的情况下 ，小偷能够盗取的最高金额 。   示例 1: [https://assets.leetcode.com/uploads/2021/03/10/rob1-tree.jpg] 输入: root = [3,2,3,null,3,null,1] 输出: 7 解释: 小偷一晚能够盗取的最高金额 3 + 3 + 1 = 7 示例 2: [https://assets.leetcode.com/uploads/2021/03/10/rob2-tree.jpg] 输入: root = [3,4,5,1,3,null,1] 输出: 9 解释: 小偷一晚能够盗取的最高金额 4 + 5 = 9   提示： * 树的节点数在 [1, 104] 范围内 * 0 <= Node.val <= 104
337. 打家劫舍 III - 力扣（LeetCode）
https://leetcode.cn/problems/house-robber-iii/description/
337. 打家劫舍 III - 力扣（LeetCode）
 

买卖股票的最佳时机

121. 买卖股票的最佳时机 - 力扣（LeetCode）
121. 买卖股票的最佳时机 - 给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。 你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。 返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。   示例 1： 输入：[7,1,5,3,6,4] 输出：5 解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。 注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。 示例 2： 输入：prices = [7,6,4,3,1] 输出：0 解释：在这种情况下, 没有交易完成, 所以最大利润为 0。   提示： * 1 <= prices.length <= 105 * 0 <= prices[i] <= 104
121. 买卖股票的最佳时机 - 力扣（LeetCode）
https://leetcode.cn/problems/best-time-to-buy-and-sell-stock/description/
121. 买卖股票的最佳时机 - 力扣（LeetCode）
 

买卖股票的最佳时机 II

122. 买卖股票的最佳时机 II - 力扣（LeetCode）
122. 买卖股票的最佳时机 II - 给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。 在每一天，你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。 返回 你能获得的 最大 利润 。   示例 1： 输入：prices = [7,1,5,3,6,4] 输出：7 解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。 随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3。 最大总利润为 4 + 3 = 7 。 示例 2： 输入：prices = [1,2,3,4,5] 输出：4 解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。 最大总利润为 4 。 示例 3： 输入：prices = [7,6,4,3,1] 输出：0 解释：在这种情况下, 交易无法获得正利润，所以不参与交易可以获得最大利润，最大利润为 0。   提示： * 1 <= prices.length <= 3 * 104 * 0 <= prices[i] <= 104
122. 买卖股票的最佳时机 II - 力扣（LeetCode）
https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii/description/
122. 买卖股票的最佳时机 II - 力扣（LeetCode）
 

买卖股票的最佳时机 III

123. 买卖股票的最佳时机 III - 力扣（LeetCode）
123. 买卖股票的最佳时机 III - 给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。 设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。 注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。   示例 1: 输入：prices = [3,3,5,0,0,3,1,4] 输出：6 解释：在第 4 天（股票价格 = 0）的时候买入，在第 6 天（股票价格 = 3）的时候卖出，这笔交易所能获得利润 = 3-0 = 3 。   随后，在第 7 天（股票价格 = 1）的时候买入，在第 8 天 （股票价格 = 4）的时候卖出，这笔交易所能获得利润 = 4-1 = 3 。 示例 2： 输入：prices = [1,2,3,4,5] 输出：4 解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。     注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。     因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。 示例 3： 输入：prices = [7,6,4,3,1] 输出：0 解释：在这个情况下, 没有交易完成, 所以最大利润为 0。 示例 4： 输入：prices = [1] 输出：0   提示： * 1 <= prices.length <= 105 * 0 <= prices[i] <= 105
123. 买卖股票的最佳时机 III - 力扣（LeetCode）
https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iii/description/
123. 买卖股票的最佳时机 III - 力扣（LeetCode）
 

买卖股票的最佳时机 IV

188. 买卖股票的最佳时机 IV - 力扣（LeetCode）
188. 买卖股票的最佳时机 IV - 给你一个整数数组 prices 和一个整数 k ，其中 prices[i] 是某支给定的股票在第 i 天的价格。 设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。也就是说，你最多可以买 k 次，卖 k 次。 注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。   示例 1： 输入：k = 2, prices = [2,4,1] 输出：2 解释：在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 2 。 示例 2： 输入：k = 2, prices = [3,2,6,5,0,3] 输出：7 解释：在第 2 天 (股票价格 = 2) 的时候买入，在第 3 天 (股票价格 = 6) 的时候卖出, 这笔交易所能获得利润 = 6-2 = 4 。 随后，在第 5 天 (股票价格 = 0) 的时候买入，在第 6 天 (股票价格 = 3) 的时候卖出, 这笔交易所能获得利润 = 3-0 = 3 。   提示： * 1 <= k <= 100 * 1 <= prices.length <= 1000 * 0 <= prices[i] <= 1000
188. 买卖股票的最佳时机 IV - 力扣（LeetCode）
https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iv/description/
188. 买卖股票的最佳时机 IV - 力扣（LeetCode）
 

买卖股票的最佳时机含冷冻期

309. 买卖股票的最佳时机含冷冻期 - 力扣（LeetCode）
309. 买卖股票的最佳时机含冷冻期 - 给定一个整数数组prices，其中第  prices[i] 表示第 i 天的股票价格 。 设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）: * 卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。 注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。   示例 1: 输入: prices = [1,2,3,0,2] 输出: 3 解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出] 示例 2: 输入: prices = [1] 输出: 0   提示： * 1 <= prices.length <= 5000 * 0 <= prices[i] <= 1000
309. 买卖股票的最佳时机含冷冻期 - 力扣（LeetCode）
https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-cooldown/description/
309. 买卖股票的最佳时机含冷冻期 - 力扣（LeetCode）
 

买卖股票的最佳时机含手续费

714. 买卖股票的最佳时机含手续费 - 力扣（LeetCode）
714. 买卖股票的最佳时机含手续费 - 给定一个整数数组 prices，其中 prices[i]表示第 i 天的股票价格 ；整数 fee 代表了交易股票的手续费用。 你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。 返回获得利润的最大值。 注意：这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。   示例 1： 输入：prices = [1, 3, 2, 8, 4, 9], fee = 2 输出：8 解释：能够达到的最大利润: 在此处买入 prices[0] = 1 在此处卖出 prices[3] = 8 在此处买入 prices[4] = 4 在此处卖出 prices[5] = 9 总利润: ((8 - 1) - 2) + ((9 - 4) - 2) = 8 示例 2： 输入：prices = [1,3,7,5,10,3], fee = 3 输出：6   提示： * 1 <= prices.length <= 5 * 104 * 1 <= prices[i] < 5 * 104 * 0 <= fee < 5 * 104
714. 买卖股票的最佳时机含手续费 - 力扣（LeetCode）
https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/description/
714. 买卖股票的最佳时机含手续费 - 力扣（LeetCode）
 

最长递增子序列

300. 最长递增子序列 - 力扣（LeetCode）
300. 最长递增子序列 - 给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。 子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。   示例 1： 输入：nums = [10,9,2,5,3,7,101,18] 输出：4 解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。 示例 2： 输入：nums = [0,1,0,3,2,3] 输出：4 示例 3： 输入：nums = [7,7,7,7,7,7,7] 输出：1   提示： * 1 <= nums.length <= 2500 * -104 <= nums[i] <= 104   进阶： * 你能将算法的时间复杂度降低到 O(n log(n)) 吗?
300. 最长递增子序列 - 力扣（LeetCode）
https://leetcode.cn/problems/longest-increasing-subsequence/description/
300. 最长递增子序列 - 力扣（LeetCode）
 

最长递增子序列

300. 最长递增子序列 - 力扣（LeetCode）
300. 最长递增子序列 - 给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。 子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。   示例 1： 输入：nums = [10,9,2,5,3,7,101,18] 输出：4 解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。 示例 2： 输入：nums = [0,1,0,3,2,3] 输出：4 示例 3： 输入：nums = [7,7,7,7,7,7,7] 输出：1   提示： * 1 <= nums.length <= 2500 * -104 <= nums[i] <= 104   进阶： * 你能将算法的时间复杂度降低到 O(n log(n)) 吗?
300. 最长递增子序列 - 力扣（LeetCode）
https://leetcode.cn/problems/longest-increasing-subsequence/description/
300. 最长递增子序列 - 力扣（LeetCode）
 

最长连续递增序列

674. 最长连续递增序列 - 力扣（LeetCode）
674. 最长连续递增序列 - 给定一个未经排序的整数数组，找到最长且 连续递增的子序列，并返回该序列的长度。 连续递增的子序列 可以由两个下标 l 和 r（l < r）确定，如果对于每个 l <= i < r，都有 nums[i] < nums[i + 1] ，那么子序列 [nums[l], nums[l + 1], ..., nums[r - 1], nums[r]] 就是连续递增子序列。   示例 1： 输入：nums = [1,3,5,4,7] 输出：3 解释：最长连续递增序列是 [1,3,5], 长度为3。 尽管 [1,3,5,7] 也是升序的子序列, 但它不是连续的，因为 5 和 7 在原数组里被 4 隔开。 示例 2： 输入：nums = [2,2,2,2,2] 输出：1 解释：最长连续递增序列是 [2], 长度为1。   提示： * 1 <= nums.length <= 104 * -109 <= nums[i] <= 109
674. 最长连续递增序列 - 力扣（LeetCode）
https://leetcode.cn/problems/longest-continuous-increasing-subsequence/description/
674. 最长连续递增序列 - 力扣（LeetCode）
 

最长重复子数组

718. 最长重复子数组 - 力扣（LeetCode）
718. 最长重复子数组 - 给两个整数数组 nums1 和 nums2 ，返回 两个数组中 公共的 、长度最长的子数组的长度 。   示例 1： 输入：nums1 = [1,2,3,2,1], nums2 = [3,2,1,4,7] 输出：3 解释：长度最长的公共子数组是 [3,2,1] 。 示例 2： 输入：nums1 = [0,0,0,0,0], nums2 = [0,0,0,0,0] 输出：5   提示： * 1 <= nums1.length, nums2.length <= 1000 * 0 <= nums1[i], nums2[i] <= 100
718. 最长重复子数组 - 力扣（LeetCode）
https://leetcode.cn/problems/maximum-length-of-repeated-subarray/description/
718. 最长重复子数组 - 力扣（LeetCode）
 

最长公共子序列

1143. 最长公共子序列 - 力扣（LeetCode）
1143. 最长公共子序列 - 给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。 一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。 * 例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。 两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。   示例 1： 输入：text1 = "abcde", text2 = "ace" 输出：3 解释：最长公共子序列是 "ace" ，它的长度为 3 。 示例 2： 输入：text1 = "abc", text2 = "abc" 输出：3 解释：最长公共子序列是 "abc" ，它的长度为 3 。 示例 3： 输入：text1 = "abc", text2 = "def" 输出：0 解释：两个字符串没有公共子序列，返回 0 。   提示： * 1 <= text1.length, text2.length <= 1000 * text1 和 text2 仅由小写英文字符组成。
1143. 最长公共子序列 - 力扣（LeetCode）
https://leetcode.cn/problems/longest-common-subsequence/description/
1143. 最长公共子序列 - 力扣（LeetCode）
 

不相交的线

1035. 不相交的线 - 力扣（LeetCode）
1035. 不相交的线 - 在两条独立的水平线上按给定的顺序写下 nums1 和 nums2 中的整数。 现在，可以绘制一些连接两个数字 nums1[i] 和 nums2[j] 的直线，这些直线需要同时满足： *  nums1[i] == nums2[j] * 且绘制的直线不与任何其他连线（非水平线）相交。 请注意，连线即使在端点也不能相交：每个数字只能属于一条连线。 以这种方法绘制线条，并返回可以绘制的最大连线数。   示例 1： [https://assets.leetcode.com/uploads/2019/04/26/142.png] 输入：nums1 = [1,4,2], nums2 = [1,2,4] 输出：2 解释：可以画出两条不交叉的线，如上图所示。 但无法画出第三条不相交的直线，因为从 nums1[1]=4 到 nums2[2]=4 的直线将与从 nums1[2]=2 到 nums2[1]=2 的直线相交。 示例 2： 输入：nums1 = [2,5,1,2,5], nums2 = [10,5,2,1,5,2] 输出：3 示例 3： 输入：nums1 = [1,3,7,1,7,5], nums2 = [1,9,2,5,1] 输出：2   提示： * 1 <= nums1.length, nums2.length <= 500 * 1 <= nums1[i], nums2[j] <= 2000
1035. 不相交的线 - 力扣（LeetCode）
https://leetcode.cn/problems/uncrossed-lines/description/
1035. 不相交的线 - 力扣（LeetCode）
 

最大子数组和

53. 最大子数组和 - 力扣（LeetCode）
53. 最大子数组和 - 给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。 子数组 是数组中的一个连续部分。   示例 1： 输入：nums = [-2,1,-3,4,-1,2,1,-5,4] 输出：6 解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。 示例 2： 输入：nums = [1] 输出：1 示例 3： 输入：nums = [5,4,-1,7,8] 输出：23   提示： * 1 <= nums.length <= 105 * -104 <= nums[i] <= 104   进阶：如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的 分治法 求解。
53. 最大子数组和 - 力扣（LeetCode）
https://leetcode.cn/problems/maximum-subarray/description/
53. 最大子数组和 - 力扣（LeetCode）
 

判断子序列

392. 判断子序列 - 力扣（LeetCode）
392. 判断子序列 - 给定字符串 s 和 t ，判断 s 是否为 t 的子序列。 字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。 进阶： 如果有大量输入的 S，称作 S1, S2, ... , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？ 致谢： 特别感谢 @pbrother  [https://leetcode.com/pbrother/]添加此问题并且创建所有测试用例。   示例 1： 输入：s = "abc", t = "ahbgdc" 输出：true 示例 2： 输入：s = "axc", t = "ahbgdc" 输出：false   提示： * 0 <= s.length <= 100 * 0 <= t.length <= 10^4 * 两个字符串都只由小写字符组成。
392. 判断子序列 - 力扣（LeetCode）
https://leetcode.cn/problems/is-subsequence/description/
392. 判断子序列 - 力扣（LeetCode）
 

不同的子序列

115. 不同的子序列 - 力扣（LeetCode）
115. 不同的子序列 - 给你两个字符串 s 和 t ，统计并返回在 s 的 子序列 中 t 出现的个数。 测试用例保证结果在 32 位有符号整数范围内。   示例 1： 输入：s = "rabbbit", t = "rabbit" 输出：3 解释： 如下所示, 有 3 种可以从 s 中得到 "rabbit" 的方案。 rabbbit rabbbit rabbbit 示例 2： 输入：s = "babgbag", t = "bag" 输出：5 解释： 如下所示, 有 5 种可以从 s 中得到 "bag" 的方案。 babgbag babgbag babgbag babgbag babgbag   提示： * 1 <= s.length, t.length <= 1000 * s 和 t 由英文字母组成
115. 不同的子序列 - 力扣（LeetCode）
https://leetcode.cn/problems/distinct-subsequences/description/
115. 不同的子序列 - 力扣（LeetCode）
 

两个字符串的删除操作

583. 两个字符串的删除操作 - 力扣（LeetCode）
583. 两个字符串的删除操作 - 给定两个单词 word1 和 word2 ，返回使得 word1 和  word2 相同所需的最小步数。 每步 可以删除任意一个字符串中的一个字符。   示例 1： 输入: word1 = "sea", word2 = "eat" 输出: 2 解释: 第一步将 "sea" 变为 "ea" ，第二步将 "eat "变为 "ea" 示例  2: 输入：word1 = "leetcode", word2 = "etco" 输出：4   提示： * 1 <= word1.length, word2.length <= 500 * word1 和 word2 只包含小写英文字母
583. 两个字符串的删除操作 - 力扣（LeetCode）
https://leetcode.cn/problems/delete-operation-for-two-strings/description/
583. 两个字符串的删除操作 - 力扣（LeetCode）
 

编辑距离

72. 编辑距离 - 力扣（LeetCode）
72. 编辑距离 - 给你两个单词 word1 和 word2， 请返回将 word1 转换成 word2 所使用的最少操作数  。 你可以对一个单词进行如下三种操作： * 插入一个字符 * 删除一个字符 * 替换一个字符   示例 1： 输入：word1 = "horse", word2 = "ros" 输出：3 解释： horse -> rorse (将 'h' 替换为 'r') rorse -> rose (删除 'r') rose -> ros (删除 'e') 示例 2： 输入：word1 = "intention", word2 = "execution" 输出：5 解释： intention -> inention (删除 't') inention -> enention (将 'i' 替换为 'e') enention -> exention (将 'n' 替换为 'x') exention -> exection (将 'n' 替换为 'c') exection -> execution (插入 'u')   提示： * 0 <= word1.length, word2.length <= 500 * word1 和 word2 由小写英文字母组成
72. 编辑距离 - 力扣（LeetCode）
https://leetcode.cn/problems/edit-distance/description/
72. 编辑距离 - 力扣（LeetCode）
 

回文子串

647. 回文子串 - 力扣（LeetCode）
647. 回文子串 - 给你一个字符串 s ，请你统计并返回这个字符串中 回文子串 的数目。 回文字符串 是正着读和倒过来读一样的字符串。 子字符串 是字符串中的由连续字符组成的一个序列。   示例 1： 输入：s = "abc" 输出：3 解释：三个回文子串: "a", "b", "c" 示例 2： 输入：s = "aaa" 输出：6 解释：6个回文子串: "a", "a", "a", "aa", "aa", "aaa"   提示： * 1 <= s.length <= 1000 * s 由小写英文字母组成
647. 回文子串 - 力扣（LeetCode）
https://leetcode.cn/problems/palindromic-substrings/description/
647. 回文子串 - 力扣（LeetCode）
 

最长回文子序列

516. 最长回文子序列 - 力扣（LeetCode）
516. 最长回文子序列 - 给你一个字符串 s ，找出其中最长的回文子序列，并返回该序列的长度。 子序列定义为：不改变剩余字符顺序的情况下，删除某些字符或者不删除任何字符形成的一个序列。   示例 1： 输入：s = "bbbab" 输出：4 解释：一个可能的最长回文子序列为 "bbbb" 。 示例 2： 输入：s = "cbbd" 输出：2 解释：一个可能的最长回文子序列为 "bb" 。   提示： * 1 <= s.length <= 1000 * s 仅由小写英文字母组成
516. 最长回文子序列 - 力扣（LeetCode）
https://leetcode.cn/problems/longest-palindromic-subsequence/description/
516. 最长回文子序列 - 力扣（LeetCode）
 

单调栈

每日温度

739. 每日温度 - 力扣（LeetCode）
739. 每日温度 - 给定一个整数数组 temperatures ，表示每天的温度，返回一个数组 answer ，其中 answer[i] 是指对于第 i 天，下一个更高温度出现在几天后。如果气温在这之后都不会升高，请在该位置用 0 来代替。   示例 1: 输入: temperatures = [73,74,75,71,69,72,76,73] 输出: [1,1,4,2,1,1,0,0] 示例 2: 输入: temperatures = [30,40,50,60] 输出: [1,1,1,0] 示例 3: 输入: temperatures = [30,60,90] 输出: [1,1,0]   提示： * 1 <= temperatures.length <= 105 * 30 <= temperatures[i] <= 100
739. 每日温度 - 力扣（LeetCode）
https://leetcode.cn/problems/daily-temperatures/description/
739. 每日温度 - 力扣（LeetCode）
 

下一个更大元素 I

496. 下一个更大元素 I - 力扣（LeetCode）
496. 下一个更大元素 I - nums1 中数字 x 的 下一个更大元素 是指 x 在 nums2 中对应位置 右侧 的 第一个 比 x 大的元素。 给你两个 没有重复元素 的数组 nums1 和 nums2 ，下标从 0 开始计数，其中nums1 是 nums2 的子集。 对于每个 0 <= i < nums1.length ，找出满足 nums1[i] == nums2[j] 的下标 j ，并且在 nums2 确定 nums2[j] 的 下一个更大元素 。如果不存在下一个更大元素，那么本次查询的答案是 -1 。 返回一个长度为 nums1.length 的数组 ans 作为答案，满足 ans[i] 是如上所述的 下一个更大元素 。   示例 1： 输入：nums1 = [4,1,2], nums2 = [1,3,4,2]. 输出：[-1,3,-1] 解释：nums1 中每个值的下一个更大元素如下所述： - 4 ，用加粗斜体标识，nums2 = [1,3,4,2]。不存在下一个更大元素，所以答案是 -1 。 - 1 ，用加粗斜体标识，nums2 = [1,3,4,2]。下一个更大元素是 3 。 - 2 ，用加粗斜体标识，nums2 = [1,3,4,2]。不存在下一个更大元素，所以答案是 -1 。 示例 2： 输入：nums1 = [2,4], nums2 = [1,2,3,4]. 输出：[3,-1] 解释：nums1 中每个值的下一个更大元素如下所述： - 2 ，用加粗斜体标识，nums2 = [1,2,3,4]。下一个更大元素是 3 。 - 4 ，用加粗斜体标识，nums2 = [1,2,3,4]。不存在下一个更大元素，所以答案是 -1 。   提示： * 1 <= nums1.length <= nums2.length <= 1000 * 0 <= nums1[i], nums2[i] <= 104 * nums1和nums2中所有整数 互不相同 * nums1 中的所有整数同样出现在 nums2 中   进阶：你可以设计一个时间复杂度为 O(nums1.length + nums2.length) 的解决方案吗？
496. 下一个更大元素 I - 力扣（LeetCode）
https://leetcode.cn/problems/next-greater-element-i/description/
496. 下一个更大元素 I - 力扣（LeetCode）
 

下一个更大元素 II

503. 下一个更大元素 II - 力扣（LeetCode）
503. 下一个更大元素 II - 给定一个循环数组 nums （ nums[nums.length - 1] 的下一个元素是 nums[0] ），返回 nums 中每个元素的 下一个更大元素 。 数字 x 的 下一个更大的元素 是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出 -1 。   示例 1: 输入: nums = [1,2,1] 输出: [2,-1,2] 解释: 第一个 1 的下一个更大的数是 2； 数字 2 找不到下一个更大的数； 第二个 1 的下一个最大的数需要循环搜索，结果也是 2。 示例 2: 输入: nums = [1,2,3,4,3] 输出: [2,3,4,-1,4]   提示: * 1 <= nums.length <= 104 * -109 <= nums[i] <= 109
503. 下一个更大元素 II - 力扣（LeetCode）
https://leetcode.cn/problems/next-greater-element-ii/
503. 下一个更大元素 II - 力扣（LeetCode）
 

接雨水

42. 接雨水 - 力扣（LeetCode）
42. 接雨水 - 给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。   示例 1： [https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/10/22/rainwatertrap.png] 输入：height = [0,1,0,2,1,0,1,3,2,1,2,1] 输出：6 解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。 示例 2： 输入：height = [4,2,0,3,2,5] 输出：9   提示： * n == height.length * 1 <= n <= 2 * 104 * 0 <= height[i] <= 105
42. 接雨水 - 力扣（LeetCode）
https://leetcode.cn/problems/trapping-rain-water/description/
42. 接雨水 - 力扣（LeetCode）
 

柱状图中最大的矩形

84. 柱状图中最大的矩形 - 力扣（LeetCode）
84. 柱状图中最大的矩形 - 给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。 求在该柱状图中，能够勾勒出来的矩形的最大面积。   示例 1: [https://assets.leetcode.com/uploads/2021/01/04/histogram.jpg] 输入：heights = [2,1,5,6,2,3] 输出：10 解释：最大的矩形为图中红色区域，面积为 10 示例 2： [https://assets.leetcode.com/uploads/2021/01/04/histogram-1.jpg] 输入： heights = [2,4] 输出： 4   提示： * 1 <= heights.length <=105 * 0 <= heights[i] <= 104
84. 柱状图中最大的矩形 - 力扣（LeetCode）
https://leetcode.cn/problems/largest-rectangle-in-histogram/description/
84. 柱状图中最大的矩形 - 力扣（LeetCode）
 

图论

所有可达路径

98. 所有可达路径
输出所有的可达路径，路径中所有节点之间空格隔开，每条路径独占一行，存在多条路径，路径输出的顺序可任意。如果不存在任何一条路径，则输出 -1。
98. 所有可达路径
https://kamacoder.com/problempage.php?pid=1170
 

所有可能的路径

797. 所有可能的路径 - 力扣（LeetCode）
797. 所有可能的路径 - 给你一个有 n 个节点的 有向无环图（DAG），请你找出所有从节点 0 到节点 n-1 的路径并输出（不要求按特定顺序）  graph[i] 是一个从节点 i 可以访问的所有节点的列表（即从节点 i 到节点 graph[i][j]存在一条有向边）。   示例 1： [https://assets.leetcode.com/uploads/2020/09/28/all_1.jpg] 输入：graph = [[1,2],[3],[3],[]] 输出：[[0,1,3],[0,2,3]] 解释：有两条路径 0 -> 1 -> 3 和 0 -> 2 -> 3 示例 2： [https://assets.leetcode.com/uploads/2020/09/28/all_2.jpg] 输入：graph = [[4,3,1],[3,2,4],[3],[4],[]] 输出：[[0,4],[0,3,4],[0,1,3,4],[0,1,2,3,4],[0,1,4]]   提示： * n == graph.length * 2 <= n <= 15 * 0 <= graph[i][j] < n * graph[i][j] != i（即不存在自环） * graph[i] 中的所有元素 互不相同 * 保证输入为 有向无环图（DAG）
797. 所有可能的路径 - 力扣（LeetCode）
https://leetcode.cn/problems/all-paths-from-source-to-target/description/
797. 所有可能的路径 - 力扣（LeetCode）
 

岛屿数量

99. 岛屿数量
给定一个由 1（陆地）和 0（水）组成的矩阵，你需要计算岛屿的数量。岛屿由水平方向或垂直方向上相邻的陆地连接而成，并且四周都是水域。你可以假设矩阵外均被水包围。
99. 岛屿数量
https://kamacoder.com/problempage.php?pid=1171
 

岛屿的最大面积

100. 岛屿的最大面积
100. 岛屿的最大面积
https://kamacoder.com/problempage.php?pid=1172
 

孤岛的总面积

101. 孤岛的总面积
给定一个由 1（陆地）和 0（水）组成的矩阵，岛屿指的是由水平或垂直方向上相邻的陆地单元格组成的区域，且完全被水域单元格包围。孤岛是那些位于矩阵内部、所有单元格都不接触边缘的岛屿。
101. 孤岛的总面积
https://kamacoder.com/problempage.php?pid=1173
 

沉没孤岛

102. 沉没孤岛
给定一个由 1（陆地）和 0（水）组成的矩阵，岛屿指的是由水平或垂直方向上相邻的陆地单元格组成的区域，且完全被水域单元格包围。孤岛是那些位于矩阵内部、所有单元格都不接触边缘的岛屿。
102. 沉没孤岛
https://kamacoder.com/problempage.php?pid=1174
 

水流问题

103. 水流问题
现有一个 N × M 的矩阵，每个单元格包含一个数值，这个数值代表该位置的相对高度。矩阵的左边界和上边界被认为是第一组边界，而矩阵的右边界和下边界被视为第二组边界。
103. 水流问题
https://kamacoder.com/problempage.php?pid=1175
 

建造最大岛屿

104. 建造最大岛屿
给定一个由 1（陆地）和 0（水）组成的矩阵，你最多可以将矩阵中的一格水变为一块陆地，在执行了此操作之后，矩阵中最大的岛屿面积是多少。
104. 建造最大岛屿
https://kamacoder.com/problempage.php?pid=1176
 

岛屿的周长

106. 岛屿的周长
106. 岛屿的周长
https://kamacoder.com/problempage.php?pid=1178
 

单词接龙

127. 单词接龙 - 力扣（LeetCode）
127. 单词接龙 - 字典 wordList 中从单词 beginWord 到 endWord 的 转换序列 是一个按下述规格形成的序列 beginWord -> s1 -> s2 -> ... -> sk： * 每一对相邻的单词只差一个字母。 *  对于 1 <= i <= k 时，每个 si 都在 wordList 中。注意， beginWord 不需要在 wordList 中。 * sk == endWord 给你两个单词 beginWord 和 endWord 和一个字典 wordList ，返回 从 beginWord 到 endWord 的 最短转换序列 中的 单词数目 。如果不存在这样的转换序列，返回 0 。   示例 1： 输入：beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log","cog"] 输出：5 解释：一个最短转换序列是 "hit" -> "hot" -> "dot" -> "dog" -> "cog", 返回它的长度 5。 示例 2： 输入：beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log"] 输出：0 解释：endWord "cog" 不在字典中，所以无法进行转换。   提示： * 1 <= beginWord.length <= 10 * endWord.length == beginWord.length * 1 <= wordList.length <= 5000 * wordList[i].length == beginWord.length * beginWord、endWord 和 wordList[i] 由小写英文字母组成 * beginWord != endWord * wordList 中的所有字符串 互不相同
127. 单词接龙 - 力扣（LeetCode）
https://leetcode.cn/problems/word-ladder/description/
127. 单词接龙 - 力扣（LeetCode）
 

有向图的完全联通

105. 有向图的完全联通
105. 有向图的完全联通
https://kamacoder.com/problempage.php?pid=1177
 

并查集类定义

 

寻找图中是否存在路径

1971. 寻找图中是否存在路径 - 力扣（LeetCode）
1971. 寻找图中是否存在路径 - 有一个具有 n 个顶点的 双向 图，其中每个顶点标记从 0 到 n - 1（包含 0 和 n - 1）。图中的边用一个二维整数数组 edges 表示，其中 edges[i] = [ui, vi] 表示顶点 ui 和顶点 vi 之间的双向边。 每个顶点对由 最多一条 边连接，并且没有顶点存在与自身相连的边。 请你确定是否存在从顶点 source 开始，到顶点 destination 结束的 有效路径 。 给你数组 edges 和整数 n、source 和 destination，如果从 source 到 destination 存在 有效路径 ，则返回 true，否则返回 false 。   示例 1： [https://assets.leetcode.com/uploads/2021/08/14/validpath-ex1.png] 输入：n = 3, edges = [[0,1],[1,2],[2,0]], source = 0, destination = 2 输出：true 解释：存在由顶点 0 到顶点 2 的路径: - 0 → 1 → 2 - 0 → 2 示例 2： [https://assets.leetcode.com/uploads/2021/08/14/validpath-ex2.png] 输入：n = 6, edges = [[0,1],[0,2],[3,5],[5,4],[4,3]], source = 0, destination = 5 输出：false 解释：不存在由顶点 0 到顶点 5 的路径.   提示： * 1 <= n <= 2 * 105 * 0 <= edges.length <= 2 * 105 * edges[i].length == 2 * 0 <= ui, vi <= n - 1 * ui != vi * 0 <= source, destination <= n - 1 * 不存在重复边 * 不存在指向顶点自身的边
1971. 寻找图中是否存在路径 - 力扣（LeetCode）
https://leetcode.cn/problems/find-if-path-exists-in-graph/description/
1971. 寻找图中是否存在路径 - 力扣（LeetCode）
 

冗余连接

684. 冗余连接 - 力扣（LeetCode）
684. 冗余连接 - 树可以看成是一个连通且 无环 的 无向 图。 给定往一棵 n 个节点 (节点值 1～n) 的树中添加一条边后的图。添加的边的两个顶点包含在 1 到 n 中间，且这条附加的边不属于树中已存在的边。图的信息记录于长度为 n 的二维数组 edges ，edges[i] = [ai, bi] 表示图中在 ai 和 bi 之间存在一条边。 请找出一条可以删去的边，删除后可使得剩余部分是一个有着 n 个节点的树。如果有多个答案，则返回数组 edges 中最后出现的那个。   示例 1： [https://pic.leetcode-cn.com/1626676174-hOEVUL-image.png] 输入: edges = [[1,2], [1,3], [2,3]] 输出: [2,3] 示例 2： [https://pic.leetcode-cn.com/1626676179-kGxcmu-image.png] 输入: edges = [[1,2], [2,3], [3,4], [1,4], [1,5]] 输出: [1,4]   提示: * n == edges.length * 3 <= n <= 1000 * edges[i].length == 2 * 1 <= ai < bi <= edges.length * ai != bi * edges 中无重复元素 * 给定的图是连通的
684. 冗余连接 - 力扣（LeetCode）
https://leetcode.cn/problems/redundant-connection/description/
684. 冗余连接 - 力扣（LeetCode）
 

冗余连接 II

685. 冗余连接 II - 力扣（LeetCode）
685. 冗余连接 II - 在本问题中，有根树指满足以下条件的 有向 图。该树只有一个根节点，所有其他节点都是该根节点的后继。该树除了根节点之外的每一个节点都有且只有一个父节点，而根节点没有父节点。 输入一个有向图，该图由一个有着 n 个节点（节点值不重复，从 1 到 n）的树及一条附加的有向边构成。附加的边包含在 1 到 n 中的两个不同顶点间，这条附加的边不属于树中已存在的边。 结果图是一个以边组成的二维数组 edges 。 每个元素是一对 [ui, vi]，用以表示 有向 图中连接顶点 ui 和顶点 vi 的边，其中 ui 是 vi 的一个父节点。 返回一条能删除的边，使得剩下的图是有 n 个节点的有根树。若有多个答案，返回最后出现在给定二维数组的答案。   示例 1： [https://assets.leetcode.com/uploads/2020/12/20/graph1.jpg] 输入：edges = [[1,2],[1,3],[2,3]] 输出：[2,3] 示例 2： [https://assets.leetcode.com/uploads/2020/12/20/graph2.jpg] 输入：edges = [[1,2],[2,3],[3,4],[4,1],[1,5]] 输出：[4,1]   提示： * n == edges.length * 3 <= n <= 1000 * edges[i].length == 2 * 1 <= ui, vi <= n
685. 冗余连接 II - 力扣（LeetCode）
https://leetcode.cn/problems/redundant-connection-ii/description/
685. 冗余连接 II - 力扣（LeetCode）
 

寻宝

53. 寻宝（第七期模拟笔试）
不同岛屿之间，路途距离不同，国王希望你可以规划建公路的方案，如何可以以最短的总公路距离将 所有岛屿联通起来（注意：这是一个无向图）。
53. 寻宝（第七期模拟笔试）
https://kamacoder.com/problempage.php?pid=1053
 

软件构建

117. 软件构建
117. 软件构建
https://kamacoder.com/problempage.php?pid=1191
 

参加科学大会

47. 参加科学大会（第六期模拟笔试）
小明的起点是第一个车站，终点是最后一个车站。然而，途中的各个车站之间的道路状况、交通拥堵程度以及可能的自然因素（如天气变化）等不同，这些因素都会影响每条路径的通行时间。
47. 参加科学大会（第六期模拟笔试）
https://kamacoder.com/problempage.php?pid=1047
 

城市间货物运输 I

94. 城市间货物运输 I
某国为促进城市间经济交流，决定对货物运输提供补贴。共有 n 个编号为 1 到 n 的城市，通过道路网络连接，网络中的道路仅允许从某个城市单向通行到另一个城市，不能反向通行。
94. 城市间货物运输 I
https://kamacoder.com/problempage.php?pid=1152
 

小明逛公园

97. 小明逛公园
给定一个公园景点图，图中有 N 个景点（编号为 1 到 N），以及 M 条双向道路连接着这些景点。每条道路上行走的距离都是已知的。
97. 小明逛公园
https://kamacoder.com/problempage.php?pid=1155
 

A*搜索算法