Practice — Your C++ Roadmap

Reaching the practice phase means you stop *learning the language* and start *thinking algorithmically in it*. C++ is a fantastic vehicle here — fast enough that brute force often passes, expressive enough that elegant code is short.

How to Use C++ in Competitive / Interview Settings

A Solid Boilerplate

#include <bits/stdc++.h>
using namespace std;
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    int n; cin >> n;
    vector<int> a(n);
    for (auto& x : a) cin >> x;
    // ...
    return 0;
}

• includes the entire STL (g++ extension) — fine for contests, avoid in production.
• sync_with_stdio(false) + cin.tie(nullptr) makes cin/cout ~10× faster.
• Read everything into vectors; iterate with range-for.

Compilation Flags You Should Know

# Day-to-day
g++ -std=c++20 -O2 -Wall -Wextra solution.cpp -o sol
# Heavy debugging
g++ -std=c++20 -O0 -g -Wall -Wextra -fsanitize=address,undefined solution.cpp -o sol

-fsanitize=address,undefined is the killer flag — catches buffer overruns, use-after-free, signed overflow at runtime.

How to Solve a Problem (5-Step Loop)

1. Read it twice. Note inputs, outputs, constraints. Check if N ≤ 100 (any algorithm), 10⁵ (need O(n log n)), 10⁸ (O(n) only). 2. Solve by hand on a tiny example. What pattern emerges? 3. Pick a data structure. Need fast lookup → unordered_map. Need sorted → set / priority_queue. Stack-like → stack or vector::back(). 4. Write & test on edge cases. Empty input, all same, all different, max constraint. 5. Read the editorial AFTER, even if you solved it. That's where you find the elegant solution and learn new patterns.

The Topic Tree to Master

Phase A — Fundamentals (50 problems)
├── Array / String manipulation
├── Hashmap counting
├── Two pointers
├── Sliding window
└── Prefix sums
Phase B — Sorting & Searching (40 problems)
├── Sort + scan
├── Binary search on sorted array
├── Binary search on the answer
└── Heap / priority_queue (top-k)
Phase C — Recursion & DP (60 problems)
├── Recursion → memoization → DP table
├── Knapsack family
├── LIS / LCS
└── Interval DP
Phase D — Graphs (30 problems)
├── BFS / DFS
├── Topological sort
├── Union-Find (DSU)
└── Dijkstra (priority_queue)
Phase E — Advanced (20 problems)
├── Segment tree / Fenwick (BIT)
├── Trie
├── Math (gcd / sieve / mod inverse)
└── String (KMP / Z / hashing)

Patterns You'll See in 80% of Problems

Two Pointers

int l = 0, r = n - 1;
while (l < r) {
    if (arr[l] + arr[r] == target) return {l, r};
    if (arr[l] + arr[r] < target) ++l;
    else                          --r;
}

Sliding Window

int l = 0, best = 0, sum = 0;
for (int r = 0; r < n; ++r) {
    sum += arr[r];
    while (sum > limit) sum -= arr[l++];
    best = max(best, r - l + 1);
}

Hashmap Counting

unordered_map<int, int> seen;
for (int i = 0; i < n; ++i) {
    int need = target - arr[i];
    if (seen.count(need)) return {seen[need], i};
    seen[arr[i]] = i;
}

BFS

queue<pair<int,int>> q;
vector<vector<bool>> visited(R, vector<bool>(C, false));
q.push({sr, sc}); visited[sr][sc] = true;
const int dr[] = {-1, 1, 0, 0};
const int dc[] = { 0, 0,-1, 1};
while (!q.empty()) {
    auto [r, c] = q.front(); q.pop();
    for (int d = 0; d < 4; ++d) {
        int nr = r + dr[d], nc = c + dc[d];
        if (nr < 0 
nr >= R
nc < 0
 
nc >= C) continue;
        if (visited[nr][nc]) continue;
        visited[nr][nc] = true;
        q.push({nr, nc});
    }
}

DFS via Recursion

function<void(int)> dfs = [&](int u) {
    visited[u] = true;
    for (int v : adj[u]) if (!visited[v]) dfs(v);
};

Dijkstra (priority_queue)

priority_queue<pair<long,int>, vector<pair<long,int>>, greater<>> pq;
vector<long> dist(n, LLONG_MAX);
dist[src] = 0;
pq.push({0, src});
while (!pq.empty()) {
    auto [d, u] = pq.top(); pq.pop();
    if (d > dist[u]) continue;
    for (auto [v, w] : adj[u]) {
        if (dist[u] + w < dist[v]) {
            dist[v] = dist[u] + w;
            pq.push({dist[v], v});
        }
    }
}

DP — Memoization Skeleton

vector<int> memo(n + 1, -1);
function<int(int)> dp = [&](int i) -> int {
    if (i <= 1) return i;
    if (memo[i] != -1) return memo[i];
    return memo[i] = dp(i - 1) + dp(i - 2);
};

Suggested Books / References

Build a Portfolio As You Learn

• Start a public GitHub repo: leetcode-solutions. One file per problem.
• README each folder by topic.
• After every batch of 10 problems, write a short markdown "what I learned".
• After 100 problems, you'll have an interview-quality portfolio without trying.

When You're Ready to Specialise

Final Loop: Solve · Read Editorial · Re-solve

1. Solve a problem on your own. 2. Read the editorial — even if you solved it. 3. Solve the same problem again, the editorial's way.

That third step is where the patterns lodge. Skip it and you re-invent the wheel forever.

You finished the C++ track. Build something — a small game, a CLI tool, an HTTP server. Real projects compress months of practice into weeks. Good luck. 🚀