【动态规划】子序列有关问题

1、最长上升子序列

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

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

方法一：动态规划

定义dp[i]表示，前i个元素，以第i个元素结尾时，最长上升子序列的长度。

转移方程：

每轮计算dp[i]的时候，需要重新遍历[0,i);

1. nums[i] > nums[j] ,nums[i]可以接在nums[j]之后，此时最长子序列的长度应该是dp[j]+1;
2. nums[i] <= nums[j],nums[i]无法接在nums[j]之后，此时最长上升子序列不成立，跳过。
   在执行每一轮循环的时候：
   dp[i] = Math.max(dp[i] , dp[j] + 1)

初始状态：

dp[i]的所有元素置为1，最起码每一个元素自己可以构成子序列，长度为1.

class Solution {
    public int lengthOfLIS(int[] nums) {
        if(nums == null || nums.length == 0){
            return 0;
        }
        int n = nums.length;
        int[] dp = new int[n];
        Arrays.fill(dp,1);
        for(int i = 0;i < n;i++){
            for(int j = 0;j < i;j++){
                if(nums[i] > nums[j]){
                    dp[i] = Math.max(dp[i],dp[j]+1);
                }
            }
        }
        int res = 1;
        for(int i = 0;i < dp.length;i++){
            res = Math.max(res,dp[i]);
        }
        return res;
    }
}

2、一组整数对能够构成的最长链

给出 n 个数对。 在每一个数对中，第一个数字总是比第二个数字小。
现在，我们定义一种跟随关系，当且仅当 b < c 时，数对(c, d) 才可以跟在 (a, b) 后面。我们用这种形式来构造一个数对链。

给定一个对数集合，找出能够形成的最长数对链的长度。你不需要用到所有的数对，你可以以任何顺序选择其中的一些数对来构造。

示例 :

输入: [[1,2], [2,3], [3,4]]

输出: 2

解释: 最长的数对链是 [1,2] -> [3,4]
注意：
给出数对的个数在 [1, 1000] 范围内。

思路：
根据数对的第二个数排序所有的数对，dp[i] 存储以 pairs[i][0] 开头的最长链的长度。当 i < j 且 pairs[j][1] < pairs[i][0]时，扩展数对链，更新 dp[j] = max(dp[i], dp[j] + 1)。

class Solution {
    public int findLongestChain(int[][] pairs) {
        if(pairs == null || pairs.length == 0) return 0;
        int n = pairs.length;
        Arrays.sort(pairs,(a,b)->(a[1]==b[1]?a[0]-b[0]:a[1]-b[1]));
        int[] dp =new int[n];
        Arrays.fill(dp,1);
        for(int i = 0;i < n;i++){
            for(int j = 0;j < i;j++){
                if(pairs[j][1] < pairs[i][0]){
                    dp[i] = Math.max(dp[i],dp[j]+1);
                }
            }
        } 
        int res = 0;
        for(int i = 0;i < n; i++){
            res = Math.max(res,dp[i]);
        }
        return res;
    }
}

3、最长摆动子序列

如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为摆动序列。第一个差（如果存在的话）可能是正数或负数。少于两个元素的序列也是摆动序列。

例如， [1,7,4,9,2,5] 是一个摆动序列，因为差值 (6,-3,5,-7,3) 是正负交替出现的。相反, [1,4,7,2,5] 和 [1,7,4,5,5] 不是摆动序列，第一个序列是因为它的前两个差值都是正数，第二个序列是因为它的最后一个差值为零。

给定一个整数序列，返回作为摆动序列的最长子序列的长度。 通过从原始序列中删除一些（也可以不删除）元素来获得子序列，剩下的元素保持其原始顺序。

示例 1:

输入: [1,7,4,9,2,5]
输出: 6
解释: 整个序列均为摆动序列。
示例 2:
输入: [1,17,5,10,13,15,10,5,16,8]
输出: 7
解释: 这个序列包含几个长度为 7摆动序列，其中一个可为[1,17,10,13,10,16,8]。
示例 3:
输入: [1,2,3,4,5,6,7,8,9]
输出: 2

class Solution {
    public int wiggleMaxLength(int[] nums) {
        if(nums == null || nums.length == 0) return 0;    
        int up = 1, down = 1;
        for(int i = 1;i < nums.length;i++){
            if(nums[i]>nums[i-1]){
                up = down +1;
            }
            if(nums[i]<nums[i-1]){
                down = up + 1;
            }
        }
        return Math.max(up,down);
    }
}

4、最长公共子序列

给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。
一个字符串的子序列是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。
例如，“ace” 是 “abcde” 的子序列，但 “aec” 不是 “abcde” 的子序列。两个字符串的「公共子序列」是这两个字符串所共同拥有的子序列。

若这两个字符串没有公共子序列，则返回 0。

示例 1:

输入：text1 = “abcde”, text2 = “ace”
输出：3
解释：最长公共子序列是 “ace”，它的长度为 3。

示例 2:
输入：text1 = “abc”, text2 = “abc”
输出：3
解释：最长公共子序列是 “abc”，它的长度为 3。

示例 3:
输入：text1 = “abc”, text2 = “def”
输出：0
解释：两个字符串没有公共子序列，返回 0。

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        if(text1 == null ||text2 == null || text1.length() == 0 || text2.length() == 0) return 0;
        char[] text1Arr = text1.toCharArray();
        char[] text2Arr = text2.toCharArray();
        int m = text1Arr.length;
        int n = text2Arr.length;
        int[][] dp = new int[m+1][n+1];
        for(int i = 1;i <= m;i++){
            for(int j = 1;j <= n;j++){
                if(text1Arr[i-1] == text2Arr[j-1]){
                    dp[i][j] = dp[i-1][j-1]+1;
                }else{
                    dp[i][j] = Math.max(dp[i-1][j],dp[i][j-1]);
                }
            }
        } 
        return dp[m][n];
    }
}