qq_60513199的博客

随着时间的推移，今年也将面临秋招，压力慢慢就上来了。刚开始的时候，有很多的题型都没见过，自己看了半天也毫无头绪，也无从下手，于是大多是时候就是看过一遍卡哥的题解，熟悉一下这类题目的解题思路，再自己动手敲一遍。训练营中，以60天为周期，大家都是同一个基础，同一个进度刷题，每天刷题题目都是一样的，这样的一个学习群，大家讨论起来更有意义。这对自律性不强的我无疑是一个非常合适的。总而言之，一刷过后，很多常见的题型心中都有了感觉，现在做题也不是毫无章法，对每种题目的解法有了整体的把握，还养成了写博客理思路的习惯。

其他情况dp[i][j]初始为0就行，这样递推公式：dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);如果s[i]与s[j]不相同，说明s[i]和s[j]的同时加入 并不能增加[i,j]区间回文子序列的长度，那么分别加入s[i]、s[j]看看哪一个可以组成最长的回文子序列。那么dp[i][j]一定是取最大的，即：dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);整体上是两种，就是s[i]与s[j]相等，s[i]与s[j]不相等这两种。

加入T[4]，T[4] == T[3] （当前遍历的元素T[i]等于栈顶元素T[st.top()]的情况），此时依然要加入栈，不用计算距离，因为我们要求的是右面第一个大于本元素的位置，而不是大于等于！我们要保持一个递增单调栈（从栈头到栈底），所以将T[0]弹出，T[1]加入，此时result数组可以记录了，result[0] = 1，即T[0]右面第一个比T[0]大的元素是T[1]。加入T[1] = 74，因为T[1] > T[0]（当前遍历的元素T[i]大于栈顶元素T[st.top()]的情况）。

前两种入度为2的情况，一定是删除指向入度为2的节点的两条边其中的一条，如果删了一条，判断这个图是一个树，那么这条边就是答案，同时注意要从后向前遍历，因为如果两条边删哪一条都可以成为树，就删最后那一条。输入一个有向图，该图由一个有着 n 个节点（节点值不重复，从 1 到 n）的树及一条附加的有向边构成。首先先计算节点的入度，edges[i][1] 表示的节点都是 箭头指向的节点，即这个几点有一个入度！题目说是无向图，返回一条可以删去的边，使得结果图是一个有着N个节点的树（即：只有一个根节点）。

在形式上，对于每个房间 i 都有一个钥匙列表 rooms[i]，每个钥匙 rooms[i][j] 由 [0,1，...，N-1] 中的一个整数表示，其中 N = rooms.length。钥匙 rooms[i][j] = v 可以打开编号为 v 的房间。给定一个 row x col 的二维网格地图 grid ，其中：grid[i][j] = 1 表示陆地， grid[i][j] = 0 表示水域。每个房间有不同的号码：0，1，2，...，N-1，并且房间里可能有一些钥匙能使你进入下一个房间。

那最后当然是取最小值，所以当word1[i - 1] 与 word2[j - 1]不相同的时候，递推公式：dp[i][j] = min({dp[i - 1][j - 1] + 2, dp[i - 1][j] + 1, dp[i][j - 1] + 1});因为 dp[i][j - 1] + 1 = dp[i - 1][j - 1] + 2，所以递推公式可简化为：dp[i][j] = min(dp[i - 1][j] + 1, dp[i][j - 1] + 1);，此时就需要编辑了，如何编辑呢？

t[j - 1])，此时相当于t要删除元素，t如果把当前元素t[j - 1]删除，那么dp[i][j] 的数值就是 看s[i - 1]与 t[j - 2]的比较结果了，即：dp[i][j] = dp[i][j - 1];if (s[i - 1] == t[j - 1])，那么dp[i][j] = dp[i - 1][j - 1] + 1;所以当s[i - 1] 与 t[j - 1]相等时，dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];

每次查找时，用两个for循环，一个for循环遍历beginword进行字母替换，另一个循环遍历26个字母，依次进行替换，再看看替换后字母有没有出现在单词集合unodered_set里，如果出现了：假如正好==endword,路径长度+1，返回结果；可以使用map记录，key为岛屿编号，value为岛屿面积 第二步：在遍历地图，遍历0的方格（因为要将0变成1），并统计该1（由0变成的1）周边岛屿面积，将其相邻面积相加在一起，遍历所有 0 之后，就可以得出 选一个0变成1 之后的最大面积。

如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。思路：dp[i][j]：长度为[0, i - 1]的字符串text1与长度为[0, j - 1]的字符串text2的最长公共子序列为dp[i][j]；即：dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);

遍历周边：分别遍历最左列（grid[i][0]),最右列（grid[i][m-1]),最上行（grid[0][j]),最下行（grid[n-1][j]),同时进行搜索，在搜索过程中将其置0。给你一个 m x n 的矩阵 board ，由若干字符 'X' 和 'O' ，找到所有被 'X' 围绕的区域，并将这些区域里所有的 'O' 用 'X' 填充。先广度优先或深度优先遍历周边，把周边的X换为'A'，然后两个for循环遍历整个grid,遇到'A'换成’O',遇到'O'换成‘X'

提到深度优先搜索（dfs），就不得不说和广度优先搜索（bfs）有什么区别先来了解dfs的过程，很多录友可能对dfs（深度优先搜索），bfs（广度优先搜索）分不清。

连续递增的子序列 可以由两个下标 l 和 r（l < r）确定，如果对于每个 l <= i < r，都有 nums[i] < nums[i + 1] ，那么子序列 [nums[l], nums[l + 1], ..., nums[r - 1], nums[r]] 就是连续递增子序列。即当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;根据dp[i][j]的定义，dp[i][j]的状态只能由dp[i - 1][j - 1]推导出来。

此时问题就是要求非交叉区间的最大个数。这里记录非交叉区间的个数还是有技巧的，如图：区间，1，2，3，4，5，6都按照右边界排好序。当确定区间 1 和 区间2 重叠后，如何确定是否与 区间3 也重贴呢？就是取。

那么dp[i][0] = max(dp[i - 1][0], dp[i - 1][3] - prices[i], dp[i - 1][1] - prices[i]);所以：dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i] - fee);所以：dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);即：dp[i][2] = dp[i - 1][0] + prices[i];

局部最优推出全局最优，找不出反例，试试贪心！如图：i 每次移动只能在 cover 的范围内移动，每移动一个元素，cover 得到该元素数值（新的覆盖范围）的补充，让 i 继续移动下去。而 cover 每次只取 max(该元素数值补充后的范围, cover 本身范围)。如果 cover 大于等于了终点下标，直接 return true 就可以了。

贪心的本质是选择每一阶段的局部最优，从而达到全局最优。这么说有点抽象，来举一个例子：例如，有一堆钞票，你可以拿走十张，如果想达到最大的金额，你要怎么拿？指定每次拿最大的，最终结果就是拿走最大数额的钱。每次拿最大的就是局部最优，最后拿走最大数额的钱就是推出全局最优。说实话贪心算法并没有固定的套路。所以唯一的难点就是如何通过局部最优，推出整体最优。最好用的策略就是举反例，如果想不到反例，那么就试一试贪心吧。

一个机场映射多个机场，机场之间要靠字母序排列，一个机场映射多个机场，可以使用std::unordered_map，如果让多个机场之间再有顺序的话，就是用std::map 或者std::multimap 或者 std::multiset。递归深度就是row控制棋盘的行，每一层里for循环的col控制棋盘的列，一行一列，确定了放置皇后的位置。从图中，可以看出，二维矩阵中矩阵的高就是这棵树的高度，矩阵的宽就是树形结构中每一个节点的宽度。遍历multiset的时候，不能删除元素，一旦删除元素，迭代器就失效了。

可以看出元素1在[1,2]中已经使用过了，但是在[2,1]中还要在使用一次1，所以处理排列问题就不用使用startIndex了。本题给出的示例，还是一个有序数组 [4, 6, 7, 7]，这更容易误导大家按照排序的思路去做了。注意： 很明显一个元素不能重复使用，所以需要startIndex，调整下一层递归的起始位置。给定一个整型数组, 你的任务是找到所有该数组的递增子序列，递增子序列的长度至少是2。图中我们对同一树层，前一位（也就是nums[i-1]）如果使用过，那么就进行去重。

正好由四个整数（每个整数位于0到255之间组成，且不能含有前导0），整数之间用'.'分隔。给定一个只包含数字的字符串s，用以表示一个 IP 地址，返回所有可能的，这些地址可以通过在s中插入'.'来形成。你重新排序或删除s中的任何数字。你可以按顺序返回答案。思路：切割问题，，和刚做过的就十分类似了。startIndex一定是需要的，因为不能重复分割，记录下一层递归分割的起始位置。本题我们还需要一个变量pointNum，记录添加逗点的数量。

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。candidates 中的数字可以无限制重复被选取。思路：本题搜索的过程抽象成树形结构如下：注意图中叶子节点的返回条件，因为本题没有组合数量要求，仅仅是总和的限制，所以递归没有层数的限制，只要选取的元素总和超过target，就返回！如果是一的话，就需要startIndex；如果是，各个集合之间相互不影响，那么就不用startIndex。

选最大的，所以 dp[i][1] = max(dp[i - 1][0] - prices[i], dp[i - 1][1]);dp[i][j]中 i表示第i天，j为 [0 - 4] 五个状态，dp[i][j]表示第i天状态j所剩最大现金。所以dp[i][2] = max(dp[i - 1][1] + prices[i], dp[i - 1][2])所以dp[i][2] = max(dp[i - 1][1] + prices[i], dp[i - 1][2])第0天第二次买入操作，初始值应该是多少呢？

i

从下图中红线部分可以看出，在集合[1,2,3,4]取1之后，下一层递归，就要在[2,3,4]中取数了，那么下一层递归如何知道从[2,3,4]中取数呢，靠的就是startIndex。第一次取1，集合变为2，3，4 ，因为k为2，我们只需要再取一个数就可以了，分别取2，3，4，得到集合[1,2] [1,3] [1,4]，以此类推。可以看出这棵树，一开始集合是 1，2，3，4， 从左向右取数，取过的数，不再重复取。，如果想让回溯法高效一些，可以加一些剪枝的操作，但也改不了回溯法就是穷举的本质。

思路：与上一题类似，只是可以多次买卖，那么递推公式中不同之处在于dp[i][0] = max(dp[i - 1][0], dp[i - 1][1]-prices[i]);如果第i天买股票了，由于买股票前需要将之前的股票抛出，那么此时dp[i][0] =dp[i - 1][1]-prices[i]，即前一天抛售后获得的现金-今天买入股票所花的价格。同样dp[i][1]取最大的，dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。如图，我们从根节点搜索，第一次遇到 cur节点是数值在[q, p]区间中，即 节点5，此时可以说明 q 和 p 一定分别存在于 节点 5的左子树，和右子树中。如图所示：p为节点6，q为节点9。

如果偷第i房间，那么dp[i] = dp[i - 2] + nums[i] ，即：第i-1房一定是不考虑的，找出 下标i-2（包括i-2）以内的房屋，最多可以偷窃的金额为dp[i-2] 加上第i房间偷到的钱。从dp[i]的定义上来讲，dp[0] 一定是 nums[0]，dp[1]就是nums[0]和nums[1]的最大值即：dp[1] = max(nums[0], nums[1]);然后dp[i]取最大值，即dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);

合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。左子数是左边的数组元素，右子树是数组右边元素，所以每次递归都需要判断一下子数组的最大值所在位置，来切割左右子数组，以构造节点；给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。在上述示例中，如果要找的值是 5，但因为没有节点值为 5，我们应该返回 NULL。给定一个不含重复元素的整数数组。思路：要知道中序遍历下，输出的二叉搜索树节点的数值是有序序列。

思路：可以重复多次使用字典里的单词，属于完全背包，字典里的单词相当于物品，给定的字符串相当于背包；将字典里的单词放到一个哈希表（集合）里，遍历的时候依次拆分给定字符串s,如果拆出单词能在字典里找到，则说明拆分成功，dp[i]=true;给定一个非空字符串 s 和一个包含非空单词的列表 wordDict，判定 s 是否可以被空格拆分为一个或多个在字典中出现的单词。当然还有那种二进制优化的方法，其实就是把每种物品的数量，打包成一个个独立的包。多重背包和01背包是非常像的， 为什么和01背包像呢？

凑足总额为j - coins[i]的最少个数为dp[j - coins[i]]，那么只需要加上一个钱币coins[i]即dp[j - coins[i]] + 1就是dp[j]（考虑coins[i]）此时我们要选择最小的dp[j]，所以递推公式：dp[j] = min(dp[j - i * i] + 1, dp[j]);dp[j] 可以由dp[j - i * i]推出， dp[j - i * i] + 1 便可以凑成dp[j]。所以dp[j] 要取所有 dp[j - coins[i]] + 1 中最小的。

所有可能的组合为： (1, 1, 1, 1) (1, 1, 2) (1, 2, 1) (1, 3) (2, 1, 1) (2, 2) (3, 1)第i件物品的重量是weight[i]，得到的价值是value[i]。给定一个由正整数组成且不存在重复数字的数组，找出和为给定目标正整数的组合的个数。思路：硬币数不限，完全背包问题，总金额是背包容量，硬币面额相当于物品重量；完全背包，求排列数，外层遍历物品，内层遍历背包容量，dp[0]初始化为1。请注意，顺序不同的序列被视作不同的组合。

思路：后序遍历结果数组中，从后往前，分别是数的根节点，由于遍历的是同一棵树，所以后续遍历的根节点，在中序结果数组中，恰好把两边切成其左右孩子数组两部分，一路切割下去，就能唯一确定一棵树；给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。返回 true, 因为存在目标和为 22 的根节点到叶子节点的路径 5->4->11->2。第四步：切割中序数组，切成中序左数组和中序右数组 （顺序别搞反了，一定是先切中序数组）说明: 叶子节点是指没有子节点的节点。

力扣题目链接(opens new window)题目难度：中等有一堆石头，每块石头的重量都是正整数。每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：如果 x == y，那么两块石头都会被完全粉碎；如果 x!= y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。最后，最多只会剩下一块石头。返回此石头最小的可能重量。如果没有石头剩下，就返回 0。输入：[2,7,4,1,8,1]输出：1。

当遇到左叶子节点的时候，记录数值，然后通过递归求取左子树左叶子之和，和 右子树左叶子之和，相加便是整个树的左叶子之和。此时还没完，递归完，要做回溯啊，因为path 不能一直加入节点，它还要删节点，然后才能加入新的节点。如果该节点的左节点不为空，该节点的左节点的左节点为空，该节点的左节点的右节点为空，则找到了一个左叶子。判断一个树的左叶子节点之和，那么一定要传入树的根节点，递归函数的返回值为数值之和，所以为int。递归的过程中依然是遇到空节点了为终止，返回0，表示当前节点为根节点的树高度为0。

这道题目我们也可以使用迭代法，但要注意，这里的迭代法可不是前中后序的迭代写法，因为本题的本质是判断两个树是否是相互翻转的，其实已经不是所谓二叉树遍历的前中后序的关系了。因为我们要比较的是根节点的两个子树是否是相互翻转的，进而判断这个树是不是对称树，所以要比较的是两个树，参数自然也是左子树节点和右子树节点。如上代码中，我们可以看出使用的遍历方式，左子树左右中，右子树右左中，所以我把这个遍历顺序也称之为“后序遍历”（尽管不是严格的后序遍历）。层序遍历一个二叉树。给定一个 N 叉树，返回其节点值的层序遍历。

这里要看一下递推公式dp[i][j] = dp[i - 1][j] + dp[i][j - 1]，dp[i][j]都是从其上方和左方推导而来，那么从左到右一层一层遍历就可以了。那么很自然，dp[i][j] = dp[i - 1][j] + dp[i][j - 1]，因为dp[i][j]只有这两个方向过来。这样就可以保证推导dp[i][j]的时候，dp[i - 1][j] 和 dp[i][j - 1]一定是有数值的。dp[i][j] ：表示从（0 ，0）出发，到(i, j) 有dp[i][j]条不同的路径。

题目链接给你两个字符串 和 ，请你在 字符串中找出 字符串的第一个匹配项的下标（下标从 0 开始）。如果 不是 的一部分，则返回 。示例 1：输入：haystack = "sadbutsad", needle = "sad"输出：0解释："sad" 在下标 0 和 6 处匹配。第一个匹配项的下标是 0 ，所以返回 0 。示例 2：输入：haystack = "leetcode", needle = "leeto"输出：-1解释："leeto" 没有在 "leetcode"

从递归公式上来讲，dp[以j为头结点左子树节点数量] * dp[以j为头结点右子树节点数量] 中以j为头结点左子树节点数量为0，也需要dp[以j为头结点左子树节点数量] = 1， 否则乘法的结果就都变成0了。在上面的分析中，其实已经看出其递推关系， dp[i] += dp[以j为头结点左子树节点数量] * dp[以j为头结点右子树节点数量] ，j相当于是头结点的元素，从1遍历到i为止。所以dp[3] = dp[2] * dp[0] + dp[1] * dp[1] + dp[0] * dp[2]

dp[i][j]由dp[i - 1][j - weight[i]]推出，dp[i - 1][j - weight[i]] 为背包容量为j - weight[i]的时候不放物品i的最大价值，那么dp[i - 1][j - weight[i]] + value[i] （物品i的价值），就是背包放物品i得到的最大价值。dp[i][j]由dp[i - 1][j]推出，即背包容量为j，里面不放物品i的最大价值，此时dp[i][j]就是dp[i - 1][j]；当容量为j,物品编号为0时，

写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。最后再说一说二叉树中深度优先和广度优先遍历实现方式，我们做二叉树相关题目，经常会使用递归的方式来实现深度优先遍历，也就是实现前中后序遍历，使用递归是比较方便的。而广度优先遍历的实现一般使用队列来实现，这也是队列先进先出的特点所决定的，因为需要先进先出的结构，才能一层一层的来遍历二叉树。确定每一层递归需要处理的信息。

寻找前k个最大元素流程如图所示：（图中的频率只有三个，所以正好构成一个大小为3的小顶堆，如果频率更多一些，则用这个小顶堆进行扫描）