LeetcodeMedium- [503. Le prochain élément plus grand II]

Une question similaire à celle-ci: LeetCodeEasy- [496. Prochain plus grand élément I]

Étant donné un tableau circulaire (l'élément suivant du dernier élément est le premier élément du tableau), affichez l'élément suivant le plus grand de chaque élément. L'élément suivant le plus grand du nombre x est dans l'ordre de parcours du tableau, le premier nombre après ce nombre est plus grand que lui, ce qui signifie que vous devez rechercher son prochain plus grand nombre dans une boucle. S'il n'existe pas, -1 est affiché.

Exemple 1:

Entrée: [1,2,1]
Sortie: [2, -1,2]
Explication: Le nombre immédiatement supérieur du premier 1 est 2; le
nombre 2 ne peut pas trouver le nombre supérieur suivant; le 
second Le prochain plus grand nombre de 1 nécessite une recherche en boucle, et le résultat est également 2.
Remarque: La longueur du tableau d'entrée ne dépassera pas 10000.

Source: LeetCode
Lien: https://leetcode-cn.com/problems/next-greater-element-ii Le
droit d'auteur appartient au réseau de déduction. Veuillez contacter l'autorisation officielle pour la réimpression commerciale, et veuillez indiquer la source de la réimpression non commerciale.

Idée 1: Inspiré par la dernière question LeetCodeEasy- [496. L'élément plus grand suivant I] , on peut penser qu'une pile peut toujours être utilisée pour trouver le nombre. Mais vous devez connaître la différence entre cette question et la question précédente: 1. Les éléments de cette question peuvent être répétés: vous ne pouvez donc pas utiliser le dictionnaire pour le stocker. Vous pouvez d'abord initialiser un tableau de réponses et trouver un directement rempli dans le tableau de réponses; 2. Ce La question est un tableau circulaire: il ne suffit donc pas de traverser la question une fois, et elle peut être complétée en utilisant deux traversées.

class Solution:
    def nextGreaterElements(self, nums: List[int]) -> List[int]:
        stack_i = [] # 存放未找到数的下标
        min_num = -0x3f3f3f3f
        i = 0
        length = len(nums)
        ans = [min_num] * length # 存放答案
        cnt = 2 * length
        while cnt > 0:
            cnt -= 1
            while stack_i != [] and nums[i] > nums[stack_i[-1]]:
                ans[stack_i[-1]] = nums[i]
                stack_i.pop()
            if ans[i] == min_num:
                stack_i.append(i)
            i = (i + 1) % length
        for i in range(length):
            if ans[i] == min_num:
                ans[i] = -1
        return ans

Idée 2: La description est la suivante, il est recommandé de regarder le code pour une meilleure compréhension.

class Solution:
    def nextGreaterElements(self, nums: List[int]) -> List[int]:
        stack_i = [] # 存放未找到数的下标
        length = len(nums)
        ans = [0] * length # 存放答案
        for j in range(2*length - 1, 0, -1): # 必须反向遍历
            i = j % length
            while stack_i != [] and nums[i] >= nums[stack_i[-1]]: # 从后开始弹出不大于当前查找值的数，直到找到或者为空为为止
                stack_i.pop()
            ans[i] = nums[stack_i[-1]] if stack_i != [] else -1
            stack_i.append(i)
        return ans