Blind 75 in C++: STL Tools, Idioms and Pitfalls by Category

The Blind 75 is the list a self-described Facebook tech lead posted on Blind on December 30, 2018: 75 LeetCode problems in ten groups, which he said he distilled from the 400 to 500 problems of his own last job hunt. C++ has every structure the list needs in its standard library, including a heap and an ordered map, so the work is choosing the right container for each group and avoiding the language's quiet failure modes. This page maps the original ten groups to STL tools, goes through the problems where C++ needs care and gives a six-week order. For the list itself, see our Blind 75 guide; for the longer list in the same language, NeetCode 150 in C++.

The original ten groups and their STL tools

Blind 75 has 19 easy, 49 medium and 7 hard problems by LeetCode's current labels, and six of them need LeetCode Premium. The original post groups them as below. Merge K Sorted Lists appears under both Linked List and Heap, which is why the groups add up to 76. Counts were read from each list's own site data on November 12, 2026. Lists are edited from time to time, so numbers can drift.

Group by group in C++

• Array: Two Sum is one pass with unordered_map<int, int>, checking for target - x before inserting x so an element never pairs with itself. Maximum Product Subarray keeps the current maximum and minimum and calls std::swap on them when the number is negative. In 3Sum, sort first, then skip duplicates with while (l < r && nums[l] == nums[l - 1]) ++l;.
• Binary: Counting Bits fills vector<int> ans(n + 1) with ans[i] = ans[i >> 1] + (i & 1); Missing Number XORs every index with every value. LeetCode's current Number of 1 Bits and Reverse Bits take an int, and Reverse Bits keeps n even and below 2 to the power 31, so the reversed value never sets the sign bit. If an interviewer uses the older uint32_t signature, shift an unsigned value.
• Dynamic programming: Coin Change uses vector<int> dp(amount + 1, amount + 1), an 'infinity' that cannot overflow when you add one. The O(n log n) Longest Increasing Subsequence keeps a vector of tails and overwrites *lower_bound(tails.begin(), tails.end(), x). Word Break compares in place with s.compare(i, w.size(), w) == 0 instead of building substrings. House Robber II runs the House Robber loop twice over index ranges rather than copied vectors.
• Graph: Number of Islands receives vector<vector<char>>, so compare with '1', not 1. Clone Graph records each copy in unordered_map<Node*, Node*> before recursing, so cycles stop. Graph Valid Tree and Number of Connected Components (both Premium) use union-find over a parent vector set up with iota(parent.begin(), parent.end(), 0). Alien Dictionary (Premium) must return an empty string when a longer word comes before its own prefix.
• Interval: plain sort on vector<vector<int>> already orders by start, then end, because vectors compare lexicographically. When Non-overlapping Intervals sorts by end, make the lambda take const vector<int>&; by-value parameters copy two vectors on every comparison. Meeting Rooms II (Premium) sorts start and end times into two vectors and sweeps them.
• Linked List: ListNode dummy(0); on the stack, then return dummy.next;. Reorder List is three steps: find the middle with slow and fast pointers, reverse the second half, interleave. For Merge K Sorted Lists, auto cmp = [](ListNode* a, ListNode* b) { return a->val > b->val; }; passed as decltype(cmp) turns the default max-heap into a min-heap.
• Matrix: Rotate Image clockwise is reverse(matrix.begin(), matrix.end()) followed by swapping matrix[i][j] with matrix[j][i] for j > i. Set Matrix Zeroes uses the first row and column as markers plus one flag. Word Search marks a cell with '#' and restores it after the recursive call.
• String: Longest Substring Without Repeating Characters keeps array<int, 128> last filled with -1. Valid Anagram compares two array<int, 26> counts with ==. Group Anagrams can key each word by string(26, 0) counts, which fit in a char because words are at most 100 letters. Encode and Decode Strings (Premium) writes to_string(s.size()) + '#' + s and reads lengths back with stoi.
• Tree: Validate Binary Search Tree has node values across the whole int range, so pass long long bounds or pointer bounds, not INT_MIN and INT_MAX. Kth Smallest Element is an iterative inorder walk with stack<TreeNode*> that stops at k. Serialize and Deserialize reads tokens with getline(in, tok, ','). In Word Search II, clear a word from its trie node once found so it is reported once.
• Heap: Top K Frequent Elements asks for better than O(n log n), so count with unordered_map and use nth_element or frequency buckets instead of a full sort. Find Median from Data Stream keeps priority_queue<int> for the lower half and a greater<int> heap for the upper half, and returns (lo.top() + (double)hi.top()) / 2.

Pitfalls that are easy to miss

• vector<bool> is not a normal vector: it packs bits and returns proxy objects, so auto& seen = visited[r][c]; does not compile. For the two visited grids in Pacific Atlantic Water Flow, vector<vector<char>> behaves like an ordinary array.
• isalnum and tolower with plain char: passing a negative char value is undefined behaviour. Valid Palindrome inputs are printable ASCII, but writing isalnum((unsigned char)ch) shows you know the rule.
• Shifting negative numbers: Sum of Two Integers takes values from -1,000 to 1,000, and the carry loop shifts (a & b) << 1. Left-shifting a negative int was undefined before C++20; LeetCode compiles as C++23, where it is defined, but (unsigned)(a & b) << 1 is safe under any compiler an interviewer uses.
• Dangling string_view: a view into a temporary sorted string, used as a map key in Group Anagrams, points at freed memory. Use string keys unless the viewed strings outlive the map.
• Binomial overflow: Unique Paths promises an answer of at most 2 times 10 to the power 9, which fits in int, but the combinatorial formula's intermediate products do not. Use the one-row DP, or long long with ans = ans * (m - 1 + i) / i, which stays exact.

Writing C++ outside LeetCode

LeetCode compiles C++ with Clang 19 using the C++23 standard and the GCC 14 standard library, at -O2 with AddressSanitizer, and includes most standard headers for you, as LeetCode's help page on language environments listed it on November 12, 2026. Interview editors are less generous, so know the real headers: <vector>, <string>, <unordered_map>, <unordered_set>, <queue>, <stack>, <algorithm>, <numeric> for iota, <array>, <sstream> and <climits>. #include <bits/stdc++.h> is a GCC library header; libc++, the library Apple's default toolchain uses, does not have it, so it fails on a standard Mac setup. Ask which standard the editor uses before relying on C++20 features such as std::popcount, contains or captureless lambdas as default-constructible comparators.

A six-week order

1. Week 1: Array (10) and Binary (5), 15 problems; get fast at unordered_map and bit loops.
2. Week 2: String (10) and Matrix (4), 14 problems; fixed-size count arrays and in-place edits.
3. Week 3: Linked List (6) and Interval (5), 11 problems; dummy nodes and comparators.
4. Week 4: Tree (14); recursive and iterative traversals, the trie and serialization.
5. Week 5: Graph (8) plus Top K Frequent Elements and Find Median from Data Stream, 10 problems.
6. Week 6: Dynamic programming (11), then redo every problem you failed.

The same list with Python's tools is in Blind 75 in Python. After Blind 75, the NeetCode 150 plan for C++ linked above adds 75 more problems with the same STL habits.

Turning a list into interview skill

Any list only helps if the practice transfers to problems you have not seen. These habits make the difference:

1. Time-box every attempt: about 25 minutes for a medium before you read a solution.
2. Keep a log with one line per problem: the pattern, the key idea and the complexity.
3. Redo failed problems after three days, a week and three weeks, without looking at your old code.
4. Explain your approach out loud before and while you code, as you would to an interviewer.
5. In the last two weeks, switch to unseen problems without topic labels.

The patterns most lists are built on are explained in array and string patterns and tree, graph and recursion patterns.

Where CoPilot Interview fits

Finishing a list is not the same as passing an interview: interviewers score how you explain your approach, your trade-offs and your complexity out loud. CoPilot Interview is an AI interview assistant; its free AI mock interview asks coding questions, listens to your spoken explanation and scores it out of ten with a model answer, which is the part a problem list cannot train. The free plan gives 15 minutes a day of live help in sessions of up to 15 minutes, with AI mock interviews included. Online assessments and live coding rounds usually forbid outside help, so practice now and follow your employer's rules on the day.

Disclosure: CoPilot Interview is our product, so weigh what we say about it accordingly.

Frequently asked questions

Is C++ a good choice for Blind 75?

Yes. The STL has hash maps, heaps and ordered maps, and solutions run fast. Code is longer than Python, so practise typing the common declarations until they are automatic.

How are the Blind 75 problems grouped?

The original post uses ten groups: Array, Binary, Dynamic Programming, Graph, Interval, Linked List, Matrix, String, Tree and Heap. Merge K Sorted Lists is listed under both Linked List and Heap.

How do I write a min-heap of ListNode pointers in C++?

Define a lambda that returns a->val > b->val and declare priority_queue<ListNode*, vector<ListNode*>, decltype(cmp)> pq(cmp). The greater-than comparison makes the smallest value come out first.

Can I use bits/stdc++.h in a C++ interview?

Only if the editor uses GCC's standard library. It is not part of libc++, so write the individual headers unless you know the setup.