第五章：序列类动态规划

---

前言

序列类动态规划问题，这类动态规划问题较为普遍，分析难度相比之前也略有提升，通常问题的输入参数会涉及数组或是字符串。相比矩阵类动态规划，序列类动态规划最大的不同在于，对于第 i 个位置的状态分析，它不仅仅需要考虑当前位置的状态，还需要考虑前面 i – 1 个位置的状态

---

一、LeetCode 第 300 号问题：最长上升子序列

题目: 给定一个无序的整数数组，找到其中最长上升子序列的长度。

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

分析：子序列是数组中不连续的一个区间，可以通过确定头尾位置来判断最大子序列，要想知道 i 位置的最大长度，必须知道 i 位置之前的位置中的最大长度，递推方程为：dp[ i ] = Math.max(dp[ j ],…,dp[ k ]) + 1, 其中 inputArray[ j ] < inputArray[ i ], inputArray[ k ] < inputArray[ i ]。

题解：

class Solution {
    public int lengthOfLIS(int[] nums) {
        if(nums==null||nums.length==0) return 0;
        
        int[] flag = new int[nums.length];
        //初始化为1,默认单位子序列最长长度为1
        Arrays.fill(flag, 1);
        int max = 0;
        for(int i=0; i<nums.length; i++){
            for(int j=0; j<i; j++){
                if(nums[j]<nums[i]){
                    flag[i] = Math.max(flag[j]+1, flag[i]);
                }
            }
            max = Math.max(max, flag[i]);
        }
         return max;
    }
}

二、LeetCode 第 256 号问题：粉刷房子

题目：假如有一排房子，共 n 个，每个房子可以被粉刷成红色、蓝色或者绿色这三种颜色中的一种，你需要粉刷所有的房子并且使其相邻的两个房子颜色不能相同。

当然，因为市场上不同颜色油漆的价格不同，所以房子粉刷成不同颜色的花费成本也是不同的。每个房子粉刷成不同颜色的花费是以一个 n x 3 的矩阵来表示的。

例如，costs[0][0]表示第 0 号房子粉刷成红色的成本花费；costs[1][2]表示第 1 号房子粉刷成绿色的花费，以此类推。请你计算出粉刷完所有房子最少的花费成本。

注意：所有花费均为正整数。

输入: [[17,2,17],[16,16,5],[14,3,19]]
输出: 10
解释: 将 0 号房子粉刷成蓝色，1 号房子粉刷成绿色，2 号房子粉刷成蓝色，最少花费: 2 + 5 + 3 = 10。

分析：假设当前的房子被粉刷的颜色是红色，那么最少花费为前一个房子（不同于当前房子颜色）在另为两种颜色下的最少花费加上当前红色颜料的花费。递推方程为 dp[ i ] [ k ] = Math.min(dp[ i - 1 ] [ l ], …, dp[ i - 1 ] [ r ] ) + costs[ i ] [ k ]， l != k, r != k

题解：

public int minCost(int[][] costs){
    if(costs==null||costs.length==0) return 0;
   
    int n = costs.length;
    int[][] flag = new int[n][3];

    for(int i=0; i<3; i++){
         flag[0][i] = costs[0][i];
    }
   
    for(int i=0; i<n; i++){
          
         flag[i][0] = Math.min(flag[i-1][1], flag[i-1][2]) + costs[i][0];
         flag[i][1] = Math.min(flag[i-1][0], flag[i-1][2]) + costs[i][0];
         flag[i][2] = Math.min(flag[i-1][0], flag[i-1][0]) + costs[i][0];
    }
    
    int min = Math.min(flag[i][0], flag[i][1], flag[i][2]);
    return min;
}

三、LeetCode 第 265 号问题：粉刷房子II

题目：假如有一排房子，共 n 个，每个房子可以被粉刷成 k 种颜色中的一种，你需要粉刷所有的房子并且使其相邻的两个房子颜色不能相同。
当然，因为市场上不同颜色油漆的价格不同，所以房子粉刷成不同颜色的花费成本也是不同的。每个房子粉刷成不同颜色的花费是以一个 n x k 的矩阵来表示的。

例如，costs[0][0] 表示第 0 号房子粉刷成 0 号颜色的成本花费；costs[1][2] 表示第 1 号房子粉刷成 2 号颜色的成本花费，以此类推。请你计算出粉刷完所有房子最少的花费成本。

注意：

所有花费均为正整数。

输入: [[1,5,3],[2,9,4]]
输出: 5
解释: 将 0 号房子粉刷成 0 号颜色，1 号房子粉刷成 2 号颜色。最少花费: 1 + 4 = 5; 或者将 0 号房子粉刷成 2 号颜色，1 号房子粉刷成 0 号颜色。最少花费: 3 + 2 = 5.

分析：
与上面解法一样，只不过是需要查找粉刷前K-1个房子的最小费用。但是这样的算法时间复杂度较高，可以通过设置最大值和次大值来降低算法复杂度，先求出前一个房子的最大值和次大值，然后，外设一个循环判断当前是否为同一个颜色，如果是，则选择次大值，如果不是，则选择最大值。递推方程为: dp[ i ] [ k ] = Math.min(dp[ i - 1 ] [ l ], …, dp[ i - 1 ] [ r ] ) + costs[ i ] [ k ]， l != k, r != k

题解：

public int minCostII(int[][] costs) {
    if (costs.length == 0 || costs[0].length == 0) {
        return 0;
    }

    int n = costs.length, k = costs[0].length;
    int[][] dp = new int[n][k];

    for (int i = 1; i < n; ++i) {
        Arrays.fill(dp[i], Integer.MAX_VALUE);
    }

    for (int i = 0; i < k; ++i) {
        dp[0][i] = costs[0][i];
    }

    for (int i = 1; i < n; ++i) {
        // min1 表示的是最大值，min2 表示的是次大值
        int min1 = Integer.MAX_VALUE, min2 = Integer.MAX_VALUE;
        int minIndex = -1;
        for (int l = 0; l < k; ++l) {
            if (min1 > dp[i - 1][l]) {
                min2 = min1;
                min1 = dp[i - 1][l];
                minIndex = l;
            } else if (min2 > dp[i - 1][l]) {
                min2 = dp[i - 1][l];
            }
        }

        for (int j = 0; j < k; ++j) {
            if (minIndex != j) {
                dp[i][j] = Math.min(dp[i][j], min1 + costs[i][j]);
            } else {
                dp[i][j] = Math.min(dp[i][j], min2 + costs[i][j]);
            }
        }
    }

    int result = Integer.MAX_VALUE;
    for (int i = 0; i < k; ++i) {
        result = Math.min(result, dp[n - 1][i]);
    }

    return result;
}

四、LeetCode 第 198 号问题：打家劫舍

题目：你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。

分析：判断当前房子是否可偷即可，如果当前房子偷了之后的金额大于没偷当前房子的金额，那么便偷了即可。递推方程为：dp[ i ] = max(dp[ i-2 ]+nums[ i ], dp[ i-1 ]);

题解：

class Solution {
    public int rob(int[] nums) {
        int n = nums.length;
  
        if(n==1) return nums[0];
        if(n==2) return nums[0]>nums[1]?nums[0]:nums[1];   

        int[] flag = new int[n];
        int max = 0;
        
        flag[0] = nums[0];
        flag[1] = nums[0]>nums[1]?nums[0]:nums[1];

        for(int i=2; i<n; i++){
              
            flag[i] = Math.max(flag[i-2]+nums[i], flag[i-1]);
            
            if(flag[i]>max) max = flag[i];
        }

        return max;
    }
} 

---

总结

序列类动态规划的系列问题还有很多，比如股票问题，这类问题通常会给你一个数组或者是字符串，在分析这些问题的时候，需要思考当前状态的选择是否要基于前面的状态，以及他们的关系是什么，以此来解决此类问题。