LeetCode पर C++: समस्याओं को कैसे हल करें और कौशल को कैसे बढ़ाएं

C++ LeetCode के लिए आदर्श भाषा क्यों है (और कैसे असफल न हों)

यदि आपने LeetCode खोला और सोचा: "मैं सब कुछ Python में लिखूंगा, वहाँ संक्षिप्त है", - रुकिए। कठोर विकास और एल्गोरिदम की वास्तविक समझ के लिए C++ किसी भी अन्य भाषा से बेहतर है। क्यों? क्योंकि यह आपको मेमोरी, गति और कार्यान्वयन की बारीकियों के बारे में सोचने पर मजबूर करता है। यह समझे बिना कोई "जादुई" sort() नहीं है कि यह कैसे काम करता है।

इस लेख में हम केवल समस्याओं को सूचीबद्ध नहीं करेंगे। हम दिखाएंगे कि LeetCode समस्याओं को हल करते समय C++ में कैसे सोचें, वास्तव में किन डेटा संरचनाओं की आवश्यकता है, और तैयार कोड टेम्पलेट देंगे। आप जानेंगे कि std::vector आपका सबसे अच्छा दोस्त क्यों है, और std::unordered_map एक गुप्त हथियार क्यों है।

तैयार हैं? चलिए शुरू करते हैं।

LeetCode के लिए शीर्ष 5 C++ डेटा संरचनाएँ

समस्याओं को हल करने में कूदने से पहले, एक "शस्त्रागार" इकट्ठा करना होगा। यहाँ वह है जो वास्तव में 90% मामलों में काम आएगा:

\n
• std::vector - डायनेमिक ऐरे। अनुक्रमों, अंतरालों, मैट्रिक्स से संबंधित सब कुछ।
\n
• std::unordered_map - हैश टेबल। गणना, डुप्लिकेट खोज, दो-योग समस्याओं के लिए।
\n
• std::set / std::unordered_set - सेट। जब किसी तत्व की उपस्थिति की तुरंत जाँच करनी हो।
\n
• std::stack / std::queue / std::deque - ट्रैवर्सल, ब्रैकेट अनुक्रम, BFS/DFS के लिए।
\n
• std::pair - जोड़े को संग्रहीत करने के लिए अपरिहार्य (उदाहरण के लिए, निर्देशांक + मान)।
\n

यहाँ एक उदाहरण है कि हैश टेबल का उपयोग करके आवृत्ति विश्लेषण के लिए मूल रैपर कैसा दिखता है:

#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

देखा? न्यूनतम कोड, अधिकतम लाभ।

समस्या का सामना कैसे करें: C++ के लिए चेकलिस्ट

शुरुआती की गलती तुरंत कोड लिखना है। सही तरीका पहले डेटा संरचना को समझना है। C++ के लिए यह महत्वपूर्ण है, क्योंकि कंटेनर का गलत चुनाव आपको Time Limit Exceeded (TLE) दे सकता है।

चरण 1. समस्या के प्रकार की पहचान करें

\n
• ऐरे / स्ट्रिंग्स → vector, string
\n
• डुप्लिकेट खोज → unordered_set
\n
• डायनेमिक प्रोग्रामिंग → vector<vector<int>>
\n
• ग्राफ → vector<vector<int>> या unordered_map<int, vector<int>>
\n

चरण 2. एल्गोरिदमिक प्रतिमान चुनें

\n
• ग्रीडी एल्गोरिदम - यदि समस्या न्यूनतम/अधिकतम के बारे में है
\n
• बाइनरी सर्च - सॉर्ट किए गए डेटा के लिए
\n
• दो पॉइंटर्स - अंतराल के लिए
\n
• DFS/BFS - ट्रैवर्सल के लिए
\n

चरण 3. स्केलेटन लिखें

तुरंत अनुकूलित करने का प्रयास न करें। पहले एक काम करने वाला समाधान, फिर रिफैक्टरिंग।

वास्तविक समस्या का विश्लेषण: Two Sum (LeetCode #1)

क्लासिक। भले ही आपने इसे हल किया हो, C++ में यह अलग तरह से सामने आता है।

शर्त: पूर्णांकों की एक सूची nums और एक पूर्णांक target दिया गया है। दो संख्याओं के सूचकांक लौटाएँ जिनका योग target के बराबर है।

खराब समाधान (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

अच्छा समाधान (O(n) unordered_map के साथ):

#include <unordered_map>\n\nstd::vector<int> twoSum(std::vector<int>& nums, int target) {\n    std::unordered_map<int, int> seen; // मान -> सूचकांक