【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]*n
        for 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] = True
                elif j==i+1:
                    if s[i]==s[j]:
                         dp[i][j] = True
                else:
                    if dp[i+1][j-1] and s[i]==s[j]:
                        dp[i][j] = True
 
                if dp[i][j]:
                    maxlen = max(maxlen, j-i+1)
                    if maxlen == j-i+1:
                        start = i
        return 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 out
            out = sub2 if len(sub2) > len(out) else out
        return out
 
    def palindrome(self, s, l, r):
        while l >= 0 and r < len(s) and s[l] == s[r]:
            l -= 1
            r += 1
        return 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]+1
                else:
                    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] = j
                elif 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])+1
        return dp[-1][-1]