关于字符串的一些操作

1.求一个数组的最长递增非连续子序列的长度

分析：当我们拿到一个题首先就要思考这道题考察的是什么？本题中，要求求的是非连续的子序列，说明什么呢？说明要回溯，既然要回溯我们就可以利用双重循环。同时要求的是最长子序列，所以要用到动态规划

思路：我们利用dp[i]来保存每个位置当前所对应的最大长度，每次比较0~i之间的所有值同dp[i]的大小，如果比dp[i]大，则重新赋值，最后刷新最大长度的值。

import java.util.Scanner;
public class Test{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        String str1=sc.next();
        int length1=str1.length();
        int[] next=new int[length1+1];
        int[] dp=new int[length1+1];
        for(int i=0;i<length1;i++) {
        	next[i]=str1.charAt(i);
        }
        for(int i=0;i<length1;i++) {
        	dp[i]=1;
        	//遍历前面所有位置，获取最大子序列长度
        	for(int j=0;j<i;j++) {
        		if(next[i]>next[j]) {
            		dp[i]=dp[j]+1>dp[i]?dp[j]+1:dp[i];
            	}
        	}
        }
        System.out.println(dp[length1-1]);
    }   
}

2.求一个数组的最长递增连续子序列

分析：前面不同的是，本题求的是连续的子序列，已经还要求把子序列打印出来。所以我们要找到每个递增序列的起始点，然后再利用所求的最大长度即可打印出最长子序列

思路：利用max来记录每个位置最大子序列长度。用一个index作为最大递增序列的起始点。用nowIndex来表示每个递增序列的起始点。每次移动时，如果下一个位置比当前位置大，则count++;然后判断是否刷新max的值。否则重置count的值，然后刷新nowIndex.

package day01;
import java.util.Scanner;

public class Test{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        String str1=sc.next();
        int length1=str1.length();
        int[] next=new int[length1+1];
        int max=0,count=0,index=0,nowIndex=0;
        for(int i=0;i<length1;i++) {
        	next[i]=str1.charAt(i);
        }
        for(int i=0;i<length1-1;i++) {
           //判断当前和后面两个大小
        	if(next[i+1]>next[i]) {
        		count++;
               //刷新max和最大递增序列的起始点
        		if(count>max) {
        			max=count;index=nowIndex;
        		}
        	}else{
                //重置count和递增序列起始点
        		count=0;
        		nowIndex=i+1;
        	}
        }
        String str=str1.substring(index, index+max+1);
        System.out.println(str);
    }   
}

3.求两个字符串的最长非连续公共子序列的长度

分析：这道题和前面第一道很类似，都是求最长非连续子序列。所以都会用到dp，但是这里是求两个字符串的公共序列，所以肯定会遍历两个字符串。每次遍历都要从头开始遍历，这点同第一题

思路：利用dp[i][j]表示当前位置所对应的最大长度，首先比较第一个str1[i]和str2[j]的大小，两者相等，则dp[i][j]=dp[i-1][j-1]+1，否则需要比较dp[i][j-1]和dp[i-1][j],取其中的较大者，这么做的目的就是让dp[i][j]始终表示是最大长度！

import java.util.Scanner;
public class Test{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        String str1=sc.next();
        String str2=sc.next();
        int length1=str1.length();
        int length2=str2.length();
        int[][] dp=new int[length1+1][length2+1]; 
        for(int i=1;i<=length1;i++) {
        	for(int j=1;j<=length2;j++) {
        		if(str1.charAt(i-1)==str2.charAt(j-1)) {
        			dp[i][j]=dp[i-1][j-1]+1;
        		}else dp[i][j]=(dp[i-1][j]>dp[i][j-1])?dp[i-1][j]:dp[i][j-1];
        	}
        }
        System.out.println(dp[length1][length2]);
    }   
}

4.求两个字符串的最长连续公共子序列

分析，这道题类似第二题。同样的道理，需要找到递增起始点，然后配合最大长度即可找到最大子序列。

思路：用dp[i][j]表示当前长度，max表示最大长度，index表示递增起始点，每次刷新max的值的同时刷新index，保证index指向的位置对应最大子序列的位置。

import java.util.Scanner;
public class Test{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        String str1=sc.next();
        String str2=sc.next();
        int length1=str1.length();
        int length2=str2.length();
        int[][] dp=new int[length1+1][length2+1]; 
        int max=0,index=0;
    	for(int i=0;i<length1;i++) {
    		for(int j=0;j<length2;j++) {
    			if(str1.charAt(i)==str2.charAt(j)) {
    				//初始化dp数组
    				if(i==0 || j==0) dp[i][j]=1;
    				else dp[i][j]=dp[i-1][j-1]+1;
    				//更新max值和index
    				if(max<dp[i][j]) {
    					max=dp[i][j];
    					index=i;
    				}
    			}
    		}
    	}
    	String str=str1.substring(index-max+1,index+1);
    	System.out.println(str);
    }   
}