Classic C++ pitfalls in contests and coding rounds

Why a pitfalls list?

C++ trusts the programmer and rarely stops you at run time. A small slip often gives a plausible but wrong answer, not a crash. Checking this list before submitting catches most of these silent errors.

1. Integer overflow

int a = 100000, b = 100000;
long long bad = a * b;          // overflow: a * b is computed in int first
long long good = 1LL * a * b;   // 10000000000
// Sum of 2 × 10^5 values up to 10^9 needs long long (up to 2 × 10^14).

2. Unsigned size()

vector<int> v;                       // empty
for (int i = 0; i < v.size() - 1; ++i) { }   // v.size() - 1 wraps to a huge number!
for (int i = 0; i + 1 < (int)v.size(); ++i) { }   // safe

3. Uninitialised variables and arrays

Local variables are not zeroed. int cnt; cnt++; is undefined. Global arrays ARE zero-initialised, which is why contest code often declares big arrays globally. When you reuse an array across test cases, reset it for each test, or you get WA on test case 2 onwards.

4. Out-of-bounds access

a[n] on an array of size n reads past the end silently. Off-by-one errors in loops and DP tables (dp[i - 1] when i is 0) are common. During practice, compile with -fsanitize=address,undefined -D_GLIBCXX_DEBUG to catch them with a clear message.

5. Slow input and output

• Use ios::sync_with_stdio(false); cin.tie(nullptr); at the start of main.
• Print '\n', not endl, inside loops: endl flushes every line, which can turn a 0.2 s program into a TLE with 10^6 lines of output.
• Do not mix printf/scanf with cin/cout after turning off sync.

6. Deep recursion

A DFS on a path-shaped graph with 10^5 or 10^6 nodes recurses that deep. With small stacks (1 MB on Windows by default) this crashes as a Runtime Error. Use an explicit stack (iterative DFS) or BFS when the depth can be large.

7. Floating-point comparison

double x = 0.1 + 0.2;
if (x == 0.3) { }                       // false!
const double EPS = 1e-9;
if (fabs(x - 0.3) < EPS) { }            // true
// Better: avoid doubles when you can (use integers, e.g. paise, or compare a*d with b*c for fractions).

8. Hash maps under attack and other traps

• On Codeforces, unordered_map with int keys can be made slow by anti-hash tests; use map or a custom hash with a random seed if you see TLE.
• Using map[key] to "check" inserts the key (and changes size()).
• Modular arithmetic: (a - b) % MOD can be negative in C++; write ((a - b) % MOD + MOD) % MOD.
• Integer division rounds toward zero: -7 / 2 is -3, not -4.
• 1 << 40 overflows int; write 1LL << 40.