代码随想录训练营第58天|LeetCode 739. 每日温度、496.下一个更大元素I

参考

代码随想录

题目一：LeetCode 739. 每日温度

暴力求解：

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& temperatures) {
        vector<int> result(temperatures.size(),0);
        for(int i = 0; i < temperatures.size() - 1; i++){
            for(int j = i+1; j < temperatures.size(); j++){
                if(temperatures[j] > temperatures[i]){
                    result[i] = j - i;
                    break;
                }
            }
        }
        return result;
    }
};

暴力求解会超时。在暴力求解中，对于每个数，从下一个数开始寻找比当前数更大的数，时间复杂度为O(n^2)，使用单调栈可以将时间复杂度降低为O(n)，但空间复杂度会变为O(n)，其实也就是用空间来换取时间。
通常是一维数组，要寻找任一个元素的右边或者左边第一个比自己大或者小的元素的位置，此时我们就要想到可以用单调栈了。
在暴力求解中，我们只关心比当前数大的第一个数的位置，使用单调栈后，可以记录比当前数小的元素，在单调栈中的元素从栈顶到栈底是递增的，整个过程中要始终保持这个状态。本题求解的是位置关系，因此单调栈中存放元素下标，这样通过下标既能知道元素的位置，也能知道元素的数值。

代码实现如下：

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& temperatures) {
        stack<int> stk;
        stk.push(0);
        vector<int> result(temperatures.size(),0);
        for(int i = 1; i < temperatures.size(); i++){
            while(!stk.empty() && temperatures[stk.top()] < temperatures[i]){
                result[stk.top()] = i - stk.top();
                stk.pop();
            }
            stk.push(i);
        }
        return result;
    }
};

题目二：LeetCode 739. 每日温度

暴力求解

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        vector<int> result(nums1.size(),-1);
        for(int i = 0; i < nums1.size(); i++){  //遍历nums1
            for(int j = 0; j < nums2.size(); j++){ //在nums2中找到nums1[i]
                if(nums1[i] == nums2[j]){   
                    for(int k = j + 1; k < nums2.size(); k++){ // 找到下一个更大的元素
                        if(nums2[k] > nums1[i]){
                            result[i] = nums2[k];
                            break;
                        }
                    }
                    break;
                }
            }
        }
        return result;
    }
};

这是个简单题，所以用暴力求解不会超时。

单调栈

在nums2中查找nums1中的元素出现的位置，除了只用上面的暴力遍历之外，还可以使用哈系表来提高效率。使用单调栈来求解，应该遍历nums2，求出每个元素的下一个更大的元素，然后只需要保存nums1中存在的元素的结果即可，因此应该用哈系表来映射nums1中的元素数值和下标。

代码实现如下：

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        vector<int> result(nums1.size(),-1);
        unordered_map<int,int> umap;
        stack<int> stk;
        //映射
        for(int i = 0; i < nums1.size(); i++)
            umap[nums1[i]] = i;  //key：数值    value：下标
        //初始化
        stk.push(0);
        
        for(int i = 1; i < nums2.size(); i++){
            while(!stk.empty() && nums2[stk.top()] < nums2[i]){
                if(umap.count(nums2[stk.top()]) > 0){  //判断nums1中是否存在 nums2[stk.top()]
                    int index = umap[nums2[stk.top()]];  //nums2[stk.top()]对应的下标
                    result[index] = nums2[i];
                }
                stk.pop();
            }
            stk.push(i);
        }
        return result;
    }
};