Problem statement

Given an array of integers temperatures representing the daily temperatures, return an array answer such that answer[i] is the number of days you have to wait after the i-th day to get a warmer temperature. If there is no future day for which this is possible, keep answer[i] = 0 instead.

Example 1

Input: temperatures = [73,74,75,71,69,72,76,73]
Output: [1,1,4,2,1,1,0,0]

Example 2

Input: temperatures = [30,40,50,60]
Output: [1,1,1,0]

Example 3

Input: temperatures = [30,60,90]
Output: [1,1,0]

Constraints

• 1 <= temperatures.length <= 10^5.

• 30 <= temperatures[i] <= 100.

Solution 1: Starting from the first day

For each temperatures[i], find the closest temperatures[j] with j > i such that temperatures[j] > temperatures[i], then answer[i] = j - i. If not found, answer[i] = 0.

Example 1

For temperatures = [73,74,75,71,69,72,76,73]:

• answer[0] = 1 since the next day is warmer (74 > 73).

• answer[1] = 1 since the next day is warmer (75 > 74).

• answer[2] = 4 since only after 4 days it is warmer (76 > 75).

• And so on.

Code

#include <vector>
#include <iostream>
using namespace std;
vector<int> dailyTemperatures(vector<int>& temperatures) {
    vector<int> answer(temperatures.size());
    for (int i = 0; i < temperatures.size(); i++) {
        answer[i] = 0;
        for (int j = i + 1; j < temperatures.size(); j++) {
            if (temperatures[j] > temperatures[i]) {
                answer[i] = j - i;
                break;
            }
        }
    }
    return answer;
}
void print(vector<int>& answer) {
    cout << "[";
    for (auto& v : answer ) {
        cout << v << ",";
    }
    cout << "]\n";
}
int main() {
    vector<int> temperatures{73,74,75,71,69,72,76,73};
    auto answer = dailyTemperatures(temperatures);
    print(answer);
    temperatures = {30,40,50,60};
    answer = dailyTemperatures(temperatures);
    print(answer);
    temperatures = {30,60,90};
    answer = dailyTemperatures(temperatures);
    print(answer);
}

Output:
[1,1,4,2,1,1,0,0,]
[1,1,1,0,]
[1,1,0,]

Complexity

• Runtime: O(N^2), where N = temperatures.length.

• Extra space: O(1).

Solution 2: Starting from the last day

The straightforward solution above is easy to understand, but the complexity is O(N^2).

The way starting from the first day to the last day does not make use of the knowledge of the answer[i] values.

• The value answer[i] > 0 tells you that temperatures[i + answer[i]] is the next temperature that is warmer than temperatures[i].

• The value answer[i] = 0 tells you that there is no warmer temperature than temperatures[i].

When computing answer[i] in the reversed order, you can use that knowledge more efficiently.

Suppose you already know the future values answer[j]. To compute an older value answer[i] with i < j, you need only to compare temperatures[i] with temperatures[i + 1] and its chain of warmer temperatures.

Example 1

For temperatures = [73,74,75,71,69,72,76,73].

Suppose you have computed all answer[j] with j > 2, answer = [?,?,?,2,1,1,0,0].

To compute answer[i = 2] for temperatures[2] = 75, you need to compare it with

• temperatures[3] = 71 (< 75). Go to the next warmer temperature than temperatures[3], which is temperatures[3 + answer[3]] = temperatures[3 + 2].

• temperatures[5] = 72 (< 75). Go to the next warmer temperature than temperatures[5], which is temperatures[5 + answer[5]] = temperatures[5 + 1].

• temperatures[6] = 76 (> 75). Stop.

• answer[i = 2] = j - i = 6 - 2 = 4.

Code

#include <vector>
#include <iostream>
using namespace std;
vector<int> dailyTemperatures(vector<int>& temperatures) {
    vector<int> answer(temperatures.size(), 0);
    for (int i = temperatures.size() - 2; i >= 0 ; i--) {
        int j = i + 1;
        while (j < temperatures.size() && temperatures[j] <= temperatures[i]) {
            if (answer[j] > 0) { // there is some temperature bigger than temperatures[j]
                j += answer[j];  // go to that value 
            } else {
                j = temperatures.size();    
            }
        }
        if (j < temperatures.size()) {
            answer[i] = j - i;
        }
    }
    return answer;
}
void print(vector<int>& answer) {
    cout << "[";
    for (auto& v : answer ) {
        cout << v << ",";
    }
    cout << "]\n";
}
int main() {
    vector<int> temperatures{73,74,75,71,69,72,76,73};
    auto answer = dailyTemperatures(temperatures);
    print(answer);
    temperatures = {30,40,50,60};
    answer = dailyTemperatures(temperatures);
    print(answer);
    temperatures = {30,60,90};
    answer = dailyTemperatures(temperatures);
    print(answer);
}

Output:
[1,1,4,2,1,1,0,0,]
[1,1,1,0,]
[1,1,0,]

Complexity

Worse cases for the while loop are when most temperatures[j] in their chain are cooler than temperatures[i].

In these cases, the resulting answer[i] will be either 0 or a big value j - i. Those extreme values give you a huge knowledge when computing answer[i] for other older days i.

The value 0 would help the while loop terminates very soon. On the other hand, the big value j - i would help the while loop skips the days j very quickly.

• Runtime: O(NlogN), where N = temperatures.length.

• Extra space: O(1).

Key takeaway

In some computations, you could improve the performance by using the knowledge of the results you have computed.

In this particular problem, it can be achieved by doing it in the reversed order.

---

Thanks for reading. Feel free to share your thought about my content.

What is your approach? The problem was picked from leetcode.com. You can submit your own solution in any programming language and check the performance there.