【LeetCode】682. Baseball Game

Python版本：python3.6.2

682. Baseball Game

You're now a baseball game point recorder.
Given a list of strings, each string can be one of the 4 following types:
Integer (one round's score): Directly represents the number of points you get in this round.
"+" (one round's score): Represents that the points you get in this round are the sum of the last two valid round's points.
"D" (one round's score): Represents that the points you get in this round are the doubled data of the last valid round's points.
"C" (an operation, which isn't a round's score): Represents the last valid round's points you get were invalid and should be removed.
Each round's operation is permanent and could have an impact on the round before and the round after.
You need to return the sum of the points you could get in all the rounds.

Example 1:
Input: ["5","2","C","D","+"]
Output: 30
Explanation:
Round 1: You could get 5 points. The sum is: 5.
Round 2: You could get 2 points. The sum is: 7.
Operation 1: The round 2's data was invalid. The sum is: 5.
Round 3: You could get 10 points (the round 2's data has been removed). The sum is: 15.
Round 4: You could get 5 + 10 = 15 points. The sum is: 30.

Example 2:
Input: ["5","-2","4","C","D","9","+","+"]
Output: 27
Explanation:
Round 1: You could get 5 points. The sum is: 5.
Round 2: You could get -2 points. The sum is: 3.
Round 3: You could get 4 points. The sum is: 7.
Operation 1: The round 3's data is invalid. The sum is: 3.
Round 4: You could get -4 points (the round 3's data has been removed). The sum is: -1.
Round 5: You could get 9 points. The sum is: 8.
Round 6: You could get -4 + 9 = 5 points. The sum is 13.
Round 7: You could get 9 + 5 = 14 points. The sum is 27.

Note:
The size of the input list will be between 1 and 1000.
Every integer represented in the list will be between -30000 and 30000.

先贴自己的代码：

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

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

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

    def size(self):
        return len(self.items)

    def top(self):
        return self.items[self.size() - 1]

class Solution:
    def calPoints(self, ops):
        """
        :type ops: List[str]
        :rtype: int
        """
        a = Stack()
        total = 0
        for operation in ops:
            if (operation[0] == '-' and operation[1:].isdigit()) or operation.isdigit():
                a.push(int(operation))
            if operation == "C":
                a.pop()
            if operation == "D":
                a.push(a.top() * 2)
            if operation == "+":
                a.push(a.items[-1]+a.items[-2])
        for i in a.items:
            total += i
        return total

验证下：

x = Solution()
print(x.calPoints(ops=["5","2","C","D","+"]))

这次用到了堆栈，记得上次二叉树的题目也是用堆栈，我硬是没搞懂二叉树，所有就放弃了，这次再次遇到类似需要用到堆栈的题目，想明白了，堆栈这类题目都是基于数组的操作，堆栈可以自己用python定义：

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

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

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

    def clear(self):
        del self.items[:]

    def empty(self):
        return self.size() == 0

    def size(self):
        return len(self.items)

    def top(self):
        return self.items[self.size()-1]

其中，

Stack():创建堆栈

push(item):向栈顶插入项

pop():返回栈顶的项，并从堆栈中删除该项

clear():清空堆栈

empty():判断堆栈是否为空

size():返回堆栈中项的个数

top():返回栈顶的项

--------------------------------------------以下大神解法--------------------------------------------------

class Solution(object):
    def calPoints(self, ops):
        # Time: O(n)
        # Space: O(n)
        history = []
        for op in ops:
            if op == 'C':
                history.pop()
            elif op == 'D':
                history.append(history[-1] * 2)
            elif op == '+':
                history.append(history[-1] + history[-2])
            else:
                history.append(int(op))
        return sum(history)

思想是一样的，差别在于速度，elseif可以加快算法速度，sum()函数取代for循环也可以加速算法。同时也可以看出，堆栈跟数组之间的区别，堆栈是在数组的基础上，多了FILO的性质，pop()函数。

• 函数sum():可用于可迭代对象的相加，如数组。