Modern C++ for LeetCode 🧑‍💻🚀

C++ has come a long way since its early days, and the "modern" C++ (starting with C++11 and beyond) offers a host of features that make solving problems on platforms like LeetCode way more efficient and enjoyable. Forget manual memory management, verbose loops, and cryptic pointer arithmetic! Modern C++ gives us tools like std::unordered_map, range-based loops, and lambda functions that let us focus more on solving problems and less on boilerplate code. Let's dive into some common algorithmic patterns and see how modern C++ makes them awesome! 💡

1. Hashmaps (using std::unordered_map) 🗺️

In old-school C, implementing a hash map meant writing your own data structure with hashing functions, collision handling, and all that jazz. Not anymore! Modern C++ gives us std::unordered_map, which is fast and easy to use.

Example: Two Sum (LeetCode #1)

#include <unordered_map>
#include <vector>

std::vector<int> twoSum(const std::vector<int>& nums, int target) {
    std::unordered_map<int, int> map; // Key: number, Value: index
    for (int i = 0; i < nums.size(); ++i) {
        int complement = target - nums[i];
        if (map.count(complement)) { // Check if complement exists in map
            return {map[complement], i};
        }
        map[nums[i]] = i;
    }
    return {};
}

Why it’s awesome:

Fast lookups: Average O(1) for key-value lookups.
No need to write custom hash functions or deal with memory allocation.

2. Binary Search (using std::binary_search) 🔍

Binary search is a classic algorithm, but in C++, we get helper functions from the header that make life easier.

Example: Search Insert Position (LeetCode #35)

#include <vector>
#include <algorithm>

int searchInsert(const std::vector<int>& nums, int target) {
    return std::lower_bound(nums.begin(), nums.end(), target) - nums.begin();
}

Why it’s awesome:

std::lower_bound: Finds the first element not less than the target.
Clean and concise: No more manually tracking low, high, and mid pointers.

3. Quicksort (using std::sort) ⚡

While implementing quicksort manually is a fun exercise, it's not something you want to do in every LeetCode problem. Modern C++ has std::sort, which is highly optimized.

Example: Sort an Array (LeetCode #912)

#include <vector>
#include <algorithm>

std::vector<int> sortArray(std::vector<int>& nums) {
    std::sort(nums.begin(), nums.end());
    return nums;
}

Why it’s awesome:

Under the hood, std::sort uses a hybrid of quicksort, heapsort, and insertion sort.
Efficient and portable: Optimized for real-world performance.

4. Two Pointer Technique (Range-based Loops + std::string Utilities) 🏃‍♂️🏃‍♀️

The two-pointer technique is perfect for problems involving arrays or strings. Modern C++ makes it easier with range-based loops and helper functions for strings.

Example: Valid Palindrome (LeetCode #125)

#include <string>
#include <cctype>

bool isPalindrome(const std::string& s) {
    int left = 0, right = s.size() - 1;
    while (left < right) {
        while (left < right && !std::isalnum(s[left])) ++left;
        while (left < right && !std::isalnum(s[right])) --right;
        if (std::tolower(s[left]) != std::tolower(s[right])) return false;
        ++left; --right;
    }
    return true;
}

Why it’s awesome:

std::isalnum and std::tolower: Built-in utilities to handle character checks.
No need for manual ASCII checks!

5. Graphs (using std::queue and std::vector) 🌉

Graph problems often involve BFS or DFS. Modern C++ shines here with containers like std::vector for adjacency lists and std::queue for BFS.

Example: Number of Islands (LeetCode #200)

#include <vector>
#include <queue>

void bfs(std::vector<std::vector<char>>& grid, int r, int c) {
    std::queue<std::pair<int, int>> q;
    q.push({r, c});
    grid[r][c] = '0'; // Mark visited
    std::vector<std::pair<int, int>> directions = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};

    while (!q.empty()) {
        auto [row, col] = q.front(); q.pop();
        for (const auto& [dr, dc] : directions) {
            int nr = row + dr, nc = col + dc;
            if (nr >= 0 && nr < grid.size() && nc >= 0 && nc < grid[0].size() && grid[nr][nc] == '1') {
                q.push({nr, nc});
                grid[nr][nc] = '0';
            }
        }
    }
}

int numIslands(std::vector<std::vector<char>>& grid) {
    int count = 0;
    for (int r = 0; r < grid.size(); ++r) {
        for (int c = 0; c < grid[0].size(); ++c) {
            if (grid[r][c] == '1') {
                ++count;
                bfs(grid, r, c);
            }
        }
    }
    return count;
}

Why it’s awesome:

std::queue: Great for BFS, abstracts away all the pointer/memory headache.

Pair destructuring with [row, col]: Clean and readable code.

Conclusion 🎉

Modern C++ takes away much of the boilerplate coding and error-prone manual work that was once necessary. Whether it's hash maps, sorting, or handling strings and graphs, these new features let you focus on problem-solving instead of fighting the language.

TL;DR of Modern C++ Features:

• std::unordered_map: O(1) lookups!
• std::lower_bound and std::sort: Simplifies search and sorting.
• Range-based loops, lambdas, and std::string utilities: Cleaner, safer, and faster code.
• std::vector and std::queue: Perfect for graphs, dynamic arrays, and more.

Now grab your favorite cup of coffee ☕ and start smashing those LeetCode problems!