Given an integer array nums, return the length of the longest strictly
increasing subsequence.A subsequence is a sequence that can be derived from an array by
deleting some or no elements without changing the order of the
remaining elements. For example, [3,6,2,7] is a subsequence of the
array [0,3,1,6,2,2,7].
Example 1:
Input: nums = [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.
Example 2:
Input: nums = [0,1,0,3,2,3]
Output: 4
Example 3:
Input: nums = [7,7,7,7,7,7,7]
Output: 1
Constraints:
1 <= nums.length <= 2500
-104 <= nums[i] <= 104
求数组中递增子数组的最大长度, 可以用DP来储存当前位置的递增最大子数组。 比如[10,9,2,5,3,7,101,18],首先在10位置的最大子数组长度为1, 9位置也为1, 2位置也是1, 5位置是2,因为【2,5】是一个长度为2的递增子数组(父数组是【10,9,2,5】)。
public int lengthOfLIS(int[] nums) {
if (nums.length == 0) return 0;
int[] dp = new int[nums.length];
dp[0] = 1;
int maxLen = 1;
// 遍历数组, 找到截止每个数的最长递增子数列长度
for (int i = 1; i < dp.length; i++) {
int currMax = 0;
for (int j = 0; j < i; j++) {
// 做一个剪枝, 只有在前面的数比当前数小的时候,才求dp长度
if (nums[j] < nums[i]) {
// 会有好几个比nums[i] 小的数,因此求出其中的最大值,实际上是一个递归的公式
currMax = Math.max(currMax, dp[j]);
}
dp[i] = currMax + 1;
maxLen = Math.max(dp[i], maxLen);
}
}
return maxLen;
}
时间复杂度O(N^2)
- Smarter way (BinarySearch)
参考
tails储存每个可能的长度的数组,tails[0]存储长度为1的所有数组的尾部的最小值,依次递增……比如说示例数组 [10,9,2,5,3,7,101,18], tails[0] 是所有长度为1 的数组, 尾部取最小,tais[0] = 2; tails[1] 是所有长度为2的数组的尾部,有[2,5], [5,7], [2,7], [3, 7], [10, 101], [10, 18], [9, 101], [9, 18], [2,101]…tails[1] = 5
这样取最小尾部的目的是为了比较当前遍历的数与其大小,如果当前遍历的数比某个长度的尾部大的时候,直接长度+1就可以; 又如果当前遍历的数在两个相邻tails之间,那么就更新当前的tails使得tails永远储存的都是最小尾部(比如tails【0】 = 9的时候,我们遍历到了2, 那么就要更新tails【0】 = 2)
public int lengthOfLIS(int[] nums) {
int[] tails = new int[nums.length];
int size = 0;
for (int x : nums) {
int i = 0, j = size;
while (i != j) {
int mid = (i + j) / 2;
if (tails[mid] < x)
i = mid + 1;
else
j = mid;
}
tails[i] = x;
if (i == size) {
size++;
}
}
return size;
}
下面的ppt可以更好地理解二分法
Princeton的patience sorting PPT
princeton是真的厉害,二分法的晦涩难懂瞬间恍然大悟。
算法:
大家都玩过蜘蛛纸牌, 现在把这一个数组看成一叠纸牌,我们需要找到若干个堆, 每个堆要保持降序比如数组 [10,9,2,5,3,7,101,18], 首先第一个堆是10,9,2, 第二个堆是5,3,依次下去。 在保持最小堆得总量的情况下,递增数列的最大长度就是堆得数量。
(Prof: 保持最小数量的堆,就是每次在堆得降序排列中,遍历到比当前头部数小的数中最小的数,比如10是头部的时候,要遍历到2, 如果只遍历到9, 那么2就会单独成一个堆,那么堆得size就不是最小的,不方便找到最长递增子数列。因为我们要跳过单独2的堆来查看)
patience sorting的时间复杂度可以控制在O(NlogN)
class Solution {
public int lengthOfLIS(int[] nums) {
List<Integer> piles = new ArrayList<>(nums.length);
for (int num : nums) {
int index = Collections.binarySearch(piles, num);
if (index < 0) index = ~index;
if (index == piles.size()) {
piles.add(num);
} else {
piles.set(index, num);
}
}
return piles.size();
}
}