Datasets:
malteklaes
/
cpp-code-code_search_net-style

Dataset card Data Studio Files Community
1
func_code_string
stringlengths
59
71.4k
#include <bits/stdc++.h> using namespace std; int main() { int a[200], n, k; for (int i = 0; i <= 200; i++) a[i] = 0; cin >> n; for (int i = 0; i < n; i++) { cin >> k; a[k]++; } int kol = 0; for (int i = 1; i <= 198; i++) kol += a[i] / 2; cout << kol / 2; return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 4000 + 5, mod = 1000000009; int n, x, y; long long P[N], d[N][N]; int main() { scanf( %d , &n); scanf( %d , &x); scanf( %d , &y); for (int i = 0; i <= max(x, y); i++) d[i][0] = 1; for (int i = 1; i <= max(x, y); i++) for (int j = 1; j <= min(n, i); j++) d[i][j] = (d[i - 1][j] + d[i - 1][j - 1]) % mod; P[0] = 1; for (int i = 1; i <= max(x, y); i++) P[i] = (P[i - 1] * i) % mod; long long ans = 0; for (int l = 2; l <= n - 1; l++) for (int r = l; r <= n - 1; r++) ans = (ans + (d[y - 1][r - l] * d[x - 1][n - (r - l + 2)]) % mod) % mod; ans = ans * ((P[x] * P[y]) % mod) % mod; printf( %I64d n , ans); return 0; }
#include <bits/stdc++.h> using namespace std; const long double eps = 1e-9; const long long INF = 1ll << 61, Mo = 1e9 + 7; int n, m, t, tu, tp, td; int h[400][400]; int s[400][400], x[400][400], z[400][400], y[400][400]; set<pair<int, int> >::iterator ii; inline int time(int h1, int h2) { if (h1 == h2) return tp; if (h1 < h2) return tu; return td; } void init() { scanf( %d%d%d , &n, &m, &t); scanf( %d%d%d , &tp, &tu, &td); int i, j; for (i = 1; i <= n; i++) for (j = 1; j <= m; j++) scanf( %d , &h[i][j]); for (j = 1; j <= m; j++) for (i = 2; i <= n; i++) { x[i][j] = x[i - 1][j] + time(h[i - 1][j], h[i][j]); s[i][j] = s[i - 1][j] + time(h[i][j], h[i - 1][j]); } for (i = 1; i <= n; i++) for (j = 2; j <= m; j++) { y[i][j] = y[i][j - 1] + time(h[i][j - 1], h[i][j]); z[i][j] = z[i][j - 1] + time(h[i][j], h[i][j - 1]); } } int main() { int i, j, k, w, ux, uy, dx, dy; init(); int ans = 2e9; for (i = 1; i <= n; i++) for (j = i + 2; j <= n; j++) { vector<pair<int, int> > V; set<pair<int, int> > U; for (k = 3; k <= m; k++) { V.push_back(pair<int, int>(y[i][k] + z[j][k] + x[j][k] - x[i][k], k)); U.insert(V.back()); } for (k = 0; k < V.size(); k++) { int tmp = t - (s[j][k + 1] - s[i][k + 1]) + (y[i][k + 1] + z[j][k + 1]); ii = U.lower_bound(pair<int, int>(tmp, 0)); if (ii != U.end() && ii->first - tmp < ans) { ans = ii->first - tmp; ux = i; uy = k + 1; dx = j; dy = ii->second; } if (ii != U.begin()) { ii--; if (tmp - ii->first < ans) { ans = tmp - ii->first; ux = i; uy = k + 1; dx = j; dy = ii->second; } } U.erase(V[k]); } } printf( %d %d %d %d n , ux, uy, dx, dy); return 0; }
#include <bits/stdc++.h> using namespace std; char BUFFER[100000 + 5]; bool readn(int &n) { return scanf( %d , &n) == 1; } bool readl(long long &n) { return scanf( %I64d , &n) == 1; } bool readd(double &n) { return scanf( %lf , &n) == 1; } bool reads(string &s) { s = ; int n = scanf( %s , BUFFER); if (n == 1) s = BUFFER; return n == 1; } bool readln(string &s) { char *valid = gets(BUFFER); if (valid) s = BUFFER; return ((bool)valid); } void Print(long long &n, bool printNewLine = true) { printNewLine ? printf( %I64d n , n) : printf( %I64d , n); } const int maxn = 1e5 + 10; int carry[maxn], f[maxn], d[maxn]; int anscnt = 0, ansfuel = 0; int N, D, F; vector<int> a, b; void calc() { int i, j, sum = 0; for (i = 0; i < N; ++i) if (d[i] >= D) if (carry[i] > 0) a.push_back(f[i]); else b.push_back(f[i]); sort(a.begin(), a.end()); sort(b.begin(), b.end()); for (i = 0; i < ((int)b.size()); ++i) { sum += b[i]; if (sum > F) break; anscnt = i + 1; ansfuel = sum; } if (0 == ((int)a.size()) || a[0] > F) return; int C = 0; for (i = 0; i < N; ++i) { C += carry[i]; C = min(C, N); } sum = a[0]; i = 1; j = 0; while (1) { if (sum > F) break; int cnt = min(i + j + C, N); if (cnt > anscnt || (cnt == anscnt && sum < ansfuel)) { anscnt = cnt; ansfuel = sum; } if (i == a.size() && j == b.size()) break; if (i < a.size() && (j == b.size() || a[i] < b[j])) { sum += a[i]; i++; } else { sum += b[j]; j++; } } } int main() { int i; cin >> N >> D >> F; for (i = 0; i < N; ++i) cin >> carry[i] >> f[i] >> d[i]; calc(); cout << anscnt << << ansfuel << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { long long a, b, w, x, c; cin >> a >> b >> w >> x >> c; long long delta = c - a; if (delta <= 0) { cout << 0 << endl; } else { double k = (1.0 * delta * x - b) / (w - x); long long t = ceil(delta + k); cout << t << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; template <typename T> inline const T MAX(T a, T b) { return ((a) > (b) ? (a) : (b)); } template <typename T> inline const T MIN(T a, T b) { return ((a) > (b) ? (b) : (a)); } template <typename T> inline const T ABS(T a) { return (((a) > 0) ? (a) : (-(a))); } int main() { ios_base::sync_with_stdio(false); cin.tie(0); int a, b, c; cin >> a >> b >> c; cout << (a * b) + (b * c) + (c * a) - (a + b + c) + 1 << endl; return 0; }
#include <bits/stdc++.h> using namespace std; const int T = 41; const long long X[] = {0, 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023, 2047, 4095, 8191, 16383, 32767, 65535, 131071, 262143, 524287, 1048575, 2097151, 4194303, 8388607, 16777215, 33554431, 67108863, 134217727, 268435455, 536870911, 1073741823, 2147483647, 4294967295LL, 8589934591LL, 17179869183LL, 34359738367LL, 68719476735LL, 137438953471LL, 274877906943LL, 549755813887LL, 1099511627775LL}; const long long Y[] = {1, 2, 5, 11, 23, 47, 95, 191, 383, 767, 1535, 3071, 6143, 12287, 24575, 49151, 98303, 196607, 393215, 786431, 1572863, 3145727, 6291455, 12582911, 25165823, 50331647, 100663295, 201326591, 402653183, 805306367, 1610612735, 3221225471LL, 6442450943LL, 12884901887LL, 25769803775LL, 51539607551LL, 103079215103LL, 206158430207LL, 412316860415LL, 824633720831LL, 1649267441663LL}; const long long Z[] = {1, 3, 6, 12, 24, 48, 96, 192, 384, 768, 1536, 3072, 6144, 12288, 24576, 49152, 98304, 196608, 393216, 786432, 1572864, 3145728, 6291456, 12582912, 25165824, 50331648, 100663296, 201326592, 402653184, 805306368, 1610612736, 3221225472LL, 6442450944LL, 12884901888LL, 25769803776LL, 51539607552LL, 103079215104LL, 206158430208LL, 412316860416LL, 824633720832LL, 1649267441664LL}; int k; long long l, r; long long ans; int tot, anstot; long long q[10], ansq[10]; void search(long long now, long long res) { if (tot > k) return; if (now == r + 1) { if (tot && ans > res) { ans = res; anstot = tot; memcpy(ansq, q, sizeof(*q) * (tot + 1)); } return; } search(now + 1, res); q[++tot] = now; search(now + 1, res ^ now); q[tot--] = 0; } void bf() { ans = r + 1; search(l, 0); cout << ans << endl; cout << anstot << endl; for (int i = 1; i <= anstot; ++i) { cout << ansq[i]; if (i != anstot) cout << ; else cout << endl; } } int main() { cin >> l >> r >> k; if (r - l + 1 <= 8) { bf(); } else { if (k >= 4) { long long x = l; if (x & 1) ++x; cout << 0 << endl; cout << 4 << endl; cout << x << << x + 1 << << x + 2 << << x + 3 << endl; } else if (k == 1) { cout << l << endl; cout << 1 << endl; cout << l << endl; } else if (k == 2) { long long x = l; if (x & 1) ++x; cout << 1 << endl; cout << 2 << endl; cout << x << << x + 1 << endl; } else { bool flag = 0; for (int i = 0; i < T; ++i) { if (l <= X[i] && Z[i] <= r) { flag = 1; cout << 0 << endl; cout << 3 << endl; cout << X[i] << << Y[i] << << Z[i] << endl; break; } } if (!flag) { long long x = l; if (x & 1) ++x; cout << 1 << endl; cout << 2 << endl; cout << x << << x + 1 << endl; } } } return 0; }
#include <bits/stdc++.h> using namespace std; int size_n, size_m; set<int> result; vector<char> marks(0); vector<string> mrk(0); int main() { int ii, jj; string str; cin >> size_n >> size_m; marks.resize(size_m); mrk.resize(size_n); cin.ignore(); for (ii = 0; ii < size_m; ii++) marks[ii] = n ; for (ii = 0; ii < size_n; ii++) { getline(cin, str); mrk[ii] = str; for (jj = 0; jj < size_m; jj++) { if ((marks[jj] == n ) || (str[jj] >= marks[jj])) marks[jj] = str[jj]; } } for (ii = 0; ii < size_m; ii++) { for (jj = 0; jj < size_n; jj++) { if (mrk[jj][ii] == marks[ii]) result.insert(jj); } } cout << result.size() << endl; return 0; }
#include <bits/stdc++.h> using namespace std; struct Node { int key, priority; int add = 0; Node *left_child = nullptr, *right_child = nullptr; Node(const int key) : key(key), priority(rand()) {} void propagate() { key += add; if (left_child) left_child->add += add; if (right_child) right_child->add += add; add = 0; } }; int size(Node* const root) { return root ? 1 + size(root->left_child) + size(root->right_child) : 0; } pair<Node*, Node*> split(Node* const root, const int key) { if (!root) return {nullptr, nullptr}; else root->propagate(); Node *left, *right; if (key <= root->key) { right = root; tie(left, right->left_child) = split(root->left_child, key); } else { left = root; tie(left->right_child, right) = split(root->right_child, key); } return {left, right}; } Node* merge(Node* const left, Node* const right) { if (!left || !right) return left ? left : right; else left->propagate(), right->propagate(); if (left->priority < right->priority) { left->right_child = merge(left->right_child, right); return left; } else { right->left_child = merge(left, right->left_child); return right; } } void erase_min(Node*& root) { if (!root) return; else root->propagate(); if (!root->left_child) root = root->right_child; else erase_min(root->left_child); } int main() { ios::sync_with_stdio(false); Node* root = nullptr; int n; cin >> n; while (n--) { int l, r; cin >> l >> r; Node *t1, *t2, *t3; tie(t1, t2) = split(root, l); tie(t2, t3) = split(t2, r); if (t2) t2->add++; erase_min(t3); root = merge(merge(t1, new Node(l)), merge(t2, t3)); } cout << size(root) << endl; }
#include <bits/stdc++.h> using namespace std; const int mxN = 1e6 + 5; vector<int> adj[mxN]; int n, m, sz[mxN], dp[mxN], dpb[mxN], mn[mxN]; bool bad[mxN]; int ans = 1e9 + 7, V; void dfs1(int v, int par = -1) { sz[v] += bad[v]; for (auto to : adj[v]) { if (par != to) { dfs1(to, v); sz[v] += sz[to]; if (sz[to]) { dpb[v] += dpb[to] + 2; mn[v] = min(mn[v], (dp[to] + 1) - (dpb[to] + 2)); } } } dp[v] = dpb[v] + mn[v]; } void dfs2(int v, int par = -1) { if (dp[v] < ans) ans = dp[v], V = v; else if (dp[v] == ans) V = min(V, v); multiset<pair<int, int> > mt; for (auto to : adj[v]) { if (sz[to]) mt.insert({min(0, (dp[to] + 1) - (dpb[to] + 2)), to}); } for (auto to : adj[v]) { if (to != par) { int dpB = dp[v], dpbB = dpb[v]; int mnB = mn[to]; int subdpB = dp[to], subdpbB = dpb[to]; dp[v] -= mt.begin()->first; if (sz[to]) mt.erase({min(0, (dp[to] + 1) - (dpb[to] + 2)), to}); if (!mt.empty()) dp[v] += mt.begin()->first; if (sz[to]) { dp[v] -= dpb[to] + 2; dpb[v] -= dpb[to] + 2; } sz[v] -= sz[to]; sz[to] += sz[v]; if (sz[v]) { dpb[to] += dpb[v] + 2; dp[to] += dpb[v] + 2; if (mn[to] > (dp[v] + 1) - (dpb[v] + 2)) { dp[to] -= mn[to]; mn[to] = (dp[v] + 1) - (dpb[v] + 2); dp[to] += mn[to]; } } dfs2(to, v); sz[to] -= sz[v]; sz[v] += sz[to]; dp[v] = dpB, dpb[v] = dpbB; mn[to] = mnB; dp[to] = subdpB, dpb[to] = subdpbB; if (sz[to]) mt.insert({min(0, (dp[to] + 1) - (dpb[to] + 2)), to}); } } } int main() { ios ::sync_with_stdio(false), cin.tie(nullptr); cin >> n >> m; for (int i = 1; i < n; ++i) { int u, v; cin >> u >> v; adj[u].push_back(v); adj[v].push_back(u); } for (int i = 1; i <= m; ++i) { int v; cin >> v; bad[v] = 1; } dfs1(1); dfs2(1); cout << V << n << ans; return 0; }
#include <bits/stdc++.h> #pragma GCC optimize( Ofast ) using namespace std; const int inf = 1000000010; const int MAXN = 300010; struct edge { int u, v, c, t, res; } E[MAXN]; int n, m, k, u, v, x, y, t, a, b, N; int comp[MAXN * 2]; bool mark[MAXN * 2]; int del[MAXN * 2]; int del2[MAXN * 2]; unordered_map<int, int> deg[MAXN]; unordered_map<int, vector<int>> GRAPH[MAXN]; vector<int> GRAPH2[MAXN]; vector<int> G[2 * MAXN]; vector<int> GR[2 * MAXN]; vector<int> topol; void add_edge(int x, int y) { G[x].push_back(y); GR[y].push_back(x); } void add(int x, int y) { add_edge(x ^ 1, y); add_edge(y ^ 1, x); } void add2(int x, int y) { add_edge(x ^ 1, y); add_edge(y ^ 1, x); del[x ^ 1]++; del[y ^ 1]++; del2[y]++; del2[x]++; } void dfs1(int node) { mark[node] = 1; for (int v : G[node]) if (!mark[v]) dfs1(v); topol.push_back(node); } void dfs2(int node, int id) { comp[node] = id; for (int v : GR[node]) if (!comp[v]) dfs2(v, id); } bool check(int T) { for (int i = 0; i < 2 * MAXN; i++) { while (del[i]) { G[i].pop_back(); del[i]--; } while (del2[i]) { GR[i].pop_back(); del2[i]--; } } for (int i = 1; i <= m; i++) if (E[i].t > T) add2(2 * i ^ 1, 2 * i ^ 1); memset(comp, 0, sizeof(comp)); memset(mark, 0, sizeof(mark)); topol.clear(); for (int i = 2; i < 2 * MAXN; i++) if (!mark[i]) dfs1(i); reverse(topol.begin(), topol.end()); int id = 1; for (int v : topol) if (!comp[v]) dfs2(v, id++); for (int i = 2; i < 2 * N + 2; i++) if (comp[i] == comp[i ^ 1]) return 0; for (int i = 1; i <= m; i++) E[i].res = (comp[2 * i] > comp[2 * i + 1]); return 1; } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); cin >> n >> m; for (int i = 1; i <= m; i++) { cin >> u >> v >> x >> y; E[i] = {u, v, x, y}; deg[u][x]++; deg[v][x]++; GRAPH[u][x].push_back(i); GRAPH[v][x].push_back(i); GRAPH2[u].push_back(i); GRAPH2[v].push_back(i); } for (int i = 1; i <= n; i++) for (pair<int, int> p : deg[i]) if (p.second > 2) return cout << No << n , 0; for (int i = 1; i <= n; i++) for (auto it : GRAPH[i]) if (it.second.size() == 2) add(it.second[0] * 2, it.second[1] * 2); N = m; for (int i = 1; i <= n; i++) if (GRAPH2[i].size() >= 2) { k = GRAPH2[i].size(); for (int j = 0; j < k; j++) { int a = GRAPH2[i][j]; add(2 * a ^ 1, 2 * (++N)); if (j) add(2 * (N - 1) ^ 1, 2 * N); if (j) add(2 * a ^ 1, 2 * (N - 1) ^ 1); } } int dwn = -1, up = inf; while (up - dwn > 1) { int mid = (dwn + up) / 2; if (check(mid)) up = mid; else dwn = mid; } if (!check(up)) return cout << No << n , 0; vector<int> out; for (int i = 1; i <= m; i++) if (E[i].res) out.push_back(i); cout << Yes n << up << << out.size() << n ; for (int i : out) cout << i << ; cout << n ; return 0; }
#include <bits/stdc++.h> using namespace std; const int MAX = 100005; bool isprime[MAX]; int a[MAX]; int ans[100005]; vector<int> factor[MAX]; void get_prime() { memset(isprime, 1, sizeof(isprime)); for (int i = 2; i < MAX; i++) { if (isprime[i]) { factor[i].push_back(i); for (int j = 2 * i; j < MAX; j += i) { factor[j].push_back(i); isprime[j] = 0; } } } } int main() { get_prime(); int n; while (cin >> n) { memset(ans, 0, sizeof(ans)); for (int i = 0; i < n; i++) cin >> a[i]; for (int i = 0; i < n; i++) { int m = 0; for (int j = 0; j < factor[a[i]].size(); j++) m = max(ans[factor[a[i]][j]] + 1, m); for (int j = 0; j < factor[a[i]].size(); j++) ans[factor[a[i]][j]] = m; } int M = 1; for (int i = 0; i < 10000; i++) M = max(M, ans[i]); cout << M << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 2e6 + 10; const int MOD = 1e9 + 7; bool mark[N]; vector<int> ps, corporator[N]; int primeMul[N], primeCnt[N], nthPower[N], b[N], n, k; int _sum(int, int); int _mul(int, int); int _pow(int, int); void _push(int&, int); int main() { cin >> n >> k; fill(primeMul, primeMul + k + 1, 1); for (int i = 1; i <= k; i++) { nthPower[i] = _pow(i, n); if (i > 1 && !mark[i]) { for (int j = i; j <= k; j += i) { mark[j] = true; primeMul[j] *= i; primeCnt[j]++; } } if (primeMul[i] == i) ps.push_back(i); } for (int i : ps) for (int j = i; j <= k; j += i) corporator[j].push_back(i); b[1] = nthPower[1]; int ans = b[1] ^ 1; for (int i = 2; i <= k; i++) { b[i] = b[i - 1]; for (int c : corporator[i]) { int v = _sum(MOD - nthPower[(i - 1) / c], nthPower[i / c]); _push(b[i], primeCnt[c] & 1 ? MOD - v : v); } _push(ans, b[i] ^ i); } cout << ans << endl; } int _sum(int a, int b) { return a + b - (a + b >= MOD ? MOD : 0); } int _mul(int a, int b) { return 1LL * a * b % MOD; } int _pow(int a, int b) { if (!b) return 1; int res = _pow(a, b >> 1); res = _mul(res, res); if (b & 1) res = _mul(res, a); return res; } void _push(int& a, int b) { a = _sum(a, b); }
#include <bits/stdc++.h> using namespace std; const int inf = 0x3f3f3f3f, maxn = 100007, mod = 1e9 + 7; const long long linf = 0x3f3f3f3f3f3f3f3fLL; const long long P = 19260817; string str; string s; bool flag; int main() { cin >> str; for (int i = 1; i <= 5; i++) { cin >> s; if (s[0] == str[0] || s[1] == str[1]) flag = true; } if (flag) { printf( YES ); } else { printf( NO ); } return 0; }
#include <bits/stdc++.h> using namespace std; const int maxn = 1005; int a[maxn]; int ans[maxn << 1]; int vis1[maxn], vis[maxn]; int main() { int T; scanf( %d , &T); while (T--) { int n; scanf( %d , &n); int res = n; int p = 0; int mex; for (int i = 1; i <= n; i++) { scanf( %d , &a[i]); vis1[i] = 0; } while (res > 0) { for (int i = 0; i <= n; i++) vis[i] = 0; for (int i = 1; i <= n; i++) vis[a[i]] = 1; for (int i = 0;; i++) { if (!vis[i]) { mex = i; break; } } if (mex == 0) { for (int i = 1; i <= n; i++) { if (!vis1[i]) { a[i] = mex; ans[++p] = i; break; } } } else { ans[++p] = mex; a[mex] = mex; vis1[mex] = 1; res--; } } printf( %d n , p); for (int i = 1; i <= p; i++) printf( %d , ans[i]); printf( n ); } return 0; }
#include <bits/stdc++.h> using namespace std; const int INF = 0x3f3f3f3f; const int maxn = 1e3 + 10, maxm = 1e6 + 5, maxc = 26; long long sum = 0, mi = 0, ma = 0; int main() { int n, w, num; scanf( %d%d , &n, &w); for (int i = 0; i < n; i++) { scanf( %d , &num); sum += num; mi = min(mi, sum); ma = max(ma, sum); } printf( %I64d n , w - ma + mi + 1 <= 0 ? 0 : w - ma + mi + 1); return 0; }
#include <bits/stdc++.h> using namespace std; #pragma comment(linker, /STACK:36777216 ) template <class T> void chmax(T& l, const T r) { l = max(l, r); } template <class T> void chmin(T& l, const T r) { l = min(l, r); } void reader(int& x) { int k, m = 0; x = 0; for (;;) { (k) = getchar_unlocked(); if (k == - ) { m = 1; break; } if ( 0 <= k && k <= 9 ) { x = k - 0 ; break; } } for (;;) { (k) = getchar_unlocked(); if (k < 0 || k > 9 ) break; x = x * 10 + k - 0 ; } if (m) x = -x; } void reader(long long& x) { int k, m = 0; x = 0; for (;;) { (k) = getchar_unlocked(); if (k == - ) { m = 1; break; } if ( 0 <= k && k <= 9 ) { x = k - 0 ; break; } } for (;;) { (k) = getchar_unlocked(); if (k < 0 || k > 9 ) break; x = x * 10 + k - 0 ; } if (m) x = -x; } int reader(char c[]) { int i, s = 0; for (;;) { (i) = getchar_unlocked(); if (i != && i != n && i != r && i != t && i != EOF) break; } c[s++] = i; for (;;) { (i) = getchar_unlocked(); if (i == || i == n || i == r || i == t || i == EOF) break; c[s++] = i; } c[s] = 0 ; return s; } template <class T, class S> void reader(T& x, S& y) { reader(x); reader(y); } template <class T, class S, class U> void reader(T& x, S& y, U& z) { reader(x); reader(y); reader(z); } template <class T, class S, class U, class V> void reader(T& x, S& y, U& z, V& w) { reader(x); reader(y); reader(z); reader(w); } void writer(int x, char c) { int s = 0, m = 0; char f[10]; if (x < 0) m = 1, x = -x; while (x) f[s++] = x % 10, x /= 10; if (!s) f[s++] = 0; if (m) putchar_unlocked( - ); while (s--) putchar_unlocked(f[s] + 0 ); putchar_unlocked(c); } void writer(long long x, char c) { int s = 0, m = 0; char f[20]; if (x < 0) m = 1, x = -x; while (x) f[s++] = x % 10, x /= 10; if (!s) f[s++] = 0; if (m) putchar_unlocked( - ); while (s--) putchar_unlocked(f[s] + 0 ); putchar_unlocked(c); } void writer(const char c[]) { int i; for (i = 0; c[i] != 0 ; i++) putchar_unlocked(c[i]); } void writer(const char x[], char c) { int i; for (i = 0; x[i] != 0 ; i++) putchar_unlocked(x[i]); putchar_unlocked(c); } template <class T> void writerLn(T x) { writer(x, n ); } template <class T, class S> void writerLn(T x, S y) { writer(x, ); writer(y, n ); } template <class T, class S, class U> void writerLn(T x, S y, U z) { writer(x, ); writer(y, ); writer(z, n ); } template <class T> void writerArr(T x[], int n) { if (!n) { putchar_unlocked( n ); return; } for (int i = 0; i < (n - 1); i++) writer(x[i], ); writer(x[n - 1], n ); } template <class T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; } template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; } template <class T> T extgcd(T a, T b, T& x, T& y) { for (T u = y = 1, v = x = 0; a;) { T q = b / a; swap(x -= q * u, u); swap(y -= q * v, v); swap(b -= q * a, a); } return b; } template <class T> T mod_inv(T a, T m) { T x, y; extgcd(a, m, x, y); return (m + x % m) % m; } template <class T> T CRT(T r1, T m1, T r2, T m2) { T a1, a2; extgcd(m1, m2, a1, a2); T ret = (m1 * a1 * r2 + m2 * a2 * r1) % (m1 * m2); return ret < 0 ? ret + m1 * m2 : ret; } int memo[100][100]; int _k; int dfs(int a, int b, int k) { if (memo[a][b] != -1) return memo[a][b]; if (k == 0) { if (_k % 2 == 0) return b % 2 == 1; else return b % 2 == 0; } int val = 0; if (a != 0) val = max(val, dfs(a - 1, b, k - 1) ^ 1); if (b != 0) val = max(val, dfs(a, b - 1, k - 1) ^ 1); return memo[a][b] = val; } int solve_dfs(int e, int o, int m) { memset(memo, -1, sizeof(memo)); _k = m; int ans = dfs(e, o, m); return ans; } int solve(int e, int o, int m) { if (m == 0) return o % 2; if (o == 0) return 0; if (e + o + 1 == m) return 0; if (m > o * 2) return 0; if (m < e * 2) return m % 2; else return (m + o + e) % 2; } void test() { for (int e = 0; e < (10); e++) { for (int o = 0; o < (10); o++) { printf( %d %d : , e, o); for (int k = 0; k < (e + o + 1); k++) { int x = solve_dfs(e, o, k); printf( %d , x); int y = solve(e, o, k); if (x != y) { cout << ? ; } } puts( ); } } } int main() { int n, m; cin >> n >> m; int e = 0, o = 0; for (int i = 0; i < (n); i++) { int x; reader(x); if (x % 2 == 0) e++; else o++; } m = n - m; int ans = solve(e, o, m); if (ans) puts( Stannis ); else puts( Daenerys ); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; long long a[n]; for (int i = 0; i < n; i++) cin >> a[i]; sort(a, a + n); long long sum = 0; for (int i = 0; i < n / 2; i++) { sum += (a[i] + a[n - i - 1]) * (a[i] + a[n - i - 1]); } cout << sum << endl; return 0; }
#include <bits/stdc++.h> using std::cin; using std::cout; const int N = 1e5 + 1; int r, a, b, m, las[N]; int main() { cin >> a >> b >> m >> r; memset(las, -1, sizeof las); las[r] = 0; for (int i = 1;; ++i) { r = (a * r + b) % m; if (~las[r]) { cout << i - las[r]; return 0; } las[r] = i; } return 0; }
#include <bits/stdc++.h> using namespace std; int n; string s[80000]; unordered_map<string, int> substrings; int main(void) { cin >> n; for (int i = 0; i < n; ++i) { cin >> s[i]; unordered_map<string, bool> used; for (int j = 1; j <= s[i].size(); ++j) { for (int k = 0; k + j <= s[i].size(); ++k) { string substring = s[i].substr(k, j); if (used.find(substring) == used.end()) { used[substring] = true; if (substrings.find(substring) == substrings.end()) { substrings[substring] = 1; } else { substrings[substring] += 1; } } } } } for (int i = 0; i < n; ++i) { for (int j = 1; j <= s[i].size(); ++j) { for (int k = 0; k + j <= s[i].size(); ++k) { if (substrings[s[i].substr(k, j)] == 1) { cout << s[i].substr(k, j) << endl; goto van; } } } van:; } return 0; }
#include <bits/stdc++.h> using namespace std; vector<int> g[3010]; bool maps[3010][3010]; int main() { int n, m; scanf( %d%d , &n, &m); for (int i = 0; i < m; i++) { int u, v; scanf( %d%d , &u, &v); g[u].push_back(v); maps[u][v] = 1; } int ans = 0; for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { if (i == j) continue; int res = 0; for (int k = 0; k < g[i].size(); k++) { int v = g[i][k]; if (maps[v][j]) res++; } ans += res * (res - 1) / 2; } } printf( %d n , ans); return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 1e5 + 7, M = 1e6 + 7, fo = 1e6; template <class T> inline void read(T &re) { char ch; while ((ch = getchar()) < 0 || ch > 9 ) ; re = ch - 48; while ((ch = getchar()) >= 0 && ch <= 9 ) re = (re << 3) + (re << 1) + ch - 48; } int num[N], tim[N], fa[N], tot, hd[N]; long long f[N]; struct road { int to, nxt, val; } r[N]; struct TreeStructure { long long sum[M]; inline void update(int x, long long ad) { for (register int i = x; i <= fo; i += i & -i) sum[i] += ad; } inline long long query(int x) { long long ret = 0; for (register int i = x; i; i -= i & -i) ret += sum[i]; return ret; } } st, sc; inline void ade(int x, int y, int z) { r[++tot].to = y; r[tot].nxt = hd[x]; r[tot].val = z; hd[x] = tot; } inline void DpOnTree(int x, long long t) { st.update(tim[x], 1ll * tim[x] * num[x]); sc.update(tim[x], num[x]); int L = 0, R = fo, mid, ans; while (L <= R) { mid = (L + R) >> 1; if (st.query(mid) <= t) { ans = mid; L = mid + 1; } else R = mid - 1; } f[x] = sc.query(ans); if (ans != fo) f[x] += (t - st.query(ans)) / (ans + 1); long long mx = 0, mx2 = 0; for (register int i = hd[x], u; i; i = r[i].nxt) { u = r[i].to; if (t - 2 * r[i].val < 0) continue; DpOnTree(u, t - 2 * r[i].val); if (f[u] >= mx) mx2 = mx, mx = f[u]; else if (f[u] > mx2) mx2 = f[u]; } if (x != 1) f[x] = max(f[x], mx2); else f[x] = max(f[x], mx); st.update(tim[x], -1ll * tim[x] * num[x]); sc.update(tim[x], -num[x]); } int main() { int n, w; long long T; read(n); read(T); for (register int i = 1; i <= n; ++i) read(num[i]); for (register int i = 1; i <= n; ++i) read(tim[i]); for (register int i = 2; i <= n; ++i) { read(fa[i]); read(w); ade(fa[i], i, w); } DpOnTree(1, T); printf( %lld , f[1]); }
#include <bits/stdc++.h> using namespace std; bool debug = false; int n, m, k; int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0}; struct uz { long long k, l, id, cnt; long long x, y, m; int i = 1; void add() { l = (l * x + y) % m; i++; } } u[5035]; vector<pair<long long, long long>> ans; int main() { scanf( %d , &n); long long aa = 0, sumk = 0; for (int(i) = 0; (i) < (int)(n); (i)++) { long long tmp = 0; scanf( %lld%lld%lld%lld%lld , &u[i].k, &u[i].l, &u[i].x, &u[i].y, &u[i].m); sumk += u[i].k; long long last = u[i].l; for (int j = 2; j <= u[i].k; j++) { long long cur = (last * u[i].x + u[i].y) % u[i].m; if (last > cur) tmp++; last = cur; } aa = max(aa, tmp); } printf( %lld n , aa); if (sumk > 200000) return 0; while (1) { long long start = ans.size(); for (int(i) = 0; (i) < (int)(n); (i)++) { while (u[i].i <= u[i].k) { ans.push_back({u[i].l, i}); u[i].add(); if (ans.back().first > u[i].l) break; } } if (start == ans.size()) break; sort(ans.begin() + start, ans.end()); if (start != 0) aa++; } for (auto p : ans) printf( %lld %lld n , p.first, p.second + 1); return 0; }
#include <bits/stdc++.h> int main() { int n; scanf( %d , &n); char arr[n + 1]; scanf( %s , arr); int ans[26]; for (int m = 0; m < 26; m++) ans[m] = 0; for (int j = 0; j < n; j++) { int k = arr[j]; if (k > 64 && k < 91) ans[k - 65] = 1; else ans[k - 97] = 1; } int sum = 0; for (int g = 0; g < 26; g++) sum = sum + ans[g]; if (sum == 26) printf( YES n ); else printf( NO n ); }
#include <bits/stdc++.h> #pragma warning(disable : 4996) using namespace std; constexpr int Dir4[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}}; constexpr int Dir8[8][2] = {{-1, -1}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 1}}; constexpr double EPS = 1e-8; const double PI = acos(-1); using int16 = short; using uint16 = unsigned short; using uint = unsigned int; using int64 = long long; using uint64 = unsigned long long; using pii = pair<int, int>; auto Equal = [](double a, double b) { return fabs(a - b) < EPS; }; constexpr int MAXN = 1500; int n, k; string s[MAXN + 1]; unordered_map<string, int64> UM; unordered_map<char, int> convert; int main() { convert[ S ] = 1; convert[ E ] = 2; convert[ T ] = 4; convert[1] = S ; convert[2] = E ; convert[4] = T ; ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); int64 ans = 0; cin >> n >> k; for (int i = (0); i < (n); ++i) { cin >> s[i]; ++UM[s[i]]; } for (int i = (0); i < (n); ++i) { for (int j = (i + 1); j < (n); ++j) { string tmp = ; for (int k = (0); k < (s[i].size()); ++k) if (s[i][k] == s[j][k]) tmp += s[i][k]; else { int x = convert[s[i][k]] | convert[s[j][k]]; tmp += convert[(~x) & 7]; } ans += UM[tmp]; } } cout << ans / 3; return 0; }
#include <bits/stdc++.h> using namespace std; template <typename T> class flow_graph { public: static constexpr T eps = (T)1e-9; struct edge { int from; int to; T c; T f; }; vector<vector<int>> g; vector<edge> edges; int n; int st; int fin; T flow; flow_graph(int _n, int _st, int _fin) : n(_n), st(_st), fin(_fin) { assert(0 <= st && st < n && 0 <= fin && fin < n && st != fin); g.resize(n); flow = 0; } void clear_flow() { for (const edge &e : edges) { e.f = 0; } flow = 0; } int add(int from, int to, T forward_cap, T backward_cap) { assert(0 <= from && from < n && 0 <= to && to < n); int id = (int)edges.size(); g[from].push_back(id); edges.push_back({from, to, forward_cap, 0}); g[to].push_back(id + 1); edges.push_back({to, from, backward_cap, 0}); return id; } }; template <typename T> class dinic { public: flow_graph<T> &g; vector<int> ptr; vector<int> d; vector<int> q; dinic(flow_graph<T> &_g) : g(_g) { ptr.resize(g.n); d.resize(g.n); q.resize(g.n); } bool expath() { fill(d.begin(), d.end(), -1); q[0] = g.fin; d[g.fin] = 0; int beg = 0, end = 1; while (beg < end) { int i = q[beg++]; for (int id : g.g[i]) { const auto &e = g.edges[id]; const auto &back = g.edges[id ^ 1]; if (back.c - back.f > g.eps && d[e.to] == -1) { d[e.to] = d[i] + 1; if (e.to == g.st) { return true; } q[end++] = e.to; } } } return false; } T dfs(int v, T w) { if (v == g.fin) { return w; } int &j = ptr[v]; while (j >= 0) { int id = g.g[v][j]; const auto &e = g.edges[id]; if (e.c - e.f > g.eps && d[e.to] == d[v] - 1) { T t = dfs(e.to, min(e.c - e.f, w)); if (t > g.eps) { g.edges[id].f += t; g.edges[id ^ 1].f -= t; return t; } } j--; } return 0; } T max_flow() { while (expath()) { for (int i = 0; i < g.n; i++) { ptr[i] = (int)g.g[i].size() - 1; } T big_add = 0; while (true) { T add = dfs(g.st, numeric_limits<T>::max()); if (add <= g.eps) { break; } big_add += add; } if (big_add <= g.eps) { break; } g.flow += big_add; } return g.flow; } vector<bool> min_cut() { max_flow(); vector<bool> ret(g.n); for (int i = 0; i < g.n; i++) { ret[i] = (d[i] != -1); } return ret; } }; template <typename T> void debug_out(T t) { cerr << t; } template <typename A, typename B> void debug_out(pair<A, B> u) { cerr << ( << u.first << << u.second << ) ; } template <typename T> void debug_out(vector<T> t) { int sz = t.size(); for (int i = 0; i < sz; i++) { debug_out(t[i]); if (i != sz - 1) cerr << , ; } } template <typename T> void debug_out(vector<vector<T>> t) { int sz = t.size(); for (int i = 0; i < sz; i++) { debug_out(t[i]); if (i != sz - 1) cerr << endl; } } int n, m, s, t; struct edge { int u, v, c, f; int id; edge(){}; edge(int _u, int _v, int _c, int _f, int _id) : u(_u), v(_v), c(_c), f(_f), id(_id){}; }; int main() { cin >> n >> m >> s >> t; s--; t--; flow_graph<int> st(n, s, t); vector<edge> res; vector<vector<int>> edges(n); vector<vector<int>> sp(n); vector<int> rev(m); const int inf = 1e9; for (int i = 0; i < m; i++) { int u, v, g; cin >> u >> v >> g; u--; v--; res.emplace_back(u, v, 0, 0, res.size()); if (g) { edges[u].push_back(res.size() - 1); sp[v].push_back(res.size() - 1); } rev[i] = g; st.add(u, v, (g ? 1 : inf), (g ? inf : 0)); } dinic<int> g(st); vector<bool> ret = g.min_cut(); vector<int> sat(m); int cnt = 0; for (edge e : res) { if (!ret[e.u] && ret[e.v]) { sat[e.id] = 1; cnt++; } } cout << cnt << endl; vector<vector<int>> stt(n), fin(n); vector<int> cur; vector<int> alive(n); function<void(int)> dfs = [&](int v) { alive[v] = 1; stt[v] = cur; for (auto i : edges[v]) { int u = res[i].v; if (alive[u]) continue; cur.push_back(i); dfs(u); cur.pop_back(); } }; for (int rot = 0; rot < 2; rot++) { fill(alive.begin(), alive.end(), 0); dfs(rot ? t : s); swap(stt, fin); for (auto &i : res) swap(i.u, i.v); swap(edges, sp); } for (int i = 0; i < m; i++) { int u = res[i].u, v = res[i].v; if (!res[i].f && rev[res[i].id]) { for (auto j : stt[u]) res[j].f++; for (auto j : fin[v]) res[j].f++; res[i].f++; } } for (auto &i : res) { if (sat[i.id]) { i.c = i.f; } else i.c = inf; } for (auto i : res) { cout << i.f << << i.c << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; const int INF = 1e9; const int N = 1005; int dp[N][2][N], n, T; struct node { int c, t; node(int c = 0, int t = 0) : c(c), t(t) {} void read() { scanf( %d%d , &t, &c); } bool operator<(const node &b) const { return t > b.t; } } a[N]; int main() { int cur, nxt, ans, val; scanf( %d%d , &n, &T); ans = 0; for (int i = 1; i <= n; i++) { a[i].read(); ans = max(ans, a[i].c); } sort(a + 1, a + n + 1); cur = 0; nxt = 1; memset(dp, 0xc0, sizeof(dp)); dp[1][0][0] = 0; for (int j = 0; j <= T; j++) { for (int i = 0; i <= n; i++) for (int t = 0; t <= n; t++) dp[i][nxt][t] = -INF - 5; for (int i = n; i >= 0; i--) for (int t = 0; t <= n; t++) { val = dp[i][cur][t]; if (val < -INF) continue; ans = max(ans, val); if (t < n) dp[i][cur][t + 1] = max(dp[i][cur][t + 1], val); if (j < T) dp[min(n, i * 2)][nxt][t] = max(dp[min(n, i * 2)][nxt][t], val); if (i > 0 && a[t].t + j <= T) { dp[i - 1][cur][t + 1] = max(dp[i - 1][cur][t + 1], val + a[t].c); ans = max(ans, val + a[t].c); } } swap(cur, nxt); } printf( %d n , ans); return 0; }
#include <bits/stdc++.h> using namespace std; int a[2000]; string s; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); ; int t; cin >> t; while (t--) { int n; cin >> n; for (int i = 1; i <= n; ++i) cin >> a[i]; s = string(60, a ); cout << s << n ; for (int i = 1; i <= n; ++i) { s[a[i]] = s[a[i]] + 1; if (s[a[i]] > z ) s[a[i]] = a ; cout << s << n ; } } return 0; }
#include <bits/stdc++.h> using namespace std; struct cs { int to, next; } a[200001]; int aa[400001], head[100001], sum[100001]; bool vi[100001], c[100001]; int n, m, z, y, x, ans, ll, S; void init(int x, int y) { a[++ll].to = y; a[ll].next = head[x]; head[x] = ll; } void dfs(int x, int y) { vi[x] = 1; aa[++ans] = x; sum[x]++; for (int k = head[x]; k; k = a[k].next) if (!vi[a[k].to]) { dfs(a[k].to, x); aa[++ans] = x; sum[x]++; } if (bool(sum[x] & 1) != c[x]) { aa[++ans] = y; sum[y]++; aa[++ans] = x; sum[x]++; } } int main() { scanf( %d%d , &n, &m); while (m--) { scanf( %d%d , &x, &y); init(x, y); init(y, x); } for (int i = 1; i <= n; i++) { cin >> c[i]; if (c[i]) S = i; } if (S) { dfs(S, -1); for (int i = 1; i <= n; i++) if (!vi[i] && c[i]) { printf( -1 ); return 0; } } if (ans > 1 && aa[ans - 1] == -1) ans -= 3; printf( %d n , ans); for (int i = 1; i <= ans; i++) printf( %d , aa[i]); }
#include <bits/stdc++.h> using namespace std; int main() { long n, i; cin >> n; long long a[n]; for (i = 0; i < n; i++) { cin >> a[i]; } if (n < 3) { cout << 0 << endl; for (i = 0; i < n; i++) cout << a[i] << ; } else { sort(a, a + n); long l = 0, r = n - 1; cout << n / 2 - (n % 2 == 0) << endl; for (i = 0; i < n; i++) { if (i % 2 == 0) { cout << a[r] << ; r--; } else { cout << a[l] << ; l++; } } } }
#include <bits/stdc++.h> using namespace std; long long n, m; vector<pair<long long, long long> > a; vector<pair<long long, long long> > fact(2, {1, 0}); long long pow2(long long i, long long m) { long long r = 1, a = 2, b = i; while (b != 0) { if (b % 2 == 1) { r = (r * a) % m; b--; } else { a = (a * a) % m; b /= 2; } } return r; } bool fun(pair<long long, long long> x, pair<long long, long long> y) { if (x.first == y.first) { return x.second < y.second; } return x.first < y.first; } int main() { cin >> n; long long tmp; for (int i = 0; i < n; i++) { cin >> tmp; a.push_back({tmp, i}); } for (int i = 0; i < n; i++) { cin >> tmp; a.push_back({tmp, i}); } sort(a.begin(), a.end(), fun); cin >> m; for (int i = 2; i <= 2 * n + 3; i++) { int r = i, ct = 0; while (r % 2 == 0) { r /= 2; ct++; } pair<long long, long long> p = fact[i - 1]; fact.push_back({(r * p.first) % m, p.second + ct}); } long long ans = 1; long long curr = 1, ct = 0; for (int i = 1; i < a.size(); i++) { if (a[i].first == a[i - 1].first) { curr++; if (a[i].second == a[i - 1].second) { ct++; } } else { ans = (ans * fact[curr].first) % m; ans = (ans * pow2(fact[curr].second - ct, m)) % m; curr = 1; ct = 0; } } ans = (ans * fact[curr].first) % m; ans = (ans * pow2(fact[curr].second - ct, m)) % m; curr = 1; ct = 0; cout << ans << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int n; char s[105]; cin >> n; cin >> s; vector<int> v; v.clear(); int cnt = 0; for (int i = 0; i < n; i++) { if (s[i] == B ) { ++cnt; } else { if (cnt != 0) { v.push_back(cnt); cnt = 0; } } } if (cnt != 0) { v.push_back(cnt); cnt = 0; } cout << v.size() << endl; for (int i = 0; i < v.size(); i++) cout << v[i] << ; cout << endl; return 0; }
#include <bits/stdc++.h> using namespace std; const int MAXN = 1; const long long MOD = 1; long long _gcd(long long a, long long b) { if (b == 0) return a; return _gcd(b, a % b); } long long gcd(long long a, long long b) { a = abs(a), b = abs(b); if (a < b) swap(a, b); return _gcd(a, b); } long long qpow(long long a, long long n) { long long rt = 1; while (n) { if (n & 1) rt = (rt * a) % MOD; a = a * a % MOD; n >>= 1; } return rt; } long long factor[MAXN]; long long inv[MAXN]; void cal_factor() { factor[0] = 1; for (int u = 1; u < MAXN; u++) { factor[u] = (factor[u - 1] * u) % MOD; } } void cal_factor_inv() { inv[0] = 1; inv[MAXN - 1] = qpow(factor[MAXN - 1], MOD - 2); for (int u = MAXN - 2; u >= 1; u--) { inv[u] = inv[u + 1] * (u + 1) % MOD; } } void init_factor() { cal_factor(); cal_factor_inv(); } long long C(long long n, long long k) { if (n < k) return 0; return factor[n] * qpow(factor[n - k], MOD - 2) % MOD * qpow(factor[k], MOD - 2) % MOD; } void solve() { int n; cin >> n; int mx = 0; int g = -1; for (int u = 0; u < n; u++) { int t; cin >> t; if (g == -1) g = t; else g = gcd(g, t); mx = max(t, mx); } if ((mx / g - n) % 2) { cout << Alice n ; } else { cout << Bob n ; } } int main() { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); solve(); }
#include <bits/stdc++.h> using namespace std; const int M = (int)1e9 + 7; const int N = (int)2e5 + 5; struct trio { long long a; long long b; long long c; }; trio dp[2][N]; long long ps[N]; int main() { cout.precision(15); cout.setf(ios::fixed); int n, k; int i; cin >> n >> k; vector<int> v(n); for (i = 0; i < n; i++) { cin >> v[i]; if (i == 0) ps[i] = v[i]; else ps[i] = ps[i - 1] + v[i]; } long long ma = 0, p1, p2; for (i = k - 1; i < n; i++) { dp[0][i].a = ps[i] - (i >= k ? ps[i - k] : 0); dp[0][i].b = i; if (i >= k) if (dp[0][i - 1].a >= dp[0][i].a) { dp[0][i].a = dp[0][i - 1].a; dp[0][i].b = dp[0][i - 1].b; } if (i >= (2 * k - 1)) { dp[1][i].a = dp[0][i - k].a + ps[i] - (i >= k ? ps[i - k] : 0); dp[1][i].b = dp[0][i - k].b; } if (dp[1][i].a > ma) { ma = dp[1][i].a; p1 = dp[1][i].b; p2 = i; } } cout << p1 + 2 - k << << p2 + 2 - k << n ; }
#include <bits/stdc++.h> using namespace std; int main() { int n, k, t, s; cin >> n >> k >> t; s = n * k * t / 100; for (int i = 0; i < n; i++) { if (s >= k) { cout << k << ; s -= k; } else if (s > 0) { cout << s << ; s = 0; } else cout << 0 ; } return 0; }
#include <bits/stdc++.h> using namespace std; const int maxn = 5e5 + 100; int a[maxn]; map<pair<int, int>, bool> mp; int main() { ios::sync_with_stdio(false); int N; cin >> N; int M; cin >> M; for (int i = 1; i <= N; i++) cin >> a[i]; for (int i = 1; i <= M; i++) { int x; int y; cin >> x >> y; mp[pair<int, int>(x, y)] = 1; } int pos = N; for (int i = N - 1; i >= 1; i--) { if (mp[pair<int, int>(a[i], a[pos])] == true) { int j; for (j = i; j < pos; j++) { if (mp[pair<int, int>(a[j], a[j + 1])]) swap(a[j], a[j + 1]); else break; } if (j == pos) pos -= 1; } } cout << N - pos; }
#include <bits/stdc++.h> using namespace std; const long long mod = 1e9 + 7; struct SquareMatrix { SquareMatrix(int _n) : n(_n) { data.assign(_n, vector<long long>(_n, 0)); } vector<long long> &operator[](int i) { return data[i]; } const vector<long long> &operator[](int i) const { return data[i]; } SquareMatrix operator*(const SquareMatrix &other) const { assert(n == other.n); SquareMatrix ret(n); for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) { for (int k = 0; k < n; ++k) { ret[i][j] = (ret[i][j] + data[i][k] * other[k][j]) % mod; } } } return ret; } vector<vector<long long>> data; int n; }; SquareMatrix quickpower(SquareMatrix m, long long p) { int n = m.n; SquareMatrix ret(n); for (int i = 0; i < n; ++i) ret[i][i] = 1; while (p) { if (p & 1) { ret = ret * m; } m = m * m; p >>= 1; } return ret; } int fun(int x) { int res = 0; while (x) { res += x % 2; x /= 2; } return res; } int main() { long long n, k, m; scanf( %lld %lld %lld , &n, &k, &m); long long num = 1 << m; SquareMatrix M(num * (k + 1)); for (int i = 0; i < num * (k + 1); i++) { int x = i % (k + 1); int y = i / (k + 1); int x1 = x; int y1 = (y * 2) % num; int x2 = x + 1; int y2 = (y * 2) % num + 1; M[i][y1 * (k + 1) + x1] += 1; if (x2 <= k) M[i][y2 * (k + 1) + x2] += fun(y) + 1ll; } M = quickpower(M, n); long long ans = 0; for (int i = 0; i < num; i++) ans = (ans + M[0][i * (k + 1) + k]) % mod; cout << ans << endl; return 0; }
#include <bits/stdc++.h> using namespace std; const int MAXN = 300000000; const int BLOCK = 100000; const int NUM = 3000; const int num[] = { 4784, 4194, 4003, 3920, 3831, 3791, 3726, 3667, 3669, 3591, 3642, 3612, 3532, 3554, 3507, 3500, 3517, 3449, 3496, 3432, 3462, 3406, 3394, 3376, 3378, 3445, 3362, 3368, 3371, 3305, 3369, 3386, 3336, 3320, 3302, 3273, 3356, 3286, 3307, 3284, 3327, 3291, 3247, 3251, 3306, 3241, 3278, 3231, 3271, 3248, 3239, 3184, 3227, 3204, 3235, 3210, 3216, 3191, 3211, 3222, 3193, 3206, 3234, 3157, 3149, 3191, 3188, 3193, 3225, 3192, 3182, 3138, 3152, 3135, 3106, 3167, 3211, 3130, 3141, 3137, 3125, 3129, 3135, 3122, 3125, 3160, 3154, 3168, 3106, 3117, 3076, 3149, 3118, 3135, 3063, 3171, 3091, 3103, 3099, 3075, 3087, 3126, 3071, 3086, 3114, 3074, 3101, 3069, 3091, 3080, 3080, 3101, 3067, 3111, 3079, 3117, 3093, 3089, 3103, 3073, 3040, 3054, 3122, 3079, 3021, 3024, 3098, 3068, 3057, 3013, 3014, 3077, 3020, 3073, 3038, 3027, 3039, 3044, 3061, 3012, 2998, 3043, 3054, 3066, 3018, 3025, 3037, 3035, 3015, 3010, 3004, 3014, 3018, 2931, 2994, 3015, 3025, 3032, 3075, 3031, 2990, 2994, 3030, 2994, 3050, 2997, 2973, 3008, 3017, 3034, 2998, 2962, 3052, 2980, 2996, 3025, 3000, 2994, 2973, 3022, 2961, 2981, 3039, 2964, 2968, 2941, 3016, 2992, 3014, 2978, 2983, 3006, 2970, 2968, 2999, 2936, 2985, 2983, 2950, 3034, 2953, 2964, 2930, 2950, 2965, 2996, 2968, 2960, 2962, 2952, 2972, 2933, 3012, 2982, 3002, 2904, 2965, 2963, 2974, 3012, 2915, 2921, 2947, 2908, 2934, 2998, 2925, 2951, 2971, 2936, 2986, 2949, 2951, 2958, 2936, 2930, 2957, 2895, 2926, 2934, 2899, 2971, 3011, 2951, 2937, 2925, 2916, 2968, 2931, 2927, 2944, 2913, 2902, 2936, 2912, 2925, 2955, 2939, 2936, 2912, 2935, 2905, 2928, 2956, 2968, 2923, 2953, 2902, 2938, 2928, 2928, 2902, 2886, 2942, 2873, 2980, 2886, 2911, 2920, 2922, 2968, 2876, 2924, 2904, 2952, 2885, 2910, 2924, 2901, 2928, 2887, 2887, 2961, 2911, 2882, 2896, 2897, 2874, 2941, 2958, 2898, 2926, 2916, 2933, 2873, 2969, 2886, 2907, 2938, 2845, 2855, 2898, 2883, 2900, 2902, 2887, 2889, 2877, 2905, 2879, 2901, 2891, 2867, 2867, 2869, 2906, 2888, 2893, 2870, 2921, 2878, 2910, 2914, 2864, 2879, 2898, 2841, 2919, 2943, 2856, 2817, 2837, 2899, 2823, 2901, 2878, 2824, 2888, 2880, 2906, 2855, 2854, 2907, 2902, 2862, 2859, 2918, 2890, 2835, 2847, 2898, 2844, 2923, 2857, 2884, 2917, 2840, 2875, 2831, 2880, 2907, 2916, 2859, 2861, 2831, 2841, 2871, 2854, 2898, 2849, 2905, 2896, 2903, 2868, 2835, 2845, 2853, 2926, 2874, 2849, 2832, 2876, 2859, 2885, 2887, 2853, 2913, 2828, 2842, 2820, 2900, 2805, 2866, 2860, 2877, 2834, 2852, 2923, 2817, 2850, 2840, 2884, 2796, 2860, 2885, 2826, 2842, 2842, 2843, 2799, 2817, 2871, 2909, 2841, 2853, 2791, 2809, 2854, 2815, 2832, 2818, 2866, 2800, 2872, 2877, 2865, 2774, 2846, 2881, 2890, 2847, 2805, 2869, 2789, 2850, 2828, 2844, 2850, 2846, 2827, 2821, 2783, 2882, 2855, 2823, 2845, 2853, 2821, 2840, 2792, 2822, 2788, 2859, 2846, 2819, 2805, 2890, 2830, 2846, 2881, 2755, 2890, 2829, 2813, 2862, 2820, 2835, 2828, 2871, 2810, 2840, 2826, 2778, 2865, 2835, 2837, 2809, 2800, 2840, 2826, 2836, 2807, 2829, 2834, 2822, 2843, 2815, 2806, 2861, 2805, 2786, 2842, 2792, 2813, 2841, 2840, 2817, 2827, 2795, 2816, 2780, 2799, 2796, 2897, 2789, 2820, 2738, 2852, 2791, 2818, 2863, 2787, 2765, 2826, 2773, 2820, 2823, 2817, 2784, 2812, 2770, 2814, 2856, 2793, 2778, 2781, 2822, 2779, 2809, 2850, 2793, 2835, 2765, 2790, 2760, 2869, 2785, 2801, 2769, 2866, 2861, 2767, 2812, 2767, 2790, 2765, 2841, 2805, 2816, 2811, 2808, 2894, 2762, 2769, 2810, 2756, 2848, 2802, 2760, 2762, 2776, 2802, 2837, 2832, 2802, 2813, 2785, 2757, 2828, 2785, 2791, 2765, 2781, 2835, 2755, 2835, 2779, 2784, 2802, 2765, 2765, 2800, 2756, 2746, 2808, 2797, 2802, 2800, 2830, 2795, 2793, 2772, 2783, 2822, 2839, 2768, 2826, 2800, 2797, 2776, 2769, 2727, 2790, 2774, 2821, 2716, 2761, 2788, 2755, 2812, 2854, 2782, 2796, 2789, 2746, 2762, 2767, 2807, 2770, 2774, 2784, 2805, 2744, 2805, 2772, 2761, 2768, 2844, 2807, 2778, 2792, 2812, 2842, 2775, 2773, 2728, 2792, 2757, 2783, 2777, 2831, 2752, 2829, 2711, 2844, 2745, 2803, 2774, 2780, 2752, 2791, 2809, 2749, 2806, 2771, 2777, 2801, 2768, 2725, 2786, 2728, 2779, 2792, 2809, 2820, 2767, 2745, 2771, 2768, 2815, 2729, 2783, 2791, 2766, 2807, 2753, 2769, 2811, 2743, 2764, 2783, 2807, 2713, 2813, 2769, 2777, 2820, 2728, 2741, 2748, 2765, 2791, 2760, 2745, 2781, 2788, 2755, 2741, 2739, 2746, 2767, 2767, 2808, 2735, 2778, 2787, 2766, 2695, 2826, 2731, 2794, 2743, 2777, 2765, 2769, 2780, 2801, 2754, 2789, 2751, 2768, 2691, 2752, 2778, 2740, 2795, 2771, 2750, 2779, 2710, 2718, 2741, 2764, 2799, 2749, 2788, 2741, 2785, 2768, 2735, 2761, 2728, 2759, 2777, 2809, 2775, 2738, 2771, 2786, 2776, 2731, 2760, 2702, 2774, 2749, 2760, 2765, 2724, 2747, 2798, 2763, 2766, 2758, 2767, 2749, 2717, 2700, 2758, 2733, 2747, 2734, 2766, 2764, 2765, 2728, 2757, 2705, 2792, 2683, 2754, 2773, 2739, 2720, 2747, 2781, 2726, 2769, 2756, 2734, 2698, 2765, 2732, 2771, 2769, 2752, 2724, 2721, 2765, 2766, 2733, 2806, 2754, 2717, 2729, 2773, 2737, 2774, 2734, 2757, 2797, 2772, 2680, 2716, 2745, 2736, 2758, 2746, 2748, 2776, 2777, 2723, 2669, 2760, 2689, 2758, 2748, 2750, 2718, 2809, 2824, 2664, 2749, 2717, 2774, 2775, 2713, 2685, 2758, 2725, 2767, 2724, 2710, 2719, 2785, 2782, 2755, 2715, 2762, 2700, 2695, 2778, 2724, 2706, 2752, 2740, 2747, 2702, 2700, 2739, 2716, 2792, 2717, 2765, 2704, 2700, 2783, 2750, 2743, 2771, 2747, 2744, 2710, 2765, 2729, 2760, 2638, 2781, 2735, 2739, 2725, 2708, 2779, 2769, 2706, 2729, 2717, 2718, 2690, 2762, 2688, 2692, 2720, 2759, 2756, 2727, 2739, 2683, 2736, 2710, 2697, 2731, 2724, 2806, 2707, 2693, 2649, 2741, 2725, 2700, 2751, 2724, 2765, 2710, 2749, 2752, 2714, 2760, 2747, 2754, 2670, 2699, 2730, 2717, 2736, 2731, 2699, 2677, 2697, 2714, 2789, 2778, 2702, 2705, 2677, 2701, 2761, 2749, 2699, 2781, 2755, 2697, 2699, 2733, 2710, 2769, 2736, 2699, 2701, 2727, 2757, 2706, 2747, 2669, 2727, 2700, 2722, 2754, 2726, 2714, 2734, 2735, 2687, 2730, 2669, 2725, 2745, 2688, 2729, 2722, 2737, 2691, 2722, 2728, 2683, 2699, 2772, 2725, 2659, 2731, 2676, 2769, 2683, 2680, 2721, 2697, 2737, 2704, 2708, 2709, 2735, 2721, 2714, 2721, 2663, 2718, 2695, 2745, 2691, 2684, 2749, 2713, 2707, 2723, 2704, 2712, 2669, 2763, 2668, 2701, 2737, 2719, 2696, 2749, 2769, 2676, 2723, 2729, 2683, 2746, 2688, 2735, 2624, 2698, 2700, 2729, 2684, 2704, 2676, 2692, 2779, 2710, 2719, 2744, 2724, 2705, 2699, 2697, 2697, 2727, 2685, 2734, 2674, 2712, 2714, 2699, 2716, 2680, 2709, 2679, 2696, 2732, 2704, 2712, 2661, 2702, 2735, 2695, 2663, 2726, 2645, 2758, 2735, 2696, 2755, 2696, 2668, 2744, 2717, 2695, 2622, 2708, 2712, 2711, 2715, 2747, 2700, 2745, 2701, 2684, 2720, 2688, 2749, 2726, 2652, 2759, 2665, 2714, 2716, 2700, 2764, 2701, 2644, 2677, 2656, 2727, 2658, 2743, 2695, 2723, 2693, 2705, 2698, 2657, 2731, 2674, 2698, 2705, 2761, 2728, 2717, 2743, 2722, 2699, 2698, 2633, 2686, 2703, 2750, 2680, 2662, 2714, 2716, 2656, 2696, 2685, 2655, 2694, 2652, 2671, 2653, 2668, 2713, 2685, 2697, 2685, 2642, 2782, 2694, 2664, 2675, 2710, 2689, 2736, 2651, 2702, 2698, 2673, 2705, 2632, 2732, 2707, 2682, 2684, 2726, 2622, 2688, 2670, 2657, 2680, 2711, 2694, 2654, 2722, 2697, 2681, 2730, 2674, 2673, 2666, 2701, 2717, 2717, 2692, 2681, 2698, 2710, 2670, 2626, 2674, 2696, 2719, 2689, 2699, 2690, 2674, 2727, 2675, 2688, 2687, 2677, 2688, 2640, 2709, 2627, 2691, 2664, 2714, 2664, 2724, 2675, 2733, 2680, 2641, 2684, 2706, 2717, 2611, 2696, 2662, 2693, 2712, 2636, 2651, 2719, 2685, 2673, 2689, 2708, 2729, 2677, 2678, 2735, 2693, 2703, 2661, 2710, 2680, 2686, 2656, 2732, 2674, 2674, 2713, 2699, 2670, 2640, 2689, 2709, 2646, 2717, 2646, 2705, 2690, 2677, 2660, 2660, 2664, 2721, 2676, 2689, 2675, 2697, 2709, 2616, 2671, 2714, 2675, 2653, 2661, 2717, 2742, 2662, 2656, 2688, 2716, 2658, 2701, 2675, 2681, 2678, 2725, 2649, 2679, 2656, 2641, 2720, 2708, 2735, 2734, 2665, 2643, 2719, 2659, 2670, 2718, 2679, 2676, 2742, 2578, 2697, 2638, 2646, 2626, 2720, 2656, 2628, 2697, 2719, 2666, 2710, 2658, 2678, 2715, 2704, 2688, 2683, 2702, 2658, 2630, 2700, 2665, 2684, 2711, 2646, 2670, 2707, 2655, 2673, 2690, 2613, 2737, 2674, 2584, 2703, 2695, 2667, 2643, 2651, 2645, 2710, 2661, 2671, 2699, 2691, 2720, 2641, 2677, 2670, 2659, 2695, 2709, 2646, 2677, 2631, 2709, 2585, 2655, 2687, 2638, 2653, 2637, 2667, 2635, 2686, 2732, 2672, 2695, 2658, 2631, 2658, 2643, 2629, 2693, 2671, 2705, 2686, 2665, 2707, 2629, 2577, 2650, 2669, 2590, 2681, 2662, 2688, 2649, 2647, 2705, 2684, 2653, 2705, 2636, 2693, 2726, 2693, 2684, 2680, 2639, 2727, 2724, 2652, 2609, 2662, 2643, 2669, 2656, 2619, 2598, 2707, 2612, 2648, 2696, 2710, 2609, 2703, 2671, 2698, 2657, 2664, 2699, 2642, 2671, 2706, 2635, 2615, 2669, 2659, 2671, 2639, 2707, 2627, 2709, 2687, 2657, 2649, 2654, 2690, 2657, 2680, 2672, 2671, 2681, 2701, 2645, 2652, 2704, 2605, 2653, 2655, 2684, 2647, 2678, 2649, 2669, 2639, 2646, 2654, 2694, 2672, 2663, 2667, 2676, 2652, 2670, 2650, 2653, 2671, 2662, 2678, 2697, 2616, 2647, 2687, 2675, 2678, 2603, 2630, 2639, 2687, 2683, 2618, 2646, 2652, 2661, 2667, 2639, 2652, 2670, 2611, 2641, 2669, 2623, 2690, 2642, 2670, 2625, 2704, 2671, 2628, 2643, 2655, 2632, 2650, 2668, 2629, 2641, 2667, 2615, 2617, 2664, 2636, 2658, 2655, 2646, 2633, 2628, 2703, 2639, 2693, 2641, 2604, 2596, 2601, 2666, 2623, 2663, 2670, 2633, 2641, 2687, 2627, 2609, 2669, 2642, 2706, 2688, 2670, 2701, 2618, 2679, 2643, 2645, 2637, 2628, 2658, 2649, 2602, 2682, 2654, 2660, 2614, 2679, 2584, 2662, 2711, 2637, 2617, 2640, 2652, 2730, 2665, 2639, 2663, 2658, 2651, 2670, 2666, 2645, 2655, 2599, 2608, 2677, 2652, 2698, 2651, 2620, 2617, 2634, 2659, 2678, 2590, 2653, 2667, 2648, 2535, 2634, 2616, 2632, 2686, 2653, 2650, 2596, 2645, 2672, 2691, 2602, 2667, 2659, 2648, 2588, 2695, 2645, 2641, 2673, 2653, 2634, 2603, 2717, 2621, 2725, 2641, 2626, 2588, 2653, 2646, 2635, 2639, 2621, 2625, 2611, 2657, 2662, 2673, 2648, 2648, 2649, 2663, 2634, 2623, 2645, 2631, 2678, 2642, 2628, 2692, 2710, 2639, 2667, 2661, 2612, 2611, 2695, 2629, 2616, 2652, 2671, 2597, 2648, 2621, 2587, 2639, 2644, 2632, 2679, 2610, 2602, 2632, 2647, 2682, 2559, 2641, 2671, 2658, 2697, 2604, 2614, 2647, 2604, 2650, 2646, 2646, 2636, 2610, 2706, 2584, 2628, 2629, 2673, 2640, 2632, 2628, 2644, 2636, 2631, 2626, 2708, 2594, 2651, 2628, 2703, 2671, 2641, 2672, 2683, 2635, 2597, 2638, 2646, 2583, 2677, 2662, 2624, 2648, 2644, 2618, 2607, 2583, 2660, 2623, 2671, 2630, 2665, 2643, 2641, 2621, 2603, 2666, 2628, 2604, 2665, 2652, 2638, 2644, 2624, 2638, 2632, 2644, 2631, 2622, 2627, 2694, 2621, 2681, 2641, 2660, 2658, 2572, 2626, 2654, 2635, 2636, 2625, 2640, 2648, 2620, 2558, 2675, 2651, 2618, 2629, 2651, 2668, 2619, 2646, 2662, 2613, 2605, 2621, 2645, 2628, 2599, 2649, 2657, 2616, 2613, 2654, 2640, 2605, 2670, 2652, 2635, 2604, 2691, 2610, 2617, 2614, 2647, 2652, 2668, 2660, 2647, 2621, 2604, 2629, 2623, 2649, 2630, 2706, 2579, 2672, 2618, 2629, 2657, 2641, 2614, 2652, 2697, 2659, 2630, 2645, 2610, 2622, 2607, 2623, 2645, 2600, 2634, 2599, 2583, 2645, 2587, 2671, 2646, 2613, 2604, 2649, 2635, 2599, 2693, 2620, 2667, 2622, 2545, 2597, 2604, 2640, 2635, 2593, 2605, 2656, 2627, 2587, 2623, 2633, 2631, 2654, 2618, 2605, 2624, 2623, 2631, 2670, 2639, 2629, 2648, 2645, 2655, 2615, 2635, 2625, 2669, 2625, 2647, 2603, 2584, 2608, 2612, 2620, 2658, 2653, 2637, 2584, 2617, 2641, 2602, 2630, 2617, 2668, 2619, 2626, 2671, 2618, 2635, 2663, 2576, 2557, 2642, 2603, 2650, 2646, 2688, 2567, 2614, 2627, 2614, 2674, 2616, 2562, 2615, 2640, 2691, 2630, 2635, 2638, 2614, 2620, 2625, 2621, 2681, 2622, 2607, 2588, 2649, 2553, 2606, 2592, 2568, 2565, 2591, 2665, 2600, 2595, 2623, 2640, 2596, 2578, 2617, 2571, 2625, 2611, 2602, 2605, 2640, 2629, 2633, 2666, 2626, 2668, 2613, 2665, 2619, 2558, 2603, 2629, 2635, 2676, 2599, 2623, 2619, 2632, 2611, 2613, 2627, 2634, 2583, 2631, 2627, 2640, 2649, 2618, 2640, 2565, 2616, 2620, 2627, 2623, 2648, 2597, 2629, 2630, 2587, 2588, 2621, 2645, 2620, 2580, 2596, 2648, 2584, 2606, 2572, 2656, 2548, 2598, 2602, 2584, 2610, 2628, 2630, 2570, 2623, 2592, 2653, 2630, 2635, 2654, 2635, 2555, 2592, 2598, 2584, 2638, 2697, 2592, 2614, 2606, 2566, 2610, 2685, 2664, 2686, 2616, 2547, 2628, 2632, 2562, 2638, 2607, 2588, 2679, 2650, 2604, 2637, 2614, 2562, 2613, 2620, 2632, 2657, 2626, 2654, 2589, 2640, 2577, 2635, 2566, 2606, 2645, 2569, 2610, 2630, 2616, 2670, 2630, 2565, 2646, 2601, 2626, 2629, 2592, 2598, 2551, 2627, 2661, 2621, 2654, 2576, 2643, 2614, 2591, 2583, 2618, 2596, 2586, 2585, 2590, 2664, 2601, 2587, 2629, 2608, 2635, 2576, 2620, 2625, 2530, 2660, 2628, 2634, 2562, 2598, 2640, 2621, 2636, 2628, 2596, 2609, 2543, 2619, 2562, 2625, 2591, 2584, 2619, 2585, 2615, 2639, 2587, 2592, 2605, 2573, 2563, 2662, 2659, 2607, 2673, 2641, 2578, 2607, 2596, 2664, 2614, 2625, 2557, 2613, 2617, 2555, 2603, 2594, 2615, 2681, 2632, 2633, 2644, 2561, 2636, 2581, 2631, 2611, 2595, 2572, 2635, 2632, 2620, 2615, 2641, 2593, 2590, 2675, 2620, 2589, 2600, 2623, 2609, 2606, 2624, 2561, 2594, 2631, 2622, 2623, 2577, 2581, 2603, 2574, 2639, 2616, 2620, 2640, 2642, 2627, 2587, 2637, 2612, 2603, 2621, 2599, 2606, 2639, 2645, 2617, 2633, 2618, 2596, 2596, 2592, 2600, 2616, 2581, 2590, 2606, 2598, 2646, 2576, 2545, 2591, 2636, 2556, 2604, 2636, 2635, 2599, 2575, 2527, 2616, 2607, 2610, 2572, 2589, 2643, 2545, 2650, 2608, 2615, 2585, 2627, 2536, 2603, 2587, 2612, 2643, 2597, 2654, 2544, 2610, 2605, 2558, 2618, 2553, 2616, 2604, 2688, 2559, 2577, 2581, 2642, 2619, 2550, 2609, 2642, 2613, 2616, 2544, 2599, 2675, 2639, 2594, 2547, 2645, 2595, 2618, 2602, 2551, 2637, 2667, 2596, 2600, 2590, 2515, 2615, 2577, 2635, 2647, 2605, 2590, 2568, 2592, 2657, 2672, 2627, 2578, 2544, 2563, 2560, 2609, 2593, 2617, 2660, 2562, 2638, 2567, 2575, 2599, 2599, 2593, 2636, 2649, 2665, 2569, 2608, 2638, 2585, 2626, 2563, 2547, 2525, 2543, 2581, 2597, 2595, 2608, 2572, 2570, 2555, 2581, 2648, 2624, 2545, 2632, 2578, 2625, 2564, 2578, 2629, 2569, 2579, 2576, 2568, 2637, 2630, 2598, 2566, 2595, 2598, 2625, 2614, 2621, 2578, 2531, 2608, 2580, 2594, 2595, 2611, 2568, 2640, 2577, 2612, 2635, 2571, 2602, 2606, 2588, 2624, 2567, 2611, 2638, 2590, 2604, 2549, 2585, 2550, 2576, 2601, 2619, 2600, 2604, 2541, 2600, 2590, 2599, 2578, 2553, 2573, 2606, 2610, 2599, 2637, 2594, 2587, 2571, 2644, 2591, 2621, 2633, 2570, 2563, 2578, 2592, 2601, 2644, 2581, 2595, 2577, 2598, 2586, 2658, 2609, 2596, 2578, 2595, 2587, 2594, 2578, 2663, 2561, 2584, 2609, 2576, 2622, 2624, 2583, 2614, 2583, 2551, 2651, 2613, 2579, 2588, 2544, 2591, 2601, 2582, 2641, 2540, 2623, 2542, 2584, 2560, 2632, 2564, 2631, 2621, 2618, 2631, 2558, 2556, 2615, 2587, 2561, 2664, 2597, 2603, 2597, 2599, 2524, 2594, 2593, 2606, 2552, 2564, 2520, 2597, 2599, 2555, 2526, 2599, 2628, 2572, 2602, 2503, 2642, 2538, 2596, 2598, 2623, 2578, 2635, 2568, 2525, 2635, 2589, 2562, 2594, 2618, 2617, 2581, 2673, 2595, 2572, 2616, 2616, 2590, 2605, 2597, 2577, 2579, 2587, 2561, 2512, 2621, 2566, 2574, 2584, 2601, 2571, 2575, 2611, 2579, 2573, 2604, 2519, 2590, 2620, 2570, 2532, 2579, 2558, 2615, 2538, 2613, 2631, 2623, 2585, 2571, 2596, 2593, 2602, 2591, 2578, 2604, 2565, 2600, 2518, 2591, 2576, 2585, 2570, 2596, 2570, 2601, 2597, 2567, 2556, 2561, 2626, 2613, 2635, 2627, 2563, 2540, 2566, 2585, 2555, 2590, 2597, 2547, 2579, 2545, 2645, 2584, 2537, 2548, 2599, 2578, 2506, 2602, 2605, 2552, 2587, 2594, 2621, 2607, 2585, 2665, 2548, 2564, 2577, 2567, 2567, 2600, 2615, 2574, 2607, 2582, 2636, 2556, 2621, 2605, 2585, 2560, 2534, 2645, 2589, 2559, 2602, 2592, 2557, 2601, 2583, 2603, 2588, 2559, 2557, 2566, 2583, 2545, 2610, 2664, 2557, 2633, 2632, 2579, 2561, 2573, 2560, 2531, 2582, 2625, 2598, 2546, 2595, 2580, 2608, 2603, 2611, 2602, 2612, 2550, 2559, 2586, 2620, 2578, 2593, 2597, 2548, 2523, 2576, 2549, 2597, 2585, 2576, 2598, 2607, 2582, 2582, 2600, 2582, 2642, 2580, 2620, 2575, 2572, 2585, 2590, 2561, 2551, 2569, 2567, 2579, 2628, 2589, 2607, 2670, 2572, 2547, 2571, 2615, 2593, 2617, 2612, 2560, 2588, 2563, 2533, 2568, 2614, 2581, 2531, 2573, 2616, 2597, 2598, 2556, 2562, 2583, 2545, 2651, 2578, 2528, 2611, 2613, 2626, 2587, 2587, 2583, 2607, 2572, 2614, 2555, 2598, 2565, 2530, 2584, 2514, 2575, 2550, 2613, 2543, 2600, 2559, 2584, 2566, 2555, 2630, 2571, 2532, 2594, 2576, 2637, 2525, 2525, 2588, 2594, 2644, 2581, 2547, 2601, 2621, 2561, 2580, 2582, 2606, 2529, 2541, 2537, 2561, 2567, 2559, 2521, 2590, 2595, 2622, 2597, 2584, 2592, 2540, 2587, 2544, 2535, 2554, 2568, 2569, 2530, 2610, 2603, 2621, 2591, 2525, 2556, 2564, 2589, 2597, 2596, 2557, 2548, 2533, 2579, 2538, 2577, 2524, 2554, 2618, 2604, 2598, 2570, 2577, 2580, 2604, 2582, 2608, 2563, 2589, 2533, 2610, 2622, 2566, 2523, 2623, 2517, 2561, 2610, 2569, 2542, 2625, 2566, 2561, 2577, 2596, 2565, 2534, 2620, 2601, 2516, 2568, 2553, 2598, 2562, 2595, 2560, 2544, 2614, 2525, 2592, 2595, 2599, 2584, 2531, 2591, 2545, 2525, 2575, 2561, 2529, 2613, 2555, 2559, 2525, 2600, 2555, 2574, 2554, 2571, 2518, 2596, 2583, 2646, 2518, 2611, 2521, 2589, 2558, 2544, 2589, 2647, 2557, 2524, 2557, 2520, 2556, 2586, 2625, 2539, 2619, 2554, 2598, 2580, 2569, 2554, 2478, 2581, 2583, 2580, 2559, 2573, 2543, 2564, 2551, 2585, 2562, 2568, 2558, 2612, 2543, 2631, 2578, 2565, 2570, 2556, 2554, 2569, 2610, 2571, 2527, 2584, 2553, 2596, 2603, 2537, 2492, 2529, 2567, 2641, 2560, 2573, 2555, 2591, 2527, 2580, 2586, 2526, 2556, 2574, 2510, 2574, 2552, 2555, 2608, 2551, 2643, 2599, 2567, 2564, 2588, 2557, 2556, 2541, 2577, 2578, 2606, 2524, 2557, 2603, 2543, 2562, 2617, 2547, 2598, 2578, 2532, 2463, 2549, 2566, 2583, 2589, 2604, 2588, 2545, 2569, 2540, 2573, 2540, 2637, 2546, 2537, 2577, 2596, 2608, 2601, 2611, 2585, 2546, 2571, 2520, 2516, 2543, 2603, 2584, 2601, 2557, 2567, 2597, 2577, 2555, 2515, 2547, 2550, 2524, 2530, 2600, 2570, 2615, 2543, 2556, 2552, 2583, 2552, 2564, 2557, 2570, 2599, 2573, 2547, 2605, 2551, 2559, 2594, 2544, 2595, 2533, 2541, 2538, 2574, 2568, 2585, 2553, 2570, 2539, 2551, 2570, 2516, 2531, 2553, 2575, 2600, 2642, 2566, 2516, 2547, 2562, 2541, 2616, 2557, 2544, 2528, 2567, 2564, 2525, 2635, 2538, 2576, 2541, 2591, 2596, 2582, 2476, 2567, 2543, 2511, 2537, 2530, 2511, 2570, 2599, 2531, 2544, 2620, 2530, 2558}; bool is_prime(int x) { if (x < 2) return 0; if (x == 2) return 1; for (int i = 2; i * i <= x; i++) { if (x % i == 0) return 0; } return 1; } int main() { int l, r, ans = 0; while (cin >> l >> r) { ans = 0; if (l <= 2 && r >= 2) ans++; if (l <= 2) { l = 3; } int L = l / BLOCK, R = r / BLOCK; if (L == R) { for (int i = l; i <= r; i++) { if ((i & 1) && i % 4 == 1 && is_prime(i)) { ans++; } } } else { for (int i = L + 1; i < R; i++) { ans += num[i]; } for (int i = l; i < (L + 1) * BLOCK; i++) { if ((i & 1) && i % 4 == 1 && is_prime(i)) { ans++; } } for (int i = R * BLOCK; i <= r; i++) { if ((i & 1) && i % 4 == 1 && is_prime(i)) { ans++; } } } cout << ans << endl; } }
#include <bits/stdc++.h> using namespace std; const int MAX = 1e5 + 9; const int MAX1 = 1e6 + 9; const double pi = acos(-1); const long long int inf = 1e9; const long long mod = 1e9 + 7; bool prime[MAX]; int pfactors[MAX]; long long int fact[MAX]; long long int ifact[MAX]; long long int mexp(long long int a, long long int b) { long long int res = 1; while (b > 0) { if (b % 2) { res = (res * a); } a = (a * a); b = b / 2; } return res; } vector<int> totient() { long long tt[MAX]; for (int i = 1; i < MAX; i++) tt[i] = i; for (int i = 2; i < MAX; i++) { if (tt[i] == i) { for (int j = i; j < MAX; j += i) { tt[j] /= i; tt[j] *= i - 1; } } } vector<int> v; for (int i = 1; i < MAX; i++) v.push_back(tt[i]); return v; } vector<int> seive() { for (int i = 2; i < MAX; i++) prime[i] = false; int k = 0; vector<int> p; for (int i = 2; i < MAX; i++) { if (!prime[i]) { for (int j = 2 * i; j < MAX; j += i) prime[j] = true; } } for (int i = 2; i < MAX; i++) { if (!prime[i]) p.push_back(i); } return p; } string s; map<int, int> mp; int n; long long int dp[100][100]; int f[MAX]; int ans[MAX]; void dfs(int cur, int a, int b, long long int x) { if (a < 0 || b < 0) return; if (x > dp[a][b]) dp[a][b] = x; else return; if (cur == 2 * n) { for (int i = 0; i < 2 * n; i++) { ans[i] = f[i]; } return; } long long int c = 1, d = 1; for (int i = 0; i < a - 1; i++) c = c * 10; for (int i = 0; i < b - 1; i++) d = d * 10; f[cur] = 0; dfs(cur + 1, a - 1, b, x + c * (s[cur] - 0 )); f[cur] = 1; dfs(cur + 1, a, b - 1, x + d * (s[cur] - 0 )); } int main() { cin >> n; cin >> s; for (int i = 0; i <= 2 * n; i++) { for (int j = 0; j <= 2 * n; j++) dp[i][j] = -1; } for (int i = 0; i <= 2 * n; i++) { f[i] = -1; ans[i] = -1; } dfs(0, n, n, 0); for (int i = 0; i < 2 * n; i++) { if (ans[i] == 0) cout << H ; else if (ans[i] == 1) cout << M ; } }
#include <bits/stdc++.h> using namespace std; int main() { string s, t; while (cin >> s >> t) { int n = s.size(); string res; for (int i = n - 1; i >= 0; --i) { char& c = s[i]; ++c; int x = 0; if (c > z ) { c = a ; x = 1; } if (!x and s < t) { res = s; break; } } cout << (res.empty() ? No such string : res) << endl; } }
#include <bits/stdc++.h> using namespace std; const int M = 210000; struct Node { long long si, fi, ti; } node[M]; int n, m; long long get_num(long long x, long long y, long long z, int dir) { long long sum = 0; if (dir == 1) { if (x <= y) { sum += y - x; if (y <= z) { sum += z - y; } else { sum += (m - 1 - y) * 2 + y - z; } } else { sum += (m - 1 - x) * 2 + x - y; if (y >= z) sum += y - z; else sum += 2 * y + z - y; } } else { if (x >= y) { sum += x - y; if (y >= z) sum += y - z; else sum += 2 * y + z - y; } else { sum += 2 * x + y - x; if (y <= z) sum += z - y; else sum += (m - 1 - y) * 2 + y - z; } } return sum; } int main() { while (scanf( %d%d , &n, &m) == 2) { for (int i = 1; i <= n; i++) { scanf( %lld%lld%lld , &node[i].si, &node[i].fi, &node[i].ti); node[i].si--; node[i].fi--; } for (int i = 1; i <= n; i++) { if (node[i].si == node[i].fi) { printf( %lld n , node[i].ti); continue; } if ((node[i].ti / (m - 1)) % 2 == 0) { long long cur = node[i].ti % (m - 1); printf( %lld n , get_num(cur, node[i].si, node[i].fi, 1) + node[i].ti); } else { long long cur = m - 1 - node[i].ti % (m - 1); printf( %lld n , get_num(cur, node[i].si, node[i].fi, -1) + node[i].ti); } } } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int i, j, n, tmp; string s; char c; scanf( %d , &n); c = b ; s = a ; for (i = 1000; i >= 2; i--) { tmp = i * (i - 1) / 2; while (n >= tmp) { n -= tmp; for (j = 0; j < i; j++) s.push_back(c); c++; } } printf( %s n , s.c_str()); return 0; }
#include <bits/stdc++.h> using namespace std; long i, n; int main() { scanf( %ld , &n); if (n % 2 != 0) { for (i = 0; i < n - 1; i++) printf( %ld , i); printf( %ld n , n - 1); for (i = 1; i < n; i++) printf( %ld , i); printf( 0 n ); printf( %ld , 1 % n); for (i = 1; i < n; i++) printf( %ld , (2 * i + 1) % n); printf( n ); } else printf( -1 n ); return 0; }
#include <bits/stdc++.h> using namespace std; const int maxN = 100 + 100; int a1, a2, b1, b2; int main() { cin >> a1 >> a2 >> b1 >> b2; if ((b2 >= a1 - 1 && b2 <= 2 * (a1 + 1)) || (b1 >= a2 - 1 && b1 <= 2 * (a2 + 1))) cout << YES << endl; else cout << NO << endl; return 0; }
#include <bits/stdc++.h> using namespace std; typedef long long ll; typedef pair<int,int> PII; #define x first #define y second typedef long long ll; const int N=2e5+10; const ll mod=1e9+7; int n,m,k,x; int w[110],ord[110]; bool st[110]; void solve() { int s=0,sum=0; cin>>n>>x; for(int i=1;i<=n;i++) { cin>>w[i]; s+=w[i]; } if(s==x) { puts( NO ); return ; } sort(w+1,w+1+n); for(int i=1;i<=n;i++) { if(sum+w[i]==x) swap(w[i],w[i+1]); sum+=w[i]; } puts( YES ); for(int i=1;i<=n;i++) { cout<<w[i]<< ; } cout<<endl; } int main() { int t; cin>>t; while(t--) { solve(); } //system( pause ); return 0; }
#include <bits/stdc++.h> using namespace std; int a[300005], b[300005], f[300005], ori[300005]; queue<int> q; int main() { int n, i, j, k, u, v, up = n; scanf( %d , &n); for (i = 1; i <= n; i++) { scanf( %d , &a[i]); } for (i = 1; i <= n; i++) { scanf( %d , &b[i]); } q.push(n); f[n] = n; while (!q.empty()) { u = q.front(); q.pop(); for (i = u - a[u]; i <= min(u, up); i++) { v = i + b[i]; if (f[v] != 0) continue; f[v] = u; ori[v] = i; q.push(v); } up = min(u - a[u], up); } if (f[0] == 0) { printf( -1 ); return 0; } vector<int> ans; for (i = 0; i < n; i = f[i]) ans.push_back(i); printf( %d n , ans.size()); for (i = ans.size() - 1; i >= 0; i--) printf( %d , ori[ans[i]]); return 0; }
#include <bits/stdc++.h> using namespace std; int main(int argc, char *argv[]) { vector<string> a; int n; cin >> n; a.resize(n); for (int i = 0; i < n; ++i) cin >> a[i]; for (int i = n - 2; i >= 0; --i) { const char *x = a[i].c_str(), *y = a[i + 1].c_str(); int j = 1; while (x[j] && x[j] == y[j]) ++j; if (x[j] > y[j]) { a[i].resize(j); } } for (string s : a) cout << s << n ; return 0; }
#include <bits/stdc++.h> using namespace std; static const double EPS = 1e-10; template <typename T, typename S> vector<T>& operator<<(vector<T>& a, S b) { a.push_back(b); return a; } template <typename T> void operator>>(vector<T>& a, int b) { while (b--) if (!a.empty()) a.pop_back(); } bool isprime(int n) { if (n < 2) return false; for (int i = 2; i * i <= n; i++) if (n % i == 0) return false; return true; } long long b_pow(long long x, long long n) { return n ? b_pow(x * x, n / 2) * (n % 2 ? x : 1) : 1ll; } string itos(int n) { stringstream ss; ss << n; return ss.str(); } vector<vector<int> > DBG; vector<set<int> > SET; int where[(200010)]; int idx[(200010)]; int box_size[(200010)]; map<int, pair<int, int> > reg; int main() { ios_base::sync_with_stdio(false); int n, m, h; cin >> h >> m >> n; for (int i = 0; i < h; i++) where[i] = -1; for (int i = 0; i < h; i++) { if (where[i] == -1) { DBG.push_back(vector<int>(0)); int x = i; int size = 0; SET.push_back(set<int>()); while (where[x] == -1) { size++; where[x] = SET.size() - 1; idx[x] = size; SET.back().insert(size); DBG.back().push_back(x); x = (x + m) % h; } box_size[SET.size() - 1] = size; } } long long ans = 0; for (int i = 0; i < n; i++) { char c; int a, b; cin >> c; if (c == + ) { cin >> a >> b; int w = where[b]; int p = idx[b]; set<int>& my = SET[w]; set<int>::iterator it = my.lower_bound(p); if (it == my.end()) { ans += box_size[w] - p; set<int>::iterator it2 = my.lower_bound(0); ans += *(it2); reg[a] = make_pair(w, *it2); my.erase(*it2); } else { ans += (*it) - p; reg[a] = make_pair(w, *it); my.erase(*it); } } else { cin >> a; int w = reg[a].first; int p = reg[a].second; SET[w].insert(p); } } cout << ans << endl; }
#include <bits/stdc++.h> using namespace std; const int N = 1e5 + 2; const int M = 2e6; const int V = 500; const int mod = 0; const int inf = 2e9 + 3; const long long INF = 1e16; int dp[V + 20][N], n, q, a[N]; int calc(int p, int k) { int ans = 0; while (p <= n) { ans++; p = p + a[p] + k; } return ans; } int main() { scanf( %d , &n); for (int i = 1; i <= n; ++i) scanf( %d , &a[i]); for (int j = 1; j <= V; ++j) for (int i = n; i >= 1; --i) dp[j][i] = 1 + dp[j][i + a[i] + j]; scanf( %d , &q); while (q--) { int p, k; scanf( %d %d , &p, &k); if (k <= V) printf( %d n , dp[k][p]); else printf( %d n , calc(p, k)); } }
#include <bits/stdc++.h> char ansStr[1000000]; int nextInt() { char ch; int s, x; do { ch = getchar(); } while (ch <= 32); if (ch == - ) { s = -1; ch = getchar(); } else s = 1; x = 0; while (ch >= 0 && ch <= 9 ) { x = x * 10 + ch - 0 ; ch = getchar(); } return s * x; } int main(void) { int i, j; int n, ans, q, cnt; n = nextInt(); ans = 0; for (i = 0; i < n * n; i++) { int a; a = nextInt(); if (i % (n + 1) == 0) ans ^= a; } q = nextInt(); cnt = 0; while (q--) { int t; t = nextInt(); if (t == 3) ansStr[cnt++] = 0 + ans; else { nextInt(); ans ^= 1; } } puts(ansStr); return 0; }
#include <bits/stdc++.h> using namespace std; vector<int> H; vector<int> L; int a[200001]; bool vis[200001]; int main() { int n; scanf( %d , &n); for (int i = 1; i <= n; i++) { scanf( %d , &a[i]); } bool T = 0; for (int i = 1; i <= n;) { bool faH = 0, faL = 0; int tailH = H.size() - 1, tailL = L.size() - 1; if (H.size() == 0) faH = 1; else if (H[tailH] < a[i]) faH = 1; if (L.size() == 0) faL = 1; else if (L[tailL] > a[i]) faL = 1; if (faH == 0 && faL == 0) { T = 1; break; } if (faH == 0 && faL == 1) { L.push_back(a[i]); vis[i] = 1; i++; } if (faH == 1 && faL == 0) { H.push_back(a[i]); vis[i] = 0; i++; } if (faH == 1 && faL == 1) { if (a[i] < a[i + 1]) { H.push_back(a[i]); vis[i] = 0; i++; } else if (a[i] > a[i + 1]) { L.push_back(a[i]); vis[i] = 1; i++; } else { H.push_back(a[i]); L.push_back(a[i + 1]); vis[i] = 0; vis[i + 1] = 1; i += 2; } } } if (T) puts( NO ); else { puts( YES ); for (int i = 1; i <= n; i++) { printf( %d , vis[i]); } } }
#include <bits/stdc++.h> int main() { int a[105][4], n, ans, flag, i, j; scanf( %d , &n); for (i = 0; i < n; i++) scanf( %d%d%d%d , &a[i][0], &a[i][1], &a[i][2], &a[i][3]); ans = -1; for (i = 0; i < n; i++) { flag = 0; for (j = 0; j < n; j++) if (a[i][0] < a[j][0] && a[i][1] < a[j][1] && a[i][2] < a[j][2]) { flag = 1; break; } if (flag == 0 && (ans == -1 || a[ans][3] > a[i][3])) ans = i; } printf( %d n , ans + 1); return 0; }
#include <bits/stdc++.h> using namespace std; signed main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); ; long long T = 1; while (T--) { long long n; cin >> n; vector<pair<long long, long long> > q1, q2, q3, q4; for (long long i = 0; i < n; i++) { long long x, y; cin >> x >> y; if (x >= 0 && y >= 0) q1.push_back({x, y}); else if (x >= 0 && y <= 0) q4.push_back({x, -y}); else if (x <= 0 && y >= 0) q2.push_back({-x, y}); else q3.push_back({-x, -y}); } sort((q1).begin(), (q1).end()); sort((q2).begin(), (q2).end()); sort((q3).begin(), (q3).end()); sort((q4).begin(), (q4).end()); vector<string> ans; for (auto it = (q1).begin(); it != (q1).end(); it++) { long long x = it->first, y = it->second; string a = , b = , c = , d = ; a = 1 + to_string(x) + R ; b = 1 + to_string(x) + L ; c = 1 + to_string(y) + U ; d = 1 + to_string(y) + D ; if (x) ans.push_back(a); if (y) ans.push_back(c); ans.push_back( 2 ); if (y) ans.push_back(d); if (x) ans.push_back(b); ans.push_back( 3 ); } for (auto it = (q2).begin(); it != (q2).end(); it++) { long long x = it->first, y = it->second; string a = , b = , c = , d = ; a = 1 + to_string(x) + L ; b = 1 + to_string(x) + R ; c = 1 + to_string(y) + U ; d = 1 + to_string(y) + D ; if (x) ans.push_back(a); if (y) ans.push_back(c); ans.push_back( 2 ); if (y) ans.push_back(d); if (x) ans.push_back(b); ans.push_back( 3 ); } for (auto it = (q3).begin(); it != (q3).end(); it++) { long long x = it->first, y = it->second; string a = , b = , c = , d = ; a = 1 + to_string(x) + L ; b = 1 + to_string(x) + R ; c = 1 + to_string(y) + D ; d = 1 + to_string(y) + U ; if (x) ans.push_back(a); if (y) ans.push_back(c); ans.push_back( 2 ); if (y) ans.push_back(d); if (x) ans.push_back(b); ans.push_back( 3 ); } for (auto it = (q4).begin(); it != (q4).end(); it++) { long long x = it->first, y = it->second; string a = , b = , c = , d = ; a = 1 + to_string(x) + R ; b = 1 + to_string(x) + L ; c = 1 + to_string(y) + D ; d = 1 + to_string(y) + U ; if (x) ans.push_back(a); if (y) ans.push_back(c); ans.push_back( 2 ); if (y) ans.push_back(d); if (x) ans.push_back(b); ans.push_back( 3 ); } cout << ans.size() << n ; for (auto it = (ans).begin(); it != (ans).end(); it++) cout << *it << n ; } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int n, k; cin >> n >> k; int s = 0; while (n--) { int a, b; cin >> a >> b; s += b - a + 1; } cout << (k - (s % k)) % k << endl; return 0; }
#include <bits/stdc++.h> using namespace std; bool sign[30010]; int num[2]; int value[30010]; int start[3][2] = {{0, 1}, {0, 2}, {1, 2}}; int n; bool Legal(int pos) { if (pos == n - 1) return true; int d = value[pos + 1] - value[pos]; for (int i = pos + 2; i < n; i++) { if (value[i] - value[i - 1] != d) return false; } return true; } bool Legal2() { int temp = -INT_MAX; int d = INT_MAX; bool ok = true; for (int i = n - 1; i >= 0; i--) { if (!sign[i]) { if (temp == -INT_MAX) { temp = value[i]; continue; } if (d == INT_MAX) { d = value[i] - temp; temp = value[i]; } else if (value[i] - temp != d) { ok = false; break; } else temp = value[i]; } } if (ok) return true; ok = true; temp = -INT_MAX; d = INT_MAX; for (int i = n - 1; i >= 0; i--) { if (!sign[i]) { if (temp == -INT_MAX) { temp = value[i]; continue; } if (d == INT_MAX) { d = value[i] - temp; temp = value[i]; } else if (value[i] - temp != d) return false; else temp = value[i]; } if (sign[i] && ok) { sign[i] = false; if (temp == -INT_MAX) { temp = value[i]; continue; } if (d == INT_MAX) { d = value[i] - temp; temp = value[i]; } else if (value[i] - temp != d) { sign[i] = true; ok = false; } else temp = value[i]; } } return true; } void Print() { for (int i = 0; i < n; i++) if (sign[i]) printf( %d , value[i]); printf( n ); for (int i = 0; i < n; i++) if (!sign[i]) printf( %d , value[i]); printf( n ); } int main() { cin >> n; for (int i = 0; i < n; i++) scanf( %d , &value[i]); if (n <= 4) { if (n == 2) cout << value[0] << endl << value[1] << endl; else if (n == 3) cout << value[0] << endl << value[1] << << value[2] << endl; else { cout << value[0] << << value[1] << endl; cout << value[2] << << value[3] << endl; } return 0; } if (value[0] + value[2] == 2 * value[1]) { if (value[0] == value[1]) { if (value[n - 1] == value[0]) { for (int i = 0; i < n - 1; i++) printf( %d , value[0]); printf( n ); printf( %d n , value[0]); return 0; } else { int pos = 3; for (; pos < n; pos++) if (value[pos] != value[0]) break; if (Legal(pos)) { for (int i = 0; i < pos; i++) printf( %d , value[0]); printf( n ); for (int i = pos; i < n; i++) printf( %d , value[i]); printf( n ); return 0; } } } else { int temp = value[2]; sign[0] = sign[1] = sign[2] = true; int d = value[1] - value[0]; int tot = 3; for (int i = 3; i < n; i++) { if (value[i] - temp != d) continue; else { temp = value[i]; sign[i] = true; tot++; } } if (Legal2()) { if (tot == n) sign[n - 1] = false; Print(); return 0; } } } for (int sss = 0; sss < 3; sss++) { memset(sign, false, sizeof(sign)); int temp = value[start[sss][1]]; int d = temp - value[start[sss][0]]; sign[start[sss][0]] = sign[start[sss][1]] = true; for (int i = 3; i < n; i++) { if (value[i] - temp != d) continue; else { temp = value[i]; sign[i] = true; } } if (Legal2()) { Print(); return 0; } } printf( No solution n ); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int n, x, y; cin >> n >> x >> y; if ((x == n / 2 || x == n / 2 + 1) and (y == n / 2 || y == n / 2 + 1)) cout << NO << endl; else cout << YES << endl; return 0; }
#include <bits/stdc++.h> const double eps = (1e-10); using namespace std; int dcmp(long double a, long double b) { return fabsl(a - b) <= eps ? 0 : (a > b) ? 1 : -1; } int getBit(int num, int idx) { return ((num >> idx) & 1) == 1; } int setBit1(int num, int idx) { return num | (1 << idx); } long long setBit0(long long num, int idx) { return num & ~(1ll << idx); } long long flipBit(long long num, int idx) { return num ^ (1ll << idx); } void M() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); } int countNumBit1(int mask) { int ret = 0; while (mask) { mask &= (mask - 1); ++ret; } return ret; } long long X, Y, x, y, fl; string st; long long sx, sy, GX, GY; int getquad(long long GX, long long GY) { int fl; if (GX >= 0 && GY >= 0) fl = 1; else if (GX <= 0 && GY >= 0) fl = 2; else if (GX <= 0 && GY <= 0) fl = 3; else fl = 4; return fl; } int main() { cin >> x >> y >> st; if (x == 0 && y == 0) { cout << Yes n ; return 0; } GX = 0, GY = 0; for (int i = 0; i < ((int)(st).size()); i++) { if (st[i] == U ) GY += 1; if (st[i] == R ) GX += 1; if (st[i] == L ) GX -= 1; if (st[i] == D ) GY -= 1; } if (GX >= 0 && GY >= 0) fl = 1; else if (GX <= 0 && GY >= 0) fl = 2; else if (GX <= 0 && GY <= 0) fl = 3; else fl = 4; X = 0, Y = 0; for (int i = 0; i < ((int)(st).size()); i++) { if (st[i] == U ) Y += 1; if (st[i] == R ) X += 1; if (st[i] == L ) X -= 1; if (st[i] == D ) Y -= 1; sx = x - X; sy = y - Y; if (sx == 0 && sy == 0) { cout << Yes n ; return 0; } if (getquad(sx, sy) != fl) continue; bool ok1 = (GX == 0 ? sx == 0 : sx % GX == 0); bool ok2 = (GY == 0 ? sy == 0 : sy % GY == 0); if (ok1 && ok2 && sx * GY == GX * sy) { cout << Yes n ; return 0; } } cout << No n ; }
#include <bits/stdc++.h> using namespace std; int s[100], n, r[100], h[100], c[100], mni = -1; bool bad; int main() { cin >> n; for (int i = 0; i < n; i++) cin >> s[i] >> r[i] >> h[i] >> c[i]; for (int i = 0; i < n; i++) { bad = false; for (int j = 0; j < n; j++) { if (s[i] < s[j] && r[i] < r[j] && h[i] < h[j]) bad = true; } if (!bad) { if (mni == -1 || c[i] < c[mni]) mni = i; } } cout << mni + 1; return 0; }
#include <bits/stdc++.h> using namespace std; bool sorts(pair<long long, long long> a, pair<long long, long long> b) { return a.second < b.second; } int main() { long long n, m, k, t; cin >> n >> m >> k >> t; string s[3] = { Carrots , Kiwis , Grapes }; vector<pair<long long, long long>> vec; for (long long i = 0; i < k; i++) { long long a, b; cin >> a >> b; a--; b--; vec.push_back(make_pair((m * a + b), 1)); } sort(vec.begin(), vec.end()); long long sum = 0; for (long long i = 0; i < k; i++) { vec[i].second += sum; sum = vec[i].second; } for (int i = 0; i < t; i++) { long long a, b; cin >> a >> b; a--; b--; long long num = m * a + b; for (int j = 0; j < vec.size(); j++) { if (vec[j].first == num) { cout << Waste << endl; break; } else { if (num < vec[0].first) { cout << s[num % 3] << endl; break; } else if (num < vec[j].first) { cout << s[(num - vec[j - 1].second) % 3] << endl; break; } else { if (num > vec[vec.size() - 1].first) { cout << s[(num - vec[vec.size() - 1].second) % 3] << endl; break; } } } } } }
#include <bits/stdc++.h> using namespace std; const int MAXN = 3e5 + 5; const int INF = 1e9; vector<int> adj[MAXN], ts; int tin[MAXN], en[MAXN], curt; bool dag; void dfs(int s, int p = -1) { tin[s] = ++curt; for (auto v : adj[s]) { if (tin[v] && !en[v]) { dag = false; return; } if (!tin[v]) dfs(v, s); } en[s] = 1; ts.push_back(s); } int main() { ios_base::sync_with_stdio(false); cin.tie(0); int n, m; cin >> n >> m; vector<int> v; vector<vector<int>> g(n, vector<int>(m)); for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { cin >> g[i][j]; if (g[i][j] > -1) v.push_back(g[i][j]); } } map<int, int> to; sort(v.begin(), v.end()); v.erase(unique(v.begin(), v.end()), v.end()); for (int i = 0; i < v.size(); i++) { to[v[i]] = i; } for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if (g[i][j] > -1) g[i][j] = to[g[i][j]]; else g[i][j] = INF; } } int cur = 0; for (int i = 0; i < n; i++) { vector<pair<int, int>> nums; for (int j = 0; j < m; j++) nums.push_back({g[i][j], j}); sort(nums.begin(), nums.end()); cur += 2; for (int j = 0; j < m; j++) { auto p = nums[j]; if (p.first == INF) break; if (j > 0 && nums[j].first != nums[j - 1].first) cur++; adj[p.second].push_back(m + cur); adj[m + cur - 1].push_back(p.second); } } dag = true; for (int i = 0; i < MAXN; i++) if (!tin[i]) dfs(i); if (!dag) { cout << -1 n ; return 0; } reverse(ts.begin(), ts.end()); for (auto x : ts) if (x < m) cout << x + 1 << ; cout << n ; }
#include <bits/stdc++.h> using namespace std; const int INF = 2147000000; const int maxn = 4e5 + 10; const int mod = 998244353; int n, I; int a[maxn]; int sum[maxn]; int main() { scanf( %d%d , &n, &I); for (int i = 1; i <= n; i++) { scanf( %d , &a[i]); } sort(a + 1, a + 1 + n); for (int i = 1; i <= n; i++) { sum[i] = sum[i - 1]; if (a[i] != a[i - 1]) sum[i]++; } int z = 8 * I / n; int ans = 0; if (z <= 20) { int K = 1 << z; if (sum[n] > K) { int l = 1, r = 1; ans = INF; int num = 1; while (l <= r && r <= n) { while (r <= n && num <= K) { ans = min(ans, l - 1 + n - r); r++; if (a[r] != a[r - 1]) num++; } while (l <= r && num > K) { l++; if (a[l] != a[l - 1]) num--; } } } } printf( %d n , ans); return 0; }
#include <bits/stdc++.h> #pragma comment(linker, /STACK:16777216 ) using namespace std; int dist[501][501]; int INF = 1000000000; int s[501][501]; int c[501][501]; int main() { int n, m; cin >> n >> m; for (int i = 1; i <= n; i++) for (int j = 1; j <= n; j++) { dist[i][j] = INF; c[i][j] = INF; } memset(s, 0, sizeof(s)); for (int i = 1; i <= n; i++) { dist[i][i] = 0; } for (int i = 1; i <= m; i++) { int x, y, l; cin >> x >> y >> l; dist[x][y] = l; dist[y][x] = l; c[x][y] = l; c[y][x] = l; } for (int k = 1; k <= n; k++) for (int i = 1; i <= n; i++) for (int j = 1; j <= n; j++) { if (dist[i][k] + dist[k][j] < dist[i][j]) { dist[i][j] = dist[i][k] + dist[k][j]; } } memset(s, 0, sizeof(s)); for (int i = 1; i <= n; i++) for (int j = 1; j <= n; j++) for (int k = 1; k <= n; k++) if (c[k][j] && dist[i][k] + c[k][j] == dist[i][j]) s[i][j]++; for (int i = 1; i <= n; i++) for (int j = i + 1; j <= n; j++) { int ans = 0; for (int k = 1; k <= n; k++) if (dist[i][k] < INF && dist[k][j] < INF) if (dist[i][k] + dist[k][j] == dist[i][j]) ans += s[i][k]; cout << ans << ; } return 0; }
#include <bits/stdc++.h> using namespace std; inline int read() { char ch = getchar(); int nega = 1; while (!isdigit(ch)) { if (ch == - ) nega = -1; ch = getchar(); } int ans = 0; while (isdigit(ch)) { ans = ans * 10 + ch - 48; ch = getchar(); } if (nega == -1) return -ans; return ans; } int add(int x, int y) { return x + y >= 1000000007 ? x + y - 1000000007 : x + y; } int sub(int x, int y) { return x - y < 0 ? x - y + 1000000007 : x - y; } int mul(int x, int y) { return 1LL * x * y % 1000000007; } int qpow(int x, int y) { int ans = 1; while (y) { if (y & 1) ans = mul(ans, x); x = mul(x, x); y >>= 1; } return ans; } int inv(int x) { return qpow(x, 1000000007 - 2); } int pw[600005], ipw[600005], i2 = 500000004; int p[600005], pos[600005], val[600005], n, Q, cnt; pair<int, int> v[600005]; struct Node { int pw, l, r, val; }; Node merge(Node x, Node y) { Node ans; ans.pw = mul(x.pw, y.pw); ans.l = add(x.l, mul(x.pw, y.l)); ans.r = add(y.r, mul(y.pw, x.r)); ans.val = add(add(mul(x.pw, y.val), mul(x.val, y.pw)), mul(x.l, y.r)); return ans; } Node t[600005 * 4]; int d[600005]; void build(int u, int l, int r) { if (l == r) { t[u].pw = 1; return; } int mid = (l + r) / 2; build((u << 1), l, mid); build((u << 1 | 1), mid + 1, r); t[u] = merge(t[(u << 1)], t[(u << 1 | 1)]); } void update(int u, int l, int r, int p, int opt) { if (l == r) { if (opt == 1) t[u] = (Node){2, d[l], d[l], 0}; else t[u] = (Node){1, 0, 0, 0}; return; } int mid = (l + r) / 2; if (p <= mid) update((u << 1), l, mid, p, opt); else update((u << 1 | 1), mid + 1, r, p, opt); t[u] = merge(t[(u << 1)], t[(u << 1 | 1)]); } void print() { printf( %d n , mul(t[1].val, ipw[n])); } signed main() { pw[0] = 1; for (int i = 1; i < 600005; i++) pw[i] = add(pw[i - 1], pw[i - 1]); ipw[0] = 1; for (int i = 1; i < 600005; i++) ipw[i] = mul(ipw[i - 1], i2); cin >> n; for (int i = 1; i <= n; i++) p[i] = read(), v[++cnt] = make_pair(p[i], i); cin >> Q; for (int i = 1; i <= Q; i++) { pos[i] = read(), val[i] = read(); v[++cnt] = make_pair(val[i], i + n); } sort(v + 1, v + cnt + 1); for (int i = 1; i <= n; i++) p[i] = lower_bound(v + 1, v + cnt + 1, make_pair(p[i], i)) - v; for (int i = 1; i <= Q; i++) val[i] = lower_bound(v + 1, v + cnt + 1, make_pair(val[i], i + n)) - v; for (int i = 1; i <= cnt; i++) d[i] = v[i].first; build(1, 1, cnt); for (int i = 1; i <= n; i++) update(1, 1, cnt, p[i], 1); print(); for (int i = 1; i <= Q; i++) { update(1, 1, cnt, p[pos[i]], 0); p[pos[i]] = val[i]; update(1, 1, cnt, p[pos[i]], 1); print(); } return 0; }
#include <bits/stdc++.h> using namespace std; const int INF = 0x3f3f3f3f; const int MAXN = 1e5 + 5; const int MAXM = 1e5 + 5; int T, N, M, K, cas; struct Edge { int u, v, w; Edge() {} Edge(int u, int v, int w) : u(u), v(v), w(w) {} bool operator<(const Edge& e) const { return w < e.w; } } edges[MAXM]; int tot; bool F[MAXN]; void init() { tot = 0; memset(F, false, sizeof(F)); } void add_edge(int u, int v, int w) { edges[tot++] = Edge(u, v, w); } int main() { int u, v, w; while (~scanf( %d %d %d , &N, &M, &K)) { init(); for (int i = 0; i < M; i++) { scanf( %d %d %d , &u, &v, &w); add_edge(u, v, w); } for (int i = 0; i < K; i++) { scanf( %d , &u); F[u] = true; } int res = INF; for (int i = 0; i < M; i++) { u = edges[i].u, v = edges[i].v, w = edges[i].w; if (F[u] == F[v]) continue; res = min(res, w); } if (res == INF) printf( -1 ); else printf( %d n , res); } return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 10005; int n, a[N]; int cnt[N]; int main() { int T; srand(time(0)); scanf( %d , &(T)); while (T--) { memset(cnt, 0, sizeof(cnt)); double ex = 0; for (int i = 1; i <= 250; i++) scanf( %d , &(a[i])), cnt[a[i]]++, ex += a[i]; ex /= 250; int tot = 0; for (int i = 1; i <= ex / 3; i++) tot += cnt[i]; if (tot < 250 / 6 - 25) { } else { double dx = 0; dx = 0; for (int i = 1; i <= 250; i++) dx = max(dx, (double)a[i]); dx /= 2.0; ex = dx; } printf( %.0lf n , ex); } return 0; }
#include <bits/stdc++.h> using namespace std; const long long INF = 1e18 + 1; const int MAX = 200001; const long long MOD = 1000000007; struct trio { int first; int second; int third; }; struct long_trio { long long first; long long second; long long third; }; double dist_point_line(int x1, int y1, int x2, int y2, int x3, int y3) { double distance = abs((y3 - y1) * x2 - (x3 - x1) * y2 + x3 * y1 - x1 * y3) / (2 * sqrt((x3 - x1) * (x3 - x1) + (y3 - y1) * (y3 - y1))); return distance; } double dist_point_point(int x1, int y1, int x2, int y2) { double distance = sqrt((x1 - y1) * (x1 - y1) + (x2 - y2) * (x2 - y2)); return distance; } long long inq(long long k, long long q) { if (q == 0) return 1; long long l = inq(k, q / 2); if (q % 2 == 0) return l * l % MOD; else return l * l * k % MOD; } long long gcd(long long a, long long b) { if (a < b) swap(a, b); if (b == 0) return a; return gcd(b, a % b); } long long cubr(long long a) { long long l = -1, r = 1e6 + 2; while (l < r - 1) { long long mid = (l + r) / 2; if (mid * mid * mid > a) r = mid; else l = mid; } return l; } long long max(long long a, long long b) { if (a > b) return a; return b; } long long min(long long a, long long b) { return -1 * max(-a, -b); } long long possible(long long q) { if (q == INF) return -1; return q; } bool correct(int x, int xx) { if (x < 0) return 0; if (x >= xx) return 0; return 1; } long long dsumm(long long x) { long long y = 1; long long z = 0; for (int i = 0; i < 18; i++) { z += x / y % 10; y *= 10; } return z; } int check_(vector<int> arr) { for (int i = 0; i < arr.size(); i++) { cout << arr[i] << ; } cout << endl; return 0; } void perms(vector<int> perm, vector<int> used, int n, int k) { if (k == 0) { check_(perm); return; } for (int i = 0; i < n; i++) { if (used[i] == 0) { used[i] = 1; perm.push_back(i); perms(perm, used, n, k - 1); perm.pop_back(); used[i] = 0; } } return; } void bins(vector<int> bin, int k) { if (k == 0) { check_(bin); return; } bin.push_back(0); bins(bin, k - 1); bin.pop_back(); bin.push_back(1); bins(bin, k - 1); bin.pop_back(); return; } string months[12] = { January , February , March , April , May , June , July , August , September , October , November , December }; int days[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; long long fact[13] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362280, 3622800, 39916800, 479001600}; int cx[6] = {1, -1, 0, 0, 0, 0}; int cy[6] = {0, 0, 1, -1, 0, 0}; int cz[6] = {0, 0, 0, 0, 1, -1}; long long n, m, ans, l, r, k; long long x[300000], abs_summ; string s; int main() { cin >> n >> l >> r; k = l + r; for (int(i) = 0; (i) != (n); i++) { cin >> x[i]; } for (int(i) = 0; (i) != (n); i++) { cin >> m; x[i] = abs(x[i] - m); } sort(x, x + n); reverse(x, x + n); while (k > 0) { x[0] = abs(x[0] - 1); sort(x, x + n); reverse(x, x + n); k--; } m = 0; for (int(i) = 0; (i) != (n); i++) { m += x[i] * x[i]; } cout << m; }
#include <bits/stdc++.h> using namespace std; const int NV = 105; const int LNV = 11; const int NE = 5015; const int NQ = 1000005; const int intmax = 0x7fffffff; int f[2005]; int a[2005]; int n, m; struct Edge { int ne, y, v; }; struct Edge2 { int x, y, v; }; bool cmp(Edge2 a, Edge2 b) { return a.v < b.v; } struct DisSet { int fa[NV], nv; void init(int n) { nv = n; for (int i = 0; i < n; i++) fa[i] = i; } int find(int x) { if (fa[x] == x) return x; return fa[x] = find(fa[x]); } void uni(int x, int y) { fa[find(x)] = find(y); } }; struct Graph { Edge e[NE]; int ep, h[NV], nv, ne; void init(int n, int m = NE) { ne = m; nv = n; ep = 2; memset(h, 0, 4 * nv); } void add(int a, int b, int v = 1) { e[ep].ne = h[a]; e[ep].y = b; e[ep].v = v; h[a] = ep; ep++; } bool dfs(int now, int d, int t) { if (t == m + 1) { if (d) return 1; return 0; } int ans = intmax; vector<pair<int, int> > p; for (int i = h[now]; i; i = e[i].ne) { if (!d) if (e[i].y < f[t]) continue; if (e[i].v) continue; p.push_back(make_pair(e[i].y, i)); } sort(p.begin(), p.end()); for (int i = 0; i < p.size(); i++) { int key = p[i].second; e[key].v = 1; e[key ^ 1].v = 1; if (dfs(e[key].y, (e[key].y > f[t]) | d, t + 1)) { a[t] = e[key].y; return 1; } e[key].v = 0; e[key ^ 1].v = 0; } return 0; } }; Graph g; int main() { scanf( %d%d , &n, &m); g.init(n, m); int la; scanf( %d , &la); f[0] = la; for (int i = 1; i <= m; i++) { int a; scanf( %d , &a); g.add(la, a, 0); g.add(a, la, 0); la = a; f[i] = a; } if (g.dfs(f[0], 0, 1)) { printf( %d , f[0]); for (int i = 1; i <= m; i++) printf( %d , a[i]); puts( ); } else puts( No solution ); }
#include <bits/stdc++.h> using namespace std; int main() { long long loop = 0, t, n, a, b, c, d; scanf( %lld , &t); while (t--) { loop++; scanf( %lld%lld%lld%lld%lld , &n, &a, &b, &c, &d); if (n * (a - b) > c + d || n * (a + b) < c - d) printf( No n ); else printf( Yes n ); } }
#include <bits/stdc++.h> using namespace std; const int N = 200000; int n; bool p[N]; int tot, ans[N][2]; int tmp[N], tmptot; int rem[N], remtot; int main() { scanf( %d , &n); for (int i = 3; i <= n / 2; ++i) if (!p[i] && i % 2) { tmptot = 0; p[i * 2] = 1; for (int j = i * 3; j <= n; j += i) { if (p[j]) continue; p[j] = 1; tmp[tmptot++] = j; } for (int j = 0; j + 1 < tmptot; j += 2) { ans[tot][0] = tmp[j]; ans[tot][1] = tmp[j + 1]; ++tot; } if (tmptot % 2) { ans[tot][0] = i; ans[tot][1] = tmp[tmptot - 1]; ++tot; rem[remtot++] = i * 2; } else { ans[tot][0] = i; ans[tot][1] = i * 2; ++tot; } } for (int i = 2; i <= n; ++i) if (!p[i] && !(i % 2)) { rem[remtot++] = i; } for (int i = 0; i + 1 < remtot; i += 2) { ans[tot][0] = rem[i]; ans[tot][1] = rem[i + 1]; ++tot; } printf( %d n , tot); for (int i = 0; i < tot; ++i) { printf( %d %d n , ans[i][0], ans[i][1]); } }
#include <bits/stdc++.h> using namespace std; struct functie { char nume[501]; int par[10], nrPar; }; struct var { char nume[501]; int tip; }; char x[1001], nvar[1001], nquery[1001], varAct[1001]; functie functii[1001]; var vari[1001]; char nfact[1001]; int n, i, j, inceput, b, nrF, nrVar, tip, lim, k, nP, l, tipuri[101], m, contor; int main() { cin >> n; cin.getline(x, 10); for (i = 1; i <= n; i++) { cin.getline(x, 1001); int p = strlen(x); for (j = 0; j < p; j++) { if (x[j] == d ) { inceput = j; break; } } b = 0; for (j = inceput + 1; j < p; j++) { while (isalpha(x[j]) || isdigit(x[j])) { nfact[b] = x[j]; b++; j++; } if (x[j] == ( ) break; } nfact[b] = 0; nrF++; strcpy(functii[nrF].nume, nfact); functii[nrF].nrPar = 1; for (j = j + 1; j < p; j++) { if (x[j] == , ) functii[nrF].nrPar++; if (x[j] == i && x[j + 1] == n && x[j + 2] == t ) { functii[nrF].par[functii[nrF].nrPar] = 1; } if (x[j] == s && x[j + 1] == t && x[j + 2] == r && x[j + 3] == i && x[j + 4] == n && x[j + 5] == g ) { functii[nrF].par[functii[nrF].nrPar] = 2; } if (x[j] == d && x[j + 1] == o && x[j + 2] == u && x[j + 3] == b && x[j + 4] == l && x[j + 5] == e ) { functii[nrF].par[functii[nrF].nrPar] = 3; } if (x[j] == T ) { functii[nrF].par[functii[nrF].nrPar] = 4; } } } cin >> m; cin.getline(x, 10); for (i = 1; i <= m; i++) { cin.getline(x, 1001); int p = strlen(x); tip = 0; for (j = 0; j < p; j++) { if (x[j] == i && x[j + 1] == n && x[j + 2] == t ) { tip = 1; lim = 3; break; } else if (x[j] == s && x[j + 1] == t && x[j + 2] == r && x[j + 3] == i && x[j + 4] == n && x[j + 5] == g ) { tip = 2; lim = 5; break; } else if (x[j] == d && x[j + 1] == o && x[j + 2] == u && x[j + 3] == b && x[j + 4] == l && x[j + 5] == e ) { tip = 3; lim = 5; break; } } b = 0; for (j = j + lim + 1; j < p; j++) { while (isalpha(x[j]) || isdigit(x[j])) { nvar[b] = x[j]; b++; j++; } } nvar[b] = 0; nrVar++; strcpy(vari[nrVar].nume, nvar); vari[nrVar].tip = tip; } cin >> k; cin.getline(x, 10); for (i = 1; i <= k; i++) { contor = 0; cin.getline(x, 1001); int p = strlen(x); b = 0; for (j = 0; j < p; j++) { while (isalpha(x[j]) || isdigit(x[j])) { nquery[b] = x[j]; b++; j++; } if (x[j] == ( ) { break; } } nquery[b] = 0; b = 0; nP = 0; for (j = j + 1; j < p; j++) { while (isdigit(x[j]) || isalpha(x[j])) { varAct[b] = x[j]; b++; j++; } if (x[j] == , || x[j] == ) ) { nP++; varAct[b] = 0; for (l = 1; l <= nrVar; l++) { if (strcmp(varAct, vari[l].nume) == 0) { tipuri[nP] = vari[l].tip; } } b = 0; } } for (l = 1; l <= nrF; l++) { bool ok = false; if (strcmp(nquery, functii[l].nume) == 0) { if (nP == functii[l].nrPar) { ok = true; for (j = 1; j <= functii[l].nrPar; j++) { if (functii[l].par[j] != tipuri[j] && functii[l].par[j] != 4) { ok = false; } } } } if (ok) contor++; } cout << contor << n ; } }
#include <bits/stdc++.h> using namespace std; int z[100005], cnt[100005]; char s[100005]; void solve() { int n, t, L, R; n = strlen(s), L = R = 0; z[0] = n; for (int i = 1; i < n; i++) { if (R < i) { L = R = i; while (R < n && s[R - L] == s[R]) R++; z[i] = R - L, R--; } else { t = i - L; if (z[t] + i - 1 < R) z[i] = z[t]; else { L = i; while (R < n && s[R - L] == s[R]) R++; z[i] = R - L, R--; } } } int ret = 0; for (int i = (n)-1; i >= (0); i--) { if (z[i] + i >= n) ++ret; ++cnt[z[i]]; } for (int i = (n)-1; i >= (0); i--) cnt[i] += cnt[i + 1]; printf( %d n , ret); for (int i = (n)-1; i >= (0); i--) if (z[i] + i >= n) printf( %d %d n , n - i, cnt[n - i]); } int main() { scanf( %s , s); solve(); return 0; }
#include <bits/stdc++.h> const double eps = 1e-8; const int oo = 0x3f3f3f3f; using namespace std; long long a, b, c, d; bool read() { if (!(cin >> a >> b >> c >> d)) return false; return true; } void process() { cout << b << << c << << c << endl; } int main() { ios_base::sync_with_stdio(0); cin.tie(0); int t = -1; cin >> t; while (t-- && read()) { process(); } return 0; }
#include <bits/stdc++.h> using namespace std; void calcula(long long int n, long long int m, long long int r[10000], long long int sumar[10000], long long int k, long long int p) { priority_queue<long long int> q; for (int i = 0; i < n; i++) q.push(r[i]); for (int paso = 1; paso <= k; paso++) { long long int x = q.top(); q.pop(); sumar[paso] = sumar[paso - 1] + x; q.push(x - m * p); } } long long int n, m, k, p; long long int c[10000], r[10000]; long long int sumac[2000000], sumar[2000000]; int main() { cin >> n >> m >> k >> p; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { int a; cin >> a; r[i] += a; c[j] += a; } } calcula(n, m, r, sumar, k, p); calcula(m, n, c, sumac, k, p); long long int maximo = -1000000000000000000LL; for (long long int kc = 0; kc <= k; kc++) { long long int kr = k - kc; maximo = max(maximo, sumar[kr] + sumac[kc] - p * kc * kr); } cout << maximo << endl; }
#include <bits/stdc++.h> using namespace std; template <typename T> inline bool chkmin(T &a, const T &b) { return a > b ? a = b, 1 : 0; } template <typename T> inline bool chkmax(T &a, const T &b) { return a < b ? a = b, 1 : 0; } const int oo = 0x3f3f3f3f; const int Mod = 1e9 + 7; const int maxn = 500000; struct edge { int id, nxt; edge() {} edge(int _id, int _nxt) : id(_id), nxt(_nxt) {} }; edge e[(maxn << 1) + 5]; int st[maxn + 5], en = 0; inline void add_edge(int first, int second) { e[en] = edge(second, st[first]), st[first] = en++; } int n; set<pair<int, int> > all[maxn + 5]; int id[maxn + 5]; int sz[maxn + 5]; int dep[maxn + 5]; int ans = 0; void dfs(int first, int f = -1) { id[first] = first; for (int i = st[first]; i != -1; i = e[i].nxt) { int second = e[i].id; if (second == f) continue; dep[second] = dep[first] + 1; dfs(second, first); if (f == -1) { chkmax(ans, (--all[id[second]].end())->first - 1); continue; } if (sz[first] < sz[second]) swap(id[first], id[second]); sz[first] += sz[second]; for (auto u : all[id[second]]) { for (int v = (u.second), _end_ = (u.first); v < _end_; ++v) { auto t = all[id[first]].lower_bound(make_pair(v, oo)); if (t == all[id[first]].end() || t->second > v) all[id[first]].insert(make_pair(v + 1, v)); else { auto t0 = t; int from = t->second, to = t->first; while (1) { auto pre = t0++; if (t0 == all[id[first]].end()) break; if (pre->first < t0->second) break; to = t0->first; } all[id[first]].erase(t, t0); all[id[first]].insert(make_pair(to + 1, from)); } } } } if (!(int((all[id[first]]).size()))) all[id[first]].insert(make_pair(dep[first] + 1, dep[first])), sz[first] = 1; } int main() { memset(st, -1, sizeof st), en = 0; scanf( %d , &n); for (int i = (0), _end_ = (n - 1); i < _end_; ++i) { int first, second; scanf( %d%d , &first, &second), --first, --second; add_edge(first, second), add_edge(second, first); } dfs(0); printf( %d n , ans); return 0; }
#include <bits/stdc++.h> using namespace std; int lft[26]; char s[111111], t[111111]; int n, m; int main() { gets(s); n = (int)strlen(s); for (int i = 0; i < n; ++i) lft[s[i] - a ]++; gets(t); m = (int)strlen(t); for (int i = 0; i < n; ++i) { bool fnd = 0; for (int let = 0; let < 26; ++let) { if (!lft[let]) continue; s[i] = a + let; lft[let]--; int pos = i + 1; for (int j = 25; j >= 0; --j) { for (int k = 0; k < lft[j]; ++k) s[pos++] = a + j; } s[n] = 0; if (strcmp(s, t) == 1) { fnd = 1; break; } lft[let]++; } if (!fnd) { cout << -1 n ; return 0; } } puts(s); return 0; }
#include <bits/stdc++.h> using namespace std; const int size = 100010; const int bound = 100; int n, m, qq; int res[size], arr[size], father[size]; vector<pair<int, int> > edge[size]; pair<int, int> q[size]; map<int, int> ans[size]; int find(int x) { return father[x] == -1 ? x : father[x] = find(father[x]); } void merge(int x, int y) { int xx = find(x), yy = find(y); if (xx != yy) { father[xx] = yy; } } void solve() { for (int c = 1; c <= m; c++) { for (auto i : edge[c]) { merge(i.first, i.second); } if (edge[c].size() > bound) { for (int j = 0; j < qq; j++) { if (find(q[j].first) == find(q[j].second)) { ++res[j]; } } } else { int num = 0; for (auto i : edge[c]) { arr[num++] = i.first; arr[num++] = i.second; } sort(arr, arr + num); num = unique(arr, arr + num) - arr; for (int u = 0; u < num; u++) { for (int v = u + 1; v < num; v++) { if (find(arr[u]) == find(arr[v])) { ++ans[arr[u]][arr[v]]; } } } } for (auto i : edge[c]) { father[i.first] = father[i.second] = -1; } } } int main() { int a, b, c; memset(father, -1, sizeof(father)); memset(res, 0, sizeof(res)); cin >> n >> m; for (int i = 0; i < m; i++) { cin >> a >> b >> c; edge[c].push_back(make_pair(a, b)); } cin >> qq; for (int i = 0; i < qq; i++) { cin >> q[i].first >> q[i].second; } solve(); for (int i = 0; i < qq; i++) { cout << res[i] + max(ans[q[i].first][q[i].second], ans[q[i].second][q[i].first]) << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int h, g, c, n, m, k, l, a[140] = {}; string s; cin >> s; n = s.length(); for (int i = 0; i < s.length(); i++) a[s[i]]++; int res = 0; for (int i = 0; i <= 139; i++) if (a[i] > 0) { res++; } if ((res < 2) || (n < 4) || (res > 4)) { printf( No ); return 0; } int kol = res; if (res == 4) { printf( Yes ); return 0; } res = 0; for (int i = 0; i <= 139; i++) if (a[i] > 1) { res++; } if ((kol == 3) && (res > 0)) { printf( Yes ); return 0; } if ((kol == 2) && (res > 1)) { printf( Yes ); return 0; } printf( No ); }
#include <bits/stdc++.h> using namespace std; const long long N = 3e5 + 5; long long a[N]; int32_t tree[N << 2], bit_cnt[N]; struct seg_tree { long long combine(long long x, long long y) { return max(x, y); } void build(long long l, long long r, long long node) { if (l == r) { tree[node] = bit_cnt[l]; return; } long long mid = (l + r) >> 1, lc = node + node, rc = 1 + lc; build(l, mid, lc); build(mid + 1, r, rc); tree[node] = combine(tree[lc], tree[rc]); } long long query(long long l, long long r, long long ql, long long qr, long long node) { if (qr < l || r < ql) return 0; if (ql <= l and r <= qr) { return tree[node]; } long long mid = (l + r) >> 1, lc = node + node, rc = 1 + lc; return combine(query(l, mid, ql, qr, lc), query(mid + 1, r, ql, qr, rc)); } }; long long dp[N][2]; long long prefix_sum[N]; void solve() { long long n; cin >> n; for (long long i = 1; i <= n; ++i) { cin >> a[i]; bit_cnt[i] = __builtin_popcountll(a[i]); } seg_tree ins; ins.build(1, n, 1); for (long long i = 1; i <= n; ++i) { prefix_sum[i] = bit_cnt[i] + prefix_sum[i - 1]; } dp[0][0] = 1; map<long long, long long> mp; mp[0] = 1; long long ans = 0; for (long long i = 1; i <= n; ++i) { long long c = prefix_sum[i] & 1LL; dp[i][0] = dp[i - 1][0]; dp[i][1] = dp[i - 1][1]; dp[i][c] += 1; ans += dp[i - 1][c]; long long res = -1, mx = bit_cnt[i]; long long sum = 0; for (long long j = i; i - j <= 62 && j > 0; --j) { mx = max(mx, (long long)bit_cnt[j]); sum += bit_cnt[j]; if ((sum - mx < mx) && (sum & 1) == 0) { --ans; } } } cout << ans << n ; } signed main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); long long t = 1; for (long long i = 1; i <= t; ++i) { solve(); } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { #ifndef ONLINE_JUDGE freopen( input.txt , r , stdin); freopen( output.txt , w , stdout); #endif ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); cout.precision(10); int t; cin >> t; while (t--) { int n; cin >> n; string s; cin >> s; int l[n + 1], r[n + 1]; l[0] = 1; for (int i = 1; i <= n; i++) { l[i] = 1; if (i == 1) { if (s[i - 1] == L ) { l[i] = 2; } } else { if (s[i - 1] == L ) { l[i] = 2; if (s[i - 2] == R ) { l[i] = 2 + l[i - 2]; } } } } r[n] = 1; for (int i = n - 1; i >= 0; i--) { r[i] = 1; if (i == n - 1) { if (s[i] == R ) { r[i] = 2; } } else { if (s[i] == R ) { r[i] = 2; if (s[i + 1] == L ) { r[i] = 2 + r[i + 2]; } } } } for (int i = 0; i <= n; i++) { cout << l[i] + r[i] - 1 << ; } cout << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 100002; int n, m, k, currentOutCost[N], cntOut, cntIn; struct flight { int i, d, c; } in[N], out[N]; multiset<int> a[N]; bool cmp(flight x, flight y) { return x.d < y.d; } int main() { scanf( %d%d%d , &n, &m, &k); for (int i = (1); i <= (int)(m); ++i) { int d, first, t, c; scanf( %d%d , &d, &first); scanf( %d%d , &t, &c); if (first) out[++cntOut] = {first, d, c}; else in[++cntIn] = {t, d, c}; } sort(out + 1, out + 1 + cntOut, cmp); sort(in + 1, in + 1 + cntIn, cmp); long long ans = 1000000000000000000ll, currOut = 0, currInSum = 0, currOutSum = 0, j = 1; for (int i = (1); i <= (int)(cntIn); ++i) a[in[i].i].insert(in[i].c); for (int i = (1); i <= (int)(n); ++i) if (((int)(a[i]).size())) currInSum += *a[i].begin(); else return cout << -1, 0; for (int i = (1); i <= (int)(cntOut); ++i) { int node = out[i].i, d = out[i].d, c = out[i].c; while (j <= cntIn and in[j].d <= d + k) { currInSum -= *a[in[j].i].begin(); a[in[j].i].erase(a[in[j].i].find(in[j].c)); if (!((int)(a[in[j].i]).size())) goto fn; currInSum += *a[in[j].i].begin(); ++j; } if (!currentOutCost[node]) { ++currOut; currInSum += currentOutCost[node] = c; } else { currInSum -= currentOutCost[node]; currentOutCost[node] = min(currentOutCost[node], c); currInSum += currentOutCost[node]; } if (currOut == n) ans = min(ans, currOutSum + currInSum); } fn: cout << (ans == 1000000000000000000ll ? -1 : ans); }
#include <bits/stdc++.h> using namespace std; int main() { int n, k, i, j, ans; cin >> n >> k; int arr[n]; for (i = 0; i < n; i++) cin >> arr[i]; sort(arr, arr + n); ans = 0; for (i = n - 1; i >= 0; i = i - k) { ans += 2 * (arr[i] - 1); } cout << ans; }
#include <bits/stdc++.h> using namespace std; template <class A, class B> ostream& operator<<(ostream& out, const pair<A, B>& a) { return out << ( << a.first << , << a.second << ) ; } template <class A> ostream& operator<<(ostream& out, const vector<A>& a) { out << [ ; for (auto it = a.begin(); it != a.end(); ++it) { if (it != a.begin()) out << , ; out << *it; } return out << ] ; } int main() { ios::sync_with_stdio(false); cin.tie(0); long long n, i, j, x, t, y, d, m; cin >> d; cin >> n >> m; vector<pair<pair<long long, long long>, pair<long long, long long>>> a(d); for (i = 0; i < d; i++) cin >> a[i].first.first >> a[i].first.second >> a[i].second.first >> a[i].second.second; long long cnt_u, cnt_d, cnt_l, cnt_r; cin >> cnt_u >> cnt_d >> cnt_l >> cnt_r; vector<long long> vl(100005, 0), vr(100005, 0), vu(100005, 0), vd(100005, 0); for (i = 0; i < d; i++) { vu[min(a[i].first.first, a[i].second.first)]++; vd[max(a[i].first.first, a[i].second.first)]++; vl[min(a[i].first.second, a[i].second.second)]++; vr[max(a[i].first.second, a[i].second.second)]++; } for (i = 1; i < 100005; i++) { vu[i] += vu[i - 1]; vl[i] += vl[i - 1]; } for (i = 100005 - 4; i >= 0; i--) { vd[i] += vd[i + 1]; vr[i] += vr[i + 1]; } for (i = 0; i < d; i++) { vu[min(a[i].first.first, a[i].second.first)]--; vd[max(a[i].first.first, a[i].second.first)]--; vl[min(a[i].first.second, a[i].second.second)]--; vr[max(a[i].first.second, a[i].second.second)]--; long long x1, x2, y1, y2; x1 = vu[max(a[i].first.first, a[i].second.first) - 1]; x2 = vd[min(a[i].first.first, a[i].second.first) + 1]; y1 = vl[max(a[i].first.second, a[i].second.second) - 1]; y2 = vr[min(a[i].first.second, a[i].second.second) + 1]; if (x1 == cnt_u && x2 == cnt_d && y1 == cnt_l && y2 == cnt_r) { cout << i + 1; return 0; } vu[min(a[i].first.first, a[i].second.first)]++; vd[max(a[i].first.first, a[i].second.first)]++; vl[min(a[i].first.second, a[i].second.second)]++; vr[max(a[i].first.second, a[i].second.second)]++; } cout << -1 ; }
#include <bits/stdc++.h> using namespace std; struct hren { long int pos, ob, tim; }; hren down, up, lin, rech, u1, u2, u3, u4; long long int c, q = 1, f = 1, g = 1; long int n, j, i, timer = 0, x, y, p = 0; void pere1(hren &q) { if (timer == q.tim) { q.pos = 1; q.ob = 1; return; } if (timer > q.tim) { q.pos += 2; q.ob += q.pos; return; } } void pere2(hren &q) { if (timer == q.tim) { q.pos = 1; q.ob = 1; return; } if (timer > q.tim) { q.pos += 1; q.ob += q.pos; return; } } void plusq(hren r) { if (r.ob > 0) q += r.ob; return; } void minusq(hren r) { if (r.ob > 0) q -= r.ob; return; } int main() { scanf( %d%d%d%I64d , &n, &x, &y, &c); down.tim = x; up.tim = n - x + 1; rech.tim = y; lin.tim = n - y + 1; u1.tim = n - y + x + 1; u3.tim = n - x + y + 1; u2.tim = x + y; u4.tim = 2 * n + 2 - x - y; while (1) { if (g >= c) { printf( %d , timer); return 0; } timer++; pere1(up); pere1(down); pere1(lin); pere1(rech); pere2(u1); pere2(u2); pere2(u3); pere2(u4); p += 4; f += p; q = 0; plusq(up); plusq(down); plusq(lin); plusq(rech); minusq(u1); minusq(u2); minusq(u3); minusq(u4); g = f - q; } return 0; }
#include <bits/stdc++.h> using namespace std; const int MAX = 2e6, mod = 998244353; int arr[101]; int n; bool rot(int idx, int deg) { deg %= 360; if (deg < 0) deg += 360; if (idx == n) return !deg; return rot(idx + 1, deg + arr[idx]) | rot(idx + 1, deg - arr[idx]); } int main() { cin >> n; for (int i = 0; i < n; i++) scanf( %d , arr + i); if (rot(0, 0)) puts( YES ); else puts( NO ); }
#include <bits/stdc++.h> using namespace std; int dp[45][45][45][45] = {0}; int sumar[45][45] = {0}; int ar[45][45] = {0}; int check(int i, int j, int p, int q) { int s1 = sumar[p][q]; int s2 = sumar[i - 1][q]; int s3 = sumar[p][j - 1]; int s4 = sumar[i - 1][j - 1]; return ((s1 - s2 - s3 + s4) == 0); } int main() { int m, q, n; char ch; scanf( %d %d %d , &n, &m, &q); for (int i = 0; i < n; i++) { getchar(); for (int j = 0; j < m; j++) { ch = getchar(); ar[i][j] = ch - 0 ; } } for (int i = 1; i <= n; i++) { for (int j = 1; j <= m; j++) { sumar[i][j] = sumar[i][j - 1] + sumar[i - 1][j] - sumar[i - 1][j - 1] + ar[i - 1][j - 1]; } } for (int i = 1; i <= n; i++) { for (int j = 1; j <= m; j++) { for (int p = i; p <= n; p++) { for (int q = j; q <= m; q++) { dp[i][j][p][q] = dp[i][j][p - 1][q] + dp[i][j][p][q - 1] - dp[i][j][p - 1][q - 1] + check(i, j, p, q); } } } } for (int p = n; p >= 1; p--) { for (int q = m; q >= 1; q--) { for (int i = p; i >= 1; i--) { for (int j = q; j >= 1; j--) { dp[i][j][p][q] += dp[i + 1][j][p][q] + dp[i][j + 1][p][q] - dp[i + 1][j + 1][p][q]; } } } } int a, b, c, d; for (int i = 0; i < q; i++) { scanf( %d %d %d %d , &a, &b, &c, &d); cout << dp[a][b][c][d] << n ; } return 0; }
#include <bits/stdc++.h> char map[55][55]; int main() { int n, ans = 2147483647; std::pair<int, int> s, t; std::queue<std::pair<int, int> > q; std::vector<std::pair<int, int> > vec1, vec2; scanf( %d %d %d %d %d , &n, &s.first, &s.second, &t.first, &t.second); for (int i = 1; i <= n; ++i) scanf( %s , map[i] + 1); vec1.push_back(s), map[s.first][s.second] = 2 , q.push(s); while (!q.empty()) { std::pair<int, int> p = q.front(); q.pop(); std::pair<int, int> temp = std::make_pair(p.first, p.second + 1); if (temp.second <= n && map[temp.first][temp.second] == 0 ) map[temp.first][temp.second] = 2 , vec1.push_back(temp), q.push(temp); temp = std::make_pair(p.first, p.second - 1); if (temp.second >= 0 && map[temp.first][temp.second] == 0 ) map[temp.first][temp.second] = 2 , vec1.push_back(temp), q.push(temp); temp = std::make_pair(p.first + 1, p.second); if (temp.first <= n && map[temp.first][temp.second] == 0 ) map[temp.first][temp.second] = 2 , vec1.push_back(temp), q.push(temp); temp = std::make_pair(p.first - 1, p.second); if (temp.first >= 0 && map[temp.first][temp.second] == 0 ) map[temp.first][temp.second] = 2 , vec1.push_back(temp), q.push(temp); } if (map[t.first][t.second] == 2 ) { putchar( 0 ); return 0; } vec2.push_back(t), map[t.first][t.second] = 2 , q.push(t); while (!q.empty()) { std::pair<int, int> p = q.front(); q.pop(); std::pair<int, int> temp = std::make_pair(p.first, p.second + 1); if (temp.second <= n && map[temp.first][temp.second] == 0 ) map[temp.first][temp.second] = 2 , vec2.push_back(temp), q.push(temp); temp = std::make_pair(p.first, p.second - 1); if (temp.second >= 0 && map[temp.first][temp.second] == 0 ) map[temp.first][temp.second] = 2 , vec2.push_back(temp), q.push(temp); temp = std::make_pair(p.first + 1, p.second); if (temp.first <= n && map[temp.first][temp.second] == 0 ) map[temp.first][temp.second] = 2 , vec2.push_back(temp), q.push(temp); temp = std::make_pair(p.first - 1, p.second); if (temp.first >= 0 && map[temp.first][temp.second] == 0 ) map[temp.first][temp.second] = 2 , vec2.push_back(temp), q.push(temp); } for (auto x1 : vec1) for (auto x2 : vec2) ans = std::min(ans, (x2.first - x1.first) * (x2.first - x1.first) + (x2.second - x1.second) * (x2.second - x1.second)); printf( %d n , ans); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { string a, s; int c(0); cin >> a >> s; sort(s.begin(), s.end()), reverse(s.begin(), s.end()); for (int i = 0; i < a.size(); i++) { if (a[i] < s[c]) a[i] = s[c++]; } cout << a << endl; }
#include <bits/stdc++.h> using namespace std; int main() { string a; cin >> a; char b[101]; int k = 0; for (int i = 0; i < a.length() - 1; ++i) { if (a[i] != a[i + 1] || a[i] != / ) { b[k] = a[i]; ++k; } } if ((k == 0) || (a[a.length() - 1] != / )) { b[k] = a[a.length() - 1]; ++k; } for (int i = 0; i < k; ++i) cout << b[i]; return 0; }
#include <bits/stdc++.h> using namespace std; long long a[1000006]; int main() { int n; cin >> n; for (int i = 0; i < n; i++) cin >> a[i]; sort(a, a + n); long long score = 0; for (int i = 0; i < n - 1; i++) score += 1ll * (i + 2) * a[i]; score += a[n - 1] * n; cout << score << endl; return 0; }
#include <bits/stdc++.h> using namespace std; typedef long long ll; typedef double db; const int mod=1e9+7; const int N=1e6+11; const double eps=0.00000001; bool check(int u,int v){ int a=0,b=0; for(int i=0;i<31;i++){ if(u>>i&1) a++; if(v>>i&1) b++; if(b){ if(!a) return false; a--,b--; } } return true; } void solve(){ int q; cin>>q; while(q--){ int u,v; cin>>u>>v; if(u<=v&&check(u,v)) cout<< YES n ; else cout<< NO n ; } } int main(){ ios_base::sync_with_stdio(false);cin.tie(0); solve(); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { string x, y; cin >> x >> y; const auto n = int(x.size()); auto ok = true; for (auto i = 0; i < n; i++) ok &= y[i] <= x[i]; if (ok) cout << y << endl; else cout << -1 << endl; }
#include <bits/stdc++.h> using namespace std; int n; int a, b, h, w, ans = INT_MAX, f[int(1e5 + 10)]; bool cmp(int x, int y) { return x > y; } void get_answ(long long x, long long y, int d, bool flag) { if (x >= a && y >= b) { ans = min(ans, d - 1); return; } if (d == n + 1) return; if ((!flag || f[d] != f[d - 1]) && x < a) get_answ(1ll * x * f[d], y, d + 1, 0); if (y < b) get_answ(x, 1ll * y * f[d], d + 1, 1); } int main() { scanf( %d%d%d%d%d , &a, &b, &h, &w, &n); for (int i = 1; i <= n; i++) scanf( %d , f + i); sort(f + 1, f + n + 1, cmp); get_answ(h, w, 1, 0); get_answ(w, h, 1, 0); if (ans != INT_MAX) printf( %d , ans); else printf( -1 ); }
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); long long int Tests = 1; while (Tests--) { long long int N; cin >> N; vector<long long int> A(N); for (long long int i = 0; i < N; i++) cin >> A[i]; if (N == 1) cout << A[0] << endl; if (N == 3) { sort((A).begin(), (A).end()); cout << A[1] << endl; } if (N == 5) { sort((A).begin(), (A).end()); cout << A[2] << endl; } } }
#include <bits/stdc++.h> using namespace std; long long bigmod(long long b, long long p, long long md) { if (p == 0) return 1; if (p % 2 == 1) { return ((b % md) * bigmod(b, p - 1, md)) % md; } else { long long y = bigmod(b, p / 2, md); return (y * y) % md; } } set<int> vis; set<int> st[200005]; vector<int> ans; int cnt; void dfs(int s) { cnt++; for (auto it = vis.begin(); it != vis.end();) { if (st[s].find(*it) == st[s].end()) { int node = *it; vis.erase(node); dfs(node); it = vis.lower_bound(node); } else it++; } } int main() { int n, m; cin >> n >> m; for (int i = 0; i < m; i++) { int a, b; cin >> a >> b; st[a].insert(b); st[b].insert(a); } for (int i = 1; i <= n; i++) vis.insert(i); for (int i = 1; i <= n; i++) { if (vis.find(i) != vis.end()) { cnt = 0; vis.erase(i); dfs(i); ans.push_back(cnt); } } cout << ans.size() << n ; sort(ans.begin(), ans.end()); for (int i = 0; i < ans.size(); i++) cout << ans[i] << ; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); ; long long k, left; cin >> k; long long base = k + 1; vector<long long> v; v.push_back(-1); left = base; for (long long i = 1; i < 2001; i++) { left++; if (left > 1000000) { v.push_back(1000000); left -= 1000000; } else { v.push_back(left); break; } } cout << v.size() << endl; for (long long i = 0; i < v.size(); i++) cout << v[i] << ; }
#include <bits/stdc++.h> using namespace std; long long jc[100005], fac[12], vp[12], P[12], s, v[100005][12], r[100005][12]; long long n, L, R, p; long long fpower(long long x, long long k) { long long ans = 1; while (k) { if (k & 1) ans = ans * x % p; x = x * x % p; k >>= 1; } if (!ans) return p; return ans; } long long c(long long x, long long y) { long long m[12] = {}, ans = 0; for (long long i = 1; i <= s; ++i) { long long o = v[x][i] - v[y][i] - v[x - y][i]; if (o >= vp[i]) continue; long long q = fpower(fac[i], vp[i] - o); m[i] = fpower(fac[i], o) * (r[x][i] * fpower(r[y][i] * r[x - y][i] % q, q / fac[i] * (fac[i] - 1) - 1) % q) % P[i]; ans += m[i] * fpower(p / P[i], P[i] / fac[i] * (fac[i] - 1)) % p; } return ans % p; } int main() { scanf( %I64d%I64d%I64d%I64d , &n, &p, &L, &R); jc[0] = 1; for (long long i = 1; i <= n; ++i) jc[i] = jc[i - 1] * i % p; long long t = p; for (long long i = 2; i * i <= t; ++i) { if (t % i) continue; fac[++s] = i; while (t % i == 0) vp[s]++, t /= i; P[s] = fpower(fac[s], vp[s]); } if (t > 1) fac[++s] = t, vp[s] = 1, P[s] = t; for (long long i = 1; i <= s; ++i) { r[0][i] = 1; for (long long j = 1; j <= n; ++j) { long long t = j, sum = 0; while (t % fac[i] == 0) t /= fac[i], sum++; v[j][i] = v[j - 1][i] + sum, r[j][i] = r[j - 1][i] * t % P[i]; } } long long ans = 0; for (long long i = 0; i <= n; ++i) { long long o = 0; if (i - L >= 0) o += c(i, (i - L) / 2); if (i - R - 1 >= 0) o -= c(i, (i - R - 1) / 2); ans = (ans + c(n, i) * o) % p; } printf( %I64d n , (p + ans % p) % p); return 0; }
#include <bits/stdc++.h> using namespace std; const int mod = 1e9 + 7; long long Inv[1000005]; void inv(int n) { Inv[1] = 1; for (int i = 2; i <= n; i++) { Inv[i] = (mod - mod / i * Inv[mod % i] % mod) % mod; } } int main() { ios_base::sync_with_stdio(0); cin.tie(0); int n; cin >> n; long long tot = 1; for (int i = 1; i < n + 1; i++) { tot *= i; tot %= mod; } vector<int> v; for (int i = 0; i < n; i++) { int add; cin >> add; v.push_back(add); } inv(n); sort(v.rbegin(), v.rend()); long long cur = 0; long long ans = 0; int last = 0; int cnt = 0; for (int i = 0; i < n; i++) { if (v[i] == last) { cur++; cnt++; continue; } if (last != v[0]) { ans += tot * last % mod * Inv[cur] % mod * cnt % mod; ans %= mod; } cur++; cnt = 1; last = v[i]; } if (last != v[0]) { ans += tot * last % mod * Inv[cur] % mod * cnt % mod; ans %= mod; } cout << ans << n ; }
#include <bits/stdc++.h> using namespace std; int f[100][300] = {0}; int main() { std::ios::sync_with_stdio(false); string s1, s2; cin >> s1 >> s2; int t1 = 0, t2 = 0, q = 0; for (int i = 0; i < s1.length(); i += 1) { if (s1[i] == + ) t1++; else t1--; } for (int i = 0; i < s2.length(); i += 1) { if (s2[i] == + ) t2++; else if (s2[i] == - ) t2--; else q++; } int w = t1 - t2; int dta = 20; f[0][dta] = 1; for (int i = 1; i <= q; i += 1) { for (int j = -10; j <= 10; j += 1) { f[i][j + dta] = f[i - 1][j + dta - 1] + f[i - 1][j + dta + 1]; } } double ans = f[q][w + dta] / double(1 << q); cout << fixed << setprecision(12) << ans << endl; return 0; }
#include <bits/stdc++.h> using namespace std; template <class T> T abs(T x) { return x > 0 ? x : -x; } const string dom[2][7] = {{ ......... , ....O.... , O.......O , O...O...O , O.O...O.O , O.O.O.O.O , OOO...OOO }, { ......... , ....O.... , ..O...O.. , ..O.O.O.. , O.O...O.O , O.O.O.O.O , O.OO.OO.O }}; const int mod = 1000000007; int n; int m; char w[1002][1002]; int g[250][250]; int can[250], can2[250]; int cnt[251], res[251]; int get(int i, int j) { string s = ; for (int p = 0; p < 3; p++) for (int q = 0; q < 3; q++) s += w[i + p][j + q]; int res = 0; for (int p = 0; p < 2; p++) for (int q = 0; q < 7; q++) if (s == dom[p][q]) res |= (p + 1); return res; } int main() { scanf( %d%d , &n, &m); gets(w[0]); for (int i = 0; i < 4 * n + 1; i++) gets(w[i]); for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) g[i][j] = get(4 * i + 1, 4 * j + 1); for (int j = 0; j < m; j++) { can[j] = int(n % 2 == 0); for (int i = 0; i < n; i++) can[j] &= int((g[i][j] & 2) != 0); } for (int j = 0; j + 1 < m; j++) { memset(cnt, 0, sizeof(cnt)); cnt[0] = 1; for (int i = 0; i < n; i++) { if (g[i][j] & g[i][j + 1] & 1) cnt[i + 1] = (cnt[i + 1] + cnt[i]) % mod; if (i + 1 < n && int(g[i][j] & g[i + 1][j] & g[i][j + 1] & g[i + 1][j + 1] & 2)) cnt[i + 2] = (cnt[i + 2] + cnt[i]) % mod; } can2[j] = (cnt[n] - can[j] * can[j + 1] + mod) % mod; } memset(res, 0, sizeof(res)); res[0] = 1; for (int j = 0; j < m; j++) { if (can[j]) res[j + 1] = (res[j + 1] + res[j]) % mod; if (j + 1 < m) res[j + 2] = (res[j + 2] + (long long)res[j] * can2[j]) % mod; } printf( %d n , res[m]); return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 1e5 + 15; struct tree { int l, r, sum; tree *left, *right; tree(int L, int R, int val) { l = L, r = R, sum = val; left = right = NULL; } }; tree *pq[N], *db[N]; tree *update(tree *cur, int l, int r, int ind, int add) { tree *ret = new tree(l, r, 0); ret->sum += cur->sum + add; if (l == r) { ret->sum = cur->sum; ret->sum += add; return ret; } int mid = (l + r) / 2; if (ind <= mid) { if (!cur->left) { cur->left = new tree(l, mid, 0); } ret->right = cur->right; ret->left = update(cur->left, l, mid, ind, add); } else { if (!cur->right) { cur->right = new tree(mid + 1, r, 0); } ret->right = update(cur->right, mid + 1, r, ind, add); ret->left = cur->left; } return ret; } int getval(tree *cur, int l, int r, int ind) { if (l == r) { return cur->sum; } int mid = (l + r) / 2; if (ind <= mid) { if (!cur->left) return 0; return getval(cur->left, l, mid, ind); } else { if (!cur->right) return 0; return getval(cur->right, mid + 1, r, ind); } } int count(tree *cur, int l, int r, int ind) { if (cur == NULL) return 0; if (ind < l) { return 0; } if (r <= ind) { return cur->sum; } int mid = (l + r) / 2; int ret = 0; if (cur->left) ret = count(cur->left, l, mid, ind); if (cur->right) ret += count(cur->right, mid + 1, r, ind); return ret; } map<string, int> Hash; int main() { int q, i; string s, name; int pos = 1; int x; cin >> q; int n = 1e5; int m = 1e9; int C = 0, v; pq[C] = new tree(1, n, -1); db[C] = new tree(1, m, 0); while (q--) { cin >> s; if (s[0] == u ) { scanf( %d , &x); pq[C + 1] = pq[C - x]; db[C + 1] = db[C - x]; } else { cin >> name; if (!Hash.count(name)) { Hash[name] = pos++; } int id = Hash[name]; if (s[0] == s ) { scanf( %d , &x); v = getval(pq[C], 1, n, id); if (v != 0) { pq[C + 1] = update(pq[C], 1, n, id, -v + x); db[C + 1] = update(db[C], 1, m, v, -1); db[C + 1] = update(db[C + 1], 1, m, x, 1); } else { pq[C + 1] = pq[C], db[C + 1] = db[C]; pq[C + 1] = update(pq[C + 1], 1, n, id, x); db[C + 1] = update(db[C + 1], 1, m, x, 1); } } else if (s[0] == q ) { pq[C + 1] = pq[C]; db[C + 1] = db[C]; v = getval(pq[C + 1], 1, n, id); if (v != 0) { printf( %d n , count(db[C + 1], 1, m, v - 1)); } else printf( -1 n ); } else { pq[C + 1] = pq[C]; db[C + 1] = db[C]; v = getval(pq[C + 1], 1, n, id); if (v != 0) { pq[C + 1] = update(pq[C + 1], 1, n, id, -v); db[C + 1] = update(db[C + 1], 1, m, v, -1); } } } ++C; } }