Java 使用递归查找所有可能的最长递增子序列
我试图使用递归找到所有可能的最长递增子序列。当我尝试一个输入数组Java 使用递归查找所有可能的最长递增子序列,java,algorithm,backtracking,lis,recursive-backtracking,Java,Algorithm,Backtracking,Lis,Recursive Backtracking,我试图使用递归找到所有可能的最长递增子序列。当我尝试一个输入数组{10,22,9,33,21,50,41,40,60,55}时,它工作了,输出是: 10 22 33 40 55 / 10 22 33 41 55 / 10 22 33 50 55 / 10 22 33 40 60 / 10 22 33 41 60 / 10 22 33 50 60 / 但是当我尝试一个输入数组{2,-3,4,90,-2,-1,-10,-9,-8}时,我得到了一个输出: -3 4 90 / -3 -2 -1 / -
{10,22,9,33,21,50,41,40,60,55}
时,它工作了,输出是:
10 22 33 40 55 /
10 22 33 41 55 /
10 22 33 50 55 /
10 22 33 40 60 /
10 22 33 41 60 /
10 22 33 50 60 /
但是当我尝试一个输入数组{2,-3,4,90,-2,-1,-10,-9,-8}
时,我得到了一个输出:
-3 4 90 /
-3 -2 -1 /
-10 -9 -8 /
在这种情况下,我没有得到2490
。我应该在我的代码中做什么更改,使其成为本案例的word
public class Main {
public static void main(String[] args) {
int arr[]={10,22,9,33,21,50,41,40,60,55};
int lis[]=new int[arr.length];
for(int i=0;i<arr.length;i++){
lis[i]=1;
}
for(int i=1;i<arr.length;i++){
for(int j=0;j<i;j++){
if(arr[i]>arr[j]&&lis[i]<lis[j]+1){
lis[i]=lis[j]+1;
}
}
}
int max=0;
for(int i=0;i<arr.length;i++){
if(max<lis[i])
max=lis[i];
}
//**************Recursive Print LIS****************
int rIndex=-1;
for(int i=arr.length-1;i>=0;i--){
if(lis[i]==max){
rIndex=i;
break;
}
}
int res[]=new int[max];
printLISRecursive(arr,rIndex,lis,res,max,max);
}
private static void printLISRecursive(int[] arr, int maxIndex, int[] lis, int[] res, int i, int max) {
if(maxIndex<0)return;
if(max==1&&lis[maxIndex]==1&&i==1){
res[i-1]=arr[maxIndex];
// System.out.println("Using Print Recursion:");
for(int j=0;j<res.length;j++){
System.out.print(res[j]+" ");
}
System.out.println();
return;
}
if(lis[maxIndex]==max){
res[i-1]=arr[maxIndex];
printLISRecursive(arr, maxIndex-1, lis, res, i-1, max-1);
}
printLISRecursive(arr, maxIndex-1, lis, res, i, max);
}
}
公共类主{
公共静态void main(字符串[]args){
int arr[]={10,22,9,33,21,50,41,40,60,55};
int lis[]=新int[arr.length];
对于(inti=0;我很想回答:算法。你的代码看起来很复杂。为什么你要传递3个数组作为参数?为什么(2,40,90)是正确的答案,而实际上输入序列中有(2,-3,4,90)?啊,我明白了,你不需要连续序列,对不起。对于:intarr[]={2,-3,4,90,-2,-1,-10,-9,-8}我得到了-10-9-8/-3-2-8/-3-4-8/-3-2-1/-3-4-1/-3-4 90/我只是复制粘贴了你的算法;-3-2-8/-3-4-8/-3-4-1并没有增加子序列。
public static int lcsrec(String x, String y) {
// If one of the strings has one character, search for that character
// in the other string and return the appropriate answer.
if (x.length() == 1)
return find(x.charAt(0), y);
if (y.length() == 1)
return find(y.charAt(0), x);
// Solve the problem recursively.
// Corresponding beginning characters match.
if (x.charAt(0) == y.charAt(0))
return 1+lcsrec(x.substring(1), y.substring(1));
// Corresponding characters do not match.
else
return max(lcsrec(x,y.substring(1)), lcsrec(x.substring(1),y));
}
public static String lcs(String a, String b){
int aLen = a.length();
int bLen = b.length();
if(aLen == 0 || bLen == 0){
return "";
}else if(a.charAt(aLen-1) == b.charAt(bLen-1)){
return lcs(a.substring(0,aLen-1),b.substring(0,bLen-1))
+ a.charAt(aLen-1);
}else{
String x = lcs(a, b.substring(0,bLen-1));
String y = lcs(a.substring(0,aLen-1), b);
return (x.length() > y.length()) ? x : y;
}
}