最长公共子序列(注意区别子串与子序列)
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;
}
}