2026年4月11日#include stdio.h int main() { long long N 2026202520242023; long long ans 0; for (long long i 0; i 1013101260121012; i) { if (N-i i) { ans; } else { return 0; } } printf(%lld, ans); return 0; }#include stdio.h long long power(long long base, long long exp) { long long res 1; base % 998244353; while (exp 0) { if (exp % 2 1) res (res * base) % 998244353; base (base * base) % 998244353; exp / 2; } return res; } int main() { long long n 2026; long long mod 998244353; long long ans (n % mod * power(2, n - 1)) % mod; printf(%lld\n, ans); return 0; }#include stdio.h int main() { int t; if (scanf(%d, t) ! 1) return 0; while (t--) { long long n, x, y; if (scanf(%lld %lld %lld, n, x, y) ! 3) break; if (x y) { printf(0\n); } else { printf(%lld\n, y - x 1); } } return 0; }#include stdio.h void solve() { int n; if (scanf(%d, n) ! 1) return; long long sum 0; long long max_a 0; for (int i 0; i n; i) { long long a_i; scanf(%lld, a_i); sum a_i; if (a_i max_a) { max_a a_i; } } if (sum % 5 0 max_a sum / 5) { printf(T\n); } else { printf(F\n); } } int main() { int t; if (scanf(%d, t) ! 1) return 0; while (t--) { solve(); } return 0; }#include stdio.h #include stdlib.h int main() { int n; if (scanf(%d, n) ! 1) return 0; char *s (char *)malloc(n 1); if (scanf(%s, s) ! 1) return 0; long long *preL (long long *)calloc(n, sizeof(long long)); long long *sufQ (long long *)calloc(n, sizeof(long long)); int *q_pos (int *)malloc(n * sizeof(int)); int m 0; long long base 0; long long curL 0; for (int i 0; i n; i) { if (s[i] L) { curL; } else if (s[i] Q) { base curL; } else { q_pos[m] i; } preL[i] curL; } long long curQ 0; for (int i n - 1; i 0; i--) { if (s[i] Q) { curQ; } sufQ[i] curQ; } long long cur_ans base; for (int i 0; i m; i) { cur_ans preL[q_pos[i]]; } long long max_ans cur_ans; for (int k 1; k m; k) { int idx q_pos[k - 1]; cur_ans sufQ[idx] - preL[idx] m - 2 * k 1; if (cur_ans max_ans) { max_ans cur_ans; } } printf(%lld\n, max_ans); free(s); free(preL); free(sufQ); free(q_pos); return 0; }#include stdio.h int parent[100005]; int find(int i) { if (parent[i] i) return i; return parent[i] find(parent[i]); } void unite(int i, int j) { int root_i find(i); int root_j find(j); if (root_i ! root_j) { parent[root_i] root_j; } } int main() { int n, m; if (scanf(%d %d, n, m) ! 2) return 0; for (int i 1; i n; i) { parent[i] i; } for (int i 0; i m; i) { int u, v; scanf(%d %d, u, v); unite(u, v); } int k 0; for (int i 1; i n; i) { if (parent[i] i) { k; } } if (k 1) { printf(0 0\n); } else { long long jumpers k - 1; long long max_load (2 * jumpers n - 1) / n; printf(%lld %lld\n, jumpers, max_load); } return 0; }#include stdio.h #include stdlib.h typedef struct { int val; int pos; } Node; int compare(const void *a, const void *b) { Node *n1 (Node *)a; Node *n2 (Node *)b; if (n1-val ! n2-val) { if (n1-val n2-val) return -1; return 1; } return n1-pos - n2-pos; } int main() { int n; if (scanf(%d, n) ! 1) return 0; int *a (int *)malloc(n * sizeof(int)); int *b (int *)malloc(n * sizeof(int)); int *z (int *)malloc((n 1) * sizeof(int)); Node *nodes (Node *)malloc(n * sizeof(Node)); int m 0; int zeros 0; z[0] 0; for (int i 0; i n; i) { if (scanf(%d, a[i]) ! 1) break; } for (int i 0; i n; i) { if (scanf(%d, b[i]) ! 1) break; int diff b[i] - a[i]; if (diff 0) { zeros; } else { nodes[m].val diff; nodes[m].pos i; m; } z[i 1] zeros; } if (m 0) { qsort(nodes, m, sizeof(Node), compare); int max_gain 0; int i 0; while (i m) { int j i; int current_gain 1; int best_in_group 1; while (j 1 m nodes[j 1].val nodes[i].val) { int penalty z[nodes[j 1].pos] - z[nodes[j].pos]; if (current_gain - penalty 1 1) { current_gain current_gain - penalty 1; } else { current_gain 1; } if (current_gain best_in_group) { best_in_group current_gain; } j; } if (best_in_group max_gain) { max_gain best_in_group; } i j 1; } printf(%d\n, zeros max_gain); } else { printf(%d\n, zeros); } free(a); free(b); free(z); free(nodes); return 0; }#include stdio.h #include stdlib.h #define MOD 998244353 typedef struct { long double priority; int id; } HeapNode; HeapNode *heap; int heapSize 0; void push(long double v, int id) { heap[heapSize].priority v; heap[heapSize].id id; int cur heapSize; while (cur 1) { int p cur / 2; if (heap[cur].priority heap[p].priority) { HeapNode tmp heap[cur]; heap[cur] heap[p]; heap[p] tmp; cur p; } else break; } } HeapNode pop() { HeapNode res heap[1]; heap[1] heap[heapSize--]; int cur 1; while (cur * 2 heapSize) { int child cur * 2; if (child 1 heapSize heap[child 1].priority heap[child].priority) child; if (heap[child].priority heap[cur].priority) { HeapNode tmp heap[cur]; heap[cur] heap[child]; heap[child] tmp; cur child; } else break; } return res; } int main() { int n; long long m; if (scanf(%d %lld, n, m) ! 2) return 0; long long *a malloc(n * sizeof(long long)); long long *b malloc(n * sizeof(long long)); long long *k calloc(n, sizeof(long long)); heap malloc((n 1) * sizeof(HeapNode)); for (int i 0; i n; i) { scanf(%lld %lld, a[i], b[i]); long double p; if (b[i] 0) p 0; else if (a[i] 0) p 1e60; else p (long double)b[i] / a[i]; push(p, i); } while (m 0 heapSize 0) { HeapNode top pop(); int idx top.id; k[idx]; m--; long double next_p (long double)b[idx] / (a[idx] k[idx] * b[idx]); push(next_p, idx); } long long total_strength 1; for (int i 0; i n; i) { long long final_val (a[i] % MOD (k[i] % MOD * (b[i] % MOD)) % MOD) % MOD; total_strength (total_strength * final_val) % MOD; } printf(%lld\n, total_strength); free(a); free(b); free(k); free(heap); return 0; }