LeetCode 739. 每日温度

两种方法：

方法一：优化后的暴力搜索

正常暴力搜索，就是遍历数组，对于每个温度向后查找到第一个高于当前温度的日期，对应的日期差即距离

优化后的暴力搜索

从后往前遍历，对于当前日期的温度也是向后查找到第一个高于当前温度的日期

优化步骤：

用一个变量a记录当前遇到的最高温度，这样可以用来减小不必要的搜索

用一个数组b记录要想观测到更高的气温，至少需要等待的天数

用一个数组c记录下一个更高气温对应的温度，这样减小重复搜索

 vector<int> dailyTemperatures(vector<int>& T) {

            //两个数组

            //index记录要观测到更高的气温T[i]要等待的天数

            //temper记录T[i]下一次观测到的对应的更高的气温

            vector<int> index(T.size(),0);

            vector<int> temper(T.size(),0);

            //从后往前遍历

            int i = T.size();

            i = i-1;

            int max_t = T[i]; // 记录当前遇到的最高温度，用来判断当前天的温度在后面还有没有希望升高，没有的话就不用往后遍历了

            for(i=i-1;i>=0;--i){

                if(T[i] >= max_t){

                    index[i] = 0;

                    temper[i] = 0;

                    max_t = T[i];

                    continue;

                }

                if(T[i+1] > T[i]){

                    index[i] = 1;

                    temper[i] = T[i+1];

                }else if(index[i+1] == 0){ //后面没有升高的温度了

                    index[i] = 0;

                    temper[i] = 0;

                }else{

                    int j = i+1; //j永远是当前i的下一天

                    bool flag = false;

                    for(;j<T.size();++j){

                        if(temper[j] > T[i]){ 

                            index[i]+=(index[j]+1);

                            temper[i] = temper[j];

                            flag = true;

                            break;

                        }

                        if(!flag)

                        {

                            index[i]+=(index[j]);

                            j+=(index[j]-1);

                        }

                    }

                }

            }

            return index;

    }

方法二：用栈记录没有访问过但还没找到更高温度的温度，复杂度为O(n)

从前往后遍历，将还没有找到更高温度的日期入栈，并且栈中温度高的放下面，温度低的放上面

每次都判断栈顶元素是否找到了更高的温度，更新

vector<int> dailyTemperatures(vector<int>& T) {

          vector<int> index(T.size(),0);

          stack<int> desc_st;

          desc_st.push(0);

          for(int i=1;i<T.size();++i){

              while(!desc_st.empty() && T[i] > T[desc_st.top()]){

                  index[desc_st.top()] = (i-desc_st.top());

                  desc_st.pop();

              }

              desc_st.push(i);

          }

          return index;

    }

结论：

方法一 优于方法二