一天一大 leet(每日温度)难度:中等 DAY-11
20200610
题目(难度:简单):
根据每日 气温 列表，请重新生成一个列表，对应位置的输出是需要再等待多久温度才会升高超过该日的天数。如果之后都不会升高，请在该位置用 0 来代替。
示例
输入: [73, 74, 75, 71, 69, 72, 76, 73]
输出: [1, 1, 4, 2, 1, 1, 0, 0]
提示
气温 列表长度的范围是 [1, 30000]。每个气温的值的均为华氏度，都是在 [30, 100] 范围内的整数。
抛砖引玉
先阐述下题目的意思：
| 73 | 74 | 75 | 71 | 69 | 72 | 76 | 73 |
|---|---|---|---|---|---|---|---|
| [74, 75, 71, 69, 72, 76, 73] | [75, 71, 69, 72, 76, 73] | [71, 69, 72, 76, 73] | [69, 72, 76, 73] | [ 72, 76, 73] | [76, 73] | [73] | [] |
| 74>73 | 75>74 | 76>75 | 72>71 | 72>69 | 76>72 | 无 | 无 |
| 原数组的索引： 73 ->0,74 -> 1 | 原数组的索引： 74 ->1,75 -> 2 | 原数组的索引： 75 ->2,76 -> 6 | 原数组的索引： 71 ->3,72 -> 5 | 原数组的索引： 69 ->4,72 -> 5 | 原数组的索引： 72 ->4,72 -> 6 | 0 | 0 |
| 1-0 | 2-1 | 6-2 | 5-3 | 5-4 | 6-4 | 0 | 0 |
遍历数组
返回数组中 A 之后项第一个大于 A 的第一个数字的索引
填充索引到新数组中 A 对应的索引位置
/**
* @param {number[]} T
* @return {number[]}
*/
var dailyTemperatures = function (T) {
var len = T.length
var _result = Array(len).fill(0)
for (var i = 0; i < len; i++) {
var item = T[i]
if (item < 100) {
for (var j = i + 1; j < len; j++) {
if (T[j] > item) {
_result[i] = j - i
break
}
}
}
}
return _result
}
官方答案
暴力
- 反向遍历温度列表。对于每个元素 T[i]，在数组 next 中找到从 T[i] + 1 到 100 中每个温度第一次出现的下标，
将其中的最小下标记为 warmerIndex，则 warmerIndex 为下一次温度比当天高的下标。
如果 warmerIndex 不为无穷大，则 warmerIndex - i 即为下一次温度比当天高的等待天数，最后令 next[T[i]] = i。 - 为什么上述做法可以保证正确呢？因为遍历温度列表的方向是反向，当遍历到元素 T[i] 时，
只有 T[i] 后面的元素被访问过，即对于任意 t，当 next[t] 不为无穷大时，一定存在 j 使得 t 等于 T[j] 且 i < j。
又由于遍历到温度列表中的每个元素时都会更新数组 next 中的对应温度的元素值，
因此对于任意 t，当 next[t] 不为无穷大时，令 j = next[t]，则 j 是满足 t 等于 T[j] 且 i < j 的最小下标
/**
* @param {number[]} T
* @return {number[]}
*/
var dailyTemperatures = function (T) {
var length = T.length
var ans = Array(length).fill(0)
var next = Array(101).fill(Number.MAX_VALUE)
for (var i = length - 1; i >= 0; --i) {
var warmerIndex = Number.MAX_VALUE
for (var t = T[i] + 1; t <= 100; ++t) {
if (next[t] < warmerIndex) {
warmerIndex = next[t]
}
}
if (warmerIndex < Number.MAX_VALUE) {
ans[i] = warmerIndex - i
}
next[T[i]] = i
}
return ans
}
单调栈
- 栈空的情况下，当前元素入栈
- 当前元素比栈顶大，则让小项出栈，栈顶更新，直到当前元素比栈顶小，停止出栈
- 此时的栈顶元素就是当前项右边的第一个比自己大的元素，计算距离并让当前项入栈
/**
* @param {number[]} T
* @return {number[]}
*/
var dailyTemperatures = function (T) {
const res = new Array(T.length).fill(0)
const stack = []
for (let i = T.length - 1; i >= 0; i--) {
while (stack.length && T[i] >= T[stack[stack.length - 1]]) {
stack.pop()
}
if (stack.length && T[i] < T[stack[stack.length - 1]]) {
res[i] = stack[stack.length - 1] - i
}
stack.push(i)
}
return res
}
高手在民间
-
遍历整个数组，如果栈不空，且当前数字大于栈顶元素，所以需要取出栈顶元素，
由于当前数字大于栈顶元素的数字，而且一定是第一个大于栈顶元素的数，直接求出下标差就是二者的距离。 -
继续看新的栈顶元素，直到当前数字小于等于栈顶元素停止，然后将数字入栈，
这样就可以一直保持递减栈，且每个数字和第一个大于它的数的距离也可以算出来。
/**
* @param {number[]} T
* @return {number[]}
*/
var dailyTemperatures = function (T) {
let res = new Array(T.length).fill(0)
let stack = []
for (let i = 0; i < T.length; i++) {
while (stack.length && T[i] > T[stack[stack.length - 1]]) {
let topIdx = stack.pop()
res[topIdx] = i - topIdx
}
stack.push(i)
}
return res
}
博客: 小书童博客(http://gaowenju.com/)
公号: 坑人的小书童
