LIS問題

連續子數組最大和

def maxSubArray(self, nums: List[int]) -> int:
        for i in range(1,len(nums)):
            nums[i] = max(nums[i-1]+nums[i],nums[i])
        return max(nums)

最長連續遞增子序列長度

def findLengthOfLCIS(self, nums: List[int]) -> int:
        if not nums:
            return 0
        dp = [1] * len(nums)
        for i in range(1,len(nums)):
            if nums[i] > nums[i-1]:
                dp[i] = dp[i-1] + 1
            else :
                dp[i] = 1
        return max(dp)

最長遞增子序列長度

解法一：DP

def lengthOfLIS(self, nums: List[int]) -> int:
        if(not nums):
            return 0
        dp = [1]*len(nums)
        for i in range(len(nums)):
            for j in range(i):
                if nums[i]>nums[j]:
                    dp[i]=max(dp[i],dp[j]+1)
        return max(dp)

[進階] 解法二：貪心+二分

思路：數組d[len]表示長度為len的的子序列末尾最大值,遍歷數組時用二分查找得到插入d的位置
舉例：[0, 8, 4, 12, 2]

第一步插入 0，d = [0]
第二步插入 8，d = [0, 8]
第三步插入 4，d = [0, 4]
第四步插入 12，d = [0, 4, 12]
第五步插入 2，d = [0, 2, 12]
最終得到最大遞增子序列長度為 3

[再進階] 輸出該序列

思路：要輸出序列，就要確定序列的最大值，然后從后向前遍歷數組
解法一知道以每個元素結尾的最長子序列長度
解法二知道固定長度子序列結尾的最小值
結合這兩個信息就可以還原最長子序列

def LIS(arr):
        if not arr: return None
        n = len(arr)
        d = [arr[0]] 
        dp = [1] * n # 記錄以元素 arr[i] 結尾的最長遞增子序列的長度
        length = 1
        for i in range(1,n): # 從1開始遍歷
            if arr[i] > d[-1]:
                d.append(arr[i]) 
                length += 1
                dp[i] = length
            else:
                # 使用bisect庫
                index = bisect.bisect(d,arr[i])
                dp[i] = index + 1 # 找到的是下標，長度需要再加1
                d[index] = arr[i] # 插入到對應位置
                # 手動實現二分
                l, r = 0, len(d)-1
                loc = -1
                while (l <= r):
                    mid = (l+r)//2
                    if (arr[i] <= d[mid]):
                        loc = mid
                        r = mid - 1
                    else:
                        l = mid + 1
                dp[i] = loc + 1
                d[loc] = arr[i] 

        ans = []
        max_val = d[-1] 
        count = len(d)
        idx  = arr.index(max_val)
        
        for i in range(idx,-1,-1):
            if not ans or (arr[i] < ans[-1] and dp[i] == count):
                ans.append(arr[i])
                count -= 1
        return ans[::-1]

回文問題

最長回文子串(長度)

def longestPalindrome(s) ：
        N = len(s)
        if N == 1: 
            return s
        dp = [[False for _ in range(N)] for _ in range(N)]
        for i in range(N):
            dp[i][i] = True
        max_len,start = 1,0
        for j in range(1,N):  #因為后面外層j-1所以j要從1開始
            for i in range(j): # i一定是小于j的，所以是循環到j
                if(s[i] == s[j]):
                    if(j-i<3): #為什么這里是3  i+1 和 j-1 的距離小于1 j-1-(i+1)<1其實也就是 i+1和j-1相等，是一個字符的時候，肯定滿足回文
                        dp[i][j]=True
                    else:
                        dp[i][j] = dp[i+1][j-1]
                if(dp[i][j]):
                    l = j - i + 1
                    if(l > max_len):
                        max_len = l 
                        start = i
        return s[start:start+max_len]

這道題要注意一個比較重要的點，至少對我來說比較重要，就是在寫二重循環的時候，為什么是先遍歷j 然后再遍歷i , 我們看下我們的思路中的這個公式 dp[i][j] = dp[i+1][j-1] 要有了后面的值才能賦值給前面，從這個二維矩陣就可以看出，列是外層循環，i是內層循環，這樣就不會出錯了

最長回文子序列長度

def longestPalindromeSubseq(self, s: str) -> int:
        n=len(s)
        dp=[[0]*n for _ in range(n)]  #定義動態規劃狀態轉移矩陣
        for i in range(n):  #   初始化對角線，單個字符子序列就是1
            dp[i][i]=1
        for i in range(n-1,-1,-1):  #從右下角開始往上遍歷 注意這里是n-1不是n
            for j in range(i+1,n):
                if s[i]==s[j]:   #當兩個字符相等時，直接子字符串加2
                    dp[i][j]= dp[i+1][j-1]+2  
                else:           #不相等時，取某邊最長的字符
                    dp[i][j]=max(dp[i][j-1],dp[i+1][j])
        return dp[0][-1]   #返回右上角位置的狀態就是最長

221 最大正方形 字節

思路已經有了，但是最后有的case沒有通過，還不知道為什么

def maximalSquare(self, matrix: List[List[str]]) -> int:
        if not matrix: return 0
        r,c = len(matrix),len(matrix[0])
        if r == 0 or c == 0 : return 0
        dp = [[int(matrix[i][j]) for j in range(c)] for i in range(r)]
        fr,fc = dp[0], [dp[i][0] for i in range(r)]
        l = max(max(fr),max(fc))
        for i in range(1,r):
            for j in range(1,c):         
                tmp = dp[i-1][j-1]
                if(matrix[i][j]=='1' and tmp>0):
                    flag =  True
                    index = 0 
                    while index < tmp:
                        if matrix[i-index-1][j] == '0' or matrix[i][j-index-1] == '0':
                            flag = False
                            break
                        index += 1
                    if flag:
                        dp[i][j] = dp[i-1][j-1] + 1
                    else:
                        dp[i][j] = dp[i-1][j-1]
                l = max(l,dp[i][j])
        return l*l

和正確答案對比一下, 如何巧妙地把邊界條件包含在循環中而不是單獨判斷

def maximalSquare(self, matrix: List[List[str]]) -> int:
        if len(matrix) == 0 or len(matrix[0]) == 0:
            return 0
        
        maxSide = 0
        rows, columns = len(matrix), len(matrix[0])
        dp = [[0] * columns for _ in range(rows)]
        for i in range(rows):
            for j in range(columns):
                if matrix[i][j] == '1':
                    if i == 0 or j == 0:
                        dp[i][j] = 1
                    else:
                        dp[i][j] = min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]) + 1
                    maxSide = max(maxSide, dp[i][j])
        
        maxSquare = maxSide * maxSide
        return maxSquare

1024. 視頻拼接

這道題其實DP的思路不是很好想, 感覺貪心更好想
用dp[i]表示覆蓋[0,i)需要的最小空間數

def videoStitching(self, clips: List[List[int]], T: int) -> int:
        l = len(clips)
        dp = [0] + [l+1]*T #0一定是0了，其他初始化一個不可能的大數len(clips)+1
        for i in range(1,T+1):
            for aj,bj in clips:
                if aj < i <= bj: #[0,i)的后面部分可以被覆蓋
                    #如果用這個部分覆蓋，數目為dp[aj]+1 不用就是dp[i] 取最小值
                    dp[i] = min(dp[i],dp[aj]+1)
        return -1 if dp[T]==l+1 else dp[T]

139. 單詞拆分

繼續動態規劃

1. 72. 編輯距離

def minDistance(self, word1: str, word2: str) -> int:
        m = len(word1)
        n = len(word2)
        #這里注意初始化的二維數組的時候，哪個在里面，哪個在外面
        dp = [[0 for _ in range(n+1)] for _ in range(m+1)] 
        for i in range(m+1):
            dp[i][0] = i 
        for j in range(n+1):
            dp[0][j] = j
        for i in range(1,m+1):
            for j in range(1,n+1):
                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][j-1]+1,dp[i-1][j-1]+1)
        return dp[-1][-1]

2.198. 打家劫舍

def rob(self, nums: List[int]) -> int:
        N = len(nums)
        if not nums:
            return 0
       
        if N == 1 : return nums[0]
        if N == 2 : return max(nums[0],nums[1])

        dp = list(range(N))
        dp[0] = nums[0]
        dp[1] = max(nums[0],nums[1])
        for i in range(2,len(nums)):
            dp[i] = max(dp[i-2] + nums[i], dp[i-1])

        return dp[-1]

3.213. 打家劫舍 II

怎么能想到把這問題拆分成 只搶第一家 和 只搶最后一家 兩個子問題？？？

def rob(self, nums: List[int]) -> int:
        N = len(nums)
        if not nums : return 0 
        if N <= 2 : return max(nums)

        def helper(nums):
            if len(nums) <= 2 : return max(nums)
            dp = [0] * len(nums)
            dp[0] = nums[0]
            dp[1] = max(nums[0],nums[1])
            for i in range(2,len(nums)):
                dp[i]=max(dp[i-1],dp[i-2]+nums[i])
            return dp[-1]
            
        return max(helper(nums[1:]),helper(nums[:-1]))

2 72. 編輯距離

我看到“方法一”三個字的時候，驚喜地以為還有方法二。。沒有，這次真沒有。動態規劃是個好東西，但難就難在如何定義DP數組里值的含義。聽我來給你捋一捋。

啥叫編輯距離？我們說word1和word2的編輯距離為X，意味著word1經過X步，變成了word2，咋變的你不用管，反正知道就需要X步，并且這是個最少的步數。

我們有word1和word2，我們定義dp[i][j]的含義為：word1的前i個字符和word2的前j個字符的編輯距離。意思就是word1的前i個字符，變成word2的前j個字符，最少需要這么多步。

例如word1 = "horse", word2 = "ros"，那么dp[3][2]=X就表示"hor"和“ro”的編輯距離，即把"hor"變成“ro”最少需要X步。

如果下標為零則表示空串，比如：dp[0][2]就表示空串""和“ro”的編輯距離

定理一：如果其中一個字符串是空串，那么編輯距離是另一個字符串的長度。比如空串“”和“ro”的編輯距離是2（做兩次“插入”操作）。再比如"hor"和空串“”的編輯距離是3（做三次“刪除”操作）。

定理二：當i>0,j>0時（即兩個串都不空時）dp[i][j]=min(dp[i-1][j]+1,dp[i][j-1]+1,dp[i-1][j-1]+int(word1[i]!=word2[j]))。

啥意思呢？舉個例子，word1 = "abcde", word2 = "fgh",我們現在算這倆字符串的編輯距離，就是找從word1，最少多少步，能變成word2？那就有三種方式：

知道"abcd"變成"fgh"多少步（假設X步），那么從"abcde"到"fgh"就是"abcde"->"abcd"->"fgh"。（一次刪除，加X步，總共X+1步）
知道"abcde"變成“fg”多少步（假設Y步），那么從"abcde"到"fgh"就是"abcde"->"fg"->"fgh"。（先Y步，再一次添加，加X步，總共Y+1步）
知道"abcd"變成“fg”多少步（假設Z步），那么從"abcde"到"fgh"就是"abcde"->"fge"->"fgh"。（先不管最后一個字符，把前面的先變好，用了Z步，然后把最后一個字符給替換了。這里如果最后一個字符碰巧就一樣，那就不用替換，省了一步）
以上三種方式算出來選最少的，就是答案。所以我們再看看定理二：

dp[i][j]=min(dp[i-1][j]+1,dp[i][j+1]+1,dp[i][j]+int(word1[i]!=word2[j]))
dp[i-1][j]：#情況一
dp[i][j-1]+1：#情況二
dp[i-1][j-1]+int(word1[i]!=word2[j])：#情況三

有了定理二的遞推公式，你就建立一個二維數組，考慮好空串的情況，總會寫出來

進階

先把二維數組的方法做出來，要還沒做出來呢，先別往下看。

由定理二可知，dp[i][j]只和dp[i-1][j],dp[i][j-1],dp[i-1][j-1]三個量有關，即二維數組中，當前元素的左邊，上邊，左上角三個元素。

那我們不用這么大的二維數組存啊！我們就用一維數組，表示原來二維數組中的一行，然后我們就反復覆蓋里面的值。dp[i-1][j]就是我當前左邊的元素，dp[i][j-1]是沒覆蓋前我這里的值，dp[i-1][j-1]好像找不見了？那我們就單獨用一個變量存著它，我們把它叫lu（left up），則代碼為：

class Solution:
    def minDistance(self, word1: str, word2: str) -> int:
        m=len(word1)
        n=len(word2)
        dp=list(range(n+1))
        for i in range(m):
            lu=dp[0]
            dp[0]=i+1
            for j in range(n):
                dp[j+1],lu=min(dp[j]+1,dp[j+1]+1,lu+int(word1[i]!=word2[j])),dp[j+1]
        return dp[-1]

5. 16. 最接近的三數之和

有了之前3數之和的經驗，這個還是解答起來比較簡單的

def threeSumClosest(self, nums: List[int], target: int) -> int:
        nums.sort()
        distance = pow(10,4)
        res = 0
        for i in range(len(nums)):
            low, high = i + 1, len(nums)-1
            while(low < high):
                sum_value = nums[i] + nums[low] + nums[high]
                if abs(sum_value-target) < distance:
                    distance = abs(sum_value-target)
                    res = sum_value
                if (sum_value > target):
                    high -= 1
                elif (sum_value == target):
                    return target
                else:
                    low += 1
        return res

6. 454. 四數相加 II

這題目用我大python有點牛逼了。。。也太簡潔明快了

def fourSumCount(self, A: List[int], B: List[int], C: List[int], D: List[int]) -> int:
        record = collections.Counter(a + b for a in A for b in B)
        return sum(record.get(- c - d, 0) for c in C for d in D)

4. 劍指 Offer 60. n個骰子的點數

這確定是個簡單題目么。。。？感覺還是有點復雜的，

從題解來看，刷到了第一個動態規劃的題目。那么我們來理一下DP問題的思路吧

• 首先要確定如何表示狀態 用dp[n][j]表示投擲完 n 枚骰子后，點數 j 的出現次數
• 然后找出狀態轉移方程，dp[n][j] = dp[n-1][j-1] + ... dp[n-1][j-6]
• 最后確定邊界條件 投擲完 1 枚骰子后,點數從1到6各出現一次 dp[1][i]=1

def twoSum(self, n: int) -> List[float]:
        dp = [ [0 for _ in range(6*n+1)] for _ in range(n+1)] #如何初始化一個n行6n列的二維數組
        for i in range(1,7):
            dp[1][i] = 1
        for i in range(2,n+1):
            for j in range(i,i*6+1):
                for k in range(1,7):
                    if(j>k):
                        dp[i][j]+=dp[i-1][j-k]
        res = []
        for i in range(n,6*n+1):
            res.append(dp[n][i]*1.0/6**n)
        return res

反復品了一下，好像又沒有那么難，重點在于思路、套路

5. 劍指 Offer 49. 丑數

1003am-1023am
有事耽誤了幾天，看了下答案，好吧，表示自己真得想不出來 mark
三指針動態規劃問題

def nthUglyNumber(self, n: int) -> int:
        dp, a, b, c = [1] * n, 0, 0, 0
        for i in range(1, n):
            n2, n3, n5 = dp[a] * 2, dp[b] * 3, dp[c] * 5
            dp[i] = min(n2, n3, n5)
            if dp[i] == n2: a += 1
            if dp[i] == n3: b += 1
            if dp[i] == n5: c += 1
        return dp[-1]