更新

exercise/exercise/100.c

@@ -0,0 +1,34 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef long long ll;
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n; if (scanf("%d", &n) != 1) return 0;
+    int a, b; if (scanf("%d %d", &a, &b) != 2) return 0;
+    int *val = (int*)malloc((size_t)(n + 1) * sizeof(int));
+    for (int i = 1; i <= n; ++i) scanf("%d", &val[i]);
+    ll *dp = (ll*)malloc((size_t)(n + 1) * sizeof(ll));
+    for (int i = 0; i <= n; ++i) dp[i] = (ll)4e18;
+    dp[0] = 0;
+    for (int i = 1; i <= n; ++i){
+        int mn = val[i], mx = val[i];
+        for (int j = i; j >= 1; --j){
+            if (val[j] < mn) mn = val[j];
+            if (val[j] > mx) mx = val[j];
+            ll cost = dp[j-1] + (ll)a + (ll)b * (ll)(mx - mn) * (ll)(mx - mn);
+            if (cost < dp[i]) dp[i] = cost;
+        }
+    }
+    printf("%lld\n", dp[n]);
+    free(dp); free(val);
+    return 0;
+}

exercise/exercise/101.c

@@ -0,0 +1,66 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef unsigned long long ull;
+
+typedef struct { ull l, r; } Interval;
+
+static int cmpL(const void *a, const void *b){
+    const Interval *x = (const Interval*)a;
+    const Interval *y = (const Interval*)b;
+    if (x->l < y->l) return -1;
+    if (x->l > y->l) return 1;
+    if (x->r < y->r) return -1;
+    if (x->r > y->r) return 1;
+    return 0;
+}
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    size_t cap = 1 << 16;
+    size_t n = 0;
+    Interval *arr = (Interval*)malloc(cap * sizeof(Interval));
+    ull A, B;
+    while (scanf("%llu %llu", &A, &B) == 2){
+        if (n == cap){
+            cap <<= 1;
+            Interval *tmp = (Interval*)realloc(arr, cap * sizeof(Interval));
+            if (!tmp){ free(arr); return 0; }
+            arr = tmp;
+        }
+        ull l = A < B ? A : B;
+        ull r = A > B ? A : B;
+        arr[n].l = l;
+        arr[n].r = r;
+        ++n;
+    }
+    if (n < 2){
+        printf("0\n");
+        free(arr);
+        return 0;
+    }
+    qsort(arr, n, sizeof(Interval), cmpL);
+    ull ans = 0ULL;
+    ull max_r_prev = arr[0].r;
+    for (size_t i = 1; i < n; ++i){
+        ull l = arr[i].l;
+        ull r = arr[i].r;
+        ull M = r < max_r_prev ? r : max_r_prev;
+        if (M >= l){
+            ull len = M - l + 1ULL;
+            if (len > ans) ans = len;
+        }
+        if (r > max_r_prev) max_r_prev = r;
+    }
+    printf("%llu\n", ans);
+    free(arr);
+    return 0;
+}

exercise/exercise/102.c

@@ -0,0 +1,81 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef unsigned long long ull;
+
+static char* dupstr(const char* s){ size_t len = strlen(s); char* p = (char*)malloc(len + 1); memcpy(p, s, len + 1); return p; }
+
+typedef struct {
+    char **keys;
+    char **vals;
+    unsigned char *used;
+    size_t cap;
+} Map;
+
+static ull fnv1a(const char *s){
+    ull h = 1469598103934665603ULL;
+    while (*s){ h ^= (unsigned char)(*s++); h *= 1099511628211ULL; }
+    return h;
+}
+
+static void map_init(Map *m, size_t n){ size_t c = 1; while (c < (n << 1)) c <<= 1; m->cap = c; m->keys = (char**)calloc(c, sizeof(char*)); m->vals = (char**)calloc(c, sizeof(char*)); m->used = (unsigned char*)calloc(c, 1); }
+
+static void map_put(Map *m, const char *k, const char *v){ size_t mask = m->cap - 1; size_t i = (size_t)(fnv1a(k) & mask); for (;;){ if (!m->used[i]){ m->used[i] = 1; m->keys[i] = dupstr(k); m->vals[i] = dupstr(v); return; } if (strcmp(m->keys[i], k) == 0){ free(m->vals[i]); m->vals[i] = dupstr(v); return; } i = (i + 1) & mask; } }
+
+static const char* map_get(Map *m, const char *k){ size_t mask = m->cap - 1; size_t i = (size_t)(fnv1a(k) & mask); for (;;){ if (!m->used[i]) return NULL; if (strcmp(m->keys[i], k) == 0) return m->vals[i]; i = (i + 1) & mask; } }
+
+static void map_free(Map *m){ for (size_t i = 0; i < m->cap; ++i){ if (m->used[i]){ free(m->keys[i]); free(m->vals[i]); } } free(m->used); free(m->keys); free(m->vals); }
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int M; if (scanf("%d", &M) != 1) return 0;
+    Map mp; map_init(&mp, (size_t)(M > 0 ? M : 1));
+    char s1[4096], s2[4096];
+    for (int i = 0; i < M; ++i){ if (scanf("%4095s %4095s", s1, s2) != 2) return 0; map_put(&mp, s1, s2); }
+    int L; if (scanf("%d", &L) != 1){ map_free(&mp); return 0; }
+    int ch; do { ch = getchar(); } while (ch != '\n' && ch != EOF);
+    char *line = NULL; size_t bufcap = 0; ssize_t linelen;
+    for (int li = 0; li < L; ++li){
+        size_t len = 0; bufcap = 4096; line = (char*)malloc(bufcap);
+        int c;
+        while ((c = getchar()) != EOF && c != '\n'){
+            if (len + 1 >= bufcap){ bufcap <<= 1; line = (char*)realloc(line, bufcap); }
+            line[len++] = (char)c;
+        }
+        line[len] = '\0';
+        char *out = (char*)malloc(len * 2 + 16);
+        size_t outlen = 0;
+        const char *p = line;
+        while (*p){
+            while (*p && (*p == ' ' || *p == '\t' || *p == '\r')) ++p;
+            if (!*p) break;
+            const char *q = p;
+            while (*q && *q != ' ' && *q != '\t' && *q != '\r') ++q;
+            size_t toklen = (size_t)(q - p);
+            char *tok = (char*)malloc(toklen + 1);
+            memcpy(tok, p, toklen); tok[toklen] = '\0';
+            const char *rep = map_get(&mp, tok);
+            const char *emit = rep ? rep : tok;
+            size_t emitlen = strlen(emit);
+            if (outlen) out[outlen++] = ' ';
+            if (outlen + emitlen + 1 >= bufcap){ size_t need = outlen + emitlen + 1; size_t nc = bufcap; while (nc < need) nc <<= 1; out = (char*)realloc(out, nc); bufcap = nc; }
+            memcpy(out + outlen, emit, emitlen); outlen += emitlen; out[outlen] = '\0';
+            free(tok);
+            p = q;
+        }
+        printf("%s\n", out);
+        free(out);
+        free(line);
+        if (c == EOF) break;
+    }
+    map_free(&mp);
+    return 0;
+}

exercise/exercise/103.c

@@ -0,0 +1,48 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef unsigned long long ull;
+
+static char* dupstr(const char* s){ size_t len = strlen(s); char* p = (char*)malloc(len + 1); memcpy(p, s, len + 1); return p; }
+
+typedef struct {
+    char **keys;
+    int *cnt;
+    unsigned char *used;
+    size_t cap;
+} MapC;
+
+static ull fnv1a(const char *s){ ull h = 1469598103934665603ULL; while (*s){ h ^= (unsigned char)(*s++); h *= 1099511628211ULL; } return h; }
+
+static void map_init(MapC *m, size_t n){ size_t c = 1; while (c < (n << 1)) c <<= 1; m->cap = c; m->keys = (char**)calloc(c, sizeof(char*)); m->cnt = (int*)calloc(c, sizeof(int)); m->used = (unsigned char*)calloc(c, 1); }
+
+static void map_inc(MapC *m, const char *k){ size_t mask = m->cap - 1; size_t i = (size_t)(fnv1a(k) & mask); for (;;){ if (!m->used[i]){ m->used[i] = 1; m->keys[i] = dupstr(k); m->cnt[i] = 1; return; } if (strcmp(m->keys[i], k) == 0){ ++m->cnt[i]; return; } i = (i + 1) & mask; } }
+
+static int map_get_cnt(MapC *m, const char *k){ size_t mask = m->cap - 1; size_t i = (size_t)(fnv1a(k) & mask); for (;;){ if (!m->used[i]) return 0; if (strcmp(m->keys[i], k) == 0) return m->cnt[i]; i = (i + 1) & mask; } }
+
+static void map_free(MapC *m){ for (size_t i = 0; i < m->cap; ++i){ if (m->used[i]) free(m->keys[i]); } free(m->used); free(m->cnt); free(m->keys); }
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int N; if (scanf("%d", &N) != 1) return 0;
+    MapC mp; map_init(&mp, (size_t)(N > 0 ? N : 1));
+    char **tks = (char**)malloc((size_t)N * sizeof(char*));
+    char buf[4096];
+    for (int i = 0; i < N; ++i){ if (scanf("%4095s", buf) != 1){ N = i; break; } tks[i] = dupstr(buf); map_inc(&mp, tks[i]); }
+    int minc = 0x7fffffff; for (size_t i = 0; i < mp.cap; ++i){ if (mp.used[i]){ if (mp.cnt[i] < minc) minc = mp.cnt[i]; } }
+    int first = 1;
+    for (int i = 0; i < N; ++i){ int c = map_get_cnt(&mp, tks[i]); if (c != minc){ if (!first) putchar(' '); first = 0; fputs(tks[i], stdout); } }
+    putchar('\n');
+    for (int i = 0; i < N; ++i) free(tks[i]);
+    free(tks);
+    map_free(&mp);
+    return 0;
+}

exercise/exercise/104.c

@@ -0,0 +1,72 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+static int M;
+
+static int imin(int a, int b){ return a < b ? a : b; }
+static int imax(int a, int b){ return a > b ? a : b; }
+
+static int S;
+static int *col;
+static int *cnt;
+static int *memo;
+
+static int idx(int l, int r, int k){ return ((l - 1) * S + (r - 1)) * M + k; }
+
+static int F(int l, int r, int k){
+    if (k >= M) k = M - 1;
+    int id = idx(l, r, k);
+    int v = memo[id];
+    if (v != -1) return v;
+    if (l == r){
+        int L = cnt[r] + k;
+        v = (L >= M) ? 0 : (M - L);
+        memo[id] = v;
+        return v;
+    }
+    int need = cnt[r] + k;
+    int best = F(l, r - 1, 0) + ((need >= M) ? 0 : (M - need));
+    for (int i = l; i <= r - 1; ++i){
+        if (col[i] == col[r]){
+            int nk = cnt[r] + k;
+            if (nk >= M) nk = M - 1;
+            int cand = F(l, i, nk) + F(i + 1, r - 1, 0);
+            if (cand < best) best = cand;
+        }
+    }
+    memo[id] = best;
+    return best;
+}
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    char s[256];
+    while (scanf("%d", &M) == 1){
+        if (scanf("%255s", s) != 1) break;
+        int n = (int)strlen(s);
+        col = (int*)malloc((size_t)(n + 1) * sizeof(int));
+        cnt = (int*)malloc((size_t)(n + 1) * sizeof(int));
+        S = 0;
+        for (int i = 0; i < n;){
+            int j = i;
+            while (j < n && s[j] == s[i]) ++j;
+            col[++S] = (int)s[i];
+            cnt[S] = j - i;
+            i = j;
+        }
+        memo = (int*)malloc((size_t)S * (size_t)S * (size_t)M * sizeof(int));
+        for (int i = 0; i < S * S * M; ++i) memo[i] = -1;
+        int ans = F(1, S, 0);
+        printf("%d\n", ans);
+        free(memo); free(cnt); free(col);
+    }
+    return 0;
+}

exercise/exercise/105.c

@@ -0,0 +1,101 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef long long ll;
+
+typedef struct { ll x; ll a; } Item;
+
+static int cmp_item(const void *p, const void *q){
+    const Item *A = (const Item*)p;
+    const Item *B = (const Item*)q;
+    if (A->x < B->x) return -1;
+    if (A->x > B->x) return 1;
+    return 0;
+}
+
+static int upper_less_ll(const ll *arr, int n, ll key){
+    int l = 1, r = n, ans = 0;
+    while (l <= r){
+        int m = (l + r) >> 1;
+        if (arr[m] < key){ ans = m; l = m + 1; }
+        else r = m - 1;
+    }
+    return ans;
+}
+
+typedef struct { int val; int idx; } Node;
+
+static Node *seg;
+static int N;
+
+static Node merge(Node a, Node b){
+    if (a.val >= b.val) return a; else return b;
+}
+
+static void build(int p, int l, int r, const int *R){
+    if (l == r){ seg[p].val = R[l]; seg[p].idx = l; return; }
+    int m = (l + r) >> 1;
+    build(p<<1, l, m, R);
+    build(p<<1|1, m+1, r, R);
+    seg[p] = merge(seg[p<<1], seg[p<<1|1]);
+}
+
+static Node query(int p, int l, int r, int ql, int qr){
+    if (ql <= l && r <= qr) return seg[p];
+    int m = (l + r) >> 1;
+    if (qr <= m) return query(p<<1, l, m, ql, qr);
+    if (ql > m) return query(p<<1|1, m+1, r, ql, qr);
+    Node a = query(p<<1, l, m, ql, qr);
+    Node b = query(p<<1|1, m+1, r, ql, qr);
+    return merge(a, b);
+}
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n; if (scanf("%d", &n) != 1) return 0;
+    Item *arr = (Item*)malloc((size_t)(n + 1) * sizeof(Item));
+    for (int i = 1; i <= n; ++i){ ll xi, ai; scanf("%lld %lld", &xi, &ai); arr[i].x = xi; arr[i].a = ai; }
+    qsort(arr + 1, n, sizeof(Item), cmp_item);
+    ll *xs = (ll*)malloc((size_t)(n + 1) * sizeof(ll));
+    for (int i = 1; i <= n; ++i) xs[i] = arr[i].x;
+    int *R = (int*)malloc((size_t)(n + 1) * sizeof(int));
+    for (int i = 1; i <= n; ++i){ ll key = arr[i].x + arr[i].a; R[i] = upper_less_ll(xs, n, key); }
+    N = n; seg = (Node*)malloc((size_t)(4 * N + 8) * sizeof(Node));
+    build(1, 1, N, R);
+    int *E = (int*)calloc((size_t)(n + 2), sizeof(int));
+    for (int i = 1; i <= n; ++i){
+        int t = i;
+        int stsz = 0;
+        int *stack = (int*)malloc((size_t)(n - i + 2) * sizeof(int));
+        while (E[t] == 0){
+            int rt = R[t];
+            Node nd = query(1, 1, N, t, rt);
+            if (nd.val == rt){ E[t] = rt + 1; break; }
+            stack[stsz++] = t;
+            t = nd.idx;
+        }
+        int res = E[t];
+        while (stsz){ E[stack[--stsz]] = res; }
+        free(stack);
+    }
+    const int MOD = 998244353;
+    int *dp = (int*)calloc((size_t)(n + 2), sizeof(int));
+    dp[n+1] = 1;
+    for (int i = n; i >= 1; --i){
+        int a1 = dp[i+1];
+        int a2 = dp[E[i]];
+        int s = a1 + a2; if (s >= MOD) s -= MOD;
+        dp[i] = s;
+    }
+    printf("%d\n", dp[1]);
+    free(dp); free(E); free(seg); free(R); free(xs); free(arr);
+    return 0;
+}

exercise/exercise/106.c

@@ -0,0 +1,52 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef struct { int to, next; } Edge;
+
+static int *head;
+static Edge *edges;
+static int ecnt;
+
+static void add_edge(int u, int v){ edges[ecnt].to = v; edges[ecnt].next = head[u]; head[u] = ecnt++; }
+
+static int cmp_desc(const void *a, const void *b){ int x = *(const int*)a, y = *(const int*)b; return y - x; }
+
+static int dfs(int u, int p){
+    int cnt = 0;
+    for (int e = head[u]; e != -1; e = edges[e].next){ int v = edges[e].to; if (v == p) continue; ++cnt; }
+    if (cnt == 0) return 0;
+    int *ts = (int*)malloc((size_t)cnt * sizeof(int));
+    int k = 0;
+    for (int e = head[u]; e != -1; e = edges[e].next){ int v = edges[e].to; if (v == p) continue; ts[k++] = dfs(v, u); }
+    qsort(ts, (size_t)cnt, sizeof(int), cmp_desc);
+    int best = 0;
+    for (int i = 0; i < cnt; ++i){ int t = 1 + i + ts[i]; if (t > best) best = t; }
+    free(ts);
+    return best;
+}
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int N; if (scanf("%d", &N) != 1) return 0;
+    head = (int*)malloc(((size_t)N + 1) * sizeof(int));
+    for (int i = 1; i <= N; ++i) head[i] = -1;
+    edges = (Edge*)malloc((size_t)(2 * (N - 1)) * sizeof(Edge));
+    ecnt = 0;
+    for (int i = 2; i <= N; ++i){ int p; scanf("%d", &p); add_edge(i, p); add_edge(p, i); }
+    int *times = (int*)malloc(((size_t)N + 1) * sizeof(int));
+    int best = 1 << 30;
+    for (int s = 1; s <= N; ++s){ int t = dfs(s, 0) + 1; times[s] = t; if (t < best) best = t; }
+    printf("%d\n", best);
+    int first = 1;
+    for (int s = 1; s <= N; ++s){ if (times[s] == best){ if (!first) putchar(' '); first = 0; printf("%d", s); } }
+    putchar('\n');
+    free(times); free(edges); free(head);
+    return 0;
+}

exercise/exercise/107.c

@@ -0,0 +1,58 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef struct { int to, next; } Edge;
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n; if (scanf("%d", &n) != 1) return 0;
+    int m = n - 1;
+    int *head = (int*)malloc(((size_t)n + 1) * sizeof(int));
+    for (int i = 1; i <= n; ++i) head[i] = -1;
+    Edge *edges = (Edge*)malloc((size_t)(2 * m) * sizeof(Edge));
+    int ecnt = 0;
+    for (int i = 0; i < m; ++i){ int x, y; scanf("%d %d", &x, &y); edges[ecnt] = (Edge){ y, head[x] }; head[x] = ecnt++; edges[ecnt] = (Edge){ x, head[y] }; head[y] = ecnt++; }
+    int *parent = (int*)malloc(((size_t)n + 1) * sizeof(int));
+    int *iter = (int*)malloc(((size_t)n + 1) * sizeof(int));
+    char *vis = (char*)calloc((size_t)n + 1, 1);
+    int *order = (int*)malloc((size_t)n * sizeof(int));
+    int *stk = (int*)malloc((size_t)n * sizeof(int));
+    int top = -1, ord = 0;
+    parent[1] = 0; iter[1] = head[1]; vis[1] = 1; stk[++top] = 1;
+    while (top >= 0){
+        int u = stk[top];
+        int e = iter[u];
+        if (e != -1){
+            iter[u] = edges[e].next;
+            int v = edges[e].to;
+            if (v == parent[u]) continue;
+            if (!vis[v]){ vis[v] = 1; parent[v] = u; iter[v] = head[v]; stk[++top] = v; }
+        } else {
+            order[ord++] = u; --top;
+        }
+    }
+    int *dp0 = (int*)calloc((size_t)n + 1, sizeof(int));
+    int *dp1 = (int*)malloc(((size_t)n + 1) * sizeof(int));
+    const int NEG = -1000000000;
+    for (int i = 1; i <= n; ++i) dp1[i] = NEG;
+    for (int t = 0; t < ord; ++t){
+        int u = order[t];
+        int base = 0;
+        for (int e = head[u]; e != -1; e = edges[e].next){ int v = edges[e].to; if (v == parent[u]) continue; int mv = dp0[v] > dp1[v] ? dp0[v] : dp1[v]; base += mv; }
+        dp0[u] = base;
+        int best = NEG;
+        for (int e = head[u]; e != -1; e = edges[e].next){ int v = edges[e].to; if (v == parent[u]) continue; int mv = dp0[v] > dp1[v] ? dp0[v] : dp1[v]; int cand = base - mv + dp0[v] + 1; if (cand > best) best = cand; }
+        dp1[u] = best;
+    }
+    int ans = dp0[1] > dp1[1] ? dp0[1] : dp1[1];
+    printf("%d\n", ans);
+    free(dp1); free(dp0); free(stk); free(order); free(vis); free(iter); free(parent); free(edges); free(head);
+    return 0;
+}

exercise/exercise/108.c

@@ -0,0 +1,17 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n; if (scanf("%d", &n) != 1) return 0;
+    for (int i = 0; i < n - 1; ++i){ int x, y; scanf("%d %d", &x, &y); }
+    if ((n & 1) == 1) puts("YES"); else puts("NO");
+    return 0;
+}

exercise/exercise/109.c

@@ -0,0 +1,52 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef struct { int to, next; } Edge;
+
+static int *head;
+static Edge *edges;
+static int ecnt;
+
+static void add_edge(int u, int v){ edges[ecnt].to = v; edges[ecnt].next = head[u]; head[u] = ecnt++; }
+
+static int cmp_desc(const void *a, const void *b){ int x = *(const int*)a, y = *(const int*)b; return y - x; }
+
+static int dfs(int u, int p){
+    int cnt = 0;
+    for (int e = head[u]; e != -1; e = edges[e].next){ int v = edges[e].to; if (v == p) continue; ++cnt; }
+    if (cnt == 0) return 0;
+    int *ts = (int*)malloc((size_t)cnt * sizeof(int));
+    int k = 0;
+    for (int e = head[u]; e != -1; e = edges[e].next){ int v = edges[e].to; if (v == p) continue; ts[k++] = dfs(v, u); }
+    qsort(ts, (size_t)cnt, sizeof(int), cmp_desc);
+    int best = 0;
+    for (int i = 0; i < cnt; ++i){ int t = 1 + i + ts[i]; if (t > best) best = t; }
+    free(ts);
+    return best;
+}
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int N; if (scanf("%d", &N) != 1) return 0;
+    head = (int*)malloc(((size_t)N + 1) * sizeof(int));
+    for (int i = 1; i <= N; ++i) head[i] = -1;
+    edges = (Edge*)malloc((size_t)(2 * (N - 1)) * sizeof(Edge));
+    ecnt = 0;
+    for (int i = 2; i <= N; ++i){ int p; scanf("%d", &p); add_edge(i, p); add_edge(p, i); }
+    int *times = (int*)malloc(((size_t)N + 1) * sizeof(int));
+    int best = 1 << 30;
+    for (int s = 1; s <= N; ++s){ int t = dfs(s, 0) + 1; times[s] = t; if (t < best) best = t; }
+    printf("%d\n", best);
+    int first = 1;
+    for (int s = 1; s <= N; ++s){ if (times[s] == best){ if (!first) putchar(' '); first = 0; printf("%d", s); } }
+    putchar('\n');
+    free(times); free(edges); free(head);
+    return 0;
+}

exercise/exercise/110.c

@@ -0,0 +1,69 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef unsigned int u32;
+
+static u32 press[25];
+
+static void init_masks(void){
+    for (int r = 0; r < 5; ++r){
+        for (int c = 0; c < 5; ++c){
+            int p = r * 5 + c;
+            u32 m = 0U;
+            m |= (1U << p);
+            if (r > 0) m |= (1U << (p - 5));
+            if (r < 4) m |= (1U << (p + 5));
+            if (c > 0) m |= (1U << (p - 1));
+            if (c < 4) m |= (1U << (p + 1));
+            press[p] = m;
+        }
+    }
+}
+
+typedef struct { u32 key; unsigned char used; unsigned char val; } Entry;
+
+static Entry *map;
+static size_t cap;
+
+static void map_init(size_t need){ size_t c = 1; while (c < need) c <<= 1; cap = c; map = (Entry*)calloc(cap, sizeof(Entry)); }
+
+static void map_put(u32 key, unsigned char v){ size_t mask = cap - 1; size_t i = (size_t)(key & mask); for (;;){ if (!map[i].used){ map[i].used = 1; map[i].key = key; map[i].val = v; return; } if (map[i].key == key){ if (v < map[i].val) map[i].val = v; return; } i = (i + 1) & mask; } }
+
+static int map_get(u32 key){ size_t mask = cap - 1; size_t i = (size_t)(key & mask); for (;;){ if (!map[i].used) return -1; if (map[i].key == key) return (int)map[i].val; i = (i + 1) & mask; } }
+
+static int popcnt(u32 x){ return __builtin_popcount(x); }
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    init_masks();
+    int T; if (scanf("%d", &T) != 1) return 0;
+    u32 ones = 0x1FFFFFFU;
+    int leftN = 12, rightN = 13;
+    int leftIdx[12]; for (int i = 0; i < 12; ++i) leftIdx[i] = i;
+    int rightIdx[13]; for (int i = 0; i < 13; ++i) rightIdx[i] = 12 + i;
+    while (T--){
+        u32 B = 0U;
+        for (int r = 0; r < 5; ++r){
+            for (int c = 0; c < 5; ++c){
+                int v; scanf("%d", &v);
+                if (v) B |= (1U << (r * 5 + c));
+            }
+        }
+        u32 D = ones ^ B;
+        size_t need = 16384;
+        map_init(need);
+        for (u32 s = 0; s < (1U << leftN); ++s){ int w = popcnt(s); if (w > 6) continue; u32 m = 0U; for (int i = 0; i < leftN; ++i){ if ((s >> i) & 1U) m ^= press[leftIdx[i]]; } map_put(m, (unsigned char)w); }
+        int best = 7;
+        for (u32 t = 0; t < (1U << rightN); ++t){ int wr = popcnt(t); if (wr > 6) continue; u32 mr = 0U; for (int i = 0; i < rightN; ++i){ if ((t >> i) & 1U) mr ^= press[rightIdx[i]]; } u32 needL = D ^ mr; int wl = map_get(needL); if (wl >= 0){ int s = wl + wr; if (s < best) best = s; } }
+        if (best <= 6) printf("%d\n", best); else printf("-1\n");
+    }
+    return 0;
+}

exercise/exercise/111.c

@@ -0,0 +1,106 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef unsigned int u32;
+
+static int MOD = 99989;
+
+static int powmod(int a, unsigned long long e){
+    long long r = 1 % MOD;
+    long long x = a % MOD;
+    while (e){
+        if (e & 1ULL) r = (r * x) % MOD;
+        x = (x * x) % MOD;
+        e >>= 1ULL;
+    }
+    return (int)r;
+}
+
+static int no_adj(u32 m){ return (m & (m << 1)) == 0U; }
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n; if (scanf("%d", &n) != 1) return 0;
+    int maxH = 0; { int t = n; while (t >= 3){ ++maxH; t /= 3; } ++maxH; }
+    int maxA = 0; { int t = n; while (t >= 2){ ++maxA; t /= 2; } }
+    if (maxH < 1) maxH = 1;
+    if (maxA < 0) maxA = 0;
+    u32 **states = (u32**)malloc((size_t)(maxH + 1) * sizeof(u32*));
+    int *state_count = (int*)malloc((size_t)(maxH + 1) * sizeof(int));
+    for (int h = 1; h <= maxH; ++h){
+        int cap = 1 << h;
+        u32 *tmp = (u32*)malloc((size_t)cap * sizeof(u32));
+        int cnt = 0;
+        for (int m = 0; m < cap; ++m){ if (no_adj((u32)m)) tmp[cnt++] = (u32)m; }
+        states[h] = (u32*)malloc((size_t)cnt * sizeof(u32));
+        for (int i = 0; i < cnt; ++i) states[h][i] = tmp[i];
+        state_count[h] = cnt;
+        free(tmp);
+    }
+    unsigned long long ans = 1ULL;
+    int r = 1;
+    while (r <= n){
+        int m = n / r;
+        int R = n / m;
+        int L = r;
+        long long cR = (long long)R - (R / 2) - (R / 3) + (R / 6);
+        long long Lm1 = (long long)(L - 1);
+        long long cL = Lm1 - (Lm1 / 2) - (Lm1 / 3) + (Lm1 / 6);
+        unsigned long long cnt_r = (unsigned long long)(cR - cL);
+        int Amax = 0; { int t = m; while (t >= 2){ ++Amax; t /= 2; } }
+        int *H = (int*)malloc(((size_t)Amax + 1) * sizeof(int));
+        int tm = m;
+        for (int a = 0; a <= Amax; ++a){
+            int s = tm;
+            int hb = 0; while (s >= 3){ ++hb; s /= 3; }
+            H[a] = hb + 1;
+            tm >>= 1;
+        }
+        int maxStates = 0;
+        for (int a = 0; a <= Amax; ++a){ if (state_count[H[a]] > maxStates) maxStates = state_count[H[a]]; }
+        int *dp_cur = (int*)calloc((size_t)maxStates, sizeof(int));
+        int *dp_nxt = (int*)calloc((size_t)maxStates, sizeof(int));
+        int h0 = H[0];
+        for (int i = 0; i < state_count[h0]; ++i){ dp_cur[i] = 1; }
+        for (int a = 0; a + 1 <= Amax; ++a){
+            int h1 = H[a];
+            int h2 = H[a+1];
+            int c1 = state_count[h1];
+            int c2 = state_count[h2];
+            for (int j = 0; j < c2; ++j) dp_nxt[j] = 0;
+            u32 *S1 = states[h1];
+            u32 *S2 = states[h2];
+            for (int i = 0; i < c1; ++i){
+                int v = dp_cur[i]; if (!v) continue;
+                u32 s1 = S1[i];
+                for (int j = 0; j < c2; ++j){
+                    u32 s2 = S2[j];
+                    if ((s1 & s2) == 0U){
+                        int t = dp_nxt[j] + v;
+                        if (t >= MOD) t -= MOD;
+                        dp_nxt[j] = t;
+                    }
+                }
+            }
+            for (int j = 0; j < c2; ++j) dp_cur[j] = dp_nxt[j];
+        }
+        int hlast = H[Amax];
+        int cnt_last = state_count[hlast];
+        int f_m = 0; for (int i = 0; i < cnt_last; ++i){ f_m += dp_cur[i]; if (f_m >= MOD) f_m -= MOD; }
+        int contrib = powmod(f_m, cnt_r);
+        ans = (ans * (unsigned long long)contrib) % MOD;
+        free(dp_nxt); free(dp_cur); free(H);
+        r = R + 1;
+    }
+    printf("%u\n", (unsigned int)ans);
+    for (int h = 1; h <= maxH; ++h) free(states[h]);
+    free(state_count); free(states);
+    return 0;
+}

exercise/exercise/112.c

@@ -0,0 +1,58 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+static int MOD = 99989;
+
+static int popcnt(int x){
+    int c = 0;
+    while (x){ x &= (x - 1); ++c; }
+    return c;
+}
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int N, M;
+    if (scanf("%d %d", &N, &M) != 2) return 0;
+    int Smax = 1 << N;
+    int *okrow = (int*)malloc((size_t)Smax * sizeof(int));
+    int *bits = (int*)malloc((size_t)Smax * sizeof(int));
+    int *list = (int*)malloc((size_t)Smax * sizeof(int));
+    int cntS = 0;
+    for (int m = 0; m < Smax; ++m){
+        if ((m & (m << 1)) == 0){ okrow[m] = 1; bits[m] = popcnt(m); list[cntS++] = m; } else { okrow[m] = 0; bits[m] = popcnt(m); }
+    }
+    char **ok = (char**)malloc((size_t)cntS * sizeof(char*));
+    for (int i = 0; i < cntS; ++i) ok[i] = (char*)malloc((size_t)cntS * sizeof(char));
+    for (int i = 0; i < cntS; ++i){
+        int a = list[i];
+        for (int j = 0; j < cntS; ++j){
+            int b = list[j];
+            int bad = (a & b) | (a & (b << 1)) | (a & (b >> 1));
+            ok[i][j] = (bad == 0) ? 1 : 0;
+        }
+    }
+    int **dp_prev = (int**)malloc((size_t)cntS * sizeof(int*));
+    int **dp_cur = (int**)malloc((size_t)cntS * sizeof(int*));
+    for (int i = 0; i < cntS; ++i){ dp_prev[i] = (int*)calloc((size_t)M + 1, sizeof(int)); dp_cur[i] = (int*)calloc((size_t)M + 1, sizeof(int)); }
+    for (int i = 0; i < cntS; ++i){ int b = bits[list[i]]; if (b <= M) dp_prev[i][b] = 1; }
+    for (int r = 1; r < N; ++r){
+        for (int j = 0; j < cntS; ++j){ for (int k = 0; k <= M; ++k) dp_cur[j][k] = 0; }
+        for (int i = 0; i < cntS; ++i){
+            for (int j = 0; j < cntS; ++j){ if (!ok[i][j]) continue; int add = bits[list[j]]; for (int k = 0; k + add <= M; ++k){ int v = dp_prev[i][k]; if (!v) continue; int t = dp_cur[j][k + add] + v; if (t >= MOD) t -= MOD; dp_cur[j][k + add] = t; } }
+        }
+        for (int j = 0; j < cntS; ++j){ for (int k = 0; k <= M; ++k) dp_prev[j][k] = dp_cur[j][k]; }
+    }
+    int ans = 0;
+    for (int i = 0; i < cntS; ++i){ int v = dp_prev[i][M]; ans += v; if (ans >= MOD) ans -= MOD; }
+    printf("%d\n", ans);
+    for (int i = 0; i < cntS; ++i){ free(dp_prev[i]); free(dp_cur[i]); free(ok[i]); }
+    free(dp_prev); free(dp_cur); free(ok); free(list); free(bits); free(okrow);
+    return 0;
+}

exercise/exercise/113.c

@@ -0,0 +1,30 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef unsigned long long ull;
+
+int main(void)
+{
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    unsigned long long n;
+    if (scanf("%llu", &n) != 1)
+        return 0;
+    unsigned long long ans = 0ULL;
+    for (unsigned long long factor = 1ULL; factor <= n; factor *= 10ULL)
+    {
+        unsigned long long high = n / (factor * 10ULL);
+        unsigned long long low = n % factor;
+        unsigned long long cur = (n / factor) % 10ULL;
+        unsigned long long term = factor * (high * 45ULL + (cur * (cur - 1ULL)) / 2ULL) + cur * (low + 1ULL);
+        ans += term;
+    }
+    printf("%llu\n", ans);
+    return 0;
+}

exercise/exercise/114.c

@@ -0,0 +1,92 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef unsigned long long ull;
+
+static const int MOD = 1000000007;
+
+typedef struct { int c; int s; int q; } Node;
+
+static ull digits[32];
+
+static ull solve(ull n){
+    if (n == (ull)-1) return 0ULL;
+    int L = 0;
+    if (n == 0ULL){ digits[L++] = 0ULL; }
+    else { while (n){ digits[L++] = n % 10ULL; n /= 10ULL; } for (int i = 0, j = L - 1; i < j; ++i, --j){ ull t = digits[i]; digits[i] = digits[j]; digits[j] = t; } }
+    static Node dp[2][2][2][6][6];
+    static Node nx[2][2][2][6][6];
+    for (int t = 0; t < 2; ++t) for (int a = 0; a < 2; ++a) for (int b = 0; b < 2; ++b) for (int m = 0; m < 6; ++m) for (int r = 0; r < 6; ++r){ dp[t][a][b][m][r].c = 0; dp[t][a][b][m][r].s = 0; dp[t][a][b][m][r].q = 0; }
+    dp[1][1][0][0][0].c = 1;
+    dp[1][1][0][0][0].s = 0;
+    dp[1][1][0][0][0].q = 0;
+    for (int pos = 0; pos < L; ++pos){
+        int lim = (int)digits[pos];
+        for (int t = 0; t < 2; ++t) for (int a = 0; a < 2; ++a) for (int b = 0; b < 2; ++b) for (int m = 0; m < 6; ++m) for (int r = 0; r < 6; ++r){ nx[t][a][b][m][r].c = 0; nx[t][a][b][m][r].s = 0; nx[t][a][b][m][r].q = 0; }
+        for (int t = 0; t < 2; ++t){
+            int up = t ? lim : 9;
+            for (int a = 0; a < 2; ++a){
+                for (int b = 0; b < 2; ++b){
+                    for (int m = 0; m < 6; ++m){
+                        for (int r = 0; r < 6; ++r){
+                            Node cur = dp[t][a][b][m][r];
+                            if (!cur.c && !cur.s && !cur.q) continue;
+                            for (int d = 0; d <= up; ++d){
+                                int nt = (t && (d == up)) ? 1 : 0;
+                                int na = (a && d == 0) ? 1 : 0;
+                                int nb = b || (d == 6);
+                                int nm = (m * 10 + d) % 6;
+                                int nr = (r + d) % 6;
+                                Node *dst = &nx[nt][na][nb][nm][nr];
+                                int cadd = cur.c;
+                                int sadd = (int)((10LL * cur.s + (long long)cadd * d) % MOD);
+                                int qadd = (int)((100LL * cur.q + (20LL * d % MOD) * cur.s + (long long)cadd * (long long)d * (long long)d) % MOD);
+                                dst->c += cadd; if (dst->c >= MOD) dst->c -= MOD;
+                                dst->s += sadd; if (dst->s >= MOD) dst->s -= MOD;
+                                dst->q += qadd; if (dst->q >= MOD) dst->q -= MOD;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        for (int t = 0; t < 2; ++t) for (int a = 0; a < 2; ++a) for (int b = 0; b < 2; ++b) for (int m = 0; m < 6; ++m) for (int r = 0; r < 6; ++r){ dp[t][a][b][m][r] = nx[t][a][b][m][r]; }
+    }
+    long long ans = 0;
+    for (int t = 0; t < 2; ++t){
+        for (int a = 0; a < 2; ++a){
+            for (int b = 0; b < 2; ++b){
+                if (b) continue;
+                for (int m = 0; m < 6; ++m){
+                    if (m == 0) continue;
+                    for (int r = 0; r < 6; ++r){
+                        if (r == 0) continue;
+                        ans += dp[t][a][b][m][r].q;
+                        if (ans >= MOD) ans -= MOD;
+                    }
+                }
+            }
+        }
+    }
+    return (ull)ans;
+}
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int T; if (scanf("%d", &T) != 1) return 0;
+    while (T--){
+        unsigned long long a, b; scanf("%llu %llu", &a, &b);
+        ull x = solve(b);
+        ull y = solve(a - 1ULL);
+        ull ans = (x >= y) ? (x - y) : (x + MOD - y);
+        printf("%llu\n", ans);
+    }
+    return 0;
+}

exercise/exercise/1149.c

@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(void)
+{
+    int n;
+    if (scanf("%d", &n) != 1)
+        return 0;
+    unsigned int N = (1u << (n + 1)) - 1u;
+    long long *w = (long long *)malloc(((size_t)N + 2) * sizeof(long long));
+    long long *mx = (long long *)malloc(((size_t)N + 2) * sizeof(long long));
+    for (unsigned int i = 1; i <= N; ++i)
+        scanf("%lld", &w[i]);
+    unsigned int first_leaf = (N >> 1) + 1u;
+    for (unsigned int i = first_leaf; i <= N; ++i)
+        mx[i] = w[i];
+    long long add = 0;
+    for (int i = (int)(first_leaf - 1u); i >= 1; --i)
+    {
+        long long L = mx[i << 1];
+        long long R = mx[(i << 1) | 1];
+        add += (L >= R) ? (L - R) : (R - L);
+        mx[i] = w[i] + ((L >= R) ? L : R);
+    }
+    printf("%lld\n", add);
+    free(w);
+    free(mx);
+    return 0;
+}

exercise/exercise/115.c

@@ -0,0 +1,37 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+static const int MOD = 1000000007;
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int f; if (scanf("%d", &f) != 1) return 0;
+    int *ns = (int*)malloc((size_t)f * sizeof(int));
+    int maxN = 0;
+    for (int i = 0; i < f; ++i){ scanf("%d", &ns[i]); if (ns[i] > maxN) maxN = ns[i]; }
+    if (maxN < 0) maxN = 0;
+    int *dp1 = (int*)calloc((size_t)maxN + 2, sizeof(int));
+    int *dp2 = (int*)calloc((size_t)maxN + 2, sizeof(int));
+    if (maxN >= 1){ dp1[1] = 3; dp2[1] = 0; }
+    for (int n = 2; n <= maxN; ++n){
+        long long a = (2LL * dp1[n-1] + 2LL * dp2[n-1]) % MOD;
+        long long b = (1LL * dp1[n-1]) % MOD;
+        dp1[n] = (int)a;
+        dp2[n] = (int)b;
+    }
+    for (int i = 0; i < f; ++i){
+        int n = ns[i];
+        if (n == 0){ printf("1\n"); continue; }
+        int ans = dp1[n]; ans += dp2[n]; if (ans >= MOD) ans -= MOD;
+        printf("%d\n", ans);
+    }
+    free(dp2); free(dp1); free(ns);
+    return 0;
+}

exercise/exercise/116.c

@@ -0,0 +1,223 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+static const int P = 61;
+
+static int C[61][61];
+static int pow2_small[400];
+
+static int pow2_mod(unsigned long long e)
+{
+    unsigned long long b = 2ULL;
+    unsigned long long r = 1ULL;
+    while (e)
+    {
+        if (e & 1ULL)
+            r = (r * b) % P;
+        b = (b * b) % P;
+        e >>= 1ULL;
+    }
+    return (int)r;
+}
+
+static int sum_prefix_mod61(unsigned long long k, long long t)
+{
+    if (t < 0)
+        return 0;
+    if ((unsigned long long)t >= k)
+        return pow2_mod(k);
+    int Kdig[16], Tdig[16];
+    int L = 0;
+    unsigned long long kk = k;
+    while (kk)
+    {
+        Kdig[L++] = (int)(kk % P);
+        kk /= P;
+    }
+    if (L == 0)
+    {
+        Kdig[L++] = 0;
+    }
+    unsigned long long tt = (unsigned long long)t;
+    int Lt = 0;
+    while (tt)
+    {
+        Tdig[Lt++] = (int)(tt % P);
+        tt /= P;
+    }
+    while (Lt < L)
+    {
+        Tdig[Lt++] = 0;
+    }
+    int Krev[16], Trev[16];
+    for (int i = 0; i < L; ++i)
+    {
+        Krev[i] = Kdig[L - 1 - i];
+        Trev[i] = Tdig[L - 1 - i];
+    }
+    int suffix_sum_digits[17];
+    suffix_sum_digits[L] = 0;
+    for (int i = L - 1; i >= 0; --i)
+        suffix_sum_digits[i] = suffix_sum_digits[i + 1] + Krev[i];
+    int res = 0;
+    for (int i = 0; i < L; ++i)
+    {
+        int limit = Trev[i];
+        int nd = Krev[i];
+        int up = (limit < nd) ? limit : nd;
+        for (int w = 0; w < up; ++w)
+        {
+            int cv = C[nd][w];
+            if (!cv)
+                continue;
+            int tail = suffix_sum_digits[i + 1];
+            int add = (int)((cv * (long long)pow2_small[tail]) % P);
+            res += add;
+            if (res >= P)
+                res -= P;
+        }
+        if (up >= 0)
+        {
+            int w = up;
+            int cv = C[nd][w];
+            if (!cv)
+            {
+                return res;
+            }
+            if (w < limit)
+            {
+                int tail = suffix_sum_digits[i + 1];
+                int add = (int)((cv * (long long)pow2_small[tail]) % P);
+                res += add;
+                if (res >= P)
+                    res -= P;
+                return res;
+            }
+        }
+    }
+    res += 1;
+    if (res >= P)
+        res -= P;
+    return res;
+}
+
+static inline char map_char(int x)
+{
+    if (x <= 9)
+        return (char)('0' + x);
+    if (x <= 35)
+        return (char)('A' + (x - 10));
+    return (char)('a' + (x - 36));
+}
+
+static int read_int_fast()
+{
+    int c = getchar();
+    while (c != EOF && (c <= ' '))
+        c = getchar();
+    if (c == EOF)
+        return -1;
+    int x = 0;
+    while (c > ' ')
+    {
+        x = x * 10 + (c - '0');
+        c = getchar();
+    }
+    return x;
+}
+
+int main(void)
+{
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    for (int n = 0; n <= 60; ++n)
+    {
+        C[n][0] = 1 % P;
+        for (int r = 1; r <= n; ++r)
+        {
+            int v = (C[n - 1][r - 1] + C[n - 1][r]) % P;
+            C[n][r] = v;
+        }
+    }
+    pow2_small[0] = 1 % P;
+    for (int i = 1; i < 400; ++i)
+    {
+        pow2_small[i] = (pow2_small[i - 1] * 2) % P;
+    }
+    int Q = read_int_fast();
+    unsigned char *A = (unsigned char *)malloc((size_t)Q + 5);
+    int head = 0, tail = 0;
+    long long cnt0 = 0, cnt1 = 0, cntq = 0;
+    int last = 0;
+    int outputs = 0;
+    for (int qi = 0; qi < Q; ++qi)
+    {
+        int x = read_int_fast();
+        x ^= (last & 3);
+        if (x == 0)
+        {
+            A[tail++] = 0;
+            ++cnt0;
+        }
+        else if (x == 1)
+        {
+            A[tail++] = 1;
+            ++cnt1;
+        }
+        else if (x == 2)
+        {
+            A[tail++] = 2;
+            ++cntq;
+        }
+        else
+        {
+            unsigned char v = A[head++];
+            if (v == 0)
+                --cnt0;
+            else if (v == 1)
+                --cnt1;
+            else
+                --cntq;
+        }
+        int L = tail - head;
+        if ((L & 1) == 1)
+        {
+            long long ones = cnt1;
+            long long k = cntq;
+            long long T = (L + 1) / 2;
+            long long need = T - ones;
+            int ans;
+            if (need <= 0)
+            {
+                ans = pow2_mod((unsigned long long)k);
+            }
+            else if (need > k)
+            {
+                ans = 0;
+            }
+            else
+            {
+                unsigned long long K = (unsigned long long)k;
+                unsigned long long sum0 = sum_prefix_mod61(K, (long long)(need - 1));
+                int twoK = pow2_mod(K);
+                ans = twoK - (int)sum0;
+                if (ans < 0)
+                    ans += P;
+            }
+            char ch = map_char(ans);
+            putchar(ch);
+            putchar('\n');
+            last = ans;
+            ++outputs;
+        }
+    }
+    free(A);
+    return 0;
+}

exercise/exercise/117.c

@@ -0,0 +1,240 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef struct
+{
+    int x, y;
+} Pt;
+
+static int manh(Pt a, Pt b)
+{
+    int dx = a.x - b.x;
+    if (dx < 0)
+        dx = -dx;
+    int dy = a.y - b.y;
+    if (dy < 0)
+        dy = -dy;
+    return dx + dy;
+}
+
+static void gen_segment(Pt a, Pt b)
+{
+    int sx = (b.x > a.x) ? 1 : (b.x < a.x ? -1 : 0);
+    int sy = (b.y > a.y) ? 1 : (b.y < a.y ? -1 : 0);
+    while (a.x != b.x)
+    {
+        a.x += sx;
+        printf(" (%d,%d)", a.x, a.y);
+    }
+    while (a.y != b.y)
+    {
+        a.y += sy;
+        printf(" (%d,%d)", a.x, a.y);
+    }
+}
+
+static int perm_next(int *p, int n)
+{
+    int i = n - 2;
+    while (i >= 0 && p[i] > p[i + 1])
+        --i;
+    if (i < 0)
+        return 0;
+    int j = n - 1;
+    while (p[j] < p[i])
+        --j;
+    int t = p[i];
+    p[i] = p[j];
+    p[j] = t;
+    int l = i + 1, r = n - 1;
+    while (l < r)
+    {
+        t = p[l];
+        p[l] = p[r];
+        p[r] = t;
+        ++l;
+        --r;
+    }
+    return 1;
+}
+
+static void best_route(Pt S, Pt *grp, int k, int *best_len, int *best_order)
+{
+    int idx[4];
+    for (int i = 0; i < k; ++i)
+        idx[i] = i;
+    int first = 1;
+    do
+    {
+        int sum = 0;
+        Pt cur = S;
+        for (int i = 0; i < k; ++i)
+        {
+            sum += manh(cur, grp[idx[i]]);
+            cur = grp[idx[i]];
+        }
+        if (first || sum < *best_len)
+        {
+            *best_len = sum;
+            for (int i = 0; i < k; ++i)
+                best_order[i] = idx[i];
+            first = 0;
+        }
+    } while (perm_next(idx, k));
+}
+
+typedef struct
+{
+    Pt *pts;
+    int cnt;
+} Bucket;
+
+int main(void)
+{
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int N;
+    if (scanf("%d", &N) != 1)
+        return 0;
+    Pt *emps = (Pt *)malloc((size_t)N * sizeof(Pt));
+    for (int i = 0; i < N; ++i)
+        scanf("%d %d", &emps[i].x, &emps[i].y);
+    Pt S;
+    scanf("%d %d", &S.x, &S.y);
+    Pt *eff = (Pt *)malloc((size_t)N * sizeof(Pt));
+    int M = 0;
+    for (int i = 0; i < N; ++i)
+    {
+        if (emps[i].x == S.x && emps[i].y == S.y)
+            continue;
+        eff[M++] = emps[i];
+    }
+    if (M == 0)
+    {
+        printf("0\n0\n");
+        free(eff);
+        free(emps);
+        return 0;
+    }
+    Bucket bkt[8];
+    for (int i = 0; i < 8; ++i)
+    {
+        bkt[i].pts = (Pt *)malloc((size_t)M * sizeof(Pt));
+        bkt[i].cnt = 0;
+    }
+    for (int i = 0; i < M; ++i)
+    {
+        int dx = eff[i].x - S.x, dy = eff[i].y - S.y;
+        int id = 0;
+        if (dx > 0 && dy > 0)
+            id = 0;
+        else if (dx < 0 && dy > 0)
+            id = 1;
+        else if (dx > 0 && dy < 0)
+            id = 2;
+        else if (dx < 0 && dy < 0)
+            id = 3;
+        else if (dx == 0 && dy > 0)
+            id = 4;
+        else if (dx == 0 && dy < 0)
+            id = 5;
+        else if (dy == 0 && dx > 0)
+            id = 6;
+        else
+            id = 7;
+        bkt[id].pts[bkt[id].cnt++] = eff[i];
+    }
+    int groups = 0;
+    int cap = (M + 3) / 4;
+    Pt **grp_pts = (Pt **)malloc((size_t)cap * sizeof(Pt *));
+    int *grp_sizes = (int *)malloc((size_t)cap * sizeof(int));
+    for (int id = 0; id < 8; ++id)
+    {
+        int c = bkt[id].cnt;
+        if (c == 0)
+            continue;
+        int *ord = (int *)malloc((size_t)c * sizeof(int));
+        for (int i = 0; i < c; ++i)
+            ord[i] = i;
+        for (int i = 0; i < c; ++i)
+        {
+            for (int j = i + 1; j < c; ++j)
+            {
+                if (manh(S, bkt[id].pts[ord[i]]) > manh(S, bkt[id].pts[ord[j]]))
+                {
+                    int t = ord[i];
+                    ord[i] = ord[j];
+                    ord[j] = t;
+                }
+            }
+        }
+        int i = 0;
+        while (i < c)
+        {
+            int k = c - i;
+            if (k > 4)
+                k = 4;
+            Pt *arr = (Pt *)malloc((size_t)k * sizeof(Pt));
+            for (int t = 0; t < k; ++t)
+                arr[t] = bkt[id].pts[ord[i + t]];
+            grp_pts[groups] = arr;
+            grp_sizes[groups] = k;
+            ++groups;
+            i += k;
+        }
+        free(ord);
+    }
+    int *lens = (int *)malloc((size_t)groups * sizeof(int));
+    int **order = (int **)malloc((size_t)groups * sizeof(int *));
+    for (int g = 0; g < groups; ++g)
+    {
+        order[g] = (int *)malloc(4 * sizeof(int));
+        int bl = 0;
+        best_route(S, grp_pts[g], grp_sizes[g], &bl, order[g]);
+        lens[g] = bl;
+    }
+    int total = 0;
+    for (int g = 0; g < groups; ++g)
+        total += lens[g];
+    printf("%d\n", total);
+    printf("%d\n", groups);
+    for (int g = 0; g < groups; ++g)
+    {
+        printf("%d", lens[g]);
+        for (int i = 0; i < grp_sizes[g]; ++i)
+        {
+            Pt p = grp_pts[g][i];
+            printf("(%d,%d)%s", p.x, p.y, (i + 1 == grp_sizes[g]) ? " " : " ");
+        }
+        printf(": ");
+        Pt cur = S;
+        printf("(%d,%d)", cur.x, cur.y);
+        for (int i = 0; i < grp_sizes[g]; ++i)
+        {
+            Pt nxt = grp_pts[g][order[g][i]];
+            gen_segment(cur, nxt);
+            cur = nxt;
+        }
+        printf("\n");
+    }
+    for (int g = 0; g < groups; ++g)
+    {
+        free(order[g]);
+        free(grp_pts[g]);
+    }
+    free(order);
+    free(grp_pts);
+    free(grp_sizes);
+    free(lens);
+    for (int i = 0; i < 8; ++i)
+        free(bkt[i].pts);
+    free(eff);
+    free(emps);
+    return 0;
+}

exercise/exercise/118.c

@@ -0,0 +1,66 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef struct { char *name; char *path; } Node;
+
+static char* dupstr(const char* s){ size_t n = strlen(s); char* p = (char*)malloc(n + 1); if (!p) exit(1); memcpy(p, s, n + 1); return p; }
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    Node *nodes = (Node*)malloc(2000 * sizeof(Node));
+    int cap = 2000, cnt = 0;
+    int last_idx[2048];
+    for (int i = 0; i < 2048; ++i) last_idx[i] = -1;
+    char buf[4096];
+    while (fgets(buf, sizeof(buf), stdin)){
+        size_t len = strlen(buf);
+        while (len && (buf[len-1] == '\n' || buf[len-1] == '\r')) buf[--len] = '\0';
+        while (len && buf[len-1] == ' ') buf[--len] = '\0';
+        if (len == 0) continue;
+        if (strcmp(buf, "#") == 0) break;
+        size_t i = 0; while (buf[i] == ' ') ++i;
+        int level = (int)i;
+        const char *name = buf + i;
+        if (*name == '\0') continue;
+        size_t nlen = strlen(name);
+        char *path;
+        if (level == 0){
+            path = (char*)malloc(1 + nlen + 1);
+            path[0] = '/';
+            memcpy(path + 1, name, nlen);
+            path[1 + nlen] = '\0';
+        } else {
+            const char *parent_path = nodes[last_idx[level - 1]].path;
+            size_t plen = strlen(parent_path);
+            path = (char*)malloc(plen + 1 + nlen + 1);
+            memcpy(path, parent_path, plen);
+            path[plen] = '/';
+            memcpy(path + plen + 1, name, nlen);
+            path[plen + 1 + nlen] = '\0';
+        }
+        if (cnt == cap){ cap <<= 1; nodes = (Node*)realloc(nodes, (size_t)cap * sizeof(Node)); }
+        nodes[cnt].name = dupstr(name);
+        nodes[cnt].path = path;
+        last_idx[level] = cnt;
+        ++cnt;
+    }
+    if (!fgets(buf, sizeof(buf), stdin)) return 0;
+    size_t len = strlen(buf);
+    while (len && (buf[len-1] == '\n' || buf[len-1] == '\r')) buf[--len] = '\0';
+    while (len && buf[len-1] == ' ') buf[--len] = '\0';
+    size_t j = 0; while (buf[j] == ' ') ++j; const char *q = buf + j;
+    int found = 0;
+    for (int i = 0; i < cnt; ++i){ if (strcmp(nodes[i].name, q) == 0){ puts(nodes[i].path); found = 1; } }
+    if (!found) puts("NULL");
+    for (int i = 0; i < cnt; ++i){ free(nodes[i].name); free(nodes[i].path); }
+    free(nodes);
+    return 0;
+}

exercise/exercise/120.c

@@ -0,0 +1,36 @@
+#include <stdio.h>
+
+typedef struct { int x, y; } P;
+
+static int n;
+static P a[105];
+static int vis[105];
+
+static void dfs(int u)
+{
+    vis[u] = 1;
+    for (int v = 0; v < n; ++v)
+    {
+        if (!vis[v] && (a[v].x == a[u].x || a[v].y == a[u].y))
+            dfs(v);
+    }
+}
+
+int main(void)
+{
+    if (scanf("%d", &n) != 1) return 0;
+    for (int i = 0; i < n; ++i)
+        scanf("%d %d", &a[i].x, &a[i].y);
+    for (int i = 0; i < n; ++i) vis[i] = 0;
+    int comp = 0;
+    for (int i = 0; i < n; ++i)
+    {
+        if (!vis[i])
+        {
+            ++comp;
+            dfs(i);
+        }
+    }
+    printf("%d\n", comp - 1);
+    return 0;
+}

exercise/exercise/121.c

@@ -0,0 +1,45 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(void)
+{
+    int n, m;
+    if (scanf("%d %d", &n, &m) != 2) return 0;
+    int *head = (int *)malloc(((size_t)n + 2) * sizeof(int));
+    for (int i = 1; i <= n; ++i) head[i] = -1;
+    int E = m * 2;
+    int *to = (int *)malloc(((size_t)E + 5) * sizeof(int));
+    int *next = (int *)malloc(((size_t)E + 5) * sizeof(int));
+    int idx = 0;
+    for (int i = 0; i < m; ++i)
+    {
+        int a, b; scanf("%d %d", &a, &b);
+        to[idx] = b; next[idx] = head[a]; head[a] = idx++;
+        to[idx] = a; next[idx] = head[b]; head[b] = idx++;
+    }
+    int x; scanf("%d", &x);
+    int *dist = (int *)malloc(((size_t)n + 2) * sizeof(int));
+    for (int i = 1; i <= n; ++i) dist[i] = -1;
+    int *q = (int *)malloc(((size_t)n + 5) * sizeof(int));
+    int hh = 0, tt = 0;
+    dist[x] = 0; q[tt++] = x;
+    while (hh < tt)
+    {
+        int u = q[hh++];
+        for (int i = head[u]; i != -1; i = next[i])
+        {
+            int v = to[i];
+            if (dist[v] == -1)
+            {
+                dist[v] = dist[u] + 1;
+                q[tt++] = v;
+            }
+        }
+    }
+    int ans = 0;
+    for (int i = 1; i <= n; ++i)
+        if (dist[i] > ans) ans = dist[i];
+    printf("%d\n", ans);
+    free(head); free(to); free(next); free(dist); free(q);
+    return 0;
+}

exercise/exercise/122.c

@@ -0,0 +1,55 @@
+#include <stdio.h>
+
+static int parent[105][105];
+static unsigned char used[105];
+
+static int findc(int c, int x)
+{
+    int p = parent[c][x];
+    while (p != x)
+    {
+        int gp = parent[c][p];
+        parent[c][x] = gp;
+        x = p;
+        p = gp;
+    }
+    return x;
+}
+
+int main(void)
+{
+    int n, m;
+    if (scanf("%d %d", &n, &m) != 2) return 0;
+    for (int c = 1; c <= m; ++c)
+    {
+        for (int i = 1; i <= n; ++i)
+            parent[c][i] = i;
+        used[c] = 0;
+    }
+    for (int i = 0; i < m; ++i)
+    {
+        int x, y, c;
+        scanf("%d %d %d", &x, &y, &c);
+        used[c] = 1;
+        int rx = findc(c, x);
+        int ry = findc(c, y);
+        if (rx != ry) parent[c][rx] = ry;
+    }
+    int q;
+    scanf("%d", &q);
+    while (q--)
+    {
+        int u, v;
+        scanf("%d %d", &u, &v);
+        int ans = 0;
+        for (int c = 1; c <= m; ++c)
+        {
+            if (!used[c]) continue;
+            int ru = findc(c, u);
+            int rv = findc(c, v);
+            if (ru == rv) ++ans;
+        }
+        printf("%d\n", ans);
+    }
+    return 0;
+}

exercise/exercise/123.c

@@ -0,0 +1,43 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(void)
+{
+    int n; if (scanf("%d", &n) != 1) return 0;
+    int E = (n - 1) * 2;
+    int *head = (int *)malloc(((size_t)n + 2) * sizeof(int));
+    int *to = (int *)malloc(((size_t)E + 5) * sizeof(int));
+    int *next = (int *)malloc(((size_t)E + 5) * sizeof(int));
+    for (int i = 1; i <= n; ++i) head[i] = -1;
+    int idx = 0;
+    for (int i = 0; i < n - 1; ++i)
+    {
+        int u, v; scanf("%d %d", &u, &v);
+        to[idx] = v; next[idx] = head[u]; head[u] = idx++;
+        to[idx] = u; next[idx] = head[v]; head[v] = idx++;
+    }
+    int *color = (int *)malloc(((size_t)n + 2) * sizeof(int));
+    for (int i = 1; i <= n; ++i) color[i] = -1;
+    int *q = (int *)malloc(((size_t)n + 5) * sizeof(int));
+    int hh = 0, tt = 0;
+    color[1] = 0; q[tt++] = 1;
+    while (hh < tt)
+    {
+        int u = q[hh++];
+        for (int i = head[u]; i != -1; i = next[i])
+        {
+            int v = to[i];
+            if (color[v] == -1)
+            {
+                color[v] = color[u] ^ 1;
+                q[tt++] = v;
+            }
+        }
+    }
+    long long a = 0, b = 0;
+    for (int i = 1; i <= n; ++i) if (color[i] == 0) ++a; else ++b;
+    long long ans = a * b - (long long)(n - 1);
+    printf("%lld\n", ans);
+    free(head); free(to); free(next); free(color); free(q);
+    return 0;
+}

exercise/exercise/124.c

@@ -0,0 +1,118 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+
+typedef struct { int v, w, next; } Edge;
+typedef struct { long long d; int u, m; } HN;
+
+static int n, m, p;
+static int *head;
+static Edge *E;
+static int ec;
+static int *pc, *pa, *pb, *pt;
+
+static HN *heap;
+static int hsz;
+
+static void hpush(HN x)
+{
+    int i = hsz++;
+    heap[i] = x;
+    while (i)
+    {
+        int p = (i - 1) >> 1;
+        if (heap[p].d <= heap[i].d) break;
+        HN t = heap[p]; heap[p] = heap[i]; heap[i] = t; i = p;
+    }
+}
+
+static HN hpop()
+{
+    HN r = heap[0];
+    heap[0] = heap[--hsz];
+    int i = 0;
+    for (;;)
+    {
+        int l = i * 2 + 1, rgt = l + 1, s = i;
+        if (l < hsz && heap[l].d < heap[s].d) s = l;
+        if (rgt < hsz && heap[rgt].d < heap[s].d) s = rgt;
+        if (s == i) break;
+        HN t = heap[i]; heap[i] = heap[s]; heap[s] = t; i = s;
+    }
+    return r;
+}
+
+int main(void)
+{
+    if (scanf("%d %d %d", &n, &m, &p) != 3) return 0;
+    head = (int *)malloc(((size_t)n + 2) * sizeof(int));
+    E = (Edge *)malloc(((size_t)m * 2 + 5) * sizeof(Edge));
+    for (int i = 1; i <= n; ++i) head[i] = -1;
+    ec = 0;
+    for (int i = 0; i < m; ++i)
+    {
+        int u, v, w; scanf("%d %d %d", &u, &v, &w);
+        E[ec].v = v; E[ec].w = w; E[ec].next = head[u]; head[u] = ec++;
+        E[ec].v = u; E[ec].w = w; E[ec].next = head[v]; head[v] = ec++;
+    }
+    pc = (int *)malloc(((size_t)p + 2) * sizeof(int));
+    pa = (int *)malloc(((size_t)p + 2) * sizeof(int));
+    pb = (int *)malloc(((size_t)p + 2) * sizeof(int));
+    pt = (int *)malloc(((size_t)p + 2) * sizeof(int));
+    for (int i = 0; i < p; ++i)
+    {
+        int c, a, b, t; scanf("%d %d %d %d", &c, &a, &b, &t);
+        pc[i] = c; pa[i] = a; pb[i] = b; pt[i] = t;
+    }
+    int M = 1 << p;
+    long long *dist = (long long *)malloc(((size_t)n * (size_t)M) * sizeof(long long));
+    for (size_t i = 0; i < (size_t)n * (size_t)M; ++i) dist[i] = LLONG_MAX;
+    heap = (HN *)malloc(((size_t)n * (size_t)M + 5) * sizeof(HN));
+    hsz = 0;
+    dist[(0) * (size_t)n + (size_t)(1 - 1)] = 0;
+    hpush((HN){0LL, 1, 0});
+    while (hsz)
+    {
+        HN cur = hpop();
+        long long cd = cur.d; int u = cur.u; int mask = cur.m;
+        if (cd != dist[(size_t)mask * (size_t)n + (size_t)(u - 1)]) continue;
+        if (u == n)
+        {
+            printf("%lld\n", cd);
+            free(head); free(E); free(pc); free(pa); free(pb); free(pt); free(dist); free(heap);
+            return 0;
+        }
+        for (int i = head[u]; i != -1; i = E[i].next)
+        {
+            int v = E[i].v; long long nd = cd + (long long)E[i].w;
+            size_t idx = (size_t)mask * (size_t)n + (size_t)(v - 1);
+            if (nd < dist[idx]) { dist[idx] = nd; hpush((HN){nd, v, mask}); }
+        }
+        for (int i = 0; i < p; ++i)
+        {
+            int bit = 1 << i;
+            if (!(mask & bit) && u == pc[i])
+            {
+                int nmask = mask | bit;
+                size_t idx = (size_t)nmask * (size_t)n + (size_t)(u - 1);
+                if (cd < dist[idx]) { dist[idx] = cd; hpush((HN){cd, u, nmask}); }
+            }
+            if (mask & bit)
+            {
+                if (u == pa[i])
+                {
+                    int v = pb[i]; long long nd = cd + (long long)pt[i];
+                    size_t idx = (size_t)mask * (size_t)n + (size_t)(v - 1);
+                    if (nd < dist[idx]) { dist[idx] = nd; hpush((HN){nd, v, mask}); }
+                }
+                if (u == pb[i])
+                {
+                    int v = pa[i]; long long nd = cd + (long long)pt[i];
+                    size_t idx = (size_t)mask * (size_t)n + (size_t)(v - 1);
+                    if (nd < dist[idx]) { dist[idx] = nd; hpush((HN){nd, v, mask}); }
+                }
+            }
+        }
+    }
+    return 0;
+}

exercise/exercise/125.c

@@ -0,0 +1,85 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+
+typedef struct { int v, w, next; } Edge;
+typedef struct { long long d; int u; } HN;
+
+static long long *dij(int n, int *head, Edge *E, int src)
+{
+    long long *dist = (long long *)malloc(((size_t)n + 1) * sizeof(long long));
+    for (int i = 1; i <= n; ++i) dist[i] = LLONG_MAX;
+    HN *heap = (HN *)malloc(((size_t)n * 4 + 5) * sizeof(HN));
+    int hsz = 0;
+    dist[src] = 0; heap[hsz++] = (HN){0, src};
+    for (int i = hsz - 1; i > 0; --i)
+    {
+        int p = (i - 1) >> 1;
+        if (heap[p].d > heap[i].d) { HN t = heap[p]; heap[p] = heap[i]; heap[i] = t; }
+    }
+    while (hsz)
+    {
+        HN cur = heap[0];
+        heap[0] = heap[--hsz];
+        int i = 0;
+        for (;;)
+        {
+            int l = i * 2 + 1, r = l + 1, s = i;
+            if (l < hsz && heap[l].d < heap[s].d) s = l;
+            if (r < hsz && heap[r].d < heap[s].d) s = r;
+            if (s == i) break;
+            HN t = heap[i]; heap[i] = heap[s]; heap[s] = t; i = s;
+        }
+        long long cd = cur.d; int u = cur.u;
+        if (cd != dist[u]) continue;
+        for (int e = head[u]; e != -1; e = E[e].next)
+        {
+            int v = E[e].v; long long nd = cd + (long long)E[e].w;
+            if (nd < dist[v])
+            {
+                dist[v] = nd;
+                int k = hsz++;
+                heap[k] = (HN){nd, v};
+                while (k)
+                {
+                    int p = (k - 1) >> 1;
+                    if (heap[p].d <= heap[k].d) break;
+                    HN t = heap[p]; heap[p] = heap[k]; heap[k] = t; k = p;
+                }
+            }
+        }
+    }
+    free(heap);
+    return dist;
+}
+
+int main(void)
+{
+    int N, M, X;
+    if (scanf("%d %d %d", &N, &M, &X) != 3) return 0;
+    int *h1 = (int *)malloc(((size_t)N + 2) * sizeof(int));
+    int *h2 = (int *)malloc(((size_t)N + 2) * sizeof(int));
+    Edge *E1 = (Edge *)malloc(((size_t)M + 5) * sizeof(Edge));
+    Edge *E2 = (Edge *)malloc(((size_t)M + 5) * sizeof(Edge));
+    for (int i = 1; i <= N; ++i) h1[i] = h2[i] = -1;
+    int c1 = 0, c2 = 0;
+    for (int i = 0; i < M; ++i)
+    {
+        int a, b, t; scanf("%d %d %d", &a, &b, &t);
+        E1[c1].v = b; E1[c1].w = t; E1[c1].next = h1[a]; h1[a] = c1++;
+        E2[c2].v = a; E2[c2].w = t; E2[c2].next = h2[b]; h2[b] = c2++;
+    }
+    long long *dx = dij(N, h1, E1, X);
+    long long *rx = dij(N, h2, E2, X);
+    long long ans = 0;
+    for (int i = 1; i <= N; ++i)
+    {
+        long long a = rx[i]; long long b = dx[i];
+        if (a == LLONG_MAX || b == LLONG_MAX) continue;
+        long long s = a + b;
+        if (s > ans) ans = s;
+    }
+    printf("%lld\n", ans);
+    free(h1); free(h2); free(E1); free(E2); free(dx); free(rx);
+    return 0;
+}

exercise/exercise/126.c

@@ -0,0 +1,51 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct { int v, next; } E;
+
+int main(void)
+{
+    int n; if (scanf("%d", &n) != 1) return 0;
+    int *a = (int *)malloc(((size_t)n + 2) * sizeof(int));
+    for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
+    int m = 2 * (n - 1) + n;
+    int *head = (int *)malloc(((size_t)n + 2) * sizeof(int));
+    E *e = (E *)malloc(((size_t)m + 5) * sizeof(E));
+    for (int i = 1; i <= n; ++i) head[i] = -1;
+    int idx = 0;
+    for (int i = 1; i < n; ++i)
+    {
+        e[idx].v = i + 1; e[idx].next = head[i]; head[i] = idx++;
+        e[idx].v = i;     e[idx].next = head[i + 1]; head[i + 1] = idx++;
+    }
+    for (int i = 1; i <= n; ++i)
+    {
+        int v = a[i];
+        e[idx].v = v; e[idx].next = head[i]; head[i] = idx++;
+    }
+    int *dist = (int *)malloc(((size_t)n + 2) * sizeof(int));
+    for (int i = 1; i <= n; ++i) dist[i] = -1;
+    int *q = (int *)malloc(((size_t)n + 5) * sizeof(int));
+    int hh = 0, tt = 0; q[tt++] = 1; dist[1] = 0;
+    while (hh < tt)
+    {
+        int u = q[hh++];
+        for (int i = head[u]; i != -1; i = e[i].next)
+        {
+            int v = e[i].v;
+            if (dist[v] == -1)
+            {
+                dist[v] = dist[u] + 1;
+                q[tt++] = v;
+            }
+        }
+    }
+    for (int i = 1; i <= n; ++i)
+    {
+        if (i > 1) putchar(' ');
+        printf("%d", dist[i]);
+    }
+    putchar('\n');
+    free(a); free(head); free(e); free(dist); free(q);
+    return 0;
+}

exercise/exercise/127.c

@@ -0,0 +1,72 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+
+int main(void)
+{
+    int n, m; long long L;
+    if (scanf("%d %d %lld", &n, &m, &L) != 3) return 0;
+    long long *dist = (long long *)malloc((size_t)(n + 1) * (size_t)(n + 1) * sizeof(long long));
+    for (int i = 1; i <= n; ++i)
+        for (int j = 1; j <= n; ++j)
+            dist[(size_t)i * (n + 1) + j] = (i == j) ? 0LL : LLONG_MAX / 4;
+    for (int i = 0; i < m; ++i)
+    {
+        int u, v; long long c; scanf("%d %d %lld", &u, &v, &c);
+        long long *d1 = &dist[(size_t)u * (n + 1) + v];
+        long long *d2 = &dist[(size_t)v * (n + 1) + u];
+        if (c < *d1) *d1 = c;
+        if (c < *d2) *d2 = c;
+    }
+    for (int k = 1; k <= n; ++k)
+    {
+        for (int i = 1; i <= n; ++i)
+        {
+            long long dik = dist[(size_t)i * (n + 1) + k];
+            if (dik == LLONG_MAX / 4) continue;
+            for (int j = 1; j <= n; ++j)
+            {
+                long long skj = dist[(size_t)k * (n + 1) + j];
+                if (skj == LLONG_MAX / 4) continue;
+                long long alt = dik + skj;
+                long long *dij = &dist[(size_t)i * (n + 1) + j];
+                if (alt < *dij) *dij = alt;
+            }
+        }
+    }
+    unsigned char *reach = (unsigned char *)malloc((size_t)(n + 1) * (size_t)(n + 1));
+    for (int i = 1; i <= n; ++i)
+        for (int j = 1; j <= n; ++j)
+            reach[(size_t)i * (n + 1) + j] = (dist[(size_t)i * (n + 1) + j] <= L) ? 1 : 0;
+    int *steps = (int *)malloc((size_t)(n + 1) * (size_t)(n + 1) * sizeof(int));
+    int *q = (int *)malloc(((size_t)n + 5) * sizeof(int));
+    for (int s = 1; s <= n; ++s)
+    {
+        for (int i = 1; i <= n; ++i) steps[(size_t)s * (n + 1) + i] = -1;
+        int hh = 0, tt = 0; q[tt++] = s; steps[(size_t)s * (n + 1) + s] = 0;
+        while (hh < tt)
+        {
+            int u = q[hh++];
+            int du = steps[(size_t)s * (n + 1) + u];
+            unsigned char *row = &reach[(size_t)u * (n + 1)];
+            for (int v = 1; v <= n; ++v)
+            {
+                if (u == v) continue;
+                if (row[v] && steps[(size_t)s * (n + 1) + v] == -1)
+                {
+                    steps[(size_t)s * (n + 1) + v] = du + 1;
+                    q[tt++] = v;
+                }
+            }
+        }
+    }
+    int qn; scanf("%d", &qn);
+    while (qn--)
+    {
+        int s, t; scanf("%d %d", &s, &t);
+        int d = steps[(size_t)s * (n + 1) + t];
+        if (d == -1) puts("-1"); else printf("%d\n", d - 1);
+    }
+    free(dist); free(reach); free(steps); free(q);
+    return 0;
+}

exercise/exercise/128.c

@@ -0,0 +1,45 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct { int u, v, w; } Edge;
+
+static int cmp_edge(const void *a, const void *b)
+{
+    const Edge *x = (const Edge *)a;
+    const Edge *y = (const Edge *)b;
+    return x->w - y->w;
+}
+
+static int find(int *fa, int x)
+{
+    while (fa[x] != x) { fa[x] = fa[fa[x]]; x = fa[x]; }
+    return x;
+}
+
+int main(void)
+{
+    int n, k;
+    if (scanf("%d %d", &n, &k) != 2) return 0;
+    Edge *E = (Edge *)malloc(((size_t)k + 5) * sizeof(Edge));
+    for (int i = 0; i < k; ++i) scanf("%d %d %d", &E[i].u, &E[i].v, &E[i].w);
+    qsort(E, (size_t)k, sizeof(Edge), cmp_edge);
+    int *fa = (int *)malloc(((size_t)n + 2) * sizeof(int));
+    for (int i = 1; i <= n; ++i) fa[i] = i;
+    long long sum = 0;
+    int used = 0;
+    for (int i = 0; i < k; ++i)
+    {
+        int fu = find(fa, E[i].u);
+        int fv = find(fa, E[i].v);
+        if (fu != fv)
+        {
+            fa[fu] = fv;
+            sum += E[i].w;
+            ++used;
+            if (used == n - 1) break;
+        }
+    }
+    if (used != n - 1) printf("-1\n"); else printf("%lld\n", sum);
+    free(E); free(fa);
+    return 0;
+}

exercise/exercise/129.c

@@ -0,0 +1,124 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+
+typedef struct { int u, v, w; } Edge;
+
+static int cmp_desc(const void *a, const void *b)
+{
+    const Edge *x = (const Edge *)a;
+    const Edge *y = (const Edge *)b;
+    return y->w - x->w;
+}
+
+static int find(int *fa, int x)
+{
+    while (fa[x] != x) { fa[x] = fa[fa[x]]; x = fa[x]; }
+    return x;
+}
+
+int main(void)
+{
+    int n, m;
+    if (scanf("%d %d", &n, &m) != 2) return 0;
+    Edge *E = (Edge *)malloc(((size_t)m + 5) * sizeof(Edge));
+    for (int i = 0; i < m; ++i) scanf("%d %d %d", &E[i].u, &E[i].v, &E[i].w);
+    qsort(E, (size_t)m, sizeof(Edge), cmp_desc);
+    int *fa = (int *)malloc(((size_t)n + 2) * sizeof(int));
+    for (int i = 1; i <= n; ++i) fa[i] = i;
+    int *head = (int *)malloc(((size_t)n + 2) * sizeof(int));
+    for (int i = 1; i <= n; ++i) head[i] = -1;
+    int *to = (int *)malloc(((size_t)(n - 1) * 2 + 5) * sizeof(int));
+    int *wt = (int *)malloc(((size_t)(n - 1) * 2 + 5) * sizeof(int));
+    int *next = (int *)malloc(((size_t)(n - 1) * 2 + 5) * sizeof(int));
+    int idx = 0;
+    for (int i = 0; i < m; ++i)
+    {
+        int fu = find(fa, E[i].u);
+        int fv = find(fa, E[i].v);
+        if (fu != fv)
+        {
+            fa[fu] = fv;
+            to[idx] = E[i].v; wt[idx] = E[i].w; next[idx] = head[E[i].u]; head[E[i].u] = idx++;
+            to[idx] = E[i].u; wt[idx] = E[i].w; next[idx] = head[E[i].v]; head[E[i].v] = idx++;
+        }
+    }
+    int LOG = 15;
+    int *depth = (int *)malloc(((size_t)n + 2) * sizeof(int));
+    for (int i = 1; i <= n; ++i) depth[i] = -1;
+    int *up = (int *)malloc((size_t)LOG * (size_t)(n + 1) * sizeof(int));
+    int *mn = (int *)malloc((size_t)LOG * (size_t)(n + 1) * sizeof(int));
+    int *q = (int *)malloc(((size_t)n + 5) * sizeof(int));
+    for (int i = 1; i <= n; ++i)
+    {
+        if (depth[i] != -1) continue;
+        int hh = 0, tt = 0; q[tt++] = i; depth[i] = 0; up[i] = i; mn[i] = INT_MAX;
+        while (hh < tt)
+        {
+            int u = q[hh++];
+            for (int e = head[u]; e != -1; e = next[e])
+            {
+                int v = to[e];
+                if (depth[v] == -1)
+                {
+                    depth[v] = depth[u] + 1;
+                    up[v] = u;
+                    mn[v] = wt[e];
+                    q[tt++] = v;
+                }
+            }
+        }
+    }
+    for (int k = 1; k < LOG; ++k)
+    {
+        for (int v = 1; v <= n; ++v)
+        {
+            int p = up[(k - 1) * (n + 1) + v];
+            up[k * (n + 1) + v] = up[(k - 1) * (n + 1) + p];
+            int a = mn[(k - 1) * (n + 1) + v];
+            int b = mn[(k - 1) * (n + 1) + p];
+            mn[k * (n + 1) + v] = (a < b) ? a : b;
+        }
+    }
+    int qn; scanf("%d", &qn);
+    while (qn--)
+    {
+        int x, y; scanf("%d %d", &x, &y);
+        if (find(fa, x) != find(fa, y)) { puts("-1"); continue; }
+        int res = INT_MAX;
+        if (depth[x] < depth[y]) { int t = x; x = y; y = t; }
+        int diff = depth[x] - depth[y];
+        for (int k = LOG - 1; k >= 1; --k)
+        {
+            int step = 1 << k;
+            if (diff >= step)
+            {
+                int val = mn[k * (n + 1) + x];
+                if (val < res) res = val;
+                x = up[k * (n + 1) + x];
+                diff -= step;
+            }
+        }
+        if (diff)
+        {
+            int val = mn[x]; if (val < res) res = val; x = up[x];
+        }
+        if (x == y) { printf("%d\n", res); continue; }
+        for (int k = LOG - 1; k >= 1; --k)
+        {
+            int ux = up[k * (n + 1) + x];
+            int uy = up[k * (n + 1) + y];
+            if (ux != uy)
+            {
+                int vx = mn[k * (n + 1) + x]; if (vx < res) res = vx;
+                int vy = mn[k * (n + 1) + y]; if (vy < res) res = vy;
+                x = ux; y = uy;
+            }
+        }
+        int vx = mn[x]; if (vx < res) res = vx; x = up[x];
+        int vy = mn[y]; if (vy < res) res = vy; y = up[y];
+        printf("%d\n", res);
+    }
+    free(E); free(fa); free(head); free(to); free(wt); free(next); free(depth); free(up); free(mn); free(q);
+    return 0;
+}

exercise/exercise/130.c

@@ -0,0 +1,64 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct { int u, v; int w; } E;
+
+static int cmp(const void *a, const void *b)
+{
+    const E *x = (const E *)a; const E *y = (const E *)b;
+    return (x->w < y->w) ? -1 : (x->w > y->w);
+}
+
+static int find(int *fa, int x)
+{
+    while (fa[x] != x) { fa[x] = fa[fa[x]]; x = fa[x]; }
+    return x;
+}
+
+int main(void)
+{
+    int n, k;
+    if (scanf("%d %d", &n, &k) != 2) return 0;
+    int *X = (int *)malloc(((size_t)n + 2) * sizeof(int));
+    int *Y = (int *)malloc(((size_t)n + 2) * sizeof(int));
+    for (int i = 1; i <= n; ++i) scanf("%d %d", &X[i], &Y[i]);
+    size_t m = (size_t)n * (size_t)(n - 1) / 2;
+    E *edges = (E *)malloc((m + 5) * sizeof(E));
+    size_t idx = 0;
+    for (int i = 1; i <= n; ++i)
+    {
+        for (int j = i + 1; j <= n; ++j)
+        {
+            long long dx = (long long)X[i] - (long long)X[j];
+            long long dy = (long long)Y[i] - (long long)Y[j];
+            long long w = dx * dx + dy * dy;
+            edges[idx].u = i; edges[idx].v = j; edges[idx].w = (int)w; ++idx;
+        }
+    }
+    qsort(edges, idx, sizeof(E), cmp);
+    int *fa = (int *)malloc(((size_t)n + 2) * sizeof(int));
+    for (int i = 1; i <= n; ++i) fa[i] = i;
+    int comps = n;
+    double ans = 0.0;
+    for (size_t i = 0; i < idx; ++i)
+    {
+        int u = edges[i].u, v = edges[i].v;
+        int fu = find(fa, u), fv = find(fa, v);
+        if (fu != fv)
+        {
+            if (comps > k)
+            {
+                fa[fu] = fv;
+                --comps;
+            }
+            else
+            {
+                ans = (double)edges[i].w;
+                break;
+            }
+        }
+    }
+    printf("%.2f\n", ans);
+    free(X); free(Y); free(edges); free(fa);
+    return 0;
+}

exercise/exercise/131.c

@@ -0,0 +1,46 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+static int M, N;
+static int CAP;
+static int *ks, *kn, *kf;
+static long long *kv;
+
+static long long dfs(int s, int f, int cur)
+{
+    if (cur == 0)
+        return (s == 0 && f == 0) ? 1LL : 0LL;
+    if (s == 0 && f == 0)
+        return (cur == 0) ? 1LL : 0LL;
+    int h = (((s * 37 + f) * 99991) ^ cur) & (CAP - 1);
+    for (;;)
+    {
+        if (ks[h] == -1)
+            break;
+        if (ks[h] == s && kn[h] == f && kf[h] == cur)
+            return kv[h];
+        h = (h + 1) & (CAP - 1);
+    }
+    long long ans = 0;
+    if (s > 0)
+        ans += dfs(s - 1, f, cur * 2);
+    if (f > 0 && cur >= 2)
+        ans += dfs(s, f - 1, cur - 2);
+    ks[h] = s; kn[h] = f; kf[h] = cur; kv[h] = ans;
+    return ans;
+}
+
+int main(void)
+{
+    if (scanf("%d %d", &M, &N) != 2) return 0;
+    CAP = 1 << 20;
+    ks = (int *)malloc((size_t)CAP * sizeof(int));
+    kn = (int *)malloc((size_t)CAP * sizeof(int));
+    kf = (int *)malloc((size_t)CAP * sizeof(int));
+    kv = (long long *)malloc((size_t)CAP * sizeof(long long));
+    for (int i = 0; i < CAP; ++i) ks[i] = -1;
+    long long ans = dfs(M, N, 5);
+    printf("%lld\n", ans);
+    free(ks); free(kn); free(kf); free(kv);
+    return 0;
+}

exercise/exercise/132.c

@@ -0,0 +1,30 @@
+#include <stdio.h>
+
+static int n, m;
+static int cur[25];
+
+static void dfs(int start, int k)
+{
+    if (k == m)
+    {
+        for (int i = 0; i < m; ++i)
+        {
+            if (i) putchar(' ');
+            printf("%d", cur[i]);
+        }
+        putchar('\n');
+        return;
+    }
+    for (int i = start; i <= n - (m - k) + 1; ++i)
+    {
+        cur[k] = i;
+        dfs(i + 1, k + 1);
+    }
+}
+
+int main(void)
+{
+    if (scanf("%d %d", &n, &m) != 2) return 0;
+    dfs(1, 0);
+    return 0;
+}

exercise/exercise/133.c

@@ -0,0 +1,56 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+static long long target;
+static int L;
+static int K;
+static int found;
+static long long ans;
+
+static void gen(int pos, int c4, int c7, long long cur)
+{
+    if (found) return;
+    if (pos == L)
+    {
+        if (c4 == K && c7 == K && cur >= target)
+        {
+            ans = cur;
+            found = 1;
+        }
+        return;
+    }
+    if (c4 < K) gen(pos + 1, c4 + 1, c7, cur * 10 + 4);
+    if (!found && c7 < K) gen(pos + 1, c4, c7 + 1, cur * 10 + 7);
+}
+
+int main(void)
+{
+    long long n;
+    if (scanf("%lld", &n) != 1) return 0;
+    target = n;
+    int len = 0; long long t = n;
+    while (t) { ++len; t /= 10; }
+    if (len == 0) len = 1;
+    if ((len & 1) == 1)
+    {
+        L = len + 1; K = L / 2;
+        long long cur = 0;
+        for (int i = 0; i < K; ++i) cur = cur * 10 + 4;
+        for (int i = 0; i < K; ++i) cur = cur * 10 + 7;
+        printf("%lld\n", cur);
+        return 0;
+    }
+    L = len; K = L / 2; found = 0; ans = 0;
+    gen(0, 0, 0, 0);
+    if (found)
+    {
+        printf("%lld\n", ans);
+        return 0;
+    }
+    L = len + 2; K = L / 2;
+    long long cur = 0;
+    for (int i = 0; i < K; ++i) cur = cur * 10 + 4;
+    for (int i = 0; i < K; ++i) cur = cur * 10 + 7;
+    printf("%lld\n", cur);
+    return 0;
+}

exercise/exercise/134.c

@@ -0,0 +1,46 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+static int CAP;
+static int *K;
+
+static int add(int x)
+{
+    int h = (x * 1315423911u) & (CAP - 1);
+    for (;;)
+    {
+        if (K[h] == -1) { K[h] = x; return 1; }
+        if (K[h] == x) return 0;
+        h = (h + 1) & (CAP - 1);
+    }
+}
+
+int main(void)
+{
+    int n; if (scanf("%d", &n) != 1) return 0;
+    CAP = 1 << 18;
+    K = (int *)malloc((size_t)CAP * sizeof(int));
+    for (int i = 0; i < CAP; ++i) K[i] = -1;
+    int *q = (int *)malloc(1024 * sizeof(int));
+    int hh = 0, tt = 0;
+    add(n); q[tt++] = n;
+    int cnt = 1;
+    while (hh < tt)
+    {
+        int x = q[hh++];
+        int t = x;
+        while (t >= 10) t /= 10;
+        int h = t;
+        int m = h / 2;
+        int d = 1, y = x;
+        while (y >= 10) { d *= 10; y /= 10; }
+        for (int k = 1; k <= m; ++k)
+        {
+            int v = k * d * 10 + x;
+            if (add(v)) { if (tt < 1024) q[tt++] = v; ++cnt; }
+        }
+    }
+    printf("%d\n", cnt);
+    free(K); free(q);
+    return 0;
+}

exercise/exercise/135.c

@@ -0,0 +1,55 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(void)
+{
+    int K, N, M;
+    if (scanf("%d %d %d", &K, &N, &M) != 3) return 0;
+    int total = K * N * M;
+    char *A = (char *)malloc((size_t)total);
+    for (int z = 0; z < K; ++z)
+        for (int i = 0; i < N; ++i)
+            for (int j = 0; j < M; ++j)
+            {
+                char c;
+                do { if (scanf(" %c", &c) != 1) return 0; } while (c != '.' && c != '#');
+                A[z * N * M + i * M + j] = c;
+            }
+    int sx, sy; if (scanf("%d %d", &sx, &sy) != 2) return 0;
+    int *q = (int *)malloc((size_t)(total + 5) * sizeof(int));
+    unsigned char *vis = (unsigned char *)malloc((size_t)total);
+    for (int i = 0; i < total; ++i) vis[i] = 0;
+    int hh = 0, tt = 0;
+    int sidx = 0 * N * M + (sx - 1) * M + (sy - 1);
+    q[tt++] = sidx; vis[sidx] = 1;
+    int infected = 1;
+    const int dz[6] = {1,-1,0,0,0,0};
+    const int dx[6] = {0,0,1,-1,0,0};
+    const int dy[6] = {0,0,0,0,1,-1};
+    while (hh < tt)
+    {
+        int idx = q[hh++];
+        int z = idx / (N * M);
+        int rem = idx % (N * M);
+        int x = rem / M;
+        int y = rem % M;
+        for (int d = 0; d < 6; ++d)
+        {
+            int nz = z + dz[d];
+            int nx = x + dx[d];
+            int ny = y + dy[d];
+            if (nz < 0 || nz >= K || nx < 0 || nx >= N || ny < 0 || ny >= M) continue;
+            int nidx = nz * N * M + nx * M + ny;
+            if (vis[nidx]) continue;
+            if (A[nidx] == '.')
+            {
+                vis[nidx] = 1;
+                q[tt++] = nidx;
+                ++infected;
+            }
+        }
+    }
+    printf("%d\n", infected);
+    free(A); free(q); free(vis);
+    return 0;
+}

exercise/exercise/136.c

@@ -0,0 +1,57 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(void)
+{
+    int n; if (scanf("%d", &n) != 1) return 0;
+    int *a = (int *)malloc((size_t)n * (size_t)n * sizeof(int));
+    int sx = -1, sy = -1;
+    for (int i = 0; i < n; ++i)
+    {
+        for (int j = 0; j < n; ++j)
+        {
+            int v; scanf("%d", &v);
+            a[i * n + j] = v;
+            if (v == 2) { sx = i; sy = j; }
+        }
+    }
+    int *dist = (int *)malloc((size_t)n * (size_t)n * sizeof(int));
+    unsigned char *vis = (unsigned char *)malloc((size_t)n * (size_t)n);
+    for (int i = 0; i < n * n; ++i) { dist[i] = -1; vis[i] = 0; }
+    int *q = (int *)malloc(((size_t)n * (size_t)n + 5) * sizeof(int));
+    int hh = 0, tt = 0;
+    int sidx = sx * n + sy;
+    dist[sidx] = 0; vis[sidx] = 1; q[tt++] = sidx;
+    const int dx[4] = {1,-1,0,0};
+    const int dy[4] = {0,0,1,-1};
+    while (hh < tt)
+    {
+        int idx = q[hh++];
+        int x = idx / n; int y = idx % n;
+        for (int d = 0; d < 4; ++d)
+        {
+            int nx = x + dx[d]; int ny = y + dy[d];
+            if (nx < 0) nx = n - 1; else if (nx >= n) nx = 0;
+            if (ny < 0) ny = n - 1; else if (ny >= n) ny = 0;
+            int nidx = nx * n + ny;
+            if (vis[nidx]) continue;
+            if (a[nidx] == 0) continue;
+            vis[nidx] = 1;
+            dist[nidx] = dist[idx] + 1;
+            q[tt++] = nidx;
+        }
+    }
+    for (int i = 0; i < n; ++i)
+    {
+        for (int j = 0; j < n; ++j)
+        {
+            int idx = i * n + j;
+            int out = (dist[idx] <= 0) ? 0 : dist[idx];
+            if (j) putchar(' ');
+            printf("%d", out);
+        }
+        putchar('\n');
+    }
+    free(a); free(dist); free(vis); free(q);
+    return 0;
+}

exercise/exercise/137.c

@@ -0,0 +1,72 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+static int len0;
+
+static int get_len(int x){ int c = 0; do { ++c; x /= 10; } while (x); return c; }
+
+static int has_zero(int x){ while (x){ if (x % 10 == 0) return 1; x /= 10; } return 0; }
+
+static void to_digits(int x, int *d, int *L){ int t = x; int l = get_len(x); *L = l; for (int i = l - 1; i >= 0; --i){ d[i] = t % 10; t /= 10; } }
+
+static int from_digits(int *d, int L){ int v = 0; for (int i = 0; i < L; ++i) v = v * 10 + d[i]; return v; }
+
+int main(void)
+{
+    int s; if (scanf("%d", &s) != 1) return 0;
+    len0 = get_len(s);
+    int m; scanf("%d", &m);
+    int *dist = (int *)malloc(100000 * sizeof(int));
+    for (int i = 0; i < 100000; ++i) dist[i] = -1;
+    int *q = (int *)malloc(70000 * sizeof(int));
+    int hh = 0, tt = 0;
+    dist[s] = 0; q[tt++] = s;
+    int d[6], tmp[6];
+    while (hh < tt)
+    {
+        int x = q[hh++];
+        int L; to_digits(x, d, &L);
+        for (int i = 0; i < L; ++i)
+        {
+            for (int j = i + 1; j < L; ++j)
+            {
+                for (int k = 0; k < L; ++k) tmp[k] = d[k];
+                int t = tmp[i]; tmp[i] = tmp[j]; tmp[j] = t;
+                int y = from_digits(tmp, L);
+                if (dist[y] == -1){ dist[y] = dist[x] + 1; q[tt++] = y; }
+            }
+        }
+        if (L >= 2)
+        {
+            for (int i = 0; i < L; ++i)
+            {
+                int p = 0; for (int k = 0; k < L; ++k){ if (k == i) continue; tmp[p++] = d[k]; }
+                int y = from_digits(tmp, L - 1);
+                if (dist[y] == -1){ dist[y] = dist[x] + 1; q[tt++] = y; }
+            }
+        }
+        if (L + 1 <= len0)
+        {
+            for (int i = 0; i < L - 1; ++i)
+            {
+                if (d[i] < d[i + 1])
+                {
+                    for (int xdig = d[i] + 1; xdig <= d[i + 1] - 1; ++xdig)
+                    {
+                        int p = 0; for (int k = 0; k <= i; ++k) tmp[p++] = d[k]; tmp[p++] = xdig; for (int k = i + 1; k < L; ++k) tmp[p++] = d[k];
+                        int y = from_digits(tmp, L + 1);
+                        if (dist[y] == -1){ dist[y] = dist[x] + 1; q[tt++] = y; }
+                    }
+                }
+            }
+        }
+    }
+    for (int i = 0; i < m; ++i)
+    {
+        int t; scanf("%d", &t);
+        if (get_len(t) > len0 || has_zero(t)) { printf("-1\n"); continue; }
+        printf("%d\n", dist[t]);
+    }
+    free(dist); free(q);
+    return 0;
+}

exercise/exercise/138.c

@@ -0,0 +1,40 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int main(void)
+{
+    int n, k;
+    if (scanf("%d %d", &n, &k) != 2)
+        return 0;
+    char *t = (char *)malloc((size_t)n + 5);
+    scanf("%s", t);
+    int *pi = (int *)malloc(((size_t)n) * sizeof(int));
+    pi[0] = 0;
+    for (int i = 1; i < n; ++i)
+    {
+        int j = pi[i - 1];
+        while (j > 0 && t[i] != t[j])
+            j = pi[j - 1];
+        if (t[i] == t[j])
+            ++j;
+        pi[i] = j;
+    }
+    int L = pi[n - 1];
+    int add = n - L;
+    size_t total = (size_t)n + (size_t)(k - 1) * (size_t)add;
+    char *s = (char *)malloc(total + 1);
+    memcpy(s, t, (size_t)n);
+    size_t pos = (size_t)n;
+    for (int i = 1; i < k; ++i)
+    {
+        memcpy(s + pos, t + L, (size_t)add);
+        pos += (size_t)add;
+    }
+    s[total] = '\0';
+    printf("%s\n", s);
+    free(t);
+    free(pi);
+    free(s);
+    return 0;
+}

exercise/exercise/139.c

@@ -0,0 +1,34 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int main(void)
+{
+    char *s = (char *)malloc(1000005);
+    if (scanf("%1000000s", s) != 1) return 0;
+    int n = (int)strlen(s);
+    int *pi = (int *)malloc((size_t)n * sizeof(int));
+    pi[0] = 0;
+    for (int i = 1; i < n; ++i)
+    {
+        int j = pi[i - 1];
+        while (j > 0 && s[i] != s[j]) j = pi[j - 1];
+        if (s[i] == s[j]) ++j;
+        pi[i] = j;
+    }
+    int L = pi[n - 1];
+    int mx = 0;
+    for (int i = 0; i < n - 1; ++i) if (pi[i] > mx) mx = pi[i];
+    while (L > 0 && mx < L) L = pi[L - 1];
+    if (L == 0)
+    {
+        printf("Just a legend\n");
+    }
+    else
+    {
+        s[L] = '\0';
+        printf("%s\n", s);
+    }
+    free(pi); free(s);
+    return 0;
+}

exercise/exercise/140.c

@@ -0,0 +1,37 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(void)
+{
+    int n, m;
+    if (scanf("%d %d", &n, &m) != 2) return 0;
+    int *nxt = (int *)malloc(((size_t)n + 1) * sizeof(int));
+    int *vis = (int *)malloc(((size_t)n + 1) * sizeof(int));
+    for (int i = 1; i <= n; ++i) { nxt[i] = 0; vis[i] = 0; }
+    int stamp = 1;
+    for (int i = 0; i < m; ++i)
+    {
+        char op;
+        int x, y;
+        if (scanf(" %c %d %d", &op, &x, &y) != 3) return 0;
+        if (op == 'A')
+        {
+            nxt[x] = y;
+            if (nxt[y] == x) nxt[y] = 0;
+        }
+        else if (op == 'Q')
+        {
+            ++stamp;
+            int v = x;
+            while (v && vis[v] != stamp)
+            {
+                vis[v] = stamp;
+                if (v == y) break;
+                v = nxt[v];
+            }
+            if (v == y) puts("Yes"); else puts("No");
+        }
+    }
+    free(nxt); free(vis);
+    return 0;
+}

exercise/exercise/141.c

@@ -0,0 +1,24 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(void)
+{
+    int n, q;
+    if (scanf("%d %d", &n, &q) != 2) return 0;
+    int *next = (int *)malloc(((size_t)n + 1) * sizeof(int));
+    for (int i = 1; i <= n; ++i) next[i] = (i == n) ? 1 : (i + 1);
+    int cur = 1, prev = n;
+    while (next[cur] != cur)
+    {
+        for (int c = 1; c < q; ++c)
+        {
+            prev = cur;
+            cur = next[cur];
+        }
+        next[prev] = next[cur];
+        cur = next[cur];
+    }
+    printf("%d\n", cur);
+    free(next);
+    return 0;
+}

exercise/exercise/142.c

@@ -0,0 +1,88 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct Node {
+    int id;
+    char name[32];
+    char gender[4];
+    char birth[16];
+    int zip;
+    char addr[64];
+    long long qq;
+    long long phone;
+    struct Node *next;
+} Node;
+
+static void read_rec(Node *p)
+{
+    char g[8];
+    scanf("%d %31s %7s %15s %d %63s %lld %lld", &p->id, p->name, g, p->birth, &p->zip, p->addr, &p->qq, &p->phone);
+    strcpy(p->gender, g);
+}
+
+static void print_rec(Node *p)
+{
+    printf("%d %s %s %s %d %s %lld %lld\n", p->id, p->name, p->gender, p->birth, p->zip, p->addr, p->qq, p->phone);
+}
+
+int main(void)
+{
+    int cnt; if (scanf("%d", &cnt) != 1) return 0;
+    Node *head = NULL, *tail = NULL;
+    for (int i = 0; i < cnt; ++i)
+    {
+        Node *p = (Node *)malloc(sizeof(Node));
+        read_rec(p); p->next = NULL;
+        if (!head) head = tail = p; else { tail->next = p; tail = p; }
+    }
+    int op; scanf("%d", &op);
+    if (op == 1)
+    {
+        Node *p = (Node *)malloc(sizeof(Node));
+        read_rec(p); p->next = NULL;
+        if (!head) head = tail = p; else { tail->next = p; tail = p; }
+        printf("The records is:\n");
+        int sz = 0; for (Node *q = head; q; q = q->next) ++sz;
+        Node **arr = (Node **)malloc((size_t)sz * sizeof(Node *));
+        int idx = 0; for (Node *q = head; q; q = q->next) arr[idx++] = q;
+        for (int i = sz - 1; i >= 0; --i) print_rec(arr[i]);
+        free(arr);
+    }
+    else if (op == 2)
+    {
+        int did; scanf("%d", &did);
+        Node *prev = NULL, *cur = head;
+        while (cur && cur->id != did) { prev = cur; cur = cur->next; }
+        if (cur)
+        {
+            if (prev) prev->next = cur->next; else head = cur->next;
+            if (tail == cur) tail = prev;
+            free(cur);
+        }
+        printf("The records is:\n");
+        int sz = 0; for (Node *q = head; q; q = q->next) ++sz;
+        Node **arr = (Node **)malloc((size_t)sz * sizeof(Node *));
+        int idx = 0; for (Node *q = head; q; q = q->next) arr[idx++] = q;
+        for (int i = sz - 1; i >= 0; --i) print_rec(arr[i]);
+        free(arr);
+    }
+    else if (op == 3)
+    {
+        int fid; scanf("%d", &fid);
+        Node *cur = head;
+        while (cur && cur->id != fid) cur = cur->next;
+        if (cur) print_rec(cur); else printf("not found\n");
+    }
+    else if (op == 4)
+    {
+        printf("The records is:\n");
+        int sz = 0; for (Node *q = head; q; q = q->next) ++sz;
+        Node **arr = (Node **)malloc((size_t)sz * sizeof(Node *));
+        int idx = 0; for (Node *q = head; q; q = q->next) arr[idx++] = q;
+        for (int i = sz - 1; i >= 0; --i) print_rec(arr[i]);
+        free(arr);
+    }
+    for (Node *q = head; q; ) { Node *nq = q->next; free(q); q = nq; }
+    return 0;
+}

exercise/exercise/143.c

@@ -0,0 +1,38 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct { int c; int e; } T;
+
+int main(void)
+{
+    int n, m;
+    if (scanf("%d %d", &n, &m) != 2) return 0;
+    T *A = (T *)malloc((size_t)n * sizeof(T));
+    T *B = (T *)malloc((size_t)m * sizeof(T));
+    for (int i = 0; i < n; ++i) scanf("%d %d", &A[i].c, &A[i].e);
+    for (int i = 0; i < m; ++i) scanf("%d %d", &B[i].c, &B[i].e);
+    int i = 0, j = 0;
+    while (i < n && j < m)
+    {
+        if (A[i].e == B[j].e)
+        {
+            int c = A[i].c + B[j].c;
+            if (c != 0) printf("%d %d\n", c, A[i].e);
+            ++i; ++j;
+        }
+        else if (A[i].e < B[j].e)
+        {
+            if (A[i].c != 0) printf("%d %d\n", A[i].c, A[i].e);
+            ++i;
+        }
+        else
+        {
+            if (B[j].c != 0) printf("%d %d\n", B[j].c, B[j].e);
+            ++j;
+        }
+    }
+    while (i < n) { if (A[i].c != 0) printf("%d %d\n", A[i].c, A[i].e); ++i; }
+    while (j < m) { if (B[j].c != 0) printf("%d %d\n", B[j].c, B[j].e); ++j; }
+    free(A); free(B);
+    return 0;
+}

exercise/exercise/144.c

@@ -0,0 +1,55 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+static uint64_t getv(FILE *f, int idx)
+{
+    uint64_t v;
+    long off = (long)idx * (long)sizeof(uint64_t);
+    fseek(f, off, SEEK_SET);
+    fread(&v, sizeof(uint64_t), 1, f);
+    return v;
+}
+
+int main(void)
+{
+    int n; if (scanf("%d", &n) != 1) return 0;
+    FILE *f = tmpfile();
+    if (!f) return 0;
+    for (int i = 0; i < n; ++i)
+    {
+        unsigned long long x; scanf("%llu", &x);
+        fwrite(&x, sizeof(uint64_t), 1, f);
+    }
+    int *st = (int *)malloc((size_t)n * sizeof(int));
+    int top = 0;
+    long long ans = 0;
+    size_t B = 1 << 20;
+    uint64_t *buf = (uint64_t *)malloc(B * sizeof(uint64_t));
+    long long pos = (long long)n - 1;
+    while (pos >= 0)
+    {
+        size_t take = (pos + 1 < (long long)B) ? (size_t)(pos + 1) : B;
+        long long start = pos - (long long)take + 1;
+        long off = (long)(start * (long long)sizeof(uint64_t));
+        fseek(f, off, SEEK_SET);
+        fread(buf, sizeof(uint64_t), take, f);
+        for (long long p = (long long)take - 1; p >= 0; --p)
+        {
+            int i = (int)(start + p);
+            uint64_t h = buf[p];
+            while (top > 0)
+            {
+                uint64_t t = getv(f, st[top - 1]);
+                if (t < h) --top; else break;
+            }
+            if (top > 0) ans += (long long)(st[top - 1] - i - 1);
+            else ans += (long long)(n - 1 - i);
+            st[top++] = i;
+        }
+        pos = start - 1;
+    }
+    printf("%lld\n", ans);
+    free(st); free(buf); fclose(f);
+    return 0;
+}

exercise/exercise/145.c

@@ -0,0 +1,19 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(void)
+{
+    int n; if (scanf("%d", &n) != 1) return 0;
+    long long *st = (long long *)malloc((size_t)n * sizeof(long long));
+    int top = 0;
+    long long ans = 0;
+    for (int i = 0; i < n; ++i)
+    {
+        long long d, h; scanf("%lld %lld", &d, &h);
+        while (top > 0 && st[top - 1] > h) --top;
+        if (h > 0 && (top == 0 || st[top - 1] < h)) { st[top++] = h; ++ans; }
+    }
+    printf("%lld\n", ans);
+    free(st);
+    return 0;
+}

exercise/exercise/146.c

@@ -0,0 +1,31 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+static const long long MOD = 99887765LL;
+
+int main(void)
+{
+    int n; long long x;
+    if (scanf("%d %lld", &n, &x) != 2) return 0;
+    int *a = (int *)malloc(((size_t)n + 1) * sizeof(int));
+    for (int i = 0; i <= n; ++i) scanf("%d", &a[i]);
+    int *st = (int *)malloc(((size_t)n + 1) * sizeof(int));
+    int top = 0;
+    long long ans = 0;
+    long long xmod = x % MOD; if (xmod < 0) xmod += MOD;
+    long long pw = 1;
+    for (int i = n; i >= 0; --i)
+    {
+        while (top > 0 && a[st[top - 1]] >= a[i]) --top;
+        int bi = (top > 0) ? a[st[top - 1]] : 0;
+        long long bmi = bi % MOD; if (bmi < 0) bmi += MOD;
+        ans += (bmi * pw) % MOD;
+        ans %= MOD;
+        if (i > 0) { pw = (pw * xmod) % MOD; }
+        st[top++] = i;
+    }
+    if (ans < 0) ans += MOD;
+    printf("%lld\n", ans);
+    free(a); free(st);
+    return 0;
+}

exercise/exercise/147.c

@@ -0,0 +1,32 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(void)
+{
+    int n, m;
+    if (scanf("%d %d", &n, &m) != 2) return 0;
+    if (m == 0) { printf("0\n"); return 0; }
+    long long *a = (long long *)malloc((size_t)n * sizeof(long long));
+    for (int i = 0; i < n; ++i) scanf("%lld", &a[i]);
+    long long *p = (long long *)malloc(((size_t)n + 1) * sizeof(long long));
+    p[0] = 0;
+    for (int i = 1; i <= n; ++i) p[i] = p[i - 1] + a[i - 1];
+    int *dq = (int *)malloc(((size_t)n + 1) * sizeof(int));
+    int head = 0, tail = 0;
+    dq[tail++] = 0;
+    long long ans = p[1] - p[0];
+    for (int i = 1; i <= n; ++i)
+    {
+        while (head < tail && dq[head] < i - m) ++head;
+        if (head < tail)
+        {
+            long long val = p[i] - p[dq[head]];
+            if (val > ans) ans = val;
+        }
+        while (head < tail && p[dq[tail - 1]] >= p[i]) --tail;
+        dq[tail++] = i;
+    }
+    printf("%lld\n", ans);
+    free(a); free(p); free(dq);
+    return 0;
+}

exercise/exercise/148.c

@@ -0,0 +1,56 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct { long long x, y; } P;
+
+static int cmpx(const void *a, const void *b){ const P *pa=a, *pb=b; if (pa->x<pb->x) return -1; if (pa->x>pb->x) return 1; return 0; }
+
+static int ok(P *p, int n, long long W, long long D)
+{
+    int *qmax = (int *)malloc((size_t)n * sizeof(int));
+    int *qmin = (int *)malloc((size_t)n * sizeof(int));
+    int hmax=0,tmax=0,hmin=0,tmin=0;
+    int l=0;
+    for (int r=0;r<n;++r)
+    {
+        while (tmax>hmax && p[qmax[tmax-1]].y<=p[r].y) --tmax;
+        qmax[tmax++]=r;
+        while (tmin>hmin && p[qmin[tmin-1]].y>=p[r].y) --tmin;
+        qmin[tmin++]=r;
+        while (p[r].x - p[l].x > W)
+        {
+            if (hmax<tmax && qmax[hmax]==l) ++hmax;
+            if (hmin<tmin && qmin[hmin]==l) ++hmin;
+            ++l;
+        }
+        if (tmax>hmax && tmin>hmin)
+        {
+            long long mx = p[qmax[hmax]].y;
+            long long mn = p[qmin[hmin]].y;
+            if (mx - mn >= D) { free(qmax); free(qmin); return 1; }
+        }
+    }
+    free(qmax); free(qmin); return 0;
+}
+
+int main(void)
+{
+    int N; long long D;
+    if (scanf("%d %lld", &N, &D) != 2) return 0;
+    P *p = (P *)malloc((size_t)N * sizeof(P));
+    for (int i=0;i<N;++i) scanf("%lld %lld", &p[i].x, &p[i].y);
+    qsort(p, N, sizeof(P), cmpx);
+    long long L=0, R=0;
+    if (N>0) R = p[N-1].x - p[0].x;
+    long long ans=-1;
+    long long lo=L, hi=R;
+    while (lo<=hi)
+    {
+        long long mid = lo + ((hi - lo) >> 1);
+        if (ok(p, N, mid, D)) { ans = mid; hi = mid - 1; }
+        else lo = mid + 1;
+    }
+    printf("%lld\n", ans);
+    free(p);
+    return 0;
+}

exercise/exercise/149.c

@@ -0,0 +1,93 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef long long LL;
+
+static LL *low, *up; // max-heap(low), min-heap(up)
+static int szLow, szUp;
+static LL *qarr; static int qh, qt;
+
+static LL *delKeys; static unsigned char *delUsed; static int DEL_CAP;
+
+static unsigned int h64(LL x){ unsigned long long u = (unsigned long long)x; u ^= u >> 33; u *= 0xff51afd7ed558ccdULL; u ^= u >> 33; u *= 0xc4ceb9fe1a85aa39ULL; u ^= u >> 33; return (unsigned int)u; }
+
+static void delInit(void){ DEL_CAP = 1<<20; delKeys = (LL*)malloc((size_t)DEL_CAP * sizeof(LL)); delUsed = (unsigned char*)malloc((size_t)DEL_CAP); for (int i=0;i<DEL_CAP;++i) delUsed[i]=0; }
+static void delClear(void){ for (int i=0;i<DEL_CAP;++i) delUsed[i]=0; }
+static void delMark(LL x){ unsigned int m = DEL_CAP-1; unsigned int h = h64(x) & m; while (delUsed[h] && delKeys[h]!=x){ h=(h+1)&m; } delKeys[h]=x; delUsed[h]=1; }
+static int delHas(LL x){ unsigned int m = DEL_CAP-1; unsigned int h = h64(x) & m; while (delUsed[h]){ if (delKeys[h]==x) return 1; h=(h+1)&m; } return 0; }
+
+static void maxPush(LL *a, int *n, LL v){ int i=*n; a[i]=v; (*n)++; while (i>0){ int p=(i-1)/2; if (a[p] >= a[i]) break; LL t=a[p]; a[p]=a[i]; a[i]=t; i=p; } }
+static LL maxTop(LL *a, int n){ return n? a[0] : 0; }
+static void maxPop(LL *a, int *n){ int s=*n; if (s==0) return; a[0]=a[s-1]; (*n)--; s=*n; int i=0; while (1){ int l=2*i+1, r=2*i+2, b=i; if (l<s && a[l]>a[b]) b=l; if (r<s && a[r]>a[b]) b=r; if (b==i) break; LL t=a[i]; a[i]=a[b]; a[b]=t; i=b; } }
+
+static void minPush(LL *a, int *n, LL v){ int i=*n; a[i]=v; (*n)++; while (i>0){ int p=(i-1)/2; if (a[p] <= a[i]) break; LL t=a[p]; a[p]=a[i]; a[i]=t; i=p; } }
+static LL minTop(LL *a, int n){ return n? a[0] : 0; }
+static void minPop(LL *a, int *n){ int s=*n; if (s==0) return; a[0]=a[s-1]; (*n)--; s=*n; int i=0; while (1){ int l=2*i+1, r=2*i+2, b=i; if (l<s && a[l]<a[b]) b=l; if (r<s && a[r]<a[b]) b=r; if (b==i) break; LL t=a[i]; a[i]=a[b]; a[b]=t; i=b; } }
+
+static void pruneLow(void){ while (szLow>0){ LL v = maxTop(low, szLow); if (!delHas(v)) break; maxPop(low, &szLow); }
+}
+static void pruneUp(void){ while (szUp>0){ LL v = minTop(up, szUp); if (!delHas(v)) break; minPop(up, &szUp); }
+}
+
+static int mcount(void){ return szLow + szUp; }
+static int targetK(void){ int m = mcount(); return m/2 + 1; }
+
+static void rebalance(void)
+{
+    pruneLow(); pruneUp();
+    int k = targetK();
+    while (szLow > 0 && szLow > k){ LL v = maxTop(low, szLow); maxPop(low, &szLow); minPush(up, &szUp, v); pruneLow(); }
+    while (szUp > 0 && szLow < k){ LL v = minTop(up, szUp); minPop(up, &szUp); maxPush(low, &szLow, v); pruneUp(); }
+}
+
+int main(void)
+{
+    delInit();
+    int n; int cas=1; while (scanf("%d", &n)==1)
+    {
+        int cap = n + 5;
+        low = (LL*)malloc((size_t)cap * sizeof(LL));
+        up  = (LL*)malloc((size_t)cap * sizeof(LL));
+        qarr= (LL*)malloc((size_t)cap * sizeof(LL));
+        szLow=szUp=0; qh=0; qt=0;
+        delClear();
+        printf("Case #%d:\n", cas++);
+        for (int i=0;i<n;++i)
+        {
+            char op[16];
+            if (scanf("%15s", op)!=1) return 0;
+            if (op[0]=='i')
+            {
+                LL x; scanf("%lld", &x);
+                qarr[qt++]=x;
+                pruneLow();
+                if (szLow==0){ maxPush(low, &szLow, x); }
+                else{
+                    LL med = maxTop(low, szLow);
+                    if (x <= med) maxPush(low, &szLow, x);
+                    else minPush(up, &szUp, x);
+                }
+                rebalance();
+            }
+            else if (op[0]=='o')
+            {
+                LL v = qarr[qh++];
+                pruneLow();
+                LL med = szLow? maxTop(low, szLow) : (LL)0;
+                delMark(v);
+                if (szLow>0 && v <= med) { szLow--; }
+                else { szUp--; }
+                rebalance();
+            }
+            else
+            {
+                pruneLow();
+                LL med = maxTop(low, szLow);
+                printf("%lld\n", med);
+            }
+        }
+        free(low); free(up); free(qarr);
+    }
+    free(delKeys); free(delUsed);
+    return 0;
+}

exercise/exercise/150.c

@@ -0,0 +1,34 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(void)
+{
+    int n; if (scanf("%d", &n) != 1) return 0;
+    long long *a = (long long *)malloc(((size_t)n + 1) * sizeof(long long));
+    for (int i = 1; i <= n; ++i) scanf("%lld", &a[i]);
+    int *L = (int *)malloc(((size_t)n + 1) * sizeof(int));
+    int *R = (int *)malloc(((size_t)n + 1) * sizeof(int));
+    for (int i = 1; i <= n; ++i) { int l, r; scanf("%d %d", &l, &r); L[i] = l; R[i] = r; }
+    int *stk = (int *)malloc(((size_t)n + 5) * sizeof(int));
+    int top = 0;
+    int cur = 1;
+    int cnt = 0;
+    int hasPrev = 0; long long prev = 0;
+    while (cur != 0 || top > 0)
+    {
+        while (cur != 0)
+        {
+            stk[top++] = cur;
+            cur = L[cur];
+        }
+        cur = stk[--top];
+        if (!hasPrev) { prev = a[cur]; hasPrev = 1; }
+        else { if (a[cur] <= prev) { printf("No\n"); free(a); free(L); free(R); free(stk); return 0; } prev = a[cur]; }
+        ++cnt;
+        cur = R[cur];
+    }
+    if (cnt != n) { printf("No\n"); }
+    else { printf("Yes\n"); }
+    free(a); free(L); free(R); free(stk);
+    return 0;
+}

exercise/exercise/151.c

@@ -0,0 +1,56 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+static void minPush(long long *h, int *sz, long long v)
+{
+    int i = (*sz);
+    h[i] = v; (*sz)++;
+    while (i > 0)
+    {
+        int p = (i - 1) >> 1;
+        if (h[p] <= h[i]) break;
+        long long t = h[p]; h[p] = h[i]; h[i] = t; i = p;
+    }
+}
+
+static long long minPop(long long *h, int *sz)
+{
+    long long r = h[0];
+    int s = --(*sz);
+    h[0] = h[s];
+    int i = 0;
+    while (1)
+    {
+        int l = (i << 1) | 1, rgt = l + 1, b = i;
+        if (l < s && h[l] < h[b]) b = l;
+        if (rgt < s && h[rgt] < h[b]) b = rgt;
+        if (b == i) break;
+        long long t = h[i]; h[i] = h[b]; h[b] = t; i = b;
+    }
+    return r;
+}
+
+int main(void)
+{
+    int n; if (scanf("%d", &n) != 1) return 0;
+    long long *h = (long long *)malloc((size_t)n * sizeof(long long));
+    int sz = 0;
+    for (int i = 0; i < n; ++i)
+    {
+        long long x; scanf("%lld", &x);
+        minPush(h, &sz, x);
+    }
+    long long ans = 0;
+    if (sz == 0) { printf("0\n"); free(h); return 0; }
+    while (sz > 1)
+    {
+        long long a = minPop(h, &sz);
+        long long b = minPop(h, &sz);
+        long long c = a + b;
+        ans += c;
+        minPush(h, &sz, c);
+    }
+    printf("%lld\n", ans);
+    free(h);
+    return 0;
+}

exercise/exercise/152.c

@@ -0,0 +1,63 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+static void minPush(long long *h, int *sz, long long v)
+{
+    int i = (*sz);
+    h[i] = v; (*sz)++;
+    while (i > 0)
+    {
+        int p = (i - 1) >> 1;
+        if (h[p] <= h[i]) break;
+        long long t = h[p]; h[p] = h[i]; h[i] = t; i = p;
+    }
+}
+
+static long long minPop(long long *h, int *sz)
+{
+    long long r = h[0];
+    int s = --(*sz);
+    h[0] = h[s];
+    int i = 0;
+    while (1)
+    {
+        int l = (i << 1) | 1, rgt = l + 1, b = i;
+        if (l < s && h[l] < h[b]) b = l;
+        if (rgt < s && h[rgt] < h[b]) b = rgt;
+        if (b == i) break;
+        long long t = h[i]; h[i] = h[b]; h[b] = t; i = b;
+    }
+    return r;
+}
+
+int main(void)
+{
+    char *s = (char *)malloc(200005);
+    if (scanf("%200000s", s) != 1) return 0;
+    long long cnt[26] = {0};
+    for (char *p = s; *p; ++p) cnt[*p - 'A']++;
+    int kinds = 0;
+    for (int i = 0; i < 26; ++i) if (cnt[i] > 0) ++kinds;
+    if (kinds == 0) { printf("0\n"); free(s); return 0; }
+    long long *h = (long long *)malloc((size_t)kinds * sizeof(long long));
+    int sz = 0;
+    for (int i = 0; i < 26; ++i) if (cnt[i] > 0) minPush(h, &sz, cnt[i]);
+    if (sz == 1)
+    {
+        long long ans = h[0];
+        printf("%lld\n", ans);
+        free(h); free(s); return 0;
+    }
+    long long ans = 0;
+    while (sz > 1)
+    {
+        long long a = minPop(h, &sz);
+        long long b = minPop(h, &sz);
+        long long c = a + b;
+        ans += c;
+        minPush(h, &sz, c);
+    }
+    printf("%lld\n", ans);
+    free(h); free(s);
+    return 0;
+}

exercise/exercise/45.c

@@ -0,0 +1,45 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+int main(void)
+{
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+
+    int n;
+    if (scanf("%d", &n) != 1) return 0;
+    long long *a = (long long*)malloc((size_t)n * sizeof(long long));
+    long long sum = 0;
+    for (int i = 0; i < n; ++i) { scanf("%lld", &a[i]); sum += a[i]; }
+    long long avg = sum / n;
+
+    long long *s = (long long*)malloc((size_t)n * sizeof(long long));
+    long long cur = 0;
+    for (int i = 0; i < n; ++i) { cur += a[i] - avg; s[i] = cur; }
+
+    long long *t = (long long*)malloc((size_t)n * sizeof(long long));
+    for (int i = 0; i < n; ++i) t[i] = s[i];
+    int cmp(const void *x, const void *y) {
+        long long ux = *(const long long*)x, uy = *(const long long*)y;
+        return (ux > uy) - (ux < uy);
+    }
+    qsort(t, (size_t)n, sizeof(long long), cmp);
+    long long med = t[n/2];
+
+    long long ans = 0;
+    for (int i = 0; i < n; ++i) {
+        long long d = s[i] - med; if (d < 0) d = -d; ans += d;
+    }
+    printf("%lld\n", ans);
+
+    free(t);
+    free(s);
+    free(a);
+    return 0;
+}

exercise/exercise/46.c

@@ -0,0 +1,40 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef struct { long long w, s; long long key; } Man;
+
+static int cmp(const void *a, const void *b) {
+    const Man *x = (const Man*)a, *y = (const Man*)b;
+    if (x->key < y->key) return -1;
+    if (x->key > y->key) return 1;
+    return 0;
+}
+
+int main(void) {
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n;
+    if (scanf("%d", &n) != 1) return 0;
+    Man *a = (Man*)malloc((size_t)n * sizeof(Man));
+    for (int i = 0; i < n; ++i) {
+        long long w, s;
+        scanf("%lld %lld", &w, &s);
+        a[i].w = w; a[i].s = s; a[i].key = w + s;
+    }
+    qsort(a, (size_t)n, sizeof(Man), cmp);
+    long long pref = 0, ans = -((long long)1<<62);
+    for (int i = 0; i < n; ++i) {
+        long long risk = pref - a[i].s;
+        if (risk > ans) ans = risk;
+        pref += a[i].w;
+    }
+    printf("%lld\n", ans);
+    free(a);
+    return 0;
+}

exercise/exercise/47.c

@@ -0,0 +1,34 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+int main(void)
+{
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int T;
+    if (scanf("%d", &T) != 1) return 0;
+    while (T--)
+    {
+        long long n;
+        if (scanf("%lld", &n) != 1) return 0;
+        long long ans;
+        if ((n & 1LL) == 0)
+        {
+            if (n == 2) ans = -1;
+            else ans = n / 4;
+        }
+        else
+        {
+            if (n < 9 || n == 11) ans = -1;
+            else ans = (n - 9) / 4 + 1;
+        }
+        printf("%lld\n", ans);
+    }
+    return 0;
+}

exercise/exercise/48.c

@@ -0,0 +1,35 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+static int cmp_int(const void *a, const void *b) {
+    int x = *(const int*)a, y = *(const int*)b;
+    return (x > y) - (x < y);
+}
+
+int main(void) {
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n, m;
+    if (scanf("%d %d", &n, &m) != 2) return 0;
+    int *d = (int*)malloc((size_t)n * sizeof(int));
+    int *w = (int*)malloc((size_t)m * sizeof(int));
+    for (int i = 0; i < n; ++i) scanf("%d", &d[i]);
+    for (int i = 0; i < m; ++i) scanf("%d", &w[i]);
+    qsort(d, (size_t)n, sizeof(int), cmp_int);
+    qsort(w, (size_t)m, sizeof(int), cmp_int);
+    int i = 0, j = 0;
+    while (i < n && j < m) {
+        if (w[j] >= d[i]) { ++i; ++j; }
+        else { ++j; }
+    }
+    printf(i == n ? "YES\n" : "NO\n");
+    free(d);
+    free(w);
+    return 0;
+}

exercise/exercise/49.c

@@ -0,0 +1,58 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef struct { double l, r; } Seg;
+
+static int cmp_seg(const void *a, const void *b) {
+    const Seg *x = (const Seg*)a, *y = (const Seg*)b;
+    if (x->r < y->r) return -1;
+    if (x->r > y->r) return 1;
+    if (x->l < y->l) return -1;
+    if (x->l > y->l) return 1;
+    return 0;
+}
+
+int main(void) {
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n, r;
+    while (scanf("%d %d", &n, &r) == 2) {
+        if (n == 0 && r == 0) break;
+        Seg *a = (Seg*)malloc((size_t)n * sizeof(Seg));
+        int ok = r >= 0;
+        for (int i = 0; i < n; ++i) {
+            int x, y;
+            scanf("%d %d", &x, &y);
+            double yy = (double)y;
+            double rr = (double)r;
+            if (!ok || yy > rr || yy < -rr) { ok = 0; continue; }
+            double t = rr*rr - yy*yy;
+            if (t < 0) { ok = 0; continue; }
+            double dx = sqrt(t);
+            a[i].l = (double)x - dx;
+            a[i].r = (double)x + dx;
+        }
+        if (!ok) {
+            printf("-1\n");
+            free(a);
+            continue;
+        }
+        qsort(a, (size_t)n, sizeof(Seg), cmp_seg);
+        const double eps = 1e-12;
+        double p = -1e300;
+        int ans = 0;
+        for (int i = 0; i < n; ++i) {
+            if (a[i].l > p + eps) { ++ans; p = a[i].r; }
+        }
+        printf("%d\n", ans);
+        free(a);
+    }
+    return 0;
+}

exercise/exercise/50.c

@@ -0,0 +1,77 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef long long ll;
+
+typedef struct { int b; ll c; } Type;
+
+static int cmp_int(const void *a, const void *b) {
+    int x = *(const int*)a, y = *(const int*)b;
+    return (x > y) - (x < y);
+}
+
+static int cmp_type(const void *a, const void *b) {
+    const Type *x = (const Type*)a, *y = (const Type*)b;
+    if (x->b < y->b) return -1;
+    if (x->b > y->b) return 1;
+    return 0;
+}
+
+static int ok(ll L, int n, const int *a, int m, const Type *t, const ll *pref, ll total) {
+    for (int i = 0; i < n; ++i) {
+        int ai = a[i];
+        int l = 0, r = m;
+        while (l < r) {
+            int mid = (l + r) >> 1;
+            if (t[mid].b >= ai) r = mid; else l = mid + 1;
+        }
+        ll need = total - pref[l];
+        ll cap = (ll)(n - i) * L;
+        if (need > cap) return 0;
+    }
+    return total <= (ll)n * L;
+}
+
+int main(void) {
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n;
+    if (scanf("%d", &n) != 1) return 0;
+    int *a = (int*)malloc((size_t)n * sizeof(int));
+    for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
+    int m;
+    scanf("%d", &m);
+    Type *t = (Type*)malloc((size_t)m * sizeof(Type));
+    for (int i = 0; i < m; ++i) scanf("%d", &t[i].b);
+    for (int i = 0; i < m; ++i) scanf("%lld", &t[i].c);
+    qsort(a, (size_t)n, sizeof(int), cmp_int);
+    qsort(t, (size_t)m, sizeof(Type), cmp_type);
+    int maxa = a[n - 1];
+    int maxb = t[m - 1].b;
+    if (maxb > maxa) {
+        printf("-1\n");
+        free(t); free(a);
+        return 0;
+    }
+    ll *pref = (ll*)malloc(((size_t)m + 1) * sizeof(ll));
+    pref[0] = 0;
+    for (int i = 0; i < m; ++i) pref[i + 1] = pref[i] + t[i].c;
+    ll total = pref[m];
+    ll lo = (total + n - 1) / n, hi = total, ans = hi;
+    while (lo <= hi) {
+        ll mid = lo + ((hi - lo) >> 1);
+        if (ok(mid, n, a, m, t, pref, total)) { ans = mid; hi = mid - 1; }
+        else lo = mid + 1;
+    }
+    printf("%lld\n", ans);
+    free(pref);
+    free(t);
+    free(a);
+    return 0;
+}

exercise/exercise/51.c

@@ -0,0 +1,34 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef long long ll;
+
+int main(void) {
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n;
+    if (scanf("%d", &n) != 1) return 0;
+    int *p = (int*)malloc((size_t)n * sizeof(int));
+    ll *d = (ll*)malloc((size_t)n * sizeof(ll));
+    for (int i = 0; i < n; ++i) scanf("%d", &p[i]);
+    for (int i = 0; i < n; ++i) scanf("%lld", &d[i]);
+    ll ans = p[n - 1];
+    ll s = 0;
+    int in = 0;
+    int start = 0;
+    for (int i = 0; i < n; ++i) {
+        s += d[i];
+        if (!in && s < 0) { in = 1; start = p[i]; }
+        if (in && s >= 0) { ans += 2LL * (p[i] - start); in = 0; }
+    }
+    printf("%lld\n", ans);
+    free(d);
+    free(p);
+    return 0;
+}

exercise/exercise/52.c

@@ -0,0 +1,87 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef struct { int val; int nxt; } Node;
+
+static Node *heap;
+static int hsz;
+
+static void swap(Node *a, Node *b){ Node t=*a; *a=*b; *b=t; }
+static int cmp(Node a, Node b){ return a.nxt > b.nxt; }
+static void heap_push(Node x){
+    int i = hsz++;
+    heap[i] = x;
+    while (i > 0) {
+        int p = (i - 1) >> 1;
+        if (cmp(heap[i], heap[p])) { swap(&heap[i], &heap[p]); i = p; } else break;
+    }
+}
+static Node heap_top(){ return heap[0]; }
+static void heap_pop(){
+    heap[0] = heap[--hsz];
+    int i = 0;
+    for (;;) {
+        int l = i * 2 + 1, r = l + 1, m = i;
+        if (l < hsz && cmp(heap[l], heap[m])) m = l;
+        if (r < hsz && cmp(heap[r], heap[m])) m = r;
+        if (m == i) break;
+        swap(&heap[i], &heap[m]); i = m;
+    }
+}
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int N,m,p;
+    while (scanf("%d %d %d", &N, &m, &p) == 3) {
+        int *seq = (int*)malloc((size_t)p * sizeof(int));
+        for (int i = 0; i < p; ++i) scanf("%d", &seq[i]);
+        int INF = p + 1;
+        int *nxt = (int*)malloc((size_t)p * sizeof(int));
+        int *last = (int*)malloc(((size_t)m + 1) * sizeof(int));
+        for (int i = 1; i <= m; ++i) last[i] = INF;
+        for (int i = p - 1; i >= 0; --i) { int v = seq[i]; nxt[i] = last[v]; last[v] = i; }
+        int *in = (int*)calloc((size_t)m + 1, sizeof(int));
+        int *cur = (int*)malloc(((size_t)m + 1) * sizeof(int));
+        for (int i = 1; i <= m; ++i) cur[i] = -1;
+        heap = (Node*)malloc((size_t)p * sizeof(Node));
+        hsz = 0;
+        int cnt = 0;
+        int miss = 0;
+        for (int i = 0; i < p; ++i) {
+            int v = seq[i];
+            if (in[v]) {
+                cur[v] = nxt[i];
+                Node x = { v, nxt[i] };
+                heap_push(x);
+            } else {
+                ++miss;
+                if (cnt < N) {
+                    in[v] = 1; cur[v] = nxt[i]; ++cnt; Node x = { v, nxt[i] }; heap_push(x);
+                } else {
+                    for (;;) {
+                        if (hsz == 0) break;
+                        Node t = heap_top();
+                        if (!in[t.val] || cur[t.val] != t.nxt) { heap_pop(); continue; }
+                        in[t.val] = 0; cur[t.val] = -1; heap_pop(); break;
+                    }
+                    in[v] = 1; cur[v] = nxt[i]; Node x = { v, nxt[i] }; heap_push(x);
+                }
+            }
+        }
+        printf("%d\n", miss);
+        free(heap);
+        free(cur);
+        free(in);
+        free(last);
+        free(nxt);
+        free(seq);
+    }
+    return 0;
+}

exercise/exercise/53.c

@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+static int cmp_int(const void *a, const void *b){
+    int x = *(const int*)a, y = *(const int*)b;
+    return (x > y) - (x < y);
+}
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n;
+    if (scanf("%d", &n) != 1) return 0;
+    int *t = (int*)malloc((size_t)n * sizeof(int));
+    for (int i = 0; i < n; ++i) scanf("%d", &t[i]);
+    qsort(t, (size_t)n, sizeof(int), cmp_int);
+    long long cur = 0, sum = 0;
+    for (int i = 0; i < n; ++i){ sum += cur; cur += t[i]; }
+    double ans = (double)sum / (double)n;
+    printf("%.2f\n", ans);
+    free(t);
+    return 0;
+}

exercise/exercise/54.c

@@ -0,0 +1,52 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef long long ll;
+
+typedef struct { unsigned int a; ll w; } Item;
+
+static int cmp(const void *x, const void *y){
+    const Item *u = (const Item*)x, *v = (const Item*)y;
+    if (u->a < v->a) return -1;
+    if (u->a > v->a) return 1;
+    return 0;
+}
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n;
+    if (scanf("%d", &n) != 1) return 0;
+    Item *arr = (Item*)malloc((size_t)n * sizeof(Item));
+    for (int i = 0; i < n; ++i){
+        unsigned int a; ll w;
+        scanf("%u %lld", &a, &w);
+        arr[i].a = a; arr[i].w = w;
+    }
+    qsort(arr, (size_t)n, sizeof(Item), cmp);
+    ll total = 0, sumMax = 0;
+    int i = 0;
+    while (i < n){
+        unsigned int cat = arr[i].a;
+        ll mx = arr[i].w;
+        total += arr[i].w;
+        int j = i + 1;
+        while (j < n && arr[j].a == cat){
+            if (arr[j].w > mx) mx = arr[j].w;
+            total += arr[j].w;
+            ++j;
+        }
+        sumMax += mx;
+        i = j;
+    }
+    ll ans = total - sumMax;
+    printf("%lld\n", ans);
+    free(arr);
+    return 0;
+}

exercise/exercise/55.c

@@ -0,0 +1,40 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n;
+    if (scanf("%d", &n) != 1) return 0;
+    int *a = (int*)malloc((size_t)n * sizeof(int));
+    for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
+    int *L = (int*)malloc((size_t)n * sizeof(int));
+    int *R = (int*)malloc((size_t)n * sizeof(int));
+    L[0] = 1;
+    for (int i = 1; i < n; ++i){
+        if (a[i] > a[i-1]) L[i] = L[i-1] + 1;
+        else if (a[i] == a[i-1]) L[i] = L[i-1];
+        else L[i] = 1;
+    }
+    R[n-1] = 1;
+    for (int i = n-2; i >= 0; --i){
+        if (a[i] > a[i+1]) R[i] = R[i+1] + 1;
+        else if (a[i] == a[i+1]) R[i] = R[i+1];
+        else R[i] = 1;
+    }
+    long long sum = 0;
+    for (int i = 0; i < n; ++i){
+        sum += (L[i] > R[i]) ? L[i] : R[i];
+    }
+    printf("%lld\n", sum);
+    free(R);
+    free(L);
+    free(a);
+    return 0;
+}

exercise/exercise/56.c

@@ -0,0 +1,58 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef long long ll;
+
+static ll sum_min(int L, int n, const int *cnt_le, const ll *sum_le){
+    return sum_le[L] + (ll)L * (ll)(n - cnt_le[L]);
+}
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int m, n;
+    if (scanf("%d %d", &m, &n) != 2) return 0;
+    int *e = (int*)malloc((size_t)n * sizeof(int));
+    int maxv = 0;
+    ll sumE = 0;
+    for (int i = 0; i < n; ++i){ scanf("%d", &e[i]); if (e[i] > maxv) maxv = e[i]; sumE += e[i]; }
+    if (sumE <= (ll)m){ printf("0\n"); free(e); return 0; }
+    int V = maxv + 1;
+    int *freq = (int*)calloc((size_t)V, sizeof(int));
+    for (int i = 0; i < n; ++i) ++freq[e[i]];
+    int *cnt_le = (int*)malloc((size_t)V * sizeof(int));
+    ll *sum_le = (ll*)malloc((size_t)V * sizeof(ll));
+    ll *sumsq_le = (ll*)malloc((size_t)V * sizeof(ll));
+    cnt_le[0] = freq[0];
+    sum_le[0] = (ll)0 * (ll)freq[0];
+    sumsq_le[0] = (ll)0;
+    for (int v = 1; v < V; ++v){
+        cnt_le[v] = cnt_le[v-1] + freq[v];
+        sum_le[v] = sum_le[v-1] + (ll)v * (ll)freq[v];
+        sumsq_le[v] = sumsq_le[v-1] + (ll)v * (ll)v * (ll)freq[v];
+    }
+    ll S = sumE - (ll)m;
+    int lo = 0, hi = maxv, L = 0;
+    while (lo <= hi){
+        int mid = lo + ((hi - lo) >> 1);
+        ll s = sum_min(mid, n, cnt_le, sum_le);
+        if (s <= S){ L = mid; lo = mid + 1; } else { hi = mid - 1; }
+    }
+    ll base_sum = sum_min(L, n, cnt_le, sum_le);
+    ll r = S - base_sum;
+    ll base_sq = sumsq_le[L] + (ll)L * (ll)L * (ll)(n - cnt_le[L]);
+    ll ans = base_sq + r * (ll)(2 * L + 1);
+    printf("%lld\n", ans);
+    free(sumsq_le);
+    free(sum_le);
+    free(cnt_le);
+    free(freq);
+    free(e);
+    return 0;
+}

exercise/exercise/57.c

@@ -0,0 +1,62 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef long long ll;
+
+static int cmp_ll(const void *a, const void *b){
+    ll x = *(const ll*)a, y = *(const ll*)b;
+    return (x > y) - (x < y);
+}
+
+static int lower_bound_ll(const ll *arr, int n, ll x){
+    int l = 0, r = n;
+    while (l < r){
+        int m = (l + r) >> 1;
+        if (arr[m] < x) l = m + 1; else r = m;
+    }
+    return l;
+}
+
+static ll *bit; static int B;
+static void bit_add(int i, ll v){ for (; i <= B; i += i & -i) bit[i] += v; }
+static ll bit_sum(int i){ ll s = 0; for (; i > 0; i -= i & -i) s += i ? bit[i] : 0; return s; }
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n; ll t;
+    if (scanf("%d %lld", &n, &t) != 2) return 0;
+    ll *a = (ll*)malloc((size_t)n * sizeof(ll));
+    for (int i = 0; i < n; ++i) scanf("%lld", &a[i]);
+    ll *pref = (ll*)malloc(((size_t)n + 1) * sizeof(ll));
+    pref[0] = 0;
+    for (int i = 1; i <= n; ++i) pref[i] = pref[i-1] + (a[i-1] - t);
+    ll *comp = (ll*)malloc(((size_t)n + 1) * sizeof(ll));
+    for (int i = 0; i <= n; ++i) comp[i] = pref[i];
+    qsort(comp, (size_t)n + 1, sizeof(ll), cmp_ll);
+    int m = 0;
+    for (int i = 0; i <= n; ++i){ if (i == 0 || comp[i] != comp[i-1]) comp[m++] = comp[i]; }
+    B = m;
+    bit = (ll*)calloc((size_t)B + 1, sizeof(ll));
+    const ll MOD = 1000000007LL;
+    ll ans = 0;
+    for (int j = 0; j <= n; ++j){
+        int idx = lower_bound_ll(comp, m, pref[j]) + 1;
+        ll cnt = bit_sum(idx);
+        ans += cnt;
+        if (ans >= MOD) ans %= MOD;
+        bit_add(idx, 1);
+    }
+    printf("%lld\n", ans % MOD);
+    free(bit);
+    free(comp);
+    free(pref);
+    free(a);
+    return 0;
+}

exercise/exercise/58.c

@@ -0,0 +1,42 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef long long ll;
+
+static int n, m;
+
+static int ok(ll mid, const int *a){
+    ll *pref = (ll*)malloc(((size_t)n + 1) * sizeof(ll));
+    pref[0] = 0;
+    for (int i = 1; i <= n; ++i) pref[i] = pref[i-1] + (ll)a[i-1] * 1000LL - mid;
+    ll min_pref = 0;
+    for (int i = m; i <= n; ++i){
+        if (pref[i - m] < min_pref) min_pref = pref[i - m];
+        if (pref[i] - min_pref >= 0) { free(pref); return 1; }
+    }
+    free(pref);
+    return 0;
+}
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    if (scanf("%d %d", &n, &m) != 2) return 0;
+    int *a = (int*)malloc((size_t)n * sizeof(int));
+    int maxa = 0;
+    for (int i = 0; i < n; ++i){ scanf("%d", &a[i]); if (a[i] > maxa) maxa = a[i]; }
+    ll lo = 0, hi = (ll)maxa * 1000LL, ans = lo;
+    while (lo <= hi){
+        ll mid = lo + ((hi - lo) >> 1);
+        if (ok(mid, a)){ ans = mid; lo = mid + 1; } else hi = mid - 1;
+    }
+    printf("%lld\n", ans);
+    free(a);
+    return 0;
+}

exercise/exercise/59.c

@@ -0,0 +1,33 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef long long ll;
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+
+    int n;
+    if (scanf("%d", &n) != 1) return 0;
+    ll *a = (ll*)malloc((size_t)n * sizeof(ll));
+    for (int i = 0; i < n; ++i) scanf("%lld", &a[i]);
+    ll sum = 0;
+    for (int i = 0; i < n; ++i) sum += a[i];
+    if ((sum & 1LL) != 0){ printf("0\n"); free(a); return 0; }
+    ll target = sum / 2;
+    ll pref = 0;
+    long long ans = 0;
+    for (int i = 0; i < n - 1; ++i){
+        pref += a[i];
+        if (pref == target) ++ans;
+    }
+    printf("%lld\n", ans);
+    free(a);
+    return 0;
+}

exercise/exercise/60.c

@@ -0,0 +1,47 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n,m;
+    if (scanf("%d %d", &n, &m) != 2) return 0;
+    int *cw = (int*)malloc((size_t)n * sizeof(int));
+    int *cb = (int*)malloc((size_t)n * sizeof(int));
+    int *cr = (int*)malloc((size_t)n * sizeof(int));
+    char *row = (char*)malloc((size_t)m + 5);
+    for (int i = 0; i < n; ++i){
+        scanf("%s", row);
+        int cW=0,cB=0,cR=0;
+        for (int j = 0; j < m; ++j){
+            char ch = row[j];
+            if (ch != 'W') ++cW;
+            if (ch != 'B') ++cB;
+            if (ch != 'R') ++cR;
+        }
+        cw[i]=cW; cb[i]=cB; cr[i]=cR;
+    }
+    int *pW = (int*)malloc(((size_t)n + 1) * sizeof(int));
+    int *pB = (int*)malloc(((size_t)n + 1) * sizeof(int));
+    int *pR = (int*)malloc(((size_t)n + 1) * sizeof(int));
+    pW[0]=0; pB[0]=0; pR[0]=0;
+    for (int i = 1; i <= n; ++i){ pW[i]=pW[i-1]+cw[i-1]; pB[i]=pB[i-1]+cb[i-1]; pR[i]=pR[i-1]+cr[i-1]; }
+    long long ans = (long long)n * m;
+    for (int i = 1; i <= n-2; ++i){
+        for (int j = i+1; j <= n-1; ++j){
+            long long cur = (long long)pW[i] + (long long)(pB[j] - pB[i]) + (long long)(pR[n] - pR[j]);
+            if (cur < ans) ans = cur;
+        }
+    }
+    printf("%lld\n", ans);
+    free(pR); free(pB); free(pW);
+    free(row);
+    free(cr); free(cb); free(cw);
+    return 0;
+}

exercise/exercise/61.c

@@ -0,0 +1,50 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n;
+    if (scanf("%d", &n) != 1) return 0;
+    char *s = (char*)malloc((size_t)n + 5);
+    scanf("%s", s);
+    int cntH = 0;
+    for (int i = 0; i < n; ++i) if (s[i] == 'H') ++cntH;
+    int cntT = n - cntH;
+    if (cntH == 0 || cntH == n){ printf("0\n"); free(s); return 0; }
+
+    char *d = (char*)malloc((size_t)2*n + 5);
+    for (int i = 0; i < n; ++i){ d[i] = s[i]; d[i+n] = s[i]; }
+
+    int lenH = cntH;
+    int t_in = 0;
+    for (int i = 0; i < lenH; ++i) if (d[i] == 'T') ++t_in;
+    int bestH = t_in;
+    for (int i = 1; i < n; ++i){
+        if (d[i-1] == 'T') --t_in;
+        if (d[i+lenH-1] == 'T') ++t_in;
+        if (t_in < bestH) bestH = t_in;
+    }
+
+    int lenT = cntT;
+    int h_in = 0;
+    for (int i = 0; i < lenT; ++i) if (d[i] == 'H') ++h_in;
+    int bestT = h_in;
+    for (int i = 1; i < n; ++i){
+        if (d[i-1] == 'H') --h_in;
+        if (d[i+lenT-1] == 'H') ++h_in;
+        if (h_in < bestT) bestT = h_in;
+    }
+
+    int ans = bestH < bestT ? bestH : bestT;
+    printf("%d\n", ans);
+    free(d);
+    free(s);
+    return 0;
+}

exercise/exercise/62.c

@@ -0,0 +1,37 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef long long ll;
+
+static int cmp_ll(const void *a, const void *b){
+    ll x = *(const ll*)a, y = *(const ll*)b;
+    return (x > y) - (x < y);
+}
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n;
+    if (scanf("%d", &n) != 1) return 0;
+    ll *q = (ll*)malloc((size_t)(n > 1 ? n - 1 : 0) * sizeof(ll));
+    for (int i = 0; i < n - 1; ++i) scanf("%lld", &q[i]);
+    ll *s = (ll*)malloc((size_t)n * sizeof(ll));
+    s[0] = 0;
+    for (int i = 1; i < n; ++i) s[i] = s[i-1] + q[i-1];
+    ll *t = (ll*)malloc((size_t)n * sizeof(ll));
+    for (int i = 0; i < n; ++i) t[i] = s[i];
+    qsort(t, (size_t)n, sizeof(ll), cmp_ll);
+    for (int i = 1; i < n; ++i){ if (t[i] == t[i-1]){ printf("-1\n"); free(t); free(s); free(q); return 0; } }
+    ll range = t[n-1] - t[0];
+    if (range != (ll)n - 1){ printf("-1\n"); free(t); free(s); free(q); return 0; }
+    ll shift = 1 - t[0];
+    for (int i = 0; i < n; ++i){ ll v = s[i] + shift; printf("%lld%c", v, (i+1==n)?'\n':' '); }
+    free(t); free(s); free(q);
+    return 0;
+}

exercise/exercise/63.c

@@ -0,0 +1,40 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef long long ll;
+
+int main(void)
+{
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+
+    ll A, B, C, D;
+    if (scanf("%lld %lld %lld %lld", &A, &B, &C, &D) != 4)
+        return 0;
+    ll lenX = B - A + 1;
+    ll ans = 0;
+    for (ll z = C; z <= D; ++z)
+    {
+        ll L = z - C;
+        ll R = z - B;
+        ll s1l = L, s1r = R < A - 1 ? R : A - 1;
+        if (s1l <= s1r)
+            ans += (s1r - s1l + 1) * lenX;
+        ll s2l = L > A ? L : A;
+        ll s2r = R < B - 1 ? R : B - 1;
+        if (s2l <= s2r)
+        {
+            ll cnt = s2r - s2l + 1;
+            ll sumk = (s2l + s2r) * cnt / 2;
+            ans += cnt * B - sumk;
+        }
+    }
+    printf("%lld\n", ans);
+    return 0;
+}

exercise/exercise/64.c

@@ -0,0 +1,55 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef long long ll;
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n,m;
+    if (scanf("%d %d", &n, &m) != 2) return 0;
+    int **a = (int**)malloc((size_t)n * sizeof(int*));
+    for (int i = 0; i < n; ++i){
+        a[i] = (int*)malloc((size_t)m * sizeof(int));
+        for (int j = 0; j < m; ++j) scanf("%d", &a[i][j]);
+    }
+    ll ans = 0;
+    ll *col = (ll*)malloc((size_t)m * sizeof(ll));
+    ll *pref = (ll*)malloc(((size_t)m + 1) * sizeof(ll));
+    int *st = (int*)malloc(((size_t)m + 1) * sizeof(int));
+    for (int top = 0; top < n; ++top){
+        for (int c = 0; c < m; ++c) col[c] = 0;
+        for (int bottom = top; bottom < n; ++bottom){
+            for (int c = 0; c < m; ++c) col[c] += a[bottom][c];
+            pref[0] = 0;
+            for (int i = 1; i <= m; ++i) pref[i] = pref[i-1] + col[i-1];
+            int sz = 0;
+            for (int i = 0; i <= m; ++i){
+                if (sz == 0 || pref[i] < pref[st[sz-1]]) st[sz++] = i;
+            }
+            int k = sz - 1;
+            for (int j = m; j >= 0 && k >= 0; --j){
+                while (k >= 0 && pref[j] > pref[st[k]]){
+                    ll width = (ll)j - (ll)st[k];
+                    ll height = (ll)bottom - (ll)top + 1;
+                    ll area = width * height;
+                    if (area > ans) ans = area;
+                    --k;
+                }
+            }
+        }
+    }
+    printf("%lld\n", ans);
+    free(st);
+    free(pref);
+    free(col);
+    for (int i = 0; i < n; ++i) free(a[i]);
+    free(a);
+    return 0;
+}

exercise/exercise/65.c

@@ -0,0 +1,31 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef long long ll;
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n;
+    if (scanf("%d", &n) != 1) return 0;
+    ll *a = (ll*)malloc((size_t)n * sizeof(ll));
+    for (int i = 0; i < n; ++i) scanf("%lld", &a[i]);
+    ll sumabs = 0;
+    for (int i = 0; i + 1 < n; ++i){
+        ll d = a[i+1] - a[i];
+        if (d < 0) d = -d;
+        sumabs += d;
+    }
+    ll enddiff = a[n-1] - a[0];
+    if (enddiff < 0) enddiff = -enddiff;
+    ll ans = (sumabs + enddiff) / 2;
+    printf("%lld\n", ans);
+    free(a);
+    return 0;
+}

exercise/exercise/66.c

@@ -0,0 +1,33 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef long long ll;
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n; ll h; int f;
+    if (scanf("%d %lld %d", &n, &h, &f) != 3) return 0;
+    ll *diff = (ll*)calloc((size_t)n + 2, sizeof(ll));
+    for (int i = 0; i < f; ++i){
+        int a,b; scanf("%d %d", &a, &b);
+        if (a == b) continue;
+        if (a > b){ int t = a; a = b; b = t; }
+        int l = a + 1, r = b - 1;
+        if (l <= r){ diff[l] += 1; diff[r+1] -= 1; }
+    }
+    ll cur = 0;
+    for (int i = 1; i <= n; ++i){
+        cur += diff[i];
+        ll ans = h - cur;
+        printf("%lld\n", ans);
+    }
+    free(diff);
+    return 0;
+}

exercise/exercise/67.c

@@ -0,0 +1,56 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef long long ll;
+
+typedef struct { ll l, r; } Seg;
+
+static int cmp_seg(const void *a, const void *b){
+    const Seg *x = (const Seg*)a, *y = (const Seg*)b;
+    if (x->l < y->l) return -1;
+    if (x->l > y->l) return 1;
+    if (x->r < y->r) return -1;
+    if (x->r > y->r) return 1;
+    return 0;
+}
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n; ll X;
+    if (scanf("%d %lld", &n, &X) != 2) return 0;
+    ll *a = (ll*)malloc((size_t)n * sizeof(ll));
+    for (int i = 0; i < n; ++i) scanf("%lld", &a[i]);
+    ll *b = (ll*)malloc((size_t)n * sizeof(ll));
+    Seg *seg = (Seg*)malloc((size_t)n * sizeof(Seg));
+    int cnt = 0;
+    for (int i = 0; i < n; ++i){
+        if (cnt > 1) qsort(seg, (size_t)cnt, sizeof(Seg), cmp_seg);
+        ll x = a[i];
+        for (int j = 0; j < cnt; ++j){
+            if (x < seg[j].l) break;
+            if (x <= seg[j].r) x = seg[j].r + 1;
+        }
+        b[i] = x;
+        ll L = x - (X - 1);
+        ll R = x + (X - 1);
+        seg[cnt].l = L;
+        seg[cnt].r = R;
+        ++cnt;
+    }
+    for (int i = 0; i < n; ++i){
+        if (i) putchar(' ');
+        printf("%lld", b[i]);
+    }
+    putchar('\n');
+    free(seg);
+    free(b);
+    free(a);
+    return 0;
+}

exercise/exercise/68.c

@@ -0,0 +1,38 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef long long ll;
+
+static int cmp_ll(const void *a, const void *b){
+    ll x = *(const ll*)a, y = *(const ll*)b;
+    return (x > y) - (x < y);
+}
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n;
+    if (scanf("%d", &n) != 1) return 0;
+    ll *a = (ll*)malloc((size_t)n * sizeof(ll));
+    ll *b = (ll*)malloc((size_t)n * sizeof(ll));
+    for (int i = 0; i < n; ++i) scanf("%lld", &a[i]);
+    for (int i = 0; i < n; ++i) scanf("%lld", &b[i]);
+    ll *d = (ll*)malloc((size_t)n * sizeof(ll));
+    for (int i = 0; i < n; ++i) d[i] = a[i] - b[i];
+    qsort(d, (size_t)n, sizeof(ll), cmp_ll);
+    int ok = 1;
+    for (int i = 0; i < n/2; ++i){
+        if (d[i] + d[n-1-i] != 0){ ok = 0; break; }
+    }
+    printf(ok ? "YES\n" : "NO\n");
+    free(d);
+    free(b);
+    free(a);
+    return 0;
+}

exercise/exercise/69.c

@@ -0,0 +1,33 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef long long ll;
+
+static int cmp_ll(const void *a, const void *b){
+    ll x = *(const ll*)a, y = *(const ll*)b;
+    return (x > y) - (x < y);
+}
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n;
+    if (scanf("%d", &n) != 1) return 0;
+    ll *a = (ll*)malloc((size_t)n * sizeof(ll));
+    for (int i = 0; i < n; ++i) scanf("%lld", &a[i]);
+    qsort(a, (size_t)n, sizeof(ll), cmp_ll);
+    ll med = a[n/2];
+    ll sum = 0;
+    for (int i = 0; i < n; ++i){
+        ll d = a[i] - med; if (d < 0) d = -d; sum += d;
+    }
+    printf("%lld\n", sum);
+    free(a);
+    return 0;
+}

exercise/exercise/70.c

@@ -0,0 +1,49 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+static int cmp_int(const void *a, const void *b){
+    int x = *(const int*)a, y = *(const int*)b;
+    return (x > y) - (x < y);
+}
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n;
+    if (scanf("%d", &n) != 1) return 0;
+    int *a = (int*)malloc((size_t)n * sizeof(int));
+    for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
+
+    int *odd = (int*)malloc((size_t)n * sizeof(int));
+    int *even = (int*)malloc((size_t)n * sizeof(int));
+    int *odd_pos = (int*)malloc((size_t)n * sizeof(int));
+    int *even_pos = (int*)malloc((size_t)n * sizeof(int));
+    int oc = 0, ec = 0;
+    for (int i = 0; i < n; ++i){
+        if ((a[i] & 1) != 0){ odd[oc] = a[i]; odd_pos[oc] = i; ++oc; }
+        else { even[ec] = a[i]; even_pos[ec] = i; ++ec; }
+    }
+    qsort(odd, (size_t)oc, sizeof(int), cmp_int);
+    qsort(even, (size_t)ec, sizeof(int), cmp_int);
+
+    int *ans = (int*)malloc((size_t)n * sizeof(int));
+    for (int i = 0; i < oc; ++i) ans[odd_pos[i]] = odd[i];
+    for (int i = 0; i < ec; ++i) ans[even_pos[i]] = even[i];
+
+    for (int i = 0; i < n; ++i){
+        if (i) putchar(' ');
+        printf("%d", ans[i]);
+    }
+    putchar('\n');
+    free(ans);
+    free(even_pos); free(odd_pos);
+    free(even); free(odd);
+    free(a);
+    return 0;
+}

exercise/exercise/71.c

@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    char ord[32];
+    if (scanf("%31s", ord) != 1) return 0;
+    char *s = (char*)malloc(100005);
+    if (scanf("%100000s", s) != 1){ free(s); return 0; }
+    int rank[26];
+    for (int i = 0; i < 26; ++i) rank[(int)(ord[i]-'a')] = i;
+    int cnt[26];
+    for (int i = 0; i < 26; ++i) cnt[i] = 0;
+    for (char *p = s; *p; ++p){ cnt[rank[(int)(*p - 'a')]]++; }
+    for (int i = 0; i < 26; ++i){
+        int c = cnt[i]; char ch = ord[i];
+        while (c--) putchar(ch);
+    }
+    putchar('\n');
+    free(s);
+    return 0;
+}

exercise/exercise/72.c

@@ -0,0 +1,31 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+static int cmp_desc(const void *a, const void *b){
+    int x = *(const int*)a, y = *(const int*)b;
+    return (y > x) - (y < x);
+}
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n,k;
+    if (scanf("%d %d", &n, &k) != 2) return 0;
+    int *a = (int*)malloc((size_t)n * sizeof(int));
+    for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
+    qsort(a, (size_t)n, sizeof(int), cmp_desc);
+    int threshold = a[k-1];
+    int cnt = 0;
+    for (int i = 0; i < n; ++i){
+        if (a[i] >= threshold && a[i] > 0) ++cnt;
+    }
+    printf("%d\n", cnt);
+    free(a);
+    return 0;
+}

exercise/exercise/73.c

@@ -0,0 +1,35 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef long long ll;
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n;
+    if (scanf("%d", &n) != 1) return 0;
+    int *a = (int*)malloc((size_t)n * sizeof(int));
+    for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
+    int parity = 0;
+    for (int i = 0; i < n; ++i){
+        for (int j = i + 1; j < n; ++j){
+            if (a[i] > a[j]) parity ^= 1;
+        }
+    }
+    int m; scanf("%d", &m);
+    for (int q = 0; q < m; ++q){
+        int l,r; scanf("%d %d", &l, &r);
+        ll len = (ll)r - (ll)l + 1;
+        ll pairs = len * (len - 1) / 2;
+        if ((pairs & 1LL) != 0) parity ^= 1;
+        if (parity) printf("odd\n"); else printf("even\n");
+    }
+    free(a);
+    return 0;
+}

exercise/exercise/74.c

@@ -0,0 +1,37 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef long long ll;
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int N; ll K;
+    if (scanf("%d %lld", &N, &K) != 2) return 0;
+    ll *L = (ll*)malloc((size_t)N * sizeof(ll));
+    ll maxL = 0;
+    for (int i = 0; i < N; ++i){
+        scanf("%lld", &L[i]);
+        if (L[i] > maxL) maxL = L[i];
+    }
+    ll lo = 1, hi = maxL, ans = 0;
+    while (lo <= hi){
+        ll mid = (lo + hi) / 2;
+        ll cnt = 0;
+        for (int i = 0; i < N; ++i){
+            cnt += L[i] / mid;
+            if (cnt >= K) break;
+        }
+        if (cnt >= K){ ans = mid; lo = mid + 1; }
+        else { hi = mid - 1; }
+    }
+    printf("%lld\n", ans);
+    free(L);
+    return 0;
+}

exercise/exercise/75.c

@@ -0,0 +1,41 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef long long ll;
+
+static int cmp_double_desc(const void *a, const void *b){
+    double x = *(const double*)a, y = *(const double*)b;
+    return (y > x) - (y < x);
+}
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n, m;
+    if (scanf("%d %d", &n, &m) != 2) return 0;
+    double *v = (double*)malloc((size_t)n * sizeof(double));
+    double *c = (double*)malloc((size_t)n * sizeof(double));
+    for (int i = 0; i < n; ++i) scanf("%lf", &v[i]);
+    for (int i = 0; i < n; ++i) scanf("%lf", &c[i]);
+    double *s = (double*)malloc((size_t)n * sizeof(double));
+    double lo = 0.0, hi = 1000.0;
+    for (int it = 0; it < 70; ++it){
+        double mid = (lo + hi) * 0.5;
+        for (int i = 0; i < n; ++i) s[i] = v[i] - mid * c[i];
+        qsort(s, (size_t)n, sizeof(double), cmp_double_desc);
+        double sum = 0.0;
+        for (int i = 0; i < m; ++i) sum += s[i];
+        if (sum >= 0.0) lo = mid; else hi = mid;
+    }
+    printf("%.3f\n", lo);
+    free(s);
+    free(c);
+    free(v);
+    return 0;
+}

exercise/exercise/76.c

@@ -0,0 +1,43 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef long long ll;
+
+static int cmp_ll_asc(const void *a, const void *b){
+    ll x = *(const ll*)a, y = *(const ll*)b;
+    return (x > y) - (x < y);
+}
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int N, M;
+    if (scanf("%d %d", &N, &M) != 2) return 0;
+    ll *x = (ll*)malloc((size_t)N * sizeof(ll));
+    for (int i = 0; i < N; ++i) scanf("%lld", &x[i]);
+    qsort(x, (size_t)N, sizeof(ll), cmp_ll_asc);
+    ll lo = 0, hi = x[N-1] - x[0], ans = 0;
+    while (lo <= hi){
+        ll mid = (lo + hi) / 2;
+        int cnt = 1;
+        ll last = x[0];
+        for (int i = 1; i < N; ++i){
+            if (x[i] - last >= mid){
+                ++cnt;
+                last = x[i];
+                if (cnt >= M) break;
+            }
+        }
+        if (cnt >= M){ ans = mid; lo = mid + 1; }
+        else { hi = mid - 1; }
+    }
+    printf("%lld\n", ans);
+    free(x);
+    return 0;
+}

exercise/exercise/77.c

@@ -0,0 +1,39 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef long long ll;
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int N; ll M;
+    if (scanf("%d %lld", &N, &M) != 2) return 0;
+    ll *h = (ll*)malloc((size_t)N * sizeof(ll));
+    ll mx = 0;
+    for (int i = 0; i < N; ++i){
+        scanf("%lld", &h[i]);
+        if (h[i] > mx) mx = h[i];
+    }
+    ll lo = 0, hi = mx, ans = 0;
+    while (lo <= hi){
+        ll mid = (lo + hi) / 2;
+        ll got = 0;
+        for (int i = 0; i < N; ++i){
+            if (h[i] > mid){
+                got += h[i] - mid;
+                if (got >= M) break;
+            }
+        }
+        if (got >= M){ ans = mid; lo = mid + 1; }
+        else { hi = mid - 1; }
+    }
+    printf("%lld\n", ans);
+    free(h);
+    return 0;
+}

exercise/exercise/78.c

@@ -0,0 +1,51 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef long long ll;
+
+static int cmp_ll(const void *a, const void *b){
+    ll x = *(const ll*)a, y = *(const ll*)b;
+    return (x > y) - (x < y);
+}
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n; ll t;
+    if (scanf("%lld %d", &t, &n) != 2) return 0;
+    ll *neg = (ll*)malloc((size_t)n * sizeof(ll));
+    ll *pos = (ll*)malloc((size_t)n * sizeof(ll));
+    int ln = 0, rn = 0;
+    for (int i = 0; i < n; ++i){
+        ll x; scanf("%lld", &x);
+        if (x < 0) neg[ln++] = -x;
+        else pos[rn++] = x;
+    }
+    qsort(neg, (size_t)ln, sizeof(ll), cmp_ll);
+    qsort(pos, (size_t)rn, sizeof(ll), cmp_ll);
+    int j = rn;
+    ll ans = 0;
+    for (int i = 0; i <= ln; ++i){
+        ll A = (i == 0 ? 0 : neg[i-1]);
+        while (j > 0){
+            ll B = pos[j-1];
+            ll v1 = 2*A + B;
+            ll v2 = A + 2*B;
+            ll need = v1 < v2 ? v1 : v2;
+            if (need <= t) break;
+            --j;
+        }
+        ll cur = (ll)i + (ll)j;
+        if (cur > ans) ans = cur;
+    }
+    printf("%lld\n", ans);
+    free(pos);
+    free(neg);
+    return 0;
+}

exercise/exercise/79.c

@@ -0,0 +1,45 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef long long ll;
+
+static ll gcdll(ll a, ll b){ while (b){ ll t = a % b; a = b; b = t; } return a; }
+
+static int ok(ll V, ll cnt1, ll cnt2, ll x, ll y){
+    ll mx = V / x;
+    ll my = V / y;
+    ll l = x / gcdll(x, y) * y;
+    ll mxy = V / l;
+    ll a_only = my - mxy;
+    ll b_only = mx - mxy;
+    ll both = V - mx - my + mxy;
+    ll needA = cnt1 - a_only; if (needA < 0) needA = 0;
+    ll needB = cnt2 - b_only; if (needB < 0) needB = 0;
+    return needA + needB <= both;
+}
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    ll cnt1, cnt2, x, y;
+    if (scanf("%lld %lld %lld %lld", &cnt1, &cnt2, &x, &y) != 4) return 0;
+    ll lo = 1, hi = 1;
+    while (!ok(hi, cnt1, cnt2, x, y)){
+        hi <<= 1;
+        if (hi <= 0) { hi = (ll)4e18; break; }
+    }
+    ll ans = hi;
+    while (lo <= hi){
+        ll mid = lo + ((hi - lo) >> 1);
+        if (ok(mid, cnt1, cnt2, x, y)){ ans = mid; hi = mid - 1; }
+        else lo = mid + 1;
+    }
+    printf("%lld\n", ans);
+    return 0;
+}

exercise/exercise/80.c

@@ -0,0 +1,79 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef long long ll;
+
+static ll *seg;
+static ll *lazyTag;
+
+static inline ll minll(ll a, ll b){ return a < b ? a : b; }
+
+static void build(int idx, int l, int r, ll *arr){
+    if (l == r){ seg[idx] = arr[l]; return; }
+    int mid = (l + r) >> 1;
+    build(idx<<1, l, mid, arr);
+    build(idx<<1|1, mid+1, r, arr);
+    seg[idx] = minll(seg[idx<<1], seg[idx<<1|1]);
+}
+
+static inline void apply(int idx, ll val){ seg[idx] += val; lazyTag[idx] += val; }
+
+static inline void pushDown(int idx){
+    ll tag = lazyTag[idx];
+    if (tag != 0){
+        apply(idx<<1, tag);
+        apply(idx<<1|1, tag);
+        lazyTag[idx] = 0;
+    }
+}
+
+static void range_add(int idx, int l, int r, int L, int R, ll val){
+    if (L <= l && r <= R){ apply(idx, val); return; }
+    pushDown(idx);
+    int mid = (l + r) >> 1;
+    if (L <= mid) range_add(idx<<1, l, mid, L, R, val);
+    if (R > mid) range_add(idx<<1|1, mid+1, r, L, R, val);
+    seg[idx] = minll(seg[idx<<1], seg[idx<<1|1]);
+}
+
+static ll range_min(int idx, int l, int r, int L, int R){
+    if (L <= l && r <= R) return seg[idx];
+    pushDown(idx);
+    int mid = (l + r) >> 1;
+    ll res = (ll)0x7fffffffffffffffLL;
+    if (L <= mid){ ll v = range_min(idx<<1, l, mid, L, R); res = minll(res, v); }
+    if (R > mid){ ll v = range_min(idx<<1|1, mid+1, r, L, R); res = minll(res, v); }
+    return res;
+}
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n, m;
+    if (scanf("%d %d", &n, &m) != 2) return 0;
+    ll *r = (ll*)malloc(((size_t)n + 1) * sizeof(ll));
+    for (int i = 1; i <= n; ++i) scanf("%lld", &r[i]);
+    seg = (ll*)calloc(((size_t)4*n + 5), sizeof(ll));
+    lazyTag = (ll*)calloc(((size_t)4*n + 5), sizeof(ll));
+    build(1, 1, n, r);
+    int bad = 0, badId = -1;
+    for (int j = 1; j <= m; ++j){
+        ll d; int s, t;
+        if (scanf("%lld %d %d", &d, &s, &t) != 3) { bad = 1; badId = j; break; }
+        ll mn = range_min(1, 1, n, s, t);
+        if (mn >= d){ range_add(1, 1, n, s, t, -d); }
+        else { bad = 1; badId = j; break; }
+    }
+    if (!bad){ printf("0\n"); }
+    else { printf("-1\n%d\n", badId); }
+    free(lazyTag);
+    free(seg);
+    free(r);
+    return 0;
+}

exercise/exercise/81.c

@@ -0,0 +1,27 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef long long ll;
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n;
+    if (scanf("%d", &n) != 1) return 0;
+    ll sum = 0, mx = 0;
+    for (int i = 0; i < n; ++i){
+        ll x; scanf("%lld", &x);
+        sum += x;
+        if (x > mx) mx = x;
+    }
+    ll g = (sum + (ll)(n - 2)) / (ll)(n - 1);
+    if (g < mx) g = mx;
+    printf("%lld\n", g);
+    return 0;
+}

exercise/exercise/82.c

@@ -0,0 +1,170 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef long long ll;
+
+typedef struct { ll a, b; } Item;
+
+static int cmp_item(const void *p, const void *q){
+    const Item *x = (const Item*)p, *y = (const Item*)q;
+    if (x->a < y->a) return -1;
+    if (x->a > y->a) return 1;
+    if (x->b < y->b) return -1;
+    if (x->b > y->b) return 1;
+    return 0;
+}
+
+static void heap_push(ll *h, int *sz, ll v){
+    int i = ++(*sz);
+    h[i] = v;
+    while (i > 1){
+        int p = i >> 1;
+        if (h[p] >= h[i]) break;
+        ll t = h[p]; h[p] = h[i]; h[i] = t;
+        i = p;
+    }
+}
+
+static ll heap_top(ll *h){ return h[1]; }
+
+static void heap_pop(ll *h, int *sz){
+    int n = *sz;
+    h[1] = h[n];
+    --(*sz);
+    int i = 1;
+    while (1){
+        int l = i << 1, r = l + 1, m = i;
+        if (l <= *sz && h[l] > h[m]) m = l;
+        if (r <= *sz && h[r] > h[m]) m = r;
+        if (m == i) break;
+        ll t = h[m]; h[m] = h[i]; h[i] = t;
+        i = m;
+    }
+}
+
+static int lower_bound_a(ll *A, int n, ll val){
+    int l = 1, r = n, ans = n + 1;
+    while (l <= r){
+        int mid = (l + r) >> 1;
+        if (A[mid] >= val){ ans = mid; r = mid - 1; }
+        else l = mid + 1;
+    }
+    return ans;
+}
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    ll v; int n, m;
+    if (scanf("%lld %d %d", &v, &n, &m) != 3) return 0;
+    Item *it = (Item*)malloc(((size_t)n + 1) * sizeof(Item));
+    for (int i = 1; i <= n; ++i){
+        scanf("%lld %lld", &it[i].a, &it[i].b);
+    }
+    qsort(it + 1, (size_t)n, sizeof(Item), cmp_item);
+    ll *A = (ll*)malloc(((size_t)n + 2) * sizeof(ll));
+    ll *B = (ll*)malloc(((size_t)n + 2) * sizeof(ll));
+    for (int i = 1; i <= n; ++i){ A[i] = it[i].a; B[i] = it[i].b; }
+    ll INF = 9000000000000000000LL;
+    int k = m / 2;
+    ll *prefK = (ll*)malloc(((size_t)n + 2) * sizeof(ll));
+    ll *sufK = (ll*)malloc(((size_t)n + 2) * sizeof(ll));
+    ll *prefK1 = (ll*)malloc(((size_t)n + 2) * sizeof(ll));
+    ll *sufK1 = (ll*)malloc(((size_t)n + 2) * sizeof(ll));
+    for (int i = 0; i <= n + 1; ++i){ prefK[i] = INF; sufK[i] = INF; prefK1[i] = INF; sufK1[i] = INF; }
+    if (k == 0){ for (int i = 0; i <= n + 1; ++i){ prefK[i] = 0; sufK[i] = 0; } }
+    else{
+        ll *heap = (ll*)malloc(((size_t)n + 5) * sizeof(ll)); int sz = 0; ll sum = 0;
+        for (int i = 1; i <= n; ++i){
+            heap_push(heap, &sz, B[i]); sum += B[i];
+            if (sz > k){ sum -= heap_top(heap); heap_pop(heap, &sz); }
+            if (sz == k) prefK[i] = sum; else prefK[i] = INF;
+        }
+        sz = 0; sum = 0;
+        for (int i = n; i >= 1; --i){
+            heap_push(heap, &sz, B[i]); sum += B[i];
+            if (sz > k){ sum -= heap_top(heap); heap_pop(heap, &sz); }
+            if (sz == k) sufK[i] = sum; else sufK[i] = INF;
+        }
+        free(heap);
+    }
+    int k1 = k - 1;
+    if (k1 <= 0){ for (int i = 0; i <= n + 1; ++i){ prefK1[i] = 0; sufK1[i] = 0; } }
+    else{
+        ll *heap = (ll*)malloc(((size_t)n + 5) * sizeof(ll)); int sz = 0; ll sum = 0;
+        for (int i = 1; i <= n; ++i){
+            heap_push(heap, &sz, B[i]); sum += B[i];
+            if (sz > k1){ sum -= heap_top(heap); heap_pop(heap, &sz); }
+            if (sz == k1) prefK1[i] = sum; else prefK1[i] = INF;
+        }
+        sz = 0; sum = 0;
+        for (int i = n; i >= 1; --i){
+            heap_push(heap, &sz, B[i]); sum += B[i];
+            if (sz > k1){ sum -= heap_top(heap); heap_pop(heap, &sz); }
+            if (sz == k1) sufK1[i] = sum; else sufK1[i] = INF;
+        }
+        free(heap);
+    }
+    ll *leftCostWith = (ll*)malloc(((size_t)n + 2) * sizeof(ll));
+    ll *rightCostWith = (ll*)malloc(((size_t)n + 2) * sizeof(ll));
+    ll *suffixMin = (ll*)malloc(((size_t)n + 3) * sizeof(ll));
+    for (int i = 1; i <= n; ++i){
+        if (prefK1[i-1] >= INF/2) leftCostWith[i] = INF; else leftCostWith[i] = prefK1[i-1] + B[i];
+    }
+    for (int j = 1; j <= n; ++j){
+        if (sufK1[j+1] >= INF/2) rightCostWith[j] = INF; else rightCostWith[j] = B[j] + sufK1[j+1];
+    }
+    suffixMin[n+1] = INF;
+    for (int j = n; j >= 1; --j){
+        ll vmin = rightCostWith[j];
+        if (suffixMin[j+1] < vmin) vmin = suffixMin[j+1];
+        suffixMin[j] = vmin;
+    }
+    ll lo = 0, hi = A[n], ans = 0;
+    while (lo <= hi){
+        ll mid = (lo + hi) >> 1;
+        int ok = 0;
+        if ((m & 1) != 0){
+            for (int i = 1; i <= n; ++i){
+                if (A[i] < mid) continue;
+                ll left = prefK[i-1];
+                ll right = sufK[i+1];
+                if (left >= INF/2 || right >= INF/2) continue;
+                ll cost = left + right + B[i];
+                if (cost <= v){ ok = 1; break; }
+            }
+        } else {
+            for (int i = 1; i <= n; ++i){
+                if (leftCostWith[i] >= INF/2) continue;
+                ll need = 2*mid - A[i];
+                int j = lower_bound_a(A, n, need);
+                if (j <= i) j = i + 1;
+                if (j > n) continue;
+                ll rc = suffixMin[j];
+                if (rc >= INF/2) continue;
+                ll cost = leftCostWith[i] + rc;
+                if (cost <= v){ ok = 1; break; }
+            }
+        }
+        if (ok){ ans = mid; lo = mid + 1; }
+        else hi = mid - 1;
+    }
+    printf("%lld\n", ans);
+    free(suffixMin);
+    free(rightCostWith);
+    free(leftCostWith);
+    free(sufK1);
+    free(prefK1);
+    free(sufK);
+    free(prefK);
+    free(B);
+    free(A);
+    free(it);
+    return 0;
+}

exercise/exercise/83.c

@@ -0,0 +1,45 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef long long ll;
+
+static int cmp_ll(const void *a, const void *b){
+    ll x = *(const ll*)a, y = *(const ll*)b;
+    return (x > y) - (x < y);
+}
+
+static ll count_leq(ll *a, int n, ll d){
+    ll cnt = 0;
+    int j = 0;
+    for (int i = 0; i < n; ++i){
+        while (a[i] - a[j] > d) ++j;
+        cnt += (ll)(i - j);
+    }
+    return cnt;
+}
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n; ll k;
+    if (scanf("%d %lld", &n, &k) != 2) return 0;
+    ll *a = (ll*)malloc((size_t)n * sizeof(ll));
+    for (int i = 0; i < n; ++i) scanf("%lld", &a[i]);
+    qsort(a, (size_t)n, sizeof(ll), cmp_ll);
+    ll lo = 0, hi = a[n-1] - a[0], ans = hi;
+    while (lo <= hi){
+        ll mid = lo + ((hi - lo) >> 1);
+        ll cnt = count_leq(a, n, mid);
+        if (cnt >= k){ ans = mid; hi = mid - 1; }
+        else lo = mid + 1;
+    }
+    printf("%lld\n", ans);
+    free(a);
+    return 0;
+}

exercise/exercise/84.c

@@ -0,0 +1,38 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef long long ll;
+
+static int cmp_ll(const void *a, const void *b){
+    ll x = *(const ll*)a, y = *(const ll*)b;
+    return (x > y) - (x < y);
+}
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n; if (scanf("%d", &n) != 1) return 0;
+    ll *a = (ll*)malloc((size_t)n * sizeof(ll));
+    ll sum = 0;
+    for (int i = 0; i < n; ++i){ scanf("%lld", &a[i]); sum += a[i]; }
+    ll avg = sum / (ll)n;
+    ll *s = (ll*)malloc((size_t)(n) * sizeof(ll));
+    ll pref = 0;
+    for (int i = 0; i < n; ++i){
+        pref += a[i] - avg;
+        s[i] = pref;
+    }
+    qsort(s, (size_t)n, sizeof(ll), cmp_ll);
+    ll med = s[n/2];
+    ll ans = 0;
+    for (int i = 0; i < n; ++i){ ll d = s[i] - med; if (d < 0) d = -d; ans += d; }
+    printf("%lld\n", ans);
+    free(s); free(a);
+    return 0;
+}

exercise/exercise/85.c

@@ -0,0 +1,23 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef unsigned long long ull;
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int m,n;
+    if (scanf("%d %d", &m, &n) != 2) return 0;
+    int S = m * (n - 1);
+    if (S <= 0){ printf("1\n"); return 0; }
+    ull a = 1, b = 1;
+    for (int i = 2; i <= S; ++i){ ull c = a + b; a = b; b = c; }
+    printf("%llu\n", b);
+    return 0;
+}

exercise/exercise/86.c

@@ -0,0 +1,74 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef struct { int nxt[26]; int end; } Node;
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    char buf[1024];
+    Node *tr = (Node*)malloc((size_t)1 * sizeof(Node));
+    int cap = 1, sz = 1;
+    for (int i = 0; i < 26; ++i) tr[0].nxt[i] = -1; tr[0].end = 0;
+    while (scanf("%1023s", buf) == 1){
+        if (buf[0] == '.' && buf[1] == '\0') break;
+        int u = 0;
+        for (int k = 0; buf[k]; ++k){
+            int c = buf[k] - 'A';
+            if (c < 0 || c >= 26) { u = -1; break; }
+            int v = tr[u].nxt[c];
+            if (v == -1){
+                if (sz == cap){ cap = cap * 2 + 4; tr = (Node*)realloc(tr, (size_t)cap * sizeof(Node)); }
+                v = sz++;
+                for (int i = 0; i < 26; ++i) tr[v].nxt[i] = -1; tr[v].end = 0;
+                tr[u].nxt[c] = v;
+            }
+            u = v;
+        }
+        if (u >= 0) tr[u].end = 1;
+    }
+    size_t S_cap = 200005;
+    char *S = (char*)malloc(S_cap);
+    size_t S_len = 0;
+    while (scanf("%1023s", buf) == 1){
+        size_t L = strlen(buf);
+        if (S_len + L + 1 > S_cap){
+            while (S_len + L + 1 > S_cap) S_cap = S_cap * 2 + 8;
+            S = (char*)realloc(S, S_cap);
+        }
+        memcpy(S + S_len, buf, L);
+        S_len += L;
+    }
+    S[S_len] = '\0';
+    int n = (int)S_len;
+    char *dp = (char*)malloc((size_t)n + 1);
+    for (int i = 0; i <= n; ++i) dp[i] = 0;
+    dp[0] = 1;
+    int ans = 0;
+    for (int i = 0; i < n; ++i){
+        if (!dp[i]) continue;
+        int u = 0;
+        for (int step = 1; step <= 10; ++step){
+            int j = i + step;
+            if (j > n) break;
+            int c = S[j-1] - 'A';
+            if (c < 0 || c >= 26) break;
+            int v = tr[u].nxt[c];
+            if (v == -1) break;
+            u = v;
+            if (tr[u].end){ dp[j] = 1; if (j > ans) ans = j; }
+        }
+    }
+    printf("%d\n", ans);
+    free(dp);
+    free(S);
+    free(tr);
+    return 0;
+}

exercise/exercise/87.c

@@ -0,0 +1,34 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n,k;
+    if (scanf("%d %d", &n, &k) != 2) return 0;
+    const int MOD = 114584;
+    int *dp = (int*)malloc(((size_t)n + 1) * sizeof(int));
+    int *pre = (int*)malloc(((size_t)n + 1) * sizeof(int));
+    dp[0] = 1;
+    pre[0] = 1;
+    for (int i = 1; i <= n; ++i){
+        long long sum = pre[i-1];
+        int idx = i - k - 1;
+        if (idx >= 0) sum -= pre[idx];
+        int val = (int)(sum % MOD);
+        if (val < 0) val += MOD;
+        dp[i] = val;
+        pre[i] = pre[i-1] + dp[i];
+        if (pre[i] >= MOD) pre[i] -= MOD;
+    }
+    printf("%d\n", dp[n]);
+    free(pre);
+    free(dp);
+    return 0;
+}

exercise/exercise/88.c

@@ -0,0 +1,33 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef long long ll;
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    ll x,n,m,k;
+    if (scanf("%lld %lld %lld %lld", &x, &n, &m, &k) != 4) return 0;
+    const int MOD = 1000000007;
+    if (x < 0){ printf("impossible\n"); return 0; }
+    int X = (int)x;
+    int *dp = (int*)malloc(((size_t)X + 1) * sizeof(int));
+    for (int i = 0; i <= X; ++i) dp[i] = 0;
+    dp[0] = 1;
+    for (int i = 1; i <= X; ++i){
+        long long s = 0;
+        if (i - (int)n >= 0) s += dp[i - (int)n];
+        if (i - (int)m >= 0) s += dp[i - (int)m];
+        if (i - (int)k >= 0) s += dp[i - (int)k];
+        dp[i] = (int)(s % MOD);
+    }
+    if (dp[X] == 0) printf("impossible\n"); else printf("%d\n", dp[X]);
+    free(dp);
+    return 0;
+}

exercise/exercise/89.c

@@ -0,0 +1,41 @@
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+typedef long long ll;
+
+int main(void){
+#ifdef _WIN32
+    system("chcp 65001 > nul");
+    SetConsoleOutputCP(65001);
+    SetConsoleCP(65001);
+#endif
+    int n; ll MOD;
+    if (scanf("%d %lld", &n, &MOD) != 2) return 0;
+    int *f = (int*)malloc(((size_t)n + 3) * sizeof(int));
+    long long *diff = (long long*)calloc(((size_t)n + 5), sizeof(long long));
+    long long pref = 0;
+    long long Dcur = 0;
+    for (int x = 1; x <= n; ++x){
+        Dcur += diff[x];
+        Dcur %= MOD;
+        if (Dcur < 0) Dcur += MOD;
+        if (x == 1) f[x] = 1 % (int)MOD; else f[x] = (int)((pref + Dcur) % MOD);
+        pref += f[x];
+        pref %= MOD;
+        int maxz = n / x;
+        for (int z = 2; z <= maxz; ++z){
+            int l = x * z;
+            int r = l + z - 1;
+            if (r > n) r = n;
+            diff[l] += f[x];
+            diff[r + 1] -= f[x];
+        }
+    }
+    printf("%d\n", (int)(f[n] % (int)MOD));
+    free(diff);
+    free(f);
+    return 0;
+}