學習動態規劃和貪心演算法的應用

題目描述

方法一：動態規劃

思路與演算法

定義 $dp[i]$ 為考慮前 $i$ 個元素，以第 $i$ 個數字結尾的最長上升子序列的長度，注意 $\text{nums}[i]$ 必須被選取。

我們從小到大計算 $dp[]$ 陣列的值，在計算 $dp[i]$ 之前，我們已經計算出 $dp[0\dots i-1]$ 的值，則狀態轉移方程為：

$$dp[i]=\text{max}(dp[j])+1,\text{其中}0\le j<i\text{且}\text{num}[j]<\text{num}[i]$$

即考慮往 $dp[0\dots i-1]$ 中最長的上升子序列後面再加一個 $\text{nums}[i]$。由於 $dp[j]$ 代表 $\text{nums}[0\dots j]$ 中以 $\text{nums}[j]$ 結尾的最長上升子序列，所以如果能從 $dp[j]$ 這個狀態轉移過來，那麼 $\text{nums}[i]$ 必然要大於 $\text{nums}[j]$，才能將 $\text{nums}[i]$ 放在 $\text{nums}[j]$ 後面以形成更長的上升子序列。

最後，整個陣列的最長上升子序列即所有 $dp[i]$ 中的最大值。
$${\text{LIS}}_{\text{length}}=\text{max}(dp[i]),\text{其中}0\le i<n$$

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

複雜度分析

• 時間複雜度：$O(n^2)$，其中 $n$ 為陣列 $\text{nums}$ 的長度。動態規劃的狀態數為 $n$，計算狀態 $dp[i]$ 時，需要 $O(n)$ 的時間遍歷 $dp[0\dots i-1]$ 的所有狀態，所以總時間複雜度為 $O(n^2)$。
• 空間複雜度：$O(n)$，需要額外使用長度為 $n$ 的 $dp$ 陣列。

方法二：貪心 + 二分查詢

思路與演算法

考慮一個簡單的貪心，如果我們要使上升子序列儘可能的長，則我們需要讓序列上升得儘可能慢，因此我們希望每次在上升子序列最後加上的那個數儘可能的小。

基於上面的貪心思路，我們維護一個陣列 $d[i]$ ，表示長度為 $i$ 的最長上升子序列的末尾元素的最小值，用 $\text{len}$ 記錄目前最長上升子序列的長度，起始時 $len$ 為 $1$，$d[1]=\text{nums}[0]$。

同時我們可以注意到 $d[i]$ 是關於 $i$ 單調遞增的。因為如果 $d[j]\ge d[i]$ 且 $j<i$，我們考慮從長度為 $i$ 的最長上升子序列的末尾刪除 $i-j$ 個元素，那麼這個序列長度變為 $j$ ，且第 $j$ 個元素 $x$（末尾元素）必然小於 $d[i]$，也就小於 $d[j]$。那麼我們就找到了一個長度為 $j$ 的最長上升子序列，並且末尾元素比 $d[j]$ 小，從而產生了矛盾。因此陣列 $d[]$ 的單調性得證。

我們依次遍歷陣列 $\text{nums}[]$ 中的每個元素，並更新陣列 $d[]$ 和 $len$ 的值。

• 如果 $\text{nums}[i]>d[\text{len}]$ 則更新 $len=len+1$，
• 否則在 $d[1\dots len]$中找滿足 $d[i-1]<\text{nums}[j]<d[i]$ 的下標 $i$，並更新 $d[i]=\text{nums}[j]$。

根據 $d$ 陣列的單調性，我們可以使用二分查詢尋找下標 $i$，優化時間複雜度。

最後整個演算法流程為：

• 設當前已求出的最長上升子序列的長度為 $\text{len}$（初始時為 $1$），從前往後遍歷陣列 $\text{nums}$，在遍歷到 $\text{nums}[i]$ 時：
  • 如果 $\text{nums}[i]>d[\text{len}]$ ，則直接加入到 $d$ 陣列末尾，並更新 $\text{len}=\text{len}+1$；
  • 否則，在 $d$ 陣列中二分查詢，找到第一個比 $\text{nums}[i]$ 小的數 $d[k]$ ，並更新 $d[k+1]=\text{nums}[i]$。

以輸入序列 $[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$。

class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        d = []
        for i in range(len(nums)):
            if (not d) or (nums[i] > d[-1]):
                d.append(nums[i])
            else:
                loc = self.bisect(d, nums[i])
                d[loc] = nums[i]
        return len(d)

    def bisect(self, nums, k):
        left = 0
        right = len(nums) - 1
        loc = right
        while left <= right:
            mid = (left + right) // 2
            if nums[mid] >= k:
                loc = mid
                right = mid - 1
            else:
                left = mid + 1
        return loc

複雜度分析

• 時間複雜度：$O(n\log n)$。陣列 $\text{nums}$ 的長度為 $n$，我們依次用陣列中的元素去更新 $d$ 陣列，而更新 $d$ 陣列時需要進行 $O(\log n)$ 的二分搜尋，所以總時間複雜度為 $O(n\log n)$。
• 空間複雜度：$O(n)$，需要額外使用長度為 $n$ 的 $d$ 陣列。