C++ sur LeetCode : comment résoudre des problèmes et améliorer ses compétences

Pourquoi le C++ est le langage idéal pour LeetCode (et comment ne pas échouer)

Si vous avez ouvert LeetCode et pensé : « Je vais tout écrire en Python, c'est concis », — stop. Pour une progression intensive et une véritable compréhension des algorithmes, le C++ surpasse tout autre langage. Pourquoi ? Parce qu'il vous oblige à réfléchir à la mémoire, à la vitesse et aux subtilités d'implémentation. Pas de sort() « magique » sans comprendre son fonctionnement.

Dans cet article, nous ne nous contenterons pas de lister des problèmes. Nous montrerons comment penser en C++ lors de la résolution de problèmes LeetCode, quelles structures de données sont réellement nécessaires, et nous fournirons des modèles de code prêts à l'emploi. Vous apprendrez pourquoi std::vector est votre meilleur ami, et std::unordered_map votre arme secrète.

Prêt ? C'est parti.

Top 5 des structures de données C++ pour LeetCode

Avant de vous lancer dans la résolution de problèmes, il faut constituer votre « arsenal ». Voici ce qui sera vraiment utile dans 90% des cas :

\n
• std::vector — tableau dynamique. Tout ce qui concerne les séquences, les intervalles, les matrices.
\n
• std::unordered_map — table de hachage. Pour les comptages, la recherche de doublons, les problèmes de somme de deux nombres.
\n
• std::set / std::unordered_set — ensembles. Quand il faut vérifier rapidement la présence d'un élément.
\n
• std::stack / std::queue / std::deque — pour les parcours, les séquences de parenthèses, BFS/DFS.
\n
• std::pair — indispensable pour stocker des paires (par exemple, coordonnées + valeur).
\n

Voici un exemple d'enveloppe de base pour l'analyse fréquentielle utilisant une table de hachage :

#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

Vous voyez ? Un minimum de code, un maximum d'efficacité.

Comment aborder un problème : checklist pour le C++

L'erreur du débutant est d'écrire le code immédiatement. La bonne approche est d'abord de comprendre la structure de données. Pour le C++, c'est crucial car un mauvais choix de conteneur peut vous coûter un Time Limit Exceeded (TLE).

Étape 1. Déterminez le type de problème

\n
• Tableaux / chaînes → vector, string
\n
• Recherche de doublons → unordered_set
\n
• Programmation dynamique → vector<vector<int>>
\n
• Graphes → vector<vector<int>> ou unordered_map<int, vector<int>>
\n

Étape 2. Choisissez le paradigme algorithmique

\n
• Algorithme glouton — si le problème concerne un minimum/maximum
\n
• Recherche binaire — pour les données triées
\n
• Deux pointeurs — pour les intervalles
\n
• DFS/BFS — pour les parcours
\n

Étape 3. Écrivez le squelette

N'essayez pas d'optimiser tout de suite. D'abord une solution fonctionnelle, ensuite le refactoring.

Analyse d'un problème réel : Two Sum (LeetCode #1)

Un classique. Même si vous l'avez déjà résolu, en C++ il se révèle différemment.

Énoncé : Soit un tableau d'entiers nums et un entier target. Retournez les indices des deux nombres dont la somme est égale à target.

Mauvaise solution (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

Bonne solution (O(n) avec unordered_map) :

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