Common Edge Cases Checklist

1
#include <bits/stdc++.h>
2
using namespace std;
3
4
// This program builds prefix sums for an array and answers [l, r] inclusive queries.
5
// It demonstrates:
6
// - Handling n = 0 and n = 1
7
// - Using long long to avoid overflow in sums
8
// - Converting 1-indexed input queries to internal 1-indexed prefix scheme
9
// - Guarding l > r by swapping
10
// - Inclusive vs exclusive care via pref[r] - pref[l-1]
11
12
int main() {
13
    ios::sync_with_stdio(false);
14
    cin.tie(nullptr);
15
16
    int n, q;
17
    if (!(cin >> n >> q)) return 0; // robust: exit on bad input
18
19
    vector<long long> a(max(0, n));
20
    for (int i = 0; i < n; ++i) cin >> a[i];
21
22
    // Prefix sums in 1-indexed style: pref[0] = 0, pref[i] = sum of first i elements.
23
    vector<long long> pref(n + 1, 0);
24
    for (int i = 1; i <= n; ++i) {
25
        pref[i] = pref[i - 1] + a[i - 1]; // use long long to avoid overflow
26
    }
27
28
    while (q--) {
29
        long long l, r; // accept large indices if problem allows up to 1e9 (we will clamp)
30
        cin >> l >> r;  
31
        if (!cin) break;
32
33
        // Typical problems guarantee valid 1 <= l <= r <= n.
34
        // If unsure, you can defensively normalize:
35
        if (l > r) swap(l, r);
36
        l = max<long long>(1, min<long long>(l, n));
37
        r = max<long long>(0, min<long long>(r, n));
38
39
        long long ans = 0;
40
        if (l <= r && n > 0) {
41
            // Inclusive range sum [l, r]: pref[r] - pref[l-1]
42
            ans = pref[r] - pref[l - 1];
43
        }
44
        cout << ans << '\n';
45
    }
46
    return 0;
47
}
48

1
#include <bits/stdc++.h>
2
using namespace std;
3
4
// Normalize x into [0, m-1] for m > 0
5
long long mod_norm(long long x, long long m) {
6
    long long r = x % m; // can be negative in C++ if x < 0
7
    if (r < 0) r += m;   // one add is enough because |r| < m
8
    return r;
9
}
10
11
// Safe multiply modulo using 128-bit intermediate
12
long long mul_mod(long long a, long long b, long long m) {
13
    __int128 prod = (__int128)a * (__int128)b;
14
    prod %= m;
15
    return (long long)prod;
16
}
17
18
// Fast exponentiation modulo m
19
long long pow_mod(long long a, long long e, long long m) {
20
    a = mod_norm(a, m);
21
    long long res = 1 % m;
22
    while (e > 0) {
23
        if (e & 1LL) res = mul_mod(res, a, m);
24
        a = mul_mod(a, a, m);
25
        e >>= 1LL;
26
    }
27
    return res;
28
}
29
30
// Integer floor division for any signs (returns floor(a/b)).
31
long long floor_div(long long a, long long b) {
32
    assert(b != 0);
33
    if (b < 0) return floor_div(-a, -b);
34
    if (a >= 0) return a / b; // trunc == floor when a >= 0 and b > 0
35
    // a < 0, b > 0
36
    // floor(a/b) = -ceil((-a)/b)
37
    return - ((-a + b - 1) / b);
38
}
39
40
// Integer ceil division for any signs (returns ceil(a/b)).
41
long long ceil_div(long long a, long long b) {
42
    assert(b != 0);
43
    if (b < 0) return ceil_div(-a, -b);
44
    if (a >= 0) return (a + b - 1) / b;
45
    // a < 0, b > 0
46
    // ceil(a/b) = -floor((-a)/b)
47
    return - ((-a) / b);
48
}
49
50
int main() {
51
    ios::sync_with_stdio(false);
52
    cin.tie(nullptr);
53
54
    long long a, b, m, x, y;
55
    // Demo input (you can pipe your own): a, b, m, x, y
56
    if (!(cin >> a >> b >> m >> x >> y)) return 0;
57
58
    cout << "mod_norm(a, m) = " << mod_norm(a, m) << '\n';
59
    cout << "(a * b) % m (safe) = " << mul_mod(a, b, m) << '\n';
60
    cout << "pow_mod(x, y, m) = " << pow_mod(x, y, m) << '\n';
61
62
    // Division corner cases
63
    long long p, q; cin >> p >> q; // try negatives like p = -3, q = 2
64
    cout << "floor_div(p, q) = " << floor_div(p, q) << '\n';
65
    cout << "ceil_div(p, q) = " << ceil_div(p, q) << '\n';
66
    cout << "C++ trunc p/q = " << (p / q) << " (trunc toward zero)\n";
67
68
    return 0;
69
}
70

1
#include <bits/stdc++.h>
2
using namespace std;
3
4
int main() {
5
    ios::sync_with_stdio(false);
6
    cin.tie(nullptr);
7
8
    int n, m;
9
    if (!(cin >> n >> m)) return 0;
10
    vector<vector<int>> adj(n);
11
12
    for (int i = 0; i < m; ++i) {
13
        int u, v; cin >> u >> v; // assume 1-indexed input as in many problems
14
        if (n == 0) continue;    // guard: no vertices
15
        // Convert to 0-indexed and clamp to [0, n-1] if needed
16
        --u; --v;
17
        if (u < 0 || u >= n || v < 0 || v >= n) continue; // defensive
18
        // Add edges (self-loops and multi-edges are okay)
19
        adj[u].push_back(v);
20
        adj[v].push_back(u);
21
    }
22
23
    vector<char> vis(n, 0);
24
    int components = 0;
25
26
    for (int s = 0; s < n; ++s) {
27
        if (vis[s]) continue;
28
        ++components; // new component discovered
29
        queue<int> q; q.push(s); vis[s] = 1;
30
        while (!q.empty()) {
31
            int u = q.front(); q.pop();
32
            for (int v : adj[u]) {
33
                if (!vis[v]) {
34
                    vis[v] = 1;
35
                    q.push(v);
36
                }
37
            }
38
        }
39
    }
40
41
    cout << components << "\n";
42
    return 0;
43
}
44