方法一 转化为lcs最长公共字串
方法二 动态规划
方法三 数组+二分查找
方法一
对单调递增的子序列X排序得到子序列Y,然后求子序列X与子序列Y的最长公共字串
方法二 动态规划
1. 先准备一个数组b b[i]=1
2. b[i]=max(b[i],b[j]+1); arr[j]<arr[i]
扫描二维码关注公众号，回复：
5410447 查看本文章
动态规划时间复杂度O(N^2)
/**
* 最长公共子序列 时间复杂度O(n^2)
* @param arr
* @return
*/
public static int longestIncreasingSubsequence(int[] arr){
int len=arr.length;
int[] brr=new int[len];
for (int i=0; i<len; i++){
brr[i] = 1;
}
for (int j=1; j<len; j++) {
for (int i=0; i<j; i++) {
if (arr[j]>arr[i] && brr[j]<brr[i]+1){ //注意longest[j]<longest[i]+1这个条件，不能省略。
brr[j] = brr[i] + 1; //计算以arr[j]结尾的序列的最长递增子序列长度
}
}
}
System.out.println(Arrays.toString(brr));
int maxNum = getMaxNum(brr);
return maxNum;
}
public static int getMaxNum(int[] arr){
int max=arr[0];
for (int i=1;i<arr.length;i++) {
if(arr[i]>max){
max=arr[i];
}
}
return max;
}
public static void main(String[] args) {
int[] arr={5,6,7,1,2,8};
int i = longestIncreasingSubsequence(arr);
System.out.println(i);
}方法三
数组+二分查找的核心思想: 数组记录中间元素,二分查找每次查找比当前大的第一个元素,并替换.
动态规划 时间复杂度O(nlogn)
代码
public static int LIS(int[] array) {
int n=array.length;
int[] B=new int[n];
int len = 1;
B[0] = array[0];
int i;
int pos = 0;
for(i=1; i<n; ++i)
{
if(array[i] > B[len-1]) //如果大于B中最大的元素，则直接插入到B数组末尾
{
B[len] = array[i];
++len;
} else {
pos = BiSearch(B, len, array[i]); //二分查找需要插入的位置
B[pos] = array[i];
}
}
return len;
}
//修改的二分查找算法，返回数组元素需要插入的位置。
public static int BiSearch(int[] b, int len, int w)
{
int left = 0, right = len - 1;
int mid;
while (left <= right)
{
mid = left + (right-left)/2;
if (b[mid] > w)
right = mid - 1;
else if (b[mid] < w)
left = mid + 1;
else //找到了该元素，则直接返回
return mid;
}
return left;//数组b中不存在该元素，则返回该元素应该插入的位置
}
public static void main(String[] args) {
int[] array = {2, 1, 6, 3, 5, 4, 8, 7, 9};
int lis = LIS(array);
System.out.println(lis);
}参考文献
https://www.cnblogs.com/coffy/p/5878915.html
https://www.cnblogs.com/wxjor/p/5524447.html
时间复杂度O(nlogn)