Datasets:
malteklaes
/
cpp-code-code_search_net-style

Dataset card Data Studio Files
xet
Community
1
func_code_string
stringlengths
59
71.4k
#include <bits/stdc++.h> using namespace std; template <typename T, typename U> inline void smin(T &a, U b) { if (a > b) a = b; } template <typename T, typename U> inline void smax(T &a, U b) { if (a < b) a = b; } int power(int a, int b, int m, int ans = 1) { for (; b; b >>= 1, a = 1LL * a * a % m) if (b & 1) ans = 1LL * ans * a % m; return ans; } int a[110]; long long calc(long long first) { if (first == 0) return 0; int nn = 0; while (first) { a[nn++] = first % 2; first /= 2; } reverse(a, a + nn); int r = 0, ans = 0; for (int i = 0; i < nn; i++) if (!a[i]) r++; if (r == 1) ans++; r = 0; a[nn] = 0; for (int i = 0; i <= nn; i++) if (a[i] == 0) { r = i; break; } ans += r - 1; for (int i = 1; i < nn - 1; i++) ans += i; return ans; } int main() { long long first, second; scanf( %I64d %I64d , &first, &second); printf( %I64d n , calc(second) - calc(first - 1)); }
#include <bits/stdc++.h> using namespace std; vector<int> graph[123490]; bool attacked[123490], visited[123490]; int n, m, parent[123490]; int dist, last; void dfs(int u, int depth) { if (attacked[u]) { if (dist < depth) { dist = depth; last = u; } else { if (dist == depth) { last = min(last, u); } } } visited[u] = true; for (int i = (int)0; i <= (int)graph[u].size() - 1; i++) { int v = graph[u][i]; if (!visited[v]) { parent[v] = u; dfs(v, depth + 1); } } } vector<int> path; void augment_path(int v) { visited[v] = true; path.push_back(v); if (parent[v] == -1) return; augment_path(parent[v]); } int all = 0; bool dfs2(int u) { visited[u] = true; int ans = 0; for (int i = (int)0; i <= (int)graph[u].size() - 1; i++) { int v = graph[u][i]; if (!visited[v]) { ans |= dfs2(v); } } if (attacked[u]) ans = 1; all += ans; return ans; } int main() { cin >> n >> m; int u, v; for (int i = (int)1; i <= (int)n - 1; i++) { cin >> u >> v; graph[u].push_back(v); graph[v].push_back(u); } int tmp = 123490; for (int i = (int)1; i <= (int)m; i++) { cin >> u; attacked[u] = true; tmp = min(tmp, u); } dist = -1; dfs(tmp, 0); tmp = last; memset(parent, -1, sizeof parent); memset(visited, 0, sizeof visited); dist = -1; dfs(last, 0); cout << min(tmp, last) << endl; memset(visited, 0, sizeof visited); dfs2(tmp); cout << (all * 2) - 2 - dist << endl; return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 2e5 + 5; int a[N], b[N], par[N], val[N], sz[N], lst[N]; vector<int> his; pair<int, int> get(int v) { if (par[v] == v) return make_pair(v, val[v]); pair<int, int> g = get(par[v]); g.second ^= val[v]; return g; } bool merge(int u, int v) { pair<int, int> gu = get(u), gv = get(v); u = gu.first; v = gv.first; if (u == v) return false; if (sz[v] < sz[u]) swap(u, v), swap(gu, gv); par[u] = v; val[u] = gu.second ^ gv.second ^ 1; sz[v] += sz[u]; his.push_back(u); return true; } void undo(int cnt) { while (cnt--) { int u = his.back(); his.pop_back(); sz[par[u]] -= sz[u]; par[u] = u; val[u] = 0; } } void solve(int l, int r, int R) { if (r < l) return; int m = (l + r) >> 1, cnt = 0; for (int i = l; i < m; i++) if (merge(a[i], b[i])) cnt++; if (l < r) { bool f = merge(a[m], b[m]); solve(m + 1, r, R); if (f) undo(1); } lst[m] = m; for (int i = R; i >= m; i--) { if (get(a[i]) == get(b[i])) { lst[m] = i; break; } if (merge(a[i], b[i])) cnt++; } undo(cnt); cnt = 0; for (int i = R; i > lst[m]; i--) if (merge(a[i], b[i])) cnt++; solve(l, m - 1, lst[m]); undo(cnt); } int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); int n, m, q; cin >> n >> m >> q; for (int i = 1; i <= m; i++) cin >> a[i] >> b[i], lst[i] = m + 1; for (int i = 1; i <= n; i++) par[i] = i, sz[i] = 1; int ptr = 1; while (ptr <= m && get(a[ptr]) != get(b[ptr])) merge(a[ptr], b[ptr]), ptr++; if (m < ptr) { while (q--) cout << NO n ; return 0; } undo(his.size()); solve(1, ptr, m); while (q--) { int l, r; cin >> l >> r; cout << (ptr < l || r < lst[l] ? YES : NO ) << n ; } return 0; }
#include <bits/stdc++.h> using namespace std; int n, a[100005]; vector<int> all, empty; inline int read() { int x = 0, f = 1; char ch = getchar(); while (!isdigit(ch)) { if (ch == - ) f = -1; ch = getchar(); } while (isdigit(ch)) { (x *= 10) += ch - 0 ; ch = getchar(); } return x * f; } vector<int> solve(int x) { if (x > 19) return empty; bool flag = false; for (int v : all) if (v & 1) { flag = true; break; } if (!flag) { for (int &v : all) v >>= 1; return solve(x + 1); } vector<int> backup, nega, posi, res; backup = all; for (int &v : all) { if (v & 1) v = (v + 1) >> 1; else v = v >> 1; } { sort(all.begin(), all.end()); all.erase(unique(all.begin(), all.end()), all.end()); }; nega = solve(x + 1); all = backup; for (int &v : all) { if (v & 1) v = (v - 1) >> 1; else v = v >> 1; } { sort(all.begin(), all.end()); all.erase(unique(all.begin(), all.end()), all.end()); }; posi = solve(x + 1); nega.push_back(-(1 << x)), posi.push_back(1 << x); return nega.size() < posi.size() ? nega : posi; } int main() { n = read(); for (int i = 1; i <= n; i++) all.push_back(read()); vector<int> res = solve(0); sort(res.begin(), res.end()); printf( %lld n , res.size()); for (int v : res) printf( %d , v); return 0; }
#include <bits/stdc++.h> using namespace std; vector<long long int> g[100005]; vector<pair<long long int, long long int> > ed; vector<long long int> w; vector<long long int> eff; long long int vis[100005]; long long int val[100005]; long long int rec(long long int i) { if (vis[i] != 1) { vis[i] = 1; long long int cur = 1, j; for (j = 0; j < g[i].size(); ++j) { cur += rec(g[i][j]); } val[i] = cur; return cur; } else return 0; } int main() { long long int n, i, y, r, c; cin >> n; for (i = 0; i < n - 1; ++i) { long long int t1, t2, t3; cin >> t1 >> t2 >> t3; g[t1].push_back(t2); g[t2].push_back(t1); ed.push_back(make_pair(t1, t2)); w.push_back(t3); } rec(1); for (i = 0; i < n - 1; ++i) { long long int ef = 0; if (val[ed[i].first] > val[ed[i].second]) { ef = val[ed[i].second] * (n - val[ed[i].second]); } else { ef = val[ed[i].first] * (n - val[ed[i].first]); } eff.push_back(ef); } double ans = 0; for (i = 0; i < eff.size(); ++i) { ans = ans + (eff[i] * (double)w[i]); } cin >> y; for (i = 0; i < y; ++i) { cin >> r >> c; ans = ans - (eff[r - 1] * (double)(w[r - 1] - (double)c)); w[r - 1] = c; printf( %0.8lf n , ans * ((n - 2) * 6) / (n * (n - 1) * (n - 2))); } return 0; }
#include <bits/stdc++.h> using namespace std; const double PI = 2.0 * acos(0.0); const double EPS = 1e-9; const int MOD = 1000003; const int INF = 1000000000; const long long LINF = 1000000000000000000LL; vector<string> vs; bool row[500010], col[500010]; int main() { int n, m, ret = 1; cin >> n >> m; string str; for (int i = int(0); i <= int(n - 1); i++) { cin >> str, vs.push_back(str); for (int j = int(0); j <= int(m - 1); j++) if (vs[i][j] != . ) row[i] = col[j] = true; } bool val = true, par; for (int i = int(0); i <= int(n - 1); i++) { if (!row[i]) ret = 2 * ret % MOD; else { for (int j = int(0); j <= int(m - 1); j++) if (vs[i][j] != . ) par = (vs[i][j] < 3 && j % 2 == 0) || (vs[i][j] >= 3 && j % 2); for (int j = int(0); j <= int(m - 1); j++) if (vs[i][j] != . ) { if (j % 2) val &= par ? vs[i][j] >= 3 : vs[i][j] < 3 ; else val &= par ? vs[i][j] < 3 : vs[i][j] >= 3 ; } } } for (int j = int(0); j <= int(m - 1); j++) { if (!col[j]) ret = 2 * ret % MOD; else { for (int i = int(0); i <= int(n - 1); i++) if (vs[i][j] != . ) par = ((vs[i][j] == 1 || vs[i][j] == 4 ) && i % 2 == 0) || (!(vs[i][j] == 1 || vs[i][j] == 4 ) && i % 2); for (int i = int(0); i <= int(n - 1); i++) if (vs[i][j] != . ) { if (i % 2) val &= par ? !(vs[i][j] == 1 || vs[i][j] == 4 ) : (vs[i][j] == 1 || vs[i][j] == 4 ); else val &= par ? (vs[i][j] == 1 || vs[i][j] == 4 ) : !(vs[i][j] == 1 || vs[i][j] == 4 ); } } } if (!val) ret = 0; printf( %d n , ret); return 0; }
#include <bits/stdc++.h> using namespace std; long long n, m, x, y, a, b, t; long long q[55][55]; long long g[55][55]; int main() { cin >> n >> m; for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) cin >> q[i][j]; for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) { cin >> g[i][j]; if (g[i][j] < q[i][j]) swap(g[i][j], q[i][j]); if (q[i][j] <= q[i - 1][j] || q[i][j] <= q[i][j - 1]) t = 1; if (g[i][j] <= g[i - 1][j] || g[i][j] <= g[i][j - 1]) t = 1; } if (t == 1) cout << Impossible ; else cout << Possible ; return 0; }
#include <bits/stdc++.h> using namespace std; int n, parent[2005] = {}; int ans = -1e9; int solve(int x, int byk) { byk += 1; if (parent[x] == -1) return byk; return solve(parent[x], byk); } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); cin >> n; for (int i = 1; i <= n; i++) { cin >> parent[i]; } for (int i = 1; i <= n; i++) { ans = max(ans, solve(i, 0)); } cout << ans << n ; return 0; }
#include <bits/stdc++.h> using namespace std; void __print(int x) { cerr << x; } void __print(long x) { cerr << x; } void __print(long long x) { cerr << x; } void __print(unsigned x) { cerr << x; } void __print(unsigned long x) { cerr << x; } void __print(unsigned long long x) { cerr << x; } void __print(float x) { cerr << x; } void __print(double x) { cerr << x; } void __print(long double x) { cerr << x; } void __print(char x) { cerr << << x << ; } void __print(const char *x) { cerr << << x << ; } void __print(const string &x) { cerr << << x << ; } void __print(bool x) { cerr << (x ? true : false ); } template <typename T, typename V> void __print(const pair<T, V> &x) { cerr << { ; __print(x.first); cerr << , ; __print(x.second); cerr << } ; } template <typename T> void __print(const T &x) { int f = 0; cerr << { ; for (auto &i : x) cerr << (f++ ? , : ), __print(i); cerr << } ; } void _print() { cerr << ] n ; } template <typename T, typename... V> void _print(T t, V... v) { __print(t); if (sizeof...(v)) cerr << , ; _print(v...); } vector<long long> adj[200005]; void solve() { long long n, m; cin >> n >> m; for (long long i = 0; i < m; i++) { long long u, v; cin >> u >> v; adj[u].push_back(v); adj[v].push_back(u); } vector<long long> cnt(n + 1); vector<long long> a(n + 1); queue<long long> q; for (long long i = 1; i < n + 1; i++) { cin >> a[i]; if (!a[i]) q.push(i); } vector<long long> ans; vector<long long> vis(n + 1); while (!q.empty()) { long long p = q.front(); q.pop(); cnt[p]++; ans.push_back(p); for (auto x : adj[p]) { cnt[x]++; if (cnt[x] == a[x]) q.push(x); } } cout << ans.size() << n ; for (auto x : ans) cout << x << ; cout << n ; } signed main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); long long t; t = 1; for (long long i = 0; i < t; i++) { solve(); } }
#include <bits/stdc++.h> using namespace std; int main() { int t; cin >> t; while (t--) { int n; cin >> n; int arr[n]; for (int i = 0; i < n; i++) cin >> arr[i]; for (int i = n - 1; i >= 0; i--) cout << arr[i] << ; cout << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; long long n, l[100005], r[100005]; signed main() { scanf( %lld , &n); long long ans = 0; for (register long long i = 1; i <= n; i++) { scanf( %lld%lld , &l[i], &r[i]); } sort(l + 1, l + n + 1); sort(r + 1, r + n + 1); for (register long long i = 1; i <= n; i++) { ans += max(l[i], r[i]); } ans += n; cout << ans; }
#include <bits/stdc++.h> using namespace std; const int MAX = 1e5 + 9; int n, nxt[MAX], a[MAX]; int main() { cin >> n; for (int i = 0; i < n; i++) cin >> a[i]; int ans = 0; for (int l = 0; l < n; l++) { for (int i = n - 2, j = n - 1; i >= 0; i--) { while (i < j - a[j]) j--; nxt[i] = j; } for (int i = 0; i < n - 1; i = nxt[i]) ans++; rotate(a, a + n - 1, a + n); } cout << ans; }
#include <bits/stdc++.h> using namespace std; long long sqr(long long x) { return (long long)(x * x); } long long my_abs(long long x) { if (x < 0) return -x; return x; } const int MN = 1000 * 1000 * 10; int main() { long long ans = 0; long long n, m; cin >> n >> m; for (long long b = 1; b <= n; b++) { long long mx_c = min(b * b, m); long long tmp_ans = 2ll * (long long)(mx_c); long long up = (long long)sqrt(sqr(b) - 1.0); long long down = (long long)ceil(sqrt((double)(sqr(b) - (long long)mx_c))); if (down > up) { ans += tmp_ans; continue; } tmp_ans -= 2ll * (up - down + 1ll); ans += tmp_ans; } for (int x = -MN; x <= -1; x++) { int tmp1, tmp2; if (abs(x) % 2 == 0) { tmp1 = abs(x - 2) / 2; tmp2 = abs(x * 2); } else { tmp1 = abs(x - 1) / 2; tmp2 = abs(x); } if (tmp1 <= n && tmp2 <= m) ans++; } cout << ans; return 0; }
#include <bits/stdc++.h> using namespace std; int MOD = 1e6 + 3; int main() { int n, m; scanf( %d%d , &n, &m); char s[n][m + 1]; for (int i = (0); i < (int)(n); i++) scanf( %s , s[i]); bool c[m][2]; bool r[n][2]; memset(c, 0, sizeof(c)), memset(r, 0, sizeof(r)); for (int i = (0); i < (int)(n); i++) { for (int j = (0); j < (int)(m); j++) { if (isdigit(s[i][j])) { int first = s[i][j] - 1 ; int R = (first / 2 + j) % 2; int C = ((first + 1) % 4 / 2 + i) % 2; r[i][R] = 1; c[j][C] = 1; } } } int ans = 1; for (int i = (0); i < (int)(m); i++) { if (c[i][0] && c[i][1]) ans = 0; else if (!c[i][0] && !c[i][1]) ans = ans * 2 % MOD; } for (int i = (0); i < (int)(n); i++) { if (r[i][0] && r[i][1]) ans = 0; else if (!r[i][0] && !r[i][1]) ans = ans * 2 % MOD; } printf( %d n , ans); return 0; }
#include <bits/stdc++.h> using namespace std; const long long mod = 1e9 + 9; struct node { long long x, y, sum; } st[1200005]; int n, q, type, L, R, a[300005]; long long f[300005]; void build(int id, int l, int r) { if (l == r) { st[id].sum = a[l]; return; } int mid = l + r >> 1; build(id << 1, l, mid); build(id << 1 | 1, mid + 1, r); st[id].sum = (st[id << 1].sum + st[id << 1 | 1].sum) % mod; } void push(int id, int l, int r) { if (st[id].x == 0 && st[id].y == 0) return; int mid = l + r >> 1, pos = mid - l + 2; long long x = st[id].x, y = st[id].y; st[id << 1].x = (st[id << 1].x + x) % mod; st[id << 1].y = (st[id << 1].y + y) % mod; st[id << 1].sum = (st[id << 1].sum + x * f[mid - l + 1] + y * (f[mid - l + 2] - 1)) % mod; st[id << 1 | 1].x = (st[id << 1 | 1].x + x * f[pos - 2] + y * f[pos - 1]) % mod; st[id << 1 | 1].y = (st[id << 1 | 1].y + x * f[pos - 1] + y * f[pos]) % mod; st[id << 1 | 1].sum = (st[id << 1 | 1].sum + x * f[r - l + 1] + y * (f[r - l + 2] - 1) - x * f[mid - l + 1] - y * (f[mid - l + 2] - 1) + mod) % mod; st[id].x = st[id].y = 0; } void update(int id, int l, int r, int u, int v) { if (l > v or r < u) return; if (u <= l && r <= v) { st[id].x = (st[id].x + f[l - u + 1]) % mod; st[id].y = (st[id].y + f[l - u + 2]) % mod; st[id].sum = (st[id].sum + f[l - u + 1] * f[r - l + 1] % mod + f[l - u + 2] * (f[r - l + 2] - 1)) % mod; return; } push(id, l, r); int mid = l + r >> 1; update(id << 1, l, mid, u, v); update(id << 1 | 1, mid + 1, r, u, v); st[id].sum = (st[id << 1].sum + st[id << 1 | 1].sum) % mod; } long long query(int id, int l, int r, int u, int v) { if (l > v or r < u) return 0; if (u <= l && r <= v) return st[id].sum; push(id, l, r); int mid = l + r >> 1; return (query(id << 1, l, mid, u, v) + query(id << 1 | 1, mid + 1, r, u, v)) % mod; } signed main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); cin >> n >> q; f[1] = 1; for (int i = 1; i <= n; ++i) { cin >> a[i]; if (i > 1) f[i] = (f[i - 1] + f[i - 2]) % mod; } f[n + 1] = (f[n] + f[n - 1]) % mod; build(1, 1, n); while (q--) { cin >> type >> L >> R; if (type == 1) update(1, 1, n, L, R); else cout << (query(1, 1, n, L, R) + mod) % mod << endl; } }
#include <bits/stdc++.h> using namespace std; string makeCentered(int len) { string output; for (int i = 0; i < 27; i++) { output.push_back( . ); } for (int i = 0; i < len; i++) { output[13 + i] = X ; output[13 - i] = X ; } return output; } string blank() { string output; for (int i = 0; i < 27; i++) { output.push_back( . ); } return output; } int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); string input; cin >> input; vector<int> target; for (int i = 0; i < input.size(); i++) { target.push_back(int(input[i])); } vector<string> output; int val = 0; for (int i = 0; i < target.size(); i++) { int curTarget = target[i]; vector<int> triSizes; int distance = curTarget - val; if (i != 0) distance = val - curTarget; while (distance < 0) distance += 256; while (distance > 0) { if (i == 0) { for (int j = 12; j >= (i == 0 ? 1 : 2); j--) { int next; if (i != 0) next = j * j - 1; else next = j * j; if (next <= distance) { for (int k = 1; k <= j + 1; k++) { cout << makeCentered(k) << endl; } distance -= next; val += next; val %= 256; cout << blank() << endl; break; } } } else { cout << makeCentered(1) << endl; cout << blank() << endl; distance -= 1; val -= 1; if (val < 0) val += 256; } } cout << blank() << endl; string curString = blank(); curString[0] = X ; curString[curString.size() - 1] = X ; cout << curString << endl; curString[curString.size() - 1] = . ; cout << curString << endl; cout << blank() << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 100005; const int INF = 0x3f3f3f3f; int n, lm, rm; int q[N], fa[N], sz[N]; bool use[N]; vector<pair<int, int> > g[N]; int getc(int u) { int qn = 0; fa[q[qn++] = u] = u; for (int i = 0; i < qn; i++) { u = q[i]; sz[u] = 1; for (int j = 0; j < g[u].size(); j++) { int v = g[u][j].first; if (use[v] || v == fa[u]) continue; fa[q[qn++] = v] = u; } } for (int i = qn - 1; i >= 0; i--) { int u = q[i]; if (sz[u] * 2 > qn) return u; sz[fa[u]] += sz[u]; } } int dep[N]; void dfs(int u, int p) { dep[u] = 1; for (int i = 0; i < g[u].size(); i++) { int v = g[u][i].first; if (v == p || use[v]) continue; dfs(v, u); dep[u] = max(dep[u], dep[v] + 1); } } bool cmp(pair<int, int> a, pair<int, int> b) { return dep[a.first] < dep[b.first]; } int Maxc; pair<int, int> f[N], ff[N]; int Q[N]; void dfs(int u, int p, int d, int val, int mid) { f[d] = max(f[d], make_pair(val, u)); for (int i = 0; i < g[u].size(); i++) { int v = g[u][i].first; int w = g[u][i].second; if (v == p || use[v]) continue; dfs(v, u, d + 1, val + (w >= mid ? 1 : -1), mid); } } pair<int, int> tmp; bool judge(int u, int mid) { int pre = 0; for (int i = 0; i <= dep[u]; i++) ff[i] = make_pair(-INF, 0); ff[0] = make_pair(0, u); int ed = 0; for (int ii = 0; ii < g[u].size(); ii++) { int v = g[u][ii].first; int w = g[u][ii].second; if (use[v]) continue; for (int i = 0; i <= dep[v]; i++) f[i] = make_pair(-INF, 0); dfs(v, u, 1, w >= mid ? 1 : -1, mid); int head = 0, rear = 0; for (int i = 0; i <= dep[v]; i++) { while (ed >= 0 && i + ed >= lm) { while (head < rear && ff[Q[rear - 1]] < ff[ed]) rear--; Q[rear++] = ed--; } while (head < rear && Q[head] + i > rm) head++; if (head < rear && ff[Q[head]].first + f[i].first >= 0) { tmp = make_pair(ff[Q[head]].second, f[i].second); return true; } } for (int i = 0; i <= dep[v]; i++) ff[i] = max(f[i], ff[i]); ed = dep[v]; } return false; } int ans = -1; pair<int, int> an; void cal(int u) { dfs(u, u); sort(g[u].begin(), g[u].end(), cmp); int l = ans, r = Maxc; while (l < r) { int mid = (l + r) >> 1; if (judge(u, mid)) l = mid + 1; else r = mid; } judge(u, l - 1); if (ans < l - 1) { ans = l - 1; an = tmp; } } void go(int c) { int rt = getc(c); use[rt] = true; cal(rt); for (int i = 0; i < g[rt].size(); i++) { int v = g[rt][i].first; if (use[v]) continue; go(v); } } int main() { scanf( %d%d%d , &n, &lm, &rm); int u, v, w; for (int i = 1; i <= n - 1; i++) { scanf( %d%d%d , &u, &v, &w); Maxc = max(Maxc, w + 1); g[u].push_back(make_pair(v, w)); g[v].push_back(make_pair(u, w)); } go(1); printf( %d %d n , an.first, an.second); return 0; }
#include <bits/stdc++.h> int main() { int n, m; double resn, resm; scanf( %d%d , &n, &m); resn = m / (double)n; resm = log(m) / log(n); if (resn > resm) { printf( > n ); } else if (resn < resm) { printf( < n ); } else printf( = n ); return 0; }
#include <bits/stdc++.h> using namespace std; void solve() { int n; cin >> n; int arr[n]; for (int i = 0; i < n; i++) cin >> arr[i]; vector<int> a(n + 1); for (int i = 1; i <= n; i++) { a[i] = a[i - 1] + arr[i - 1]; } int m; cin >> m; for (int i = 0; i < m; i++) { int l, r; cin >> l >> r; l--; cout << (a[r] - a[l]) / 10 << endl; } } int main() { ios_base::sync_with_stdio(0); cin.tie(NULL); int t = 1; while (t--) solve(); return 0; }
#include <bits/stdc++.h> using namespace std; const int maxn = 700 + 7; const int MOD = 1e9 + 7; const int INF = 1e9 + 7; int a[maxn]; int g[maxn][maxn]; int n; struct as { int l, r, v; bool operator<(const as& b) const { if (l < b.l) return true; if (l > b.l) return false; if (r < b.r) return true; if (r > b.r) return false; return v < b.v; } }; map<as, bool> mp; int gcd(int x, int y) { return x == 0 ? y : gcd(y % x, x); } void get() { int i, j; for (i = 0; i <= n; i++) { for (j = 0; j <= n; j++) { if (i != j && gcd(a[i], a[j]) != 1) { g[i][j] = 1; } } } return; } bool solve(int l, int r, int pos) { if (l > r) return true; if (mp.count(as{l, r, pos})) { return mp[as{l, r, pos}]; } int i, j; for (i = l; i <= r; i++) { if (g[pos][i]) { if (solve(l, i - 1, i) && solve(i + 1, r, i)) { mp[as{l, r, pos}] = true; return true; } } } mp[as{l, r, pos}] = false; return false; } int main() { int i, j, m, t, z; scanf( %d , &n); for (i = 1; i <= n; i++) { scanf( %d , &a[i]); } get(); if (solve(1, n, 0)) { puts( Yes ); } else puts( No ); return 0; }
#include <bits/stdc++.h> using namespace std; int a[1000005], b[1000005]; int main() { int n, ans = 0; cin >> n; for (int i = 1; i <= n; i++) { int x; scanf( %d , &x); a[x]++; } for (int i = 1000000; i >= 1; i--) { if (!a[i]) continue; b[i] = 1; for (int j = 2 * i; j <= 1000000; j += i) { if (a[j] && b[i] < b[j] + 1) b[i] = b[j] + 1; } if (ans < b[i]) ans = b[i]; } cout << ans; return 0; }
#include <bits/stdc++.h> using namespace std; int n, m, x, y, vx, vy; int refx, refy; long long exgcd(long long a, long long b, long long &x, long long &y) { if (!b) { x = 1, y = 0; return a; } long long res = exgcd(b, a % b, y, x); y -= (a / b) * x; return res; } int main() { scanf( %d%d%d%d%d%d , &n, &m, &x, &y, &vx, &vy); if (vx == 0) { if (x == 0 || x == n) { if (vy == 1) printf( %d %d n , x, m); else printf( %d %d n , x, 0); } else puts( -1 ); return 0; } if (vy == 0) { if (y == 0 || y == m) { if (vx == 1) printf( %d %d n , n, y); else printf( %d %d n , 0, y); } else puts( -1 ); return 0; } if (vx == -1) refx = 1, x = n - x; if (vy == -1) refy = 1, y = m - y; long long a, b, g; g = exgcd(n, m, a, b); if ((x - y) % g != 0) { puts( -1 ); return 0; } long long t = (x - y) / g; a *= t, b *= t; int _m = m / g, _n = n / g; long long _a = (a % _m + _m + _m - 1) % _m + 1, _b = -((x - y) - _a * n) / m; long long ansx = n, ansy = m; if (_a % 2 == 0) ansx = n - ansx; if (_b % 2 == 0) ansy = m - ansy; if (refx) ansx = n - ansx; if (refy) ansy = m - ansy; printf( %I64d %I64d , ansx, ansy); return 0; }
#include <bits/stdc++.h> using namespace std; const long long int mod = 998244353; const int sz = 1e5 + 3, inf = 1e9 + 10; int a[sz], match[sz], c[sz]; int fr[sz]; bool vis[sz]; long long int x[sz]; void solve() { memset(vis, 1, sizeof vis); memset(match, 0, sizeof match); int n; cin >> n; for (int i = 1; i <= n; i++) { int k; cin >> k; for (int j = 0; j < k; j++) cin >> a[j]; for (int j = 0; j < k; j++) { if (vis[a[j]]) { vis[a[j]] = 0; match[i] = a[j]; break; } } } bool f = 0; for (int i = 1; i <= n; i++) { if (match[i]) continue; for (int j = 1; j <= n; j++) { if (vis[j]) { cout << IMPROVE n ; cout << i << << j << n ; f = 1; break; } } if (f) break; } if (!f) cout << OPTIMAL n ; } int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); int t; cin >> t; while (t--) solve(); return 0; }
#include <bits/stdc++.h> using namespace std; const long long maxn = 123; long long a[maxn], b[maxn], n, m; char s[maxn]; long long vis[20], t[20], sb[maxn]; void dfs(long long stp, long long sa) { if (sa > sb[stp + 1]) return; if (stp == 0) { cout << sa << endl; exit(0); } if (stp > n) { dfs(stp - 1, sa); return; } for (long long i = 9; i >= 0; i--) if (vis[i] && sa * 10 + i <= sb[stp]) { --vis[i]; dfs(stp - 1, sa * 10 + i); ++vis[i]; } } int main() { long long i; scanf( %s , s + 1); n = strlen(s + 1); for (i = 1; i <= n; i++) a[i] = s[n - i + 1] - 0 ; scanf( %s , s + 1); m = strlen(s + 1); for (i = 1; i <= m; i++) b[i] = s[m - i + 1] - 0 ; for (i = m; i; i--) sb[i] = sb[i + 1] * 10 + b[i]; for (i = 1; i <= n; i++) ++vis[a[i]]; dfs(m, 0); return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 2e5 + 5; int n, l[N], r[N], id[N]; bool cmp(int x, int y) { return r[x] == r[y] ? l[x] < l[y] : r[x] < r[y]; } int main() { cin >> n; for (int x, w, i = 1; i <= n; ++i) { cin >> x >> w; l[i] = x - w, r[i] = x + w, id[i] = i; } sort(id + 1, id + n + 1, cmp); int ans = 0, las = -2e9; for (int i = 1; i <= n; ++i) if (las <= l[id[i]]) ++ans, las = r[id[i]]; cout << ans; return 0; }
#include <bits/stdc++.h> using namespace std; const int NMAX = 110, VMAX = 1000100; int T, N; int number[NMAX], diff[NMAX * NMAX]; int b[NMAX]; bool val[VMAX]; int main() { int i, j, k, t; bool flag; scanf( %d , &T); for (t = 0; t < T; t += 1) { memset(val, 0, sizeof(val)); memset(diff, 0, sizeof(diff)); flag = true; scanf( %d , &N); for (i = 1; i <= N; i += 1) { scanf( %d , &number[i]); if (val[number[i]]) flag = false; val[number[i]] = true; } sort(number + 1, number + N + 1); if (!flag) printf( NO n ); else if (N == 1) printf( YES n1 n ); else { for (i = 1; i <= N; i += 1) { for (j = i + 1; j <= N; j += 1) diff[++diff[0]] = number[j] - number[i]; } memset(val, 0, sizeof(val)); sort(diff + 1, diff + diff[0] + 1); diff[0] = unique(diff + 1, diff + diff[0] + 1) - diff - 1; printf( YES n ); for (i = 1; i <= N; i += 1) { for (j = b[i - 1] + 1; val[j]; j += 1) ; b[i] = j; printf( %d%c , b[i], n [i == N ? 1 : 0]); for (k = 1; k <= diff[0]; k += 1) val[diff[k] + b[i]] = true; } } } exit(0); }
#include <bits/stdc++.h> using namespace std; const long long mod = 998244353; long long bin_pow(long long a, long long b) { if (b == 0) { return 1; } long long res = bin_pow(a, b / 2); res *= res; res %= mod; if (b % 2) { res *= a; res %= mod; } return res; } long long inv(long long x) { return bin_pow(x, mod - 2); } int32_t main() { ios_base::sync_with_stdio(0); long long n; cin >> n; n *= 2; vector<long long> a(n); for (long long i = 0; i < (long long)(n); i++) { cin >> a[i]; } sort(a.begin(), a.end()); long long ans = 0; n /= 2; for (long long i = 0; i < (long long)(n); i++) { ans -= a[i]; } for (long long i = 0; i < (long long)(n); i++) { ans += a[i + n]; } ans %= mod; for (long long i = 0; i < (long long)(n); i++) { ans *= n + 1 + i; ans %= mod; } for (long long i = 0; i < (long long)(n); i++) { ans *= inv(i + 1); ans %= mod; } cout << ans << endl; }
#include <bits/stdc++.h> int main(int argc, char const *argv[]) { int n, i; scanf( %d , &n); getchar(); char row[n]; for (i = 0; i < n; ++i) { row[i] = getchar(); } if (n == 1 && row[0] == 0 ) { printf( No n ); return 0; } for (i = 1; i < n; ++i) { if (row[i] == 1 && row[i - 1] == 1 ) { printf( No n ); return 0; } } int cantCero = 0; if (row[0] == 0 ) { cantCero++; } for (i = 1; i < n; ++i) { if (row[i] == 0 ) { if (row[i - 1] == 0 ) { cantCero++; } else { cantCero = 1; } if (cantCero == 2 && (i == 1 || i == n - 1)) { printf( No n ); return 0; } if (cantCero == 3) { printf( No n ); return 0; } } else { cantCero = 0; } } printf( Yes n ); return 0; }
#include <bits/stdc++.h> using namespace std; using ll = long long; using ull = unsigned long long; using ld = long double; template <typename T1, typename T2> inline void chkmin(T1& x, const T2& y) { if (y < x) x = y; } template <typename T1, typename T2> inline void chkmax(T1& x, const T2& y) { if (x < y) x = y; } const int N = 1e5 + 10; const int B = 300; struct Node { int next_node; int prev_node; int jump; }; int n, q; Node nodes[N]; bool used[N]; int find_jump(int v) { for (int i = 0; i < B; ++i) { v = nodes[v].next_node; } return v; } void build() { for (int i = 0; i < n; ++i) { if (used[i]) continue; int v = i; int jump = find_jump(i); while (!used[v]) { used[v] = true; nodes[v].jump = jump; v = nodes[v].next_node; jump = nodes[jump].next_node; } } } void relax_jumps(int v) { int jump = v; for (int i = 0; i < B; ++i) { v = nodes[v].prev_node; } for (int i = 0; i <= B; ++i) { nodes[v].jump = jump; v = nodes[v].next_node; jump = nodes[jump].next_node; } } void upd(int i, int j) { int next_i = nodes[i].next_node; int next_j = nodes[j].next_node; nodes[i].next_node = next_j; nodes[j].next_node = next_i; nodes[next_i].prev_node = j; nodes[next_j].prev_node = i; relax_jumps(i); relax_jumps(j); } int getAns(int v, int k) { while (k) { if (k >= B) { v = nodes[v].jump; k -= B; } else { v = nodes[v].next_node; --k; } } return v; } signed main() { ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0); cout.precision(20), cout.setf(ios::fixed); cin >> n >> q; for (int i = 0; i < n; ++i) { cin >> nodes[i].next_node; --nodes[i].next_node; nodes[nodes[i].next_node].prev_node = i; } build(); while (q--) { int t; cin >> t; if (t == 1) { int i, j; cin >> i >> j; --i; --j; upd(i, j); } else if (t == 2) { int v, k; cin >> v >> k; --v; cout << getAns(v, k) + 1 << n ; } else { assert(false); } } return 0; }
#include <bits/stdc++.h> using namespace std; const int MAX = 100 + 10; pair<int, int> d[MAX]; int main() { int i; set<int> first, second; for ((i) = (1); (i) <= (8); ++(i)) { scanf( %d%d , &d[i].first, &d[i].second); first.insert(d[i].first); second.insert(d[i].second); } if (first.size() != 3 || second.size() != 3) { cout << ugly << endl; return 0; } set<int>::iterator a, b; for ((a) = (first.begin()); (a) != (first.end()); ++(a)) for ((b) = (second.begin()); (b) != (second.end()); ++(b)) { int flag = 0; for ((i) = (1); (i) <= (8); ++(i)) if (d[i].first == *a && d[i].second == *b) { flag = 1; break; } if (a == ++first.begin() && b == ++second.begin()) { if (flag) { cout << ugly << endl; return 0; } } else if (!flag) { cout << ugly << endl; return 0; } } cout << respectable << endl; return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 1e5 + 10; const long long inf = 1e18 + 10; long long dis[N], sid[N], mark[N], h[N], dp[N], c[N]; pair<pair<long long, long long>, long long> E[N]; vector<pair<long long, long long> > adj[N], jda[N], g[N]; priority_queue<pair<long long, long long>, vector<pair<long long, long long> >, greater<pair<long long, long long> > > pq; void dfs(long long v, long long id) { mark[v] = 1; dp[v] = inf; for (pair<long long, long long> e : g[v]) { long long u = e.first, ind = e.second; if (ind == id) continue; if (mark[u]) { dp[v] = min(dp[v], h[u]); } else { h[u] = h[v] + 1; dfs(u, ind); dp[v] = min(dp[v], dp[u]); if (h[v] < dp[u]) c[ind] = 1; } } } int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); long long n, m, s, t; cin >> n >> m >> s >> t; for (int i = 0; i < m; i++) { long long u, v, w; cin >> u >> v >> w; adj[u].push_back({v, w}); jda[v].push_back({u, w}); E[i] = {{u, v}, w}; } fill(dis, dis + N, inf); dis[s] = 0; pq.push({0, s}); while (!pq.empty()) { long long d = pq.top().first, v = pq.top().second; pq.pop(); if (d != dis[v]) continue; for (pair<long long, long long> e : adj[v]) { long long u = e.first, w = e.second; if (d + w < dis[u]) { dis[u] = d + w; pq.push({d + w, u}); } } } fill(sid, sid + N, inf); sid[t] = 0; pq.push({0, t}); while (!pq.empty()) { long long d = pq.top().first, v = pq.top().second; pq.pop(); if (d != sid[v]) continue; for (pair<long long, long long> e : jda[v]) { long long u = e.first, w = e.second; if (d + w < sid[u]) { sid[u] = d + w; pq.push({d + w, u}); } } } for (int i = 0; i < m; i++) { long long u = E[i].first.first, v = E[i].first.second, w = E[i].second; if (dis[u] + w + sid[v] == dis[t]) { g[u].push_back({v, i}); g[v].push_back({u, i}); } } dfs(s, -1); for (int i = 0; i < m; i++) { long long u = E[i].first.first, v = E[i].first.second, w = E[i].second; if (dis[u] + w + sid[v] == dis[t]) { if (c[i]) cout << YES n ; else if (1 < w) cout << CAN << << 1 << n ; else cout << NO n ; } else { long long cst = dis[u] + w + sid[v]; long long dif = cst - dis[t] + 1; if (dif < w) cout << CAN << << dif << n ; else cout << NO n ; } } return 0; }
#include <bits/stdc++.h> using namespace std; int n, m; int p[2 * 100001], rnk[2 * 100001]; int cnt[2 * 100001]; long long pref[2 * 100001 + 5]; long long ans[2 * 100001 + 5]; vector<pair<int, int> > q; struct Edge { int a, b; int w; Edge(int a, int b, int w) : a(a), b(b), w(w) {} }; vector<Edge> e; bool comp(const Edge &one, const Edge &two) { return one.w < two.w; } void init() { pref[0] = 0; for (int i = 1; i <= 2 * 100001; ++i) pref[i] = pref[i - 1] + (i - 1); } void dsu_init() { for (int i = 0; i < 2 * 100001; ++i) { p[i] = i; rnk[i] = 0; cnt[i] = 1; } } int dsu_find(int v) { if (p[v] == v) return v; return p[v] = dsu_find(p[v]); } int dsu_meld(int a, int b, int &prev) { a = dsu_find(a), b = dsu_find(b); if (a == b) return 0; if (rnk[a] < rnk[b]) swap(a, b); p[b] = a; cnt[a] += cnt[b]; prev = cnt[b]; if (rnk[a] == rnk[b]) ++rnk[a]; return cnt[a]; } int main() { cin.sync_with_stdio(0); cin.tie(NULL); cout.tie(NULL); init(); dsu_init(); cin >> n >> m; int a, b, w; for (int i = 0; i < n - 1; ++i) { cin >> a >> b >> w; --a, --b; e.emplace_back(a, b, w); } sort(e.begin(), e.end(), comp); for (int i = 0; i < m; ++i) { cin >> a; q.push_back({a, i}); } sort(q.begin(), q.end()); long long sum = 0; int bnd = 0; int prev, now; for (int i = 0; i < q.size(); ++i) { for (int j = bnd; j < e.size(); ++j) { if (e[j].w > q[i].first) break; now = dsu_meld(e[j].a, e[j].b, prev); sum -= pref[prev]; sum += (pref[now] - pref[now - prev]); ++bnd; } ans[q[i].second] = sum; } for (int i = 0; i < m; ++i) cout << ans[i] << ; return 0; }
#include <bits/stdc++.h> using namespace std; template <class T> inline T gcd(T a, T b) { return (b) == 0 ? (a) : gcd((b), ((a) % (b))); } template <class T> inline T lcm(T a, T b) { return ((a) / gcd((a), (b)) * (b)); } template <class T> inline T BigMod(T Base, T power, T M = 1000000007) { if (power == 0) return 1; if (power & 1) return ((Base % M) * (BigMod(Base, power - 1, M) % M)) % M; else { T y = BigMod(Base, power / 2, M) % M; return (y * y) % M; } } template <class T> inline T ModInv(T A, T M = 1000000007) { return BigMod(A, M - 2, M); } int fx[] = {-1, +0, +1, +0, +1, +1, -1, -1, +0}; int fy[] = {+0, -1, +0, +1, +1, -1, +1, -1, +0}; int day[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; double arr[111]; double dp[111]; double pre[111]; int main() { int n, i, j; double answer = 0; cin >> n; for (i = 1; i <= n; i++) cin >> arr[i]; sort(arr + 1, arr + n + 1); dp[n] = arr[n]; pre[n] = (1 - arr[n]); for (i = n - 1; i >= 1; i--) { pre[i] = (1 - arr[i]) * pre[i + 1]; dp[i] = arr[i] * pre[i + 1] + dp[i + 1] * (1 - arr[i]); } for (i = 1; i <= n; i++) answer = max(answer, dp[i]); printf( %.10f , answer); return 0; }
#include <bits/stdc++.h> using namespace std; const int fx[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}}; const int fxx[8][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}, {1, 1}, {1, -1}, {-1, 1}, {-1, -1}}; template <typename T, typename TT> ostream& operator<<(ostream& s, pair<T, TT> t) { return s << ( << t.first << , << t.second << ) ; } template <typename T> ostream& operator<<(ostream& s, vector<T> t) { s << [ ; for (int i = 0; i < ((int)(t.size())) - 1; i++) s << t[i] << , ; s << t[((int)(t.size())) - 1] << ] ; return s; } const int MOD = 1e9 + 7; template <typename T> inline T gcD(T a, T b) { if (a < b) swap(a, b); while (b) { a = a % b; b ^= a; a ^= b; b ^= a; }; return a; } template <typename T> inline T pow_mod(T a, T b) { T res = 1; while (b) { if (b & 1) res = (res * a) % MOD; a = (a * a) % MOD; b >>= 1; } return res; } struct Node { int value, x, y; bool operator<(const Node other) const { if (value == other.value && x == other.x) return y < other.y; else if (value == other.value) return x < other.x; else return value < other.value; } }; const int MAXN = 310; int room[MAXN][MAXN]; int dis[MAXN][MAXN]; vector<Node> dp[MAXN * MAXN]; vector<Node> bfs; int main() { int n, m, p; cin >> n >> m >> p; for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) { cin >> room[i][j]; if (room[i][j] == 1) { dp[1].push_back({i + j, i, j}); } else dp[room[i][j]].push_back({(int)1e9, i, j}); } for (int i = 2; i < p + 1; i++) { if (dp[i - 1].size() * dp[i].size() >= n * m) { bfs.clear(); sort(dp[i - 1].begin(), dp[i - 1].end()); bfs.push_back(dp[i - 1][0]); for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) dis[i][j] = (int)1e9; dis[dp[i - 1][0].x][dp[i - 1][0].y] = dp[i - 1][0].value; int pt = 1; int j = 0; while (j < bfs.size()) { Node top = bfs[j++]; while (pt < dp[i - 1].size() && dp[i - 1][pt].value <= top.value) bfs.push_back(dp[i - 1][pt++]); for (int k = 0; k < 4; k++) { int new_x = top.x + fx[k][0]; int new_y = top.y + fx[k][1]; if (new_x >= 0 && new_x < n && new_y >= 0 && new_y < m) { if (dis[new_x][new_y] > top.value + 1) { dis[new_x][new_y] = top.value + 1; bfs.push_back({dis[new_x][new_y], new_x, new_y}); } } } } for (__typeof((dp[i]).begin()) v = (dp[i]).begin(); v != (dp[i]).end(); ++v) { v->value = dis[v->x][v->y]; } } else { for (__typeof((dp[i]).begin()) v = (dp[i]).begin(); v != (dp[i]).end(); ++v) { for (__typeof((dp[i - 1]).begin()) w = (dp[i - 1]).begin(); w != (dp[i - 1]).end(); ++w) { v->value = min(v->value, w->value + abs(w->x - v->x) + abs(w->y - v->y)); } } } } cout << dp[p][0].value << endl; return 0; }
#include <bits/stdc++.h> using namespace std; map<int, int> mp; int a[100010]; int main() { int i = 0, j = 0; int n, m; while (scanf( %d%d , &n, &m) != EOF) { mp.clear(); int f; for (i = 1; i <= n; ++i) { scanf( %d , &f); if (mp.find(f) != mp.end()) { mp[f] = -2; } else { mp[f] = i; } } int b; bool flag1 = false; bool flag2 = false; for (i = 1; i <= m; ++i) { scanf( %d , &b); if (!flag1) { if (mp.find(b) == mp.end()) { flag1 = true; } else if (-2 == mp[b]) { flag2 = true; } else { a[i] = mp[b]; } } } if (flag1) { printf( Impossible n ); } else if (flag2) { printf( Ambiguity n ); } else { printf( Possible n ); for (int i = 1; i <= m; ++i) { printf( %d , a[i]); } printf( n ); } } return 0; }
#include <bits/stdc++.h> using namespace std; int vis[1500000 + 5], a[1000006], marked[1500000], pt = 2; vector<int> v[1500000 + 5]; bool broken; bool hoyKina(int x) { for (int i = 0; i < v[x].size(); i++) { if (marked[v[x][i]]) return false; } for (int i = 0; i < v[x].size(); i++) { marked[v[x][i]] = 1; } return true; } int cal(int x) { if (broken) { while (1) { if (hoyKina(pt)) return pt; pt++; } } while (1) { if (hoyKina(x)) return x; broken = true; x++; } } int main() { for (int i = 2; i <= 1500000; i++) { if (vis[i]) continue; for (int j = i; j <= 1500000; j += i) { vis[j] = 1; v[j].push_back(i); } } int n, x; cin >> n; for (int i = 1; i <= n; i++) { cin >> x; printf( %d , cal(x)); } printf( n ); return 0; }
#include <bits/stdc++.h> using namespace std; const bool debug = true; const int MAXN = 100010; int dp[MAXN], t[MAXN]; const int inf = 2000000010; int n; int first_lower(int x) { if (x < 0) return 0; return upper_bound(t + 1, t + n + 1, x) - t - 1; } struct node { int mx; int lazy; node() {} node(int _mx, int _lazy) { mx = _mx; lazy = _lazy; } node operator+(const node &a) const { return *(new node(max(mx, a.mx), 0)); } } st[4 * MAXN]; int value[MAXN]; void propagate(int idx, int left, int right) { if (st[idx].lazy == 0) return; st[idx].mx += st[idx].lazy; if (left != right) { st[2 * idx].lazy += st[idx].lazy; st[2 * idx + 1].lazy += st[idx].lazy; } st[idx].lazy = 0; } void update(int idx, int left, int right, int l, int r, int val) { if (l <= left && right <= r) { st[idx].lazy += val; return; } propagate(idx, left, right); if (r > (left + right) / 2) update(2 * idx + 1, (left + right) / 2 + 1, right, l, r, val); if (l <= (left + right) / 2) update(2 * idx, left, (left + right) / 2, l, r, val); propagate(2 * idx, left, (left + right) / 2); propagate(2 * idx + 1, (left + right) / 2 + 1, right); st[idx] = st[2 * idx] + st[2 * idx + 1]; } int get(int idx, int left, int right) { propagate(idx, left, right); if (left != right) { propagate(2 * idx, left, (left + right) / 2); propagate(2 * idx + 1, (left + right) / 2 + 1, right); } if (left == right) if (st[idx].mx > 0) return value[left]; else return -1; if (st[2 * idx + 1].mx > 0) return get(2 * idx + 1, (left + right) / 2 + 1, right); else if (st[2 * idx].mx > 0) return get(2 * idx, left, (left + right) / 2); else return -1; } int main() { scanf( %d , &n); for (int i = 1; i <= n; i++) { int p, type; scanf( %d %d , &p, &type); if (type == 1) { int val; scanf( %d , &val); value[p] = val; update(1, 1, n, 1, p, 1); } else update(1, 1, n, 1, p, -1); printf( %d n , get(1, 1, n)); } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int n, k; cin >> n >> k; string s; cin >> s; if (n == 1 && k == 1) { cout << 0 << endl; return 0; } if (s[0] != 1 && k) { k--; s[0] = 1 ; } for (int i = 1; i < n && k; i++) { if (s[i] != 0 ) { s[i] = 0 ; k--; } } cout << s << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int getint() { unsigned int c; int x = 0; while (((c = getchar()) - 0 ) >= 10) { if (c == - ) return -getint(); if (!~c) exit(0); } do { x = (x << 3) + (x << 1) + (c - 0 ); } while (((c = getchar()) - 0 ) < 10); return x; } int getc_str(char str[]) { unsigned int c, n = 0; while ((c = getchar()) <= ) ; if (!~c) exit(0); do { str[n++] = c; } while ((c = getchar()) > ); str[n] = 0 ; return n; } const long long MOD = 1000000007; long long dp[123][2789]; int n; char in[123]; int main() { int i, j, k, tcc, tc = getint(); dp[0][0] = 1; for (i = 0; i < 111; i++) { for (j = 0; j <= 2600; j++) { for (k = 0; k < 26; k++) { (dp[i + 1][j + k] += dp[i][j]) %= MOD; } } } for (tcc = 0; tcc < tc; tcc++) { n = getc_str(in); int sum = 0; for (i = 0; i < n; i++) sum += in[i] - a ; int res = (dp[n][sum] - 1 + MOD) % MOD; printf( %d n , res); } return 0; }
#include <bits/stdc++.h> using namespace std; struct Edge { int x; int y; int w; }; const int N = 200 + 7; const int INF = (int)1e9; int n; int m; int d[N][N]; struct T { int f; int s; }; bool operator<(T a, T b) { return a.s - a.f < b.s - b.f; } int solve(int x, int y, int w) { vector<T> pts; for (int i = 1; i <= n; i++) { pts.push_back({d[x][i], d[y][i] + w}); } sort(pts.begin(), pts.end()); vector<int> pre(n), suf(n); pre[0] = pts[0].s; for (int i = 1; i < n; i++) { pre[i] = max(pre[i - 1], pts[i].s); } suf[n - 1] = pts[n - 1].f; for (int i = n - 2; i >= 0; i--) { suf[i] = max(suf[i + 1], pts[i].f); } vector<int> tt(n); for (int i = 0; i < n; i++) { tt[i] = (pts[i].s - pts[i].f) / 2; } int ret = INF; for (int last = -1; last < n; last++) { if (last == -1) { int m_suf = suf[last + 1]; int t = tt[last + 1]; ret = min(ret, m_suf + t); continue; } if (last == n - 1) { int m_pre = pre[last]; int t = tt[last]; ret = min(ret, m_pre - t); continue; } int t1 = tt[last]; int t2 = tt[last + 1]; int m_pre = pre[last]; int m_suf = suf[last + 1]; ret = min(ret, max(m_suf + t1, m_pre - t1)); ret = min(ret, max(m_suf + t2, m_pre - t2)); int t = (m_pre - m_suf) / 2; if (t1 <= t && t <= t2) { ret = min(ret, max(m_suf + t, m_pre - t)); } } return ret; } int main() { ios::sync_with_stdio(0); cin.tie(0); cin >> n >> m; for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { d[i][j] = INF; } d[i][i] = 0; } vector<Edge> e(m); for (int i = 0; i < m; i++) { cin >> e[i].x >> e[i].y >> e[i].w; e[i].w *= 2; d[e[i].x][e[i].y] = d[e[i].y][e[i].x] = e[i].w; } for (int k = 1; k <= n; k++) { for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { d[i][j] = min(d[i][j], d[i][k] + d[k][j]); } } } solve(e[0].x, e[0].y, e[0].w); int ret = INF; for (auto &it : e) { ret = min(ret, solve(it.x, it.y, it.w)); } if (ret % 2 == 0) { cout << ret / 2 << .0 n ; } else { cout << ret / 2 << .5 n ; } }
#include <bits/stdc++.h> using namespace std; const int MAXN = 100005; string a, b; int n; int x[MAXN], y[MAXN]; void pre() { int cnt = 0, len = b.size(); for (int i = 0; i < n; i++) { if (cnt == len) continue; if (b[cnt] == a[i]) { x[cnt] = i; cnt++; } } cnt = len - 1; for (int i = n - 1; i >= 0; i--) { if (cnt < 0) continue; if (b[cnt] == a[i]) { y[cnt] = n - 1 - i; cnt--; } } } int bs(int val, int in) { int s = 0, e = in, mid; while (s <= e) { mid = (s + e) / 2; if (x[mid] < val) s = mid + 1; else if (x[mid] > val) e = mid - 1; else return mid; } return e; } int main() { ios::sync_with_stdio(NULL); cin.tie(0); cin >> a; cin >> b; n = a.size(); std::fill(x, x + b.size(), MAXN); std::fill(y, y + b.size(), MAXN); pre(); int ani = MAXN, len = b.size(); pair<int, int> ans = make_pair(-1, len); for (int i = len - 1; i >= 0; i--) { int an = bs(n - 1 - y[i], i - 1); if (ani > i - an - 1) { if (an == -1 && y[i] >= n) continue; if (an != -1 && x[an] + y[i] + 1 >= n) continue; ani = i - an - 1; ans = make_pair(an, i); } } for (int i = 0; i < len; i++) if (x[i] < n && len - i - 1 < ani) { ani = len - i - 1; ans = make_pair(i, len); } if (ans.first == -1 && ans.second == len) cout << - n ; else { if (ans.first != -1) cout << b.substr(0, ans.first + 1); if (ans.second != len) cout << b.substr(ans.second, len - ans.second); cout << n ; } }
#include <bits/stdc++.h> using namespace std; const int mod = 1e9 + 7; struct segtree { int n; vector<pair<int, int>> st; segtree(int _n) { n = _n; st.assign(4 * n + 5, make_pair(0, 0)); } pair<int, int> merge(pair<int, int> a, pair<int, int> b) { pair<int, int> res = make_pair(min(a.first, b.first), 0); if (a.first == res.first) res.second += a.second; if (b.first == res.first) res.second += b.second; if (res.second >= mod) res.second -= mod; return res; } void update(int id, int l, int r, int pos, int val, int num) { if (l > pos || r < pos) return; if (l == r) { st[id] = make_pair(val, num); return; } int mid = (l + r) >> 1; update(id << 1, l, mid, pos, val, num); update(id << 1 | 1, mid + 1, r, pos, val, num); st[id] = merge(st[id << 1], st[id << 1 | 1]); } pair<int, int> get(int id, int l, int r, int u, int v) { if (l > v || r < u) return make_pair((int)2e9, 0); if (l >= u && r <= v) return st[id]; int mid = (l + r) >> 1; pair<int, int> lnode = get(id << 1, l, mid, u, v); pair<int, int> rnode = get(id << 1 | 1, mid + 1, r, u, v); return merge(lnode, rnode); } void update(int pos, int val, int num) { update(1, 1, n, pos, val, num); } pair<int, int> get(int l, int r) { return get(1, 1, n, l, r); } }; const int N = 2e5 + 5; pair<int, int> a[N]; pair<int, int> dp[N]; int n; int maxpre[N]; int main() { ios_base::sync_with_stdio(0); cin.tie(0); cin >> n; for (int i = 1; i <= n; i++) { cin >> a[i].first >> a[i].second; } sort(a + 1, a + n + 1); segtree st(n); for (int i = 1; i <= n; i++) { swap(a[i].first, a[i].second); int lo = 0; int hi = i; while (hi - lo > 1) { int mid = (lo + hi) >> 1; if (a[mid].second <= a[i].first) lo = mid; else hi = mid; } if (!lo) dp[i] = make_pair(a[i].first, 1); else { dp[i] = st.get(1, lo); dp[i].first += a[i].first; } st.update(i, dp[i].first - a[i].second, dp[i].second); } pair<int, int> ans = make_pair((int)2e9, 0); int mx = 0; for (int i = n; i >= 1; i--) if (a[i].second > mx) { if (ans.first == dp[i].first) { ans.second += dp[i].second; if (ans.second >= mod) ans.second -= mod; } else if (ans.first > dp[i].first) ans = dp[i]; mx = max(mx, a[i].first); } cout << ans.second; return 0; }
#include <bits/stdc++.h> using namespace std; long long a[200005], dp1[200005], dp2[200005]; int main() { long long n, k, x; int xx; cin >> n >> k >> x; for (int i = 1; i <= n; i++) { scanf( %d , &xx); a[i] = xx; } sort(a + 1, a + n + 1); for (int i = 1; i <= n; i++) { if (i != 1) { dp1[i] = dp1[i - 1] | a[i - 1]; } } for (int i = n; i >= 1; i--) { dp2[i] = dp2[i + 1] | a[i + 1]; } long long mx = 0; long long pw = 1; for (int i = 1; i <= k; i++) { pw *= x; } for (int i = n; i >= 1; i--) { mx = max(mx, ((pw * a[i]) | dp1[i] | dp2[i])); } cout << mx; }
#include <bits/stdc++.h> using namespace std; int fun(int x, int y, int z) { return x * x + y * y + z * z + x * y + y * z + z * x; } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); int t, n; cin >> t; while (t--) { cin >> n; int a[n]; int f = true; for (int i = 0; i < n; i++) cin >> a[i]; for (int i = 1; i < n - 1; i++) { if (a[i] > a[i - 1] && a[i] > a[i + 1]) { cout << YES << endl; f = false; cout << i << << i + 1 << << i + 2 << endl; break; } } if (f) cout << NO << endl; } }
#include <bits/stdc++.h> using namespace std; int a[300010]; struct _ { int val, rpos; }; vector<_> min_, max_; int vmin[1200010], cmin[1200010], add[1200010]; void pushup(int rt) { if (vmin[rt << 1] == vmin[rt << 1 | 1]) { vmin[rt] = vmin[rt << 1]; cmin[rt] = cmin[rt << 1] + cmin[rt << 1 | 1]; } else { if (vmin[rt << 1] < vmin[rt << 1 | 1]) { vmin[rt] = vmin[rt << 1]; cmin[rt] = cmin[rt << 1]; } else { vmin[rt] = vmin[rt << 1 | 1]; cmin[rt] = cmin[rt << 1 | 1]; } } } void build(int l, int r, int rt) { if (l == r) { cmin[rt] = 1; return; } int m = l + r >> 1; build(l, m, rt << 1); build(m + 1, r, rt << 1 | 1); pushup(rt); } void pushdown(int rt) { if (add[rt]) { add[rt << 1] += add[rt]; vmin[rt << 1] += add[rt]; add[rt << 1 | 1] += add[rt]; vmin[rt << 1 | 1] += add[rt]; add[rt] = 0; return; } } void update(int L, int R, int c, int l, int r, int rt) { if (L <= l && r <= R) { add[rt] += c; vmin[rt] += c; return; } int m = l + r >> 1; pushdown(rt); if (m >= L) update(L, R, c, l, m, rt << 1); if (m < R) update(L, R, c, m + 1, r, rt << 1 | 1); pushup(rt); } struct __ { int v, c; __ operator+(const __ &ob) const { __ rv; if (v == ob.v) { rv.v = v; rv.c = c + ob.c; } else { if (v < ob.v) { rv.v = v; rv.c = c; } else { rv.v = ob.v; rv.c = ob.c; } } return rv; } }; __ query(int L, int R, int l, int r, int rt) { if (L <= l && r <= R) return (__){vmin[rt], cmin[rt]}; int m = l + r >> 1; pushdown(rt); __ ans; ans.v = 998244353; if (m >= L) ans = ans + query(L, R, l, m, rt << 1); if (m < R) ans = ans + query(L, R, m + 1, r, rt << 1 | 1); return ans; } int main() { ios::sync_with_stdio(0); cin.tie(0); int n; cin >> n; build(1, n, 1); int i; int x, y; for (i = 1; i <= n; ++i) { cin >> x >> y; a[x] = y; } min_.push_back((_){-1, 0}); max_.push_back((_){n + 1, 0}); long long ans = 0; for (i = 1; i <= n; ++i) { while (min_.back().val >= a[i]) { update(min_[min_.size() - 2].rpos + 1, min_.back().rpos, min_.back().val, 1, n, 1); min_.pop_back(); } update(min_.back().rpos + 1, i, -a[i], 1, n, 1); min_.push_back((_){a[i], i}); while (max_.back().val <= a[i]) { update(max_[max_.size() - 2].rpos + 1, max_.back().rpos, -max_.back().val, 1, n, 1); max_.pop_back(); } update(max_.back().rpos + 1, i, a[i], 1, n, 1); max_.push_back((_){a[i], i}); update(1, i, -1, 1, n, 1); ans += query(1, i, 1, n, 1).c; } cout << ans << n ; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { ios::sync_with_stdio(false); cin.tie(NULL); int q; cin >> q; while (q--) { int n; cin >> n; string s, t; cin >> s >> t; string ss = s; string tt = t; sort(ss.begin(), ss.end()); sort(tt.begin(), tt.end()); int ans; if (ss != tt) ans = -1; else { ans = INT_MAX; for (int i = 0; i < n; i++) { int k = i; for (int j = 0; j < n; j++) { if (k < n and s[j] == t[k]) k++; } ans = min(ans, n - k + i); } } cout << ans << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); long long p, q, i, t, i1 = 0, i2 = 0, mx; char c; cin >> t; long long a[368], b[368]; for (i = 0; i < 368; i++) { a[i] = 0; b[i] = 0; } for (i = 0; i < t; i++) { cin >> c >> p >> q; if (c == F ) { b[p]++; b[q + 1]--; } else { a[p]++; a[q + 1]--; } } mx = 0; for (i = 1; i < 367; i++) { a[i] += a[i - 1]; b[i] += b[i - 1]; mx = max(mx, (min(a[i], b[i]) * 2)); } cout << mx << endl; return 0; }
#include <bits/stdc++.h> using namespace std; using ll = long long int; string s, t; int mp[28], tempMap[28]; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); int i, j, len1, len2, can = -1; cin >> s >> t; len1 = (int)s.size(), len2 = (int)t.size(); for (i = 0; i < len1; i++) { mp[s[i] - a ]++; } int rng = min(len1, len2) - 1; if (len1 > len2) rng++; for (i = 0; i < rng; i++) { if (mp[t[i] - a ]) { mp[t[i] - a ]--; for (j = 0; j < 26; j++) { tempMap[j] = mp[j]; } bool flag = false; if (i == len2 - 1) { if (len1 > len2 && i == rng - 1) flag = true, can = i; } else { for (j = t[i + 1] - a + 1; j < 26; j++) { if (mp[j]) { flag = true; break; } } if (flag) can = i; } } else { break; } } memset(mp, 0, sizeof mp); for (i = 0; i < len1; i++) mp[s[i] - a ]++; if (can == -1) { int found = -1; for (i = t[0] - a + 1; i < 26; i++) { if (mp[i]) { found = i; break; } } if (found == -1) cout << -1 << endl; else { cout << (char)(found + a ); mp[found]--; for (i = 0; i < 26; i++) { for (j = 0; j < mp[i]; j++) { cout << (char)(i + a ); } } cout << endl; } } else { for (i = 0; i <= can; i++) { cout << t[i]; mp[t[i] - a ]--; } if (len1 > len2 && can == len2 - 1) { for (i = 0; i < 26; i++) { for (j = 0; j < mp[i]; j++) { cout << (char)(i + a ); } } cout << endl; } else { for (i = t[can + 1] - a + 1; i < 26; i++) { if (mp[i]) { cout << (char)(i + a ); mp[i]--; break; } } for (i = 0; i < 26; i++) { for (j = 0; j < mp[i]; j++) { cout << (char)(i + a ); } } cout << endl; } } return 0; }
#include <bits/stdc++.h> int main() { int n, h, arr[1000], c = 0, i; scanf( %d %d , &n, &h); for (i = 0; i < n; i++) { scanf( %d , &arr[i]); if (arr[i] > h) c = c + 2; else c = c + 1; } printf( %d , c); return 0; }
#include <bits/stdc++.h> const int M = 5004; int n, m, a[55], b[55]; double p[55], eps = 1e-9; double f[55][5005], cnt; double chk(double x) { for (int i = n; i >= 1; i--) { for (int j = m + 1; j <= M; j++) f[i + 1][j] = x; for (int j = 0; j <= m; j++) { f[i][j] = (f[i + 1][j + a[i]] + a[i]) * p[i] + (f[i + 1][j + b[i]] + b[i]) * (1 - p[i]); if (f[i][j] > x) f[i][j] = x; } } return f[1][0]; } int main() { scanf( %d%d , &n, &m); for (int i = 1; i <= n; i++) { scanf( %d%d%lf , &a[i], &b[i], &p[i]); p[i] = p[i] / 100; } double l = 0, r = 1e9; while (l + eps < r) { long double mid = (l + r) / 2.0; if (chk(mid) < mid) r = mid; else l = mid; cnt++; if (cnt > 128) break; } printf( %.9lf n , l); }
#include <bits/stdc++.h> using namespace std; int main() { string a; vector<string> input; int n; cin >> n; bool flag = false; for (int i = 0; i < n; i++) { cin >> a; if (!flag && a[0] == a[1] && a[0] == O ) { a[0] = + ; a[1] = + ; flag = true; } if (!flag && a[3] == a[4] && a[3] == O ) { a[3] = + ; a[4] = + ; flag = true; } input.push_back(a); } if (flag) { cout << YES << endl; for (int i = 0; i < n; i++) { cout << input[i] << endl; } } else cout << NO << endl; return 0; }
#include <bits/stdc++.h> using namespace std; long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; } long long lb = 1000; void vrikodara(long long n = 12) { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); cout << setprecision(n) << fixed; } void solve() { string s, t; cin >> s >> t; vector<long long> v1(26, 0), v2(26, 0); for (auto i : s) v1[i - a ]++; for (auto i : t) v2[i - a ]++; long long n = t.length(); long long a = n; if (s.length() <= n) { a = s.length(); a--; } t += 55; for (long long i = a - 1; i >= -1; i--) { vector<long long> v = v1; bool flag = true; string ans = ; for (long long j = 0; j <= i; j++) { if (!v[t[j] - a ]) { flag = false; break; } ans += t[j]; v[t[j] - a ]--; } if (flag) { char ch = t[i + 1]; flag = false; for (long long i = 0; i < 26; i++) { if (v[i] && (char)( a + i) > ch) { v[i]--; char r = (char)(i + a ); ans += r; for (long long i = 0; i < 26; i++) { while (v[i]--) { char r = (char)(i + a ); ans += r; } } cout << ans; return; } } } } cout << -1 ; } int32_t main() { vrikodara(); long long t = 1; while (t--) { solve(); } return 0; }
#include <bits/stdc++.h> using namespace std; vector<long long> gaps(1e5 + 1); int32_t main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); ; long long t; cin >> t; while (t--) { long long a, b, c, n; cin >> a >> b >> c; n = (abs(b - a)) * 2; long long ans = ((n / 2) + c); if (ans > n) ans = ans % n; if (n % 2 != 0 || c > n || a > n || b > n || ans > n || ans == a || ans == b) ans = -1; cout << ans << n ; } return 0; }
#include <bits/stdc++.h> using namespace std; template <typename T> void print(vector<T> v) { for (T e : v) { cout << e << ; } cout << endl; } template <typename T> void print(vector<vector<T>> v) { int n = v.size(); for (int i = 0; i < n; i++) { cout << i << : ; for (T e : v[i]) { cout << e << ; } cout << endl; } } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); vector<int> a(6); for (int i = 0; i < 6; i++) { cin >> a[i]; } cout << (int)(pow(a[0] + a[1] + a[2], 2) - a[0] * a[0] - a[2] * a[2] - a[4] * a[4]) << endl; }
#include <bits/stdc++.h> using namespace std; const unsigned long long maxn = 1000 + 10; const int INF = 0x3f3f3f3f; const double eps = 1e-10; const double pi = acos(-1.0); int g[maxn][maxn]; struct haha { int x, y, w; } p[maxn * 10], p0[maxn * 10]; struct Edge { int from, to, dist; }; struct HeapNode { int d, u; bool operator<(const HeapNode& rhs) const { return d > rhs.d; } }; struct Dijkstra { int n, m; vector<Edge> edges; vector<int> G[maxn]; bool done[maxn]; int d[maxn]; int p[maxn]; void init(int n) { this->n = n; for (int i = 0; i < n; ++i) G[i].clear(); edges.clear(); } void AddEdge(int from, int to, int dist) { edges.push_back((Edge){from, to, dist}); m = edges.size(); G[from].push_back(m - 1); } void dijkstra(int s) { priority_queue<HeapNode> Q; p[s] = -1; for (int i = 0; i < n; ++i) d[i] = INF; d[s] = 0; memset(done, 0, sizeof done); Q.push((HeapNode){0, s}); while (!Q.empty()) { HeapNode x = Q.top(); Q.pop(); int u = x.u; if (done[u]) continue; done[u] = true; for (int i = 0; i < G[u].size(); ++i) { Edge& e = edges[G[u][i]]; if (d[e.to] > d[u] + e.dist) { d[e.to] = d[u] + e.dist; p[e.to] = e.from; Q.push((HeapNode){d[e.to], e.to}); } } } } } dij; int main() { int n, m, L, s, t; int cnt = 0, cnt2 = 0; scanf( %d %d %d %d %d , &n, &m, &L, &s, &t); dij.init(n); for (int i = 0; i < m; ++i) { int u, v, w; scanf( %d %d %d , &u, &v, &w); g[u][v] = g[v][u] = w; if (w) { p[cnt].x = u; p[cnt].w = w; p[cnt++].y = v; dij.AddEdge(u, v, w); dij.AddEdge(v, u, w); } else { p0[cnt2].x = u; p0[cnt2].w = 0; p0[cnt2++].y = v; } } dij.dijkstra(s); if (dij.d[t] < L) return 0 * puts( NO ); if (dij.d[t] == L) { puts( YES ); for (int i = 0; i < cnt; ++i) { printf( %d %d %d n , p[i].x, p[i].y, p[i].w); } for (int i = 0; i < cnt2; ++i) { printf( %d %d %d n , p0[i].x, p0[i].y, INF); } return 0; } int pos = -1; for (int i = 0; i < cnt2; ++i) { dij.AddEdge(p0[i].x, p0[i].y, 1); dij.AddEdge(p0[i].y, p0[i].x, 1); dij.dijkstra(s); if (dij.d[t] > L) continue; pos = i; break; } if (pos == -1) return 0 * puts( NO ); puts( YES ); for (int i = 0; i < cnt; ++i) { printf( %d %d %d n , p[i].x, p[i].y, p[i].w); } for (int i = 0; i < pos; ++i) printf( %d %d %d n , p0[i].x, p0[i].y, 1); printf( %d %d %d n , p0[pos].x, p0[pos].y, L - dij.d[t] + 1); for (int i = pos + 1; i < cnt2; ++i) printf( %d %d %d n , p0[i].x, p0[i].y, INF); return 0; }
#include <bits/stdc++.h> using namespace std; using ll = long long int; using int64 = long long int; template <typename T> void chmax(T &a, T b) { a = max(a, b); } template <typename T> void chmin(T &a, T b) { a = min(a, b); } template <typename T> void chadd(T &a, T b) { a = a + b; } int dx[] = {0, 0, 1, -1}; int dy[] = {1, -1, 0, 0}; const ll INF = 1001001001001001LL; const ll MOD = 1000000007LL; int main() { int N; scanf( %d , &N); vector<int> A(N); for (int i = 0; i < N; i++) scanf( %d , &A[i]); sort(A.begin(), A.end()); ll ans = INF; { for (int x = 1; x * x <= A[0]; x++) { int d = A[0] / x, m = A[0] % x; for (int k = d; k >= d - (m == 0); k--) { int mi = k, ma = k + 1; ll sum = 0; for (int i = 0; i < N; i++) { ll b = (A[i] + ma - 1) / ma; if (mi * b <= A[i]) sum += b; else sum = INF; } ans = min(ans, sum); } } } { for (int x = 1; x * x <= A[0]; x++) { int mi = x, ma = x + 1; ll sum = 0; for (int i = 0; i < N; i++) { ll b = (A[i] + ma - 1) / ma; if (mi * b <= A[i]) sum += b; else sum = INF; } ans = min(ans, sum); } } cout << ans << endl; return 0; }
#include <bits/stdc++.h> const int N = 100010; const int inf = 0x3f3f3f3f; using namespace std; map<string, int> A, B; string y; int solve(string x) { y = ; int sz = x.size(); int a = 0, b = 0; for (int i = 0; i < sz; i++) { if (x[i] == * ) a++; else if (x[i] == & ) b++; else y += x[i]; } if (B[y] == 0 || A[y] == inf || (A[y] + a - b) < 0) return inf; return A[y] + a - b; } int main() { int n; cin >> n; A[ void ] = 0; B[ void ] = 1; for (int i = 0; i < n; i++) { string a, b, c; cin >> a >> b; if (a == typedef ) { cin >> c; A[c] = solve(b); B[c] = B[y]; } else { A[b] = solve(b); if (A[b] == inf) puts( errtype ); else { printf( void ); for (int j = 0; j < A[b]; j++) printf( * ); puts( ); } } } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; cout << n + n / 2; return 0; }
#include <bits/stdc++.h> using namespace std; inline void read(int &data) { data = 0; int e = 1; char ch = getchar(); while ((ch < 0 || ch > 9 ) && ch != - ) ch = getchar(); if (ch == - ) e = -1, ch = getchar(); while (ch >= 0 && ch <= 9 ) data = data * 10 + ch - 48, ch = getchar(); data *= e; } inline void read(long long &data) { data = 0; int e = 1; char ch = getchar(); while ((ch < 0 || ch > 9 ) && ch != - ) ch = getchar(); if (ch == - ) e = -1, ch = getchar(); while (ch >= 0 && ch <= 9 ) data = data * 10 + ch - 48, ch = getchar(); data *= e; } inline void write(int data) { if (data < 0) data = -data, putchar( - ); if (data > 9) write(data / 10); putchar(data % 10 + 48); } inline void write(long long data) { if (data < 0) data = -data, putchar( - ); if (data > 9) write(data / 10); putchar(data % 10 + 48); } bool cmp(int a, int b) { return a < b; } priority_queue<long long, vector<long long>, greater<long long> > q; long long n, x, ans = 0; int main() { read(n); for (int i = 1; i <= n; ++i) { read(x); if (q.empty() || q.top() > x) q.push(x); else { ans += x - q.top(); q.pop(); q.push(x), q.push(x); } } write(ans), puts( ); }
#include <bits/stdc++.h> using namespace std; const long long N = 4e5 + 5; const long long M = 1e6 + 5; const long long inf = 1e18; const long long eps = 1e-5; inline long long read() { long long s = 0; register bool neg = 0; register char c = getchar(); for (; c < 0 || c > 9 ; c = getchar()) neg |= (c == - ); for (; c >= 0 && c <= 9 ; s = s * 10 + (c ^ 48), c = getchar()) ; s = (neg ? -s : s); return s; } long long a, b, c, fa[N][21], mx[N][21], F[N], dep[N], C[N]; bool vis[N]; struct node { long long x, y, val, real, id; bool vis; bool operator<(const node &o) const { return val < o.val; } } s[N]; vector<pair<long long, long long> > st[N]; inline long long f(long long n) { return F[n] == n ? n : F[n] = f(F[n]); } inline void dfs(long long n, long long lst, long long p) { dep[n] = dep[lst] + 1; fa[n][0] = lst; mx[n][0] = p; for (long long i = (1); i <= (20); ++i) { fa[n][i] = fa[fa[n][i - 1]][i - 1]; mx[n][i] = max(mx[n][i - 1], mx[fa[n][i - 1]][i - 1]); } for (long long i = (0); i <= (((long long)((st[n]).size())) - 1); ++i) { long long v = st[n][i].first; if (v == lst) continue; dfs(v, n, st[n][i].second); } } inline long long LCA(long long n, long long m) { if (dep[n] < dep[m]) swap(n, m); long long res = -inf; for (long long i = (20); i >= (0); --i) if (dep[fa[n][i]] >= dep[m]) { res = max(res, mx[n][i]); n = fa[n][i]; } if (n == m) return res; for (long long i = (20); i >= (0); --i) if (fa[n][i] != fa[m][i]) { res = max(res, max(mx[n][i], mx[m][i])); n = fa[n][i]; m = fa[m][i]; } res = max(res, max(mx[n][0], mx[m][0])); return res; } inline void del(long long n, long long m) { vis[n] = vis[m] = 1; while (n != m) { if (dep[n] <= dep[m]) m = fa[m][0]; else n = fa[n][0]; vis[n] = vis[m] = 1; } } signed main() { memset(mx, -0x3f, sizeof(mx)); a = read(); b = read(); for (long long i = (1); i <= (a); ++i) F[i] = i; for (long long i = (1); i <= (b); ++i) s[i].val = read(); for (long long i = (1); i <= (b); ++i) C[i] = read(); for (long long i = (1); i <= (b); ++i) { s[i].x = read(); s[i].y = read(); s[i].id = i; } c = read(); for (long long i = (1); i <= (b); ++i) s[i].real = s[i].val - c / C[i]; sort(s + 1, s + b + 1); long long mn = 1, ans = 0, a1, a2 = inf, t1, t2, t3, mn1; for (long long i = (1); i <= (b); ++i) { long long f1 = f(s[i].x), f2 = f(s[i].y); if (f1 == f2) continue; F[f1] = f2; ans += s[i].val; if (s[i].real - s[i].val < s[mn].real - s[mn].val) mn = i; s[i].vis = 1; st[s[i].x].push_back(make_pair(s[i].y, s[i].val)); st[s[i].y].push_back(make_pair(s[i].x, s[i].val)); } a1 = ans + s[mn].real - s[mn].val; dfs(1, 0, -inf); for (long long i = (1); i <= (b); ++i) { if (s[i].vis) continue; long long tmp = LCA(s[i].x, s[i].y); if (ans - tmp + s[i].real < a2) { a2 = ans - tmp + s[i].real; t3 = tmp; t1 = s[i].x, t2 = s[i].y; mn1 = i; } } printf( %lld n , min(a1, a2)); if (a1 < a2) { for (long long i = (1); i <= (b); ++i) if (s[i].vis) { if (mn == i) printf( %lld %lld n , s[i].id, s[i].real); else printf( %lld %lld n , s[i].id, s[i].val); } } else { del(t1, t2); for (long long i = (1); i <= (b); ++i) { if (!s[i].vis) continue; if (t1 && vis[s[i].x] && vis[s[i].y] && s[i].val == t3) t1 = 0; else printf( %lld %lld n , s[i].id, s[i].val); } printf( %lld %lld n , s[mn1].id, s[mn1].real); } return 0; }
#include <bits/stdc++.h> using namespace std; int x; void dfsUtil(int node, int count, bool visited[], int& maxCount, vector<vector<int> >& adj) { visited[node] = true; count++; for (auto& i : adj[node]) { if (!visited[i]) { if (count >= maxCount) { maxCount = count; x = i; } dfsUtil(i, count, visited, maxCount, adj); } } } void dfs(int node, int n, vector<vector<int> >& adj, int& maxCount) { bool visited[n]; int count = 0; for (int i = 0; i < n; ++i) visited[i] = false; dfsUtil(node, 1, visited, maxCount, adj); } int diameter(vector<vector<int> >& adj, int n) { int maxCount = INT_MIN; dfs(0, n, adj, maxCount); dfs(x, n, adj, maxCount); return maxCount; } bool vis[100010]; int dist[100010]; void dfs1(int v, int p, vector<vector<int> >& adj) { if (vis[v]) return; vis[v] = true; if (p == -1) dist[v] = 0; else dist[v] = dist[p] + 1; for (auto& u : adj[v]) { dfs1(u, v, adj); } } void solve() { int n, a, b, da, db; cin >> n >> a >> b >> da >> db; a--; b--; vector<vector<int> > adj(n); for (int i = 0; i < n - 1; i++) { int u, v; cin >> u >> v; u--; v--; adj[u].push_back(v); adj[v].push_back(u); } if (db <= 2 * da) { cout << Alice << endl; return; } for (int i = 0; i < n; i++) { vis[i] = false; } dfs1(a, -1, adj); if (dist[b] <= da) { cout << Alice << endl; return; } if (diameter(adj, n) - 1 >= 2 * da + 1) { cout << Bob << endl; } else { cout << Alice << endl; } } int main() { ios::sync_with_stdio(0); cin.tie(0); mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); int t; cin >> t; while (t--) { solve(); } }
#include <bits/stdc++.h> using namespace std; struct Nod { int mark, label; } nod[200010]; int val[200010]; bool cmp1(Nod n1, Nod n2) { if (n1.mark != n2.mark) return n1.mark > n2.mark; return n1.label < n2.label; } bool cmp2(Nod n1, Nod n2) { if (n1.mark != n2.mark) return n1.mark > n2.mark; return n1.label > n2.label; } int main() { int n, a, b; scanf( %d , &n); scanf( %d%d , &a, &b); for (int i = 0; i < n; ++i) { scanf( %d , &nod[i].mark); nod[i].label = i; } if (a == b) { for (int i = 1; i < n; ++i) if (i <= n / 2) printf( 1 ); else printf( 2 ); printf( 2 n ); return 0; } if (a < b) { sort(nod, nod + n, cmp1); for (int i = 0; i < n; ++i) { if (i < a) val[nod[i].label] = 1; else val[nod[i].label] = 2; } } else { sort(nod, nod + n, cmp2); for (int i = 0; i < n; ++i) { if (i < b) val[nod[i].label] = 2; else val[nod[i].label] = 1; } } for (int i = 0; i < n - 1; ++i) printf( %d , val[i]); printf( %d n , val[n - 1]); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int s[100], t[100], n, p, i, j, solv, tim, c; scanf( %d%d , &n, &p); for (i = 0; i < n; i++) { scanf( %d%d , &s[i], &t[i]); } for (i = 1; i < n; i++) for (j = 0; j < n - i; j++) if (s[j] < s[j + 1] || (s[j] == s[j + 1] && t[j] > t[j + 1])) { swap(s[j], s[j + 1]); swap(t[j], t[j + 1]); } solv = s[p - 1]; tim = t[p - 1]; c = 0; for (i = p - 1; i >= 0; i--) { if (solv == s[i] && t[i] == tim) c++; else break; } for (i = p; i < n; i++) { if (solv == s[i] && t[i] == tim) c++; else break; } printf( %d , c); return 0; }
#include <bits/stdc++.h> using namespace std; bool valid(string s) { int start = 0, end = s.length() - 1; while (start < end) { if (s[start] == a && s[end] == a ) { start++; end--; } else if (s[start] == a && s[end] == z ) { return false; } else if (s[start] == z && s[end] == a ) { return false; } else if (s[start] == z && s[end] == z ) { start++; end--; } else if (s[start] == z ) { if (abs(s[start] - s[end]) == 2 || abs(s[start] - s[end]) == 0) { start++; end--; } else { return false; } } else if (s[start] == a ) { if (abs(s[start] - s[end]) == 2 || abs(s[start] - s[end]) == 0) { start++; end--; } else { return false; } } else if (s[end] == a ) { if (abs(s[start] - s[end]) == 2 || abs(s[start] - s[end]) == 0) { start++; end--; } else { return false; } } else if (s[end] == z ) { if (abs(s[start] - s[end]) == 2 || abs(s[start] - s[end]) == 0) { start++; end--; } else { return false; } } else { if (abs(s[start] - s[end]) == 2 || abs(s[start] - s[end]) == 0) { start++; end--; } else { return false; } } } } int main() { int n, t; string s; scanf( %d , &n); for (int i = 0; i < n; i++) { scanf( %d , &t); cin >> s; if (valid(s)) cout << YES << endl; else cout << NO << endl; } return 0; }
#include <bits/stdc++.h> using lli = long long int; int main() { std::string str; lli q, a, b, n, needSum; lli ost = 0; std::cin >> q; for (int i = 0; i < q; ++i) { std::cin >> a >> b >> n >> needSum; if (a * n == needSum || b == needSum) { std::cout << Yes << std::endl; continue; } if (a * n > needSum) { ost = needSum % n; if (b >= ost) { std::cout << Yes << std::endl; continue; } } else { if (a * n + b >= needSum) { std::cout << Yes << std::endl; continue; } } std::cout << No << std::endl; } return 0; }
#include <bits/stdc++.h> using namespace std; const int maxn = 2e5 + 5; int num[5005], cnt[5005] = {}, id[5005]; int dp[5005][5005]; bool used[5005]; int main() { ios::sync_with_stdio(0); cin.tie(0); int n, k; cin >> n >> k; for (int i = 1; i <= n; i++) cin >> num[i]; sort(num + 1, num + n + 1); for (int i = 1; i <= n; i++) { int r = i; while (r + 1 <= n && (num[r + 1] - num[i]) <= 5) r++; cnt[i] = r; } for (int i = n; i >= 1; i--) { for (int j = 1; j <= k; j++) { dp[i][j] = dp[i + 1][j]; dp[i][j] = max(dp[i][j], dp[cnt[i] + 1][j - 1] + cnt[i] - i + 1); } } int ans = 0; for (int i = 1; i <= n; i++) ans = max(ans, dp[1][i]); cout << ans << n ; }
#include <bits/stdc++.h> using namespace std; long long int powerMod(long long int x, unsigned long long int y) { if (y == 0) return 1; long long int p = powerMod(x, y / 2) % 1000000007; p = (p * p) % 1000000007; return (y % 2 == 0) ? p : (x * p) % 1000000007; } long long int power(long long int x, unsigned long long int y) { if (y == 0) return 1; long long int p = power(x, y / 2); p = (p * p); return (y % 2 == 0) ? p : (x * p); } int main() { cin.tie(0)->sync_with_stdio(0); int t; cin >> t; while (t--) { long long int n; cin >> n; vector<long long int> arr(n); for (int i = 0; i < n; ++i) cin >> arr[i]; if (n % 2 == 0) cout << YES n ; else { bool ok = true; for (int i = 0; i < n - 1; ++i) { if (arr[i + 1] <= arr[i]) { ok = false; break; } } if (!ok) cout << YES n ; else cout << NO n ; } } }
#include <bits/stdc++.h> using namespace std; const int N = 1e5 + 7; int n, m, B, a[N], c[N], ans[N]; struct Node { int l, r, id; Node() {} Node(int _l, int _r, int _id) { l = _l, r = _r, id = _id; } bool operator<(const Node &p) const { return r < p.r; } } Q[N]; vector<int> V, q[400]; int calc(int l, int r) { int ret = 0; for (int i = (l); i < (r + 1); ++i) { int x = a[i]; ++c[x]; ret += c[x] == V[x]; ret -= c[x] == V[x] + 1; } for (int i = (l); i < (r + 1); ++i) c[a[i]] = 0; return ret; } int main() { scanf( %d%d , &n, &m); B = sqrt(n); for (int i = (0); i < (n); ++i) { scanf( %d , &a[i]); V.push_back(a[i]); } sort(V.begin(), V.end()); V.erase(unique(V.begin(), V.end()), V.end()); for (int i = (0); i < (n); ++i) a[i] = lower_bound(V.begin(), V.end(), a[i]) - V.begin(); for (int i = (0); i < (m); ++i) { int l, r; scanf( %d%d , &l, &r); Q[i] = Node(l - 1, r - 1, i); } sort(Q, Q + m); for (int i = (0); i < (m); ++i) if (Q[i].r - Q[i].l + 1 <= B) { ans[Q[i].id] = calc(Q[i].l, Q[i].r); } else { q[Q[i].l / B + (Q[i].l % B > 0)].push_back(i); } for (int i = (0); i < (B + 1); ++i) { int j = 0, k = 0, cnt = 0; for (j = B * i; j < n && k < ((int)(q[i]).size()); ++j) { ++c[a[j]]; cnt += c[a[j]] == V[a[j]], cnt -= c[a[j]] == V[a[j]] + 1; while (k < ((int)(q[i]).size()) && j == Q[q[i][k]].r) { int tmp = cnt; for (int r = (Q[q[i][k]].l); r < (B * i); ++r) { ++c[a[r]]; tmp += c[a[r]] == V[a[r]], tmp -= c[a[r]] == V[a[r]] + 1; } for (int r = (Q[q[i][k]].l); r < (B * i); ++r) --c[a[r]]; ans[Q[q[i][k++]].id] = tmp; } } for (int r = (B * i); r < (j); ++r) c[a[r]] = 0; } for (int i = (0); i < (m); ++i) printf( %d n , ans[i]); return 0; }
#include <bits/stdc++.h> using namespace std; const double pi = acos(-1); const double eps = 1e-8; const int maxn = 1e6 + 5; const int maxm = 3e4 + 5; const long long mod = 1e9 + 7; const long long inf = 0x3f3f3f3f; const int _inf = -1e9 + 7; inline int scan() { int m = 0; char c = getchar(); while (c < 0 || c > 9 ) c = getchar(); while (c >= 0 && c <= 9 ) m = m * 10 + c - 0 , c = getchar(); return m; } int N, Q, S, M, K; int num[200]; int dp[200][30000]; int main() { cin >> N >> K >> S; for (int i = 1; i <= N; i++) { scanf( %d , num + i); } memset(dp, inf, sizeof dp); dp[0][0] = 0; for (int i = 1; i <= N; i++) { for (int j = i - 1; j >= 0; j--) { for (int k = i * j; k >= 0; k--) { dp[j + 1][k + i - j - 1] = min(dp[j + 1][k + i - j - 1], dp[j][k] + num[i]); } } } int ans = inf; for (int i = 0; i <= min(S, N * N); i++) ans = min(ans, dp[K][i]); cout << ans; return 0; }
#include <bits/stdc++.h> using namespace std; void read(int &x) { register int c = getchar(); x = 0; for (; c < 48 || c > 57; c = getchar()) ; for (; c > 47 && c < 58; c = getchar()) x = (x << 1) + (x << 3) + c - 48; } queue<int> y[300005], v; int main() { int n, q, w = 0, x, z = 0, t = 0; read(n); read(q); while (q--) { read(x); if (x == 1) { read(x); v.push(x); y[x].push(t++); } else if (x == 2) { read(x); z += y[x].size(); while (!y[x].empty()) y[x].pop(); } else { read(x); while (x > w) { if (!y[v.front()].empty() && y[v.front()].front() < x) { y[v.front()].pop(); z++; } ++w; v.pop(); } } printf( %d n , t - z); } }
#include <bits/stdc++.h> using namespace std; struct P { int x; int a; }; P data[105]; bool cmp(P x, P y) { return x.x < y.x; } int main() { int n; int x, a; int po = 0, ne = 0; int res = 0; scanf( %d , &n); for (int i = 0; i < n; ++i) { scanf( %d%d , &x, &a); data[i].x = x; data[i].a = a; if (x < 0) ++ne; else ++po; } sort(data, data + n, cmp); if (ne > po) { for (int i = n - 1; i >= n - po * 2 - 1; --i) { res += data[i].a; } } else { for (int i = 0; i < ne * 2 + 1; ++i) { res += data[i].a; } } printf( %d n , res); return 0; }
#include <bits/stdc++.h> using namespace std; int count = 0; bool YES = false; vector<string> record; int compare(vector<string> cards, int pile1, int pile2) { if (cards.at(pile1)[0] == cards.at(pile2)[0] || cards.at(pile1)[1] == cards.at(pile2)[1]) return 1; return 0; } void move(vector<string> cards) { int N = cards.size(); int end = N - 1; if (N >= 4) { if (compare(cards, end, end - 3)) { string str = ; for (int k = 0; k < cards.size(); k++) { str += cards.at(k); } for (int k = 0; k < record.size(); k++) { if (str == record.at(k)) return; } record.push_back(str); vector<string> cards_t = cards; cards_t.at(end - 3) = cards_t.at(end); cards_t.pop_back(); move(cards_t); if (YES) return; } if (compare(cards, end, end - 1)) { vector<string> cards_t = cards; cards_t.at(end - 1) = cards_t.at(end); cards_t.pop_back(); move(cards_t); if (YES) return; } } else if (N > 1) { if (compare(cards, end, end - 1)) { vector<string> cards_t = cards; cards_t.at(end - 1) = cards_t.at(end); cards_t.pop_back(); move(cards_t); if (YES) return; } } else if (N == 1) { YES = true; return; } return; } int main() { vector<string> cards; int t; string card; cin >> t; for (int i = 0; i < t; i++) { cin >> card; cards.push_back(card); } move(cards); if (YES) cout << YES << endl; else cout << NO << endl; return 0; }
/* in the name of Anton */ /* Compete against Yourself. Author - Aryan (@aryanc403) Atcoder library - https://atcoder.github.io/ac-library/production/document_en/ */ #include <algorithm> #include <cassert> #include <limits> #include <queue> #include <vector> #include <algorithm> #include <utility> #include <vector> namespace atcoder { namespace internal { template <class E> struct csr { std::vector<int> start; std::vector<E> elist; csr(int n, const std::vector<std::pair<int, E>>& edges) : start(n + 1), elist(edges.size()) { for (auto e : edges) { start[e.first + 1]++; } for (int i = 1; i <= n; i++) { start[i] += start[i - 1]; } auto counter = start; for (auto e : edges) { elist[counter[e.first]++] = e.second; } } }; } // namespace internal } // namespace atcoder #include <vector> namespace atcoder { namespace internal { template <class T> struct simple_queue { std::vector<T> payload; int pos = 0; void reserve(int n) { payload.reserve(n); } int size() const { return int(payload.size()) - pos; } bool empty() const { return pos == int(payload.size()); } void push(const T& t) { payload.push_back(t); } T& front() { return payload[pos]; } void clear() { payload.clear(); pos = 0; } void pop() { pos++; } }; } // namespace internal } // namespace atcoder namespace atcoder { template <class Cap, class Cost> struct mcf_graph { public: mcf_graph() {} mcf_graph(int n) : _n(n) {} int add_edge(int from, int to, Cap cap, Cost cost) { assert(0 <= from && from < _n); assert(0 <= to && to < _n); assert(0 <= cap); assert(0 <= cost); int m = int(_edges.size()); _edges.push_back({from, to, cap, 0, cost}); return m; } struct edge { int from, to; Cap cap, flow; Cost cost; }; edge get_edge(int i) { int m = int(_edges.size()); assert(0 <= i && i < m); return _edges[i]; } std::vector<edge> edges() { return _edges; } std::pair<Cap, Cost> flow(int s, int t) { return flow(s, t, std::numeric_limits<Cap>::max()); } std::pair<Cap, Cost> flow(int s, int t, Cap flow_limit) { return slope(s, t, flow_limit).back(); } std::vector<std::pair<Cap, Cost>> slope(int s, int t) { return slope(s, t, std::numeric_limits<Cap>::max()); } std::vector<std::pair<Cap, Cost>> slope(int s, int t, Cap flow_limit) { assert(0 <= s && s < _n); assert(0 <= t && t < _n); assert(s != t); int m = int(_edges.size()); std::vector<int> edge_idx(m); auto g = [&]() { std::vector<int> degree(_n), redge_idx(m); std::vector<std::pair<int, _edge>> elist; elist.reserve(2 * m); for (int i = 0; i < m; i++) { auto e = _edges[i]; edge_idx[i] = degree[e.from]++; redge_idx[i] = degree[e.to]++; elist.push_back({e.from, {e.to, -1, e.cap - e.flow, e.cost}}); elist.push_back({e.to, {e.from, -1, e.flow, -e.cost}}); } auto _g = internal::csr<_edge>(_n, elist); for (int i = 0; i < m; i++) { auto e = _edges[i]; edge_idx[i] += _g.start[e.from]; redge_idx[i] += _g.start[e.to]; _g.elist[edge_idx[i]].rev = redge_idx[i]; _g.elist[redge_idx[i]].rev = edge_idx[i]; } return _g; }(); auto result = slope(g, s, t, flow_limit); for (int i = 0; i < m; i++) { auto e = g.elist[edge_idx[i]]; _edges[i].flow = _edges[i].cap - e.cap; } return result; } private: int _n; std::vector<edge> _edges; struct _edge { int to, rev; Cap cap; Cost cost; }; std::vector<std::pair<Cap, Cost>> slope(internal::csr<_edge>& g, int s, int t, Cap flow_limit) { std::vector<std::pair<Cost, Cost>> dual_dist(_n); std::vector<int> prev_e(_n); std::vector<bool> vis(_n); struct Q { Cost key; int to; bool operator<(Q r) const { return key > r.key; } }; std::vector<int> que_min; std::vector<Q> que; auto dual_ref = [&]() { for (int i = 0; i < _n; i++) { dual_dist[i].second = std::numeric_limits<Cost>::max(); } std::fill(vis.begin(), vis.end(), false); que_min.clear(); que.clear(); size_t heap_r = 0; dual_dist[s].second = 0; que_min.push_back(s); while (!que_min.empty() || !que.empty()) { int v; if (!que_min.empty()) { v = que_min.back(); que_min.pop_back(); } else { while (heap_r < que.size()) { heap_r++; std::push_heap(que.begin(), que.begin() + heap_r); } v = que.front().to; std::pop_heap(que.begin(), que.end()); que.pop_back(); heap_r--; } if (vis[v]) continue; vis[v] = true; if (v == t) break; Cost dual_v = dual_dist[v].first, dist_v = dual_dist[v].second; for (int i = g.start[v]; i < g.start[v + 1]; i++) { auto e = g.elist[i]; if (!e.cap) continue; Cost cost = e.cost - dual_dist[e.to].first + dual_v; if (dual_dist[e.to].second - dist_v > cost) { Cost dist_to = dist_v + cost; dual_dist[e.to].second = dist_to; prev_e[e.to] = e.rev; if (dist_to == dist_v) { que_min.push_back(e.to); } else { que.push_back(Q{dist_to, e.to}); } } } } if (!vis[t]) { return false; } for (int v = 0; v < _n; v++) { if (!vis[v]) continue; dual_dist[v].first -= dual_dist[t].second - dual_dist[v].second; } return true; }; Cap flow = 0; Cost cost = 0, prev_cost_per_flow = -1; std::vector<std::pair<Cap, Cost>> result = {{Cap(0), Cost(0)}}; while (flow < flow_limit) { if (!dual_ref()) break; Cap c = flow_limit - flow; for (int v = t; v != s; v = g.elist[prev_e[v]].to) { c = std::min(c, g.elist[g.elist[prev_e[v]].rev].cap); } for (int v = t; v != s; v = g.elist[prev_e[v]].to) { auto& e = g.elist[prev_e[v]]; e.cap += c; g.elist[e.rev].cap -= c; } Cost d = -dual_dist[s].first; flow += c; cost += c * d; if (prev_cost_per_flow == d) { result.pop_back(); } result.push_back({flow, cost}); prev_cost_per_flow = d; } return result; } }; } // namespace atcoder #ifdef ARYANC403 #include <header.h> #else #pragma GCC optimize ( Ofast ) #pragma GCC target ( sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx ) #pragma GCC optimize ( -ffloat-store ) #include<bits/stdc++.h> #define dbg(args...) 42; #endif using namespace std; #define fo(i,n) for(i=0;i<(n);++i) #define repA(i,j,n) for(i=(j);i<=(n);++i) #define repD(i,j,n) for(i=(j);i>=(n);--i) #define all(x) begin(x), end(x) #define sz(x) ((lli)(x).size()) #define pb push_back #define mp make_pair #define X first #define Y second #define endl n typedef long long int lli; typedef long double mytype; typedef pair<lli,lli> ii; typedef vector<ii> vii; typedef vector<lli> vi; const auto start_time = std::chrono::high_resolution_clock::now(); void aryanc403() { #ifdef ARYANC403 auto end_time = std::chrono::high_resolution_clock::now(); std::chrono::duration<double> diff = end_time-start_time; cerr<< Time Taken : <<diff.count()<< n ; #endif } const lli INF = 0xFFFFFFFFFFFFFFFL; lli seed; mt19937 rng(seed=chrono::steady_clock::now().time_since_epoch().count()); inline lli rnd(lli l=0,lli r=INF) {return uniform_int_distribution<lli>(l,r)(rng);} class CMP {public: bool operator()(ii a , ii b) //For min priority_queue . { return ! ( a.X < b.X || ( a.X==b.X && a.Y <= b.Y )); }}; void add( map<lli,lli> &m, lli x,lli cnt=1) { auto jt=m.find(x); if(jt==m.end()) m.insert({x,cnt}); else jt->Y+=cnt; } void del( map<lli,lli> &m, lli x,lli cnt=1) { auto jt=m.find(x); if(jt->Y<=cnt) m.erase(jt); else jt->Y-=cnt; } bool cmp(const ii &a,const ii &b) { return a.X<b.X||(a.X==b.X&&a.Y<b.Y); } const lli mod = 1000000007L; // const lli maxN = 1000000007L; lli T,n,i,j,k,in,cnt,l,r,u,v,x,y; lli m; string s; vi a; vii b; //priority_queue < ii , vector < ii > , CMP > pq;// min priority_queue . lli countPaths(vii edges){ const int inf=1e9; atcoder::mcf_graph<lli,lli> g(2*n + 2); for(int i=0;i<n;++i){ g.add_edge(2*n,i,1,0); g.add_edge(i+n,2*n+1,1,0); } for(auto x:edges){ g.add_edge(x.X,n+x.Y,1,inf-1); } return n-g.flow(2*n,2*n+1).X; } lli removeOne(vii &edges,int curVal){ for(int i=0;i<n;++i){ vii ed; for(auto x:edges){ if(x.Y==i) continue; ed.pb(x); } if(curVal==countPaths(ed)){ edges.swap(ed); return -(i+1); } ed.clear(); for(auto x:edges){ if(x.X==i) continue; ed.pb(x); } if(curVal==countPaths(ed)){ edges.swap(ed); return (i+1); } } assert(false); } vi solve(vii edges,lli k){ vi answers(k+1,-INF); dbg(countPaths(edges)); const int st=countPaths(edges); for(int fw=st;fw<=k;++fw){ answers[fw]=removeOne(edges,fw+1); } return answers; } int main(void) { ios_base::sync_with_stdio(false);cin.tie(NULL); // freopen( txt.in , r , stdin); // freopen( txt.out , w , stdout); // cout<<std::fixed<<std::setprecision(35); // cin>>T;while(T--) { cin>>n>>m>>k; vii edges; fo(i,m) { cin>>u>>v; u--;v--; edges.pb({u,v}); } auto operations=solve(edges,k); b.resize(k+1); for(int i=1;i<=k;++i){ cin>>b[i].X>>b[i].Y; b[i].Y=min(b[i].X,b[i].Y); } b[0]={INF,1e12}; lli curVal=-INF; vector<vi> ansb(k+1); auto getBest=[&](const lli rest){ vector<vi> before(k+1); auto bb=b; auto insert=[&](const int place,const int op){ before[place].pb(op); bb[place].X-=bb[place].Y; bb[place].X=max(bb[place].X,0LL); bb[place].Y=min(bb[place].Y,bb[place].X); }; for(int i=1;i<rest&&i<=k;++i){ if(operations[i]==-INF) continue; const int op=operations[i]; int place=0; for(int j=1;j<=i;++j){ if(bb[place].Y>bb[j].Y) place=j; } insert(place,op); } for(int i=rest;i<=k;++i){ if(operations[i]==-INF) continue; const int op=operations[i]; insert(rest,op); } lli cst=0; for(int i=1;i<=k;++i) cst+=bb[i].X; dbg(bb,cst); if(cst>curVal){ curVal=cst; ansb.swap(before); } }; for(int rest=1;rest<=k+1;++rest){ getBest(rest); } dbg(curVal); vi ans; for(int i=1;i<=k;++i){ for(auto x:ansb[i]) ans.pb(x); ans.pb(0); } cout<<sz(ans)<<endl; for(auto x:ans) cout<<x<< ; cout<<endl; } aryanc403(); return 0; }
#include <bits/stdc++.h> using namespace std; int n, a[3005], ans; int main() { scanf( %d , &n); for (int i = 0; i < n; i++) { scanf( %d , a + i); for (int j = 0; j < i; j++) { if (a[j] > a[i]) ans++; } } if (ans % 2) printf( %.6lf , (ans - 1) * 2.0 + 1); else printf( %.6lf , ans * 2.0); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int arr[100000 + 1]; int n, a; set<int> s; cin >> n; vector<bool> vst(n, false); for (int i = 0; i < n; ++i) { cin >> a; arr[i] = a; s.insert(a); } int k = 1; if (n != 1) for (int i = 0; i < n; ++i) { int j = arr[i]; if (!vst[j] && j <= n) { vst[j] = 1; cout << j << ; } else { while (s.count(k) || vst[k]) { k++; } vst[k] = true; cout << k << ; k++; } } else cout << 1 ; }
#include <bits/stdc++.h> using namespace std; int perm[55]; int main() { int n; long long m; scanf( %d%lld , &n, &m); m--; int l = 1; int r = n; for (long long i = n - 2; i >= 0; i--) { if (m & (1LL << i)) { perm[r] = n - 2 - i + 1; r--; } else { perm[l] = n - 2 - i + 1; l++; } } perm[l] = n; for (int i = 1; i <= n; i++) { printf( %d , perm[i]); } return 0; }
#include <bits/stdc++.h> using namespace std; pair<long int, long int> p[500005]; bool cmp(pair<long int, long int> p1, pair<long int, long int> p2) { if (p1.second < p2.second) return true; else { if (p1.first < p2.first) return true; else return false; } } int main() { int n; int i, ans = 0, l; cin >> n; for (i = 0; i < n; i++) cin >> p[i].second >> p[i].first; sort(p, p + n); ans++; l = p[0].first; for (i = 1; i < n; i++) { if (p[i].second > l) { l = p[i].first; ans++; } } cout << ans << endl; return 0; }
#include <bits/stdc++.h> using namespace std; vector<int> alz(string a) { int n = a.size(); vector<int> res(n); int left = 0, right = 0; for (int k = 1; k < n; k++) { if (right < k) { right = left = k; while (right < n && a[right] == a[right - left]) right++; res[k] = right - left; right--; } else { int k1 = k - left; if (res[k1] < right - k + 1) res[k] = res[k1]; else { left = k; while (right < n && a[right] == a[right - left]) right++; res[k] = right - left; right--; } } } return res; } int main() { ios::sync_with_stdio(0); cin.tie(0); string ar[3]; cin >> ar[0] >> ar[1] >> ar[2]; int ta = ar[0].size() + ar[1].size() + ar[2].size(); int res = ta; int a = ar[0].size(), b = ar[1].size(), c = ar[2].size(); string neo; int per[] = {0, 1, 2}; vector<int> z; do { z = alz(ar[per[1]] + $ + ar[per[0]]); int mi = 0; int ta = ar[per[1]].size() + 1 + ar[per[0]].size(); bool ins = false; for (int i = ar[per[1]].size() + 1; i < ta; i++) { if (z[i] == ar[per[1]].size()) { ins = true; break; } if (z[i] + i == ta) { mi = z[i]; break; } } if (ins) neo = ar[per[0]]; else neo = ar[per[0]].substr(0, ar[per[0]].size() - mi) + ar[per[1]]; ins = false; z = alz(ar[per[2]] + $ + neo); ta = ar[per[2]].size() + 1 + neo.size(); mi = 0; for (int i = ar[per[2]].size() + 1; i < ta; i++) { if (z[i] == ar[per[2]].size()) { ins = true; break; } if (z[i] + i == ta) { mi = z[i]; break; } } if (ins) { res = min(res, (int)neo.size()); } else res = min(res, (int)neo.size() + (int)ar[per[2]].size() - mi); } while (next_permutation(per, per + 3)); cout << res << n ; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; int x[n]; for (int i = 0; i < n; i++) cin >> x[i]; sort(x, x + n); int c = n / 2, ans = 0; for (int i = 0; i < n / 2 && c < n; i++, c++) if (x[i] * 2 <= x[c]) ans++; else i--; cout << n - ans << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { long long int t, n, x, m, z, u, v, f, a, b, l, r; cin >> t; while (t--) { cin >> n >> x >> m; a = x; b = x; for (int i = 0; i < m; i++) { cin >> l >> r; if (a >= l && a <= r && b >= l && b <= r) { a = min(a, l); b = max(b, r); } else if (a >= l && a <= r && b >= r) { a = min(a, l); b = max(b, r); } else if (a <= l && b >= l && b <= r) { a = min(a, l); b = max(b, r); } else if (a == l || b == l || a == r || b == r) { a = min(a, l); b = max(b, r); } } cout << b - a + 1 << endl; } }
#include <bits/stdc++.h> using namespace std; int main() { int x; cin >> x; int a[x], i; for (i = 0; i < x; i++) { cin >> a[i]; } sort(a, a + x); int s = 0; int j = 0, m = 0; for (i = 0; i < x; i++) { while (j < x && a[j] - a[i] <= 5) { j++; s = max(s, j - i); } } cout << s; }
#include <bits/stdc++.h> using namespace std; int n, m; vector<pair<char, long long> > s1; vector<pair<char, long long> > s2; vector<pair<char, long long> > p; int sl, pl; int lps[1000009]; vector<int> ii; void calclps() { lps[0] = 0; int j = 0, i = 1; while (i < pl) { if (p[j] == p[i]) { if (j == 0) { lps[i] = 1; } else { lps[i] = j + 1; } j++; i++; } else { if (j == 0) { lps[i] = 0; i++; } else { j = lps[j - 1]; } } } } void kmp() { ii.clear(); if (p.size() == 1) { for (int i = 0; i < (int)sl; i++) { if (s1[i] == p[0]) ii.push_back(i); } return; } calclps(); int i = 0, j = 0; while (i < sl) { if (s1[i] == p[j]) { if (j == pl - 1) { ii.push_back(i - pl + 1); j = lps[j - 1]; } else { i++; j++; } } else { if (j == 0) i++; else j = lps[j - 1]; } } } void print(vector<pair<char, long long> > v) { cout << printing : << endl; for (int i = 0; i < (int)v.size(); i++) { cout << v[i].first << << v[i].second << endl; } } int main() { scanf( %d , &n); scanf( %d , &m); for (int i = 0; i < n; i++) { long long a; cin >> a; getchar(); char c = getchar(); if (i != 0 && s1[s1.size() - 1].first == c) { s1[s1.size() - 1].second += a; } else { s1.push_back(make_pair(c, a)); } } for (int i = 0; i < m; i++) { long long a; cin >> a; getchar(); char c = getchar(); if (i != 0 && s2[s2.size() - 1].first == c) { s2[s2.size() - 1].second += a; } else { s2.push_back(make_pair(c, a)); } } long long ans = 0; if (s2.size() == 1) { char c = s2[0].first; long long v = s2[0].second; for (int i = 0; i < (int)s1.size(); i++) { if (c == s1[i].first && s1[i].second >= v) { ans += s1[i].second - v + 1; } } } else if (s2.size() == 2) { char c1 = s2[0].first; char c2 = s2[1].first; long long v1 = s2[0].second; long long v2 = s2[1].second; for (int i = 1; i < (int)s1.size(); i++) { if (s1[i - 1].first == c1 && s1[i].first == c2 && s1[i - 1].second >= v1 && s1[i].second >= v2) ans++; } } else { for (int i = 1; i < (int)s2.size() - 1; i++) { p.push_back(s2[i]); } sl = s1.size(); pl = p.size(); kmp(); for (int i = 0; i < (int)ii.size(); i++) { int x = ii[i]; if (x > 0 && x + pl < n && s1[x - 1].first == s2[0].first && s1[x - 1].second >= s2[0].second && s1[x + pl].first == s2[s2.size() - 1].first && s1[x + pl].second >= s2[s2.size() - 1].second) ans++; } } cout << ans << endl; }
#include <bits/stdc++.h> using namespace std; const int INF = 1e9; const int MOD = 1e9 + 7; const long long INF64 = 1e18; const long double EPS = 1e-7; mt19937 myrand(time(NULL)); const int N = 100 * 1000 + 13; int n, ac, d; pair<int, int> a[N]; long double t[N]; bool read() { if (scanf( %d%d%d , &n, &ac, &d) != 3) return 0; for (int i = 0; i < (n); i++) scanf( %d%d , &a[i].first, &a[i].second); return 1; } void solve() { for (int i = 0; i < (n); i++) { long double cur = a[i].second * 1.0 / ac; t[i] = a[i].first; if (cur * cur * ac / 2 > d - EPS) t[i] += sqrtl(d * 2.0 / ac); else t[i] += cur + (d - cur * cur * ac / 2) / a[i].second; if (i && t[i] < t[i - 1]) t[i] = t[i - 1]; printf( %.10f n , (double)t[i]); } } int main() { while (read()) solve(); return 0; }
#include <bits/stdc++.h> using namespace std; int maxint = ~0U >> 1; int flow, cost; int pi[200001 + 1], v[200001 + 1]; int S, T; int INF = 1000000000; int tempAdd = 100000; struct etype { int t, c; etype* next; etype* pair; etype() { next = 0; } etype(int _t, int _c, etype* _n) { t = _t, c = _c, next = _n; } } * e[200001 + 1], *eb[200001 + 1], *Pe, *Pool; int aug(int w, int lim) { int t; v[w] = 1; if (w == T) { flow += lim; return lim; } for (etype*& i = e[w]; i; i = i->next) if (i->c && !v[i->t] && pi[w] == pi[i->t] + 1) if (t = aug(i->t, min(lim, i->c))) return i->c -= t, i->pair->c += t, t; return 0; } bool fix() { int t = maxint; for (int i = S; i <= T; i++) if (v[i]) { for (etype* j = eb[i]; j; j = j->next) if (j->c && !v[j->t]) t = min(t, pi[j->t] + 1 - pi[i]); } if (t == maxint) return 0; for (int i = S; i <= T; i++) if (v[i]) e[i] = eb[i], pi[i] += t; return 1; } void addedge(int s, int t, int c) { ++Pe; Pe->t = t, Pe->c = c, Pe->next = e[s]; e[s] = Pe; ++Pe; Pe->t = s, Pe->c = 0, Pe->next = e[t]; e[t] = Pe; e[s]->pair = e[t]; e[t]->pair = e[s]; } void prepare() { if (Pool == NULL) Pool = new etype[1000001]; Pe = Pool; memset(e, 0, sizeof(e)); } int MaxFlow() { flow = 0, cost = 0; memcpy(eb, e, sizeof(e)); memset(pi, 0, sizeof(pi)); do { do memset(v, 0, sizeof(v)); while (aug(S, maxint)); } while (fix()); return flow; } int nDog, nPeople; int oriSex[10001]; int g; int dogNode(int x) { return 1 + x; } int peopleNode(int x) { return 1 + 10000 + x; } int MAIN() { prepare(); S = 1, T = 1 + 10000 + 2000 + 1; cin >> nDog >> nPeople >> g; int ifAllGet = 0; for (int i = 1; i <= nDog; i++) cin >> oriSex[i]; for (int i = 1; i <= nDog; i++) { int t; cin >> t; addedge(S, dogNode(i), tempAdd); addedge(dogNode(i), T, tempAdd); if (oriSex[i] == 0) addedge(dogNode(i), T, t); else addedge(S, dogNode(i), t); } for (int i = 1; i <= nPeople; i++) { addedge(S, peopleNode(i), tempAdd); addedge(peopleNode(i), T, tempAdd); int wantSex, pay, needDog; cin >> wantSex >> pay >> needDog; ifAllGet += pay; if (wantSex == 0) addedge(peopleNode(i), T, pay); else addedge(S, peopleNode(i), pay); for (int j = 1; j <= needDog; j++) { int t; cin >> t; if (wantSex == 1) addedge(peopleNode(i), dogNode(t), INF); else addedge(dogNode(t), peopleNode(i), INF); } int isFriend; cin >> isFriend; if (isFriend) { if (wantSex == 0) addedge(peopleNode(i), T, g); else addedge(S, peopleNode(i), g); } } cout << ifAllGet - MaxFlow() + (nDog + nPeople) * tempAdd << endl; return 0; } int main() { ios ::sync_with_stdio(false); cout << fixed << setprecision(16); return MAIN(); }
#include <bits/stdc++.h> using namespace std; template <class T> bool inside(T a, T b, T c) { return a <= b && b <= c; } long long modpower(long long x, long long n) { long long m = 1000000007; long long ans = 1; x = (x + m) % m; while (n > 0) { if (n & 1) { ans = (ans * x) % m; } n = n >> 1; x = (x * x) % m; } return ans; } long long am(long long a, long long b) { return (a + b) % 1000000007; } long long sm(long long a, long long b) { return (a - b + 1000000007) % 1000000007; } long long mm(long long a, long long b) { return (a * b) % 1000000007; } long long dm(long long a, long long b) { return (a * modpower(b, 1000000007 - 2)) % 1000000007; } int main() { ios_base::sync_with_stdio(false); ; cin.tie(NULL); cout.tie(NULL); ; long long n; cin >> n; cout << sm(modpower(3, 3 * n), modpower(7, n)) << n ; return 0; }
#include <bits/stdc++.h> using namespace std; const int MAXN = 222222; const int inf = 1e9 + 7; vector<int> adj[MAXN], radj[MAXN]; int vis[MAXN], q[MAXN], qn, C; int cost[MAXN], mn[MAXN], cnt[MAXN]; void dfs(int u) { vis[u] = 1; for (auto v : adj[u]) { if (vis[v] == 1) continue; dfs(v); } q[qn++] = u; } void rdfs(int u) { vis[u] = C; for (int i = 0; i < radj[u].size(); i++) { int v = radj[u][i]; if (vis[v] == 0) rdfs(v); } } void SCC(int n) { for (int i = 1; i <= n; i++) vis[i] = 0; qn = C = 0; for (int i = 1; i <= n; i++) { if (!vis[i]) { dfs(i); } } for (int i = 1; i <= n; i++) vis[i] = 0; for (int i = qn - 1; i >= 0; i--) { int cc = q[i]; if (!vis[cc]) { C++; rdfs(cc); } } } int main() { int n, m, u, v; scanf( %d , &n); for (int i = 1; i <= n; i++) scanf( %d , cost + i); scanf( %d , &m); for (int i = 0; i < m; i++) { scanf( %d%d , &u, &v); adj[u].push_back(v); radj[v].push_back(u); } SCC(n); for (int i = 1; i <= C; i++) { mn[i] = inf; cnt[i] = 0; } for (int i = 1; i <= n; i++) { int cc = vis[i]; if (mn[cc] == cost[i]) cnt[cc]++; if (mn[cc] > cost[i]) mn[cc] = cost[i], cnt[cc] = 1; } long long ansc = 0, ansn = 1; for (int i = 1; i <= C; i++) { ansc += mn[i]; ansn = (1LL * ansn * cnt[i]) % inf; } printf( %lld %lld n , ansc, ansn); return 0; }
#include <bits/stdc++.h> using namespace std; const int MAX = (2e5) + 10; pair<int, int> ara[MAX]; int id[MAX]; vector<int> didi[MAX]; void solve() { int n; cin >> n; for (int i = 0; i <= n - 1; i++) { cin >> ara[i].first; } for (int i = 0; i <= n - 1; i++) { cin >> ara[i].second; } sort(ara, ara + n, [](pair<int, int> x, pair<int, int> y) { return (x.first == y.first) ? x.second > y.second : x.first < y.first; }); int cp = -1; priority_queue<int> que; long long sum, prin; sum = prin = 0; for (int i = 0; i <= n - 1; i++) { if (cp >= ara[i].first) { que.push(ara[i].second); sum += ara[i].second; } else { if (!que.empty()) { sum -= que.top(); que.pop(); prin += sum; cp++; i--; } else { cp = ara[i].first; i--; } } } while (!que.empty()) { sum -= que.top(); que.pop(); prin += sum; } cout << prin << endl; } int main() { ios::sync_with_stdio(false); int tc; solve(); return 0; }
#include <bits/stdc++.h> using namespace std; long long n, m, num[200001], sum[200001], ans; set<int> s; int main() { cin >> n >> m; for (int i = 0; i < m; i++) s.insert(i); for (int i = 0; i < n; i++) { int d, tmp; cin >> num[i]; d = num[i] % m; if (d > *s.rbegin()) tmp = *s.begin(); else tmp = *s.lower_bound(d); sum[tmp]++; if (sum[tmp] == n / m) s.erase(tmp); int s = (tmp - d + m) % m; ans += s; num[i] += s; } cout << ans << endl; for (int i = 0; i < n; i++) cout << num[i] << ; return 0; }
#include <bits/stdc++.h> using namespace std; int m[100100]; vector<int> diff[100100]; int main() { int n; cin >> n; for (int i = 1; i <= n; i++) { cin >> m[i]; diff[i - m[i]].push_back(i); } long long sum = 0; int d = 0, tot = 1; for (int i = 2; i <= n; i++) { auto it = upper_bound(diff[d + 1].begin(), diff[d + 1].end(), i); sum += tot - m[i]; if (it != diff[d + 1].end() || m[i] == tot) tot++; else { d++; sum--; } } cout << sum << endl; return 0; }
#include <bits/stdc++.h> int main() { int a, b; scanf( %d %d , &a, &b); printf( %d , a * b / 2); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int n, i, j; cin >> n; set<int> row; set<int> col; map<int, int> row_map; map<int, int> col_map; for (i = 1; i <= n; i++) { string s; cin >> s; for (j = 1; j <= n; j++) { if (s[j - 1] == . ) { row.insert(i); col.insert(j); row_map[i] = j; col_map[j] = i; } } } if (row.size() == n) { for (i = 1; i <= n; i++) { cout << i << << row_map[i] << endl; } } else if (col.size() == n) { for (j = 1; j <= n; j++) { cout << col_map[j] << << j << endl; } } else cout << -1 << endl; }
#include <bits/stdc++.h> using namespace std; int n, a[200005], sum; int main() { cin >> n; for (int i = 1; i <= n; i++) cin >> a[i], sum ^= a[i]; if (n % 2 == 0) { if (sum) { puts( NO ); return 0; } n--; } puts( YES ); printf( %d n , n - 1); for (int i = 1; i <= n - 2; i += 2) printf( %d %d %d n , i, i + 1, i + 2); for (int i = 1; i <= n - 2; i += 2) printf( %d %d %d n , i, i + 1, n); }
#include bits/stdc++.h using namespace std; typedef long long ll; typedef long double ld; typedef complex<ld> cd; typedef pair<int, int> pi; typedef pair<ll,ll> pl; typedef pair<ld,ld> pd; typedef vector<int> vi; typedef vector<ld> vd; typedef vector<ll> vl; typedef vector<pi> vpi; typedef vector<pl> vpl; typedef vector<cd> vcd; #define FOR(i, a, b) for (int i=a; i<(b); i++) #define F0R(i, a) for (int i=0; i<(a); i++) #define FORd(i,a,b) for (int i = (b)-1; i >= a; i--) #define F0Rd(i,a) for (int i = (a)-1; i >= 0; i--) #define trav(a,x) for (auto& a : x) #define uid(a, b) uniform_int_distribution<int>(a, b)(rng) #define sz(x) (int)(x).size() #define mp make_pair #define pb push_back #define f first #define s second #define lb lower_bound #define ub upper_bound #define all(x) x.begin(), x.end() #define ins insert template<class T> bool ckmin(T& a, const T& b) { return b < a ? a = b, 1 : 0; } template<class T> bool ckmax(T& a, const T& b) { return a < b ? a = b, 1 : 0; } mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); const int MOD = 1000000007; const char nl = n ; const int MX = 100001; //check the limits, dummy int main() { //freopen( input.txt , r , stdin); ios_base::sync_with_stdio(0); cin.tie(0); int T; cin >> T; while(T--) { int N; cin >> N; vector<string> A(N); F0R(i, N) { cin >> A[i]; //debug(A[i]); } bool good[N][N]; F0R(i, N) F0R(j, N) good[i][j] = false; F0R(x, 10) { F0R(i, N) { F0R(j, N) { if (A[i][j] - 0 == x) { good[i][j] = true; break; } } F0Rd(j, N) { if (A[i][j] - 0 == x) { good[i][j] = true; break; } } } F0R(j, N) { F0R(i, N) { if (A[i][j] - 0 == x) { good[i][j] = true; break; } } F0Rd(i, N) { if (A[i][j] - 0 == x) { good[i][j] = true; break; } } } } vpi pos[10]; F0R(i, N) { F0R(j, N) { if (good[i][j]) { int cur = A[i][j] - 0 ; //debug(cur, A[i][j]); pos[cur].pb({i, j}); } //cout << good[i][j] << ; } //cout << n ; } F0R(x, 10) { int ans = 0; //debug(pos[x].size()); F0R(i, sz(pos[x])) { FOR(j, i+1, sz(pos[x])) { pi X = pos[x][i], Y = pos[x][j]; //debug(X.f, X.s, Y.f, Y.s); if (X.f == Y.f) { ckmax(ans, abs(X.s - Y.s) * max(X.f, N-1-X.f)); } else if (X.s == Y.s) { ckmax(ans, abs(X.f - Y.f) * max(X.s, N-1-X.s)); } else { ckmax(ans, max(abs(X.s-Y.s)*max(max(X.f, Y.f), N-1-min(X.f, Y.f)), abs(X.f-Y.f)*max(max(X.s, Y.s), N-1-min(X.s, Y.s)))); } } } cout << ans << ; } cout << nl; } return 0; } // read the question correctly (ll vs int) // template by bqi343
#include <bits/stdc++.h> using namespace std; unsigned long long t1, t2, c1, c2, t0; unsigned long long yy1 = 0, y2 = 0; unsigned long long resyy1, resy2; inline bool besser(unsigned long long res1, unsigned long long res2, unsigned long long res3, unsigned long long res4) { return res1 * t1 * res4 + res2 * t2 * res3 < res3 * t1 * res2 + res4 * t2 * res1; } inline bool eq(unsigned long long res1, unsigned long long res2, unsigned long long res3, unsigned long long res4) { return res1 * t1 * res4 + res2 * t2 * res3 == res3 * t1 * res2 + res4 * t2 * res1; } int main() { cin >> t1 >> t2 >> c1 >> c2 >> t0; if (t1 == t2) { cout << c1 << << c2 << endl; return 0; } resyy1 = 0, resy2 = c2; yy1 = 1; while (yy1 <= c1) { while (y2 <= c2 && (t1 * yy1 + t2 * y2 < t0 * (yy1 + y2))) y2++; if (y2 > c2) break; if ((t1 * yy1 + t2 * y2 < t0 * (yy1 + y2))) { break; } else { if (besser(yy1, y2, resyy1, resy2)) { resyy1 = yy1, resy2 = y2; yy1++; continue; } if (eq(yy1, y2, resyy1, resy2) && (yy1 + y2 > resyy1 + resy2)) { resyy1 = yy1, resy2 = y2; yy1++; continue; } } yy1++; } cout << resyy1 << << resy2 << endl; }
#include <bits/stdc++.h> using namespace std; const int MOD = 1e9 + 7; const long long INF = 1e18; const long double PI = 4 * atan((long double)1); const int INFTY = 1e7; template <unsigned int N> class Field { inline unsigned int pow(unsigned int a, unsigned int p) { unsigned int r = 1, e = a; while (p) { if (p & 1) { r = ((unsigned long long)r * e) % N; } e = ((unsigned long long)e * e) % N; p >>= 1; } return r; } inline unsigned int inv(unsigned int a) { return pow(a, N - 2); } public: inline Field(int x = 0) : v(x) {} inline Field<N> pow(int p) { return (*this) ^ p; } inline Field<N> operator^(int p) { return {(int)pow(v, (unsigned int)p)}; } inline Field<N> &operator+=(const Field<N> &o) { if (v + o.v >= N) v += o.v - N; else v += o.v; return *this; } inline Field<N> &operator-=(const Field<N> &o) { if (v < o.v) v -= o.v - N; else v -= o.v; return *this; } inline Field<N> &operator*=(const Field<N> &o) { v = (unsigned long long)v * o.v % N; return *this; } inline Field<N> &operator/=(const Field<N> &o) { return *this *= inv(o.v); } inline Field<N> operator+(const Field<N> &o) const { Field<N> r{*this}; return r += o; } inline Field<N> operator-(const Field<N> &o) const { Field<N> r{*this}; return r -= o; } inline Field<N> operator*(const Field<N> &o) const { Field<N> r{*this}; return r *= o; } inline Field<N> operator/(const Field<N> &o) const { Field<N> r{*this}; return r /= o; } inline Field<N> operator-() { if (v) return {(int)(N - v)}; else return {0}; }; inline Field<N> &operator++() { ++v; if (v == N) v = 0; return *this; } inline Field<N> operator++(int) { Field<N> r{*this}; ++*this; return r; } inline Field<N> &operator--() { --v; if (v == -1) v = N - 1; return *this; } inline Field<N> operator--(int) { Field<N> r{*this}; --*this; return r; } inline bool operator==(const Field<N> &o) const { return o.v == v; } inline bool operator!=(const Field<N> &o) const { return o.v != v; } inline explicit operator unsigned int() const { return v; } inline static vector<Field<N>> fact(int t) { vector<Field<N>> F(t + 1, 1); for (int i = 2; i <= t; ++i) { F[i] = F[i - 1] * i; } return F; } inline static vector<Field<N>> invfact(int t) { vector<Field<N>> F(t + 1, 1); Field<N> X{1}; for (int i = 2; i <= t; ++i) { X = X * i; } F[t] = 1 / X; for (int i = t - 1; i >= 2; --i) { F[i] = F[i + 1] * (i + 1); } return F; } private: unsigned int v; }; template <unsigned int N> istream &operator>>(std::istream &is, Field<N> &first) { unsigned int v; is >> v; first = v; return is; } template <unsigned int N> ostream &operator<<(std::ostream &os, const Field<N> &first) { return os << (unsigned int)first; } template <unsigned int N> Field<N> operator+(int i, const Field<N> &first) { return Field<N>(i) + first; } template <unsigned int N> Field<N> operator-(int i, const Field<N> &first) { return Field<N>(i) - first; } template <unsigned int N> Field<N> operator*(int i, const Field<N> &first) { return Field<N>(i) * first; } template <unsigned int N> Field<N> operator/(int i, const Field<N> &first) { return Field<N>(i) / first; } long long fact[200005]; long long MI[200005]; int main() { ios::sync_with_stdio(0); cin.tie(NULL); cout.tie(NULL); long long n, m; cin >> n; vector<pair<long long, long long>> a(2 * n); for (int i = 0; i < (2 * n); i++) cin >> a[i].first, a[i].second = i % n; sort(a.begin(), a.end()); cin >> m; fact[0] = fact[1] = 1; for (int i = 2; i <= 200000; ++i) fact[i] = (1ll * fact[i - 1] * i) % m; MI[0] = 1; MI[1] = (m + 1) / 2; for (int i = 2; i <= 200000; ++i) MI[i] = (MI[i - 1] * MI[1]) % m; int i = 0; long long ans = 1; while (i < 2 * n) { int j = i, c = 0; while (j < 2 * n && a[i].first == a[j].first) { if (j > i && a[j].second == a[j - 1].second) { c++; } j++; } for (int x = 1; x <= j - i; x++) { int y = x; while (y % 2 == 0 && c > 0) { y /= 2; c--; } ans = (ans * y) % m; } i = j; } cout << ans << endl; }
#include <bits/stdc++.h> using namespace std; const double eps = 1e-6; double r; int main() { scanf( %lf , &r); for (int a = 1; a <= 10; ++a) { for (int h = 1; h <= 10; ++h) { double area = (a / 2.0 * h); double bot = sqrt(a * a / 4.0 + h * h); double tmp = area / bot; if (fabs(tmp - r) < eps) { printf( %d %d n , a, h); return 0; } } } }
#include <bits/stdc++.h> using namespace std; long long modpow(long long a, long long p, long long mod) { long long ret = 1; while (p) { if (p & 1) ret = (ret * a) % mod; a = (a * a) % mod; p /= 2; } return ret; } long long power(long long a, long long p) { long long ret = 1; while (p) { if (p & 1) ret = (ret * a); a = (a * a); p /= 2; } return ret; } int compare(const void* a, const void* b) { return (*(int*)a - *(int*)b); } int main() { int i, j, k, tmp; ios_base::sync_with_stdio(0); cin.tie(NULL); int n, m; cin >> n >> m; vector<pair<int, int> > f(n); vector<int> b(m); vector<int> f1(n); int fch[100010] = {0}; int fin[100010] = {0}; for (i = 0; i < n; i++) { cin >> j; f[i] = make_pair(j, i); f1[i] = j; fch[j] += 1; fin[j] = i; } for (i = 0; i < m; i++) { cin >> b[i]; } vector<int> a(m); int flam = 0; int flim = 0; for (i = 0; i < m; i++) { if (fch[b[i]] == 0) { flim = 1; } if (fch[b[i]] > 1) { flam = 1; } a[i] = fin[b[i]] + 1; } if (flim == 1) { cout << Impossible << endl; return 0; } if (flam == 1) { cout << Ambiguity << endl; return 0; } cout << Possible << endl; for (i = 0; i < m; i++) cout << a[i] << ; cout << endl; return 0; }
#include <bits/stdc++.h> using namespace std; const int maxn = 501010; int n, k; int a[maxn], b[maxn]; long long s; int cnt; priority_queue<pair<int, int> > q; void Check(int d) { s = 0; cnt = 0; for (int i = 1; i <= n; ++i) { q.push(make_pair(d - a[i], 0)); int tmp = b[i] - q.top().first; if (tmp < 0) { s += tmp; if (!q.top().second) ++cnt; q.pop(); q.push(make_pair(b[i], 1)); } } while (q.size()) q.pop(); } int main() { scanf( %d%d , &n, &k); for (int i = 1; i <= n; ++i) scanf( %d , a + i); for (int i = 1; i <= n; ++i) scanf( %d , b + i); long long l = 0, r = 2e9, mid; while (l < r) { mid = (l + r) >> 1; Check(mid); if (cnt < k) l = mid + 1; else r = mid; } Check(l); printf( %lld n , s + 1ll * l * k); return 0; }
#include <bits/stdc++.h> using namespace std; long long int power(long long int x, long long int y, long long int p) { long long int res = 1; x = x % p; while (y > 0) { if (y & 1) res = (res * x) % p; y = y / 2; x = (x * x) % p; } return res; } void solve() { long long int n, m, l, h, i; cin >> n >> m; l = 0; h = n * m - 1; while (l < h) { cout << l / m + 1 << << l % m + 1 << n ; cout << h / m + 1 << << h % m + 1 << n ; ++l, --h; } if (l == h) cout << l / m + 1 << << l % m + 1 << n ; } int main() { long long int t = 1; while (t--) { solve(); } return 0; }
#include <bits/stdc++.h> using namespace std; void read_file(bool outToFile = true) {} int n, m; bool vis[500 + 9][500 + 9]; string s; int l; int x, y; int ans[100000 + 1 + 9]; string alpha = *URDL ; int dij[5][2] = {{0, 0}, {-1, 0}, {0, +1}, {+1, 0}, {0, -1}}; bool valid(int i, int j) { return 0 <= i && i < n && 0 <= j && j < m; } int main() { read_file(); while (scanf( %d%d , &n, &m) != EOF) { scanf( %d%d , &x, &y); x--, y--; memset(vis, 0, sizeof vis); cin >> s; s = * + s; l = s.length(); for (int i = 0; i < l - 1; i++) { int nx, ny; nx = x + dij[alpha.find(s[i])][0]; ny = y + dij[alpha.find(s[i])][1]; if (!valid(nx, ny)) { ans[i] = 0; continue; } x = nx, y = ny; if (!vis[x][y]) { vis[x][y] = 1; ans[i] = 1; } else ans[i] = 0; } int cnt = n * m; for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) cnt -= vis[i][j]; ans[l - 1] = cnt; for (int i = 0; i < l; i++) printf( %d%c , ans[i], n [i == l - 1]); } }