最长递增子序列，最长递增字串

最长递增子序列；

动态规划的思路求解。遍历数组至index =i处，0到i-1的递增子序列是可以确定的。现在用一个数组B存储：B[1]中存储的是长度为1的递增子序列的最后一个元素的值，B[2]中存储的是长度为2的递增子序列的最后一个元素的值。假设现在遍历到index =i处，i往前看，可以得到一个B[1]....B[m]的数组，有两种情况：1）array[i]的值比B[m]还要大，则此时最长的递增子序列长度为m+1，令B[+1] = array[i];2)array[i]的值介于B[1]....B[m]之间，找到B[j]<array[i],B[j+1]>array[i]，修改B[i+1]
= array[i];

最后最长递增子序列的长度为m，注意最长递增子序列可能不是唯一的。找出其中一个长度为m的最长递增子序列。1）从len-1开始遍历array，首先找到B[m]=array[k]，将result[m-1]=array[k];2)往前遍历，两种情况，当要填充result[m-2]时，只需要找到array[k]<result[m-1],result[m-2]=array[k]；当要result数组最后两个位置填充满了以后,array[k]<result[m-x],result[m-x-1] = array[k];else
result[m-x] =array[k] 注：策略的思想是从后往前看，找到下降最慢的一个子序列

public class LongestIncreaSubSeq {

public static void main(String[] arqs){

int[] a = new int[]{1,-1,2,-3,4,-5,6,-7};

System.out.println("长度："+longestIncSubSeq(a));

}

public static int longestIncSubSeq(int[] array){
int len = array.length;
if(len == 0)
return 0;
int[] B = new int[len+1];

B[1] = array[0];
int j=1;
for(int i=1;i<len;i++){
int tmp =array[i];
if(tmp > B[j]){
B[j+1] = tmp;
j++;
}else{
int start=1,end = j;
while(start<end){
int c = (start+end)/2;
if(B[c] <tmp)
start = c+1;
else
end=c;
}
B[start] = tmp;
}
}

int[] result = new int[j];
boolean flag = false;
for(int i=len-1,k=j-1;i>=0&&k>=0;i--){
if(B[j] == array[i]){
result[k] = array[i];
flag = true;
}
if(flag){
if(k == j-1){
if(array[i]<result[k]){
result[k-1] = array[i];
k--;
}
}else{
if(array[i]>=result[k]){
result[k] = array[i];
}else{
result[k-1] = array[i];
k--;
}
}
}
}

for(int i=0;i<result.length;i++){
System.out.print(result[i]+" ");
}

return j;

}

}

最长递增字串

public class LongestIncSubSeq_02 {

public static void main(String[] arqs){

int[] a = new int[]{1,2,3,-1,2,3,4,5,6};
System.out.println("长度："+longestIncSubSeq(a));

}

public static int longestIncSubSeq(int[] array){
int len = array.length;
if(len ==0)
return 0;

int start_index =0;
int tmp_len = 0;
int max_start_index =0;
int max_len=0;

for(int i=1;i<len;i++){
if(array[i]>array[i-1]){
continue;
}else{
tmp_len = i-1-start_index+1;
if(tmp_len >max_len){
max_len = tmp_len;
max_start_index = start_index;
}
start_index = i;
}
}
tmp_len = len-1-start_index+1;
if(tmp_len >max_len){
max_len = tmp_len;
max_start_index = start_index;
}

for(int i=0;i<max_len;i++){
System.out.print(array[i+max_start_index]+" ");
}

return max_len;
}

}