package algorithm.apps;
/**
* 最长单调递增子序列的求法 LIS
*
* @author Toy
*/
public class LIS {
/**
* 动态规划(n^2),记表备查 b[0,n-1]记录以a[i]结尾的最长递增子序列长度
*
* @param a
* @return
*/
public int lis_01(int[] a) {
int n = a.length;
if (n <= 0) {
return 0;
}
int max = 0;
int[] b = new int[n];
b[0] = 1;
for (int i = 1; i < n; i++) {
int ki = 0;
for (int j = 0; j < i; j++) {
if (a[i] >= a[j] && ki < b[j]) {
ki = b[j];
}
}
b[i] = ki + 1;
}
for (int i = 0; i < n; i++) {
if (b[i] > max) {
max = b[i];
}
}
return max;
}
/**
* 动态规划(n*log n),记表备查 k是序列a[0:i]的最长递增子序列的长度 b[k]是a[0:i]中所有长度为 k
* 的单调递增子序列中的最小结尾元素值 则可知b是单调递增的
*
* @param a
* @return
*/
public int lis_02(int[] a) {
int n = a.length;
if (n <= 0) {
return 0;
}
int[] b = new int[n];
b[1] = a[0];
int k = 1;
for (int i = 1; i < n; i++) {
if (a[i] >= b[k]) {
b[++k] = a[i];
} else {
b[binary(a, i, b, k)] = a[i];
}
}
return k;
}
/**
* 在数组b[0:k]中找到a[i]的存放位置,满足 b[j-1]<=a[i]<b[j];
*
* @param a
* @param i
* @param b
* @param k
* @return
*/
private int binary(int[] a, int i, int[] b, int k) {
if (a[i] < b[1]) {
return 1;
}
int m = 1;
int n = k;
while (m != n - 1) {
int mid = (m + n) / 2;
if (b[mid] <= a[i]) {
m = mid;
} else {
n = k;
}
}
return n;
}
/**
* 第一种思路在状态转移时的复杂度为o(n),即在找a[k]前面满足a[j]<a[k]的最大b[j]时采用的是顺序查找的方法,复杂度为o(n).
* 设想如果能把顺序查找改为折半查找,则状态转移时的复杂度为o(lg(n)),于是产生方法二的思想
*
* @param args
*/
public static void main(String[] args) {
int[] a = new int[] { 5, 2, 3, 1, 4, 6, 6, 7 };
LIS s = new LIS();
int max_01 = s.lis_01(a);
System.out.println("method 01: " + max_01);
int max_02 = s.lis_02(a);
System.out.println("method 02: " + max_02);
}
}
最长单调递增子序列的求法
最新推荐文章于 2020-12-27 13:53:39 发布