【科学刷题】动态规划

392. 判断子序列

加到【编辑距离】中

解码方法 / 把数字翻译成字符串

剑指 Offer 46. 把数字翻译成字符串

class Solution:
    def translateNum(self, num: int) -> int:
        numbers = str(num)
        L = len(numbers)
        dp=[1]*L
        for i in range(1, L):
            dp[i] = dp[i-1] + (dp[i-2] if '10'<=numbers[i-1:i+1]<='25' else 0)
        return dp[L-1]

class Solution:
    def translateNum(self, num: int) -> int:
        s=str(num)
        n=len(s)
        dp=[1]+[0]*n
        for i in range(1, n+1):
            # if s[i-1]!='0': # diff
            dp[i]+=dp[i-1] # diff
            if i>1 and '10'<=s[i-2:i]<'26': # <= diff
                dp[i]+=dp[i-2]
        return dp[-1]

91. 解码方法

class Solution:
    def numDecodings(self, s: str) -> int:
        n=len(s)
        dp=[1]+[0]*n
        for i in range(1, n+1):
            if s[i-1]!='0':
                dp[i]+=dp[i-1]
            if i>1 and '10'<=s[i-2:i]<='26':
                dp[i]+=dp[i-2]
        return dp[-1]

174. 地下城游戏

174. 地下城游戏

class Solution:
    def calculateMinimumHP(self, dungeon: List[List[int]]) -> int:
        m = len(dungeon)
        n = len(dungeon[0])
        dp = [[inf] * (n + 1) for _ in range(m + 1)]
        dp[m][n - 1] = dp[m - 1][n] = 1
        for i in range(m - 1, -1, -1):
            for j in range(n - 1, -1, -1):
                # minn: 走出这个格子至少能剩下多少体力
                minn = min(dp[i + 1][j], dp[i][j + 1])
                # dp_{i,j}: 走出这个格子至少要具备多少体力
                dp[i][j] = max(minn - dungeon[i][j], 1)
        return dp[0][0]

403. 青蛙过河

403. 青蛙过河

时间复杂度： $O(N^2)$

class Solution:
    def canCross(self, stones: List[int]) -> bool:
        mapper={
   }
        for stone in stones:
            mapper[stone]=set()
        mapper[0].add(0)
        for stone in stones:
            for k in mapper[stone]:
                for step in range(k-1,k+2):
                    if step>0 and stone+step in mapper:
                        mapper[stone+step].add(step)
        return len(mapper[stones[-1]])>0

不同路径（考虑障碍物的DP）

62. 不同路径

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        dp=[[0]*(n+1) for _ in range(m+1)]
        dp[1][1]=1
        for i in range(1, m+1):
            for j in range(1, n+1):
                if i==1 and j==1:
                    continue
                dp[i][j]=dp[i-1][j]+dp[i][j-1<