LeetCode——682. 棒球比赛

题目

你现在是一场采用特殊赛制棒球比赛的记录员。这场比赛由若干回合组成，过去几回合的得分可能会影响以后几回合的得分。

比赛开始时，记录是空白的。你会得到一个记录操作的字符串列表 ops，其中 ops[i] 是你需要记录的第 i 项操作，ops 遵循下述规则：

整数 x - 表示本回合新获得分数 x
“+” - 表示本回合新获得的得分是前两次得分的总和。题目数据保证记录此操作时前面总是存在两个有效的分数。
“D” - 表示本回合新获得的得分是前一次得分的两倍。题目数据保证记录此操作时前面总是存在一个有效的分数。
“C” - 表示前一次得分无效，将其从记录中移除。题目数据保证记录此操作时前面总是存在一个有效的分数。
请你返回记录中所有得分的总和。

思路

利用一个栈来做，对应的字符串执行对应的操作，等到执行完一整个字符串数组之后， 便将整个栈中的数字弹出并且计算出总和。

代码

class Solution {
    public int calPoints(String[] ops) {
        Stack<String> stack=new Stack();//开一个栈
        int length=ops.length;
        for (int i=0;i<length;++i)
        {
            if (ops[i].equals("C"))
                stack.pop();
            else  if (ops[i].equals("D"))
            {
                stack.add((Integer.parseInt(stack.peek())<<1)+"");
            }
            else if (ops[i].equals("+"))
            {
                int a=Integer.parseInt(stack.pop());
                int b=Integer.parseInt(stack.peek());
                stack.add(a+"");
                stack.add((a+b)+"");
            }
            else
            {
                int ans=Integer.parseInt(ops[i]);
                stack.add(ans+"");
            }
        }

        int result=0;
        while (!stack.isEmpty())
        {
            result+=Integer.parseInt(stack.pop());
        }
        return  result;
    }
}

结果

AC了，不过速度太慢了。

改进

后来仔细一想，其实不用每次都要利用字符串来做，我们的栈可以开一个整形的栈，这样子，就不需要每次都开一个新的字符串，因而减少内存和时间的开销。

代码

import java.util.Stack;
//棒球比赛
class Solution {
    public int calPoints(String[] ops) {
        Stack<Integer> stack=new Stack();//开一个栈
        int length=ops.length;
        for (int i=0;i<length;++i)
        {
            if (ops[i].equals("C"))
                stack.pop();
            else  if (ops[i].equals("D"))
            {
                stack.add(stack.peek()<<1);
            }
            else if (ops[i].equals("+"))
            {
                int a=stack.pop();
                int b=stack.peek();
                stack.add(a);
                stack.add(a+b);
            }
            else
            {
                int ans=Integer.parseInt(ops[i]);
                stack.add(ans);
            }
        }
        int result=0;
        while (!stack.isEmpty())
        {
            result+=stack.pop();
        }
        return  result;
    }
}

结果

AC了，并且速度和内存的消耗都减少了。

再改进

有一点更加新的想法是，其实也可以不用栈，而是直接使用ArrayList，然后操作就跟栈一样，这样速度也许可以加快。

代码

import java.util.ArrayList;
//棒球比赛
class Solution {
    public int calPoints(String[] ops) {
        ArrayList<Integer> list=new ArrayList();
        int length=ops.length;
        for (int i=0;i<length;++i)
        {
            if (ops[i].equals("C"))
                list.remove(list.size()-1);//删除最后一个数字
            else  if (ops[i].equals("D"))
            {
                list.add(list.get(list.size()-1)*2);
            }
            else if (ops[i].equals("+"))
            {
                int a=list.get(list.size()-1);
                int b=list.get(list.size()-2);
                list.add(a+b);
            }
            else
            {
                list.add(Integer.parseInt(ops[i]));
            }
        }

        int result=0;
        int size=list.size();
        for (int i=0;i<size;++i)
            result+=list.get(i);
        return  result;
    }
}

结果

AC，并且速度加快了1ms，其实挺好了，能减少时间就可以。

再再改进

既然可以使用ArrayList来解答，那么何不直接使用数组来解答，主要的问题就是解决数组的长度问题，而且利用数组随去随用的特点，对于"C"、“D”、"+"这三个操作都会大幅提高速度。数组最长的情况下，所有的都是数字，然后，结果就是需要将这些数组都加起来，所以我们可以确定数组的最大长度就是字符串数组的长度。

代码

class Solution {
    public int calPoints(String[] ops) {
        int length=ops.length;
        int numbers[]=new int[length];
        int index=0;//存放数字的数组
        for (int i=0;i<length;++i)
        {
            if (ops[i].equals("C"))//赋值为0并且结果数组的下标减1
                numbers[index--]=0;
            else  if (ops[i].equals("D"))
            {
                numbers[index]=2*numbers[index-1];
                ++index;
            }
            else if (ops[i].equals("+"))
            {
                numbers[index]=numbers[index-1]+numbers[index-2];
                ++index;
            }
            else
            {
                numbers[index]=Integer.parseInt(ops[i]);
                ++index;
            }
        }

        int result=0;
        for (int i=0;i<index;++i)
            result+=numbers[i];
        return  result;
    }
}

结果

人在不同的时刻很容易有不同的想法，只要能有改进了，这些想法就不是没有用的。