m0_59385870的博客

给你一个 只包含正整数 的 非空 数组 nums。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。解释：数组可以分割成 [1, 5, 5] 和 [11]。解释：数组不能分割成两个元素和相等的子集。输入：nums = [1,5,11,5]输入：nums = [1,2,3,5]重量就是价值,价值就是重量的背包问题。从普通问题中抽象出01背包。状态压缩型二维到一维的写法。

给你一个整数 n ，求恰由 n 个节点组成且节点值从 1 到 n 互不相同的 二叉搜索树 有多少种？返回满足题意的二叉搜索树的种数。

第一题就是纯依赖关系的递推,类似于爬楼梯,当前状态依赖于前面已经处理过的状态,最前面即首元素或首行列的元素需要初始化。机器人试图达到网格的右下角（在下图中标记为 “Finish”）。一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。输入：obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]输入：obstacleGrid = [[0,1],[0,0]]

给你一个整数数组 cost ，其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。输入：cost = [1,100,1,1,1,100,1,1,100,1]你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。输入：cost = [10,15,20]请你计算并返回达到楼梯顶部的最低花费。解释：你将从下标为 1 的台阶开始。解释：你将从下标为 0 的台阶开始。

斐波那契数 （通常用 F(n) 表示）形成的序列称为 斐波那契数列。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。F(n) = F(n - 1) + F(n - 2)，其中 n > 1。解释：F(2) = F(1) + F(0) = 1 + 0 = 1。解释：F(3) = F(2) + F(1) = 1 + 1 = 2。解释：F(4) = F(3) + F(2) = 2 + 1 = 3。给定 n ，请计算 F(n)。

每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。解释：如上图所示，4 皇后问题存在两个不同的解法。二维集合问题,但仍然单层回溯。输出：[[“Q”]]

而返回结果集则通常需要一个路径数组(一维)和一个路径集数组(二维),每条路径都是一个答案,搭配两处push,ans.push(path),path.push(arr[i]);再难的题逐步划分问题就简单了->暴力for枚举答案,然后是否是答案的组成结点自己写一个针对结点的判断函数,暴力for可以解答,但for太多了n个for,则递归。返回一个结果,则是bool类型,即搜到了一个结果就向上返回,即返回当前答案树枝,而不需要递归其它的树枝了。数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。

给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素。你可以按 任意顺序 返回答案。输出：[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。输入：nums = [4,4,3,2,1]去重+结点判断(答案长度,答案单调性)输入：nums = [4,6,7,7]输出：[[4,4]]

每次递归都新声明一个set,表示在每个树节点处维护一个hash表,树的深度间(递归深度)不会影响,即纵向不会影响彼此,也不会树枝去重,但是宽度间,即同层的节点,横向会去重,因为每一层都维护同样一个hash表,除非相同发生在纵向,不然则在横向上需要树宽去重,即for去重(continue);给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]输入：nums = [1,2,2]输出：[[],[0]]

例如：“0.1.2.201” 和 “192.168.1.1” 是 有效 IP 地址，但是 “0.011.255.245”、“192.168.1.312” 和 “192.168@1.1” 是 无效 IP 地址。你可以按任何顺序返回答案。输出：[“10.20.30.40”,“102.0.30.40”,“10.203.0.40”]输出：[“255.255.11.135”,“255.255.111.35”]输出：[“0.10.0.10”,“0.100.1.0”]输入：s = “0000”输入：s = “1111”

以a/a/b开头的答案结束,以a/a开头的答案结束,以a/开头的答案结束_____逐步回溯。我第一刀切在第一个a处,(因为满足条件),后续所有的刀都以前一刀为基础向后切割。如果起终点间形成的区间满足条件,则照着终点切割,形成的切割区间即子串加入路径。再for++,将切割点后移,然后开始答案数组的第二个元素,即路径的制造。输出：[[“a”,“a”,“b”],[“aa”,“b”]]每一轮传入切割区间的新起点,再由该轮的i++控制终点。a/a/b/a/a/c加入答案数组。回溯到第一刀位置,后移,满足,切割。

1.递归去重:(去重复下标,不在同一下标取值)任意集合只要不可重复选取当前位置元素时就要应用,但并不保证是否组合有重复元素,因为集合可能本身含重复值,体现在。1.特判去重:(去除重复组合,哪怕来自不同下标),必须是含重复值的集合并且该集合要求返回的组合间不能相同.输入: candidates = [10,1,2,7,6,1,5], target = 8,输入: candidates = [2,5,2,1,2], target = 5,重复集合不可重复选取每个位置上的数字(深度去重中的递归去重)

多个集合间的组合问题,首先看集合间存在搭配问题与否,如果不需要,实质处理的还是单个集合的回溯组合问题,只是多个集合需要拿完才能开始ans.push.path。输出：[“ad”,“ae”,“af”,“bd”,“be”,“bf”,“cd”,“ce”,“cf”]给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。digits[i] 是范围 [‘2’, ‘9’] 的一个数字。输入：digits = “23”输出：[“a”,“b”,“c”]输入：digits = “2”输入：digits = “”

在[1,9]范围内使用4个不同的数字，我们可以得到的最小和是1+2+3+4 = 10，因为10 > 1，没有有效的组合。宽度剪枝:集合大小-(给定组合大小-已有组合大小)+1…返回 所有可能的有效组合的列表。该列表不能包含相同的组合两次，组合可以以任何顺序返回。输出: [[1,2,6], [1,3,5], [2,3,4]]输入: k = 3, n = 7。输入: k = 3, n = 9。输入: k = 4, n = 1。输出: [[1,2,4]]解释: 不存在有效的组合。没有其他符合的组合了。

给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。进阶：你所设计算法的时间复杂度 必须 优于 O(n log n) ，其中 n 是数组大小。题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的。输入: nums = [1,1,1,2,2,3], k = 2。k 的取值范围是 [1, 数组中不相同的元素的个数]输入: nums = [1], k = 1。

单调队列

tokens[i] 是一个算符（“+”、“-”、“*” 或 “/”），或是在范围 [-200, 200] 内的一个整数。输入：tokens = [“10”,“6”,“9”,“3”,“+”,“-11”,“该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * )。解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9。输入：tokens = [“4”,“13”,“5”,“/”,“+”]输入：tokens = [“2”,“1”,“+”,“3”,“*”]

字符串模拟"栈的思想"

给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。每个右括号都有一个对应的相同类型的左括号。s 仅由括号 ‘()[]{}’ 组成。左括号必须用相同类型的右括号闭合。输入：s = “()[]{}”左括号必须以正确的顺序闭合。输入：s = “()”输入：s = “(]”

你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。void push(int x) 将元素 x 压入栈顶。int pop() 移除并返回栈顶元素。int top() 返回栈顶元素。

你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。你能否实现每个操作均摊时间复杂度为 O(1) 的队列？换句话说，执行 n 个操作的总时间复杂度为 O(n) ，即使其中一个操作可能花费较长时间。你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）

给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。如果剩余字符少于 k 个，则将剩余字符全部反转。输入：s = “abcdefg”, k = 2。输入：s = “abcd”, k = 2。输出：“bacdfeg”s 仅由小写英文组成。

注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。进阶：如果字符串在你使用的编程语言中是一种可变数据类型，请尝试使用 O(1) 额外空间复杂度的 原地 解法。s 中使用至少一个空格将字符串中的 单词 分隔开。解释：如果两个单词间有多余的空格，反转后的字符串需要将单词间的空格减少到仅有一个。给你一个字符串 s ，请你反转字符串中 单词 的顺序。解释：反转后的字符串中不能存在前导空格和尾随空格。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。给定一个链表的头节点 head ，返回链表开始入环的第一个节点。输入：head = [3,2,0,-4], pos = 1。输入：head = [1,2], pos = 0。解释：链表中有一个环，其尾部连接到第二个节点。解释：链表中有一个环，其尾部连接到第一个节点。输出：返回索引为 1 的链表节点。解释：链表中没有环。

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。链表中节点的数目在范围 [0, 100] 内。输入：head = [1,2,3,4]输入：head = [1]输出：[2,1,4,3]输入：head = []

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。链表中节点的数目在范围 [0, 100] 内。输入：head = [1,2,3,4]输入：head = [1]输出：[2,1,4,3]输入：head = []

进阶：链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题。输入：head = [1,2,3,4,5]链表中节点的数目范围是 [0, 5000]输入：head = [1,2]输出：[5,4,3,2,1]输入：head = []

void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。val 是当前节点的值，next 是指向下一个节点的指针/引用。void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。int get(int index) 获取链表中下标为 index 的节点的值。void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点。输入：head = [1,2,6,3,4,5,6], val = 6。输入：head = [7,7,7,7], val = 7。列表中的节点数目在范围 [0, 104] 内。输入：head = [], val = 1。输出：[1,2,3,4,5]

输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]输入：nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0]解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1]。输入：nums = [2,7,11,15], target = 9。输入：nums = [3,2,4], target = 6。输入：nums = [3,3], target = 6。

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i!输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]输入：nums = [1,0,-1,0,-2,2], target = 0。输入：nums = [2,2,2,2,2], target = 8。不同的三元组是 [-1,0,1] 和 [-1,-1,2]。输入：nums = [-1,0,1,2,-1,-4]输出：[[-1,-1,2],[-1,0,1]]

给定两个数组 nums1 和 nums2 ，返回 它们的交集。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序。

哈希数组

给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix。输出：[[1,2,3],[8,9,4],[7,6,5]]

解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。输入：nums = [0,1,2,2,3,0,4,2], val = 2。元素的顺序可以改变。输入：nums = [3,2,2,3], val = 3。输出：5, nums = [0,1,3,0,4]

有序数组的平方

209. 长度最小的子数组