malteklaes/cpp-code-code_search_net-style · Datasets at Hugging Face

func_code_string stringlengths 59 71.4k
#include <bits/stdc++.h> using namespace std; int n, flag = 0; int matrix[2505][2505]; int parent[2505]; vector<int> graph[2505]; int vis[2505], num[2505]; struct Edge { int u, v, w; Edge() {} Edge(int u, int v, int w) : u(u), v(v), w(w) {} }; vector<Edge> edge; bool cmp(const Edge &a, const Edge &b) { return a.w < b.w; } void init() { for (int i = 1; i <= 2505; i++) parent[i] = i; } void input() { for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { scanf( %d , &matrix[i][j]); if (i == j && matrix[i][j] != 0) flag = 1; if (i > j && matrix[i][j] != matrix[j][i]) flag = 1; if (i < j) edge.push_back(Edge(i, j, matrix[i][j])); } } } int findfather(int x) { if (x == parent[x]) return x; return parent[x] = findfather(parent[x]); } void Union(int x, int y) { int rx = findfather(x); int ry = findfather(y); if (rx > ry) swap(rx, ry); if (rx != ry) parent[ry] = rx; } void Krukal() { sort(edge.begin(), edge.end(), cmp); int cnt = 0; for (int i = 0; i < edge.size(); i++) { int u = edge[i].u; int v = edge[i].v; int ru = findfather(u); int rv = findfather(v); if (ru != rv) { graph[u].push_back(v); graph[v].push_back(u); cnt++; Union(u, v); } if (cnt == n - 1) break; } } void dfs(int u, int fa, int tmp) { vis[u] = 1; for (int i = 0; i < graph[u].size(); i++) { int k = graph[u][i]; if (vis[k]) continue; if (k == fa) continue; num[k] = max(tmp, matrix[u][k]); dfs(k, u, num[k]); } } int main() { scanf( %d , &n); init(); input(); if (flag) { printf( NOT MAGIC n ); return 0; } Krukal(); for (int i = 1; i <= n; i++) { memset(vis, 0, sizeof(vis)); dfs(i, -1, 0); for (int j = i + 1; j <= n; j++) { if (num[j] != matrix[i][j]) { flag = 1; break; } } if (flag) break; } if (flag) printf( NOT MAGIC n ); else printf( MAGIC n ); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int already = 0; int n, k; cin >> n >> k; int ans = 0; for (int i = 0; i < k; ++i) { int cnt; cin >> cnt; int first; cin >> first; if (first == 1) { int good = 1; already = 1; --ans; while (good < cnt) { cin >> first; if (first == good + 1) { ++good; already = good; --ans; } else { ++good; break; } } ans += cnt; while (good < cnt) { cin >> first; ++good; } } else { ans += (cnt - 1); for (int j = 1; j < cnt; ++j) cin >> first; } } ans += (n - already); cout << ans; return 0; }
#include <bits/stdc++.h> using namespace std; long long t, x, y, p, q; bool check(long long mid) { long long pp = p * mid; long long qq = q * mid; if (pp - x < 0 \|\| qq - y < 0) return false; return (pp - x <= qq - y); } int main() { scanf( %lld , &t); while (t--) { scanf( %lld %lld %lld %lld , &x, &y, &p, &q); if (x * q == p * y) { printf( 0 n ); continue; } long long lo = 1, hi = 2000000000; while (lo + 1 < hi) { long long mid = (lo + hi) / 2LL; if (check(mid)) hi = mid; else lo = mid; } if (check(lo)) hi = lo; if (check(hi)) printf( %lld n , hi * q - y); else printf( -1 n ); } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int t, i, x; cin >> t; while (t--) { int angle; cin >> angle; x = 360 % (180 - angle); if (x == 0) { cout << YES << endl; } else cout << NO << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; long long M = 1e9 + 7; const int N = 3e5 + 7; const int K = 5e3 + 7; int n, k; int a[N]; int dp[K][K]; int main() { scanf( %d%d , &n, &k); for (int i = 1; i <= n; i++) scanf( %d , &a[i]); sort(a + 1, a + n + 1); int top = (n + k - 1) / k; int low = n / k; int ctop = n % k; int clow = k - ctop; for (int i = 0; i < K; i++) for (int j = 0; j < K; j++) dp[i][j] = -1; dp[0][0] = 0; for (int i = 0; i <= ctop; i++) for (int j = 0; j <= clow; j++) if (i \|\| j) { dp[i][j] = 2e9 + 7; int pnt = i * top + j * low; if (j) dp[i][j] = dp[i][j - 1] + a[pnt] - a[pnt - low + 1]; if (i) dp[i][j] = min(dp[i][j], dp[i - 1][j] + a[pnt] - a[pnt - top + 1]); } cout << dp[ctop][clow]; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int h1, t1, h2, t2, ansh, anst; scanf( %2d:%2d , &h1, &t1); scanf( %2d:%2d , &h2, &t2); if (t1 < t2) { h1--, t1 += 60; } anst = t1 - t2; ansh = h1 - h2; if (ansh < 0) ansh += 24; printf( %02d:%02d n , ansh, anst); return 0; }
#include <bits/stdc++.h> int n; int a[105], l[105]; int id[105]; int dp[105][105][2]; int main() { scanf( %d , &n); for (int i = 0; i < (int)(n); ++i) scanf( %d %d , &a[i], &l[i]); for (int i = 0; i < (int)(n); ++i) id[i] = i; std::sort(id, id + n, [&](int x, int y) { return a[x] < a[y]; }); dp[0][0][0] = 0; for (int i = 0; i < (int)(n); ++i) { for (int j = 0; j < (int)(i + 1); ++j) { for (int k = 0; k < (int)(2); ++k) { int mj = -1, mk = -1; for (int nj = i; nj < n; ++nj) { for (int nk = 0; nk < (int)(2); ++nk) { if (mj == -1 \|\| a[id[mj]] + mk * l[id[mj]] < a[id[nj]] + nk * l[id[nj]]) mj = nj, mk = nk; dp[nj + 1][mj + 1][mk] = std::max( dp[nj + 1][mj + 1][mk], dp[i][j][k] + a[id[mj]] + mk * l[id[mj]] - std::max( (j ? a[id[j - 1]] + k * l[id[j - 1]] : -0x3f3f3f3f), a[id[nj]] - (!nk) * l[id[nj]])); } } } } } int ans = 0; for (int j = 0; j < (int)(n + 1); ++j) for (int k = 0; k < (int)(2); ++k) { ans = std::max(ans, dp[n][j][k]); } printf( %d n , ans); return 0; }
#include <bits/stdc++.h> using namespace std; const int MAX = 111, K = 26; int n; string name[MAX]; namespace G { struct V : vector<int> { V() : odw(false) {} bool odw; int wyj; }; V g[K]; void krawedz(char a, char b) { g[int(a) - int( a )].push_back(int(b) - int( a )); } int t = 0; stack<int> stos; void dfs(int v) { g[v].odw = true; for (int i = 0; i < ((int((g[v]).size()))); i++) { int u = g[v][i]; if (!g[u].odw) dfs(u); } stos.push(v); g[v].wyj = t++; } bool poprawne_sortowanie() { for (int v = 0; v < (K); v++) for (int i = 0; i < ((int((g[v]).size()))); i++) { int u = g[v][i]; if (g[v].wyj < g[u].wyj) return false; } return true; } bool sortowanie_topologiczne() { for (int i = 0; i < (K); i++) if (!g[i].odw) dfs(i); return poprawne_sortowanie(); } void wypisz_sortowanie() { assert((int((stos).size())) == 26); while (!stos.empty()) { cout << char(int( a ) + stos.top()); stos.pop(); } cout << n ; } } // namespace G void wczytaj_dane() { cin >> n; for (int i = 0; i < (n); i++) cin >> name[i]; } int roznica(const string& a, const string& b) { int m = min((int((a).size())), (int((b).size()))); for (int i = 0; i < (m); i++) if (a[i] != b[i]) return i; return -1; } bool porownuj(const string& a, const string& b) { int i = roznica(a, b); if (i == -1) return (int((a).size())) < (int((b).size())); G::krawedz(a[i], b[i]); return true; } void zrob_test() { wczytaj_dane(); for (int i = 0; i < (n - 1); i++) if (!porownuj(name[i], name[i + 1])) { cout << Impossible n ; return; } if (G::sortowanie_topologiczne()) G::wypisz_sortowanie(); else cout << Impossible n ; } int main() { ios_base::sync_with_stdio(0); zrob_test(); return 0; }
#include <bits/stdc++.h> using namespace std; long long Pow(int a, int b) { long long ans = 1; for (int i = 0; i < b; i++) { ans = (ans * a) % 1000000007; } return ans; } int main() { long long n, k; cin >> n >> k; cout << (Pow(n - k, n - k) * Pow(k, k - 1)) % 1000000007 << endl; return 0; }
#include <bits/stdc++.h> using namespace std; vector<int> v[200005]; int CR, n, k, sz[200005], target[200005], cented[200005]; void getsize(int now, int pre) { sz[now] = (target[now] == 1); for (int i = 0; i < v[now].size(); i++) { int next = v[now][i]; if (next == pre \|\| cented[next]) continue; getsize(next, now); sz[now] += sz[next]; } } int getcent(int now, int pre, int R) { for (int i = 0; i < v[now].size(); i++) { int next = v[now][i]; if (next == pre \|\| cented[next]) continue; if (sz[next] > sz[R] / 2) return getcent(next, now, R); } return now; } priority_queue<pair<int, int> > pq; int centdfs(int now) { getsize(now, -1); int cc = getcent(now, -1, now); cented[cc] = 1; if (CR == -1) CR = cc; return cc; } int gcnt = 0; vector<int> tmp[200005]; void go(int now, int pre) { if (target[now]) tmp[gcnt].push_back(now); for (int i = 0; i < v[now].size(); i++) { int next = v[now][i]; if (next == pre) continue; go(next, now); } } int main() { CR = -1; scanf( %d %d , &n, &k); for (int a, b, i = 0; i < n - 1; i++) { scanf( %d %d , &a, &b); v[a].push_back(b); v[b].push_back(a); } for (int i = 1; i <= k; i++) { for (int t, j = 0; j < 2; j++) { scanf( %d , &t); target[t] = 1; } } centdfs(1); printf( 1 n%d n , CR); for (int i = 0; i < v[CR].size(); i++) { ++gcnt; go(v[CR][i], CR); if (tmp[gcnt].empty()) continue; pq.push(make_pair((int)tmp[gcnt].size(), gcnt)); } while (!pq.empty()) { pair<int, int> p = pq.top(); pq.pop(); if ((int)pq.size() == 0) { printf( %d %d %d n , tmp[p.second].back(), CR, CR); break; } pair<int, int> p2 = pq.top(); pq.pop(); printf( %d %d %d n , tmp[p.second].back(), tmp[p2.second].back(), CR); tmp[p.second].pop_back(); tmp[p2.second].pop_back(); if (--p.first != 0) { pq.push(p); } if (--p2.first != 0) { pq.push(p2); } } }
#include <bits/stdc++.h> using namespace std; const int MAX = 100005; vector<int> A, B[MAX], C, D; int visited[MAX]; int n, m; void DFS(int u) { visited[u] = 1; C.push_back(u); for (int i = 0; i < B[u].size(); i++) { int current = B[u][i]; if (visited[current] == 0) DFS(current); } } int main() { int n; scanf( %d , &n); A.clear(); for (int i = 0; i <= n; i++) visited[i] = 0; string s; for (int i = 0; i < n; i += 1) { int val; cin >> val; A.push_back(val); } for (int i = 0; i < MAX; i++) B[i].clear(); for (int i = 0; i < n; i++) { cin >> s; for (int j = 0; j < n; j++) { if (s[j] == 1 ) { B[i + 1].push_back(j + 1); B[j + 1].push_back(i + 1); } } } for (int i = 1; i <= n; i++) { C.clear(); D.clear(); if (visited[i] == 0) { DFS(i); for (int j = 0; j < C.size(); j++) { D.push_back(A[C[j] - 1]); } sort(C.begin(), C.end()); sort(D.begin(), D.end()); for (int j = 0; j < C.size(); j++) { A[C[j] - 1] = D[j]; } } } for (int i = 0; i < A.size(); i++) printf( %d , A[i]); printf( n ); return 0; }
#include <bits/stdc++.h> using namespace std; int n, m, s, ans = 0, f[2 * 200005]; inline int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); } int main() { scanf( %d%d%d , &n, &m, &s); for (register int i = 1; i <= m + n; i++) f[i] = i; for (register int i = 1; i <= s; i++) { register int a, b; scanf( %d%d , &a, &b), b += n; f[find(b)] = find(a); } for (register int i = 1; i <= n + m; i++) if (f[i] == i) ans++; printf( %d , ans - 1); return 0; }
#include <bits/stdc++.h> #pragma GCC optimize(3, Ofast , inline ) const double eps = 1e-7; const int maxn = 3e5 + 10; const int prime[15] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37}; const int dir[4][2] = {1, 0, -1, 0, 0, 1, 0, -1}; int spgcd(int a, int b) { while (b ^= a ^= b ^= a %= b) ; return a; } inline int mul(int a, int b, int p) { return (long long)a * b % p; } template <typename T> void scan(T &x) { x = 0; bool _ = 0; T c = getchar(); _ = c == 45; c = _ ? getchar() : c; while (c < 48 \|\| c > 57) c = getchar(); for (; c < 48 \|\| c > 57; c = getchar()) ; for (; c > 47 && c < 58; c = getchar()) x = (x << 3) + (x << 1) + (c & 15); x = _ ? -x : x; } template <typename T> void printn(T n) { bool _ = 0; _ = n < 0; n = _ ? -n : n; char snum[65]; int i = 0; do { snum[i++] = n % 10 + 48; n /= 10; } while (n); --i; if (_) putchar(45); while (i >= 0) putchar(snum[i--]); } template <typename First, typename... Ints> void scan(First &arg, Ints &...rest) { scan(arg); scan(rest...); } template <typename T> void print(T n) { printn(n); putchar(10); } template <typename First, typename... Ints> void print(First arg, Ints... rest) { printn(arg); putchar(32); print(rest...); } using namespace std; map<int, int> mp; void solve() { int n; cin >> n; for (int i = 1; i <= n; i++) { int l, r; cin >> l >> r; mp[l]++, mp[r]--; } int ans = 0, id = 1; int sum = 0; for (auto i : mp) { sum += i.second; if (sum > ans) { ans = sum; id = i.first; } } cout << id << << ans << endl; } int main() { ios::sync_with_stdio(0), cin.tie(0), cout.tie(0); solve(); return 0; }
#include <bits/stdc++.h> using namespace std; const int sz = (1 << 22); bool ar[sz], us[2][sz]; int n, m, bg; void dfs(int v, int t) { us[t][v] = 1; if (t == 0) { if (us[1][bg ^ v] == 0) dfs(bg ^ v, 1); } else { if (ar[v] and us[0][v] == 0) dfs(v, 0); for (int i = 0; i < n; i++) { if (v & (1 << i)) { int ne = v - (1 << i); if (us[1][ne] == 0) dfs(ne, 1); } } } } int main() { int an = 0; cin >> n >> m; bg = (1 << n) - 1; for (int a = 0; a < m; a++) { int x; scanf( %d , &x); ar[x] = 1; } for (int a = 0; a < (1 << n); a++) { if (ar[a] and us[0][a] == 0) { dfs(a, 0), an++; } } cout << an; }
#include <bits/stdc++.h> using namespace std; const int mod = 1e9 + 7; long long a[50]; long long inv[50]; long long Finv[50]; long long n, s; void init() { inv[1] = 1; for (int i = 2; i <= 50; i++) { inv[i] = (mod - mod / i) * inv[mod % i] % mod; } Finv[0] = 1; for (int i = 1; i <= 50; i++) { Finv[i] = Finv[i - 1] % mod * inv[i] % mod; } } long long C(long long n, long long m) { if (n < 0 \|\| m < 0 \|\| m > n) return 0; long long res = 1; for (long long i = n; i > n - m; i--) { res = (i % mod * res) % mod; } res = res % mod * Finv[m] % mod; return res % mod; } int main() { init(); cin >> n >> s; for (int i = 0; i < n; i++) { cin >> a[i]; } long long res = 0; for (long long i = 0; i < (1ll << n); i++) { long long tmp = s; long long cnt = 0; for (long long j = 0; j < n; j++) { if ((1ll << j) & i) { tmp -= a[j] + 1; cnt++; } } if (tmp < 0) continue; if (cnt & 1) { res = (((res - C(tmp + n - 1, n - 1)) % mod + mod) % mod) % mod; } else { res = (res + C(tmp + n - 1, n - 1) % mod) % mod; } } cout << res << endl; }
#include <bits/stdc++.h> using namespace std; int main() { int N; cin >> N; if (N % 2 == 0) cout << -1 << endl; else { for (int i = 0; i < N; i++) cout << i << (i == N - 1 ? n : ); for (int i = 0; i < N; i++) cout << ((long long)(N - 2) * i) % N << (i == N - 1 ? n : ); for (int i = 0; i < N; i++) cout << ((long long)(N - 2) * i + i) % N << (i == N - 1 ? n : ); } return 0; }
#include <bits/stdc++.h> using namespace std; int sqrt_maxn = 505; const int maxsqrt_n = 205; const int maxn = 100005; int a[maxn]; struct node { int val; node* next; node* front; }; node* front[maxsqrt_n]; node* rail[maxsqrt_n]; int dp[maxsqrt_n][maxn]; node* new_node() { static node a[200005]; static int top = 0; return &a[top++]; } void insert_node(int x, int y) { node* t = new_node(); t->val = y; t->next = front[x]; if (front[x] != 0) front[x]->front = t; t->front = 0; front[x] = t; } void trans_inside(int x, int y) { register int j = x / sqrt_maxn; register int i; register node* t1 = front[j]; for (i = j * sqrt_maxn; i <= x; i++) { t1 = t1->next; } register node* t2 = t1; for (; i <= y; i++) { t2 = t2->next; } t1->front->next = t2; t2->front->next = t2->next; t2->next->front = t2->front; t2->front = t1->front; t2->next = t1; t1->front = t2; } void trans(int x, int y) { register int jx = x / sqrt_maxn; register int i; register node* t1 = front[jx]; for (i = jx * sqrt_maxn; i <= x; i++) { t1 = t1->next; } int jy = y / sqrt_maxn; register node* t2 = front[jy]; for (i = jy * sqrt_maxn; i <= y; i++) { t2 = t2->next; } t1->front->next = t2; t2->front->next = t2->next; t2->next->front = t2->front; t2->front = t1->front; t2->next = t1; t1->front = t2; dp[jx][t2->val]++; dp[jy][t2->val]--; for (i = jx; i < jy; i++) { t1 = front[i + 1]->next; t2 = rail[i]->front; t1->front->next = t2; t2->front->next = t2->next; t2->next->front = t2->front; t2->front = t1->front; t2->next = t1; t1->front = t2; dp[i + 1][t2->val]++; dp[i][t2->val]--; } } int calc_inside(int x, int y, int val) { int j = x / sqrt_maxn; int i; node* t1 = front[j]; for (i = j * sqrt_maxn; i <= x; i++) { t1 = t1->next; } register int ans = 0; for (; i <= y; i++) { if (t1->val == val) ans++; t1 = t1->next; } if (t1->val == val) ans++; return ans; } int calc(int x, int y, int val) { int j = x / sqrt_maxn; int i; node* t1 = front[j]; for (i = j * sqrt_maxn; i <= x; i++) { t1 = t1->next; } int ans = 0; for (; t1->val != -2;) { if (t1->val == val) ans++; t1 = t1->next; } int jy = y / sqrt_maxn; for (i = j + 1; i < jy; i++) { ans += dp[i][val]; } t1 = front[jy]; for (i = jy * sqrt_maxn; i <= y; i++) { t1 = t1->next; if (t1->val == val) ans++; } return ans; } int main() { fprintf(stderr, %d n , clock()); int n; scanf( %d , &n); int i; for (i = 0; i < n; i++) { scanf( %d , &a[i]); a[i]--; } memset(dp, 0, sizeof(dp)); for (i = 0; i < n; i += sqrt_maxn) { register int temp = i / sqrt_maxn; front[temp] = 0; int j; insert_node(temp, -2); rail[temp] = front[temp]; for (j = i + sqrt_maxn - 1; j >= i; j--) { if (j >= n) continue; insert_node(temp, a[j]); dp[temp][a[j]]++; } insert_node(temp, -1); } int lastans = 0; int q; scanf( %d , &q); for (i = 0; i < q; i++) { int oper; scanf( %d , &oper); if (oper == 1) { int x, y; scanf( %d%d , &x, &y); x = (x - 1 + lastans) % n; y = (y - 1 + lastans) % n; if (x > y) swap(x, y); if (x == y) continue; if (x / sqrt_maxn == y / sqrt_maxn) { trans_inside(x, y); } else { trans(x, y); } } else { int x, y, z; scanf( %d%d%d , &x, &y, &z); x = (x - 1 + lastans) % n; y = (y - 1 + lastans) % n; z = (z - 1 + lastans) % n; if (x > y) swap(x, y); if (x / sqrt_maxn == y / sqrt_maxn) { lastans = calc_inside(x, y, z); } else { lastans = calc(x, y, z); } printf( %d n , lastans); } } fprintf(stderr, %d n , clock()); return 0; }
#include <bits/stdc++.h> using namespace std; const int mod = 998244353; const int M = 80; const int N = 4100; long long c[M][M], m; struct Tree { struct Node { int ne, to; } e[2 * N]; int vis[N], tot = 0, he[N], sz[N], mx[N], q[N], n, rp, mn; long long step[M], f[N][M], g[N][M], tmp[M], ans[M]; void add(int x, int y) { e[++tot].ne = he[x]; he[x] = tot; e[tot].to = y; } void addedge(int x, int y) { add(x, y); add(y, x); } void dfs1(int x, int fa) { int i, y; sz[x] = 1; mx[x] = 0; for (i = he[x]; i; i = e[i].ne) { y = e[i].to; if ((!vis[y]) && (y != fa)) { dfs1(y, x); sz[x] += sz[y]; if (sz[y] > mx[x]) mx[x] = sz[y]; } } } void dfsrt(int now, int x, int fa, int &rt) { int i, y; mx[x] = max(mx[x], sz[now] - sz[x]); if (mx[x] < mn) { mn = mx[x]; rt = x; } for (i = he[x]; i; i = e[i].ne) { y = e[i].to; if ((!vis[y]) && (y != fa)) dfsrt(now, y, x, rt); } } void dfs2(int x, int fa) { int i, y; q[++rp] = x; for (i = he[x]; i; i = e[i].ne) { y = e[i].to; if ((!vis[y]) && (y != fa)) dfs2(y, x); } } void divide(int x) { int rt, i, j, k, y; mn = n; dfs1(x, 0); dfsrt(x, x, 0, rt); vis[rt] = 1; for (i = he[rt]; i; i = e[i].ne) if (!vis[e[i].to]) divide(e[i].to); vis[rt] = 0; rp = 0; dfs2(rt, 0); memset(step, 0, sizeof(step)); for (i = he[rt]; i; i = e[i].ne) { y = e[i].to; if (!vis[y]) for (j = 0; j <= m - 2; j++) step[j + 2] = (step[j + 2] + f[y][j]) % mod; } memset(f[rt], 0, sizeof(f[rt])); f[rt][0] = 1; for (i = 1; i <= m; i++) for (j = 2; j <= i; j++) f[rt][i] = (f[rt][i] + f[rt][i - j] * step[j]) % mod; for (i = 2; i <= rp; i++) { memset(tmp, 0, sizeof(tmp)); for (j = 2; j <= m; j++) for (k = 0; k <= j - 2; k++) tmp[j] = (tmp[j] + g[q[i]][k] * f[rt][j - k - 2]) % mod; for (j = 2; j <= m; j++) for (k = 0; k <= j - 2; k++) f[q[i]][j] = (f[q[i]][j] + g[q[i]][k] * tmp[j - k]) % mod; } for (i = 1; i <= rp; i++) memset(g[q[i]], 0, sizeof(g[q[i]])); g[x][0] = 1; for (i = 1; i <= m; i++) for (j = 1; j <= rp; j++) for (k = he[q[j]]; k; k = e[k].ne) { y = e[k].to; if (!vis[y]) g[q[j]][i] = (g[q[j]][i] + g[y][i - 1]) % mod; } } void solve() { divide(1); for (int i = 0; i <= m; i++) for (int j = 1; j <= n; j++) ans[i] = (ans[i] + f[j][i]) % mod; } } tr1, tr2; int main() { int i, j, k, x, y; long long out; scanf( %d%d%d , &tr1.n, &tr2.n, &m); for (i = 1; i < tr1.n; i++) { scanf( %d%d , &x, &y); tr1.addedge(x, y); } for (i = 1; i < tr2.n; i++) { scanf( %d%d , &x, &y); tr2.addedge(x, y); } for (i = 0; i <= m; i++) c[i][0] = 1; for (i = 1; i <= m; i++) for (j = 1; j <= i; j++) c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod; tr1.solve(); tr2.solve(); out = 0; for (i = 0; i <= m; i++) out = (out + (c[m][i] * tr1.ans[i]) % mod * tr2.ans[m - i]) % mod; printf( %I64d n , out); return 0; }
#include <bits/stdc++.h> using namespace std; struct trie { struct tree { long long al[26]; bool ex; } nxt[100005]; long long cnt, dep[100005]; void insert(char *s) { long long l = strlen(s), rt = 0; for (register long long i = 0; i < l; i++) { long long c = s[i] - a ; if (!nxt[rt].al[c]) nxt[rt].al[c] = ++cnt, dep[cnt] = dep[rt] + 1; rt = nxt[rt].al[c]; } nxt[rt].ex = 1; } } tr; priority_queue<long long> q[100005]; long long n, ans = 0; char s[100005]; template <typename T> inline void read(T &x) { T c = getchar(), f = 0; for (; c < 48 \|\| 57 < c; c = getchar()) if (c == - ) f = 1; for (x = 0; 48 <= c && c <= 57; c = getchar()) x = (x << 3) + (x << 1) + (c ^ 48); if (f) x = -x; } template <typename T> inline void print(T x) { if (x < 0) x = -x, putchar( - ); if (x > 9) print(x / 10); putchar(x % 10 + 48); } inline void merge(long long x, long long y) { while (!q[y].empty()) q[x].push(q[y].top()), q[y].pop(); } void dfs(long long x) { for (register long long i = 0; i < 26; i++) if (tr.nxt[x].al[i]) dfs(tr.nxt[x].al[i]); for (register long long i = 0; i < 26; i++) if (tr.nxt[x].al[i]) merge(x, tr.nxt[x].al[i]); if (!x) return; if (tr.nxt[x].ex) ans += tr.dep[x], q[x].push(tr.dep[x]); else ans -= q[x].top() - tr.dep[x], q[x].pop(), q[x].push(tr.dep[x]); } signed main() { scanf( %lld , &n); for (register long long i = 1; i <= n; i++) scanf( %s , s), tr.insert(s); dfs(0), printf( %lld , ans); return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 2e5 + 5; int n, T, ans; int t[N]; priority_queue<int> pq; int main() { scanf( %d%d , &n, &T); for (int i = 1; i <= n; ++i) { scanf( %d , &t[i]); t[i] = t[i] > i ? t[i] - i : 0; } for (int i = 1; i <= n; ++i) { pq.push(t[i]); while ((long long)pq.top() + i >= T && !pq.empty()) { pq.pop(); } ans = max(ans, (int)pq.size()); } printf( %d n , ans); return 0; }
#include <bits/stdc++.h> int main() { int a, b, i, j, c = 0; int fil, col; scanf( %d , &a); scanf( %d , &b); char myChar; int aux[2][3]; for (i = 0; i < a; i++) { for (j = 0; j < b; j++) { scanf( %c , &myChar); if (myChar == * ) { aux[0][c] = i + 1; aux[1][c] = j + 1; c++; } } } for (i = 0; i < 2; i++) { for (j = i + 1; j < 3; j++) { if (aux[0][i] == aux[0][j]) { aux[0][i] = -1; aux[0][j] = -1; } if (aux[1][i] == aux[1][j]) { aux[1][i] = -1; aux[1][j] = -1; } } } for (i = 0; i < 3; i++) { if (aux[0][i] != -1) { fil = aux[0][i]; } if (aux[1][i] != -1) { col = aux[1][i]; } } printf( %d %d , fil, col); return 0; }
#include <bits/stdc++.h> using namespace std; const int MOD = 1000000007; const char nl = n ; const int MX = 100001; int main() { ios_base::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr); int t; cin >> t; for (int tt = 0; tt < (t); tt++) { int n; cin >> n; for (int i = 0; i < (n); i++) cout << 1 ; cout << n ; } return 0; }
#include <bits/stdc++.h> using namespace std; using ll = long long; const ll INF = 1e18 + 1; const ll mod = 1e9 + 7; vector<vector<ll> > adj; vector<ll> desc, max_n; ll gmnc = INF; void print_vec(vector<ll> vec) { for (int i = 0; i < vec.size(); ++i) { cout << vec[i] << ; } cout << endl; } ll desc_cnt(ll curr, ll par) { ll cnt = 1; for (auto it : adj[curr]) { if (it != par) { cnt += desc_cnt(it, curr); } } desc[curr] = cnt; return cnt; } void max_neigh_cnt(ll curr, ll par) { ll mnc = -INF; mnc = max(mnc, desc[1] - desc[curr]); for (auto it : adj[curr]) { if (it != par) { mnc = max(mnc, desc[it]); } } gmnc = min(gmnc, mnc); max_n[curr] = mnc; for (auto it : adj[curr]) { if (it != par) { max_neigh_cnt(it, curr); } } } int main() { cin.tie(0); ios_base::sync_with_stdio(0); ll t; cin >> t; while (t--) { ll n; cin >> n; adj.clear(); desc.clear(); max_n.clear(); gmnc = INF; adj.resize(n + 1); desc.resize(n + 1); max_n.resize(n + 1); for (int i = 1; i <= n - 1; ++i) { ll x, y; cin >> x >> y; adj[x].push_back(y); adj[y].push_back(x); } desc_cnt(1, 1); max_neigh_cnt(1, 1); vector<ll> cn; for (int i = 1; i <= n; ++i) { if (max_n[i] == gmnc) { cn.push_back(i); } } pair<ll, ll> e1, e2; if (cn.size() > 1) { for (auto it : adj[cn[0]]) { if (it != cn[1]) { e1 = make_pair(cn[0], it); e2 = make_pair(cn[1], it); break; } } } else { e1 = make_pair(cn[0], adj[cn[0]][0]); e2 = e1; } cout << e1.first << << e1.second << endl; cout << e2.first << << e2.second << endl; } }
#include <bits/stdc++.h> using namespace std; char s[400010]; int a[200]; vector<int> S; vector<int> d, q; int main() { int n; scanf( %d %s , &n, s); for (int i = 0; i < n; i++) a[s[i]]++; int p = 0; for (int i = 0; i < 128; i++) { if (a[i] % 2) p++, a[i]--, S.push_back(i); if (a[i]) { d.push_back(i); q.push_back(a[i]); } } if (p == 0) { int cn = 0; for (int i = 0; i < 128; i++) { while (a[i]) s[cn++] = i, a[i] -= 2; } for (int i = 0; i < cn; i++) s[cn + i] = s[cn - i - 1]; s[n] = 0 ; printf( 1 n%s n , s); } else { int Min = n; for (int i = 1; i * i <= n; i++) { if (n % i == 0) { if (i % 2 && n / i >= p && (n / i - p) % 2 == 0) Min = min(Min, n / i); if (n / i % 2 && i >= p && (i - p) % 2 == 0) Min = min(Min, i); } } printf( %d n , Min); int L = n / Min; int pi = L / 2; int now = 0; for (int i = 0; i < Min; i++) { int x = pi + i * L; if (S.size() > i) s[x] = S[i]; else { while (!q[now]) now++; s[x] = d[now]; S.push_back(d[now]); S.push_back(d[now]); q[now] -= 2; } for (int i = 0; i < L / 2; i++) { while (!q[now]) now++; s[x - i - 1] = d[now]; s[x + i + 1] = d[now]; q[now] -= 2; } } for (int i = 0; i < n; i++) { printf( %c , s[i]); if (i % L == L - 1 && i != n - 1) printf( ); } printf( n ); } return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 1e6, SZ = 800, INF = 1 << 29; const long long LINF = (1LL << 60), mod = 1e9 + 7; const long double eps = 1e-8, PI = acos(-1.0); inline int dcmp(double x, double y = 0.0) { return abs(x - y) < eps; } template <typename Type> inline Type ru(Type &v) { static char READ_DATA; static int SIGNAL_INPUT = 1; while ((READ_DATA = getchar()) < 0 \|\| READ_DATA > 9 ) if (READ_DATA == - ) SIGNAL_INPUT = -1; else if (READ_DATA == EOF) return EOF; v = READ_DATA - 0 ; while ((READ_DATA = getchar()) >= 0 && READ_DATA <= 9 ) v = v * 10 + READ_DATA - 0 ; v = SIGNAL_INPUT; return v; } template <typename A, typename B> inline int ru(A &x, B &y) { if (ru(x) == EOF) return EOF; ru(y); return 2; } template <typename A, typename B, typename C> inline int ru(A &x, B &y, C &z) { if (ru(x) == EOF) return EOF; ru(y); ru(z); return 3; } long long gcd(long long a, long long b) { a = abs(a); b = abs(b); while (b) { a %= b; swap(a, b); } return a; } const int maxn = 1e6 + 5; int n, a[maxn], m, d[maxn], id[maxn]; int cmp(const int &i, const int &j) { return d[(i + 1) / 2] > d[(j + 1) / 2]; } int main() { ru(n); for (int i = 1; i <= n; i++) { ru(d[i]); } for (int i = 1; i < 2 n; i += 2) { a[++m] = i; } sort(a + 1, a + m + 1, cmp); for (int i = 2; i <= m; i++) { printf( %d %d n , a[i - 1], a[i]); } for (int i = 1; i <= n; i++) { int j = (a[i] + 1) / 2; if (i + d[j] - 1 <= m) { printf( %d %d n , 2 * j, a[i + d[j] - 1]); if (i + d[j] - 1 == m) { a[++m] = 2 * j; } } else { printf( %d %d n , 2 * j, a[i - d[j] + 1]); } } }
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(0); cin.tie(0); int t; cin >> t; while (t--) { int kq = 0; vector<pair<int, int> > res; int n, k; cin >> n >> k; vector<bool> used(2 * n + 1, false); for (int i = 1; i <= k; i++) { int u, v; cin >> u >> v; res.push_back({min(u, v), max(u, v)}); used[u] = true; used[v] = true; } vector<int> conlai; for (int i = 1; i <= 2 * n; i++) { if (!used[i]) conlai.push_back(i); } int len = n - k; for (int i = 0; i < len; i++) { res.push_back({conlai[i], conlai[i + len]}); } for (int i = 0; i < res.size(); i++) { for (int j = i + 1; j < res.size(); j++) { int a = (res[j].first - res[i].first) * (res[j].second - res[i].first); int b = (res[j].first - res[i].second) * (res[j].second - res[i].second); if (a * b < 0) { kq++; } } } cout << kq << endl; } }
#include <bits/stdc++.h> int main() { long n, k, x, a, y; scanf( %ld %ld , &n, &k); a = n; x = n; while (x >= k) { y = x % k; x = x / k; a = a + x; x = x + y; } printf( %ld n , a); return 0; }
#include <bits/stdc++.h> using namespace std; template <typename T, typename U> inline void smin(T &a, U b) { if (a > b) a = b; } template <typename T, typename U> inline void smax(T &a, U b) { if (a < b) a = b; } int power(int a, int b, int m, int ans = 1) { for (; b; b >>= 1, a = 1LL * a * a % m) if (b & 1) ans = 1LL * ans * a % m; return ans; } const int maxn = 110; int a[maxn]; int arr[maxn * maxn]; int cat[maxn * maxn][maxn]; map<set<int>, int> mp; int top; int recure(set<int> s) { if (s.empty()) return 0; if (mp.count(s)) return mp[s]; int d = (--s.end()); int vis[maxn]; memset(vis, 0, sizeof(vis)); for (int i = 1; i <= d; i++) { set<int> res; for (set<int>::iterator it = s.begin(); it != s.end(); it++) { if (it < i) res.insert(it); else if (it > i) res.insert(it - i); } vis[recure(res)] = 1; } int g; for (int i = 0; i < maxn; i++) if (!vis[i]) { g = i; break; } mp[s] = g; return g; } int main() { int n, Num = 0; cin >> n; for (int i = 0; i < n; i++) scanf( %d , &a[i]); for (int i = 0; i < n; i++) { long long num = 1ll a[i]; for (int j = 2; 1ll * j * j <= num; j++) { if (num % j) continue; while (num % j == 0) num /= j; arr[Num++] = j; } if (num > 1) { arr[Num++] = (int)num; } } sort(arr, arr + Num); Num = unique(arr, arr + Num) - arr; for (int i = 0; i < n; i++) { long long num = 1ll * a[i]; for (int j = 2; 1ll * j * j <= num; j++) { if (num % j) continue; int cnt = 0; while (num % j == 0) num /= j, cnt++; int t = lower_bound(arr, arr + Num, j) - arr; cat[t][cnt] = 1; } if (num > 1) { int t = lower_bound(arr, arr + Num, (int)num) - arr; cat[t][1] = 1; } } int ok = 0; for (int i = 0; i < Num; i++) { set<int> res; res.clear(); for (int j = 1; j < maxn; j++) { if (cat[i][j]) res.insert(j); } ok ^= recure(res); } if (ok) puts( Mojtaba ); else puts( Arpa ); return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 505; int n, now, siz[N], f[N]; bool vis[N]; vector<int> g, ans[N]; inline bool cmp(int x, int y) { return siz[x] < siz[y]; } void divide(int l, int r) { if (l > r) return; cout << 1 << endl << 1 << endl << r - l + 1 << endl; for (int i = l; i <= r; ++i) cout << g[i] << ; cout << endl << now << endl; int x, mid = (l + r) >> 1; cin >> x; if (!x) return; if (l == r) return vis[g[l]] = 1, ans[now].push_back(g[l]); divide(l, mid), divide(mid + 1, r); } int main() { cin >> n, siz[1] = n; for (int i = 2; i <= n; ++i) { cout << 1 << endl << 1 << endl << n - 1 << endl; for (int j = 2; j <= n; ++j) cout << j << ; cout << endl << i << endl; cin >> siz[i]; } for (int i = 1; i <= n; ++i) f[i] = i; sort(f + 1, f + n + 1, cmp); for (int i = 1; i <= n; ++i) { now = f[i]; divide(0, g.size() - 1); for (unsigned i = 0; i < g.size(); ++i) if (vis[g[i]]) g.erase(g.begin() + i--); g.push_back(now); } cout << ANSWER << endl; for (int i = 1; i <= n; ++i) for (int j : ans[i]) cout << i << << j << endl; return 0; }
#include <bits/stdc++.h> using namespace std; long long n, k; long long c[100006], freq[100006], people[100006], h[100006]; long long catche[5005][505]; long long dp(long long left, long long pep) { if (left == 0 \|\| pep == 0) return 0; long long &ans = catche[left][pep]; if (ans != -1) return ans; ans = 0; for (long long j = 1; j <= min(left, k); j++) { ans = max(ans, h[j] + dp(left - j, pep - 1)); } return ans; } int32_t main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); cin >> n >> k; long long ans = 0; long long i, j; for (i = 1; i <= (n * k); i++) { long long x; cin >> x; freq[x]++; } for (i = 1; i <= n; i++) { long long x; cin >> x; people[x]++; } for (i = 1; i <= k; i++) { cin >> h[i]; } for (i = 1; i <= 100005; i++) { if (!people[i]) { continue; } for (j = 0; j <= freq[i]; j++) { for (long long kk = 0; kk <= people[i]; kk++) { catche[j][kk] = -1; } } ans += dp(freq[i], people[i]); } cout << ans << n ; }
#include <bits/stdc++.h> using namespace std; const long long int N = 100005; void solve() { long long int m, n; cin >> n >> m; long long int count = 0; for (long long int i = 1; i <= n; i++) { count += (m + i % 5) / 5; } cout << count << endl; return; } int32_t main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); solve(); return 0; }
#include <bits/stdc++.h> using namespace std; template <class T> bool uin(T &a, T b) { if (a > b) { a = b; return true; } return false; } template <class T> bool uax(T &a, T b) { if (a < b) { a = b; return true; } return false; } const int MAXN = 1100000; vector<int> lft[MAXN], rgt[MAXN]; int leftf[MAXN], anyf[MAXN]; int lc[MAXN], rc[MAXN]; char s[10]; struct TNode { int left, right; int L, R; int maxk; TNode(int L = -1, int R = -1) : left(-1), right(-1), L(L), R(R), maxk(-1e9) {} }; const int MAXT = 2100000; TNode t[MAXT]; int tc = 0; int buildTree(int L, int R) { int node = tc++; t[node] = TNode(L, R); if (R - L == 1) return node; int M = (L + R) / 2; t[node].left = buildTree(L, M); t[node].right = buildTree(M, R); return node; } int getMax(int node, int L, int R) { if (max(L, t[node].L) >= min(R, t[node].R)) return -1e9; if (L <= t[node].L && t[node].R <= R) return t[node].maxk; return max(getMax(t[node].left, L, R), getMax(t[node].right, L, R)); } void setMax(int node, int i, int x) { if (i >= t[node].R \|\| i < t[node].L) return; if (i == t[node].L && i + 1 == t[node].R) { t[node].maxk = x; return; } setMax(t[node].left, i, x); setMax(t[node].right, i, x); t[node].maxk = max(t[t[node].left].maxk, t[t[node].right].maxk); } bool buildAns(int l, int r) { if (anyf[l] > r) return false; for (int x : rgt[l]) { if (x <= leftf[l]) return false; } if (leftf[l] == l) { lc[l] = -1; if (r == l) return true; rc[l] = l + 1; return buildAns(l + 1, r); } lc[l] = l + 1; if (!buildAns(lc[l], leftf[l])) return false; if (leftf[l] == r) return true; rc[l] = leftf[l] + 1; return buildAns(rc[l], r); } void print(int v) { if (v == -1) return; print(lc[v]); printf( %d , v + 1); print(rc[v]); } int main() { ios::sync_with_stdio(false); cin.tie(nullptr); cout.precision(10); cout << fixed; int N, C; scanf( %d%d , &N, &C); bool ok = true; int root = buildTree(0, N); for (int i = 0; i < (int)(C); ++i) { int x, y; scanf( %d%d%s , &x, &y, s); --x; --y; ok &= x < y; if (s[0] == L ) lft[x].push_back(y); else rgt[x].push_back(y); } if (!ok) { cout << IMPOSSIBLE n ; return 0; } for (int i = (int)(N)-1; i >= 0; --i) { leftf[i] = anyf[i] = i; for (int x : lft[i]) { uax(leftf[i], getMax(root, i, x + 1)); } for (int x : rgt[i]) { uax(anyf[i], getMax(root, i, x + 1)); } uax(anyf[i], leftf[i]); setMax(root, i, anyf[i]); } for (int i = 0; i < (int)(N); ++i) lc[i] = rc[i] = -1; if (!buildAns(0, N - 1)) { cout << IMPOSSIBLE n ; return 0; } print(0); printf( n ); return 0; }
#include <bits/stdc++.h> using namespace std; int cnt[15]; string a[100009]; const long long mod = 998244353LL; int main() { int i, len1, len2, n, j; long long p, sum, val; cin >> n; for (i = 1; i <= n; i++) { cin >> a[i]; reverse(a[i].begin(), a[i].end()); cnt[a[i].size()]++; } for (i = 1, val = 0; i <= n; i++) { len2 = a[i].size(); for (len1 = 1; len1 <= 10; len1++) { sum = 0; if (len1 < len2) { for (j = 0, p = 1; j < len1; j++) { sum += p * (a[i][j] - 48); p = (p * 10LL) % mod; sum += p * (a[i][j] - 48); p = (p * 10LL) % mod; } for (j = len1; j < len2; j++) { sum += p * (a[i][j] - 48); sum += p * (a[i][j] - 48); p = (p * 10LL) % mod; } } else { for (j = 0, p = 1; j < len2; j++) { sum += p * (a[i][j] - 48); p = (p * 10LL) % mod; sum += p * (a[i][j] - 48); p = (p * 10LL) % mod; } } val += (sum % mod) * cnt[len1]; val %= mod; } } cout << val << n ; return 0; }
#include <bits/stdc++.h> using namespace std; template <typename T, size_t N> int SIZE(const T (&t)[N]) { return N; } template <typename T> int SIZE(const T(&t)) { return t.size(); } string to_string(char b) { return + string({b}) + ; } string to_string(bool b) { return (b ? true : false ); } string to_string(const string &t, int x1 = 0, int x2 = 1e9) { string ret = ; for (int i = min(x1, SIZE(t)), _i = min(x2, SIZE(t) - 1); i <= _i; ++i) { ret += t[i]; } return + ret + ; } string to_string(const char t) { string ret(t); return to_string(ret); } template <size_t N> string to_string(const bitset<N> &t, int x1 = 0, int x2 = 1e9) { string ret = ; for (int i = min(x1, SIZE(t)), _i = min(x2, SIZE(t) - 1); i <= _i; ++i) { ret += t[i] + 0 ; } return + ret + ; } template <typename T, typename... Coords> string to_string(const T(&t), int x1 = 0, int x2 = 1e9, Coords... C); template <typename T, typename S> string to_string(const pair<T, S>(&t)) { return ( + to_string(t.first) + , + to_string(t.second) + ) ; } template <typename T, typename... Coords> string to_string(const T(&t), int x1, int x2, Coords... C) { string ret = [ ; x1 = min(x1, SIZE(t)); auto e = begin(t); advance(e, x1); for (int i = x1, _i = min(x2, SIZE(t) - 1); i <= _i; ++i) { ret += (i != x1 ? , : ) + to_string(e, C...); e = next(e); } return ret + ] ; } void dbgm() { ; } template <typename T, typename... S> void dbgm(T t, S... s) { cout << to_string(t) << \| ; dbgm(s...); } void dbgs() { ; } template <typename T, typename... S> void dbgs(T t, S... s) { cout << t << ; dbgs(s...); } const long long N = 2e5 + 3, M = 1e9 + 7; int v[N], h[N]; int main() { int n, m; cin >> n >> m; for (int i = 1, _i = n; i <= _i; ++i) { int x; cin >> x; v[i] = x; } sort(v + 1, v + 1 + n); int pt = 0, hans = 0; for (int i = 1, _i = m; i <= _i; ++i) { int x1, x2, y; cin >> x1 >> x2 >> y; if (x1 == 1) { if (x2 == 1e9) { hans++; } else { h[++pt] = x2; } } } m = pt; sort(h + 1, h + 1 + m, greater<int>()); int j = n; int ans = 1e9; for (int i = 1, _i = m + 1; i <= _i; ++i) { while (v[j] > h[i]) { --j; } ans = min(ans, j + max(i - 1, 0)); } dbgs(ans + hans); }
#include <bits/stdc++.h> using namespace std; ifstream fin( fisier.in ); ofstream fout( fisier.out ); int v[1000000], minl[1000000], minr[1000000]; int main() { int n, i; cin >> n; for (i = 1; i <= n; ++i) cin >> v[i]; for (i = 1; i <= n; ++i) minl[i] = min(minl[i - 1] + 1, v[i]); for (i = n; i >= 1; --i) minr[i] = min(minr[i + 1] + 1, v[i]); int res = 0; for (i = 1; i <= n; ++i) res = max(res, min(minr[i], minl[i])); cout << res; return 0; }
#include <bits/stdc++.h> using namespace std; long long dx[] = {1, 0, -1, 0}; long long dy[] = {0, 1, 0, -1}; long long gcd(long long x, long long y) { if (y == 0) return x; else return gcd(y, x % y); } long long expo(long long n, long long m, long long p) { long long r = 1; n = n % p; while (m > 0) { if (m % 2) r = (r * n) % p; n = (n * n) % p; m = m / 2; } return r % p; } bool isPrime(long long n) { if (n <= 1) return false; if (n <= 3) return true; if (n % 2 == 0 \|\| n % 3 == 0) return false; for (long long i = 5; i * i <= n; i = i + 6) if (n % i == 0 \|\| n % (i + 2) == 0) return false; return true; } int32_t main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); ; long long t; cin >> t; long long tc = 1; while (t--) { long long n; cin >> n; if (n == 1) { cout << 1337 << n ; } else if (n == 2) { cout << 11337 << n ; } else if (n == 3) { cout << 111337 << n ; } else { long long m; for (long long i = 1; i <= n; i++) { long long x = (i * (i - 1)) / 2; if (x > n) { m = i - 1; break; } } long long r = n - (m * (m - 1)) / 2; string ans; ans.push_back( 1 ); ans.push_back( 3 ); ans.push_back( 3 ); while (r) { ans.push_back( 7 ); r--; } m -= 2; while (m) { ans.push_back( 3 ); m--; } ans.push_back( 7 ); cout << ans << n ; } } }
#include <bits/stdc++.h> using namespace std; int n, m, x, y, z, k, w, ans; int A[400], B[400]; char c[2]; int main() { scanf( %d , &n); for (int i = (0); i < (n); i++) { scanf( %s%d%d , &c, &x, &y); if (c[0] == M ) { for (int j = (x); j <= (y); j++) A[j]++; } else { for (int j = (x); j <= (y); j++) B[j]++; } } for (int i = (1); i <= (366); i++) ans = max(ans, min(A[i], B[i])); printf( %d n , ans * 2); return 0; }
#include <bits/stdc++.h> using namespace std; const int INF = (int)1e9; struct edge { int u, v; int flow; int cost; edge() {} edge(int u, int v, int f, int c) : u(u), v(v), flow(f), cost(c) {} }; struct MinCostMaxFlow { int N; vector<vector<int> > G; vector<edge> E; int numEdges; vector<int> found, dad; vector<int> dist; MinCostMaxFlow(int N) : N(N), G(N), found(N), dist(N), dad(N), numEdges(0) {} void addEdge(int from, int to, int capacity, int cost) { G[from].push_back(numEdges++); E.push_back(edge(from, to, capacity, cost)); G[to].push_back(numEdges++); E.push_back(edge(to, from, 0, int(-1) * cost)); } bool spfa(int s, int t) { fill(dad.begin(), dad.end(), -1); fill(dist.begin(), dist.end(), INF); fill(found.begin(), found.end(), 0); queue<int> Q; dist[s] = 0; Q.push(s); found[s] = true; while (!Q.empty()) { int u = Q.front(); Q.pop(); if (u == t) continue; for (int i = 0; i < G[u].size(); ++i) { edge &pres = E[G[u][i]]; int v = pres.v; if (pres.flow <= 0) continue; if (dist[u] + pres.cost < dist[v]) { dad[v] = G[u][i]; dist[v] = dist[u] + pres.cost; if (!found[v]) Q.push(v), found[v] = true; } } found[u] = false; } return (dad[t] != -1); } int dfs(int s, int t) { int flow = INF; for (int i = dad[t]; i != -1; i = dad[E[i].u]) { if (E[i].flow < flow) flow = E[i].flow; } for (int i = dad[t]; i != -1; i = dad[E[i].u]) { E[i].flow -= flow; E[i ^ 1].flow += flow; } return flow; } pair<int, int> getMaxFlow(int s, int t) { int totflow = 0; int totcost = 0; while (spfa(s, t)) { int amt = dfs(s, t); totflow += amt; totcost += dist[t] * (int)amt; } return make_pair(totflow, totcost); } }; int main() { int n, m; cin >> n >> m; vector<int> a(n); for (int i = 0; i < n; ++i) cin >> a[i]; MinCostMaxFlow mcmf(n * 2 + m + 2); for (int i = 0; i < n; ++i) { for (int j = i + 1; j < n; ++j) { mcmf.addEdge(i + 1, j + n + 1 + m, 1, (a[i] == a[j] ? 0 : __builtin_popcount(a[j]))); } } for (int i = 0; i < m; ++i) { for (int j = 0; j < n; ++j) { mcmf.addEdge(i + n + 1, j + n + m + 1, 1, __builtin_popcount(a[j])); } mcmf.addEdge(0, i + n + 1, 1, 0); } for (int i = 0; i < n; ++i) { mcmf.addEdge(0, i + 1, 1, 0); mcmf.addEdge(i + n + m + 1, n + m + n + 1, 1, 0); } pair<int, int> ret = mcmf.getMaxFlow(0, n + n + m + 1); vector<int> who(n); for (int i = 1; i <= n + m; ++i) { for (int c : mcmf.G[i]) { edge e = mcmf.E[c]; if (e.flow == 0 && e.v != 0) { who[e.v - n - m - 1] = i - 1; assert(e.u == i); } } } vector<int> last(n, -1); vector<string> fans; for (int i = 0; i < n; ++i) { int f = who[i]; if (f >= n) { stringstream ss; ss << (char)(f - n + a ) << = << a[i] << ; ss << print( << (char)(f - n + a ) << ) ; string tmp; ss >> tmp; fans.push_back(tmp); ss >> tmp; fans.push_back(tmp); last[i] = f - n; } else { if (a[who[i]] == a[i]) { stringstream ss; ss << print( << (char)(last[who[i]] + a ) << ) ; string tmp; ss >> tmp; fans.push_back(tmp); } else { stringstream ss; ss << (char)(last[who[i]] + a ) << = << a[i] << ; ss << print( << (char)(last[who[i]] + a ) << ) ; string tmp; ss >> tmp; fans.push_back(tmp); ss >> tmp; fans.push_back(tmp); } last[i] = last[who[i]]; } } cout << fans.size() << << ret.second << n ; for (string t : fans) cout << t << n ; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { long long int l, r; cin >> l >> r; if (l == r) { cout << l; return 0; } cout << 2 << endl; }
// author: xay5421 // created: Mon May 3 17:34:21 2021 #include<bits/stdc++.h> #define rep(i,a,b) for(int i=(a);i<=(b);++i) #define per(i,a,b) for(int i=(a);i>=(b);--i) using namespace std; typedef long long LL; const LL INFLL=0X3F3F3F3F3F3F3F3FLL; const int N=200005; int n,Q,_w[N],_v[N],id[N],_id[N]; LL _a[N],sw0[N4][18],sv0[N4][18],sw1[N4][18]; void bud(int k1,int k2,int k3,int k4,int k5){ if(k2>k5\|\|k3<k4)return; if(k2==k3){ rep(k,1,17){ if(_w[id[k2]]<(1<<k)){ sw0[k1][k]=_a[id[k2]]_w[id[k2]]; sv0[k1][k]=_a[id[k2]]_v[id[k2]]; } sw1[k1][k]=INFLL; if(_w[id[k2]]>=(1<<(k-1))&&_w[id[k2]]<(1<<k)&&_a[id[k2]]){ sw1[k1][k]=_w[id[k2]]; } } return; } int mid=(k2+k3)>>1; bud(k12,k2,mid,k4,k5),bud(k12+1,mid+1,k3,k4,k5); rep(k,1,17){ sw0[k1][k]=sw0[k12][k]+sw0[k12+1][k]; sv0[k1][k]=sv0[k12][k]+sv0[k12+1][k]; if(sw1[k12][k]<sw0[k12][k-1]+sw1[k12+1][k]){ sw1[k1][k]=sw1[k12][k]; }else{ sw1[k1][k]=sw0[k12][k-1]+sw1[k12+1][k]; } } } void add(int x,int y){ _a[x]+=y; bud(1,1,n,_id[x],_id[x]); } LL rem,vv; int _k; void clip(){ while(_k>0&&(1<<(_k-1))>rem)--_k; } void qry(int k1,int k2,int k3){ if(k2==k3){ LL tt=min(_a[id[k2]],rem/_w[id[k2]]); rem-=tt_w[id[k2]]; vv+=tt_v[id[k2]]; return; } int mid=(k2+k3)>>1; clip(); if(sw0[k1][_k]<=rem){ rem-=sw0[k1][_k]; vv+=sv0[k1][_k]; return; } if(sw1[k1][_k]>rem&&sw0[k1][_k-1]<=rem){ rem-=sw0[k1][_k-1]; vv+=sv0[k1][_k-1]; return; } qry(k12,k2,mid); clip(); qry(k1*2+1,mid+1,k3); } void sol(LL x){ _k=17,rem=x,vv=0; clip(); qry(1,1,n); printf( %lld n ,vv); } int main(){ #ifdef xay5421 freopen( a.in , r ,stdin); #endif scanf( %d%d ,&n,&Q); rep(i,1,n){ scanf( %lld%d%d ,&_a[i],&_w[i],&_v[i]); id[i]=i; } sort(id+1,id+1+n,[&](int x,int y){return _v[x]^_v[y]?_v[x]>_v[y]:_w[x]<_w[y];}); rep(i,1,n)_id[id[i]]=i; bud(1,1,n,1,n); while(Q--){ int t; scanf( %d ,&t); if(t==1){ int x,y; scanf( %d%d ,&x,&y); add(y,x); }else if(t==2){ int x,y; scanf( %d%d ,&x,&y); add(y,-x); }else{ LL x; scanf( %lld ,&x); sol(x); } } return 0; }
#include <bits/stdc++.h> using namespace std; const double EPS = 1e-10; int main() { ios_base::sync_with_stdio(0); cin.tie(0); int ax, ay, bx, by, cx, cy; cin >> ax >> ay >> bx >> by >> cx >> cy; complex<long double> a(ax, ay), b(bx, by), c(cx, cy); long double d1 = abs(b - a), d2 = abs(c - b); long double ang1 = arg(b - a), ang2 = arg(c - b); cout << ((abs(d1 - d2) < EPS && abs(ang1 - ang2) > EPS) ? Yes : No ) << endl; }
#include <bits/stdc++.h> using namespace std; int main() { long long a, b, c; cin >> a >> b >> c; cout << (a / c + (a % c != 0)) * (b / c + (b % c != 0)); return 0; }
#include <bits/stdc++.h> using namespace std; template <typename T> inline void upmin(T &x, T y) { y < x ? x = y : 0; } template <typename T> inline void upmax(T &x, T y) { x < y ? x = y : 0; } const long double pi = acos(-1); const int oo = 1 << 30; const long long OO = 1e18; const int N = 1e5 + 100; int gi() { int w = 0; bool q = 1; char c = getchar(); while ((c < 0 \|\| c > 9 ) && c != - ) c = getchar(); if (c == - ) q = 0, c = getchar(); while (c >= 0 && c <= 9 ) w = w * 10 + c - 0 , c = getchar(); return q ? w : -w; } int w[N]; int p[N]; inline int phi(int n) { int ans = n; for (int i = 2; i <= n; i++) if (!(n % i)) { ans = ans / i * (i - 1); while (!(n % i)) n /= i; } return ans; } inline int mul(int x, int y, int mod) { return 1LL * x * y >= mod ? 1LL * x * y % mod + mod : x * y; } inline int qpow(int x, int y, int mod) { int ans = 1; while (y) { if (y & 1) ans = mul(ans, x, mod); x = mul(x, x, mod); y >>= 1; } return ans; } int main() { int n = gi(), i, Q, m, l, r, ans; p[0] = gi(); for (m = 0; p[m] != 1; p[m + 1] = phi(p[m]), m++) ; p[m + 1] = 1; for (i = 1; i <= n; i++) w[i] = gi(); Q = gi(); while (Q--) { l = gi(), r = gi(); ans = 1; for (i = min(r - l, m); ~i; i--) ans = qpow(w[i + l], ans, p[i]); cout << ans % p[0] << endl; } return 0; }
#include <bits/stdc++.h> int a[100006]; int vis[100006]; int visyu[100006]; int main() { int n, x; scanf( %d%d , &n, &x); for (int i = 1; i <= n; i++) { scanf( %d , &a[i]); vis[a[i]]++; if (vis[a[i]] == 2) { printf( 0 n ); return 0; } } int mans = -1; for (int i = 1; i <= n; i++) { visyu[a[i] & x]++; if (visyu[a[i] & x] && vis[a[i] & x] && ((a[i] & x) != a[i])) { printf( 1 n ); return 0; } else if (visyu[a[i] & x] == 2) { mans = 2; } } printf( %d n , mans); }
#include <bits/stdc++.h> using namespace std; template <typename T> void Read(T &cn) { char c; int sig = 1; while (!isdigit(c = getchar())) if (c == - ) sig = -1; cn = c - 48; while (isdigit(c = getchar())) cn = cn * 10 + c - 48; cn = sig; } template <typename T> void Write(T cn) { if (cn < 0) { putchar( - ); cn = 0 - cn; } int wei = 0; T cm = 0; int cx = cn % 10; cn /= 10; while (cn) wei++, cm = cm 10 + cn % 10, cn /= 10; while (wei--) putchar(cm % 10 + 48), cm /= 10; putchar(cx + 48); } template <typename T> void Max(T &cn, T cm) { cn = cn < cm ? cm : cn; } template <typename T> void Min(T &cn, T cm) { cn = cn < cm ? cn : cm; } struct qwe { long long v, c; void getit() { Read(v); Read(c); } inline friend bool operator<(qwe a, qwe b) { return a.v == b.v ? a.c > b.c : a.v < b.v; } }; struct xian { long long k, b; long long suan(long long cn) { return (cn - b + k - 1) / k; } void mk(long long cn, long long cm) { k = cn; b = cm; } }; qwe a[200100 + 1]; int n; long long m; int xu[200100 + 1], xlen; long long f[200100 + 1], g[200100 + 1]; xian zhan[200100 + 1]; int l, r; int jiao_z(long long cn, xian A, xian B) { return cn * (A.k - B.k) <= (B.b - A.b); } int jiao(xian A, xian B, xian C) { double db1 = (B.b - A.b), db2 = (C.b - B.b); double dk1 = (A.k - B.k), dk2 = (B.k - C.k); return db1 * dk2 >= db2 * dk1; } long long qiu(int cn, int cm) { while (l < r && jiao_z(zhan[l].suan(cn), zhan[l], zhan[l + 1])) l++; if (l > r) return -10000000000000000; return -zhan[l].suan(cn) * (cm - zhan[l].k) - cn + zhan[l].b; } void zeng(int ck, long long cb) { xian lin; lin.mk(ck, cb); while (l < r && jiao(zhan[r - 1], zhan[r], lin)) r--; zhan[++r] = lin; } int main() { Read(n); Read(m); for (int i = 1; i <= n; i++) a[i].getit(); sort(a + 1, a + n + 1); xlen = 0; for (int i = 1; i <= n; i++) { if (a[i].v <= 0) continue; while (xlen && a[xu[xlen]].c > a[i].c) xlen--; xu[++xlen] = i; } for (int i = 1; i <= xlen; i++) a[i] = a[xu[i]]; n = xlen; f[0] = 0; a[0].v = a[0].c = 0; l = 1; r = 0; f[1] = 0; zeng(a[1].v, f[1]); long long ans = (m + a[1].v - 1) / a[1].v; for (int i = 2; i <= n; i++) { f[i] = qiu(a[i].c, a[i].v); zeng(a[i].v, f[i]); Min(ans, (m - f[i] + a[i].v - 1) / a[i].v); } Write(ans); puts( ); return 0; }
#include <bits/stdc++.h> using namespace std; const int maxn = 400010; int c[maxn]; int ans[maxn]; void upd(int n, int k) { n++; while (n < maxn) c[n] += k, n += n & (-n); } int get(int n) { n++; int ans = 0; while (n) ans += c[n], n -= n & (-n); return ans; } int BS(int n) { int l = 0, r = maxn - 1, mid; while (l < r) { mid = (l + r) / 2; if (get(mid) >= n) r = mid; else l = mid + 1; } return l; } int arr[maxn]; int a[maxn], b[maxn]; int main() { int n, i, j, k; cin >> n; for (i = 0; i < n; i++) cin >> a[i]; for (i = 0; i < n; i++) cin >> b[i]; for (i = 0; i < n; i++) upd(i, 1); for (i = 0; i < n; i++) { arr[i] += get(a[i]) - 1; upd(a[i], -1); } for (i = 0; i < n; i++) upd(i, 1); for (i = 0; i < n; i++) { arr[i] += get(b[i]) - 1; upd(b[i], -1); } for (i = n - 1; i >= 0; i--) { if (arr[i] <= n - i - 1) ; else { arr[i] %= n - i; if (i) arr[i - 1]++; } } for (i = 0; i < n; i++) upd(i, 1); for (i = 0; i < n; i++) ans[i] = BS(arr[i] + 1), upd(ans[i], -1); for (i = 0; i < n; i++) cout << ans[i] << ; puts( ); }
#include <bits/stdc++.h> using namespace std; class SegmentTree { public: SegmentTree(int _n) : n(_n), N(_n << 1), data(N, INT_MAX) { h = 0; while (1 << h <= N) { ++h; } } void build(vector<int>& nums) { copy(nums.begin(), nums.end(), data.begin() + n); for (int i = n - 1; i > 0; --i) { data[i] = min(data[i << 1], data[i << 1 \| 1]); } } int get(int l, int r) { l += n; r += n; int res = INT_MAX; while (l <= r) { if (l & 0x1) { res = min(res, data[l++]); } if (!(r & 0x1)) { res = min(res, data[r--]); } l >>= 1; r >>= 1; } return res; } private: int N; int n; int h; vector<int> data; }; class SuffixArray { public: SuffixArray(const string& s) : N(s.length()), st(N + 100) { build(s); } const vector<int>& getSuffixArray() { return sa; } const vector<int>& getIndexArray() { return indices; } const vector<int>& getLcpArray() { return lcp; } long long lcpOf(int l, int r) { if (l == r) { return N - l; } l = indices[l]; r = indices[r]; if (l > r) { swap(l, r); } return st.get(l + 1, r); } private: int N; vector<int> sa; vector<int> indices; vector<int> lcp; SegmentTree st; struct Datum { public: Datum(int i = -1, int k0 = -1, int k1 = -1) : index(i), key0(k0), key1(k1) {} bool operator<(const Datum& other) const { return key0 == other.key0 ? key1 < other.key1 : key0 < other.key0; } int index; int key0; int key1; }; void build(const string& s) { N = s.length(); sa.clear(); sa.resize(N, -1); indices.clear(); indices.resize(N, -1); vector<Datum> data(N); for (int i = 0; i < N; ++i) { data[i].index = i; data[i].key0 = s[i]; } auto update = [&](int gap) { int idx = -1, preKey0 = -1, preKey1 = -1; for (int i = 0; i < N; ++i) { int key0 = data[i].key0, key1 = data[i].key1; if (key0 != preKey0 \|\| key1 != preKey1) { data[i].key0 = ++idx; preKey0 = key0; preKey1 = key1; } else { data[i].key0 = idx; } indices[data[i].index] = i; } for (int i = 0; i < N; ++i) { int j = data[i].index + gap; if (j < N) { data[i].key1 = data[indices[j]].key0; } else { data[i].key1 = -1; } } }; sort(data.begin(), data.end()); int gap = 1; update(gap); while (gap <= N) { sort(data.begin(), data.end()); update(gap <<= 1); } for (int i = 0; i < N; ++i) { sa[i] = data[i].index; indices[sa[i]] = i; } buildLcp(s); } void buildLcp(const string& s) { lcp.clear(); lcp.resize(N, 0); int len = 0; for (int i = 0; i < N; ++i) { int idx = indices[i]; if (idx == 0) { lcp[idx] = 0; len = 0; continue; } int j = sa[idx - 1]; while (i + len < N && j + len < N && s[i + len] == s[j + len]) { ++len; } lcp[idx] = len; if (len > 0) { --len; } } st.build(lcp); } }; class Solution { public: Solution(const string& s) : N(s.length()), sfxArr(s), lcp(N + 1000, make_pair(-1, -1)), cnts(N + 1000, 0), sums(N + 1000, 0LL), S(s) {} long long query(vector<int>& A, int n, vector<int>& B, int m) { const auto& indices = sfxArr.getIndexArray(); auto cmp = [&](int l, int r) { return indices[l] < indices[r]; }; sort(A.begin(), A.begin() + n, cmp); sort(B.begin(), B.begin() + m, cmp); if (n > m) { swap(A, B); swap(n, m); } long long res = 0; int size = 0; long long sum = 0; for (int i = 0, j = 0; i < n \|\| j < m;) { if (j == m) { break; } if (i < n && indices[A[i]] <= indices[B[j]]) { int len = 0; int cnt = 0; if (i == 0) { len = N - A[i]; cnt = 0; } else { len = sfxArr.lcpOf(A[i - 1], A[i]); cnt = 0; while (size > 0) { if (lcp[size - 1].first >= len) { sum -= 1LL * lcp[size - 1].first * lcp[size - 1].second; cnt += lcp[size - 1].second; --size; } else { break; } } } if (cnt > 0) { lcp[size].first = len; lcp[size].second = cnt; sum += 1LL * len * cnt; cnts[size + 1] = cnts[size] + cnt; sums[size + 1] = sum; ++size; } lcp[size].first = N - A[i]; lcp[size].second = 1; sum += N - A[i]; cnts[size + 1] = cnts[size] + 1; sums[size + 1] = sum; assert(cnts[size + 1] == i + 1); ++size; ++i; } else { if (i - 1 >= 0) { int len = sfxArr.lcpOf(A[i - 1], B[j]); auto it = lower_bound(lcp.begin(), lcp.begin() + size, make_pair(len, 0)); int idx = it - lcp.begin() - 1; if (idx < 0) { res += 1LL * len * i; } else { res += sums[idx + 1] + 1LL * len * (i - cnts[idx + 1]); } } ++j; } } size = 0; sum = 0; for (int i = n - 1, j = m - 1; i >= 0 \|\| j >= 0;) { if (j < 0) { break; } if (i >= 0 && indices[A[i]] > indices[B[j]]) { int len = 0; int cnt = 0; if (i == n - 1) { len = N - A[i]; cnt = 0; } else { len = sfxArr.lcpOf(A[i + 1], A[i]); cnt = 0; while (size > 0) { if (lcp[size - 1].first >= len) { sum -= 1LL * lcp[size - 1].first * lcp[size - 1].second; cnt += lcp[size - 1].second; --size; } else { break; } } } if (cnt > 0) { lcp[size].first = len; lcp[size].second = cnt; sum += 1LL * len * cnt; cnts[size + 1] = cnts[size] + cnt; sums[size + 1] = sum; ++size; } lcp[size].first = N - A[i]; lcp[size].second = 1; sum += N - A[i]; cnts[size + 1] = cnts[size] + 1; sums[size + 1] = sum; assert(cnts[size + 1] == n - i); ++size; --i; } else { if (i + 1 < n) { int len = sfxArr.lcpOf(A[i + 1], B[j]); auto it = lower_bound(lcp.begin(), lcp.begin() + size, make_pair(len, 0)); int idx = it - lcp.begin() - 1; if (idx < 0) { res += 1LL * len * (n - i - 1); } else { res += sums[idx + 1] + 1LL * len * (n - i - 1 - cnts[idx + 1]); } } --j; } } return res; } private: int N; string S; SuffixArray sfxArr; vector<pair<int, int>> lcp; vector<int> cnts; vector<long long> sums; void check(vector<int>& A, int n, vector<int>& B, int m, long long res) { long long ans = 0; int N = S.length(); auto LCP = [&](int x, int y) { int res = 0; for (int i = x, j = y; i < N && j < N; ++i, ++j) { if (S[i] == S[j]) { ++res; } else { break; } } return res; }; for (int i = 0; i < n; ++i) { for (int j = 0; j < m; ++j) { int a = A[i], b = B[j]; ans += LCP(a, b); } } if (ans != res) { cout << ERROR: WA << got << res << but expected << ans << endl; } } }; void test() { vector<string> ts = {{ adsfadfqiewruypzdjfquwieroyzsdf , zduoifyqewrjhlzjkdhfvuioqerwy , adsfuiaednbklzjdrfyquioerwyhadnfb , aaaaaaaaaaaaaaa , axaaxadaxaacaaxxaad }}; cout << test << endl; for (auto s : ts) { Solution sol(s); int n = s.length(); vector<int> A(n); iota(A.begin(), A.end(), 0); vector<int> B(n); iota(B.begin(), B.end(), 0); sol.query(A, n, B, n); } } int main(int argc, char** argv) { ios::sync_with_stdio(false); cin.tie(0); int n, q; cin >> n >> q; string s; cin >> s; Solution sol(s); vector<int> A(n + 100); vector<int> B(n + 100); int k, l; while (q-- > 0) { cin >> k >> l; for (int i = 0; i < k; ++i) { cin >> A[i]; --A[i]; } for (int j = 0; j < l; ++j) { cin >> B[j]; --B[j]; } cout << sol.query(A, k, B, l) << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; long long n, l, x, y; long long a[100100]; int main() { cin >> n >> l >> x >> y; for (int i = 0; i < n; i++) cin >> a[i]; bool fx = false, fy = false; for (int i = 0; i < n; i++) { if (binary_search(a, a + n, a[i] + x)) { fx = true; break; } } for (int i = 0; i < n; i++) { if (binary_search(a, a + n, a[i] + y)) { fy = true; break; } } if (fx && fy) { printf( 0 n ); return 0; } if (fx && !fy) { printf( 1 n ); cout << y << endl; return 0; } if (!fx && fy) { printf( 1 n ); cout << x << endl; return 0; } for (int i = 0; i < n; i++) { if (binary_search(a, a + n, a[i] + x + y)) { printf( 1 n ); cout << a[i] + x << endl; return 0; } } for (int i = 0; i < n; i++) { if (binary_search(a, a + n, a[i] + y - x)) { if (a[i] + y > l && a[i] - x < 0) continue; if (a[i] + y <= l) { printf( 1 n ); cout << a[i] + y << endl; } else { printf( 1 n ); cout << a[i] - x << endl; } return 0; } } printf( 2 n ); cout << x << << y << endl; return 0; }
#include <bits/stdc++.h> using namespace std; const int MAX = 500010; int n, m; int seg[MAX]; int vis[MAX]; int p[MAX]; int in[MAX], out[MAX]; int aux = 0; vector<int> adj[MAX]; set<int> s; int main() { ios_base::sync_with_stdio(0); cin.tie(0); int x, s; cin >> x >> s; if (!s) { if (x == 1) cout << 0 0 n ; else cout << -1 -1 n ; return 0; } if (9 * x < s) { cout << -1 -1 n ; return 0; } string sb; int s1 = s; for (int i = 1; i <= x; i++) { if (s > 9) sb += 9 , s -= 9; else if (i == x) sb += 0 + s; else if (s > 1) sb += 0 + (s - 1), s = 1; else sb += 0 ; } reverse(sb.begin(), sb.end()); cout << sb << n ; string st; for (int i = 1; i <= x; i++) { if (s1 >= 9) st += 9 , s1 -= 9; else st += s1 + 0 , s1 = 0; } cout << st << n ; }
#include <bits/stdc++.h> using namespace std; const long long N = 1e5 + 5; long long n, k; long long a[N]; bool check(long double x) { long double ans1 = 0, ans2 = 0; for (long long i = 0; i < n; i++) { if (a[i] > x) ans1 += (long double)(a[i] - x); if (x > a[i]) ans2 += (long double)(x - a[i]); } return ans1 * (100 - k) * 0.01 >= ans2; } int32_t main() { ios_base::sync_with_stdio(0); cin.tie(0); cin >> n >> k; for (long long i = 0; i < n; i++) cin >> a[i]; long double l = min_element(a, a + n), r = max_element(a, a + n) + 1; for (long long i = 0; i < 300; i++) { long double mid = (l + r) / 2; if (check(mid)) l = mid; else r = mid; } cout << fixed << setprecision(12); cout << l << n ; }
#include <bits/stdc++.h> using namespace std; long long a[100000]; int main() { long long n; long long cnt = 0; scanf( %I64d , &n); for (long long i = 0; i < n; i++) { scanf( %I64d , &a[i]); for (long long j = 0; j < i; j++) if (a[j] > a[i]) cnt++; } cout << (cnt % 2 + (cnt / 2) * 4) << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int n; vector<int> v; map<int, int> a, b; int main() { ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0); cin >> n; int m = n / 2; if (n % 2 != 0) { m++; } for (int i = 1; i <= n; i++) { int x, y; cin >> x >> y; a[x]++; if (x != y) { b[y]++; } v.push_back(x); v.push_back(y); } int ans = 1e9; for (int i = 0; i < 2 * n; i++) { int cur = v[i]; int cnt = a[cur]; int need = max(0, m - cnt); if (b[cur] >= need) { ans = min(ans, need); } } if (ans == 1e9) { cout << -1; return 0; } cout << ans; }
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); int n; cin >> n; int arr[n]; int count = 0; int count1 = 0; for (int i = 0; i < n; i++) { cin >> arr[i]; if (arr[i] & 1) { count++; } } int f[n]; int sum = 0; for (int i = 0; i < n; i++) { f[i] = floor(double(arr[i]) / 2); sum += f[i]; } for (int i = 0; i < n; i++) { if (sum == 0) break; if (arr[i] & 1) { sum++; f[i]++; } } for (int i = 0; i < n; i++) { cout << f[i] << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; int mnt[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; int mntl[] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; int main() { int y1, y2, m1, m2, d1, d2, i, j, k, l, ans = 0; scanf( %d:%d:%d , &y1, &m1, &d1); scanf( %d:%d:%d , &y2, &m2, &d2); if (y1 == y2 && m1 == m2) cout << abs(d1 - d2); else { int chk1 = y1 * 365 + m1 * 30 + d1; int chk2 = y2 * 365 + m2 * 30 + d2; if (chk2 < chk1) { int tmp; tmp = y1; y1 = y2; y2 = tmp; tmp = m1; m1 = m2; m2 = tmp; tmp = d1; d1 = d2; d2 = tmp; } for (i = y1 + 1; i < y2; i++) { ans += 365; if (i % 400 == 0 \|\| (i % 4 == 0 && i % 100 != 0)) ans += 1; } if ((y1 % 4 == 0 && y1 % 100 != 0) \|\| (y1 % 400 == 0)) { int lm = 13; if (y1 == y2) lm = m2; for (i = m1 + 1; i < lm; i++) { ans += mntl[i - 1]; } ans += mntl[m1 - 1] - d1 + 1; } else { int lm = 13; if (y1 == y2) lm = m2; for (i = m1 + 1; i < lm; i++) { ans += mnt[i - 1]; } ans += mnt[m1 - 1] - d1 + 1; } if ((y2 % 4 == 0 && y2 % 100 != 0) \|\| (y2 % 400 == 0)) { int lm = 1; if (y1 != y2) { for (i = lm; i < m2; i++) { ans += mntl[i - 1]; } } ans += d2 - 1; } else { int lm = 1; if (y1 != y2) { for (i = lm; i < m2; i++) { ans += mnt[i - 1]; } } ans += d2 - 1; } cout << ans << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; inline void io() { freopen( input.txt , r , stdin); freopen( output.txt , w , stdout); } long long I() { long long a; cin >> a; return a; } void PV(vector<long long> v) { for (long long i = 0; i < (long long)v.size(); i++) cout << v[i] << ; cout << n ; } void PA(long long v[], long long n, long long x = 0) { for (long long i = x; i < n + x; i++) cout << v[i] << ; cout << n ; } void IA(long long a[], long long n, long long x = 0) { for (long long i = x; i < n + x; i++) cin >> a[i]; } const long long N = (2e5) + 7, N1 = 1e9 + 7, MOD = 1e9 + 7, INF = (1e17 + 7); long long fact[N]; long long power(long long a, long long b) { long long k = 1; for (; b; b /= 2, a = a * a % MOD) if (b % 2 == 1) k = k * a % MOD; return k % MOD; } void pre() { fact[0] = 1; for (long long i = 1; i < N; i++) fact[i] = (fact[i - 1] * i) % N1; } void solve() { long long n; cin >> n; long long ans = fact[2 * n] * (power(2, N1 - 2)); ans %= MOD; cout << ans << n ; } signed main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); long long t1 = 1, x0 = 1; pre(); cin >> t1; while (t1--) { solve(); } }
#include <bits/stdc++.h> using namespace std; stack<int> sk; int main() { int T; string s; cin >> T; while (T--) { while (sk.size()) sk.pop(); cin >> s; int cnt = 0; for (int i = 0; i < s.size(); ++i) { if (sk.empty()) { sk.push(s[i] - 0 ); continue; } if (s[i] == 0 && sk.top() == 1) { cnt++; sk.pop(); } else if (s[i] == 1 && sk.top() == 0) { cnt++; sk.pop(); } else sk.push(s[i] - 0 ); } if (cnt % 2) puts( DA ); else puts( NET ); } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int n, m, i, j, k, chng_cnt; cin >> n >> m; int ara1[n + 1], ara2[n + 1], cnt[m + 1], maximizedMin; memset(cnt, 0, sizeof(cnt)); memset(ara1, 0, sizeof(ara1)); memset(ara2, 0, sizeof(ara2)); for (i = 1; i <= n; i++) { cin >> ara1[i]; } maximizedMin = n / m; for (i = 1; i <= n; i++) { if (ara1[i] > m) { ara2[i] = -1; } else { cnt[ara1[i]]++; if (cnt[ara1[i]] <= maximizedMin) { ara2[i] = ara1[i]; } else { ara2[i] = -1; } } } chng_cnt = 0; for (i = 1; i <= m; i++) { if (cnt[i] < maximizedMin) { for (j = 1; j <= n; j++) { if (cnt[i] == maximizedMin) break; if (ara2[j] == -1) { ara2[j] = i; cnt[i]++; chng_cnt++; } } } } for (i = 1; i <= n; i++) { if (ara2[i] == -1) { ara2[i] = ara1[i]; } } printf( %d %d n , maximizedMin, chng_cnt); for (i = 1; i <= n; i++) { if (i == n) printf( %d n , ara2[i]); else printf( %d , ara2[i]); } return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 1111; const int M = 33333; const int INF = 2e9 + 9; int n, m; int s, t; int erased_edge; struct Edge { int u, v, c; Edge() {} Edge(int u, int v, int c) { this->u = u; this->v = v; this->c = c; } int to(int node) { return u ^ node ^ v; } } E[M]; vector<int> a[N]; vector<int> path; vector<int> findPath() { queue<int> Q; vector<int> trace(n + 1, -1); trace[t] = 0; Q.push(t); while (!Q.empty()) { int u = Q.front(); Q.pop(); for (int e : a[u]) if (erased_edge != e) { int v = E[e].to(u); if (trace[v] != -1) continue; trace[v] = e; Q.push(v); } } vector<int> ans; if (trace[s] == -1) return ans; for (int u = s; u != t; u = E[trace[u]].to(u)) { ans.push_back(trace[u]); } return ans; } vector<int> solveOneEdge() { int best = INF; int ans = -1; for (int e : path) { erased_edge = e; if (findPath().empty() && best > E[e].c) { best = E[e].c; ans = e; } } vector<int> res; res.push_back(best); res.push_back(ans); return res; } int timer = 0; int parent_edge[N], parent_cost[N]; int num[N], low[N]; bool containST[N]; void dfs(int u) { ; num[u] = ++timer; low[u] = INF; containST[u] = u == t; for (int e : a[u]) { if (e == erased_edge \|\| e == parent_edge[u]) continue; int v = E[e].to(u); if (num[v]) { ; low[u] = min(low[u], num[v]); } else { parent_edge[v] = e; parent_cost[v] = E[e].c; dfs(v); low[u] = min(low[u], low[v]); containST[u] \|= containST[v]; } } } vector<int> solveTwoEdge() { int best = INF; int ans1 = -1, ans2 = -1; for (int e : path) { erased_edge = e; timer = 0; fill(parent_edge + 1, parent_edge + n + 1, 0); fill(num + 1, num + n + 1, 0); fill(containST + 1, containST + n + 1, 0); parent_edge[s] = -1; ; dfs(s); for (int v = 1; v <= n; ++v) if (v != s && low[v] >= num[v] && containST[v]) { if (best > E[erased_edge].c + parent_cost[v]) { best = E[erased_edge].c + parent_cost[v]; ans1 = erased_edge; ans2 = parent_edge[v]; }; ; } } vector<int> res; res.push_back(best); res.push_back(ans1); res.push_back(ans2); return res; } int main() { ios_base ::sync_with_stdio(0); cin >> n >> m; cin >> s >> t; for (int i = 1; i <= m; ++i) { int u, v, c; cin >> u >> v >> c; E[i] = Edge(u, v, c); a[u].push_back(i); a[v].push_back(i); } ::path = findPath(); ; if (::path.empty()) { cout << 0 << n << 0 << n ; return 0; } vector<int> one = solveOneEdge(); vector<int> two = solveTwoEdge(); int mn = min(one[0], two[0]); if (mn == INF) { cout << -1 n ; return 0; } if (one[0] < two[0]) { cout << one[0] << n << 1 << n << one[1] << n ; return 0; } cout << two[0] << n << 2 << n << two[1] << << two[2] << n ; }
#include <bits/stdc++.h> using namespace std; int main() { long long i, j, k, n, arr[200010]; cin >> n; for (i = 0; i < n; i++) cin >> arr[i]; long long sum = arr[n - 1]; for (i = n - 1; i > 0; i--) { if (arr[i] <= arr[i - 1] && arr[i - 1] != 0) { if (arr[i] == 0) arr[i - 1] = arr[i]; else arr[i - 1] = arr[i] - 1; } sum += arr[i - 1]; } cout << sum; }
#include <bits/stdc++.h> using namespace std; const int MOD = 1e9 + 7; const int SIZE = 1e6 + 10; const int INF = 2147483647; template <class T> void maa(T& x, T y) { if (x < y) x = y; } template <class T> void mii(T& x, T y) { if (x > y) x = y; } int a[SIZE]; int record[SIZE][3], rn; void update_answer(int ll, int rr, int cul) { record[rn][0] = ll; record[rn][1] = rr; record[rn][2] = cul; rn++; } int C, l[SIZE], r[SIZE], c[SIZE], cn, cc_pos[SIZE]; pair<int, int> cc[SIZE]; vector<pair<int, int> > qq; int single_add[SIZE]; int kerker[SIZE]; set<pair<int, int> > singles; pair<int, int> BIT[SIZE][2]; void ins(int x, int v) { pair<int, int> me = make_pair(v, x); for (; x < SIZE; x += x & -x) { if (me > BIT[x][0]) { if (BIT[x][0].second != me.second) { BIT[x][1] = BIT[x][0]; } BIT[x][0] = me; } else if (me > BIT[x][1]) { BIT[x][1] = me; } } } int qq_BIT(int x, int id) { int res = 0; for (; x; x -= x & -x) { if (BIT[x][0].second != id) res = max(res, BIT[x][0].first); else res = max(res, BIT[x][1].first); } return res; } void update_single(int id, int v) { single_add[id] += v; ins(cc_pos[id], single_add[id]); } int get_single_ma(int id) { int it = upper_bound(cc + 1, cc + cn, make_pair(C - c[id], INF)) - cc - 1; if (it) { return qq_BIT(it, cc_pos[id]); } return 0; } pair<int, int> GP(int x, int y) { if (x > y) return make_pair(y, x); return make_pair(x, y); } int an[SIZE]; int main() { int n; scanf( %d%d , &(n), &(C)); vector<pair<int, int> > rain; cn = 1; for (int i = (1); i < (n + 1); ++i) { scanf( %d%d%d , &(l[i]), &(r[i]), &(c[i])); rain.push_back(make_pair(l[i], i)); rain.push_back(make_pair(r[i], -i)); cc[cn++] = make_pair(c[i], i); } sort(cc + 1, cc + cn); for (int i = (1); i < (cn); ++i) cc_pos[cc[i].second] = i; sort((rain).begin(), (rain).end()); rain.push_back(make_pair(2000000000, 0)); int(m); scanf( %d , &m); for (int i = 0; i < (m); ++i) { int(x); scanf( %d , &x); qq.push_back(make_pair(x, i)); } sort((qq).begin(), (qq).end()); map<pair<int, int>, int> pair_add; set<int> now; int zero = 0; int pair_ma = 0; if (rain[0].first) { update_answer(0, rain[0].first, 0); zero += rain[0].first; } for (int i = 0, j; i < 2 * n; i = j) { for (j = i; j < 2 * n && rain[j].first == rain[i].first; j++) { int id = rain[j].second; if (id < 0) { now.erase(-id); } else { now.insert(id); } } if (((int)(now).size()) == 0) { update_answer(rain[i].first, rain[j].first, zero + max(pair_ma, get_single_ma(0))); zero += rain[j].first - rain[i].first; } else if (((int)(now).size()) == 1) { int me = now.begin(); if (c[me] <= C) { int v = single_add[me] + max(get_single_ma(me), kerker[me]); update_answer(rain[i].first, rain[j].first, zero + v); update_single(me, rain[j].first - rain[i].first); maa(pair_ma, v + rain[j].first - rain[i].first); } } else if (((int)(now).size()) == 2) { int me = now.begin(); int you = *now.rbegin(); if (c[me] + c[you] <= C) { update_answer( rain[i].first, rain[j].first, zero + single_add[me] + single_add[you] + pair_add[GP(me, you)]); pair_add[GP(me, you)] += rain[j].first - rain[i].first; maa(pair_ma, single_add[me] + single_add[you] + pair_add[GP(me, you)]); maa(kerker[me], pair_add[GP(me, you)] + single_add[you]); maa(kerker[you], pair_add[GP(me, you)] + single_add[me]); } } } { int it = 0; for (int i = 0; i < (rn); ++i) { while (it < m && record[i][1] - record[i][0] + record[i][2] >= qq[it].first) { an[qq[it].second] = record[i][0] + (qq[it].first - record[i][2]); it++; } } } for (int i = 0; i < (m); ++i) printf( %d n , an[i]); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { long long n, k; cin >> n >> k; string s; cin >> s; if (k == 0) { cout << s; return 0; } if (s.length() == 1) { if (k > 0) { cout << 0 ; return 0; } } if (s[0] != 1 ) { s[0] = 1 ; k--; } for (long long i = 1; i < n; i++) { if (k > 0) if (s[i] != 0 ) { s[i] = 0 ; k--; } } cout << s; }
#include <bits/stdc++.h> using namespace std; int main() { int test; scanf( %d , &test); while (test--) { int fuck; string str; scanf( %d , &fuck); cin >> str; string ans = ; for (auto &x : str) { if ((x - 0 ) % 2 == 1) { ans += x; if (ans.size() == 2) { break; } } } if (ans.size() == 2) { puts(ans.c_str()); continue; } puts( -1 ); } return 0; }
#include <bits/stdc++.h> using namespace std; map<long long, int> MP; int Q = 1; vector<pair<int, int> > adj[500005]; long long C[500005]; set<int> S; int p[500005]; long long pw(int x) { if (!x) return 1LL; if (x & 1) return 2 * pw(x - 1) % 1000000007; long long hf = pw(x / 2); return hf * hf % 1000000007; } int par(int x) { if (p[x] == x) return x; return p[x] = par(p[x]); } int main() { int N, M, K; scanf( %d%d%d , &N, &M, &K); long long X = (1LL << K); for (int i = 1; i <= N; i++) scanf( %lld , &C[i]); for (int i = 0; i < M; i++) { int u, v; scanf( %d%d , &u, &v); long long x = C[u] ^ C[v]; int t = MP[x]; if (!t) { MP[x] = Q; adj[Q].push_back(pair<int, int>(u, v)); Q++; } else { adj[t].push_back(pair<int, int>(u, v)); } } int ans = 0; for (int i = 1; i <= N; i++) p[i] = i; for (int i = 1; i < Q; i++) { int sz = N; for (pair<int, int> j : adj[i]) { int u = j.first, v = j.second; S.insert(u); S.insert(v); if (par(u) != par(v)) { sz--; p[p[v]] = p[u]; } } ans = (ans + pw(sz)) % 1000000007; while (S.size()) { int now = (S.begin()); p[now] = now; S.erase(S.begin()); } } printf( %lld n , ((X - Q + 1) % 1000000007 pw(N) % 1000000007 + ans) % 1000000007); return 0; }
#include <bits/stdc++.h> using namespace std; template <typename T, typename L> bool smax(T &x, L y) { return x < y ? (x = y, true) : false; } struct Q { int p, id; }; int get(int, int); void dfs(int); void sack(int, bool); const int MAXN = 1e5 + 15, LG = 20; int h[MAXN], cnt[MAXN]; int st[MAXN], ft[MAXN], add[MAXN]; int ans[MAXN]; int par[LG][MAXN]; vector<int> adj[MAXN]; vector<Q> node[MAXN]; int n, m; int32_t main() { ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0); cerr << HELLO WORLD :) n ; cin >> n; for (int i = 1; i <= n; i++) { int tmp; cin >> tmp; adj[tmp].push_back(i); } dfs(0); cin >> m; for (int i = 1; i <= m; i++) { int p, v; cin >> v >> p; node[get(v, p)].push_back({p, i}); } sack(0, 0); for (int i = 1; i <= m; i++) cout << ans[i] << ; return cout << n , false; } void dfs(int v) { static int t = 0; st[v] = t++; add[st[v]] = v; for (int i = 1; i < LG; i++) par[i][v] = par[i - 1][par[i - 1][v]]; for (auto u : adj[v]) { h[u] = h[v] + 1; par[0][u] = v; dfs(u); } ft[v] = t; } int get(int v, int p) { int u = v; for (int i = LG - 1; ~i; i--) if (p >> i & 1) u = par[i][u]; return u; } void sack(int v, bool keep) { int id = -1, mx = -1; for (auto u : adj[v]) if (smax(mx, ft[u] - st[u])) id = u; for (auto u : adj[v]) if (u != id) sack(u, 0); if (id != -1) sack(id, 1); for (auto u : adj[v]) if (u != id) for (int i = st[u]; i < ft[u]; i++) cnt[h[add[i]]]++; cnt[h[v]]++; if (v) for (auto u : node[v]) ans[u.id] = cnt[h[v] + u.p] - 1; if (!keep) for (int i = st[v]; i < ft[v]; i++) cnt[h[add[i]]]--; }
#include <bits/stdc++.h> using namespace std; vector<vector<int> > g, tr, comp; vector<int> us, vis, whr, col; void dfs(int v) { us[v] = 1; for (int i = 0; i < g[v].size(); i++) { int j = g[v][i]; if (!us[j]) dfs(j); } vis.push_back(v); return; } void dfstr(int v) { comp[comp.size() - 1].push_back(v); whr[v] = comp.size() - 1; us[v] = 1; for (int i = 0; i < tr[v].size(); i++) { int j = tr[v][i]; if (!us[j]) dfstr(j); } return; } void doit(int v, int c) { us[v] = 1; if ((v & 1) ^ c) col[v / 2] = 1; else col[v / 2] = 0; for (int i = 0; i < g[v].size(); i++) { int j = g[v][i]; if (!us[j]) doit(j, c); } return; } int main() { iostream::sync_with_stdio(0); cin.tie(0), cout.tie(0); int n; cin >> n; vector<string> all(n); vector<pair<string, string> > add(n); for (int i = 0; i < n; i++) { string s, c; cin >> s >> c; all[i] = s.substr(0, 2); add[i].first = s.substr(2, 1); add[i].second = c.substr(0, 1); } g.resize(2 * n); tr.resize(2 * n); for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { if (i == j) continue; if (all[i] + add[i].first == all[j] + add[j].first) { g[2 * i].push_back(2 * j + 1); g[2 * j].push_back(2 * i + 1); tr[2 * j + 1].push_back(2 * i); tr[2 * i + 1].push_back(2 * j); g[2 * i + 1].push_back(2 * j + 1); g[2 * j + 1].push_back(2 * i + 1); tr[2 * i + 1].push_back(2 * j + 1); tr[2 * j + 1].push_back(2 * i + 1); } if (all[i] + add[i].first == all[j] + add[j].second) { g[2 * i].push_back(2 * j); g[2 * j + 1].push_back(2 * i + 1); tr[2 * j].push_back(2 * i); tr[2 * i + 1].push_back(2 * j + 1); } if (all[i] + add[i].second == all[j] + add[j].second) { g[2 * i + 1].push_back(2 * j); g[2 * j + 1].push_back(2 * i); tr[2 * j].push_back(2 * i + 1); tr[2 * i].push_back(2 * j + 1); } if (all[i] + add[i].second == all[j] + add[j].first) { g[2 * i + 1].push_back(2 * j + 1); g[2 * j].push_back(2 * i); tr[2 * j + 1].push_back(2 * i + 1); tr[2 * i].push_back(2 * j); } } } us.resize(2 * n, 0); for (int i = 0; i < 2 * n; i++) { if (!us[i]) { dfs(i); } } us.assign(2 * n, 0); whr.resize(2 * n); for (int i = 2 * n - 1; i >= 0; i--) { int x = vis[i]; if (!us[x]) { comp.emplace_back(vector<int>()); dfstr(x); } } for (int i = 0; i < n; i++) { if (whr[2 * i] == whr[2 * i + 1]) { cout << NO n ; return 0; } } col.resize(n); us.assign(2 * n, 0); reverse(comp.begin(), comp.end()); for (int i = 0; i < comp.size(); i++) { for (int j = 0; j < comp[i].size(); j++) { if (!us[comp[i][j]]) doit(comp[i][j], 1); } } cout << YES n ; for (int i = 0; i < n; i++) { cout << all[i] << (col[i] == 0 ? add[i].first : add[i].second) << n ; } return 0; }
#include <bits/stdc++.h> using namespace std; const long long int conv[][3] = {{1, 2, 3}, {2, 3, 1}, {3, 1, 2}}; void solve(long long int n) { int r = n % 3; if (r != 0) n = (n / 3 + 1) * 3; if (r == 0) r = 2; else r = r - 1; int k = 0; long long int cnt = 3; while (cnt < n) { k++; cnt += 3 * pow(4, k); } cnt -= 3 * pow(4, k); cnt = n - cnt; vector<int> v(k + 1); v[0] = 1; int j; for (int i = 1; i < k + 1; i++) { for (j = 0; j < 4; j++) { cnt -= 3 * pow(4, k - i); if (cnt <= 0) { cnt += 3 * pow(4, k - i); break; } } v[i] = j; } long long int ans = 0; for (int i = 0; i < k + 1; i++) { if (v[i] > 0) { ans += conv[v[i] - 1][r] << (2 * (k - i)); } } printf( %lld n , ans); } int main() { int t; long long int n; scanf( %d , &t); while (t--) { scanf( %lld , &n); solve(n); } return 0; }
#include <bits/stdc++.h> using namespace std; const long long inf = 9.2e18; const int maxn = 1e6 + 70; const int INF = 2.1e9; const int maxm = 1e6 + 70; const int MOD = 1e9 + 7; const double eps = 1e-7; const double PI = acos(-1.0); int n, m, k; vector<int> G[maxn]; int dep[maxn], mind[maxn], dp[maxn]; int dfs(int u) { if (!G[u].size()) { mind[u] = dep[u] - k; dp[u] = 1; return 1; } else { int mx = 0; mind[u] = dep[u]; dp[u] = 0; for (int i = 0; i < G[u].size(); i++) { int v = G[u][i]; dep[v] = dep[u] + 1; int val = dfs(v); mind[u] = min(mind[u], mind[v]); if (mind[v] <= dep[u]) { dp[u] += dp[v]; mx = max(mx, val - dp[v]); } else { mx = max(mx, val); } } return dp[u] + mx; } } int main() { while (cin >> n >> k) { for (int i = 1; i <= n; i++) G[i].clear(); for (int i = 2; i <= n; i++) { int f; scanf( %d , &f); G[f].push_back(i); } dep[1] = 0; int ans = dfs(1); cout << ans << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(0); cin.tie(0); long long n, d, a, b, x, y; cin >> n >> d >> a >> b; pair<long long, long long> arr[n]; for (int i = 0; i < n; i++) { cin >> x >> y; x = a; y = b; arr[i] = {x + y, i + 1}; } sort(arr, arr + n); vector<int> vec; for (int i = 0; i < n; i++) { if (d >= arr[i].first) { d -= arr[i].first; vec.push_back(arr[i].second); } else break; } cout << vec.size() << endl; for (int i = 0; i < vec.size(); i++) cout << vec[i] << ; return 0; }
#include <bits/stdc++.h> using namespace std; long long gcd(long long a, long long b) { if (b == 0) return a; else return gcd(b, a % b); } const int maxn = 5e4 + 9; int p[1009], a[1009]; bool vis[1009]; int dfs(int i) { if (vis[i]) return i; vis[i] = 1; int id = dfs(p[i]); return id; } int main() { int n; cin >> n; for (int i = 1; i <= n; i++) { cin >> p[i]; } for (int i = 1; i <= n; i++) { memset(vis, 0, sizeof(vis)); a[i] = dfs(i); } for (int i = 1; i <= n; i++) { cout << a[i] << ; } cout << endl; return 0; }
#include <bits/stdc++.h> using namespace std; const long long int M = 1e3 + 7; map<long long int, long long int> value, visit; long long int n, m, points[M][M]; long long int bfs(long long int node) { long long int i; for (i = 1; i < n + 1; i++) { if (points[node][i] == 1) { if (value[i] == 0) { value[i] = value[node]; } else if (value[i] != 2 && value[i] != value[node]) return -1; } } return 0; } long long int check() { long long int i, j; for (i = 1; i < n + 1; i++) { for (j = 1; j < n + 1; j++) { if (points[i][j] == 1) { if ((value[i] == 1 && value[j] == 3) \|\| (value[i] == 3 && value[j] == 1)) { return 0; } } } } } int main() { scanf( %lld , &n); scanf( %lld , &m); long long int i, j, a, b, cnta = 0, cntb = 0, cntc = 0; for (i = 0; i < m; i++) { scanf( %lld , &a); scanf( %lld , &b); points[a][b] = 1; points[b][a] = 1; } for (i = 1; i < n + 1; i++) { long long int flag = 1; for (j = 1; j < n + 1; j++) { if (points[i][j] == 0 && i != j) flag = 0; } if (flag == 1) { value[i] = 2; } } for (i = 1; i < n + 1; i++) { for (j = 1; j < n + 1; j++) { if (points[i][j] == 0 && i != j) { if (value[i] == 0 \|\| value[j] == 0) { if (value[i] == 0 && value[j] == 0) { value[i] = 1; value[j] = 3; if (bfs(i) == -1) { printf( No n ); return 0; } if (bfs(j) == -1) { printf( No n ); return 0; } } else if (value[i] == 0) { value[i] = 4 - value[j]; if (bfs(i) == -1) { printf( No n ); return 0; } } else { value[j] = 4 - value[i]; if (bfs(j) == -1) { printf( No n ); return 0; } } } else if (value[i] == value[j]) { printf( No n ); return 0; } } } } if (check() == 0) { printf( No n ); return 0; } printf( Yes n ); for (i = 1; i < n + 1; i++) { if (value[i] == 1) printf( a ); else if (value[i] == 2) printf( b ); else printf( c ); } printf( n ); return 0; }
#include <bits/stdc++.h> using namespace std; const long long N = 1 << 17; const long long MN = N; long long s[MN]; long long m[MN]; long long rr[MN]; bool st[2 * N]; long long tme[2 * N]; long long lz[2 * N]; long long nn; vector<pair<long long, pair<long long, long long> > > manaFull[2 * N]; struct second { long long s, m, r; }; void f1(long long k, long long l, long long r) { for (long long i = l; i <= r; ++i) { if (rr[i]) { manaFull[k].push_back({m[i] / rr[i] + !!(m[i] % rr[i]), {m[i], rr[i]}}); } else { manaFull[k].push_back({1e18, {m[i], rr[i]}}); } } sort(manaFull[k].begin(), manaFull[k].end()); for (long long i = 1; i < manaFull[k].size(); ++i) { manaFull[k][i].second.first += manaFull[k][i - 1].second.first; } for (long long i = (long long)manaFull[k].size() - 1; i > 0; --i) { manaFull[k][i - 1].second.second += manaFull[k][i].second.second; } if (l == r) return; long long mid = (l + r) / 2; f1(k * 2, l, mid); f1(k * 2 + 1, mid + 1, r); } long long getFirstNotFull(long long k, long long t) { long long lo = 0; long long hi = (long long)manaFull[k].size() - 1; long long res = hi + 1; while (lo <= hi) { long long mid = (lo + hi) / 2; if (manaFull[k][mid].first > t) { hi = mid - 1; res = mid; } else { lo = mid + 1; } } return res; } void lol(long long k, long long l, long long r, long long t) { if (l < r && lz[k]) { lz[k] = 0; lz[k * 2] = 1; lz[k * 2 + 1] = 1; tme[k * 2] = tme[k]; tme[k * 2 + 1] = tme[k]; } } bool eka[2 * N]; long long absorbMana(long long k, long long l, long long r, long long x, long long y, long long t) { long long res = 0; if (l > y \|\| r < x) return 0; if (l >= x && r <= y && lz[k]) { long long firstNotFull = getFirstNotFull(k, t - tme[k]); if (firstNotFull != 0) { res += manaFull[k][firstNotFull - 1].second.first; } long long sz = r - l + 1; if (firstNotFull != sz) res += (manaFull[k][firstNotFull].second.second) * (t - tme[k]); if (eka[k]) { eka[k] = 0; res = min(m[k - N], s[k - N] + (t - tme[k]) * rr[k - N]); } lz[k] = 1; tme[k] = t; return res; } lol(k, l, r, t); long long mid = (l + r) / 2; long long q = absorbMana(k * 2, l, mid, x, y, t); long long w = absorbMana(k * 2 + 1, mid + 1, r, x, y, t); if (l >= x && r <= y) { lz[k] = 1; tme[k] = t; } return q + w; } int main() { long long n; ios_base::sync_with_stdio(0); cin.tie(0); cin >> n; nn = n; for (long long i = 0; i < n; ++i) { cin >> s[i] >> m[i] >> rr[i]; lz[i + N] = 1; eka[i + N] = 1; } f1(1, 0, N - 1); long long m; cin >> m; for (long long i = 0; i < m; ++i) { long long t, l, r; cin >> t >> l >> r; cout << absorbMana(1, 0, N - 1, l - 1, r - 1, t) << n ; } }
#include<bits/stdc++.h> #define pb(x) push_back(x) #define all(x) x.begin(), x.end() #define N 200005 #define FIFO ios::sync_with_stdio(false) #define cout3(x, y, z) cout << x << << y << << z << endl #define cout2(x, y) cout << x << << y << endl #define INF (1<<30) #define MOD 1000000007 #define ones(x) __builtin_popcountll(x) #define EPS 1e-6 using namespace std; long double v; map<pair<long double, long double>, long double>memo; long double DP(long double c, long double m, long double p){ //cout3(c, m, p); if(c < EPS && m < EPS)return p; if(memo.find(make_pair(c, m)) != memo.end())return memo[make_pair(c, m)]; long double ans = 0; //chosing c if(c > EPS){ if(c + EPS <= v){ if(m > EPS)ans += c * (1 + DP(0, m + c/2., p + c/2.)); else ans += c * (1 + DP(0, m, p + c)); } else{ if(m > EPS)ans += c * (1 + DP(c - v, m + v/2, p + v/2)); else ans += c * (1 + DP(c - v, m, p + v)); } } if(m > EPS){ if(m + EPS <= v){ if(c > EPS)ans += m * (1 + DP(c + m/2, 0, p + m/2)); else ans += m * (1 + DP(c, 0, p + m)); } else{ if(c > EPS)ans += m * (1 + DP(c + v/2, m - v, p + v/2)); else ans += m * (1 + DP(c, m - v, p + v)); } } if(p > EPS)ans += p; return memo[make_pair(c, m)] = ans; } //string cases[7] = { 2 , 02 , 012 , 0112 , 12 , 102 , 1002 }; int main(){ FIFO; int tc = 0; cin >> tc; while(tc--){ long double c, m, p, ans = 0; cin >> c >> m >> p >> v; memo.clear(); cout << fixed << setprecision(6) << DP(c, m, p) << endl; /* for(int i = 0; i < 7; i++){ double curProp[] = {c, m, p}; bool ok = true; double prop = 1.0; for(int j = 0, id; j < cases[i].size() && ok; j++){ id = cases[i][j] - 0 ; if(curProp[id] == 0)ok = false; else{ prop = curProp[id]; if(curProp[id] <= v){ vector<int>candidates; int len = 0; for(int l = 0; l < 3; l++)if(l != id && curProp[l] != 0)candidates.pb(l); len = candidates.size(); double add = curProp[id]/len; for(int l = 0; l < candidates.size(); l++)curProp[candidates[l]] += add; curProp[id] = 0; } else{ vector<int>candidates; int len = 0; for(int l = 0; l < 3; l++)if(l != id && curProp[l] != 0)candidates.pb(l); len = candidates.size(); double add = v/len; for(int l = 0; l < candidates.size(); l++)curProp[candidates[l]] += add; curProp[id] -= v; } } //for(int l = 0; l < 3; l++)cout << curProp[l] << ; //cout << endl; } //cout2(ok, prop); if(ok)ans += prop cases[i].size(); } cout << ans << endl; */ } }
#include <bits/stdc++.h> using namespace std; const long long mod = 1e9 + 7; const long long mod1 = 998244353; long long power(long long a, long long b) { long long res = 1; while (b > 0) { if (b % 2 == 1) { res = (res * a) % mod; } a = (a * a) % mod; b >>= 1; } return res; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); int t; t = 1; long long lookup[1001][11]; for (int i = 0; i < 1001; i++) { for (int j = 0; j < 11; j++) { lookup[i][j] = 0; } } lookup[0][0] = 0; for (int i = 1; i <= 10; i++) { lookup[1][i] = 1; lookup[0][i] = 1; } for (int i = 1; i <= 1000; i++) { lookup[i][1] = i; lookup[i][0] = 1; } for (int i = 2; i <= 1000; i++) { for (int j = 2; j <= 10; j++) { lookup[i][j] += lookup[i - 1][j] + lookup[i][j - 1]; lookup[i][j] %= mod; } } while (t--) { int n, m; cin >> n >> m; long long ans = 0; long long temp1, temp2, temp3; for (int i = 1; i <= n; i++) { temp1 = n - i + 1; temp1 = lookup[temp1][m]; temp2 = i; temp2 = lookup[temp2][m - 1]; temp3 = (temp1 * temp2) % mod; ans += temp3; ans %= mod; } cout << ans; } }
#include <bits/stdc++.h> #pragma GCC optimize(2) #pragma GCC optimize(3) #pragma GCC optimize( Ofast ) #pragma GCC optimize( inline ) #pragma GCC optimize( -fgcse ) #pragma GCC optimize( -fgcse-lm ) #pragma GCC optimize( -fipa-sra ) #pragma GCC optimize( -ftree-pre ) #pragma GCC optimize( -ftree-vrp ) #pragma GCC optimize( -fpeephole2 ) #pragma GCC optimize( -ffast-math ) #pragma GCC optimize( -fsched-spec ) #pragma GCC optimize( unroll-loops ) #pragma GCC optimize( -falign-jumps ) #pragma GCC optimize( -falign-loops ) #pragma GCC optimize( -falign-labels ) #pragma GCC optimize( -fdevirtualize ) #pragma GCC optimize( -fcaller-saves ) #pragma GCC optimize( -fcrossjumping ) #pragma GCC optimize( -fthread-jumps ) #pragma GCC optimize( -funroll-loops ) #pragma GCC optimize( -fwhole-program ) #pragma GCC optimize( -freorder-blocks ) #pragma GCC optimize( -fschedule-insns ) #pragma GCC optimize( inline-functions ) #pragma GCC optimize( -ftree-tail-merge ) #pragma GCC optimize( -fschedule-insns2 ) #pragma GCC optimize( -fstrict-aliasing ) #pragma GCC optimize( -fstrict-overflow ) #pragma GCC optimize( -falign-functions ) #pragma GCC optimize( -fcse-skip-blocks ) #pragma GCC optimize( -fcse-follow-jumps ) #pragma GCC optimize( -fsched-interblock ) #pragma GCC optimize( -fpartial-inlining ) #pragma GCC optimize( no-stack-protector ) #pragma GCC optimize( -freorder-functions ) #pragma GCC optimize( -findirect-inlining ) #pragma GCC optimize( -fhoist-adjacent-loads ) #pragma GCC optimize( -frerun-cse-after-loop ) #pragma GCC optimize( inline-small-functions ) #pragma GCC optimize( -finline-small-functions ) #pragma GCC optimize( -ftree-switch-conversion ) #pragma GCC optimize( -foptimize-sibling-calls ) #pragma GCC optimize( -fexpensive-optimizations ) #pragma GCC optimize( -funsafe-loop-optimizations ) #pragma GCC optimize( inline-functions-called-once ) #pragma GCC optimize( -fdelete-null-pointer-checks ) using namespace std; const long long maxn = 1005; const long long maxm = 1000005; const long long dd = 998244353; long long n, m; long long a[maxm], sav[maxm], dp[maxn][maxn], col[maxn][maxn], L[maxn], R[maxn]; vector<long long> t[maxn]; struct nod { long long val, pos; } uni[maxm]; inline bool cmp(nod x, nod y) { return x.val < y.val; } inline long long read() { long long ret = 0, f = 1; char ch = getchar(); while (!isdigit(ch)) { if (ch == - ) f = -f; ch = getchar(); } while (isdigit(ch)) { ret = ret * 10 + ch - 0 ; ch = getchar(); } return ret * f; } void scan() { m = read(); n = read(); for (long long k = 1; k <= n; k++) { uni[k].val = read(); uni[k].pos = k; } } void prework() { long long lst = 0; sort(uni + 1, uni + n + 1, cmp); for (long long k = 1; k <= n; k++) { if (uni[k].val != uni[k - 1].val) lst++; sav[uni[k].pos] = lst; } m = lst; long long now = 0; for (long long k = 1; k <= n; k++) if (sav[k] != a[now]) a[++now] = sav[k]; n = now; for (long long k = 1; k <= n; k++) t[a[k]].push_back(k); for (long long k = 1; k <= m; k++) L[k] = t[k][0], R[k] = t[k][t[k].size() - 1]; for (long long k = 1; k <= m; k++) for (long long j = k + 1; j <= m; j++) if ((L[j] <= R[k] && R[k] < R[j]) \|\| (R[j] >= L[k] && L[k] > L[j])) { puts( 0 ); exit(0); } for (long long k = 1; k <= n; k++) { long long now = k; for (long long j = k; j <= n; j++) col[k][j] = a[j] > a[now] ? now : now = j; } } void solve() { for (long long k = 0; k <= n + 1; k++) for (long long j = 0; j <= k; j++) dp[k][j] = 1; dp[0][1] = dp[1][1]; for (long long k = 2; k <= n; k++) { for (long long l = 1; l + k - 1 <= n; l++) { long long r = l + k - 1; long long x = col[l][r], siz = t[a[x]].size(); long long ll = L[a[x]], rr = R[a[x]]; long long ans1 = 0, ans2 = 0, ans3 = 1; for (long long k = l - 1; k < ll; k++) ans1 = (ans1 + dp[l][k] * dp[k + 1][ll - 1]) % dd; for (long long k = r + 1; k > rr; k--) ans2 = (ans2 + dp[k][r] * dp[rr + 1][k - 1]) % dd; dp[l][r] = ans1 * ans2 % dd; for (long long k = 0; k < siz - 1; k++) ans3 = ans3 * dp[t[a[x]][k] + 1][t[a[x]][k + 1] - 1] % dd; dp[l][r] = dp[l][r] * ans3 % dd; } } printf( %lld n , dp[1][n]); } signed main() { scan(); prework(); solve(); return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 1e6 + 7; const int mod = 1e9 + 7; int n, m, f[N], jc[N], njc[N], ans; int qpow(int x, int y) { if (!x) return 0; int res = 1; for (; y; x = 1ll * x * x % mod, y >>= 1) if (y & 1) res = 1ll * res * x % mod; return res; } int ny(int x) { return qpow(x, mod - 2); } int C(int x, int y) { return 1ll * jc[x] * njc[x - y] % mod * njc[y] % mod; } int main() { scanf( %d%d , &n, &m); jc[0] = njc[0] = 1; for (int i = 1, iE = n; i <= iE; i++) jc[i] = 1ll * jc[i - 1] * i % mod, njc[i] = ny(jc[i]); ans = n; f[0] = 1; int sum = 1; for (int i = 1, iE = n - 1; i <= iE; i++) { f[i] = sum, f[i] = 1ll * f[i] * ny(i) % mod, (sum += f[i]) %= mod; if (i >= m) (sum += mod - f[i - m]) %= mod; } for (int i = 0, iE = n - 1; i <= iE; i++) (ans += mod - f[i]) %= mod; ans = 1ll * ans * jc[n - 1] % mod; printf( %d n , ans); return 0; }
#include <bits/stdc++.h> #pragma 03 using namespace std; int main() { cout << INTERCAL n ; return 0; }
#include <bits/stdc++.h> using namespace std; pair<int, int> a[26]; int b[26]; int main() { for (int i = 0; i < 26; i++) a[i].second = i; string s; cin >> s; int d; cin >> d; for (int i = 0; i < int(s.size()); i++) a[int(s[i] - a )].first++; sort(a, a + 26); int tmp = 0; for (int i = 0; i < 26; i++) if (d >= a[i].first) { b[tmp] = a[i].second; tmp++; d -= a[i].first; } bool g; cout << 26 - tmp << endl; for (int i = 0; i < int(s.size()); i++) { g = 1; for (int j = 0; j < tmp; j++) if (int(s[i] - a ) == b[j]) g = 0; if (g) cout << s[i]; } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { long long int res = 0; int a[200005], n, i, mm = INT_MAX; scanf( %d , &n); for (i = 1; i <= n; ++i) { scanf( %d , &a[i]); mm = min(mm, a[i]); } set<int> second; for (i = 1; i <= n; ++i) if (a[i] == mm) second.insert(i); res = 1ll * mm * n; long long int mx = 0; for (i = 1; i <= n; ++i) { if (a[i] == mm) continue; auto it = second.upper_bound(i); if (it != second.end()) mx = max(mx, (long long int)(it - i)); else mx = max(mx, (long long int)(n - i + second.begin())); } res += mx; printf( %lld , res); return 0; }
#include <bits/stdc++.h> using namespace std; int points[11] = {0, 25, 18, 15, 12, 10, 8, 6, 4, 2, 1}; struct T { vector<int> a; string name; T() { for (int i = (1); i <= (55); i++) a.push_back(0); } bool operator<(const T &b) const { return a > b.a; } } ma[1100]; int n, games; map<string, int> name; int main() { cin >> games; while (games--) { int man; cin >> man; for (int i = (1); i <= (man); i++) { string s; cin >> s; int id = name[s]; if (id == 0) { id = name[s] = ++n; ma[id].name = s; } if (i <= 10) ma[id].a[0] += points[i]; ma[id].a[i]++; } } sort(ma + 1, ma + n + 1); cout << ma[1].name << endl; for (int i = (1); i <= (n); i++) swap(ma[i].a[0], ma[i].a[1]); sort(ma + 1, ma + n + 1); cout << ma[1].name << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(0); int n; while (cin >> n) { int pos, val; multimap<int, int> mp1, mp2; while (n--) { cin >> pos >> val; pos < 0 ? mp1.insert(pair<int, int>(pos, val)) : mp2.insert(pair<int, int>(pos, val)); } int min_size = min(mp1.size(), mp2.size()); multimap<int, int>::reverse_iterator it1 = mp1.rbegin(); multimap<int, int>::iterator it2 = mp2.begin(); long long ans = 0; for (int i = 0; i < min_size; ++i, ++it1, ++it2) ans += ((it1->second) + (it2->second)); if (mp1.size() > mp2.size()) ans += (it1->second); if (mp1.size() < mp2.size()) ans += (it2->second); cout << ans << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; const int maxn = 3e5 + 10; vector<int> G[maxn]; int p[maxn], d[maxn], vis[maxn], mx, rt; int find(int x) { if (p[x] != x) p[x] = find(p[x]); return p[x]; } void dfs(int u, int fa, int dep, int tp) { vis[u] = 1; if (dep > mx) { mx = dep; if (!tp) rt = u; } if (tp) p[u] = rt; for (int i = 0; i < G[u].size(); i++) { int v = G[u][i]; if (v != fa) dfs(v, u, dep + 1, tp); } } int main() { int n, m, q, tp, u, v; scanf( %d%d%d , &n, &m, &q); for (int i = 1; i <= n; i++) p[i] = i; for (int i = 1; i <= m; i++) { scanf( %d%d , &u, &v); G[u].push_back(v); G[v].push_back(u); } for (int i = 1; i <= n; i++) if (!vis[i]) { mx = rt = 0; dfs(i, 0, 0, 0); dfs(rt, 0, 0, 1); d[rt] = mx; } while (q--) { scanf( %d , &tp); if (tp == 2) { scanf( %d%d , &u, &v); int fu = find(u), fv = find(v); if (fu != fv) { p[fu] = fv; int t1 = d[fu] / 2 + d[fu] % 2; int t2 = d[fv] / 2 + d[fv] % 2; d[fv] = max(d[fu], d[fv]); d[fv] = max(d[fv], t1 + t2 + 1); } } else { scanf( %d , &u); int fu = find(u); printf( %d n , d[fu]); } } }
#include <bits/stdc++.h> using namespace std; const int Maxn = 1010, Maxm = 20; const unsigned long long Seed = 19990213; const long long Mod = 1000000007; int n, m, cnt, tot1, fst1[Maxn], pre1[Maxn << 1], to1[Maxn << 1], tot2, fst2[Maxm], pre2[Maxm << 1], to2[Maxm << 1], bel[Maxm], tot[Maxm], stat[(1 << 12) + 10][Maxm], cur[Maxm], S, w[Maxm], size[Maxm]; bool vis[Maxn], leaf[Maxm]; long long f[Maxn][Maxm], g[Maxn][(1 << 12) + 10], ans; unsigned long long ha[Maxm]; map<unsigned long long, bool> Hash; vector<int> son[Maxn], sub[Maxm]; int Get() { char ch; int v = 0; bool f = false; while (!isdigit(ch = getchar())) if (ch == - ) f = true; v = ch - 48; while (isdigit(ch = getchar())) v = v * 10 + ch - 48; if (f) return -v; else return v; } void AddE1(int x, int y) { pre1[++tot1] = fst1[x], fst1[x] = tot1, to1[tot1] = y; pre1[++tot1] = fst1[y], fst1[y] = tot1, to1[tot1] = x; } void AddE2(int x, int y) { pre2[++tot2] = fst2[x], fst2[x] = tot2, to2[tot2] = y; pre2[++tot2] = fst2[y], fst2[y] = tot2, to2[tot2] = x; } bool cmp(const int &a, const int &b) { return ha[a] < ha[b] \|\| (ha[a] == ha[b] && size[a] < size[b]); } void Add(long long &x, long long y) { x += y; if (x >= Mod) x -= Mod; } void Calc(int x, int fa) { leaf[x] = true, size[x] = 1; sub[x].clear(); for (int i = fst2[x]; i; i = pre2[i]) if (to2[i] != fa) { Calc(to2[i], x); size[x] += size[to2[i]]; sub[x].push_back(to2[i]); leaf[x] = false; } if (leaf[x]) ha[x] = 666072; else { ha[x] = 0; sort(sub[x].begin(), sub[x].end(), cmp); for (int i = 0; i < sub[x].size(); i++) ha[x] = (ha[x] * Seed + ha[sub[x][i]]) % Mod; ha[x] = ha[x] * 1234 % Mod; } } void Transform(int x, int w, int s) { if (x == cnt + 1) { S = max(S, s); for (int i = 1; i <= cnt; i++) stat[s][i] = cur[i]; return; } else { for (int i = 0; i <= tot[x]; i++) { cur[x] = i; Transform(x + 1, w * (tot[x] + 1), s + i * w); } } } void dfs(int x) { vis[x] = true; son[x].clear(); for (int i = fst1[x]; i; i = pre1[i]) if (!vis[to1[i]]) son[x].push_back(to1[i]), dfs(to1[i]); int len1 = int(son[x].size()); for (int i = 1; i <= m; i++) if (leaf[i]) f[x][i] = 1; else if (len1 > 0) { f[x][i] = 0, cnt = 0, S = 0; int len2 = int(sub[i].size()); for (int j = 0; j <= len2 - 1; j++) { bel[++cnt] = sub[i][j], tot[cnt] = 1; for (; j < len2 - 1 && ha[sub[i][j]] == ha[sub[i][j + 1]] && size[sub[i][j]] == size[sub[i][j + 1]]; j++) tot[cnt]++; } w[1] = 1; for (int j = 2; j <= cnt; j++) w[j] = w[j - 1] * (tot[j - 1] + 1); Transform(1, 1, 0); for (int s = 0; s <= S; s++) g[0][s] = 0; g[0][S] = 1; for (int j = 0; j <= len1 - 1; j++) { int u = son[x][j]; for (int s = 0; s <= S; s++) g[j + 1][s] = g[j][s]; for (int k = 1; k <= cnt; k++) { int v = bel[k]; if (f[u][v]) { for (int s = 0; s <= S; s++) if (stat[s][k]) { Add(g[j + 1][s - w[k]], g[j][s] * f[u][v] % Mod); } } } } f[x][i] = g[len1][0]; } } void solve(int root) { for (int i = 1; i <= n; i++) vis[i] = false; dfs(1); long long res = 0; for (int i = 1; i <= n; i++) { Add(ans, f[i][root]); Add(res, f[i][root]); for (int j = 1; j <= m; j++) f[i][j] = 0; } } int main() { n = Get(); int x, y; for (int i = 1; i <= n - 1; i++) x = Get(), y = Get(), AddE1(x, y); m = Get(); for (int i = 1; i <= m - 1; i++) x = Get(), y = Get(), AddE2(x, y); for (int i = 1; i <= m; i++) { Calc(i, -1); if (!Hash[ha[i]]) { Hash[ha[i]] = true; solve(i); } } cout << ans << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int a[300005]; int lastone[300005]; int nextone[300005]; long long sum[300005]; vector<int> vt[3]; int main() { int n; scanf( %d , &n); for (int i = 1; i <= n; i++) { scanf( %d , &a[i]); sum[i] = sum[i - 1] + a[i]; lastone[i] = (a[i] == 1000) ? i : lastone[i - 1]; } for (int i = n; i >= 1; i--) { nextone[i] = (a[i] == 1000) ? i : nextone[i + 1]; } long long ans = sum[n]; for (int i = 1; i <= n; i++) { long long bonus = sum[i] / 10; long long rem = sum[n] - sum[i]; long long res = sum[i] + rem - min(rem, bonus); ans = min(ans, res); if (a[i] == 2000) { int las = lastone[i]; if (las) { res = sum[las - 1]; bonus = sum[las - 1] / 10; res += a[las] - min(a[las] + 0ll, bonus); bonus -= min(a[las] + 0ll, bonus); bonus += (sum[i] - sum[las]) / 10; res += (sum[i] - sum[las]); rem = sum[n] - sum[i]; res += rem - min(rem, bonus); ans = min(ans, res); } las = nextone[i + 1]; if (las) { res = sum[i]; bonus = sum[i] / 10; res += (sum[las - 1] - sum[i]) - min(sum[las - 1] - sum[i], bonus); bonus -= min(sum[las - 1] - sum[i], bonus); bonus += a[las] / 10; res += a[las]; rem = sum[n] - sum[las]; res += rem - min(rem, bonus); ans = min(ans, res); } } } printf( %lld n , ans); }
#include <bits/stdc++.h> using namespace std; const long long INF = 2000000000000000000; long double eps = 1e-12; long long t, n, m, a; vector<long long> vec; void Stefan() { cin >> n >> m; long long cur = 1; for (int i = 0; i < n; i++) { cin >> a; vec.push_back(a); } if (n > m) { cout << 0; return; } for (int i = 0; i < n; i++) { for (int j = i + 1; j < n; j++) { cur *= abs(vec[i] - vec[j]); cur %= m; if (!cur) { cout << 0; return; } } } cout << cur; } int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); t = 1; while (t) { Stefan(); t--; } }
#include <bits/stdc++.h> using namespace std; #define f first #define s second #define pb push_back #define ar array #define all(x) x.begin(), x.end() #define siz(x) (int)x.size() #define FOR(x, y, z) for(int x = (y); x < (z); x++) #define ROF(x, z, y) for(int x = (y-1); x >= (z); x--) #define F0R(x, z) FOR(x, 0, z) #define R0F(x, z) ROF(x, 0, z) #define trav(x, y) for(auto&x:y) using ll = long long; using vi = vector<int>; using vl = vector<long long>; using pii = pair<int, int>; using vpii = vector<pair<int, int>>; template<class T> inline bool ckmin(T&a, T b) {return b < a ? a = b, 1 : 0;} template<class T> inline bool ckmax(T&a, T b) {return b > a ? a = b, 1 : 0;} mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); const char nl = n ; const int mxN = 2e5 + 10; const int MOD = 1e9 + 7; const long long infLL = 1e18; struct dsu{ int n; vector<int> sz, par; void init(int _n){ n = _n; sz.resize(n); par.resize(n); F0R(i, n) sz[i] = 1, par[i] = i; } int find(int x){ return par[x] = ( x == par[x] ? par[x] : find(par[x])); } void comb(int a, int b) { a=find(a); b=find(b); if(a!=b) {sz[a]+=sz[b]; par[b] = a; } } }; #undef D #define D QWERWQWEQWEQWEQ dsu D; set<ar<int, 3>> pq; int32_t main(){ ios_base::sync_with_stdio(0); cin.tie(0); int n; cin >> n; vector<vi> a(n, vi(n)); vi par(n10); D.init(10n); vector<int> ans(10n); int cnt = n; F0R(i, n){ F0R(j, n){ cin >> a[i][j]; if(i<=j) pq.insert(ar<int, 3>{a[i][j], i, j}); } } while(!pq.empty()){ ar<int, 3> t = pq.begin(); pq.erase(t); if(t[1]==t[2]){ ans[t[1]] = t[0]; } else{ int u = D.find(t[1]), v = D.find(t[2]); if(t[0]==ans[u]) par[v] = u, D.comb(u, v); else if(t[0]==ans[v]) par[u] = v, D.comb(v, u); else { ans[cnt] = t[0]; par[u]=cnt; par[v]=cnt; D.comb(cnt, u); D.comb(cnt, v); cnt++; } } } cout << cnt << nl; F0R(i, cnt){ cout << ans[i] << ; } cout << nl; cout << cnt << nl; F0R(i, cnt-1){ cout << i+1 << << par[i]+1 << nl; } return 0; }
#include <bits/stdc++.h> using namespace std; int n; int main() { cin >> n; const int maxN = n; int r[maxN]; int c[maxN]; int a[maxN][maxN]; for (int i = 0; i < n; i++) { r[i] = 0; for (int j = 0; j < n; j++) { cin >> a[i][j]; r[i] = r[i] + a[i][j]; } } for (int i = 0; i < n; i++) { c[i] = 0; for (int j = 0; j < n; j++) { c[i] = c[i] + a[j][i]; } } int ans = 0; for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { if (c[j] > r[i]) { ans++; } } } cout << ans; return 0; }
#include <bits/stdc++.h> using namespace std; template <typename T> inline T read() { T f = 0, x = 0; char c = getchar(); while (!isdigit(c)) f = c == - , c = getchar(); while (isdigit(c)) x = x * 10 + c - 48, c = getchar(); return f ? -x : x; } namespace run { const int mod = 998244353, N = 1 << 16, inv2 = (mod + 1) / 2; inline int add(int x, int y) { return x + y >= mod ? x - mod + y : x + y; } inline int sub(int x, int y) { return x >= y ? x - y : x + mod - y; } inline int qpow(int x, int y) { int ret = 1; while (y) { if (y & 1) ret = 1LL * x * ret % mod; x = 1LL * x * x % mod, y >>= 1; } return ret; } int inv[17], fac[17], ifac[17]; inline void Getln(int a, int b, int len) { assert(a[0] == 1), b[0] = 0; for (int i = 0; i < len - 1; i++) { int sum = 1LL * a[i + 1] * (i + 1) % mod; for (int j = 0; j < i; j++) sum = sub(sum, 1LL * a[i - j] * (j + 1) % mod * b[j + 1] % mod); b[i + 1] = 1LL * sum * inv[i + 1] % mod; } } inline void Getexp(int a, int b, int len) { assert(a[0] == 0), b[0] = 1; for (int i = 0; i < len - 1; i++) { b[i + 1] = 0; for (int j = 0; j <= i; j++) b[i + 1] = (1LL * (j + 1) * a[j + 1] % mod * b[i - j] + b[i + 1]) % mod; b[i + 1] = 1LL * inv[i + 1] * b[i + 1] % mod; } } inline void fwt_xor(int a, int inv, int limit) { for (int mid = 1; mid < limit; mid <<= 1) for (int i = 0; i < limit; i += (mid << 1)) for (int j = 0; j < mid; j++) { int x = a[i + j], y = a[i + j + mid]; if (inv == -1) x = 1LL inv2 * x % mod, y = 1LL * inv2 * y % mod; a[i + j] = add(x, y), a[i + j + mid] = sub(x, y); } } int a[N], n, f[N], K, C, vis[N]; map<vector<int>, int> mp; vector<int> st[209]; int count[N], tot, top, num[209], r[209], A[209]; int main() { n = read<int>(), K = read<int>(), C = read<int>(); inv[0] = inv[1] = fac[0] = ifac[0] = ifac[1] = 1, count[0] = 0; for (int i = 1; i <= K; i++) fac[i] = 1LL * fac[i - 1] * i % mod; for (int i = 2; i <= K; i++) inv[i] = 1LL * (mod - mod / i) * inv[mod % i] % mod, ifac[i] = 1LL * inv[i] * ifac[i - 1] % mod; for (int i = 1; i < 1 << C; i++) count[i] = count[i >> 1] + (i & 1); int xorsum = 0; for (int i = 0; i < n; i++) xorsum ^= (a[i] = read<int>()); for (int i = 0; i < n; i++) { vector<int> b; for (int j = 0; j <= K; j++) b.push_back(a[i] ^ (a[i] - j)); mp[b]++; } for (map<vector<int>, int>::iterator i = mp.begin(); i != mp.end(); i++) st[++top] = i->first, num[top] = i->second; for (int s = 0; s < 1 << C; s++) { tot = 0; for (int i = 1; i <= top; i++) { int tmp = 0; for (int j = 0; j <= K; j++) tmp = (tmp << 1) \| (count[st[i][j] & s] & 1); if (!vis[tmp]) A[++tot] = tmp, r[tot] = num[i], vis[tmp] = tot; else r[vis[tmp]] += num[i]; } static int c[17], d[17], ret[17]; memset(ret, 0, sizeof ret); for (int i = 1; i <= tot; i++) { for (int j = 0; j <= K; j++) c[j] = (A[i] >> (K - j) & 1) ? mod - ifac[j] : ifac[j]; Getln(c, d, K + 1); for (int j = 0; j <= K; j++) ret[j] = (1LL * d[j] * r[i] + ret[j]) % mod; vis[A[i]] = 0; } Getexp(ret, c, K + 1), f[s] = 1LL * c[K] * fac[K] % mod; } fwt_xor(f, -1, 1 << C); int p = qpow(qpow(n, K), mod - 2); for (int i = 0; i < 1 << C; i++) printf( %lld , 1LL * f[i ^ xorsum] * p % mod); return 0; } } // namespace run int main() { return run::main(); }
#include <bits/stdc++.h> using namespace std; int n, m, dx, dy; int a[1000001]; int cnt[1000000] = {}; bool vis[1000000] = {}; inline int gcd(int a, int b) { while (b) a %= b, swap(a, b); return a; } int main() { ios_base::sync_with_stdio(false); cin >> n >> m >> dx >> dy; int g = gcd(dx, dy); dx /= g, dy /= g; a[0] = 0; int x = 0, y = 0; for (int i = 1; i <= n; ++i) { x += dx; if (x >= n) x -= n; y += dy; if (y >= n) y -= n; a[x] = y; } for (int i = 0; i < (int)(m); ++i) { cin >> x >> y; int c = y - a[x]; if (c < 0) c += n; ++cnt[c]; } int best = -1, bestind = -1; int delta = a[n]; for (int i = 0; i < (int)(n); ++i) if (!vis[i]) { int cur = 0; int j = i; while (!vis[j]) { vis[j] = true; cur += cnt[j]; j += delta; } if (cur > best) { best = cur; bestind = i; } } cout << 0 << << bestind << n ; return 0; }
#include <bits/stdc++.h> using namespace std; template <class T> inline T checkmin(T &a, T b) { return (a < b) ? a : a = b; } template <class T> inline T checkmax(T &a, T b) { return (a > b) ? a : a = b; } template <class T> T GCD(T a, T b) { if (a < 0) return GCD(-a, b); if (b < 0) return GCD(a, -b); return (a == 0) ? b : GCD(b % a, a); } template <class T> T LCM(T a, T b) { if (a < 0) return LCM(-a, b); if (b < 0) return LCM(a, -b); return (a == 0 \|\| b == 0) ? 0 : a / GCD(a, b) * b; } template <class T> inline T sqr(T X) { return X * X; } namespace Poor { const int MaxiN = 100005; const int LogMaxiN = 18; const int CharSet = 256; int N; char St[MaxiN]; long long Ra[CharSet]; long long X[LogMaxiN][MaxiN]; int SA[MaxiN], H[MaxiN]; int LCP(int A, int B) { int Rec = A; for (int j = LogMaxiN - 1; j >= 0; --j) if (A + (1 << j) <= N && B + (1 << j) <= N && X[j][A] == X[j][B]) { A += (1 << j); B += (1 << j); } return A - Rec; } bool Cmp(int A, int B) { int L = LCP(A, B); return A + L == N \|\| (B + L < N && St[A + L] < St[B + L]); } long long Solve(int L, int R, int C) { int Len = LCP(SA[L], SA[R]); long long res = (long long)(R - L + 1) * (R - L + 2) / 2LL * (long long)(Len - C); if (L == R) return res; if (LCP(SA[L], SA[L]) == Len) return res + Solve(L + 1, R, Len); if (LCP(SA[R], SA[R]) == Len) return res + Solve(L, R - 1, Len); int l = L, r = R; while (l < r) { int mid = (l + r + 1) >> 1; if (LCP(SA[L], SA[mid]) > Len) l = mid; else r = mid - 1; } res += Solve(L, l, Len) + Solve(l + 1, R, Len); return res; } void Run() { srand(time(NULL)); gets(St); N = strlen(St); for (int i = 0; i < CharSet; ++i) Ra[i] = (long long)rand() + (((long long)rand()) << 32LL); for (int i = 0; i < N; ++i) X[0][i] = Ra[(int)St[i]]; for (int j = 0; j < LogMaxiN - 1; ++j) for (int i = 0; i < N - (1 << j); ++i) X[j + 1][i] = (X[j][i] * Ra[j + 1]) ^ (X[j][i + (1 << j)]); for (int i = 0; i < N; ++i) SA[i] = i; sort(SA, SA + N, Cmp); cout << Solve(0, N - 1, 0) << endl; } } // namespace Poor int main() { Poor::Run(); return 0; }
#include <bits/stdc++.h> using namespace std; bool ansnull(int a, int b, int c, int d) { int ans = 0; if (a != 0) ++ans; if (b != 0) ++ans; if (c != 0) ++ans; if (d != 0) ++ans; if (ans >= 2) return true; else return false; } int main() { int a[100010][5]; int n, k; cin >> n >> k; for (int i = 0; i <= n; ++i) for (int j = 1; j <= 4; ++j) a[i][j] = 0; for (int i = 1; i <= n; ++i) for (int j = 1; j <= k; ++j) cin >> a[i][j]; vector<int> v(20, 0); for (int i = 1; i <= n; ++i) { int sum = 0; for (int j = 1; j <= 4; ++j) { sum += a[i][j] * (1 << (4 - j)); } v[sum]++; } if (v[0] != 0) { cout << YES ; return 0; } if (ansnull(v[1], v[2], v[4], v[8])) { cout << YES ; return 0; } int ind = -1; for (int i = 0; i <= 3; ++i) if (v[(1 << i)] != 0) ind = (1 << i); if (ansnull(v[12], v[3], 0, 0)) { cout << YES ; return 0; } if (ansnull(v[6], v[9], 0, 0)) { cout << YES ; return 0; } if (ansnull(v[5], v[10], 0, 0)) { cout << YES ; return 0; } if (ind != -1) { if (v[15 - ind] != 0) { cout << YES ; return 0; } if (ind == 1) { if (v[12] != 0 \|\| v[6] != 0 \|\| v[10] != 0) { cout << YES ; return 0; } } if (ind == 2) { if (v[12] != 0 \|\| v[9] != 0 \|\| v[5] != 0) { cout << YES ; return 0; } } if (ind == 4) { if (v[9] != 0 \|\| v[3] != 0 \|\| v[10] != 0) { cout << YES ; return 0; } } if (ind == 8) { if (v[6] != 0 \|\| v[3] != 0 \|\| v[5] != 0) { cout << YES ; return 0; } } } cout << NO ; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { long long a, b, c, k; cin >> a >> b >> c >> k; if (k >= a + b + c - 3) { cout << a * b * c << endl; } else { long long res = 1; for (int x1 = 0; x1 < a; x1++) { long long help = (-k + x1) / (-2); for (int n = -1; n < 1; n++) { long long x2 = min(min(help + n, b - 1), k - x1); long long x3 = min(k - x1 - x2, c - 1); res = max(res, (1 + x1) * (1 + x2) * (1 + x3)); } } for (int x1 = 0; x1 < a; x1++) { long long help = (-k + x1) / (-2); for (int n = -1; n < 1; n++) { long long x2 = min(min(help + n, c - 1), k - x1); long long x3 = min(k - x1 - x2, b - 1); res = max(res, (1 + x1) * (1 + x2) * (1 + x3)); } } cout << res << endl; } }
#include <bits/stdc++.h> using namespace std; int main() { int n, i, j; scanf( %d , &n); int arr[n]; for (i = 0; i < n; i++) scanf( %d , &arr[i]); int t = 0; int index = -1; for (i = 0; i < n; i++) if (arr[i] - arr[(i + 1) % n] > 0) { t++; index = i; } if (t > 1) { cout << -1 n ; return 0; } if (index == -1) cout << 0 n ; else cout << (n - index - 1) << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; for (int i = 0; i < n; ++i) { int x; cin >> x; cout << x - !(x & 1) << ; } }
#include <bits/stdc++.h> using namespace std; struct node { int x, y, z; }; node q[200001]; int n, m; bool ok[2][100001]; char s[100005]; int main(void) { scanf( %d %d , &n, &m); for (int i = 0; i < 2; ++i) { scanf( %s , s + 1); for (int j = 1; j <= n; ++j) if (s[j] == - ) ok[i][j] = true; } bool flag = false; q[1].x = 0; q[1].y = 1; q[1].z = 0; int h = 1, e = 1; ok[0][1] = false; while (h <= e) { node p = q[h]; ++h; int i = p.x, j = p.y, k = p.z; if (j <= k) continue; if ((j + 1 > n) \|\| (j + m > n)) { flag = true; break; } if (ok[i][j + 1]) { ++e; q[e].x = i; q[e].y = j + 1; q[e].z = k + 1; ok[i][j + 1] = false; } if (ok[i ^ 1][j + m]) { ++e; q[e].x = i ^ 1; q[e].y = j + m; q[e].z = k + 1; ok[i ^ 1][j + m] = false; } if (ok[i][j - 1]) { ++e; q[e].x = i; q[e].y = j - 1; q[e].z = k + 1; ok[i][j - 1] = false; } } if (flag) printf( YES n ); else printf( NO n ); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int t, n, cnt[2000000]; scanf( %d , &n); for (int i = 0; i < 2000000; ++i) cnt[i] = 0; for (int i = 0; i < n; ++i) { scanf( %d , &t); cnt[t]++; } long long ans = 0; for (int i = 0; i < 2000000 - 1; ++i) { cnt[i + 1] += cnt[i] / 2; if (cnt[i] % 2) ++ans; } cout << ans << endl; }
#include <bits/stdc++.h> #pragma GCC optimize( Ofast,no-stack-protector,unroll-loops,fast-math ) #pragma GCC target( sse,sse2,sse3,ssse3,sse4.1,sse4.2,avx,avx2,popcnt,tune=native ) using namespace std; namespace _c { const double pi = acos(-1.0); namespace min { const int i8 = -128; const int i16 = -32768; const int i = -2147483647 - 1; const long long l = -9223372036854775807LL - 1; } // namespace min namespace max { const int i8 = 127; const int i16 = 32767; const int i = 2147483647; const long long l = 9223372036854775807LL; } // namespace max } // namespace _c namespace _f { template <typename T> inline const T gcd(T m, T n) { while (n != 0) { T t = m % n; m = n; n = t; } return m; } template <typename T> inline const T max(const T &a, const T &b) { return a > b ? a : b; } template <typename T> inline const T min(const T &a, const T &b) { return a < b ? a : b; } template <typename T> inline const T abs(const T &a) { return a > 0 ? a : -a; } template <typename T> inline T pow(T a, T b) { T res = 1; while (b > 0) { if (b & 1) { res = res * a; } a = a * a; b >>= 1; } return res; } template <typename T> inline T pow(T a, T b, const T &m) { a %= m; T res = 1; while (b > 0) { if (b & 1) { res = res * a % m; } a = a * a % m; b >>= 1; } return res % m; } } // namespace _f namespace io { template <typename T> inline void read(T &t) { register T res = 0, neg = 1; char g = getchar(); for (; !isdigit(g); g = getchar()) { if (g == - ) { neg = -1; } } for (; isdigit(g); g = getchar()) { res = res * 10 + g - 0 ; } t = res * neg; } inline int in() { register int T; read(T); return T; } inline long long in_ll() { register long long T; read(T); return T; } } // namespace io int Ans, T(2), x[11000], y[11000], z[11000], r[11000], f[11000], F[11000], s[1100000], b[11000], n, m, t[11000], c[11000], K, q[11000], Q[11000]; void In(int a, int b, int c, int d) { x[T] = f[a]; y[T] = b; z[T] = c; r[T] = d; f[a] = T++; x[T] = f[b]; y[T] = a; z[T] = 0; r[T] = -d; f[b] = T++; } int main() { int i, j, k; scanf( %d%d , &n, &K); for (i = 0; i < n; i++) { scanf( %d%d%d , s + i, t + i, c + i); t[i] += s[i]; q[m++] = s[i]; q[m++] = t[i]; } q[m++] = -1; std::sort(q, q + m); for (i = j = 1; i < m; i++) if (q[i] != q[j - 1]) q[j++] = q[i]; m = j; for (i = 0; i + 1 < m; i++) In(i, i + 1, K, 0); for (i = 0; i < n; i++) { for (j = 0; j < m; j++) if (q[j] == s[i]) break; s[i] = j; for (j = 0; j < m; j++) if (q[j] == t[i]) break; t[i] = j; Q[i] = T; In(s[i], t[i], 1, -c[i]); } s[0] = 0; for (;;) { memset(b, 127, sizeof(b)); b[0] = 0; for (i = 0, j = 1; i < j; i++) for (k = f[s[i]]; k; k = x[k]) if (z[k] && b[s[i]] + r[k] < b[y[k]]) { b[y[k]] = b[s[i]] + r[k]; F[y[k]] = k; s[j++] = y[k]; } if (b[m - 1] == 2139062143) break; j = 2139062143; for (i = m - 1; i; i = y[F[i] ^ 1]) if (j > z[F[i]]) j = z[F[i]]; for (i = m - 1; i; i = y[F[i] ^ 1]) { Ans += j * r[F[i]]; z[F[i]] -= j; z[F[i] ^ 1] += j; } } for (i = 0; i < n; i++) if (z[Q[i]]) printf( 0 ); else printf( 1 ); printf( n ); return 0; }
#include <bits/stdc++.h> using namespace std; auto random_address = [] { char p = new char; delete p; return (uint64_t)p; }; mt19937 rng(chrono::steady_clock::now().time_since_epoch().count() (random_address() \| 1)); const int INF = 1e9 + 5; struct edge { int a, b, color, index; }; int N, M, K; vector<edge> edges; vector<vector<int>> color_count; void set_color(edge &e, int color) { color_count[e.a][e.color]--; color_count[e.b][e.color]--; e.color = color; color_count[e.a][e.color]++; color_count[e.b][e.color]++; } bool fix() { vector<int> minimum(N, INF), maximum(N, 0); for (int i = 0; i < N; i++) for (int k = 0; k < K; k++) { minimum[i] = min(minimum[i], color_count[i][k]); maximum[i] = max(maximum[i], color_count[i][k]); } bool change = false; for (edge &e : edges) if ((maximum[e.a] - minimum[e.a] > 2 && color_count[e.a][e.color] == maximum[e.a]) \|\| (maximum[e.b] - minimum[e.b] > 2 && color_count[e.b][e.color] == maximum[e.b])) { set_color(e, rng() % K); change = true; } return change; } int main() { cin >> N >> M >> K; color_count.assign(N, vector<int>(K, 0)); for (int i = 0; i < N; i++) { int _; cin >> _; } edges.resize(M); for (int i = 0; i < M; i++) { edge &e = edges[i]; cin >> e.a >> e.b; e.a--; e.b--; e.index = i; e.color = rng() % K; color_count[e.a][e.color]++; color_count[e.b][e.color]++; } bool bad; do { shuffle(edges.begin(), edges.end(), rng); bad = false; while (fix()) bad = true; } while (bad); vector<int> answers(M); for (edge &e : edges) answers[e.index] = e.color + 1; for (int i = 0; i < M; i++) cout << answers[i] << n ; }
#include <bits/stdc++.h> using namespace std; #pragma GCC diagnostic warning -Wall int main() { int n; scanf( %d , &n); vector<vector<int> > sec(n); for (typeof(n) i = (0); i < (n); i++) { int k; scanf( %d , &k); sec[i].resize(k); for (typeof(k) j = (0); j < (k); j++) scanf( %d , &sec[i][j]); sort((sec[i]).begin(), (sec[i]).end()); } int count = 0; for (typeof(n) i = (0); i < (n); i++) { int k = int(sec[i].size()); if (not k) continue; int lasth = sec[i][0]; ; int l = (i - 1 + n) % n; int r = (i + 1) % n; for (typeof(k) j = (1); j < (k); j++) { int nl = lower_bound((sec[l]).begin(), (sec[l]).end(), sec[i][j]) - lower_bound((sec[l]).begin(), (sec[l]).end(), lasth); int nr = lower_bound((sec[r]).begin(), (sec[r]).end(), sec[i][j]) - lower_bound((sec[r]).begin(), (sec[r]).end(), lasth); if (nl != nr) count++; lasth = sec[i][j]; } } printf( %d n , count); }
#include <bits/stdc++.h> using namespace std; int main() { long long n, g; cin >> n >> g; vector<long long> v, ans; map<long long, long long> m; map<long long, long long>::iterator it; for (int i = 0; i < n; i++) { long long a; cin >> a; m[a]++; } for (it = m.begin(); it != m.end(); ++it) { v.push_back(it->second); } long long s1 = 0; for (int i = 0; i < v.size() - 1; i++) { long long s = 0; for (int j = i + 1; j < v.size(); j++) { s += v[j]; } s1 += s * v[i]; } cout << s1 << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(0), cout.tie(0); cout << fixed << setprecision(15); int N, M, S, K; cin >> N >> M >> S >> K; vector<int> type(N); for (int i = 0; i < N; i++) { cin >> type[i]; --type[i]; } vector<vector<int>> adj(N); for (int i = 0; i < M; i++) { int u, v; cin >> u >> v; adj[u - 1].push_back(v - 1); adj[v - 1].push_back(u - 1); } vector<vector<int>> opt(N); for (int tp = 0; tp < S; tp++) { vector<int> dist(N, -1); queue<pair<int, int>> q; for (int i = 0; i < N; i++) { if (type[i] == tp) { q.push({i, 0}); dist[i] = 0; } } while (!q.empty()) { int loc = q.front().first; int tot = q.front().second; q.pop(); for (int nbr : adj[loc]) { if (dist[nbr] != -1) continue; dist[nbr] = tot + 1; q.push({nbr, tot + 1}); } }; ; for (int i = 0; i < N; i++) { opt[i].push_back(dist[i]); } } for (int i = 0; i < N; i++) { sort((opt[i]).begin(), (opt[i]).end()); int ans = 0; for (int j = 0; j < K; j++) { ans += opt[i][j]; } cout << ans << ; } cout << endl; return 0; }

#include <bits/stdc++.h> using namespace std; int n, flag = 0; int matrix[2505][2505]; int parent[2505]; vector<int> graph[2505]; int vis[2505], num[2505]; struct Edge { int u, v, w; Edge() {} Edge(int u, int v, int w) : u(u), v(v), w(w) {} }; vector<Edge> edge; bool cmp(const Edge &a, const Edge &b) { return a.w < b.w; } void init() { for (int i = 1; i <= 2505; i++) parent[i] = i; } void input() { for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { scanf( %d , &matrix[i][j]); if (i == j && matrix[i][j] != 0) flag = 1; if (i > j && matrix[i][j] != matrix[j][i]) flag = 1; if (i < j) edge.push_back(Edge(i, j, matrix[i][j])); } } } int findfather(int x) { if (x == parent[x]) return x; return parent[x] = findfather(parent[x]); } void Union(int x, int y) { int rx = findfather(x); int ry = findfather(y); if (rx > ry) swap(rx, ry); if (rx != ry) parent[ry] = rx; } void Krukal() { sort(edge.begin(), edge.end(), cmp); int cnt = 0; for (int i = 0; i < edge.size(); i++) { int u = edge[i].u; int v = edge[i].v; int ru = findfather(u); int rv = findfather(v); if (ru != rv) { graph[u].push_back(v); graph[v].push_back(u); cnt++; Union(u, v); } if (cnt == n - 1) break; } } void dfs(int u, int fa, int tmp) { vis[u] = 1; for (int i = 0; i < graph[u].size(); i++) { int k = graph[u][i]; if (vis[k]) continue; if (k == fa) continue; num[k] = max(tmp, matrix[u][k]); dfs(k, u, num[k]); } } int main() { scanf( %d , &n); init(); input(); if (flag) { printf( NOT MAGIC n ); return 0; } Krukal(); for (int i = 1; i <= n; i++) { memset(vis, 0, sizeof(vis)); dfs(i, -1, 0); for (int j = i + 1; j <= n; j++) { if (num[j] != matrix[i][j]) { flag = 1; break; } } if (flag) break; } if (flag) printf( NOT MAGIC n ); else printf( MAGIC n ); return 0; }

#include <bits/stdc++.h> using namespace std; int main() { int already = 0; int n, k; cin >> n >> k; int ans = 0; for (int i = 0; i < k; ++i) { int cnt; cin >> cnt; int first; cin >> first; if (first == 1) { int good = 1; already = 1; --ans; while (good < cnt) { cin >> first; if (first == good + 1) { ++good; already = good; --ans; } else { ++good; break; } } ans += cnt; while (good < cnt) { cin >> first; ++good; } } else { ans += (cnt - 1); for (int j = 1; j < cnt; ++j) cin >> first; } } ans += (n - already); cout << ans; return 0; }

#include <bits/stdc++.h> using namespace std; long long t, x, y, p, q; bool check(long long mid) { long long pp = p * mid; long long qq = q * mid; if (pp - x < 0 || qq - y < 0) return false; return (pp - x <= qq - y); } int main() { scanf( %lld , &t); while (t--) { scanf( %lld %lld %lld %lld , &x, &y, &p, &q); if (x * q == p * y) { printf( 0 n ); continue; } long long lo = 1, hi = 2000000000; while (lo + 1 < hi) { long long mid = (lo + hi) / 2LL; if (check(mid)) hi = mid; else lo = mid; } if (check(lo)) hi = lo; if (check(hi)) printf( %lld n , hi * q - y); else printf( -1 n ); } return 0; }

#include <bits/stdc++.h> using namespace std; int main() { int t, i, x; cin >> t; while (t--) { int angle; cin >> angle; x = 360 % (180 - angle); if (x == 0) { cout << YES << endl; } else cout << NO << endl; } return 0; }

#include <bits/stdc++.h> using namespace std; long long M = 1e9 + 7; const int N = 3e5 + 7; const int K = 5e3 + 7; int n, k; int a[N]; int dp[K][K]; int main() { scanf( %d%d , &n, &k); for (int i = 1; i <= n; i++) scanf( %d , &a[i]); sort(a + 1, a + n + 1); int top = (n + k - 1) / k; int low = n / k; int ctop = n % k; int clow = k - ctop; for (int i = 0; i < K; i++) for (int j = 0; j < K; j++) dp[i][j] = -1; dp[0][0] = 0; for (int i = 0; i <= ctop; i++) for (int j = 0; j <= clow; j++) if (i || j) { dp[i][j] = 2e9 + 7; int pnt = i * top + j * low; if (j) dp[i][j] = dp[i][j - 1] + a[pnt] - a[pnt - low + 1]; if (i) dp[i][j] = min(dp[i][j], dp[i - 1][j] + a[pnt] - a[pnt - top + 1]); } cout << dp[ctop][clow]; return 0; }

#include <bits/stdc++.h> using namespace std; int main() { int h1, t1, h2, t2, ansh, anst; scanf( %2d:%2d , &h1, &t1); scanf( %2d:%2d , &h2, &t2); if (t1 < t2) { h1--, t1 += 60; } anst = t1 - t2; ansh = h1 - h2; if (ansh < 0) ansh += 24; printf( %02d:%02d n , ansh, anst); return 0; }

#include <bits/stdc++.h> int n; int a[105], l[105]; int id[105]; int dp[105][105][2]; int main() { scanf( %d , &n); for (int i = 0; i < (int)(n); ++i) scanf( %d %d , &a[i], &l[i]); for (int i = 0; i < (int)(n); ++i) id[i] = i; std::sort(id, id + n, [&](int x, int y) { return a[x] < a[y]; }); dp[0][0][0] = 0; for (int i = 0; i < (int)(n); ++i) { for (int j = 0; j < (int)(i + 1); ++j) { for (int k = 0; k < (int)(2); ++k) { int mj = -1, mk = -1; for (int nj = i; nj < n; ++nj) { for (int nk = 0; nk < (int)(2); ++nk) { if (mj == -1 || a[id[mj]] + mk * l[id[mj]] < a[id[nj]] + nk * l[id[nj]]) mj = nj, mk = nk; dp[nj + 1][mj + 1][mk] = std::max( dp[nj + 1][mj + 1][mk], dp[i][j][k] + a[id[mj]] + mk * l[id[mj]] - std::max( (j ? a[id[j - 1]] + k * l[id[j - 1]] : -0x3f3f3f3f), a[id[nj]] - (!nk) * l[id[nj]])); } } } } } int ans = 0; for (int j = 0; j < (int)(n + 1); ++j) for (int k = 0; k < (int)(2); ++k) { ans = std::max(ans, dp[n][j][k]); } printf( %d n , ans); return 0; }

#include <bits/stdc++.h> using namespace std; const int MAX = 111, K = 26; int n; string name[MAX]; namespace G { struct V : vector<int> { V() : odw(false) {} bool odw; int wyj; }; V g[K]; void krawedz(char a, char b) { g[int(a) - int( a )].push_back(int(b) - int( a )); } int t = 0; stack<int> stos; void dfs(int v) { g[v].odw = true; for (int i = 0; i < ((int((g[v]).size()))); i++) { int u = g[v][i]; if (!g[u].odw) dfs(u); } stos.push(v); g[v].wyj = t++; } bool poprawne_sortowanie() { for (int v = 0; v < (K); v++) for (int i = 0; i < ((int((g[v]).size()))); i++) { int u = g[v][i]; if (g[v].wyj < g[u].wyj) return false; } return true; } bool sortowanie_topologiczne() { for (int i = 0; i < (K); i++) if (!g[i].odw) dfs(i); return poprawne_sortowanie(); } void wypisz_sortowanie() { assert((int((stos).size())) == 26); while (!stos.empty()) { cout << char(int( a ) + stos.top()); stos.pop(); } cout << n ; } } // namespace G void wczytaj_dane() { cin >> n; for (int i = 0; i < (n); i++) cin >> name[i]; } int roznica(const string& a, const string& b) { int m = min((int((a).size())), (int((b).size()))); for (int i = 0; i < (m); i++) if (a[i] != b[i]) return i; return -1; } bool porownuj(const string& a, const string& b) { int i = roznica(a, b); if (i == -1) return (int((a).size())) < (int((b).size())); G::krawedz(a[i], b[i]); return true; } void zrob_test() { wczytaj_dane(); for (int i = 0; i < (n - 1); i++) if (!porownuj(name[i], name[i + 1])) { cout << Impossible n ; return; } if (G::sortowanie_topologiczne()) G::wypisz_sortowanie(); else cout << Impossible n ; } int main() { ios_base::sync_with_stdio(0); zrob_test(); return 0; }

#include <bits/stdc++.h> using namespace std; long long Pow(int a, int b) { long long ans = 1; for (int i = 0; i < b; i++) { ans = (ans * a) % 1000000007; } return ans; } int main() { long long n, k; cin >> n >> k; cout << (Pow(n - k, n - k) * Pow(k, k - 1)) % 1000000007 << endl; return 0; }

#include <bits/stdc++.h> using namespace std; vector<int> v[200005]; int CR, n, k, sz[200005], target[200005], cented[200005]; void getsize(int now, int pre) { sz[now] = (target[now] == 1); for (int i = 0; i < v[now].size(); i++) { int next = v[now][i]; if (next == pre || cented[next]) continue; getsize(next, now); sz[now] += sz[next]; } } int getcent(int now, int pre, int R) { for (int i = 0; i < v[now].size(); i++) { int next = v[now][i]; if (next == pre || cented[next]) continue; if (sz[next] > sz[R] / 2) return getcent(next, now, R); } return now; } priority_queue<pair<int, int> > pq; int centdfs(int now) { getsize(now, -1); int cc = getcent(now, -1, now); cented[cc] = 1; if (CR == -1) CR = cc; return cc; } int gcnt = 0; vector<int> tmp[200005]; void go(int now, int pre) { if (target[now]) tmp[gcnt].push_back(now); for (int i = 0; i < v[now].size(); i++) { int next = v[now][i]; if (next == pre) continue; go(next, now); } } int main() { CR = -1; scanf( %d %d , &n, &k); for (int a, b, i = 0; i < n - 1; i++) { scanf( %d %d , &a, &b); v[a].push_back(b); v[b].push_back(a); } for (int i = 1; i <= k; i++) { for (int t, j = 0; j < 2; j++) { scanf( %d , &t); target[t] = 1; } } centdfs(1); printf( 1 n%d n , CR); for (int i = 0; i < v[CR].size(); i++) { ++gcnt; go(v[CR][i], CR); if (tmp[gcnt].empty()) continue; pq.push(make_pair((int)tmp[gcnt].size(), gcnt)); } while (!pq.empty()) { pair<int, int> p = pq.top(); pq.pop(); if ((int)pq.size() == 0) { printf( %d %d %d n , tmp[p.second].back(), CR, CR); break; } pair<int, int> p2 = pq.top(); pq.pop(); printf( %d %d %d n , tmp[p.second].back(), tmp[p2.second].back(), CR); tmp[p.second].pop_back(); tmp[p2.second].pop_back(); if (--p.first != 0) { pq.push(p); } if (--p2.first != 0) { pq.push(p2); } } }

#include <bits/stdc++.h> using namespace std; const int MAX = 100005; vector<int> A, B[MAX], C, D; int visited[MAX]; int n, m; void DFS(int u) { visited[u] = 1; C.push_back(u); for (int i = 0; i < B[u].size(); i++) { int current = B[u][i]; if (visited[current] == 0) DFS(current); } } int main() { int n; scanf( %d , &n); A.clear(); for (int i = 0; i <= n; i++) visited[i] = 0; string s; for (int i = 0; i < n; i += 1) { int val; cin >> val; A.push_back(val); } for (int i = 0; i < MAX; i++) B[i].clear(); for (int i = 0; i < n; i++) { cin >> s; for (int j = 0; j < n; j++) { if (s[j] == 1 ) { B[i + 1].push_back(j + 1); B[j + 1].push_back(i + 1); } } } for (int i = 1; i <= n; i++) { C.clear(); D.clear(); if (visited[i] == 0) { DFS(i); for (int j = 0; j < C.size(); j++) { D.push_back(A[C[j] - 1]); } sort(C.begin(), C.end()); sort(D.begin(), D.end()); for (int j = 0; j < C.size(); j++) { A[C[j] - 1] = D[j]; } } } for (int i = 0; i < A.size(); i++) printf( %d , A[i]); printf( n ); return 0; }

#include <bits/stdc++.h> using namespace std; int n, m, s, ans = 0, f[2 * 200005]; inline int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); } int main() { scanf( %d%d%d , &n, &m, &s); for (register int i = 1; i <= m + n; i++) f[i] = i; for (register int i = 1; i <= s; i++) { register int a, b; scanf( %d%d , &a, &b), b += n; f[find(b)] = find(a); } for (register int i = 1; i <= n + m; i++) if (f[i] == i) ans++; printf( %d , ans - 1); return 0; }

#include <bits/stdc++.h> #pragma GCC optimize(3, Ofast , inline ) const double eps = 1e-7; const int maxn = 3e5 + 10; const int prime[15] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37}; const int dir[4][2] = {1, 0, -1, 0, 0, 1, 0, -1}; int spgcd(int a, int b) { while (b ^= a ^= b ^= a %= b) ; return a; } inline int mul(int a, int b, int p) { return (long long)a * b % p; } template <typename T> void scan(T &x) { x = 0; bool _ = 0; T c = getchar(); _ = c == 45; c = _ ? getchar() : c; while (c < 48 || c > 57) c = getchar(); for (; c < 48 || c > 57; c = getchar()) ; for (; c > 47 && c < 58; c = getchar()) x = (x << 3) + (x << 1) + (c & 15); x = _ ? -x : x; } template <typename T> void printn(T n) { bool _ = 0; _ = n < 0; n = _ ? -n : n; char snum[65]; int i = 0; do { snum[i++] = n % 10 + 48; n /= 10; } while (n); --i; if (_) putchar(45); while (i >= 0) putchar(snum[i--]); } template <typename First, typename... Ints> void scan(First &arg, Ints &...rest) { scan(arg); scan(rest...); } template <typename T> void print(T n) { printn(n); putchar(10); } template <typename First, typename... Ints> void print(First arg, Ints... rest) { printn(arg); putchar(32); print(rest...); } using namespace std; map<int, int> mp; void solve() { int n; cin >> n; for (int i = 1; i <= n; i++) { int l, r; cin >> l >> r; mp[l]++, mp[r]--; } int ans = 0, id = 1; int sum = 0; for (auto i : mp) { sum += i.second; if (sum > ans) { ans = sum; id = i.first; } } cout << id << << ans << endl; } int main() { ios::sync_with_stdio(0), cin.tie(0), cout.tie(0); solve(); return 0; }

#include <bits/stdc++.h> using namespace std; const int sz = (1 << 22); bool ar[sz], us[2][sz]; int n, m, bg; void dfs(int v, int t) { us[t][v] = 1; if (t == 0) { if (us[1][bg ^ v] == 0) dfs(bg ^ v, 1); } else { if (ar[v] and us[0][v] == 0) dfs(v, 0); for (int i = 0; i < n; i++) { if (v & (1 << i)) { int ne = v - (1 << i); if (us[1][ne] == 0) dfs(ne, 1); } } } } int main() { int an = 0; cin >> n >> m; bg = (1 << n) - 1; for (int a = 0; a < m; a++) { int x; scanf( %d , &x); ar[x] = 1; } for (int a = 0; a < (1 << n); a++) { if (ar[a] and us[0][a] == 0) { dfs(a, 0), an++; } } cout << an; }

#include <bits/stdc++.h> using namespace std; const int mod = 1e9 + 7; long long a[50]; long long inv[50]; long long Finv[50]; long long n, s; void init() { inv[1] = 1; for (int i = 2; i <= 50; i++) { inv[i] = (mod - mod / i) * inv[mod % i] % mod; } Finv[0] = 1; for (int i = 1; i <= 50; i++) { Finv[i] = Finv[i - 1] % mod * inv[i] % mod; } } long long C(long long n, long long m) { if (n < 0 || m < 0 || m > n) return 0; long long res = 1; for (long long i = n; i > n - m; i--) { res = (i % mod * res) % mod; } res = res % mod * Finv[m] % mod; return res % mod; } int main() { init(); cin >> n >> s; for (int i = 0; i < n; i++) { cin >> a[i]; } long long res = 0; for (long long i = 0; i < (1ll << n); i++) { long long tmp = s; long long cnt = 0; for (long long j = 0; j < n; j++) { if ((1ll << j) & i) { tmp -= a[j] + 1; cnt++; } } if (tmp < 0) continue; if (cnt & 1) { res = (((res - C(tmp + n - 1, n - 1)) % mod + mod) % mod) % mod; } else { res = (res + C(tmp + n - 1, n - 1) % mod) % mod; } } cout << res << endl; }

#include <bits/stdc++.h> using namespace std; int main() { int N; cin >> N; if (N % 2 == 0) cout << -1 << endl; else { for (int i = 0; i < N; i++) cout << i << (i == N - 1 ? n : ); for (int i = 0; i < N; i++) cout << ((long long)(N - 2) * i) % N << (i == N - 1 ? n : ); for (int i = 0; i < N; i++) cout << ((long long)(N - 2) * i + i) % N << (i == N - 1 ? n : ); } return 0; }

#include <bits/stdc++.h> using namespace std; int sqrt_maxn = 505; const int maxsqrt_n = 205; const int maxn = 100005; int a[maxn]; struct node { int val; node* next; node* front; }; node* front[maxsqrt_n]; node* rail[maxsqrt_n]; int dp[maxsqrt_n][maxn]; node* new_node() { static node a[200005]; static int top = 0; return &a[top++]; } void insert_node(int x, int y) { node* t = new_node(); t->val = y; t->next = front[x]; if (front[x] != 0) front[x]->front = t; t->front = 0; front[x] = t; } void trans_inside(int x, int y) { register int j = x / sqrt_maxn; register int i; register node* t1 = front[j]; for (i = j * sqrt_maxn; i <= x; i++) { t1 = t1->next; } register node* t2 = t1; for (; i <= y; i++) { t2 = t2->next; } t1->front->next = t2; t2->front->next = t2->next; t2->next->front = t2->front; t2->front = t1->front; t2->next = t1; t1->front = t2; } void trans(int x, int y) { register int jx = x / sqrt_maxn; register int i; register node* t1 = front[jx]; for (i = jx * sqrt_maxn; i <= x; i++) { t1 = t1->next; } int jy = y / sqrt_maxn; register node* t2 = front[jy]; for (i = jy * sqrt_maxn; i <= y; i++) { t2 = t2->next; } t1->front->next = t2; t2->front->next = t2->next; t2->next->front = t2->front; t2->front = t1->front; t2->next = t1; t1->front = t2; dp[jx][t2->val]++; dp[jy][t2->val]--; for (i = jx; i < jy; i++) { t1 = front[i + 1]->next; t2 = rail[i]->front; t1->front->next = t2; t2->front->next = t2->next; t2->next->front = t2->front; t2->front = t1->front; t2->next = t1; t1->front = t2; dp[i + 1][t2->val]++; dp[i][t2->val]--; } } int calc_inside(int x, int y, int val) { int j = x / sqrt_maxn; int i; node* t1 = front[j]; for (i = j * sqrt_maxn; i <= x; i++) { t1 = t1->next; } register int ans = 0; for (; i <= y; i++) { if (t1->val == val) ans++; t1 = t1->next; } if (t1->val == val) ans++; return ans; } int calc(int x, int y, int val) { int j = x / sqrt_maxn; int i; node* t1 = front[j]; for (i = j * sqrt_maxn; i <= x; i++) { t1 = t1->next; } int ans = 0; for (; t1->val != -2;) { if (t1->val == val) ans++; t1 = t1->next; } int jy = y / sqrt_maxn; for (i = j + 1; i < jy; i++) { ans += dp[i][val]; } t1 = front[jy]; for (i = jy * sqrt_maxn; i <= y; i++) { t1 = t1->next; if (t1->val == val) ans++; } return ans; } int main() { fprintf(stderr, %d n , clock()); int n; scanf( %d , &n); int i; for (i = 0; i < n; i++) { scanf( %d , &a[i]); a[i]--; } memset(dp, 0, sizeof(dp)); for (i = 0; i < n; i += sqrt_maxn) { register int temp = i / sqrt_maxn; front[temp] = 0; int j; insert_node(temp, -2); rail[temp] = front[temp]; for (j = i + sqrt_maxn - 1; j >= i; j--) { if (j >= n) continue; insert_node(temp, a[j]); dp[temp][a[j]]++; } insert_node(temp, -1); } int lastans = 0; int q; scanf( %d , &q); for (i = 0; i < q; i++) { int oper; scanf( %d , &oper); if (oper == 1) { int x, y; scanf( %d%d , &x, &y); x = (x - 1 + lastans) % n; y = (y - 1 + lastans) % n; if (x > y) swap(x, y); if (x == y) continue; if (x / sqrt_maxn == y / sqrt_maxn) { trans_inside(x, y); } else { trans(x, y); } } else { int x, y, z; scanf( %d%d%d , &x, &y, &z); x = (x - 1 + lastans) % n; y = (y - 1 + lastans) % n; z = (z - 1 + lastans) % n; if (x > y) swap(x, y); if (x / sqrt_maxn == y / sqrt_maxn) { lastans = calc_inside(x, y, z); } else { lastans = calc(x, y, z); } printf( %d n , lastans); } } fprintf(stderr, %d n , clock()); return 0; }

#include <bits/stdc++.h> using namespace std; const int mod = 998244353; const int M = 80; const int N = 4100; long long c[M][M], m; struct Tree { struct Node { int ne, to; } e[2 * N]; int vis[N], tot = 0, he[N], sz[N], mx[N], q[N], n, rp, mn; long long step[M], f[N][M], g[N][M], tmp[M], ans[M]; void add(int x, int y) { e[++tot].ne = he[x]; he[x] = tot; e[tot].to = y; } void addedge(int x, int y) { add(x, y); add(y, x); } void dfs1(int x, int fa) { int i, y; sz[x] = 1; mx[x] = 0; for (i = he[x]; i; i = e[i].ne) { y = e[i].to; if ((!vis[y]) && (y != fa)) { dfs1(y, x); sz[x] += sz[y]; if (sz[y] > mx[x]) mx[x] = sz[y]; } } } void dfsrt(int now, int x, int fa, int &rt) { int i, y; mx[x] = max(mx[x], sz[now] - sz[x]); if (mx[x] < mn) { mn = mx[x]; rt = x; } for (i = he[x]; i; i = e[i].ne) { y = e[i].to; if ((!vis[y]) && (y != fa)) dfsrt(now, y, x, rt); } } void dfs2(int x, int fa) { int i, y; q[++rp] = x; for (i = he[x]; i; i = e[i].ne) { y = e[i].to; if ((!vis[y]) && (y != fa)) dfs2(y, x); } } void divide(int x) { int rt, i, j, k, y; mn = n; dfs1(x, 0); dfsrt(x, x, 0, rt); vis[rt] = 1; for (i = he[rt]; i; i = e[i].ne) if (!vis[e[i].to]) divide(e[i].to); vis[rt] = 0; rp = 0; dfs2(rt, 0); memset(step, 0, sizeof(step)); for (i = he[rt]; i; i = e[i].ne) { y = e[i].to; if (!vis[y]) for (j = 0; j <= m - 2; j++) step[j + 2] = (step[j + 2] + f[y][j]) % mod; } memset(f[rt], 0, sizeof(f[rt])); f[rt][0] = 1; for (i = 1; i <= m; i++) for (j = 2; j <= i; j++) f[rt][i] = (f[rt][i] + f[rt][i - j] * step[j]) % mod; for (i = 2; i <= rp; i++) { memset(tmp, 0, sizeof(tmp)); for (j = 2; j <= m; j++) for (k = 0; k <= j - 2; k++) tmp[j] = (tmp[j] + g[q[i]][k] * f[rt][j - k - 2]) % mod; for (j = 2; j <= m; j++) for (k = 0; k <= j - 2; k++) f[q[i]][j] = (f[q[i]][j] + g[q[i]][k] * tmp[j - k]) % mod; } for (i = 1; i <= rp; i++) memset(g[q[i]], 0, sizeof(g[q[i]])); g[x][0] = 1; for (i = 1; i <= m; i++) for (j = 1; j <= rp; j++) for (k = he[q[j]]; k; k = e[k].ne) { y = e[k].to; if (!vis[y]) g[q[j]][i] = (g[q[j]][i] + g[y][i - 1]) % mod; } } void solve() { divide(1); for (int i = 0; i <= m; i++) for (int j = 1; j <= n; j++) ans[i] = (ans[i] + f[j][i]) % mod; } } tr1, tr2; int main() { int i, j, k, x, y; long long out; scanf( %d%d%d , &tr1.n, &tr2.n, &m); for (i = 1; i < tr1.n; i++) { scanf( %d%d , &x, &y); tr1.addedge(x, y); } for (i = 1; i < tr2.n; i++) { scanf( %d%d , &x, &y); tr2.addedge(x, y); } for (i = 0; i <= m; i++) c[i][0] = 1; for (i = 1; i <= m; i++) for (j = 1; j <= i; j++) c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod; tr1.solve(); tr2.solve(); out = 0; for (i = 0; i <= m; i++) out = (out + (c[m][i] * tr1.ans[i]) % mod * tr2.ans[m - i]) % mod; printf( %I64d n , out); return 0; }

#include <bits/stdc++.h> using namespace std; struct trie { struct tree { long long al[26]; bool ex; } nxt[100005]; long long cnt, dep[100005]; void insert(char *s) { long long l = strlen(s), rt = 0; for (register long long i = 0; i < l; i++) { long long c = s[i] - a ; if (!nxt[rt].al[c]) nxt[rt].al[c] = ++cnt, dep[cnt] = dep[rt] + 1; rt = nxt[rt].al[c]; } nxt[rt].ex = 1; } } tr; priority_queue<long long> q[100005]; long long n, ans = 0; char s[100005]; template <typename T> inline void read(T &x) { T c = getchar(), f = 0; for (; c < 48 || 57 < c; c = getchar()) if (c == - ) f = 1; for (x = 0; 48 <= c && c <= 57; c = getchar()) x = (x << 3) + (x << 1) + (c ^ 48); if (f) x = -x; } template <typename T> inline void print(T x) { if (x < 0) x = -x, putchar( - ); if (x > 9) print(x / 10); putchar(x % 10 + 48); } inline void merge(long long x, long long y) { while (!q[y].empty()) q[x].push(q[y].top()), q[y].pop(); } void dfs(long long x) { for (register long long i = 0; i < 26; i++) if (tr.nxt[x].al[i]) dfs(tr.nxt[x].al[i]); for (register long long i = 0; i < 26; i++) if (tr.nxt[x].al[i]) merge(x, tr.nxt[x].al[i]); if (!x) return; if (tr.nxt[x].ex) ans += tr.dep[x], q[x].push(tr.dep[x]); else ans -= q[x].top() - tr.dep[x], q[x].pop(), q[x].push(tr.dep[x]); } signed main() { scanf( %lld , &n); for (register long long i = 1; i <= n; i++) scanf( %s , s), tr.insert(s); dfs(0), printf( %lld , ans); return 0; }

#include <bits/stdc++.h> using namespace std; const int N = 2e5 + 5; int n, T, ans; int t[N]; priority_queue<int> pq; int main() { scanf( %d%d , &n, &T); for (int i = 1; i <= n; ++i) { scanf( %d , &t[i]); t[i] = t[i] > i ? t[i] - i : 0; } for (int i = 1; i <= n; ++i) { pq.push(t[i]); while ((long long)pq.top() + i >= T && !pq.empty()) { pq.pop(); } ans = max(ans, (int)pq.size()); } printf( %d n , ans); return 0; }

#include <bits/stdc++.h> int main() { int a, b, i, j, c = 0; int fil, col; scanf( %d , &a); scanf( %d , &b); char myChar; int aux[2][3]; for (i = 0; i < a; i++) { for (j = 0; j < b; j++) { scanf( %c , &myChar); if (myChar == * ) { aux[0][c] = i + 1; aux[1][c] = j + 1; c++; } } } for (i = 0; i < 2; i++) { for (j = i + 1; j < 3; j++) { if (aux[0][i] == aux[0][j]) { aux[0][i] = -1; aux[0][j] = -1; } if (aux[1][i] == aux[1][j]) { aux[1][i] = -1; aux[1][j] = -1; } } } for (i = 0; i < 3; i++) { if (aux[0][i] != -1) { fil = aux[0][i]; } if (aux[1][i] != -1) { col = aux[1][i]; } } printf( %d %d , fil, col); return 0; }

#include <bits/stdc++.h> using namespace std; const int MOD = 1000000007; const char nl = n ; const int MX = 100001; int main() { ios_base::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr); int t; cin >> t; for (int tt = 0; tt < (t); tt++) { int n; cin >> n; for (int i = 0; i < (n); i++) cout << 1 ; cout << n ; } return 0; }

#include <bits/stdc++.h> using namespace std; using ll = long long; const ll INF = 1e18 + 1; const ll mod = 1e9 + 7; vector<vector<ll> > adj; vector<ll> desc, max_n; ll gmnc = INF; void print_vec(vector<ll> vec) { for (int i = 0; i < vec.size(); ++i) { cout << vec[i] << ; } cout << endl; } ll desc_cnt(ll curr, ll par) { ll cnt = 1; for (auto it : adj[curr]) { if (it != par) { cnt += desc_cnt(it, curr); } } desc[curr] = cnt; return cnt; } void max_neigh_cnt(ll curr, ll par) { ll mnc = -INF; mnc = max(mnc, desc[1] - desc[curr]); for (auto it : adj[curr]) { if (it != par) { mnc = max(mnc, desc[it]); } } gmnc = min(gmnc, mnc); max_n[curr] = mnc; for (auto it : adj[curr]) { if (it != par) { max_neigh_cnt(it, curr); } } } int main() { cin.tie(0); ios_base::sync_with_stdio(0); ll t; cin >> t; while (t--) { ll n; cin >> n; adj.clear(); desc.clear(); max_n.clear(); gmnc = INF; adj.resize(n + 1); desc.resize(n + 1); max_n.resize(n + 1); for (int i = 1; i <= n - 1; ++i) { ll x, y; cin >> x >> y; adj[x].push_back(y); adj[y].push_back(x); } desc_cnt(1, 1); max_neigh_cnt(1, 1); vector<ll> cn; for (int i = 1; i <= n; ++i) { if (max_n[i] == gmnc) { cn.push_back(i); } } pair<ll, ll> e1, e2; if (cn.size() > 1) { for (auto it : adj[cn[0]]) { if (it != cn[1]) { e1 = make_pair(cn[0], it); e2 = make_pair(cn[1], it); break; } } } else { e1 = make_pair(cn[0], adj[cn[0]][0]); e2 = e1; } cout << e1.first << << e1.second << endl; cout << e2.first << << e2.second << endl; } }

#include <bits/stdc++.h> using namespace std; char s[400010]; int a[200]; vector<int> S; vector<int> d, q; int main() { int n; scanf( %d %s , &n, s); for (int i = 0; i < n; i++) a[s[i]]++; int p = 0; for (int i = 0; i < 128; i++) { if (a[i] % 2) p++, a[i]--, S.push_back(i); if (a[i]) { d.push_back(i); q.push_back(a[i]); } } if (p == 0) { int cn = 0; for (int i = 0; i < 128; i++) { while (a[i]) s[cn++] = i, a[i] -= 2; } for (int i = 0; i < cn; i++) s[cn + i] = s[cn - i - 1]; s[n] = 0 ; printf( 1 n%s n , s); } else { int Min = n; for (int i = 1; i * i <= n; i++) { if (n % i == 0) { if (i % 2 && n / i >= p && (n / i - p) % 2 == 0) Min = min(Min, n / i); if (n / i % 2 && i >= p && (i - p) % 2 == 0) Min = min(Min, i); } } printf( %d n , Min); int L = n / Min; int pi = L / 2; int now = 0; for (int i = 0; i < Min; i++) { int x = pi + i * L; if (S.size() > i) s[x] = S[i]; else { while (!q[now]) now++; s[x] = d[now]; S.push_back(d[now]); S.push_back(d[now]); q[now] -= 2; } for (int i = 0; i < L / 2; i++) { while (!q[now]) now++; s[x - i - 1] = d[now]; s[x + i + 1] = d[now]; q[now] -= 2; } } for (int i = 0; i < n; i++) { printf( %c , s[i]); if (i % L == L - 1 && i != n - 1) printf( ); } printf( n ); } return 0; }

#include <bits/stdc++.h> using namespace std; const int N = 1e6, SZ = 800, INF = 1 << 29; const long long LINF = (1LL << 60), mod = 1e9 + 7; const long double eps = 1e-8, PI = acos(-1.0); inline int dcmp(double x, double y = 0.0) { return abs(x - y) < eps; } template <typename Type> inline Type ru(Type &v) { static char READ_DATA; static int SIGNAL_INPUT = 1; while ((READ_DATA = getchar()) < 0 || READ_DATA > 9 ) if (READ_DATA == - ) SIGNAL_INPUT = -1; else if (READ_DATA == EOF) return EOF; v = READ_DATA - 0 ; while ((READ_DATA = getchar()) >= 0 && READ_DATA <= 9 ) v = v * 10 + READ_DATA - 0 ; v *= SIGNAL_INPUT; return v; } template <typename A, typename B> inline int ru(A &x, B &y) { if (ru(x) == EOF) return EOF; ru(y); return 2; } template <typename A, typename B, typename C> inline int ru(A &x, B &y, C &z) { if (ru(x) == EOF) return EOF; ru(y); ru(z); return 3; } long long gcd(long long a, long long b) { a = abs(a); b = abs(b); while (b) { a %= b; swap(a, b); } return a; } const int maxn = 1e6 + 5; int n, a[maxn], m, d[maxn], id[maxn]; int cmp(const int &i, const int &j) { return d[(i + 1) / 2] > d[(j + 1) / 2]; } int main() { ru(n); for (int i = 1; i <= n; i++) { ru(d[i]); } for (int i = 1; i < 2 * n; i += 2) { a[++m] = i; } sort(a + 1, a + m + 1, cmp); for (int i = 2; i <= m; i++) { printf( %d %d n , a[i - 1], a[i]); } for (int i = 1; i <= n; i++) { int j = (a[i] + 1) / 2; if (i + d[j] - 1 <= m) { printf( %d %d n , 2 * j, a[i + d[j] - 1]); if (i + d[j] - 1 == m) { a[++m] = 2 * j; } } else { printf( %d %d n , 2 * j, a[i - d[j] + 1]); } } }

#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(0); cin.tie(0); int t; cin >> t; while (t--) { int kq = 0; vector<pair<int, int> > res; int n, k; cin >> n >> k; vector<bool> used(2 * n + 1, false); for (int i = 1; i <= k; i++) { int u, v; cin >> u >> v; res.push_back({min(u, v), max(u, v)}); used[u] = true; used[v] = true; } vector<int> conlai; for (int i = 1; i <= 2 * n; i++) { if (!used[i]) conlai.push_back(i); } int len = n - k; for (int i = 0; i < len; i++) { res.push_back({conlai[i], conlai[i + len]}); } for (int i = 0; i < res.size(); i++) { for (int j = i + 1; j < res.size(); j++) { int a = (res[j].first - res[i].first) * (res[j].second - res[i].first); int b = (res[j].first - res[i].second) * (res[j].second - res[i].second); if (a * b < 0) { kq++; } } } cout << kq << endl; } }

#include <bits/stdc++.h> int main() { long n, k, x, a, y; scanf( %ld %ld , &n, &k); a = n; x = n; while (x >= k) { y = x % k; x = x / k; a = a + x; x = x + y; } printf( %ld n , a); return 0; }

#include <bits/stdc++.h> using namespace std; template <typename T, typename U> inline void smin(T &a, U b) { if (a > b) a = b; } template <typename T, typename U> inline void smax(T &a, U b) { if (a < b) a = b; } int power(int a, int b, int m, int ans = 1) { for (; b; b >>= 1, a = 1LL * a * a % m) if (b & 1) ans = 1LL * ans * a % m; return ans; } const int maxn = 110; int a[maxn]; int arr[maxn * maxn]; int cat[maxn * maxn][maxn]; map<set<int>, int> mp; int top; int recure(set<int> s) { if (s.empty()) return 0; if (mp.count(s)) return mp[s]; int d = *(--s.end()); int vis[maxn]; memset(vis, 0, sizeof(vis)); for (int i = 1; i <= d; i++) { set<int> res; for (set<int>::iterator it = s.begin(); it != s.end(); it++) { if (*it < i) res.insert(*it); else if (*it > i) res.insert(*it - i); } vis[recure(res)] = 1; } int g; for (int i = 0; i < maxn; i++) if (!vis[i]) { g = i; break; } mp[s] = g; return g; } int main() { int n, Num = 0; cin >> n; for (int i = 0; i < n; i++) scanf( %d , &a[i]); for (int i = 0; i < n; i++) { long long num = 1ll * a[i]; for (int j = 2; 1ll * j * j <= num; j++) { if (num % j) continue; while (num % j == 0) num /= j; arr[Num++] = j; } if (num > 1) { arr[Num++] = (int)num; } } sort(arr, arr + Num); Num = unique(arr, arr + Num) - arr; for (int i = 0; i < n; i++) { long long num = 1ll * a[i]; for (int j = 2; 1ll * j * j <= num; j++) { if (num % j) continue; int cnt = 0; while (num % j == 0) num /= j, cnt++; int t = lower_bound(arr, arr + Num, j) - arr; cat[t][cnt] = 1; } if (num > 1) { int t = lower_bound(arr, arr + Num, (int)num) - arr; cat[t][1] = 1; } } int ok = 0; for (int i = 0; i < Num; i++) { set<int> res; res.clear(); for (int j = 1; j < maxn; j++) { if (cat[i][j]) res.insert(j); } ok ^= recure(res); } if (ok) puts( Mojtaba ); else puts( Arpa ); return 0; }

#include <bits/stdc++.h> using namespace std; const int N = 505; int n, now, siz[N], f[N]; bool vis[N]; vector<int> g, ans[N]; inline bool cmp(int x, int y) { return siz[x] < siz[y]; } void divide(int l, int r) { if (l > r) return; cout << 1 << endl << 1 << endl << r - l + 1 << endl; for (int i = l; i <= r; ++i) cout << g[i] << ; cout << endl << now << endl; int x, mid = (l + r) >> 1; cin >> x; if (!x) return; if (l == r) return vis[g[l]] = 1, ans[now].push_back(g[l]); divide(l, mid), divide(mid + 1, r); } int main() { cin >> n, siz[1] = n; for (int i = 2; i <= n; ++i) { cout << 1 << endl << 1 << endl << n - 1 << endl; for (int j = 2; j <= n; ++j) cout << j << ; cout << endl << i << endl; cin >> siz[i]; } for (int i = 1; i <= n; ++i) f[i] = i; sort(f + 1, f + n + 1, cmp); for (int i = 1; i <= n; ++i) { now = f[i]; divide(0, g.size() - 1); for (unsigned i = 0; i < g.size(); ++i) if (vis[g[i]]) g.erase(g.begin() + i--); g.push_back(now); } cout << ANSWER << endl; for (int i = 1; i <= n; ++i) for (int j : ans[i]) cout << i << << j << endl; return 0; }

#include <bits/stdc++.h> using namespace std; long long n, k; long long c[100006], freq[100006], people[100006], h[100006]; long long catche[5005][505]; long long dp(long long left, long long pep) { if (left == 0 || pep == 0) return 0; long long &ans = catche[left][pep]; if (ans != -1) return ans; ans = 0; for (long long j = 1; j <= min(left, k); j++) { ans = max(ans, h[j] + dp(left - j, pep - 1)); } return ans; } int32_t main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); cin >> n >> k; long long ans = 0; long long i, j; for (i = 1; i <= (n * k); i++) { long long x; cin >> x; freq[x]++; } for (i = 1; i <= n; i++) { long long x; cin >> x; people[x]++; } for (i = 1; i <= k; i++) { cin >> h[i]; } for (i = 1; i <= 100005; i++) { if (!people[i]) { continue; } for (j = 0; j <= freq[i]; j++) { for (long long kk = 0; kk <= people[i]; kk++) { catche[j][kk] = -1; } } ans += dp(freq[i], people[i]); } cout << ans << n ; }

#include <bits/stdc++.h> using namespace std; const long long int N = 100005; void solve() { long long int m, n; cin >> n >> m; long long int count = 0; for (long long int i = 1; i <= n; i++) { count += (m + i % 5) / 5; } cout << count << endl; return; } int32_t main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); solve(); return 0; }

#include <bits/stdc++.h> using namespace std; template <class T> bool uin(T &a, T b) { if (a > b) { a = b; return true; } return false; } template <class T> bool uax(T &a, T b) { if (a < b) { a = b; return true; } return false; } const int MAXN = 1100000; vector<int> lft[MAXN], rgt[MAXN]; int leftf[MAXN], anyf[MAXN]; int lc[MAXN], rc[MAXN]; char s[10]; struct TNode { int left, right; int L, R; int maxk; TNode(int L = -1, int R = -1) : left(-1), right(-1), L(L), R(R), maxk(-1e9) {} }; const int MAXT = 2100000; TNode t[MAXT]; int tc = 0; int buildTree(int L, int R) { int node = tc++; t[node] = TNode(L, R); if (R - L == 1) return node; int M = (L + R) / 2; t[node].left = buildTree(L, M); t[node].right = buildTree(M, R); return node; } int getMax(int node, int L, int R) { if (max(L, t[node].L) >= min(R, t[node].R)) return -1e9; if (L <= t[node].L && t[node].R <= R) return t[node].maxk; return max(getMax(t[node].left, L, R), getMax(t[node].right, L, R)); } void setMax(int node, int i, int x) { if (i >= t[node].R || i < t[node].L) return; if (i == t[node].L && i + 1 == t[node].R) { t[node].maxk = x; return; } setMax(t[node].left, i, x); setMax(t[node].right, i, x); t[node].maxk = max(t[t[node].left].maxk, t[t[node].right].maxk); } bool buildAns(int l, int r) { if (anyf[l] > r) return false; for (int x : rgt[l]) { if (x <= leftf[l]) return false; } if (leftf[l] == l) { lc[l] = -1; if (r == l) return true; rc[l] = l + 1; return buildAns(l + 1, r); } lc[l] = l + 1; if (!buildAns(lc[l], leftf[l])) return false; if (leftf[l] == r) return true; rc[l] = leftf[l] + 1; return buildAns(rc[l], r); } void print(int v) { if (v == -1) return; print(lc[v]); printf( %d , v + 1); print(rc[v]); } int main() { ios::sync_with_stdio(false); cin.tie(nullptr); cout.precision(10); cout << fixed; int N, C; scanf( %d%d , &N, &C); bool ok = true; int root = buildTree(0, N); for (int i = 0; i < (int)(C); ++i) { int x, y; scanf( %d%d%s , &x, &y, s); --x; --y; ok &= x < y; if (s[0] == L ) lft[x].push_back(y); else rgt[x].push_back(y); } if (!ok) { cout << IMPOSSIBLE n ; return 0; } for (int i = (int)(N)-1; i >= 0; --i) { leftf[i] = anyf[i] = i; for (int x : lft[i]) { uax(leftf[i], getMax(root, i, x + 1)); } for (int x : rgt[i]) { uax(anyf[i], getMax(root, i, x + 1)); } uax(anyf[i], leftf[i]); setMax(root, i, anyf[i]); } for (int i = 0; i < (int)(N); ++i) lc[i] = rc[i] = -1; if (!buildAns(0, N - 1)) { cout << IMPOSSIBLE n ; return 0; } print(0); printf( n ); return 0; }

#include <bits/stdc++.h> using namespace std; int cnt[15]; string a[100009]; const long long mod = 998244353LL; int main() { int i, len1, len2, n, j; long long p, sum, val; cin >> n; for (i = 1; i <= n; i++) { cin >> a[i]; reverse(a[i].begin(), a[i].end()); cnt[a[i].size()]++; } for (i = 1, val = 0; i <= n; i++) { len2 = a[i].size(); for (len1 = 1; len1 <= 10; len1++) { sum = 0; if (len1 < len2) { for (j = 0, p = 1; j < len1; j++) { sum += p * (a[i][j] - 48); p = (p * 10LL) % mod; sum += p * (a[i][j] - 48); p = (p * 10LL) % mod; } for (j = len1; j < len2; j++) { sum += p * (a[i][j] - 48); sum += p * (a[i][j] - 48); p = (p * 10LL) % mod; } } else { for (j = 0, p = 1; j < len2; j++) { sum += p * (a[i][j] - 48); p = (p * 10LL) % mod; sum += p * (a[i][j] - 48); p = (p * 10LL) % mod; } } val += (sum % mod) * cnt[len1]; val %= mod; } } cout << val << n ; return 0; }

#include <bits/stdc++.h> using namespace std; template <typename T, size_t N> int SIZE(const T (&t)[N]) { return N; } template <typename T> int SIZE(const T(&t)) { return t.size(); } string to_string(char b) { return + string({b}) + ; } string to_string(bool b) { return (b ? true : false ); } string to_string(const string &t, int x1 = 0, int x2 = 1e9) { string ret = ; for (int i = min(x1, SIZE(t)), _i = min(x2, SIZE(t) - 1); i <= _i; ++i) { ret += t[i]; } return + ret + ; } string to_string(const char *t) { string ret(t); return to_string(ret); } template <size_t N> string to_string(const bitset<N> &t, int x1 = 0, int x2 = 1e9) { string ret = ; for (int i = min(x1, SIZE(t)), _i = min(x2, SIZE(t) - 1); i <= _i; ++i) { ret += t[i] + 0 ; } return + ret + ; } template <typename T, typename... Coords> string to_string(const T(&t), int x1 = 0, int x2 = 1e9, Coords... C); template <typename T, typename S> string to_string(const pair<T, S>(&t)) { return ( + to_string(t.first) + , + to_string(t.second) + ) ; } template <typename T, typename... Coords> string to_string(const T(&t), int x1, int x2, Coords... C) { string ret = [ ; x1 = min(x1, SIZE(t)); auto e = begin(t); advance(e, x1); for (int i = x1, _i = min(x2, SIZE(t) - 1); i <= _i; ++i) { ret += (i != x1 ? , : ) + to_string(*e, C...); e = next(e); } return ret + ] ; } void dbgm() { ; } template <typename T, typename... S> void dbgm(T t, S... s) { cout << to_string(t) << | ; dbgm(s...); } void dbgs() { ; } template <typename T, typename... S> void dbgs(T t, S... s) { cout << t << ; dbgs(s...); } const long long N = 2e5 + 3, M = 1e9 + 7; int v[N], h[N]; int main() { int n, m; cin >> n >> m; for (int i = 1, _i = n; i <= _i; ++i) { int x; cin >> x; v[i] = x; } sort(v + 1, v + 1 + n); int pt = 0, hans = 0; for (int i = 1, _i = m; i <= _i; ++i) { int x1, x2, y; cin >> x1 >> x2 >> y; if (x1 == 1) { if (x2 == 1e9) { hans++; } else { h[++pt] = x2; } } } m = pt; sort(h + 1, h + 1 + m, greater<int>()); int j = n; int ans = 1e9; for (int i = 1, _i = m + 1; i <= _i; ++i) { while (v[j] > h[i]) { --j; } ans = min(ans, j + max(i - 1, 0)); } dbgs(ans + hans); }

#include <bits/stdc++.h> using namespace std; ifstream fin( fisier.in ); ofstream fout( fisier.out ); int v[1000000], minl[1000000], minr[1000000]; int main() { int n, i; cin >> n; for (i = 1; i <= n; ++i) cin >> v[i]; for (i = 1; i <= n; ++i) minl[i] = min(minl[i - 1] + 1, v[i]); for (i = n; i >= 1; --i) minr[i] = min(minr[i + 1] + 1, v[i]); int res = 0; for (i = 1; i <= n; ++i) res = max(res, min(minr[i], minl[i])); cout << res; return 0; }

#include <bits/stdc++.h> using namespace std; long long dx[] = {1, 0, -1, 0}; long long dy[] = {0, 1, 0, -1}; long long gcd(long long x, long long y) { if (y == 0) return x; else return gcd(y, x % y); } long long expo(long long n, long long m, long long p) { long long r = 1; n = n % p; while (m > 0) { if (m % 2) r = (r * n) % p; n = (n * n) % p; m = m / 2; } return r % p; } bool isPrime(long long n) { if (n <= 1) return false; if (n <= 3) return true; if (n % 2 == 0 || n % 3 == 0) return false; for (long long i = 5; i * i <= n; i = i + 6) if (n % i == 0 || n % (i + 2) == 0) return false; return true; } int32_t main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); ; long long t; cin >> t; long long tc = 1; while (t--) { long long n; cin >> n; if (n == 1) { cout << 1337 << n ; } else if (n == 2) { cout << 11337 << n ; } else if (n == 3) { cout << 111337 << n ; } else { long long m; for (long long i = 1; i <= n; i++) { long long x = (i * (i - 1)) / 2; if (x > n) { m = i - 1; break; } } long long r = n - (m * (m - 1)) / 2; string ans; ans.push_back( 1 ); ans.push_back( 3 ); ans.push_back( 3 ); while (r) { ans.push_back( 7 ); r--; } m -= 2; while (m) { ans.push_back( 3 ); m--; } ans.push_back( 7 ); cout << ans << n ; } } }

#include <bits/stdc++.h> using namespace std; int n, m, x, y, z, k, w, ans; int A[400], B[400]; char c[2]; int main() { scanf( %d , &n); for (int i = (0); i < (n); i++) { scanf( %s%d%d , &c, &x, &y); if (c[0] == M ) { for (int j = (x); j <= (y); j++) A[j]++; } else { for (int j = (x); j <= (y); j++) B[j]++; } } for (int i = (1); i <= (366); i++) ans = max(ans, min(A[i], B[i])); printf( %d n , ans * 2); return 0; }

#include <bits/stdc++.h> using namespace std; const int INF = (int)1e9; struct edge { int u, v; int flow; int cost; edge() {} edge(int u, int v, int f, int c) : u(u), v(v), flow(f), cost(c) {} }; struct MinCostMaxFlow { int N; vector<vector<int> > G; vector<edge> E; int numEdges; vector<int> found, dad; vector<int> dist; MinCostMaxFlow(int N) : N(N), G(N), found(N), dist(N), dad(N), numEdges(0) {} void addEdge(int from, int to, int capacity, int cost) { G[from].push_back(numEdges++); E.push_back(edge(from, to, capacity, cost)); G[to].push_back(numEdges++); E.push_back(edge(to, from, 0, int(-1) * cost)); } bool spfa(int s, int t) { fill(dad.begin(), dad.end(), -1); fill(dist.begin(), dist.end(), INF); fill(found.begin(), found.end(), 0); queue<int> Q; dist[s] = 0; Q.push(s); found[s] = true; while (!Q.empty()) { int u = Q.front(); Q.pop(); if (u == t) continue; for (int i = 0; i < G[u].size(); ++i) { edge &pres = E[G[u][i]]; int v = pres.v; if (pres.flow <= 0) continue; if (dist[u] + pres.cost < dist[v]) { dad[v] = G[u][i]; dist[v] = dist[u] + pres.cost; if (!found[v]) Q.push(v), found[v] = true; } } found[u] = false; } return (dad[t] != -1); } int dfs(int s, int t) { int flow = INF; for (int i = dad[t]; i != -1; i = dad[E[i].u]) { if (E[i].flow < flow) flow = E[i].flow; } for (int i = dad[t]; i != -1; i = dad[E[i].u]) { E[i].flow -= flow; E[i ^ 1].flow += flow; } return flow; } pair<int, int> getMaxFlow(int s, int t) { int totflow = 0; int totcost = 0; while (spfa(s, t)) { int amt = dfs(s, t); totflow += amt; totcost += dist[t] * (int)amt; } return make_pair(totflow, totcost); } }; int main() { int n, m; cin >> n >> m; vector<int> a(n); for (int i = 0; i < n; ++i) cin >> a[i]; MinCostMaxFlow mcmf(n * 2 + m + 2); for (int i = 0; i < n; ++i) { for (int j = i + 1; j < n; ++j) { mcmf.addEdge(i + 1, j + n + 1 + m, 1, (a[i] == a[j] ? 0 : __builtin_popcount(a[j]))); } } for (int i = 0; i < m; ++i) { for (int j = 0; j < n; ++j) { mcmf.addEdge(i + n + 1, j + n + m + 1, 1, __builtin_popcount(a[j])); } mcmf.addEdge(0, i + n + 1, 1, 0); } for (int i = 0; i < n; ++i) { mcmf.addEdge(0, i + 1, 1, 0); mcmf.addEdge(i + n + m + 1, n + m + n + 1, 1, 0); } pair<int, int> ret = mcmf.getMaxFlow(0, n + n + m + 1); vector<int> who(n); for (int i = 1; i <= n + m; ++i) { for (int c : mcmf.G[i]) { edge e = mcmf.E[c]; if (e.flow == 0 && e.v != 0) { who[e.v - n - m - 1] = i - 1; assert(e.u == i); } } } vector<int> last(n, -1); vector<string> fans; for (int i = 0; i < n; ++i) { int f = who[i]; if (f >= n) { stringstream ss; ss << (char)(f - n + a ) << = << a[i] << ; ss << print( << (char)(f - n + a ) << ) ; string tmp; ss >> tmp; fans.push_back(tmp); ss >> tmp; fans.push_back(tmp); last[i] = f - n; } else { if (a[who[i]] == a[i]) { stringstream ss; ss << print( << (char)(last[who[i]] + a ) << ) ; string tmp; ss >> tmp; fans.push_back(tmp); } else { stringstream ss; ss << (char)(last[who[i]] + a ) << = << a[i] << ; ss << print( << (char)(last[who[i]] + a ) << ) ; string tmp; ss >> tmp; fans.push_back(tmp); ss >> tmp; fans.push_back(tmp); } last[i] = last[who[i]]; } } cout << fans.size() << << ret.second << n ; for (string t : fans) cout << t << n ; return 0; }

#include <bits/stdc++.h> using namespace std; int main() { long long int l, r; cin >> l >> r; if (l == r) { cout << l; return 0; } cout << 2 << endl; }

// author: xay5421 // created: Mon May 3 17:34:21 2021 #include<bits/stdc++.h> #define rep(i,a,b) for(int i=(a);i<=(b);++i) #define per(i,a,b) for(int i=(a);i>=(b);--i) using namespace std; typedef long long LL; const LL INFLL=0X3F3F3F3F3F3F3F3FLL; const int N=200005; int n,Q,_w[N],_v[N],id[N],_id[N]; LL _a[N],sw0[N*4][18],sv0[N*4][18],sw1[N*4][18]; void bud(int k1,int k2,int k3,int k4,int k5){ if(k2>k5||k3<k4)return; if(k2==k3){ rep(k,1,17){ if(_w[id[k2]]<(1<<k)){ sw0[k1][k]=_a[id[k2]]*_w[id[k2]]; sv0[k1][k]=_a[id[k2]]*_v[id[k2]]; } sw1[k1][k]=INFLL; if(_w[id[k2]]>=(1<<(k-1))&&_w[id[k2]]<(1<<k)&&_a[id[k2]]){ sw1[k1][k]=_w[id[k2]]; } } return; } int mid=(k2+k3)>>1; bud(k1*2,k2,mid,k4,k5),bud(k1*2+1,mid+1,k3,k4,k5); rep(k,1,17){ sw0[k1][k]=sw0[k1*2][k]+sw0[k1*2+1][k]; sv0[k1][k]=sv0[k1*2][k]+sv0[k1*2+1][k]; if(sw1[k1*2][k]<sw0[k1*2][k-1]+sw1[k1*2+1][k]){ sw1[k1][k]=sw1[k1*2][k]; }else{ sw1[k1][k]=sw0[k1*2][k-1]+sw1[k1*2+1][k]; } } } void add(int x,int y){ _a[x]+=y; bud(1,1,n,_id[x],_id[x]); } LL rem,vv; int _k; void clip(){ while(_k>0&&(1<<(_k-1))>rem)--_k; } void qry(int k1,int k2,int k3){ if(k2==k3){ LL tt=min(_a[id[k2]],rem/_w[id[k2]]); rem-=tt*_w[id[k2]]; vv+=tt*_v[id[k2]]; return; } int mid=(k2+k3)>>1; clip(); if(sw0[k1][_k]<=rem){ rem-=sw0[k1][_k]; vv+=sv0[k1][_k]; return; } if(sw1[k1][_k]>rem&&sw0[k1][_k-1]<=rem){ rem-=sw0[k1][_k-1]; vv+=sv0[k1][_k-1]; return; } qry(k1*2,k2,mid); clip(); qry(k1*2+1,mid+1,k3); } void sol(LL x){ _k=17,rem=x,vv=0; clip(); qry(1,1,n); printf( %lld n ,vv); } int main(){ #ifdef xay5421 freopen( a.in , r ,stdin); #endif scanf( %d%d ,&n,&Q); rep(i,1,n){ scanf( %lld%d%d ,&_a[i],&_w[i],&_v[i]); id[i]=i; } sort(id+1,id+1+n,[&](int x,int y){return _v[x]^_v[y]?_v[x]>_v[y]:_w[x]<_w[y];}); rep(i,1,n)_id[id[i]]=i; bud(1,1,n,1,n); while(Q--){ int t; scanf( %d ,&t); if(t==1){ int x,y; scanf( %d%d ,&x,&y); add(y,x); }else if(t==2){ int x,y; scanf( %d%d ,&x,&y); add(y,-x); }else{ LL x; scanf( %lld ,&x); sol(x); } } return 0; }

#include <bits/stdc++.h> using namespace std; const double EPS = 1e-10; int main() { ios_base::sync_with_stdio(0); cin.tie(0); int ax, ay, bx, by, cx, cy; cin >> ax >> ay >> bx >> by >> cx >> cy; complex<long double> a(ax, ay), b(bx, by), c(cx, cy); long double d1 = abs(b - a), d2 = abs(c - b); long double ang1 = arg(b - a), ang2 = arg(c - b); cout << ((abs(d1 - d2) < EPS && abs(ang1 - ang2) > EPS) ? Yes : No ) << endl; }

#include <bits/stdc++.h> using namespace std; int main() { long long a, b, c; cin >> a >> b >> c; cout << (a / c + (a % c != 0)) * (b / c + (b % c != 0)); return 0; }

#include <bits/stdc++.h> using namespace std; template <typename T> inline void upmin(T &x, T y) { y < x ? x = y : 0; } template <typename T> inline void upmax(T &x, T y) { x < y ? x = y : 0; } const long double pi = acos(-1); const int oo = 1 << 30; const long long OO = 1e18; const int N = 1e5 + 100; int gi() { int w = 0; bool q = 1; char c = getchar(); while ((c < 0 || c > 9 ) && c != - ) c = getchar(); if (c == - ) q = 0, c = getchar(); while (c >= 0 && c <= 9 ) w = w * 10 + c - 0 , c = getchar(); return q ? w : -w; } int w[N]; int p[N]; inline int phi(int n) { int ans = n; for (int i = 2; i <= n; i++) if (!(n % i)) { ans = ans / i * (i - 1); while (!(n % i)) n /= i; } return ans; } inline int mul(int x, int y, int mod) { return 1LL * x * y >= mod ? 1LL * x * y % mod + mod : x * y; } inline int qpow(int x, int y, int mod) { int ans = 1; while (y) { if (y & 1) ans = mul(ans, x, mod); x = mul(x, x, mod); y >>= 1; } return ans; } int main() { int n = gi(), i, Q, m, l, r, ans; p[0] = gi(); for (m = 0; p[m] != 1; p[m + 1] = phi(p[m]), m++) ; p[m + 1] = 1; for (i = 1; i <= n; i++) w[i] = gi(); Q = gi(); while (Q--) { l = gi(), r = gi(); ans = 1; for (i = min(r - l, m); ~i; i--) ans = qpow(w[i + l], ans, p[i]); cout << ans % p[0] << endl; } return 0; }

#include <bits/stdc++.h> int a[100006]; int vis[100006]; int visyu[100006]; int main() { int n, x; scanf( %d%d , &n, &x); for (int i = 1; i <= n; i++) { scanf( %d , &a[i]); vis[a[i]]++; if (vis[a[i]] == 2) { printf( 0 n ); return 0; } } int mans = -1; for (int i = 1; i <= n; i++) { visyu[a[i] & x]++; if (visyu[a[i] & x] && vis[a[i] & x] && ((a[i] & x) != a[i])) { printf( 1 n ); return 0; } else if (visyu[a[i] & x] == 2) { mans = 2; } } printf( %d n , mans); }

#include <bits/stdc++.h> using namespace std; template <typename T> void Read(T &cn) { char c; int sig = 1; while (!isdigit(c = getchar())) if (c == - ) sig = -1; cn = c - 48; while (isdigit(c = getchar())) cn = cn * 10 + c - 48; cn *= sig; } template <typename T> void Write(T cn) { if (cn < 0) { putchar( - ); cn = 0 - cn; } int wei = 0; T cm = 0; int cx = cn % 10; cn /= 10; while (cn) wei++, cm = cm * 10 + cn % 10, cn /= 10; while (wei--) putchar(cm % 10 + 48), cm /= 10; putchar(cx + 48); } template <typename T> void Max(T &cn, T cm) { cn = cn < cm ? cm : cn; } template <typename T> void Min(T &cn, T cm) { cn = cn < cm ? cn : cm; } struct qwe { long long v, c; void getit() { Read(v); Read(c); } inline friend bool operator<(qwe a, qwe b) { return a.v == b.v ? a.c > b.c : a.v < b.v; } }; struct xian { long long k, b; long long suan(long long cn) { return (cn - b + k - 1) / k; } void mk(long long cn, long long cm) { k = cn; b = cm; } }; qwe a[200100 + 1]; int n; long long m; int xu[200100 + 1], xlen; long long f[200100 + 1], g[200100 + 1]; xian zhan[200100 + 1]; int l, r; int jiao_z(long long cn, xian A, xian B) { return cn * (A.k - B.k) <= (B.b - A.b); } int jiao(xian A, xian B, xian C) { double db1 = (B.b - A.b), db2 = (C.b - B.b); double dk1 = (A.k - B.k), dk2 = (B.k - C.k); return db1 * dk2 >= db2 * dk1; } long long qiu(int cn, int cm) { while (l < r && jiao_z(zhan[l].suan(cn), zhan[l], zhan[l + 1])) l++; if (l > r) return -10000000000000000; return -zhan[l].suan(cn) * (cm - zhan[l].k) - cn + zhan[l].b; } void zeng(int ck, long long cb) { xian lin; lin.mk(ck, cb); while (l < r && jiao(zhan[r - 1], zhan[r], lin)) r--; zhan[++r] = lin; } int main() { Read(n); Read(m); for (int i = 1; i <= n; i++) a[i].getit(); sort(a + 1, a + n + 1); xlen = 0; for (int i = 1; i <= n; i++) { if (a[i].v <= 0) continue; while (xlen && a[xu[xlen]].c > a[i].c) xlen--; xu[++xlen] = i; } for (int i = 1; i <= xlen; i++) a[i] = a[xu[i]]; n = xlen; f[0] = 0; a[0].v = a[0].c = 0; l = 1; r = 0; f[1] = 0; zeng(a[1].v, f[1]); long long ans = (m + a[1].v - 1) / a[1].v; for (int i = 2; i <= n; i++) { f[i] = qiu(a[i].c, a[i].v); zeng(a[i].v, f[i]); Min(ans, (m - f[i] + a[i].v - 1) / a[i].v); } Write(ans); puts( ); return 0; }

#include <bits/stdc++.h> using namespace std; const int maxn = 400010; int c[maxn]; int ans[maxn]; void upd(int n, int k) { n++; while (n < maxn) c[n] += k, n += n & (-n); } int get(int n) { n++; int ans = 0; while (n) ans += c[n], n -= n & (-n); return ans; } int BS(int n) { int l = 0, r = maxn - 1, mid; while (l < r) { mid = (l + r) / 2; if (get(mid) >= n) r = mid; else l = mid + 1; } return l; } int arr[maxn]; int a[maxn], b[maxn]; int main() { int n, i, j, k; cin >> n; for (i = 0; i < n; i++) cin >> a[i]; for (i = 0; i < n; i++) cin >> b[i]; for (i = 0; i < n; i++) upd(i, 1); for (i = 0; i < n; i++) { arr[i] += get(a[i]) - 1; upd(a[i], -1); } for (i = 0; i < n; i++) upd(i, 1); for (i = 0; i < n; i++) { arr[i] += get(b[i]) - 1; upd(b[i], -1); } for (i = n - 1; i >= 0; i--) { if (arr[i] <= n - i - 1) ; else { arr[i] %= n - i; if (i) arr[i - 1]++; } } for (i = 0; i < n; i++) upd(i, 1); for (i = 0; i < n; i++) ans[i] = BS(arr[i] + 1), upd(ans[i], -1); for (i = 0; i < n; i++) cout << ans[i] << ; puts( ); }

#include <bits/stdc++.h> using namespace std; class SegmentTree { public: SegmentTree(int _n) : n(_n), N(_n << 1), data(N, INT_MAX) { h = 0; while (1 << h <= N) { ++h; } } void build(vector<int>& nums) { copy(nums.begin(), nums.end(), data.begin() + n); for (int i = n - 1; i > 0; --i) { data[i] = min(data[i << 1], data[i << 1 | 1]); } } int get(int l, int r) { l += n; r += n; int res = INT_MAX; while (l <= r) { if (l & 0x1) { res = min(res, data[l++]); } if (!(r & 0x1)) { res = min(res, data[r--]); } l >>= 1; r >>= 1; } return res; } private: int N; int n; int h; vector<int> data; }; class SuffixArray { public: SuffixArray(const string& s) : N(s.length()), st(N + 100) { build(s); } const vector<int>& getSuffixArray() { return sa; } const vector<int>& getIndexArray() { return indices; } const vector<int>& getLcpArray() { return lcp; } long long lcpOf(int l, int r) { if (l == r) { return N - l; } l = indices[l]; r = indices[r]; if (l > r) { swap(l, r); } return st.get(l + 1, r); } private: int N; vector<int> sa; vector<int> indices; vector<int> lcp; SegmentTree st; struct Datum { public: Datum(int i = -1, int k0 = -1, int k1 = -1) : index(i), key0(k0), key1(k1) {} bool operator<(const Datum& other) const { return key0 == other.key0 ? key1 < other.key1 : key0 < other.key0; } int index; int key0; int key1; }; void build(const string& s) { N = s.length(); sa.clear(); sa.resize(N, -1); indices.clear(); indices.resize(N, -1); vector<Datum> data(N); for (int i = 0; i < N; ++i) { data[i].index = i; data[i].key0 = s[i]; } auto update = [&](int gap) { int idx = -1, preKey0 = -1, preKey1 = -1; for (int i = 0; i < N; ++i) { int key0 = data[i].key0, key1 = data[i].key1; if (key0 != preKey0 || key1 != preKey1) { data[i].key0 = ++idx; preKey0 = key0; preKey1 = key1; } else { data[i].key0 = idx; } indices[data[i].index] = i; } for (int i = 0; i < N; ++i) { int j = data[i].index + gap; if (j < N) { data[i].key1 = data[indices[j]].key0; } else { data[i].key1 = -1; } } }; sort(data.begin(), data.end()); int gap = 1; update(gap); while (gap <= N) { sort(data.begin(), data.end()); update(gap <<= 1); } for (int i = 0; i < N; ++i) { sa[i] = data[i].index; indices[sa[i]] = i; } buildLcp(s); } void buildLcp(const string& s) { lcp.clear(); lcp.resize(N, 0); int len = 0; for (int i = 0; i < N; ++i) { int idx = indices[i]; if (idx == 0) { lcp[idx] = 0; len = 0; continue; } int j = sa[idx - 1]; while (i + len < N && j + len < N && s[i + len] == s[j + len]) { ++len; } lcp[idx] = len; if (len > 0) { --len; } } st.build(lcp); } }; class Solution { public: Solution(const string& s) : N(s.length()), sfxArr(s), lcp(N + 1000, make_pair(-1, -1)), cnts(N + 1000, 0), sums(N + 1000, 0LL), S(s) {} long long query(vector<int>& A, int n, vector<int>& B, int m) { const auto& indices = sfxArr.getIndexArray(); auto cmp = [&](int l, int r) { return indices[l] < indices[r]; }; sort(A.begin(), A.begin() + n, cmp); sort(B.begin(), B.begin() + m, cmp); if (n > m) { swap(A, B); swap(n, m); } long long res = 0; int size = 0; long long sum = 0; for (int i = 0, j = 0; i < n || j < m;) { if (j == m) { break; } if (i < n && indices[A[i]] <= indices[B[j]]) { int len = 0; int cnt = 0; if (i == 0) { len = N - A[i]; cnt = 0; } else { len = sfxArr.lcpOf(A[i - 1], A[i]); cnt = 0; while (size > 0) { if (lcp[size - 1].first >= len) { sum -= 1LL * lcp[size - 1].first * lcp[size - 1].second; cnt += lcp[size - 1].second; --size; } else { break; } } } if (cnt > 0) { lcp[size].first = len; lcp[size].second = cnt; sum += 1LL * len * cnt; cnts[size + 1] = cnts[size] + cnt; sums[size + 1] = sum; ++size; } lcp[size].first = N - A[i]; lcp[size].second = 1; sum += N - A[i]; cnts[size + 1] = cnts[size] + 1; sums[size + 1] = sum; assert(cnts[size + 1] == i + 1); ++size; ++i; } else { if (i - 1 >= 0) { int len = sfxArr.lcpOf(A[i - 1], B[j]); auto it = lower_bound(lcp.begin(), lcp.begin() + size, make_pair(len, 0)); int idx = it - lcp.begin() - 1; if (idx < 0) { res += 1LL * len * i; } else { res += sums[idx + 1] + 1LL * len * (i - cnts[idx + 1]); } } ++j; } } size = 0; sum = 0; for (int i = n - 1, j = m - 1; i >= 0 || j >= 0;) { if (j < 0) { break; } if (i >= 0 && indices[A[i]] > indices[B[j]]) { int len = 0; int cnt = 0; if (i == n - 1) { len = N - A[i]; cnt = 0; } else { len = sfxArr.lcpOf(A[i + 1], A[i]); cnt = 0; while (size > 0) { if (lcp[size - 1].first >= len) { sum -= 1LL * lcp[size - 1].first * lcp[size - 1].second; cnt += lcp[size - 1].second; --size; } else { break; } } } if (cnt > 0) { lcp[size].first = len; lcp[size].second = cnt; sum += 1LL * len * cnt; cnts[size + 1] = cnts[size] + cnt; sums[size + 1] = sum; ++size; } lcp[size].first = N - A[i]; lcp[size].second = 1; sum += N - A[i]; cnts[size + 1] = cnts[size] + 1; sums[size + 1] = sum; assert(cnts[size + 1] == n - i); ++size; --i; } else { if (i + 1 < n) { int len = sfxArr.lcpOf(A[i + 1], B[j]); auto it = lower_bound(lcp.begin(), lcp.begin() + size, make_pair(len, 0)); int idx = it - lcp.begin() - 1; if (idx < 0) { res += 1LL * len * (n - i - 1); } else { res += sums[idx + 1] + 1LL * len * (n - i - 1 - cnts[idx + 1]); } } --j; } } return res; } private: int N; string S; SuffixArray sfxArr; vector<pair<int, int>> lcp; vector<int> cnts; vector<long long> sums; void check(vector<int>& A, int n, vector<int>& B, int m, long long res) { long long ans = 0; int N = S.length(); auto LCP = [&](int x, int y) { int res = 0; for (int i = x, j = y; i < N && j < N; ++i, ++j) { if (S[i] == S[j]) { ++res; } else { break; } } return res; }; for (int i = 0; i < n; ++i) { for (int j = 0; j < m; ++j) { int a = A[i], b = B[j]; ans += LCP(a, b); } } if (ans != res) { cout << ERROR: WA << got << res << but expected << ans << endl; } } }; void test() { vector<string> ts = {{ adsfadfqiewruypzdjfquwieroyzsdf , zduoifyqewrjhlzjkdhfvuioqerwy , adsfuiaednbklzjdrfyquioerwyhadnfb , aaaaaaaaaaaaaaa , axaaxadaxaacaaxxaad }}; cout << test << endl; for (auto s : ts) { Solution sol(s); int n = s.length(); vector<int> A(n); iota(A.begin(), A.end(), 0); vector<int> B(n); iota(B.begin(), B.end(), 0); sol.query(A, n, B, n); } } int main(int argc, char** argv) { ios::sync_with_stdio(false); cin.tie(0); int n, q; cin >> n >> q; string s; cin >> s; Solution sol(s); vector<int> A(n + 100); vector<int> B(n + 100); int k, l; while (q-- > 0) { cin >> k >> l; for (int i = 0; i < k; ++i) { cin >> A[i]; --A[i]; } for (int j = 0; j < l; ++j) { cin >> B[j]; --B[j]; } cout << sol.query(A, k, B, l) << endl; } return 0; }

#include <bits/stdc++.h> using namespace std; long long n, l, x, y; long long a[100100]; int main() { cin >> n >> l >> x >> y; for (int i = 0; i < n; i++) cin >> a[i]; bool fx = false, fy = false; for (int i = 0; i < n; i++) { if (binary_search(a, a + n, a[i] + x)) { fx = true; break; } } for (int i = 0; i < n; i++) { if (binary_search(a, a + n, a[i] + y)) { fy = true; break; } } if (fx && fy) { printf( 0 n ); return 0; } if (fx && !fy) { printf( 1 n ); cout << y << endl; return 0; } if (!fx && fy) { printf( 1 n ); cout << x << endl; return 0; } for (int i = 0; i < n; i++) { if (binary_search(a, a + n, a[i] + x + y)) { printf( 1 n ); cout << a[i] + x << endl; return 0; } } for (int i = 0; i < n; i++) { if (binary_search(a, a + n, a[i] + y - x)) { if (a[i] + y > l && a[i] - x < 0) continue; if (a[i] + y <= l) { printf( 1 n ); cout << a[i] + y << endl; } else { printf( 1 n ); cout << a[i] - x << endl; } return 0; } } printf( 2 n ); cout << x << << y << endl; return 0; }

#include <bits/stdc++.h> using namespace std; const int MAX = 500010; int n, m; int seg[MAX]; int vis[MAX]; int p[MAX]; int in[MAX], out[MAX]; int aux = 0; vector<int> adj[MAX]; set<int> s; int main() { ios_base::sync_with_stdio(0); cin.tie(0); int x, s; cin >> x >> s; if (!s) { if (x == 1) cout << 0 0 n ; else cout << -1 -1 n ; return 0; } if (9 * x < s) { cout << -1 -1 n ; return 0; } string sb; int s1 = s; for (int i = 1; i <= x; i++) { if (s > 9) sb += 9 , s -= 9; else if (i == x) sb += 0 + s; else if (s > 1) sb += 0 + (s - 1), s = 1; else sb += 0 ; } reverse(sb.begin(), sb.end()); cout << sb << n ; string st; for (int i = 1; i <= x; i++) { if (s1 >= 9) st += 9 , s1 -= 9; else st += s1 + 0 , s1 = 0; } cout << st << n ; }

#include <bits/stdc++.h> using namespace std; const long long N = 1e5 + 5; long long n, k; long long a[N]; bool check(long double x) { long double ans1 = 0, ans2 = 0; for (long long i = 0; i < n; i++) { if (a[i] > x) ans1 += (long double)(a[i] - x); if (x > a[i]) ans2 += (long double)(x - a[i]); } return ans1 * (100 - k) * 0.01 >= ans2; } int32_t main() { ios_base::sync_with_stdio(0); cin.tie(0); cin >> n >> k; for (long long i = 0; i < n; i++) cin >> a[i]; long double l = *min_element(a, a + n), r = *max_element(a, a + n) + 1; for (long long i = 0; i < 300; i++) { long double mid = (l + r) / 2; if (check(mid)) l = mid; else r = mid; } cout << fixed << setprecision(12); cout << l << n ; }

#include <bits/stdc++.h> using namespace std; long long a[100000]; int main() { long long n; long long cnt = 0; scanf( %I64d , &n); for (long long i = 0; i < n; i++) { scanf( %I64d , &a[i]); for (long long j = 0; j < i; j++) if (a[j] > a[i]) cnt++; } cout << (cnt % 2 + (cnt / 2) * 4) << endl; return 0; }

#include <bits/stdc++.h> using namespace std; int n; vector<int> v; map<int, int> a, b; int main() { ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0); cin >> n; int m = n / 2; if (n % 2 != 0) { m++; } for (int i = 1; i <= n; i++) { int x, y; cin >> x >> y; a[x]++; if (x != y) { b[y]++; } v.push_back(x); v.push_back(y); } int ans = 1e9; for (int i = 0; i < 2 * n; i++) { int cur = v[i]; int cnt = a[cur]; int need = max(0, m - cnt); if (b[cur] >= need) { ans = min(ans, need); } } if (ans == 1e9) { cout << -1; return 0; } cout << ans; }

#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); int n; cin >> n; int arr[n]; int count = 0; int count1 = 0; for (int i = 0; i < n; i++) { cin >> arr[i]; if (arr[i] & 1) { count++; } } int f[n]; int sum = 0; for (int i = 0; i < n; i++) { f[i] = floor(double(arr[i]) / 2); sum += f[i]; } for (int i = 0; i < n; i++) { if (sum == 0) break; if (arr[i] & 1) { sum++; f[i]++; } } for (int i = 0; i < n; i++) { cout << f[i] << endl; } return 0; }

#include <bits/stdc++.h> using namespace std; int mnt[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; int mntl[] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; int main() { int y1, y2, m1, m2, d1, d2, i, j, k, l, ans = 0; scanf( %d:%d:%d , &y1, &m1, &d1); scanf( %d:%d:%d , &y2, &m2, &d2); if (y1 == y2 && m1 == m2) cout << abs(d1 - d2); else { int chk1 = y1 * 365 + m1 * 30 + d1; int chk2 = y2 * 365 + m2 * 30 + d2; if (chk2 < chk1) { int tmp; tmp = y1; y1 = y2; y2 = tmp; tmp = m1; m1 = m2; m2 = tmp; tmp = d1; d1 = d2; d2 = tmp; } for (i = y1 + 1; i < y2; i++) { ans += 365; if (i % 400 == 0 || (i % 4 == 0 && i % 100 != 0)) ans += 1; } if ((y1 % 4 == 0 && y1 % 100 != 0) || (y1 % 400 == 0)) { int lm = 13; if (y1 == y2) lm = m2; for (i = m1 + 1; i < lm; i++) { ans += mntl[i - 1]; } ans += mntl[m1 - 1] - d1 + 1; } else { int lm = 13; if (y1 == y2) lm = m2; for (i = m1 + 1; i < lm; i++) { ans += mnt[i - 1]; } ans += mnt[m1 - 1] - d1 + 1; } if ((y2 % 4 == 0 && y2 % 100 != 0) || (y2 % 400 == 0)) { int lm = 1; if (y1 != y2) { for (i = lm; i < m2; i++) { ans += mntl[i - 1]; } } ans += d2 - 1; } else { int lm = 1; if (y1 != y2) { for (i = lm; i < m2; i++) { ans += mnt[i - 1]; } } ans += d2 - 1; } cout << ans << endl; } return 0; }

#include <bits/stdc++.h> using namespace std; inline void io() { freopen( input.txt , r , stdin); freopen( output.txt , w , stdout); } long long I() { long long a; cin >> a; return a; } void PV(vector<long long> v) { for (long long i = 0; i < (long long)v.size(); i++) cout << v[i] << ; cout << n ; } void PA(long long v[], long long n, long long x = 0) { for (long long i = x; i < n + x; i++) cout << v[i] << ; cout << n ; } void IA(long long a[], long long n, long long x = 0) { for (long long i = x; i < n + x; i++) cin >> a[i]; } const long long N = (2e5) + 7, N1 = 1e9 + 7, MOD = 1e9 + 7, INF = (1e17 + 7); long long fact[N]; long long power(long long a, long long b) { long long k = 1; for (; b; b /= 2, a = a * a % MOD) if (b % 2 == 1) k = k * a % MOD; return k % MOD; } void pre() { fact[0] = 1; for (long long i = 1; i < N; i++) fact[i] = (fact[i - 1] * i) % N1; } void solve() { long long n; cin >> n; long long ans = fact[2 * n] * (power(2, N1 - 2)); ans %= MOD; cout << ans << n ; } signed main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); long long t1 = 1, x0 = 1; pre(); cin >> t1; while (t1--) { solve(); } }

#include <bits/stdc++.h> using namespace std; stack<int> sk; int main() { int T; string s; cin >> T; while (T--) { while (sk.size()) sk.pop(); cin >> s; int cnt = 0; for (int i = 0; i < s.size(); ++i) { if (sk.empty()) { sk.push(s[i] - 0 ); continue; } if (s[i] == 0 && sk.top() == 1) { cnt++; sk.pop(); } else if (s[i] == 1 && sk.top() == 0) { cnt++; sk.pop(); } else sk.push(s[i] - 0 ); } if (cnt % 2) puts( DA ); else puts( NET ); } return 0; }

#include <bits/stdc++.h> using namespace std; int main() { int n, m, i, j, k, chng_cnt; cin >> n >> m; int ara1[n + 1], ara2[n + 1], cnt[m + 1], maximizedMin; memset(cnt, 0, sizeof(cnt)); memset(ara1, 0, sizeof(ara1)); memset(ara2, 0, sizeof(ara2)); for (i = 1; i <= n; i++) { cin >> ara1[i]; } maximizedMin = n / m; for (i = 1; i <= n; i++) { if (ara1[i] > m) { ara2[i] = -1; } else { cnt[ara1[i]]++; if (cnt[ara1[i]] <= maximizedMin) { ara2[i] = ara1[i]; } else { ara2[i] = -1; } } } chng_cnt = 0; for (i = 1; i <= m; i++) { if (cnt[i] < maximizedMin) { for (j = 1; j <= n; j++) { if (cnt[i] == maximizedMin) break; if (ara2[j] == -1) { ara2[j] = i; cnt[i]++; chng_cnt++; } } } } for (i = 1; i <= n; i++) { if (ara2[i] == -1) { ara2[i] = ara1[i]; } } printf( %d %d n , maximizedMin, chng_cnt); for (i = 1; i <= n; i++) { if (i == n) printf( %d n , ara2[i]); else printf( %d , ara2[i]); } return 0; }

#include <bits/stdc++.h> using namespace std; const int N = 1111; const int M = 33333; const int INF = 2e9 + 9; int n, m; int s, t; int erased_edge; struct Edge { int u, v, c; Edge() {} Edge(int u, int v, int c) { this->u = u; this->v = v; this->c = c; } int to(int node) { return u ^ node ^ v; } } E[M]; vector<int> a[N]; vector<int> path; vector<int> findPath() { queue<int> Q; vector<int> trace(n + 1, -1); trace[t] = 0; Q.push(t); while (!Q.empty()) { int u = Q.front(); Q.pop(); for (int e : a[u]) if (erased_edge != e) { int v = E[e].to(u); if (trace[v] != -1) continue; trace[v] = e; Q.push(v); } } vector<int> ans; if (trace[s] == -1) return ans; for (int u = s; u != t; u = E[trace[u]].to(u)) { ans.push_back(trace[u]); } return ans; } vector<int> solveOneEdge() { int best = INF; int ans = -1; for (int e : path) { erased_edge = e; if (findPath().empty() && best > E[e].c) { best = E[e].c; ans = e; } } vector<int> res; res.push_back(best); res.push_back(ans); return res; } int timer = 0; int parent_edge[N], parent_cost[N]; int num[N], low[N]; bool containST[N]; void dfs(int u) { ; num[u] = ++timer; low[u] = INF; containST[u] = u == t; for (int e : a[u]) { if (e == erased_edge || e == parent_edge[u]) continue; int v = E[e].to(u); if (num[v]) { ; low[u] = min(low[u], num[v]); } else { parent_edge[v] = e; parent_cost[v] = E[e].c; dfs(v); low[u] = min(low[u], low[v]); containST[u] |= containST[v]; } } } vector<int> solveTwoEdge() { int best = INF; int ans1 = -1, ans2 = -1; for (int e : path) { erased_edge = e; timer = 0; fill(parent_edge + 1, parent_edge + n + 1, 0); fill(num + 1, num + n + 1, 0); fill(containST + 1, containST + n + 1, 0); parent_edge[s] = -1; ; dfs(s); for (int v = 1; v <= n; ++v) if (v != s && low[v] >= num[v] && containST[v]) { if (best > E[erased_edge].c + parent_cost[v]) { best = E[erased_edge].c + parent_cost[v]; ans1 = erased_edge; ans2 = parent_edge[v]; }; ; } } vector<int> res; res.push_back(best); res.push_back(ans1); res.push_back(ans2); return res; } int main() { ios_base ::sync_with_stdio(0); cin >> n >> m; cin >> s >> t; for (int i = 1; i <= m; ++i) { int u, v, c; cin >> u >> v >> c; E[i] = Edge(u, v, c); a[u].push_back(i); a[v].push_back(i); } ::path = findPath(); ; if (::path.empty()) { cout << 0 << n << 0 << n ; return 0; } vector<int> one = solveOneEdge(); vector<int> two = solveTwoEdge(); int mn = min(one[0], two[0]); if (mn == INF) { cout << -1 n ; return 0; } if (one[0] < two[0]) { cout << one[0] << n << 1 << n << one[1] << n ; return 0; } cout << two[0] << n << 2 << n << two[1] << << two[2] << n ; }

#include <bits/stdc++.h> using namespace std; int main() { long long i, j, k, n, arr[200010]; cin >> n; for (i = 0; i < n; i++) cin >> arr[i]; long long sum = arr[n - 1]; for (i = n - 1; i > 0; i--) { if (arr[i] <= arr[i - 1] && arr[i - 1] != 0) { if (arr[i] == 0) arr[i - 1] = arr[i]; else arr[i - 1] = arr[i] - 1; } sum += arr[i - 1]; } cout << sum; }

#include <bits/stdc++.h> using namespace std; const int MOD = 1e9 + 7; const int SIZE = 1e6 + 10; const int INF = 2147483647; template <class T> void maa(T& x, T y) { if (x < y) x = y; } template <class T> void mii(T& x, T y) { if (x > y) x = y; } int a[SIZE]; int record[SIZE][3], rn; void update_answer(int ll, int rr, int cul) { record[rn][0] = ll; record[rn][1] = rr; record[rn][2] = cul; rn++; } int C, l[SIZE], r[SIZE], c[SIZE], cn, cc_pos[SIZE]; pair<int, int> cc[SIZE]; vector<pair<int, int> > qq; int single_add[SIZE]; int kerker[SIZE]; set<pair<int, int> > singles; pair<int, int> BIT[SIZE][2]; void ins(int x, int v) { pair<int, int> me = make_pair(v, x); for (; x < SIZE; x += x & -x) { if (me > BIT[x][0]) { if (BIT[x][0].second != me.second) { BIT[x][1] = BIT[x][0]; } BIT[x][0] = me; } else if (me > BIT[x][1]) { BIT[x][1] = me; } } } int qq_BIT(int x, int id) { int res = 0; for (; x; x -= x & -x) { if (BIT[x][0].second != id) res = max(res, BIT[x][0].first); else res = max(res, BIT[x][1].first); } return res; } void update_single(int id, int v) { single_add[id] += v; ins(cc_pos[id], single_add[id]); } int get_single_ma(int id) { int it = upper_bound(cc + 1, cc + cn, make_pair(C - c[id], INF)) - cc - 1; if (it) { return qq_BIT(it, cc_pos[id]); } return 0; } pair<int, int> GP(int x, int y) { if (x > y) return make_pair(y, x); return make_pair(x, y); } int an[SIZE]; int main() { int n; scanf( %d%d , &(n), &(C)); vector<pair<int, int> > rain; cn = 1; for (int i = (1); i < (n + 1); ++i) { scanf( %d%d%d , &(l[i]), &(r[i]), &(c[i])); rain.push_back(make_pair(l[i], i)); rain.push_back(make_pair(r[i], -i)); cc[cn++] = make_pair(c[i], i); } sort(cc + 1, cc + cn); for (int i = (1); i < (cn); ++i) cc_pos[cc[i].second] = i; sort((rain).begin(), (rain).end()); rain.push_back(make_pair(2000000000, 0)); int(m); scanf( %d , &m); for (int i = 0; i < (m); ++i) { int(x); scanf( %d , &x); qq.push_back(make_pair(x, i)); } sort((qq).begin(), (qq).end()); map<pair<int, int>, int> pair_add; set<int> now; int zero = 0; int pair_ma = 0; if (rain[0].first) { update_answer(0, rain[0].first, 0); zero += rain[0].first; } for (int i = 0, j; i < 2 * n; i = j) { for (j = i; j < 2 * n && rain[j].first == rain[i].first; j++) { int id = rain[j].second; if (id < 0) { now.erase(-id); } else { now.insert(id); } } if (((int)(now).size()) == 0) { update_answer(rain[i].first, rain[j].first, zero + max(pair_ma, get_single_ma(0))); zero += rain[j].first - rain[i].first; } else if (((int)(now).size()) == 1) { int me = *now.begin(); if (c[me] <= C) { int v = single_add[me] + max(get_single_ma(me), kerker[me]); update_answer(rain[i].first, rain[j].first, zero + v); update_single(me, rain[j].first - rain[i].first); maa(pair_ma, v + rain[j].first - rain[i].first); } } else if (((int)(now).size()) == 2) { int me = *now.begin(); int you = *now.rbegin(); if (c[me] + c[you] <= C) { update_answer( rain[i].first, rain[j].first, zero + single_add[me] + single_add[you] + pair_add[GP(me, you)]); pair_add[GP(me, you)] += rain[j].first - rain[i].first; maa(pair_ma, single_add[me] + single_add[you] + pair_add[GP(me, you)]); maa(kerker[me], pair_add[GP(me, you)] + single_add[you]); maa(kerker[you], pair_add[GP(me, you)] + single_add[me]); } } } { int it = 0; for (int i = 0; i < (rn); ++i) { while (it < m && record[i][1] - record[i][0] + record[i][2] >= qq[it].first) { an[qq[it].second] = record[i][0] + (qq[it].first - record[i][2]); it++; } } } for (int i = 0; i < (m); ++i) printf( %d n , an[i]); return 0; }

#include <bits/stdc++.h> using namespace std; int main() { long long n, k; cin >> n >> k; string s; cin >> s; if (k == 0) { cout << s; return 0; } if (s.length() == 1) { if (k > 0) { cout << 0 ; return 0; } } if (s[0] != 1 ) { s[0] = 1 ; k--; } for (long long i = 1; i < n; i++) { if (k > 0) if (s[i] != 0 ) { s[i] = 0 ; k--; } } cout << s; }

#include <bits/stdc++.h> using namespace std; int main() { int test; scanf( %d , &test); while (test--) { int fuck; string str; scanf( %d , &fuck); cin >> str; string ans = ; for (auto &x : str) { if ((x - 0 ) % 2 == 1) { ans += x; if (ans.size() == 2) { break; } } } if (ans.size() == 2) { puts(ans.c_str()); continue; } puts( -1 ); } return 0; }

#include <bits/stdc++.h> using namespace std; map<long long, int> MP; int Q = 1; vector<pair<int, int> > adj[500005]; long long C[500005]; set<int> S; int p[500005]; long long pw(int x) { if (!x) return 1LL; if (x & 1) return 2 * pw(x - 1) % 1000000007; long long hf = pw(x / 2); return hf * hf % 1000000007; } int par(int x) { if (p[x] == x) return x; return p[x] = par(p[x]); } int main() { int N, M, K; scanf( %d%d%d , &N, &M, &K); long long X = (1LL << K); for (int i = 1; i <= N; i++) scanf( %lld , &C[i]); for (int i = 0; i < M; i++) { int u, v; scanf( %d%d , &u, &v); long long x = C[u] ^ C[v]; int t = MP[x]; if (!t) { MP[x] = Q; adj[Q].push_back(pair<int, int>(u, v)); Q++; } else { adj[t].push_back(pair<int, int>(u, v)); } } int ans = 0; for (int i = 1; i <= N; i++) p[i] = i; for (int i = 1; i < Q; i++) { int sz = N; for (pair<int, int> j : adj[i]) { int u = j.first, v = j.second; S.insert(u); S.insert(v); if (par(u) != par(v)) { sz--; p[p[v]] = p[u]; } } ans = (ans + pw(sz)) % 1000000007; while (S.size()) { int now = *(S.begin()); p[now] = now; S.erase(S.begin()); } } printf( %lld n , ((X - Q + 1) % 1000000007 * pw(N) % 1000000007 + ans) % 1000000007); return 0; }

#include <bits/stdc++.h> using namespace std; template <typename T, typename L> bool smax(T &x, L y) { return x < y ? (x = y, true) : false; } struct Q { int p, id; }; int get(int, int); void dfs(int); void sack(int, bool); const int MAXN = 1e5 + 15, LG = 20; int h[MAXN], cnt[MAXN]; int st[MAXN], ft[MAXN], add[MAXN]; int ans[MAXN]; int par[LG][MAXN]; vector<int> adj[MAXN]; vector<Q> node[MAXN]; int n, m; int32_t main() { ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0); cerr << HELLO WORLD :) n ; cin >> n; for (int i = 1; i <= n; i++) { int tmp; cin >> tmp; adj[tmp].push_back(i); } dfs(0); cin >> m; for (int i = 1; i <= m; i++) { int p, v; cin >> v >> p; node[get(v, p)].push_back({p, i}); } sack(0, 0); for (int i = 1; i <= m; i++) cout << ans[i] << ; return cout << n , false; } void dfs(int v) { static int t = 0; st[v] = t++; add[st[v]] = v; for (int i = 1; i < LG; i++) par[i][v] = par[i - 1][par[i - 1][v]]; for (auto u : adj[v]) { h[u] = h[v] + 1; par[0][u] = v; dfs(u); } ft[v] = t; } int get(int v, int p) { int u = v; for (int i = LG - 1; ~i; i--) if (p >> i & 1) u = par[i][u]; return u; } void sack(int v, bool keep) { int id = -1, mx = -1; for (auto u : adj[v]) if (smax(mx, ft[u] - st[u])) id = u; for (auto u : adj[v]) if (u != id) sack(u, 0); if (id != -1) sack(id, 1); for (auto u : adj[v]) if (u != id) for (int i = st[u]; i < ft[u]; i++) cnt[h[add[i]]]++; cnt[h[v]]++; if (v) for (auto u : node[v]) ans[u.id] = cnt[h[v] + u.p] - 1; if (!keep) for (int i = st[v]; i < ft[v]; i++) cnt[h[add[i]]]--; }

#include <bits/stdc++.h> using namespace std; vector<vector<int> > g, tr, comp; vector<int> us, vis, whr, col; void dfs(int v) { us[v] = 1; for (int i = 0; i < g[v].size(); i++) { int j = g[v][i]; if (!us[j]) dfs(j); } vis.push_back(v); return; } void dfstr(int v) { comp[comp.size() - 1].push_back(v); whr[v] = comp.size() - 1; us[v] = 1; for (int i = 0; i < tr[v].size(); i++) { int j = tr[v][i]; if (!us[j]) dfstr(j); } return; } void doit(int v, int c) { us[v] = 1; if ((v & 1) ^ c) col[v / 2] = 1; else col[v / 2] = 0; for (int i = 0; i < g[v].size(); i++) { int j = g[v][i]; if (!us[j]) doit(j, c); } return; } int main() { iostream::sync_with_stdio(0); cin.tie(0), cout.tie(0); int n; cin >> n; vector<string> all(n); vector<pair<string, string> > add(n); for (int i = 0; i < n; i++) { string s, c; cin >> s >> c; all[i] = s.substr(0, 2); add[i].first = s.substr(2, 1); add[i].second = c.substr(0, 1); } g.resize(2 * n); tr.resize(2 * n); for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { if (i == j) continue; if (all[i] + add[i].first == all[j] + add[j].first) { g[2 * i].push_back(2 * j + 1); g[2 * j].push_back(2 * i + 1); tr[2 * j + 1].push_back(2 * i); tr[2 * i + 1].push_back(2 * j); g[2 * i + 1].push_back(2 * j + 1); g[2 * j + 1].push_back(2 * i + 1); tr[2 * i + 1].push_back(2 * j + 1); tr[2 * j + 1].push_back(2 * i + 1); } if (all[i] + add[i].first == all[j] + add[j].second) { g[2 * i].push_back(2 * j); g[2 * j + 1].push_back(2 * i + 1); tr[2 * j].push_back(2 * i); tr[2 * i + 1].push_back(2 * j + 1); } if (all[i] + add[i].second == all[j] + add[j].second) { g[2 * i + 1].push_back(2 * j); g[2 * j + 1].push_back(2 * i); tr[2 * j].push_back(2 * i + 1); tr[2 * i].push_back(2 * j + 1); } if (all[i] + add[i].second == all[j] + add[j].first) { g[2 * i + 1].push_back(2 * j + 1); g[2 * j].push_back(2 * i); tr[2 * j + 1].push_back(2 * i + 1); tr[2 * i].push_back(2 * j); } } } us.resize(2 * n, 0); for (int i = 0; i < 2 * n; i++) { if (!us[i]) { dfs(i); } } us.assign(2 * n, 0); whr.resize(2 * n); for (int i = 2 * n - 1; i >= 0; i--) { int x = vis[i]; if (!us[x]) { comp.emplace_back(vector<int>()); dfstr(x); } } for (int i = 0; i < n; i++) { if (whr[2 * i] == whr[2 * i + 1]) { cout << NO n ; return 0; } } col.resize(n); us.assign(2 * n, 0); reverse(comp.begin(), comp.end()); for (int i = 0; i < comp.size(); i++) { for (int j = 0; j < comp[i].size(); j++) { if (!us[comp[i][j]]) doit(comp[i][j], 1); } } cout << YES n ; for (int i = 0; i < n; i++) { cout << all[i] << (col[i] == 0 ? add[i].first : add[i].second) << n ; } return 0; }

#include <bits/stdc++.h> using namespace std; const long long int conv[][3] = {{1, 2, 3}, {2, 3, 1}, {3, 1, 2}}; void solve(long long int n) { int r = n % 3; if (r != 0) n = (n / 3 + 1) * 3; if (r == 0) r = 2; else r = r - 1; int k = 0; long long int cnt = 3; while (cnt < n) { k++; cnt += 3 * pow(4, k); } cnt -= 3 * pow(4, k); cnt = n - cnt; vector<int> v(k + 1); v[0] = 1; int j; for (int i = 1; i < k + 1; i++) { for (j = 0; j < 4; j++) { cnt -= 3 * pow(4, k - i); if (cnt <= 0) { cnt += 3 * pow(4, k - i); break; } } v[i] = j; } long long int ans = 0; for (int i = 0; i < k + 1; i++) { if (v[i] > 0) { ans += conv[v[i] - 1][r] << (2 * (k - i)); } } printf( %lld n , ans); } int main() { int t; long long int n; scanf( %d , &t); while (t--) { scanf( %lld , &n); solve(n); } return 0; }

#include <bits/stdc++.h> using namespace std; const long long inf = 9.2e18; const int maxn = 1e6 + 70; const int INF = 2.1e9; const int maxm = 1e6 + 70; const int MOD = 1e9 + 7; const double eps = 1e-7; const double PI = acos(-1.0); int n, m, k; vector<int> G[maxn]; int dep[maxn], mind[maxn], dp[maxn]; int dfs(int u) { if (!G[u].size()) { mind[u] = dep[u] - k; dp[u] = 1; return 1; } else { int mx = 0; mind[u] = dep[u]; dp[u] = 0; for (int i = 0; i < G[u].size(); i++) { int v = G[u][i]; dep[v] = dep[u] + 1; int val = dfs(v); mind[u] = min(mind[u], mind[v]); if (mind[v] <= dep[u]) { dp[u] += dp[v]; mx = max(mx, val - dp[v]); } else { mx = max(mx, val); } } return dp[u] + mx; } } int main() { while (cin >> n >> k) { for (int i = 1; i <= n; i++) G[i].clear(); for (int i = 2; i <= n; i++) { int f; scanf( %d , &f); G[f].push_back(i); } dep[1] = 0; int ans = dfs(1); cout << ans << endl; } return 0; }

#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(0); cin.tie(0); long long n, d, a, b, x, y; cin >> n >> d >> a >> b; pair<long long, long long> arr[n]; for (int i = 0; i < n; i++) { cin >> x >> y; x *= a; y *= b; arr[i] = {x + y, i + 1}; } sort(arr, arr + n); vector<int> vec; for (int i = 0; i < n; i++) { if (d >= arr[i].first) { d -= arr[i].first; vec.push_back(arr[i].second); } else break; } cout << vec.size() << endl; for (int i = 0; i < vec.size(); i++) cout << vec[i] << ; return 0; }

#include <bits/stdc++.h> using namespace std; long long gcd(long long a, long long b) { if (b == 0) return a; else return gcd(b, a % b); } const int maxn = 5e4 + 9; int p[1009], a[1009]; bool vis[1009]; int dfs(int i) { if (vis[i]) return i; vis[i] = 1; int id = dfs(p[i]); return id; } int main() { int n; cin >> n; for (int i = 1; i <= n; i++) { cin >> p[i]; } for (int i = 1; i <= n; i++) { memset(vis, 0, sizeof(vis)); a[i] = dfs(i); } for (int i = 1; i <= n; i++) { cout << a[i] << ; } cout << endl; return 0; }

#include <bits/stdc++.h> using namespace std; const long long int M = 1e3 + 7; map<long long int, long long int> value, visit; long long int n, m, points[M][M]; long long int bfs(long long int node) { long long int i; for (i = 1; i < n + 1; i++) { if (points[node][i] == 1) { if (value[i] == 0) { value[i] = value[node]; } else if (value[i] != 2 && value[i] != value[node]) return -1; } } return 0; } long long int check() { long long int i, j; for (i = 1; i < n + 1; i++) { for (j = 1; j < n + 1; j++) { if (points[i][j] == 1) { if ((value[i] == 1 && value[j] == 3) || (value[i] == 3 && value[j] == 1)) { return 0; } } } } } int main() { scanf( %lld , &n); scanf( %lld , &m); long long int i, j, a, b, cnta = 0, cntb = 0, cntc = 0; for (i = 0; i < m; i++) { scanf( %lld , &a); scanf( %lld , &b); points[a][b] = 1; points[b][a] = 1; } for (i = 1; i < n + 1; i++) { long long int flag = 1; for (j = 1; j < n + 1; j++) { if (points[i][j] == 0 && i != j) flag = 0; } if (flag == 1) { value[i] = 2; } } for (i = 1; i < n + 1; i++) { for (j = 1; j < n + 1; j++) { if (points[i][j] == 0 && i != j) { if (value[i] == 0 || value[j] == 0) { if (value[i] == 0 && value[j] == 0) { value[i] = 1; value[j] = 3; if (bfs(i) == -1) { printf( No n ); return 0; } if (bfs(j) == -1) { printf( No n ); return 0; } } else if (value[i] == 0) { value[i] = 4 - value[j]; if (bfs(i) == -1) { printf( No n ); return 0; } } else { value[j] = 4 - value[i]; if (bfs(j) == -1) { printf( No n ); return 0; } } } else if (value[i] == value[j]) { printf( No n ); return 0; } } } } if (check() == 0) { printf( No n ); return 0; } printf( Yes n ); for (i = 1; i < n + 1; i++) { if (value[i] == 1) printf( a ); else if (value[i] == 2) printf( b ); else printf( c ); } printf( n ); return 0; }

#include <bits/stdc++.h> using namespace std; const long long N = 1 << 17; const long long MN = N; long long s[MN]; long long m[MN]; long long rr[MN]; bool st[2 * N]; long long tme[2 * N]; long long lz[2 * N]; long long nn; vector<pair<long long, pair<long long, long long> > > manaFull[2 * N]; struct second { long long s, m, r; }; void f1(long long k, long long l, long long r) { for (long long i = l; i <= r; ++i) { if (rr[i]) { manaFull[k].push_back({m[i] / rr[i] + !!(m[i] % rr[i]), {m[i], rr[i]}}); } else { manaFull[k].push_back({1e18, {m[i], rr[i]}}); } } sort(manaFull[k].begin(), manaFull[k].end()); for (long long i = 1; i < manaFull[k].size(); ++i) { manaFull[k][i].second.first += manaFull[k][i - 1].second.first; } for (long long i = (long long)manaFull[k].size() - 1; i > 0; --i) { manaFull[k][i - 1].second.second += manaFull[k][i].second.second; } if (l == r) return; long long mid = (l + r) / 2; f1(k * 2, l, mid); f1(k * 2 + 1, mid + 1, r); } long long getFirstNotFull(long long k, long long t) { long long lo = 0; long long hi = (long long)manaFull[k].size() - 1; long long res = hi + 1; while (lo <= hi) { long long mid = (lo + hi) / 2; if (manaFull[k][mid].first > t) { hi = mid - 1; res = mid; } else { lo = mid + 1; } } return res; } void lol(long long k, long long l, long long r, long long t) { if (l < r && lz[k]) { lz[k] = 0; lz[k * 2] = 1; lz[k * 2 + 1] = 1; tme[k * 2] = tme[k]; tme[k * 2 + 1] = tme[k]; } } bool eka[2 * N]; long long absorbMana(long long k, long long l, long long r, long long x, long long y, long long t) { long long res = 0; if (l > y || r < x) return 0; if (l >= x && r <= y && lz[k]) { long long firstNotFull = getFirstNotFull(k, t - tme[k]); if (firstNotFull != 0) { res += manaFull[k][firstNotFull - 1].second.first; } long long sz = r - l + 1; if (firstNotFull != sz) res += (manaFull[k][firstNotFull].second.second) * (t - tme[k]); if (eka[k]) { eka[k] = 0; res = min(m[k - N], s[k - N] + (t - tme[k]) * rr[k - N]); } lz[k] = 1; tme[k] = t; return res; } lol(k, l, r, t); long long mid = (l + r) / 2; long long q = absorbMana(k * 2, l, mid, x, y, t); long long w = absorbMana(k * 2 + 1, mid + 1, r, x, y, t); if (l >= x && r <= y) { lz[k] = 1; tme[k] = t; } return q + w; } int main() { long long n; ios_base::sync_with_stdio(0); cin.tie(0); cin >> n; nn = n; for (long long i = 0; i < n; ++i) { cin >> s[i] >> m[i] >> rr[i]; lz[i + N] = 1; eka[i + N] = 1; } f1(1, 0, N - 1); long long m; cin >> m; for (long long i = 0; i < m; ++i) { long long t, l, r; cin >> t >> l >> r; cout << absorbMana(1, 0, N - 1, l - 1, r - 1, t) << n ; } }

#include<bits/stdc++.h> #define pb(x) push_back(x) #define all(x) x.begin(), x.end() #define N 200005 #define FIFO ios::sync_with_stdio(false) #define cout3(x, y, z) cout << x << << y << << z << endl #define cout2(x, y) cout << x << << y << endl #define INF (1<<30) #define MOD 1000000007 #define ones(x) __builtin_popcountll(x) #define EPS 1e-6 using namespace std; long double v; map<pair<long double, long double>, long double>memo; long double DP(long double c, long double m, long double p){ //cout3(c, m, p); if(c < EPS && m < EPS)return p; if(memo.find(make_pair(c, m)) != memo.end())return memo[make_pair(c, m)]; long double ans = 0; //chosing c if(c > EPS){ if(c + EPS <= v){ if(m > EPS)ans += c * (1 + DP(0, m + c/2., p + c/2.)); else ans += c * (1 + DP(0, m, p + c)); } else{ if(m > EPS)ans += c * (1 + DP(c - v, m + v/2, p + v/2)); else ans += c * (1 + DP(c - v, m, p + v)); } } if(m > EPS){ if(m + EPS <= v){ if(c > EPS)ans += m * (1 + DP(c + m/2, 0, p + m/2)); else ans += m * (1 + DP(c, 0, p + m)); } else{ if(c > EPS)ans += m * (1 + DP(c + v/2, m - v, p + v/2)); else ans += m * (1 + DP(c, m - v, p + v)); } } if(p > EPS)ans += p; return memo[make_pair(c, m)] = ans; } //string cases[7] = { 2 , 02 , 012 , 0112 , 12 , 102 , 1002 }; int main(){ FIFO; int tc = 0; cin >> tc; while(tc--){ long double c, m, p, ans = 0; cin >> c >> m >> p >> v; memo.clear(); cout << fixed << setprecision(6) << DP(c, m, p) << endl; /* for(int i = 0; i < 7; i++){ double curProp[] = {c, m, p}; bool ok = true; double prop = 1.0; for(int j = 0, id; j < cases[i].size() && ok; j++){ id = cases[i][j] - 0 ; if(curProp[id] == 0)ok = false; else{ prop *= curProp[id]; if(curProp[id] <= v){ vector<int>candidates; int len = 0; for(int l = 0; l < 3; l++)if(l != id && curProp[l] != 0)candidates.pb(l); len = candidates.size(); double add = curProp[id]/len; for(int l = 0; l < candidates.size(); l++)curProp[candidates[l]] += add; curProp[id] = 0; } else{ vector<int>candidates; int len = 0; for(int l = 0; l < 3; l++)if(l != id && curProp[l] != 0)candidates.pb(l); len = candidates.size(); double add = v/len; for(int l = 0; l < candidates.size(); l++)curProp[candidates[l]] += add; curProp[id] -= v; } } //for(int l = 0; l < 3; l++)cout << curProp[l] << ; //cout << endl; } //cout2(ok, prop); if(ok)ans += prop * cases[i].size(); } cout << ans << endl; */ } }

#include <bits/stdc++.h> using namespace std; const long long mod = 1e9 + 7; const long long mod1 = 998244353; long long power(long long a, long long b) { long long res = 1; while (b > 0) { if (b % 2 == 1) { res = (res * a) % mod; } a = (a * a) % mod; b >>= 1; } return res; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); int t; t = 1; long long lookup[1001][11]; for (int i = 0; i < 1001; i++) { for (int j = 0; j < 11; j++) { lookup[i][j] = 0; } } lookup[0][0] = 0; for (int i = 1; i <= 10; i++) { lookup[1][i] = 1; lookup[0][i] = 1; } for (int i = 1; i <= 1000; i++) { lookup[i][1] = i; lookup[i][0] = 1; } for (int i = 2; i <= 1000; i++) { for (int j = 2; j <= 10; j++) { lookup[i][j] += lookup[i - 1][j] + lookup[i][j - 1]; lookup[i][j] %= mod; } } while (t--) { int n, m; cin >> n >> m; long long ans = 0; long long temp1, temp2, temp3; for (int i = 1; i <= n; i++) { temp1 = n - i + 1; temp1 = lookup[temp1][m]; temp2 = i; temp2 = lookup[temp2][m - 1]; temp3 = (temp1 * temp2) % mod; ans += temp3; ans %= mod; } cout << ans; } }

#include <bits/stdc++.h> #pragma GCC optimize(2) #pragma GCC optimize(3) #pragma GCC optimize( Ofast ) #pragma GCC optimize( inline ) #pragma GCC optimize( -fgcse ) #pragma GCC optimize( -fgcse-lm ) #pragma GCC optimize( -fipa-sra ) #pragma GCC optimize( -ftree-pre ) #pragma GCC optimize( -ftree-vrp ) #pragma GCC optimize( -fpeephole2 ) #pragma GCC optimize( -ffast-math ) #pragma GCC optimize( -fsched-spec ) #pragma GCC optimize( unroll-loops ) #pragma GCC optimize( -falign-jumps ) #pragma GCC optimize( -falign-loops ) #pragma GCC optimize( -falign-labels ) #pragma GCC optimize( -fdevirtualize ) #pragma GCC optimize( -fcaller-saves ) #pragma GCC optimize( -fcrossjumping ) #pragma GCC optimize( -fthread-jumps ) #pragma GCC optimize( -funroll-loops ) #pragma GCC optimize( -fwhole-program ) #pragma GCC optimize( -freorder-blocks ) #pragma GCC optimize( -fschedule-insns ) #pragma GCC optimize( inline-functions ) #pragma GCC optimize( -ftree-tail-merge ) #pragma GCC optimize( -fschedule-insns2 ) #pragma GCC optimize( -fstrict-aliasing ) #pragma GCC optimize( -fstrict-overflow ) #pragma GCC optimize( -falign-functions ) #pragma GCC optimize( -fcse-skip-blocks ) #pragma GCC optimize( -fcse-follow-jumps ) #pragma GCC optimize( -fsched-interblock ) #pragma GCC optimize( -fpartial-inlining ) #pragma GCC optimize( no-stack-protector ) #pragma GCC optimize( -freorder-functions ) #pragma GCC optimize( -findirect-inlining ) #pragma GCC optimize( -fhoist-adjacent-loads ) #pragma GCC optimize( -frerun-cse-after-loop ) #pragma GCC optimize( inline-small-functions ) #pragma GCC optimize( -finline-small-functions ) #pragma GCC optimize( -ftree-switch-conversion ) #pragma GCC optimize( -foptimize-sibling-calls ) #pragma GCC optimize( -fexpensive-optimizations ) #pragma GCC optimize( -funsafe-loop-optimizations ) #pragma GCC optimize( inline-functions-called-once ) #pragma GCC optimize( -fdelete-null-pointer-checks ) using namespace std; const long long maxn = 1005; const long long maxm = 1000005; const long long dd = 998244353; long long n, m; long long a[maxm], sav[maxm], dp[maxn][maxn], col[maxn][maxn], L[maxn], R[maxn]; vector<long long> t[maxn]; struct nod { long long val, pos; } uni[maxm]; inline bool cmp(nod x, nod y) { return x.val < y.val; } inline long long read() { long long ret = 0, f = 1; char ch = getchar(); while (!isdigit(ch)) { if (ch == - ) f = -f; ch = getchar(); } while (isdigit(ch)) { ret = ret * 10 + ch - 0 ; ch = getchar(); } return ret * f; } void scan() { m = read(); n = read(); for (long long k = 1; k <= n; k++) { uni[k].val = read(); uni[k].pos = k; } } void prework() { long long lst = 0; sort(uni + 1, uni + n + 1, cmp); for (long long k = 1; k <= n; k++) { if (uni[k].val != uni[k - 1].val) lst++; sav[uni[k].pos] = lst; } m = lst; long long now = 0; for (long long k = 1; k <= n; k++) if (sav[k] != a[now]) a[++now] = sav[k]; n = now; for (long long k = 1; k <= n; k++) t[a[k]].push_back(k); for (long long k = 1; k <= m; k++) L[k] = t[k][0], R[k] = t[k][t[k].size() - 1]; for (long long k = 1; k <= m; k++) for (long long j = k + 1; j <= m; j++) if ((L[j] <= R[k] && R[k] < R[j]) || (R[j] >= L[k] && L[k] > L[j])) { puts( 0 ); exit(0); } for (long long k = 1; k <= n; k++) { long long now = k; for (long long j = k; j <= n; j++) col[k][j] = a[j] > a[now] ? now : now = j; } } void solve() { for (long long k = 0; k <= n + 1; k++) for (long long j = 0; j <= k; j++) dp[k][j] = 1; dp[0][1] = dp[1][1]; for (long long k = 2; k <= n; k++) { for (long long l = 1; l + k - 1 <= n; l++) { long long r = l + k - 1; long long x = col[l][r], siz = t[a[x]].size(); long long ll = L[a[x]], rr = R[a[x]]; long long ans1 = 0, ans2 = 0, ans3 = 1; for (long long k = l - 1; k < ll; k++) ans1 = (ans1 + dp[l][k] * dp[k + 1][ll - 1]) % dd; for (long long k = r + 1; k > rr; k--) ans2 = (ans2 + dp[k][r] * dp[rr + 1][k - 1]) % dd; dp[l][r] = ans1 * ans2 % dd; for (long long k = 0; k < siz - 1; k++) ans3 = ans3 * dp[t[a[x]][k] + 1][t[a[x]][k + 1] - 1] % dd; dp[l][r] = dp[l][r] * ans3 % dd; } } printf( %lld n , dp[1][n]); } signed main() { scan(); prework(); solve(); return 0; }

#include <bits/stdc++.h> using namespace std; const int N = 1e6 + 7; const int mod = 1e9 + 7; int n, m, f[N], jc[N], njc[N], ans; int qpow(int x, int y) { if (!x) return 0; int res = 1; for (; y; x = 1ll * x * x % mod, y >>= 1) if (y & 1) res = 1ll * res * x % mod; return res; } int ny(int x) { return qpow(x, mod - 2); } int C(int x, int y) { return 1ll * jc[x] * njc[x - y] % mod * njc[y] % mod; } int main() { scanf( %d%d , &n, &m); jc[0] = njc[0] = 1; for (int i = 1, iE = n; i <= iE; i++) jc[i] = 1ll * jc[i - 1] * i % mod, njc[i] = ny(jc[i]); ans = n; f[0] = 1; int sum = 1; for (int i = 1, iE = n - 1; i <= iE; i++) { f[i] = sum, f[i] = 1ll * f[i] * ny(i) % mod, (sum += f[i]) %= mod; if (i >= m) (sum += mod - f[i - m]) %= mod; } for (int i = 0, iE = n - 1; i <= iE; i++) (ans += mod - f[i]) %= mod; ans = 1ll * ans * jc[n - 1] % mod; printf( %d n , ans); return 0; }

#include <bits/stdc++.h> #pragma 03 using namespace std; int main() { cout << INTERCAL n ; return 0; }

#include <bits/stdc++.h> using namespace std; pair<int, int> a[26]; int b[26]; int main() { for (int i = 0; i < 26; i++) a[i].second = i; string s; cin >> s; int d; cin >> d; for (int i = 0; i < int(s.size()); i++) a[int(s[i] - a )].first++; sort(a, a + 26); int tmp = 0; for (int i = 0; i < 26; i++) if (d >= a[i].first) { b[tmp] = a[i].second; tmp++; d -= a[i].first; } bool g; cout << 26 - tmp << endl; for (int i = 0; i < int(s.size()); i++) { g = 1; for (int j = 0; j < tmp; j++) if (int(s[i] - a ) == b[j]) g = 0; if (g) cout << s[i]; } return 0; }

#include <bits/stdc++.h> using namespace std; int main() { long long int res = 0; int a[200005], n, i, mm = INT_MAX; scanf( %d , &n); for (i = 1; i <= n; ++i) { scanf( %d , &a[i]); mm = min(mm, a[i]); } set<int> second; for (i = 1; i <= n; ++i) if (a[i] == mm) second.insert(i); res = 1ll * mm * n; long long int mx = 0; for (i = 1; i <= n; ++i) { if (a[i] == mm) continue; auto it = second.upper_bound(i); if (it != second.end()) mx = max(mx, (long long int)(*it - i)); else mx = max(mx, (long long int)(n - i + *second.begin())); } res += mx; printf( %lld , res); return 0; }

#include <bits/stdc++.h> using namespace std; int points[11] = {0, 25, 18, 15, 12, 10, 8, 6, 4, 2, 1}; struct T { vector<int> a; string name; T() { for (int i = (1); i <= (55); i++) a.push_back(0); } bool operator<(const T &b) const { return a > b.a; } } ma[1100]; int n, games; map<string, int> name; int main() { cin >> games; while (games--) { int man; cin >> man; for (int i = (1); i <= (man); i++) { string s; cin >> s; int id = name[s]; if (id == 0) { id = name[s] = ++n; ma[id].name = s; } if (i <= 10) ma[id].a[0] += points[i]; ma[id].a[i]++; } } sort(ma + 1, ma + n + 1); cout << ma[1].name << endl; for (int i = (1); i <= (n); i++) swap(ma[i].a[0], ma[i].a[1]); sort(ma + 1, ma + n + 1); cout << ma[1].name << endl; return 0; }

#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(0); int n; while (cin >> n) { int pos, val; multimap<int, int> mp1, mp2; while (n--) { cin >> pos >> val; pos < 0 ? mp1.insert(pair<int, int>(pos, val)) : mp2.insert(pair<int, int>(pos, val)); } int min_size = min(mp1.size(), mp2.size()); multimap<int, int>::reverse_iterator it1 = mp1.rbegin(); multimap<int, int>::iterator it2 = mp2.begin(); long long ans = 0; for (int i = 0; i < min_size; ++i, ++it1, ++it2) ans += ((it1->second) + (it2->second)); if (mp1.size() > mp2.size()) ans += (it1->second); if (mp1.size() < mp2.size()) ans += (it2->second); cout << ans << endl; } return 0; }

#include <bits/stdc++.h> using namespace std; const int maxn = 3e5 + 10; vector<int> G[maxn]; int p[maxn], d[maxn], vis[maxn], mx, rt; int find(int x) { if (p[x] != x) p[x] = find(p[x]); return p[x]; } void dfs(int u, int fa, int dep, int tp) { vis[u] = 1; if (dep > mx) { mx = dep; if (!tp) rt = u; } if (tp) p[u] = rt; for (int i = 0; i < G[u].size(); i++) { int v = G[u][i]; if (v != fa) dfs(v, u, dep + 1, tp); } } int main() { int n, m, q, tp, u, v; scanf( %d%d%d , &n, &m, &q); for (int i = 1; i <= n; i++) p[i] = i; for (int i = 1; i <= m; i++) { scanf( %d%d , &u, &v); G[u].push_back(v); G[v].push_back(u); } for (int i = 1; i <= n; i++) if (!vis[i]) { mx = rt = 0; dfs(i, 0, 0, 0); dfs(rt, 0, 0, 1); d[rt] = mx; } while (q--) { scanf( %d , &tp); if (tp == 2) { scanf( %d%d , &u, &v); int fu = find(u), fv = find(v); if (fu != fv) { p[fu] = fv; int t1 = d[fu] / 2 + d[fu] % 2; int t2 = d[fv] / 2 + d[fv] % 2; d[fv] = max(d[fu], d[fv]); d[fv] = max(d[fv], t1 + t2 + 1); } } else { scanf( %d , &u); int fu = find(u); printf( %d n , d[fu]); } } }

#include <bits/stdc++.h> using namespace std; const int Maxn = 1010, Maxm = 20; const unsigned long long Seed = 19990213; const long long Mod = 1000000007; int n, m, cnt, tot1, fst1[Maxn], pre1[Maxn << 1], to1[Maxn << 1], tot2, fst2[Maxm], pre2[Maxm << 1], to2[Maxm << 1], bel[Maxm], tot[Maxm], stat[(1 << 12) + 10][Maxm], cur[Maxm], S, w[Maxm], size[Maxm]; bool vis[Maxn], leaf[Maxm]; long long f[Maxn][Maxm], g[Maxn][(1 << 12) + 10], ans; unsigned long long ha[Maxm]; map<unsigned long long, bool> Hash; vector<int> son[Maxn], sub[Maxm]; int Get() { char ch; int v = 0; bool f = false; while (!isdigit(ch = getchar())) if (ch == - ) f = true; v = ch - 48; while (isdigit(ch = getchar())) v = v * 10 + ch - 48; if (f) return -v; else return v; } void AddE1(int x, int y) { pre1[++tot1] = fst1[x], fst1[x] = tot1, to1[tot1] = y; pre1[++tot1] = fst1[y], fst1[y] = tot1, to1[tot1] = x; } void AddE2(int x, int y) { pre2[++tot2] = fst2[x], fst2[x] = tot2, to2[tot2] = y; pre2[++tot2] = fst2[y], fst2[y] = tot2, to2[tot2] = x; } bool cmp(const int &a, const int &b) { return ha[a] < ha[b] || (ha[a] == ha[b] && size[a] < size[b]); } void Add(long long &x, long long y) { x += y; if (x >= Mod) x -= Mod; } void Calc(int x, int fa) { leaf[x] = true, size[x] = 1; sub[x].clear(); for (int i = fst2[x]; i; i = pre2[i]) if (to2[i] != fa) { Calc(to2[i], x); size[x] += size[to2[i]]; sub[x].push_back(to2[i]); leaf[x] = false; } if (leaf[x]) ha[x] = 666072; else { ha[x] = 0; sort(sub[x].begin(), sub[x].end(), cmp); for (int i = 0; i < sub[x].size(); i++) ha[x] = (ha[x] * Seed + ha[sub[x][i]]) % Mod; ha[x] = ha[x] * 1234 % Mod; } } void Transform(int x, int w, int s) { if (x == cnt + 1) { S = max(S, s); for (int i = 1; i <= cnt; i++) stat[s][i] = cur[i]; return; } else { for (int i = 0; i <= tot[x]; i++) { cur[x] = i; Transform(x + 1, w * (tot[x] + 1), s + i * w); } } } void dfs(int x) { vis[x] = true; son[x].clear(); for (int i = fst1[x]; i; i = pre1[i]) if (!vis[to1[i]]) son[x].push_back(to1[i]), dfs(to1[i]); int len1 = int(son[x].size()); for (int i = 1; i <= m; i++) if (leaf[i]) f[x][i] = 1; else if (len1 > 0) { f[x][i] = 0, cnt = 0, S = 0; int len2 = int(sub[i].size()); for (int j = 0; j <= len2 - 1; j++) { bel[++cnt] = sub[i][j], tot[cnt] = 1; for (; j < len2 - 1 && ha[sub[i][j]] == ha[sub[i][j + 1]] && size[sub[i][j]] == size[sub[i][j + 1]]; j++) tot[cnt]++; } w[1] = 1; for (int j = 2; j <= cnt; j++) w[j] = w[j - 1] * (tot[j - 1] + 1); Transform(1, 1, 0); for (int s = 0; s <= S; s++) g[0][s] = 0; g[0][S] = 1; for (int j = 0; j <= len1 - 1; j++) { int u = son[x][j]; for (int s = 0; s <= S; s++) g[j + 1][s] = g[j][s]; for (int k = 1; k <= cnt; k++) { int v = bel[k]; if (f[u][v]) { for (int s = 0; s <= S; s++) if (stat[s][k]) { Add(g[j + 1][s - w[k]], g[j][s] * f[u][v] % Mod); } } } } f[x][i] = g[len1][0]; } } void solve(int root) { for (int i = 1; i <= n; i++) vis[i] = false; dfs(1); long long res = 0; for (int i = 1; i <= n; i++) { Add(ans, f[i][root]); Add(res, f[i][root]); for (int j = 1; j <= m; j++) f[i][j] = 0; } } int main() { n = Get(); int x, y; for (int i = 1; i <= n - 1; i++) x = Get(), y = Get(), AddE1(x, y); m = Get(); for (int i = 1; i <= m - 1; i++) x = Get(), y = Get(), AddE2(x, y); for (int i = 1; i <= m; i++) { Calc(i, -1); if (!Hash[ha[i]]) { Hash[ha[i]] = true; solve(i); } } cout << ans << endl; return 0; }

#include <bits/stdc++.h> using namespace std; int a[300005]; int lastone[300005]; int nextone[300005]; long long sum[300005]; vector<int> vt[3]; int main() { int n; scanf( %d , &n); for (int i = 1; i <= n; i++) { scanf( %d , &a[i]); sum[i] = sum[i - 1] + a[i]; lastone[i] = (a[i] == 1000) ? i : lastone[i - 1]; } for (int i = n; i >= 1; i--) { nextone[i] = (a[i] == 1000) ? i : nextone[i + 1]; } long long ans = sum[n]; for (int i = 1; i <= n; i++) { long long bonus = sum[i] / 10; long long rem = sum[n] - sum[i]; long long res = sum[i] + rem - min(rem, bonus); ans = min(ans, res); if (a[i] == 2000) { int las = lastone[i]; if (las) { res = sum[las - 1]; bonus = sum[las - 1] / 10; res += a[las] - min(a[las] + 0ll, bonus); bonus -= min(a[las] + 0ll, bonus); bonus += (sum[i] - sum[las]) / 10; res += (sum[i] - sum[las]); rem = sum[n] - sum[i]; res += rem - min(rem, bonus); ans = min(ans, res); } las = nextone[i + 1]; if (las) { res = sum[i]; bonus = sum[i] / 10; res += (sum[las - 1] - sum[i]) - min(sum[las - 1] - sum[i], bonus); bonus -= min(sum[las - 1] - sum[i], bonus); bonus += a[las] / 10; res += a[las]; rem = sum[n] - sum[las]; res += rem - min(rem, bonus); ans = min(ans, res); } } } printf( %lld n , ans); }

#include <bits/stdc++.h> using namespace std; const long long INF = 2000000000000000000; long double eps = 1e-12; long long t, n, m, a; vector<long long> vec; void Stefan() { cin >> n >> m; long long cur = 1; for (int i = 0; i < n; i++) { cin >> a; vec.push_back(a); } if (n > m) { cout << 0; return; } for (int i = 0; i < n; i++) { for (int j = i + 1; j < n; j++) { cur *= abs(vec[i] - vec[j]); cur %= m; if (!cur) { cout << 0; return; } } } cout << cur; } int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); t = 1; while (t) { Stefan(); t--; } }

#include <bits/stdc++.h> using namespace std; #define f first #define s second #define pb push_back #define ar array #define all(x) x.begin(), x.end() #define siz(x) (int)x.size() #define FOR(x, y, z) for(int x = (y); x < (z); x++) #define ROF(x, z, y) for(int x = (y-1); x >= (z); x--) #define F0R(x, z) FOR(x, 0, z) #define R0F(x, z) ROF(x, 0, z) #define trav(x, y) for(auto&x:y) using ll = long long; using vi = vector<int>; using vl = vector<long long>; using pii = pair<int, int>; using vpii = vector<pair<int, int>>; template<class T> inline bool ckmin(T&a, T b) {return b < a ? a = b, 1 : 0;} template<class T> inline bool ckmax(T&a, T b) {return b > a ? a = b, 1 : 0;} mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); const char nl = n ; const int mxN = 2e5 + 10; const int MOD = 1e9 + 7; const long long infLL = 1e18; struct dsu{ int n; vector<int> sz, par; void init(int _n){ n = _n; sz.resize(n); par.resize(n); F0R(i, n) sz[i] = 1, par[i] = i; } int find(int x){ return par[x] = ( x == par[x] ? par[x] : find(par[x])); } void comb(int a, int b) { a=find(a); b=find(b); if(a!=b) {sz[a]+=sz[b]; par[b] = a; } } }; #undef D #define D QWERWQWEQWEQWEQ dsu D; set<ar<int, 3>> pq; int32_t main(){ ios_base::sync_with_stdio(0); cin.tie(0); int n; cin >> n; vector<vi> a(n, vi(n)); vi par(n*10); D.init(10*n); vector<int> ans(10*n); int cnt = n; F0R(i, n){ F0R(j, n){ cin >> a[i][j]; if(i<=j) pq.insert(ar<int, 3>{a[i][j], i, j}); } } while(!pq.empty()){ ar<int, 3> t = *pq.begin(); pq.erase(t); if(t[1]==t[2]){ ans[t[1]] = t[0]; } else{ int u = D.find(t[1]), v = D.find(t[2]); if(t[0]==ans[u]) par[v] = u, D.comb(u, v); else if(t[0]==ans[v]) par[u] = v, D.comb(v, u); else { ans[cnt] = t[0]; par[u]=cnt; par[v]=cnt; D.comb(cnt, u); D.comb(cnt, v); cnt++; } } } cout << cnt << nl; F0R(i, cnt){ cout << ans[i] << ; } cout << nl; cout << cnt << nl; F0R(i, cnt-1){ cout << i+1 << << par[i]+1 << nl; } return 0; }

#include <bits/stdc++.h> using namespace std; int n; int main() { cin >> n; const int maxN = n; int r[maxN]; int c[maxN]; int a[maxN][maxN]; for (int i = 0; i < n; i++) { r[i] = 0; for (int j = 0; j < n; j++) { cin >> a[i][j]; r[i] = r[i] + a[i][j]; } } for (int i = 0; i < n; i++) { c[i] = 0; for (int j = 0; j < n; j++) { c[i] = c[i] + a[j][i]; } } int ans = 0; for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { if (c[j] > r[i]) { ans++; } } } cout << ans; return 0; }

#include <bits/stdc++.h> using namespace std; template <typename T> inline T read() { T f = 0, x = 0; char c = getchar(); while (!isdigit(c)) f = c == - , c = getchar(); while (isdigit(c)) x = x * 10 + c - 48, c = getchar(); return f ? -x : x; } namespace run { const int mod = 998244353, N = 1 << 16, inv2 = (mod + 1) / 2; inline int add(int x, int y) { return x + y >= mod ? x - mod + y : x + y; } inline int sub(int x, int y) { return x >= y ? x - y : x + mod - y; } inline int qpow(int x, int y) { int ret = 1; while (y) { if (y & 1) ret = 1LL * x * ret % mod; x = 1LL * x * x % mod, y >>= 1; } return ret; } int inv[17], fac[17], ifac[17]; inline void Getln(int *a, int *b, int len) { assert(a[0] == 1), b[0] = 0; for (int i = 0; i < len - 1; i++) { int sum = 1LL * a[i + 1] * (i + 1) % mod; for (int j = 0; j < i; j++) sum = sub(sum, 1LL * a[i - j] * (j + 1) % mod * b[j + 1] % mod); b[i + 1] = 1LL * sum * inv[i + 1] % mod; } } inline void Getexp(int *a, int *b, int len) { assert(a[0] == 0), b[0] = 1; for (int i = 0; i < len - 1; i++) { b[i + 1] = 0; for (int j = 0; j <= i; j++) b[i + 1] = (1LL * (j + 1) * a[j + 1] % mod * b[i - j] + b[i + 1]) % mod; b[i + 1] = 1LL * inv[i + 1] * b[i + 1] % mod; } } inline void fwt_xor(int *a, int inv, int limit) { for (int mid = 1; mid < limit; mid <<= 1) for (int i = 0; i < limit; i += (mid << 1)) for (int j = 0; j < mid; j++) { int x = a[i + j], y = a[i + j + mid]; if (inv == -1) x = 1LL * inv2 * x % mod, y = 1LL * inv2 * y % mod; a[i + j] = add(x, y), a[i + j + mid] = sub(x, y); } } int a[N], n, f[N], K, C, vis[N]; map<vector<int>, int> mp; vector<int> st[209]; int count[N], tot, top, num[209], r[209], A[209]; int main() { n = read<int>(), K = read<int>(), C = read<int>(); inv[0] = inv[1] = fac[0] = ifac[0] = ifac[1] = 1, count[0] = 0; for (int i = 1; i <= K; i++) fac[i] = 1LL * fac[i - 1] * i % mod; for (int i = 2; i <= K; i++) inv[i] = 1LL * (mod - mod / i) * inv[mod % i] % mod, ifac[i] = 1LL * inv[i] * ifac[i - 1] % mod; for (int i = 1; i < 1 << C; i++) count[i] = count[i >> 1] + (i & 1); int xorsum = 0; for (int i = 0; i < n; i++) xorsum ^= (a[i] = read<int>()); for (int i = 0; i < n; i++) { vector<int> b; for (int j = 0; j <= K; j++) b.push_back(a[i] ^ (a[i] - j)); mp[b]++; } for (map<vector<int>, int>::iterator i = mp.begin(); i != mp.end(); i++) st[++top] = i->first, num[top] = i->second; for (int s = 0; s < 1 << C; s++) { tot = 0; for (int i = 1; i <= top; i++) { int tmp = 0; for (int j = 0; j <= K; j++) tmp = (tmp << 1) | (count[st[i][j] & s] & 1); if (!vis[tmp]) A[++tot] = tmp, r[tot] = num[i], vis[tmp] = tot; else r[vis[tmp]] += num[i]; } static int c[17], d[17], ret[17]; memset(ret, 0, sizeof ret); for (int i = 1; i <= tot; i++) { for (int j = 0; j <= K; j++) c[j] = (A[i] >> (K - j) & 1) ? mod - ifac[j] : ifac[j]; Getln(c, d, K + 1); for (int j = 0; j <= K; j++) ret[j] = (1LL * d[j] * r[i] + ret[j]) % mod; vis[A[i]] = 0; } Getexp(ret, c, K + 1), f[s] = 1LL * c[K] * fac[K] % mod; } fwt_xor(f, -1, 1 << C); int p = qpow(qpow(n, K), mod - 2); for (int i = 0; i < 1 << C; i++) printf( %lld , 1LL * f[i ^ xorsum] * p % mod); return 0; } } // namespace run int main() { return run::main(); }

#include <bits/stdc++.h> using namespace std; int n, m, dx, dy; int a[1000001]; int cnt[1000000] = {}; bool vis[1000000] = {}; inline int gcd(int a, int b) { while (b) a %= b, swap(a, b); return a; } int main() { ios_base::sync_with_stdio(false); cin >> n >> m >> dx >> dy; int g = gcd(dx, dy); dx /= g, dy /= g; a[0] = 0; int x = 0, y = 0; for (int i = 1; i <= n; ++i) { x += dx; if (x >= n) x -= n; y += dy; if (y >= n) y -= n; a[x] = y; } for (int i = 0; i < (int)(m); ++i) { cin >> x >> y; int c = y - a[x]; if (c < 0) c += n; ++cnt[c]; } int best = -1, bestind = -1; int delta = a[n]; for (int i = 0; i < (int)(n); ++i) if (!vis[i]) { int cur = 0; int j = i; while (!vis[j]) { vis[j] = true; cur += cnt[j]; j += delta; } if (cur > best) { best = cur; bestind = i; } } cout << 0 << << bestind << n ; return 0; }

#include <bits/stdc++.h> using namespace std; template <class T> inline T checkmin(T &a, T b) { return (a < b) ? a : a = b; } template <class T> inline T checkmax(T &a, T b) { return (a > b) ? a : a = b; } template <class T> T GCD(T a, T b) { if (a < 0) return GCD(-a, b); if (b < 0) return GCD(a, -b); return (a == 0) ? b : GCD(b % a, a); } template <class T> T LCM(T a, T b) { if (a < 0) return LCM(-a, b); if (b < 0) return LCM(a, -b); return (a == 0 || b == 0) ? 0 : a / GCD(a, b) * b; } template <class T> inline T sqr(T X) { return X * X; } namespace Poor { const int MaxiN = 100005; const int LogMaxiN = 18; const int CharSet = 256; int N; char St[MaxiN]; long long Ra[CharSet]; long long X[LogMaxiN][MaxiN]; int SA[MaxiN], H[MaxiN]; int LCP(int A, int B) { int Rec = A; for (int j = LogMaxiN - 1; j >= 0; --j) if (A + (1 << j) <= N && B + (1 << j) <= N && X[j][A] == X[j][B]) { A += (1 << j); B += (1 << j); } return A - Rec; } bool Cmp(int A, int B) { int L = LCP(A, B); return A + L == N || (B + L < N && St[A + L] < St[B + L]); } long long Solve(int L, int R, int C) { int Len = LCP(SA[L], SA[R]); long long res = (long long)(R - L + 1) * (R - L + 2) / 2LL * (long long)(Len - C); if (L == R) return res; if (LCP(SA[L], SA[L]) == Len) return res + Solve(L + 1, R, Len); if (LCP(SA[R], SA[R]) == Len) return res + Solve(L, R - 1, Len); int l = L, r = R; while (l < r) { int mid = (l + r + 1) >> 1; if (LCP(SA[L], SA[mid]) > Len) l = mid; else r = mid - 1; } res += Solve(L, l, Len) + Solve(l + 1, R, Len); return res; } void Run() { srand(time(NULL)); gets(St); N = strlen(St); for (int i = 0; i < CharSet; ++i) Ra[i] = (long long)rand() + (((long long)rand()) << 32LL); for (int i = 0; i < N; ++i) X[0][i] = Ra[(int)St[i]]; for (int j = 0; j < LogMaxiN - 1; ++j) for (int i = 0; i < N - (1 << j); ++i) X[j + 1][i] = (X[j][i] * Ra[j + 1]) ^ (X[j][i + (1 << j)]); for (int i = 0; i < N; ++i) SA[i] = i; sort(SA, SA + N, Cmp); cout << Solve(0, N - 1, 0) << endl; } } // namespace Poor int main() { Poor::Run(); return 0; }

#include <bits/stdc++.h> using namespace std; bool ansnull(int a, int b, int c, int d) { int ans = 0; if (a != 0) ++ans; if (b != 0) ++ans; if (c != 0) ++ans; if (d != 0) ++ans; if (ans >= 2) return true; else return false; } int main() { int a[100010][5]; int n, k; cin >> n >> k; for (int i = 0; i <= n; ++i) for (int j = 1; j <= 4; ++j) a[i][j] = 0; for (int i = 1; i <= n; ++i) for (int j = 1; j <= k; ++j) cin >> a[i][j]; vector<int> v(20, 0); for (int i = 1; i <= n; ++i) { int sum = 0; for (int j = 1; j <= 4; ++j) { sum += a[i][j] * (1 << (4 - j)); } v[sum]++; } if (v[0] != 0) { cout << YES ; return 0; } if (ansnull(v[1], v[2], v[4], v[8])) { cout << YES ; return 0; } int ind = -1; for (int i = 0; i <= 3; ++i) if (v[(1 << i)] != 0) ind = (1 << i); if (ansnull(v[12], v[3], 0, 0)) { cout << YES ; return 0; } if (ansnull(v[6], v[9], 0, 0)) { cout << YES ; return 0; } if (ansnull(v[5], v[10], 0, 0)) { cout << YES ; return 0; } if (ind != -1) { if (v[15 - ind] != 0) { cout << YES ; return 0; } if (ind == 1) { if (v[12] != 0 || v[6] != 0 || v[10] != 0) { cout << YES ; return 0; } } if (ind == 2) { if (v[12] != 0 || v[9] != 0 || v[5] != 0) { cout << YES ; return 0; } } if (ind == 4) { if (v[9] != 0 || v[3] != 0 || v[10] != 0) { cout << YES ; return 0; } } if (ind == 8) { if (v[6] != 0 || v[3] != 0 || v[5] != 0) { cout << YES ; return 0; } } } cout << NO ; return 0; }

#include <bits/stdc++.h> using namespace std; int main() { long long a, b, c, k; cin >> a >> b >> c >> k; if (k >= a + b + c - 3) { cout << a * b * c << endl; } else { long long res = 1; for (int x1 = 0; x1 < a; x1++) { long long help = (-k + x1) / (-2); for (int n = -1; n < 1; n++) { long long x2 = min(min(help + n, b - 1), k - x1); long long x3 = min(k - x1 - x2, c - 1); res = max(res, (1 + x1) * (1 + x2) * (1 + x3)); } } for (int x1 = 0; x1 < a; x1++) { long long help = (-k + x1) / (-2); for (int n = -1; n < 1; n++) { long long x2 = min(min(help + n, c - 1), k - x1); long long x3 = min(k - x1 - x2, b - 1); res = max(res, (1 + x1) * (1 + x2) * (1 + x3)); } } cout << res << endl; } }

#include <bits/stdc++.h> using namespace std; int main() { int n, i, j; scanf( %d , &n); int arr[n]; for (i = 0; i < n; i++) scanf( %d , &arr[i]); int t = 0; int index = -1; for (i = 0; i < n; i++) if (arr[i] - arr[(i + 1) % n] > 0) { t++; index = i; } if (t > 1) { cout << -1 n ; return 0; } if (index == -1) cout << 0 n ; else cout << (n - index - 1) << endl; return 0; }

#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; for (int i = 0; i < n; ++i) { int x; cin >> x; cout << x - !(x & 1) << ; } }

#include <bits/stdc++.h> using namespace std; struct node { int x, y, z; }; node q[200001]; int n, m; bool ok[2][100001]; char s[100005]; int main(void) { scanf( %d %d , &n, &m); for (int i = 0; i < 2; ++i) { scanf( %s , s + 1); for (int j = 1; j <= n; ++j) if (s[j] == - ) ok[i][j] = true; } bool flag = false; q[1].x = 0; q[1].y = 1; q[1].z = 0; int h = 1, e = 1; ok[0][1] = false; while (h <= e) { node p = q[h]; ++h; int i = p.x, j = p.y, k = p.z; if (j <= k) continue; if ((j + 1 > n) || (j + m > n)) { flag = true; break; } if (ok[i][j + 1]) { ++e; q[e].x = i; q[e].y = j + 1; q[e].z = k + 1; ok[i][j + 1] = false; } if (ok[i ^ 1][j + m]) { ++e; q[e].x = i ^ 1; q[e].y = j + m; q[e].z = k + 1; ok[i ^ 1][j + m] = false; } if (ok[i][j - 1]) { ++e; q[e].x = i; q[e].y = j - 1; q[e].z = k + 1; ok[i][j - 1] = false; } } if (flag) printf( YES n ); else printf( NO n ); return 0; }

#include <bits/stdc++.h> using namespace std; int main() { int t, n, cnt[2000000]; scanf( %d , &n); for (int i = 0; i < 2000000; ++i) cnt[i] = 0; for (int i = 0; i < n; ++i) { scanf( %d , &t); cnt[t]++; } long long ans = 0; for (int i = 0; i < 2000000 - 1; ++i) { cnt[i + 1] += cnt[i] / 2; if (cnt[i] % 2) ++ans; } cout << ans << endl; }

#include <bits/stdc++.h> #pragma GCC optimize( Ofast,no-stack-protector,unroll-loops,fast-math ) #pragma GCC target( sse,sse2,sse3,ssse3,sse4.1,sse4.2,avx,avx2,popcnt,tune=native ) using namespace std; namespace _c { const double pi = acos(-1.0); namespace min { const int i8 = -128; const int i16 = -32768; const int i = -2147483647 - 1; const long long l = -9223372036854775807LL - 1; } // namespace min namespace max { const int i8 = 127; const int i16 = 32767; const int i = 2147483647; const long long l = 9223372036854775807LL; } // namespace max } // namespace _c namespace _f { template <typename T> inline const T gcd(T m, T n) { while (n != 0) { T t = m % n; m = n; n = t; } return m; } template <typename T> inline const T max(const T &a, const T &b) { return a > b ? a : b; } template <typename T> inline const T min(const T &a, const T &b) { return a < b ? a : b; } template <typename T> inline const T abs(const T &a) { return a > 0 ? a : -a; } template <typename T> inline T pow(T a, T b) { T res = 1; while (b > 0) { if (b & 1) { res = res * a; } a = a * a; b >>= 1; } return res; } template <typename T> inline T pow(T a, T b, const T &m) { a %= m; T res = 1; while (b > 0) { if (b & 1) { res = res * a % m; } a = a * a % m; b >>= 1; } return res % m; } } // namespace _f namespace io { template <typename T> inline void read(T &t) { register T res = 0, neg = 1; char g = getchar(); for (; !isdigit(g); g = getchar()) { if (g == - ) { neg = -1; } } for (; isdigit(g); g = getchar()) { res = res * 10 + g - 0 ; } t = res * neg; } inline int in() { register int T; read(T); return T; } inline long long in_ll() { register long long T; read(T); return T; } } // namespace io int Ans, T(2), x[11000], y[11000], z[11000], r[11000], f[11000], F[11000], s[1100000], b[11000], n, m, t[11000], c[11000], K, q[11000], Q[11000]; void In(int a, int b, int c, int d) { x[T] = f[a]; y[T] = b; z[T] = c; r[T] = d; f[a] = T++; x[T] = f[b]; y[T] = a; z[T] = 0; r[T] = -d; f[b] = T++; } int main() { int i, j, k; scanf( %d%d , &n, &K); for (i = 0; i < n; i++) { scanf( %d%d%d , s + i, t + i, c + i); t[i] += s[i]; q[m++] = s[i]; q[m++] = t[i]; } q[m++] = -1; std::sort(q, q + m); for (i = j = 1; i < m; i++) if (q[i] != q[j - 1]) q[j++] = q[i]; m = j; for (i = 0; i + 1 < m; i++) In(i, i + 1, K, 0); for (i = 0; i < n; i++) { for (j = 0; j < m; j++) if (q[j] == s[i]) break; s[i] = j; for (j = 0; j < m; j++) if (q[j] == t[i]) break; t[i] = j; Q[i] = T; In(s[i], t[i], 1, -c[i]); } s[0] = 0; for (;;) { memset(b, 127, sizeof(b)); b[0] = 0; for (i = 0, j = 1; i < j; i++) for (k = f[s[i]]; k; k = x[k]) if (z[k] && b[s[i]] + r[k] < b[y[k]]) { b[y[k]] = b[s[i]] + r[k]; F[y[k]] = k; s[j++] = y[k]; } if (b[m - 1] == 2139062143) break; j = 2139062143; for (i = m - 1; i; i = y[F[i] ^ 1]) if (j > z[F[i]]) j = z[F[i]]; for (i = m - 1; i; i = y[F[i] ^ 1]) { Ans += j * r[F[i]]; z[F[i]] -= j; z[F[i] ^ 1] += j; } } for (i = 0; i < n; i++) if (z[Q[i]]) printf( 0 ); else printf( 1 ); printf( n ); return 0; }

#include <bits/stdc++.h> using namespace std; auto random_address = [] { char *p = new char; delete p; return (uint64_t)p; }; mt19937 rng(chrono::steady_clock::now().time_since_epoch().count() * (random_address() | 1)); const int INF = 1e9 + 5; struct edge { int a, b, color, index; }; int N, M, K; vector<edge> edges; vector<vector<int>> color_count; void set_color(edge &e, int color) { color_count[e.a][e.color]--; color_count[e.b][e.color]--; e.color = color; color_count[e.a][e.color]++; color_count[e.b][e.color]++; } bool fix() { vector<int> minimum(N, INF), maximum(N, 0); for (int i = 0; i < N; i++) for (int k = 0; k < K; k++) { minimum[i] = min(minimum[i], color_count[i][k]); maximum[i] = max(maximum[i], color_count[i][k]); } bool change = false; for (edge &e : edges) if ((maximum[e.a] - minimum[e.a] > 2 && color_count[e.a][e.color] == maximum[e.a]) || (maximum[e.b] - minimum[e.b] > 2 && color_count[e.b][e.color] == maximum[e.b])) { set_color(e, rng() % K); change = true; } return change; } int main() { cin >> N >> M >> K; color_count.assign(N, vector<int>(K, 0)); for (int i = 0; i < N; i++) { int _; cin >> _; } edges.resize(M); for (int i = 0; i < M; i++) { edge &e = edges[i]; cin >> e.a >> e.b; e.a--; e.b--; e.index = i; e.color = rng() % K; color_count[e.a][e.color]++; color_count[e.b][e.color]++; } bool bad; do { shuffle(edges.begin(), edges.end(), rng); bad = false; while (fix()) bad = true; } while (bad); vector<int> answers(M); for (edge &e : edges) answers[e.index] = e.color + 1; for (int i = 0; i < M; i++) cout << answers[i] << n ; }

#include <bits/stdc++.h> using namespace std; #pragma GCC diagnostic warning -Wall int main() { int n; scanf( %d , &n); vector<vector<int> > sec(n); for (typeof(n) i = (0); i < (n); i++) { int k; scanf( %d , &k); sec[i].resize(k); for (typeof(k) j = (0); j < (k); j++) scanf( %d , &sec[i][j]); sort((sec[i]).begin(), (sec[i]).end()); } int count = 0; for (typeof(n) i = (0); i < (n); i++) { int k = int(sec[i].size()); if (not k) continue; int lasth = sec[i][0]; ; int l = (i - 1 + n) % n; int r = (i + 1) % n; for (typeof(k) j = (1); j < (k); j++) { int nl = lower_bound((sec[l]).begin(), (sec[l]).end(), sec[i][j]) - lower_bound((sec[l]).begin(), (sec[l]).end(), lasth); int nr = lower_bound((sec[r]).begin(), (sec[r]).end(), sec[i][j]) - lower_bound((sec[r]).begin(), (sec[r]).end(), lasth); if (nl != nr) count++; lasth = sec[i][j]; } } printf( %d n , count); }

#include <bits/stdc++.h> using namespace std; int main() { long long n, g; cin >> n >> g; vector<long long> v, ans; map<long long, long long> m; map<long long, long long>::iterator it; for (int i = 0; i < n; i++) { long long a; cin >> a; m[a]++; } for (it = m.begin(); it != m.end(); ++it) { v.push_back(it->second); } long long s1 = 0; for (int i = 0; i < v.size() - 1; i++) { long long s = 0; for (int j = i + 1; j < v.size(); j++) { s += v[j]; } s1 += s * v[i]; } cout << s1 << endl; return 0; }

#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(0), cout.tie(0); cout << fixed << setprecision(15); int N, M, S, K; cin >> N >> M >> S >> K; vector<int> type(N); for (int i = 0; i < N; i++) { cin >> type[i]; --type[i]; } vector<vector<int>> adj(N); for (int i = 0; i < M; i++) { int u, v; cin >> u >> v; adj[u - 1].push_back(v - 1); adj[v - 1].push_back(u - 1); } vector<vector<int>> opt(N); for (int tp = 0; tp < S; tp++) { vector<int> dist(N, -1); queue<pair<int, int>> q; for (int i = 0; i < N; i++) { if (type[i] == tp) { q.push({i, 0}); dist[i] = 0; } } while (!q.empty()) { int loc = q.front().first; int tot = q.front().second; q.pop(); for (int nbr : adj[loc]) { if (dist[nbr] != -1) continue; dist[nbr] = tot + 1; q.push({nbr, tot + 1}); } }; ; for (int i = 0; i < N; i++) { opt[i].push_back(dist[i]); } } for (int i = 0; i < N; i++) { sort((opt[i]).begin(), (opt[i]).end()); int ans = 0; for (int j = 0; j < K; j++) { ans += opt[i][j]; } cout << ans << ; } cout << endl; return 0; }