LeetCode.682 Baseball Game

最新推荐文章于 2024-04-28 21:24:32 发布

原创最新推荐文章于 2024-04-28 21:24:32 发布 · 759 阅读

0 ·

CC 4.0 BY-SA版权

LeetCode算法编程专栏收录该内容

225 篇文章

订阅专栏

本文介绍了一种棒球比赛的计分算法，通过解析特定的字符串指令来更新得分，包括加分、双倍得分、取消得分等操作。文章提供了两种实现方案，一种是基于数组的方法，另一种是使用栈进行实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目：

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.分析1（数组-推荐）：

class Solution {
    public int calPoints(String[] ops) {
        //给定字符串数组，每个对应的关系如题上所述，你需要返回最后的得分之和
        //思路：使用数组实现
        if (ops.length == 0) return 0;

        int sum = 0;
        int[] nums = new int[ops.length];
        //和数组中的游标
        int index = 0;
        for (int i = 0; i < ops.length; i++) {
            //取第一个符号
            char op = ops[i].toCharArray()[0];
            switch (op) {
                case '+':
                    //两和相加
                    int numP=nums[index - 1] + nums[index - 2];
                    nums[index++] = numP;
                    break;
                case 'D':
                    int numD=nums[index-1]*2;
                    nums[index++] = numD;
                    break;
                case 'C':
                    nums[--index] = 0;
                    break;
                default:
                    //数字
                    nums[index++] = Integer.parseInt(ops[i]);
                    break;
            }
        }
        //将结果求和
        for (int j = 0; j < nums.length; j++) {
            sum += nums[j];
        }

        return sum;
    }
}

分析2（原创-易理解）：

class Solution {
    public int calPoints(String[] ops) {
        //给定字符串数组，每个对应的关系如题上所述，你需要返回最后的得分之和
        //思路：使用一个stack来记录每回合的得分
        if(ops.length==0) return 0;

        Stack <Integer>stack=new Stack<>();
        int sum=0;
        for(int i=0;i<ops.length;i++){
            //负数的情况，长度为2
            if(ops[i].length()==2){
                sum+=Integer.parseInt(ops[i]);
                stack.push(Integer.parseInt(ops[i]));
            }else{
                //字母的情况
                //加倍
                if(ops[i].equals("D")){
                    if(!stack.empty()){
                        //取栈顶元素，并不将其剔除
                        int score=stack.peek()*2;
                        sum+=score;
                        //重新入栈
                        stack.push(score);
                    }
                }else if(ops[i].equals("C")){
                    //移除栈顶元素
                    if(!stack.empty()){
                        //减去一个元素
                        sum-=stack.pop();
                    }

                } else if(ops[i].equals("+")){
                    //相加
                    int lastNum=stack.pop();
                    //另一个需要相加的数不取出
                    int temp=lastNum+stack.peek();
                    sum+=temp;
                    //入栈
                    stack.push(lastNum);
                    stack.push(temp);
                }else{
                    //正数
                    sum+=Integer.parseInt(ops[i]);
                    stack.push(Integer.parseInt(ops[i]));
                }
            }
        }
        return sum;
    }
}