func_code_string
stringlengths 59
71.4k
|
|---|
#include <bits/stdc++.h> using namespace std; const int INF = 1000000000; const int diri[4] = {-1, 0, 1, 0}; const int dirj[4] = {0, 1, 0, -1}; int A, B; int va[110000], vb[110000]; bool esquerra(int a, int b) { if (b < 0) return false; if (a == 0) return true; return va[a - 1] < vb[b]; } bool dreta(int a, int b) { if (b + 1 >= B) return false; if (a + 1 == A) return true; return va[a + 1] > vb[b + 1]; } int main() { int spam; cin >> A >> B >> spam >> spam; for (int i = 0; i < int(A); ++i) cin >> va[i]; for (int i = 0; i < int(B); ++i) cin >> vb[i]; vector<int> dist(B, -1); int res = A; int b = -1; for (int a = 0; a < A; ++a) { while (b + 1 < B and vb[b + 1] <= va[a]) ++b; int d = INF; if (0 <= b and b < B) d = min(d, abs(va[a] - vb[b])); if (b + 1 < B) d = min(d, abs(va[a] - vb[b + 1])); if (esquerra(a, b) and d == abs(va[a] - vb[b])) { if (dist[b] == -1 or dist[b] == d) { dist[b] = d; --res; continue; } } if (dreta(a, b) and d == abs(va[a] - vb[b + 1])) { dist[b + 1] = d; --res; continue; } } cout << res << endl; } |
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; int biceps = 0, back = 0, chest = 0; for (int i = 0; i < n; i++) { int a; cin >> a; if (i % 3 == 0) chest += a; if (i % 3 == 1) biceps += a; if (i % 3 == 2) back += a; } if (chest > back && chest > biceps) cout << chest ; if (back > chest && back > biceps) cout << back ; if (biceps > chest && biceps > back) cout << biceps ; return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int t, n; cin >> t; while (t--) { cin >> n; int a[n], flag = 0, x; for (int i = 0; i < n; i++) cin >> a[i]; for (int i = 0; i < n; i++) { if (a[i] % 2 == 0) { x = i + 1; flag = 1; break; } } if (n == 1 && flag == 0) cout << -1 << endl; else if (flag == 1) cout << 1 << endl << x << endl; else cout << 2 << endl << 1 << << 2 << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; const int MAX = 2e5 + 10; int cnt[MAX]; vector<int> up, down; int main() { ios::sync_with_stdio(false); memset(cnt, 0, sizeof(cnt)); int n, x, max_num = -1; cin >> n; for (int i = 0; i < n; i++) { cin >> x; cnt[x]++; max_num = max(max_num, x); } for (int i = 0; i <= max_num; i++) { if (cnt[i] > 2) { cout << NO << endl; return 0; } } for (int i = max_num; i >= 0; i--) { if (cnt[i]) { down.push_back(i); cnt[i]--; } } for (int i = 0; i <= max_num; i++) { if (cnt[i]) { up.push_back(i); cnt[i]--; } } cout << YES << endl; cout << up.size() << endl; if (up.size() > 0) { for (int i = 0; i < up.size() - 1; i++) cout << up[i] << ; cout << up[up.size() - 1] << endl; } else { cout << << endl; } cout << down.size() << endl; if (down.size() > 0) { for (int i = 0; i < down.size() - 1; i++) cout << down[i] << ; cout << down[down.size() - 1] << endl; } else { cout << << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; const int MAXN = 101000; int N; bool getv(int n) { int a, b; printf( ? %d n , 1 + n); fflush(stdout); scanf( %d , &a); printf( ? %d n , 1 + n + (N / 2)); fflush(stdout); scanf( %d , &b); if (a == b) { printf( ! %d n , 1 + n); exit(0); } return a > b; } int main() { scanf( %d , &N); if (N % 4 > 0) { printf( ! -1 n ); return 0; } bool bvt = getv(0); int low = 0, high = N / 2; while (high > low + 1) { int mid = low + (high - low) / 2; if (getv(mid) == bvt) low = mid; else high = mid; } getv(high); printf( ! -1 n ); return 0; } |
#include <bits/stdc++.h> using namespace std; long long n, len, i, j, a[300009]; int main() { while (scanf( %I64d , &n) == 1) { for (i = 0; i < n; i++) { scanf( %I64d , &a[i]); } sort(a, a + n); if (n % 2 != 0) { printf( %I64d n , a[n / 2]); } else { printf( %I64d n , a[n / 2 - 1]); } } return 0; } |
#include <bits/stdc++.h> using namespace std; const double PI = 3.14159265358979323846; const double eps = (1e-10); int isGreater(long double x, long double y) { if (abs(x - y) < eps) return 0; if (x > y) return 1; return -1; } const int MOD = 998244353; int mult(int x, int y) { return (1LL * x * y) % MOD; } int add(int x, int y) { x += y; while (x >= MOD) x -= MOD; while (x < 0) x += MOD; return x; } int add(vector<int> v) { int ret = 0; for (int i = 0; i < (int)((v).size()); ++i) ret = add(ret, v[i]); return ret; } const int MAX_N = 3e5 + 5; vector<int> adj[MAX_N]; int dp[MAX_N][3][2]; int n; void calc(int u, int p) { for (int v : adj[u]) { if (v != p) calc(v, u); } dp[u][0][1] = 0; dp[u][0][0] = 1; for (int v : adj[u]) { if (v != p) dp[u][0][0] = mult(dp[u][0][0], add({dp[v][0][0], dp[v][2][0], dp[v][2][1]})); } dp[u][2][0] = dp[u][2][1] = 1; for (int v : adj[u]) { if (v != p) { dp[u][2][0] = mult(dp[u][2][0], add({dp[v][1][0], dp[v][1][1], dp[v][2][0], dp[v][2][1], dp[v][0][0]})); dp[u][2][1] = mult(dp[u][2][1], add({dp[v][1][0], dp[v][2][0], dp[v][2][1], dp[v][0][0]})); } } dp[u][2][0] = add(dp[u][2][0], -dp[u][0][0]); dp[u][2][1] = add(dp[u][2][1], -dp[u][0][0]); if (u == 0) return; dp[u][1][0] = dp[u][1][1] = 1; for (int v : adj[u]) { if (v != p) { dp[u][1][0] = mult(dp[u][1][0], add({dp[v][0][0], dp[v][2][0], dp[v][2][1], dp[v][1][0], dp[v][1][1]})); dp[u][1][1] = mult(dp[u][1][1], add({dp[v][0][0], dp[v][2][0], dp[v][2][1], dp[v][1][0]})); } } } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); cin >> 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); } calc(0, n); cout << add({dp[0][0][0], dp[0][2][0], dp[0][2][1], -1}); return 0; } |
#include <bits/stdc++.h> using namespace std; vector<pair<long long, long long>> calced; long long x_m(long long m, long long mod) { for (pair<long long, long long> a : calced) { if (a.first == m) return a.second; } if (m == 1) return 1 % mod; if (m == 2) return 3 % mod; for (long long i = 1; i < m; i *= 2) { if (i * 2 > m) { long long pw = x_m(i, mod); long long pw2 = x_m(i - 1, mod); long long val = (pw + (m - i) * (pw - pw2)) % mod; if (val < 0) val += mod; calced.insert(calced.begin(), make_pair(m, val)); return val; } if (i * 2 == m) { long long val = (2 * (x_m(m - 1, mod)) + 1) % mod; if (val < 0) val += mod; calced.insert(calced.begin(), make_pair(m, val)); return val; } } } int main() { ios::sync_with_stdio(false); cin.tie(nullptr); int n; cin >> n; for (int i = 0; i < n; i++) { calced.clear(); long long d, m; cin >> d >> m; cout << x_m(d, m) << endl; } } |
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; while (n--) { string s; cin >> s; int i, k, cnt = 0; for (i = 0; i < s.length(); i++) if (s[i] != 0 ) break; k = i; for (i; i < s.length(); i++) if (s[i] == 0 ) cnt++; for (int j = s.length(); j >= k; j--) { if (s[j] == 0 ) cnt--; else if (s[j] == 1 ) break; } cout << cnt << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(0); cin.tie(NULL); ; long long t; cin >> t; while (t--) { long long n, x, m; cin >> n >> x >> m; long long c, d; long long l = x, r = x; while (m--) { cin >> c >> d; if (c <= l && d >= r) { l = c; r = d; } else if (c <= l && d <= r && d >= l) l = c; else if (l <= c && c <= r && d >= r) r = d; } cout << (r - l + 1) << n ; } return 0; } |
#include <bits/stdc++.h> using namespace std; const long long inf = 27; long long n, a[inf], b[inf], c[inf], ans = -1e9; vector<long long> res; map<pair<long long, long long>, pair<long long, vector<long long> > > mp; vector<long long> mask; void btadd(long long pos, long long sum1, long long sum2, long long sum3) { if (pos == n / 2) { long long id1 = sum2 - sum1, id2 = sum3 - sum1; pair<long long, long long> id = make_pair(id1, id2); if (mp.find(id) == mp.end()) mp[id] = make_pair(sum1, mask); else mp[id] = max(mp[id], make_pair(sum1, mask)); return; } mask.push_back(1); btadd(pos + 1, sum1, sum2 + b[pos], sum3 + c[pos]); mask.pop_back(); mask.push_back(2); btadd(pos + 1, sum1 + a[pos], sum2, sum3 + c[pos]); mask.pop_back(); mask.push_back(3); btadd(pos + 1, sum1 + a[pos], sum2 + b[pos], sum3); mask.pop_back(); } vector<long long> merge(vector<long long> x, vector<long long> y) { for (auto o : y) x.push_back(o); return x; } void bt(long long pos, long long sum1, long long sum2, long long sum3) { if (pos == n + 1) { long long id1 = sum1 - sum2, id2 = sum1 - sum3; pair<long long, long long> id = make_pair(id1, id2); if (mp.find(id) == mp.end()) return; if (mp[id].first + sum1 > ans) ans = mp[id].first + sum1, res = merge(mp[id].second, mask); return; } mask.push_back(1); bt(pos + 1, sum1, sum2 + b[pos], sum3 + c[pos]); mask.pop_back(); mask.push_back(2); bt(pos + 1, sum1 + a[pos], sum2, sum3 + c[pos]); mask.pop_back(); mask.push_back(3); bt(pos + 1, sum1 + a[pos], sum2 + b[pos], sum3); mask.pop_back(); } int main() { cin >> n; for (long long i = 1; i <= n; i++) cin >> a[i] >> b[i] >> c[i]; if (n == 1) { if ((a[1] == 0 && b[1] == 0)) cout << LM << endl, exit(0); if (a[1] == 0 && c[1] == 0) cout << LW << endl, exit(0); if (b[1] == 0 && c[1] == 0) cout << MW << endl, exit(0); cout << Impossible << endl; exit(0); } btadd(1, 0, 0, 0); bt(n / 2, 0, 0, 0); if (res.empty()) cout << Impossible << endl, exit(0); for (int i = 1; i <= n; i++) if (res[i - 1] == 1) cout << MW << endl; else if (res[i - 1] == 2) cout << LW << endl; else cout << LM << endl; } |
#include <bits/stdc++.h> using namespace std; int main() { string s; cin >> s; int sl = s.length(); pair<int, int> a[26] = {}; for (int i = 0; i < 26; i++) a[i].second = i + a ; for (int i = 0; i < sl; i++) a[s[i] - a ].first++; sort(a, a + 26, greater<pair<int, int> >()); string ans(sl, ? ); bool valid = false; for (int i = 1; i < sl / 2; i++) ans[i] = a[0].second, a[0].first--; for (int i = sl / 2; i < sl; i++) { int sq = sqrt(i + 1); bool ok = false; for (int j = 2; j <= sq; j++) ok |= ((i + 1) % j == 0); if (ok) ans[i] = a[0].second, a[0].first--; } if (a[0].first >= 0) { string rem = ; for (int i = 0; i < 26; i++) while (a[i].first--) rem.push_back(a[i].second); for (int i = 0, j = 0; i < sl; i++) if (ans[i] == ? ) { ans[i] = rem[j]; j++; } valid = true; } if (valid == false) cout << NO n ; else cout << YES n << ans << n ; return 0; } |
#include <bits/stdc++.h> using namespace std; using ll = long long; using ull = unsigned long long; constexpr ll MAXN = 100000 + 5; int n, m; ll bot, inc, dam; ll maxh[MAXN]; ll starth[MAXN]; ll regen[MAXN]; vector<pair<ll, ll>> up[MAXN]; unordered_map<ll, ll> mt; unordered_set<ll> tpoints; void gen(const int id) { const ll mh = maxh[id]; const ll reg = regen[id]; auto &cup = up[id]; sort(cup.begin(), cup.end()); int in = 0; ll prect = -1; ll prech = -1; int i = 0; vector<pair<ll, ll>> cal; while (i < cup.size() || cal.size()) { if (cal.size()) { ll prect = cal[0].first; ll prech = cal[0].second; cal.clear(); if (i >= cup.size() || prect < cup[i].first) { if (prech <= dam) { tpoints.insert(prect); if (reg) { prect++; prech = min(prech + reg, mh); cal.emplace_back(prect, prech); } } else { mt[prect]--; in = 0; } } continue; } auto const p = cup[i]; const ll ct = p.first; const ll ch = p.second; if (ch < dam) { if (in == 1) { } else { in = 1; mt[ct]++; tpoints.insert(ct); } if (reg) { prect = ct + (dam - ch) / reg; prech = ch + (prect - ct) * reg; cal.emplace_back(prect, prech); } } else if (ch > dam) { if (in == 1) { tpoints.insert(ct - 1); mt[ct]--; in = 0; } } else if (ch == dam) { if (in == 0) { in = 1; mt[ct]++; tpoints.insert(ct); } else { tpoints.insert(ct); } if (reg) { prect = ct + 1; prech = min(mh, prech + reg); cal.emplace_back(prect, prech); } } i++; } } int main() { ios::sync_with_stdio(false); int inf = 0; cin >> n >> m; cin >> bot >> inc >> dam; ll base = 0; for (int i = 1; i <= n; ++i) { cin >> maxh[i] >> starth[i] >> regen[i]; if (maxh[i] <= dam) { if (inc > 0) { inf = 1; } else base++; } up[i].emplace_back(0, starth[i]); } for (int i = 0; i < m; ++i) { int t, id, h; cin >> t >> id >> h; up[id].emplace_back(t, h); } if (inf) { cout << -1; return 0; } for (int i = 1; i <= n; ++i) { if (maxh[i] > dam) gen(i); } for (auto const &p : mt) { tpoints.insert(p.first); } ll ret = 0; vector<pair<ll, ll>> vm(mt.begin(), mt.end()); sort(vm.begin(), vm.end()); auto mit = vm.begin(); vector<ll> tt(tpoints.begin(), tpoints.end()); sort(tt.begin(), tt.end()); for (auto t : tt) { while (mit != vm.end() && mit->first <= t) { base += mit->second; ++mit; } ret = max(ret, base * (bot + inc * t)); } ret = max(ret, base * (bot)); if (base > 0 && inc > 0) { inf = 1; } if (inf) { cout << -1; return 0; } cout << ret; } |
#include <bits/stdc++.h> using namespace std; const int N = 2000005; const int P = 998244353; long long n; long long f[N], g[N]; long long a[N]; long long inv_9, inv_6, inv_1; long long ans; long long exp_3[N]; long long fac[N], c_n[N]; inline long long ksm(long long base, long long x) { long long res = 1; while (x) { if (x & 1) res *= base, res %= P; base *= base, base %= P; x >>= 1; } return res; } void work() { int type; for (int i = 0; i < n; i++) { if ((n - i) % 2 == 0) type = 1; else type = P - 1; ans += ((c_n[i]) * (((type) * ((P + ksm((exp_3[i] - 1 + P) % P, n) - ksm(exp_3[i], n)) % P) % P)) % P), ans %= P; } ans *= 3, ans %= P; ans = P - ans, ans %= P; for (int i = 1; i <= n; i++) { if (i & 1) type = 1; else type = P - 1; ans += ((2) * (((type) * (((c_n[i]) * (ksm(3, n * n - i * (n - 1))) % P)) % P)) % P), ans %= P; } } void init() { scanf( %lld , &n); a[2 * n] = ksm(3, 2 * n); a[n] = ((P - 2) * ksm(3, n)) % P; a[0] = 1; exp_3[0] = 1; for (int i = 1; i <= n; i++) exp_3[i] = ((3) * (exp_3[i - 1]) % P); fac[0] = 1; for (int i = 1; i <= n; i++) fac[i] = ((i) * (fac[i - 1]) % P); for (int i = 0; i <= n; i++) c_n[i] = ((fac[n]) * (((ksm(fac[i], P - 2)) * (ksm(fac[n - i], P - 2)) % P)) % P); work(); printf( %lld n , ans); } int main(int argc, char** argv) { init(); return 0; } |
#include <bits/stdc++.h> using namespace std; int n, u, d, l, r, i, h[10005]; string a; int main() { cin >> n >> a; for (i = 0; i < n; i++) { if (a[i] == 0 ) d = r = l = 1; if (a[i] == 1 || a[i] == 2 || a[i] == 3 ) u = 1; if (a[i] == 1 || a[i] == 4 || a[i] == 7 ) l = 1; if (a[i] == 3 || a[i] == 6 || a[i] == 9 ) r = 1; if (a[i] == 7 || a[i] == 9 ) d = 1; } if (u == 1 && d == 1 && r == 1 && l == 1) cout << YES ; else cout << NO ; return 0; } |
#include <bits/stdc++.h> using namespace std; const int N = 200005; int k; int arr[N]; vector<int> v[N]; vector<int> gap[N]; int solve(int l, int r, int c) { int m = (l + r) >> 1; if (l == r) return v[c][l]; if (l >= r) return 0; if (r == l + 1) { if (gap[c][l] <= k) return v[c][l] + v[c][r]; else return 0; } int lt = m; int rt = m; int cost = 0; int ans = v[c][m]; int maxi = max(solve(l, m, c), solve(m, r, c)); while (cost + gap[c][rt] <= k) { cost += gap[c][rt]; ans += v[c][rt + 1]; rt++; if (rt >= r) break; } maxi = max(ans, maxi); while (rt >= m) { if (lt == l) break; while (cost + gap[c][lt - 1] <= k) { cost += gap[c][lt - 1]; ans += v[c][lt - 1]; lt--; if (lt == l) break; } if (maxi < ans) maxi = ans; if (rt < l + 1) break; ans -= v[c][rt]; cost -= gap[c][--rt]; } return maxi; } signed main() { int n, m; cin >> n >> m >> k; int count[n + 5]; count[n] = -1; count[n + 1] = -1; for (int i = 0; i < n; i++) { cin >> arr[i]; count[i] = -1; } int ct = 1; arr[n] = n + 2; count[arr[0]] = 0; for (int i = 1; i < n + 1; i++) { if (arr[i] == arr[i - 1]) ct++; if (arr[i] != arr[i - 1]) { v[arr[i - 1]].push_back(ct); if (count[arr[i]] != -1) { gap[arr[i]].push_back(i - count[arr[i]] - 1); } count[arr[i - 1]] = i - 1; ct = 1; } } int maxi = -1; for (int i = 1; i <= m; i++) { maxi = max(solve(0, v[i].size() - 1, i), maxi); } cout << maxi << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { long int n, k, t; cin >> n >> k >> t; if (t < k) cout << t << endl; else if (t > n) cout << k - (t - n) << endl; else cout << k << endl; } |
#include <bits/stdc++.h> using namespace std; const long long INF = 1e17; struct edge { int u, v; edge() {} edge(int _u, int _v) : u(_u), v(_v) {} }; struct node { vector<edge> edges; }; struct tree { vector<node> nodes; int root, n; tree(int _n, int _r = 0) : n(_n), root(_r) { nodes.resize(n); } void add_edge(int u, int v) { edge e1(u, v); edge e2(v, u); nodes[u].edges.push_back(e1); nodes[v].edges.push_back(e2); } vector<pair<int, int>> findDiametersAndCenters() { vector<pair<int, int>> ans; vector<bool> vis1(n, 0), vis2(n, 0); vector<int> parent(n, 0); for (int i = 0; i < n; i++) { if (vis1[i]) { continue; } int diameter, d1, d2; findDiameter(i, vis1, vis2, parent, diameter, d1, d2); int c = findCenter(d2, diameter, parent); ans.push_back({diameter, c}); } return move(ans); } pair<int, int> bfs(int u, vector<bool> &visited, vector<int> &parent) { queue<pair<int, int>> Q; visited[u] = true; int dist = 0; Q.push({u, 0}); while (!Q.empty()) { u = Q.front().first; dist = Q.front().second; Q.pop(); for (auto &e : nodes[u].edges) { if (visited[e.v]) { continue; } visited[e.v] = true; Q.push({e.v, dist + 1}); parent[e.v] = u; } } return {u, dist}; } void findDiameter(int u, vector<bool> &vis1, vector<bool> &vis2, vector<int> &parent, int &diameter, int &d1, int &d2) { d1 = bfs(u, vis1, parent).first; auto p = bfs(d1, vis2, parent); d2 = p.first; diameter = p.second; } int findCenter(int u, int diameter, vector<int> &parent) { diameter >>= 1; while (diameter--) { u = parent[u]; } return u; } }; int main() { ios::sync_with_stdio(0); cin.tie(0), cout.tie(0); int n, m; cin >> n >> m; tree t(n); for (int i = 0; i < m; i++) { int u, v; cin >> u >> v; u--; v--; t.add_edge(u, v); } vector<pair<int, int>> DnC = t.findDiametersAndCenters(); sort(DnC.rbegin(), DnC.rend()); int res = DnC[0].first; if (DnC.size() >= 2) { res = max(res, (DnC[0].first + 1) / 2 + (DnC[1].first + 1) / 2 + 1); } if (DnC.size() >= 3) { res = max(res, (DnC[1].first + 1) / 2 + (DnC[2].first + 1) / 2 + 2); } cout << res << n ; for (int i = 1; i < DnC.size(); i++) { cout << DnC[i].second + 1 << << DnC[0].second + 1 << n ; } } |
#include <bits/stdc++.h> using namespace std; const int N = 3e4 + 100, M = 210; int gi() { int w = 0; bool q = 1; char c = getchar(); while ((c < 0 || c > 9 ) && c != - ) c = getchar(); if (c == - ) q = 0, c = getchar(); while (c >= 0 && c <= 9 ) w = w * 10 + c - 0 , c = getchar(); return q ? w : -w; } void go() { puts( -1 ); exit(0); } int d[M][N], id[N]; int p[M][N], pre[N]; bool in[N]; int C; int fa[N]; vector<int> e[N]; inline int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); } vector<pair<int, int> > sub[N]; inline void link(int a, int b) { if (find(a) == find(b)) go(); fa[find(a)] = find(b); e[a].push_back(b); e[b].push_back(a); } inline void dfs(int k, int D, int fa) { if (D != d[C][k]) go(); for (int t : e[k]) if (t != fa) dfs(t, D + 1, k); } int main() { int n = gi(), m = gi(), i, j, k, last, ld, t, mx, to; for (i = 1; i <= n; i++) fa[i] = i; for (i = 1; i <= m; i++) { for (j = 1; j <= n; j++) if (!(d[i][j] = gi())) id[i] = j; if (!id[i]) go(); } p[1][0] = id[1]; in[id[1]] = true; for (k = 2; k <= m; k++) { for (i = 1; i <= n; i++) if (d[1][i] + d[k][i] == d[1][id[k]]) p[k][d[1][i]] = i, in[i] = true; for (i = d[1][id[k]]; i; i--) { if (!p[k][i]) go(); pre[p[k][i]] = p[k][i - 1]; } } for (k = 1; k <= n; k++) if (!in[k]) { mx = -1; for (i = 1; i <= m; i++) { t = (d[1][id[i]] + d[1][k] - d[i][k]) / 2; if (t > mx) mx = t, to = p[i][t]; } sub[to].push_back(make_pair(d[1][k], k)); } for (k = 1; k <= n; k++) { sort(sub[k].begin(), sub[k].end()); for (i = 0, last = k, ld = d[1][k]; i < sub[k].size(); i++) { if (i && sub[k][i].first != sub[k][i - 1].first) ld = d[1][last = sub[k][i - 1].second]; if (sub[k][i].first != ld + 1) go(); pre[sub[k][i].second] = last; } } for (i = 1; i <= n; i++) if (pre[i]) link(pre[i], i); else if (i != id[1]) go(); for (i = 1; i <= n; i++) if (pre[i]) printf( %d %d n , pre[i], i); return 0; } |
#include <bits/stdc++.h> using namespace std; int a[1001]; int main() { int n; scanf( %d , &n); int m = n; int pos = 0; int k = 1; while (true) { if (a[pos] == 0) m--; if (m == 0) { printf( YES n ); return 0; } a[pos] = 1; if (pos == (pos + k) % n) { printf( NO n ); return 0; } pos = (pos + k) % n; k++; } return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; if (n == 1) cout << 1 << << 1 << n << 1; else cout << 2 * (n - 1) << << 2 << n << 1 << << 2; return 0; } |
#include <bits/stdc++.h> using namespace std; const long long maxn = 200010; const long long MOD = 1e9 + 7; const long long INF = 1e9; const long long LINF = 1e18; long long n, m, a[maxn], b[maxn]; map<long long, long long> M, N; string s, ss; set<long long> S; long long l, r, h; int32_t main() { ios_base::sync_with_stdio(false); cin.tie(0); cin >> n; for (long long i = 0; i < n; i++) cin >> a[i]; sort(a, a + n); long long ans = 0; for (long long i = 0; i < n; i++) ans += ((a[i] % 10007) * (a[n - i - 1] % 10007)) % 10007, ans %= 10007; cout << ans; } |
#include <bits/stdc++.h> using namespace std; char buffer[1000005]; char str[1000005]; vector<vector<int>> loop; int n; int op(int k, int d) { int t = -1; strcpy(buffer, str); loop.clear(); vector<int> nxt(k); vector<int> pre(k + 1); vector<int> vis(k + 1); vector<int> lpi(k + 1); vector<int> lpj(k + 1); for (int i = 0; i < d; ++i) for (int j = 0;; ++j) { if (j * d + i >= k) break; pre[t + 1] = j * d + i; nxt[j * d + i] = t++; } pre[k] = -1; for (int i = 0; i < k; ++i) if (!vis[i]) { vector<int> temp; loop.push_back(temp); int tp = loop.size() - 1; int p = i; while (p <= k && !vis[p]) { vis[p] = 1; lpi[p] = tp; lpj[p] = loop[tp].size(); loop[tp].push_back(p - 1); p = pre[p] + 1; } } for (int i = 0; i < n; ++i) { if (i < k - 1) { if (lpi[i + 1] == 0) { t = min(lpj[i + 1], n - k + 1); str[loop[0][lpj[i + 1] - t] + t] = buffer[i]; } else { t = n - k + 1; t = lpj[i + 1] - t; int sz = loop[lpi[i + 1]].size(); t %= sz; t += sz; t %= sz; str[loop[lpi[i + 1]][t] + n - k + 1] = buffer[i]; } } else { t = min(n - k + 1 - (i - k + 1), lpj[k]); str[loop[0][lpj[k] - t] + t + (i - k + 1)] = buffer[i]; } } str[n] = 0; return 0; } int main() { scanf( %s , str); n = strlen(str); int m; cin >> m; int k, d; for (int i = 0; i < m; ++i) { scanf( %d%d , &k, &d); op(k, d); printf(str); putchar( n ); } return 0; } |
#include <bits/stdc++.h> using namespace std; long long n, T, a, b, c; int x[4], y[4]; long long cost[4]; string ans; long long f(long long x, long long y) { return (x + y) * (abs(y - x) + 1) / 2; } long long Cal(int X, int Y, int x, int y) { if (X <= x && Y <= y) return f(0, x + y - X - Y) + f(0, n + n - x - y); if (X >= x && Y >= y) return f(X + Y - x - y, n + n - x - y); if (X <= x && Y >= y) return f(x + Y - X - y, Y - y + 1) + f(Y - y, n + n - x - y); return f(X + y - x - Y, X - x + 1) + f(X - x, n + n - x - y); } long long rm[4]; bool ok(int X, int Y) { for (int i = 0; i < 4; ++i) if ((rm[i] = T - cost[i] - Cal(X, Y, x[i], y[i])) < 0) return false; if (X < a + c && Y < b + c) return ((rm[1] >> 1) + (rm[2] >> 1)) >= (long long)(a + c - max((int)a, X)) * (b + c - max((int)b, Y)); return true; } int main() { cin >> n >> T >> a >> b >> c; --c; x[1] = x[0] = a, y[2] = y[0] = b; x[2] = x[3] = a + c, y[1] = y[3] = b + c; int X = 1, Y = 1; for (int i = 0; i < 4; ++i) if (Cal(X, Y, x[i], y[i]) - abs(x[i] - X) - abs(y[i] - Y) > T) return puts( Impossible ), 0; while (X != n || Y != n) { if (X < n && ok(X + 1, Y)) ++X, ans += R ; else ++Y, ans += U ; for (int i = 0; i < 4; ++i) cost[i] += abs(x[i] - X) + abs(y[i] - Y); } cout << ans << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int n, m; cin >> n >> m; int s, f, t; for (int i = 0; i < n; i++) { cin >> s >> f >> t; int flag = t / (m - 1); int yushu = t % (m - 1); int floor; if (flag & 1) { floor = m - yushu; } else floor = 1 + yushu; int totaltime = 0; if (s > floor) { if (flag % 2 == 0) totaltime = s - floor; else totaltime = floor - 1 + s - 1, flag = 0; floor = s; } else if (s < floor) { if (flag % 2 == 0) { totaltime = (m - floor) + (m - s); flag = 1; } else totaltime = floor - s; floor = s; } if (s == f) { totaltime = t; } else { if (floor > f) { if (flag % 2 == 0) { totaltime += (m - floor + m - f); } else totaltime += floor - f; } else if (floor < f) { if (flag % 2 == 0) totaltime += f - floor; else totaltime += floor - 1 + f - 1; } totaltime += t; } cout << totaltime << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; const int MAX = 1e5 + 25; long long a[MAX]; int main() { ios_base::sync_with_stdio(false); long long n, k, h; cin >> n >> h >> k; for (int i = 0; i < n; i++) cin >> a[i]; long long ans = 0; long long in = a[0]; for (int i = 1; i < n; i++) { if (in + a[i] <= h) { in += a[i]; } else { double x = (a[i] + in - h) * 1.0 / k; long long x1 = floor(x); long long x2 = ceil(x); long long t1 = in, t2 = in; t1 -= x1 * k; if (t1 < 0) t1 = 0; if (t1 + a[i] <= h) { in -= x1 * k; if (in < 0) in = 0; in += a[i]; ans += x1; continue; } t2 -= x2 * k; if (t2 < 0) t2 = 0; if (t2 + a[i] <= h) { in -= x2 * k; if (in < 0) in = 0; in += a[i]; ans += x2; } } } if (in > 0) { long long t1 = in / k; long long t2 = in % k; ans += t1; if (t2) ans++; } cout << ans; } |
#include <bits/stdc++.h> using namespace std; int main() { std::ios::sync_with_stdio(false); std::cin.tie(0); long long n; cin >> n; vector<int> v(n); for (int i = (0); i < (n); ++i) cin >> v[i]; sort(v.begin(), v.end()); vector<int> res = {v[0]}; for (int i = (0); i < (n); ++i) for (int j = (0); j < (31); ++j) { int lx = v[i] - (1 << j); int rx = v[i] + (1 << j); bool isl = binary_search(v.begin(), v.end(), lx); bool isr = binary_search(v.begin(), v.end(), rx); if (isl && isr && int(res.size()) < 3) { res = {lx, v[i], rx}; } if (isl && int((int)res.size()) < 2) { res = {lx, v[i]}; } } cout << (int)res.size() << endl; for (auto it : res) cout << it << ; } |
#include <bits/stdc++.h> using namespace std; const int MAXN = 0; const int MOD = 1000000007; template <class T> inline void CLR(T &g) { T t; swap(t, g); } template <class T> inline void CLR(T &g, int a) { memset(g, a, sizeof g); } template <class T> inline void CPY(T &a, T &b) { memcpy(a, b, sizeof a); } template <class T> inline bool inr(T a, T b, T c) { return (a >= b && a <= c); } inline int acc(int a, int b) { return !!(a & (1 << b - 1)); } inline int fil(int a, int b, int c) { return a & ~(1 << b - 1) | (c ? (1 << b - 1) : 0); } int N, M, K, Q; int a, b, c, l; long long calc1(int p, int x1, int x2, int y1, int y2) { int dx = x2 - x1 + 1, dy = y2 - y1 + 1; if (dx <= dy) { if (p - x1 < y1) return 0; else if (p - x2 < y1) return (1ll * (p - x1 - y1 + 1 + 1) * (p - x1 - y1 + 1) / 2); else if (p - x1 < y2) return (1ll * (p - x1 - y1 + 1 + 1) * (p - x1 - y1 + 1) / 2) - (1ll * (p - x2 - y1 + 1) * (p - x2 - y1) / 2); else if (p - x2 <= y2) return (1ll * (p - x1 - y1 + 1 + 1) * (p - x1 - y1 + 1) / 2) - (1ll * (p - x2 - y1 + 1) * (p - x2 - y1) / 2) - (1ll * (p - x1 - y2 + 1) * (p - x1 - y2) / 2); else return 1ll * (x2 - x1 + 1) * (y2 - y1 + 1); } else return calc1(p, y1, y2, x1, x2); } long long calc(int p, int x1, int x2, int y1, int y2) { if (l + a + b + c - p <= p) return 0; if (x1 > x2 || y1 > y2) return 0; return -calc1(p, x1, x2, y1, y2) + calc1(l + a + b + c - p, x1, x2, y1, y2); } int main() { int T, o = 0; scanf( %d%d%d%d , &a, &b, &c, &l); long long sum = 0; for (register int(i) = a, _end_ = (a + l); (i) <= _end_; ++(i)) sum += calc(i, b, i, c, i); for (register int(i) = b, _end_ = (b + l); (i) <= _end_; ++(i)) sum += calc(i, a, i - 1, c, i); for (register int(i) = c, _end_ = (c + l); (i) <= _end_; ++(i)) sum += calc(i, a, i - 1, b, i - 1); cout << sum << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; const int MAXN = 4e5 + 5; const int MAXQ = 5e5 + 5; const int MAXP = 8e6 + 5; template <typename T> void chkmax(T &x, T y) { x = max(x, y); } template <typename T> void chkmin(T &x, T y) { x = min(x, y); } template <typename T> void read(T &x) { x = 0; int f = 1; char c = getchar(); for (; !isdigit(c); c = getchar()) if (c == - ) f = -f; for (; isdigit(c); c = getchar()) x = x * 10 + c - 0 ; x *= f; } template <typename T> void write(T x) { if (x < 0) x = -x, putchar( - ); if (x > 9) write(x / 10); putchar(x % 10 + 0 ); } template <typename T> void writeln(T x) { write(x); puts( ); } struct SegmentTreeMerging { struct Node { int lc, rc, sum; bool leaf; } a[MAXP]; int size, n; void init(int x) { n = x; size = 0; } void update(int root) { a[root].sum = a[a[root].lc].sum + a[a[root].rc].sum; } void modify(int &root, int l, int r, int pos, int d) { if (root == 0) root = ++size; if (l == r) { a[root].sum += d; a[root].leaf = true; return; } int mid = (l + r) / 2; if (mid >= pos) modify(a[root].lc, l, mid, pos, d); else modify(a[root].rc, mid + 1, r, pos, d); update(root); } void modify(int &root, int val, int d) { modify(root, 1, n, val, d); } int merge(int x, int y) { if (x == 0 || y == 0) return x + y; if (a[x].leaf) { a[x].sum += a[y].sum; return x; } a[x].lc = merge(a[x].lc, a[y].lc); a[x].rc = merge(a[x].rc, a[y].rc); update(x); return x; } void join(int &to, int from) { to = merge(to, from); } int query(int root, int l, int r, int ql, int qr) { if (root == 0) return 0; if (l == ql && r == qr) return a[root].sum; int mid = (l + r) / 2, ans = 0; if (mid >= ql) ans += query(a[root].lc, l, mid, ql, min(mid, qr)); if (mid + 1 <= qr) ans += query(a[root].rc, mid + 1, r, max(mid + 1, ql), qr); return ans; } int query(int root, int l, int r) { return query(root, 1, n, l, r); } } ST; struct SuffixAutomaton { struct Node { int child[26]; int father, depth; } a[MAXN]; vector<int> e[MAXN]; vector<int> home[MAXN]; vector<pair<int, int>> s[MAXN]; int n, root, size, last; int newnode(int dep) { a[++size].depth = dep; return size; } void init() { size = 0; root = last = 0; } void extend(int ch) { int p = last, np; if (a[p].child[ch]) { int q = a[p].child[ch]; if (a[p].depth + 1 == a[q].depth) np = q; else { np = newnode(a[p].depth + 1); memcpy(a[np].child, a[q].child, sizeof(a[q].child)); a[np].father = a[q].father; a[q].father = np; while (a[p].child[ch] == q) { a[p].child[ch] = np; p = a[p].father; } } } else { np = newnode(a[p].depth + 1); while (a[p].child[ch] == 0) { a[p].child[ch] = np; p = a[p].father; } if (a[p].child[ch] == np) a[np].father = root; else { int q = a[p].child[ch]; if (a[q].depth == a[p].depth + 1) a[np].father = q; else { int nq = newnode(a[p].depth + 1); memcpy(a[nq].child, a[q].child, sizeof(a[q].child)); a[nq].father = a[q].father; a[q].father = a[np].father = nq; while (a[p].child[ch] == q) { a[p].child[ch] = nq; p = a[p].father; } } } } last = np; } void insert(char *s) { last = 0, n++; int len = strlen(s + 1); for (int i = 1; i <= len; i++) { extend(s[i] - a ); home[n].push_back(last); } } int rt[MAXN], ans[MAXQ]; vector<pair<pair<int, int>, int>> q[MAXN]; void work(int pos) { for (auto x : s[pos]) ST.modify(rt[pos], x.first, x.second); for (auto x : e[pos]) { work(x); ST.join(rt[pos], rt[x]); } for (auto x : q[pos]) ans[x.second] = ST.query(rt[pos], x.first.first, x.first.second); } void solve(int m) { for (int i = 1; i <= size; i++) e[a[i].father].push_back(i); for (int i = 1; i <= n; i++) for (unsigned j = 0; j < home[i].size(); j++) s[home[i][j]].emplace_back(i, 1); work(0); for (int i = 1; i <= m; i++) writeln(ans[i]); } } SAM; char s[MAXN]; int main() { int n, m; read(n), read(m); SAM.init(), ST.init(n); for (int i = 1; i <= n; i++) { scanf( n%s , s + 1); SAM.insert(s); } for (int i = 1; i <= m; i++) { int l, r, k; read(l), read(r), read(k); SAM.q[SAM.home[k].back()].emplace_back(make_pair(l, r), i); } SAM.solve(m); return 0; } |
#include <bits/stdc++.h> using namespace std; int a[100000], d[100000]; int main() { int n, ans = 0; cin >> n; for (int i = 0; i < n; i++) scanf( %d , &a[i]); vector<int> p; for (int i = 0; i < n; i++) { if (a[i] == 1) ans = max(ans, 1); p.clear(); int x = a[i]; int k = 0; for (int j = 2; j <= sqrt(x); j++) if (x % j == 0) { p.push_back(j); k = max(k, d[j] + 1); while (x % j == 0) x /= j; } if (x > 1) { p.push_back(x); k = max(k, d[x] + 1); } ans = max(ans, k); for (int j = 0; j < p.size(); j++) d[p[j]] = max(d[p[j]], k); } cout << ans; return 0; } |
#include <bits/stdc++.h> using namespace std; const int M = 1010, mod = 1000000007; vector<vector<int> > lst[M]; vector<vector<int> > flag[M]; vector<int> sz[M]; vector<int> tmp, bmp; vector<pair<int, int> > edge; int id[M][M]; int pos[M][M]; int visited[M]; string s, t; void make_list(int u, string &a) { int i = 0, j = 0; char d[10]; tmp.clear(); a += , ; while (a[i] != : ) i++; i++; while (i < a.size()) { if (a[i] == , ) { d[j++] = 0 ; if (atoi(d) > 0) tmp.push_back(atoi(d)); j = 0; } else d[j++] = a[i]; i++; } bmp.resize(tmp.size()); for (i = 0; i < tmp.size(); i++) { int v = tmp[i]; id[v][u] = lst[u].size(); pos[v][u] = i; } lst[u].push_back(tmp); flag[u].push_back(bmp); sz[u].push_back(tmp.size()); } void dec(int u, int v) { for (int i = 0; i < lst[u].size(); i++) { for (int j = 0; j < lst[u][i].size(); j++) { if (lst[u][i][j] == v) { sz[u][i]--; flag[u][i][j] = 1; return; } } } } bool isinsane(int u) { int i, j, k, cnt = 0; for (i = 0; i < lst[u].size(); i++) cnt += (sz[u][i] > 0); return cnt != 1; } pair<int, int> find_leaf(int n) { int i, j, k; vector<int> r; for (i = 1; i <= n; i++) r.push_back(i); random_shuffle((r).begin(), (r).end()); for (int first = 0; first < r.size(); first++) { i = r[first]; if (visited[i]) continue; for (j = 0; j < lst[i].size(); j++) { if (sz[i][j] == 1) { for (k = 0; k < flag[i][j].size(); k++) { if (flag[i][j][k] == 0) return make_pair(i, lst[i][j][k]); } } } } return make_pair(-1, -1); } int main() { ios_base::sync_with_stdio(false); int n, i, j, k; srand(time(NULL)); memset((id), (-1), sizeof(id)); cin >> n; for (j = 1; j <= n; j++) { cin >> s; s += - ; for (i = 0; i < s.size(); i++) { if (s[i] == - ) { make_list(j, t); t.clear(); } else t += s[i]; } } while (true) { pair<int, int> g = find_leaf(n); if (g.first == -1) break; edge.push_back(g); int u = g.second, v = g.first; visited[u] = 1; if (isinsane(u)) { printf( %d n , -1); return 0; } for (i = 1; i <= n; i++) { if (visited[i]) continue; int l = id[u][i], r = id[v][i], p = pos[u][i]; if (l == -1) continue; if (i != v && l != r) { printf( %d n , -1); return 0; } flag[i][l][p] = 1; sz[i][l]--; } dec(u, g.first); } if (edge.size() != n - 1) printf( %d n , -1); else { printf( %d n , edge.size()); for (pair<int, int> e : edge) printf( %d %d n , e.first, e.second); } return 0; } |
#include <bits/stdc++.h> using namespace std; inline void checkMAX(int& a, int b) { if (a < b) a = b; } inline void checkMIN(int& a, int b) { if (a > b) a = b; } int main() { char s[333] = {}; cin >> s; int mn = 0, mx = 0, curr = 0; for (int i = 0; s[i]; i++) { if (s[i] == + ) curr++; else curr--; checkMIN(mn, curr); checkMAX(mx, curr); } cout << (mx - mn) << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { char str[25]; gets(str); int let[26]; for (int i = 0; i < 26; i++) { let[i] = 0; } int len = 0; for (int i = 0; str[i]; i++) { let[str[i] - a ]++; len++; } long long c = 0; for (int i = 0; i < 26; i++) { c = c + (len + 1) - let[i]; } cout << c << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int n, cnt = 0; cin >> n; for (int i = 1; i <= n; i++) { int ans = (i * (i + 1)) / 2; if (ans == n) { cnt = 1; break; } } if (cnt == 1) cout << YES << endl; else cout << NO << endl; } |
#include <bits/stdc++.h> #define For(i, a, b) for(int i = a; i <= b; i++) #define Ford(i, a, b) for(int i = a; i >= b; i--) #define make_pair(a,b) mp(a, b) using namespace std; const int N= 2e5 + 1067, K = 17, md=1e9 + 7; int n, k; int f[N][30], g[1 << K], dem[30]; string s; bool check(int x) { int en = n - 1; for(char j = a ; j < a + k; j++) f[n][j] = f[n + 1][j] = n, dem[j] = 0; Ford(i, n - 1, 0) { for(char j = a ; j < a + k; j++) f[i][j] = f[i + 1][j]; ++dem[s[i]]; if (en >= i + x) { --dem[s[en]]; en -= 1; } char c = - ; int diversity = 0; for(char j = a ; j < a + k; j++) { if (dem[j]) { diversity += 1; c = j; } } if (diversity == 0) { for(char j = a ; j < a + k; j++) f[i][j] = i + x - 1; } else if (diversity == 1) { f[i][c] = i + x - 1; } } For(mask, 0, (1 << k) - 1) g[mask] = n; g[0] = -1; For(mask, 0, (1 << k) - 1) { For(i, 0, k - 1) if (!(mask & (1 << i))) { g[mask ^ (1 << i)] = min(g[mask ^ (1 << i)], f[g[mask] + 1][(char)( a + i)]); } } return g[(1 << k) - 1] < n; } int bs(int l, int r) { while (l < r) { if (l == r - 1) { if (check(r)) return r; else return l; } int mid = (l + r) / 2; if (check(mid)) l = mid; else r = mid - 1; } return l; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cin >> n >> k; cin >> s; cout << bs(0, n) << endl; } |
#include <bits/stdc++.h> using namespace std; int n, a[150005]; vector<int> v; set<pair<int, int> > ans; int compute() { int problem = 0; for (int i = 1; i <= n; i = i + 2) { if (a[i] >= a[i + 1]) { problem++; } } for (int i = 2; i <= n; i = i + 2) { if (a[i] <= a[i + 1]) { problem++; } } return problem; } vector<int> findproblems() { vector<int> q; for (int i = 1; i <= n; i = i + 2) { if (a[i] >= a[i + 1]) { q.push_back(i); if (i >= 1 && i <= n) { q.push_back(i + 1); } } } for (int i = 2; i <= n; i = i + 2) { if (a[i] <= a[i + 1]) { q.push_back(i); if (i >= 1 && i <= n) { q.push_back(i + 1); } } } sort(q.begin(), q.end()); return q; } void swap(int i, int j) { int tempa = a[i]; a[i] = a[j]; a[j] = tempa; } int check(int e) { if (e % 2 == 0) { if (a[e] > a[e - 1] && a[e] > a[e + 1]) { return 0; } return 1; } if (a[e] < a[e - 1] && a[e] < a[e + 1]) { return 0; } return 1; } int threeandfour(int i, int j, vector<int> q) { swap(i, j); int flag = 0; for (int i = 0; i < q.size(); i++) { flag += check(q[i]); } flag += check(i); flag += check(j); swap(i, j); return flag; } int main() { scanf( %d , &n); for (int i = 1; i <= n; i++) { scanf( %d , &a[i]); } a[0] = 150005; if (n % 2 == 0) { a[n + 1] = -10; } else { a[n + 1] = 150005; } int problem = compute(); if (problem > 4) { cout << 0 << endl; } else { v = findproblems(); for (int i = 0; i < v.size(); i++) { for (int j = 1; j <= n; j++) { if (threeandfour(v[i], j, v) == 0) { ans.insert(make_pair(v[i], j)); ans.insert(make_pair(j, v[i])); } } } cout << ans.size() / 2 << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; bool comp(pair<int, int> a, pair<int, int> b) { if (a.second < b.second) return true; return false; } bool com(pair<int, int> a, pair<int, int> b) { return a.first > b.first; } signed main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); ; long long n, k; cin >> n >> k; vector<long long> ar(n); vector<pair<long long, long long> > br(n); for (long long i = 0; i < n; ++i) cin >> ar[i], br[i] = {ar[i], i}; sort(br.begin(), br.end(), com); br.resize(k); sort(br.begin(), br.end(), comp); long long mx = br[0].first, sec = 1; for (long long i = 1; i < br.size(); ++i) { mx += br[i].first; sec = (sec * (br[i].second - br[i - 1].second)) % 998244353; } cout << mx << << sec; return 0; } |
#include <bits/stdc++.h> using namespace std; const int N = 5e5 + 10; long long n, ans, f[N], now, sum; char s[N]; signed main() { scanf( %lld , &n); scanf( %s , s + 1); for (long long i = 1; i <= n; i++) f[i] = n + 1; for (long long i = n; i >= 1; i--) { if (s[i] - 0 ) sum += f[++now] - i; else { while (now) f[now] = now + i, now--; } ans += sum; } printf( %lld n , ans); return 0; } |
#include <bits/stdc++.h> using namespace std; const int N = 3e5 + 5; int t; struct node { char id; int num; } ans[N]; string a; int cot; int main() { cin >> a; if (a.length() == 1) { cout << 0 << endl; return 0; } cot = 1; ans[cot].id = a[0]; ans[cot].num = 1; for (register int i = 0; i <= a.length() - 2; ++i) { if (a[i + 1] == a[i]) ans[cot].num++; else { ans[++cot].id = a[i + 1]; ans[cot].num = 1; } } if (cot % 2 == 0 || ans[cot / 2 + 1].num < 2) { cout << 0 << endl; return 0; } int now = 1; int fg = 0; while (now != cot / 2 + 1) { if (ans[now].id != ans[cot - now + 1].id || ans[now].num + ans[cot - now + 1].num < 3) { fg = 1; break; } now++; } if (!fg) cout << ans[cot / 2 + 1].num + 1 << endl; else cout << 0 << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; const long long mod = 1e9 + 7; long long dx[] = {-1, 0, 1, 0}; long long dy[] = {0, -1, 0, 1}; vector<long long> v(10); string s; set<string> st; void call(string s, long long pos) { if (pos == 10) { sort(s.begin(), s.end()); st.insert(s); return; } if (v[pos] == 0) { call(s, pos + 1); return; } for (long long i = 1; i <= v[pos]; i++) { char c = 0 + pos; string x = string(i, c); call(s + x, pos + 1); } } int32_t main() { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); vector<long long> f(20); f[0] = f[1] = 1; for (long long i = 2; i < 20; i++) { f[i] = f[i - 1] * i; } cin >> s; for (long long i = 0; i < s.size(); i++) v[s[i] - 0 ]++; string x = ; call(x, 0); long long ans = 0; for (auto i : st) { string &x = i; vector<long long> cnt(10); for (long long i = 0; i < x.size(); i++) { cnt[x[i] - 0 ]++; } long long val = f[x.size()]; for (long long i = 0; i < 10; i++) { val = val / f[cnt[i]]; } ans += val; if (v[0] > 0) { long long val1 = f[x.size() - 1]; cnt[0]--; for (long long i = 0; i < 10; i++) val1 = val1 / f[cnt[i]]; ans -= val1; } } cout << ans << n ; } |
#include <bits/stdc++.h> int n; int a[1001000]; int b[1001000]; int c[1001000]; int ans; int main() { int i, j; scanf( %d , &n); n++; for (i = 2; i <= n; i++) { scanf( %d , &a[i]); b[i] = 1; c[i] = 0; j = i; if (ans < b[j]) ans = b[j]; while (a[j] != 1) { if (ans < b[j]) ans = b[j]; if (ans < b[a[j]]) ans = b[a[j]]; if (b[a[j]] < b[j]) { b[a[j]] = b[j]; c[a[j]] = 1; } else if (c[a[j]] == 1 && b[a[j]] == b[j]) { b[a[j]] = b[j] + 1; c[a[j]] = 0; } else if (c[a[j]] == 0 && b[a[j]] == b[j]) { c[a[j]] = 1; break; } else break; if (ans < b[a[j]]) ans = b[a[j]]; j = a[j]; } printf( %d , ans); } } |
#include <bits/stdc++.h> using namespace std; bool sortbysec(pair<int, string> a, pair<int, string> b) { if (a.first != b.first) return a.first > b.first; else return a.second < b.second; } int binarySearch(vector<int> a, int n, int key) { int low = 0; int high = n, mid; while (low <= high) { mid = (low + high) / 2; if (a[mid] <= key) { low = mid + 1; } else if (a[mid] > key) { high = mid - 1; } } if (high - low == 1) { if (a[low] >= key) return low; else return high; } else return mid; } vector<int> SieveOfEratosthenes(int n) { vector<int> prime(n + 1, 1); for (int p = 2; p * p <= n; p++) { if (prime[p] == 1) { for (int i = p * p; i <= n; i += p) prime[i] = 0; } } return prime; } vector<pair<long long, long long>> v; void primeFactors(long long n) { v.clear(); long long k = 0; while (n % 2 == 0) { k++; n = n / 2; } if (k != 0) v.push_back({2, k}); for (long long i = 3; i <= sqrt(n); i = i + 2) { k = 0; while (n % i == 0) { k++; n = n / i; } if (k != 0) v.push_back({i, k}); } if (n > 2) v.push_back({n, 1}); } signed main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); int t = 1; while (t--) { long long n; cin >> n; long long ans = n; long long a[n]; for (int i = 0; i < n; i++) { cin >> a[i]; ans += (i + 1) * (a[i] - 1); } cout << ans; } } |
#include <bits/stdc++.h> using namespace std; int main() { int n, a; cin >> n >> a; if (a % 2 != 0) { cout << (((a - 1) / 2) + 1) << n ; } else { cout << ((n / 2) - ((a - 2) / 2)) << n ; } } |
#include <bits/stdc++.h> using namespace std; long long n, m, x, _, a, d, t[100001], ans; long long rua(long long l, long long r) { if (r < l) return _; if (_ >= n * a) { ans++; return r + d; } if (l % a && l / a == r / a) { ans++; return r + d; } long long f = min((l - 1) / a + 1, n); long long la = min(r / a, n); long long k = (la - f) / x + 1; ans += k; f += (k - 1) * x; f *= a; if (f + d >= r) { return f + d; } ans++; return r + d; } int main() { scanf( %I64d%I64d%I64d%I64d , &n, &m, &a, &d), x = d / a + 1; for (long long i = 1; i <= m; i++) scanf( %I64d , &t[i]), _ = rua(_ + 1, t[i]); rua(_ + 1, n * a); printf( %I64d n , ans); return 0; } |
#include <bits/stdc++.h> using namespace std; int n, m, a[100001], q, sum; int b[1000001]; int main() { int n, m, q, sum = 0; cin >> n; for (int i = 1; i <= n; i++) { cin >> a[i]; b[a[i] + sum] = i; b[1 + sum] = i; sum += a[i]; } cin >> m; for (int j = 1; j <= m; j++) { cin >> q; if (b[q]) { cout << b[q] << endl; continue; } for (int k = 1; k <= 1000; k++) { if (b[q + k]) { cout << b[q + k] << endl; break; } if (b[q - k]) { cout << b[q - k] << endl; break; } } } return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int n; long long int sum = 0; cin >> n; int a, b; int max = INT_MIN; for (int i = 0; i < n; i++) { cin >> a >> b; sum = sum - a + b; if (max < sum) max = sum; } cout << max; return 0; } |
#include <bits/stdc++.h> #pragma GCC optimize( Ofast ) #pragma GCC target( avx,avx2,fma ) #pragma GCC optimization( unroll-loops ) const int mod = 1e9 + 7; using namespace std; template <class T> void cinn(T& x) { cin >> x; } template <class H, class... T> void cinn(H& h, T&... t) { cinn(h); cinn(t...); } template <class A> void cinn(vector<A>& x) { for (auto& a : x) cinn(a); } void Shazam() { long long n, k; cinn(n, k); vector<long long> a(n); cinn(a); long long ans = 0; for (long long i = k; i < 101; i++) { long long cnt = 0; for (long long j = 0; j < n; j++) { cnt += (a[j] / i); } ans = max(ans, cnt * i); } cout << ans << n ; } int main() { ios::sync_with_stdio(0); cin.tie(0); long long t = 1; while (t--) Shazam(); return 0; } |
#include <bits/stdc++.h> using namespace std; int const N = 1e5 + 13; int const INF = 1e9 + 13; int n, m; set<int> p[N]; int l[N], r[N]; int pos[N], x[N]; int tsz; int a[N]; int type[N]; vector<int> t[N * 4], tright[N * 4]; vector<long long> F[N * 4]; vector<int> qid; vector<pair<int, int>> qpos[N]; vector<int> lposes; bool cmpl(int i, int j) { return l[i] < l[j]; } void merge(vector<int> &v, vector<int> &l, vector<int> &r) { int lp = 0; int rp = 0; int ln = l.size(); int rn = r.size(); while (lp < ln || rp < rn) { if (rp == rn || (lp < ln && ::r[l[lp]] < ::r[r[rp]])) { v.push_back(l[lp++]); } else { v.push_back(r[rp++]); } } } void build(int v, int tl, int tr) { if (tl == tr) { t[v].push_back(qid[tl]); F[v].assign(1, 0LL); for (int i = 0; i < t[v].size(); ++i) { qpos[t[v][i]].push_back(make_pair(v, i)); } tright[v].push_back(r[qid[tl]]); } else { int tm = (tl + tr) / 2; build(v * 2 + 1, tl, tm); build(v * 2 + 2, tm + 1, tr); merge(t[v], t[v * 2 + 1], t[v * 2 + 2]); for (int i = 0; i < t[v].size(); ++i) { qpos[t[v][i]].push_back(make_pair(v, i)); tright[v].push_back(r[t[v][i]]); } F[v].assign(t[v].size(), 0LL); } } void updF(vector<long long> &F, int x, int v) { int n = F.size(); while (x < n) { F[x] += v; x |= (x + 1); } } long long getF(vector<long long> &F, int x) { long long res = 0; while (x >= 0) { res += F[x]; x = (x & (x + 1)) - 1; } return res; } void upd(vector<long long> &F, int l, int r, int val) { if (l > r) return; updF(F, l, val); updF(F, r + 1, -val); } int getLeft(vector<int> &v, int val) { int l = -1; int r = v.size(); while (r - l > 1) { int m = (l + r) / 2; if (v[m] >= val) r = m; else l = m; } return r; } int getRight(vector<int> &v, int val) { int l = -1; int r = v.size(); while (r - l > 1) { int m = (l + r) / 2; if (v[m] <= val) l = m; else r = m; } return l; } void upd(int v, int tl, int tr, int ll, int lr, int rl, int rr, int val) { if (tl > lr || ll > tr) return; if (ll <= tl && tr <= lr) { int left = getLeft(tright[v], rl); int right = getRight(tright[v], rr); upd(F[v], left, right, val); return; } int tm = (tl + tr) / 2; upd(v * 2 + 1, tl, tm, ll, lr, rl, rr, val); upd(v * 2 + 2, tm + 1, tr, ll, lr, rl, rr, val); } long long answer(int id) { long long res = 0; for (int i = 0; i < qpos[id].size(); ++i) { res += getF(F[qpos[id][i].first], qpos[id][i].second); } return res; } void push(int pos, int val) { set<int>::iterator bef, aft; bef = p[val].lower_bound(pos); aft = p[val].upper_bound(pos); if (bef != p[val].begin()) { --bef; int lp = (*bef); int dist = pos - lp; lp = getRight(lposes, lp); int rp = (aft == p[val].end() ? INF : (*aft) - 1); upd(0, 0, tsz - 1, 0, lp, pos, rp, dist); } bef = p[val].lower_bound(pos); aft = p[val].upper_bound(pos); if (aft != p[val].end()) { int lp; if (bef != p[val].begin()) { --bef; lp = (*bef) + 1; } else { lp = 0; } lp = getLeft(lposes, lp); int rp = getRight(lposes, pos); int rpp = (*aft); int dist = rpp - pos; upd(0, 0, tsz - 1, lp, rp, rpp, INF, dist); } p[val].insert(pos); } void pop(int pos, int val) { p[val].erase(pos); set<int>::iterator bef, aft; bef = p[val].lower_bound(pos); aft = p[val].upper_bound(pos); if (bef != p[val].begin()) { --bef; int lp = (*bef); int dist = pos - lp; lp = getRight(lposes, lp); int rp = (aft == p[val].end() ? INF : (*aft) - 1); upd(0, 0, tsz - 1, 0, lp, pos, rp, -dist); } bef = p[val].lower_bound(pos); aft = p[val].upper_bound(pos); if (aft != p[val].end()) { int lp; if (bef != p[val].begin()) { --bef; lp = (*bef) + 1; } else { lp = 0; } lp = getLeft(lposes, lp); int rp = getRight(lposes, pos); int rpp = (*aft); int dist = rpp - pos; upd(0, 0, tsz - 1, lp, rp, rpp, INF, -dist); } } void solve() { cin >> n >> m; for (int i = 0; i < n; ++i) cin >> a[i]; for (int i = 0; i < m; ++i) { cin >> type[i]; if (type[i] == 1) { cin >> pos[i] >> x[i]; --pos[i]; } else { cin >> l[i] >> r[i]; --l[i]; --r[i]; qid.push_back(i); } } tsz = qid.size(); if (tsz == 0) return; sort(qid.begin(), qid.end(), cmpl); for (int i = 0; i < qid.size(); ++i) lposes.push_back(l[qid[i]]); build(0, 0, tsz - 1); for (int i = 0; i < n; ++i) push(i, a[i]); for (int i = 0; i < m; ++i) { if (type[i] == 1) { pop(pos[i], a[pos[i]]); a[pos[i]] = x[i]; push(pos[i], a[pos[i]]); } else { long long ans = answer(i); cout << ans << endl; } } } int main() { solve(); return 0; } |
#include <bits/stdc++.h> using namespace std; long long bigmod(long long p, long long e, long long M) { long long ret = 1; for (; e > 0; e >>= 1) { if (e & 1) ret = (ret * p) % M; p = (p * p) % M; } return ret; } long long extended(long long a, long long b, long long &x, long long &y) { a = abs(a); b = abs(b); long long g, x1, y1; if (!b) { x = 1; y = 0; g = a; return g; } g = extended(b, a % b, x1, y1); x = y1; y = x1 - (a / b) * y1; return g; } long long modinverse(long long a, long long M) { return bigmod(a, M - 2, M); } long long bpow(long long p, long long e) { long long ret = 1; for (; e > 0; e >>= 1) { if (e & 1) ret = (ret * p); p = (p * p); } return ret; } int toInt(string s) { int sm; stringstream ss(s); ss >> sm; return sm; } int toLlint(string s) { long long int sm; stringstream ss(s); ss >> sm; return sm; } string convertInt(long long number) { if (number == 0) return 0 ; string temp = ; string returnvalue = ; while (number > 0) { temp += number % 10 + 48; number /= 10; } for (int i = 0; i < temp.length(); i++) returnvalue += temp[temp.length() - i - 1]; return returnvalue; } long long ar[550], n, m, b, modd; long long dp[550][550]; int main() { long long n, m, b, modd; cin >> n >> m >> b >> modd; for (int i = 1; i <= n; i++) { cin >> ar[i]; } for (int i = 1; i <= n; i++) { if (ar[i] <= b) dp[1][ar[i]]++; dp[1][ar[i]] %= 1000000007; for (int j = 0; j <= b; j++) { for (int k = 1; k <= m; k++) { if (ar[i] + j > b) continue; dp[k][ar[i] + j] += dp[k - 1][j]; dp[k][ar[i] + j] %= modd; } } } long long ans = 0; for (int i = 0; i <= b; i++) { ans += dp[m][i]; ans %= modd; } cout << ans << endl; } |
#include <bits/stdc++.h> using namespace std; int main() { string a; cin >> a; int result; result = 26 + 25 * a.length(); cout << result; return 0; } |
#include <bits/stdc++.h> using namespace std; int n, pos[200001]; struct node { node *l, *r; long long int lazy, lazy2; }; node *root[200001]; int build(int s, int e, node *n) { if (s == e) { n->l = n->r = NULL; n->lazy = -1, n->lazy2 = 1; return 0; } int mid = (s + e) / 2; n->l = new node, n->r = new node; build(s, mid, n->l), build(mid + 1, e, n->r); n->lazy = n->lazy2 = 0; return 0; } pair<long long int, long long int> query(int s, int e, int q, node *n) { if (s == e) return make_pair(n->lazy, n->lazy2); int mid = (s + e) / 2; pair<long long int, long long int> p; if (q <= mid) p = query(s, mid, q, n->l); else p = query(mid + 1, e, q, n->r); return make_pair(p.first + n->lazy, p.second + n->lazy2); } int update(int s, int e, int as, int ae, node *o, node *n, int x, int t) { if ((s >= as) && (e <= ae)) { n->l = o->l, n->r = o->r; n->lazy = o->lazy + x, n->lazy2 = o->lazy2 + (long long int)x * t; return 0; } int mid = (s + e) / 2; if (ae <= mid) { n->r = o->r, n->l = new node; update(s, mid, as, ae, o->l, n->l, x, t); } else if (as > mid) { n->l = o->l, n->r = new node; update(mid + 1, e, as, ae, o->r, n->r, x, t); } else { n->l = new node, n->r = new node; update(s, mid, as, ae, o->l, n->l, x, t); update(mid + 1, e, as, ae, o->r, n->r, x, t); } n->lazy = o->lazy, n->lazy2 = o->lazy2; return 0; } int tree[1 << 19]; int build2(int s, int e, int i) { if (s == e) { tree[i] = -1; return 0; } int mid = (s + e) / 2; build2(s, mid, 2 * i + 1), build2(mid + 1, e, 2 * i + 2); tree[i] = -1; return 0; } int query2(int s, int e, int qs, int qe, int i) { if ((s > qe) || (e < qs)) return 1e9; else if ((s >= qs) && (e <= qe)) return tree[i]; int mid = (s + e) / 2; return min(query2(s, mid, qs, qe, 2 * i + 1), query2(mid + 1, e, qs, qe, 2 * i + 2)); } int update2(int s, int e, int ai, int i, int num) { if ((s > ai) || (e < ai)) return 0; else if (s == e) { tree[i] = num; return 0; } int mid = (s + e) / 2; update2(s, mid, ai, 2 * i + 1, num), update2(mid + 1, e, ai, 2 * i + 2, num); tree[i] = min(tree[2 * i + 1], tree[2 * i + 2]); return 0; } int update3(int s, int e, int as, int ae, int i, int ol, int nl, int t) { if ((s > ae) || (e < as)) return 0; else if (ol == nl) return 0; else if ((s >= as) && (e <= ae)) { if (s == e) { nl = min(nl, tree[i]), ol = min(ol, tree[i]); if (nl > ol) { node *r2 = new node; update(0, n, s, e, root[t + 1], r2, nl - ol, t); root[t + 1] = r2; } return 0; } else if (nl <= tree[i]) { node *r2 = new node; update(0, n, s, e, root[t + 1], r2, nl - ol, t); root[t + 1] = r2; return 0; } } int mid = (s + e) / 2; update3(s, mid, as, ae, 2 * i + 1, ol, nl, t); update3(mid + 1, e, as, ae, 2 * i + 2, min(ol, tree[2 * i + 1]), min(nl, tree[2 * i + 1]), t); return 0; } long long int getAns(int l, int r, int k) { if (k == -1) return (long long int)(r - l + 1) * (r - l + 2) / 2; int s = 0, e = r + 1; while (s < e) { int m = (s + e) / 2; pair<long long int, long long int> p = query(0, n, k, root[m + 1]); if (p.first < l) s = m + 1; else e = m; } if (s > r) return 0; else { pair<long long int, long long int> p = query(0, n, k, root[r + 1]); pair<long long int, long long int> p2 = query(0, n, k, root[s]); return (p.first * (r + 1) - p.second) - (p2.first * s - p2.second) - (long long int)(r - s + 1) * (l - 1); } } int main() { int i; int a, l, r, k; long long int lans = 0; scanf( %d , &n); for (i = 0; i <= n; i++) pos[i] = -1; root[0] = new node; build(0, n, root[0]), build2(0, n, 0); for (i = 0; i < n; i++) { scanf( %d %d %d %d , &a, &l, &r, &k); a = (a + lans) % (n + 1); l = (l + lans) % (i + 1); r = (r + lans) % (i + 1); if (l > r) swap(l, r); k = (k + lans) % (n + 1); int q = query2(0, n, 0, a, 0); if (q != pos[a]) pos[a] = i, update2(0, n, a, 0, i), root[i + 1] = root[i]; else { pos[a] = i, update2(0, n, a, 0, i); int q2 = query2(0, n, 0, a, 0); root[i + 1] = root[i]; update3(0, n, a, n, 0, q, q2, i); } lans = getAns(l, r, k - 1) - getAns(l, r, k); printf( %I64d n , lans); } return 0; } |
#include <bits/stdc++.h> using namespace std; class node { public: int lo, hi, value; node *left, *right; node(const int _lo, const int _hi) { left = right = NULL; lo = _lo, hi = _hi, value = 0; } void build() { if (lo == hi) return; const int mid = (lo + hi) >> 1; left = new node(lo, mid), left->build(); right = new node(mid + 1, hi), right->build(); } void update(const int idx) { if (lo > idx or hi < idx) return; if (lo == idx and hi == idx) { ++value; return; } left->update(idx); right->update(idx); value = left->value + right->value; } int query(const int _lo, const int _hi) { if (lo > _hi or hi < _lo) return 0; if (lo >= _lo and hi <= _hi) return value; int a = left->query(_lo, _hi); int b = right->query(_lo, _hi); return a + b; } int leftmost() { if (lo == hi) return lo; if (left->value) return left->leftmost(); return right->leftmost(); } int rightmost() { if (value == hi - lo + 1) return lo - 1; if (lo == hi) return lo; if (right->value < right->hi - right->lo + 1) return right->rightmost(); return left->rightmost(); } }; int main() { printf( 1 ); int n; scanf( %d , &n); node root = node(1, n); root.build(); for (int i = 0; i < n; ++i) { int x; scanf( %d , &x); root.update(x); printf( %d , root.query(root.leftmost(), root.rightmost()) + 1); } return !printf( n ); }; |
#include <bits/stdc++.h> using namespace std; int tree[(1 << 20)]; void add(int x, int val) { for (int i = x; i < (1 << 20); i = ((i) | (i + 1))) tree[i] += val; } int sum(int x) { int ans = 0; for (int i = x; i > 0; i = ((i) & (i - 1))) ans += tree[i - 1]; return ans; } int N, Q; map<int, int> idtohook; map<int, int> appearance; priority_queue<pair<int, int> > segments; map<int, int> nextL, nextR; vector<pair<int, pair<int, int> > > query; map<int, int> zip; vector<int> ans; int input(void) { int ans; scanf( %d , &ans); return ans; } void count_query(int low, int high) { query.push_back(make_pair(0, make_pair(low, high))); zip[low] = zip[high] = 0; } void enter_query(int id) { int hook = -1; while (1) { pair<int, int> p = segments.top(); segments.pop(); int L = p.second; int R = L + p.first; if (nextR[L] != R || nextL[R] != L) continue; hook = (L + R + 1) / 2; nextL[hook] = L; nextL[R] = hook; nextR[L] = hook; nextR[hook] = R; segments.push(make_pair(hook - L, L)); segments.push(make_pair(R - hook, hook)); break; } query.push_back(make_pair(1, make_pair(hook, 1))); idtohook[id] = hook; zip[hook] = 0; } void leave_query(int id) { int hook = idtohook[id]; int L = nextL[hook], R = nextR[hook]; nextL[hook] = nextR[hook] = -1; nextL[R] = L; nextR[L] = R; segments.push(make_pair(R - L, L)); query.push_back(make_pair(1, make_pair(hook, -1))); } void solve(void) { int i; i = 0; for (__typeof((zip).begin()) itr = (zip).begin(); itr != (zip).end(); itr++) { (itr->second) = i; i++; } for ((i) = 0; (i) < (int)(query.size()); (i)++) { int type = query[i].first; if (type == 0) { int low = zip[query[i].second.first]; int high = zip[query[i].second.second]; int tmp = sum(high + 1); if (low > 0) tmp -= sum(low); ans.push_back(tmp); } else { int pos = zip[query[i].second.first]; add(pos, query[i].second.second); } } } int main(void) { int i; N = input(); Q = input(); segments.push(make_pair(N + 1, 0)); nextR[0] = N + 1; nextL[N + 1] = 0; zip[0] = zip[N + 1] = 0; for ((i) = 0; (i) < (int)(Q); (i)++) { int x = input(); if (x == 0) { int low = input(), high = input(); count_query(low, high); } else { appearance[x]++; int tmp = appearance[x]; if (tmp % 2 == 1) { enter_query(x); } else { leave_query(x); } } } solve(); for ((i) = 0; (i) < (int)(ans.size()); (i)++) printf( %d n , ans[i]); return 0; } |
#include <bits/stdc++.h> int main() { int x; int n, m; scanf( %d %d , &n, &m); if (m == 3 && n > 4) { printf( -1 n ); return 0; } for (x = 0; x < m; ++x) printf( %d %d n , x, x * x + 10001); for (x = 0; x < n - m; ++x) printf( %d %d n , x, -x * x); return 0; } |
#include <bits/stdc++.h> using namespace std; int n, m, tp; int a[2000002]; int main() { scanf( %d , &tp); int p = 1, i, j; for (i = 0; i <= 100; i++) { n++; if (p == tp) break; p *= 4; } for (i = 0; i < tp; i++) scanf( %d , &a[i]); sort(a, a + tp); long long ans = 0; p = 1; for (i = 0; i < n; i++) { for (j = 0; j < p; j++) ans += (long long)a[tp - j - 1]; p *= 4; } printf( %I64d , ans); } |
#include <bits/stdc++.h> using namespace std; int mod = 1000000007; const int inf = 1034567891; const long long LL_INF = 1234567890123456789ll; template <typename Arg1> void __f(const char* name, Arg1&& arg1) { cout << name << : << arg1 << n ; } template <typename Arg1, typename... Args> void __f(const char* names, Arg1&& arg1, Args&&... args) { const char* comma = strchr(names + 1, , ); cout.write(names, comma - names) << : << arg1 << | ; __f(comma + 1, args...); } template <typename T> T GCD(T a, T b) { long long t; while (a) { t = a; a = b % a; b = t; } return b; } template <typename T> string toString(T a) { return to_string(a); } template <typename T> void toInt(string s, T& x) { stringstream str(s); str >> x; } inline int add(int x, int y) { x += y; if (x >= mod) x -= mod; return x; } inline int sub(int x, int y) { x -= y; if (x < 0) x += mod; return x; } inline int mul(int x, int y) { return (x * 1ll * y) % mod; } inline int powr(int a, long long b) { int x = 1 % mod; while (b) { if (b & 1) x = mul(x, a); a = mul(a, a); b >>= 1; } return x; } inline int inv(int a) { return powr(a, mod - 2); } string str; long long give(int l, int r) { long long ans = 0, p = 0; for (int i = r; i >= l; i--) { ans += (1ll << p) * (str[i] - 48); p++; } return ans; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); int test; cin >> test; while (test--) { cin >> str; int n = str.size(); long long ans = 0; int nxt = -1; bool ok = false; for (int i = n - 1; i >= 0; i--) { if (!ok) { nxt = i; } if (str[i] == 1 ) { nxt = i; } int e = nxt - i; for (int j = nxt; j < nxt + 20 && j < n; j++) { long long num = give(nxt, j); if (num == (j - nxt + 1 + e)) { ans++; } } if (str[i] == 1 ) { ok = true; nxt = i; } } cout << ans << n ; } return 0; } |
#include <bits/stdc++.h> using namespace std; long long res = 1; int main() { int n; cin >> n; for (int i = 1; i < n; ++i) { res += i * 12; } cout << res; return 0; } |
#include <bits/stdc++.h> using namespace std; const int OO = 0x3f3f3f3f, N = 1e5 + 5, mod = 1e9 + 7; const double pi = acos(-1), EPS = 1e-8; int n; string str; map<deque<char>, deque<char>> mp; bool is(deque<char> ck, string s) { if (ck.size() != s.size()) return 0; for (int i = 0; i < s.size(); ++i) if (ck[i] != s[i]) return 0; return 1; } int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); deque<char> t; t.push_back( v ); t.push_back( o ); t.push_back( i ); t.push_back( d ); mp[t] = t; cin >> n; cin.ignore(); while (n--) { getline(cin, str); bool out = 0; deque<char> tmp, s; for (int i = 0; i < str.size(); ++i) { if (str[i] == ) { if (tmp.size()) { if (is(tmp, typeof )) out = 1; else s = tmp; } tmp.clear(); } else tmp.push_back(str[i]); } deque<char> var = tmp; if (out) { int And = 0, pointer = 0; while (var.front() == & ) ++And, var.pop_front(); while (var.back() == * ) ++pointer, var.pop_back(); if (mp[var].size() == 0) { cout << errtype n ; continue; } var = mp[var]; while (var.back() == * ) ++pointer, var.pop_back(); int x = min(And, pointer); And -= x; pointer -= x; if (And) cout << errtype n ; else if (mp[var].size()) { for (char go : mp[var]) cout << go; while (pointer--) cout << * ; cout << n ; } else cout << errtype n ; } else { int And = 0, pointer = 0; while (s.front() == & ) { ++And; s.pop_front(); } while (s.back() == * ) { ++pointer; s.pop_back(); } int x = min(And, pointer); pointer -= x; And -= x; if (mp[s].size()) { s = mp[s]; while (s.back() == * && And) { --And; s.pop_back(); } while (s.front() == & && pointer) { --pointer; s.pop_front(); } if (And && mp[var].size()) mp.erase(var); else if (And == 0) { while (pointer--) s.push_back( * ); mp[var] = s; } } else if (mp[var].size()) mp.erase(var); } } return 0; } |
#include <bits/stdc++.h> using namespace std; struct debugger { template <typename T> debugger& operator,(const T& v) { cerr << v << t ; return *this; } } dbg; template <class A, class B> ostream& operator<<(ostream& o, const pair<A, B>& p) { return o << ( << p.first << , << p.second << ) ; } template <class T> ostream& operator<<(ostream& o, const vector<T>& v) { o << [ ; for (__typeof((v).end()) it = (v).begin(); it != (v).end(); ++it) o << *it << , ; return o << ] ; } template <class T> ostream& operator<<(ostream& o, const set<T>& v) { o << [ ; for (__typeof((v).end()) it = (v).begin(); it != (v).end(); ++it) o << *it << , ; return o << ] ; } template <class T> inline void MAX(T& a, T b) { if (a < b) a = b; } template <class T> inline void MIN(T& a, T b) { if (a > b) a = b; } template <class T> inline bool read(T& x) { int c = getchar(); int sgn = 1; while (~c && c < 0 || c > 9 ) { if (c == - ) sgn = -1; c = getchar(); } for (x = 0; ~c && 0 <= c && c <= 9 ; c = getchar()) x = x * 10 + c - 0 ; x *= sgn; return ~c; } int a[15], l = 0; int main() { memset(a, 0, sizeof a); for (__typeof((6) - 1) i = (0); i <= (6) - 1; ++i) { int x = ({ int a; scanf( %d , &a); a; }); a[x]++; if (a[x] >= 4) l = x; } if (!l) puts( Alien ); else { a[l] -= 4; int c = 0; for (__typeof((10) - 1) i = (0); i <= (10) - 1; ++i) if (a[i]) c++; if (c > 1) puts( Bear ); else puts( Elephant ); } } |
#include <bits/stdc++.h> #pragma GCC optimize( Ofast,unroll-loops ) #pragma loop - opt(on) #pragma GCC target( sse,sse2,sse3,ssse3,sse4,avx,avx2,fma,tune=native ) using namespace std; const long long mxN = 1e5 + 5; long long n, m, Q; bitset<mxN> vis, in, incy; long long dsu[mxN], lca[mxN], eu[mxN], ev[mxN], tag[mxN], sum[mxN]; vector<long long> g[mxN], q[mxN]; long long get(long long x) { return x == dsu[x] ? x : dsu[x] = get(dsu[x]); } void tarjan(long long u, long long p = -1) { dsu[u] = u; in[u] = 1; for (long long v : g[u]) if (!in[v]) tarjan(v, u); for (long long i : q[u]) { long long v = u ^ eu[i] ^ ev[i]; if (vis[v]) { lca[i] = get(v); } if (v == u) lca[v] = u; } vis[u] = 1; dsu[u] = p; } vector<long long> stk; void dfs(long long u, long long p = -1) { vis[u] = in[u] = 1; stk.emplace_back(u); for (long long v : g[u]) { if (v == p) continue; if (in[v]) { tag[v]++; incy[v] = 1; while (!stk.empty() and stk.back() != v) { incy[stk.back()] = 1, stk.pop_back(); } stk.pop_back(); } if (vis[v]) continue; dfs(v, u); } if (!stk.empty() and stk.back() == u) stk.pop_back(); in[u] = 0; } void add(long long u) { vis[u] = 1; sum[u] += tag[u]; for (long long v : g[u]) { if (vis[v]) continue; sum[v] += sum[u]; add(v); } } signed main() { ios_base::sync_with_stdio(0); cin.tie(0); ; cin >> n >> m; while (m--) { long long a, b; cin >> a >> b; g[a].emplace_back(b); g[b].emplace_back(a); } dfs(1, 0); vis = 0; add(1); cin >> Q; for (long long i = 0; i < Q; i++) { cin >> eu[i] >> ev[i]; q[eu[i]].emplace_back(i); q[ev[i]].emplace_back(i); } vis = 0; in = 0; tarjan(1, 0); vector<long long> p2(n + 1); p2[0] = 1; for (long long i = 1; i <= n; i++) p2[i] = (p2[i - 1] << 1) % 1000000007; for (long long i = 0; i < Q; i++) { cout << p2[sum[eu[i]] + sum[ev[i]] - 2 * sum[lca[i]] + incy[lca[i]]] << n ; } } |
#include <bits/stdc++.h> using namespace std; int main() { long long n, c = 0; cin >> n; for (long long i = 1; i < n; ++i) { if (n % i == 0) c++; } cout << c << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; char in[100000 + 1]; int main() { vector<array<int, 4> > cur, nex; cur.push_back(array<int, 4>{{}}); int n; scanf( %d , &n); scanf( %s , in); for (int i = 0; i < n; i++) { int p = -1; switch (in[i]) { case G : p = 0; break; case H : p = 1; break; case R : p = 2; break; case S : p = 3; break; } if (p >= 0) { for (int i = 0; i < cur.size(); i++) { cur[i][p]++; } continue; } nex.clear(); for (auto a : cur) { int m = a[0]; for (int i = 1; i < 4; i++) { m = min(m, a[i]); } for (int i = 0; i < 4; i++) { if (a[i] == m) { nex.push_back(a); nex.back()[i]++; } } } sort(nex.begin(), nex.end()); nex.resize(unique(nex.begin(), nex.end()) - nex.begin()); nex.swap(cur); } const char* str[] = { Gryffindor , Hufflepuff , Ravenclaw , Slytherin }; for (int i = 0; i < 4; i++) { for (auto a : cur) { int m = a[0]; for (int i = 1; i < 4; i++) { m = min(m, a[i]); } if (a[i] == m) { puts(str[i]); break; } } } return 0; } |
#include <bits/stdc++.h> using namespace std; long long cross(pair<long long, long long> a, pair<long long, long long> b, pair<long long, long long> c) { pair<long long, long long> v1 = make_pair(b.first - a.first, b.second - a.second); pair<long long, long long> v2 = make_pair(c.first - a.first, c.second - a.second); if ((long long)v1.first * (long long)v2.second - (long long)v2.first * (long long)v1.second > 0) return 1; else if ((long long)v1.first * (long long)v2.second - (long long)v2.first * (long long)v1.second < 0) return -1; return 0; } int main(int argc, char* argv[]) { long long n; cin >> n; vector<long long> arr(n); for (long long i = 0; i < n; i++) { cin >> arr[i]; } vector<pair<long long, long long> > p; p.push_back(make_pair(-1, 0)); long long s = 0; for (long long i = 0; i < n; i++) { s += arr[i]; p.push_back(make_pair(i, s)); } stack<pair<long long, long long> > ch; ch.push(p[0]); ch.push(p[1]); for (long long i = 2; i < n + 1; i++) { pair<long long, long long> top = ch.top(); ch.pop(); while (ch.size() > 0 && cross(ch.top(), top, p[i]) == -1) { top = ch.top(); ch.pop(); } ch.push(top); ch.push(p[i]); } vector<pair<long long, long long> > vec; while (ch.size()) { vec.push_back(ch.top()); ch.pop(); } reverse(vec.begin(), vec.end()); vector<double> cev; long long cur = 0; for (long long i = -1; i < n; i++) { if (vec[cur].first == i) cev.push_back(vec[cur].second); else { if (cur < vec.size() - 1 && vec[cur + 1].first <= i) { cur++; i--; continue; } long long x1 = vec[cur + 1].first - vec[cur].first; long long y1 = vec[cur + 1].second - vec[cur].second; long long x2 = i - vec[cur].first; cev.push_back((((double)x2 * (double)y1) / (double)x1) + vec[cur].second); } } for (long long i = 0; i < cev.size() - 1; i++) { cout << setprecision(13) << double(cev[i + 1] - cev[i]) << ; } cout << endl; } |
#include <bits/stdc++.h> using namespace std; bool func(deque<int>& v) { int x = v.back(); if (x > 1) { v.pop_back(); int y = x / 2; int y2 = x - y; if (y == 1) v.push_front(y); else v.push_back(y); if (y2 == 1) v.push_front(y2); else v.push_back(y2); return true; } return false; } void printv(deque<int>& v) { for (int i = 0; i < v.size(); i++) cout << v[i] << ; cout << endl; } int main() { int k; int xyz[3]; cin >> xyz[0] >> xyz[1] >> xyz[2] >> k; sort(xyz, xyz + 3); deque<int> first, second, third; first.push_back(xyz[2]); second.push_back(xyz[1]); third.push_back(xyz[0]); int i = 0; while (i < k) { if (func(first)) i++; else break; if (i < k && func(second)) i++; if (i < k && func(third)) i++; } cout << (long long int)first.size() * second.size() * third.size(); } |
#include <bits/stdc++.h> using namespace std; void solve() { int n; cin >> n; string s; cin >> s; int cnt = 0; vector<int> v; char last = * ; for (int i = 0, to = n; i < to; i++) { if (last != s[i]) { if (cnt > 0) v.push_back(cnt); cnt = 1; last = s[i]; } else { cnt++; } } v.push_back(cnt); int ans = 0; int resto = 0; for (int i = 0, to = (int)v.size(); i < to; i++) { if (v[i] > 1) { resto -= (v[i] - 2); resto = max(resto, 0); ans++; } else { resto++; ans++; } } cout << ans - resto / 2 << n ; } int main() { ios::sync_with_stdio(0); cin.tie(NULL); int t = 1; cin >> t; while (t--) solve(); return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int n, k = 0; cin >> n; int arr[n + 2]; arr[0] = arr[n + 1] = 0; for (int i = 1; i <= n; i++) cin >> arr[i]; for (int i = 1; i <= n; i++) if (arr[i - 1] == 1 && arr[i + 1] == 1 && arr[i] == 0) arr[i + 1] = 0, k++; cout << k; return 0; } |
#include <bits/stdc++.h> using namespace std; inline long long int read() { char C = getchar(); long long int N = 0, F = 1; while (( 0 > C || C > 9 ) && (C != - )) C = getchar(); if (C == - ) F = -1, C = getchar(); while ( 0 <= C && C <= 9 ) N = (N << 1) + (N << 3) + (C - 48), C = getchar(); return F * N; } long long int D[250005], NEXT[250005], ST[250005], LIM; long long int F[250005][2], SUM[250005]; struct DQ { priority_queue<long long int> A, B; void push(long long int x) { A.push(x); } void condense() { while (A.size() && B.size() && A.top() == B.top()) { A.pop(); B.pop(); } } void pop() { condense(); A.pop(); } long long int top() { condense(); return A.top(); } void del(long long int x) { B.push(x); } long long int size() { return A.size() - B.size(); } } H[250005]; bool vis[250005]; vector<long long int> VECD[250005]; vector<pair<long long int, long long int> > E[250005]; bool cmp(pair<long long int, long long int> A, pair<long long int, long long int> B) { return D[A.first] < D[B.first]; } void dele(long long int wch) { vis[wch] = true; for (long long int i = ST[wch]; i < E[wch].size(); i++) { if (vis[E[wch][i].first]) continue; long long int to = E[wch][i].first, wei = E[wch][i].second; H[to].push(wei); SUM[to] += wei; } } void upd(long long int wch, long long int num, vector<long long int>& cont) { while (H[wch].size() > num) { cont.push_back(H[wch].top()); SUM[wch] -= H[wch].top(); H[wch].pop(); } } void upd(long long int wch, long long int num) { while (H[wch].size() > num) { SUM[wch] -= H[wch].top(); H[wch].pop(); } } void dfs(long long int wch) { long long int tot = 0, ned; ned = D[wch] - LIM; vector<long long int> DEL, ADD; upd(wch, ned); vis[wch] = true; while (ST[wch] < E[wch].size() && D[E[wch][ST[wch]].first] <= LIM) ST[wch]++; for (long long int i = ST[wch]; i < E[wch].size(); i++) { long long int to = E[wch][i].first, wei = E[wch][i].second; if (vis[to]) continue; dfs(to); if (F[to][0] + wei <= F[to][1]) { tot += F[to][0] + wei; ned--; } else { long long int c = F[to][0] + wei - F[to][1]; tot += F[to][1]; DEL.push_back(c); H[wch].push(c); SUM[wch] += c; } } upd(wch, max(ned, (long long int)0), ADD); F[wch][1] = tot + SUM[wch]; upd(wch, max((long long int)0, ned - 1), ADD); F[wch][0] = tot + SUM[wch]; for (long long int i = 0; i < ADD.size(); i++) H[wch].push(ADD[i]), SUM[wch] += ADD[i]; for (long long int i = 0; i < DEL.size(); i++) H[wch].del(DEL[i]), SUM[wch] -= DEL[i]; } int main() { long long int N, ans = 0; N = read(); for (long long int i = 1; i < N; i++) { long long int a, b, c; a = read(), b = read(), c = read(); D[a]++, D[b]++; E[a].push_back({b, c}); E[b].push_back({a, c}); ans += c; } printf( %I64d , ans); for (long long int i = 1; i <= N; i++) { sort(E[i].begin(), E[i].end(), cmp); VECD[D[i]].push_back(i); } NEXT[N - 1] = N; for (long long int i = N - 2; i >= 1; i--) { if (VECD[i + 1].size()) NEXT[i] = i + 1; else NEXT[i] = NEXT[i + 1]; } for (LIM = 1; LIM < N; LIM++) { for (long long int j = 0; j < VECD[LIM].size(); j++) dele(VECD[LIM][j]); long long int sum = 0; for (long long int j = LIM + 1; j < N; j = NEXT[j]) { for (long long int k = 0; k < VECD[j].size(); k++) { if (vis[VECD[j][k]]) continue; dfs(VECD[j][k]); sum += F[VECD[j][k]][1]; } } printf( %I64d , sum); for (long long int j = LIM + 1; j < N; j = NEXT[j]) for (long long int k = 0; k < VECD[j].size(); k++) vis[VECD[j][k]] = false; } return 0; } |
#include <bits/stdc++.h> const int N = 1e5 + 3; struct edge { int v, nxt; } g[N + N]; int n, head[N], k; double ans; inline void Insert(int u, int v) { g[++k] = (edge){v, head[u]}; head[u] = k; } void Dfs(int u, int dep, int fa) { int v; ans += 1.0 / dep; for (int i = head[u]; i; i = g[i].nxt) if ((v = g[i].v) != fa) Dfs(v, dep + 1, u); } int main() { int u, v; scanf( %d , &n); for (int i = 1; i < n; i++) scanf( %d%d , &u, &v), Insert(u, v), Insert(v, u); Dfs(1, 1, 0); printf( %.9lf n , ans); return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int test; cin >> test; int n; string rakh1, rakh2, rakh, ch, ch_min; while (test--) { cin >> n; cin >> ch; ch_min = ch; int pos = 1; for (int i = 1; i < (n - 1); i++) { rakh1 = ch.substr(0, i); rakh2 = ch.substr(i, n - 1); if ((n % 2 != 0 && i % 2 == 0) || (n % 2 == 0 && i % 2 != 0)) reverse(rakh1.begin(), rakh1.end()); rakh = rakh2 + rakh1; if (ch_min > rakh) { pos = i + 1; ch_min = rakh; } } reverse(ch.begin(), ch.end()); if (ch_min > ch) { pos = n; ch_min = ch; } cout << ch_min << endl; cout << pos << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; int fastMax(int x, int y) { return (((y - x) >> (32 - 1)) & (x ^ y)) ^ y; } int fastMin(int x, int y) { return (((y - x) >> (32 - 1)) & (x ^ y)) ^ x; } void solve() { long long int x, y, z; cin >> x >> y >> z; long long int x1, y1, z1; cin >> x1 >> y1 >> z1; long long int a1, a2, a3, a4, a5, a6; cin >> a1 >> a2 >> a3 >> a4 >> a5 >> a6; long long int ans = 0; if (x > x1) ans += a6; else if (x < 0) ans += a5; if (y > y1) ans += a2; else if (y < 0) ans += a1; if (z > z1) ans += a4; else if (z < 0) ans += a3; cout << ans << endl; } signed main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); ; long long int t; t = 1; while (t--) solve(); } |
#include <bits/stdc++.h> using namespace std; const int INF = INT_MAX; const long long INFL = LLONG_MAX; int N, M, ans[200100], n, m; int main() { cin >> N >> M; n = m = 0; ans[0] = 0; n++; for (int(i) = 1; (i) <= (N + M - 1); (i)++) { if (i & 1) { if (ans[i - 1]) { if (n < N) { ans[i] = 0; n++; } else { ans[i] = 1; m++; } } else { if (m < M) { ans[i] = 1; m++; } else { ans[i] = 0; n++; } } } else { if (ans[i - 1]) { if (m < M) { ans[i] = 1; m++; } else { ans[i] = 0; n++; } } else { if (n < N) { ans[i] = 0; n++; } else { ans[i] = 1; m++; } } } } int s11 = 0; int s12 = 0; for (int(i) = 1; (i) <= (N + M - 1); (i)++) { if (ans[i - 1] == ans[i]) s11++; else s12++; } n = m = 0; ans[0] = 1; m++; for (int(i) = 1; (i) <= (N + M - 1); (i)++) { if (i & 1) { if (ans[i - 1]) { if (n < N) { ans[i] = 0; n++; } else { ans[i] = 1; m++; } } else { if (m < M) { ans[i] = 1; m++; } else { ans[i] = 0; n++; } } } else { if (ans[i - 1]) { if (m < M) { ans[i] = 1; m++; } else { ans[i] = 0; n++; } } else { if (n < N) { ans[i] = 0; n++; } else { ans[i] = 1; m++; } } } } int s21 = 0; int s22 = 0; for (int(i) = 1; (i) <= (N + M - 1); (i)++) { if (ans[i - 1] == ans[i]) s21++; else s22++; } if (s11 < s21) { cout << s21 << << s22 << endl; } else { cout << s11 << << s12 << endl; } } |
#include <bits/stdc++.h> using namespace std; long long n, mod; pair<long long, long long> a[200100]; long long d[200100]; long long first(int t, int k) { long long res = 1; for (int i = 1; i <= k; i++) d[i] = i; for (int j = 2; t;) if (d[j] % 2) j += 2; else while (d[j] % 2 == 0 && t) { d[j] /= 2; t--; } for (int i = 1; i <= k; i++) res = (res * d[i]) % mod; return res; } int main() { cin >> n; for (int i = 0; i < 2 * n; ++i) { cin >> a[i].first; a[i].second = (i % n) + 1; } sort(a, a + 2 * n); cin >> mod; long long r = 1; for (int i = 0; i < 2 * n; i++) { long long k, t = 0; for (k = i + 1; k < 2 * n && a[k].first == a[i].first; k++) if (a[k].second == a[k - 1].second) t++; k--; r = (r * first(t, k - i + 1)) % mod; i = k; } cout << r; return 0; } |
#include <bits/stdc++.h> using namespace std; const long long N = 1e5 + 5; long long n, k, z, a[N]; signed main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); long long t; cin >> t; while (t--) { cin >> n >> k >> z; long long sum = 0; for (long long i = 1; i <= n; i++) cin >> a[i]; long long ans = 0; for (long long j = 0; j <= z; j++) { long long s = k - j; if (s < j) break; long long sum = 0; long long mx = 0; for (long long i = 1; i <= s - j + 1; i++) sum += a[i], mx = max(a[i] + a[i + 1], mx); ans = max(ans, sum + mx * j); } cout << ans << n ; } return 0; } |
#include <bits/stdc++.h> using namespace std; int n, m; char a[60][60]; bool isRowChecked[60]; bool isColChecked[60]; bool doCheck(int r, int c) { bool isRowRegard[60]; bool isColRegard[60]; memset(isRowRegard, false, sizeof(isRowRegard)); memset(isColRegard, false, sizeof(isColRegard)); std::vector<int> rows; std::vector<int> cols; for (int rr = r; rr < n; rr++) { if (a[rr][c] == # ) { isRowRegard[rr] = true; rows.push_back(rr); } } for (int cc = c; cc < m; cc++) { if (a[r][cc] == # ) { isColRegard[cc] = true; cols.push_back(cc); } } for (int i = 0; i < rows.size(); i++) { for (int cc = 0; cc < m; cc++) { if ((a[rows[i]][cc] == . ) && (isColRegard[cc] == true)) return false; if ((a[rows[i]][cc] == # ) && (isColRegard[cc] == false)) return false; } } for (int j = 0; j < cols.size(); j++) { for (int rr = 0; rr < n; rr++) { if ((a[rr][cols[j]] == . ) && (isRowRegard[rr] == true)) return false; if ((a[rr][cols[j]] == # ) && (isRowRegard[rr] == false)) return false; } } for (int i = 0; i < rows.size(); i++) isRowChecked[rows[i]] = true; for (int j = 0; j < cols.size(); j++) isColChecked[cols[j]] = true; return true; } int main() { scanf( %d%d n , &n, &m); for (int i = 0; i < n; i++) scanf( %s n , a[i]); memset(isRowChecked, false, sizeof(isRowChecked)); memset(isColChecked, false, sizeof(isColChecked)); for (int r = 0; r < n; r++) { if (isRowChecked[r]) continue; for (int c = 0; c < m; c++) { if (isColChecked[c]) continue; if (a[r][c] == # ) { if (doCheck(r, c) == false) { printf( No n ); return 0; } } } } printf( Yes n ); return 0; } |
#include <bits/stdc++.h> using namespace std; long long power(long long x, long long y, long long md = 1000000007) { long long res = 1; x %= md; while (y > 0) { if (y & 1) res = (res * x) % md; x = (x * x) % md; y = y >> 1; } return res % md; } signed main() { long long n, m; cin >> n >> m; long long root = sqrt(n) + 1; std::vector<long long> factors; std::vector<pair<int, int> > v(m); for (int i = 1; i < root; i++) { if (n % i) continue; long long temp = n / i; factors.push_back(i); if (i != temp && temp != n) factors.push_back(temp); } std::vector<long long> check(m, 0); std::map<pair<long long, long long>, long long> map; for (int i = 0; i < m; i++) { long long a, b; cin >> a >> b; a--; b--; if (b < a) swap(a, b); v[i] = make_pair(a, b); map[v[i]] = i; } for (int i = 0; i < factors.size(); i++) { for (int j = 0; j < m; j++) check[i] = 0; long long x = factors[i]; long long first = 1; for (int j = 0; j < m; j++) { long long a = min((v[j].first + x) % n, (v[j].second + x) % n); long long b = max((v[j].first + x) % n, (v[j].second + x) % n); std::map<pair<long long, long long>, long long>::iterator it = map.find(make_pair(a, b)); if (it == map.end()) { first = 0; break; } } if (first) { cout << Yes ; return 0; } } cout << No ; } |
#include <bits/stdc++.h> using namespace std; const long long INF = 1e17; struct Node { int to; long long dis; int type; Node(int a = 0, long long b = 0, int c = 0) { to = a; dis = b; type = c; } friend bool operator<(Node a, Node b) { if (a.dis != b.dis) return a.dis > b.dis; return a.type > b.type; } }; int n, m, k; int vis[100005], p[100005]; long long dis[100005]; vector<Node> v[100005]; void djs(int x) { memset(vis, 0, sizeof(vis)); memset(p, 0, sizeof(p)); for (int i = 0; i <= n; i++) dis[i] = INF; priority_queue<Node> q; q.push(Node(x, 0, 0)); dis[x] = 0; Node u, w; while (!q.empty()) { u = q.top(); q.pop(); if (u.dis != dis[u.to] || vis[u.to]) continue; vis[u.to] = 1; for (int i = 0; i < v[u.to].size(); i++) { w = v[u.to][i]; if (!vis[w.to]) { if (u.dis + w.dis < dis[w.to]) { dis[w.to] = u.dis + w.dis; q.push(Node(w.to, dis[w.to], 0)); p[w.to] = w.type; } else if (u.dis + w.dis == dis[w.to] && w.type == 0) { p[w.to] = w.type; } } } } } int main() { while (~scanf( %d%d%d , &n, &m, &k)) { for (int i = 0; i <= n; i++) { while (!v[i].empty()) v[i].clear(); } int a, b; long long c; for (int i = 0; i < m; i++) { scanf( %d%d%lld , &a, &b, &c); v[a].push_back(Node(b, c, 0)); v[b].push_back(Node(a, c, 0)); } for (int i = 0; i < k; i++) { scanf( %d%lld , &b, &c); v[1].push_back(Node(b, c, 1)); v[b].push_back(Node(1, c, 1)); } djs(1); for (int i = 2; i <= n; i++) { k -= p[i]; } printf( %d n , k); } return 0; } |
#include <bits/stdc++.h> using namespace std; using ll = long long; int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); int n, m; cin >> n >> m; int arr[m]; for (int i = 0; i < m; i++) cin >> arr[i]; long long res = arr[0]; for (int i = 1; i < m; i++) { if (arr[i] - arr[i - 1] < 0) { res += (n - arr[i - 1]) + arr[i]; } else res += (arr[i] - arr[i - 1]); } cout << res - 1 << n ; return 0; } |
#include <bits/stdc++.h> using namespace std; long long a1, a2, a3, sum = 0, a12, a23, a31; int main() { cin >> a1 >> a2 >> a3; sum = a1 + a2 + a3; if (sum % 2) { cout << Impossible ; return 0; } sum /= 2; a12 = sum - a3; a23 = sum - a1; a31 = sum - a2; if (a12 < 0 || a23 < 0 || a31 < 0) { cout << Impossible ; return 0; } else cout << a12 << << a23 << << a31; } |
#include <bits/stdc++.h> using namespace std; const int N = 400005; char a[N]; int n, k, delta, top, st[N]; bool vis[N]; int main() { scanf( %d%d , &n, &k), scanf( %s , a + 1); delta = (n - k) / 2, top = 0; for (int i = 1; i <= n; ++i) { if (a[i] == ( ) st[++top] = i; else { if (delta) { --delta, vis[i] = 1; vis[st[top]] = 1; } --top; } } for (int i = 1; i <= n; ++i) if (!vis[i]) printf( %c , a[i]); puts( ); return 0; } |
//AYUSH VERMA //********************************************* ********************************* //***************/A ************************** ****** *********///************* //**************//Y ************************ ******** *******///************** //*************///U ********************** ********** **A**///*************** //************///*S* ******************** ************ *M*///**************** //***********/////H ****************** ************** R///***************** //**********///******* **************** **************** E//****************** //*********///********* ************** ****************** V/******************* //************************************* ***************************************** #include<bits//stdc++.h> #define till(condition) while(condition) #define ull unsigned long long int #define ll long long int #define space printf( ) #define nl printf( n ) #define MOD 1000000007 using namespace std; int main() { int t; cin>>t; till(t--) { int n; cin>>n; ll a[100001],want[100001]; ll max=0; ll maxtest=0; for(int i=0;i<n;i++) { cin>>a[i]; if(a[i]>maxtest) { maxtest=a[i]; } } sort(a,a+n,greater<int>()); ll wantsum=0; for(int i=0;i<n;i++) { want[i]=(maxtest-a[i]); wantsum+=(want[i]); } for(int i=0;i<n;i++) { ll temp=a[i],fill; ll tempwantsum=wantsum-want[i]; if(i!=0) { fill=a[0]; } else { fill=a[1]; } ll subs=(n-1)*(temp-fill); if(subs>0) { tempwantsum-=(subs); } // cout<< * <<temp; // nl; if(tempwantsum<=temp) { temp-=(tempwantsum); if(temp%(n-1)!=0) { ll ans=(n-1)-(temp%(n-1)); if(ans>max) { max=ans; } } } else { if((tempwantsum-temp)>max) { max=(tempwantsum-temp); } } // cout<< ** <<max; // nl; } cout<<max; nl; } } |
#include <bits/stdc++.h> using namespace std; int dist[600 + 15][600 + 15]; int start[200 + 15]; int MAX_ = INT_MAX / 2 - 5; vector<pair<int, int> > sas[1000]; int cap[250000 + 15]; int v, e, n, k; int pop_w[1000]; int pop_kr[1000]; int group[1000]; int last_checked[1000]; int dead[1000]; int res; int num = 0; bool b = 0; int to_add; bool DFS(int w, int bneck) { if (w == n + v + 2) { to_add = bneck; res += to_add; return 1; } for (int i = last_checked[w] + 1; i < sas[w].size(); i++) { int do_ = sas[w][i].first; int neck = min(bneck, cap[sas[w][i].second]); last_checked[w] = i; if (neck && !dead[do_]) if (DFS(do_, neck)) { cap[sas[w][i].second] -= to_add; cap[sas[w][i].second ^ 1] += to_add; return 1; } } return 0; } int DINIC() { for (int i = 0; i <= n + v + 3; i++) { group[i] = -1; dead[i] = 0; last_checked[i] = -1; } queue<pair<int, int> > q; q.push({0, 0}); group[0] = 0; while (!q.empty()) { int top_w = q.front().first; int top_g = q.front().second; q.pop(); for (int i = 0; i < sas[top_w].size(); i++) if (group[sas[top_w][i].first] == -1) { group[sas[top_w][i].first] = top_g + 1; q.push({sas[top_w][i].first, top_g + 1}); } } int ile = 0; while (DFS(0, INT_MAX)) ile++; return ile; } bool CHECK(int t) { for (int i = 0; i <= n + v + 3; i++) sas[i].clear(); int place; num = 0; for (int i = 1; i <= n; i++) { place = start[i]; for (int j = 1; j <= v; j++) { if (dist[place][j] <= t) { sas[i].push_back({j + n, num}); sas[j + n].push_back({i, num + 1}); cap[num] = 1; cap[num + 1] = 0; num += 2; } } } for (int i = 1; i <= n; i++) { sas[0].push_back({i, num}); sas[i].push_back({0, num + 1}); cap[num] = 1; cap[num + 1] = 0; num += 2; } for (int i = n + 1; i <= n + v; i++) { sas[i].push_back({n + v + 2, num}); sas[n + v + 2].push_back({i, num + 1}); cap[num] = 1; cap[num + 1] = 0; num += 2; } res = 0; while (DINIC()) { }; if (res >= k) return 1; return 0; } int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); cin >> v >> e >> n >> k; for (int i = 1; i <= n; i++) cin >> start[i]; for (int i = 1; i <= v; i++) for (int j = 1; j <= v; j++) dist[i][j] = MAX_; for (int i = 1; i <= v; i++) dist[i][i] = 0; int h, j, r; for (int i = 1; i <= e; i++) { cin >> h >> j >> r; dist[h][j] = min(dist[h][j], r); dist[j][h] = min(dist[j][h], r); } for (int mid = 1; mid <= v; mid++) for (int x = 1; x <= v; x++) for (int y = 1; y <= v; y++) dist[x][y] = min(dist[x][y], dist[x][mid] + dist[mid][y]); if (!CHECK(1731311)) { cout << -1; return 0; } int b = 0; int e = 1731311; while (b <= e) { int mid = (b + e) / 2; if (CHECK(mid)) e = mid - 1; else b = mid + 1; } cout << b; } |
#include <bits/stdc++.h> using namespace std; const int oo = 0x3f3f3f3f; const double eps = 1e-9; const int maxn = 100000 + 10; int go[maxn][26], fail[maxn]; int I[maxn], F[maxn], S[maxn], FIN[maxn]; int total; void push(string &s, int index, int freq) { int u = 0; for (auto c : s) { int x = c - a ; if (!go[u][x]) go[u][x] = total++; u = go[u][x]; } I[u] = index, F[u] = freq, S[u] = s.length(), FIN[u] = u; } void build() { queue<pair<int, int> > q; for (int i = 0; i < 26; ++i) { if (go[0][i]) q.push({go[0][i], 0}); } while (!q.empty()) { auto x = q.front(); q.pop(); int u = x.first, f = x.second; fail[u] = f; if (!FIN[u]) FIN[u] = FIN[f]; for (int i = 0; i < 26; ++i) { if (go[u][i]) q.push({go[u][i], go[f][i]}); else go[u][i] = go[f][i]; } } } int ANSWER[maxn]; queue<int> deq[maxn]; int main() { ios_base::sync_with_stdio(0); cin.tie(0); total = 1; string s; cin >> s; int q; cin >> q; for (int i = 1; i <= q; ++i) { int f; string t; cin >> f >> t; push(t, i, f); } build(); memset(ANSWER, 0x3f, sizeof ANSWER); for (int i = 0, u = 0; i < (int)s.length(); ++i) { u = go[u][s[i] - a ]; int v = FIN[u]; while (v) { int idx = I[v]; deq[idx].push(i); if (deq[idx].size() > F[v]) deq[idx].pop(); if (deq[idx].size() == F[v]) { int beg = deq[idx].front(); ANSWER[idx] = min(ANSWER[idx], i - beg + S[v]); } v = FIN[fail[v]]; } } for (int i = 1; i <= q; ++i) { if (ANSWER[i] == oo) cout << -1 << n ; else cout << ANSWER[i] << n ; } return 0; } |
#include <bits/stdc++.h> using namespace std; const long long N = 1e18; const long long mod = 1e9; long long dp[100005]; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); long long t = 1; cin >> t; while (t--) { long long n, k; cin >> n >> k; long long i; long long a[n]; set<long long> s; long long c = 0; for (i = 0; i < n; i++) { cin >> a[i]; s.insert(a[i]); if (i > 0) { if (a[i] != a[i - 1]) { c++; } } } long long d = s.size(); if (d <= k) { cout << 1 << endl; } else { if (k == 1 && (d != k)) { cout << -1 << endl; } else { cout << (((c % (k - 1)) == 0) ? (c / (k - 1)) : (c / (k - 1) + 1)) << endl; } } } return 0; } |
#include <bits/stdc++.h> using namespace std; const long long N = 3e5 + 10, M = 2097152 + 10; long long n, x, ans, ar[N], mark[M][2]; int32_t main() { ios::sync_with_stdio(0); cin.tie(0); cin >> n; for (long long i = 0; i < n; i++) cin >> ar[i]; mark[0][1]++; for (long long i = 0; i < n; i++) { x ^= ar[i]; mark[x][i & 1]++; } for (long long i = 0; i < M; i++) { ans += (mark[i][0] * (mark[i][0] - 1)) / 2; ans += (mark[i][1] * (mark[i][1] - 1)) / 2; } cout << ans; } |
#include <bits/stdc++.h> using namespace std; int main() { long long int t; cin >> t; while (t--) { long long int a, b, c, d, e, y = 0, x = 0, l = 0, z = 0, k = 0, m = 0; cin >> a >> b >> c >> d >> e; if (d > e) { while (a > 1 && b > 0) { y++; a = a - 2; b = b - 1; } while (a > 1 && c > 0) { x++; a = a - 2; c = c - 1; } l = (d * y) + (x * e); cout << l << endl; } else { while (a > 1 && c > 0) { z++; a = a - 2; c = c - 1; } while (a > 1 && b > 0) { k++; a = a - 2; b = b - 1; } m = (e * z) + (k * d); cout << m << endl; } y = 0, x = 0, l = 0, z = 0, k = 0, m = 0; } return 0; } |
#include <bits/stdc++.h> using namespace std; using ll = long long; const ll MOD = 1e9 + 7, N = 1e5 + 10; const ll MX = 1e8; int32_t main() { ios::sync_with_stdio(false); cin.tie(NULL); string s; cin >> s; ll ans = 0; for (ll i = 0; i < MX; i += 25) { string k = to_string(i); if (k.length() != s.length()) continue; set<ll> se; ll bad = 1; 42; for (ll j = 0; j < k.length(); j++) { if (s[j] == _ ) continue; if (s[j] == X ) { se.insert(k[j] - 0 ); if (se.size() > 1) break; continue; } if (s[j] != k[j]) bad = 0; } ans += (se.size() <= 1 and bad); } cout << ans << n ; return 0; } |
#include <bits/stdc++.h> using namespace std; char c1[1005], c2[1005]; long long f[100005][2], ans, k, l; bool pd; int main() { scanf( %s , c1); scanf( %s , c2); scanf( %lld , &k); l = strlen(c1); f[0][0] = 1; for (register long long i = 1; i <= k; i = -~i) { f[i][0] = ((l - 1) * f[i - 1][1]) % 1000000007; f[i][1] = (((l - 2) * f[i - 1][1]) % 1000000007 + f[i - 1][0]) % 1000000007; } for (register long long i = 0; i < l; i = -~i) { pd = false; for (register long long j = 0; j < l; j = -~j) if (c1[(i + j) % l] != c2[j]) { pd = true; break; } if (!pd) { if (i) ans = (ans + f[k][1]) % 1000000007; else ans = (ans + f[k][0]) % 1000000007; } } printf( %lld , ans); return 0; } |
#include <bits/stdc++.h> using namespace std; struct LCA { int logn; vector<int> depth; vector<vector<int> > lca; vector<vector<int> > *edges; LCA(int n, vector<vector<int> > *edges) { logn = log(n) / log(2) + 1; depth.resize(n + 1, 0); lca.resize(n + 1, vector<int>(logn, 0)); this->edges = edges; build(); } void dfs(int u, int p) { lca[u][0] = p; for (int i = 1; i < logn; i++) { lca[u][i] = lca[lca[u][i - 1]][i - 1]; } depth[u] = depth[p] + 1; for (auto &v : (*edges)[u]) { if (p != v) { dfs(v, u); } } } int parent(int v, int h) { for (int i = logn - 1; i >= 0; i--) { if (h & (1 << i)) { v = lca[v][i]; } } return v; } int lessParent(int u, int p) { return parent(u, depth[u] - depth[p] - 1); } int get(int u, int v) { if (depth[u] > depth[v]) { swap(u, v); } int h = depth[v] - depth[u]; v = parent(v, h); if (u == v) { return u; } for (int i = logn - 1; i >= 0; i--) { if (lca[u][i] != lca[v][i]) { u = lca[u][i]; v = lca[v][i]; } } return lca[u][0]; } void build() { dfs(1, 0); } } * lca; struct GraphBuilder { enum DIRECT { UP = 0, DOWN, }; int n; int k; vector<vector<int> > *e; vector<pair<int, int> > edges; set<pair<int, int> > cache; vector<vector<int> > addedVertices; vector<vector<int> > deletedVertices; LCA *lca; struct Node { int id; Node *leftChild; Node *rightChild; Node(int v, Node *l, Node *r) { id = v; leftChild = l; rightChild = r; } }; vector<pair<Node *, Node *> > root; GraphBuilder(int m, vector<vector<int> > *e) { k = 2 * m - 1; n = 2 * m - 1; this->e = e; lca = new LCA(e->size() - 1, e); addedVertices.resize(e->size()); deletedVertices.resize(e->size()); for (int i = 0; i < m; i++) { for (int j = 0; j < 2; j++) { int u, v; scanf( %d %d , &u, &v); int p = lca->get(u, v); if (u != p) { addedVertices[u].push_back((i << 1) | j); deletedVertices[lca->lessParent(u, p)].push_back((i << 1) | j); } if (v != p) { addedVertices[v].push_back((i << 1) | j); deletedVertices[lca->lessParent(v, p)].push_back((i << 1) | j); } } } root.resize(e->size(), {0, 0}); dfs(1, 0); } void dfs(int u, int p) { for (auto &v : (*e)[u]) { if (v != p) { dfs(v, u); root[u].first = merge(root[u].first, root[v].first, DOWN); root[u].second = merge(root[u].second, root[v].second, UP); } } for (auto &x : addedVertices[u]) { root[u].first = addVertex(0, n, root[u].first, (x ^ 1), DOWN); root[u].second = addVertex(0, n, root[u].second, x, UP); } for (auto &x : deletedVertices[u]) { root[u].first = delVertex(0, n, root[u].first, (x ^ 1), DOWN); root[u].second = delVertex(0, n, root[u].second, x, UP); if (root[u].first) { add(x, root[u].first->id); } if (root[u].second) { add(root[u].second->id, (x ^ 1)); } } } void add(int u, int v) { edges.push_back({u, v}); } void addEdge(Node *p, int direct) { if (direct == DOWN) { if (p->leftChild) { add(p->id, p->leftChild->id); } if (p->rightChild) { add(p->id, p->rightChild->id); } } else { if (p->leftChild) { add(p->leftChild->id, p->id); } if (p->rightChild) { add(p->rightChild->id, p->id); } } } Node *addVertex(int l, int r, Node *p, int v, int direct) { if (!p) { p = new Node(0, 0, 0); } if (l == r) { return new Node(v, 0, 0); } else { int mid = (l + r) >> 1; Node *newNode = new Node(++k, p->leftChild, p->rightChild); if (v <= mid) { newNode->leftChild = addVertex(l, mid, p->leftChild, v, direct); } else { newNode->rightChild = addVertex(mid + 1, r, p->rightChild, v, direct); } addEdge(newNode, direct); return newNode; } } Node *delVertex(int l, int r, Node *p, int v, int direct) { if (l == r) { return 0; } else { int mid = (l + r) >> 1; Node *newNode = new Node(++k, p->leftChild, p->rightChild); if (v <= mid) { newNode->leftChild = delVertex(l, mid, p->leftChild, v, direct); } else { newNode->rightChild = delVertex(mid + 1, r, p->rightChild, v, direct); } if (!newNode->leftChild && !newNode->rightChild) { return 0; } addEdge(newNode, direct); return newNode; } } Node *merge(Node *p1, Node *p2, int direct) { if (!p1 || !p2) { return p1 ? p1 : p2; } else { Node *left = merge(p1->leftChild, p2->leftChild, direct); Node *right = merge(p1->rightChild, p2->rightChild, direct); Node *newNode = new Node(++k, left, right); addEdge(newNode, direct); return newNode; } } }; struct SAT { int n; vector<int> st; vector<int> mark; vector<int> group; vector<vector<int> > edges; vector<vector<int> > revEdges; SAT(int n, vector<pair<int, int> > &e) { this->n = n + 1; mark.resize(n + 1, 0); group.resize(n + 1, 0); edges.resize(n + 1); revEdges.resize(n + 1); for (auto &p : e) { addEdge(p.first, p.second); } } void addEdge(int u, int v) { edges[u].push_back(v); revEdges[v].push_back(u); } void dfs1(int u) { mark[u] = 1; for (auto &v : edges[u]) { if (mark[v] == 0) { dfs1(v); } } st.push_back(u); } void dfs2(int u, int k) { group[u] = k; for (auto &v : revEdges[u]) { if (group[v] == 0) { dfs2(v, k); } } } void solve() { for (int i = 0; i < n; i++) { if (mark[i] == 0) { dfs1(i); } } int k = 0; for (int i = st.size() - 1; i >= 0; i--) { int u = st[i]; if (group[u] == 0) { k++; dfs2(u, k); } } } void answer(int m) { for (int i = 0; i < 2 * m; i += 2) { if (group[i] == group[i | 1]) { printf( NO ); return; } } printf( YES n ); for (int i = 0; i < 2 * m; i += 2) { printf( %d n , (group[i] > group[i | 1]) ? 1 : 2); } } }; int main() { int n; scanf( %d , &n); vector<vector<int> > edges(n + 1); for (int i = 1; i < n; i++) { int u, v; scanf( %d %d , &u, &v); edges[u].push_back(v); edges[v].push_back(u); } int m; scanf( %d , &m); GraphBuilder builder(m, &edges); SAT solver(builder.k, builder.edges); solver.solve(); solver.answer(m); } |
#include <bits/stdc++.h> using namespace std; const int mxn = 257; string rec[mxn][3]; bool been[mxn][3]; inline int G(string s) { int t = 0; for (int i = 0; i < s.size(); ++i) t = t * 2 + s[i] - 0 ; return t; } priority_queue<pair<int, int> > pq; bool changed; string Min(string a, string b) { if (a.size() != b.size()) { if (a.size() < b.size()) return a; else return b; } return min(a, b); } inline void upd(string& a, string b) { if (a == b) return; if (Min(a, b) == b) { changed = 1; a = b; } } inline void prep() { int n = 256; for (int i = 0; i < n; ++i) for (int j = 0; j < 3; ++j) rec[i][j] = zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz ; rec[G( 00001111 )][0] = x ; rec[G( 00110011 )][0] = y ; rec[G( 01010101 )][0] = z ; for (changed = 1; changed;) { changed = 0; for (int i = 0; i < n; ++i) for (int j = 0; j < 2; ++j) upd(rec[i][j + 1], rec[i][j]); for (int i = 0; i < n; ++i) upd(rec[i ^ 255][0], ! + rec[i][0]); for (int i = 0; i < n; ++i) for (int j = 0; j < n; ++j) upd(rec[i & j][1], rec[i][1] + & + rec[j][0]), upd(rec[i | j][2], rec[i][2] + | + rec[j][1]); for (int i = 0; i < n; ++i) upd(rec[i][0], ( + rec[i][2] + ) ); } } int main() { ios_base::sync_with_stdio(false); cin.tie(0), cout.tie(0); int T = 1; cin >> T; prep(); for (; T--;) { string s; cin >> s; int t = G(s); cout << Min(Min(rec[t][0], rec[t][1]), rec[t][2]) << n ; } } |
#include <bits/stdc++.h> using namespace std; const int maxn = 4e6 + 5; const int inf = 0x3f3f3f3f; int main() { int n; scanf( %d , &n); char a; getchar(); int ans = 0; for (int i = 1; i <= n; i++) { scanf( %c , &a); if (a == - ) ans--; else ans++; ans = max(0, ans); } printf( %d n , ans); } |
#include <bits/stdc++.h> using namespace std; int main() { int n, s = 0; cin >> n; int a[n]; for (int x = 0; x < n; ++x) { cin >> a[x]; s += a[x] * (x + 1); } cout << s << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; char s[200005]; int n, k; int main() { scanf( %d%d , &n, &k); scanf( %s , s); if (n == 1) { if (k == 0) printf( %c n , s[0]); else printf( 0 n ); } else { if (k == 0) printf( %s n , s); else { if (s[0] != 1 ) k--; s[0] = 1 ; int t = 1; while (t < n && k) { if (s[t] != 0 ) { s[t] = 0 ; k--; } t++; } printf( %s , s); } } return 0; } |
#include <bits/stdc++.h> #pragma comment(linker, /STACK:1024000000,1024000000 ) using namespace std; const long long LINF = (1LL << 62); const int INF = 1 << 30; const int NS = 100010; const int MS = 19; const int MOD = 1000000007; const double PI = acos(-1.0); int n, m, q, h[NS]; pair<int, int> s[NS]; int L[NS], R[NS]; int solve() {} int main() { while (~scanf( %d %d , &n, &q)) { m = n - 1; for (int i = 1; i <= n; i++) { scanf( %d , &h[i]); if (i > 1) { h[i - 1] = abs(h[i - 1] - h[i]); s[i - 1] = make_pair(h[i - 1], i - 1); } } sort(s + 1, s + m + 1); set<int> idSet; idSet.insert(0); idSet.insert(n); for (int i = m; i >= 1; i--) { int pos = s[i].second; idSet.insert(pos); __typeof(idSet.begin()) it = idSet.find(pos); L[pos] = *(--it); it++, it++; R[pos] = *(it); } int x, y; for (int qi = 0; qi < q; qi++) { scanf( %d %d , &x, &y); long long ans = 0; for (int i = x; i < y; i++) { int lb = i - max(L[i], x - 1); int rb = min(R[i], y) - i; ans += 1LL * h[i] * lb * rb; } printf( %I64d n , ans); } } return 0; } |
#include <bits/stdc++.h> using namespace std; const int M = 2 * 1e5 + 10; int a[M]; int main() { long long s, n, p1, c, pos1, pos2, p2, i, ans = 1, d, x, j; scanf( %I64d , &n); for (i = 0; i < n; i++) scanf( %I64d , &a[i]); if (a[0] != -1) { p1 = a[0]; pos1 = 0; c = 1; } else c = 0; s = 0; ans = 1; for (i = 1; i < n; i++) { if (i == 10) i = 10; if (c == 0) { if (a[i] != -1) { c = 1; p1 = a[i]; pos1 = i; } continue; } if (c == 1) { if (a[i] != -1) { if ((a[i] - p1) % (i - pos1) != 0) { ans++; s = i; c = 1; p1 = a[i]; pos1 = i; } else { c = 2; p2 = a[i]; pos2 = i; d = (p2 - p1) / (pos2 - pos1); x = p1 + d * (s - pos1); if (x <= 0) { ans++; c = 1; p1 = a[i]; pos1 = i; s = i; } } } continue; } d = (p2 - p1) / (pos2 - pos1); x = p1 + d * (i - pos1); if (a[i] == -1) { if (x <= 0) { ans++; c = 0; s = i; } continue; } else { if (x != a[i]) { ans++; s = i; c = 1; p1 = a[i]; pos1 = i; } } } printf( %I64d , ans); return 0; } |
#include <bits/stdc++.h> using namespace std; int gcd(int a, int b) { if (a == 0) { return b; } else { return gcd(b % a, a); } } int main() { int l_a, r_a, t_a; int l_b, r_b, t_b; int l_x, r_x, t_x; cin >> l_a >> r_a >> t_a; cin >> l_b >> r_b >> t_b; if (r_b - l_b < r_a - l_a) { l_x = l_b, r_x = r_b, t_x = t_b; l_b = l_a, r_b = r_a, t_b = t_a; l_a = l_x, r_a = r_x, t_a = t_x; } int g = gcd(t_a, t_b); int c = l_b - l_a; int c_1, c_2; if (l_b - l_a >= 0) { c_1 = c % g; c_2 = (-(c % g - g)) % g; } else { c_1 = g - (-c) % g; c_2 = (-(c_1 - g)) % g; } int answer = r_a - l_a + 1 - c_1; answer = max(answer, min(r_b - l_b + 1 - c_2, r_a - l_a + 1)); cout << max(answer, 0); } |
#include <bits/stdc++.h> using namespace std; const long long N = 10000; const long long M = 60; vector<long long> v; long long n, first, t, a[N], second, cn, p; void val(long long first) { long long second, z; second = first; first = upper_bound((v).begin(), (v).end(), first) - v.begin() - 1; ; second = (second - v[first] + a[first]) % v[first]; z = second + v[first]; while (1) { second = z - v[first]; p = (second - a[first] >= 0) ? (v[first] + (second - a[first])) : (v[first] * 2 - (a[first] - second)); cout << p << ; if (p == 1) break; first--; z >>= 1; } } int main() { cin >> n; for (long long i = (long long)0; i <= (long long)M; i++) v.push_back((1LL << i)); for (long long i = (long long)1; i <= (long long)n; i++) { cin >> t; if (t <= 2) { cin >> first >> second; first = upper_bound((v).begin(), (v).end(), first) - v.begin() - 1; ; for (long long j = (long long)first; j <= (long long)M; j++) { a[j] += (second % v[j]) * (1LL << (j - first)); if (a[j] < 0) a[j] %= v[j], a[j] += v[j]; a[j] %= v[j]; if (t == 1) break; } } else { cn++; cin >> first; val(first); cout << << n ; } } } |
#include <bits/stdc++.h> #pragma GCC optimize( O3 ) #pragma GCC optimize( Ofast,no-stack-protector ) using namespace std; void err(istream_iterator<string> it) {} template <typename T, typename... Args> void err(istream_iterator<string> it, T a, Args... args) { cerr << *it << = << a << n ; err(++it, args...); } function<void(void)> ____ = []() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); }; template <typename T> vector<T> &operator<<(vector<T> &__container, T x) { __container.push_back(x); return __container; } template <typename T> ostream &operator<<(ostream &out, vector<T> &__container) { for (T _ : __container) out << _ << ; return out; } void sci() {} template <typename... Args> void sci(int &x, Args &...args) { scanf( %d , &x); sci(args...); } void scl() {} template <typename... Args> void scl(long long int &x, Args &...args) { scanf( %lld , &x); scl(args...); } const int MAXN = 2e5 + 7; double ret; int rt; int n, w[MAXN], root, sz[MAXN], maxsz[MAXN]; double derivative[MAXN]; bool vis[MAXN]; vector<pair<int, int> > G[MAXN]; void findroot(int u, int par, int tot) { sz[u] = 1; maxsz[u] = 0; for (auto &e : G[u]) { int v = e.first, c = e.second; if (vis[v] or v == par) continue; findroot(v, u, tot); sz[u] += sz[v]; ((maxsz[u]) = (maxsz[u]) > (sz[v]) ? (maxsz[u]) : (sz[v])); } ((maxsz[u]) = (maxsz[u]) > (tot - sz[u]) ? (maxsz[u]) : (tot - sz[u])); if (maxsz[u] < maxsz[root]) root = u; } double cost; void dfs(int u, int par, int wt) { cost += pow(wt, 1.5) * w[u]; derivative[u] = w[u] * 1.5 * pow(wt, 0.5); for (auto &e : G[u]) { int v = e.first, c = e.second; if (v == par) continue; dfs(v, u, wt + c); derivative[u] += derivative[v]; } } void divide(int u) { if (vis[u]) return; vis[u] = true; cost = 0; double sd = 0; for (auto &e : G[u]) { int v = e.first, c = e.second; dfs(v, u, c); sd += derivative[v]; } if (cost < ret) ret = cost, rt = u; for (auto &e : G[u]) { int v = e.first; if (sd - 2 * derivative[v] >= 0) continue; root = 0; findroot(v, u, sz[v]); divide(root); return; } } void solve() { sci(n); for (int i = 1; i <= n; i++) sci(w[i]); for (int i = 1; i < n; i++) { int u, v, c; sci(u, v, c); G[u] << pair<int, int>(v, c); G[v] << pair<int, int>(u, c); } ret = LLONG_MAX; maxsz[root = 0] = 0x3f3f3f3f; findroot(1, 0, n); divide(root); cout << rt << << fixed << setprecision(10) << ret << n ; } int main() { solve(); return 0; } |
#include <bits/stdc++.h> using namespace std; const int mod = 998244353, maxn = 5e5 + 79; void upd(int& a, const int& b) { a = (a + b) % mod; } int mul(const int& a, const int& b) { return (a * 1ll * b) % (long long)mod; } vector<vector<int> > dp(maxn, vector<int>(2, 0)); vector<vector<int> > g(maxn); vector<int> pw2(maxn, 1); int sum = 0, n; int dfs(int u, int p = -1) { dp[u][0] = 1; int e = 0; for (int v : g[u]) { if (v == p) continue; e += 1 + dfs(v, u); vector<int> dp2(2, 0); upd(dp2[1], mul(dp[u][0], dp[v][0])); upd(sum, mul(2, mul(mul(dp[u][0], dp[v][0]), pw2[n - 1 - e]))); upd(dp2[0], mul(dp[u][0], dp[v][1])); upd(dp2[1], mul(dp[u][1], dp[v][0])); upd(dp2[1], mul(dp[u][1], dp[v][1])); upd(dp2[0], mul(dp[u][0], dp[v][0])); upd(dp2[0], mul(dp[u][0], dp[v][1])); upd(dp2[1], mul(dp[u][1], dp[v][0])); upd(dp2[1], mul(dp[u][1], dp[v][1])); dp[u] = dp2; } return e; } int main() { ios::sync_with_stdio(false); cin.tie(0); for (int i = 1; i < maxn; i++) pw2[i] = mul(pw2[i - 1], 2); cin >> n; for (int i = 0, u, v; i < n - 1; i++) { cin >> u >> v; g[--u].push_back(--v), g[v].push_back(u); } dfs(0); cout << sum << n ; return 0; } |
#include <bits/stdc++.h> using namespace std; int sum[1000000 + 10][27]; char c1[1000000 + 10], c2[1000000 + 10]; long long n, m; long long len1, len2; long long gcd(long long a, long long b) { long long t = a; while (b) { a = b; b = t % b; t = a; } return a; } int main() { cin >> n >> m; scanf( %s%s , c1, c2); len1 = strlen(c1), len2 = strlen(c2); long long t = gcd(len1, len2); long long k = n / (len2 / t); long long res = 0; for (int i = 0; i < len2; ++i) sum[i % t][c2[i] - a ]++; for (int i = 0; i < len1; ++i) for (int j = 0; j < 26; ++j) if (j != c1[i] - a ) res += sum[i % t][j]; res *= k; cout << res << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { string x; cin >> x; int c1 = 0, c0 = 0; bool f = 0; for (int i = 0; i < x.size(); i++) { if (x[i] == 0 ) { c0++; } else if (x[i] == 1 ) { c1++; } if (c0 < 7 && x[i] == 1 ) { c0 = 0; } if (c1 < 7 && x[i] == 0 ) { c1 = 0; } } if (c1 >= 7 || c0 >= 7) { cout << YES << endl; } else { cout << NO << endl; } } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.