Given an unsorted array of integers, find the length of longest increasing subsequence.
For example,
Given [10, 9, 2, 5, 3, 7, 101, 18]
,
The longest increasing subsequence is [2, 3, 7, 101]
, therefore the length is 4
. Note that there may be more than one LIS combination, it is only necessary for you to return the length.
Your algorithm should run in O(n2) complexity.
Follow up: Could you improve it to O(n log n) time complexity?
java
class Solution {
public int lengthOfLIS(int[] nums) {
if (nums == null || nums.length == 0) {
return 0;
}
if (nums.length == 1) {
return 1;
}
// state
int[] f = new int[nums.length];
// initialize
for (int i = 0; i < f.length; i++) {
f[i] = Integer.MIN_VALUE;
}
f[0] = 0;
// function
for (int i = 1; i < nums.length; i++) {
for (int j = 0; j < i; j++) {
if (nums[i] > nums[j]) {
f[i] = Math.max(f[i], f[j] + 1);
}
}
if (f[i] == Integer.MIN_VALUE) {
f[i] = 0;
}
}
int sum = 0;
for (int i = 0; i < f.length; i++) {
sum = Math.max(f[i], sum);
}
return sum + 1;
}
}
python
class Solution:
"""
@param: nums: An integer array
@return: The length of LIS (longest increasing subsequence)
"""
def longestIncreasingSubsequence(self, nums):
# write your code here
if nums is None or len(nums) == 0:
return 0
if len(nums) == 1:
return 1
res = [-float('inf')] * len(nums)
res[0] = 0
for i in range(1, len(nums)):
for j in range(i):
if nums[i] > nums[j]:
res[i] = max(res[i], res[j] + 1)
if res[i] == -float('inf'):
res[i] = 0
return max(res) + 1