题目描述
Given an unsorted array of integers, find the length of longest increasing subsequence.
Example:
Input: [10,9,2,5,3,7,101,18]
Output: 4
Explanation: The longest increasing subsequence is [2,3,7,101], therefore the length is 4.
要求:严格单调递增,只有这种情况才进行增加元素的情况
子序列:可以不连续,结果序列中两个元素中间可以有空格
视频讲解
解题思路
解法1.一维动态规划,两次循环,逐步记录最大值
- dp[i] = max{ dp[j] +1 } if ( n[j] < n[i]) )
- dp[i] = 1, if all n[j]>=n[i], 表示i 之前的元素均大于或者等于 i,增长序列为n[i] 单独一个元素作为一个增长序列。
- dp[i]表示以下表i为尾的最长的递增序列,还需要一个max记录所有的dp[i]中的最大值,处理完第i个数字后,如果 dp[i]>max, 则需要更新最大值,否则max还是保持原来的最大值。
代码(Java版本)
import java.util.Arrays;
public class LongestIncreasingSubsequence {
public int solution(int [] nums)
{
int n = nums.length;
if(n==0) return 0;
if(n==1) return 1;
int max = 1;
int [] dp =new int[n];
Arrays.fill(dp,1);
dp[0] =1;
for(int i=1;i<n;++i){
for(int j=i-1;j>=0;--j)
{
if(nums[j]<nums[i])
{
//因为要求一个增长序列,u=
// 状态转移方程dp[i]在前面选择一个num[j]<nums[i],总多条件中选择一个·满足题意的max 的j,然后加i
dp[i] = Math.max(dp[j]+1,dp[i]);
}
//如果一个元素找不到一个比他任何一个比他小的元素,那么以这个元素为nums[i] 为尾巴的增长序列只能为1,自己本身
}
max = Math.max(max,dp[i]);
}
return max;
}
public static void main(String[] args) {
LongestIncreasingSubsequence test = new LongestIncreasingSubsequence();
int [] array = {10,9,2,5,3,7,101,18};
System.out.println(test.solution(array));
}
}
性能分析
时间复杂度为o(n^2),两次循环,外部循环为顺序处理每一个元素,第二次循环为逆序前向查找满足题意的曾长序列;空间复杂度为o(n),一个状态方程记录数组。
解法二:二分查找
思路
设置一个数组dp[],用于二分查找,逐步遍历原数组n[i],对于每一个遍历到的原数组元素,我们采用二分查找方法查找他在dp有序数组中的位置,在dp数组中采用二分查找一个不小于n[i]的数,如果这个数字不存在,那么直接在dp数组后面加上遍历到的数字,如果存在,则将这个数字更新为当前遍历到的数字,最后返回
代码
int[] dp = new int[n.length];
int size = 0;
for (int x : n) {
int i = 0, j = size;
while (i != j) {
int m = (i + j) / 2;
if (dp[m] < x)
i = m + 1;
else
j = m;
}
dp[i] = x;
if (i == size) ++size;
}
return size;
}
代码解析:刚开始dp数组为空,size为数组dp的长度,将x加入到dp数组中,
性能分析
每一个元素均需要进行一个二分查找,二分查找每一趟是Olog(n),共有n次,所以总的时间复杂度为o(nlog(n)),空间复杂度为o(n)
二分查找的分析理解
B [size]数组当中的元素长度优势有序的情况
可以利用O(N),记录当前最长的数组序列即可,B[size],记录处理到A[i]处元素的最长递增序列, 如果A[i]>B[size] 说明可以直接添加即可 B[size] = A[i]是该种情况, 如果A[i]<B[size], 我们就要在B[size] 数组当中查找一个位置直接将A[i] 插入该节点,进行一个替
B[j] 记录到底代表什么意思呢,我们可以这样理解, 主要是用来记录, 序列长度最长为j的最末尾元素为B[j]
代码
class Solution {
public int lengthOfLIS(int[] A) {
if(A==null||A.length==0)
return 0;
int length = A.length;
int[] B = new int[length];
B[0] = A[0];
int end = 0;
for (int i = 1; i < length; ++i) {
// 如果当前数比B中最后一个数还大,直接添加
if (A[i] > B[end]) { B[++end] = A[i]; continue;
}
// 否则,需要先找到替换位置
int pos = findInsertPos(B, A[i], 0, end);
B[pos] = A[i];
}
/
return end+ 1;
}
private int findInsertPos(int[] B, int n, int start, int end) {
while (start < end) {
int mid = start + (end - start) / 2;// 直接使用(high + low) / 2 可能导致溢出
if (B[mid] < n) {
start = mid + 1;
} else if (B[mid] > n) {
end = mid ;
} else {
return mid;
}
}
return start;
}
}