【暴力】LeetCode 300. Longest Increasing Subsequence

最新推荐文章于 2024-04-05 19:53:39 发布

原创最新推荐文章于 2024-04-05 19:53:39 发布 · 305 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#LeetCode 300. Longest Increasi

LeetCode练习题专栏收录该内容

168 篇文章

订阅专栏

本文介绍了解决LeetCode 300题——最长递增子序列问题的两种方法。第一种是时间复杂度为O(n^2)的暴力搜索算法；第二种则是更高效的O(nlogn)算法。通过实例代码详细解释了两种算法的具体实现。

LeetCode 300. Longest Increasing Subsequence

Solution1：我的答案
暴力搜索，时间复杂度 $O(n^2)$

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n = nums.size(), res = 1;
        if (!n) return 0;
        if (n == 1) return 1;
        //注意：这种对数组初始化的方式只会初始化第一个为1
        int dp[n] = {1};
        for (int i = 1; i < n; i++) {
            dp[i] = 1;
            for (int j = 0; j < i; j++) {
                if (nums[i] > nums[j]) {
                    dp[i] = max(dp[i], dp[j] + 1);
                } 
            }
            res = max(dp[i], res);
        }
        return res;
    }
};

Solution2：
时间复杂度 $O(nlogn)$
参考链接：[1]http://www.cnblogs.com/grandyang/p/4938187.html
[2]https://leetcode.com/problems/longest-increasing-subsequence/discuss/148060/Easy-To-Understand-Python-Code-With-Clear-Explanation-O(nlogn)
一个有点奇妙的算法~

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        vector<int> dp;
        for (int i = 0; i < nums.size(); ++i) {
            int left = 0, right = dp.size();
            while (left < right) {
                int mid = left + (right - left) / 2;
                if (dp[mid] < nums[i]) left = mid + 1;
                else right = mid;
            }
            if (right >= dp.size()) dp.push_back(nums[i]);
            else dp[right] = nums[i];
        }
        return dp.size();
    }
};