O problema 682 do LeetCode simula um rgeistrador de pontos de um jogo de beisebol. Dada uma lista de strings, cada string pode ser um dos seguintes tipos:

• Número inteiro: Representa diretamente os pontos ganhos na rodada atual.
• "+": Os pontos da rodada atual são a soma dos pontos das duas últimas rodadas válidas.
• "D": Os pontos da rodada atual são o dobro dos pontos da última rodada válida.
• "C": Remove os pontos da última rodada válida (não conta como rodada pontuada).

Cada operação é permanente e pode afetar as rodadas anteriores e posteriores. O objetivo é retornar a soma total de pontos de todas as rodadas.

Exemplo 1

Entrada: ["5","2","C","D","+"]
Saída: 30
Explicação:
Rodada 1: Recebe 5 pontos. Soma: 5.
Rodada 2: Recebe 2 pontos. Soma: 7.
Operação 1 (C): Remove a rodada 2. Soma: 5.
Rodada 3 (D): O dobro da última válida (5). Soma: 5 + 10 = 15.
Rodada 4 (+): Soma das duas últimas válidas (5 + 10 = 15). Soma: 15 + 15 = 30.

Exemplo 2

Entrada: ["5","-2","4","C","D","9","+","+"]
Saída: 27
Explicação:
Rodada 1: 5 pontos. Soma: 5.
Rodada 2: -2 pontos. Soma: 3.
Rodada 3: 4 pontos. Soma: 7.
Operação 1 (C): Remove rodada 3. Soma: 3.
Rodada 4 (D): Dobro da última válida (-2). Soma: 3 + (-4) = -1.
Rodada 5: 9 pontos. Soma: -1 + 9 = 8.
Rodada 6 (+): Soma das últimas válidas (-4 + 9 = 5). Soma: 8 + 5 = 13.
Rodada 7 (+): Soma das últimas válidas (9 + 5 = 14). Soma: 13 + 14 = 27.

Restrições

• O tamanho da lista de entrada está entre 1 e 1000.
• Os números inteiros representados estão entre -30000 e 30000.

Estratégia de Solução

A abordagem mais simples é usar uma estrutura de dados linear (como um vetor ou lista) para armazenar os pontos das rodadas válidas. Percorremos a lista de operações uma vez e aplicamos as regras:

• Se for um número, adicionamos ao final do vetor.
• Se for "+", somamos os dois últimos elementos do vetor e adicionamos o resultado.
• Se for "D", dobramos o último elemento e adicionamos.
• Se for "C", removemos o último elemento.

Ao final, somamos todos os valores no vetor.

Implementação em C++

class Solution {
public:
    int calPoints(vector<string>& ops) {
        vector<int> pontos;
        for (const string& op : ops) {
            int n = pontos.size();
            if (op == "+") {
                // Soma dos dois últimos pontos válidos
                pontos.push_back(pontos[n-1] + pontos[n-2]);
            } else if (op == "D") {
                // Dobro do último ponto válido
                pontos.push_back(2 * pontos[n-1]);
            } else if (op == "C") {
                // Remove o último ponto válido
                pontos.pop_back();
            } else {
                // Número inteiro: converte string para int
                pontos.push_back(stoi(op));
            }
        }
        int total = 0;
        for (int p : pontos) {
            total += p;
        }
        return total;
    }
};
</int></string>

Implementação em Java

import java.util.ArrayList;
import java.util.List;

class Solution {
    public int calPoints(String[] ops) {
        List<integer> lista = new ArrayList<>();
        for (String op : ops) {
            int n = lista.size();
            if (op.equals("+")) {
                // Soma dos dois últimos
                lista.add(lista.get(n-1) + lista.get(n-2));
            } else if (op.equals("D")) {
                // Dobro do último
                lista.add(2 * lista.get(n-1));
            } else if (op.equals("C")) {
                // Remove o último
                lista.remove(n-1);
            } else {
                // Número inteiro
                lista.add(Integer.parseInt(op));
            }
        }
        int total = 0;
        for (int p : lista) {
            total += p;
        }
        return total;
    }
}
</integer>