【力客热题HOT100】-【100】739 每日温度

重点：

（1）暴力搜索：O(n^2)，思路简单，超时；

（2）动态规划：类似于火箭击落敌机，复杂度O(nlogn)，可以；写清逻辑，更新index；

（3）单调栈：O(n)空间和时间复杂度，最佳解；

（4）单调栈的用法：一维数组，寻找一个元素的右边或者左边第一个比自己大或者小的元素的位置，就用单调栈，时间复杂度O(n)；

739. 每日温度

难度中等1233收藏分享切换为英文接收动态反馈

给定一个整数数组 temperatures ，表示每天的温度，返回一个数组 answer ，其中 answer[i] 是指对于第 i 天，下一个更高温度出现在几天后。如果气温在这之后都不会升高，请在该位置用 0 来代替。

示例 1:

输入: temperatures = [73,74,75,71,69,72,76,73]
输出: [1,1,4,2,1,1,0,0]

示例 2:

输入: temperatures = [30,40,50,60]
输出: [1,1,1,0]

示例 3:

输入: temperatures = [30,60,90]
输出: [1,1,0]

提示：

• 1 <= temperatures.length <= 105
• 30 <= temperatures[i] <= 100

解析：

方法1：暴力搜索

最容易想到的暴力搜索。复杂度O(n^2)，每次寻找后面第一个比自己大的。不过超时。

方法2：动态规划

跟火箭击落敌机那个题类似，可用动态规划，从后往前遍历。每天跳跃式遍历，找到比自己温度高的。最坏情况下复杂度也是O(n^2)，平均是O(nlogn)。

方法3：单调栈

什么时候用单调栈呢？一维数组，寻找一个元素的右边或者左边第一个比自己大或者小的元素的位置，就用单调栈，时间复杂度O(n)。

单调栈的本质是空间换时间。遍历过程中需要使用一个栈来记录右边第一个比当前高的元素。

我们概括为以下几点：

（1）栈内存的是元素的下标；

（2）每次新元素入栈分为三种情况：

         ——当前元素值>栈顶元素值：栈顶元素一直出栈，同时更新result数组，新元素入栈顶；

         ——当前元素值<=栈顶元素值：新元素直接入栈；

（3）result数组初始化为0，那么遍历完整个数组，result即为答案；

详细可见注解：代码随想录 (programmercarl.com)

代码：

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

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& temperatures) {
        vector<int> lable(temperatures.size(),0);
        for(int i=temperatures.size()-2;i>=0;i--){
            if(temperatures[i]>=temperatures[i+1]){
                if(lable[i+1]==0)
                    lable[i]=0;
                else{
                    //i+1天比i天温度低，并且i+1天label不为0，即有比i+1温度高的
                    //跳跃式找答案有两种情况
                    //第一种找到了比自己高的温度，直接标记lable数组，然后break
                    //第二种，找到一个更高的温度但没当前高，而且label为0，说明没有比自己高的
                    int index=i+1+lable[i+1];
                    while(index<temperatures.size()){
                        if(temperatures[index]>temperatures[i]){
                            lable[i]=index-i;
                            break;
                        }
                        else if(lable[index]==0)
                            break;
                        index+=lable[index];
                    }
                }
            }
            else
                lable[i]=1;
        }
        return lable;
    }
};

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& temperatures) {
        if(temperatures.size()==1)
            return {0};
        vector<int> result(temperatures.size(),0);
        stack<int> stk;
        while(!stk.empty())
            stk.pop();
        stk.push(0);
        for(int i=1;i<temperatures.size();i++){
            //如果当前栈为空，直接入栈
            if(stk.empty())
                stk.push(i);
            //如果不为空，但当前栈顶元素更大，也直接入栈
            else if(temperatures[i]<=temperatures[stk.top()])
                stk.push(i);
            //如果栈不为空，且当前温度比栈顶温度大，则准备出栈
            else{
                while((!stk.empty())){
                    if(temperatures[stk.top()]<temperatures[i]){
                        result[stk.top()]=i-stk.top();
                        stk.pop();
                    }
                    else
                        break;
                }
                stk.push(i);
            }
        }
        return result;
    }
};