leetcode动态规划之子序列问题总结 JAVA实现

最新推荐文章于 2024-11-01 15:19:21 发布
最新推荐文章于 2024-11-01 15:19:21 发布
阅读量311 收藏 1
点赞数 1
文章标签： leetcode 动态规划 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56878414/article/details/127081062
版权

文章目录

LeetCode 392.判断子序列
给定字符串 s 和 t ，判断 s 是否为 t 的子序列。

字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

进阶：

如果有大量输入的 S，称作 S1, S2, ... , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？



 

示例 1：

输入：s = "abc", t = "ahbgdc"
输出：true
示例 2：

输入：s = "axc", t = "ahbgdc"
输出：false
双指针
class Solution {
    public boolean isSubsequence(String s, String t) {
        int m = s.length();
        int n = t.length();

        int i = 0, j=0;

        while(i<m&&j<n){
            if(s.charAt(i)==t.charAt(j)){
                i++;
                j++;
            }else{
                j++;
            }
        }
            return i==m;
  
    }
}
动态规划
 public boolean isSubsequence(String s, String t) {
        int length1 = s.length(); int length2 = t.length();
        int[][] dp = new int[length1+1][length2+1];
        for(int i = 1; i <= length1; i++){
            for(int j = 1; j <= length2; j++){
                if(s.charAt(i-1) == t.charAt(j-1)){
                    dp[i][j] = dp[i-1][j-1] + 1;
                }else{
                    dp[i][j] = dp[i][j-1];
                }
            }
        }
        if(dp[length1][length2] == length1){
            return true;
        }else{
            return false;
        }
    }
LeetCode 115.不同的子序列（困难）
给定一个字符串 s 和一个字符串 t ，计算在 s 的子序列中 t 出现的个数。

字符串的一个 子序列 是指，通过删除一些（也可以不删除）字符且不干扰剩余字符相对位置所组成的新字符串。（例如，"ACE" 是 "ABCDE" 的一个子序列，而 "AEC" 不是）

题目数据保证答案符合 32 位带符号整数范围。

 

示例 1：

输入：s = "rabbbit", t = "rabbit"
输出：3
解释：
如下图所示, 有 3 种可以从 s 中得到 "rabbit" 的方案。
rabbbit
rabbbit
rabbbit
示例 2：

输入：s = "babgbag", t = "bag"
输出：5
解释：
如下图所示, 有 5 种可以从 s 中得到 "bag" 的方案。 
babgbag
babgbag
babgbag
babgbag
babgbag


class Solution {
    public int numDistinct(String s, String t) {
        int m = s.length(), n = t.length();
        int[][] dp = new int[m + 1][n + 1];
        for (int i = 0; i <= m; i++)
            dp[i][0] = 1;

        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (j > i)
                    continue;
                if (s.charAt(i - 1) == t.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }
        return dp[m][n];
    }
}
LeetCode 53.最大子序和
给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

子数组 是数组中的一个连续部分。

 

示例 1：

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

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

输入：nums = [5,4,-1,7,8]
输出：23
贪心
class Solution {
    public int maxSubArray(int[] nums) {
        int result =  Integer.MIN_VALUE;
        int count = 0;
        for(int i = 0;i<nums.length;i++){
            count+=nums[i];
            if(count>result){
                result = count;
            }
            if(count <=0){
                count =0;
            }

        }

             return result;
    }
}
动态规划
class Solution {
    public int maxSubArray(int[] nums) {
        int len = nums.length;
		int[] dp = new int[len];
		dp[0] = nums[0];
        int ans = dp[0];
		for(int i = 1; i < len; i++) {
			dp[i] = Math.max(nums[i],dp[i-1] + nums[i]);
            ans = Math.max(ans,dp[i]);
		}
		return ans;
    }
}
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
动态规划
class Solution {
    public int lengthOfLIS(int[] nums) {
        int len = nums.length;
        if(len < 2) return len;
		int[] dp = new int[len];//以i为结尾的最长递增子序列的长度
		int ans = 0;
		Arrays.fill(dp, 1);
		for(int i = 0; i < len; i++) {
			for(int j = 0; j < i; j++) {
				if(nums[j] < nums[i]) {//如果这个数小于这段的数，那么有递增子序列
					if(dp[j] >= dp[i]) {
						dp[i] = dp[j] + 1;
					}
				}
				ans = Math.max(dp[i], ans);
			}
		}
		return ans;
    }
}
二分查找法
class Solution {
    public int lengthOfLIS(int[] nums) {
        int ans = 0;
		int len = nums.length;
		int[] dp = new int[len];
		for(int i = 0; i < len; i++) {
			int sit = Arrays.binarySearch(dp,0,ans,nums[i]);//找到比nums[i]大的元素的位置
			sit = sit < 0 ? - sit - 1:sit;
            dp[sit] = nums[i];//替换第一个比他大的位置
			if(sit == ans) {//如果正好比子序列中所有的数都大，那么最长递增子序列长度增一
				ans++;
			}
		}
		return ans;
    }
}
LeetCode 673.最长递增子序列的个数
给定一个未排序的整数数组 nums ， 返回最长递增子序列的个数 。
注意:这个数列必须是严格递增的。

示例 1:
输入: [1,3,5,4,7]
输出: 2
解释: 有两个最长递增子序列，分别是 [1, 3, 4, 7] 和[1, 3, 5, 7]。

示例 2:
输入: [2,2,2,2,2]
输出: 5
解释: 最长递增子序列的长度是1，并且存在5个子序列的长度为1，因此输出5

class Solution {
    public int findNumberOfLIS(int[] nums) {
        int len = nums.length;
        if(len < 2) return len;
        int[] lengths = new int[len];//递增子序列的几种情况
        int[] dp = new int[len];//每种递增子序列的个数
        Arrays.fill(dp,1);
        for(int i = 0; i < len; i++) {
             for(int j = 0; j < i; j++) {
                 if(nums[j] < nums[i]) {
                     if(lengths[j] >= lengths[i]) {
                         lengths[i] = lengths[j] + 1;
                         dp[i] = dp[j];
                     }else if(lengths[j] + 1 == lengths[i]) {
                         dp[i] += dp[j];
                     }
                 }
             }
        }
        int lengest = 0, ans = 0;
        for(int length : lengths) {
            lengest = Math.max(lengest,length);
        }
        for(int i = 0; i < len; i++) {
            if(lengths[i] == lengest) {
                ans += dp[i];
            }
        }
        return ans;
    }
}
LeetCode 674.最长连续递增子序列的长度
给定一个未经排序的整数数组，找到最长且 连续递增的子序列，并返回该序列的长度。

连续递增的子序列 可以由两个下标 l 和 r（l < r）确定，如果对于每个 l <= i < r，都有 nums[i] < nums[i + 1] ，那么子序列 [nums[l], nums[l + 1], ..., nums[r - 1], nums[r]] 就是连续递增子序列。

 

示例 1：

输入：nums = [1,3,5,4,7]
输出：3
解释：最长连续递增序列是 [1,3,5], 长度为3。
尽管 [1,3,5,7] 也是升序的子序列, 但它不是连续的，因为 5 和 7 在原数组里被 4 隔开。 
示例 2：

输入：nums = [2,2,2,2,2]
输出：1
解释：最长连续递增序列是 [2], 长度为1。
暴力求解
class Solution {
    public int findLengthOfLCIS(int[] nums) {
        int len = nums.length;
        int ans = 1;
        int max = ans;
        for (int i = 0; i < len - 1; i++) {
            if (nums[i+1] <= nums[i]) max = 0;
            ans = Math.max(++max, ans);
        }
        return ans;
    }
}
动态规划
//版本一
class Solution {
    public int findLengthOfLCIS(int[] nums) {
            int n = nums.length;
            int[] dp = new int[n+1];
            Arrays.fill(dp,1);
            for(int i = 1;i<n;i++){
                if(nums[i]>nums[i-1])
                dp[i] = Math.max(dp[i],dp[i-1]+1);
            }
            int max = 1;
            for(int num:dp){
                max = Math.max(max,num);
            }

            return max;
    }
}
//优化
class Solution {
    public int findLengthOfLCIS(int[] nums) {
            int n = nums.length;
            int[] dp = new int[n+1];
            Arrays.fill(dp,1);
            int res = 1;
            for(int i = 1;i<n;i++){
                if(nums[i]>nums[i-1])
                dp[i] = dp[i-1]+1;
                if(dp[i]>res) res = dp[i];
            }



            return res;
    }
}
LeetCode 1218.最长定差子序列
给你一个整数数组 arr 和一个整数 difference，请你找出并返回 arr 中最长等差子序列的长度，该子序列中相邻元素之间的差等于 difference 。

子序列 是指在不改变其余元素顺序的情况下，通过删除一些元素或不删除任何元素而从 arr 派生出来的序列。

 

示例 1：

输入：arr = [1,2,3,4], difference = 1
输出：4
解释：最长的等差子序列是 [1,2,3,4]。

class Solution {
    public int longestSubsequence(int[] arr, int difference) {
        int ans = 1;
		Map<Integer, Integer> map = new HashMap<Integer, Integer>();
		for(int i = 0; i < arr.length; i++) {
			int temp = map.getOrDefault(arr[i]-difference, 0) + 1;//表示之前出现过等差子序列
			map.put(arr[i], temp);//新的长度
			ans = Math.max(ans, temp);
		}
		return ans;
    }
}
LeetCode 1143.最长公共子序列
给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。

一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。

例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。
两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。

 

示例 1：
输入：text1 = "abcde", text2 = "ace" 
输出：3 

解释：最长公共子序列是 "ace" ，它的长度为 3 。

示例 2：
输入：text1 = "abc", text2 = "abc"
输出：3

解释：最长公共子序列是 "abc" ，它的长度为 3 。

示例 3：
输入：text1 = "abc", text2 = "def"
输出：0

解释：两个字符串没有公共子序列，返回 0 。
 

提示：
1 <= text1.length, text2.length <= 1000
text1 和 text2 仅由小写英文字符组成。

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int m=text1.length();
        int n=text2.length();
        int[][] dp=new int[m+1][n+1];

        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                if(text1.charAt(i-1)==text2.charAt(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];
    }
}
LeetCode 718.最长重复子数组
给两个整数数组 nums1 和 nums2 ，返回 两个数组中 公共的 、长度最长的子数组的长度 。

 

示例 1：

输入：nums1 = [1,2,3,2,1], nums2 = [3,2,1,4,7]
输出：3
解释：长度最长的公共子数组是 [3,2,1] 。
示例 2：

输入：nums1 = [0,0,0,0,0], nums2 = [0,0,0,0,0]
输出：5

1.确定dp数组（dp table）以及下标的含义

​ dp[i] [j] ：以下标i - 1为结尾的A，和以下标j - 1为结尾的B，最长重复子数组长度为dp[i] [j]。 （特别注意： “以下标i - 1为结尾的A” 标明一定是 以A[i-1]为结尾的字符串 ）

此时细心的同学应该发现，那dp[0] [0]是什么含义呢？总不能是以下标-1为结尾的A数组吧。

其实dp[i] [j]的定义也就决定着，我们在遍历dp[i][j]的时候i 和 j都要从1开始。

那有同学问了，我就定义dp[i][j]为 以下标i为结尾的A，和以下标j 为结尾的B，最长重复子数组长度。不行么？

行倒是行！ 但实现起来就麻烦一点，大家看下面的dp数组状态图就明白了。

2.确定递推公式

根据dp[i] [j]的定义，dp[i] [j]的状态只能由dp[i - 1] [j - 1]推导出来。

即当A[i - 1] 和B[j - 1]相等的时候，dp[i] [j] = dp[i - 1] [j - 1] + 1;

根据递推公式可以看出，遍历i 和 j 要从1开始！

3.dp数组如何初始化

根据dp[i][j]的定义，dp[i] [0] 和dp[0] [j]其实都是没有意义的！

但dp[i] [0] 和dp[0] [j]要初始值，因为 为了方便递归公式dp[i] [j] = dp[i - 1] [j - 1] + 1;

所以dp[i] [0] 和dp[0 ][j]初始化为0。

//版本1
class Solution {
    public int findLength(int[] A, int[] B) {
        int len1 = A.length;
		int len2 = B.length;
		int[][] dp = new int[len1+1][len2+1];
		//初始化
		for(int i = 0; i < len1; i++) {
			dp[i][0] = 0;
		}
		for(int j = 0; j < len2; j++) {
			dp[0][j] = 0;
		}
		int ans = 0;
		//找出最长公共子数组
		for(int i = 1; i <= len1; i++) {
			for(int j = 1; j <= len2; j++) {
				if(A[i-1] == B[j-1]) {
					dp[i][j] = dp[i-1][j-1] + 1;
				}else {
					dp[i][j] = 0;
				}
				ans = Math.max(dp[i][j], ans);
			}
		}
		return ans;
    }
}
//版本2
class Solution {
    public int findLength(int[] nums1, int[] nums2) {
         int result = 0;
         int[][] dp = new int[nums1.length + 1][nums2.length + 1];
        
        for (int i = 1; i < nums1.length + 1; i++) {
            for (int j = 1; j < nums2.length + 1; j++) {
                if (nums1[i - 1] == nums2[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                    result = Math.max(result, dp[i][j]);
                }
            }
        }
        
        return result;
    }
}
LeetCode 516.最长回文子序列 返回长度
给你一个字符串 s ，找出其中最长的回文子序列，并返回该序列的长度。

子序列定义为：不改变剩余字符顺序的情况下，删除某些字符或者不删除任何字符形成的一个序列。

 

示例 1：

输入：s = "bbbab"
输出：4
解释：一个可能的最长回文子序列为 "bbbb" 。
示例 2：

输入：s = "cbbd"
输出：2
解释：一个可能的最长回文子序列为 "bb" 。
 

提示：

1 <= s.length <= 1000
s 仅由小写英文字母组成


//版本1
class Solution {
    public int longestPalindromeSubseq(String s) {
        int len = s.length();
        if(len <= 1) return len;
		int[][] dp = new int[len+1][len+1];
		for(int i = 0; i < len; i++) {
			dp[i][i] = 0;
		}
		char[] c = new char[len];
		int k = 0;
		for(int i = len-1; i >= 0; i--) {
			c[k++] = s.charAt(i);
		}
		for(int i = 1; i <= len; i++) {
			for(int j = 1; j <= len; j++) {
				if(c[j-1] == s.charAt(i-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[len][len];	
    }
}
//版本2
/*
	**1.确定dp数组（dp table）以及下标的含义**

	dp[i] [j]：字符串s在[i, j]范围内最长的回文子序列的长度为dp[i] [j]。

	**2.确定递推公式**

	在判断回文子串的题目中，关键逻辑就是看s[i]与s[j]是否相同。

	如果s[i]与s[j]相同，那么dp[i] [j] = dp[i + 1] [j - 1] + 2;
*/
 class Solution {
    public int longestPalindromeSubseq(String s) {
        int len = s.length();
        int[][] dp = new int[len + 1][len + 1];
        for (int i = len - 1; i >= 0; i--) { // 从后往前遍历 保证情况不漏
            dp[i][i] = 1; // 初始化
            for (int j = i + 1; j < len; j++) {
                if (s.charAt(i) == s.charAt(j)) {
                    dp[i][j] = dp[i + 1][j - 1] + 2;
                } else {
                    dp[i][j] = Math.max(dp[i + 1][j], Math.max(dp[i][j], dp[i][j - 1]));
                }
            }
        }
        return dp[0][len - 1];
    }
}
LeetCode 5.最长回文子串
给你一个字符串 s，找到 s 中最长的回文子串。

 

示例 1：

输入：s = "babad"
输出："bab"
解释："aba" 同样是符合题意的答案。
示例 2：

输入：s = "cbbd"
输出："bb"
暴力枚举
  public String longestPalindrome(String s) {
        String res = "";
        for(int i = 0; i < s.length(); i++) {
            // 最长回文子串是奇数时
            String s_odd = palindrome(s, i-1, i+1);
            // 最长回文子串是偶数时
            String s_even = palindrome(s, i, i + 1);
            // 比较以i开始扩散，最长回文子串是奇数和偶数，哪个更长
            String curr = s_odd.length() > s_even.length() ? s_odd : s_even;
            // 更新最长的文子串
            if(curr.length() > res.length()) res = curr;
        }
        return res;
    }

    private String palindrome(String s, int l, int r) {
        while(l >= 0 && r < s.length()) {
            // 向两端扩散，找最长回文子串
            if(s.charAt(l) == s.charAt(r)) {
                l--;
                r++;
            }else break;
        }
        // 找到以l和r开始的最长回文子串并返回
        return s.substring(l + 1, r);
    }
动态规划
//版本1
class Solution {
    public String longestPalindrome(String s) {
        		int len = s.length();
		if(s == null || len < 1) return s;
		int[][] dp = new int[len][len];
		String ans = "";
		int r = 1;
		int l = 0;
		String t = "";
		

		for(int i = 1; i < len; i++) {
			dp[i][i] = 1;
			for(int j = 0; j < i; j++) {
				if(s.charAt(i) == s.charAt(j)) {
					if(i - j < 3) {
						dp[j][i] = 1;
					}else {
						dp[j][i] = dp[j + 1][i - 1];
					}
					
				}else {
					dp[j][i] = 0;
					
				}
				if(dp[j][i] == 1) {
					int temp = i - j + 1;
					if(temp > r) {
						r = temp;
						l = j;
					}
				}
			}
		}
		return s.substring(l,r+l);
	}

}

//版本2
class Solution {
    public String longestPalindrome(String s) {
       int len = s.length();
        if(len == 1) {
            return s;
        }
        int maxLen = 1;
        int start = 0;
        boolean[][] dp = new boolean[len][len];
        for(int j = 1; j < len; j++) {
            for(int i = 0; i < j; i++) {
                if(s.charAt(i) != s.charAt(j)) { // 两边字符不同
                    dp[i][j] = false; // 必不是回文子串
                } else { // 两边字符相同
                    if(j - i < 3){ // 子串长度为2或3
                        dp[i][j] = true; // 必为回文子串
                    } else { // 子串长度大于3
                        dp[i][j] = dp[i+1][j-1]; // 与其之前的子串相关
                    }
                }
                if(dp[i][j] && (j-i+1 > maxLen)) {
                    maxLen = j - i + 1;
                    start = i;
                }
            }
        }
        return s.substring(start, start + maxLen);
    }
LeetCode 1027.最长等差数列
给你一个整数数组 nums，返回 nums 中最长等差子序列的长度。

回想一下，nums 的子序列是一个列表 nums[i1], nums[i2], ..., nums[ik] ，且 0 <= i1 < i2 < ... < ik <= nums.length - 1。并且如果 seq[i+1] - seq[i]( 0 <= i < seq.length - 1) 的值都相同，那么序列 seq 是等差的。

 

示例 1：

输入：nums = [3,6,9,12]
输出：4
解释： 
整个数组是公差为 3 的等差数列。
示例 2：

输入：nums = [9,4,7,2,10]
输出：3
解释：
最长的等差子序列是 [4,7,10]。
示例 3：

输入：nums = [20,1,15,3,10,5,8]
输出：4
解释：
最长的等差子序列是 [20,15,10,5]。
暴力枚举
class Solution {
public int longestArithSeqLength(int[] nums) {
        //暴力枚举 每两个的值
        int len=nums.length;int max=2;int max1=2;
        for(int i=0;i<len;i++){
            for(int j=i+1;j<len;j++){
                int k=nums[i]-nums[j];int left=nums[j];
                for(int x=j+1;x<len;x++){
                    if(left==nums[x]+k){
                        max++;
                        left=nums[x];
                        if(max>max1)max1=max;
                    }
                }
                max=2;
            }
        }
        return max1;
    }
    
  }
动态规划
class Solution {
    public int longestArithSeqLength(int[] nums) {
        //该dp[i][j]表示的含义为以索引i结尾的元素 公差为j的最大索引长度
        //考虑到公差可能为负数且数据范围为[0,500] 即公差范围为[-500,500]所以在每个公差之前加上500保证为整数
        int [][]dp = new int[nums.length][1001];
        int ans = 1;
        for(int i = 0; i < nums.length; i++)
        {
            for(int j = 0; j < i; j++)
            {
                int dif = nums[i] - nums[j] + 500;//表示的是以i为倒数第一个数 j为倒数第二个数的等差数列的公差
                dp[i][dif] = Math.max(dp[i][dif],dp[j][dif] + 1);
                ans = Math.max(ans,dp[i][dif]);
            }
        }
        return ans + 1;
    }
}
LeetCode 873.最长的斐波那契子序列的长度
如果序列 X_1, X_2, ..., X_n 满足下列条件，就说它是 斐波那契式 的：

n >= 3
对于所有 i + 2 <= n，都有 X_i + X_{i+1} = X_{i+2}
给定一个严格递增的正整数数组形成序列 arr ，找到 arr 中最长的斐波那契式的子序列的长度。如果一个不存在，返回  0 。

（回想一下，子序列是从原序列 arr 中派生出来的，它从 arr 中删掉任意数量的元素（也可以不删），而不改变其余元素的顺序。例如， [3, 5, 8] 是 [3, 4, 5, 6, 7, 8] 的一个子序列）

 

示例 1：

输入: arr = [1,2,3,4,5,6,7,8]
输出: 5
解释: 最长的斐波那契式子序列为 [1,2,3,5,8] 。
示例 2：

输入: arr = [1,3,7,11,12,14,18]
输出: 3
解释: 最长的斐波那契式子序列有 [1,11,12]、[3,11,14] 以及 [7,11,18] 。
 

提示：

3 <= arr.length <= 1000
1 <= arr[i] < arr[i + 1] <= 10^9


//版本1
class Solution {
    public int lenLongestFibSubseq(int[] A) {
       int len = A.length;
		if(len <= 2) return len;
		int[][] dp = new int[len][len];//dp以A[i]为最后一个数的最长斐波拉契子序列的长度
		for(int i = 0; i < len; i++) {
			Arrays.fill(dp[i], 2);//初始化
		}
		int ans = 0;
		//从前面的数组中选两个元素，如果相等就长度增一
		int l = 0;
		int r = 0;
		for(int i = 1; i < len; i++) {
			r = i - 1;
            l = 0;
			while(l < r) {
				int sum = A[l] + A[r];
				if(sum == A[i]) {
					dp[r][i] = Math.max(dp[r][i], dp[l][r] + 1);
					ans = Math.max(ans, dp[r][i]);
					l++;
					r--;
				}else if(sum < A[i]){
					l++;					
				}else {
                    r--;
                }
			}
		}
		return ans;
    }
}
//版本2
class Solution {
    public int lenLongestFibSubseq(int[] A) {
        //从i开始，下一个是j
        int max = 2;
        for(int i = 0; i < A.length; i++){
            for(int j = i + 1; j < A.length; j++){
                int tmpI = A[i];
                int tmpJ = A[j];
                int sum = tmpI + tmpJ;
                int cur = 2;
                //存在
                while(Arrays.binarySearch(A, sum) >= 0){
                    tmpI = tmpJ;
                    tmpJ = sum;
                    sum = tmpI + tmpJ;
                    cur++;
                }
                max = Math.max(max, cur);
            }
        }
        return max < 3 ? 0 : max;
    }
}
bobo_cke
关注
动态规划之子序列问题
小朱小朱绝不认输的博客
11-26 3559
文章目录一、动态规划之子序列问题二、leetcode例题讲解子序列问题1. 子序列（不连续）300. 最长递增子序列1143. 最长公共子序列1035. 不相交的线2. 子序列（连续）674. 最长连续递增序列718. 最长重复子数组53. 最大子序和3. 编辑距离392. 判断子序列115. 不同的子序列583. 两个字符串的删除操作72. 编辑距离4. 回文串647. 回文子串516. 最长回文子序列 子序列问题是动态规划中一系列常见的问题，有多个种类，这里对动态规划的子序列问题进行汇总。 一、动态规划
leetcode 1425. 带限制的子序列和
2201_75526359的博客
07-09 69
依次算出以nums[i]结尾的数组的最大和，用h[i]表示，不同之处在于相邻两个数的下标有一定的限制，按照从左到右的顺序依次加入数组元素，加入的元素的下标需要与队首的下标差小于等于k，否则将队首弹出，因为队首存放的是最大值，只有当前存放的元素与最大值的下标差符合条件时，数组的和才会尽可能地大，最后就是维护一个单调递减队列，保持队首最大。
leetcode动态规划中子序列问题求解分析
qq_45248909的博客
04-14 523
前面几篇文章介绍了代码随想录中的背包问题，股票问题等，本篇文章介绍剩余的子序列问题。若有错误，望指正。link。
【LeetCode】最长公共子序列（动态规划）
小七的博客
07-31 515
LeetCode 691：给定两个字符串str1和str2， 返回这两个字符串的最长公共子序列长度 比如 ： str1 = “a12b3c456d”,str2 = “1ef23ghi4j56k” 最长公共子序列是“123456”，所以返回长度6 。利用动态规划求解
leetcode 动态规划——java实现
weixin_44040169的博客
08-13 719
dp代表的什么，状态转移方程，填表
LeetCode1143. 最长公共子序列 动态规划详解
Lentr0py的博客
08-12 645
通过动态规划的思想，我们能够高效地解决最长公共子序列问题。通过合理定义dp数组的含义，状态转移方程，以及对初始状态的处理，可以解决类似的子序列问题。
leetcode动态规划之子序列、子串问题
echo_186的博客
04-14 800
leetcode刷题记录动态规划一、斐波那契数列1、迭代写法（dp数组） 动态规划 一、斐波那契数列 1、迭代写法（dp数组） // An highlighted block class Solution { public: int fib(int n) { vector<int> dp(n+1,0);//vector<int>要记得初始化 if(n<1) return 0; if(n==1||n==2)
leetcode1143. 最长公共子序列-动态规划(java)
SP_1024的博客
06-04 1612
给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。例如，“ace” 是 “abcde” 的子序列，但 “aec” 不是 “abcde” 的子序列。两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。解释：最长公共子序列是 “ace” ，它的长度为 3。解释：最长公共子序列是 “abc” ，它的长度为 3。解释：两个字符串没有公共子序列，返回 0。
LeetCode 300. 最长递增子序列 动态规划 + 贪心 详解
Lentr0py的博客
08-12 1079
最长递增子序列问题通过动态规划和贪心 + 二分查找两种方法来解决。动态规划法简单直观，但时间复杂度较高，而贪心 + 二分查找法在时间复杂度上具有优势，适用于数据规模较大的情况。
Java实现 LeetCode 300 最长上升子序列
12-22
300. 最长上升子序列 给定一个无序的整数数组，找到其中最长上升子序列的长度。 示例: 输入: [10,9,2,5,3,7,101,18] 输出: 4 解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。 说明: 可能会有多种最长上升子...
Java实现 LeetCode 659 分割数组为连续子序列 (哈希)
12-21
这个问题是LeetCode中的第659题，名为“分割数组为连续子序列”。题目要求给定一个升序排列的整数数组，判断是否可以将其分割成至少包含三个连续整数的子序列。如果可以，返回true；否则，返回false。题目中提到的...
【leetcode】300.最长上升子序列（动态规划多种解法， java实现）
Viper的程序员修炼手册
08-06 1013
300. 最长上升子序列 难度中等 给定一个无序的整数数组，找到其中最长上升子序列的长度。 示例: 输入: [10,9,2,5,3,7,101,18] 输出: 4 解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。 说明: 可能会有多种最长上升子序列的组合，你只需要输出对应的长度即可。 你算法的时间复杂度应该为 O(n2) 。 进阶: 你能将算法的时间复杂度降低到 O(n log n) 吗? 分析 首先，需要对「子序列」和「子串」这两个概念进行区分； 子序列（subsequen
Leetcode动态规划题
weixin_41812379的博客
03-10 743
动态规划 基本思想：问题的最优解如果可以由子问题的最优解推导得到，则可以先求解子问题的最优解，再构造原问题的最优解；若子问题有较多的重复出现，则可以自底向上从最终子问题向原问题逐步求解。 使用条件：可分为多个相关子问题，子问题的解被重复使用。 基本步骤： 首先创建一个存放子问题的解的空间，并做初始化。 将原问题尝试拆成多个子问题，并使得子问题的解可以求出原问题的解，这个通过子问题解求出原问题解的方程就叫做状态转移方程。 根据状态转移方程自底向上得到原问题解。 （附加）有时候存放子问题的解的空间可以优化得更
【力扣 + 牛客 | SQL题 | 每日5题】牛客SQL热题216，217，223
2301_80912559的博客
10-30 970
你正在搭建一个用户活跃度的画像，其中一个与活跃度相关的特征是“最长连续登录天数”， 请用SQL实现“2023年1月1日-2023年1月31日用户最长的连续登录天数”一句话：两个记录的日期的差值如果等于两记录的排名差值，说明中间一直是连续的。使用join查询方式找出没有分类的电影id以及其电影名称。这不一眼窗口函数么。
【力扣专题栏】合并K个升序链表，3种解法讲解如何实现vector容器里面多个链表的合并？
2301_78704584的博客
10-30 344
解释：首先vector容器里面放有多个元素，每个元素是一个链表，每个链表含有0个或多个节点。当到达递归结束条件时，就开始往回归并。
Leetcode 62. 不同路径 动态规划+空间优化
最新发布
想买很多漂亮衣服但是买不起的博客
11-01 286
【代码】Leetcode 62. 不同路径 动态规划+空间优化。
【二分查找】【三种写法】——在排序数组中查找元素的第一个和最后一个位置#力扣hot100
weixin_47868976的博客
10-31 1032
给你一个按照非递减顺序排列的整数数组nums，和一个目标值target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值target，返回[-1, -1]。必须设计并实现时间复杂度为O(log n)的算法解决此问题。
力扣-最小覆盖子串
Dennis_nafla的博客
10-29 297
可以定义一个distance这样的int变量，当移动右指针后，如果此时右指针指向的字符在当前窗口中的个数严格小于t中所需要的个数，那么distance++。滑动窗口，初始时左右指针都指向s的第一个字符,对于每个遍历到的窗口，判断当前窗口是否包含了t中所需要的所有字符，不是的话就移动右指针，是的话就移动左指针。在移动左指针前,如果此时左指针指向的字符在当前窗口中的个数等于t中所需要的个数，那么distance--。给定一个字符串s,和目标字符串t，需要找出s中包含t中所有字符且长度最小子串，输出这个子串。
LeetCode115：不同的子序列
Ricky_youngone的博客
10-29 254
这个是因为先判断s[i - 1]==t[i - 1]的话，第一种情况就是我们的s和t串都往前走一个单位，这个算一个，然后再加上能够符合这个条件的方案，也即是dp[i - 1][j]，这个就是t串不走了，但是s串能往前走，并且还相等的。这里就把dp[i][0] = 1;这个也需要我们去画一个2*2的方格，然后去看到这个dp[i][j]是从哪两个方向推导出来的，比如这个题，就可以从由上到下，由左到右推导出来这个公式，那么遍历顺序就直接从1开始就好。dp含义：以i-1为结尾的s中有以j-1为结尾的t的个数为。
PHP解决LeetCode乘积最大子序列问题详解
"乘积最大子序列"是leetcode中的一个经典动态规划问题，它要求找出一个数组中乘积最大的连续子序列。 标题中提到的“php-leetcode题解之乘积最大子序列.zip”表明这是一份使用PHP语言编写的关于leetcode题解的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值