三道典型连续子序列题

最新推荐文章于 2022-10-04 16:58:34 发布
最新推荐文章于 2022-10-04 16:58:34 发布
阅读量203 收藏
点赞数
分类专栏： Java

一、问题描述

这是三道典型的dp问题。
最长上升子序列： 在一列数中寻找一些数，这些数满足：任意两个数a[i]和a[j]，若i<j，必有a[i]<a[j]，这样最长的子序列称为最长递增（上升）子序列。

设dp[i]表示以i为结尾的最长递增子序列的长度，则状态转移方程为：dp[i] = max{dp[j]+1}, 1<=j<i,a[j]<a[i].时间复杂度为O(n*n)；

考虑两个数a[x]和a[y]，x<y且a[x]<a[y],且dp[x]=dp[y]，那么我们该选择哪个呢？显然a[x],因为它更有潜力，也就是说我们可以用a[x]来替换掉a[y]，也就是说我们需要维护一个数据结构来存储可能的递增子序列的元素，并且需要在某些时候进行替换。因此我们可以用一个链表来存储，并且在查找替换位置的时候用二分查找来实现，这样时间复杂度为O(nlogn)。


最大连续子序列和：在一列数中寻找一些数，这些数满足：任意两个数a[i]和a[j]，若i+1=j，必有a[i]<a[j]，且∑()最大。需要明确的是状态转移方程中的状态代表的含义。因为contiguous，所以dp[i]代表的应该以i位置元素结尾的连续值，并非最大值。


最长公共子串：两个字符串中的最常公共连续子串。

找 两个字符串的最长公共子串，这个子串要求在原字符串中是连续的。其实这又是一个序贯决策问题，可以用动态规划来求解。我们采用一个二维矩阵来记录中间的结 果。这个二维矩阵怎么构造呢？直接举个例子吧："bab"和"caba"(当然我们现在一眼就可以看出来最长公共子串是"ba"或"ab")
　　 b　　a　　b
c　　0　　0　　0
a　　0　　1　　0
b　　1　　0　　1
a　　0　　1　　0
我们看矩阵的斜对角线最长的那个就能找出最长公共子串。
不过在二维矩阵上找最长的由1组成的斜对角线也是件麻烦费时的事，下面改进：当要在矩阵是填1时让它等于其左上角元素加1。
　　 b　　a　　b
c　　0　　0　　0
a　　0　　1　　0
b　　1　　0　　2
a　　0　　2　　0
这样矩阵中的最大元素就是 最长公共子串的长度。

因此我们需要维护一个二维数组，行数为第一个字符串的长度，列数为第二个字符串的长度。为了截取子串，那么我们需要子串的起始和结束索引。借助之前的分析，因为dp里记录的是到某个节点的长度，因此我们可以通过维护一个长度和结束索引来变相的记录子串的起始和结束索引。

二、Java 代码


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     /**
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 * 最长递增子序列
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 * 
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 * @param nums
    
    
    
   
   
  5. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 * @return
    
    
    
   
   
  6. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 */
    
    
    
   
   
  7. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     public int getLIS(int[] nums) {
    
    
    
   
   
  8. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
            
     
     if (nums==
     
     null || nums.length==
     
     0) {
    
    
    
   
   
  9. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    			
     
     return 
     
     0;
    
    
    
   
   
  10. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		}
    
    
    
   
   
  11. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     int max = 
     
     1;
    
    
    
   
   
  12. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     int[] dp = 
     
     new 
     
     int[nums.length];
    
    
    
   
   
  13. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     for (
     
     int i = 
     
     0; i < nums.length; i++) {
    
    
    
   
   
  14. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     			dp[i] = 
     
     1;
    
    
    
   
   
  15. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    			
     
     for (
     
     int j = 
     
     0; j < i; j++) {
    
    
    
   
   
  16. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    				
     
     if (nums[j]<nums[i]) {
    
    
    
   
   
  17. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     					dp[i] = Math.max(dp[i], dp[j]+
     
     1);
    
    
    
   
   
  18. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     					max = Math.max(dp[i], max);
    
    
    
   
   
  19. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     				}
    
    
    
   
   
  20. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     			}
    
    
    
   
   
  21. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		}
    
    
    
   
   
  22. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     return max;
    
    
    
   
   
  23. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
         }
    
    
    
   
   
  24. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     /**
    
    
    
   
   
  25. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 * 最长递增子序列
    
    
    
   
   
  26. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 * 
    
    
    
   
   
  27. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 * @param nums
    
    
    
   
   
  28. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 * @return
    
    
    
   
   
  29. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 */
    
    
    
   
   
  30. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     public int getLIS(int[] nums) {
    
    
    
   
   
  31. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     if (nums == 
     
     null || nums.length == 
     
     0) {
    
    
    
   
   
  32. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    			
     
     return 
     
     0;
    
    
    
   
   
  33. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		}
    
    
    
   
   
  34. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		ArrayList<Integer> dp = 
     
     new ArrayList<>();
    
    
    
   
   
  35. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     for (
     
     int item : nums) {
    
    
    
   
   
  36. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    			
     
     if (dp.size() == 
     
     0 || dp.get(dp.size() - 
     
     1) < item) {
    
    
    
   
   
  37. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     				dp.add(item);
    
    
    
   
   
  38. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     			} 
     
     else {
    
    
    
   
   
  39. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    				
     
     int i = Collections.binarySearch(dp, item);
     
     //insert position
    
    
    
   
   
  40. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     				dp.set(i < 
     
     0 ? -i - 
     
     1 : i, item);
    
    
    
   
   
  41. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     			}
    
    
    
   
   
  42. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		}
    
    
    
   
   
  43. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     return dp.size();
    
    
    
   
   
  44. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	}
    
    
    
   
   
  45. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  46. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     /**
    
    
    
   
   
  47. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 * 最大连续子序列和
    
    
    
   
   
  48. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 * 
    
    
    
   
   
  49. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 * @param nums
    
    
    
   
   
  50. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 * @return
    
    
    
   
   
  51. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 */
    
    
    
   
   
  52. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     public int getMaxSubArray(int[] nums) {
    
    
    
   
   
  53. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     if (nums == 
     
     null || nums.length == 
     
     0) {
    
    
    
   
   
  54. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    			
     
     return 
     
     0;
    
    
    
   
   
  55. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		}
    
    
    
   
   
  56. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     int maxEndingHere = 
     
     0;
    
    
    
   
   
  57. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     int maxSoFar = Integer.MIN_VALUE;
    
    
    
   
   
  58. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     for (
     
     int i = 
     
     0; i < nums.length; i++) {
    
    
    
   
   
  59. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    			
     
     if (maxEndingHere < 
     
     0) {
    
    
    
   
   
  60. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     				maxEndingHere = 
     
     0;
    
    
    
   
   
  61. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     			}
    
    
    
   
   
  62. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     			maxEndingHere += nums[i];
    
    
    
   
   
  63. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     			maxSoFar = Math.max(maxSoFar, maxEndingHere);
    
    
    
   
   
  64. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		}
    
    
    
   
   
  65. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     return maxSoFar;
    
    
    
   
   
  66. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	}
    
    
    
   
   
  67. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  68. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     /**
    
    
    
   
   
  69. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 * 最长公共子串
    
    
    
   
   
  70. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 * 
    
    
    
   
   
  71. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 * @param a
    
    
    
   
   
  72. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 * @param b
    
    
    
   
   
  73. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 * @return
    
    
    
   
   
  74. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	 */
    
    
    
   
   
  75. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     public String getLCS(String a, String b) {
    
    
    
   
   
  76. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     if (a == 
     
     null || b == 
     
     null || a.length() == 
     
     0 || b.length() == 
     
     0) {
    
    
    
   
   
  77. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    			
     
     return 
     
     null;
    
    
    
   
   
  78. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		}
    
    
    
   
   
  79. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     int[][] dp = 
     
     new 
     
     int[a.length()][b.length()];
    
    
    
   
   
  80. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     int endHere = 
     
     0;
    
    
    
   
   
  81. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     int maxLen = 
     
     0;
    
    
    
   
   
  82. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     for (
     
     int i = 
     
     0; i < a.length(); i++) {
    
    
    
   
   
  83. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    			
     
     for (
     
     int j = 
     
     0; j < b.length(); j++) {
    
    
    
   
   
  84. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    				
     
     if (i == 
     
     0 || j == 
     
     0) {
    
    
    
   
   
  85. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     					dp[i][j] = a.charAt(i) == b.charAt(j) ? 
     
     1 : 
     
     0;
    
    
    
   
   
  86. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     				} 
     
     else {
    
    
    
   
   
  87. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     					dp[i][j] = a.charAt(i) == b.charAt(j) ? dp[i - 
     
     1][j - 
     
     1] + 
     
     1
    
    
    
   
   
  88. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     							: 
     
     0;
    
    
    
   
   
  89. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     				}
    
    
    
   
   
  90. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    				
     
     if (dp[i][j] > maxLen) {
    
    
    
   
   
  91. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     					maxLen = dp[i][j];
    
    
    
   
   
  92. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     					endHere = i;
    
    
    
   
   
  93. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     				}
    
    
    
   
   
  94. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     			}
    
    
    
   
   
  95. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		}
    
    
    
   
   
  96. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    		
     
     return a.substring(endHere - maxLen + 
     
     1, endHere + 
     
     1);
    
    
    
   
   
  97. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	}


wwwwp1761860177
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
字符串中查找长度最大的递增字符子串
qfl_sdu的博客
06-07 427
功能描述 比如字符串“1239871234509876123456789"中，递增字串为： 123 9 8 7 12345 09 8 7 7 123456789 最长的就是123456789 代码 #include <stdio.h> #include <string.h> #define MAX_SIZE 100000 int main() { char buf[MAX_SIZE] = {0}; int i = 0,len = 0,index = 0; char maxbuf
python字符串中最长的连续升序子串_Python算法之旅系列文章目录
weixin_39627699的博客
12-20 168
Article Directory文章目录前言人生苦短，我用Python。Python语言以其简明优雅、易于开发，代码简短，可扩展性强和丰富的第三方库等特征深受广大人们喜爱。多数人使用Python来进行软件开发和数据处理，作为一名高中信息技术教师，我想从学习算法的角度来使用Python，利用Python简明优雅的特性来描述算法问题，使程序员能直指问题的核心，而不是陷入代码细节的泥淖。我计...
力扣300：最长递增子序列（Java动态规划+双指针）
m0_49499183的博客
10-04 1310
给你一个整数数组 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。
Java最长递增子序列的个数leetcode
qq_42900213的博客
04-28 487
给定一个未排序的整数数组nums，返回最长递增子序列的个数。 注意这个数列必须是严格递增的。 class Solution { public int findNumberOfLIS(int[] nums) { int n = nums.length; int[] f = new int[n]; int[] g = new int[n]; //当前最长子串长度 int max = 1; ...
lintcode 最长上升连续子序列 II(二维最长上升连续序列)
aipiannian6725的博客
11-22 315
题目链接：http://www.lintcode.com/zh-cn/problem/longest-increasing-continuous-subsequence-ii/ 最长上升连续子序列 II 　　给定一个整数矩阵（其中，有 n 行， m 列），请找出矩阵中的最长上升连续子序列。（最长上升连续子序列可从任意行或任意列开始，向上/下/左/右任意方向移动）。 样例 ...
PTA丨最长连续递增子序列
09-30
本题“PTA丨最长连续递增子序列”是一个典型的动态规划问题，它涉及到数组处理、序列分析以及优化算法等方面的知识。 首先，我们要明确什么是“最长连续递增子序列”。在给定的整数数组中，一个连续递增子序列是指...
Java实现 LeetCode 659 分割数组为连续子序列 (哈希)
12-21
在LeetCode的第659题“分割数组为连续子序列”中，主要涉及的问题是判断一个升序排列且可能包含重复元素的整数数组，是否可以被分割成多个至少包含三个连续整数的子序列。这是一个组合问题，可以通过哈希表来优化...
javascript-leetcode面试题解动态规划问题之第1143题最长公共子序列-题解.zip
最新发布
03-16
本压缩包文件“javascript-leetcode面试题解动态规划问题之第1143题最长公共子序列-题解.zip”包含了关于动态规划解决方案的详细解析，这是一道典型的算法面试题。 动态规划是一种解决复杂问题的有效方法，它通过将...
十套数据结构试题及答案.doc
09-28
数组是一种静态的数据结构，元素在内存中是连续存放的，可以通过下标快速访问。链表则是动态数据结构，元素之间的关系通过指针建立，插入和删除操作通常比数组更灵活。栈是一种后进先出（LIFO）的数据结构，常用于...
最长上升子串
qq_41706331的博客
05-16 2348
给定一个数组求其最长上升子串 输入样例： 6 3 2 4 5 3 6 输出样例： 3 解释：子串区别于子序列，子序列不要求连续，子串要求连续 #include<cstdio> #include<algorithm> using namespace std; int dp[100]; int main() { int n,list[100],ans=...
字符串的最大递增子串
天地正气，古今完人
09-15 2538
字符串的最大递增子串
字符串的连续递增数字串
零丁若叹
04-19 3647
求字符串的连续递增数字子串，如“abcd123456”
动态规划解最长上升子序列（全）
相由心生的博客
10-08 5237
1、动态规划问题导览： 最长上升子序列（longest  increasing subsequence）问题，也可以叫最长非降序子序列，简称LIS。是动态规划算法的一个经典应用。 我们都知道，动态规划的一个特点就是当前解可以由上一个阶段的解推出， 由此，把我们要求的问题简化成一个更小的子问题。子问题具有相同的求解方式，只不过是规模小了而已。最长上升子序列就符合这一特性。我们要求n个数的最长上...
寻找字符串里边的最长连续子串
boKeB1
07-13 659
function foo(str){ if(str == null)return "" var curr = "" var map = {} var count = 0 //整理map-count for(let i in str){ curr = i if(curr[i+1] == curr){ count ++ }else{ map[curr] = 1 } } //在map中找出最大的count即target var target for(let i in
最长上升子序列(Java)
qq_43404873的博客
10-29 976
题目 方法一: public static int getMax(int n,int[]a){ //记录最长上升子序列问题 int [] dp = new int[n]; int res = 0 ; int maxj = 0; //记录上升序列的最后的一个值 for (int i = 0; i < n; i++) { res++; //将自身加进去 maxj = a[i
最大连续子串和
热门推荐
没有永远的渣渣
10-31 1万+
public int MaxSubArray(int[] array){ int sum = array[0]; int temp = array[0]; int indexFirst = 0; int indexLast = 0; for(int i=1; i<array.length; i++){ if(temp < 0
找出连续最长数字串python_字符串中找出连续最长的数字串
weixin_39593523的博客
12-20 1843
36/*算法思想：用max表示经过的数字长度最大值，count表示数字计数器，当为字母时重置为0*end表示数字尾部，每次满足数字时，对max进行判断，当max小于于count时，更新max和end*/import java.util.Scanner;public class Main {public static void main(String[] args) {Scanner scanner...
动态规划（三）最长递增子序列LIS、最大连续子序列和、最大连续子序列乘积
coolwriter的博客
04-12 4795
最长递增子序列LIS 问题 给定一个长度为N的数组，找出一个最长的单调自增子序列（不一定连续，但是顺序不能乱）。例如：给定一个长度为6的数组A{5， 6， 7， 1， 2， 8}，则其最长的单调递增子序列为{5，6，7，8}，长度为4. 最长递增子序列 O(NlgN）算法 假设存在一个序列d[1..9] ={ 2，1 ，5 ，3 ，6，4， 8 ，9， 7}，可以看出来它的LIS长度为5...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值