子序列

最长公共子序列(LCS)（lintcode 77）

描述：给出两个字符串，找到最长公共子序列(LCS)，返回LCS的长度。（不需要连续）
样例：
给出"ABCD" 和 "EDCA"，这个LCS是 "A" (或 D或C)，返回1
给出 "ABCD" 和 "EACB"，这个LCS是"AC"返回 2

public class Solution {
    /**
     * @param A: A string
     * @param B: A string
     * @return: The length of longest common subsequence of A and B
     */
    public int longestCommonSubsequence(String A, String B) {
        int dp[][] = new int[A.length()+1][B.length()+1];
        for(int i=0;i<=A.length();i++){
            dp[i][0] = 0;
        }
        for(int i=0;i<=B.length();i++){
            dp[0][i] =0;
        }
        for(int i=1;i<=A.length();i++){
            for(int j=1;j<=B.length();j++){
                //注意是下标是i-1，j-1
                if(A.charAt(i-1)==B.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]; 
                }
            }
        }
        return dp[A.length()][B.length()];
    }
}

最长公共子串

描述：给出两个字符串，找到最长公共子串，并返回其长度。子串要连续

public class Solution {
    /**
     * @param A: A string
     * @param B: A string
     * @return: the length of the longest common substring.
     */
    public int longestCommonSubstring(String A, String B) {
        // write your code here
        int dp[][] = new int[A.length()+1][B.length()+1];
        int max = 0;
        for(int i=0;i<=A.length();i++){
            dp[i][0] = 0;
        }
        for(int i=0;i<=B.length();i++){
            dp[0][i] =0;
        }
        for(int i=1;i<=A.length();i++){
            for(int j=1;j<=B.length();j++){
                //注意是下标是i-1，j-1
                if(A.charAt(i-1)==B.charAt(j-1)){
                    int a = dp[i][j] = dp[i-1][j-1]+1;
                    if(max<a) max = a;
                }else{
                    dp[i][j] = 0; //不同之处
                }
            }
        }
        return max;
    }
}

最长上升连续子序列(lintcode 397)

给定一个整数数组（下标从 0 到 n-1， n 表示整个数组的规模），请找出该数组中的最长上升连续子序列。（最长上升连续子序列可以定义为从右到左或从左到右的序列。）
样例
给定 [5, 4, 2, 1, 3], 其最长上升连续子序列（LICS）为 [5, 4, 2, 1], 返回 4.
给定 [5, 1, 2, 3, 4], 其最长上升连续子序列（LICS）为 [1, 2, 3, 4], 返回 4.

public class Solution {
    /**
     * @param A: An array of Integer
     * @return: an integer
     */
    public int longestIncreasingContinuousSubsequence(int[] a) {
        if(a.length==0) return 0;
        int max = Integer.MIN_VALUE;
        int last=a[0];
        int c1=1;
        int c2=1;
        for(int i=0;i<a.length;i++){
            if(a[i]>last){
                c1++;
            }else{
                c1=1;
            }
            if(a[i]<last){
                c2++;
            }else{
                c2=1;
            }
            last=a[i];
            if(c1>max) max = c1;
            if(c2>max) max = c2;
        }
        return max;
    }
}

最长上升子序列（lintcode 76）

描述：给定一个整数序列，找到最长上升子序列（LIS），返回LIS的长度。不连续。
o(n2)

public class Solution {
    /**
     * @param nums: An integer array
     * @return: The length of LIS (longest increasing subsequence)
     */
    public int longestIncreasingSubsequence(int[] nums) {
        if(nums.length==0) return 0;
        int s[] = new int[nums.length];
        int max = Integer.MIN_VALUE;
        for(int i=0;i<nums.length;i++){
            s[i] = 1;
            for(int j=i-1;j>=0;j--){
                //从前一个位置一直遍历到头，不能遍历一半
                if(nums[i]>nums[j]&&(s[j]+1)>s[i]){
                    s[i] = s[j]+1;
                }
            }
            if(s[i]>max) max = s[i];
        }
        return max;
    }
}