Leetcode序列问题——Java

最长公共子序列，乘积最大子序列，和最大子序列，最长上升子序列

最长公共子序列LCS

使用一个二维dp数组表示两个字符串的最长公共子序列的长度，dp[i][j]表示当s1取到第i个字符，s2取到第j个字符时的LCS。
dp[i][j]分两种情况达到：

• 当s1[i] == s2[j]时，现在s1和s2的LCS就是上一个字符时的LCS+1: dp[i][j] = dp[i-1][j-1] +1
• 当s1[i] != s2[j]时，现在s1和s2的LCS就看看是i-1时的LCS长，还是j-1时的LCS长，取最大值:

public String LCS(String s1, String s2){
	int[][] dp = new int[s1.length()+1][s2.length()+1];
	for(int i = 1; i <= s1.length(); i++){
		for(int j = 1; j <= s2.length(); j++){
			if(s1.charAt(i - 1) == s2.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[s1.length()][s2.length()];
}

乘积最大的连续子序列

使用一个二维dp数组表示当前的最大乘积，dp[i][0]表示当前的最大乘积，dp[i][1]表示当前的最小乘积（因为乘了负数），当当前数是正数时，就让它跟dp[i][0]乘，当当前数是负数时，就让它跟dp[i][1]乘，这样就可以得到最大乘积。

public int maxMulti(int[] arr){
	int[][] dp = new int[arr.length][2];
	//设置初态
	dp[0][0] = arr[0];
	dp[0][1] = arr[0];
	int max = arr[0];
	for(int i = 1; i < arr.length; i++){
		dp[i][0] = Math.max(Math.max(dp[i-1][0] * arr[i], dp[i-1][1] * arr[i]), arr[i]);
		dp[i][1] = Math.min(Math.min(dp[i-1][0] * arr[i], dp[i-1][1] * arr[i]), arr[i]);
		max = Math.max(max, dp[i][0]);
	}
	return max;
}

和最大的连续子序列

思路同上

public int maxMulti(int[] arr){
	int[][] dp = new int[arr.length][2];
	//设置初态
	dp[0][0] = arr[0];
	dp[0][1] = arr[0];
	int max = arr[0];
	for(int i = 1; i < arr.length; i++){
		dp[i][0] = Math.max(Math.max(dp[i-1][0] + arr[i], dp[i-1][1] + arr[i]), arr[i]);
		dp[i][1] = Math.min(Math.min(dp[i-1][0] + arr[i], dp[i-1][1] + arr[i]), arr[i]);
		max = Math.max(max, dp[i][0]);
	}
	return max;
}

也可以使用临时最大值cur记录当前的最大值，然后更新

public int maxMulti(int[] arr){
	int cur = arr[0];
	int max = arr[0];
	for(int i = 1; i < arr.length; i++){
		cur = Math.max(cur + arr[i], arr[i]);
		max = Math.max(cur, max);
	}
	return max;
}

最长上升子序列（非连续）

使用一个一维dp表示到第i个字符时的最长序列长度，使用两重循环，第一重一个指针i从头到尾，第二重一个指针j从头遍历到i，如果前数小于后数（arr[j] < arr[i]）表示时上升的序列，并且当前上升长度+1后超过了之前的上升长度，就更新这个长度

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

最长上升子序列（连续）

设置临时变量cur记录当前的最长序列长度，如果前数大于后数了则不为上升序列了，就更新序列长度

public int lengthOfLIS(int[] arr){
	int cur = 1; //最短的子序列长度为1
	int max = 0;
	for(int i = 1; i < arr.length; i++){
		if(arr[i-1] < arr[i])
			cur++;
		else{
			max = Math.max(cur, max);
			cur = 1; //重置cur，方便下次重新开始计数
		}
	}
	return Math.max(cur, max); 
	//这里使用max函数的原因是防止出现序列是[1,2,3]这种完全升序，导致else块不执行，max得不到更新，最后return 0的错误
}