動態規劃解題思路

算法能力就是程序員的內力，內力強者對編程利劍的把控能力就更強。

數鍵盤

動態規劃就是，經過遞推的方式，由最基本的答案推導出更復雜答案的方法，直到找到最終問題的解。或者是，經過遞歸的方式，將複雜問題化解爲更簡單問題的方法，直到化解爲有明確答案的最基礎問題。

問：你如今用的鍵盤上有多少個鍵帽？

當我問你這個問題時，你必定想到了解決方案，一個個數確定能獲得答案。

咱們能夠把這個簡單的問題，用公式定義的更加清楚：設 F(n) 爲鍵帽的總數，求 F(n) 的值。當你開始數第一個的鍵帽的時候，你獲得了 F(1) = 1，這是一個最基本的答案。數數過程當中，下一個答案等於上一個答案加 1。在狀態規劃中，咱們一般把階段性的答案，稱做狀態。複雜狀態與簡單狀態之間存在的轉化關係，叫作狀態轉移方程，狀態轉移方程是動態規範的核心，這這道題目中就是：

F(i) = F(i - 1) + 1 ( 0<i≤N)

當咱們使用遞推的方式，來求解動態規劃時，咱們會從 1 開始數起，一步步累加獲得最終的狀態：

F(1) = 1

F(2) = F(1) + 1

...

F(N) = f(N-1) + 1

當咱們使用遞歸的方式，來求解動態規劃時，咱們會從把全部的鍵帽數量，記做狀態 F(N)，當咱們數了一個鍵帽後，那麼 剩下的狀態就記做 F(N-1)，所以：

F(N) = F(N-1) + 1

F(N-1) = F(N-2) + 1

...

F(1) = 1

不管是遞推仍是遞歸，都是獲得的答案無疑都是同樣的，只不過思惟的方式有些不同。遞推是正向思惟，先有基礎答案後由複雜答案，最後得出最終問題的答案。遞歸是逆向思惟，先有複雜的問題，而後把它化解爲更簡單的問題，直到分解爲能一眼看出答案的基本問題。

數鍵盤雖然是一個很簡單的遊戲，可是解答的過程當中已經包含了最基礎的動態規劃解題思路：

1. 定義狀態
2. 再從新定義問題
3. 找到最基礎的狀態
4. 找出狀態轉移方程
5. 編程求解

最長上升子序列

問：給定一個無序的整數數組，找到其中最長上升子序列的長度。

示例：

輸入: [10,9,2,5,3,7,101,18]
輸出: 4 
解釋: 最長的上升子序列是 [2,3,7,101]，它的長度是 4。

說明：

• 可能會有多種最長上升子序列的組合，你只須要輸出對應的長度便可。
• 你算法的時間複雜度應該爲 O(n2) 。

這道題目的問題是，求最長上升子序列的長度。直接拿到這個問題，確定一臉懵逼，最長上升子序列的長度是什麼？斷詞斷句一個個解釋，序列、子序列、上升序列、最長上升子序列的長度。

序列：這裏指的是，一個無序的整數數組。

子序列：將原序列中的部分值，從新組合成一個新的序列，這個新的序列就是子序列。一個序列能夠有多個子序列。如，原序列 [1, 5, 2, 3]，那麼 [1, 5] 和 [1, 2, 3] 都是原序列的子序列。

上升序列：從前日後看，序列中的前面的數字比後面的數字更小，序列呈遞增規律，就是上升序列。[1, 2, 3] 就是上升序列，[1,2,0] 就不是上升序列。

最長上升子序列的長度：一個序列可能會有多個上升子序列，其中長度最長的叫作最長上升子序列，其長度叫作最長上升子序列的長度。

動態規劃方法一

第一步：定義狀態。定義狀態爲，以當前序列第 i 個數字結尾的最長上升子序列的長度，記做 L(i)，0≤i≤N-1，N爲序列長度。示例：序列[1,2,3]，狀態 L[1] = 2 ，表示第 1 個以 2 結尾的最長上升子序列的長度爲 2。

第二步：從新定位問題。序列中的最長上升子序列，不必定是以最後一個數字結尾，而是全部狀態中的最大值，即 Math.max(L[0],L[1],…,L(N-1))。示例：[1,2,0] 的最長上升子序列是 [1,2] ，是以第1個數字結尾的。

第三步：找到最基礎的狀態。當序列爲空時，結尾的最長上升子序列的長度爲0。可是咱們發現，最初咱們定義的狀態，並不能表示該最基礎的狀態，所以須要對狀態的定義稍做修正。

狀態：以當前序列第 index 個數字結尾的最長上升子序列的長度，index 是序列的下標，記 i = index + 1 ，狀態爲 L(i)，0≤i≤N，N爲序列長度。此時 L[0] 表示空序列的最長上升子序列的長度 L[0] = 0，L[1] 表示以序列中第 0 位數字結尾的最長上升子序列的長度，L[1] = 1。

第四步：找到狀態轉移方程。若 L[i] 大於 1，則 L[i] 表示的子序列，去掉最後一位數，依舊是一個子序列，記該子序列爲 L[j] 。其關係爲 L[i] = L[j] + 1 。其中 L[j] 的最後一位 nums[j -1] < nums[i - 1]，且 L[j] = Math.max( L[1],…,L[i-1]) ，0<j<i。

例如：序列A [1, 2, 6, 3, 4]

1. L[0] = 0
2. L[1] = 1
3. L[2] = Math.max( L[1]) + 1 =  L[1] + 1 = 2, 其中 nums[1-1] < nums[2-1] 
4. L[3] = Math.max(L[1], L[2]) + 1 =  L[2] + 1 = 2, 其中 nums[2-1] < nums[3-1] 
5. L[4] = Math.max(L[1], L[2],L[3]) + 1 =  L[2] + 1 = 2, 其中 nums[2-1] < nums[4-1] 
6. L[5] = Math.max(L[1], L[2],L[3],L[4]) + 1 =  L[4] + 1 = 2, 其中 nums[4-1] < nums[5-1]

變成爲：

function lengthOfLIS(nums) {
    const dp = [0]

    for (let i = 1; i <= nums.length; i++) {

        let max = 0

        for (let j = 1; j < i; j++) {
            if (nums[j - 1] < nums[i - 1]) {
                max = Math.max(max, dp[j])
            }
        }

        dp[i] = max + 1
    }

    return Math.max(...dp)
};

動態規劃方法二

第一步：定義狀態。在序列前 index 項中，全部可能成爲最長上升子序列的子序列。S[i]

示例：A [10,  1, 12,  2, 3]
S[0] = [[10]]
S[1] = [[10], [1]]
S[2] = [[10, 12], [1, 12]]
S[3] = [[10, 12], [1, 12], [1, 2]]
S[4] = [[10, 12], [1, 12], [1, 2, 3]]

當 S[1] = [[10], [1]] 時，A[2] 存在三種狀況，①當 10 < A[2] 時， [10, A[2]] 和 [1, A[2]] 表示的長度等價；②當 1 < A[2] ≤ 10 時， [1, A[2]] 比 [10] 長；③當 A[2] ≤ 1 時，S[3] = [[10], [1], A[3]]。

由於題目只須要返回最終長度，因此 [10] 或 [1] 兩種狀況實際，能夠簡寫爲 [1] 這一種狀況。A[3] 存在 3中狀況，分別爲①當 10 < A[2] 時， [1, A[2]] ；②當 1 < A[2] ≤ 10 時， [1, A[2]]；③當 A[2] ≤ 1 時，S[3] = [A[3]]。所以可證實，只保留 [1] 一種狀況，實際上已經表明了 [10] 或 [1] 兩種狀況。

對狀態進行從新定義：在序列前 i 項中，長度爲 k 的上升子序列中，最後一位的最小值。S[i]

示例：A [10,  1, 12,  2, 3]
S[0] = [10]
S[1] = [1]
S[2] = [1,12]
S[3] = [1,2]
S[4] = [1,2,3]

第二步：從新定位問題。 求 S[N-1] 的長度，其中 N 爲序列的長度。

第三步：找到最基礎的狀態。當序列爲空時，結尾的最長上升子序列的長度爲0，所以對問題和狀態進行從新修正。

狀態：在序列前 i + 1 項中，長度爲 k 的上升子序列中，最後一位的最小值。S[i]

問題：求 S[N] 的長度，其中 N 爲序列的長度。

第四步：找到狀態轉移方程。若是 A[i-1] 比 S[i] 最後一位還要大，記做 S[i][len -1] < A[i-1] ，便可以組成一個更長子序列，s[i] = [...s[i -1],A[i-1]]。若是 A[i-1] 比 S[i] 中某一位 S[i][j]要小，可是比該位的前一位 S[i][j-1]要大，更具第一步中的推論，能夠用 A[i-1] 替換掉 S[i][j] ，S[i] = […,S[i][j-1],A[i-1] ,…]

示例：A [10,  1, 12,  2, 3]
S[0] = []      // 初始化
S[1] = [10]    // 在最後添加 A[1-1]=10
S[2] = [1]     // A[2-1] < S[2][0]，所以替換掉 S[2][0]
S[3] = [1,12]  // 在最後添加 A[3-1]= 12
S[4] = [1,2]   // S[2][0] < A[2-1] < S[2][1]，所以替換掉 S[2][1]
S[5] = [1,2,3] // 在最後添加 A[5-1]= 3

實現：

function lengthOfLIS(nums) {

    const sequence = []

    // 複雜度 n
    for (let i = 1; i <= nums.length; i++) {

        let len = sequence.length
        
        // 增長
        if (sequence[len - 1] < nums[i-1]) {
            sequence[len] = nums[i-1]
          
        // 替換  
        } else {
            // sequence 具備單調性，可使用 logn 複雜度的二分查找，查找到 S[i][j-1]<A[i]<=S[i][j] (0≤j≤i) 的位置，並對 S[i][j] 進行從新賦值。

            let target = nums[i-1]
            let start = 0
            let end = len
            let mid = parseInt(len / 2)
            let x = 0

            while (start <= end) {
                if (target === sequence[mid]) {
                    x = mid
                    break
                } else if (sequence[mid] < target) {
                    x = mid + 1
                    start = mid + 1
                    mid = parseInt((start + end) / 2)
                } else {
                    x = mid
                    end = mid - 1
                    mid = parseInt((start + end) / 2)
                }
            }
            sequence[x] = nums[i-1]
        }
    }

    return sequence.length
};