下一个大数的问题

最新推荐文章于 2021-04-12 13:15:43 发布

原创最新推荐文章于 2021-04-12 13:15:43 发布 · 520 阅读

0 ·

CC 4.0 BY-SA版权

leetcode刷题记录专栏收录该内容

19 篇文章

订阅专栏

问题来源:

点击打开链接

问题描述:

You are given two arrays (without duplicates) nums1 and nums2 where nums1’s elements are subset of nums2. Find all the next greater numbers for nums1's elements in the corresponding places of nums2.

The Next Greater Number of a number x in nums1 is the first greater number to its right in nums2. If it does not exist, output -1 for this number.

Example 1:

Input: nums1 = [4,1,2], nums2 = [1,3,4,2].
Output: [-1,3,-1]
Explanation:
    For number 4 in the first array, you cannot find the next greater number for it in the second array, so output -1.
    For number 1 in the first array, the next greater number for it in the second array is 3.
    For number 2 in the first array, there is no next greater number for it in the second array, so output -1.

Example 2:

Input: nums1 = [2,4], nums2 = [1,2,3,4].
Output: [3,-1]
Explanation:
    For number 2 in the first array, the next greater number for it in the second array is 3.
    For number 4 in the first array, there is no next greater number for it in the second array, so output -1.

Note:

All elements in nums1 and nums2 are unique.
The length of both nums1 and nums2 would not exceed 1000.

我的解决方案:

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& findNums, vector<int>& nums) {
        vector<int> ret;
        for(int i=0;i<findNums.size();++i)
        {
            int tmp=-1;
            bool find=false;
            for(int j=0;j<nums.size() && tmp==-1;++j)
            {
                if(findNums[i]==nums[j])
                   find=true;
                if(find && findNums[i]<nums[j])
                    tmp=nums[j];
            }
            ret.push_back(tmp);
        }
        return ret;
    }
};

思考:

题目挺简单的,双重循环来找右边第二大的数,这个思路很容易想到.不过缺点也是显而易见的,每一个数都需要循环才能找到在第二个数组中的位置,时间复杂性很糟糕.有些循环是没有多余的,因此优化的思路可以考虑用空间换时间.采用一个map来记录数组二中每个元素和他右边第一个比他大的元素的对应关系.那么对于数组一,只需要在map中进行寻找即可.构造map的时候,也需要双重循环,但是内层循环可以从每次的元素之后开始循环,时间复杂度可以降低为O(log2n)

以下是自己优化后的代码:

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& findNums, vector<int>& nums) {
        vector<int> ret;
        unordered_map<int,int> m;
        for(int i=0;i<nums.size();++i)
            for(int j=i;j<nums.size();++j)
                if(nums[i]<nums[j])
                {
                    m[nums[i]]=nums[j];
                    break;
                }
        for(int i=0;i<findNums.size();++i)
          ret.push_back(m.count(findNums[i])?m[findNums[i]]:-1);
        return ret;
    }
};