【算法】子序列问题合集

前言

动态规划的核心设计思想是数学归纳法

假如我们想证明一个数学结论：

1. 那么先假设这个结论在 k < n 时成立
2. 想办法推导证明出 k = n 的时候此结论也成立。

是需要一个 dp 数组嘛？

1. 可以假设 dp[0...i - 1] 都已经被算出来了
2. 然后问自己：怎么通过这些结果算出 dp[i]？
3. 首先要定义清楚的 dp 数组的含义，即 dp[i] 的值到底代表是什么？

Tips：”子序列“ 和 ”子串“ 区别

• 子串一定是连续的
• 子序列不一定是连续的

子序列问题是最常见的算法问题，而且并不好解决。

一旦涉及子序列和最值，那几乎可以肯定，考察的是动态规划技巧，时间复杂度一般都是 O(n ^ 2)

既然用到动态规划，那就要定义 dp 数组，寻找状态转移关系。

两种思路：

1. 第一种思路模板是一个一维的 dp 数组：

int n = array.length;
int [] dp = new int[n];

for (int i = 1; i < n; ++i) {
    for (int j = 0; j < i; ++j) {
        dp[i] = 最值(dp[i], dp[j] + ...)
    }
}

1. 第二种思路模板是一个二维的 dp 数组：

int n = arr.length;
int [][] dp = new int[n][n];

for (int i = 0; i < n; ++i) {
    for (int j = 0; j < n; ++j) {
        if (arr[i] == arr[j]) 
            dp[i][j] = dp[i][j] + ...
        else
            dp[i][j] = 最值(...)
    }
}

题目

（1）LeetCode 300 最长递增子序列

题目描述

---

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

示例 1：
输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。

示例 2：
输入：nums = [0,1,0,3,2,3]
输出：4

示例 3：
输入：nums = [7,7,7,7,7,7,7]
输出：1

思路解法

---

定义是这样的：dp[i] 表示以 nums[i] 这个数结尾的最长递增子序列的长度。

可以推出 base case：dp[i] 初始值为 1, 因为以 nums[i] 结尾的最长递增子序列起码要包含它自己。

public class LeetCode_300 {

    // 方法一：
    // Time: o(n^2), Space: o(n), Faster: 27.93%
    public int lengthOfLISDP(int [] nums) {
        if (nums == null || nums.length == 0) return 0;
        int n = nums.length, max = 1;
        int [] d = new int[n];
        d[0] = 1;

        for (int i = 1; i < n; ++i) {
            for (int j = 0; j < i; ++j) {
                int cur = nums[i] > nums[j] ? d[j] + 1 : 1;
                d[i] = Math.max(d[i], cur);
            }
            max = Math.max(max, d[i]);
        }
        return max;
    }

    // 方法二：
    // Time: o(n * log(n)), Space: o(n), Faster:  92.62%
    public int lengthOfLISBinarySearch(int[] nums) {
        if (nums == null || nums.length == 0) return 0;
        // 牌堆数初始化为 0
        int len = 0;
        int [] top = new int[nums.length];
        for (int x : nums) {
            int left = binarySearchInsertPosition(top, len, x);
            // 把这张牌放到牌堆顶，牌堆顶的牌是这个堆最小的
            top[left] = x;
            // 没找到合适的牌堆，新建一堆
            if (left == len) ++len;
        }
        return len;
    }

    private int binarySearchInsertPosition(int[] d, int len, int x) {
        int low = 0, high = len - 1;
        while (low <= high) {
            int mid = low + (high - low) / 2;
            if (x < d[mid]) high = mid - 1;
            else if (x > d[mid]) low = mid + 1;
            else return mid;
        }
        return low;
    }

}

（2）LeetCode 53 最大子序和

题目描述

---

给定一个整数数组 nums，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例:

输入: [-2,1,-3,4,-1,2,1,-5,4]
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

思路解法

---

题目解读：以 nums[i] 为结尾的 “最大子数组和” 为 dp[i]

使用数学归纳法来找状态转移关系：假设已经算出了 dp[i - 1], 如何推导出 dp[i] 呢？

dp[i] 有两种 “选择”：

1. 要么与前面的相邻子数组连接，形成一个和更大的子树组
2. 要么不与前面的子数组连接，自成