// Week 1: You get WA due to integer overflow
// You fix it and move on

// Week 3: You forget about integer overflow
// You get WA again, spend 30 minutes debugging

// Week 5: Same mistake, same frustration
// You feel like you're not improving

// THE FIX: Write it down. Review it. Never forget.

## Mistake Entry #[number]

**Date:** YYYY-MM-DD
**Problem:** [Problem Name + Link]
**Mistake Category:** [Syntax / Logic / Implementation / Edge Case / Careless]

### What Happened
[Describe the mistake in 1-2 sentences]

### The Code That Was Wrong
```cpp
// Paste the buggy code here

// Paste the fixed code here

### Option 2: Simple Spreadsheet

| Date | Problem | Category | Mistake | Fix | Prevention | Tags |
|------|---------|----------|---------|-----|------------|------|
| 2024-01-15 | CF 1234A | Overflow | Used int for n*n | Cast to ll | Always ll for products | #overflow |
| 2024-01-16 | CF 1235B | Edge | Empty string | Check s.empty() | Test n=0 first | #edge #string |

### Option 3: VS Code Snippets

Create a snippets file that grows from your mistakes:

```json
{
  "Safe Modular Add": {
    "prefix": "modadd",
    "body": [
      "((${1:a} % MOD) + (${2:b} % MOD) + MOD) % MOD"
    ],
    "description": "Mistake #14: Negative mod issue"
  },
  "Binary Search Template": {
    "prefix": "binsearch",
    "body": [
      "int lo = 0, hi = n - 1;",
      "while (lo < hi) {",
      "    int mid = lo + (hi - lo) / 2;",
      "    if (${1:condition}) hi = mid;",
      "    else lo = mid + 1;",
      "}",
      "// Answer is at index lo"
    ],
    "description": "Mistake #23: Binary search off-by-one"
  }
}

// MISTAKE: Using int for large products
int n = 1e5;
int result = n * n;  // OVERFLOW! 

// FIX: Always use long long for products
long long result = (long long)n * n;  // Correct

// MISTAKE: Wrong loop bounds
for (int i = 0; i <= n; i++) {
    arr[i] = 0;  // Access arr[n] - out of bounds!
}

// FIX: Use < n for 0-indexed arrays
for (int i = 0; i < n; i++) {
    arr[i] = 0;
}

// MISTAKE: Negative numbers in modulo
int x = -5 % 3;  // Result is -2 in C++!

// FIX: Safe modulo
int safe_mod(int x, int m) {
    return ((x % m) + m) % m;
}

// MISTAKE: Infinite loop
while (lo <= hi) {
    int mid = (lo + hi) / 2;  // Can overflow!
    if (arr[mid] < target) lo = mid;  // INFINITE LOOP!
}

// FIX: Correct binary search
while (lo < hi) {
    int mid = lo + (hi - lo) / 2;  // Safe from overflow
    if (arr[mid] < target) lo = mid + 1;
    else hi = mid;
}

// MISTAKE: Not resetting visited array between test cases
bool visited[N];

void solve() {
    // visited still has values from previous test!
}

// FIX: Reset at start of each test case
void solve() {
    memset(visited, false, sizeof(visited));
    // or
    fill(visited, visited + n, false);
}

// MISTAKE: Using cin >> s for strings with spaces
string s;
cin >> s;  // Only reads until first space!

// FIX: Use getline for full line
getline(cin, s);

// WATCH OUT: After cin >> n, you need cin.ignore()
int n; cin >> n;
cin.ignore();
getline(cin, s);

// MISTAKE: Assuming global arrays are initialized
int dp[N][M];  // Local: RANDOM values!

// FIX: Always initialize
int dp[N][M] = {};  // All zeros

// or
memset(dp, 0, sizeof(dp));
memset(dp, -1, sizeof(dp));  // Works for -1 and 0 only!

// For other values, use fill
fill(&dp[0][0], &dp[0][0] + N*M, INF);

☐ Does this problem involve large numbers? → Use long long
☐ Am I working with arrays? → Double-check bounds
☐ Is there modular arithmetic? → Use safe_mod function
☐ Multiple test cases? → Reset all global variables
☐ String input after integers? → cin.ignore() before getline
☐ Binary search needed? → Use tested template

☐ All variables use correct data types
☐ Array indices are within bounds
☐ Edge cases handled (n=0, n=1, empty input)
☐ Output format matches exactly (spaces, newlines)
☐ All test cases produce correct output
☐ No debug statements left in code (cerr, cout)

// Template: Safe binary search (lower bound)
int binary_search_lower(vector<int>& arr, int target) {
    int lo = 0, hi = arr.size();  // hi = size, not size-1
    while (lo < hi) {
        int mid = lo + (hi - lo) / 2;  // Prevent overflow
        if (arr[mid] < target) lo = mid + 1;
        else hi = mid;
    }
    return lo;  // First element >= target
}

// Common mistake: Using <= in while condition with this template
// Common mistake: Using (lo + hi) / 2 → can overflow
// Common mistake: lo = mid instead of lo = mid + 1 → infinite loop

// Template: Safe DP initialization
const long long INF = 1e18;  // Not INT_MAX (adding to it overflows)
vector<vector<long long>> dp(n + 1, vector<long long>(m + 1, INF));

// Common mistakes:
// 1. Using INT_MAX → addition causes overflow
// 2. Wrong dimension order
// 3. Not handling base cases
// 4. Wrong recurrence order (depends on what values)

// Template: Safe BFS
void bfs(int start) {
    queue<int> q;
    vector<bool> visited(n + 1, false);  // Always declare locally!
    
    q.push(start);
    visited[start] = true;  // Mark BEFORE pushing
    
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        
        for (int v : adj[u]) {
            if (!visited[v]) {
                visited[v] = true;  // Mark BEFORE pushing
                q.push(v);
            }
        }
    }
}

// Common mistakes:
// 1. Marking visited AFTER pushing → duplicates in queue
// 2. Not resetting visited between test cases
// 3. Wrong graph size (1-indexed vs 0-indexed)

FRONT: Integer overflow in multiplication
BACK: Always cast at least one operand to long long
       (long long)a * b NOT (long long)(a * b)

MY "NEVER AGAIN" LIST:

1. Integer overflow in n*n → ALWAYS use long long
2. Forgot to reset visited[] → Reset at start of solve()
3. Wrong binary search termination → Use tested template
4. Modulo with negative numbers → Use safe_mod()
5. Reading string after int → Always cin.ignore()