LeetCode496. 下一个更大元素 I

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