动态规划解题思路

时间 2019-11-07

原文原文链接

算法能力就是程序员的内力，内力强者对编程利剑的把控能力就更强。程序员

数键盘

动态规划就是，经过递推的方式，由最基本的答案推导出更复杂答案的方法，直到找到最终问题的解。或者是，经过递归的方式，将复杂问题化解为更简单问题的方法，直到化解为有明确答案的最基础问题。算法

问：你如今用的键盘上有多少个键帽？编程

当我问你这个问题时，你必定想到了解决方案，一个个数确定能获得答案。数组

咱们能够把这个简单的问题，用公式定义的更加清楚：设 F(n) 为键帽的总数，求 F(n) 的值。当你开始数第一个的键帽的时候，你获得了 F(1) = 1，这是一个最基本的答案。数数过程当中，下一个答案等于上一个答案加 1。在状态规划中，咱们一般把阶段性的答案，称做状态。复杂状态与简单状态之间存在的转化关系，叫作状态转移方程，状态转移方程是动态规范的核心，这这道题目中就是：spa

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

当咱们使用递推的方式，来求解动态规划时，咱们会从 1 开始数起，一步步累加获得最终的状态：code

F(1) = 1

F(2) = F(1) + 1

...

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

当咱们使用递归的方式，来求解动态规划时，咱们会从把全部的键帽数量，记做状态 F(N)，当咱们数了一个键帽后，那么剩下的状态就记做 F(N-1)，所以：blog

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

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

...

F(1) = 1

不管是递推仍是递归，都是获得的答案无疑都是同样的，只不过思惟的方式有些不同。递推是正向思惟，先有基础答案后由复杂答案，最后得出最终问题的答案。递归是逆向思惟，先有复杂的问题，而后把它化解为更简单的问题，直到分解为能一眼看出答案的基本问题。递归

数键盘虽然是一个很简单的游戏，可是解答的过程当中已经包含了最基础的动态规划解题思路：游戏

定义状态
再从新定义问题
找到最基础的状态
找出状态转移方程
编程求解

最长上升子序列

问：给定一个无序的整数数组，找到其中最长上升子序列的长度。rem

示例：

输入: [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
};