算法刷题日志——dp

最长连续递增序列

这题遍历即可，如果数组中的数是递增的那就数量++，否则就重新开始计数。

class Solution {
    public int findLengthOfLCIS(int[] nums) {
            int len=nums.length;
            if(len<=1){
                return len;
            }
            int ans=1;
            int cnt=1;
           for(int i=0;i<len-1;i++){
               if(nums[i+1]>nums[i]){
                        cnt++;
               }else{
                   cnt=1;
               }
            ans=cnt>ans?cnt:ans;
           }
        return ans;

    }
}

最长重复子数组

A 、B数组各抽出一个前缀子数组，单看它们的末尾项，如果它们俩不一样——以它们俩为末尾项形成的公共子数组的长度为0，如果它们俩一样，以它们俩为末尾项的公共子数组，长度保底为1
dp[i][j] ：长度为i，末尾项为A[i-1]的子数组，与长度为j，末尾项为B[j-1]的子数组，二者的最大公共后缀子数组长度。

class Solution {
    public int findLength(int[] A, int[] B) {
        int n = A.length;
        int m = B.length;
        int[][] dp = new int[n + 1][m + 1]; // dp[i][j]表示A的前i项与B的前j项的最长重复子数组长度
        int ans = 0;
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                if (A[i - 1] == B[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                    ans = Math.max(ans,dp[i][j]);
                }
            }
        }
        return ans;
    }
}

判断子序列

class Solution {
    public boolean isSubsequence(String s, String t) {
        if (s.length() == 0) return true;
        for (int i = 0, j = 0; j < t.length(); j++) {
            if (s.charAt(i) == t.charAt(j)) {
                // 若已经遍历完 s ，则提前返回 true
                if (++i == s.length())
                    return true;
            }
        }
        return false;
    }
}