算法题复健之路 第二天 动态规划

70 72 1143 动态规划题

动态规划的重点在于分解，把大问题变成小问题，小问题解决后，加起来变成大问题，

一共几步路非常重要，第一步，确定边界条件，第二步，创建一个空的矩阵 一般是要把问题分成两个部分长度M,N ，数组先确定0时的特殊边界值，后面分解问题，例如把i位置的问题分解成i-1或者i-2 ,j-1之类的等等，最后要达到的效果是把大问题变成几个他的子问题相加的和，至于子问题如何解，跟递归一样，不需要知道，先假设他已经解了，这样列出关系式子，再从1到n 从底到顶，开始几个for循环遍历，将子问题一步步从1加到要求解的N即可，列出72和1143两个问题的解如下：

class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        def qs(nums, left, right):
            temp = nums[(left+right)//2]
            i, j = left, right
            while i <= j:
                while nums[i] < temp: i += 1
                while nums[j] > temp: j -= 1
            
                if i <= j:
                    nums[i], nums[j] = nums[j], nums[i]

                    i += 1
                    j -= 1

            if i < right: qs(nums, i, right)
            if j > left: qs(nums, left, j)
        
        qs(nums, 0, len(nums)-1)

        return nums

class Solution:
    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
        m = len(text1)
        n = 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]