sjsjs11的博客

我们可以使用堆来模拟丑数的情况，我们定义一个堆，堆顶是最小的数，这个时候我们让堆顶的数乘以factors的三个不同因子的情况，继续加入到堆中，然后将堆顶元素弹出，这个时候堆顶元素就是第二小的数（包含已弹出的最小数），也就是第二个丑数，然后不断继续将堆顶元素乘以factors中顶三个不同因子，得到更多丑数。这时候我们要将他们正确插入到dp中，这时候就找其中最小的数也就是2放到dp[2]中，dp[2]中放的是1x2。那么三者中3最小，所以dp[3]中存放的是1x3=3，这个时候令p3++指向2。

也就是我们在计算dfs(i,j)的时候，我们不断猜测k，我们既要计算出此时选择k的最大支付金额的路径（即运气最差的时候）。我们定义一个ans来记录dfs中最小能保证获胜的支付金额，首先我们先在i到j的范围内不断猜测数字k是多少，然后定义一个cost来代表选择k的时候可能最坏情况，而ans用来表示我们应该选取哪个k可以保证最小的最大支付金额。递推的边界情况是i >= j，因为这个时候i=j，我们可以猜对数字，所以这个时候的开销是0。每当你猜了数字 x 并且猜错了的时候，你需要支付金额为 x 的现金。

我们观察题目可以发现，题目中最多有三种分数，他们取决于第一次操作采用哪一种方式。也就是说如果我们采用回溯的方式，那么我们可以根据第一次操作的方式来分别进行回溯，因为这样子就知道后面回溯的分数要等于多少。我们定义dfs(i,j)表示下标i到j的nums的相同分数的最大操作数目是多少，也就是说当我们知道我们要使分数为target，那么假设有一种方式。我们回溯的界限是当i >= j当时候，返回0，因为已经无法进行任何操作。输入：nums = [3,2,1,2,3,4]输入：nums = [3,2,6,1,4]

我们要求子序列构造的最长回文串长度，实际上就是将word1和word2合成一个字符串，然后求最长回文串长度，由于题目要求word1和word2都要有字符构成回文串。当s[i] = s[j]的时候，dp[i][j]一定包含s[i]和s[j]，那么我们就可以判断i如果在word1范围内，j在word2范围内，就说明该dp[i][j]记录的最长回文串长度一定有word1和word2贡献的字符。解释：从 word1 中选出 “ab” ，从 word2 中选出 “cba” ，得到回文串 “abcba”。

我们转变思路，要找到最少插入次数，实际上就是要找最长的回文子序列的长度是多少，然后剩下的字符我们就需要插入字符配对构成回文串。给你一个字符串 s ，每一次操作你都可以在字符串的任意位置插入任意字符。解释：字符串 “zzazz” 已经是回文串了，所以不需要做任何插入操作。解释：插入 5 个字符后字符串变为 “leetcodocteel”。解释：字符串可变为 “mbdadbm” 或者 “mdbabdm”。输入：s = “leetcode”输入：s = “zzazz”输入：s = “mbadm”

我们定义一个三维数组dp[k][i][j]来表示在i到j范围内并且以k开头的回文子序列的总数。当s[I] = s[j]的时候，那么i+1到j-1中的回文子序列加上两边的x都是以x为开头的回文子序列，并且字符c可以构成c或者cc两个回文子序列，所以有状态转移方程。因此，当前子串 s[i…j] 中以 c 为边界的回文子序列，与子串 s[i…解释：6 个不同的非空回文子字符序列分别为：‘b’, ‘c’, ‘bb’, ‘cc’, ‘bcb’, ‘bccb’。s[i] 仅包含 ‘a’, ‘b’, ‘c’ 或 ‘d’

定义dp[i][j]为从i到j到最大回文子序列长度，然后遍历i和j的索引，如果s[i] = s[j]，那么就可以由dp[i+1][j-1]+2状态转移而来，否则可以由max(dp[i+1][j], dp[i][j-1])进行状态转移而来。子序列定义为：不改变剩余字符顺序的情况下，删除某些字符或者不删除任何字符形成的一个序列。给你一个字符串 s ，找出其中最长的回文子序列，并返回该序列的长度。解释：一个可能的最长回文子序列为 “bbbb”。解释：一个可能的最长回文子序列为 “bb”。

因此，最终答案是 36-2 = 34。时间复杂度：O(n m^2 k)，其中 n 是掷骰子的次数，m 是随机数的种类数，在本题中等于 6，k 是 rollMax 数组中的最大值。这道题我们定义一个三维数组dp[i][j][k]表示已经完成了i次投掷，并且第i次投掷的结果是是数字j，然后j已经连续摇到了k次。输入：n = 2, rollMax = [1,1,2,2,2,3]输入：n = 2, rollMax = [1,1,1,1,1,1]输入：n = 3, rollMax = [1,1,1,2,2,3]

这道题我们定义一个三维数组dp[i][j][m]，i代表在前i个数中的,最多能进行j次操作1，m次操作2的最小数组和。接下来我们还要考虑既进行操作1又进行操作2的情况，由于nums[i]一定是非负数，所以我们如果能先除后减最好，我们可以将两个操作的计算都进行放置在。输入： nums = [2,8,3,19,3], k = 3, op1 = 1, op2 = 1。对 nums[1] = 4 应用操作 1，使 nums[1] = 2。对 nums[2] = 3 应用操作 2，使 nums[2] = 0。

解释：青蛙可以成功过河，按照如下方案跳跃：跳 1 个单位到第 2 块石子, 然后跳 2 个单位到第 3 块石子, 接着 跳 2 个单位到第 4 块石子, 然后跳 3 个单位到第 6 块石子, 跳 4 个单位到第 7 块石子, 最后，跳 5 个单位到第 8 个石子（即最后一块石子）。也就是说从第i-1块石头开始可以跳i步，如果第i-1块石头和第i块石头之间的距离大于i步，那么就直接return false。当i为n-1并且dp[i][k]为true的时候，说明可以到最后一块石头，则返回true。

这道题可以定义一个三维数组dp[i][j][k]用来表示走了i步后落在位置(j,k)的路径总数。，count是dp[i][j][k]，j1和k1是第i+1步后落的位置。输入：m = 2, n = 2, maxMove = 2, startRow = 0, startColumn = 0。输入：m = 1, n = 3, maxMove = 3, startRow = 0, startColumn = 1。注：由于i+1只由i转移而来，可以压缩dp[i][j][k]为dp[j][k]，进行空间优化。

首先我们要初始化第一列的值，我们假设第一列的值可能是0~9之间任何一个值k，然后grid第一列中不等于k则要修改成k，所以有多少个不等于k的值就要操作多少次，记录到cost中，最后dp[0][k] = cost。如果下面相邻格子存在的话，它们的值相等，也就是 grid[i][j] == grid[i + 1][j]（如果存在）。输入：grid = [[1,0,2],[1,0,2]]输入：grid = [[1,1,1],[0,0,0]]输入：grid = [[1],[2],[3]]

arr1 是单调 非递减 的，换句话说 arr1[0] <= arr1[1] <= …<= arr1[n - 1]。arr2 是单调 非递增 的，换句话说 arr2[0] >= arr2[1] >= …>= arr2[n - 1]。对于所有的 0 <= i <= n - 1 都有 arr1[i] + arr2[i] == nums[i]。给你一个长度为 n 的 正 整数数组 nums。输入：nums = [5,5,5,5]请你返回所有 单调 数组对的数目。输入：nums = [2,3,2]

首先由于arr1是非递减的，那么也就是说arr1[i] >= arr1[i-1]，然后arr2是非递增的，也就是说arr2[i] <= arr2[i-1]。我们假设arr1[i]为j，arr1[i-1]为k，arr2[i] = nums[i] - j而arr2[i-1] = nums[i-1] - k。那么我们知道了最大值k，我们就可以知道当前f[i][j]可以由f[i-1][0],f[i-1][1]…+f[i-1][k]的值，我们可以计算上一个状态的前缀和，当我们知道最大的k的时候就可以直接使用。

设有n件工作分配给n个人，将工作i分配给第j个人所需的费用cij。试设计一个算法，为每个人都分配1件不同的工作，并使总费用最小。（c++记忆化搜索）

羽毛球队有男女运动员各n人。给定2个nxn矩阵P和Q。P[i][j]是男运动员i和女运动员j配对组成混合双打的男运动员竞赛优势；Q[i][j]是女运动员i和男运动员j配合的女运动员竞赛优势。P[i][j]不一定等于Q[j][i]。男运动员i和女运动员j组成的男女双方竞赛优势为多少？

由于状态j一直是由上一个状态j-1进行状态转移而来，那么可以定义一个新的一维数组来储存上一轮的j-1状态下的dp[i]是多少，于是我们可以使用滚动数组的方式将二维压缩成一维，最后返回dp[0]即可。最开始想到的办法是定义一个二维数组dp[i][j]，来表示在i的位置的时候，并且以及已经进行了j步，最后所能到达下标0的位置的方案数。最后我们能列出状态转移方程。给你两个整数 steps 和 arrLen ，请你计算并返回：在恰好执行 steps 次操作以后，指针仍然指向索引 0 处的方案数。

由于观察状态转移方程i都是由上一个状态i-1状态转移而来，那么我们可以采用滚动的方式进行空间压缩，我们定义dp[c]为以字符c为结尾的最长理想子序列的长度，并且而外定义一个变量maxLen来记录被转移状态的最长理想子序列的长度，所以当前的最长理想子序列长度就是。对于子序列题目，我们通常可以定义一个二维数组dp[i][c]用来表示在s的前i个字符（i从0开始）并且以c字符作为结尾的最长理想子序列。最后假设我们不以s[i]作为结尾，那么当前的状态dp[i][j]则要继承上一个状态的dp[i-1][j]。

输入：n = 3, k = 2, stayScore = [[3,4,2],[2,1,2]], travelScore = [[0,2,1],[2,0,4],[3,2,0]]这道题我们可以使用记忆化搜索的方法，我们定义状态为 dfs(i,j)，表示第 i 天到第 k−1 天，从城市 j 开始旅游，可以获得的最多点数。输入：n = 2, k = 1, stayScore = [[2,3]], travelScore = [[0,2],[1,0]]旅客从城市 1 出发并停留在城市 1 可以得到最多点数。

这道题我们需要注意的是如何定义dp的范围，由于startPos和k都在1000以内，那么负轴上最低的是startPos-k，因为startPos是正整数，所以负轴上最低是-999，正轴上最高是startPos+k，也就是2000，那么他们的范围就是3000，由于方便处理动态规划过程中的边界问题，令dp的行大小为3000+2。那么我们可以知道dp[i][j]可以由dp[i-1][j-1]和dp[i+1][j-1]状态转移而来。输入：startPos = 1, endPos = 2, k = 3。

举个例子，如果在铺第i列的时候，我们铺完后第i列只有上面方块被覆盖，也就是dp[i][1]，那么如图可以知道，我们如果第i-1列没有任何方块，那么它可以用一个倒L来使得第i-1列全部被覆盖，并且第i列的上面方块被覆盖。或者第i-1列只有下面方块被覆盖，我们可以使用一个横着的两格砖块来使第i-1列全部被覆盖并且第i列的上面方块被覆盖。两个平铺不同，当且仅当面板上有四个方向上的相邻单元中的两个，使得恰好有一个平铺有一个瓷砖占据两个正方形。给定整数 n ，返回可以平铺 2 x n 的面板的方法的数量。

一个是当我们发现了棋子的终点位置，我们可以知道他在一次移动中能够到达的起始位置是哪里，我们定义一个数组moves来储存这些信息，moves的索引则是棋子的终点的位置。解释：我们可以拨打的所有有效号码为[04, 06, 16, 18, 27, 29, 34, 38, 40, 43, 49, 60, 61, 67, 72, 76, 81, 83, 92, 94]象棋骑士有一个独特的移动方式，它可以垂直移动两个方格，水平移动一个方格，或者水平移动两个方格，垂直移动一个方格(两者都形成一个 L 的形状)。

这道题我们要储存三个状态，一个是天数，一个是缺勤的次数，一个是最后几天连续迟到的天数。首先当以P为结尾的时候，说明是到课的，那么就是说前一天只要是能得到出勤奖励，那么这一天也一定会有出勤奖励，得到状态转移方程。给你一个整数 n ，表示出勤记录的长度（次数）。如果最后一天是L，那么说明最后一天迟到了，那么前一天最多只能迟到一次，否则最后一天无法满足出勤奖励，所以得出状态转移方程。如果最后一天是A，那么就说明要满足出勤奖励，则前一天不能有缺勤的情况，因为缺勤两次就无法满足出勤奖励，得到状态转移方程。

解释：所有可能的字符串分别是：“ae”, “ea”, “ei”, “ia”, “ie”, “io”, “iu”, “oi”, “ou” 和 “ua”。字符串中的每个字符都应当是小写元音字母（‘a’, ‘e’, ‘i’, ‘o’, ‘u’）解释：所有可能的字符串分别是：“a”, “e”, “i” , “o” 和 “u”。每个元音 ‘e’ 后面只能跟着 ‘a’ 或者是 ‘i’每个元音 ‘o’ 后面只能跟着 ‘i’ 或者是 ‘u’每个元音 ‘i’ 后面 不能 再跟着另一个 ‘i’

T0 = 0, T1 = 1, T2 = 1, 且在 n >= 0 的条件下 Tn+3 = Tn + Tn+1 + Tn+2。答案保证是一个 32 位整数，即 answer <= 2^31 - 1。我们可以定义dp[i] 为Ti ，然后可以根据题目得出状态转移。给你整数 n，请返回第 n 个泰波那契数 Tn 的值。，最后返回dp[n]即可。输出：1389537。

斐波那契数 （通常用 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。定义一个数组dp[i]代表f(n)的值，然后得出状态转移方程。给定 n ，请计算 F(n)。

经典的动态规划基础题，我们可以定义一个dp[i]为爬i个阶梯的方法，那么我们可以列出动态转移方程。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？需要 n 阶你才能到达楼顶。解释：有两种方法可以爬到楼顶。解释：有三种方法可以爬到楼顶。1 阶 + 1 阶 + 1 阶。，最后返回dp[n]即可。

需要注意的是，f[i][d] += cnt + 1的+=不能写成=，这是因为可能出现子序列元素相同的情况，这样就会出现同d不同j的情况，所以我们采用累加的方法。这道题我们先定义数组dp[i][d]表示以nums[i]为结尾，公差为d的等差子序列的个数（包括长度为2的子序列），我们接下来找到状态转移方程。例如，[1, 3, 5, 7, 9]、[7, 7, 7, 7] 和 [3, -1, -5, -9] 都是等差序列。例如，[2,5,10] 是 [1,2,1,2,4,1,5,10] 的一个子序列。

这道题的突破口是我们要明白要满足(a+b) mod k=(b+c) mod k，实际上可以转换成a mod k = c mod k，也就是说有效子序列的奇数项的模k后的数都相同，偶数项模k后的数也相同。我们维护一个二维数组 f[y][x]，表示最后两项模 k 分别为 y 和 x 的子序列的长度，那么也就是说f[3][2]可以由f[2][3] + 1进行状态转移而来。输入：nums = [1,4,2,3,1,4], k = 3。输入：nums = [1,2,3,4,5], k = 2。最后返回ans即可。

接着我们定义一个哈希表indices用来储存每个元素对应的位置，我们现在需要做的就是遍历所有可能的i和j，由于知道arr[i]和arr[j]的值，如果要形成斐波那契数列，那么k的值也能知道。例如， [3, 5, 8] 是 [3, 4, 5, 6, 7, 8] 的一个子序列）解释: 最长的斐波那契式子序列有 [1,11,12]、[3,11,14] 以及 [7,11,18]。输入: arr = [1,3,7,11,12,14,18]输入: arr = [1,2,3,4,5,6,7,8]

最后返回ans即可。给你一个整数数组 arr 和一个整数 difference，请你找出并返回 arr 中最长等差子序列的长度，该子序列中相邻元素之间的差等于 difference。输入：arr = [1,5,7,8,5,3,4,2,1], difference = -2。输入：arr = [1,2,3,4], difference = 1。输入：arr = [1,3,5,7], difference = 1。解释：最长的等差子序列是 [1,2,3,4]。解释：最长的等差子序列是 [7,5,3,1]。

我们可以使用回溯的方法，我们可以遍历数组的每一个元素，然后对他们进行回溯，他们会不断以O(1)的时间复杂度去寻找无序集合s里面是否有他们的平方。如果找到有他们的平方的数，那么就储存最长方波到memo[x]中，并且与ans比较。我们定义nums中的元素为x，我们定义dp[x]为该元素为结尾的最大波长。要进行状态转移的前提是元素x进行根号后是整数（真实运算时），如果判断x进行根号后是整数，那么我们可以列出状态转移方程。输入：nums = [4,3,6,16,8,2]输入：nums = [2,3,5,6,7]

所以为了避免计算不存在days中的天数的过程浪费太多时间，我们可以定义指针i、j、k，用来表示1天、7天、30天三种票，f[i+1] 表示完成 days[0] 到 days[i] 的最小花费。前面的记忆化搜索和递推的方法，都取决于days中最大元素的大小是多少，如果days中最大元素的大小很大，那么就会导致很多计算是不必要的，因为我们实际上在状态转移过程中需要计算的是days[i]存在的天数，如果所计算的天数不属于days[i]，也会往前转移到最近的days[i]元素。，其中 n 是 days 的长度。

我们可以从后向前遍历i，在推算动态转换方程的时候，当我们不选择第i个题目，dp[i]由dp[i+1]转移而来，当我们选择第i歌题目的时候，他由第i到题目的分数并加上。给你一个下标从 0 开始的二维整数数组 questions ，其中 questions[i] = [pointsi, brainpoweri]。输入：questions = [[1,1],[2,2],[3,3],[4,4],[5,5]]输入：questions = [[3,2],[4,3],[4,4],[2,5]]最后返回dp[0]即可。

我们这道题在定义f数组上新增了一个维度，用于储存k的值，定义 f[i][j] 表示参加前 i 个会议中的至多 j 个，能得到的会议价值的最大和。输入：events = [[1,1,1],[2,2,2],[3,3,3],[4,4,4]], k = 3。输入：events = [[1,2,4],[3,4,3],[2,3,10]], k = 2。输入：events = [[1,2,4],[3,4,3],[2,3,1]], k = 2。解释：选择绿色的活动会议 0 和 1，得到总价值和为 4 + 3 = 7。

并且使用 f[i] 表示前 i 份兼职工作可以获得的最大报酬。乘客信息用一个下标从 0 开始的二维数组 rides 表示，其中 rides[i] = [starti, endi, tipi] 表示第 i 位乘客需要从地点 starti 前往 endi ，愿意支付 tipi 元的小费。输入：n = 20, rides = [[1,6,1],[3,10,2],[10,12,3],[11,12,2],[12,15,2],[13,18,1]]输入：n = 5, rides = [[2,5,4],[1,5,1]]

乘客信息用一个下标从 0 开始的二维数组 rides 表示，其中 rides[i] = [starti, endi, tipi] 表示第 i 位乘客需要从地点 starti 前往 endi ，愿意支付 tipi 元的小费。输入：n = 20, rides = [[1,6,1],[3,10,2],[10,12,3],[11,12,2],[12,15,2],[13,18,1]]，其中 m 是 rides 的长度，n 是地点数目。输入：n = 5, rides = [[2,5,4],[1,5,1]]

我们可以以某个offer的end为索引储存到数组group中，储存的是start和gold数据，也就是offer[0]和offer[2]。将位于 [0,0] 范围内的房屋以 1 金币的价格出售给第 1 位买家，并将位于 [1,3] 范围内的房屋以 2 金币的价格出售给第 3 位买家。输入：n = 5, offers = [[0,0,1],[0,2,10],[1,3,2]]输入：n = 5, offers = [[0,0,1],[0,2,2],[1,3,2]]返回你可以赚取的金币的最大数目。

想象我们有一个指针m，他的作用是在m处作为状态转移的位置，于是我们可以由f[m][j-1]也就是从m-1下标开始及之前分割成j-1个回文串需要的最少修改字符数，然后加上cost[m][i-1]也就是f[i][j]。然后我们定义一个二维数组f[i][j]，用 f[i][j] 表示对于字符串 S 的前 i 个字符，将它分割成 j 个非空且不相交的回文串，最少需要修改的字符数。我们遍历数组，然后内层循环j，当j=1的时候，说明不分割，所以f[i][1] = cost[0][i-1]。s 中只含有小写英文字母。

因为由于我们状态进行了压缩，所以f[x]里面实际上保存的信息是上一轮的数据，如果我们i使用正序去遍历，那么f[i]就会覆盖掉f[x]的数据，导致在状态转移的过程中，无法读取到上一轮的f[x]的数据。，也就是说，我们枚举i后，从j-1到i-1的范围内枚举x，这样子f[i][j]就可以由f[x][j-1]加上第x个元素到第i个元素的平均值转移而来。nums 的最优分组是[9], [1, 2, 3], [9]. 得到的分数是 9 + (1 + 2 + 3) / 3 + 9 = 20.输出: 20.00000。