深度不学习！！的博客

显然不会，因为哈希表本身就是记录所需元素的个数的，一开始，那些不需要的元素是没有进行初始化的，或者说初始化为0，遇到一个则变成-1。在第二步的时候，count为0了，虽然此时窗口内的长度已经覆盖了t，但是并不是要立即记录窗口的长度值。right不断往右的过程中，遇到字符先判断hs里该值对应的value是否大于0，如果大于0，则表示是我们需要的值，此时再让count减一。所以在判断何时终止左边界的时候就非常好想了，如果碰到左边界的值在哈希表中的value为0了，则说明这个左边界的值是必须需要的，此时终止。

例如：98，一旦出现strNum[i - 1] > strNum[i]的情况（非单调递增），首先想让strNum[i - 1]–，然后strNum[i]给为9，这样这个整数就是89，即小于98的最大的单调递增整数。从后向前遍历不断寻找 下标 i 的值小于 i-1 的情况(不符合递增)，则让 i 的值减1，然后让 i 后面的值都变成9(贪心原则)。举个例子，数字：332，从前向后遍历的话，那么就把变成了329，此时2又小于了第一位的3了，真正的结果应该是299。输入: n = 1234。

思路：从a开始遍历，a的最后一次出现的位置是8，如果从a到8这个位置之间的所有元素的最远位置都在8之内，则这就可以划分为一个区间。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。返回一个表示每个字符串片段的长度的列表。像 “ababcbacadefegde”, “hijhklij” 的划分是错误的，因为划分的片段数较少。划分结果为 “ababcbaca”, “defegde”, “hijhklij”。比如下图第二个区间中的d最远距离为14，扫描到e的时候，最远距离更新为15.

记录第一个值的右边界，不断遍历后续的值的左边界，如果后续的左边界都小于刚才记录的右边界，则表示 这些都值都有重叠区间，可以一箭射完。输入：points = [[10,16],[2,8],[1,6],[7,12]]显然我们要先考虑小的气球，因为考虑大的可能射不到小的，先考虑小的能射到大的。输入：points = [[1,2],[3,4],[5,6],[7,8]]输入：points = [[1,2],[2,3],[3,4],[4,5]]-在x = 6处射出箭，击破气球[2,8]和[1,6]。

举例：上了第一节体育课，老师给大家排好了体操的队伍，可是大家脑子都很笨，记不清自己在哪，老师说，你就看前面有几个比自己高的就行！就像这样：[[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]该上第二节课的时候，大家记住了前面有几个比自己高的，却还是忘记了怎么排，老师见状让学生从高到低排好队，身高一样的，比自己高的越多，越往后面站，像这样：

正向遍历： 87>2，则评分为87的同学糖果数 为 评分为2的同学的糖果数加1，初始为1，1，1。此时变成了2，1，1.。再次扫描到2的时候，评分为2的同学为 评分为1的同学的糖果数+1，糖果数就变成了2，2，1。这时候就发现不对了，还要修改87评分的同学的糖果数。反向遍历： 2>1 则评分为2的同学的糖果为 评分为1的同学的糖果数加1。评分为87的同学糖果数为 评分为2的同学的糖果数加1。没绕进去，这就是一个很简单想通的问题，因为每个数的更新需要依靠右边的值，的所以要右边的值先更新，再更新左边的值。

感觉这是一道逻辑题。经常开长途高速的司机朋友应该比较容易懂？？玄学了。。。

本着有便宜不占王八蛋的原则，贪心走起。

相反，[1, 4, 7, 2, 5] 和 [1, 7, 4, 5, 5] 不是摆动序列，第一个序列是因为它的前两个差值都是正数，第二个序列是因为它的最后一个差值为零。其中一个是 [1, 17, 10, 13, 10, 16, 8] ，各元素之间的差值为 (16, -7, 3, -3, 6, -8)。例如， [1, 7, 4, 9, 2, 5] 是一个 摆动序列 ，因为差值 (6, -3, 5, -7, 3) 是正负交替出现的。输入：nums = [1,17,5,10,13,15,10,5,16,8]

从公式dp[i][j] = dp[i + 1][j - 1] + 2 和 dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]) 可以看出，dp[i][j]是依赖于dp[i + 1][j - 1] 和 dp[i + 1][j]。最后一个出来的元素肯定是最右上角的元素，反想dp含义dp[i][j] 表示数组[i:j] 中的最长回文子序列的长度。即：dp[i][j] = max(dp[i + 1][j], dp[i][j - 1])回文字符串 是正着读和倒过来读一样的字符串。

替换掉A的末尾元素 也就是 A[i-2]，使其等于B[j-2],那么就是以下标 i−2 为结尾的 word1 与 j−2 为结尾的 word2 的最近编辑距离 即 dp[i-1][j-1] 再加上一个替换元素的操作 ， dp[i-1][j-1]+1.删A的一个元素，那么就是以下标 i−2为结尾的 A与j−1 为结尾的 B的最近编辑距离 再加上一个操作。删B的一个元素，那么就是以下标 i−1为结尾的 A与j−2 为结尾的 B的最近编辑距离 再加上一个操作。

只要记住这里可能是0 到 i , 1 到 i , n到i，反正就是 不管是从哪里到i，dp[i] 就表示到下标i的子序列的最大和。这块就要回头看dp的含义了，dp表示以i下标为结尾的，也就是以nums[i]为结尾的最大子数组和，所以当前的nums[i]无论如何必加入。遍历到nums[i] 的时候，肯定是要这个值，因为我们dp的含义就是到这个值的，也就是从这个值之前的子数组的最大和。这里有一个东西就是返回什么值，要看dp的含义，再来一遍，dp[i] 定义为以下标i为结束下标的子数组的最大和。

这三道题思路基本一样，尤其是最后两道，代码都一样，一点不需要改的，所以放一起把。

连续递增的子序列 可以由两个下标 l 和 r（l < r）确定，如果对于每个 l

主要是为了给持有状态下使用的，持有状态中有一个情况是：今天买入，则前一天不能卖的约束，而这里分出来的情况刚好应对这种约束，即i天买入变为持有状态，则 i-1 天为非持有且非i-1天卖的情况，也就是上面分的情况里的第二个。第 i天非持有状态,且非i天当天卖出: dp[i][0]=max(dp[i-1][0],dp[i-1][2])第 i 天持有状态 :dp[i][1]=max(dp[i-1][1],dp[i-1][0]-p[i])第 i天非持有状态，且非i天当天卖出 ：定义状态为dp[0][0]

解释：在第 2 天 (股票价格 = 2) 的时候买入，在第 3 天 (股票价格 = 6) 的时候卖出, 这笔交易所能获得利润 = 6-2 = 4。所以就是： dp[i][2] = max(dp[i-1][2],dp[i-1][1]+prices[i])所以就是：dp[i][1] = max(dp[i-1][1],dp[i-1][0]-prices[i])继续从2次中找规律，每次买入的时候都是-prices[0]，卖的时候都是0.dp[i][j] ：第i天的状态为j，所剩下的最大现金是dp[i][j]

所以就是： dp[i][2] = max(dp[i-1][2],dp[i-1][1]+prices[i])所以就是：dp[i][1] = max(dp[i-1][1],dp[i-1][0]-prices[i])所以：dp[i][3] = max(dp[i-1][3],dp[i-1][2]-prices[i])公式：dp[i][4] = max(dp[i-1][4],dp[i-1][3]+prices[i])dp[i][1]: 表示 第 i 天 第一次持有股票的状态 时手里的最大金额。

解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3。输入：prices = [7,1,5,3,6,4]

贪心这个思路就比较简单了，在遍历数组的同时一直记录遍历过数值的最小值，然后不断计算当前遍历的元素 与 最小值之间的差，遍历的过程中保存这个差的最大值。dp[0][0]表示第 0 天持有股票，这不可能是前几天买入的，所以必然是今天买入的，所以此时 dp[0][] = -prices[0]解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5。同时，你不能在买入前卖出股票。dp[0][1]表示第0天不持有股票，那肯定手里的钱就是0了。

我是一个专业的小偷！！！！据说这道题传播暴力，犯罪思想，即将被和谐？且做且珍惜哈哈，少有的有点意思的题了这是。老规矩，dp五步走

在计算新的dp[j]的时候，肯定要继承上一个dp[j]的状态，这里我说一个例子吧，假如本轮状态要考虑加入2这个数，上一轮状态没有考虑2，此处要明白上一轮虽然没有考虑2，但是已经装满背包j了，上一轮的状态dp[j]已经是要记录的答案了，只是没有考虑2，所以本轮计算新的dp[j]的时候要算上上一轮的答案，然后再计算本轮考虑了2的结果这个自然就是dp[j-2]，这点不懂的话可以看01背包理论基础。当前填满容量为j的包的方法数 = 之前填满容量为j的包的方法数 + 之前填满容量为j - num的包的方法数。

也是两种情况，不放这个石头 则dp[j] = dp[j]，放这个石头那就是dp[j-stones[i]]+stones[i] (腾出即将放进来的石头的容量，加上他的价值)这个没啥好说的 直接是全0就行了，只是有一点要注意，dp[j]表示背包容量为j，所以dp的长度要初始化成 总和的一半再加1。组合 2 和 4，得到 2，所以数组转化为 [2,7,1,8,1]，组合 7 和 8，得到 1，所以数组转化为 [2,1,1,1]，组合 2 和 1，得到 1，所以数组转化为 [1,1,1]，

在一个 m*n 的棋盘的每一格都放有一个礼物，每个礼物都有一定的价值（价值大于 0）。给定一个棋盘及其上面的礼物的价值，请计算你最多能拿到多少价值的礼物？这个就很简单了，题目告诉了每一步只能往右边或者下边走，所以每一个格子取决于其左边或者上边的最大值(上一步的最优状态)。这种没有固定顺序，先遍历行也行，先遍历列也行，因为他们所需要的格子(左侧或上侧)都已经初始化好了。即 dp[i][j] = max(dp[i-1][j],dp[i][j-1])dp[i][j] 表示到[i][j]这个格子时的最大礼物值。

里面循环范围是从 target到nums[i]（含），这里我一开始就写错了，注意这里的里层循环遍历的是背包容量，如果你的背包容量已经无法装下当前的 i 物品了，那就不用往后进行了，所以是到nums[i]截至。背包容量就是 target， dp[j] 则代表 背包容量为j时能凑的最大的子集和为dp[j]，最后如果 dp[target] == target 则就是找到了某个子集使其等于目标值。递推公式:dp[j] = max(dp[j],dp[j-nums[i]]+nums[i])

有很多种背包 ，完全背包啊概率背包啊，多重背包啥的，但都逃不过01背包，01背包是基础、题目大概是这样的：有一个小偷，背着书包去偷东西，这个小偷的背包有固定容量，所偷的物品有固定的价值和其对应的重量。现在问，小偷能偷走东西的最大价值。老规矩。

i-j 可以继续拆分，那么实际上这里就可以直接使用之前计算过的j的最优解 也就是 dp[i-j],此时乘积就是 j *dp[i-j]。这一点其实从遍历顺序里就能看出来，第二层的for 里 j从1遍历到了i，所以j其实是已经从1拆分到了i的，所以不需要考虑拆分他了。我在评论看到一个用数学方法找递推公式的，这里就浅说一下，证明一堆，总之就是，一个整数的拆分后的最大乘积一定是。然后就是要拆分的那个j，j从1遍历到i，这块别写错了，假如拆10的话，最多就是1和9。局部的去想这个问题，一个数 i 的拆分情况。

动态规划问题都有一种局部操作的思想，这道题就是看到[i][j]有几种路径由谁决定，由于题目已经说了，只能由往右边或者下边走，所以到[i][j] 的不同路径数，由dp[i-1][j]和dp[i][j-1]相加决定。一开始dp数组全部为0，只要障碍物不在起点，则就让dp[0][0] =1 依此来初始化dp[i][0]和dp[0][j]的值。所以有递推公式：dp[i][j] = dp[i-1][j]+dp[i][j-1]最终结果显然是dp[-1][-1]。那么在dp数组里就是 1，1，1，1，0，0，0。

这点很重要比如cost = [10,15,20] 从1号位置开始走两步，直接能达到X的位置，花费15。为最小花费。

从递推公式F(n) = F(n - 1) + F(n - 2)可以看出来，i 项和 i+1 项 决定了i+2项，所以从前往后遍历。其实可以从递推公式F(n) = F(n - 1) + F(n - 2)里看出来，我们只需要维护两个值就可以了。入门题嘛，题目里已经给出出来了，F(n) = F(n - 1) + F(n - 2)。F(n) = F(n - 1) + F(n - 2)，其中 n > 1。解释：F(3) = F(2) + F(1) = 1 + 1 = 2。给定 n ，请计算 F(n)。

比如刚才的[1,1,1] 在不用startindex的循环中，每一层的每一次都会考虑所有的nums= [1,2,3]里的数值，第一次取1,下一层依旧从[1,2,3]里选，如果没有去重，则又会取1，加入去重之后选择了2，然后选3，正好可以达到目的。上一道题中所给的数组没有重复的值，所以使用非常简单的方法，直接判断了一下当前遍历的元素在path数组里有没有，没有的话再继续操作，而这道题没法用这个方法了，比如[1,1,2]这里有两个1，但是个合法的答案，因为这两个1是不同的元素，只是值相等。

这是这道题比较有意思的地方，终止条件可以理解为，收集结果的地方，实际上对于包括之前的子集问题，是没有终止条件的，就是任何子节点的结果都需要，而这道题唯一需要注意的两个地方就是，当前记录的答案里面是不是的元素是不是大于1个，而且是不是递增的。输出：[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]因为这道题需要去重，而又不能用之前组合总和2里的那个去重思路，因为这是找子序列，不能排序，排序之后顺序就乱了。输出：[[4,4]]

这道题和前面不同的唯一的地方就是这个终止条件，可以老规矩画树出来看看，实际上在本题下，树上的每一个节点都要收集，所以说这道题没有终止条件，只要循环体for循环完成就行了。这道题对比前几个回溯的题，明显简单了一些，就是终止条件那块稍微变动了一下，这算是回溯的另一个小块，前面是组合和分割，这个算是集合 子集的一个小分支吧。输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]思路就是，每次遍历一个元素，都让当前答案集里的每一个集合都加上这个元素，再放入答案集。

还有一点就是题目要求不得删改原s字符中的数值，但是题目s所给长度范围又达到20个，而合法ip最大长度也就是每一段都是3个字符，所以最长也就是12个字符，在这里可以设置一个终止条件，就是所给s长度大于12，则直接return。这道题也是分割，而且比上一个字符串分割感觉看上去要清晰一些，也是找组合的题嘛，回溯嘛，你要问我能不能暴力，我只能说， 可以暴力，看到有人这么做了，N层for，写到怀疑人生。这里的参数非常简单，就一个值，就是startindex，用于记录下次从哪里开始遍历。输入：s = “101023”

在之前的回溯中已经比较套路化了，for里的i变量控制横向，startindex控制纵向告诉下一层横向的i从哪里开始，所以实际上这里的startindex就是切割点。这个题的参数比较好确定，一个是记录路径上元素的列表path，另一个就是回溯中常用的startindex了，这个参数就不多说了，之前的文章里说了N边啦。看上面我偷的那个图，里面的 ‘|’ 表示分割，显然，当 分割符到字符串末尾的时候，表示分割完了，也就是到叶子节点了。输出：[[“a”,“a”,“b”],[“aa”,“b”]]输出：[[“a”]]

其实是本题的要求，例子还是[1,1,2]，你可以 ----第一个1和第二个1组成[1,1]，因为他们使用了不同 1，只是值相同而已，这里显然是取第一个1下面的分支的操作过程，所以在一个组合里，元素是可以相同的，而如果你取的是第一个1和2，以及第二个1和2，这样就以为着有两个相同的组合 [1,2]了，虽然用的不是同一个1，但题目不允许这样。这时候就是切分支带来的重复结果，所以我们要判断是不是切分支了，如果没切分支，重复是可以的，因为一个分支最终的叶子就是一个组合结果。的进化版，先做39再做这个比较好。

这里的startindex要搞清楚，他是记录 当前遍历下标从哪里开始的，在一个集合里取值 比如[2,3] 那么你取的是组合，此时 [2,3] 和[3,2]这俩是一样的，所以要记录遍历的下标，防止往回取。首先对数组排序 [2,3,5] 则可以发现，第一轮取了2之后，下面的分支可以2和3和5，在取3的时候，2+3已经超过4了 所以后面的分支就没必要进行了，就在这里剪枝。所以这里的剪枝 其实 只有2后面分支的3和5不需要考虑，而2，2这个分支还是需要的，所以是横向分支剪枝，所以这个剪枝放在for里。

这里为啥不是 index == len(digits) -1呢，因为终止条件在下面for循环处理的前面，如果这里 是index == len(digits) -1 就终止了，相当于digits的最后一个元素没处理。这里的循环要注意，刚开始的时候说过了，横向控制的是数字映射的字母个数，所以这里要取出来里面有多少个字母，遍历他们。输出：[“ad”,“ae”,“af”,“bd”,“be”,“bf”,“cd”,“ce”,“cf”]输出：[“a”,“b”,“c”]输入：digits = “2”

第二个可以剪的地方，就是i的最大遍历起始位置，这一点在上一题中也详细的说过了，这里就不说了，公式： 9 - (k - len(temp)) + 1 + 1。终止条件就很简单了，如果temp里的个数等于题目所给，则终止，在此之前若temp里的和等于题目所给的值，则先记录到答案集合再终止。在[1,9]范围内使用4个不同的数字，我们可以得到的最小和是1+2+3+4 = 10，因为10 > 1，没有有效的组合。这次的题目和上一次的有所不同，上一个题给的n是从1到n个数遍历，组合为k个数。输出: [[1,2,4]]

看一下需要剪掉的部分，当记录数组temp中为空，且当前i取3的时候，剩下可取元素为4，那么取了3再进入一下分支取4，temp中也仅有两个值。首先需要题目给出的n和k没跑了，另外还有一个，可以在图中看到，当选择1之后，只能从2，3，4里再选，选择2之后，只能从剩下的3，4里选，也就是，选择i之后，只能从i+1里去选，所以要有一个记录下标的值startindex。假设n=4，k=4 也就是 一共四个数，取4个数，这里盗用一下卡哥的图，可以看到 除了最左边的一条，其余都不符合要求，都可以剪掉。

这是一个误区~~不会出现这种情况，因为一开始说了，要记住一点，这是一个单调队列，最左边存的永远是最大值，也就是说，这个例子当11进队的时候，[1，2] 这两个元素必然已经被弹出去了。首先弄一个列表当单调队列， queue = [X,X,X,X,X,X,X] 这里面放了一堆元素，元素从左边进，从右边出，要始终记住一点，这是个单调队列，递增或递减，这里用递减，也就是 最左边的元素也就是 queue[0]始终是最大值。输入：nums = [1,3,-1,-3,5,3,6,7], k = 3。