最长公共子序列与最长递增子序列

最长公共子序列（注意区别子串与子序列）

1、序列str1和序列str2
·长度分别为m和n；
·创建1个二维数组L[m.n]；
  ·初始化L数组内容为0
  ·m和n分别从0开始，m++，n++循环：
     - 如果str1[m] == str2[n]，则L[m,n] = L[m - 1, n -1] + 1；
     - 如果str1[m] != str2[n]，则L[m,n] = max{L[m,n - 1]，L[m - 1, n]}
  ·最后从L[m,n]中的数字一定是最大的，且这个数字就是最长公共子序列的长度
  ·从数组L中找出一个最长的公共子序列

 //最长公共子序列
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String s1 = sc.nextLine();
		String s2 = sc.nextLine();
		int len1 = s1.length();
		int len2 = s2.length();
		int max = 0;
		int dp[][] = new int[len1 + 1][len2 + 1];
		// LCS问题,逆向思维求解
		for (int i = len1 - 1; i >= 0; i--) {
			for (int j = len2 - 1; j >= 0; j--) {
				if (s1.charAt(i) == s2.charAt(j))
					dp[i][j] = dp[i + 1][j + 1] + 1;
				else
					dp[i][j] = Math.max(dp[i][j + 1], dp[i + 1][j]);
			}
		}
		System.out.println(dp[0][0]);
	}

最长递增子序列

给定一个长度为N的数组，找出一个最长的单调自增子序列（不一定连续，但是顺序不能乱）
	例如：给定一个长度为8的数组A{1,3,5,2,4,6,7,8}，则其最长的单调递增子序列为{1,2,4,6,7,8}，长度为6.
	输入描述:
	第一行包含一个整数T，代表测试数据组数。
	对于每组测试数据：
	N-数组的长度
	a1 a2 ... an （需要计算的数组）
	保证：
	1<=N<=3000,0<=ai<=MAX_INT.
	输出描述:
	对于每组数据，输出一个整数，代表最长递增子序列的长度。
	输入例子:
	2
	7
	89 256 78 1 46 78 8
	5
	6 4 8 2 17
	输出例子:
	3
	3

设L=<a1,a2,…,an>是n个不同的实数的序列，L的递增子序列是这样一个子序列Lin=<aK1,ak2,…,akm>，其中k1<k2<…<km且aK1<ak2<…<akm。求最大的m值。
二，    第一种算法：转化为LCS问题求解
设序列X=<b1,b2,…,bn>是对序列L=<a1,a2,…,an>按递增排好序的序列。那么显然X与L的最长公共子序列即为L的最长递增子序列。这样就把求最长递增子序列的问题转化为求最长公共子序列问题LCS了。
最长公共子序列问题用动态规划的算法可解。设Li=< a1,a2,…,ai>,Xj=< b1,b2,…,bj>，它们分别为L和X的子序列。令C[i,j]为Li与Xj的最长公共子序列的长度。则有如下的递推方程：
这可以用时间复杂度为O(n2)的算法求解。求最长递增子序列的算法时间复杂度由排序所用的O(nlogn)的时间加上求LCS的O(n2)的时间，算法的最坏时间复杂度为O(nlogn)＋O(n2)＝O(n2)。
三，  第二种算法：动态规划法

设f(i)表示L中以ai为末元素的最长递增子序列的长度。则有如下的递推方程：LIS[i+1]=max{1,LIS[j]+1},  a[i+1]>a[j],  for any j <= i 。。这个递推方程的意思是，在求以ai为末元素的最长递增子序列时，找到所有序号在L前面且小于ai的元素aj，即j<i且aj<ai。如果这样的元素存在，那么对所有aj,都有一个以aj为末元素的最长递增子序列的长度f(j)，把其中最大的LIS(j)选出来，那么LIS(i)就等于最大的LIS(j)加上1，即以ai为末元素的最长递增子序列，等于以使LIS(j)最大的那个aj为末元素的递增子序列最末再加上ai；如果这样的元素不存在，那么ai自身构成一个长度为1的以ai为末元素的递增子序列。

public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		for (int i = 0; i < n; i++) {
			int m = sc.nextInt();
			int arr[] = new int[m];
			for (int j = 0; j < m; j++)
				arr[j] = sc.nextInt();
			int dp[] = new int[m];
			Arrays.fill(dp, 1);
			int max = 0;
			for (int k = 0; k < m; k++) {
				for (int l = 0; l < k; l++)
					if (arr[k] > arr[l] && dp[l] + 1 > dp[k]) {
						dp[k] = dp[l] + 1;
						max = Math.max(max, dp[k]);
					}
			}
			System.out.println(max);
		}
	}

最长递增子序列输出第一个序列

给定一个长度为N的数组，找出一个最长的单调自增子序列（不一定连续，但是顺序不能乱）
    例如：给定一个长度为8的数组A{1,3,5,2,4,6,7,8}，则其最长的单调递增子序列为{1,2,4,6,7,8}，长度为6.
    输入描述:
    第一行包含一个整数T，代表测试数据组数。
    对于每组测试数据：
    N-数组的长度
    a1 a2 ... an （需要计算的数组）
    保证：
    1<=N<=3000,0<=ai<=MAX_INT.
    输出描述:
    对于每组数据，输出一个整数序列，代表最长递增子序列。
    若有多组最长上升子序列，输出第一组。
    保证：1<=T<=20,1<=N<=3000,0<=ai<=MAX_INT.
    输入例子:
    2
    7
    89 256 78 1 46 78 8
    5
    6 4 8 2 17
    输出例子:
    1 46 78
    6 8 17

public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		for (int i = 0; i < n; i++) {
			int m = sc.nextInt();
			int arr[] = new int[m];
			for (int j = 0; j < m; j++)
				arr[j] = sc.nextInt();
			int dp[] = new int[m];
			Arrays.fill(dp, 1); 
			int max = 0;
			//总的结果集合
			ArrayList<ArrayList<Integer>> ret=new ArrayList<>();
			for (int k = 0; k < m; k++) {
				//存储中间结果
				ArrayList<Integer> temp=new ArrayList<>();
				for (int l = 0; l < k; l++)
					if (arr[k] > arr[l] && dp[l] + 1 > dp[k]) {
						dp[k] = dp[l] + 1;
						temp.add(arr[l]);
						max = Math.max(max, dp[k]);
					}
				temp.add(arr[k]);
				ret.add(temp);
			}
			//System.out.println(max);
			//找到第一个size为max 的集合。
			int ii=0;
			for(;ii<ret.size();ii++){
				if(ret.get(ii).size()==max)
					break;
			}
			//格式控制输出
			ArrayList<Integer> list=ret.get(ii);
			StringBuffer sb=new StringBuffer();
			for(int k=0;k<list.size()-1;k++)
				sb.append(list.get(k)+" ");
			sb.append(list.get(list.size()-1));
			System.out.println(sb);
		}
	}

最长公共子串的第一个序列

import java.util.Arrays;
import java.util.Scanner;
public class LIS {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String s1 = sc.next().toLowerCase();
		String s2 = sc.next().toLowerCase();
		System.out.println("result=" + lis(s1, s2));
	}

	public static String lis(String s1, String s2) {
		int n1 = s1.length();
		int n2 = s2.length();
		String max = "";
		String dp[][] = new String[n1 + 1][n2 + 1];
		//为了避免输出null
		for (int i = 0; i <= n1; i++)
			Arrays.fill(dp[i], "");
		for (int i = n1 - 1; i >= 0; i--) {
			for (int j = n2 - 1; j >= 0; j--) {
				if (s1.charAt(i) == s2.charAt(j) && 
						(dp[i + 1][j + 1]).length()+1 >= max.length()) {
					dp[i][j] = s1.charAt(i) + dp[i + 1][j + 1];
					max = dp[i][j];
				} else
					dp[i][j] = "";
			}
		}
		return max;
	}
}