最长子序列

1. 最长递增子序列（注意不连续）

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

1）动态规划

dp[i]--------到i为止包括i递增子序列的长度，最后一位必须包括nums[i]

dp[i]=Math.max(dp[0],dp[1],....,dp[i-1])+1;

if(nums[i]>nums[j]) dp[i]=Math.max(dp[i],dp[j]+1);

 public int lengthOfLIS(int[] nums) {
        if (nums.length==1) return 1;
        int[] dp=new int[nums.length];
        int result=1;
        for(int i=0;i<nums.length;i++) {dp[i]=1;}
        
        for(int i=1;i<nums.length;i++){//
            
          for(int j=0;j<i;j++){
             if(nums[i]>nums[j]) dp[i]=Math.max(dp[i],dp[j]+1);}
            
             if(dp[i]>result) result=dp[i];
          }
        return result;}

2) 贪心

思路：上升子序列尽可能的长，则我们需要让序列上升得尽可能慢，因此我们希望每次在上升子序列最后加上的那个数尽可能的小

维护数组 d[i]，表示长度为 i 的最长上升子序列的末尾元素的最小值，用len 记录目前最长上升子序列的长度，起始时 len为 1，d[1]=nums[0]。

注意：d[i] 是关于i单调递增的。

依次遍历数组 nums ，并更新数组 d 和 len的值。如果nums[i]>d[len] 则更新 len = len + 1，否则在 d[1...len]中找满足d[i−1]<nums[j]<d[i] 的下标 i，并更新d[i]=nums[j]。根据d数组的单调性，我们可以使用二分查找寻找下标 i，优化时间复杂度。

最后整个算法流程为：

设当前已求出的最长上升子序列的长度为 len（初始时为 1），从前往后遍历数组 nums，在遍历到nums[i] 时：

如果nums[i]>d[len] ，则直接加入到 d 数组末尾，并更新len=len+1；

否则，在 d数组中二分查找，找到第一个比 nums[i] 小的数 d[k]，并更新 d[k+1]=nums[i]。

2. 重复子数组

解题套路：dp[i][j]------>以下标i - 1为结尾的A，和以下标j - 1为结尾的B，最⻓重复⼦数组⻓度为dp[i][j]

2.1) 最⻓重复⼦数组

给两个整数数组 A 和 B ，返回两个数组中公共的、⻓度最⻓的⼦数组的⻓度。

class Solution {
//dp[i][j]->以下标i-1为结尾的A,和以下标j-1为结尾的B,最⻓重复⼦数组⻓度为dp[i][j]
    public int findLength(int[] nums1, int[] nums2) {
        //想要得到dp[nums1.length][nums2.length]
    int[][] dp=new int[nums1.length+1][nums2.length+1];
        dp