【LeetCode】53 and 1143（动态规划）

53. 最大子数组和

解法：动态规划
为了寻求dp[i]和dp[i-1]之间的关联，我们定义dp[i]为以nums[i]为边界的最大连续子数组和。这样我们能够得到转化方程：dp[i] = max(dp[i-1]+nums[i], nums[i])

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        n = len(nums)
        dp = [0] * n
        res = float("-inf")
        for i in range(n):
            if i == 0:
                dp[i] = nums[i]
            else:
                dp[i] = max(dp[i-1]+nums[i], nums[i])
            if dp[i] > res:
                res = dp[i]
        return res

1143. 最长公共子序列

解法：动态规划
最长公共子序列问题是典型的二维动态规划问题。
假设字符串text1和 text2的长度分别为 m 和 n，创建 m 行 n 列的二维数组 dp，其中dp[i][j]表示text1[:i]和text2[:j] 的最长公共子序列的长度。
这时可以采用自顶向下和自底向上两个解法。其中自底向上的状态转移方程如下：

自顶向下过程类似，只是计算顺序不同，同时需要维护备忘录避免重复计算。

# 自底向上
class Solution:
    def longestCommonSubsequence(self, text1: str, text2: str) -> 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[m][n]

# 自顶向下，递归dp
class Solution:
    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
        visited = [[0]*len(text2) for _ in range(len(text1))]
        def dp(s1, i, s2, j):
            if i >= len(s1) or j >= len(s2):
                return 0
            if visited[i][j] != 0:
                return visited[i][j]
            if s1[i] == s2[j]:
                visited[i][j] = 1 + dp(s1, i+1, s2, j+1)
                return visited[i][j]
            else:
                visited[i][j] = max(
                    dp(s1, i+1, s2, j),
                    dp(s1, i, s2, j+1)
                )
                return visited[i][j]
        return dp(text1, 0, text2, 0)