leetcode 300. Longest Increasing Subsequence

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. 

Note:

• 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?

分析：求解数组最长递增子序列（严格递增）.

思路一：暴力求解。递归。

最简单的方法是找出所有的递增子序列，然后返回最长递增子序列的长度。为此，我们使用递归函数lengthOfLIS返回当前元素(对应于curpos)以后可能出现的LIS长度(包括当前元素)。在每个函数调用中，我们考虑两种情况:

1) 当前元素比LIS中包含的前一个元素大。在这种情况下，我们可以在LIS中包含当前元素。因此，我们通过包含它来求出LIS的长度。此外，我们还通过在LIS中不包含当前元素来确定LIS的长度。因此，当前函数调用返回的值是两个长度中的最大值。

2) 当前元素小于LIS中包含的前一个元素。在这种情况下，我们不能在LIS中包含当前元素。因此，我们仅通过在LIS中不包含当前元素来确定LIS的长度。

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int len = nums.size();
        return lengthOfLIS(nums, INT_MIN, 0, len);
    }
private:
    int lengthOfLIS(vector<int> nums, int prev, int curpos, int len) {
        if (curpos == len) {
            return 0;
        }
        int taken = 0;
        if (nums[curpos] > prev) {
            taken = 1 + lengthOfLIS(nums, nums[curpos], curpos + 1, len);
        }
        int notaken = lengthOfLIS(nums, prev, curpos + 1, len);
        return max(taken, notaken);
    }
};

时间复杂度O(2ⁿ)

思路二：记忆化的递归

在前一种方法中，许多递归调用必须一次又一次地使用相同的参数。通过将特定调用的结果存储在二维记忆数组memo中，可以消除这种冗余。memo[i][j]表示可以使用nums[i]作为LIS中包含/不包含的前一个元素，而nums[j]作为LIS中包含/不包含的当前元素，来表示LIS的长度。这里，nums表示给定的数组。

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        
        int len = nums.size();
        vector<vector<int> > memo(len + 1, vector<int>(len, -1));
        //memset(memo, -1, sizeof(memo));
        return lengthOfLIS(nums, -1, 0, len, memo);
    }
private:
    int lengthOfLIS(vector<int> nums, int previndex, int curpos, int len, vector<vector<int> > &memo) {
        if (curpos == len) {
            return 0;
        }
        if (memo[previndex + 1][curpos] >= 0) {
            return memo[previndex + 1][curpos];
        }
        int taken = 0;
        if (previndex < 0 || nums[curpos] > nums[previndex]) {
            taken = 1 + lengthOfLIS(nums, curpos, curpos + 1, len, memo);
        }
        int notaken = lengthOfLIS(nums, previndex, curpos + 1, len, memo);
        memo[previndex + 1][curpos] = max(taken, notaken);
        return memo[previndex + 1][curpos];
    }
}; 

时间复杂度O(n²), 空间复杂度 O(n²)

思路三：动态规划，dp[i]表示以下标为i的数字为结尾的最长递增子序列长度。

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int len = nums.size();
        vector<int> dp(len, 0);
        int maxn = 0;
        for (int i = 0; i < len; i++) {
            dp[i] = 1;
            for (int j = 0; j < i; j++) {
                if (nums[i] > nums[j])
                    dp[i] = max(dp[i], dp[j] + 1);
            }
            maxn = max(maxn, dp[i]);
        }
        return maxn;
    }
};

时间复杂度：O(n²), 空间复杂度O(n)

思路四：动规+二分

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int len = nums.size();
        if (len == 0)
            return 0;
        int *dp = new int[len];
        int length = 0;
        for (int i = 0; i < len; i++) {
            int ind = BinarySearch(dp, 0, length, nums[i]);
            dp[ind] = nums[i];
            if (ind == length)
                length++;
        }
        return length;
    }
private:
    //返回数组中第一个大于target的数的下标
    int BinarySearch(int *p, int left, int right, int target) {
        while (left < right) {
            int mid =  ((right - left) >> 1) + left;
            if (p[mid] < target)
                left = mid + 1;
            else
                right = mid;
        }
        return right;
    }
};