Delete ioi2025

ioi2025/festival.cpp

@@ -1,140 +0,0 @@
-#include <bits/stdc++.h>
-using namespace std;
-
-struct Booster {
-    long long price;   // P[i]
-    int       typ;     // T[i]   (2..4)
-    int       idx;     // original coupon index
-    double    a;       // P[i] * T[i] / (T[i]-1)   for sorting
-};
-
-using ll = long long;
-const ll INF64 = numeric_limits<long long>::max();
-
-/*---------------------------------------------------------------*/
-/*  Main function required by the statement                        */
-vector<int> max_coupons(int A,
-                        vector<int> P,
-                        vector<int> T)
-{
-    const int N = (int)P.size();
-
-    /* ----------- 1. split into boosters and cheap coupons ----------- */
-    vector<Booster> boosters;
-    boosters.reserve(N);
-    vector<pair<ll,int>> cheap;          // (price , idx)
-    cheap.reserve(N);
-
-    for (int i = 0; i < N; ++i) {
-        if (T[i] == 1) {
-            cheap.emplace_back(P[i], i);
-        } else {
-            Booster b;
-            b.price = P[i];
-            b.typ   = T[i];
-            b.idx   = i;
-            b.a     = (double)P[i] * (double)T[i] / (double)(T[i] - 1);
-            boosters.push_back(b);
-        }
-    }
-
-    /* -------------------- 2. sort the two groups ------------------- */
-    sort(boosters.begin(), boosters.end(),
-         [](const Booster& x, const Booster& y){ return x.a < y.a; });
-
-    sort(cheap.begin(), cheap.end(),
-         [](const pair<ll,int>& x, const pair<ll,int>& y){ return x.first < y.first; });
-
-    int C = (int)cheap.size();
-    vector<ll> cheapPref(C + 1, 0);           // cheapPref[0] = 0
-    vector<int> cheapIdx(C);
-    for (int i = 0; i < C; ++i) {
-        cheapPref[i+1] = cheapPref[i] + cheap[i].first;
-        cheapIdx[i]    = cheap[i].second;
-    }
-
-    /* --------------------- 3. DP over boosters --------------------- */
-    // DP vectors – state id is its position in the vectors
-    vector<ll>  tokens;   // tokens left after the state
-    vector<int> cnts;     // number of boosters taken in the state
-    vector<int> prev;     // previous state id
-    vector<int> idxs;     // coupon index of the last taken booster
-
-    tokens.push_back((ll)A);   // state 0 – start
-    cnts  .push_back(0);
-    prev  .push_back(-1);
-    idxs  .push_back(-1);
-
-    vector<int> frontier;      // ids of non‑dominated states
-    frontier.push_back(0);
-
-    for (const Booster& b : boosters) {
-        vector<int> added;            // newly created states (ids)
-        added.reserve(frontier.size());
-
-        for (int sid : frontier) {
-            if (tokens[sid] >= b.price) {
-                // (tokens[sid] - price) * typ   – do it in 128‑bit to avoid overflow
-                __int128 tmp = (__int128)(tokens[sid] - b.price) * (ll)b.typ;
-                ll newTok = (tmp > INF64) ? INF64 : (ll)tmp;
-
-                tokens.push_back(newTok);
-                cnts  .push_back(cnts[sid] + 1);
-                prev  .push_back(sid);
-                idxs  .push_back(b.idx);
-                added.push_back((int)tokens.size() - 1);
-            }
-        }
-
-        // ---- merge old and new states, keep only non‑dominated ----
-        vector<int> cand = frontier;
-        cand.insert(cand.end(), added.begin(), added.end());
-
-        sort(cand.begin(), cand.end(),
-             [&](int a, int b) {
-                 if (tokens[a] != tokens[b]) return tokens[a] > tokens[b];
-                 return cnts[a] > cnts[b];
-             });
-
-        vector<int> newFrontier;
-        int bestCnt = -1;
-        for (int sid : cand) {
-            if (cnts[sid] > bestCnt) {
-                newFrontier.push_back(sid);
-                bestCnt = cnts[sid];
-            }
-        }
-        frontier.swap(newFrontier);
-    }
-
-    /* -------------------- 4. Choose the best final state -------------------- */
-    long long bestTotal = -1;
-    int bestState = -1;
-    int bestCheap  = 0;               // how many cheap coupons we can buy
-
-    for (int sid : frontier) {
-        ll curTok = tokens[sid];
-        // number of cheap coupons affordable with curTok tokens
-        int cheapCnt = (int)(upper_bound(cheapPref.begin(), cheapPref.end(), curTok)
-                             - cheapPref.begin()) - 1;
-        long long total = (long long)cnts[sid] + cheapCnt;
-        if (total > bestTotal) {
-            bestTotal = total;
-            bestState = sid;
-            bestCheap = cheapCnt;
-        }
-    }
-
-    /* -------------------- 5. Reconstruct the answer -------------------- */
-    vector<int> answer;
-    // boosters (taken in reverse order)
-    for (int sid = bestState; sid != 0; sid = prev[sid])
-        answer.push_back(idxs[sid]);
-    reverse(answer.begin(), answer.end());
-
-    // cheap coupons – they are already sorted by price
-    for (int i = 0; i < bestCheap; ++i)
-        answer.push_back(cheapIdx[i]);
-
-    return answer;
-}

ioi2025/migrations-subtask1.cpp

@@ -1,83 +0,0 @@
-// ------------------------------------------------------------
-//  Dinosaur migration – research team (send_message) and Museum
-// ------------------------------------------------------------
-
-#include <vector>
-#include <utility>   // std::pair
-#include <algorithm> // std::max
-
-// -----------------------------------------------------------------
-//  Constants and global data that survive across calls of send_message
-// -----------------------------------------------------------------
-static const int _BLOCK = 100;          // block size for the encoding
-
-// current test case size (0 means “no test case started yet”)
-static int _curr_N = -1;
-
-// depth[v] for the vertices that have already been visited
-static std::vector<int> _depth;
-
-// deepest distance seen so far and the *largest* vertex that attains it
-static int _max_depth = -1;
-static int _max_node  = -1;
-
-int send_message(int N, int i, int Pi)
-{
-    // (re)initialise the data structures when we get a new test case
-    if (N != _curr_N) {
-        _curr_N   = N;
-        _depth.assign(N, 0);   // depth[0] stays 0, others are filled later
-        _max_depth = -1;
-        _max_node  = -1;
-    }
-
-    // depth of the current vertex
-    int d = _depth[Pi] + 1;
-    _depth[i] = d;
-
-    // keep the deepest vertex seen so far (largest index on ties)
-    if (d > _max_depth || (d == _max_depth && i > _max_node)) {
-        _max_depth = d;
-        _max_node  = i;
-    }
-
-    // decide what (if anything) to send from site i
-    if (i == N - 2) {                       // second‑last site – send block part
-        int block = _max_node / _BLOCK;     // integer division, always >= 0
-        return block + 1;                   // 1 … 100
-    }
-    else if (i == N - 1) {                  // last site – send remainder part
-        int rem = _max_node % _BLOCK;       // remainder in [0, 99]
-        return rem + 1;                     // 1 … 100
-    }
-    else {
-        return 0;                           // no message
-    }
-}
-
-std::pair<int,int> longest_path(std::vector<int> S)
-{
-    const int N = static_cast<int>(S.size());
-
-    if (N == 1) {
-        return {0, 0};
-    }
-
-    // The two last entries are the encoded answer.
-    int block_val = S[N - 2];
-    int rem_val   = S[N - 1];
-
-    // Convert back to the original block index (0‑based) and remainder.
-    int block = (block_val > 0) ? (block_val - 1) : 0;   // 0 … 99
-    int rem   = (rem_val   > 0) ? (rem_val   - 1) : 0;   // 0 … 99
-
-    // Re‑assemble the index of the farthest vertex.
-    int idx = block * _BLOCK + rem;
-
-    if (idx < 0)            idx = 0;
-    else if (idx >= N)      idx = N - 1;
-
-    // Site 0 is always an endpoint of a diameter (as required by the
-    // original research problem).  The second endpoint is `idx`.
-    return {0, idx};
-}

ioi2025/migrations-subtask2.cpp

@@ -1,190 +0,0 @@
-#include <bits/stdc++.h>
-using namespace std;
-
-/* -----------------------------------------------------------------
-   Global state that is shared between successive calls of
-   send_message for the *same* test case.
-   It is re‑initialised each time the first node (i == 1) of a new
-   test case is processed.
-   ----------------------------------------------------------------- */
-namespace {
-    // total number of vertices of the current test case
-    static int  total_nodes = 0;
-    // binary‑lifting depth
-    static int  LOG = 0;
-    static vector<int>            depth;               // depth[v]
-    static vector<vector<int>>    up;                  // up[k][v] = 2^k‑th ancestor
-
-    // current diameter (a,b) and its length
-    static int  a = 0, b = 0, diam = 0;
-
-    // auxiliary values that are saved at specific steps
-    static int  a2 = -1;          // a after node N‑2
-    static int  b2 = -1;          // b after node N‑2
-    static int  b_at_N3 = -1;     // b after node N‑3
-}
-
-/* -----------------------------------------------------------------
-   Helper functions working on the global structures
-   ----------------------------------------------------------------- */
-static void reinit(int N)
-{
-    total_nodes = N;
-    LOG = 0;
-    while ((1 << LOG) <= N) ++LOG;   // floor(log2(N)) + 1
-    ++LOG;                           // a little safety margin
-
-    depth.assign(N, 0);                       // depth[0] = 0 already
-    up.assign(LOG, vector<int>(N, 0));        // all ancestors of the root = 0
-
-    a = b = diam = 0;
-    a2 = b2 = -1;
-    b_at_N3 = -1;
-}
-
-/* LCA by binary lifting */
-static int lca(int u, int v)
-{
-    if (depth[u] < depth[v]) swap(u, v);
-    int diff = depth[u] - depth[v];
-    for (int k = 0; diff; ++k) {
-        if (diff & 1) u = up[k][u];
-        diff >>= 1;
-    }
-    if (u == v) return u;
-    for (int k = LOG - 1; k >= 0; --k) {
-        if (up[k][u] != up[k][v]) {
-            u = up[k][u];
-            v = up[k][v];
-        }
-    }
-    return up[0][u];
-}
-
-/* Distance between two vertices */
-static int dist(int u, int v)
-{
-    int w = lca(u, v);
-    return depth[u] + depth[v] - 2 * depth[w];
-}
-
-/* -----------------------------------------------------------------
-   send_message – called while the tree is being built (sites 1 … N‑1)
-   Returns 0 (no message) or an integer that will be sent to the museum.
-   ----------------------------------------------------------------- */
-int send_message(int N, int i, int Pi)          // C‑link for clarity
-{
-    // first call of a new test case → initialise the global data
-    if (i == 1) {
-        reinit(N);
-    }
-
-    /* ---- insert the new leaf i (parent = Pi) ---- */
-    int d = depth[Pi] + 1;
-    depth[i] = d;
-    up[0][i] = Pi;
-    for (int k = 1; k < LOG; ++k) {
-        int anc = up[k - 1][i];
-        up[k][i] = up[k - 1][anc];
-    }
-
-    /* ---- maintain the current diameter (a,b) ---- */
-    int da = dist(i, a);
-    int db = dist(i, b);
-    if (da > diam) {
-        b   = i;
-        diam = da;
-    } else if (db > diam) {
-        a   = i;
-        diam = db;
-    }
-
-    /* ---- send the three tiny messages (only at i = N‑3, N‑2, N‑1) ---- */
-    if (total_nodes >= 4 && i == total_nodes - 3 && i >= 1) {
-        /* i == N‑3 : store b after node N‑3 (store +1 because 0 would be ambiguous) */
-        b_at_N3 = b;
-        return b + 1;                // 1 ≤ value ≤ 20000
-    }
-    else if (i == total_nodes - 2 && i >= 1) {
-        /* i == N‑2 : store a and the whole diameter after this step */
-        a2 = a;
-        b2 = b;
-        return a + 1;                // a+1 (still ≤ 20000)
-    }
-    else if (i == total_nodes - 1 && i >= 1) {
-        /* i == N‑1 : compute the flag (1 … 5) */
-        int a_final = a;
-        int b_final = b;
-        int a2_local = a2;
-        int b2_local = b2;
-        int b0 = b_at_N3;            // b after node N‑3 (may be outdated)
-
-        int flag = 1;                // default (fallback)
-
-        if (a_final == a2_local && b_final == b2_local) {
-            flag = (b2_local == total_nodes - 2) ? 2 : 1;
-        }
-        else if (a_final == a2_local && b_final == total_nodes - 1) {
-            flag = 3;                // b replaced at the last insertion
-        }
-        else if (a_final == total_nodes - 1 && b_final == b2_local) {
-            flag = (b2_local == total_nodes - 2) ? 5 : 4;
-        }
-        else {
-            flag = 1;                // should never happen
-        }
-
-        return flag;                 // already in [1,5]
-    }
-
-    return 0;                        // all other vertices: no message
-}
-
-/* -----------------------------------------------------------------
-   longest_path – decodes the three messages produced by send_message
-   and returns a pair of vertices that realise the tree diameter.
-   ----------------------------------------------------------------- */
-pair<int,int> longest_path(vector<int> S)
-{
-    size_t N = S.size();
-
-    if (N <= 1) return {0, 0};
-    if (N == 2) return {0, 1};
-    if (N == 3) return {1, 2};
-
-    // N >= 4 : three stored values are at positions N‑3, N‑2, N‑1
-    int a_msg = S[N - 2];          // a after node N‑2   (+1)
-    int b_msg = S[N - 3];          // b after node N‑3   (+1)
-    int flag  = S[N - 1];          // 1 … 5
-
-    int a = a_msg - 1;             // a after node N‑2
-    int b0 = b_msg - 1;            // b after node N‑3
-
-    int u, v;
-    switch (flag) {
-        case 1:                    // both old endpoints survive
-            u = a;
-            v = b0;
-            break;
-        case 2:                    // b changed at N‑2, a survived
-            u = a;
-            v = static_cast<int>(N) - 2;
-            break;
-        case 3:                    // b replaced at N‑1, a survived
-            u = a;
-            v = static_cast<int>(N) - 1;
-            break;
-        case 4:                    // a replaced at N‑1, b survived (b unchanged at N‑2)
-            u = b0;
-            v = static_cast<int>(N) - 1;
-            break;
-        case 5:                    // a replaced at N‑1, b changed at N‑2
-            u = static_cast<int>(N) - 2;
-            v = static_cast<int>(N) - 1;
-            break;
-        default:                   // safety fallback – should never be hit
-            u = a;
-            v = b0;
-    }
-    return {u, v};
-}

ioi2025/obstacles.cpp

@@ -1,222 +0,0 @@
-#include <bits/stdc++.h>
-using namespace std;
-
-/* ------------------------------------------------------------------ */
-/*  Disjoint Set Union (Union–Find)                                   */
-/* ------------------------------------------------------------------ */
-struct DSU {
-    vector<int> parent, sz;
-    DSU(int n = 0) { init(n); }
-
-    void init(int n) {
-        parent.resize(n);
-        sz.assign(n, 1);
-        iota(parent.begin(), parent.end(), 0);
-    }
-
-    int find(int x) {
-        while (parent[x] != x) {
-            parent[x] = parent[parent[x]];
-            x = parent[x];
-        }
-        return x;
-    }
-
-    void union_sets(int a, int b) {
-        a = find(a);
-        b = find(b);
-        if (a == b) return;
-        if (sz[a] < sz[b]) swap(a, b);
-        parent[b] = a;
-        sz[a] += sz[b];
-    }
-};
-
-/* ------------------------------------------------------------------ */
-/*  Segment tree for range maximum (static)                           */
-/* ------------------------------------------------------------------ */
-struct MaxSegTree {
-    int n;          // original size
-    int size;       // power of two >= n
-    vector<int> tree;   // 2*size elements
-
-    MaxSegTree() : n(0), size(0) {}
-
-    explicit MaxSegTree(const vector<int>& data) {
-        build(data);
-    }
-
-    void build(const vector<int>& data) {
-        n = static_cast<int>(data.size());
-        size = 1;
-        while (size < n) size <<= 1;
-        tree.assign(2 * size, 0);
-        for (int i = 0; i < n; ++i) tree[size + i] = data[i];
-        for (int i = size - 1; i > 0; --i)
-            tree[i] = max(tree[i << 1], tree[i << 1 | 1]);
-    }
-
-    // inclusive query [l, r]; returns -1 for empty interval
-    int query(int l, int r) const {
-        if (l > r) return -1;
-        l += size; r += size;
-        int res = -1;
-        while (l <= r) {
-            if (l & 1)  res = max(res, tree[l++]);
-            if (!(r & 1)) res = max(res, tree[r--]);
-            l >>= 1; r >>= 1;
-        }
-        return res;
-    }
-};
-
-/* ------------------------------------------------------------------ */
-/*  Segment tree that stores min / max *active* column indices         */
-/* ------------------------------------------------------------------ */
-struct ActiveSegTree {
-    int n;                 // number of columns
-    int size;              // power of two >= n
-    vector<int> max_tree; // maximum active index inside the node
-    vector<int> min_tree; // minimum active index inside the node
-
-    explicit ActiveSegTree(int n_) : n(n_) {
-        size = 1;
-        while (size < n) size <<= 1;
-        max_tree.assign(2 * size, -1);
-        min_tree.assign(2 * size, n);
-    }
-
-    // mark column idx as active
-    void activate(int idx) {
-        int i = idx + size;
-        max_tree[i] = idx;
-        min_tree[i] = idx;
-        for (i >>= 1; i; i >>= 1) {
-            int left  = i << 1;
-            int right = left | 1;
-            max_tree[i] = max(max_tree[left], max_tree[right]);
-            min_tree[i] = min(min_tree[left], min_tree[right]);
-        }
-    }
-
-    // maximum active index in [l, r]; -1 if none
-    int query_max(int l, int r) const {
-        if (l > r) return -1;
-        l += size; r += size;
-        int res = -1;
-        while (l <= r) {
-            if (l & 1)  res = max(res, max_tree[l++]);
-            if (!(r & 1)) res = max(res, max_tree[r--]);
-            l >>= 1; r >>= 1;
-        }
-        return res;
-    }
-
-    // minimum active index in [l, r]; n if none
-    int query_min(int l, int r) const {
-        if (l > r) return n;
-        l += size; r += size;
-        int res = n;
-        while (l <= r) {
-            if (l & 1)  res = min(res, min_tree[l++]);
-            if (!(r & 1)) res = min(res, min_tree[r--]);
-            l >>= 1; r >>= 1;
-        }
-        return res;
-    }
-};
-
-int N = 0, M = 0;
-vector<int> pref_max;   // prefix maximum of T, length N
-vector<int> comp;       // component id for each column
-DSU* dsu = nullptr;     // created inside initialize
-
-/* ------------------------------------------------------------------ */
-/*  Interface required by the statement                                 */
-/* ------------------------------------------------------------------ */
-void initialize(vector<int> T, vector<int> H)
-{
-    N = static_cast<int>(T.size());
-    M = static_cast<int>(H.size());
-
-    /* 1. prefix maximum of temperatures */
-    pref_max.assign(N, 0);
-    pref_max[0] = T[0];
-    for (int i = 1; i < N; ++i)
-        pref_max[i] = max(pref_max[i-1], T[i]);
-
-    /* 2. first blocked row for every column */
-    vector<int> col_by_h(M);
-    iota(col_by_h.begin(), col_by_h.end(), 0);
-    sort(col_by_h.begin(), col_by_h.end(),
-         [&](int a, int b){ return H[a] > H[b]; });
-
-    vector<int> first_block(M, N);
-    int ptr = 0;
-    for (int i = 0; i < N; ++i) {
-        int ti = T[i];
-        while (ptr < M && H[col_by_h[ptr]] >= ti) {
-            int col = col_by_h[ptr];
-            first_block[col] = i;
-            ++ptr;
-        }
-    }
-
-    vector<int> Lcol(M);
-    for (int j = 0; j < M; ++j) {
-        if (first_block[j] == N) Lcol[j] = N - 1;
-        else                     Lcol[j] = first_block[j] - 1;
-    }
-
-    /* 3. V[j] = max temperature in rows 0 … Lcol[j] */
-    vector<int> V(M);
-    for (int j = 0; j < M; ++j) {
-        if (Lcol[j] >= 0) V[j] = pref_max[Lcol[j]];
-        else               V[j] = -1;          // column can never be reached
-    }
-
-    /* 4. segment tree for range maximum of humidity (static) */
-    MaxSegTree seg_H(H);
-
-    /* 5. DSU over columns */
-    dsu = new DSU(M);
-
-    /* 6. process columns in decreasing V */
-    vector<int> order(M);
-    iota(order.begin(), order.end(), 0);
-    sort(order.begin(), order.end(),
-         [&](int a, int b){ return V[a] > V[b]; });
-
-    ActiveSegTree active_seg(M);   // no column active at the beginning
-
-    for (int col : order) {
-        int vcol = V[col];
-        active_seg.activate(col);               // make the column active
-
-        // ---- left neighbour ----
-        int left = -1;
-        if (col > 0) left = active_seg.query_max(0, col - 1);
-        if (left != -1) {
-            int max_h = seg_H.query(left, col);
-            if (max_h < vcol) dsu->union_sets(col, left);
-        }
-
-        // ---- right neighbour ----
-        int right = M;
-        if (col + 1 < M) right = active_seg.query_min(col + 1, M - 1);
-        if (right != M) {
-            int max_h = seg_H.query(col, right);
-            if (max_h < vcol) dsu->union_sets(col, right);
-        }
-    }
-
-    /* 7. store the component id for every column */
-    comp.resize(M);
-    for (int i = 0; i < M; ++i) comp[i] = dsu->find(i);
-}
-
-bool can_reach(int L, int R, int S, int D)
-{
-    (void)L; (void)R;          // unused, required by the signature
-    return comp[S] == comp[D];
-}

ioi2025/souvenirs-subtask1_3.cpp

@@ -1,46 +0,0 @@
-#include <vector>
-#include <utility>
-
-using namespace std;
-
-// Provided by the judge.  It returns the list of types bought and the
-// number of coins that remain after giving M coins.
-pair<vector<int>, long long> transaction(long long M);
-
-void buy_souvenirs(int N, long long P0)
-{
-    vector<long long> price(N, 0);
-    vector<int>      bought(N, 0);
-
-    price[0] = P0;                     // price of type 0 is known
-
-    // -------- Phase 1 : discover all prices ----------
-    for (int i = 1; i < N; ++i) {
-        long long M = price[i - 1] - 1;                // guaranteed < price[i-1] and ≥ price[i]
-        auto [L, R] = transaction(M);                  // L – bought types, R – remaining coins
-
-        for (int t : L) ++bought[t];
-
-        long long spent = M - R;                       // total money spent in this transaction
-
-        if (L.size() == 1) {
-            price[i] = spent;                          // only type i was bought
-        } else {
-            price[i] = spent - 1;                       // cheapest type (price 1) was also bought
-            int extra = -1;
-            for (int t : L) if (t != i) { extra = t; break; }
-            if (extra != -1 && price[extra] == 0) {
-                price[extra] = 1;                       // cheapest type has price 1
-            }
-        }
-    }
-
-    // -------- Phase 2 : buy the remaining copies ----------
-    for (int i = 1; i < N; ++i) {
-        while (bought[i] < i) {
-            long long M = price[i];                    // give exactly the price of type i
-            auto [L, R] = transaction(M);
-            for (int t : L) ++bought[t];
-        }
-    }
-}

ioi2025/souvenirs-subtask4.cpp

@@ -1,22 +0,0 @@
-#include <vector>
-#include <utility>
-
-std::pair<std::vector<int>, long long> transaction(long long M);   // provided by the judge
-
-void buy_souvenirs(int N, long long P0)
-{
-    long long M1 = P0 - 1;
-    auto [L1, R1] = transaction(M1);
-
-    if (L1.size() == 2) {
-        long long S  = M1 - R1;
-        long long M2 = S / 2;
-        transaction(M2);
-        return;
-    }
-
-    long long P1 = M1 - R1;
-    long long M  = P1 - 1;
-    transaction(M);
-    transaction(M);
-}

ioi2025/triples-part1.cpp

@@ -1,126 +0,0 @@
-#include <bits/stdc++.h>
-using namespace std;
-
-long long count_triples(vector<int> H)
-{
-    const int N = static_cast<int>(H.size());
-
-    long long cnt1 = 0, cnt2 = 0, cnt3 = 0, cnt4 = 0,
-              cnt5 = 0, cnt6 = 0, equal_cnt = 0;
-
-    /* ---------- assignment 1 ---------- */
-    for (int i = 0; i < N; ++i) {
-        int j = i + H[i];
-        if (j >= N) continue;
-        int b = H[j];
-        int k = j + b;
-        if (k >= N) continue;
-        if (H[k] == H[i] + b) ++cnt1;
-    }
-
-    /* ---------- assignment 2 ---------- */
-    for (int i = 0; i < N; ++i) {
-        int j = i + H[i];
-        if (j >= N) continue;
-        int b = H[j] - H[i];
-        if (b <= 0) continue;
-        int k = j + b;
-        if (k >= N) continue;
-        if (H[k] == b) ++cnt2;
-    }
-
-    /* ---------- assignment 3 ---------- */
-    for (int j = 0; j < N; ++j) {
-        int i = j - H[j];
-        if (i < 0) continue;
-        int b = H[i];
-        int k = j + b;
-        if (k >= N) continue;
-        if (H[k] == H[j] + b) ++cnt3;
-    }
-
-    /* ---------- assignment 5 ---------- */
-    for (int j = 0; j < N; ++j) {
-        int i = j - H[j];
-        if (i < 0) continue;
-        int b = H[i] - H[j];
-        if (b <= 0) continue;
-        int k = j + b;
-        if (k >= N) continue;
-        if (H[k] == b) ++cnt5;
-    }
-
-    /* ---------- assignment 6 ---------- */
-    for (int j = 0; j < N; ++j) {
-        int k = j + H[j];
-        if (k >= N) continue;
-        int a = H[k];
-        int i = j - a;
-        if (i < 0) continue;
-        if (H[i] == a + H[j]) ++cnt6;
-    }
-
-    /* ---------- assignment 4 (group i+H[i] = k-H[k]) ---------- */
-    // groups[T] = list of k such that k - H[k] == T   (T = “key”)
-    unordered_map<int, vector<int>> groups;
-    groups.reserve(N * 2);
-    for (int k = 0; k < N; ++k) {
-        int T = k - H[k];
-        groups[T].push_back(k);            // k grows, so each vector stays sorted
-    }
-
-    for (int i = 0; i < N; ++i) {
-        int T = i + H[i];
-        auto it = groups.find(T);
-        if (it == groups.end()) continue;   // no k with the needed key
-
-        const vector<int>& ks = it->second;
-        // first k that is > i
-        auto posIter = upper_bound(ks.begin(), ks.end(), i);
-        int H_i = H[i];
-
-        for (auto kIt = posIter; kIt != ks.end(); ++kIt) {
-            int k = *kIt;
-            int j = k - H_i;
-            if (j >= N) break;               // larger k → larger j, so we can stop
-            // i < j < k holds automatically for the chosen ks
-            if (H[j] == k - i) ++cnt4;
-        }
-    }
-
-    long long total = cnt1 + cnt2 + cnt3 + cnt4 + cnt5 + cnt6;
-
-    /* ---------- triples with equal distances (a = b) ----------
-       These triples were counted twice (once in the main total and
-       once in the equal‑distance special case), therefore we subtract
-       them once at the end.                                         */
-    for (int i = 0; i < N; ++i) {
-        int a = H[i];
-
-        // case 1 : distance = a   (i → j → k, with j = i+a, k = i+2a)
-        int j = i + a;
-        if (j < N) {
-            int k = i + 2 * a;
-            if (k < N) {
-                bool ok = (H[j] == a && H[k] == 2 * a) ||
-                          (H[j] == 2 * a && H[k] == a);
-                if (ok) ++equal_cnt;
-            }
-        }
-
-        // case 2 : distance = 2a   (i → j (a) → k (2a), but we treat a = H[i]/2)
-        if (a % 2 == 0) {
-            int a2 = a / 2;
-            if (a2 > 0) {
-                j = i + a2;
-                int k = i + a;                     // i + 2*a2 = i + a
-                if (j < N && k < N) {
-                    if (H[j] == a2 && H[k] == a2) ++equal_cnt;
-                }
-            }
-        }
-    }
-
-    return total - equal_cnt;
-}
-

ioi2025/triples-part2-subtask1.cpp

@@ -1,141 +0,0 @@
-#include <algorithm>
-#include <array>
-#include <cassert>
-#include <random>
-#include <vector>
-
-/* ----------------------------------------------------------------------
-   Helper type – a triple together with the *sorted* list of its three
-   distances (d1 , d2 , d3).  The distances are stored already sorted so
-   we can compare them directly with the sorted heights of the same
-   triple.
-   ---------------------------------------------------------------------- */
-struct Triple
-{
-    int i{}, j{}, k{};                     // indices i<j<k
-    std::array<int, 3> ds{};              // sorted distances (d1,d2,d3)
-
-    Triple(int a, int b, int c) : i(a), j(b), k(c)
-    {
-        int d1 = j - i;
-        int d2 = k - j;
-        int d3 = k - i;
-        ds = { d1, d2, d3 };
-        std::sort(ds.begin(), ds.end());   // make it sorted (ds[0] ≤ ds[1] ≤ ds[2])
-    }
-};
-
-/* ----------------------------------------------------------------------
-   Count how many triples are *mythical* for a given height vector H.
-   A triple is mythical iff the three heights (sorted) are exactly the
-   three distances (also sorted) of that triple.
-   ---------------------------------------------------------------------- */
-static int countTriples(const std::vector<int>& H,
-                        const std::vector<Triple>& triples)
-{
-    int cnt = 0;
-    for (const auto& tr : triples)
-    {
-        std::array<int,3> hs = { H[tr.i], H[tr.j], H[tr.k] };
-        std::sort(hs.begin(), hs.end());
-
-        if (hs == tr.ds) ++cnt;
-    }
-    return cnt;
-}
-
-std::vector<int> construct_range(int M, int K)
-{
-    /* ---- 1. pre‑compute all triples for N = max(3,M) ----------------- */
-    const int N = std::max(3, M);
-    std::vector<Triple> triples;
-    triples.reserve(N * (N-1) * (N-2) / 6);          // upper bound for #triples
-
-    for (int i = 0; i < N; ++i)
-        for (int j = i + 1; j < N; ++j)
-            for (int k = j + 1; k < N; ++k)
-                triples.emplace_back(i, j, k);
-
-    /* ---- 2. random search ------------------------------------------------ */
-    std::mt19937 rng{ std::random_device{}() };
-
-    // distribution for the initial random heights: 1 … N‑1 (inclusive)
-    std::uniform_int_distribution<int> initDist(1, N - 1);
-
-    // same distribution we will use when we need a random element of `ds`
-    // (the distances themselves are already in the range 1 … N‑1)
-    // No extra work required – we simply shuffle the three already‑present
-    // numbers.
-
-    int best_cnt = -1;
-    std::vector<int> best_H;
-
-    const int max_restarts = 5;
-    const int max_moves    = 20000;      // moves per restart
-
-    for (int restart = 0; restart < max_restarts; ++restart)
-    {
-        /* ---- a) random initial configuration --------------------------- */
-        std::vector<int> cur_H(N);
-        for (int i = 0; i < N; ++i)
-            cur_H[i] = initDist(rng);
-
-        int cur_cnt = countTriples(cur_H, triples);
-
-        if (cur_cnt > best_cnt)
-        {
-            best_cnt = cur_cnt;
-            best_H   = cur_H;
-        }
-        if (cur_cnt >= K)
-            return cur_H;                 // we already hit the target
-
-        /* ---- b) local hill‑climbing / random‑move phase ----------------- */
-        std::vector<int> cur = cur_H;      // we will mutate this copy
-
-        for (int move = 0; move < max_moves; ++move)
-        {
-            // pick a random triple
-            const Triple& tr = triples[ std::uniform_int_distribution<int>(0, triples.size() - 1)(rng) ];
-
-            // remember the old three heights (so we can revert)
-            int old_i = cur[tr.i];
-            int old_j = cur[tr.j];
-            int old_k = cur[tr.k];
-
-            // permute the three distances of this triple
-            std::array<int,3> dlist = tr.ds;   // copy
-            std::shuffle(dlist.begin(), dlist.end(), rng);
-
-            // apply the move
-            cur[tr.i] = dlist[0];
-            cur[tr.j] = dlist[1];
-            cur[tr.k] = dlist[2];
-
-            int new_cnt = countTriples(cur, triples);
-
-            // accept the move only if it does not make the global count worse
-            if (new_cnt >= cur_cnt)
-            {
-                cur_cnt = new_cnt;
-                if (cur_cnt > best_cnt)
-                {
-                    best_cnt = cur_cnt;
-                    best_H   = cur;
-                }
-                if (cur_cnt >= K)
-                    return cur;          // success – we reached K
-            }
-            else
-            {
-                // revert the move (the triple must be mythical again)
-                cur[tr.i] = old_i;
-                cur[tr.j] = old_j;
-                cur[tr.k] = old_k;
-            }
-        }   // end of one restart's move loop
-    }   // end of all restarts
-
-    // never reached K – return the best we ever found (it is still a legal vector)
-    return best_H;
-}

ioi2025/triples-part2-subtask2.cpp

@@ -1,358 +0,0 @@
-#include <bits/stdc++.h>
-
-using namespace std;
-
-long long count_triples(vector<int> H)
-{
-    const int N = static_cast<int>(H.size());
-
-    long long cnt1 = 0, cnt2 = 0, cnt3 = 0, cnt4 = 0,
-              cnt5 = 0, cnt6 = 0, equal_cnt = 0;
-
-    /* ---------- assignment 1 ---------- */
-    for (int i = 0; i < N; ++i) {
-        int j = i + H[i];
-        if (j >= N) continue;
-        int b = H[j];
-        int k = j + b;
-        if (k >= N) continue;
-        if (H[k] == H[i] + b) ++cnt1;
-    }
-
-    /* ---------- assignment 2 ---------- */
-    for (int i = 0; i < N; ++i) {
-        int j = i + H[i];
-        if (j >= N) continue;
-        int b = H[j] - H[i];
-        if (b <= 0) continue;
-        int k = j + b;
-        if (k >= N) continue;
-        if (H[k] == b) ++cnt2;
-    }
-
-    /* ---------- assignment 3 ---------- */
-    for (int j = 0; j < N; ++j) {
-        int i = j - H[j];
-        if (i < 0) continue;
-        int b = H[i];
-        int k = j + b;
-        if (k >= N) continue;
-        if (H[k] == H[j] + b) ++cnt3;
-    }
-
-    /* ---------- assignment 5 ---------- */
-    for (int j = 0; j < N; ++j) {
-        int i = j - H[j];
-        if (i < 0) continue;
-        int b = H[i] - H[j];
-        if (b <= 0) continue;
-        int k = j + b;
-        if (k >= N) continue;
-        if (H[k] == b) ++cnt5;
-    }
-
-    /* ---------- assignment 6 ---------- */
-    for (int j = 0; j < N; ++j) {
-        int k = j + H[j];
-        if (k >= N) continue;
-        int a = H[k];
-        int i = j - a;
-        if (i < 0) continue;
-        if (H[i] == a + H[j]) ++cnt6;
-    }
-
-    /* ---------- assignment 4 (group i+H[i] = k-H[k]) ---------- */
-    // groups[T] = list of k such that k - H[k] == T   (T = “key”)
-    unordered_map<int, vector<int>> groups;
-    groups.reserve(N * 2);
-    for (int k = 0; k < N; ++k) {
-        int T = k - H[k];
-        groups[T].push_back(k);            // k grows, so each vector stays sorted
-    }
-
-    for (int i = 0; i < N; ++i) {
-        int T = i + H[i];
-        auto it = groups.find(T);
-        if (it == groups.end()) continue;   // no k with the needed key
-
-        const vector<int>& ks = it->second;
-        // first k that is > i
-        auto posIter = upper_bound(ks.begin(), ks.end(), i);
-        int H_i = H[i];
-
-        for (auto kIt = posIter; kIt != ks.end(); ++kIt) {
-            int k = *kIt;
-            int j = k - H_i;
-            if (j >= N) break;               // larger k → larger j, so we can stop
-            // i < j < k holds automatically for the chosen ks
-            if (H[j] == k - i) ++cnt4;
-        }
-    }
-
-    long long total = cnt1 + cnt2 + cnt3 + cnt4 + cnt5 + cnt6;
-
-    /* ---------- triples with equal distances (a = b) ----------
-       These triples were counted twice (once in the main total and
-       once in the equal‑distance special case), therefore we subtract
-       them once at the end.                                         */
-    for (int i = 0; i < N; ++i) {
-        int a = H[i];
-
-        // case 1 : distance = a   (i → j → k, with j = i+a, k = i+2a)
-        int j = i + a;
-        if (j < N) {
-            int k = i + 2 * a;
-            if (k < N) {
-                bool ok = (H[j] == a && H[k] == 2 * a) ||
-                          (H[j] == 2 * a && H[k] == a);
-                if (ok) ++equal_cnt;
-            }
-        }
-
-        // case 2 : distance = 2a   (i → j (a) → k (2a), but we treat a = H[i]/2)
-        if (a % 2 == 0) {
-            int a2 = a / 2;
-            if (a2 > 0) {
-                j = i + a2;
-                int k = i + a;                     // i + 2*a2 = i + a
-                if (j < N && k < N) {
-                    if (H[j] == a2 && H[k] == a2) ++equal_cnt;
-                }
-            }
-        }
-    }
-
-    return total - equal_cnt;
-}
-
-
-
-/* -------------------------------------------------------------
-   2.  greedy_builder – builds a candidate array from (h0,h1)
-   ------------------------------------------------------------- */
-static vector<int> greedy_builder(int N, int h0, int h1,
-                                  int D, int max_h)
-{
-    vector<int> H(N, 1);
-    H[0] = h0;
-    H[1] = h1;
-
-    vector<int> cnt(max_h + 1, 0);
-    vector<int> last(max_h + 1, 0);
-    int version = 0;
-    const int twoD = 2 * D;
-
-    for (int k = 2; k < N; ++k) {
-        ++version;
-        int best_cnt = 0;
-        int best_missing = 1;
-        int i_start = k - twoD;
-        if (i_start < 0) i_start = 0;
-
-        for (int i = i_start; i < k; ++i) {
-            int hi = H[i];
-            int s = k - i;
-            if (hi >= s) continue;
-
-            // ----- left candidate j = i + hi -----
-            int j = i + hi;
-            if (j < k) {
-                int a = hi;
-                int b = s - hi;
-                int hj = H[j];
-                bool ok = (hj == a || hj == b || hj == s) &&
-                          !(a != b && hi == hj);
-                if (ok) {
-                    int missing = 2 * s - hi - hj;
-                    if (1 <= missing && missing <= max_h) {
-                        if (last[missing] != version) {
-                            cnt[missing] = 1;
-                            last[missing] = version;
-                        } else {
-                            ++cnt[missing];
-                        }
-                        if (cnt[missing] > best_cnt) {
-                            best_cnt = cnt[missing];
-                            best_missing = missing;
-                        }
-                    }
-                }
-            }
-
-            // ----- right candidate j2 = k - hi -----
-            int j2 = k - hi;
-            if (j2 > i && j2 != i + hi) {
-                int a = s - hi;
-                int b = hi;
-                int hj = H[j2];
-                bool ok = (hj == a || hj == b || hj == s) &&
-                          !(a != b && hi == hj);
-                if (ok) {
-                    int missing = 2 * s - hi - hj;
-                    if (1 <= missing && missing <= max_h) {
-                        if (last[missing] != version) {
-                            cnt[missing] = 1;
-                            last[missing] = version;
-                        } else {
-                            ++cnt[missing];
-                        }
-                        if (cnt[missing] > best_cnt) {
-                            best_cnt = cnt[missing];
-                            best_missing = missing;
-                        }
-                    }
-                }
-            }
-        }
-
-        H[k] = (best_cnt > 0) ? best_missing : 1;
-    }
-    return H;
-}
-
-/* -------------------------------------------------------------
-   3.  construct_range – the whole construction routine
-   ------------------------------------------------------------- */
-vector<int> construct_range(int M, int K)
-{
-    const int N = max(3, M);                 // we always use exactly N = M (M>=3 in tests)
-    const int max_h = N - 1;
-    int D = (N - 1) / 2;
-    if (D == 0) D = 1;
-
-    long long best_T = -1;
-    vector<int> best_H;
-
-    /* ----- helper: evaluate a candidate and keep the best one ----- */
-    auto evaluate = [&](const vector<int>& H) {
-        long long T = count_triples(H);
-        if (T > best_T) {
-            best_T = T;
-            best_H = H;
-            if (best_T >= K) throw runtime_error("enough triples");
-        }
-    };
-
-    /* ----- deterministic patterns ----- */
-    auto add_pattern = [&](const vector<int>& pat) {
-        int repeats = N / static_cast<int>(pat.size()) + 1;
-        vector<int> H;
-        H.reserve(N);
-        for (int i = 0; i < repeats; ++i) H.insert(H.end(), pat.begin(), pat.end());
-        H.resize(N);
-        evaluate(H);
-    };
-
-    add_pattern({1, 1, 2});
-    add_pattern({1, 2, 1});
-    add_pattern({2, 1, 1});
-
-    // a2 pattern – 4 on positions whose block‑index %3 ==0
-    vector<int> H(N);
-    for (int i = 0; i < N; ++i) {
-        if (i % 2 == 0) {                     // even index
-            int pos = i / 2;
-            H[i] = (pos % 3 == 0) ? 4 : 2;
-        } else {                               // odd index
-            int pos = (i - 1) / 2;
-            H[i] = (pos % 3 == 0) ? 4 : 2;
-        }
-    }
-    evaluate(H);
-
-    /* ----- start pairs for the greedy builder ----- */
-    unordered_set<long long> start_pairs;     // encode pair (h0,h1) in a 64‑bit key
-    auto encode = [&](int a, int b) -> long long { return (static_cast<long long>(a) << 32) | static_cast<unsigned int>(b); };
-
-    int limit = min(20, max_h);
-    for (int h0 = 1; h0 <= limit; ++h0)
-        for (int h1 = 1; h1 <= limit; ++h1)
-            start_pairs.insert(encode(h0, h1));
-
-    start_pairs.insert(encode(max_h, max_h));
-    start_pairs.insert(encode(max_h, 1));
-    start_pairs.insert(encode(1, max_h));
-    if (max_h >= 2) {
-        start_pairs.insert(encode(max_h - 1, max_h - 1));
-        start_pairs.insert(encode(max_h - 2, max_h - 2));
-    }
-
-    mt19937_64 rnd(123456789ULL);
-    for (int i = 0; i < 30; ++i) {
-        int h0 = uniform_int_distribution<int>(1, max_h)(rnd);
-        int h1 = uniform_int_distribution<int>(1, max_h)(rnd);
-        start_pairs.insert(encode(h0, h1));
-    }
-
-    vector<pair<int,int>> start_list;
-    start_list.reserve(start_pairs.size());
-    for (auto key : start_pairs) {
-        int h0 = static_cast<int>(key >> 32);
-        int h1 = static_cast<int>(key & 0xffffffff);
-        start_list.emplace_back(h0, h1);
-    }
-    shuffle(start_list.begin(), start_list.end(),
-            mt19937_64(987654321ULL));
-
-    /* ----- greedy builder for every start pair ----- */
-    try {
-        for (auto [h0, h1] : start_list) {
-            int h0c = max(1, min(max_h, h0));
-            int h1c = max(1, min(max_h, h1));
-            vector<int> cand = greedy_builder(N, h0c, h1c, D, max_h);
-            evaluate(cand);
-        }
-    } catch (const runtime_error&) {
-        // we already hit K – just keep the current best
-    }
-
-    /* ----- hill climbing if needed ----- */
-    if (best_T < K) {
-        vector<int> cur_H = best_H;
-        long long cur_T = best_T;
-
-        // values we are allowed to change to (small numbers + the maximal one)
-        vector<int> cand_vals;
-        int small_limit = min(N, 30);
-        for (int v = 1; v <= small_limit; ++v) cand_vals.push_back(v);
-        if (max_h > small_limit) cand_vals.push_back(max_h);
-        sort(cand_vals.begin(), cand_vals.end());
-        cand_vals.erase(unique(cand_vals.begin(), cand_vals.end()), cand_vals.end());
-
-        mt19937_64 rnd_hc(987654321ULL);
-        uniform_int_distribution<int> idx_dist(0, N - 1);
-        uniform_int_distribution<int> val_dist(0, static_cast<int>(cand_vals.size()) - 1);
-
-        for (int step = 0; step < 20000 && best_T < K; ++step) {
-            int i = idx_dist(rnd_hc);
-            int new_val = cand_vals[val_dist(rnd_hc)];
-            if (new_val == cur_H[i]) continue;
-
-            int old = cur_H[i];
-            cur_H[i] = new_val;
-            long long new_T = count_triples(cur_H);
-            if (new_T > cur_T) {
-                cur_T = new_T;
-                if (new_T > best_T) {
-                    best_T = new_T;
-                    best_H = cur_H;
-                    if (best_T >= K) break;
-                }
-            } else {
-                cur_H[i] = old;   // revert
-            }
-        }
-    }
-
-    /* ----- final safety clamp ----- */
-    vector<int> out_H(N);
-    for (int i = 0; i < N; ++i) {
-        int v = best_H[i];
-        if (v < 1) v = 1;
-        if (v > max_h) v = max_h;
-        out_H[i] = v;
-    }
-    out_H.resize(N);
-    return out_H;
-}
-

ioi2025/triples-part2-subtask3.cpp

@@ -1,196 +0,0 @@
-#include <algorithm>
-#include <cassert>
-#include <random>
-#include <utility>
-#include <vector>
-#include <cstdint>
-#include <unordered_map>
-
-/* ------------------------------------------------------------------ */
-/* Helper that implements the “greedy builder”.                         */
-/* It returns both the constructed height vector H and the total T.    */
-/* ------------------------------------------------------------------ */
-static std::pair<std::vector<int>, long long>
-greedy_builder(int N,
-               int h0,
-               int h1,
-               const std::vector<int>& useful_vals,
-               std::mt19937& rng)
-{
-    std::vector<int> H(N, 0);
-    H[0] = h0;
-    H[1] = h1;
-
-    const int max_missing = N - 1;                // allowed values are 1 … max_missing
-    std::vector<int> cnt(max_missing + 1, 0);
-    std::vector<int> last(max_missing + 1, 0);
-
-    long long total_T = 0;                        // may be larger than int
-    const int D = (N - 1) / 2;
-    const int twoD = 2 * D;
-
-    int version = 0;                              // increased for every k
-
-    for (int k = 2; k < N; ++k) {
-        ++version;                                // new “run” for this k
-
-        int best_cnt = 0;                         // best counter for this k
-        int best_missing = 1;                     // associated missing value
-
-        int i_start = k - twoD;
-        if (i_start < 0) i_start = 0;
-
-        for (int i = i_start; i < k; ++i) {
-            int hi = H[i];
-            int s = k - i;                        // s = k-i > 0
-
-            if (hi >= s) continue;                // no candidate possible
-
-            /* ---------- left distance candidate j = i + hi ---------- */
-            int j = i + hi;
-            if (j < k) {
-                int a = hi;
-                int b = s - hi;                    // the two distances that must appear together
-                int hj = H[j];
-                if (hj == a || hj == b || hj == s) {
-                    if (! (a != b && hi == hj)) { // the “not (a!=b && hi==hj)” guard
-                        int missing = 2 * s - hi - hj;
-                        if (1 <= missing && missing <= max_missing) {
-                            if (last[missing] != version) {
-                                cnt[missing] = 1;
-                                last[missing] = version;
-                            } else {
-                                ++cnt[missing];
-                            }
-                            int cur = cnt[missing];
-                            if (cur > best_cnt) {
-                                best_cnt = cur;
-                                best_missing = missing;
-                            }
-                        }
-                    }
-                }
-            }
-
-            /* ---------- right distance candidate j = k - hi ---------- */
-            j = k - hi;                            // right‑hand candidate, must be > i and not the same as left one
-            if (j > i && j != i + hi) {
-                int a = s - hi;
-                int b = hi;
-                int hj = H[j];
-                if (hj == a || hj == b || hj == s) {
-                    if (! (a != b && hi == hj)) {
-                        int missing = 2 * s - hi - hj;
-                        if (1 <= missing && missing <= max_missing) {
-                            if (last[missing] != version) {
-                                cnt[missing] = 1;
-                                last[missing] = version;
-                            } else {
-                                ++cnt[missing];
-                            }
-                            int cur = cnt[missing];
-                            if (cur > best_cnt) {
-                                best_cnt = cur;
-                                best_missing = missing;
-                            }
-                        }
-                    }
-                }
-            }
-        }   // end for i
-
-        if (best_cnt > 0) {
-            H[k] = best_missing;
-            total_T += best_cnt;
-        } else {
-            std::uniform_int_distribution<int> dist(0, static_cast<int>(useful_vals.size()) - 1);
-            H[k] = useful_vals[dist(rng)];
-        }
-    }
-
-    return {std::move(H), total_T};
-}
-
-/* ------------------------------------------------------------------ */
-/* Main routine requested by the problem statement.                     */
-/* ------------------------------------------------------------------ */
-std::vector<int> construct_range(int M, int K)
-{
-    /* ---- 1. decide N ------------------------------------------------ */
-    int N = std::max(3, M);
-    if (N > M) N = M;
-    // after this: 3 <= N <= M (or N = M when M < 3)
-
-    const int max_h = N - 1;               // allowed heights are 1 … max_h
-
-    /* ---- 2. useful fallback values ---------------------------------- */
-    std::vector<int> useful_vals;
-    int limit = std::min(N, 10); 
-    for (int v = 1; v <= limit; ++v) useful_vals.push_back(v);
-    if (max_h >= 1 && std::find(useful_vals.begin(), useful_vals.end(), max_h) == useful_vals.end())
-        useful_vals.push_back(max_h);
-
-    /* ---- 3. deterministic seeds -------------------------------------- */
-    std::vector<std::pair<int, int>> seeds = {
-        {1, 1}, {1, 2}, {2, 1}, {2, 2}
-    };
-    if (max_h >= 1) seeds.emplace_back(max_h, max_h);
-    if (max_h >= 2) seeds.emplace_back(max_h - 1, max_h - 1);
-    seeds.emplace_back(max_h, 1);
-    seeds.emplace_back(1, max_h);
-
-    /* ---- 4. a few random seeds (fixed RNG) -------------------------- */
-    std::mt19937 rnd(123456);
-    std::uniform_int_distribution<int> dist01(1, max_h);
-    for (int i = 0; i < 3; ++i) {
-        int h0 = dist01(rnd);
-        int h1 = dist01(rnd);
-        seeds.emplace_back(h0, h1);
-    }
-
-    /* ---- 5. deduplicate ---------------------------------------------- */
-    std::vector<std::pair<int, int>> uniq_seeds;
-    {
-        std::vector<bool> seen((max_h + 1) * (max_h + 1), false); // cheap, because max_h is at most a few thousands
-        for (auto &p : seeds) {
-            int h0 = std::max(1, std::min(max_h, p.first));
-            int h1 = std::max(1, std::min(max_h, p.second));
-            int idx = (h0 - 1) * (max_h + 1) + (h1 - 1);
-            if (!seen[idx]) {
-                seen[idx] = true;
-                uniq_seeds.emplace_back(h0, h1);
-            }
-        }
-    }
-    seeds.swap(uniq_seeds);
-
-    /* ---- 6. try every seed, keep the best one ----------------------- */
-    std::vector<int> best_H;
-    long long best_T = -1;
-
-    std::mt19937 rng(123456);              // same RNG for the fallback values
-    for (const auto &seed : seeds) {
-        int h0 = std::max(1, std::min(max_h, seed.first));
-        int h1 = std::max(1, std::min(max_h, seed.second));
-
-        auto [H, T] = greedy_builder(N, h0, h1, useful_vals, rng);
-        if (T > best_T) {
-            best_T = T;
-            best_H = H;                    // copy
-            if (best_T >= K) break;        // early exit when we already have enough
-        }
-    }
-
-    /* ---- 7. final clamping (safety) ---------------------------------- */
-    for (int &v : best_H) {
-        if (v < 1) v = 1;
-        else if (v > max_h) v = max_h;
-    }
-
-    if (static_cast<int>(best_H.size()) > N)
-        best_H.resize(N);
-    else if (static_cast<int>(best_H.size()) < N)
-        best_H.resize(N, 1);               // should not happen, but just in case
-
-    return best_H;
-}

ioi2025/triples-part2-subtask4.cpp

@@ -1,122 +0,0 @@
-#include <vector>
-#include <algorithm>   // std::min, std::max
-
-std::vector<int> construct_range(int M, int /* K */)
-{
-    // -----------------------------------------------------------------
-    // 1) decide the final length N and the maximal allowed height
-    // -----------------------------------------------------------------
-    int N = std::max(3, M);
-    if (N > M)                // this makes N = M when M < 3
-        N = M;
-
-    int max_allowed = N - 1;               // heights are in [1 .. max_allowed]
-
-    // radius of the sliding window
-    int D = std::min(3500, (N - 1) / 2);
-    int twoD = 2 * D;
-
-    // -----------------------------------------------------------------
-    // 2) data structures
-    // -----------------------------------------------------------------
-    std::vector<int> H(N, 0);
-    H[0] = 1;
-    if (N > 1)
-        H[1] = 2;                         // second peak gets a different height
-
-    // versioned counters for the “missing’’ height
-    std::vector<int> cnt(max_allowed + 1, 0);
-    std::vector<int> last(max_allowed + 1, 0);
-    int version = 0;                      // increased for every k
-    int total = 0;                        // lower bound on the number of triples
-
-    // -----------------------------------------------------------------
-    // 3) greedy construction
-    // -----------------------------------------------------------------
-    for (int k = 2; k < N; ++k) {
-        ++version;
-        int i_start = k - twoD;
-        if (i_start < 0) i_start = 0;
-
-        int best_cnt = 0;
-        int best_missing = 1;             // default if nothing is found
-
-        // scan the recent window [i_start, k)
-        for (int i = i_start; i < k; ++i) {
-            int hi = H[i];
-            int s  = k - i;                // distance i → k
-            if (hi >= s) continue;         // cannot be used, skip
-
-            // -------------------------------------------------------------
-            // left candidate: j = i + hi
-            // -------------------------------------------------------------
-            int j = i + hi;                // always < k because hi < s
-            int hj = H[j];
-            int a = hi;
-            int b = s - hi;
-            // (hj == a or hj == b or hj == s) and not (a != b && hi == hj)
-            if ((hj == a || hj == b || hj == s) &&
-                !(a != b && hi == hj)) {
-                int missing = 2 * s - hi - hj;
-                if (1 <= missing && missing <= max_allowed) {
-                    if (last[missing] != version) {
-                        cnt[missing] = 1;
-                        last[missing] = version;
-                    } else {
-                        ++cnt[missing];
-                    }
-                    int cur = cnt[missing];
-                    if (cur > best_cnt) {
-                        best_cnt   = cur;
-                        best_missing = missing;
-                    }
-                }
-            }
-
-            // -------------------------------------------------------------
-            // right candidate: j2 = k - hi   (different from the left one)
-            // -------------------------------------------------------------
-            int j2 = k - hi;
-            if (j2 > i && j2 != i + hi) {
-                hj = H[j2];
-                a = s - hi;
-                b = hi;
-                if ((hj == a || hj == b || hj == s) &&
-                    !(a != b && hi == hj)) {
-                    int missing = 2 * s - hi - hj;
-                    if (1 <= missing && missing <= max_allowed) {
-                        if (last[missing] != version) {
-                            cnt[missing] = 1;
-                            last[missing] = version;
-                        } else {
-                            ++cnt[missing];
-                        }
-                        int cur = cnt[missing];
-                        if (cur > best_cnt) {
-                            best_cnt   = cur;
-                            best_missing = missing;
-                        }
-                    }
-                }
-            }
-        } // end for i
-
-        // choose the best missing height (or 1 if nothing helped)
-        if (best_cnt > 0) {
-            H[k] = best_missing;
-            total += best_cnt;
-        } else {
-            H[k] = 1;
-        }
-    }
-
-    // -----------------------------------------------------------------
-    // 4) safety clamp (normally already satisfied)
-    // -----------------------------------------------------------------
-    for (int &v : H) {
-        if (v < 1)          v = 1;
-        else if (v > max_allowed) v = max_allowed;
-    }
-
-    return H;          // the constructed range
-}

ioi2025/triples-part2-subtask5.cpp

@@ -1,141 +0,0 @@
-#include <bits/stdc++.h>
-using namespace std;
-
-/* ------------------------------------------------------------
-   Greedy construction of one block
-   ------------------------------------------------------------ */
-static pair<vector<int>, long long> build_block(int B, int D)
-{
-    /* H[0] … H[B‑1] – heights, 1 ≤ H[i] ≤ B‑1 */
-    vector<int> H(B, 0);
-    H[0] = 1;
-    H[1] = 1;                     // any value 1 … B‑1 would work
-
-    const int max_allowed = B - 1;
-    int max_missing = 4 * D;
-    if (max_missing > max_allowed) max_missing = max_allowed;
-    if (max_missing < 1)            max_missing = 1;   // at least 1
-
-    /* versioned counters for “missing” values (size = max_missing+1)   */
-    vector<int> cnt(max_missing + 1, 0);
-    vector<int> last(max_missing + 1, 0);
-    int version = 0;
-
-    long long total = 0;          // total number of triples created in the block
-    const int twoD = 2 * D;
-
-    for (int k = 2; k < B; ++k) {
-        ++version;                // start a fresh counting round for this k
-        int best_cnt = 0;
-        int best_missing = 1;     // default – will be overwritten if we find a better one
-
-        /* the distance from the leftmost i we have to examine.
-           i must satisfy k‑i ≤ 2·D, i.e. i ≥ k‑2·D                */
-        int i_start = k - twoD;
-        if (i_start < 0) i_start = 0;
-
-        for (int i = i_start; i < k; ++i) {
-            int hi = H[i];
-            int s  = k - i;                // distance i → k
-            if (hi >= s) continue;         // hi must be smaller than the distance
-
-            /* ----------------------------------------------------
-               left candidate : j = i + hi   (the point that would be
-               exactly hi units to the right of i)
-               ---------------------------------------------------- */
-            int j = i + hi;
-            if (j < k) {
-                int a = hi;
-                int b = s - hi;
-                int hj = H[j];
-                if ( (hj == a || hj == b || hj == s) &&
-                     !(a != b && hi == hj) )                // avoid the “a≠b && hi==hj” case
-                {
-                    int missing = 2 * s - hi - hj;          // how many triples this choice would give
-                    if (1 <= missing && missing <= max_missing) {
-                        if (last[missing] != version) {
-                            cnt[missing] = 1;
-                            last[missing] = version;
-                        } else {
-                            ++cnt[missing];
-                        }
-                        if (cnt[missing] > best_cnt) {
-                            best_cnt = cnt[missing];
-                            best_missing = missing;
-                        }
-                    }
-                }
-            }
-
-            /* ----------------------------------------------------
-               right candidate : j2 = k – hi   (the point that would be
-               exactly hi units to the left of k)
-               ---------------------------------------------------- */
-            int j2 = k - hi;
-            if (j2 > i && j2 != i + hi) {      // must be a *different* position
-                int a = s - hi;
-                int b = hi;
-                int hj = H[j2];
-                if ( (hj == a || hj == b || hj == s) &&
-                     !(a != b && hi == hj) )
-                {
-                    int missing = 2 * s - hi - hj;
-                    if (1 <= missing && missing <= max_missing) {
-                        if (last[missing] != version) {
-                            cnt[missing] = 1;
-                            last[missing] = version;
-                        } else {
-                            ++cnt[missing];
-                        }
-                        if (cnt[missing] > best_cnt) {
-                            best_cnt = cnt[missing];
-                            best_missing = missing;
-                        }
-                    }
-                }
-            }
-        }   // end for i
-
-        if (best_cnt > 0) {
-            H[k] = best_missing;
-            total += best_cnt;
-        } else {
-            H[k] = 1;               // fall‑back – the smallest admissible value
-        }
-    }   // end for k
-
-    return {H, total};
-}
-
-/* ------------------------------------------------------------
-   Whole range construction
-   ------------------------------------------------------------ */
-vector<int> construct_range(int M, int K)
-{
-    int N = M;
-    if (N < 3) N = 3; 
-
-    /* block size – a good compromise between speed and strength */
-    int B = min(N, 25000);
-
-    /* window size – large enough to create many triples but not too large */
-    int D = (B - 1) / 2;
-    if (D > 4000) D = 4000;
-    if (D == 0)   D = 1;
-
-    /* Build one block and repeat it to fill the whole range   */
-    auto [block, /*unused*/] = build_block(B, D);
-
-    int reps = N / B;
-    int rest = N % B;
-
-    vector<int> H;
-    H.reserve(N);
-    for (int r = 0; r < reps; ++r) H.insert(H.end(), block.begin(), block.end());
-    H.insert(H.end(), block.begin(), block.begin() + rest);   // add the leftover part
-    H.resize(N);                                              // ensure length exactly N
-
-    /* At this point every H[i] already satisfies
-       1 ≤ H[i] ≤ B‑1 ≤ N‑1, i.e. the required bounds.            */
-    return H;
-}

ioi2025/triples-part2-subtask6.cpp

@@ -1,131 +0,0 @@
-#include <vector>
-#include <algorithm>   // for std::min, std::max
-#include <cstddef>     // for std::size_t
-#include <cassert>
-
-static std::vector<int> greedy_block(int B, int D)
-{
-    /*  H will hold the heights for the block, 0‑based indices               */
-    std::vector<int> H(B, 0);
-
-    const int max_missing = B - 1;                 // allowed values: 1 … max_missing
-    const int twoD = 2 * D;
-
-    /* temporary counters, version stamps and the version counter            */
-    std::vector<int> cnt(max_missing + 1, 0);
-    std::vector<int> last(max_missing + 1, 0);
-    int version = 0;
-
-    for (int k = 0; k < B; ++k) {
-        ++version;                                 // start a new “window”
-
-        int i_start = k - twoD;
-        if (i_start < 0) i_start = 0;
-
-        int best_cnt = 0;
-        int best_missing = 1;                      // any legal value if we cannot improve
-
-        for (int i = i_start; i < k; ++i) {
-            int hi = H[i];
-            int s = k - i;                          // distance i → k
-            if (hi >= s) continue;                  // hi cannot be used
-
-            /* ----------- left side: j = i + hi -------------------------- */
-            int j = i + hi;
-            if (j < k) {
-                int hj = H[j];
-                int a = hi;
-                int b = s - hi;
-
-                bool ok = (hj == a) || (hj == b) || (hj == s);
-                ok = ok && !(a != b && hi == hj);  // forbid the symmetric case
-
-                if (ok) {
-                    int miss = 2 * s - hi - hj;    // the “missing” value
-                    if (miss >= 1 && miss <= max_missing) {
-                        if (last[miss] != version) {
-                            cnt[miss] = 1;
-                            last[miss] = version;
-                        } else {
-                            ++cnt[miss];
-                        }
-
-                        if (cnt[miss] > best_cnt) {
-                            best_cnt = cnt[miss];
-                            best_missing = miss;
-                        }
-                    }
-                }
-            }
-
-            /* ----------- right side: j = k - hi ------------------------- */
-            int j2 = k - hi;
-            if (j2 > i && j2 != i + hi) {
-                int hj = H[j2];
-                int a = s - hi;
-                int b = hi;
-
-                bool ok = (hj == a) || (hj == b) || (hj == s);
-                ok = ok && !(a != b && hi == hj);  // same symmetric check
-
-                if (ok) {
-                    int miss = 2 * s - hi - hj;
-                    if (miss >= 1 && miss <= max_missing) {
-                        if (last[miss] != version) {
-                            cnt[miss] = 1;
-                            last[miss] = version;
-                        } else {
-                            ++cnt[miss];
-                        }
-
-                        if (cnt[miss] > best_cnt) {
-                            best_cnt = cnt[miss];
-                            best_missing = miss;
-                        }
-                    }
-                }
-            }
-        }   // end of inner loop over i
-
-        /* write the height for position k */
-        if (best_cnt > 0)
-            H[k] = best_missing;
-        else
-            H[k] = 1;                               // any legal value is fine
-    }
-
-    return H;
-}
-
-/* ------------------------------------------------------------------ */
-/*  Public API – exactly the signature required by the task            */
-/* ------------------------------------------------------------------ */
-std::vector<int> construct_range(int M, int K)
-{
-    (void)K;   // avoid unused‑parameter warning
-
-    const int N = std::max(3, M);               // final length of the range
-    const int B = std::min(N, 20000);           // block size (greedy works better with a limit)
-    const int D = std::min(4000, (B - 1) / 2);   // half‑window size
-
-    std::vector<int> block = greedy_block(B, D);
-
-    const int repeats = N / B;
-    const int rest    = N % B;
-
-    std::vector<int> H;
-    H.reserve(N);
-    for (int r = 0; r < repeats; ++r)
-        H.insert(H.end(), block.begin(), block.end());
-    H.insert(H.end(), block.begin(), block.begin() + rest);   // the possible tail
-
-    /* Clamp to the allowed interval [1, N‑1] – this is a harmless safety net.   */
-    const int max_allowed = N - 1;
-    for (int &v : H) {
-        if (v < 1) v = 1;
-        else if (v > max_allowed) v = max_allowed;
-    }
-
-    H.resize(N);   // just in case something went wrong (should already be N)
-    return H;
-}

ioi2025/worldmap.cpp

@@ -1,202 +0,0 @@
-#include <bits/stdc++.h>
-using namespace std;
-
-/* ----------------------------------------------------------------------
-   create_map
-   ---------------------------------------------------------------------- */
-vector<vector<int>> create_map(int N, int M,
-                               vector<int> A, vector<int> B)
-{
-    /* --------------------------------------------------------------
-       0‑based adjacency matrix and list of edges
-       -------------------------------------------------------------- */
-    vector<vector<char>> adj(N, vector<char>(N, 0));
-    vector<pair<int,int>> edges;
-    edges.reserve(M);
-
-    for (int k = 0; k < M; ++k) {
-        int u = A[k] - 1;                 // to 0‑based
-        int v = B[k] - 1;
-        adj[u][v] = adj[v][u] = 1;
-        edges.emplace_back(u, v);
-    }
-    const int M_edges = static_cast<int>(edges.size());
-
-    /* --------------------------------------------------------------
-       edge_id[u][v]  (only for u < v)  →  index of the edge in `edges`
-       -------------------------------------------------------------- */
-    vector<vector<int>> edge_id(N, vector<int>(N, -1));
-    for (int idx = 0; idx < M_edges; ++idx) {
-        int u = edges[idx].first;
-        int v = edges[idx].second;
-        if (u > v) swap(u, v);
-        edge_id[u][v] = idx;
-    }
-
-    /* --------------------------------------------------------------
-       neighbour_mask[i] – bit mask of colours that may be placed
-       next to a cell whose colour is i (loops + the 4‑neighbours)
-       -------------------------------------------------------------- */
-    vector<uint64_t> neighbour_mask(N, 0);
-    for (int i = 0; i < N; ++i) {
-        uint64_t mask = 1ULL << i;                // the colour itself
-        for (int j = 0; j < N; ++j)
-            if (adj[i][j]) mask |= (1ULL << j);
-        neighbour_mask[i] = mask;
-    }
-    const uint64_t all_mask = (N == 64) ? ~0ULL : ((1ULL << N) - 1ULL);
-
-    /* --------------------------------------------------------------
-       board size K (smallest board that could possibly work)
-       -------------------------------------------------------------- */
-    int K0 = static_cast<int>(sqrt((double)N));
-    while (K0 * K0 < N) ++K0;                     // ceil(sqrt(N))
-
-    int Kedge = 0;
-    while (2 * Kedge * (Kedge - 1) < M_edges) ++Kedge;
-
-    int K = max(K0, Kedge);
-    K = max(K, 2 * N);                            // a bit of spare space
-    if (K > 240) K = 240;                         // safety cap
-
-    /* --------------------------------------------------------------
-       random generator – used for the “several random attempts”
-       -------------------------------------------------------------- */
-    std::mt19937 rng(
-        static_cast<unsigned>(chrono::steady_clock::now()
-                                 .time_since_epoch()
-                                 .count()));
-
-    const int MAX_ATTEMPTS = 500;
-
-    for (int attempt = 0; attempt < MAX_ATTEMPTS; ++attempt) {
-        /* ----- fresh board for this attempt ---------------------- */
-        vector<vector<int>> grid(K, vector<int>(K, -1));
-        uint64_t used_colours = 0;                // bit mask of colours already used
-        vector<char> covered(M_edges, 0);
-        int covered_cnt = 0;
-        bool ok = true;
-
-        /* ----- greedy filling of the K×K board ------------------- */
-        for (int i = 0; i < K && ok; ++i) {
-            for (int j = 0; j < K; ++j) {
-                uint64_t allowed = all_mask;      // colours allowed by neighbours
-
-                if (i > 0) {
-                    int top = grid[i-1][j];
-                    allowed &= neighbour_mask[top];
-                }
-                if (j > 0) {
-                    int left = grid[i][j-1];
-                    allowed &= neighbour_mask[left];
-                }
-
-                if (allowed == 0) {               // dead end → restart whole board
-                    ok = false;
-                    break;
-                }
-
-                uint64_t missing = all_mask & ~used_colours;
-                uint64_t missing_allowed = allowed & missing;
-
-                /* ----- pick the colour with the best gain ---------- */
-                int best_gain = -1;
-                vector<int> candidates;
-
-                uint64_t mask = allowed;
-                while (mask) {
-                    uint64_t lsb = mask & -mask;
-                    int c = __builtin_ctzll(lsb);   // colour index (0‑based)
-                    mask ^= lsb;
-
-                    int gain = 0;
-
-                    /* edges that would become covered if we use colour c */
-                    if (i > 0) {
-                        int nt = grid[i-1][j];
-                        if (nt != c && adj[nt][c]) {
-                            int u = min(nt, c), v = max(nt, c);
-                            int eid = edge_id[u][v];
-                            if (eid != -1 && !covered[eid]) ++gain;
-                        }
-                    }
-                    if (j > 0) {
-                        int nl = grid[i][j-1];
-                        if (nl != c && adj[nl][c]) {
-                            int u = min(nl, c), v = max(nl, c);
-                            int eid = edge_id[u][v];
-                            if (eid != -1 && !covered[eid]) ++gain;
-                        }
-                    }
-
-                    /* huge bonus for a colour that has never been used */
-                    if (missing_allowed && ( (1ULL << c) & missing_allowed ))
-                        gain += 1000;
-
-                    if (gain > best_gain) {
-                        best_gain = gain;
-                        candidates.clear();
-                        candidates.push_back(c);
-                    } else if (gain == best_gain) {
-                        candidates.push_back(c);
-                    }
-                }   // end while(mask)
-
-                /* ----- random tie‑break among the best candidates --- */
-                uniform_int_distribution<int> dist(0, (int)candidates.size() - 1);
-                int chosen = candidates[dist(rng)];
-
-                /* ----- store the colour -------------------------------- */
-                grid[i][j] = chosen;
-                used_colours |= (1ULL << chosen);
-
-                /* ----- mark newly created edges ------------------------ */
-                if (i > 0) {
-                    int nt = grid[i-1][j];
-                    if (nt != chosen && adj[nt][chosen]) {
-                        int u = min(nt, chosen), v = max(nt, chosen);
-                        int eid = edge_id[u][v];
-                        if (eid != -1 && !covered[eid]) {
-                            covered[eid] = 1;
-                            ++covered_cnt;
-                        }
-                    }
-                }
-                if (j > 0) {
-                    int nl = grid[i][j-1];
-                    if (nl != chosen && adj[nl][chosen]) {
-                        int u = min(nl, chosen), v = max(nl, chosen);
-                        int eid = edge_id[u][v];
-                        if (eid != -1 && !covered[eid]) {
-                            covered[eid] = 1;
-                            ++covered_cnt;
-                        }
-                    }
-                }
-            }   // end for j
-        }       // end for i
-
-        if (!ok) continue;
-        if (used_colours != all_mask) continue;        // not all colours used
-        if (covered_cnt != M_edges) continue;          // some edges still uncovered
-
-        /* ----- SUCCESS – convert to 1‑based output ---------------- */
-        vector<vector<int>> answer(K, vector<int>(K));
-        for (int i = 0; i < K; ++i)
-            for (int j = 0; j < K; ++j)
-                answer[i][j] = grid[i][j] + 1;          // back to 1‑based
-        return answer;
-    }   // end for attempts
-
-    /* --------------------------------------------------------------
-       Very unlikely fallback – deterministic construction
-       -------------------------------------------------------------- */
-    int Kfallback = max(2 * N, 2);
-    Kfallback = min(Kfallback, 240);
-    vector<vector<int>> grid(Kfallback, vector<int>(Kfallback, 1));
-    int limit = min(N, Kfallback);
-    for (int i = 0; i < limit; ++i)
-        grid[i][i] = i + 1;                     // put distinct colours on the diagonal
-
-    return grid;
-}