【LeetCode】503, Siguiente elemento más grande II. Nivel de dificultad: Moderado. Comprensión profunda del "próximo problema más grande/más pequeño" método de pila monotónica de uso común

0. Tema

Dada una matriz circular nums (el siguiente elemento de nums[nums.length - 1] es nums[0]), devuelve el siguiente elemento mayor de cada elemento en nums.

El siguiente elemento mayor del número x es el primer número mayor después de este número, en el orden transversal de la matriz, lo que significa que debe realizar un bucle para buscar su siguiente número mayor. Si no está presente, salida -1.

Ejemplo 1:

输入: nums = [1,2,1]
输出: [2,-1,2]
解释: 第一个 1 的下一个更大的数是 2；
数字 2 找不到下一个更大的数； 
第二个 1 的下一个最大的数需要循环搜索，结果也是 2。

Ejemplo 2:

输入: nums = [1,2,3,4,3]
输出: [2,3,4,-1,4]

1. Mi solución: pila monotónica

1.1 Análisis

Esta pregunta es la misma que [LeetCode] 739, temperatura diaria. Nivel de dificultad: Moderado. Una variedad de soluciones, vale la pena estudiar Muy similar, se recomienda leer 739 preguntas primero

Los dos puntos que esta pregunta es más difícil que la pregunta 739 son:

1. La matriz debe estar en bucle de un extremo a otro, así que encuentre una manera de implementar el recorrido de bucle de matriz.
2. Si no hay un número mayor para un número determinado, se devuelve -1; de hecho, es para encontrar todas las posiciones del valor máximo en la matriz (el valor máximo es más de uno)

Ambas dificultades tienen soluciones inteligentes:

1. Es muy problemático recorrer la matriz directamente. Otra forma de pensar es copiar la matriz y ensamblar una nueva matriz con el doble de la longitud original. ¿No es atravesar la nueva matriz una vez equivalente a recorrer la matriz original dos veces?
2. Inicialice la lista de valores devueltos con -1, la posición con un valor mayor se sobrescribirá con el nuevo valor, la posición con el valor máximo no se procesará y -1 aún se conservará

De esta manera, ambas dificultades se resuelven y consideraremos qué método usar a continuación. La conclusión es:

Para el problema de "encontrar el más cercano más grande o más pequeño que el valor actual", puede usar una pila monotónica para resolverlo

¿Por qué se puede usar una pila monotónica para este tipo de problema? Para obtener una explicación detallada, consulte ¿Por qué usar "pila monotónica"? Desde la perspectiva de "solución simple" para entender "pila monotónica"

1.2 Código primario, escrito directamente según la idea de pila monotónica

El código escrito directamente de acuerdo con la idea de pila monotónica es el siguiente:

class Solution:
    def nextGreaterElements(self, nums: List[int]) -> List[int]:
        # 实现循环的一种方法：将数组复制一遍;取前 nums 个结果即可
        new_nums=nums*2
        length=len(new_nums)
        ans=[-1]*length    # 为了避免单独判断最大的元素的位置，用-1初始化数组

        stack=[]
        for i in range(length):
            if not stack:
                stack.append([i,new_nums[i]])
            else:
                if new_nums[i]>stack[-1][1]:
                    while stack and new_nums[i]>stack[-1][1]:
                        ans[stack[-1][0]]=new_nums[i]
                        stack.pop()
                    stack.append([i,new_nums[i]])
                else:
                    stack.append([i,new_nums[i]])
        return ans[:length//2]

1.3 Código simplificado

Obviamente, el código en 1.2 se puede simplificar, el código simplificado es el siguiente:

class Solution:
    def nextGreaterElements(self, nums: List[int]) -> List[int]:
        # 实现循环的一种方法：将数组复制一遍;取前 nums 个结果即可
        new_nums=nums*2
        length=len(new_nums)
        ans=[-1]*length    # 为了避免单独判断最大的元素的位置，用-1初始化数组

        stack=[]
        for i in range(length):
            if not stack:
                stack.append([i,new_nums[i]])
            else:
                while stack and new_nums[i]>stack[-1][1]:
                    ans[stack[-1][0]]=new_nums[i]
                    stack.pop()
                stack.append([i,new_nums[i]])
        return ans[:length//2]