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; const int N = 2e5 + 5; char s[200]; int main() { int T; scanf( %d , &T); for (int t = 1; t <= T; t++) { bool num = 0, xx = 0, dx = 0; vector<int> res; scanf( %s , s + 1); int len = strlen(s + 1); for (int i = 1; i <= len; i++) { if (isdigit(s[i])) { if (!num) num = 1; else res.push_back(i); } if (isalpha(s[i])) { if (s[i] == tolower(s[i])) { if (!xx) xx = 1; else res.push_back(i); } else { if (!dx) dx = 1; else res.push_back(i); } } } int cnt = 1; if (num == 0) s[res.back()] = 1 , res.pop_back(); if (xx == 0) s[res.back()] = a , res.pop_back(); if (dx == 0) s[res.back()] = A , res.pop_back(); printf( %s n , s + 1); } }
#include <bits/stdc++.h> using namespace std; int main() { long long int n, k; cin >> n; long long int a[n]; for (int i = 0; i < n; i++) cin >> a[i]; sort(a, a + n); int sum = 0; for (int i = 0; i < n - 1; i++) sum += (a[n - 1] - a[i]); cout << sum; }
#include <bits/stdc++.h> void swap(int , int ); int main() { int i, j, k; int n; scanf( %d , &n); int arr[n]; for (i = 0; i < n; i++) { scanf( %d , &arr[i]); } int limit = n / 2; for (i = 0; i < limit; i++) { if (i % 2 == 0) { swap(&arr[i], &arr[n - i - 1]); } } for (i = 0; i < n; i++) { printf( %d , arr[i]); } } void swap(int a, int b) { int t; t = a; a = b; b = t; }
#include <bits/stdc++.h> using namespace std; int main() { int n, m; scanf( %d %d , &n, &m); int a, b, a_min, b_min; scanf( %d %d , &a_min, &b_min); for (int i = 1; i < n; i++) { scanf( %d %d , &a, &b); if (a * b_min < a_min * b) { a_min = a; b_min = b; } } double c = m * a_min / (b_min * 1.0f); printf( %f n , c); return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 2e5; struct P { long long x, y; bool a; P() {} P(long long _x, long long _y, bool _a) : x(_x), y(_y), a(_a) {} long long operator^(const P &t) const { return x * t.y - y * t.x; } bool operator<(const P &t) const { if (y == t.y) return x < t.x; return y < t.y; } P operator-(const P &t) const { return P(x - t.x, y - t.y, 0); } } p[N]; int n, m; bool flag[N]; int st[N], tops; void granhamScan() { st[0] = 0; tops = 1; for (int i = 1; i < m; ++i) { while (tops >= 2 && ((p[st[tops - 1]] - p[st[tops - 2]]) ^ (p[i] - p[st[tops - 1]])) < 0) { flag[st[tops - 1]] = false; tops--; } st[tops++] = i; flag[i] = true; } for (int i = m - 1; i >= 0; --i) { if (flag[i]) continue; while (tops >= 2 && ((p[st[tops - 1]] - p[st[tops - 2]]) ^ (p[i] - p[st[tops - 1]])) < 0) { flag[st[tops - 1]] = false; tops--; } st[tops++] = i; flag[i] = true; } } bool check() { for (int i = 0; i < tops; ++i) { if (!p[st[i]].a) return 0; } return 1; } int main() { scanf( %d , &n); for (int i = 0; i < n; ++i) { int x, y; scanf( %d%d , &x, &y); p[i] = P(x, y, 1); } scanf( %d , &m); m += n; for (int i = n; i < m; ++i) { int x, y; scanf( %d%d , &x, &y); p[i] = P(x, y, 0); } sort(p, p + m); p[m] = p[0]; granhamScan(); if (check()) printf( YES n ); else printf( NO n ); return 0; }
#include <bits/stdc++.h> using namespace std; const int INF = 0x3f3f3f3f; const long double EPS = 1e-6; const int N = 200020, MOD = 998244353; int n, k; long long a[N + 20], fact[N + 20], inv[N + 20]; long long qpow(long long a, long long b, long long p = MOD) { long long ans = 1; for (; b; b >>= 1) { if (b & 1) ans = ans * a % p; a = a * a % p; } return ans % p; } void prework() { fact[0] = 1; for (int i = 1; i <= N; i++) fact[i] = fact[i - 1] * i % MOD; inv[N - 1] = qpow(fact[N - 1], MOD - 2) % MOD; for (int i = N - 2; ~i; i--) inv[i] = inv[i + 1] * (i + 1) % MOD; } long long C(int n, int m) { if (n - m < 0 \|\| m < 0) return 0; return fact[n] % MOD * inv[m] % MOD * inv[n - m] % MOD % MOD; } int main() { prework(); cin >> n >> k; for (int i = 1; i <= n; i++) cin >> a[i]; long long ans = 0; int c = 0, m = 0; a[n + 1] = a[1]; for (int i = 1; i <= n; i++) if (a[i] != a[i + 1]) m++; for (int i = 0; i <= m / 2; i++) { ans += C(m, i) % MOD * C(m - i, i) % MOD * qpow(k - 2, m - 2 * i) % MOD; ans %= MOD; } ans = (qpow(k, m) - ans + MOD) % MOD * qpow(2, MOD - 2) % MOD; cout << ans % MOD * qpow(k, n - m) % MOD << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int n, m; vector<int> A; vector<pair<int, int> > M; vector<int> PP; int turn; set<int> Go; int ans(int x) { cout << x + 1 << endl; if (Go.empty()) exit(0); cin >> x; return x - 1; } signed main() { ; cin >> n >> m; A.resize(n << 1); for (auto &x : A) cin >> x; M.resize(m); for (auto &x : M) cin >> x.first >> x.second, x.first--, x.second--; PP.assign(n << 1, -1); for (auto x : M) PP[x.first] = x.second, PP[x.second] = x.first; for (int i = 0; i < n << 1; i++) { Go.insert(i); } cin >> turn; if (turn == 1) { for (auto x : M) { if (A[x.first] > A[x.second]) { ans(x.first); Go.erase(x.first); Go.erase(x.second); } else { ans(x.second); Go.erase(x.first); Go.erase(x.second); } } while (Go.size()) { int mx = -1, r = -1; for (auto &x : Go) { if (mx < A[x]) mx = A[x], r = x; } Go.erase(r); Go.erase(ans(r)); } } else { int x; cin >> x; x--; Go.erase(x); while (PP[x] != -1) { Go.erase(PP[x]); x = ans(PP[x]); Go.erase(x); } for (auto x : M) { if (!Go.count(x.first)) continue; if (A[x.first] > A[x.second]) { ans(x.first); Go.erase(x.first); Go.erase(x.second); } else { ans(x.second); Go.erase(x.first); Go.erase(x.second); } } while (Go.size()) { int mx = -1, r = -1; for (auto &x : Go) { if (mx < A[x]) mx = A[x], r = x; } Go.erase(r); Go.erase(ans(r)); } } }
#include <bits/stdc++.h> using namespace std; int ans[500][500], st[500][500]; vector<pair<int, int> > go[500][500]; vector<vector<int> > cc; vector<int> c; int mv[1 << 20]; int it; void pr(int n, int k) { if (k == 1) { c.push_back(n); mv[(((c[4] * 16 + c[3]) * 16 + c[2]) * 16 + c[1]) * 16 + c[0]] = it; cc.push_back(c); it++; c.pop_back(); return; } for (int j = 0; j <= n; j++) { c.push_back(j); pr(n - j, k - 1); c.pop_back(); } } int kkk[5] = {1, 16, 256, 4096, 65536}; void get_int(int &ans) { ans = 0; char c = getchar(); while (c < 0 \|\| c > 9 ) c = getchar(); while (c >= 0 && c <= 9 ) { ans = ans * 10 + c - 0 ; c = getchar(); } } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); pr(8, 5); queue<pair<int, int> > pp; for (int j = 0; j < cc.size(); j++) { vector<int> vv = cc[j]; int cnum = (((vv[4] * 16 + vv[3]) * 16 + vv[2]) * 16 + vv[1]) * 16 + vv[0]; bool ok = true; for (int q = 0; q < cc.size(); q++) { bool ok1 = true; for (int ii = 1; ii < 5; ii++) { if (cc[j][ii]) { ok = false; for (int jj = 1; jj < 5; jj++) { if (cc[q][jj]) { ok1 = false; cnum -= kkk[ii]; cnum += kkk[(ii + jj) % 5]; go[q][mv[cnum]].push_back(make_pair(j, q)); st[j][q]++; cnum += kkk[ii]; cnum -= kkk[(ii + jj) % 5]; } } if (ok) { ans[j][q] = 1; pp.push(make_pair(j, q)); } else if (ok1) { ans[j][q] = 2; pp.push(make_pair(j, q)); } } } } } while (!pp.empty()) { int j = pp.front().first; int q = pp.front().second; pp.pop(); for (auto v : go[j][q]) { if (ans[v.first][v.second]) continue; if (ans[j][q] == 2) { ans[v.first][v.second] = 1; pp.push(v); continue; } st[v.first][v.second]--; if (st[v.first][v.second] == 0) { ans[v.first][v.second] = 2; pp.push(v); continue; } } } int t; cin >> t; for (int i = 0; i < t; i++) { int f; cin >> f; int a = 0, b = 0; for (int j = 0; j < 8; j++) { int k; cin >> k; a += (1 << (k * 4)); } for (int j = 0; j < 8; j++) { int k; cin >> k; b += (1 << (k * 4)); } int k1 = mv[a], k2 = mv[b]; if (f == 0) { if (ans[k1][k2] == 1) cout << Alice << n ; if (ans[k1][k2] == 2) cout << Bob << n ; if (ans[k1][k2] == 0) cout << Deal << n ; } else { swap(k1, k2); if (ans[k1][k2] == 2) cout << Alice << n ; if (ans[k1][k2] == 1) cout << Bob << n ; if (ans[k1][k2] == 0) cout << Deal << n ; } } return 0; }
#include <bits/stdc++.h> using namespace std; int n, i; int a, b, c, d; vector<long long> v; long long ans; void add(int a, int b) { ans += a - b; v.push_back(a + b); } void add_stack() { if (a + b >= c + d) { add(a, b); add(c, d); return; } if (a > d) add(a - d, d - a); if (b > c) add(c - b, b - c); } int main() { scanf( %d , &n); for (i = 1; i <= n; i++) { scanf( %d%d%d%d , &a, &b, &c, &d); add_stack(); } sort(v.begin(), v.end()); reverse(v.begin(), v.end()); long long sgn = 1; for (auto e : v) { ans += sgn * e; sgn *= -1; } printf( %lld , ans / 2); return 0; }
#include <bits/stdc++.h> using namespace std; const int M = 4005; int read() { int x = 0, f = 1; char c; while ((c = getchar()) < 0 \|\| c > 9 ) { if (c == - ) f = -1; } while (c >= 0 && c <= 9 ) { x = (x << 3) + (x << 1) + (c ^ 48); c = getchar(); } return x * f; } int n, m, t, a[M], s[M], siz[M], ch[M][2]; long long dp[M][M]; void upd(long long &x, long long y) { x = max(x, y); } void dfs(int u) { dp[u][0] = 0; if (!u) return; int ls = ch[u][0], rs = ch[u][1]; dfs(ls); dfs(rs); siz[u] = 1 + siz[ls] + siz[rs]; for (int i = 0; i <= siz[ls]; i++) for (int j = 0; j <= siz[rs]; j++) upd(dp[u][i + j], dp[ls][i] + dp[rs][j] - 2ll * i * j * a[u]); for (int i = siz[u] - 1; i >= 0; i--) upd(dp[u][i + 1], dp[u][i] + (m - 2 * i - 1ll) * a[u]); } signed main() { n = read(); m = read(); memset(dp, -0x3f, sizeof dp); for (int i = 1; i <= n; i++) { a[i] = read(); while (t > 0 && a[s[t]] > a[i]) ch[i][0] = s[t--]; if (t) ch[s[t]][1] = i; s[++t] = i; } dfs(s[1]); printf( %lld n , dp[s[1]][m]); }
#include <bits/stdc++.h> using namespace std; int n, m, q, l, r; double d, s, t, x, y; int tree[2000010 * 4], pl[2000010 * 4], pr[2000010 * 4], cnt = 1; bool flag[2000010 * 4]; void change(int l, int r, int id, int l1, int r1) { if (l >= l1 && r <= r1) { tree[id] = r - l + 1; flag[id] = 1; return; } if (flag[id]) return; int mid = (l + r) >> 1; if (l1 <= mid) { if (pl[id] == 0) pl[id] = ++cnt; change(l, mid, pl[id], l1, r1); } if (r1 > mid) { if (pr[id] == 0) pr[id] = ++cnt; change(mid + 1, r, pr[id], l1, r1); } tree[id] = tree[pl[id]] + tree[pr[id]]; } int dist(int l, int r, int l1, int r1) { int l2 = max(l, l1); int r2 = min(r, r1); return r2 - l2 + 1; } int query(int l, int r, int id, int l1, int r1) { if (l1 > r1) return 0; if (l >= l1 && r <= r1) return tree[id]; if (flag[id]) return dist(l, r, l1, r1); int mid = (l + r) >> 1; int res = 0; if (l1 <= mid && pl[id]) res += query(l, mid, pl[id], l1, r1); if (r1 > mid && pr[id]) res += query(mid + 1, r, pr[id], l1, r1); return res; } int main() { scanf( %lf%lf%lf , &d, &s, &t); d = -1.0; scanf( %d , &n); for (int i = 1; i <= n; i++) { scanf( %d%d , &l, &r); change(1, 0x3FFFFFFF, 1, l, r - 1); } scanf( %d , &q); for (int i = 1; i <= q; i++) { scanf( %lf%lf , &x, &y); double ts = (y + d) / y; double l1 = x + (s - x) / ts; double r1 = x + (t - x) / ts; int l2 = ceil(l1); int r2 = floor(r1); double ans = 0; if (l2 == r2 + 1) { if (query(1, 0x3FFFFFFF, 1, l2 - 1, l2 - 1)) ans = r1 - l1; } else { ans += query(1, 0x3FFFFFFF, 1, l2, r2 - 1); if (query(1, 0x3FFFFFFF, 1, l2 - 1, l2 - 1)) ans += l2 1.0 - l1; if (query(1, 0x3FFFFFFF, 1, r2, r2)) ans += r1 - r2 * 1.0; } ans *= ts; printf( %.6lf n , ans); } }
#include <bits/stdc++.h> using namespace std; map<string, string> m; int main() { int n; string j, x; cin >> n; while (n--) { cin >> j >> x; if (m.count(j) == 0) m[x] = j; else { m[x] = m[j]; m.erase(j); } } cout << m.size() << endl; map<string, string>::iterator it; for (it = m.begin(); it != m.end(); it++) { cout << it->second << << it->first << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 1000010; int cnt, lst, fa[N * 2], len[N * 2], ch[N * 2][26]; long long w[N * 2], ans; int od[N * 2], rk[N * 2], l = 1; char s[N]; void Init() { cnt = lst = 1; } void Insert(int c) { int p = lst, np = lst = ++cnt; len[np] = len[p] + 1; while (p && ch[p][c] == 0) ch[p][c] = np, p = fa[p]; if (!p) fa[np] = 1; else { int q = ch[p][c], nq; if (len[q] == len[p] + 1) fa[np] = q; else { len[nq = ++cnt] = len[p] + 1; fa[nq] = fa[q]; fa[q] = fa[np] = nq; memcpy(ch[nq], ch[q], sizeof(ch[q])); while (ch[p][c] == q) ch[p][c] = nq, p = fa[p]; } } } int n; int main() { Init(); scanf( %d , &n); for (int i = 1; i <= n; i++) { scanf( %s , s + l); l += strlen(s + l); s[l++] = # ; } for (int i = 1, j = 0, x, p; i <= n; i++) { lst = 1; for (j += 1; s[j] != # ; j++) { Insert(s[j] - a ); } } for (int i = 1, j = 0, x, p; i <= n; i++) { scanf( %d , &x); for (p = 1, j += 1; s[j] != # ; j++) { p = ch[p][s[j] - a ]; w[p] += x; } } for (int i = 1; i <= cnt; i++) rk[len[i]] += 1; for (int i = 1; i <= cnt; i++) rk[i] += rk[i - 1]; for (int i = 1; i <= cnt; i++) od[rk[len[i]]--] = i; for (int i = cnt; i >= 1; i--) w[fa[od[i]]] += w[od[i]]; for (int i = 2; i <= cnt; i++) ans = max(ans, len[i] * w[i]); printf( %lld n , ans); return 0; }
#include <bits/stdc++.h> using namespace std; int t, n, m, ans; vector<vector<int>> gh, used; int dx[8] = {1, 1, 1, 0, 0, -1, -1, -1}; int dy[8] = {1, 0, -1, 1, -1, 1, 0, -1}; bool onseg(double x1, double y1, double x2, double y2, double x, double y) { double d1 = sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1)); double d2 = sqrt((x - x2) * (x - x2) + (y - y2) * (y - y2)); double d3 = sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)); return abs(d3 - d2 - d1) < 1e-9; } void bfs(int y, int x) { if (gh[y][x] == 0) return; if (used[y][x]) return; used[y][x] = true; vector<pair<int, int>> todo, temp, bunch; int cx, cy, nx, ny; todo.push_back({y, x}); bunch.push_back({y, x}); while (true) { if (todo.empty()) break; for (int i = 0; i < todo.size(); i++) { cy = todo[i].first, cx = todo[i].second; for (int j = 0; j < 8; j++) { ny = cy + dy[j]; nx = cx + dx[j]; if (ny >= 0 && ny < n && nx >= 0 && nx < m) { if (used[ny][nx] == 0) { temp.push_back({ny, nx}); bunch.push_back({ny, nx}); used[ny][nx] = 1; } } } } todo = temp; temp.clear(); } if (bunch.size() % 4) return; int len = bunch.size() / 4; int topx, topy, btx, bty; topx = bunch[0].second, topy = bunch[0].first; btx = topx + len, bty = topy + len; bool sq = true; for (int j = 1; j < bunch.size(); j++) { int nx = bunch[j].second, ny = bunch[j].first; if (!onseg(topx, topy, btx, topy, nx, ny) && !onseg(topx, topy, topx, bty, nx, ny) && !onseg(btx, bty, btx, topy, nx, ny) && !onseg(btx, bty, topx, bty, nx, ny)) { sq = false; break; } } if (sq) { ans++; return; } sq = true; topx = bunch[0].second, topy = bunch[0].first; btx = topx, bty = topy + 2 * len; for (int j = 1; j < bunch.size(); j++) { int nx = bunch[j].second, ny = bunch[j].first; if (!onseg(topx, topy, topx - len, topy + len, nx, ny) && !onseg(topx, topy, topx + len, topy + len, nx, ny) && !onseg(btx, bty, topx - len, topy + len, nx, ny) && !onseg(btx, bty, topx + len, topy + len, nx, ny)) { sq = false; break; } } if (sq) { ans++; } } void solve() { cin >> n >> m; gh = used = vector<vector<int>>(n, vector<int>(m)); ans = 0; char ch; int val; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { cin >> ch; val = ch - 0 ; if (val == 0) used[i][j] = 1; gh[i][j] = val; } } for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) if (used[i][j] == 0) bfs(i, j); } cout << ans << endl; } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cin >> t; while (t--) solve(); return 0; }
#include <bits/stdc++.h> using namespace std; const int MAX_N = 2000; int N; int board[MAX_N][MAX_N]; int cur[MAX_N][MAX_N]; int row[MAX_N], col[MAX_N]; char buf[MAX_N + 10]; void pb(int arr[MAX_N][MAX_N]) { for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { printf( %d , arr[i][j]); } puts( ); } } int solve() { int ans = 0; for (int i = N - 1; i > 0; i--) { for (int j = 0; j < N - i; j++) { int y = i + j, x = j; cur[y][x] = row[y] ^ col[x]; if (cur[y][x] ^ board[y][x]) { ans++; cur[y][x] ^= 1; row[y] ^= 1; col[x] ^= 1; } } } for (int i = 0; i < N; i++) { if (col[i] ^ row[i]) { board[i][i] ^= 1; } } memset(col, 0, sizeof(col)); memset(row, 0, sizeof(row)); for (int j = N - 1; j > 0; j--) { for (int i = 0; i < N - j; i++) { int y = i, x = j + i; cur[y][x] = row[y] ^ col[x]; if (cur[y][x] ^ board[y][x]) { ans++; cur[y][x] ^= 1; row[y] ^= 1; col[x] ^= 1; } } } for (int i = 0; i < N; i++) { if (row[i] ^ col[i] ^ board[i][i]) { ans++; } } return ans; } int main() { scanf( %d , &N); for (int i = 0; i < N; i++) { scanf( %s , buf); for (int j = 0; j < N; j++) { board[i][j] = buf[j] & 1; } } printf( %d n , solve()); return 0; }
#include <bits/stdc++.h> using namespace std; const int MAXN = 2e3 + 5; const int P = 998244353; template <typename T> void chkmax(T &x, T y) { x = max(x, y); } template <typename T> void chkmin(T &x, T y) { x = min(x, y); } template <typename T> void read(T &x) { x = 0; int f = 1; char c = getchar(); for (; !isdigit(c); c = getchar()) if (c == - ) f = -f; for (; isdigit(c); c = getchar()) x = x * 10 + c - 0 ; x = f; } template <typename T> void write(T x) { if (x < 0) x = -x, putchar( - ); if (x > 9) write(x / 10); putchar(x % 10 + 0 ); } template <typename T> void writeln(T x) { write(x); puts( ); } struct BinaryIndexTree { int n, a[MAXN]; void init(int x) { n = x; memset(a, 0, sizeof(a)); } void modify(int x, int d) { for (int i = x; i <= n; i += i & -i) a[i] += d; } int query(int x) { int ans = 0; for (int i = x; i >= 1; i -= i & -i) ans += a[i]; return ans; } int query(int l, int r) { int ans = 0; for (int i = r; i >= 1; i -= i & -i) ans += a[i]; for (int i = l - 1; i >= 1; i -= i & -i) ans -= a[i]; return ans; } } BIT[3]; int n, a[MAXN][MAXN], dp[MAXN][MAXN], power[MAXN]; void update(int &x, int y) { x += y; if (x >= P) x -= P; } int main() { read(n), dp[0][0] = 1; for (int i = 1; i <= n; i++) { dp[i][0] = 1ll i * dp[i - 1][0] % P; for (int j = 1; j <= i; j++) dp[i][j] = (dp[i][j - 1] - dp[i - 1][j - 1] + P) % P; } power[0] = 1; for (int i = 1; i <= n; i++) power[i] = 1ll * power[i - 1] * dp[n][n] % P; for (int i = 1; i <= n; i++) for (int j = 1; j <= n; j++) read(a[i][j]); int ans = 0; BIT[0].init(n); for (int i = n; i >= 1; i--) { BIT[0].modify(a[1][i], 1); update(ans, 1ll * BIT[0].query(a[1][i] - 1) * dp[n - i][0] % P * power[n - 1] % P); } for (int i = 2; i <= n; i++) { bool visa[MAXN], visb[MAXN]; memset(visa, 0, sizeof(visa)); memset(visb, 0, sizeof(visb)); BIT[0].init(n), BIT[1].init(n); for (int j = n; j >= 1; j--) { visb[a[i][j]] = true; if (!visa[a[i][j]]) BIT[0].modify(a[i][j], 1); else BIT[1].modify(a[i][j], 1); int cnt = BIT[1].query(n); update(ans, 1ll * BIT[0].query(a[i][j] - 1) * dp[n - j][cnt] % P * power[n - i] % P); if (cnt) update(ans, 1ll * BIT[1].query(a[i][j] - 1) * dp[n - j][cnt - 1] % P * power[n - i] % P); if (a[i][j] > a[i - 1][j] && visb[a[i - 1][j]]) { if (visa[a[i - 1][j]]) update(ans, P - 1ll * dp[n - j][cnt - 1] * power[n - i] % P); else update(ans, P - 1ll * dp[n - j][cnt] * power[n - i] % P); } if (!visb[a[i - 1][j]]) visa[a[i - 1][j]] = true; else { visa[a[i - 1][j]] = true; BIT[0].modify(a[i - 1][j], -1); BIT[1].modify(a[i - 1][j], 1); } } } writeln(ans); return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 2e5 + 5; int main() { ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0); long long n, x; cin >> n, x = n; long long cnt = 0, d = n; for (int i = 2; 1LL * i * i <= x; i++) { if (x % i == 0) { cnt++, d = i; while (x % i == 0) x /= i; } if (cnt > 2) break; } if (x > 1) cnt++; if (cnt <= 1) cout << d; else cout << 1; return 0; }
#include <bits/stdc++.h> using namespace std; const double EPS = 1E-8; inline bool eq(double a, double b) { return a - b < EPS && b - a < EPS; } inline bool ne(double a, double b) { return a + EPS < b \|\| b + EPS < a; } inline bool ls(double a, double b) { return a + EPS < b; } inline bool gr(double a, double b) { return b + EPS < a; } inline bool le(double a, double b) { return a - EPS < b; } inline bool ge(double a, double b) { return b - EPS < a; } int arr[1111][1111]; int main() { int n; scanf( %d , &n); for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { scanf( %d , &arr[i][j]); } } int sum = 0; for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { sum = (sum + arr[i][j] * arr[j][i]) & 1; } } int q; scanf( %d , &q); for (int i = 0; i < q; i++) { int ctrl; scanf( %d , &ctrl); if (ctrl == 3) putchar( 0 + sum); else { scanf( %d , &ctrl); sum = 1 - sum; } } return 0; }
#include <bits/stdc++.h> using namespace std; inline char gc() { static char buf[100000], p1 = buf, p2 = buf; return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2) ? EOF : p1++; } inline long long read() { long long x = 0; char ch = getchar(); bool positive = 1; for (; !isdigit(ch); ch = getchar()) if (ch == - ) positive = 0; for (; isdigit(ch); ch = getchar()) x = x 10 + ch - 0 ; return positive ? x : -x; } inline void write(long long a) { if (a < 0) { a = -a; putchar( - ); } if (a >= 10) write(a / 10); putchar( 0 + a % 10); } inline void wri(long long a) { write(a); putchar( ); } inline void writeln(long long a) { write(a); puts( ); } const int N = 1 << 17 \| 2, mod = 998244353; int sum, A[N], B[N], C[N], f[N]; long long ksm(long long a, int b) { a %= mod; int ans = 1; for (; b; b >>= 1) { if (b & 1) ans = ans * a % mod; a = a * a % mod; } return ans; } void FWT(int a, int n) { for (int i = 0; i < n; i++) { for (int j = 0; j < (1 << n); j++) if (j >> i & 1) { int x = a[j]; a[j] = a[j ^ (1 << i)] >= x ? a[j ^ (1 << i)] - x : a[j ^ (1 << i)] - x + mod; a[j ^ (1 << i)] = a[j ^ (1 << i)] + x >= mod ? a[j ^ (1 << i)] + x - mod : a[j ^ (1 << i)] + x; } } } void ba(int &a) { if (a > mod / 2) a = a - mod; } signed main() { int n = read(), k = read(); int x = read(), y = read(), z = read(); for (int i = 0; i < n; i++) { int a = read(), b = read() ^ a, c = read() ^ a; sum ^= a; A[b]++; B[c]++; C[b ^ c]++; } FWT(A, k); FWT(B, k); FWT(C, k); for (int i = 0; i < (1 << k); i++) { int t1 = n, t2 = A[i], t3 = B[i], t4 = C[i]; ba(t2); ba(t3); ba(t4); f[i] = ksm((long long)x + y + z, (t1 + t2 + t3 + t4) / 4) ksm((long long)x + y - z, (t1 + t2 - t3 - t4) / 4) % mod * ksm((long long)x - y + z, (t1 - t2 + t3 - t4) / 4) % mod * ksm((long long)x - y - z, (t1 - t2 - t3 + t4) / 4) % mod; f[i] = (f[i] + mod) % mod; } FWT(f, k); long long in = ksm(1 << k, mod - 2); for (int i = 0; i < (1 << k); i++) f[i] = f[i] * in % mod; for (int i = 0; i < (1 << k); i++) { wri(f[i ^ sum]); } }
#include <bits/stdc++.h> using namespace std; const int N = 28; vector<int> g[N]; int vis[2000000]; int main() { int k, n; string ss, s; cin >> k >> ss; for (int i = 0; i < k; ++i) s += ss; for (int i = 0; i != s.size(); ++i) g[s[i] - a ].push_back(i); cin >> n; vector<int>::iterator it; for (int i = 0; i < n; ++i) { cin >> k >> ss; it = g[ss[0] - a ].begin(); g[ss[0] - a ].erase(it + k - 1); } memset(vis, 0, sizeof(vis)); for (int i = 0; i < 26; ++i) for (int j = 0; j < g[i].size(); ++j) vis[g[i][j]] = 1; for (int i = 0; i != s.size(); ++i) if (vis[i]) cout << s[i]; return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 1e3 + 5; int n, m; int adj[N][N], d[N][N]; bool check(int a, int b) { if (a >= 0 && a < n && b >= 0 && b < m && adj[a][b] != -1) return 1; return 0; } void bfs(int x, int y) { d[x][y] = 0; queue<pair<int, int> > q; q.push({x, y}); while (!q.empty()) { int dir[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}}; pair<int, int> p = q.front(); q.pop(); for (int i = 0; i < 4; i++) { int ii = dir[i][0] + p.first; int jj = dir[i][1] + p.second; if (check(ii, jj) && d[ii][jj] == -1) { q.push({ii, jj}); d[ii][jj] = d[p.first][p.second] + 1; } } } } int main() { cin >> n >> m; for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) d[i][j] = -1; pair<int, int> e, s; char c; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { cin >> c; if (c == E ) { e.first = i; e.second = j; adj[i][j] = 0; } else if (c == S ) { s.first = i; s.second = j; adj[i][j] = 0; } else if (c == T ) adj[i][j] = -1; else adj[i][j] = (c - 0 ); } } bfs(e.first, e.second); int len = d[s.first][s.second]; long long int ans = 0; for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) if (d[i][j] != -1 && d[i][j] <= len) ans += adj[i][j]; cout << ans << endl; }
#include <bits/stdc++.h> using namespace std; inline string GetString() { char S[1000005]; scanf( %s , S); string ret = S; return ret; } inline char getc() { char c = ; while (c == \|\| c == t \|\| c == r \|\| c == n ) c = getchar(); return c; } template <typename t> t getnum() { t res = 0; char c; int sign = 1; while (1) { c = getchar(); if (c == \|\| c == n ) continue; else break; } if (c == + ) { } else if (c == - ) sign = -1; else res = c - 0 ; while (1) { c = getchar(); if (c >= 0 && c <= 9 ) res = res * 10 + c - 0 ; else break; } return res * sign; } int main(int argc, char** argv) { int n = getnum<int>(); int m = getnum<int>(); int i = getnum<int>(); int j = getnum<int>(); int a = getnum<int>(); int b = getnum<int>(); int satu = 10000000, dua = 10000000, tiga = 10000000, empat = 10000000; if ((i - 1) % a == 0 && (j - 1) % b == 0) { int x = (i - 1) / a, y = (j - 1) / b; if (x % 2 == y % 2) satu = max(x, y); } if ((i - 1) % a == 0 && (m - j) % b == 0) { int x = (i - 1) / a, y = (m - j) / b; if (x % 2 == y % 2) dua = max(x, y); } if ((n - i) % a == 0 && (j - 1) % b == 0) { int x = (n - i) / a, y = (j - 1) / b; if (x % 2 == y % 2) tiga = max(x, y); } if ((n - i) % a == 0 && (m - j) % b == 0) { int x = (n - i) / a, y = (m - j) / b; if (x % 2 == y % 2) empat = max(x, y); } int ans = min(satu, min(dua, min(tiga, empat))); if (ans != 0 && (a > n - 1 \|\| b > m - 1)) ans = 10000000; if (ans == 10000000) puts( Poor Inna and pony! ); else printf( %d n , ans); return 0; }
#include <bits/stdc++.h> using namespace std; int arr[1003][1003]; int n, m; int dp[1003][1003]; int vis[1003][1003]; int dx[4] = {0, 1, 0, -1}; int dy[4] = {1, 0, -1, 0}; int dfs(int i, int j, int x) { if (vis[i][j] == 2) { printf( Poor Inna! n ); exit(0); } if (dp[i][j] != -1) return dp[i][j]; vis[i][j] = 2; int temp2 = 0; int temp3 = 0; if (arr[i][j] == 3) temp3 = 1; for (int k = 0; k < 4; k++) { int ee = i + dx[k]; int rr = j + dy[k]; if (ee >= 0 & ee < n && rr >= 0 && rr < m && arr[ee][rr] == (x + 1) % 4) { temp2 = max(temp2, dfs(ee, rr, (x + 1) % 4)); } } temp2 += temp3; vis[i][j] = 1; if (arr[i][j] == 0) dp[i][j] = temp2; return temp2; } int main() { char temp; for (int i = 0; i < 1003; i++) for (int j = 0; j < 1003; j++) { dp[i][j] = -1; vis[i][j] = 0; } scanf( %d %d , &n, &m); for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) { cin >> temp; if (temp == D ) arr[i][j] = 0; if (temp == I ) arr[i][j] = 1; if (temp == M ) arr[i][j] = 2; if (temp == A ) arr[i][j] = 3; } for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) { if (arr[i][j] == 0 && vis[i][j] == 0) { int temp1 = dfs(i, j, 0); } } int ans = 0; for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) if (ans < dp[i][j]) ans = dp[i][j]; if (ans == 0) printf( Poor Dima! n ); else printf( %d n , ans); return 0; }
#include <bits/stdc++.h> using namespace std; int ex, ey; bool a[207][207]; bool vis[207][207]; int dx[4] = {0, 0, 1, -1}; int dy[4] = {-1, 1, 0, 0}; int bfs() { queue<pair<int, int>> q; vis[100][100] = true; q.push(make_pair(100, 100)); int dep = 0; while (int(q.size())) { int size = int(q.size()); while (size--) { pair<int, int> top = q.front(); q.pop(); vis[top.first][top.second] = true; if (top.first == ex && top.second == ey) return dep; for (int i = 0; i < int(4); i++) { int nx = top.first + dx[i]; int ny = top.second + dy[i]; if (a[nx][ny] && !vis[nx][ny]) { q.push(make_pair(nx, ny)); } } } dep++; } return -1; } int main() { string second; cin >> second; ex = ey = 100; for (int i = 0; i < int(int(second.size())); i++) { a[ex][ey] = true; if (second[i] == R ) ex++; if (second[i] == L ) ex--; if (second[i] == U ) ey--; if (second[i] == D ) ey++; if (a[ex][ey]) { puts( BUG ); return 0; } } a[ex][ey] = true; int ans = bfs(); ans < int(second.size()) ? puts( BUG ) : puts( OK ); }
#include <bits/stdc++.h> using namespace std; const int MAXN = 513; int N, ans[MAXN]; multiset<int> m; int gcd(int a, int b) { if (a < b) swap(a, b); if (b == 0) return a; return gcd(b, a % b); } void solve() { for (int k = N; k >= 1; k--) { ans[k] = -(m.begin()); m.erase(m.find(-ans[k])); for (int i = k + 1; i <= N; i++) { m.erase(m.find(-gcd(ans[k], ans[i]))); m.erase(m.find(-gcd(ans[k], ans[i]))); } } } int main() { scanf( %d , &N); int x; for (int i = 1; i <= N N; i++) { scanf( %d , &x); m.insert(-x); } solve(); for (int i = 1; i <= N; i++) printf( %d%c , ans[i], n [i == N]); return 0; }
#include <bits/stdc++.h> using namespace std; static const double EPS = 1e-6; const long double pi = acos(-1.0); int dx[] = {0, 1, 0, -1, 1, 1, -1, -1, 0}, dy[] = {1, 0, -1, 0, 1, -1, 1, -1, 0}; int aq[5][5]; int main() { int n; cin >> n; for (int i = 0; i < (int)(n); ++i) { int x, y; cin >> x >> y; aq[x - 1][y - 1] = aq[y - 1][x - 1] = 1; } int ap = 0, nap = 0; for (int i = 0; i < (int)(5); ++i) for (int j = 0; j < (int)(i); ++j) for (int k = 0; k < (int)(j); ++k) { if (aq[i][j] && aq[j][k] && aq[k][i]) ap = 1; if (!aq[i][j] && !aq[j][k] && !aq[k][i]) nap = 1; } if (ap \|\| nap) cout << WIN << endl; else cout << FAIL << endl; }
#include <bits/stdc++.h> using namespace std; const int64_t INF = 0x3f3f3f3f; const int64_t INFLL = 0x3f3f3f3f3f3f3f3f; const int64_t MOD = 1e9 + 7; const double EPS = 1e-9; const double PI = acos(-1); mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); int64_t rand(int64_t x, int64_t y) { return uniform_int_distribution<int64_t>(x, y)(rng); } int64_t mul(int64_t a, int64_t b) { int64_t ret = (1ll * (a % MOD) * (b % MOD)) % MOD; return (ret + MOD) % MOD; } int64_t add(int64_t a, int64_t b) { int64_t ret = (1ll * (a % MOD) + (b % MOD)) % MOD; return (ret + MOD) % MOD; } int64_t pow_exp(int64_t n, int64_t p) { if (!p) return 1; if (p & 1) return mul(n, pow_exp(n, p - 1)); int64_t tmp = pow_exp(n, p / 2); return mul(tmp, tmp); } const int64_t MAX = 2e5 + 10; const int64_t NMAX = 2e5 + 10; const int64_t MMAX = 2e5 + 10; const int64_t LOG_MAX = ceil(log2(double(NMAX))); const int64_t BLOCK = ceil(sqrt(double(NMAX))); int64_t n; string str[20]; map<int64_t, vector<int64_t> > mp[20]; int64_t tot[20]; int64_t mem[1 << 20]; int64_t go(int64_t msk, int64_t sm) { if (msk + 1 == 1 << n) { return 0; } int64_t &ret = mem[msk]; if (ret + 1) return ret; int64_t ans = 0; for (int64_t i = 0; i < n; i++) if (((msk >> i) & 1) == 0) { int64_t mn = mp[i].begin()->first; if (sm + mn >= 0) { int64_t cans = 0; cans += go(msk ^ (1 << i), sm + tot[i]); auto it = mp[i].find(-sm); if (it != mp[i].end()) cans += it->second.size(); ans = max(ans, cans); } else { auto it = mp[i].find(-sm); if (it == mp[i].end()) { continue; } if (it == mp[i].begin()) { int64_t cans = it->second.size(); ans = max(ans, cans); } else { auto &v = mp[i][-sm]; int64_t r = (--it)->second.front(); int64_t cans = lower_bound(v.begin(), v.end(), r) - v.begin(); ans = max(ans, cans); } } } return ret = ans; } int32_t main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); ; cin >> n; for (int64_t i = 0; i < n; i++) { cin >> str[i]; } for (int64_t i = 0; i < n; i++) { int64_t sm = 0; for (int64_t j = 0; j < str[i].size(); j++) { sm += str[i][j] == ( ? +1 : -1; mp[i][sm].push_back(j); } tot[i] = sm; } memset(mem, -1, sizeof mem); cout << go(0, 0) << n ; }
#include <bits/stdc++.h> using namespace std; const int N = 100005; const double inf = 1e10; int n, m, q, Eu[N], Ev[N], all[N], vis[N]; vector<int> V; map<pair<int, int>, int> F, S; struct P { double x, y; } p[N]; inline P operator+(const P& a, const P& b) { return (P){a.x + b.x, a.y + b.y}; } inline P operator-(const P& a, const P& b) { return (P){a.x - b.x, a.y - b.y}; } inline double operator(const P& a, const P& b) { return a.x b.y - b.x * a.y; } inline double operator/(const P& b, const P& a) { return atan2(b.y - a.y, b.x - a.x); } inline bool operator<(const P& a, const P& b) { return a.x != b.x ? a.x < b.x : a.y < b.y; } inline double crs(P p, P a, P b) { return (a - p) * (b - p); } struct E { int v; double a; }; inline bool operator<(const E& a, const E& b) { return a.a < b.a; } vector<E> G[N]; inline void add(int u, int v) { G[u].push_back((E){v, p[v] / p[u]}); F[make_pair(u, v)] = 0; } int dfs(int x, int p) { vis[x] = 1; int s = 1; for (int i = 0; i < G[x].size(); i++) { int y = G[x][i].v; if (!vis[y]) s += dfs(y, x); } if (p) { F[make_pair(p, x)] += s; F[make_pair(x, p)] -= s; } return s; } inline int calc(int a, int b, int c) { return ((p[b] / p[a]) < (p[c] / p[a]) ? 0 : all[a]) + S[make_pair(a, c)] - S[make_pair(a, b)] - F[make_pair(a, c)]; } int main() { scanf( %d%d , &n, &m); int T = n + 1; p[T] = (P){-inf, 0}; for (int i = 1; i <= m; i++) scanf( %d%d , &Eu[i], &Ev[i]); for (int i = 1; i <= n; i++) scanf( %lf%lf , &p[i].x, &p[i].y); for (int i = 1; i <= m; i++) add(Eu[i], Ev[i]), add(Ev[i], Eu[i]); int x = 1; for (int i = 2; i <= n; i++) if (p[i] < p[x]) x = i; add(T, x); add(x, T); dfs(T, 0); for (int i = 1; i <= n + 1; i++) sort(G[i].begin(), G[i].end()); for (int i = 1; i <= n + 1; i++) { int x = i; S[make_pair(i, i)] = 0; for (int j = 0; j < G[i].size(); j++) { int y = G[i][j].v; all[i] += F[make_pair(i, y)]; S[make_pair(i, y)] = S[make_pair(i, x)] + F[make_pair(i, y)]; x = y; } } scanf( %d , &q); while (q--) { int k; scanf( %d , &k); V.clear(); for (int i = 1, x; i <= k; i++) scanf( %d , &x), V.push_back(x); int ans = 0, cc = V.size(); double s = 0; p[0] = (P){0, 0}; for (int i = 0; i < cc; i++) s += crs(p[0], p[V[i ? i - 1 : cc - 1]], p[V[i]]); if (s > 0) reverse(V.begin(), V.end()); for (int i = 0; i < cc; i++) ans += calc(V[i], V[i ? i - 1 : cc - 1], V[(i + 1) % cc]); printf( %d n , ans + cc); } return 0; }
#include <bits/stdc++.h> int main() { int a, b, c, d, flag = 0; scanf( %d %d %d %d , &a, &b, &c, &d); if (a + b > c && b + c > a && c + a > b) flag = 1; else if (b + c > d && c + d > b && d + b > c) flag = 1; else if (c + d > a && d + a > c && a + c > d) flag = 1; else if (a + b > d && b + d > a && d + a > b) flag = 1; if (flag == 1) printf( TRIANGLE ); else { if (a + b == c \|\| b + c == a \|\| c + a == b) flag = 2; else if (b + c == d \|\| c + d == b \|\| d + b == c) flag = 2; else if (c + d == a \|\| d + a == c \|\| a + c == d) flag = 2; else if (a + b == d \|\| b + d == a \|\| d + a == b) flag = 2; } if (flag == 2) printf( SEGMENT ); else if (flag == 0) printf( IMPOSSIBLE ); }
#include <bits/stdc++.h> const int MAXN = 1000; int ba[MAXN], bb[MAXN]; int a, b, da, db, t, x, l1, l2; int main() { scanf( %d %d %d %d %d %d , &x, &t, &a, &b, &da, &db); int tm = 0; while (a >= 0) { ba[l1++] = a; a -= da; tm++; if (tm >= t) break; } tm = 0; while (b >= 0) { bb[l2++] = b; b -= db; tm++; if (tm >= t) break; } for (int i = 0; i < l1; i++) if (ba[i] == x) { printf( YES n ); return 0; } if (x == 0) { printf( YES n ); return 0; } for (int i = 0; i < l2; i++) if (bb[i] == x) { printf( YES n ); return 0; } for (int i = 0; i < l1; i++) for (int j = 0; j < l2; j++) if (ba[i] + bb[j] == x) { printf( YES n ); return 0; } printf( NO n ); return 0; return 0; }
#include <bits/stdc++.h> using namespace std; struct Item { int id, t, d, p; Item(int _id = 0, int _t = 0, int _d = 0, int _p = 0) : id(_id), t(_t), d(_d), p(_p) {} bool operator<(const Item &rhs) const { return d < rhs.d; } }; constexpr int kN = 101, kT = 2001; Item a[kN]; int dp[kN][kT]; int tk[kN][kT]; int main() { int n; scanf( %d , &n); int t, d, p; for (int i = 0; i < n; ++i) { scanf( %d %d %d , &t, &d, &p); a[i] = Item(i + 1, t, d, p); } sort(a, a + n); for (int i = 0; i < n; ++i) { for (int j = 0; j + a[i].t < a[i].d; ++j) { if (dp[i][j] + a[i].p > dp[i + 1][j + a[i].t]) { dp[i + 1][j + a[i].t] = dp[i][j] + a[i].p; tk[i + 1][j + a[i].t] = 1; } } for (int j = 0; j < kT; ++j) { if (dp[i][j] > dp[i + 1][j]) { dp[i + 1][j] = dp[i][j]; tk[i + 1][j] = 0; } } } int x = 0; for (int i = 0; i < a[n - 1].d; ++i) { if (dp[n][i] > dp[n][x]) { x = i; } } printf( %d n , dp[n][x]); vector<int> ans; for (int i = n; i > 0; --i) { if (tk[i][x]) { ans.push_back(a[i - 1].id); x -= a[i - 1].t; } } reverse(ans.begin(), ans.end()); printf( %d n , ans.size()); for (int i = 0; i < ans.size(); ++i) { printf( %d , ans[i]); } printf( n ); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); int n; cin >> n; set<int> s; while (1) { int k = s.size(); s.insert(n); int m = s.size(); if (k == m) break; n = n + 1; while (n % 10 == 0) { n = n / 10; } } cout << s.size() << endl; return 0; }
#include <bits/stdc++.h> using namespace std; bool comp(pair<long long, long long> a, pair<long long, long long> b) { return a.first > b.first; } long long findBest(vector<pair<long long, long long> >& ps, long long x) { long long res = 0; for (long long i = 0; i < ps.size(); i++) { long long num = ps[i].second; long long diff = ps[i].first; if (x - num >= 0) { res += (num * diff); x -= num; } else { res += (x * diff); break; } } return res; } int main() { long long n, s; cin >> n >> s; vector<pair<long long, long long> > ps; long long total = 0; long long positives = 0; long long pieces = 0; for (long long i = 0; i < n; i++) { long long num, a, b; cin >> num >> a >> b; ps.push_back(make_pair(a - b, num)); total += num * b; pieces += num; if (a - b > 0) { positives += num; } } sort(ps.begin(), ps.end(), comp); long long pizzas = (pieces % s == 0) ? (pieces / s) : (pieces / s + 1); long long extra = pizzas * s - pieces; long long best = total; if (positives > 0) { best = max(best, findBest(ps, positives / s * s) + total); if (positives % s != 0) { long long x = max(positives, (positives / s + 1) * s - extra); best = max(best, findBest(ps, x) + total); } } cout << best << endl; return 0; }
#include <bits/stdc++.h> using namespace std; struct node { int i; int num; } a[1005]; bool cmp(node x, node y) { return x.num < y.num; } int main() { int t; scanf( %d , &t); while (t--) { int n, m; scanf( %d %d , &n, &m); int i, j; int ans = 0; for (i = 1; i <= n; i++) { scanf( %d , &a[i].num); a[i].i = i; ans += a[i].num; } if (m < n \|\| n <= 2) { printf( -1 n ); continue; } ans = 2; sort(a + 1, a + 1 + n, cmp); int num = a[1].num + a[2].num; ans += (m - n) num; printf( %d n , ans); for (i = 2; i <= n; i++) { printf( %d %d n , i - 1, i); } printf( 1 %d n , n); for (i = 0; i < (m - n); i++) { if (a[1].i > a[2].i) printf( %d %d n , a[2].i, a[1].i); else printf( %d %d n , a[1].i, a[2].i); } } return 0; }
#include <bits/stdc++.h> using namespace std; const int MAXN = 1000 + 7, MAX_SUM = 10 * 1000 + 7, DELTA = 1000 * 1000 * 1000 + 7; long long inputArray[MAXN], numberOfSubarrays[MAXN][2 * MAX_SUM], PSum; int main() { int numberOfInput; cin >> numberOfInput; for (int i = 0; i < numberOfInput; ++i) { cin >> inputArray[i]; PSum += inputArray[i]; } numberOfSubarrays[0][MAX_SUM + inputArray[0]] = numberOfSubarrays[0][MAX_SUM - inputArray[0]] = 1; for (int i = 1; i < numberOfInput; ++i) { for (int j = 0; j < 2 * MAX_SUM; ++j) { numberOfSubarrays[i][j] += numberOfSubarrays[i - 1][j - inputArray[i]]; } for (int j = 2 * MAX_SUM - 1; j >= 0; --j) { numberOfSubarrays[i][j] += numberOfSubarrays[i - 1][j + inputArray[i]]; numberOfSubarrays[i][j] %= DELTA; } numberOfSubarrays[i][MAX_SUM + inputArray[i]] = numberOfSubarrays[i][MAX_SUM + inputArray[i]] + 1; numberOfSubarrays[i][MAX_SUM - inputArray[i]] = numberOfSubarrays[i][MAX_SUM - inputArray[i]] + 1; } long long ans = 0; for (int i = 0; i < numberOfInput; ++i) { ans += numberOfSubarrays[i][MAX_SUM]; ans %= DELTA; } cout << ans << endl; return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 100005; struct heap { vector<pair<int, int> > v; int loc[N]; heap() { v.push_back(make_pair(-1, -1)); memset(loc, -1, sizeof loc); } void push(pair<int, int> p) { int cur; cur = v.size(); loc[p.second] = cur; v.push_back(p); while (v[cur] < v[cur >> 1]) { swap(v[cur], v[cur >> 1]); swap(loc[v[cur].second], loc[v[cur >> 1].second]); cur >>= 1; } } void pop() { if (empty()) return; swap(v[1], v.back()); loc[v[1].second] = 1; loc[v.back().second] = -1; v.pop_back(); int cur = 1; while ((cur << 1) < v.size()) { if ((cur << 1) + 1 == v.size()) { if (v[cur] > v[cur << 1]) swap(v[cur], v[cur << 1]), swap(loc[v[cur].second], loc[v[cur << 1].second]); break; } if (v[cur] < min(v[cur << 1], v[(cur << 1) + 1])) break; if (v[cur << 1] < v[(cur << 1) + 1]) { swap(v[cur], v[cur << 1]); swap(loc[v[cur].second], loc[v[cur << 1].second]); cur <<= 1; } else { swap(v[cur], v[(cur << 1) + 1]); swap(loc[v[cur].second], loc[v[(cur << 1) + 1].second]); cur = (cur << 1) + 1; } } } pair<int, int> top() { return v[1]; } bool empty() { return v.size() == 1; } }; int n, m; vector<int> bad[N]; vector<pair<int, int> > v[N]; int d[N]; heap pq; int main() { ios::sync_with_stdio(false); cin >> n >> m; for (int i = 0; i < m; i++) { int a, b, c; cin >> a >> b >> c; --a, --b; v[a].push_back(make_pair(b, c)); v[b].push_back(make_pair(a, c)); } for (int i = 0; i < n; i++) { int num; cin >> num; while (num--) { int a; cin >> a; bad[i].push_back(a); } } for (int i = 0; i < n; i++) d[i] = 0x3f3f3f3f; d[0] = 0; pq.push(make_pair(0, 0)); while (!pq.empty()) { pair<int, int> tp = pq.top(); pq.pop(); int t = tp.first; int cur = tp.second; if (t != d[cur]) continue; int j = 0; while (j < bad[cur].size() && bad[cur][j] < t) j++; while (j < bad[cur].size() && bad[cur][j] == t) t++, j++; for (int i = 0; i < v[cur].size(); i++) { int to = v[cur][i].first, cost = v[cur][i].second; if (t + cost < d[to]) { d[to] = t + cost; pq.push(make_pair(d[to], to)); } } } if (d[n - 1] >= 0x3f3f3f3f) puts( -1 ); else cout << d[n - 1] << endl; return 0; }
#include <bits/stdc++.h> using namespace std; const int MAXN = 1111; const int INF = 0x7f7f7f7f; int cases; const double EPS = 1e-8; inline int sgn(double a) { return a < -EPS ? -1 : a > EPS; } int main() { double s, a, b, c; cin >> s >> a >> b >> c; if (!sgn(a) && !sgn(b) && !sgn(c)) { puts( 1.0 0.0 0.0 ); } else { double ts = s / (a + b + c); printf( %.10f %.10f %.10f n , a * ts, b * ts, c * ts); } }
#include <bits/stdc++.h> using namespace std; const int mod = 1000000007; int cnt[4]; int main() { int n; scanf( %d , &n); getchar(); for (int i = 0; i < n; ++i) { char ch = getchar(); if (ch == A ) { ++cnt[0]; } else if (ch == C ) { ++cnt[1]; } else if (ch == G ) { ++cnt[2]; } else if (ch == T ) { ++cnt[3]; } } int mx = max_element(cnt, cnt + 4); int nMax = count(cnt, cnt + 4, mx); long long ans = 1; for (int i = 0; i < n; ++i) { ans = (ans nMax) % mod; } cout << ans << endl; }
#include <bits/stdc++.h> using namespace std; const long long mod = 1e9 + 7; const long long MAX = 1e6 + 10; long long a[100005]; int main() { long long n, k, m, sum, t, len; string s, d; while (cin >> n) { int flag = 1; sum = 0; if (n % 2 == 0) { cout << n / 2 << endl; for (long long i = (1); i <= (n / 2); ++i) cout << 2 << ; cout << endl; } else { cout << (n - 3) / 2 + 1 << endl; for (long long i = (1); i <= ((n - 3) / 2); ++i) cout << 2 << ; cout << 3 << endl; } } return 0; }
#include <bits/stdc++.h> using namespace std; long long a[200010], t; int n; long long b[200010]; int g[200010]; bool no[200010]; int main() { scanf( %d %I64d , &n, &t); for (int i = 1; i <= n; i++) scanf( %I64d , &a[i]); for (int i = 1; i <= n; i++) { int x; scanf( %d , &x); if (x < i) { printf( No n ); return 0; } g[i]++; g[x]--; no[x] = 1; } int now = 0; b[0] = 0; for (int i = 1; i <= n; i++) { now += g[i]; if (now > 0) { if (no[i]) { printf( No n ); return 0; } b[i] = max(a[i + 1] + t, b[i - 1] + 1); } else { b[i] = max(a[i] + t, b[i - 1] + 1); if (no[i] && (b[i] >= a[i + 1] + t && i != n)) { printf( No n ); return 0; } } } printf( Yes n ); for (int i = 1; i <= n; i++) printf( %I64d , b[i]); printf( n ); return 0; }
#include <bits/stdc++.h> using namespace std; const long long mod = 998244353; const int maxn = 2e5 + 100; long long dp[52][52][52]; bool vis[52][52][52]; long long val[52][52][52]; int a[maxn], w[maxn]; long long qmod(long long a, long long b) { long long ans = 1; while (b) { if (b & 1) ans = ans * a % mod; b >>= 1; a = a * a % mod; } return ans; } int flag; int dfs(int n, int i, int j, int k, long long p, long long v, long long sp, long long sn) { if (!n) { return 1LL * p * v % mod; } if (vis[i][j][k]) { return val[i][j][k] * qmod(dp[i][j][k], mod - 2) % mod * p % mod; } dp[i][j][k] = p; val[i][j][k] += dfs(n - 1, i + 1, j, k, 1LL * p * sp % mod * qmod(v + sp + sn, mod - 2) % mod, v, sp + 1, sn); val[i][j][k] += dfs(n - 1, i, j + 1, k, 1LL * p * sn % mod * qmod(v + sp + sn, mod - 2) % mod, v, sp, max(sn - 1, 0LL)); val[i][j][k] += dfs(n - 1, i, j, k + 1, 1LL * p * v % mod * qmod(v + sp + sn, mod - 2) % mod, max(v + flag, 0LL), sp, sn); val[i][j][k] %= mod; vis[i][j][k] = 1; return val[i][j][k]; } int main() { ios::sync_with_stdio(false); long long sn = 0, sp = 0; int n, m; cin >> n >> m; for (int i = 0; i < n; ++i) { cin >> a[i]; } for (int i = 0; i < n; ++i) { cin >> w[i]; if (a[i]) { sp += w[i]; } else sn += w[i]; } for (int i = 0; i < n; ++i) { memset(dp, 0, sizeof dp); memset(vis, 0, sizeof vis); memset(val, 0, sizeof val); if (a[i]) { flag = 1; sp -= w[i]; } else { flag = -1; sn -= w[i]; } cout << dfs(m, 0, 0, 0, 1, w[i], sp, sn) << endl; if (a[i]) { sp += w[i]; } else sn += w[i]; } return 0; }
#include <bits/stdc++.h> using namespace std; using ll = long long; using ii = pair<int, int>; const int N = 200005; const int M = 300; const int OFF = N * M; int _cnt[N + N * M]; int cnt = _cnt + OFF; int main() { char s[N]; scanf( %s , s); int n = strlen(s); int psum[N]; for (int i = 0; i < n; i++) { s[i] -= 0 ; psum[i] = s[i]; if (i) psum[i] += psum[i - 1]; } int sq = min(M, (int)sqrt(n)); ll ans = 0; for (int j = 1; j < sq; j++) { cnt[-1] = 1; for (int i = 0; i < n; i++) { int val = i - j psum[i]; if (psum[i]) { ans += cnt[val]; } cnt[val]++; } for (int i = 0; i < n; i++) { int val = i - j * psum[i]; cnt[val]--; } } int nxt[N]; nxt[n] = n; for (int i = n - 1; i >= 0; i--) { nxt[i] = nxt[i + 1]; if (s[i] == 1) nxt[i] = i; } for (int i = 0; i < n; i++) { int r = nxt[i]; int q = 1; while (r < n && q * sq <= n - i) { int p = nxt[r + 1]; int rig = max(r, i + q * sq - 1); if (rig <= p) { ans += (p - i) / q - (rig - i) / q; } r = p; q++; } } printf( %lld n , ans); return 0; }
#include <bits/stdc++.h> using namespace std; const int MAXN = 2005, MOD = 998244353; char ch[MAXN]; long long cnt[MAXN], dp[MAXN][MAXN]; long long KSM(long long a, long long t) { long long ans = 1; while (t) { if (t & 1) ans = ans * a % MOD; t >>= 1; a = a * a % MOD; } return ans; } int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); cin >> (ch + 1); int n = strlen(ch + 1); for (int i = 1; i <= n; i++) cnt[i] = cnt[i - 1] + (ch[i] == ? ); for (int j = 1; j <= n; j++) for (int i = j - 1; i; i--) { if (ch[i] != ) && ch[j] != ( ) dp[i][j] = (dp[i][j] + dp[i + 1][j - 1] + KSM(2, cnt[j - 1] - cnt[i])) % MOD; if (ch[i] != ( ) dp[i][j] = (dp[i][j] + dp[i + 1][j]) % MOD; if (ch[j] != ) ) dp[i][j] = (dp[i][j] + dp[i][j - 1]) % MOD; if (ch[i] != ( && ch[j] != ) ) dp[i][j] = (dp[i][j] - dp[i + 1][j - 1] + MOD) % MOD; } cout << dp[1][n]; }
#include <bits/stdc++.h> int main() { int i, j, l, x = 0; char s[100005]; gets(s); l = strlen(s); for (i = 0, j = l - 1; i < l / 2; i++, j--) { if (s[i] != s[j]) { x = 1; break; } } if (x == 1) { printf( NO n ); } else { for (i = 0; i < l; i++) { if (s[i] == A \|\| s[i] == H \|\| s[i] == I \|\| s[i] == M \|\| s[i] == O \|\| s[i] == T \|\| s[i] == U \|\| s[i] == V \|\| s[i] == W \|\| s[i] == X \|\| s[i] == Y ) { x = 0; } else { x = 1; break; } } if (x == 1) { printf( NO n ); } else { printf( YES n ); } } return 0; }
#include <bits/stdc++.h> #pragma GCC optimize( O3 ) using namespace std; const int MAX = 2e3 + 5; const long long MAX2 = 11; const long long MOD = 998244353; const long long MOD2 = 1000005329; const long long INF = 2e18; const int dr[] = {1, 0, -1, 0, 1, 1, -1, -1, 0}; const int dc[] = {0, 1, 0, -1, 1, -1, 1, -1, 0}; const double pi = acos(-1); const double EPS = 1e-9; const int block = 2000; int q, x, y, cnt; map<string, pair<long long, long long>> ans, dp; map<string, bool> jen; map<string, vector<string>> isi; string s, ty, c; pair<long long, long long> solve(string o) { if (!jen.count(o)) return ans[o]; if (isi[o].empty()) return {0, 0}; if (dp.count(o)) return dp[o]; int hit = isi[o].size() - 1; long long mx = 0, ttl = 0; pair<long long, long long> res; if (jen[o]) { for (auto i : isi[o]) { res = solve(i); mx = max(mx, res.second); ttl += res.first; } return dp[o] = {ttl + 2 * ans[o].first + hit * ans[o].second, mx + 2 * ans[o].first}; } { for (auto i : isi[o]) { res = solve(i); mx = max(mx, res.first); ttl += res.second; } return dp[o] = {mx + 2 * ans[o].first, ttl + 2 * ans[o].first + hit * ans[o].second}; } } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); cin >> q; while (q--) { cin >> ty; x = y = cnt = 0; if (ty == Widget ) { cin >> s; c = ; for (auto i : s) { if (i == ( \|\| i == ) \|\| i == , ) ++cnt; else if (cnt == 1) x = x * 10 + i - 0 ; else if (cnt == 2) y = y * 10 + i - 0 ; else c.push_back(i); } ans[c] = {x, y}; } else if (ty == VBox ) { cin >> s; ans[s]; jen[s]; } else if (ty == HBox ) { cin >> s; ans[s]; jen[s] = 1; } else { s = c = ; for (auto i : ty) { if (i == . ) ++cnt; else if (i == ( ) { if (c == pack ) cnt = 2; else if (c == set_border ) cnt = 3; else if (c == set_spacing ) cnt = 4; c = ; } else if (i == ) ) continue; else if (cnt == 0) s.push_back(i); else if (cnt == 1 \|\| cnt == 2) c.push_back(i); else if (cnt == 3 \|\| cnt == 4) x = x * 10 + i - 0 ; else return 1; } if (cnt == 2) isi[s].push_back(c); else if (cnt == 3) ans[s].first = x; else ans[s].second = x; } } pair<long long, long long> res; for (auto i : ans) { res = solve(i.first); cout << i.first << << res.first << << res.second << n ; } return 0; }
#include <bits/stdc++.h> using namespace std; const long long int inf = 1e18; int n, m, k, x, p; int mat[1005][1005]; void solve(int tc) { cin >> n >> m >> k >> p; for (int i = 0; i < n; ++i) { for (int j = 0; j < m; ++j) { cin >> mat[i][j]; } } multiset<int, greater<int> > msRow, msCol; for (int r = 0; r < n; ++r) { long long int rowSum = 0LL; for (int i = 0; i < m; ++i) { rowSum += mat[r][i]; } msRow.insert(rowSum); } for (int c = 0; c < m; ++c) { long long int colSum = 0LL; for (int i = 0; i < n; ++i) { colSum += mat[i][c]; } msCol.insert(colSum); } vector<long long int> rows(k + 1, 0LL), cols(k + 1, 0LL); for (int i = 1; i <= k; ++i) { rows[i] = msRow.begin(); msRow.erase(msRow.begin()); msRow.insert(rows[i] - (1LL p * m)); rows[i] += rows[i - 1]; cols[i] = msCol.begin(); msCol.erase(msCol.begin()); msCol.insert(cols[i] - (1LL p * n)); cols[i] += cols[i - 1]; } long long int ans = -inf; for (int i = 0; i <= k; ++i) { long long int tp = rows[i] + cols[k - i]; tp -= 1LL * p * i * (k - i); if (tp > ans) ans = tp; } cout << ans << n ; } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); int tt = 1; for (int i = 1; i <= tt; ++i) { solve(i); } return 0; }
#include <bits/stdc++.h> using namespace std; const long long PR = 1000000009; long long n, A[3][100009], dp[3][100009]; int main() { ios::sync_with_stdio(false); cin >> n; for (int i = 0; i < 100009; i++) A[0][i] = A[1][i] = A[2][i] = 0, dp[0][i] = dp[1][i] = dp[2][i] = -1 * 10000000000000000ll; for (int i = 0; i < n; i++) { cin >> A[0][i]; } for (int i = 0; i < n; ++i) cin >> A[1][i]; for (int i = 0; i < n; ++i) cin >> A[2][i]; dp[2][n] = 0; for (int i = n - 1; i >= 0; i--) { long long presum = A[0][i]; dp[0][i] = max(dp[0][i], presum + dp[0][i + 1]); dp[2][i] = max(dp[2][i], A[2][i] + dp[2][i + 1]); presum += A[1][i]; dp[0][i] = max(dp[0][i], presum + dp[1][i + 1]); dp[2][i] = max(dp[2][i], A[2][i] + A[1][i] + dp[1][i + 1]); presum += A[2][i]; dp[0][i] = max(dp[0][i], presum + dp[2][i + 1]); dp[2][i] = max(dp[2][i], presum + dp[0][i + 1]); presum += A[0][i + 1] + A[1][i + 1] + A[2][i + 1]; dp[2][i] = max(dp[2][i], presum + dp[0][i + 2]); dp[0][i] = max(dp[0][i], presum + dp[2][i + 2]); dp[1][i] = max(dp[1][i], A[1][i] + dp[1][i + 1]); dp[1][i] = max(dp[1][i], A[1][i] + A[0][i] + dp[0][i + 1]); dp[1][i] = max(dp[1][i], A[1][i] + A[2][i] + dp[2][i + 1]); } cout << dp[0][0] << n ; return 0; };
#include <bits/stdc++.h> using namespace std; const double pi = 3.1415926535; const double eps = 1e-6; struct TE { int a, b, c; } E[501000]; int tr[501000], n, x[501000], m; bool cmp(TE a, TE b) { return a.a < b.a; } int low(int a) { return (a & (-a)); } int ask(int a) { int ret = 1992837465; while (a) { ret = min(ret, tr[a]); a -= low(a); } return ret; } void ins(int a, int b) { while (a <= n + 5) { tr[a] = min(tr[a], b); a += low(a); } } int main() { scanf( %d , &n); for (int i = 0; i < n; i++) scanf( %d , &E[i].a); for (int i = 0; i < n; i++) scanf( %d , &E[i].b); for (int i = 0; i < n; i++) scanf( %d , &E[i].c); for (int i = 0; i < n; i++) { E[i].a = -E[i].a; E[i].b = -E[i].b; E[i].c = -E[i].c; x[i] = E[i].b; } sort(x, x + n); m = unique(x, x + n) - x; for (int i = 0; i < n; i++) E[i].b = (lower_bound(x, x + m, E[i].b) - x) + 1; sort(E, E + n, cmp); for (int i = 0; i <= n + 5; i++) tr[i] = 1992837465; int ans = 0; for (int i = 0; i < n; i++) { int h = i; while (i < n && E[i].a == E[h].a) { if (ask(E[i].b - 1) < E[i].c) { ans++; } i++; } i--; for (int j = h; j <= i; j++) ins(E[j].b, E[j].c); } printf( %d n , ans); }
#include <bits/stdc++.h> using namespace std; const int maxn = 300005; int n, u, v, x, trie[maxn << 1][26], sz[maxn << 1], tot, cnt[maxn], res; char op[2]; int merge(int a, int b) { if (!a \|\| !b) return a + b; int rt = ++tot; memset(trie[rt], 0, sizeof trie[rt]); sz[rt] = 1; for (int i = 0; i < 26; ++i) { trie[rt][i] = merge(trie[a][i], trie[b][i]); sz[rt] += sz[trie[rt][i]]; } return rt; } void dfs(int u, int dep) { sz[u] = 1; for (int i = 0; i < 26; ++i) if (trie[u][i]) { dfs(trie[u][i], dep + 1); sz[u] += sz[trie[u][i]]; } cnt[dep] += sz[u]; tot = n; int rt = 0; for (int i = 0; i < 26; ++i) rt = merge(rt, trie[u][i]); cnt[dep] -= max(1, sz[rt]); } int main() { scanf( %d , &n); for (int i = 0; i < n - 1; ++i) { scanf( %d%d%s , &u, &v, op); trie[u][op[0] - a ] = v; } dfs(1, 0); res = 0; for (int i = 1; i < n; ++i) if (cnt[i] > cnt[res]) res = i; printf( %d n%d n , sz[1] - cnt[res], res + 1); return 0; }
#include <bits/stdc++.h> using namespace std; const long long int p = 1e9 + 7; const int N = 1e5 + 1; long long int fact[N]; long long int ncr[N]; long long int n_1cr[N]; void factorial() { fact[0] = fact[1] = 1; for (int i = 2; i < N; i++) { fact[i] = i * fact[i - 1]; fact[i] %= p; } } long long int fastPower(long long int a, long long int b) { if (b == 0) return 1; long long int tmp = fastPower(a, b / 2); if (b & 1) return (tmp % p * tmp % p * a % p) % p; return (tmp % p * tmp % p) % p; } long long int nCr(int n) { ncr[0] = 1; n_1cr[0] = 1; for (int i = 1; i <= n; i++) { long long int iPower = fastPower(i, p - 2); ncr[i] = (ncr[i - 1] * (n - i + 1)) % p; ncr[i] = iPower; ncr[i] %= p; n_1cr[i] = (n_1cr[i - 1] % p (n - i) % p) % p; n_1cr[i] = iPower; n_1cr[i] %= p; } } long long int nCr(int n, int r) { long long ans = 1; ans = (fact[n - r] fact[r]) % p; ans = (fact[n] * fastPower(ans, p - 2)) % p; return ans; } int main() { int n; long long int sum = 0; cin >> n; factorial(); for (int i = 1; i <= n; i++) { sum += nCr(n - 1, i - 1) * nCr(n, i); sum %= p; } sum *= 2; sum %= p; sum -= n; cout << sum << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int n, m, M; vector<set<int> > A; vector<set<pair<int, int> > > B; vector<int> d, f, F, G; vector<bool> v; inline void upd(int& a, int b) { if (d[a] > d[b]) a = b; } void ff(int x, int y) { f[x] = x, v[x] = 1; for (set<int>::iterator i = A[x].begin(); i != A[x].end(); i++) if (v[i]) { if (i != y) upd(f[x], i); } else d[i] = d[x] + 1, ff(i, x), upd(f[x], f[i]); } void ff(int x) { f[x] = f[f[x]], v[x] = 0; for (set<int>::iterator i = A[x].begin(); i != A[x].end(); i++) if (v[i]) ff(i); } bool gg(int x, int y, int fa) { if (x == y) return 1; for (set<pair<int, int> >::iterator i = B[x].begin(); i != B[x].end(); i++) if (i->first != fa) if (gg(i->first, y, x)) { v[i->second] = v[i->second ^ 1] = 1; return 1; } return 0; } int main() { scanf( %d%d , &n, &m); A.resize(n); for (int i = 0, x, y; i < m; i++) scanf( %d%d , &x, &y), --x, --y, A[x].insert(y), A[y].insert(x); if (n == 2) { puts( -1 ); return 0; } d.resize(n, 0), f.resize(n), v.resize(n, 0); ff(0, -1), ff(0); F.resize(n); for (int i = 0; i < n; i++) if (f[i] == i) F[i] = (int)G.size(), G.push_back(i); for (int i = 0; i < n; i++) F[i] = F[f[i]]; B.resize((int)G.size()); for (int i = 0; i < n; i++) for (set<int>::iterator j = A[i].begin(); j != A[i].end(); j++) if (F[i] != F[j]) { set<pair<int, int> >::iterator p = B[F[i]].lower_bound(make_pair(F[j], -1)); if (p != B[F[i]].end() && p->first == F[j]) continue; B[F[i]].insert(make_pair(F[j], M++)), B[F[*j]].insert(make_pair(F[i], M++)); } if ((int)G.size() == 1) { puts( 0 ); return 0; } if ((int)G.size() == 2) { puts( 1 ); for (int i = 0; i < n; i++) for (int j = i + 1; j < n; j++) if (F[i] != F[j] && A[i].find(j) == A[i].end()) { printf( %d %d n , i + 1, j + 1); return 0; } } vector<int> L; for (int i = 0; i < (int)G.size(); i++) if ((int)B[i].size() == 1) L.push_back(i); printf( %d n , ((int)L.size() + 1) / 2); while (1) { random_shuffle(L.begin(), L.end()); bool F = 0, FF = 1; if ((int)L.size() & 1) F = 1, L.push_back(L[0]); v.clear(), v.resize(M, 0); for (int i = 0; i < (int)L.size(); i += 2) gg(L[i], L[i + 1], -1); for (int i = 0; i < M; i++) if (!v[i]) { FF = 0; break; } if (FF) { for (int i = 0; i < (int)L.size(); i += 2) printf( %d %d n , G[L[i]] + 1, G[L[i + 1]] + 1); return 0; } if (F) L.erase(L.end() - 1); } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); long long int T = 1; while (T--) { long long int n, i, j; cin >> n; long long int a[n + 5]; long long int b[n + 5]; unordered_map<long long int, long long int> rnk; long long int ans = 0; for (i = 0; i < n; i++) { cin >> a[i]; } j = 0; for (i = 0; i < n; i++) { cin >> b[i]; if (b[i] != a[j]) { ans++; rnk[b[i]]++; } else { j++; while (j < n && rnk.find(a[j]) != rnk.end()) j++; } } cout << ans << n ; } return 0; }
#include <bits/stdc++.h> using namespace std; const long long MOD = 1e9 + 7; const long long MAXN = 2e5 + 7; long long a[MAXN]; bool good[MAXN]; long long want[MAXN], pref[MAXN], next_[MAXN]; signed main() { ios_base::sync_with_stdio(false); cout.precision(40); long long n; cin >> n; for (long long i = 0; i < n; ++i) { cin >> a[i]; } stack<long long> st; for (long long i = 0; i < n; ++i) { while (st.size() && a[st.top()] < a[i]) { next_[st.top()] = i; st.pop(); } st.push(i); } while (st.size()) { next_[st.top()] = n; st.pop(); } long long mx1 = -MOD; long long mx2 = -MOD; for (long long i = 0; i < n; ++i) { if (a[i] < mx1 && a[i] > mx2) { want[i] = true; } if (a[i] > mx1) { mx2 = mx1; mx1 = a[i]; } else if (a[i] > mx2) { mx2 = a[i]; } } pref[0] = want[0]; for (long long i = 1; i < n; ++i) { pref[i] = pref[i - 1] + want[i]; } long long mx = -MOD; long long ans = -MOD; long long best = -1; for (long long i = 0; i < n; ++i) { mx = max(mx, a[i]); if (a[i] != mx) continue; long long j = next_[i]; long long new_ans = pref[j - 1] - pref[i] - 1; if (new_ans > ans \|\| (new_ans == ans && a[i] < a[best])) { ans = new_ans; best = i; } } mx = -MOD; for (long long i = 0; i < n; ++i) { mx = max(mx, a[i]); if (a[i] == mx) continue; long long new_ans = 0; if (new_ans > ans \|\| (new_ans == ans && a[i] < a[best])) { ans = new_ans; best = i; } } cout << a[best] << n ; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { long long t; cin >> t; while (t--) { long long n, m; cin >> n >> m; long long sum = 0; for (long long i = 0; i < n; i++) { long long x; cin >> x; sum += x; } cout << min(sum, m) << n ; } return 0; }
#include <bits/stdc++.h> using namespace std; int n; int x, y; int p[1000003]; int r[1000003]; map<int, int> a; int ans[200003]; int s; int parent(int x) { if (p[x] < 0) return x; return p[x] = parent(p[x]); } void join(int x, int y) { p[y] = parent(x); } int main() { fill_n(p, 1000003, -1); scanf( %d , &n); for (int i = 0; i < n; ++i) { scanf( %d%d , &x, &y); if (y) join(x, y); a.insert(pair<int, int>(x, y)); } int i = 2; int j = 0; while (a[j] != 0) { ans[i] = a[j]; j = a[j]; i += 2; } i = 1; j = 0; while (p[j] < 0 \|\| parent(j) == 0) j++; j = parent(j); ans[i] = j; i += 2; while (a[j] != 0) { ans[i] = a[j]; j = a[j]; i += 2; } for (i = 1; i <= n; ++i) printf( %d , ans[i]); return 0; }
#include <bits/stdc++.h> using namespace std; long long C(int a, int b) { long long ans = 1; for (int i = 0; i < b; ++i) ans = (a - i), ans /= (i + 1); return ans; } int main() { int n; while (cin >> n) cout << C(n + 4, 5) C(n + 2, 3) << endl; }
#include <bits/stdc++.h> using namespace std; const long long maxn = 1e5 + 10; struct Seg { long long mn, id; }; long long arr[maxn], N, P, ans[maxn]; Seg seg[maxn << 2]; inline Seg pushup(long long cur) { Seg l = seg[cur << 1], r = seg[cur << 1 \| 1]; if (l.mn == r.mn) { return l; } else if (l.mn < r.mn) { Seg mer; mer.id = l.id, mer.mn = l.mn; return mer; } else { Seg mer; mer.id = r.id, mer.mn = r.mn; return mer; } } long long query(long long cur, long long L, long long R, long long l, long long r) { if (L > R) return -1; if (l >= L && r <= R) { return seg[cur].id; } long long mid = (l + r) >> 1; long long lid = -1, rid = -1; if (mid >= L) lid = query(cur << 1, L, R, l, mid); if (mid < R) rid = query(cur << 1 \| 1, L, R, mid + 1, r); if (lid == -1) return rid; else if (rid == -1) return lid; else { return arr[lid] > arr[rid] ? rid : lid; } } long long query2(long long cur, long long l, long long r, const long long x) { if (l == r) { return l; } long long mid = (l + r) >> 1; if (seg[cur << 1].mn <= x) { return query2(cur << 1, l, mid, x); } return query2(cur << 1 \| 1, mid + 1, r, x); } void build(long long l, long long r, long long cur) { seg[cur].id = l, seg[cur].mn = arr[l]; if (l == r) return; long long mid = (l + r) >> 1; build(l, mid, cur << 1); build(mid + 1, r, cur << 1 \| 1); seg[cur] = pushup(cur); } void update(long long pos, long long l, long long r, long long cur, long long x) { if (l == r) { seg[cur].mn = x; arr[pos] = x; return; } long long mid = (l + r) >> 1; if (mid >= pos) { update(pos, l, mid, cur << 1, x); } else { update(pos, mid + 1, r, cur << 1 \| 1, x); } seg[cur] = pushup(cur); } signed main() { ios::sync_with_stdio(false); cin >> N >> P; for (register long long i = 1; i <= N; ++i) { cin >> arr[i]; } build(1, N, 1); long long cnt = 0, cur = 0; while (cnt < N) { cur = max(cur, seg[1].mn); long long x = query2(1, 1, N, cur); ans[x] = cur += P; ++cnt; update(x, 1, N, 1, 0x3f3f3f3f3f3f3f3f); while (cnt < N) { x = query(1, 1, x - 1, 1, N); if (x == -1 \|\| arr[x] > cur) break; ans[x] = cur += P, ++cnt; update(x, 1, N, 1, 0x3f3f3f3f3f3f3f3f); } } for (register long long i = 1; i <= N; ++i) { cout << ans[i] << ; } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; int count = 0; while ((count * (count + 1)) / 2 <= n) { ++count; } --count; int val = (count * (count + 1)) / 2; int diff = n - val; cout << count << n ; for (int i = 1; i <= count; ++i) { if (i == count) { cout << count + diff << ; break; } cout << i << ; } }
#include <bits/stdc++.h> using namespace std; int t; int n; int a[100086]; int main() { scanf( %d , &t); while (t--) { scanf( %d , &n); for (int i = 1; i <= n; i++) scanf( %d , &a[i]); int x = 0, y = a[1]; for (int i = 2; i <= n; i++) { if (a[i] > a[i - 1]) { x += a[i] - a[i - 1]; } else { y -= a[i - 1] - a[i]; } } puts(y >= 0 ? YES : NO ); } }
#include <bits/stdc++.h> using namespace std; int k, b, n; map<int, int>::iterator it; int main() { map<int, int> mp; while (scanf( %d%d%d , &k, &b, &n) != EOF) { mp.clear(); if (b == 0) { int a, sum = 0; long long res = 0; mp[0] = 1; for (int i = 1; i <= n; i++) { scanf( %d , &a); if (a) sum++; if (mp.find(sum) == mp.end()) mp[sum] = 1; else mp[sum]++; } for (it = mp.begin(); it != mp.end(); it++) { long long tmp = it->second; res += tmp * (tmp - 1) / 2; } cout << res << endl; } else { int a, ss = 0; long long res = 0, pre = 0; mp[0] = 1; for (int i = 1; i <= n; i++) { scanf( %d , &a); if (a) { ss += a; ss %= (k - 1); int ff = (ss - b + k - 1) % (k - 1); int st = mp.find(ff) == mp.end() ? 0 : mp[ff]; pre = st; res += st; if (mp.find(ss) == mp.end()) mp[ss] = 1; else mp[ss]++; } else { res += pre; mp[ss]++; } } cout << res << endl; } } }
#include <bits/stdc++.h> using namespace std; const int N = 2e5 + 5; int a[N], cnt[N * 2], n, m; long long solve(int m) { int s = n; memset(cnt, 0, sizeof(cnt)); cnt[s] = 1; long long add = 0, ans = 0; for (int i = 1; i <= n; i++) { if (a[i] >= m) add += cnt[s], s++; else s--, add -= cnt[s]; cnt[s]++; ans += add; } return ans; } int main() { scanf( %d %d , &n, &m); for (int i = 1; i <= n; i++) scanf( %d , &a[i]); printf( %lld n , solve(m) - solve(m + 1)); return 0; }
#include <bits/stdc++.h> using namespace std; long long t1, t2, x1, x2, t; bool Check(long long y1, long long y2) { return t1 * y1 + t2 * y2 >= t * (y1 + y2); } double HotBath(long long y1, long long y2) { return 1.0 * (t1 * y1 + t2 * y2) / (y1 + y2); } int main() { cin >> t1 >> t2 >> x1 >> x2 >> t; long long Y1 = 0, Y2 = 0; if (HotBath(x1, x2) >= t) Y1 = x1, Y2 = x2; if (HotBath(x1, 0) >= t && x1 >= Y1 + Y2) Y1 = x1, Y2 = 0; if (HotBath(0, x2) >= t && x2 >= Y1 + Y2) Y1 = 0, Y2 = x2; for (long long y1 = 0; y1 <= x1; y1++) { long long y2 = 0; long long Start = 0, End = x2; while (Start <= End) { long long Mid = Start + End >> 1; if (Check(y1, Mid)) { y2 = Mid; End = Mid - 1; } else Start = Mid + 1; } if (y1 + y2 == 0) continue; double New = HotBath(y1, y2); double Old = HotBath(Y1, Y2); if (New >= 1.0 * t) { if (New < Old) { Old = New; Y1 = y1; Y2 = y2; } else if (fabs(New - Old) <= 1e-9 && (Y1 + Y2 < y1 + y2)) { Y1 = y1; Y2 = y2; } } } cout << Y1 << << Y2 << n ; return 0; }
#include <bits/stdc++.h> using namespace std; const int maxN = 2000 + 5; int n, mark[maxN], m, st[maxN], start, high[maxN], on[maxN], cnt; vector<int> adj[maxN]; vector<int> s; void DFS(int v) { s.push_back(v); on[v] = mark[v] = 1; st[v] = high[v] = start++; for (int i = 0; i < adj[v].size(); i++) { int x = adj[v][i]; if (mark[x]) { if (on[x]) high[v] = min(high[v], high[x]); } else { DFS(x); high[v] = min(high[v], high[x]); } } if (st[v] == high[v]) { int x = s.back(); while (!s.empty() && st[x] >= st[v]) { on[x] = 0; s.pop_back(); x = s.back(); } cnt++; } } int main() { ios::sync_with_stdio(false), cin.tie(0), cout.tie(0); cin >> n; for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { int x; cin >> x; if (x) adj[i].push_back(j); } } for (int i = 0; i < n; i++) if (!mark[i]) DFS(i); if (cnt == 1) cout << YES n ; else cout << NO n ; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int w, h, ring, plate = 0; cin >> w >> h >> ring; for (int i = 0; i < ring; i++) { if (i > 0) { w -= 4; h -= 4; } plate += (w * 2) + ((h - 2) * 2); } cout << plate; return 0; }
#include <bits/stdc++.h> using namespace std; long long b, ans; int main(void) { cin >> b; for (long long i = 1; i * i <= b; i++) { if (b % i == 0) { ans = ans + 2; } if (i * i == b) ans--; } cout << ans << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { long long int n, q, i, num, x, y; cin >> n >> q; for (i = 0; i < q; i++) { cin >> x >> y; if ((x + y) % 2 == 0) { x--; num = (n / 2 + n % 2) * (x / 2 + x % 2) + (n / 2) * (x / 2) + (y / 2 + y % 2); } else { x--; num = (n / 2 + n % 2) * (x / 2) + (n / 2) * (x / 2 + x % 2) + (y / 2 + y % 2) + (n * n) / 2 + (n * n) % 2; } cout << num << endl; } return 0; }
#include <bits/stdc++.h> int main() { long long int n; std::cin >> n; if (n % 2 == 0) { std::cout << n / 2 << std::endl; } else { std::cout << -(n + 1) / 2 << std::endl; } return 0; }
#include <bits/stdc++.h> using namespace std; const long long MOD = 1e9 + 7; const long long INF = 1e18; const string nl = n ; int32_t main() { ios::sync_with_stdio(0); cin.tie(nullptr); long long n, k, second, t; cin >> n >> k >> second >> t; vector<pair<long long, long long>> a(n); for (auto& i : a) { cin >> i.first >> i.second; } vector<long long> b(k); for (auto& i : b) { cin >> i; } sort(b.begin(), b.end()); vector<long long> temp = {0}; for (auto& i : b) { temp.push_back(i); } temp.push_back(second); b = temp; auto check = [&](long long x) -> bool { long long ans = 0; for (long long i = 0; i < ((long long)(b).size()); ++i) { long long dist = b[i] - (i == 0 ? 0 : b[i - 1]); long long hld = min(x - dist, dist); if (hld < 0) { return 0; } ans += hld + (dist - hld) * 2; } return ans <= t; }; long long l = 0, r = 2e9; while (l < r) { long long mid = (l + r) / 2; if (check(mid)) { r = mid; } else { l = mid + 1; } } auto cmp = [&](pair<long long, long long> a, pair<long long, long long> b) -> bool { return a.second < b.second; }; sort(a.begin(), a.end(), cmp); long long ans = INF; for (long long i = 0; i < ((long long)(a).size()); ++i) { if (a[i].second >= l) { ans = min(ans, a[i].first); } } cout << (ans == INF ? -1 : ans) << nl; }
#include <bits/stdc++.h> using namespace std; const int oo = (int)1e9; const double PI = 2 * acos(0.0); const double eps = 1e-9; int main() { ios_base::sync_with_stdio(false); int n, arra[100010], arrb[100010]; cin >> n; for (int i = 0; i < (int)(n); i++) { cin >> arra[i]; arrb[i] = arra[i]; } sort(arrb, arrb + n); int cnt = 0; for (int i = 0; i < (int)(n); i++) if (arra[i] != arrb[i]) cnt++; if (cnt == 2 \|\| cnt == 0) cout << YES << endl; else cout << NO << endl; return 0; }
#include <bits/stdc++.h> using namespace std; inline int read() { int x = 0; char ch = getchar(); bool positive = 1; for (; ch < 0 \|\| ch > 9 ; ch = getchar()) if (ch == - ) positive = 0; for (; ch >= 0 && ch <= 9 ; ch = getchar()) x = x * 10 + ch - 0 ; return positive ? x : -x; } int N, K; int a[105], b[105], s[105]; int t[105]; inline void trans_one(int p[]) { for (int i = 1; i <= N; ++i) t[i] = p[a[i]]; for (int i = 1; i <= N; ++i) p[i] = t[i]; } inline void trans_two(int p[]) { for (int i = 1; i <= N; ++i) t[a[i]] = p[i]; for (int i = 1; i <= N; ++i) p[i] = t[i]; } inline bool equal(int a[], int b[]) { for (int i = 1; i <= N; ++i) if (a[i] != b[i]) return 0; return 1; } int main() { N = read(), K = read(); for (int i = 1; i <= N; ++i) a[i] = read(); for (int i = 1; i <= N; ++i) s[i] = read(); for (int i = 1; i <= N; ++i) b[i] = i; if (equal(b, s)) return printf( NO n ), 0; int l = 1 << 30, r = 1 << 30; for (int i = 1; i <= K + 1; ++i) { trans_one(b); if (equal(b, s)) { r = i; break; } } for (int i = 1; i <= N; ++i) b[i] = i; for (int i = 1; i <= K + 1; ++i) { trans_two(b); if (equal(b, s)) { l = i; break; } } if (l % 2 == K % 2 && K >= l) { if (l > 1 \|\| r > 1 \|\| K - l == 0) return printf( YES n ), 0; } if (r % 2 == K % 2 && K >= r) { if (r > 1 \|\| l > 1 \|\| K - r == 0) return printf( YES n ), 0; } printf( NO n ); return 0; }
#include <bits/stdc++.h> using namespace std; long long MOD = 1e9 + 7, MAX = 1e18; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); ; long long t; cin >> t; while (t--) { long long n0, n1, n2, i; cin >> n0 >> n1 >> n2; string second = ; if (n1) { if (n1 % 2) { for (i = 0; i <= n1; i++) { if (i % 2) second.push_back( 0 ); else second.push_back( 1 ); } while (n2--) cout << 1; cout << second; while (n0--) cout << 0; cout << n ; } else { for (i = 1; i <= n1; i++) { if (i % 2) second.push_back( 0 ); else second.push_back( 1 ); } while (n2--) cout << 1; cout << 1; while (n0--) cout << 0; cout << second << n ; } } else { if (n2) for (i = 0; i <= n2; i++) cout << 1; if (n0) for (i = 0; i <= n0; i++) cout << 0; cout << n ; } } return 0; }
#include <bits/stdc++.h> using namespace std; int l[123], r[123]; int d[123]; int main() { ios_base::sync_with_stdio(false); int n; cin >> n; l[0] = 0; for (int i = 1; i < n; ++i) { int x; cin >> x; l[i] = l[i - 1] + x; } r[n - 1] = 0; vector<int> a; for (int i = 0; i < (int)n - 1; ++i) { int x; cin >> x; a.push_back(x); } int k = n - 2; for (int i = n - 2; i >= 0; --i) { r[i] = r[i + 1] + a[k]; k--; } for (int i = 0; i < (int)n; ++i) cin >> d[i]; int res[123]; for (int i = 0; i < (int)n; ++i) res[i] = d[i] + l[i] + r[i]; sort(res, res + n); cout << res[0] + res[1]; return 0; }
#include <bits/stdc++.h> using namespace std; inline long long max3(long long a, long long b, long long c) { return (a) > (b) ? ((a) > (c) ? (a) : (c)) : ((b) > (c) ? (b) : (c)); } inline long long min3(long long a, long long b, long long c) { return (a) < (b) ? ((a) < (c) ? (a) : (c)) : ((b) < (c) ? (b) : (c)); } long long extgcd(long long a, long long b, long long &x, long long &y) { if (b == 0) { x = 1; y = 0; return a; } long long d = extgcd(b, a % b, y, x); y -= a / b * x; return d; } inline long long mod(long long a, long long m) { return (a % m + m) % m; } long long modinv(long long a) { long long x, y; extgcd(a, 1000000007, x, y); return mod(x, 1000000007); } long long gcd(long long u, long long v) { long long r; while (0 != v) { r = u % v; u = v; v = r; } return u; } long long lcm(long long u, long long v) { return u / gcd(u, v) * v; } void get_all_factors(int a[], long long int n) { long long int w = sqrt(n); for (int i = 1; i <= w; i++) { if (n % i == 0) { a[i]++; a[n / i]++; } } long long int x = ceil(sqrt(n)); if (sqrt(n) == ceil(sqrt(n))) a[(int)sqrt(n)]--; } long long int memo[100000][110] = {0}; long long C(long long n, long long r) { if (r == 0 \|\| r == n) return 1; if (memo[n][r] != -1) return memo[n][r]; return memo[n][r] = (C(n - 1, r - 1) % 1000000007 + C(n - 1, r) % 1000000007) % 1000000007; } int valid(string s, int i) { if (s == lol or i == -1000050000) { return 0; } return 1; } void status(string s1 = lol , long long int i1 = -1000050000, string s2 = lol , long long int i2 = -1000050000, string s3 = lol , long long int i3 = -1000050000) { if (1) { if (valid(s1, i1)) { cout << s1 << = << i1 << ; } if (valid(s2, i2)) { cout << s2 << = << i2 << ; } if (valid(s3, i3)) { cout << s3 << = << i3 << ; } cout << endl; } } long long int poww(long long b, long long e) { if (e == 0) return 1; else if (e % 2 == 0) { long long a = pow(b, e / 2); return a * a; } else { long long a = pow(b, e / 2); return b * a * a; } } long long int powm(long long x, long long y, long long m = 1000000007) { x = x % m; long long res = 1; while (y) { if (y & 1) res = res * x; res %= m; y = y >> 1; x = x * x; x %= m; } return res; } vector<pair<int, int> > range(1000000); vector<int> adj[1000000]; vector<int> d(1000000, 0); int p[1000000] = {0}; int T = 0; void dfs(int v, int pa = -1, int dep = 0) { p[v] = pa; d[v] = dep; range[v].first = T; T++; for (auto i : adj[v]) { if (i != pa) { dfs(i, v, dep + 1); } } range[v].second = T; T++; } int main() { int n, m; cin >> n >> m; for (int i = 0; i < n - 1; i++) { int u, v; cin >> u >> v; adj[u].push_back(v); adj[v].push_back(u); } dfs(1); while (m--) { int k; cin >> k; int a[k]; for (int i = 0; i < k; i++) { cin >> a[i]; } int it = a[0]; for (auto i : a) { if (d[i] > d[it]) { it = i; } } for (auto &i : a) { if (it == i) { continue; } if (p[i] != -1) { i = p[i]; } } int ok = 1; for (auto i : a) { if (range[i].first <= range[it].first and range[i].second >= range[it].second) { } else { ok = 0; break; } } if (ok) { cout << YES << endl; } else { cout << NO << endl; } } }
#include <bits/stdc++.h> using namespace std; template <typename T> bool mmax(T &m, const T q) { if (m < q) { m = q; return true; } else return false; } template <typename T> bool mmin(T &m, const T q) { if (m > q) { m = q; return true; } else return false; } const int MOD = 1e9 + 7; const int MAXN = 5e5 + 3; const int INF = 1e9; int main(int argc, char *argv) { ios::sync_with_stdio(false); cin.tie(0); int ntest; cin >> ntest; while (ntest--) { long long x, y, a, b; cin >> x >> y >> a >> b; long long ans = a (abs(x) + abs(y)); mmin(ans, b * abs(x) + a * abs(y - x)); mmin(ans, b * abs(y) + a * abs(x - y)); cout << ans << n ; } return 0; }
#include <bits/stdc++.h> using namespace std; const int maxn = 2e5 + 5; int lazy[maxn << 2]; int a[maxn], c[maxn]; void pushup(int l, int r, int rt) { lazy[rt << 1] = lazy[rt << 1 \| 1] = lazy[rt]; lazy[rt] = 0; } void update(int L, int R, int c, int l, int r, int rt) { if (L <= l && R >= r) { lazy[rt] = c; return; } if (lazy[rt]) pushup(l, r, rt); if (L <= ((l + r) >> 1)) update(L, R, c, l, ((l + r) >> 1), rt << 1); if (R > ((l + r) >> 1)) update(L, R, c, ((l + r) >> 1) + 1, r, rt << 1 \| 1); } void query(int l, int r, int rt) { if (l == r) { c[l] = lazy[rt]; return; } if (lazy[rt]) pushup(l, r, rt); query(l, ((l + r) >> 1), rt << 1); query(((l + r) >> 1) + 1, r, rt << 1 \| 1); } struct T { int l, r; } b[maxn]; int main() { map<int, int> mp; int n, k; cin >> n >> k; for (int i = 1; i <= n; i++) cin >> a[i]; for (int i = 1; i <= n; i++) { if (a[i] == 0) continue; if (mp[a[i]]) b[a[i]].r = i; else mp[a[i]] = 1, b[a[i]].l = i, b[a[i]].r = i; } for (int i = 1; i <= k; i++) { if (mp[i]) { update(b[i].l, b[i].r, i, 1, n, 1); } } query(1, n, 1); bool d = true; for (int i = 1; i <= n; i++) { if (c[i] != a[i] && a[i] != 0) d = false; } if (!d) { cout << NO << endl; return 0; } bool ff = true; for (int i = 1; i <= n; i++) { if (a[i] == k) ff = false; } if (ff) { bool dd = false; for (int i = 1; i <= n; i++) if (a[i] == 0) { dd = true; c[i] = k; break; } if (!dd) { cout << NO << endl; return 0; } } cout << YES << endl; for (int i = 1; i <= n; i++) { if (a[i] == 0 && c[i] == 0) { c[i] = 1; } cout << c[i] << ; } cout << endl; }
#include <bits/stdc++.h> using namespace std; int main() { int t, n, x; scanf( %d , &n); priority_queue<int, vector<int>, greater<int> > que; long long ans = 0; for (int i = 0; i < n; i++) { scanf( %d , &x); if (que.empty() \|\| que.top() > x) que.push(x); else { ans += x - que.top(); que.pop(); que.push(x); que.push(x); } } printf( %lld n , ans); return 0; }
#include <bits/stdc++.h> using namespace std; mt19937 rndll(chrono::steady_clock::now().time_since_epoch().count()); const int INF = 0x3f3f3f3f, MOD = 1e9 + 7; const int N = 2e5 + 5; int n, q, a, b, cnt, k, par[N]; vector<int> adj[N], v; pair<int, int> rng[N]; void dfs(int u, int p) { par[u] = (p != -1 ? p : u); rng[u] = {INF, -INF}; for (auto v : adj[u]) if (v != p) { dfs(v, u); rng[u].first = min(rng[u].first, rng[v].first); rng[u].second = max(rng[u].second, rng[v].second); } if (rng[u].first == INF) cnt++, rng[u] = {cnt, cnt}; } bool query(vector<int> &v) { int l = -INF, r = INF; for (auto x : v) l = max(l, rng[par[x]].first), r = min(r, rng[par[x]].second); return l <= r; } int main() { ios_base::sync_with_stdio(0), cin.tie(0); cin >> n >> q; for (int i = 0; i < n - 1; i++) { cin >> a >> b; adj[a].push_back(b), adj[b].push_back(a); } dfs(1, -1); while (q--) { cin >> k; v.resize(k); for (int i = 0; i < k; i++) cin >> v[i]; cout << (query(v) ? YES n : NO n ); } }
#include <bits/stdc++.h> using namespace std; int main() { int n; vector<int> v; cin >> n; int x = 1; for (int i = 1; i <= n; i++) { int d; cin >> d; if (d == x) { v.push_back(i + 2000); x++; } } cout << v.size() << endl; for (int i = 0; i < v.size(); i++) cout << v[i] << ; return 0; }
#include <bits/stdc++.h> using namespace std; const int maxn = 2e5 + 7; const int inf = 0x3f3f3f3f; const int mod = 1e9 + 7; long long ans; int a[maxn]; int ned[maxn]; int n; int main() { scanf( %d , &n); for (int i = 1; i <= n; i++) { scanf( %d , &a[i]); ned[i] = a[i] + 1; } for (int i = 2; i <= n; i++) { ned[i] = max(ned[i], ned[i - 1]); } for (int i = n; i >= 1; i--) { ned[i] = max(ned[i + 1] - 1, ned[i]); ans += (ned[i] - a[i] - 1); } printf( %I64d n , ans); }
#include <bits/stdc++.h> using namespace std; vector<long long> A; long long B[1000000] = {0}; bool cmp(long long x, long long y) { return x > y; } int main() { A.clear(); string S1, S2; cin >> S1; for (long long i = 0; i < S1.size(); i++) A.push_back(S1[i] - 0 ); cin >> S2; for (long long i = 0; i < S2.size(); i++) B[i] = S2[i] - 0 ; sort(B, B + S2.size(), cmp); long long find = 0; for (long long i = 0; i < A.size(); i++) if (A[i] < B[find]) A[i] = B[find++]; for (long long i = 0; i < A.size(); i++) cout << A[i]; }
#include <bits/stdc++.h> using namespace std; struct Point { int num; int next[3001]; int count; }; Point a[3001]; int dis[3001]; int p[3001]; int cir[3001]; int cir1[3001]; int f(int n) { int i, num = 0, d = 1; loop: while (1) { num = 0; for (i = 1; i <= n; i++) { if (a[i].num - a[i].count == 1) { a[i].count++; p[num++] = i; } } for (i = 0; i < num; i++) { for (int j = 0; j < a[p[i]].num; j++) a[a[p[i]].next[j]].count++; } for (i = 1; i <= n; i++) { if (a[i].num - a[i].count > 0 && a[i].num - a[i].count != 2) goto loop; } num = 0; for (i = 1; i <= n; i++) { if (a[i].num - a[i].count == 2) cir[num++] = i; } return num; } } int main() { int b[4], n, i, t, sum, num, flag; int from, to; cin >> n; for (i = 1; i <= n; i++) { cin >> from >> to; a[from].next[a[from].num++] = to; a[to].next[a[to].num++] = from; } int step = 0; sum = num = f(n); memset(dis, 0xff, sizeof(dis)); for (i = 0; i < num; i++) dis[cir[i]] = step; while (sum < n) { int k = 0; step++; flag = 0; for (i = 0; i < num; i++) { for (int j = 0; j < a[cir[i]].num; j++) { int next = a[cir[i]].next[j]; if (dis[next] == -1) { sum++; flag = 1; dis[next] = step; cir1[k++] = next; continue; } } if (!flag) cir[i] = -1; } memcpy(cir, cir1, k * sizeof(cir1[0])); num = k; } for (i = 1; i <= n; i++) if (i != n) cout << dis[i] << ; else cout << dis[i] << endl; return 0; }
#include <bits/stdc++.h> using namespace std; template <typename T> inline bool chkmin(T &x, T y) { return x > y ? x = y, 1 : 0; } template <typename T> inline bool chkmax(T &x, T y) { return x < y ? x = y, 1 : 0; } template <typename T> inline void read(T &x) { char ch = getchar(); int f = 1; x = 0; while (ch < 0 \|\| ch > 9 ) { if (ch == - ) f = -1; ch = getchar(); } while (ch >= 0 && ch <= 9 ) x = x * 10 + ch - 0 , ch = getchar(); x = f; } template <typename T, typename... Args> inline void read(T &x, Args &...args) { char ch = getchar(); int f = 1; x = 0; while (ch < 0 \|\| ch > 9 ) { if (ch == - ) f = -1; ch = getchar(); } while (ch >= 0 && ch <= 9 ) x = x 10 + ch - 0 , ch = getchar(); x = f; read(args...); } int n, m, C, emp, dlt, len[300050], crs[300050], ans[300050]; set<int> se; map<int, int> both[300050]; struct Time { int t, x; bool operator<(const Time &rhs) const { return t < rhs.t; } } a[300050 << 2]; struct cloud { int l, r, c; bool operator<(const cloud &rhs) const { return c < rhs.c; } } c[300050]; struct Query { int x, id; bool operator<(const Query &rhs) const { return x < rhs.x; } } q[300050]; int maxv[300050 << 2]; void modify(int u, int l, int r, int x) { if (l == r) return (void)(maxv[u] = len[x]); if (x <= ((l + r) >> 1)) modify(u << 1, l, ((l + r) >> 1), x); else modify(u << 1 \| 1, ((l + r) >> 1) + 1, r, x); maxv[u] = max(maxv[u << 1], maxv[u << 1 \| 1]); } int query(int u, int l, int r, int tl, int tr) { if (tl > tr) return 0; if (tl <= l && r <= tr) return maxv[u]; int ret = 0; if (tl <= ((l + r) >> 1)) ret = query(u << 1, l, ((l + r) >> 1), tl, tr); if (((l + r) >> 1) < tr) chkmax(ret, query(u << 1 \| 1, ((l + r) >> 1) + 1, r, tl, tr)); return ret; } int main() { read(n, C); for (register int i = 1; i <= n; ++i) read(c[i].l, c[i].r, c[i].c); sort(c + 1, c + n + 1); int tot = 0; for (register int i = 1; i <= n; ++i) a[++tot] = Time{c[i].l, i}, a[++tot] = Time{c[i].r, -i}; a[++tot] = Time{int(2e9), 0}; sort(a + 1, a + tot + 1); read(m); for (register int i = 1; i <= m; ++i) read(q[i].x), q[i].id = i; sort(q + 1, q + m + 1); int pos = 1; for (register int i = 1; i <= tot; ++i) { int T = a[i].t - a[i - 1].t; if (se.empty()) emp += T; else if (se.size() == 1) { int x = se.begin(), cur = -1e9; len[x] += T, crs[x] += T, modify(1, 1, n, x); int rr = upper_bound(c + 1, c + n + 1, cloud{0, 0, C - c[x].c}) - c - 1; if (rr >= x) chkmax(cur, query(1, 1, n, 1, x - 1)), chkmax(cur, query(1, 1, n, x + 1, rr)); else chkmax(cur, query(1, 1, n, 1, rr)); chkmax(crs[x], len[x] + cur); if (c[x].c <= C) chkmax(dlt, crs[x]); } else if (se.size() == 2) { int x = se.begin(), y = se.rbegin(); if (c[x].c + c[y].c <= C) { both[x][y] += T; chkmax(crs[x], both[x][y] + len[x] + len[y]), chkmax(crs[y], both[x][y] + len[x] + len[y]); chkmax(dlt, max(crs[x], crs[y])); } } while (pos <= m && dlt + emp >= q[pos].x) ans[q[pos].id] = a[i].t - (dlt + emp - q[pos].x), pos++; if (a[i].x > 0) se.insert(a[i].x); else se.erase(-a[i].x); } for (register int i = 1; i <= m; ++i) printf( %d n , ans[i]); return 0; }
#include <bits/stdc++.h> using namespace std; const int _ = 600 + 7; const int __ = 1e5 + 7; const int S = 601, T = 602; const int inf = 0x3f3f3f3f; int n; int lst[_], nxt[__], to[__], cap[__], tot = 1; long long ans; int gi() { int x = 0; bool f = 0; char c = getchar(); while (!isdigit(c) and c != - ) c = getchar(); if (c == - ) f = 1, c = getchar(); while (isdigit(c)) x = (x << 3) + (x << 1) + c - 0 , c = getchar(); return f ? -x : x; } void Add(int x, int y, int c) { nxt[++tot] = lst[x]; to[tot] = y; cap[tot] = c; lst[x] = tot; nxt[++tot] = lst[y]; to[tot] = x; cap[tot] = 0; lst[y] = tot; } void Init() { n = gi(); for (int i = 1; i <= n; ++i) { int m = gi(); for (int j = 1; j <= m; ++j) Add(i, gi() + n, inf); } for (int i = 1; i <= n; ++i) { int v = gi(); ans -= v; Add(S, i, inf - v), Add(i + n, T, inf); } } int d[_], cur[_]; queue<int> q; bool Bfs() { memset(d, -1, sizeof d); while (!q.empty()) q.pop(); d[S] = 0, q.push(S); while (!q.empty()) { int u = q.front(); q.pop(); for (int i = lst[u]; i; i = nxt[i]) if (cap[i] and d[to[i]] == -1) { d[to[i]] = d[u] + 1, q.push(to[i]); if (to[i] == T) return 1; } } return 0; } int Dfs(int u, int flow) { if (u == T) return flow; int res = flow; for (int &i = cur[u]; i; i = nxt[i]) if (cap[i] and d[to[i]] == d[u] + 1) { int tmp = Dfs(to[i], min(res, cap[i])); cap[i] -= tmp, cap[i ^ 1] += tmp; res -= tmp; if (!res) return flow; } return flow - res; } void Run() { long long maxFlow = -1ll * n * inf; int flow; while (Bfs()) { memcpy(cur, lst, sizeof cur); do { flow = Dfs(S, inf); maxFlow += flow; } while (flow); } cout << min(0ll, -(ans - maxFlow)) << endl; } int main() { Init(); Run(); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int n, k, a[100010]; cin >> n >> k; if (n / 2 > k) printf( -1 n ); else { if (n == 1) { if (k == 0) printf( 1 n ); else printf( -1 n ); } else { int t = k - (n / 2 - 1); printf( %d %d , t, 2 * t); int cnt = 1; for (int i = 1; i < n / 2; i++) { printf( %d %d , 900000000 + cnt, 900000000 + cnt + 1); cnt += 2; } if (n % 2) printf( 1000000000 ); } } }
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); long long int t; cin >> t; while (t--) { long long int a, b, n, s; cin >> a >> b >> n >> s; long long int r = s % n; long long int q = s / n; if (q <= a) { if (r <= b) { cout << YES << n ; } else cout << NO << n ; } else if (((q - a) * n + r) <= b) { cout << YES << n ; } else { cout << NO << n ; } } }
#include <bits/stdc++.h> using namespace std; string itos(int x) { stringstream ss; ss << x; return ss.str(); } int xorsum, n, a[110]; map<int, int> grun; int sieve[31700]; vector<int> p; int mex(set<int> &s) { for (int i = 0;; i++) if (not s.count(i)) return i; } int getGrundy(int x) { if (grun.count(x)) return grun[x]; if (x == 1) return grun[x] = 0; set<int> s; for (int i = 1; (1 << i) <= x; i++) s.insert(getGrundy(x >> i \| (x & ((1 << i) - 1)))); return grun[x] = mex(s); } void solve(int x) { int mask = 0; for (int i = 0; i < n; i++) { int cnt = 0; while (a[i] % x == 0) cnt++, a[i] /= x; mask \|= (1 << cnt); } xorsum ^= getGrundy(mask); } int main() { ios_base::sync_with_stdio(false); cin >> n; for (int i = 0; i < n; i++) cin >> a[i]; for (int i = 2; i < 31700; i++) { if (not sieve[i]) { p.push_back((i)); for (int j = i * i; j < 31700; j += i) sieve[j] = 1; } } for (int i = 0; i < n; i++) { auto it1 = p.begin(); while (a[i] > 1) { if (it1 == p.end()) { solve(a[i]); break; } else if (a[i] % it1 == 0) solve(it1); it1++; } } cout << (xorsum ? Mojtaba : Arpa ) << endl; return 0; }
#include <bits/stdc++.h> using namespace std; const long long int Maxn3 = 1e3 + 10; const long long int Maxn4 = 1e4 + 10; const long long int Maxn5 = 1e5 + 10; const long long int Maxn6 = 1e6 + 10; const long long int Maxn7 = 1e7 + 10; const long long int Maxn8 = 1e8 + 10; const long long int Maxn9 = 1e9 + 10; const long long int Maxn18 = 1e18 + 10; const long long int Mod1 = 1e7 + 7; const long long int Mod2 = 1e9 + 7; const long long int LLMax = LLONG_MAX; const long long int LLMin = LLONG_MIN; const long long int INTMax = INT_MAX; const long long int INTMin = INT_MIN; long long int mn = LLMax, mx = LLMin; char s[Maxn6]; int main() { ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL); string s1( ... n.X. n ), s2( .X. n ), s; long long int res = 0; cin >> s; for (long long int i = 0; i < s.size(); i++) { if (res < s[i]) res += 256; while (res > s[i]) { res--; cout << s1; } cout << s2; } }
#include <bits/stdc++.h> std::mt19937 rng( (int)std::chrono::steady_clock::now().time_since_epoch().count()); int main() { std::ios_base::sync_with_stdio(false); std::cin.tie(NULL); int n, w, m; std::cin >> n >> w >> m; std::cout << std::setprecision(10) << std::fixed; std::vector<std::vector<std::pair<int, int>>> ans(m); w = m; int cup = n w / m; int rest = w; for (int i = 0, j = 0; i < m; i++) { if (rest > 0 && rest != w && rest > cup) { std::cout << NO n ; return 0; } int want = cup; while (want > 0) { int use = std::min(rest, want); assert(use != 0); ans[i].emplace_back(use, j + 1); want -= use; rest -= use; if (rest == 0) { j++; rest = w; } } } std::cout << YES n ; for (auto vec : ans) { for (int i = 0; i < (int)vec.size(); i++) { std::cout << vec[i].second << << (double)vec[i].first / m << (i + 1 == (int)vec.size() ? n : ); } } }
#include <bits/stdc++.h> using namespace std; constexpr int INF = 1e9 + 1; constexpr long long LLINF = 1e18 + 1; long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; } long long lcm(long long a, long long b) { return a / gcd(a, b) * b; } void solve() { int n, t; cin >> n; vector<int> arr(101); for (__typeof(n) i = 0; i < n; i++) { cin >> t; arr[t] = 1; } int col = 0; for (int i = 1; i <= 100; i++) if (arr[i]) { for (int j = i; j <= 100; j += i) { arr[j] = 0; } col++; } printf( %d n , col); } int main() { ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0); int t = 1; while (t--) solve(); }
#include <bits/stdc++.h> using namespace std; int main() { long long n; cin >> n; long long a[n]; for (int i = 0; i < n; i++) cin >> a[i]; cout << a[1] - a[0] << << a[n - 1] - a[0] << endl; for (int i = 1; i <= n - 2; i++) { cout << min(a[i] - a[i - 1], a[i + 1] - a[i]) << << max(a[i] - a[0], a[n - 1] - a[i]) << endl; } cout << a[n - 1] - a[n - 2] << << a[n - 1] - a[0]; return 0; }
#include <bits/stdc++.h> using namespace std; const int mod = 998244353; int power(int v, int u) { if (!u) return 1; int ok = power(v, u >> 1); if (u & 1) return (long long)ok * ok % mod * v % mod; return (long long)ok * ok % mod; } const int maxm = 2e5; int b[maxm + 10]; int main() { int n, m, A; scanf( %d%d%d , &n, &m, &A); for (int i = 1; i <= m; i++) scanf( %d , &b[i]); int ans = 1; int inv2 = power(2, mod - 2); for (int i = 1; i <= m; i++) ans = (long long)ans * (((long long)power(A, 2 * (b[i] - b[i - 1])) + power(A, b[i] - b[i - 1])) % mod * inv2 % mod) % mod; ans = (long long)ans * power(A, n - b[m] - b[m]) % mod; printf( %d n , ans); return 0; }
#include <bits/stdc++.h> using namespace std; const long double eps = 1e-9; const int inf = (1 << 30) - 1; const long long inf64 = ((long long)1 << 62) - 1; const long double pi = acos(-1); template <class T> T sqr(T x) { return x * x; } template <class T> T abs(T x) { return x < 0 ? -x : x; } const int MAXK = 105; const int magic = 100 * 1000; int a[MAXK]; int ans_small[MAXK][magic]; long long get_ans(long long n, int k) { if (k == 0) { return n; } if (n < magic) { return ans_small[k][n]; } return get_ans(n, k - 1) - get_ans(n / a[k - 1], k - 1); } int main() { ios_base::sync_with_stdio(0); long long n; int k; cin >> n >> k; for (int i = 0; i < k; ++i) { cin >> a[i]; } sort(a, a + k); for (int i = 0; i < magic; ++i) { ans_small[0][i] = i; } for (int i = 1; i <= k; ++i) { for (int j = 0; j < magic; ++j) { ans_small[i][j] = ans_small[i - 1][j] - ans_small[i - 1][j / a[i - 1]]; } } cout << get_ans(n, k) << endl; return 0; }
#include <bits/stdc++.h> using namespace std; const long long mod = 1000000007; long long Power(long long a, long long b) { if (a == 0) return 0LL; long long ans = 1; while (b) { if (b & 1) ans = (ans * a) % mod; a = (a * a) % mod; b >>= 1; } return ans; } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); long long n, m, k; cin >> n >> m >> k; if (k == -1 && n % 2 != m % 2) { cout << 0 << endl; return 0; } long long ans = Power(Power(2, (n - 1)), m - 1); cout << ans << endl; }
#include <bits/stdc++.h> using namespace std; const int mod = 1e9 + 7; long long dp[20][20][20]; int a[20]; long long num[20]; long long dfs(int pos, int pre, int sta, bool flag) { if (pos == 0) { if (pre == sta) return 1; else return 0; } if (dp[pos][pre][sta] != -1 && !flag) return dp[pos][pre][sta]; int maxx = flag ? a[pos] : 9; long long sum = 0; for (int i = 0; i <= maxx; i++) { sum += dfs(pos - 1, pre + (i == 4 \|\| i == 7), sta, flag && (i == a[pos])); } if (!flag) dp[pos][pre][sta] = sum; return sum; } long long solve(int pos, int res) { long long ans = 0; if (pos == 7) return 1; for (int i = 0; i <= res; i++) { if (num[i]) { num[i]--; ans = (ans + (num[i] + 1) * solve(pos + 1, res - i) % mod) % mod; num[i]++; } } return ans; } void cal(int x) { int len = 0; while (x) { len++; a[len] = x % 10; x /= 10; } for (int i = 0; i <= len; i++) { num[i] = dfs(len, 0, i, 1); } num[0]--; long long ans = 0; for (int i = 1; i <= len; i++) { ans = (ans + num[i] * solve(1, i - 1) % mod) % mod; } printf( %lld n , ans); } int main() { memset(dp, -1, sizeof dp); int m; scanf( %d , &m); cal(m); }
#include <bits/stdc++.h> using namespace std; int a[29]; int main() { int n, k; char s[105]; scanf( %d , &n); scanf( %d , &k); scanf( %s , s + 1); bool f(true); for (int i = 1; i <= n; ++i) { int temp = s[i] - a ; a[temp]++; if (a[temp] > k) { f = false; break; } } if (f) printf( YES n ); else printf( NO n ); return 0; }
#include <bits/stdc++.h> const int mod = 1000003; char str[2010]; int f[2010][2010]; int main() { int n, i, j, len; bool flag = true; gets(str); n = strlen(str); for (i = 0; i <= n; i++) { if (str[i] == * \|\| str[i] == / \|\| i == n) if (i == 0 \|\| str[i - 1] < 0 \|\| str[i - 1] > 9 ) flag = false; } if (!flag) { printf( 0 n ); return 0; } f[0][0] = 1; len = 0; for (i = 1; i <= n; i++) { flag = ( 0 <= str[i - 1] && str[i - 1] <= 9 ); if (!flag) len++; for (j = len; j >= 0; j--) { if (flag) { f[i][j] = f[i - 1][j]; if ( 0 > str[i] \|\| str[i] > 9 ) f[i][j] = (f[i][j] + f[i][j + 1]) % mod; } else if (j > 0) f[i][j] = f[i - 1][j - 1]; } } printf( %d n , f[n][0]); return 0; }
#include <bits/stdc++.h> using namespace std; using ll = long long; using vi = vector<int>; using vl = vector<ll>; using pi = pair<int, int>; namespace output { void pr(int x) { cout << x; } void pr(long x) { cout << x; } void pr(ll x) { cout << x; } void pr(unsigned x) { cout << x; } void pr(unsigned long x) { cout << x; } void pr(unsigned long long x) { cout << x; } void pr(float x) { cout << x; } void pr(double x) { cout << x; } void pr(long double x) { cout << x; } void pr(char x) { cout << x; } void pr(const char* x) { cout << x; } void pr(const string& x) { cout << x; } void pr(bool x) { pr(x ? true : false ); } template <class T1, class T2> void pr(const pair<T1, T2>& x); template <class T> void pr(const T& x); template <class T, class... Ts> void pr(const T& t, const Ts&... ts) { pr(t); pr(ts...); } template <class T1, class T2> void pr(const pair<T1, T2>& x) { pr( { , x.first, , , x.second, } ); } template <class T> void pr(const T& x) { pr( { ); bool fst = 1; for (const auto& a : x) pr(!fst ? , : , a), fst = 0; pr( } ); } void ps() { pr( n ); } template <class T, class... Ts> void ps(const T& t, const Ts&... ts) { pr(t); if (sizeof...(ts)) pr( ); ps(ts...); } void pc() { cout << ] << endl; } template <class T, class... Ts> void pc(const T& t, const Ts&... ts) { pr(t); if (sizeof...(ts)) pr( , ); pc(ts...); } } // namespace output using namespace output; const int MX = 200005; const int MOD = (int)(1e9 + 7); const ll INF = (ll)1e18; int main() { ios::sync_with_stdio(false); cin.tie(0); int n; cin >> n; vi a(n); vi cnt(101); for (int i = 0; i < n; i++) { cin >> a[i]; cnt[a[i]]++; } pi best = make_pair(-1, -1); for (int i = 1; i <= 100; i++) { if (cnt[i] > best.second) best = make_pair(i, cnt[i]); } for (int i = 1; i <= 100; i++) { if (i != best.first && cnt[i] == best.second) { cout << n << n ; return 0; } } int ret = 0; for (int v = 1; v <= 100; v++) { if (v == best.first) continue; int ans = 0; vi nv(n); for (int i = 0; i < n; i++) { if (a[i] == v) nv[i] = -1; else if (a[i] == best.first) nv[i] = 1; } vi mn(2 * n + 1, -2); mn[n] = -1; int sum = 0; for (int i = 0; i < n; i++) { sum += nv[i]; if (mn[sum + n] != -2) ans = max(ans, i - mn[sum + n]); else mn[sum + n] = i; } ret = max(ret, ans); } cout << ret << n ; }
#include <bits/stdc++.h> using namespace std; const int maxn = 1e5 + 10; long long int cal(long long int num) { return (num * (num + 1)) / 2ll; } void solve() { long long int n; scanf( %lld , &n); n--; long long int ans = 0, k = 1; for (long long int i = 1; i <= n; i <<= 1) { ans += ((n - i) / (i << 1) + 1) * i; } printf( %lld n , ans); } int main() { int t = 1; while (t--) { solve(); } return 0; }
#include <bits/stdc++.h> using namespace std; const int MOD = 1e9 + 9; const double eps = 1e-5; const int maxN = 2e3 + 10; const int inf = 1e9; int n, m; vector<pair<int, int> > a[maxN]; int vis[maxN], c[maxN]; vector<int> pat; inline void dfs(int v, int f = -1) { for (int i = 0; i < a[v].size(); i++) { if (a[v][i].first <= f) continue; if (!vis[a[v][i].second]) { vis[a[v][i].second] = 1; dfs(a[v][i].first); } } pat.push_back(v); } inline void init() { cin >> n >> m; for (int i = 0; i < m + 1; i++) { cin >> c[i]; c[i]--; } for (int i = 1; i < m + 1; i++) { int v = c[i - 1], u = c[i]; a[v].push_back(make_pair(u, i - 1)); a[u].push_back(make_pair(v, i - 1)); } for (int i = 0; i < n; i++) sort(a[i].begin(), a[i].end()); } inline void solve() { for (int i = m - 1; i >= 0; i--) { memset(vis, 0, sizeof vis); pat.clear(); for (int j = 0; j < i; j++) vis[j] = 1; dfs(c[i], c[i + 1]); if (i + pat.size() == m + 1) { reverse(pat.begin(), pat.end()); for (int j = 0; j < i; j++) cout << c[j] + 1 << ; for (int j = 0; j < pat.size(); j++) cout << pat[j] + 1 << ; cout << endl; return; } } cout << No solution << endl; } int main() { ios_base::sync_with_stdio(0); cin.tie(); cout.tie(); init(); solve(); return 0; }
#include <bits/stdc++.h> using namespace std; int n, m; vector<int> edge[110000]; vector<pair<int, int> > R; set<int> N; int find(int rt, int to) { int i; for (i = 0; i < edge[rt].size(); i++) { if (edge[rt][i] == to) return 1; } return 0; } int dfs(int rt) { if (R.size() == m \|\| R.size() == n - 1) return 1; N.erase(rt); set<int>::iterator it; for (it = N.begin(); it != N.end(); it++) { if (find(rt, it)) continue; R.push_back(make_pair(rt, it)); if (dfs(it)) return 1; R.pop_back(); it = N.find(it); } N.insert(rt); return 0; } int main() { int a, b, i; scanf( %d%d , &n, &m); for (i = 1; i <= m; i++) { scanf( %d%d , &a, &b); edge[a].push_back(b); edge[b].push_back(a); } for (i = 1; i <= n; i++) { N.insert(i); } for (i = 1; i <= n; i++) { if (dfs(i)) { if (n == m) R.push_back(make_pair(R[0].first, R[R.size() - 1].second)); for (i = 0; i < m; i++) printf( %d %d n , R[i].first, R[i].second); return 0; } } puts( -1 ); return 0; }

#include <bits/stdc++.h> using namespace std; const int N = 2e5 + 5; char s[200]; int main() { int T; scanf( %d , &T); for (int t = 1; t <= T; t++) { bool num = 0, xx = 0, dx = 0; vector<int> res; scanf( %s , s + 1); int len = strlen(s + 1); for (int i = 1; i <= len; i++) { if (isdigit(s[i])) { if (!num) num = 1; else res.push_back(i); } if (isalpha(s[i])) { if (s[i] == tolower(s[i])) { if (!xx) xx = 1; else res.push_back(i); } else { if (!dx) dx = 1; else res.push_back(i); } } } int cnt = 1; if (num == 0) s[res.back()] = 1 , res.pop_back(); if (xx == 0) s[res.back()] = a , res.pop_back(); if (dx == 0) s[res.back()] = A , res.pop_back(); printf( %s n , s + 1); } }

#include <bits/stdc++.h> using namespace std; int main() { long long int n, k; cin >> n; long long int a[n]; for (int i = 0; i < n; i++) cin >> a[i]; sort(a, a + n); int sum = 0; for (int i = 0; i < n - 1; i++) sum += (a[n - 1] - a[i]); cout << sum; }

#include <bits/stdc++.h> void swap(int *, int *); int main() { int i, j, k; int n; scanf( %d , &n); int arr[n]; for (i = 0; i < n; i++) { scanf( %d , &arr[i]); } int limit = n / 2; for (i = 0; i < limit; i++) { if (i % 2 == 0) { swap(&arr[i], &arr[n - i - 1]); } } for (i = 0; i < n; i++) { printf( %d , arr[i]); } } void swap(int *a, int *b) { int t; t = *a; *a = *b; *b = t; }

#include <bits/stdc++.h> using namespace std; int main() { int n, m; scanf( %d %d , &n, &m); int a, b, a_min, b_min; scanf( %d %d , &a_min, &b_min); for (int i = 1; i < n; i++) { scanf( %d %d , &a, &b); if (a * b_min < a_min * b) { a_min = a; b_min = b; } } double c = m * a_min / (b_min * 1.0f); printf( %f n , c); return 0; }

#include <bits/stdc++.h> using namespace std; const int N = 2e5; struct P { long long x, y; bool a; P() {} P(long long _x, long long _y, bool _a) : x(_x), y(_y), a(_a) {} long long operator^(const P &t) const { return x * t.y - y * t.x; } bool operator<(const P &t) const { if (y == t.y) return x < t.x; return y < t.y; } P operator-(const P &t) const { return P(x - t.x, y - t.y, 0); } } p[N]; int n, m; bool flag[N]; int st[N], tops; void granhamScan() { st[0] = 0; tops = 1; for (int i = 1; i < m; ++i) { while (tops >= 2 && ((p[st[tops - 1]] - p[st[tops - 2]]) ^ (p[i] - p[st[tops - 1]])) < 0) { flag[st[tops - 1]] = false; tops--; } st[tops++] = i; flag[i] = true; } for (int i = m - 1; i >= 0; --i) { if (flag[i]) continue; while (tops >= 2 && ((p[st[tops - 1]] - p[st[tops - 2]]) ^ (p[i] - p[st[tops - 1]])) < 0) { flag[st[tops - 1]] = false; tops--; } st[tops++] = i; flag[i] = true; } } bool check() { for (int i = 0; i < tops; ++i) { if (!p[st[i]].a) return 0; } return 1; } int main() { scanf( %d , &n); for (int i = 0; i < n; ++i) { int x, y; scanf( %d%d , &x, &y); p[i] = P(x, y, 1); } scanf( %d , &m); m += n; for (int i = n; i < m; ++i) { int x, y; scanf( %d%d , &x, &y); p[i] = P(x, y, 0); } sort(p, p + m); p[m] = p[0]; granhamScan(); if (check()) printf( YES n ); else printf( NO n ); return 0; }

#include <bits/stdc++.h> using namespace std; const int INF = 0x3f3f3f3f; const long double EPS = 1e-6; const int N = 200020, MOD = 998244353; int n, k; long long a[N + 20], fact[N + 20], inv[N + 20]; long long qpow(long long a, long long b, long long p = MOD) { long long ans = 1; for (; b; b >>= 1) { if (b & 1) ans = ans * a % p; a = a * a % p; } return ans % p; } void prework() { fact[0] = 1; for (int i = 1; i <= N; i++) fact[i] = fact[i - 1] * i % MOD; inv[N - 1] = qpow(fact[N - 1], MOD - 2) % MOD; for (int i = N - 2; ~i; i--) inv[i] = inv[i + 1] * (i + 1) % MOD; } long long C(int n, int m) { if (n - m < 0 || m < 0) return 0; return fact[n] % MOD * inv[m] % MOD * inv[n - m] % MOD % MOD; } int main() { prework(); cin >> n >> k; for (int i = 1; i <= n; i++) cin >> a[i]; long long ans = 0; int c = 0, m = 0; a[n + 1] = a[1]; for (int i = 1; i <= n; i++) if (a[i] != a[i + 1]) m++; for (int i = 0; i <= m / 2; i++) { ans += C(m, i) % MOD * C(m - i, i) % MOD * qpow(k - 2, m - 2 * i) % MOD; ans %= MOD; } ans = (qpow(k, m) - ans + MOD) % MOD * qpow(2, MOD - 2) % MOD; cout << ans % MOD * qpow(k, n - m) % MOD << endl; return 0; }

#include <bits/stdc++.h> using namespace std; int n, m; vector<int> A; vector<pair<int, int> > M; vector<int> PP; int turn; set<int> Go; int ans(int x) { cout << x + 1 << endl; if (Go.empty()) exit(0); cin >> x; return x - 1; } signed main() { ; cin >> n >> m; A.resize(n << 1); for (auto &x : A) cin >> x; M.resize(m); for (auto &x : M) cin >> x.first >> x.second, x.first--, x.second--; PP.assign(n << 1, -1); for (auto x : M) PP[x.first] = x.second, PP[x.second] = x.first; for (int i = 0; i < n << 1; i++) { Go.insert(i); } cin >> turn; if (turn == 1) { for (auto x : M) { if (A[x.first] > A[x.second]) { ans(x.first); Go.erase(x.first); Go.erase(x.second); } else { ans(x.second); Go.erase(x.first); Go.erase(x.second); } } while (Go.size()) { int mx = -1, r = -1; for (auto &x : Go) { if (mx < A[x]) mx = A[x], r = x; } Go.erase(r); Go.erase(ans(r)); } } else { int x; cin >> x; x--; Go.erase(x); while (PP[x] != -1) { Go.erase(PP[x]); x = ans(PP[x]); Go.erase(x); } for (auto x : M) { if (!Go.count(x.first)) continue; if (A[x.first] > A[x.second]) { ans(x.first); Go.erase(x.first); Go.erase(x.second); } else { ans(x.second); Go.erase(x.first); Go.erase(x.second); } } while (Go.size()) { int mx = -1, r = -1; for (auto &x : Go) { if (mx < A[x]) mx = A[x], r = x; } Go.erase(r); Go.erase(ans(r)); } } }

#include <bits/stdc++.h> using namespace std; int ans[500][500], st[500][500]; vector<pair<int, int> > go[500][500]; vector<vector<int> > cc; vector<int> c; int mv[1 << 20]; int it; void pr(int n, int k) { if (k == 1) { c.push_back(n); mv[(((c[4] * 16 + c[3]) * 16 + c[2]) * 16 + c[1]) * 16 + c[0]] = it; cc.push_back(c); it++; c.pop_back(); return; } for (int j = 0; j <= n; j++) { c.push_back(j); pr(n - j, k - 1); c.pop_back(); } } int kkk[5] = {1, 16, 256, 4096, 65536}; void get_int(int &ans) { ans = 0; char c = getchar(); while (c < 0 || c > 9 ) c = getchar(); while (c >= 0 && c <= 9 ) { ans = ans * 10 + c - 0 ; c = getchar(); } } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); pr(8, 5); queue<pair<int, int> > pp; for (int j = 0; j < cc.size(); j++) { vector<int> vv = cc[j]; int cnum = (((vv[4] * 16 + vv[3]) * 16 + vv[2]) * 16 + vv[1]) * 16 + vv[0]; bool ok = true; for (int q = 0; q < cc.size(); q++) { bool ok1 = true; for (int ii = 1; ii < 5; ii++) { if (cc[j][ii]) { ok = false; for (int jj = 1; jj < 5; jj++) { if (cc[q][jj]) { ok1 = false; cnum -= kkk[ii]; cnum += kkk[(ii + jj) % 5]; go[q][mv[cnum]].push_back(make_pair(j, q)); st[j][q]++; cnum += kkk[ii]; cnum -= kkk[(ii + jj) % 5]; } } if (ok) { ans[j][q] = 1; pp.push(make_pair(j, q)); } else if (ok1) { ans[j][q] = 2; pp.push(make_pair(j, q)); } } } } } while (!pp.empty()) { int j = pp.front().first; int q = pp.front().second; pp.pop(); for (auto v : go[j][q]) { if (ans[v.first][v.second]) continue; if (ans[j][q] == 2) { ans[v.first][v.second] = 1; pp.push(v); continue; } st[v.first][v.second]--; if (st[v.first][v.second] == 0) { ans[v.first][v.second] = 2; pp.push(v); continue; } } } int t; cin >> t; for (int i = 0; i < t; i++) { int f; cin >> f; int a = 0, b = 0; for (int j = 0; j < 8; j++) { int k; cin >> k; a += (1 << (k * 4)); } for (int j = 0; j < 8; j++) { int k; cin >> k; b += (1 << (k * 4)); } int k1 = mv[a], k2 = mv[b]; if (f == 0) { if (ans[k1][k2] == 1) cout << Alice << n ; if (ans[k1][k2] == 2) cout << Bob << n ; if (ans[k1][k2] == 0) cout << Deal << n ; } else { swap(k1, k2); if (ans[k1][k2] == 2) cout << Alice << n ; if (ans[k1][k2] == 1) cout << Bob << n ; if (ans[k1][k2] == 0) cout << Deal << n ; } } return 0; }

#include <bits/stdc++.h> using namespace std; int n, i; int a, b, c, d; vector<long long> v; long long ans; void add(int a, int b) { ans += a - b; v.push_back(a + b); } void add_stack() { if (a + b >= c + d) { add(a, b); add(c, d); return; } if (a > d) add(a - d, d - a); if (b > c) add(c - b, b - c); } int main() { scanf( %d , &n); for (i = 1; i <= n; i++) { scanf( %d%d%d%d , &a, &b, &c, &d); add_stack(); } sort(v.begin(), v.end()); reverse(v.begin(), v.end()); long long sgn = 1; for (auto e : v) { ans += sgn * e; sgn *= -1; } printf( %lld , ans / 2); return 0; }

#include <bits/stdc++.h> using namespace std; const int M = 4005; int read() { int x = 0, f = 1; char c; while ((c = getchar()) < 0 || c > 9 ) { if (c == - ) f = -1; } while (c >= 0 && c <= 9 ) { x = (x << 3) + (x << 1) + (c ^ 48); c = getchar(); } return x * f; } int n, m, t, a[M], s[M], siz[M], ch[M][2]; long long dp[M][M]; void upd(long long &x, long long y) { x = max(x, y); } void dfs(int u) { dp[u][0] = 0; if (!u) return; int ls = ch[u][0], rs = ch[u][1]; dfs(ls); dfs(rs); siz[u] = 1 + siz[ls] + siz[rs]; for (int i = 0; i <= siz[ls]; i++) for (int j = 0; j <= siz[rs]; j++) upd(dp[u][i + j], dp[ls][i] + dp[rs][j] - 2ll * i * j * a[u]); for (int i = siz[u] - 1; i >= 0; i--) upd(dp[u][i + 1], dp[u][i] + (m - 2 * i - 1ll) * a[u]); } signed main() { n = read(); m = read(); memset(dp, -0x3f, sizeof dp); for (int i = 1; i <= n; i++) { a[i] = read(); while (t > 0 && a[s[t]] > a[i]) ch[i][0] = s[t--]; if (t) ch[s[t]][1] = i; s[++t] = i; } dfs(s[1]); printf( %lld n , dp[s[1]][m]); }

#include <bits/stdc++.h> using namespace std; int n, m, q, l, r; double d, s, t, x, y; int tree[2000010 * 4], pl[2000010 * 4], pr[2000010 * 4], cnt = 1; bool flag[2000010 * 4]; void change(int l, int r, int id, int l1, int r1) { if (l >= l1 && r <= r1) { tree[id] = r - l + 1; flag[id] = 1; return; } if (flag[id]) return; int mid = (l + r) >> 1; if (l1 <= mid) { if (pl[id] == 0) pl[id] = ++cnt; change(l, mid, pl[id], l1, r1); } if (r1 > mid) { if (pr[id] == 0) pr[id] = ++cnt; change(mid + 1, r, pr[id], l1, r1); } tree[id] = tree[pl[id]] + tree[pr[id]]; } int dist(int l, int r, int l1, int r1) { int l2 = max(l, l1); int r2 = min(r, r1); return r2 - l2 + 1; } int query(int l, int r, int id, int l1, int r1) { if (l1 > r1) return 0; if (l >= l1 && r <= r1) return tree[id]; if (flag[id]) return dist(l, r, l1, r1); int mid = (l + r) >> 1; int res = 0; if (l1 <= mid && pl[id]) res += query(l, mid, pl[id], l1, r1); if (r1 > mid && pr[id]) res += query(mid + 1, r, pr[id], l1, r1); return res; } int main() { scanf( %lf%lf%lf , &d, &s, &t); d *= -1.0; scanf( %d , &n); for (int i = 1; i <= n; i++) { scanf( %d%d , &l, &r); change(1, 0x3FFFFFFF, 1, l, r - 1); } scanf( %d , &q); for (int i = 1; i <= q; i++) { scanf( %lf%lf , &x, &y); double ts = (y + d) / y; double l1 = x + (s - x) / ts; double r1 = x + (t - x) / ts; int l2 = ceil(l1); int r2 = floor(r1); double ans = 0; if (l2 == r2 + 1) { if (query(1, 0x3FFFFFFF, 1, l2 - 1, l2 - 1)) ans = r1 - l1; } else { ans += query(1, 0x3FFFFFFF, 1, l2, r2 - 1); if (query(1, 0x3FFFFFFF, 1, l2 - 1, l2 - 1)) ans += l2 * 1.0 - l1; if (query(1, 0x3FFFFFFF, 1, r2, r2)) ans += r1 - r2 * 1.0; } ans *= ts; printf( %.6lf n , ans); } }

#include <bits/stdc++.h> using namespace std; map<string, string> m; int main() { int n; string j, x; cin >> n; while (n--) { cin >> j >> x; if (m.count(j) == 0) m[x] = j; else { m[x] = m[j]; m.erase(j); } } cout << m.size() << endl; map<string, string>::iterator it; for (it = m.begin(); it != m.end(); it++) { cout << it->second << << it->first << endl; } return 0; }

#include <bits/stdc++.h> using namespace std; const int N = 1000010; int cnt, lst, fa[N * 2], len[N * 2], ch[N * 2][26]; long long w[N * 2], ans; int od[N * 2], rk[N * 2], l = 1; char s[N]; void Init() { cnt = lst = 1; } void Insert(int c) { int p = lst, np = lst = ++cnt; len[np] = len[p] + 1; while (p && ch[p][c] == 0) ch[p][c] = np, p = fa[p]; if (!p) fa[np] = 1; else { int q = ch[p][c], nq; if (len[q] == len[p] + 1) fa[np] = q; else { len[nq = ++cnt] = len[p] + 1; fa[nq] = fa[q]; fa[q] = fa[np] = nq; memcpy(ch[nq], ch[q], sizeof(ch[q])); while (ch[p][c] == q) ch[p][c] = nq, p = fa[p]; } } } int n; int main() { Init(); scanf( %d , &n); for (int i = 1; i <= n; i++) { scanf( %s , s + l); l += strlen(s + l); s[l++] = # ; } for (int i = 1, j = 0, x, p; i <= n; i++) { lst = 1; for (j += 1; s[j] != # ; j++) { Insert(s[j] - a ); } } for (int i = 1, j = 0, x, p; i <= n; i++) { scanf( %d , &x); for (p = 1, j += 1; s[j] != # ; j++) { p = ch[p][s[j] - a ]; w[p] += x; } } for (int i = 1; i <= cnt; i++) rk[len[i]] += 1; for (int i = 1; i <= cnt; i++) rk[i] += rk[i - 1]; for (int i = 1; i <= cnt; i++) od[rk[len[i]]--] = i; for (int i = cnt; i >= 1; i--) w[fa[od[i]]] += w[od[i]]; for (int i = 2; i <= cnt; i++) ans = max(ans, len[i] * w[i]); printf( %lld n , ans); return 0; }

#include <bits/stdc++.h> using namespace std; int t, n, m, ans; vector<vector<int>> gh, used; int dx[8] = {1, 1, 1, 0, 0, -1, -1, -1}; int dy[8] = {1, 0, -1, 1, -1, 1, 0, -1}; bool onseg(double x1, double y1, double x2, double y2, double x, double y) { double d1 = sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1)); double d2 = sqrt((x - x2) * (x - x2) + (y - y2) * (y - y2)); double d3 = sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)); return abs(d3 - d2 - d1) < 1e-9; } void bfs(int y, int x) { if (gh[y][x] == 0) return; if (used[y][x]) return; used[y][x] = true; vector<pair<int, int>> todo, temp, bunch; int cx, cy, nx, ny; todo.push_back({y, x}); bunch.push_back({y, x}); while (true) { if (todo.empty()) break; for (int i = 0; i < todo.size(); i++) { cy = todo[i].first, cx = todo[i].second; for (int j = 0; j < 8; j++) { ny = cy + dy[j]; nx = cx + dx[j]; if (ny >= 0 && ny < n && nx >= 0 && nx < m) { if (used[ny][nx] == 0) { temp.push_back({ny, nx}); bunch.push_back({ny, nx}); used[ny][nx] = 1; } } } } todo = temp; temp.clear(); } if (bunch.size() % 4) return; int len = bunch.size() / 4; int topx, topy, btx, bty; topx = bunch[0].second, topy = bunch[0].first; btx = topx + len, bty = topy + len; bool sq = true; for (int j = 1; j < bunch.size(); j++) { int nx = bunch[j].second, ny = bunch[j].first; if (!onseg(topx, topy, btx, topy, nx, ny) && !onseg(topx, topy, topx, bty, nx, ny) && !onseg(btx, bty, btx, topy, nx, ny) && !onseg(btx, bty, topx, bty, nx, ny)) { sq = false; break; } } if (sq) { ans++; return; } sq = true; topx = bunch[0].second, topy = bunch[0].first; btx = topx, bty = topy + 2 * len; for (int j = 1; j < bunch.size(); j++) { int nx = bunch[j].second, ny = bunch[j].first; if (!onseg(topx, topy, topx - len, topy + len, nx, ny) && !onseg(topx, topy, topx + len, topy + len, nx, ny) && !onseg(btx, bty, topx - len, topy + len, nx, ny) && !onseg(btx, bty, topx + len, topy + len, nx, ny)) { sq = false; break; } } if (sq) { ans++; } } void solve() { cin >> n >> m; gh = used = vector<vector<int>>(n, vector<int>(m)); ans = 0; char ch; int val; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { cin >> ch; val = ch - 0 ; if (val == 0) used[i][j] = 1; gh[i][j] = val; } } for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) if (used[i][j] == 0) bfs(i, j); } cout << ans << endl; } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cin >> t; while (t--) solve(); return 0; }

#include <bits/stdc++.h> using namespace std; const int MAX_N = 2000; int N; int board[MAX_N][MAX_N]; int cur[MAX_N][MAX_N]; int row[MAX_N], col[MAX_N]; char buf[MAX_N + 10]; void pb(int arr[MAX_N][MAX_N]) { for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { printf( %d , arr[i][j]); } puts( ); } } int solve() { int ans = 0; for (int i = N - 1; i > 0; i--) { for (int j = 0; j < N - i; j++) { int y = i + j, x = j; cur[y][x] = row[y] ^ col[x]; if (cur[y][x] ^ board[y][x]) { ans++; cur[y][x] ^= 1; row[y] ^= 1; col[x] ^= 1; } } } for (int i = 0; i < N; i++) { if (col[i] ^ row[i]) { board[i][i] ^= 1; } } memset(col, 0, sizeof(col)); memset(row, 0, sizeof(row)); for (int j = N - 1; j > 0; j--) { for (int i = 0; i < N - j; i++) { int y = i, x = j + i; cur[y][x] = row[y] ^ col[x]; if (cur[y][x] ^ board[y][x]) { ans++; cur[y][x] ^= 1; row[y] ^= 1; col[x] ^= 1; } } } for (int i = 0; i < N; i++) { if (row[i] ^ col[i] ^ board[i][i]) { ans++; } } return ans; } int main() { scanf( %d , &N); for (int i = 0; i < N; i++) { scanf( %s , buf); for (int j = 0; j < N; j++) { board[i][j] = buf[j] & 1; } } printf( %d n , solve()); return 0; }

#include <bits/stdc++.h> using namespace std; const int MAXN = 2e3 + 5; const int P = 998244353; template <typename T> void chkmax(T &x, T y) { x = max(x, y); } template <typename T> void chkmin(T &x, T y) { x = min(x, y); } template <typename T> void read(T &x) { x = 0; int f = 1; char c = getchar(); for (; !isdigit(c); c = getchar()) if (c == - ) f = -f; for (; isdigit(c); c = getchar()) x = x * 10 + c - 0 ; x *= f; } template <typename T> void write(T x) { if (x < 0) x = -x, putchar( - ); if (x > 9) write(x / 10); putchar(x % 10 + 0 ); } template <typename T> void writeln(T x) { write(x); puts( ); } struct BinaryIndexTree { int n, a[MAXN]; void init(int x) { n = x; memset(a, 0, sizeof(a)); } void modify(int x, int d) { for (int i = x; i <= n; i += i & -i) a[i] += d; } int query(int x) { int ans = 0; for (int i = x; i >= 1; i -= i & -i) ans += a[i]; return ans; } int query(int l, int r) { int ans = 0; for (int i = r; i >= 1; i -= i & -i) ans += a[i]; for (int i = l - 1; i >= 1; i -= i & -i) ans -= a[i]; return ans; } } BIT[3]; int n, a[MAXN][MAXN], dp[MAXN][MAXN], power[MAXN]; void update(int &x, int y) { x += y; if (x >= P) x -= P; } int main() { read(n), dp[0][0] = 1; for (int i = 1; i <= n; i++) { dp[i][0] = 1ll * i * dp[i - 1][0] % P; for (int j = 1; j <= i; j++) dp[i][j] = (dp[i][j - 1] - dp[i - 1][j - 1] + P) % P; } power[0] = 1; for (int i = 1; i <= n; i++) power[i] = 1ll * power[i - 1] * dp[n][n] % P; for (int i = 1; i <= n; i++) for (int j = 1; j <= n; j++) read(a[i][j]); int ans = 0; BIT[0].init(n); for (int i = n; i >= 1; i--) { BIT[0].modify(a[1][i], 1); update(ans, 1ll * BIT[0].query(a[1][i] - 1) * dp[n - i][0] % P * power[n - 1] % P); } for (int i = 2; i <= n; i++) { bool visa[MAXN], visb[MAXN]; memset(visa, 0, sizeof(visa)); memset(visb, 0, sizeof(visb)); BIT[0].init(n), BIT[1].init(n); for (int j = n; j >= 1; j--) { visb[a[i][j]] = true; if (!visa[a[i][j]]) BIT[0].modify(a[i][j], 1); else BIT[1].modify(a[i][j], 1); int cnt = BIT[1].query(n); update(ans, 1ll * BIT[0].query(a[i][j] - 1) * dp[n - j][cnt] % P * power[n - i] % P); if (cnt) update(ans, 1ll * BIT[1].query(a[i][j] - 1) * dp[n - j][cnt - 1] % P * power[n - i] % P); if (a[i][j] > a[i - 1][j] && visb[a[i - 1][j]]) { if (visa[a[i - 1][j]]) update(ans, P - 1ll * dp[n - j][cnt - 1] * power[n - i] % P); else update(ans, P - 1ll * dp[n - j][cnt] * power[n - i] % P); } if (!visb[a[i - 1][j]]) visa[a[i - 1][j]] = true; else { visa[a[i - 1][j]] = true; BIT[0].modify(a[i - 1][j], -1); BIT[1].modify(a[i - 1][j], 1); } } } writeln(ans); return 0; }

#include <bits/stdc++.h> using namespace std; const int N = 2e5 + 5; int main() { ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0); long long n, x; cin >> n, x = n; long long cnt = 0, d = n; for (int i = 2; 1LL * i * i <= x; i++) { if (x % i == 0) { cnt++, d = i; while (x % i == 0) x /= i; } if (cnt > 2) break; } if (x > 1) cnt++; if (cnt <= 1) cout << d; else cout << 1; return 0; }

#include <bits/stdc++.h> using namespace std; const double EPS = 1E-8; inline bool eq(double a, double b) { return a - b < EPS && b - a < EPS; } inline bool ne(double a, double b) { return a + EPS < b || b + EPS < a; } inline bool ls(double a, double b) { return a + EPS < b; } inline bool gr(double a, double b) { return b + EPS < a; } inline bool le(double a, double b) { return a - EPS < b; } inline bool ge(double a, double b) { return b - EPS < a; } int arr[1111][1111]; int main() { int n; scanf( %d , &n); for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { scanf( %d , &arr[i][j]); } } int sum = 0; for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { sum = (sum + arr[i][j] * arr[j][i]) & 1; } } int q; scanf( %d , &q); for (int i = 0; i < q; i++) { int ctrl; scanf( %d , &ctrl); if (ctrl == 3) putchar( 0 + sum); else { scanf( %d , &ctrl); sum = 1 - sum; } } return 0; }

#include <bits/stdc++.h> using namespace std; inline char gc() { static char buf[100000], *p1 = buf, *p2 = buf; return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2) ? EOF : *p1++; } inline long long read() { long long x = 0; char ch = getchar(); bool positive = 1; for (; !isdigit(ch); ch = getchar()) if (ch == - ) positive = 0; for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - 0 ; return positive ? x : -x; } inline void write(long long a) { if (a < 0) { a = -a; putchar( - ); } if (a >= 10) write(a / 10); putchar( 0 + a % 10); } inline void wri(long long a) { write(a); putchar( ); } inline void writeln(long long a) { write(a); puts( ); } const int N = 1 << 17 | 2, mod = 998244353; int sum, A[N], B[N], C[N], f[N]; long long ksm(long long a, int b) { a %= mod; int ans = 1; for (; b; b >>= 1) { if (b & 1) ans = ans * a % mod; a = a * a % mod; } return ans; } void FWT(int *a, int n) { for (int i = 0; i < n; i++) { for (int j = 0; j < (1 << n); j++) if (j >> i & 1) { int x = a[j]; a[j] = a[j ^ (1 << i)] >= x ? a[j ^ (1 << i)] - x : a[j ^ (1 << i)] - x + mod; a[j ^ (1 << i)] = a[j ^ (1 << i)] + x >= mod ? a[j ^ (1 << i)] + x - mod : a[j ^ (1 << i)] + x; } } } void ba(int &a) { if (a > mod / 2) a = a - mod; } signed main() { int n = read(), k = read(); int x = read(), y = read(), z = read(); for (int i = 0; i < n; i++) { int a = read(), b = read() ^ a, c = read() ^ a; sum ^= a; A[b]++; B[c]++; C[b ^ c]++; } FWT(A, k); FWT(B, k); FWT(C, k); for (int i = 0; i < (1 << k); i++) { int t1 = n, t2 = A[i], t3 = B[i], t4 = C[i]; ba(t2); ba(t3); ba(t4); f[i] = ksm((long long)x + y + z, (t1 + t2 + t3 + t4) / 4) * ksm((long long)x + y - z, (t1 + t2 - t3 - t4) / 4) % mod * ksm((long long)x - y + z, (t1 - t2 + t3 - t4) / 4) % mod * ksm((long long)x - y - z, (t1 - t2 - t3 + t4) / 4) % mod; f[i] = (f[i] + mod) % mod; } FWT(f, k); long long in = ksm(1 << k, mod - 2); for (int i = 0; i < (1 << k); i++) f[i] = f[i] * in % mod; for (int i = 0; i < (1 << k); i++) { wri(f[i ^ sum]); } }

#include <bits/stdc++.h> using namespace std; const int N = 28; vector<int> g[N]; int vis[2000000]; int main() { int k, n; string ss, s; cin >> k >> ss; for (int i = 0; i < k; ++i) s += ss; for (int i = 0; i != s.size(); ++i) g[s[i] - a ].push_back(i); cin >> n; vector<int>::iterator it; for (int i = 0; i < n; ++i) { cin >> k >> ss; it = g[ss[0] - a ].begin(); g[ss[0] - a ].erase(it + k - 1); } memset(vis, 0, sizeof(vis)); for (int i = 0; i < 26; ++i) for (int j = 0; j < g[i].size(); ++j) vis[g[i][j]] = 1; for (int i = 0; i != s.size(); ++i) if (vis[i]) cout << s[i]; return 0; }

#include <bits/stdc++.h> using namespace std; const int N = 1e3 + 5; int n, m; int adj[N][N], d[N][N]; bool check(int a, int b) { if (a >= 0 && a < n && b >= 0 && b < m && adj[a][b] != -1) return 1; return 0; } void bfs(int x, int y) { d[x][y] = 0; queue<pair<int, int> > q; q.push({x, y}); while (!q.empty()) { int dir[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}}; pair<int, int> p = q.front(); q.pop(); for (int i = 0; i < 4; i++) { int ii = dir[i][0] + p.first; int jj = dir[i][1] + p.second; if (check(ii, jj) && d[ii][jj] == -1) { q.push({ii, jj}); d[ii][jj] = d[p.first][p.second] + 1; } } } } int main() { cin >> n >> m; for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) d[i][j] = -1; pair<int, int> e, s; char c; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { cin >> c; if (c == E ) { e.first = i; e.second = j; adj[i][j] = 0; } else if (c == S ) { s.first = i; s.second = j; adj[i][j] = 0; } else if (c == T ) adj[i][j] = -1; else adj[i][j] = (c - 0 ); } } bfs(e.first, e.second); int len = d[s.first][s.second]; long long int ans = 0; for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) if (d[i][j] != -1 && d[i][j] <= len) ans += adj[i][j]; cout << ans << endl; }

#include <bits/stdc++.h> using namespace std; inline string GetString() { char S[1000005]; scanf( %s , S); string ret = S; return ret; } inline char getc() { char c = ; while (c == || c == t || c == r || c == n ) c = getchar(); return c; } template <typename t> t getnum() { t res = 0; char c; int sign = 1; while (1) { c = getchar(); if (c == || c == n ) continue; else break; } if (c == + ) { } else if (c == - ) sign = -1; else res = c - 0 ; while (1) { c = getchar(); if (c >= 0 && c <= 9 ) res = res * 10 + c - 0 ; else break; } return res * sign; } int main(int argc, char** argv) { int n = getnum<int>(); int m = getnum<int>(); int i = getnum<int>(); int j = getnum<int>(); int a = getnum<int>(); int b = getnum<int>(); int satu = 10000000, dua = 10000000, tiga = 10000000, empat = 10000000; if ((i - 1) % a == 0 && (j - 1) % b == 0) { int x = (i - 1) / a, y = (j - 1) / b; if (x % 2 == y % 2) satu = max(x, y); } if ((i - 1) % a == 0 && (m - j) % b == 0) { int x = (i - 1) / a, y = (m - j) / b; if (x % 2 == y % 2) dua = max(x, y); } if ((n - i) % a == 0 && (j - 1) % b == 0) { int x = (n - i) / a, y = (j - 1) / b; if (x % 2 == y % 2) tiga = max(x, y); } if ((n - i) % a == 0 && (m - j) % b == 0) { int x = (n - i) / a, y = (m - j) / b; if (x % 2 == y % 2) empat = max(x, y); } int ans = min(satu, min(dua, min(tiga, empat))); if (ans != 0 && (a > n - 1 || b > m - 1)) ans = 10000000; if (ans == 10000000) puts( Poor Inna and pony! ); else printf( %d n , ans); return 0; }

#include <bits/stdc++.h> using namespace std; int arr[1003][1003]; int n, m; int dp[1003][1003]; int vis[1003][1003]; int dx[4] = {0, 1, 0, -1}; int dy[4] = {1, 0, -1, 0}; int dfs(int i, int j, int x) { if (vis[i][j] == 2) { printf( Poor Inna! n ); exit(0); } if (dp[i][j] != -1) return dp[i][j]; vis[i][j] = 2; int temp2 = 0; int temp3 = 0; if (arr[i][j] == 3) temp3 = 1; for (int k = 0; k < 4; k++) { int ee = i + dx[k]; int rr = j + dy[k]; if (ee >= 0 & ee < n && rr >= 0 && rr < m && arr[ee][rr] == (x + 1) % 4) { temp2 = max(temp2, dfs(ee, rr, (x + 1) % 4)); } } temp2 += temp3; vis[i][j] = 1; if (arr[i][j] == 0) dp[i][j] = temp2; return temp2; } int main() { char temp; for (int i = 0; i < 1003; i++) for (int j = 0; j < 1003; j++) { dp[i][j] = -1; vis[i][j] = 0; } scanf( %d %d , &n, &m); for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) { cin >> temp; if (temp == D ) arr[i][j] = 0; if (temp == I ) arr[i][j] = 1; if (temp == M ) arr[i][j] = 2; if (temp == A ) arr[i][j] = 3; } for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) { if (arr[i][j] == 0 && vis[i][j] == 0) { int temp1 = dfs(i, j, 0); } } int ans = 0; for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) if (ans < dp[i][j]) ans = dp[i][j]; if (ans == 0) printf( Poor Dima! n ); else printf( %d n , ans); return 0; }

#include <bits/stdc++.h> using namespace std; int ex, ey; bool a[207][207]; bool vis[207][207]; int dx[4] = {0, 0, 1, -1}; int dy[4] = {-1, 1, 0, 0}; int bfs() { queue<pair<int, int>> q; vis[100][100] = true; q.push(make_pair(100, 100)); int dep = 0; while (int(q.size())) { int size = int(q.size()); while (size--) { pair<int, int> top = q.front(); q.pop(); vis[top.first][top.second] = true; if (top.first == ex && top.second == ey) return dep; for (int i = 0; i < int(4); i++) { int nx = top.first + dx[i]; int ny = top.second + dy[i]; if (a[nx][ny] && !vis[nx][ny]) { q.push(make_pair(nx, ny)); } } } dep++; } return -1; } int main() { string second; cin >> second; ex = ey = 100; for (int i = 0; i < int(int(second.size())); i++) { a[ex][ey] = true; if (second[i] == R ) ex++; if (second[i] == L ) ex--; if (second[i] == U ) ey--; if (second[i] == D ) ey++; if (a[ex][ey]) { puts( BUG ); return 0; } } a[ex][ey] = true; int ans = bfs(); ans < int(second.size()) ? puts( BUG ) : puts( OK ); }

#include <bits/stdc++.h> using namespace std; const int MAXN = 513; int N, ans[MAXN]; multiset<int> m; int gcd(int a, int b) { if (a < b) swap(a, b); if (b == 0) return a; return gcd(b, a % b); } void solve() { for (int k = N; k >= 1; k--) { ans[k] = -(*m.begin()); m.erase(m.find(-ans[k])); for (int i = k + 1; i <= N; i++) { m.erase(m.find(-gcd(ans[k], ans[i]))); m.erase(m.find(-gcd(ans[k], ans[i]))); } } } int main() { scanf( %d , &N); int x; for (int i = 1; i <= N * N; i++) { scanf( %d , &x); m.insert(-x); } solve(); for (int i = 1; i <= N; i++) printf( %d%c , ans[i], n [i == N]); return 0; }

#include <bits/stdc++.h> using namespace std; static const double EPS = 1e-6; const long double pi = acos(-1.0); int dx[] = {0, 1, 0, -1, 1, 1, -1, -1, 0}, dy[] = {1, 0, -1, 0, 1, -1, 1, -1, 0}; int aq[5][5]; int main() { int n; cin >> n; for (int i = 0; i < (int)(n); ++i) { int x, y; cin >> x >> y; aq[x - 1][y - 1] = aq[y - 1][x - 1] = 1; } int ap = 0, nap = 0; for (int i = 0; i < (int)(5); ++i) for (int j = 0; j < (int)(i); ++j) for (int k = 0; k < (int)(j); ++k) { if (aq[i][j] && aq[j][k] && aq[k][i]) ap = 1; if (!aq[i][j] && !aq[j][k] && !aq[k][i]) nap = 1; } if (ap || nap) cout << WIN << endl; else cout << FAIL << endl; }

#include <bits/stdc++.h> using namespace std; const int64_t INF = 0x3f3f3f3f; const int64_t INFLL = 0x3f3f3f3f3f3f3f3f; const int64_t MOD = 1e9 + 7; const double EPS = 1e-9; const double PI = acos(-1); mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); int64_t rand(int64_t x, int64_t y) { return uniform_int_distribution<int64_t>(x, y)(rng); } int64_t mul(int64_t a, int64_t b) { int64_t ret = (1ll * (a % MOD) * (b % MOD)) % MOD; return (ret + MOD) % MOD; } int64_t add(int64_t a, int64_t b) { int64_t ret = (1ll * (a % MOD) + (b % MOD)) % MOD; return (ret + MOD) % MOD; } int64_t pow_exp(int64_t n, int64_t p) { if (!p) return 1; if (p & 1) return mul(n, pow_exp(n, p - 1)); int64_t tmp = pow_exp(n, p / 2); return mul(tmp, tmp); } const int64_t MAX = 2e5 + 10; const int64_t NMAX = 2e5 + 10; const int64_t MMAX = 2e5 + 10; const int64_t LOG_MAX = ceil(log2(double(NMAX))); const int64_t BLOCK = ceil(sqrt(double(NMAX))); int64_t n; string str[20]; map<int64_t, vector<int64_t> > mp[20]; int64_t tot[20]; int64_t mem[1 << 20]; int64_t go(int64_t msk, int64_t sm) { if (msk + 1 == 1 << n) { return 0; } int64_t &ret = mem[msk]; if (ret + 1) return ret; int64_t ans = 0; for (int64_t i = 0; i < n; i++) if (((msk >> i) & 1) == 0) { int64_t mn = mp[i].begin()->first; if (sm + mn >= 0) { int64_t cans = 0; cans += go(msk ^ (1 << i), sm + tot[i]); auto it = mp[i].find(-sm); if (it != mp[i].end()) cans += it->second.size(); ans = max(ans, cans); } else { auto it = mp[i].find(-sm); if (it == mp[i].end()) { continue; } if (it == mp[i].begin()) { int64_t cans = it->second.size(); ans = max(ans, cans); } else { auto &v = mp[i][-sm]; int64_t r = (--it)->second.front(); int64_t cans = lower_bound(v.begin(), v.end(), r) - v.begin(); ans = max(ans, cans); } } } return ret = ans; } int32_t main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); ; cin >> n; for (int64_t i = 0; i < n; i++) { cin >> str[i]; } for (int64_t i = 0; i < n; i++) { int64_t sm = 0; for (int64_t j = 0; j < str[i].size(); j++) { sm += str[i][j] == ( ? +1 : -1; mp[i][sm].push_back(j); } tot[i] = sm; } memset(mem, -1, sizeof mem); cout << go(0, 0) << n ; }

#include <bits/stdc++.h> using namespace std; const int N = 100005; const double inf = 1e10; int n, m, q, Eu[N], Ev[N], all[N], vis[N]; vector<int> V; map<pair<int, int>, int> F, S; struct P { double x, y; } p[N]; inline P operator+(const P& a, const P& b) { return (P){a.x + b.x, a.y + b.y}; } inline P operator-(const P& a, const P& b) { return (P){a.x - b.x, a.y - b.y}; } inline double operator*(const P& a, const P& b) { return a.x * b.y - b.x * a.y; } inline double operator/(const P& b, const P& a) { return atan2(b.y - a.y, b.x - a.x); } inline bool operator<(const P& a, const P& b) { return a.x != b.x ? a.x < b.x : a.y < b.y; } inline double crs(P p, P a, P b) { return (a - p) * (b - p); } struct E { int v; double a; }; inline bool operator<(const E& a, const E& b) { return a.a < b.a; } vector<E> G[N]; inline void add(int u, int v) { G[u].push_back((E){v, p[v] / p[u]}); F[make_pair(u, v)] = 0; } int dfs(int x, int p) { vis[x] = 1; int s = 1; for (int i = 0; i < G[x].size(); i++) { int y = G[x][i].v; if (!vis[y]) s += dfs(y, x); } if (p) { F[make_pair(p, x)] += s; F[make_pair(x, p)] -= s; } return s; } inline int calc(int a, int b, int c) { return ((p[b] / p[a]) < (p[c] / p[a]) ? 0 : all[a]) + S[make_pair(a, c)] - S[make_pair(a, b)] - F[make_pair(a, c)]; } int main() { scanf( %d%d , &n, &m); int T = n + 1; p[T] = (P){-inf, 0}; for (int i = 1; i <= m; i++) scanf( %d%d , &Eu[i], &Ev[i]); for (int i = 1; i <= n; i++) scanf( %lf%lf , &p[i].x, &p[i].y); for (int i = 1; i <= m; i++) add(Eu[i], Ev[i]), add(Ev[i], Eu[i]); int x = 1; for (int i = 2; i <= n; i++) if (p[i] < p[x]) x = i; add(T, x); add(x, T); dfs(T, 0); for (int i = 1; i <= n + 1; i++) sort(G[i].begin(), G[i].end()); for (int i = 1; i <= n + 1; i++) { int x = i; S[make_pair(i, i)] = 0; for (int j = 0; j < G[i].size(); j++) { int y = G[i][j].v; all[i] += F[make_pair(i, y)]; S[make_pair(i, y)] = S[make_pair(i, x)] + F[make_pair(i, y)]; x = y; } } scanf( %d , &q); while (q--) { int k; scanf( %d , &k); V.clear(); for (int i = 1, x; i <= k; i++) scanf( %d , &x), V.push_back(x); int ans = 0, cc = V.size(); double s = 0; p[0] = (P){0, 0}; for (int i = 0; i < cc; i++) s += crs(p[0], p[V[i ? i - 1 : cc - 1]], p[V[i]]); if (s > 0) reverse(V.begin(), V.end()); for (int i = 0; i < cc; i++) ans += calc(V[i], V[i ? i - 1 : cc - 1], V[(i + 1) % cc]); printf( %d n , ans + cc); } return 0; }

#include <bits/stdc++.h> int main() { int a, b, c, d, flag = 0; scanf( %d %d %d %d , &a, &b, &c, &d); if (a + b > c && b + c > a && c + a > b) flag = 1; else if (b + c > d && c + d > b && d + b > c) flag = 1; else if (c + d > a && d + a > c && a + c > d) flag = 1; else if (a + b > d && b + d > a && d + a > b) flag = 1; if (flag == 1) printf( TRIANGLE ); else { if (a + b == c || b + c == a || c + a == b) flag = 2; else if (b + c == d || c + d == b || d + b == c) flag = 2; else if (c + d == a || d + a == c || a + c == d) flag = 2; else if (a + b == d || b + d == a || d + a == b) flag = 2; } if (flag == 2) printf( SEGMENT ); else if (flag == 0) printf( IMPOSSIBLE ); }

#include <bits/stdc++.h> const int MAXN = 1000; int ba[MAXN], bb[MAXN]; int a, b, da, db, t, x, l1, l2; int main() { scanf( %d %d %d %d %d %d , &x, &t, &a, &b, &da, &db); int tm = 0; while (a >= 0) { ba[l1++] = a; a -= da; tm++; if (tm >= t) break; } tm = 0; while (b >= 0) { bb[l2++] = b; b -= db; tm++; if (tm >= t) break; } for (int i = 0; i < l1; i++) if (ba[i] == x) { printf( YES n ); return 0; } if (x == 0) { printf( YES n ); return 0; } for (int i = 0; i < l2; i++) if (bb[i] == x) { printf( YES n ); return 0; } for (int i = 0; i < l1; i++) for (int j = 0; j < l2; j++) if (ba[i] + bb[j] == x) { printf( YES n ); return 0; } printf( NO n ); return 0; return 0; }

#include <bits/stdc++.h> using namespace std; struct Item { int id, t, d, p; Item(int _id = 0, int _t = 0, int _d = 0, int _p = 0) : id(_id), t(_t), d(_d), p(_p) {} bool operator<(const Item &rhs) const { return d < rhs.d; } }; constexpr int kN = 101, kT = 2001; Item a[kN]; int dp[kN][kT]; int tk[kN][kT]; int main() { int n; scanf( %d , &n); int t, d, p; for (int i = 0; i < n; ++i) { scanf( %d %d %d , &t, &d, &p); a[i] = Item(i + 1, t, d, p); } sort(a, a + n); for (int i = 0; i < n; ++i) { for (int j = 0; j + a[i].t < a[i].d; ++j) { if (dp[i][j] + a[i].p > dp[i + 1][j + a[i].t]) { dp[i + 1][j + a[i].t] = dp[i][j] + a[i].p; tk[i + 1][j + a[i].t] = 1; } } for (int j = 0; j < kT; ++j) { if (dp[i][j] > dp[i + 1][j]) { dp[i + 1][j] = dp[i][j]; tk[i + 1][j] = 0; } } } int x = 0; for (int i = 0; i < a[n - 1].d; ++i) { if (dp[n][i] > dp[n][x]) { x = i; } } printf( %d n , dp[n][x]); vector<int> ans; for (int i = n; i > 0; --i) { if (tk[i][x]) { ans.push_back(a[i - 1].id); x -= a[i - 1].t; } } reverse(ans.begin(), ans.end()); printf( %d n , ans.size()); for (int i = 0; i < ans.size(); ++i) { printf( %d , ans[i]); } printf( n ); return 0; }

#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); int n; cin >> n; set<int> s; while (1) { int k = s.size(); s.insert(n); int m = s.size(); if (k == m) break; n = n + 1; while (n % 10 == 0) { n = n / 10; } } cout << s.size() << endl; return 0; }

#include <bits/stdc++.h> using namespace std; bool comp(pair<long long, long long> a, pair<long long, long long> b) { return a.first > b.first; } long long findBest(vector<pair<long long, long long> >& ps, long long x) { long long res = 0; for (long long i = 0; i < ps.size(); i++) { long long num = ps[i].second; long long diff = ps[i].first; if (x - num >= 0) { res += (num * diff); x -= num; } else { res += (x * diff); break; } } return res; } int main() { long long n, s; cin >> n >> s; vector<pair<long long, long long> > ps; long long total = 0; long long positives = 0; long long pieces = 0; for (long long i = 0; i < n; i++) { long long num, a, b; cin >> num >> a >> b; ps.push_back(make_pair(a - b, num)); total += num * b; pieces += num; if (a - b > 0) { positives += num; } } sort(ps.begin(), ps.end(), comp); long long pizzas = (pieces % s == 0) ? (pieces / s) : (pieces / s + 1); long long extra = pizzas * s - pieces; long long best = total; if (positives > 0) { best = max(best, findBest(ps, positives / s * s) + total); if (positives % s != 0) { long long x = max(positives, (positives / s + 1) * s - extra); best = max(best, findBest(ps, x) + total); } } cout << best << endl; return 0; }

#include <bits/stdc++.h> using namespace std; struct node { int i; int num; } a[1005]; bool cmp(node x, node y) { return x.num < y.num; } int main() { int t; scanf( %d , &t); while (t--) { int n, m; scanf( %d %d , &n, &m); int i, j; int ans = 0; for (i = 1; i <= n; i++) { scanf( %d , &a[i].num); a[i].i = i; ans += a[i].num; } if (m < n || n <= 2) { printf( -1 n ); continue; } ans *= 2; sort(a + 1, a + 1 + n, cmp); int num = a[1].num + a[2].num; ans += (m - n) * num; printf( %d n , ans); for (i = 2; i <= n; i++) { printf( %d %d n , i - 1, i); } printf( 1 %d n , n); for (i = 0; i < (m - n); i++) { if (a[1].i > a[2].i) printf( %d %d n , a[2].i, a[1].i); else printf( %d %d n , a[1].i, a[2].i); } } return 0; }

#include <bits/stdc++.h> using namespace std; const int MAXN = 1000 + 7, MAX_SUM = 10 * 1000 + 7, DELTA = 1000 * 1000 * 1000 + 7; long long inputArray[MAXN], numberOfSubarrays[MAXN][2 * MAX_SUM], PSum; int main() { int numberOfInput; cin >> numberOfInput; for (int i = 0; i < numberOfInput; ++i) { cin >> inputArray[i]; PSum += inputArray[i]; } numberOfSubarrays[0][MAX_SUM + inputArray[0]] = numberOfSubarrays[0][MAX_SUM - inputArray[0]] = 1; for (int i = 1; i < numberOfInput; ++i) { for (int j = 0; j < 2 * MAX_SUM; ++j) { numberOfSubarrays[i][j] += numberOfSubarrays[i - 1][j - inputArray[i]]; } for (int j = 2 * MAX_SUM - 1; j >= 0; --j) { numberOfSubarrays[i][j] += numberOfSubarrays[i - 1][j + inputArray[i]]; numberOfSubarrays[i][j] %= DELTA; } numberOfSubarrays[i][MAX_SUM + inputArray[i]] = numberOfSubarrays[i][MAX_SUM + inputArray[i]] + 1; numberOfSubarrays[i][MAX_SUM - inputArray[i]] = numberOfSubarrays[i][MAX_SUM - inputArray[i]] + 1; } long long ans = 0; for (int i = 0; i < numberOfInput; ++i) { ans += numberOfSubarrays[i][MAX_SUM]; ans %= DELTA; } cout << ans << endl; return 0; }

#include <bits/stdc++.h> using namespace std; const int N = 100005; struct heap { vector<pair<int, int> > v; int loc[N]; heap() { v.push_back(make_pair(-1, -1)); memset(loc, -1, sizeof loc); } void push(pair<int, int> p) { int cur; cur = v.size(); loc[p.second] = cur; v.push_back(p); while (v[cur] < v[cur >> 1]) { swap(v[cur], v[cur >> 1]); swap(loc[v[cur].second], loc[v[cur >> 1].second]); cur >>= 1; } } void pop() { if (empty()) return; swap(v[1], v.back()); loc[v[1].second] = 1; loc[v.back().second] = -1; v.pop_back(); int cur = 1; while ((cur << 1) < v.size()) { if ((cur << 1) + 1 == v.size()) { if (v[cur] > v[cur << 1]) swap(v[cur], v[cur << 1]), swap(loc[v[cur].second], loc[v[cur << 1].second]); break; } if (v[cur] < min(v[cur << 1], v[(cur << 1) + 1])) break; if (v[cur << 1] < v[(cur << 1) + 1]) { swap(v[cur], v[cur << 1]); swap(loc[v[cur].second], loc[v[cur << 1].second]); cur <<= 1; } else { swap(v[cur], v[(cur << 1) + 1]); swap(loc[v[cur].second], loc[v[(cur << 1) + 1].second]); cur = (cur << 1) + 1; } } } pair<int, int> top() { return v[1]; } bool empty() { return v.size() == 1; } }; int n, m; vector<int> bad[N]; vector<pair<int, int> > v[N]; int d[N]; heap pq; int main() { ios::sync_with_stdio(false); cin >> n >> m; for (int i = 0; i < m; i++) { int a, b, c; cin >> a >> b >> c; --a, --b; v[a].push_back(make_pair(b, c)); v[b].push_back(make_pair(a, c)); } for (int i = 0; i < n; i++) { int num; cin >> num; while (num--) { int a; cin >> a; bad[i].push_back(a); } } for (int i = 0; i < n; i++) d[i] = 0x3f3f3f3f; d[0] = 0; pq.push(make_pair(0, 0)); while (!pq.empty()) { pair<int, int> tp = pq.top(); pq.pop(); int t = tp.first; int cur = tp.second; if (t != d[cur]) continue; int j = 0; while (j < bad[cur].size() && bad[cur][j] < t) j++; while (j < bad[cur].size() && bad[cur][j] == t) t++, j++; for (int i = 0; i < v[cur].size(); i++) { int to = v[cur][i].first, cost = v[cur][i].second; if (t + cost < d[to]) { d[to] = t + cost; pq.push(make_pair(d[to], to)); } } } if (d[n - 1] >= 0x3f3f3f3f) puts( -1 ); else cout << d[n - 1] << endl; return 0; }

#include <bits/stdc++.h> using namespace std; const int MAXN = 1111; const int INF = 0x7f7f7f7f; int cases; const double EPS = 1e-8; inline int sgn(double a) { return a < -EPS ? -1 : a > EPS; } int main() { double s, a, b, c; cin >> s >> a >> b >> c; if (!sgn(a) && !sgn(b) && !sgn(c)) { puts( 1.0 0.0 0.0 ); } else { double ts = s / (a + b + c); printf( %.10f %.10f %.10f n , a * ts, b * ts, c * ts); } }

#include <bits/stdc++.h> using namespace std; const int mod = 1000000007; int cnt[4]; int main() { int n; scanf( %d , &n); getchar(); for (int i = 0; i < n; ++i) { char ch = getchar(); if (ch == A ) { ++cnt[0]; } else if (ch == C ) { ++cnt[1]; } else if (ch == G ) { ++cnt[2]; } else if (ch == T ) { ++cnt[3]; } } int mx = *max_element(cnt, cnt + 4); int nMax = count(cnt, cnt + 4, mx); long long ans = 1; for (int i = 0; i < n; ++i) { ans = (ans * nMax) % mod; } cout << ans << endl; }

#include <bits/stdc++.h> using namespace std; const long long mod = 1e9 + 7; const long long MAX = 1e6 + 10; long long a[100005]; int main() { long long n, k, m, sum, t, len; string s, d; while (cin >> n) { int flag = 1; sum = 0; if (n % 2 == 0) { cout << n / 2 << endl; for (long long i = (1); i <= (n / 2); ++i) cout << 2 << ; cout << endl; } else { cout << (n - 3) / 2 + 1 << endl; for (long long i = (1); i <= ((n - 3) / 2); ++i) cout << 2 << ; cout << 3 << endl; } } return 0; }

#include <bits/stdc++.h> using namespace std; long long a[200010], t; int n; long long b[200010]; int g[200010]; bool no[200010]; int main() { scanf( %d %I64d , &n, &t); for (int i = 1; i <= n; i++) scanf( %I64d , &a[i]); for (int i = 1; i <= n; i++) { int x; scanf( %d , &x); if (x < i) { printf( No n ); return 0; } g[i]++; g[x]--; no[x] = 1; } int now = 0; b[0] = 0; for (int i = 1; i <= n; i++) { now += g[i]; if (now > 0) { if (no[i]) { printf( No n ); return 0; } b[i] = max(a[i + 1] + t, b[i - 1] + 1); } else { b[i] = max(a[i] + t, b[i - 1] + 1); if (no[i] && (b[i] >= a[i + 1] + t && i != n)) { printf( No n ); return 0; } } } printf( Yes n ); for (int i = 1; i <= n; i++) printf( %I64d , b[i]); printf( n ); return 0; }

#include <bits/stdc++.h> using namespace std; const long long mod = 998244353; const int maxn = 2e5 + 100; long long dp[52][52][52]; bool vis[52][52][52]; long long val[52][52][52]; int a[maxn], w[maxn]; long long qmod(long long a, long long b) { long long ans = 1; while (b) { if (b & 1) ans = ans * a % mod; b >>= 1; a = a * a % mod; } return ans; } int flag; int dfs(int n, int i, int j, int k, long long p, long long v, long long sp, long long sn) { if (!n) { return 1LL * p * v % mod; } if (vis[i][j][k]) { return val[i][j][k] * qmod(dp[i][j][k], mod - 2) % mod * p % mod; } dp[i][j][k] = p; val[i][j][k] += dfs(n - 1, i + 1, j, k, 1LL * p * sp % mod * qmod(v + sp + sn, mod - 2) % mod, v, sp + 1, sn); val[i][j][k] += dfs(n - 1, i, j + 1, k, 1LL * p * sn % mod * qmod(v + sp + sn, mod - 2) % mod, v, sp, max(sn - 1, 0LL)); val[i][j][k] += dfs(n - 1, i, j, k + 1, 1LL * p * v % mod * qmod(v + sp + sn, mod - 2) % mod, max(v + flag, 0LL), sp, sn); val[i][j][k] %= mod; vis[i][j][k] = 1; return val[i][j][k]; } int main() { ios::sync_with_stdio(false); long long sn = 0, sp = 0; int n, m; cin >> n >> m; for (int i = 0; i < n; ++i) { cin >> a[i]; } for (int i = 0; i < n; ++i) { cin >> w[i]; if (a[i]) { sp += w[i]; } else sn += w[i]; } for (int i = 0; i < n; ++i) { memset(dp, 0, sizeof dp); memset(vis, 0, sizeof vis); memset(val, 0, sizeof val); if (a[i]) { flag = 1; sp -= w[i]; } else { flag = -1; sn -= w[i]; } cout << dfs(m, 0, 0, 0, 1, w[i], sp, sn) << endl; if (a[i]) { sp += w[i]; } else sn += w[i]; } return 0; }

#include <bits/stdc++.h> using namespace std; using ll = long long; using ii = pair<int, int>; const int N = 200005; const int M = 300; const int OFF = N * M; int _cnt[N + N * M]; int *cnt = _cnt + OFF; int main() { char s[N]; scanf( %s , s); int n = strlen(s); int psum[N]; for (int i = 0; i < n; i++) { s[i] -= 0 ; psum[i] = s[i]; if (i) psum[i] += psum[i - 1]; } int sq = min(M, (int)sqrt(n)); ll ans = 0; for (int j = 1; j < sq; j++) { cnt[-1] = 1; for (int i = 0; i < n; i++) { int val = i - j * psum[i]; if (psum[i]) { ans += cnt[val]; } cnt[val]++; } for (int i = 0; i < n; i++) { int val = i - j * psum[i]; cnt[val]--; } } int nxt[N]; nxt[n] = n; for (int i = n - 1; i >= 0; i--) { nxt[i] = nxt[i + 1]; if (s[i] == 1) nxt[i] = i; } for (int i = 0; i < n; i++) { int r = nxt[i]; int q = 1; while (r < n && q * sq <= n - i) { int p = nxt[r + 1]; int rig = max(r, i + q * sq - 1); if (rig <= p) { ans += (p - i) / q - (rig - i) / q; } r = p; q++; } } printf( %lld n , ans); return 0; }

#include <bits/stdc++.h> using namespace std; const int MAXN = 2005, MOD = 998244353; char ch[MAXN]; long long cnt[MAXN], dp[MAXN][MAXN]; long long KSM(long long a, long long t) { long long ans = 1; while (t) { if (t & 1) ans = ans * a % MOD; t >>= 1; a = a * a % MOD; } return ans; } int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); cin >> (ch + 1); int n = strlen(ch + 1); for (int i = 1; i <= n; i++) cnt[i] = cnt[i - 1] + (ch[i] == ? ); for (int j = 1; j <= n; j++) for (int i = j - 1; i; i--) { if (ch[i] != ) && ch[j] != ( ) dp[i][j] = (dp[i][j] + dp[i + 1][j - 1] + KSM(2, cnt[j - 1] - cnt[i])) % MOD; if (ch[i] != ( ) dp[i][j] = (dp[i][j] + dp[i + 1][j]) % MOD; if (ch[j] != ) ) dp[i][j] = (dp[i][j] + dp[i][j - 1]) % MOD; if (ch[i] != ( && ch[j] != ) ) dp[i][j] = (dp[i][j] - dp[i + 1][j - 1] + MOD) % MOD; } cout << dp[1][n]; }

#include <bits/stdc++.h> int main() { int i, j, l, x = 0; char s[100005]; gets(s); l = strlen(s); for (i = 0, j = l - 1; i < l / 2; i++, j--) { if (s[i] != s[j]) { x = 1; break; } } if (x == 1) { printf( NO n ); } else { for (i = 0; i < l; i++) { if (s[i] == A || s[i] == H || s[i] == I || s[i] == M || s[i] == O || s[i] == T || s[i] == U || s[i] == V || s[i] == W || s[i] == X || s[i] == Y ) { x = 0; } else { x = 1; break; } } if (x == 1) { printf( NO n ); } else { printf( YES n ); } } return 0; }

#include <bits/stdc++.h> #pragma GCC optimize( O3 ) using namespace std; const int MAX = 2e3 + 5; const long long MAX2 = 11; const long long MOD = 998244353; const long long MOD2 = 1000005329; const long long INF = 2e18; const int dr[] = {1, 0, -1, 0, 1, 1, -1, -1, 0}; const int dc[] = {0, 1, 0, -1, 1, -1, 1, -1, 0}; const double pi = acos(-1); const double EPS = 1e-9; const int block = 2000; int q, x, y, cnt; map<string, pair<long long, long long>> ans, dp; map<string, bool> jen; map<string, vector<string>> isi; string s, ty, c; pair<long long, long long> solve(string o) { if (!jen.count(o)) return ans[o]; if (isi[o].empty()) return {0, 0}; if (dp.count(o)) return dp[o]; int hit = isi[o].size() - 1; long long mx = 0, ttl = 0; pair<long long, long long> res; if (jen[o]) { for (auto i : isi[o]) { res = solve(i); mx = max(mx, res.second); ttl += res.first; } return dp[o] = {ttl + 2 * ans[o].first + hit * ans[o].second, mx + 2 * ans[o].first}; } { for (auto i : isi[o]) { res = solve(i); mx = max(mx, res.first); ttl += res.second; } return dp[o] = {mx + 2 * ans[o].first, ttl + 2 * ans[o].first + hit * ans[o].second}; } } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); cin >> q; while (q--) { cin >> ty; x = y = cnt = 0; if (ty == Widget ) { cin >> s; c = ; for (auto i : s) { if (i == ( || i == ) || i == , ) ++cnt; else if (cnt == 1) x = x * 10 + i - 0 ; else if (cnt == 2) y = y * 10 + i - 0 ; else c.push_back(i); } ans[c] = {x, y}; } else if (ty == VBox ) { cin >> s; ans[s]; jen[s]; } else if (ty == HBox ) { cin >> s; ans[s]; jen[s] = 1; } else { s = c = ; for (auto i : ty) { if (i == . ) ++cnt; else if (i == ( ) { if (c == pack ) cnt = 2; else if (c == set_border ) cnt = 3; else if (c == set_spacing ) cnt = 4; c = ; } else if (i == ) ) continue; else if (cnt == 0) s.push_back(i); else if (cnt == 1 || cnt == 2) c.push_back(i); else if (cnt == 3 || cnt == 4) x = x * 10 + i - 0 ; else return 1; } if (cnt == 2) isi[s].push_back(c); else if (cnt == 3) ans[s].first = x; else ans[s].second = x; } } pair<long long, long long> res; for (auto i : ans) { res = solve(i.first); cout << i.first << << res.first << << res.second << n ; } return 0; }

#include <bits/stdc++.h> using namespace std; const long long int inf = 1e18; int n, m, k, x, p; int mat[1005][1005]; void solve(int tc) { cin >> n >> m >> k >> p; for (int i = 0; i < n; ++i) { for (int j = 0; j < m; ++j) { cin >> mat[i][j]; } } multiset<int, greater<int> > msRow, msCol; for (int r = 0; r < n; ++r) { long long int rowSum = 0LL; for (int i = 0; i < m; ++i) { rowSum += mat[r][i]; } msRow.insert(rowSum); } for (int c = 0; c < m; ++c) { long long int colSum = 0LL; for (int i = 0; i < n; ++i) { colSum += mat[i][c]; } msCol.insert(colSum); } vector<long long int> rows(k + 1, 0LL), cols(k + 1, 0LL); for (int i = 1; i <= k; ++i) { rows[i] = *msRow.begin(); msRow.erase(msRow.begin()); msRow.insert(rows[i] - (1LL * p * m)); rows[i] += rows[i - 1]; cols[i] = *msCol.begin(); msCol.erase(msCol.begin()); msCol.insert(cols[i] - (1LL * p * n)); cols[i] += cols[i - 1]; } long long int ans = -inf; for (int i = 0; i <= k; ++i) { long long int tp = rows[i] + cols[k - i]; tp -= 1LL * p * i * (k - i); if (tp > ans) ans = tp; } cout << ans << n ; } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); int tt = 1; for (int i = 1; i <= tt; ++i) { solve(i); } return 0; }

#include <bits/stdc++.h> using namespace std; const long long PR = 1000000009; long long n, A[3][100009], dp[3][100009]; int main() { ios::sync_with_stdio(false); cin >> n; for (int i = 0; i < 100009; i++) A[0][i] = A[1][i] = A[2][i] = 0, dp[0][i] = dp[1][i] = dp[2][i] = -1 * 10000000000000000ll; for (int i = 0; i < n; i++) { cin >> A[0][i]; } for (int i = 0; i < n; ++i) cin >> A[1][i]; for (int i = 0; i < n; ++i) cin >> A[2][i]; dp[2][n] = 0; for (int i = n - 1; i >= 0; i--) { long long presum = A[0][i]; dp[0][i] = max(dp[0][i], presum + dp[0][i + 1]); dp[2][i] = max(dp[2][i], A[2][i] + dp[2][i + 1]); presum += A[1][i]; dp[0][i] = max(dp[0][i], presum + dp[1][i + 1]); dp[2][i] = max(dp[2][i], A[2][i] + A[1][i] + dp[1][i + 1]); presum += A[2][i]; dp[0][i] = max(dp[0][i], presum + dp[2][i + 1]); dp[2][i] = max(dp[2][i], presum + dp[0][i + 1]); presum += A[0][i + 1] + A[1][i + 1] + A[2][i + 1]; dp[2][i] = max(dp[2][i], presum + dp[0][i + 2]); dp[0][i] = max(dp[0][i], presum + dp[2][i + 2]); dp[1][i] = max(dp[1][i], A[1][i] + dp[1][i + 1]); dp[1][i] = max(dp[1][i], A[1][i] + A[0][i] + dp[0][i + 1]); dp[1][i] = max(dp[1][i], A[1][i] + A[2][i] + dp[2][i + 1]); } cout << dp[0][0] << n ; return 0; };

#include <bits/stdc++.h> using namespace std; const double pi = 3.1415926535; const double eps = 1e-6; struct TE { int a, b, c; } E[501000]; int tr[501000], n, x[501000], m; bool cmp(TE a, TE b) { return a.a < b.a; } int low(int a) { return (a & (-a)); } int ask(int a) { int ret = 1992837465; while (a) { ret = min(ret, tr[a]); a -= low(a); } return ret; } void ins(int a, int b) { while (a <= n + 5) { tr[a] = min(tr[a], b); a += low(a); } } int main() { scanf( %d , &n); for (int i = 0; i < n; i++) scanf( %d , &E[i].a); for (int i = 0; i < n; i++) scanf( %d , &E[i].b); for (int i = 0; i < n; i++) scanf( %d , &E[i].c); for (int i = 0; i < n; i++) { E[i].a = -E[i].a; E[i].b = -E[i].b; E[i].c = -E[i].c; x[i] = E[i].b; } sort(x, x + n); m = unique(x, x + n) - x; for (int i = 0; i < n; i++) E[i].b = (lower_bound(x, x + m, E[i].b) - x) + 1; sort(E, E + n, cmp); for (int i = 0; i <= n + 5; i++) tr[i] = 1992837465; int ans = 0; for (int i = 0; i < n; i++) { int h = i; while (i < n && E[i].a == E[h].a) { if (ask(E[i].b - 1) < E[i].c) { ans++; } i++; } i--; for (int j = h; j <= i; j++) ins(E[j].b, E[j].c); } printf( %d n , ans); }

#include <bits/stdc++.h> using namespace std; const int maxn = 300005; int n, u, v, x, trie[maxn << 1][26], sz[maxn << 1], tot, cnt[maxn], res; char op[2]; int merge(int a, int b) { if (!a || !b) return a + b; int rt = ++tot; memset(trie[rt], 0, sizeof trie[rt]); sz[rt] = 1; for (int i = 0; i < 26; ++i) { trie[rt][i] = merge(trie[a][i], trie[b][i]); sz[rt] += sz[trie[rt][i]]; } return rt; } void dfs(int u, int dep) { sz[u] = 1; for (int i = 0; i < 26; ++i) if (trie[u][i]) { dfs(trie[u][i], dep + 1); sz[u] += sz[trie[u][i]]; } cnt[dep] += sz[u]; tot = n; int rt = 0; for (int i = 0; i < 26; ++i) rt = merge(rt, trie[u][i]); cnt[dep] -= max(1, sz[rt]); } int main() { scanf( %d , &n); for (int i = 0; i < n - 1; ++i) { scanf( %d%d%s , &u, &v, op); trie[u][op[0] - a ] = v; } dfs(1, 0); res = 0; for (int i = 1; i < n; ++i) if (cnt[i] > cnt[res]) res = i; printf( %d n%d n , sz[1] - cnt[res], res + 1); return 0; }

#include <bits/stdc++.h> using namespace std; const long long int p = 1e9 + 7; const int N = 1e5 + 1; long long int fact[N]; long long int ncr[N]; long long int n_1cr[N]; void factorial() { fact[0] = fact[1] = 1; for (int i = 2; i < N; i++) { fact[i] = i * fact[i - 1]; fact[i] %= p; } } long long int fastPower(long long int a, long long int b) { if (b == 0) return 1; long long int tmp = fastPower(a, b / 2); if (b & 1) return (tmp % p * tmp % p * a % p) % p; return (tmp % p * tmp % p) % p; } long long int nCr(int n) { ncr[0] = 1; n_1cr[0] = 1; for (int i = 1; i <= n; i++) { long long int iPower = fastPower(i, p - 2); ncr[i] = (ncr[i - 1] * (n - i + 1)) % p; ncr[i] *= iPower; ncr[i] %= p; n_1cr[i] = (n_1cr[i - 1] % p * (n - i) % p) % p; n_1cr[i] *= iPower; n_1cr[i] %= p; } } long long int nCr(int n, int r) { long long ans = 1; ans = (fact[n - r] * fact[r]) % p; ans = (fact[n] * fastPower(ans, p - 2)) % p; return ans; } int main() { int n; long long int sum = 0; cin >> n; factorial(); for (int i = 1; i <= n; i++) { sum += nCr(n - 1, i - 1) * nCr(n, i); sum %= p; } sum *= 2; sum %= p; sum -= n; cout << sum << endl; return 0; }

#include <bits/stdc++.h> using namespace std; int n, m, M; vector<set<int> > A; vector<set<pair<int, int> > > B; vector<int> d, f, F, G; vector<bool> v; inline void upd(int& a, int b) { if (d[a] > d[b]) a = b; } void ff(int x, int y) { f[x] = x, v[x] = 1; for (set<int>::iterator i = A[x].begin(); i != A[x].end(); i++) if (v[*i]) { if (*i != y) upd(f[x], *i); } else d[*i] = d[x] + 1, ff(*i, x), upd(f[x], f[*i]); } void ff(int x) { f[x] = f[f[x]], v[x] = 0; for (set<int>::iterator i = A[x].begin(); i != A[x].end(); i++) if (v[*i]) ff(*i); } bool gg(int x, int y, int fa) { if (x == y) return 1; for (set<pair<int, int> >::iterator i = B[x].begin(); i != B[x].end(); i++) if (i->first != fa) if (gg(i->first, y, x)) { v[i->second] = v[i->second ^ 1] = 1; return 1; } return 0; } int main() { scanf( %d%d , &n, &m); A.resize(n); for (int i = 0, x, y; i < m; i++) scanf( %d%d , &x, &y), --x, --y, A[x].insert(y), A[y].insert(x); if (n == 2) { puts( -1 ); return 0; } d.resize(n, 0), f.resize(n), v.resize(n, 0); ff(0, -1), ff(0); F.resize(n); for (int i = 0; i < n; i++) if (f[i] == i) F[i] = (int)G.size(), G.push_back(i); for (int i = 0; i < n; i++) F[i] = F[f[i]]; B.resize((int)G.size()); for (int i = 0; i < n; i++) for (set<int>::iterator j = A[i].begin(); j != A[i].end(); j++) if (F[i] != F[*j]) { set<pair<int, int> >::iterator p = B[F[i]].lower_bound(make_pair(F[*j], -1)); if (p != B[F[i]].end() && p->first == F[*j]) continue; B[F[i]].insert(make_pair(F[*j], M++)), B[F[*j]].insert(make_pair(F[i], M++)); } if ((int)G.size() == 1) { puts( 0 ); return 0; } if ((int)G.size() == 2) { puts( 1 ); for (int i = 0; i < n; i++) for (int j = i + 1; j < n; j++) if (F[i] != F[j] && A[i].find(j) == A[i].end()) { printf( %d %d n , i + 1, j + 1); return 0; } } vector<int> L; for (int i = 0; i < (int)G.size(); i++) if ((int)B[i].size() == 1) L.push_back(i); printf( %d n , ((int)L.size() + 1) / 2); while (1) { random_shuffle(L.begin(), L.end()); bool F = 0, FF = 1; if ((int)L.size() & 1) F = 1, L.push_back(L[0]); v.clear(), v.resize(M, 0); for (int i = 0; i < (int)L.size(); i += 2) gg(L[i], L[i + 1], -1); for (int i = 0; i < M; i++) if (!v[i]) { FF = 0; break; } if (FF) { for (int i = 0; i < (int)L.size(); i += 2) printf( %d %d n , G[L[i]] + 1, G[L[i + 1]] + 1); return 0; } if (F) L.erase(L.end() - 1); } return 0; }

#include <bits/stdc++.h> using namespace std; int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); long long int T = 1; while (T--) { long long int n, i, j; cin >> n; long long int a[n + 5]; long long int b[n + 5]; unordered_map<long long int, long long int> rnk; long long int ans = 0; for (i = 0; i < n; i++) { cin >> a[i]; } j = 0; for (i = 0; i < n; i++) { cin >> b[i]; if (b[i] != a[j]) { ans++; rnk[b[i]]++; } else { j++; while (j < n && rnk.find(a[j]) != rnk.end()) j++; } } cout << ans << n ; } return 0; }

#include <bits/stdc++.h> using namespace std; const long long MOD = 1e9 + 7; const long long MAXN = 2e5 + 7; long long a[MAXN]; bool good[MAXN]; long long want[MAXN], pref[MAXN], next_[MAXN]; signed main() { ios_base::sync_with_stdio(false); cout.precision(40); long long n; cin >> n; for (long long i = 0; i < n; ++i) { cin >> a[i]; } stack<long long> st; for (long long i = 0; i < n; ++i) { while (st.size() && a[st.top()] < a[i]) { next_[st.top()] = i; st.pop(); } st.push(i); } while (st.size()) { next_[st.top()] = n; st.pop(); } long long mx1 = -MOD; long long mx2 = -MOD; for (long long i = 0; i < n; ++i) { if (a[i] < mx1 && a[i] > mx2) { want[i] = true; } if (a[i] > mx1) { mx2 = mx1; mx1 = a[i]; } else if (a[i] > mx2) { mx2 = a[i]; } } pref[0] = want[0]; for (long long i = 1; i < n; ++i) { pref[i] = pref[i - 1] + want[i]; } long long mx = -MOD; long long ans = -MOD; long long best = -1; for (long long i = 0; i < n; ++i) { mx = max(mx, a[i]); if (a[i] != mx) continue; long long j = next_[i]; long long new_ans = pref[j - 1] - pref[i] - 1; if (new_ans > ans || (new_ans == ans && a[i] < a[best])) { ans = new_ans; best = i; } } mx = -MOD; for (long long i = 0; i < n; ++i) { mx = max(mx, a[i]); if (a[i] == mx) continue; long long new_ans = 0; if (new_ans > ans || (new_ans == ans && a[i] < a[best])) { ans = new_ans; best = i; } } cout << a[best] << n ; return 0; }

#include <bits/stdc++.h> using namespace std; int main() { long long t; cin >> t; while (t--) { long long n, m; cin >> n >> m; long long sum = 0; for (long long i = 0; i < n; i++) { long long x; cin >> x; sum += x; } cout << min(sum, m) << n ; } return 0; }

#include <bits/stdc++.h> using namespace std; int n; int x, y; int p[1000003]; int r[1000003]; map<int, int> a; int ans[200003]; int s; int parent(int x) { if (p[x] < 0) return x; return p[x] = parent(p[x]); } void join(int x, int y) { p[y] = parent(x); } int main() { fill_n(p, 1000003, -1); scanf( %d , &n); for (int i = 0; i < n; ++i) { scanf( %d%d , &x, &y); if (y) join(x, y); a.insert(pair<int, int>(x, y)); } int i = 2; int j = 0; while (a[j] != 0) { ans[i] = a[j]; j = a[j]; i += 2; } i = 1; j = 0; while (p[j] < 0 || parent(j) == 0) j++; j = parent(j); ans[i] = j; i += 2; while (a[j] != 0) { ans[i] = a[j]; j = a[j]; i += 2; } for (i = 1; i <= n; ++i) printf( %d , ans[i]); return 0; }

#include <bits/stdc++.h> using namespace std; long long C(int a, int b) { long long ans = 1; for (int i = 0; i < b; ++i) ans *= (a - i), ans /= (i + 1); return ans; } int main() { int n; while (cin >> n) cout << C(n + 4, 5) * C(n + 2, 3) << endl; }

#include <bits/stdc++.h> using namespace std; const long long maxn = 1e5 + 10; struct Seg { long long mn, id; }; long long arr[maxn], N, P, ans[maxn]; Seg seg[maxn << 2]; inline Seg pushup(long long cur) { Seg l = seg[cur << 1], r = seg[cur << 1 | 1]; if (l.mn == r.mn) { return l; } else if (l.mn < r.mn) { Seg mer; mer.id = l.id, mer.mn = l.mn; return mer; } else { Seg mer; mer.id = r.id, mer.mn = r.mn; return mer; } } long long query(long long cur, long long L, long long R, long long l, long long r) { if (L > R) return -1; if (l >= L && r <= R) { return seg[cur].id; } long long mid = (l + r) >> 1; long long lid = -1, rid = -1; if (mid >= L) lid = query(cur << 1, L, R, l, mid); if (mid < R) rid = query(cur << 1 | 1, L, R, mid + 1, r); if (lid == -1) return rid; else if (rid == -1) return lid; else { return arr[lid] > arr[rid] ? rid : lid; } } long long query2(long long cur, long long l, long long r, const long long x) { if (l == r) { return l; } long long mid = (l + r) >> 1; if (seg[cur << 1].mn <= x) { return query2(cur << 1, l, mid, x); } return query2(cur << 1 | 1, mid + 1, r, x); } void build(long long l, long long r, long long cur) { seg[cur].id = l, seg[cur].mn = arr[l]; if (l == r) return; long long mid = (l + r) >> 1; build(l, mid, cur << 1); build(mid + 1, r, cur << 1 | 1); seg[cur] = pushup(cur); } void update(long long pos, long long l, long long r, long long cur, long long x) { if (l == r) { seg[cur].mn = x; arr[pos] = x; return; } long long mid = (l + r) >> 1; if (mid >= pos) { update(pos, l, mid, cur << 1, x); } else { update(pos, mid + 1, r, cur << 1 | 1, x); } seg[cur] = pushup(cur); } signed main() { ios::sync_with_stdio(false); cin >> N >> P; for (register long long i = 1; i <= N; ++i) { cin >> arr[i]; } build(1, N, 1); long long cnt = 0, cur = 0; while (cnt < N) { cur = max(cur, seg[1].mn); long long x = query2(1, 1, N, cur); ans[x] = cur += P; ++cnt; update(x, 1, N, 1, 0x3f3f3f3f3f3f3f3f); while (cnt < N) { x = query(1, 1, x - 1, 1, N); if (x == -1 || arr[x] > cur) break; ans[x] = cur += P, ++cnt; update(x, 1, N, 1, 0x3f3f3f3f3f3f3f3f); } } for (register long long i = 1; i <= N; ++i) { cout << ans[i] << ; } return 0; }

#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; int count = 0; while ((count * (count + 1)) / 2 <= n) { ++count; } --count; int val = (count * (count + 1)) / 2; int diff = n - val; cout << count << n ; for (int i = 1; i <= count; ++i) { if (i == count) { cout << count + diff << ; break; } cout << i << ; } }

#include <bits/stdc++.h> using namespace std; int t; int n; int a[100086]; int main() { scanf( %d , &t); while (t--) { scanf( %d , &n); for (int i = 1; i <= n; i++) scanf( %d , &a[i]); int x = 0, y = a[1]; for (int i = 2; i <= n; i++) { if (a[i] > a[i - 1]) { x += a[i] - a[i - 1]; } else { y -= a[i - 1] - a[i]; } } puts(y >= 0 ? YES : NO ); } }

#include <bits/stdc++.h> using namespace std; int k, b, n; map<int, int>::iterator it; int main() { map<int, int> mp; while (scanf( %d%d%d , &k, &b, &n) != EOF) { mp.clear(); if (b == 0) { int a, sum = 0; long long res = 0; mp[0] = 1; for (int i = 1; i <= n; i++) { scanf( %d , &a); if (a) sum++; if (mp.find(sum) == mp.end()) mp[sum] = 1; else mp[sum]++; } for (it = mp.begin(); it != mp.end(); it++) { long long tmp = it->second; res += tmp * (tmp - 1) / 2; } cout << res << endl; } else { int a, ss = 0; long long res = 0, pre = 0; mp[0] = 1; for (int i = 1; i <= n; i++) { scanf( %d , &a); if (a) { ss += a; ss %= (k - 1); int ff = (ss - b + k - 1) % (k - 1); int st = mp.find(ff) == mp.end() ? 0 : mp[ff]; pre = st; res += st; if (mp.find(ss) == mp.end()) mp[ss] = 1; else mp[ss]++; } else { res += pre; mp[ss]++; } } cout << res << endl; } } }

#include <bits/stdc++.h> using namespace std; const int N = 2e5 + 5; int a[N], cnt[N * 2], n, m; long long solve(int m) { int s = n; memset(cnt, 0, sizeof(cnt)); cnt[s] = 1; long long add = 0, ans = 0; for (int i = 1; i <= n; i++) { if (a[i] >= m) add += cnt[s], s++; else s--, add -= cnt[s]; cnt[s]++; ans += add; } return ans; } int main() { scanf( %d %d , &n, &m); for (int i = 1; i <= n; i++) scanf( %d , &a[i]); printf( %lld n , solve(m) - solve(m + 1)); return 0; }

#include <bits/stdc++.h> using namespace std; long long t1, t2, x1, x2, t; bool Check(long long y1, long long y2) { return t1 * y1 + t2 * y2 >= t * (y1 + y2); } double HotBath(long long y1, long long y2) { return 1.0 * (t1 * y1 + t2 * y2) / (y1 + y2); } int main() { cin >> t1 >> t2 >> x1 >> x2 >> t; long long Y1 = 0, Y2 = 0; if (HotBath(x1, x2) >= t) Y1 = x1, Y2 = x2; if (HotBath(x1, 0) >= t && x1 >= Y1 + Y2) Y1 = x1, Y2 = 0; if (HotBath(0, x2) >= t && x2 >= Y1 + Y2) Y1 = 0, Y2 = x2; for (long long y1 = 0; y1 <= x1; y1++) { long long y2 = 0; long long Start = 0, End = x2; while (Start <= End) { long long Mid = Start + End >> 1; if (Check(y1, Mid)) { y2 = Mid; End = Mid - 1; } else Start = Mid + 1; } if (y1 + y2 == 0) continue; double New = HotBath(y1, y2); double Old = HotBath(Y1, Y2); if (New >= 1.0 * t) { if (New < Old) { Old = New; Y1 = y1; Y2 = y2; } else if (fabs(New - Old) <= 1e-9 && (Y1 + Y2 < y1 + y2)) { Y1 = y1; Y2 = y2; } } } cout << Y1 << << Y2 << n ; return 0; }

#include <bits/stdc++.h> using namespace std; const int maxN = 2000 + 5; int n, mark[maxN], m, st[maxN], start, high[maxN], on[maxN], cnt; vector<int> adj[maxN]; vector<int> s; void DFS(int v) { s.push_back(v); on[v] = mark[v] = 1; st[v] = high[v] = start++; for (int i = 0; i < adj[v].size(); i++) { int x = adj[v][i]; if (mark[x]) { if (on[x]) high[v] = min(high[v], high[x]); } else { DFS(x); high[v] = min(high[v], high[x]); } } if (st[v] == high[v]) { int x = s.back(); while (!s.empty() && st[x] >= st[v]) { on[x] = 0; s.pop_back(); x = s.back(); } cnt++; } } int main() { ios::sync_with_stdio(false), cin.tie(0), cout.tie(0); cin >> n; for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { int x; cin >> x; if (x) adj[i].push_back(j); } } for (int i = 0; i < n; i++) if (!mark[i]) DFS(i); if (cnt == 1) cout << YES n ; else cout << NO n ; return 0; }

#include <bits/stdc++.h> using namespace std; int main() { int w, h, ring, plate = 0; cin >> w >> h >> ring; for (int i = 0; i < ring; i++) { if (i > 0) { w -= 4; h -= 4; } plate += (w * 2) + ((h - 2) * 2); } cout << plate; return 0; }

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

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

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

#include <bits/stdc++.h> using namespace std; const long long MOD = 1e9 + 7; const long long INF = 1e18; const string nl = n ; int32_t main() { ios::sync_with_stdio(0); cin.tie(nullptr); long long n, k, second, t; cin >> n >> k >> second >> t; vector<pair<long long, long long>> a(n); for (auto& i : a) { cin >> i.first >> i.second; } vector<long long> b(k); for (auto& i : b) { cin >> i; } sort(b.begin(), b.end()); vector<long long> temp = {0}; for (auto& i : b) { temp.push_back(i); } temp.push_back(second); b = temp; auto check = [&](long long x) -> bool { long long ans = 0; for (long long i = 0; i < ((long long)(b).size()); ++i) { long long dist = b[i] - (i == 0 ? 0 : b[i - 1]); long long hld = min(x - dist, dist); if (hld < 0) { return 0; } ans += hld + (dist - hld) * 2; } return ans <= t; }; long long l = 0, r = 2e9; while (l < r) { long long mid = (l + r) / 2; if (check(mid)) { r = mid; } else { l = mid + 1; } } auto cmp = [&](pair<long long, long long> a, pair<long long, long long> b) -> bool { return a.second < b.second; }; sort(a.begin(), a.end(), cmp); long long ans = INF; for (long long i = 0; i < ((long long)(a).size()); ++i) { if (a[i].second >= l) { ans = min(ans, a[i].first); } } cout << (ans == INF ? -1 : ans) << nl; }

#include <bits/stdc++.h> using namespace std; const int oo = (int)1e9; const double PI = 2 * acos(0.0); const double eps = 1e-9; int main() { ios_base::sync_with_stdio(false); int n, arra[100010], arrb[100010]; cin >> n; for (int i = 0; i < (int)(n); i++) { cin >> arra[i]; arrb[i] = arra[i]; } sort(arrb, arrb + n); int cnt = 0; for (int i = 0; i < (int)(n); i++) if (arra[i] != arrb[i]) cnt++; if (cnt == 2 || cnt == 0) cout << YES << endl; else cout << NO << endl; return 0; }

#include <bits/stdc++.h> using namespace std; inline int read() { int x = 0; char ch = getchar(); bool positive = 1; for (; ch < 0 || ch > 9 ; ch = getchar()) if (ch == - ) positive = 0; for (; ch >= 0 && ch <= 9 ; ch = getchar()) x = x * 10 + ch - 0 ; return positive ? x : -x; } int N, K; int a[105], b[105], s[105]; int t[105]; inline void trans_one(int p[]) { for (int i = 1; i <= N; ++i) t[i] = p[a[i]]; for (int i = 1; i <= N; ++i) p[i] = t[i]; } inline void trans_two(int p[]) { for (int i = 1; i <= N; ++i) t[a[i]] = p[i]; for (int i = 1; i <= N; ++i) p[i] = t[i]; } inline bool equal(int a[], int b[]) { for (int i = 1; i <= N; ++i) if (a[i] != b[i]) return 0; return 1; } int main() { N = read(), K = read(); for (int i = 1; i <= N; ++i) a[i] = read(); for (int i = 1; i <= N; ++i) s[i] = read(); for (int i = 1; i <= N; ++i) b[i] = i; if (equal(b, s)) return printf( NO n ), 0; int l = 1 << 30, r = 1 << 30; for (int i = 1; i <= K + 1; ++i) { trans_one(b); if (equal(b, s)) { r = i; break; } } for (int i = 1; i <= N; ++i) b[i] = i; for (int i = 1; i <= K + 1; ++i) { trans_two(b); if (equal(b, s)) { l = i; break; } } if (l % 2 == K % 2 && K >= l) { if (l > 1 || r > 1 || K - l == 0) return printf( YES n ), 0; } if (r % 2 == K % 2 && K >= r) { if (r > 1 || l > 1 || K - r == 0) return printf( YES n ), 0; } printf( NO n ); return 0; }

#include <bits/stdc++.h> using namespace std; long long MOD = 1e9 + 7, MAX = 1e18; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); ; long long t; cin >> t; while (t--) { long long n0, n1, n2, i; cin >> n0 >> n1 >> n2; string second = ; if (n1) { if (n1 % 2) { for (i = 0; i <= n1; i++) { if (i % 2) second.push_back( 0 ); else second.push_back( 1 ); } while (n2--) cout << 1; cout << second; while (n0--) cout << 0; cout << n ; } else { for (i = 1; i <= n1; i++) { if (i % 2) second.push_back( 0 ); else second.push_back( 1 ); } while (n2--) cout << 1; cout << 1; while (n0--) cout << 0; cout << second << n ; } } else { if (n2) for (i = 0; i <= n2; i++) cout << 1; if (n0) for (i = 0; i <= n0; i++) cout << 0; cout << n ; } } return 0; }

#include <bits/stdc++.h> using namespace std; int l[123], r[123]; int d[123]; int main() { ios_base::sync_with_stdio(false); int n; cin >> n; l[0] = 0; for (int i = 1; i < n; ++i) { int x; cin >> x; l[i] = l[i - 1] + x; } r[n - 1] = 0; vector<int> a; for (int i = 0; i < (int)n - 1; ++i) { int x; cin >> x; a.push_back(x); } int k = n - 2; for (int i = n - 2; i >= 0; --i) { r[i] = r[i + 1] + a[k]; k--; } for (int i = 0; i < (int)n; ++i) cin >> d[i]; int res[123]; for (int i = 0; i < (int)n; ++i) res[i] = d[i] + l[i] + r[i]; sort(res, res + n); cout << res[0] + res[1]; return 0; }

#include <bits/stdc++.h> using namespace std; inline long long max3(long long a, long long b, long long c) { return (a) > (b) ? ((a) > (c) ? (a) : (c)) : ((b) > (c) ? (b) : (c)); } inline long long min3(long long a, long long b, long long c) { return (a) < (b) ? ((a) < (c) ? (a) : (c)) : ((b) < (c) ? (b) : (c)); } long long extgcd(long long a, long long b, long long &x, long long &y) { if (b == 0) { x = 1; y = 0; return a; } long long d = extgcd(b, a % b, y, x); y -= a / b * x; return d; } inline long long mod(long long a, long long m) { return (a % m + m) % m; } long long modinv(long long a) { long long x, y; extgcd(a, 1000000007, x, y); return mod(x, 1000000007); } long long gcd(long long u, long long v) { long long r; while (0 != v) { r = u % v; u = v; v = r; } return u; } long long lcm(long long u, long long v) { return u / gcd(u, v) * v; } void get_all_factors(int a[], long long int n) { long long int w = sqrt(n); for (int i = 1; i <= w; i++) { if (n % i == 0) { a[i]++; a[n / i]++; } } long long int x = ceil(sqrt(n)); if (sqrt(n) == ceil(sqrt(n))) a[(int)sqrt(n)]--; } long long int memo[100000][110] = {0}; long long C(long long n, long long r) { if (r == 0 || r == n) return 1; if (memo[n][r] != -1) return memo[n][r]; return memo[n][r] = (C(n - 1, r - 1) % 1000000007 + C(n - 1, r) % 1000000007) % 1000000007; } int valid(string s, int i) { if (s == lol or i == -1000050000) { return 0; } return 1; } void status(string s1 = lol , long long int i1 = -1000050000, string s2 = lol , long long int i2 = -1000050000, string s3 = lol , long long int i3 = -1000050000) { if (1) { if (valid(s1, i1)) { cout << s1 << = << i1 << ; } if (valid(s2, i2)) { cout << s2 << = << i2 << ; } if (valid(s3, i3)) { cout << s3 << = << i3 << ; } cout << endl; } } long long int poww(long long b, long long e) { if (e == 0) return 1; else if (e % 2 == 0) { long long a = pow(b, e / 2); return a * a; } else { long long a = pow(b, e / 2); return b * a * a; } } long long int powm(long long x, long long y, long long m = 1000000007) { x = x % m; long long res = 1; while (y) { if (y & 1) res = res * x; res %= m; y = y >> 1; x = x * x; x %= m; } return res; } vector<pair<int, int> > range(1000000); vector<int> adj[1000000]; vector<int> d(1000000, 0); int p[1000000] = {0}; int T = 0; void dfs(int v, int pa = -1, int dep = 0) { p[v] = pa; d[v] = dep; range[v].first = T; T++; for (auto i : adj[v]) { if (i != pa) { dfs(i, v, dep + 1); } } range[v].second = T; T++; } int main() { int n, m; cin >> n >> m; for (int i = 0; i < n - 1; i++) { int u, v; cin >> u >> v; adj[u].push_back(v); adj[v].push_back(u); } dfs(1); while (m--) { int k; cin >> k; int a[k]; for (int i = 0; i < k; i++) { cin >> a[i]; } int it = a[0]; for (auto i : a) { if (d[i] > d[it]) { it = i; } } for (auto &i : a) { if (it == i) { continue; } if (p[i] != -1) { i = p[i]; } } int ok = 1; for (auto i : a) { if (range[i].first <= range[it].first and range[i].second >= range[it].second) { } else { ok = 0; break; } } if (ok) { cout << YES << endl; } else { cout << NO << endl; } } }

#include <bits/stdc++.h> using namespace std; template <typename T> bool mmax(T &m, const T q) { if (m < q) { m = q; return true; } else return false; } template <typename T> bool mmin(T &m, const T q) { if (m > q) { m = q; return true; } else return false; } const int MOD = 1e9 + 7; const int MAXN = 5e5 + 3; const int INF = 1e9; int main(int argc, char **argv) { ios::sync_with_stdio(false); cin.tie(0); int ntest; cin >> ntest; while (ntest--) { long long x, y, a, b; cin >> x >> y >> a >> b; long long ans = a * (abs(x) + abs(y)); mmin(ans, b * abs(x) + a * abs(y - x)); mmin(ans, b * abs(y) + a * abs(x - y)); cout << ans << n ; } return 0; }

#include <bits/stdc++.h> using namespace std; const int maxn = 2e5 + 5; int lazy[maxn << 2]; int a[maxn], c[maxn]; void pushup(int l, int r, int rt) { lazy[rt << 1] = lazy[rt << 1 | 1] = lazy[rt]; lazy[rt] = 0; } void update(int L, int R, int c, int l, int r, int rt) { if (L <= l && R >= r) { lazy[rt] = c; return; } if (lazy[rt]) pushup(l, r, rt); if (L <= ((l + r) >> 1)) update(L, R, c, l, ((l + r) >> 1), rt << 1); if (R > ((l + r) >> 1)) update(L, R, c, ((l + r) >> 1) + 1, r, rt << 1 | 1); } void query(int l, int r, int rt) { if (l == r) { c[l] = lazy[rt]; return; } if (lazy[rt]) pushup(l, r, rt); query(l, ((l + r) >> 1), rt << 1); query(((l + r) >> 1) + 1, r, rt << 1 | 1); } struct T { int l, r; } b[maxn]; int main() { map<int, int> mp; int n, k; cin >> n >> k; for (int i = 1; i <= n; i++) cin >> a[i]; for (int i = 1; i <= n; i++) { if (a[i] == 0) continue; if (mp[a[i]]) b[a[i]].r = i; else mp[a[i]] = 1, b[a[i]].l = i, b[a[i]].r = i; } for (int i = 1; i <= k; i++) { if (mp[i]) { update(b[i].l, b[i].r, i, 1, n, 1); } } query(1, n, 1); bool d = true; for (int i = 1; i <= n; i++) { if (c[i] != a[i] && a[i] != 0) d = false; } if (!d) { cout << NO << endl; return 0; } bool ff = true; for (int i = 1; i <= n; i++) { if (a[i] == k) ff = false; } if (ff) { bool dd = false; for (int i = 1; i <= n; i++) if (a[i] == 0) { dd = true; c[i] = k; break; } if (!dd) { cout << NO << endl; return 0; } } cout << YES << endl; for (int i = 1; i <= n; i++) { if (a[i] == 0 && c[i] == 0) { c[i] = 1; } cout << c[i] << ; } cout << endl; }

#include <bits/stdc++.h> using namespace std; int main() { int t, n, x; scanf( %d , &n); priority_queue<int, vector<int>, greater<int> > que; long long ans = 0; for (int i = 0; i < n; i++) { scanf( %d , &x); if (que.empty() || que.top() > x) que.push(x); else { ans += x - que.top(); que.pop(); que.push(x); que.push(x); } } printf( %lld n , ans); return 0; }

#include <bits/stdc++.h> using namespace std; mt19937 rndll(chrono::steady_clock::now().time_since_epoch().count()); const int INF = 0x3f3f3f3f, MOD = 1e9 + 7; const int N = 2e5 + 5; int n, q, a, b, cnt, k, par[N]; vector<int> adj[N], v; pair<int, int> rng[N]; void dfs(int u, int p) { par[u] = (p != -1 ? p : u); rng[u] = {INF, -INF}; for (auto v : adj[u]) if (v != p) { dfs(v, u); rng[u].first = min(rng[u].first, rng[v].first); rng[u].second = max(rng[u].second, rng[v].second); } if (rng[u].first == INF) cnt++, rng[u] = {cnt, cnt}; } bool query(vector<int> &v) { int l = -INF, r = INF; for (auto x : v) l = max(l, rng[par[x]].first), r = min(r, rng[par[x]].second); return l <= r; } int main() { ios_base::sync_with_stdio(0), cin.tie(0); cin >> n >> q; for (int i = 0; i < n - 1; i++) { cin >> a >> b; adj[a].push_back(b), adj[b].push_back(a); } dfs(1, -1); while (q--) { cin >> k; v.resize(k); for (int i = 0; i < k; i++) cin >> v[i]; cout << (query(v) ? YES n : NO n ); } }

#include <bits/stdc++.h> using namespace std; int main() { int n; vector<int> v; cin >> n; int x = 1; for (int i = 1; i <= n; i++) { int d; cin >> d; if (d == x) { v.push_back(i + 2000); x++; } } cout << v.size() << endl; for (int i = 0; i < v.size(); i++) cout << v[i] << ; return 0; }

#include <bits/stdc++.h> using namespace std; const int maxn = 2e5 + 7; const int inf = 0x3f3f3f3f; const int mod = 1e9 + 7; long long ans; int a[maxn]; int ned[maxn]; int n; int main() { scanf( %d , &n); for (int i = 1; i <= n; i++) { scanf( %d , &a[i]); ned[i] = a[i] + 1; } for (int i = 2; i <= n; i++) { ned[i] = max(ned[i], ned[i - 1]); } for (int i = n; i >= 1; i--) { ned[i] = max(ned[i + 1] - 1, ned[i]); ans += (ned[i] - a[i] - 1); } printf( %I64d n , ans); }

#include <bits/stdc++.h> using namespace std; vector<long long> A; long long B[1000000] = {0}; bool cmp(long long x, long long y) { return x > y; } int main() { A.clear(); string S1, S2; cin >> S1; for (long long i = 0; i < S1.size(); i++) A.push_back(S1[i] - 0 ); cin >> S2; for (long long i = 0; i < S2.size(); i++) B[i] = S2[i] - 0 ; sort(B, B + S2.size(), cmp); long long find = 0; for (long long i = 0; i < A.size(); i++) if (A[i] < B[find]) A[i] = B[find++]; for (long long i = 0; i < A.size(); i++) cout << A[i]; }

#include <bits/stdc++.h> using namespace std; struct Point { int num; int next[3001]; int count; }; Point a[3001]; int dis[3001]; int p[3001]; int cir[3001]; int cir1[3001]; int f(int n) { int i, num = 0, d = 1; loop: while (1) { num = 0; for (i = 1; i <= n; i++) { if (a[i].num - a[i].count == 1) { a[i].count++; p[num++] = i; } } for (i = 0; i < num; i++) { for (int j = 0; j < a[p[i]].num; j++) a[a[p[i]].next[j]].count++; } for (i = 1; i <= n; i++) { if (a[i].num - a[i].count > 0 && a[i].num - a[i].count != 2) goto loop; } num = 0; for (i = 1; i <= n; i++) { if (a[i].num - a[i].count == 2) cir[num++] = i; } return num; } } int main() { int b[4], n, i, t, sum, num, flag; int from, to; cin >> n; for (i = 1; i <= n; i++) { cin >> from >> to; a[from].next[a[from].num++] = to; a[to].next[a[to].num++] = from; } int step = 0; sum = num = f(n); memset(dis, 0xff, sizeof(dis)); for (i = 0; i < num; i++) dis[cir[i]] = step; while (sum < n) { int k = 0; step++; flag = 0; for (i = 0; i < num; i++) { for (int j = 0; j < a[cir[i]].num; j++) { int next = a[cir[i]].next[j]; if (dis[next] == -1) { sum++; flag = 1; dis[next] = step; cir1[k++] = next; continue; } } if (!flag) cir[i] = -1; } memcpy(cir, cir1, k * sizeof(cir1[0])); num = k; } for (i = 1; i <= n; i++) if (i != n) cout << dis[i] << ; else cout << dis[i] << endl; return 0; }

#include <bits/stdc++.h> using namespace std; template <typename T> inline bool chkmin(T &x, T y) { return x > y ? x = y, 1 : 0; } template <typename T> inline bool chkmax(T &x, T y) { return x < y ? x = y, 1 : 0; } template <typename T> inline void read(T &x) { char ch = getchar(); int f = 1; x = 0; while (ch < 0 || ch > 9 ) { if (ch == - ) f = -1; ch = getchar(); } while (ch >= 0 && ch <= 9 ) x = x * 10 + ch - 0 , ch = getchar(); x *= f; } template <typename T, typename... Args> inline void read(T &x, Args &...args) { char ch = getchar(); int f = 1; x = 0; while (ch < 0 || ch > 9 ) { if (ch == - ) f = -1; ch = getchar(); } while (ch >= 0 && ch <= 9 ) x = x * 10 + ch - 0 , ch = getchar(); x *= f; read(args...); } int n, m, C, emp, dlt, len[300050], crs[300050], ans[300050]; set<int> se; map<int, int> both[300050]; struct Time { int t, x; bool operator<(const Time &rhs) const { return t < rhs.t; } } a[300050 << 2]; struct cloud { int l, r, c; bool operator<(const cloud &rhs) const { return c < rhs.c; } } c[300050]; struct Query { int x, id; bool operator<(const Query &rhs) const { return x < rhs.x; } } q[300050]; int maxv[300050 << 2]; void modify(int u, int l, int r, int x) { if (l == r) return (void)(maxv[u] = len[x]); if (x <= ((l + r) >> 1)) modify(u << 1, l, ((l + r) >> 1), x); else modify(u << 1 | 1, ((l + r) >> 1) + 1, r, x); maxv[u] = max(maxv[u << 1], maxv[u << 1 | 1]); } int query(int u, int l, int r, int tl, int tr) { if (tl > tr) return 0; if (tl <= l && r <= tr) return maxv[u]; int ret = 0; if (tl <= ((l + r) >> 1)) ret = query(u << 1, l, ((l + r) >> 1), tl, tr); if (((l + r) >> 1) < tr) chkmax(ret, query(u << 1 | 1, ((l + r) >> 1) + 1, r, tl, tr)); return ret; } int main() { read(n, C); for (register int i = 1; i <= n; ++i) read(c[i].l, c[i].r, c[i].c); sort(c + 1, c + n + 1); int tot = 0; for (register int i = 1; i <= n; ++i) a[++tot] = Time{c[i].l, i}, a[++tot] = Time{c[i].r, -i}; a[++tot] = Time{int(2e9), 0}; sort(a + 1, a + tot + 1); read(m); for (register int i = 1; i <= m; ++i) read(q[i].x), q[i].id = i; sort(q + 1, q + m + 1); int pos = 1; for (register int i = 1; i <= tot; ++i) { int T = a[i].t - a[i - 1].t; if (se.empty()) emp += T; else if (se.size() == 1) { int x = *se.begin(), cur = -1e9; len[x] += T, crs[x] += T, modify(1, 1, n, x); int rr = upper_bound(c + 1, c + n + 1, cloud{0, 0, C - c[x].c}) - c - 1; if (rr >= x) chkmax(cur, query(1, 1, n, 1, x - 1)), chkmax(cur, query(1, 1, n, x + 1, rr)); else chkmax(cur, query(1, 1, n, 1, rr)); chkmax(crs[x], len[x] + cur); if (c[x].c <= C) chkmax(dlt, crs[x]); } else if (se.size() == 2) { int x = *se.begin(), y = *se.rbegin(); if (c[x].c + c[y].c <= C) { both[x][y] += T; chkmax(crs[x], both[x][y] + len[x] + len[y]), chkmax(crs[y], both[x][y] + len[x] + len[y]); chkmax(dlt, max(crs[x], crs[y])); } } while (pos <= m && dlt + emp >= q[pos].x) ans[q[pos].id] = a[i].t - (dlt + emp - q[pos].x), pos++; if (a[i].x > 0) se.insert(a[i].x); else se.erase(-a[i].x); } for (register int i = 1; i <= m; ++i) printf( %d n , ans[i]); return 0; }

#include <bits/stdc++.h> using namespace std; const int _ = 600 + 7; const int __ = 1e5 + 7; const int S = 601, T = 602; const int inf = 0x3f3f3f3f; int n; int lst[_], nxt[__], to[__], cap[__], tot = 1; long long ans; int gi() { int x = 0; bool f = 0; char c = getchar(); while (!isdigit(c) and c != - ) c = getchar(); if (c == - ) f = 1, c = getchar(); while (isdigit(c)) x = (x << 3) + (x << 1) + c - 0 , c = getchar(); return f ? -x : x; } void Add(int x, int y, int c) { nxt[++tot] = lst[x]; to[tot] = y; cap[tot] = c; lst[x] = tot; nxt[++tot] = lst[y]; to[tot] = x; cap[tot] = 0; lst[y] = tot; } void Init() { n = gi(); for (int i = 1; i <= n; ++i) { int m = gi(); for (int j = 1; j <= m; ++j) Add(i, gi() + n, inf); } for (int i = 1; i <= n; ++i) { int v = gi(); ans -= v; Add(S, i, inf - v), Add(i + n, T, inf); } } int d[_], cur[_]; queue<int> q; bool Bfs() { memset(d, -1, sizeof d); while (!q.empty()) q.pop(); d[S] = 0, q.push(S); while (!q.empty()) { int u = q.front(); q.pop(); for (int i = lst[u]; i; i = nxt[i]) if (cap[i] and d[to[i]] == -1) { d[to[i]] = d[u] + 1, q.push(to[i]); if (to[i] == T) return 1; } } return 0; } int Dfs(int u, int flow) { if (u == T) return flow; int res = flow; for (int &i = cur[u]; i; i = nxt[i]) if (cap[i] and d[to[i]] == d[u] + 1) { int tmp = Dfs(to[i], min(res, cap[i])); cap[i] -= tmp, cap[i ^ 1] += tmp; res -= tmp; if (!res) return flow; } return flow - res; } void Run() { long long maxFlow = -1ll * n * inf; int flow; while (Bfs()) { memcpy(cur, lst, sizeof cur); do { flow = Dfs(S, inf); maxFlow += flow; } while (flow); } cout << min(0ll, -(ans - maxFlow)) << endl; } int main() { Init(); Run(); return 0; }

#include <bits/stdc++.h> using namespace std; int main() { int n, k, a[100010]; cin >> n >> k; if (n / 2 > k) printf( -1 n ); else { if (n == 1) { if (k == 0) printf( 1 n ); else printf( -1 n ); } else { int t = k - (n / 2 - 1); printf( %d %d , t, 2 * t); int cnt = 1; for (int i = 1; i < n / 2; i++) { printf( %d %d , 900000000 + cnt, 900000000 + cnt + 1); cnt += 2; } if (n % 2) printf( 1000000000 ); } } }

#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); long long int t; cin >> t; while (t--) { long long int a, b, n, s; cin >> a >> b >> n >> s; long long int r = s % n; long long int q = s / n; if (q <= a) { if (r <= b) { cout << YES << n ; } else cout << NO << n ; } else if (((q - a) * n + r) <= b) { cout << YES << n ; } else { cout << NO << n ; } } }

#include <bits/stdc++.h> using namespace std; string itos(int x) { stringstream ss; ss << x; return ss.str(); } int xorsum, n, a[110]; map<int, int> grun; int sieve[31700]; vector<int> p; int mex(set<int> &s) { for (int i = 0;; i++) if (not s.count(i)) return i; } int getGrundy(int x) { if (grun.count(x)) return grun[x]; if (x == 1) return grun[x] = 0; set<int> s; for (int i = 1; (1 << i) <= x; i++) s.insert(getGrundy(x >> i | (x & ((1 << i) - 1)))); return grun[x] = mex(s); } void solve(int x) { int mask = 0; for (int i = 0; i < n; i++) { int cnt = 0; while (a[i] % x == 0) cnt++, a[i] /= x; mask |= (1 << cnt); } xorsum ^= getGrundy(mask); } int main() { ios_base::sync_with_stdio(false); cin >> n; for (int i = 0; i < n; i++) cin >> a[i]; for (int i = 2; i < 31700; i++) { if (not sieve[i]) { p.push_back((i)); for (int j = i * i; j < 31700; j += i) sieve[j] = 1; } } for (int i = 0; i < n; i++) { auto it1 = p.begin(); while (a[i] > 1) { if (it1 == p.end()) { solve(a[i]); break; } else if (a[i] % *it1 == 0) solve(*it1); it1++; } } cout << (xorsum ? Mojtaba : Arpa ) << endl; return 0; }

#include <bits/stdc++.h> using namespace std; const long long int Maxn3 = 1e3 + 10; const long long int Maxn4 = 1e4 + 10; const long long int Maxn5 = 1e5 + 10; const long long int Maxn6 = 1e6 + 10; const long long int Maxn7 = 1e7 + 10; const long long int Maxn8 = 1e8 + 10; const long long int Maxn9 = 1e9 + 10; const long long int Maxn18 = 1e18 + 10; const long long int Mod1 = 1e7 + 7; const long long int Mod2 = 1e9 + 7; const long long int LLMax = LLONG_MAX; const long long int LLMin = LLONG_MIN; const long long int INTMax = INT_MAX; const long long int INTMin = INT_MIN; long long int mn = LLMax, mx = LLMin; char s[Maxn6]; int main() { ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL); string s1( ... n.X. n ), s2( .X. n ), s; long long int res = 0; cin >> s; for (long long int i = 0; i < s.size(); i++) { if (res < s[i]) res += 256; while (res > s[i]) { res--; cout << s1; } cout << s2; } }

#include <bits/stdc++.h> std::mt19937 rng( (int)std::chrono::steady_clock::now().time_since_epoch().count()); int main() { std::ios_base::sync_with_stdio(false); std::cin.tie(NULL); int n, w, m; std::cin >> n >> w >> m; std::cout << std::setprecision(10) << std::fixed; std::vector<std::vector<std::pair<int, int>>> ans(m); w *= m; int cup = n * w / m; int rest = w; for (int i = 0, j = 0; i < m; i++) { if (rest > 0 && rest != w && rest > cup) { std::cout << NO n ; return 0; } int want = cup; while (want > 0) { int use = std::min(rest, want); assert(use != 0); ans[i].emplace_back(use, j + 1); want -= use; rest -= use; if (rest == 0) { j++; rest = w; } } } std::cout << YES n ; for (auto vec : ans) { for (int i = 0; i < (int)vec.size(); i++) { std::cout << vec[i].second << << (double)vec[i].first / m << (i + 1 == (int)vec.size() ? n : ); } } }

#include <bits/stdc++.h> using namespace std; constexpr int INF = 1e9 + 1; constexpr long long LLINF = 1e18 + 1; long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; } long long lcm(long long a, long long b) { return a / gcd(a, b) * b; } void solve() { int n, t; cin >> n; vector<int> arr(101); for (__typeof(n) i = 0; i < n; i++) { cin >> t; arr[t] = 1; } int col = 0; for (int i = 1; i <= 100; i++) if (arr[i]) { for (int j = i; j <= 100; j += i) { arr[j] = 0; } col++; } printf( %d n , col); } int main() { ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0); int t = 1; while (t--) solve(); }

#include <bits/stdc++.h> using namespace std; int main() { long long n; cin >> n; long long a[n]; for (int i = 0; i < n; i++) cin >> a[i]; cout << a[1] - a[0] << << a[n - 1] - a[0] << endl; for (int i = 1; i <= n - 2; i++) { cout << min(a[i] - a[i - 1], a[i + 1] - a[i]) << << max(a[i] - a[0], a[n - 1] - a[i]) << endl; } cout << a[n - 1] - a[n - 2] << << a[n - 1] - a[0]; return 0; }

#include <bits/stdc++.h> using namespace std; const int mod = 998244353; int power(int v, int u) { if (!u) return 1; int ok = power(v, u >> 1); if (u & 1) return (long long)ok * ok % mod * v % mod; return (long long)ok * ok % mod; } const int maxm = 2e5; int b[maxm + 10]; int main() { int n, m, A; scanf( %d%d%d , &n, &m, &A); for (int i = 1; i <= m; i++) scanf( %d , &b[i]); int ans = 1; int inv2 = power(2, mod - 2); for (int i = 1; i <= m; i++) ans = (long long)ans * (((long long)power(A, 2 * (b[i] - b[i - 1])) + power(A, b[i] - b[i - 1])) % mod * inv2 % mod) % mod; ans = (long long)ans * power(A, n - b[m] - b[m]) % mod; printf( %d n , ans); return 0; }

#include <bits/stdc++.h> using namespace std; const long double eps = 1e-9; const int inf = (1 << 30) - 1; const long long inf64 = ((long long)1 << 62) - 1; const long double pi = acos(-1); template <class T> T sqr(T x) { return x * x; } template <class T> T abs(T x) { return x < 0 ? -x : x; } const int MAXK = 105; const int magic = 100 * 1000; int a[MAXK]; int ans_small[MAXK][magic]; long long get_ans(long long n, int k) { if (k == 0) { return n; } if (n < magic) { return ans_small[k][n]; } return get_ans(n, k - 1) - get_ans(n / a[k - 1], k - 1); } int main() { ios_base::sync_with_stdio(0); long long n; int k; cin >> n >> k; for (int i = 0; i < k; ++i) { cin >> a[i]; } sort(a, a + k); for (int i = 0; i < magic; ++i) { ans_small[0][i] = i; } for (int i = 1; i <= k; ++i) { for (int j = 0; j < magic; ++j) { ans_small[i][j] = ans_small[i - 1][j] - ans_small[i - 1][j / a[i - 1]]; } } cout << get_ans(n, k) << endl; return 0; }

#include <bits/stdc++.h> using namespace std; const long long mod = 1000000007; long long Power(long long a, long long b) { if (a == 0) return 0LL; long long ans = 1; while (b) { if (b & 1) ans = (ans * a) % mod; a = (a * a) % mod; b >>= 1; } return ans; } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); long long n, m, k; cin >> n >> m >> k; if (k == -1 && n % 2 != m % 2) { cout << 0 << endl; return 0; } long long ans = Power(Power(2, (n - 1)), m - 1); cout << ans << endl; }

#include <bits/stdc++.h> using namespace std; const int mod = 1e9 + 7; long long dp[20][20][20]; int a[20]; long long num[20]; long long dfs(int pos, int pre, int sta, bool flag) { if (pos == 0) { if (pre == sta) return 1; else return 0; } if (dp[pos][pre][sta] != -1 && !flag) return dp[pos][pre][sta]; int maxx = flag ? a[pos] : 9; long long sum = 0; for (int i = 0; i <= maxx; i++) { sum += dfs(pos - 1, pre + (i == 4 || i == 7), sta, flag && (i == a[pos])); } if (!flag) dp[pos][pre][sta] = sum; return sum; } long long solve(int pos, int res) { long long ans = 0; if (pos == 7) return 1; for (int i = 0; i <= res; i++) { if (num[i]) { num[i]--; ans = (ans + (num[i] + 1) * solve(pos + 1, res - i) % mod) % mod; num[i]++; } } return ans; } void cal(int x) { int len = 0; while (x) { len++; a[len] = x % 10; x /= 10; } for (int i = 0; i <= len; i++) { num[i] = dfs(len, 0, i, 1); } num[0]--; long long ans = 0; for (int i = 1; i <= len; i++) { ans = (ans + num[i] * solve(1, i - 1) % mod) % mod; } printf( %lld n , ans); } int main() { memset(dp, -1, sizeof dp); int m; scanf( %d , &m); cal(m); }

#include <bits/stdc++.h> using namespace std; int a[29]; int main() { int n, k; char s[105]; scanf( %d , &n); scanf( %d , &k); scanf( %s , s + 1); bool f(true); for (int i = 1; i <= n; ++i) { int temp = s[i] - a ; a[temp]++; if (a[temp] > k) { f = false; break; } } if (f) printf( YES n ); else printf( NO n ); return 0; }

#include <bits/stdc++.h> const int mod = 1000003; char str[2010]; int f[2010][2010]; int main() { int n, i, j, len; bool flag = true; gets(str); n = strlen(str); for (i = 0; i <= n; i++) { if (str[i] == * || str[i] == / || i == n) if (i == 0 || str[i - 1] < 0 || str[i - 1] > 9 ) flag = false; } if (!flag) { printf( 0 n ); return 0; } f[0][0] = 1; len = 0; for (i = 1; i <= n; i++) { flag = ( 0 <= str[i - 1] && str[i - 1] <= 9 ); if (!flag) len++; for (j = len; j >= 0; j--) { if (flag) { f[i][j] = f[i - 1][j]; if ( 0 > str[i] || str[i] > 9 ) f[i][j] = (f[i][j] + f[i][j + 1]) % mod; } else if (j > 0) f[i][j] = f[i - 1][j - 1]; } } printf( %d n , f[n][0]); return 0; }

#include <bits/stdc++.h> using namespace std; using ll = long long; using vi = vector<int>; using vl = vector<ll>; using pi = pair<int, int>; namespace output { void pr(int x) { cout << x; } void pr(long x) { cout << x; } void pr(ll x) { cout << x; } void pr(unsigned x) { cout << x; } void pr(unsigned long x) { cout << x; } void pr(unsigned long long x) { cout << x; } void pr(float x) { cout << x; } void pr(double x) { cout << x; } void pr(long double x) { cout << x; } void pr(char x) { cout << x; } void pr(const char* x) { cout << x; } void pr(const string& x) { cout << x; } void pr(bool x) { pr(x ? true : false ); } template <class T1, class T2> void pr(const pair<T1, T2>& x); template <class T> void pr(const T& x); template <class T, class... Ts> void pr(const T& t, const Ts&... ts) { pr(t); pr(ts...); } template <class T1, class T2> void pr(const pair<T1, T2>& x) { pr( { , x.first, , , x.second, } ); } template <class T> void pr(const T& x) { pr( { ); bool fst = 1; for (const auto& a : x) pr(!fst ? , : , a), fst = 0; pr( } ); } void ps() { pr( n ); } template <class T, class... Ts> void ps(const T& t, const Ts&... ts) { pr(t); if (sizeof...(ts)) pr( ); ps(ts...); } void pc() { cout << ] << endl; } template <class T, class... Ts> void pc(const T& t, const Ts&... ts) { pr(t); if (sizeof...(ts)) pr( , ); pc(ts...); } } // namespace output using namespace output; const int MX = 200005; const int MOD = (int)(1e9 + 7); const ll INF = (ll)1e18; int main() { ios::sync_with_stdio(false); cin.tie(0); int n; cin >> n; vi a(n); vi cnt(101); for (int i = 0; i < n; i++) { cin >> a[i]; cnt[a[i]]++; } pi best = make_pair(-1, -1); for (int i = 1; i <= 100; i++) { if (cnt[i] > best.second) best = make_pair(i, cnt[i]); } for (int i = 1; i <= 100; i++) { if (i != best.first && cnt[i] == best.second) { cout << n << n ; return 0; } } int ret = 0; for (int v = 1; v <= 100; v++) { if (v == best.first) continue; int ans = 0; vi nv(n); for (int i = 0; i < n; i++) { if (a[i] == v) nv[i] = -1; else if (a[i] == best.first) nv[i] = 1; } vi mn(2 * n + 1, -2); mn[n] = -1; int sum = 0; for (int i = 0; i < n; i++) { sum += nv[i]; if (mn[sum + n] != -2) ans = max(ans, i - mn[sum + n]); else mn[sum + n] = i; } ret = max(ret, ans); } cout << ret << n ; }

#include <bits/stdc++.h> using namespace std; const int maxn = 1e5 + 10; long long int cal(long long int num) { return (num * (num + 1)) / 2ll; } void solve() { long long int n; scanf( %lld , &n); n--; long long int ans = 0, k = 1; for (long long int i = 1; i <= n; i <<= 1) { ans += ((n - i) / (i << 1) + 1) * i; } printf( %lld n , ans); } int main() { int t = 1; while (t--) { solve(); } return 0; }

#include <bits/stdc++.h> using namespace std; const int MOD = 1e9 + 9; const double eps = 1e-5; const int maxN = 2e3 + 10; const int inf = 1e9; int n, m; vector<pair<int, int> > a[maxN]; int vis[maxN], c[maxN]; vector<int> pat; inline void dfs(int v, int f = -1) { for (int i = 0; i < a[v].size(); i++) { if (a[v][i].first <= f) continue; if (!vis[a[v][i].second]) { vis[a[v][i].second] = 1; dfs(a[v][i].first); } } pat.push_back(v); } inline void init() { cin >> n >> m; for (int i = 0; i < m + 1; i++) { cin >> c[i]; c[i]--; } for (int i = 1; i < m + 1; i++) { int v = c[i - 1], u = c[i]; a[v].push_back(make_pair(u, i - 1)); a[u].push_back(make_pair(v, i - 1)); } for (int i = 0; i < n; i++) sort(a[i].begin(), a[i].end()); } inline void solve() { for (int i = m - 1; i >= 0; i--) { memset(vis, 0, sizeof vis); pat.clear(); for (int j = 0; j < i; j++) vis[j] = 1; dfs(c[i], c[i + 1]); if (i + pat.size() == m + 1) { reverse(pat.begin(), pat.end()); for (int j = 0; j < i; j++) cout << c[j] + 1 << ; for (int j = 0; j < pat.size(); j++) cout << pat[j] + 1 << ; cout << endl; return; } } cout << No solution << endl; } int main() { ios_base::sync_with_stdio(0); cin.tie(); cout.tie(); init(); solve(); return 0; }

#include <bits/stdc++.h> using namespace std; int n, m; vector<int> edge[110000]; vector<pair<int, int> > R; set<int> N; int find(int rt, int to) { int i; for (i = 0; i < edge[rt].size(); i++) { if (edge[rt][i] == to) return 1; } return 0; } int dfs(int rt) { if (R.size() == m || R.size() == n - 1) return 1; N.erase(rt); set<int>::iterator it; for (it = N.begin(); it != N.end(); it++) { if (find(rt, *it)) continue; R.push_back(make_pair(rt, *it)); if (dfs(*it)) return 1; R.pop_back(); it = N.find(*it); } N.insert(rt); return 0; } int main() { int a, b, i; scanf( %d%d , &n, &m); for (i = 1; i <= m; i++) { scanf( %d%d , &a, &b); edge[a].push_back(b); edge[b].push_back(a); } for (i = 1; i <= n; i++) { N.insert(i); } for (i = 1; i <= n; i++) { if (dfs(i)) { if (n == m) R.push_back(make_pair(R[0].first, R[R.size() - 1].second)); for (i = 0; i < m; i++) printf( %d %d n , R[i].first, R[i].second); return 0; } } puts( -1 ); return 0; }