LeetCode496. 下一个更大元素 I

2021-10-27 12:34:59 阅读：138 来源： 互联网

标签：nums 复杂度元素 len LeetCode496 数组更大 nums1 dp

description

给你两个没有重复元素的数组 nums1 和 nums2 ，其中nums1 是 nums2 的子集。

请你找出 nums1 中每个元素在 nums2 中的下一个比其大的值。

nums1 中数字 x 的下一个更大元素是指 x 在 nums2 中对应位置的右边的第一个比 x 大的元素。如果不存在，对应位置输出 -1 。

示例 1：

输入: nums1 = [4,1,2], nums2 = [1,3,4,2].
输出: [-1,3,-1]
解释:
对于 num1 中的数字 4 ，你无法在第二个数组中找到下一个更大的数字，因此输出 -1 。
对于 num1 中的数字 1 ，第二个数组中数字1右边的下一个较大数字是 3 。
对于 num1 中的数字 2 ，第二个数组中没有下一个更大的数字，因此输出 -1 。

示例2：

输入: nums1 = [2,4], nums2 = [1,2,3,4].
输出: [3,-1]
解释:
对于 num1 中的数字 2 ，第二个数组中的下一个较大数字是 3 。
对于 num1 中的数字 4 ，第二个数组中没有下一个更大的数字，因此输出 -1 。

提示：
1 <= nums1.length <= nums2.length <= 1000
0 <= nums1[i], nums2[i] <= 104
nums1和nums2中所有整数互不相同
nums1 中的所有整数同样出现在 nums2 中

分析

这道题刚看到时没有仔细读题，浪费了一定的时间。本题的题意其实很简单，对nums1中的每个元素，在nums2中找到相同的元素，并找到其右面第一个比它大的元素，如果不存在则输出-1。理解题意后，这应该是一道模拟就可以实现的题。

解法1：暴力模拟

代码实现

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n = nums.size();
        if(n == 0) return 0;
        vector<int> dp(n, 0);
        for(int i = 0; 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);
                }
            }
        }
        return *max_element(dp.begin(), dp.end());
    }
};

复杂度：

时间复杂度：O(n²)，n 为数组 nums 的长度。对nums[i]进行遍历用时O(n²)；对每个nums[i]求解dp[i] 时，需要 O(n) 的时间遍历 dp[0…i−1] 的所有情况，所以总时间复杂度为 O(n²)
空间复杂度：O(n)，使用长度为n的dp数组。

解法2：贪心+二分查找

这个解法是看题解看到的另外一种目前看最优解法，复杂度更低（O(nlogn)）。
考虑一个简单的贪心，如果我们要使上升子序列尽可能的长，则我们需要让序列上升得尽可能慢，因此我们希望每次在上升子序列最后加上的那个数尽可能的小。
基于上面的贪心思路，我们维护一个数组 d ，d[i]表示长度为 i 的最长上升子序列的末尾元素的最小值，用 len 记录目前最长上升子序列的长度，起始时 len 为 1，d[1]=nums[0]。
我们依次遍历数组 nums 中的每个元素，并更新数组 d 和 len 的值。如果 nums[i] > d[len] 则更新 len=len+1，否则在d[1…len]中找满足 d[i−1] < nums[j] < d[i] 的下标 i，并更新d[i]=nums[j]。

此处：因为 d 数组是严格单调递增的，所以我们可以使用二分查找寻找下标 i，优化时间复杂度。

整个算法流程：

设当前已求出的最长上升子序列的长度为 len（初始为 1），从前往后遍历数组 nums，在遍历到 nums[i] 时：

如果 nums[i] > d[len] ，则直接加入到 dd 数组末尾，并更新 len=len+1；

否则，在 d 数组中二分查找，找到第一个比 nums[i] 小的数 d[k] ，并更新 d[k+1]=nums[i]。

例：

以输入序列 [0, 8, 4, 12, 2] 为例：
第一步插入 0，d = [0]；
第二步插入 8，d = [0, 8]；
第三步插入 4，d = [0, 4]；
第四步插入 12，d = [0, 4, 12]；
第五步插入 2，d = [0, 2, 12]。

代码实现

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int len = 1, n = nums.size();
        if(n == 0) return 0;
        vector<int> d(n + 1, 0);
        d[len] = nums[0];
        for(int i = 1; i < n; i++){
            if(nums[i] > d[len]) 
                d[++len] = nums[i];
            else{
                int l = 1, r = len, pos = 0;
                while(l <= r){
                    int mid = l + (r - l)/2;
                    if(d[mid] < nums[i]){ 
                        pos = mid;
                        l = mid + 1;
                    }
                    else {
                        r = mid - 1;
                    }
                }
                d[pos + 1] = nums[i];
            }
        }
        return len;
    }
};

注意：此处二分查找思路、要求、写法较为特殊，要反复、仔细将其研究明白。

复杂度

时间复杂度：O(nlogn) ，数组 nums 的长度为 n，我们依次用数组中的元素去更新 d 数组，而更新 d 数组时需要进行 O(logn) 的二分搜索，所以总时间复杂度为 O(nlogn)。
空间复杂度：O(n)，需要使用辅助数组 d 数组（长度为n）。

标签：nums,复杂度,元素,len,LeetCode496,数组,更大,nums1,dp
来源： https://blog.csdn.net/qq_40718681/article/details/120981517

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

LeetCode496. 下一个更大元素 I

description

分析

解法1：暴力模拟

代码实现

复杂度：

解法2：贪心+二分查找

代码实现

复杂度