Question

我有一个关于Python中堆栈的问题。我试图解决Hackerrank中的Maximum Element任务：

您有一个空序列，您将获得N个查询。每个查询是以下三种类型之一：
1 x  -Push the element x into the stack.
2    -Delete the element present at the top of the stack.
3    -Print the maximum element in the stack.
输入的第一行包含一个整数N。每个N行包含上述查询。（保证每个查询都是有效。）

为了解决这个问题，我写了这样的话：

class Stack:
    def __init__(self):
        self.items = []

    def push(self, item):
        self.items.append(item)

    def pop(self):
        return self.items.pop()

    def maxEl(self):
        return max(self.items)


s = Stack()   

for i in range(int(input())):
    n = input().split()

    if n[0] == '1':
        s.push(int(n[1]))
    elif n[0] == '2':
        s.pop()
    else:
        print(s.maxEl())

它可以工作，但是显然太慢了，我在28个测试用例中仅通过了18个（由于超时）。我已经找到了类似的解决方案，并且速度足够快，但是我不明白为什么：

class Stack:
    def __init__(self):
        self.arr = [0]
        self.max = [0]

    def push(self, data):
        self.arr.append(data)
        if self.max[-1] <= data:
            self.max.append(data)

    def pop(self):
        if self.arr[-1] == self.max[-1]:
            self.max.pop()
        self.arr.pop()


N = int(input())
s = Stack()

for _ in range(N):
    x = str(input())

    if x[0] == '1':
        s.push(int(x[2:]))

    elif x[0] == '2':
        s.pop()

    else:
        print(s.max[-1])

有人可以解释我为什么我的代码表现不佳吗？谢谢。

Answer 1

除了返回堆栈中最大元素的代码之外，这两种解决方案非常相似。

在解决方案中，您使用def maxEl(self): return max(self.items)函数：

O(n)

这在max()时间运行，因为O(1)必须在最坏的情况下检查每个元素。

在其他解决方案中，最大值存储在另一个堆栈中，因此获取当前最大值只是一个索引操作，它在s.max[-1]时间运行：

<CCC>
    <BBB>This is test</BBB>
</CCC>

在每次推送/弹出时更新最大值堆栈也有一些成本，但是这些操作仍然是constant time。

Answer 2

给出问题的定义，即使有效的解决方案也做得太多。更具体地说，您只需要记住堆栈中的最大值；像

s = []
for _ in range(N):
    x = str(input())
    if x[0] == '1':
        v = int(x[2:])
        s.append(v if len(s) == 0 else max(v, s[-1]))
    elif x[0] == '2':
        s.pop()
    else:
        print(s[-1])

应该足够。

堆栈和优化-来自Hackerrank的示例

2 个答案: