150. Evaluación de expresión polaca inversa

Implementación usando una pila para resolver operaciones matemáticas:

class Solution {
public:
    bool esNumero(const string& s) {
        if (s.empty()) return false;
        if (s[0] == '-' && s.size() > 1) {
            for (int i = 1; i < s.size(); ++i) {
                if (!isdigit(s[i])) return false;
            }
        } else {
            for (char c : s) {
                if (!isdigit(c)) return false;
            }
        }
        return true;
    }

    int calcularRPN(vector<string>& tokens) {
        stack<int> pila;
        for (const string& token : tokens) {
            if (esNumero(token)) {
                pila.push(stoi(token));
            } else if (pila.size() >= 2) {
                int op2 = pila.top(); pila.pop();
                int op1 = pila.top(); pila.pop();
                int resultado = 0;
                if (token == "+") resultado = op1 + op2;
                else if (token == "-") resultado = op1 - op2;
                else if (token == "*") resultado = op1 * op2;
                else if (token == "/") resultado = op1 / op2;
                pila.push(resultado);
            }
        }
        return pila.top();
    }
};

239. Máximo de ventana deslizante

Solución basada en cola monótona descendente:

class Solution {
public:
    class ColaMaxima {
    public:
        void eliminar(int valor) {
            if (!cola.empty() && cola.front() == valor) {
                cola.pop_front();
            }
        }

        void insertar(int valor) {
            while (!cola.empty() && valor > cola.back()) {
                cola.pop_back();
            }
            cola.push_back(valor);
        }

        int obtenerMaximo() {
            return cola.front();
        }

    private:
        deque<int> cola;
    };

    vector<int> maximoVentana(vector<int>& nums, int k) {
        ColaMaxima cm;
        vector<int> resultados;
        
        for (int i = 0; i < k; ++i) {
            cm.insertar(nums[i]);
        }
        resultados.push_back(cm.obtenerMaximo());

        for (int i = k; i < nums.size(); ++i) {
            cm.eliminar(nums[i - k]);
            cm.insertar(nums[i]);
            resultados.push_back(cm.obtenerMaximo());
        }
        
        return resultados;
    }
};

347. Elementos frecuentes K

Dos enfoques para encontrar los elementos más frecuentes:

class Solution {
public:
    // Enfoque de clasificación
    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int, int> frecuencia;
        for (int num : nums) frecuencia[num]++;

        vector<pair<int, int>> elementos(frecuencia.begin(), frecuencia.end());
        sort(elementos.begin(), elementos.end(), 
            [](const pair<int, int>& a, const pair<int, int>& b) {
                return a.second > b.second;
            });

        vector<int> resultado;
        for (int i = 0; i < k; ++i) {
            resultado.push_back(elementos[i].first);
        }
        return resultado;
    }

    // Enfoque de cola de prioridad
    vector<int> topKFrequentHeap(vector<int>& nums, int k) {
        unordered_map<int, int> frecuencia;
        for (int num : nums) frecuencia[num]++;

        auto cmp = [](const pair<int, int>& a, const pair<int, int>& b) {
            return a.second > b.second;
        };
        priority_queue<pair<int, int>, vector<pair<int, int>>, decltype(cmp)> heap(cmp);

        for (auto& [num, freq] : frecuencia) {
            heap.push({num, freq});
            if (heap.size() > k) heap.pop();
        }

        vector<int> resultado(k);
        for (int i = k-1; i >=0; --i) {
            resultado[i] = heap.top().first;
            heap.pop();
        }
        return resultado;
    }
};