【Leetcode】top 100 多维动态规划

62 不同路径

一个机器人位于一个 m x n 网格的左上角，机器人每次只能向下或者向右移动一步，机器人试图达到网格的右下角，问总共有多少条不同的路径？

分析：dp[i][j] 代表走到 (i, j) 的路径总和数

递推规律：dp[i][j] = dp[i-1][j] + dp[i][j-1]

初始条件：dp[0][:] = 1 dp[:][0] = 1
class Solution(object):def uniquePaths(self, m, n):""":type m: int:type n: int:rtype: int"""dp = [[1]*n for _ in range(m)]for i in range(1, m):for j in range(1,n):dp[i][j] = dp[i-1][j] + dp[i][j-1]return dp[-1][-1]# 滚动数组更新，记录dp可同时表示i-1和i行
# 因为更新dp[i][j]时需要用到的dp[i-1][j]未被更新，而dp[i][j-1]已更新
class Solution(object):def uniquePaths(self, m, n):""":type m: int:type n: int:rtype: int"""dp = [1]*nfor i in range(1, m):for j in range(1,n):dp[j] = dp[j] + dp[j-1]return dp[-1]
官方技巧：移动到 (m, n) 总共需要 m+n-2 步，其中必有 m-1 步向下移动，n-1 步向左移动，故总路径为组合数：C(m+n-2)(m-1)

64 最小路径和

给定一个包含非负整数的 m x n 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。说明：每次只能向下或者向右移动一步。

分析：dp[i][j] 代表走到 (i, j) 的数字总和

递推规律：dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + nums[i][j]

初始条件：dp[0][j] = sum(nums[0][:j]) dp[i][0] = sum(nums[:i][0])

class Solution(object):def minPathSum(self, grid):""":type grid: List[List[int]]:rtype: int"""m, n = len(grid), len(grid[0])dp = [[0]*n for _ in range(m)]for i in range(m):for j in range(n):if i==0:dp[i][j]=dp[i][j-1]+grid[i][j] elif j==0:dp[i][j]=dp[i-1][j]+grid[i][j] else:dp[i][j] = min(dp[i-1][j], dp[i][j-1])+grid[i][j]return dp[-1][-1]# 这里有个trick，因为要处理0行0列，所以初始化必须得是0
# 因为处理0行0列时-1行-1列还没处理，元素均为0，不会对累加产生影响

5 最长回文子串

给你一个字符串 s，找到 s 中最长的回文子串。

方法一：二维动态规划

分析：dp[i][j] 代表 s[i:j] 是否为回文子串的情况

递推规律：dp[i][j] = dp[i+1][j-1] + (s[i]==s[j])

初始条件：i=j时 dp[i][j] = true

需要记录最长长度和起始位置；注意dp的！！！更新方向！！！
class Solution(object):def longestPalindrome(self, s):""":type s: str:rtype: str"""dp = [[False]*length for _ in range(length)]start, maxlen, length = 0, 0, len(s)for i in range(length-1,-1,-1):for j in range(i,length):if j==i:dp[i][j] = Trueelif j==i+1:if s[i]==s[j]:dp[i][j] = Trueelse:if dp[i+1][j-1] and s[i]==s[j]:dp[i][j] = Trueif dp[i][j]:maxlen = max(maxlen, j-i+1)if maxlen == j-i+1:start = ireturn s[start:start+maxlen]# 问题出在需要用dp[i+1][j-1]决定dp[i][j]的状态，所以需要先更新dp的左下方（i需要倒序）
方法二：中心扩散法

回文子串的有1or2个中心；
class Solution(object):def longestPalindrome(self, s):""":type s: str:rtype: str"""out = ''for i in range(len(s)):sub1 = self.palindrome(s, i, i)sub2 = self.palindrome(s, i, i+1)out = sub1 if len(sub1) > len(out) else outout = sub2 if len(sub2) > len(out) else outreturn outdef palindrome(self, s, l, r):while l >= 0 and r < len(s) and s[l] == s[r]:l -= 1r += 1return s[l+1:r]
相同时间复杂度的情况下，方法二比方法一节省了内存开销；

减小时间复杂度：马拉车算法...

1143 最长公共子序列

给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。如果不存在公共子序列，返回 0 。

分析：dp[i][j] 代表 text1[0:i] 和 text2[0:j] 的最长公共子序列的长度

递推规律：当text1[i] = text2[j]时，dp[i][j] = dp[i-1][j-1]+1

当text1[i] != text2[j]时，dp[i][j] = max(dp[i-1][j], dp[i][j-1])

初始条件：dp[0][:]=0 dp[:][0]=0
class Solution(object):def longestCommonSubsequence(self, text1, text2):""":type text1: str:type text2: str:rtype: int"""m, n = len(text1), len(text2)dp = [[0]*(n+1) for _ in range(m+1)]for i in range(1,m+1):for j in range(1,n+1):if text1[i-1]==text2[j-1]:dp[i][j] = dp[i-1][j-1]+1else:dp[i][j] = max(dp[i-1][j], dp[i][j-1])return dp[-1][-1]

72 编辑距离

给你两个单词 word1 和 word2， 请返回将 word1 转换成 word2 所使用的最少操作数 。你可以进行插入/删除/替换三种操作；

分析：dp[i][j] 代表 word1[0:i] 转换成 word2[0:j] 使用的最少操作数；

递推规律：当 word1[i-1] = word2[j-1] 时，dp[i][j] = dp[i-1][j-1]

  当 word1[i-1] != word2[j-1] 时，dp[i][j] = min(增/删/改)+1

                增：word[i-1][j] 删：word[i+1][j] 改：word[i-1][j-1] 但增/删会卡死i的遍历方向；

                        增加word1和删减word2的操作数等价：word1=smile word2=smilea

                        增：word[i-1][j] 删：word[i][j-1] 改：word[i-1][j-1]

初始条件：dp[0][j]=j dp[i][0]=i
class Solution(object):def minDistance(self, word1, word2):""":type word1: str:type word2: str:rtype: int"""m, n = len(word1), len(word2)dp = [[0]*(n+1) for _ in range(m+1)]for i in range(m+1):for j in range(n+1):if i==0:dp[i][j] = jelif j==0:dp[i][j] = i else:if word1[i-1]==word2[j-1]:dp[i][j] = dp[i-1][j-1]else:dp[i][j] = min(dp[i-1][j-1], dp[i-1][j], dp[i][j-1])+1return dp[-1][-1]