C++ no LeetCode: como resolver problemas e turbinar suas habilidades

Por que C++ é a linguagem ideal para LeetCode (e como não fracassar)

Se você abriu o LeetCode e pensou: "Vou escrever tudo em Python, é mais conciso", — pare. Para um crescimento hardcore e uma compreensão real de algoritmos, C++ dá vantagem sobre qualquer outra linguagem. Por quê? Porque te obriga a pensar sobre memória, velocidade e detalhes de implementação. Nada de sort() "mágico" sem entender como funciona.

Neste artigo, não vamos apenas listar problemas. Vamos mostrar como pensar em C++ ao resolver problemas do LeetCode, quais estruturas de dados são realmente necessárias e fornecer modelos de código prontos. Você aprenderá por que std::vector é seu melhor amigo e std::unordered_map é sua arma secreta.

Pronto? Vamos lá.

Top 5 estruturas de dados em C++ para LeetCode

Antes de sair resolvendo problemas, você precisa montar seu "arsenal". Aqui está o que realmente será útil em 90% dos casos:

\n
• std::vector — array dinâmico. Tudo relacionado a sequências, intervalos, matrizes.
\n
• std::unordered_map — tabela hash. Para contagens, busca de duplicatas, problemas de two-sum.
\n
• std::set / std::unordered_set — conjuntos. Quando você precisa verificar rapidamente a existência de um elemento.
\n
• std::stack / std::queue / std::deque — para travessias, sequências de parênteses, BFS/DFS.
\n
• std::pair — indispensável para armazenar pares (por exemplo, coordenadas + valor).
\n

Aqui está um exemplo de como fica um wrapper básico para análise de frequência usando tabela hash:

#include <unordered_map>\n#include <vector>\n#include <string>\n\nstd::unordered_map<std::string, int> countWords(const std::vector<std::string>& words) {\n    std::unordered_map<std::string, int> freq;\n    for (const auto& w : words) {\n        freq[w]++;\n    }\n    return freq;\n}\n

Viu? Mínimo de código, máximo de utilidade.

Como abordar um problema: checklist para C++

O erro do iniciante é sair escrevendo código imediatamente. O caminho certo é primeiro entender a estrutura de dados. Para C++, isso é crítico, pois a escolha errada do contêiner pode custar um Time Limit Exceeded (TLE).

Passo 1. Identifique o tipo de problema

\n
• Arrays / strings → vector, string
\n
• Busca de duplicatas → unordered_set
\n
• Programação dinâmica → vector<vector<int>>
\n
• Grafos → vector<vector<int>> ou unordered_map<int, vector<int>>
\n

Passo 2. Escolha o paradigma algorítmico

\n
• Algoritmo guloso — se o problema for de mínimo/máximo
\n
• Busca binária — para dados ordenados
\n
• Dois ponteiros — para intervalos
\n
• DFS/BFS — para travessias
\n

Passo 3. Escreva o esqueleto

Não tente otimizar imediatamente. Primeiro uma solução funcional, depois a refatoração.

Análise de um problema real: Two Sum (LeetCode #1)

Clássico. Mesmo que você já tenha resolvido, em C++ ele se revela de forma diferente.

Enunciado: Dado um array de inteiros nums e um inteiro target. Retorne os índices dos dois números cuja soma é igual a target.

Solução ruim (O(n²)):

std::vector<int> twoSum_brute(std::vector<int>& nums, int target) {\n    for (int i = 0; i < nums.size(); ++i) {\n        for (int j = i + 1; j < nums.size(); ++j) {\n            if (nums[i] + nums[j] == target) {\n                return {i, j};\n            }\n        }\n    }\n    return {};\n}\n

Solução boa (O(n) com unordered_map):

#include <unordered_map>\n\nstd::vector<int> twoSum(std::vector<int>& nums, int target) {\n    std::unordered_map<int, int> seen; // valor -> índice