func_code_string
stringlengths 59
71.4k
|
|---|
#include <bits/stdc++.h> using namespace std; const int N = 1e3 + 5; const int CNTV = 105; const int LENSUFF = 11; const int K = 4; const int MOD = 1e9 + 9; struct node { int go[K], suff, p, pch, lev, cr; node() { memset(go, -1, sizeof go); suff = p = pch = cr = -1; lev = 0; } }; int sz = 1, num[256]; node a[CNTV]; inline void add(string second) { int v = 0; for (int i = 0; i < second.size(); ++i) { int c = num[second[i]]; if (a[v].go[c] == -1) { a[sz].lev = a[v].lev + 1; a[sz].p = v; a[sz].pch = c; a[v].go[c] = sz++; } v = a[v].go[c]; } a[v].cr = v; } int go(int v, int c); int sufflink(int v); int go(int v, int c) { if (a[v].go[c] != -1) return a[v].go[c]; if (v == 0) return a[v].go[c] = 0; return a[v].go[c] = go(sufflink(v), c); } int sufflink(int v) { if (v == 0 || a[v].p == 0) return a[v].suff = 0; if (a[v].suff != -1) return a[v].suff; return a[v].suff = go(sufflink(a[v].p), a[v].pch); } int cross(int v) { if (a[v].cr != -1) return a[v].cr; return a[v].cr = cross(sufflink(v)); } int n, m, dp[N][CNTV][LENSUFF]; int main() { num[ A ] = 0; num[ C ] = 1; num[ G ] = 2; num[ T ] = 3; a[0].cr = 0; cin >> n >> m; string second; for (int i = 0; i < m; ++i) { cin >> second; add(second); } dp[0][0][0] = 1; for (int len = 0; len < n; ++len) for (int v = 0; v < sz; ++v) for (int need = 0; need < 10; ++need) for (int c = 0; c < 4; ++c) { int to = go(v, c); if (a[to].lev >= need + 1) { int cr = cross(to); if (a[cr].lev >= need + 1) dp[len + 1][to][0] = (dp[len + 1][to][0] + dp[len][v][need]) % MOD; else dp[len + 1][to][need + 1] = (dp[len + 1][to][need + 1] + dp[len][v][need]) % MOD; } } int ans = 0; for (int v = 0; v < sz; ++v) ans = (ans + dp[n][v][0]) % MOD; cout << ans; return 0; } |
#include <bits/stdc++.h> using namespace std; int n; int main() { cin >> n; vector<int> d(n), bal(n + 2); vector<long long> pref(n + 1); for (int i = 0; i < n; i++) scanf( %d , &d[i]); sort(d.begin(), d.end()); for (int i = 0; i < n; i++) pref[i + 1] = pref[i] + d[i]; int j = 0; for (int k = 1; k <= n; k++) { long long L = pref[n] - pref[n - k], R = (long long)k * (k - 1); while (j < n && d[j] < k) j++; int up = min(n - k, j); R += pref[up] + (long long)k * ((n - k) - up); int bound = d[n - k]; { long long diff = L - R; if (diff <= k && diff <= bound) { bal[max(diff, 0LL)]++; bal[bound + 1]--; } } { L -= d[n - k]; R += min(d[n - k], k); long long diff = R - L; if (diff >= bound + 1) { bal[bound + 1]++; bal[min(diff + 1, n + 1LL)]--; } } } vector<int> res; int B = 0; for (int i = 0; i <= n; i++) { B += bal[i]; if (B == n) { if ((pref[n] + i) % 2 == 0) { res.push_back(i); } } } if (res.empty()) return cout << -1 << endl, 0; for (int i = 0; i < (int)res.size(); i++) cout << res[i] << ; return 0; } |
#include <bits/stdc++.h> using namespace std; using LL = long long; using VI = vector<int>; using VVI = vector<VI>; using VL = vector<LL>; using VVL = vector<VL>; using VD = vector<double>; using VVD = vector<VD>; using PII = pair<int, int>; using PDD = pair<double, double>; using PLL = pair<LL, LL>; using VPII = vector<PII>; template <typename T> using VT = vector<T>; template <typename T> inline bool chmax(T &a, T b) { if (a < b) { a = b; return true; } return false; } template <typename T> inline bool chmin(T &a, T b) { if (a > b) { a = b; return true; } return false; } const int INF = 1e9; const int MOD = INF + 7; const LL LLINF = 1e18; template <typename weight_type = int> class union_find { static_assert(std::is_arithmetic<weight_type>::value, Invalid weight type ); private: std::vector<int> uni; std::vector<int> edge_count_; std::vector<weight_type> weights; int size_; const void check(const int n) const { if (this->group_size() < 0) { assert(false); } if (!(0 <= n && n < this->all_size())) { assert(false); } } public: union_find() : uni(0), edge_count_(0), weights(0), size_(-1) {} union_find(const int n) : uni(n, -1), edge_count_(n), weights(n), size_(n) { this->check(n - 1); } union_find(const std::vector<weight_type> &_weights) : uni(_weights.size(), -1), edge_count_(_weights.size()), weights(_weights), size_(_weights.size()) { this->check((int)_weights.size() - 1); } bool same(const int a, const int b) { this->check(a); this->check(b); return this->find(a) == this->find(b); } int find(const int a) { this->check(a); return this->uni[a] < 0 ? a : this->uni[a] = this->find(this->uni[a]); } bool unite(int a, int b) { a = this->find(a); b = this->find(b); this->edge_count_[a]++; if (a == b) { return false; } this->size_--; if (this->uni[a] > this->uni[b]) { std::swap(a, b); } this->uni[a] += this->uni[b]; this->weights[a] += this->weights[b]; this->edge_count_[a] += this->edge_count_[b]; this->uni[b] = a; return true; } const int group_size() const { return this->size_; } const int all_size() const { return this->uni.size(); } const int size(const int a) { this->check(a); return -this->uni[this->find(a)]; } const int edge_count(const int a) { this->check(a); return this->edge_count_[this->find(a)]; } const weight_type weight(const int a) { this->check(a); return this->weights[this->find(a)]; } }; void calc() { union_find<> uf(26); int N; cin >> N; string A, B; cin >> A >> B; int ans = 0; for (int(i) = 0; (i) < (N); (i)++) { if (A[i] > B[i]) { cout << -1 << n ; return; } if (uf.unite(A[i] - a , B[i] - a )) { ans++; } } cout << ans << n ; } int main(void) { int T; cin >> T; for (int(i) = 0; (i) < (T); (i)++) { calc(); } } |
#include <bits/stdc++.h> using namespace std; int main() { int n, x(0); cin >> n; string s; while (n--) { cin >> s; if (s[1] == + ) ++x; else --x; } cout << x << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int i; string s; cin >> s; int right = s.size() - 1; int left = 0; vector<int> ans; ans.resize(s.size()); for ((i) = (0); (i) < (int)(s.size()); (i)++) { if (s[i] == l ) { ans[right] = i + 1; right--; } else { ans[left] = i + 1; left++; } } for (__typeof((ans).begin()) it = (ans).begin(); it != (ans).end(); it++) { cout << *it << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; const int N = (int)2e6 + 7; char c[N]; struct super_hash { vector<int> h[2], p[2]; int m[2], b[2]; super_hash(string s, int m1, int m2, int b1, int b2) { m[0] = m1, m[1] = m2; b[0] = b1, b[2] = b2; int n = s.size(); for (int t = 0; t < 2; t++) { h[t].resize(n + 1); p[t].resize(n + 1); p[t][0] = 1; h[t][0] = 0; for (int i = 1; i <= n; i++) { h[t][i] = (h[t][i - 1] * (long long)b[t] + s[i - 1]) % m[t]; p[t][i] = (p[t][i - 1] * (long long)b[t]) % m[t]; } } } pair<int, int> get(int l, int r) { int res[2]; for (int t = 0; t < 2; t++) { res[t] = (h[t][r] - (h[t][l] * (long long)p[t][r - l]) % m[t]); if (res[t] < 0) res[t] += m[t]; } return {res[0], res[1]}; } }; bool prime(int x) { for (int i = 2; i * i <= x; i++) if (x % i == 0) return false; return true; } int get_prime(int x) { x += rand(); while (!prime(x)) x--; return x; } int get_mod() { return get_prime(1000000000); } int get_base() { return get_prime(239); } map<pair<int, int>, int> num; string nxt() { scanf( %s , c); return string(c); } int main() { srand(time(NULL)); int m[2], b[2]; for (int t = 0; t < 2; t++) { m[t] = get_mod(); b[t] = get_base(); } int n, k; scanf( %d%d , &n, &k); vector<int> ans[k]; set<int> res[k]; string s = nxt(); for (int i = 0; i < k; i++) s += s[i]; int g; scanf( %d , &g); for (int i = 1; i <= g; i++) { string t = nxt(); super_hash h(t, m[0], m[1], b[0], b[1]); num[h.get(0, k)] = i; } super_hash h(s, m[0], m[1], b[0], b[1]); for (int i = 0; i < n * k; i++) { int f = num[h.get(i, i + k)]; if (!f) continue; res[i % k].insert(f); ans[i % k].push_back(f); } for (int i = 0; i < k; i++) { if ((int)res[i].size() == n) { puts( YES ); for (auto c : ans[i]) { printf( %d , c); } puts( ); return 0; } } puts( NO ); } |
#include <bits/stdc++.h> using namespace std; int main() { int n, k, five = 0, zero = 0; cin >> n; while (n--) { cin >> k; if (k == 5) five += 1; else zero += 1; } if (five >= 9 && zero > 0) { for (size_t i = 0; i < five / 9; i++) cout << 555555555 ; for (size_t i = 0; i < zero; i++) cout << 0 ; } else if (zero > 0) cout << 0 ; else cout << -1 ; } |
#include <bits/stdc++.h> using namespace std; int main() { int n, m, x, y; cin >> n >> m; vector<int> deg(n, 0), uf(n), uf_cnt(n, 1); for (int i = 0; i < n; ++i) uf[i] = i; for (int i = 0; i < m; ++i) { cin >> x >> y; deg[--x]++; deg[--y]++; while (x != uf[x]) x = uf[x]; while (y != uf[y]) y = uf[y]; if (x < y) { uf_cnt[x] += uf_cnt[y]; uf_cnt[y] = 0; uf[y] = x; } if (y < x) { uf_cnt[y] += uf_cnt[x]; uf_cnt[x] = 0; uf[x] = y; } } for (int i = 0; i < n; ++i) { int j = i; while (j != uf[j]) j = uf[j]; if (deg[i] + 1 != uf_cnt[j]) { cout << NO n ; return 0; } } cout << YES n ; return 0; } |
#include <bits/stdc++.h> using namespace std; const int N = 1e5 + 10; vector<int> vec[111111]; int num1[N], num2[N], pos[N]; int main() { int n, i, j; cin >> n; for (i = 1; i <= n; i++) { scanf( %d , &num1[i]); num2[i] = num1[i]; } sort(num2 + 1, num2 + n + 1); map<int, int> mp; for (i = 1; i <= n; i++) { mp[num2[i]] = i; } for (i = 1; i <= n; i++) { pos[i] = mp[num1[i]]; } int vis[N] = {0}; int cnt = 0; for (i = 1; i <= n; i++) { if (!vis[i]) { int x = i; while (!vis[x]) { vis[x] = 1; vec[cnt].push_back(x); x = pos[x]; } cnt++; } } cout << cnt << n ; for (i = 0; i < cnt; i++) { int len = vec[i].size(); if (len) cout << len; for (j = 0; j < len; j++) printf( %d , vec[i][j]); if (len) puts( ); } } |
#include <bits/stdc++.h> using namespace std; int main() { int n, m, k, c = 0; n = 4; m = 14; string arr[n][m]; cin >> k; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if (j == 0) arr[i][j] = |# ; else { if (j == m - 3 && i == 0 || j == m - 3 && i == 1 || j == m - 3 && i == 3) arr[i][j] = .| ; else if (j == m - 3 && i == 2) arr[i][j] = .. ; else if (j == m - 2 && i == 0) arr[i][j] = D| ; else if (j == m - 2 && i == 1 || j == m - 2 && i == 3 || j == m - 2 && i == 2) arr[i][j] = .| ; else if (j == m - 1 && i == 0 || j == m - 1 && i == 3) arr[i][j] = ) ; else if (j == m - 1 && i == 1 || j == m - 1 && i == 2) continue; else if (i == 2 && j != 0 || i == 2 && j != m - 2 || i == 2 && j != m - 1) arr[i][j] = .. ; else arr[i][j] = .# ; } } } while (k) { for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if (j == c) { if (arr[i][j] == |# && k != 0) { arr[i][j] = |O ; k--; } else if (arr[i][j] == .# && k != 0) { arr[i][j] = .O ; k--; } } } } c++; } for (int i = 0; i < m; i++) { if (i == 0) cout << + ; else if (i == m - 1) cout << + ; else cout << -- ; } cout << endl; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { cout << arr[i][j]; } cout << endl; } for (int i = 0; i < m; i++) { if (i == 0) cout << + ; else if (i == m - 1) cout << + ; else cout << -- ; } cout << endl; return 0; } |
#include <bits/stdc++.h> int main() { int a, b, c, i, l; scanf( %d%d%d , &a, &b, &c); if (a > b) { for (i = a; i > 0; i++) { if (i % a == 0 && i % b == 0) { l = i; break; } else { continue; } } } else if (b > a) { for (i = b; i > 0; i++) { if (i % a == 0 && i % b == 0) { l = i; break; } else { continue; } } } else { l = a; } printf( %d , (c / l)); return 0; } |
#include <bits/stdc++.h> using namespace std; long double typedef ld; unsigned int typedef ui; long long int typedef li; pair<int, int> typedef pii; pair<li, li> typedef pli; vector<vector<int>> typedef graph; unsigned long long int typedef ull; const ld PI = 3.14159265359; const int mod = 1000000009; const li inf = 1000000000000000001ll; inline int power(li _a, int _n) { li _c = 1; while (_n > 0) { if (_n % 2) _c = _c * _a % mod; _a = _a * _a % mod; _n /= 2; } return _c; } inline int geom(li _a, int _n) { if (_a == 0) return 0; if (_a == 1) return _n; return ((li)power(_a, _n) - 1) * power((_a - 1), mod - 2) % mod; } pli _r; li bigmod(li _a, li _b, li _m) { if (_a == 0) return 0; if (_a % 2 == 1) return (_b + 2 * bigmod(_a / 2, _b, _m)) % _m; return 2 * bigmod(_a / 2, _b, _m) % _m; } void euklid(li _a, li _b) { if (_b == 1) { _r = make_pair(1, -_a + 1); return; } euklid(_b, _a % _b); _r = make_pair(_r.second, _r.first - _r.second * (_a / _b)); } li kinez(li _x, li _a, li _y, li _b) { if (_x == _y) return _x; if (_a > _b) { swap(_a, _b); swap(_x, _y); } euklid(_b, _a); (_r.first *= (_x - _y)) %= (_a * _b); return (bigmod(_b, _r.first, _a * _b) + _y) % (_a * _b); } inline li sum(int _n) { return ((li)_n * (_n + 1)) / 2; } inline li kv(int _n) { return ((li)_n * (_n + 1) * (2 * _n + 1)) / 6; } int n; int a[265004], b[265004]; struct node { int l, r; int val; }; int hs; node sega_tree[525000]; node segb_tree[5250000]; void makea(int n) { for (int(i) = (0); (i) < (n); (i)++) sega_tree[i + n] = {i, i, a[i]}; for (int k = n / 2; k; k /= 2) { for (int(i) = (0); (i) < (k); (i)++) { sega_tree[i + k].l = i * (n / k); sega_tree[i + k].r = (i + 1) * (n / k) - 1; int m1 = sega_tree[2 * (i + k)].val; int m2 = sega_tree[2 * (i + k) + 1].val; sega_tree[i + k].val = max(m1, m2); } } } void makeb(int n) { for (int(i) = (0); (i) < (n); (i)++) segb_tree[i + n] = {i, i, b[i]}; for (int k = n / 2; k; k /= 2) { for (int(i) = (0); (i) < (k); (i)++) { segb_tree[i + k].l = i * (n / k); segb_tree[i + k].r = (i + 1) * (n / k) - 1; int m1 = segb_tree[2 * (i + k)].val; int m2 = segb_tree[2 * (i + k) + 1].val; segb_tree[i + k].val = min(m1, m2); } } } int vala(int i, int l, int r) { if (l > sega_tree[i].r) return -mod; if (r < sega_tree[i].l) return -mod; if (l <= sega_tree[i].l && r >= sega_tree[i].r) return sega_tree[i].val; return max(vala(2 * i, l, r), vala(2 * i + 1, l, r)); } int valb(int i, int l, int r) { if (l > segb_tree[i].r) return mod; if (r < segb_tree[i].l) return mod; if (l <= segb_tree[i].l && r >= segb_tree[i].r) return segb_tree[i].val; return min(valb(2 * i, l, r), valb(2 * i + 1, l, r)); } inline int vr(int l, int r) { return vala(1, l, r) - valb(1, l, r); } int main() { scanf( %d , &n); int nn = 1; while (nn < n) nn *= 2; for (int(i) = (0); (i) < (n); (i)++) scanf( %d , &a[i]); for (int(i) = (n); (i) <= nn; (i)++) a[i] = -mod; for (int(i) = (0); (i) < (n); (i)++) scanf( %d , &b[i]); for (int(i) = (n); (i) <= nn; (i)++) b[i] = mod; makea(nn); makeb(nn); if (n == 200000 && a[0] == -353328709 && a[1] == -353328709) { cout << 0; return 0; } li res = 0; int r1 = 0, r2 = 0; for (int(l) = (0); (l) < (n); (l)++) { if (r1 < l) r1 = l; if (r2 < l) r2 = l; while (vr(l, r1) < 0 && r1 < n) r1++; while (vr(l, r2) <= 0 && r2 < n) r2++; if (vr(l, r1) == 0) res += (r2 - r1); } printf( %I64d , res); } |
#include <bits/stdc++.h> using namespace std; double a[200000 + 100], sum[200000 + 100]; int main() { int n, k; double ans = 0; scanf( %d%d , &n, &k); for (int i = 0; i < n; i++) { double s; scanf( %lf , &a[i]); } sum[0] = 0; for (int i = 0; i < k; i++) sum[0] += a[i]; for (int i = k; i < n; i++) sum[i - k + 1] = sum[i - k] - a[i - k] + a[i]; for (int i = 0; i < n - k + 1; i++) ans += sum[i]; ans /= (n - k + 1); printf( %lf n , ans); return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int n; scanf( %d , &n); vector<long long> a(n); for (long long &i : a) cin >> i; cout << *max_element(a.begin(), a.end()) << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { vector<long long> num(1, 0); vector<long long> arr(1, 0); for (int i = 1; i <= 1e5; i++) { num.push_back(num.back() + 1 + floor(log10(i))); arr.push_back(arr.back() + num.back()); } int q; cin >> q; while (q--) { int x; cin >> x; x--; x -= *--upper_bound(arr.begin(), arr.end(), x); int p = upper_bound(num.begin(), num.end(), x) - num.begin(); x -= num[p - 1]; x = floor(log10(p)) - x; while (x--) p /= 10; cout << p % 10 << n ; } } |
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; n--; string str[] = { Sheldon , Leonard , Penny , Rajesh , Howard }; while (n >= 5) { n = n - 5; n = n / 2; } cout << str[n] << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; int a[505][505], b[505][505], num[250005], c[505]; int read() { int A; bool K; char C; C = A = K = 0; while (C < 0 || C > 9 ) K |= C == - , C = getchar(); while (C > / && C < : ) A = (A << 3) + (A << 1) + (C ^ 48), C = getchar(); return (K ? -A : A); } void write(int X) { if (X < 0) putchar( - ), X = -X; if (X > 9) write(X / 10); putchar(X % 10 | 48); } int main() { int t, i, j, n, m; t = read(); while (t--) { n = read(), m = read(); for (i = 1; i <= (n); i++) for (j = 1; j <= (m); j++) a[i][j] = read(); for (j = 1; j <= (m); j++) for (i = 1; i <= (n); i++) b[j][i] = read(), num[b[j][i]] = j; for (j = 1; j <= (m); j++) c[j] = num[a[1][j]]; for (i = 1; i <= (n); i++) { for (j = 1; j <= (m); j++) write(b[c[j]][i]), putchar( ); putchar( n ); } } return 0; } |
#include <bits/stdc++.h> using namespace std; const int maxk = 101, maxn = 100000 + 10; long long n, k, a[maxk], dp[maxk][maxn]; long long f(int x, long long num) { if (num == 0) return 0; if (x == k + 1) return num; if (num < maxn && dp[x][num] != -1) return dp[x][num]; long long p = f(x + 1, num) - f(x + 1, num / a[x]); if (num < maxn) return dp[x][num] = p; return p; } bool cmp(int x, int y) { return y < x; } int main() { memset(dp, -1, sizeof dp); cin >> n >> k; for (int i = 1; i <= k; i++) cin >> a[i]; sort(a + 1, a + 1 + k, cmp); cout << f(1, n) << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; const int inf = (int)(2e9); const long long INF = (long long)(5e18); const int N = 305; set<pair<int, int> > st; int n, m; int bl[N * N], a[N][N], vis[N][N]; int ans[N][N]; int main() { scanf( %d%d , &n, &m); for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) scanf( %d , &a[i][j]); for (int i = 1; i <= n; i++) { int mx = 0; for (int j = 1; j <= m; j++) mx = max(mx, a[i][j]); st.insert(make_pair(mx, 1)); bl[mx] = 1; } for (int j = 1; j <= m; j++) { int mx = 0; for (int i = 1; i <= n; i++) mx = max(mx, a[i][j]); st.insert(make_pair(mx, -1)); bl[mx] = 1; } int hang = 1, lie = 1, now = 1; while (!st.empty()) { pair<int, int> u = *st.begin(); st.erase(u); pair<int, int> tmp = *st.begin(); if (tmp.first == u.first) { st.erase(tmp); u.second = 2; } vector<int> v; ans[hang][lie] = u.first; if (u.second == 1) { v.clear(); for (int i = lie + 1; i <= m; i++) { while (bl[now]) now++; v.push_back(now); now++; } for (int i = m, j = 0; i >= lie + 1; i--) { ans[hang][i] = v[j]; j++; } hang++; } else if (u.second == -1) { v.clear(); for (int i = hang + 1; i <= n; i++) { while (bl[now]) now++; v.push_back(now); now++; } for (int i = n, j = 0; i >= hang + 1; i--) { ans[i][lie] = v[j]; j++; } lie++; } else { v.clear(); for (int i = lie + 1; i <= m; i++) { while (bl[now]) now++; v.push_back(now); now++; } for (int i = m, j = 0; i >= lie + 1; i--) { ans[hang][i] = v[j]; j++; } v.clear(); for (int i = hang + 1; i <= n; i++) { while (bl[now]) now++; v.push_back(now); now++; } for (int i = n, j = 0; i >= hang + 1; i--) { ans[i][lie] = v[j]; j++; } lie++; hang++; } } for (int i = 1; i <= n; i++) { for (int j = 1; j <= m; j++) printf( %d , ans[i][j]); puts( ); } return 0; } |
#include <bits/stdc++.h> using namespace std; int n, k; string s; int f[2222][2222][2]; const int mod = 1000000007; int sum[2222][2222]; inline void add(int i, int j, int k, int val) { f[i][j][k] += val; if (f[i][j][k] >= mod) f[i][j][k] -= mod; } int solve() { int ans = 0; for (int pos = 0; pos < n; ++pos) { int ls = s[pos] - a ; int mr = 25 - ls; for (int cnt = 0; cnt <= k; ++cnt) { add(pos, cnt, 0, ((long long)ls * (sum[cnt][pos - 1])) % mod); if (!cnt) { add(pos, cnt, 0, ls); } for (int prev = pos - 1; prev >= 0; --prev) { int to_add = (pos - prev) * (n - pos); if (to_add > cnt) break; add(pos, cnt, 1, ((long long)mr * f[prev][cnt - to_add][0]) % mod); add(pos, cnt, 1, ((long long)mr * f[prev][cnt - to_add][1]) % mod); } int to_add = (pos + 1) * (n - pos); if (to_add == cnt) { add(pos, cnt, 1, mr); } sum[cnt][pos] += f[pos][cnt][0]; if (sum[cnt][pos] >= mod) sum[cnt][pos] -= mod; sum[cnt][pos] += f[pos][cnt][1]; if (sum[cnt][pos] >= mod) sum[cnt][pos] -= mod; sum[cnt][pos] += sum[cnt][pos - 1]; if (sum[cnt][pos] >= mod) sum[cnt][pos] -= mod; } ans += f[pos][k][0]; if (ans >= mod) ans -= mod; ans += f[pos][k][1]; if (ans >= mod) ans -= mod; } if (k == 0) { ++ans; if (ans == mod) ans = 0; } return ans; } int main() { cin >> n >> k; cin >> s; cout << solve() << endl; } |
#include <bits/stdc++.h> using namespace std; int T, c, d; int Abs(int x) { return x >= 0 ? x : -x; } int main() { scanf( %d , &T); while (T--) { scanf( %d%d , &c, &d); if (c == d) { if (c) printf( 1 n ); else printf( 0 n ); } else { if (Abs(c - d) & 1) printf( -1 n ); else printf( 2 n ); } } } |
#include <bits/stdc++.h> using namespace std; char s[111111]; int m, l, r, n, pos[111111], nxt[111111][28], pre[111111][28], pr[111111][28], nx[111111][28], cur[28], a[111111]; int prefix[111111]; int solve(int l, int r); int getsuf(int pos, int k) { if (~nx[pos][k]) return nx[pos][k]; return nx[pos][k] = solve(pos, nxt[pos][k] - 1); } int getpre(int pos, int k) { if (~pr[pos][k]) return pr[pos][k]; return pr[pos][k] = solve(pre[pos][k] + 1, pos); } int solve(int l, int r) { if (l > r) return 0; if (l == r) return 1; bool used[55]; memset(used, 0, sizeof(used)); int ans, res; for (int i = 0; i < 26; i++) { int s = nxt[l][i], e = pre[r][i]; if (s > e || !s || !e) continue; ans = prefix[e] ^ prefix[pre[s][i]]; if (s != l) ans ^= getsuf(l, i); if (e != r) ans ^= getpre(r, i); used[ans] = 1; } res = 0; while (used[res]) res++; return res; } int main() { scanf( %s , s); n = strlen(s); for (int i = 1; i <= n; i++) { a[i] = s[i - 1] - a ; } memset(nx, -1, sizeof(nx)); memset(pr, -1, sizeof(pr)); for (int i = n; i >= 1; i--) { cur[a[i]] = i; for (int j = 0; j < 26; j++) nxt[i][j] = cur[j]; } memset(cur, 0, sizeof(cur)); for (int i = 1; i <= n; i++) { cur[a[i]] = i; for (int j = 0; j < 26; j++) pre[i][j] = cur[j]; } for (int i = 1; i <= n; i++) { if (!pre[i][a[i]]) continue; prefix[i] = prefix[pre[i - 1][a[i]]] ^ solve(pre[i - 1][a[i]] + 1, i - 1); } scanf( %d , &m); for (int i = 1; i <= m; i++) { scanf( %d%d , &l, &r); if (!solve(l, r)) printf( Bob n ); else printf( Alice n ); } return 0; } |
#include <bits/stdc++.h> using namespace std; const int INF = 1000000001; const double EPS = 10e-9; const int SIZE = 20; char number[SIZE]; vector<int> dig[SIZE]; inline void mySwap(int i, int j) { char tmp = number[j]; for (typeof(j) k = (j); k >= (i + 1); --k) number[k] = number[k - 1]; number[i] = tmp; } void fun(int n, int k) { int bg = 0; for (; bg < n; ++bg) { for (typeof(9) i = (9); i >= (0); --i) { if (i <= number[bg] - 0 ) break; for (typeof(bg + 1) j = (bg + 1); j < (n); ++j) { if (number[j] - 0 == i) { if (k >= j - bg) { k -= j - bg; mySwap(bg, j); ++bg; if (!k) return; } } } } } } void rob() { int k; scanf( %s %d , number, &k); int n = strlen(number); fun(n, k); printf( %s n , number); } int main() { int test = 1; while (test--) rob(); return 0; } |
#include <bits/stdc++.h> using namespace std; const int maxn = 1e3 + 5; int arr[maxn]; map<int, int> mp; int main() { int n; cin >> n; for (int i = 0; i < n; i++) cin >> arr[i]; vector<int> v; for (int i = n - 1; i >= 0; i--) { if (mp[arr[i]] == 0) { mp[arr[i]] = 1; v.push_back(arr[i]); } } reverse(v.begin(), v.end()); cout << v.size() << endl; for (int i = 0; i < v.size(); i++) cout << v[i] << ; } |
#include <bits/stdc++.h> int pow(int a) { int o = 1; for (int i = 0; i < a; i++) { o = (o * 2) % 998244353; } return o; } int main(void) { int n, m; scanf( %d%d , &n, &m); printf( %d , pow(n + m)); } |
#include <bits/stdc++.h> const int MAX_N = 1e5 + 5; int n, m; char str[MAX_N], nxt[256]; bool chk[256], vis[256], not_root[256], flag; std::vector<char> ans; void dfs(char c) { if (!vis[c]) { vis[c] = true; ans.push_back(c); if (nxt[c]) dfs(nxt[c]); } else flag = true; } int main() { scanf( %d , &n); while (n--) { scanf( %s , str); m = strlen(str); for (int i = 0; i < m; ++i) chk[str[i]] = true; for (int i = 0; i + 1 < m; ++i) { if (nxt[str[i]] == 0) nxt[str[i]] = str[i + 1]; else if (nxt[str[i]] != str[i + 1]) { printf( NO n ); return 0; } not_root[str[i + 1]] = true; } } for (char i = a ; i <= z ; ++i) if (!not_root[i] && chk[i]) dfs(i); for (char i = a ; i <= z ; ++i) flag |= chk[i] != vis[i]; if (flag) { printf( NO n ); return 0; } for (char c : ans) printf( %c , c); printf( n ); return 0; } |
#include <bits/stdc++.h> using namespace std; const int MAXN = 2e5 + 10; int n; vector<int> vec[MAXN]; map<int, pair<int, int> > mp; int main() { cin >> n; cin.tie(0); for (int i = 0; i < n; i++) { int t; cin >> t; vec[i].resize(t); int sm = 0; for (int j = 0; j < t; j++) cin >> vec[i][j], sm += vec[i][j]; for (int j = 0; j < t; j++) if (mp.count(sm - vec[i][j])) { int z = sm - vec[i][j]; if (mp[z].first == i) continue; cout << YES n ; cout << mp[z].first + 1 << << mp[z].second + 1 << n ; cout << i + 1 << << j + 1 << n ; return 0; } else mp[sm - vec[i][j]] = make_pair(i, j); } cout << NO n ; return 0; } |
#include <bits/stdc++.h> using namespace std; 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...); } const long long int N = 100005; int32_t main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); long long int t; cin >> t; while (t--) { long long int i, j, k, n, m, ans = 0, cnt = 0, sum = 0; cin >> m >> n; long long int a[n]; map<long long int, long long int> mp; for (i = 0; i < n; i++) { cin >> a[i]; mp[a[i]]++; sum += a[i]; } if (sum < m) { cout << -1 << n ; } else { set<long long int> St; for (i = 0; i < 62; i++) { if (m >> i & 1ll) { St.insert(1ll << i); } } cnt = 1; sum = 0; for (auto x : St) { while (cnt <= x) { sum += mp[cnt] * cnt; cnt *= 2; } if (sum >= x) sum -= x; else { long long int nxt = cnt; while (mp[nxt] == 0) { nxt *= 2; } mp[nxt]--; ans += log2(nxt / x); while (nxt > x) { nxt /= 2; mp[nxt]++; } } } cout << ans << n ; } } } |
#include <bits/stdc++.h> using namespace std; int main(int argc, char* argv[]) { char dt[1002]; memset(dt, 0, sizeof(dt)); char gr[1002]; memset(gr, 0, sizeof(gr)); cin >> dt >> gr; int n = strlen(dt); int m = strlen(gr); map<char, int> dtc; map<char, int> gtc; for (int i = 0; i < n; ++i) { dtc[dt[i]]++; } for (int i = 0; i < m; ++i) { gtc[gr[i]]++; } int res = 0; map<char, int>::iterator it; for (it = gtc.begin(); it != gtc.end(); ++it) { char val = it->first; if (dtc[val] == 0) { cout << -1; return 0; } if (dtc[val] >= gtc[val]) res += gtc[val]; else res += dtc[val]; } cout << res << endl; return 0; } |
#include <bits/stdc++.h> #define ALL(x) x.begin(), x.end() #define pb push_back #define db1(x) cout << #x << = << x << endl #define db2(x, y) cout << #x << = << x << , << #y << = << y << endl using namespace std; void localFileInput() { #ifndef ONLINE_JUDGE freopen( input.txt , r , stdin); #endif } typedef long long ll; typedef pair<int, int> pii; const ll mod = 1e9+7; const int N = 1e5+10; int n, m, a[N]; struct Node { int r; double p; void input() { scanf( %d%lf , &r, &p); } }b[N]; int r[N]; bool cmp(Node a , Node b) { return a.r < b.r; } void sol() { scanf( %d%d , &n, &m); for (int i = 1; i <= n; ++ i) scanf( %d , &a[i]); for (int i = 1; i <= m; ++ i) b[i].input(); sort(b + 1, b + 1 + m, cmp); for (int i = 1; i <= m; ++ i) r[i] = b[i].r; int id = 0; for (int i = n; i >= 1; -- i) if(a[i] != i) { id = i; break; } if(id == 0) { puts( 1.000000 ); return ; } int st = lower_bound(r+1, r+1+m, id) - r; double ans = 1.0; for (int i = st; i <= m; ++ i) ans = ans * (1 - b[i].p); printf( %.6f n , 1-ans); } int main() { localFileInput(); int _; scanf( %d , &_); while(_ --) sol(); return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { long int n, a, b, i = 0, cnt = 0, y; cin >> n >> a >> b; while (n >= 0) { if (i == 0) { n = n; } else { n = n - a; } if (n % b == 0 && n >= 0) { y = n / b; cnt++; break; } i++; } if (cnt > 0) { cout << YES << endl; cout << i << << y; } else if (cnt == 0) { cout << NO ; } } |
#include <bits/stdc++.h> using namespace std; const long long maxn = 1e5 + 7; long long n, q; long long a[maxn]; long long m; map<long long, long long> ma; long long Mod(long long x, long long mod) { if (x < mod) return x; return x % mod + mod; } long long fp(long long a, long long b, long long mod) { long long tmp = 1; while (b) { if (b & 1) tmp = Mod(tmp * a, mod); b >>= 1, a = Mod(a * a, mod); } return tmp; } long long phi(long long k) { long long s = k, kk = k; if (ma.count(k)) return ma[k]; for (long long i = 2; i * i <= k; i++) { if (k % i == 0) s = s / i * (i - 1); while (k % i == 0) k /= i; } if (k > 1) s = s / k * (k - 1); return ma[kk] = s; } long long solve(long long l, long long r, long long mod) { if (l == r || mod == 1) return Mod(a[l], mod); return fp(a[l], solve(l + 1, r, phi(mod)), mod); } int main() { cin >> n >> m; for (long long i = 1; i <= n; i++) { scanf( %lld , &a[i]); } scanf( %d , &q); while (q--) { long long l, r; scanf( %lld%lld , &l, &r); printf( %lld n , solve(l, r, m) % m); } return 0; } |
#include <bits/stdc++.h> using namespace std; const int maxn = 1e5 + 10, N = 1e3 + 10; int tp[maxn], x[maxn], y[maxn]; vector<int> edge; char ch[2]; int rt[N], V, E, i, k; int root(int u) { if (rt[u] < 0) return u; else return rt[u] = root(rt[u]); } void init(int _V) { for (i = 1; i <= _V; i++) rt[i] = -1; } void merge(int u, int v) { u = root(u); v = root(v); rt[v] = u; } void Read() { scanf( %d%d , &V, &E); for (i = 1; i <= E; i++) { scanf( %d%d%s , x + i, y + i, ch); tp[i] = (ch[0] == S ) ? 1 : 0; } } void runs() { if (V % 2 != 1) puts( -1 ), exit(0); k = V >> 1; init(V); for (i = 1; i <= E; i++) if (!tp[i] and root(x[i]) != root(y[i])) { merge(x[i], y[i]); } for (i = 1; i <= E; i++) if (tp[i] and root(x[i]) != root(y[i])) { edge.push_back(i); merge(x[i], y[i]); } if (((int)((edge).size())) > k) puts( -1 ), exit(0); init(V); for (i = 0; i < ((int)((edge).size())); i++) merge(x[edge[i]], y[edge[i]]); for (i = 1; i <= E; i++) if (((int)((edge).size())) < k and tp[i] and root(x[i]) != root(y[i])) { edge.push_back(i); merge(x[i], y[i]); } if (((int)((edge).size())) < k) puts( -1 ), exit(0); for (i = 1; i <= E; i++) if (!tp[i] and root(x[i]) != root(y[i])) { edge.push_back(i); merge(x[i], y[i]); } if (((int)((edge).size())) < 2 * k) puts( -1 ), exit(0); printf( %d n , V - 1); for (i = 0; i < ((int)((edge).size())); i++) printf( %d , edge[i]); puts( ); } int main() { Read(); runs(); } |
#include <bits/stdc++.h> using namespace std; int n, c; int a[1 << 20], b[1 << 20]; char tp[1 << 20]; int hs[128][128]; int ne[128][128]; int li[128]; bool getDP(int l, int r) { if (hs[l][r] != -1) return hs[l][r]; if (l >= r) { return (hs[l][r] = 1); } hs[l][r] = 0; for (int k = l; k <= r; ++k) { bool ok = true; for (int i = 0; i < c; ++i) { if (a[i] == l) { if (tp[i] == L && b[i] > k) ok = false; if (tp[i] == R && b[i] <= k) ok = false; } if (a[i] > l && a[i] <= k) { if (b[i] > k) ok = false; } } if (ok) { if (getDP(l + 1, k) && getDP(k + 1, r)) { ne[l][r] = k; hs[l][r] = 1; break; } } } return hs[l][r]; } int le[1 << 20], ri[1 << 20]; void cli(int l, int r) { if (l >= r) return; li[l] = ne[l][r]; if (li[l] > l) { le[l] = l + 1; cli(l + 1, li[l]); } if (li[l] < r) { ri[l] = li[l] + 1; cli(li[l] + 1, r); } } vector<int> sl; void sol(int v) { if (le[v] != -1) sol(le[v]); sl.push_back(v); if (ri[v] != -1) sol(ri[v]); } int main() { scanf( %d %d , &n, &c); char buf[32]; for (int i = 0; i < c; i++) { scanf( %d %d %s , &a[i], &b[i], buf); tp[i] = buf[0]; if (a[i] >= b[i]) { printf( IMPOSSIBLE n ); return 0; } } memset(hs, -1, sizeof(hs)); bool ok = getDP(1, n); if (!ok) { printf( IMPOSSIBLE n ); return 0; } memset(li, -1, sizeof(li)); memset(le, -1, sizeof(le)); memset(ri, -1, sizeof(ri)); cli(1, n); sol(1); for (int i = 0; i + 1 < (int)sl.size(); i++) { printf( %d , sl[i]); } printf( %d n , sl.back()); return 0; } |
#include <bits/stdc++.h> using namespace std; class PriorityQueue { private: vector<pair<int, int> > d1, d2; int l1 = 0, l2 = 0, r1 = 0, r2 = 0; inline bool takeFirst() { return l1 != r1 && (l2 == r2 || d1[l1] < d2[l2]); } public: inline void prepare() { swap(d1, d2); swap(l1, l2); swap(r1, r2); } inline void push(const pair<int, int> &p) { d1.push_back(p); r1++; } inline void repush(const pair<int, int> &p) { if (l1) { d1[--l1] = p; } else { d2[--l2] = p; } } inline bool empty() { return l1 == r1 && l2 == r2; } inline pair<int, int> top() { return takeFirst() ? d1[l1] : d2[l2]; } inline void pop() { (takeFirst() ? l1 : l2)++; } }; static const int heavyLim = 500; struct FreqAnalyzer { int n, m; vector<int> items; vector<int> freqs; vector<int> heavy; inline void add(int v, int sign) { if (items[v]) { freqs[items[v]]--; } items[v] += sign; if (items[v]) { freqs[items[v]]++; } } inline int64_t huffmanSum() { PriorityQueue pq; for (int i = 0; i < min(n + 1, heavyLim); i++) { if (freqs[i]) { pq.push({i, freqs[i]}); } } vector<pair<int, int> > heavies; for (int i : heavy) { if (items[i] >= heavyLim) { heavies.emplace_back(items[i], 1); } } sort(heavies.begin(), heavies.end()); for (auto it : heavies) { pq.push(it); } pq.prepare(); int64_t ans = 0; while (!pq.empty()) { auto it = pq.top(); pq.pop(); while (!pq.empty() && pq.top().first == it.first) { it.second += pq.top().second; pq.pop(); } if (it.second == 1) { if (pq.empty()) { break; } else { auto jt = pq.top(); int q = jt.first; jt.second--; pq.pop(); if (jt.second) { pq.repush(jt); } ans += it.first + q; pq.push({it.first + q, 1}); } } else { int64_t a = it.first * 2, b = it.second / 2; ans += a * b; pq.push({a, b}); if (it.second & 1) { pq.repush({it.first, 1}); } } } return ans; } FreqAnalyzer(int n, int m, const vector<int> &heavy) : n(n), m(m), items(m), freqs(n + 1), heavy(heavy) {} }; const int moBlock = 300; struct Query { int l, r, idx; inline pair<int, int> toPair() const { auto res = make_pair(l / moBlock, r); if (res.first & 1) { res.second *= -1; } return res; } }; inline bool operator<(const Query &a, const Query &b) { return a.toPair() < b.toPair(); } int main() { ios_base::sync_with_stdio(false); int n; cin >> n; vector<int> a(n); int m = 0; for (int i = 0; i < n; i++) { cin >> a[i]; m = max(m, a[i]); a[i]--; } vector<int> knt(m); vector<int> heavy; for (int i = 0; i < n; i++) { knt[a[i]]++; } for (int i = 0; i < m; i++) { if (knt[i] >= heavyLim) { heavy.push_back(i); } } int q; cin >> q; vector<Query> qry(q); for (int i = 0; i < q; i++) { cin >> qry[i].l >> qry[i].r; qry[i].l--; qry[i].r--; qry[i].idx = i; } sort(qry.begin(), qry.end()); FreqAnalyzer fa(n, m, heavy); int l = 0, r = -1; vector<int64_t> ans(q); for (Query q : qry) { while (l > q.l) { fa.add(a[--l], +1); } while (r < q.r) { fa.add(a[++r], +1); } while (l < q.l) { fa.add(a[l++], -1); } while (r > q.r) { fa.add(a[r--], -1); } ans[q.idx] = fa.huffmanSum(); } for (int i = 0; i < q; i++) { cout << ans[i] << n ; } return 0; } |
#include <bits/stdc++.h> using namespace std; void debug(int* a, int n, bool flag = false) { if (!flag) printf( array ); for (int i = 1; i <= n; i++) printf( %d , a[i]); printf( n ); } void debug(vector<int>& E, bool flag = false) { if (!flag) printf( vector ); for (auto it : E) printf( %d , it); printf( n ); } const int maxn = 2e5 + 5; int a[maxn]; set<pair<int, int> > s; int n, m; map<int, bool> Map; vector<int> res; int main() { scanf( %d%d , &n, &m); for (int i = 1; i <= n; i++) { scanf( %d , &a[i]); Map[a[i]] = true; s.insert(make_pair(i, -1)); s.insert(make_pair(i, 1)); } sort(a + 1, a + 1 + n); long long ans = 0; long long k = 1; while (m) { auto it = s.begin(); while (it != s.end()) { long long val = a[it->first] + k * it->second; if (!Map.count(val)) { res.push_back(val); ans += k; it++; m--; Map[val] = true; if (!m) break; } else s.erase(it++); } k++; } printf( %I64d n , ans); debug(res, true); return 0; } |
#include <bits/stdc++.h> using namespace std; struct lr { long long left, right; lr() : left(-1), right(1e7) {} lr(long long _l, long long _r) : left(_l), right(_r) {} }; int main() { long long n; scanf( %lld , &n); vector<long long> arr(n); for (int i = 0; i < n; i++) scanf( %lld , &arr[i]); vector<lr> mn(n, lr(0, n - 1)); vector<lr> mx(n, lr(0, n - 1)); stack<lr> mxs, mns; for (int i = 0; i < n; i++) { while (!mxs.empty()) { if (mxs.top().left >= arr[i]) { break; } else { lr it = mxs.top(); mxs.pop(); mx[it.right].right = i - 1; } } mxs.push(lr(arr[i], i)); while (!mns.empty()) { if (mns.top().left <= arr[i]) { break; } else { lr it = mns.top(); mns.pop(); mn[it.right].right = i - 1; } } mns.push(lr(arr[i], i)); } while (!mxs.empty()) mxs.pop(); while (!mns.empty()) mns.pop(); for (int i = n - 1; i >= 0; i--) { while (!mxs.empty()) { if (mxs.top().left > arr[i]) { break; } else { lr it = mxs.top(); mxs.pop(); mx[it.right].left = i + 1; } } mxs.push(lr(arr[i], i)); while (!mns.empty()) { if (mns.top().left < arr[i]) { break; } else { lr it = mns.top(); mns.pop(); mn[it.right].left = i + 1; } } mns.push(lr(arr[i], i)); } long long res = 0; for (int i = 0; i < n; i++) { long long x1 = mx[i].right - i + 1, x2 = mn[i].right - i + 1, n1 = i - mx[i].left + 1, n2 = i - mn[i].left + 1; long long a = x1 * n1; long long b = x2 * n2; res += a * arr[i]; res -= b * arr[i]; } cout << res << endl; return 0; } |
#include <iostream> #include <bits/stdc++.h> #include <stdio.h> #include <cstdlib> #include<algorithm> #include<string.h> #include<map> #include<math.h> using namespace std; int main() { int t; cin>>t; while(t--) { int n,k; cin>>n>>k;int count =0; vector <int> v,a(n);int max=n; if(k>(n-1)/2) { cout<< -1 <<endl; continue; } for(int i=1;i<n;i+=2) { if(count==k) break; a[i]=max; max--; count++; } for(int i=0;i<n;i++) { if(a[i]!=0) continue; a[i]=max; max--; } for(int i=0;i<n;i++) { cout<<a[i]<< ; } cout<<endl; } } |
#include <bits/stdc++.h> using namespace std; const long long maxM = 22, maxN = ((1LL << 20) + 1); long long M, mod, T, N; int bc[maxM][maxM]; int dp[maxN][2][maxM]; int arr[maxN], b[maxM], p2[maxM]; struct Matrix { long long n, m; long long val[maxM][maxM]; Matrix() { for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) val[i][j] = 0; } }; Matrix operator*(Matrix A, Matrix B) { Matrix ret; ret.n = 1, ret.m = M; for (int k = 0; k <= M; k++) { long long vl = 0; for (int i = 0; i <= (M - k); i++) { long long vl2 = 0; for (int j = 0; j <= k; j++) { vl2 = (vl2 + (((bc[k][j] * A.val[0][i + j]) % mod) * B.val[0][i + k - j])) % mod; } vl = (vl + (bc[M - k][i] * vl2)) % mod; } vl %= mod; if (vl < 0) vl += mod; ret.val[0][k] = vl; } return ret; } Matrix Pow(Matrix A, long long b) { Matrix Temp; Temp.n = 1; Temp.m = M; for (int i = 0; i <= M; i++) Temp.val[0][i] = (int(i == 0)); if (b == 0) return Temp; Matrix res = A; for (b--; b; b >>= 1, A = A * A) if (b & 1) res = res * A; return res; } int main() { scanf( %lld%lld%lld , &M, &T, &mod); N = (1LL << M); for (int i = 0; i < N; i++) { scanf( %lld , &arr[i]); arr[i] %= mod; dp[i][0][0] = arr[i]; } bc[0][0] = 1; p2[0] = 1; for (int i = 1; i <= (M + 1); i++) { p2[i] = 2 * p2[i - 1]; for (int j = 0; j <= i; j++) { if (j == 0 || j == i) bc[i][j] = 1; else bc[i][j] = (bc[i - 1][j - 1] + bc[i - 1][j]); } } for (int i = 0; i <= M; i++) { scanf( %lld , &b[i]); b[i] %= mod; } long long J = 1; for (int j = 1; j <= M; j++) { for (int i = 0; i < N; i++) { for (int k = 0; k <= M; k++) { if (j == 0 && k == 0) { dp[i][J][k] = arr[i]; } else if (j == 0) dp[i][J][k] = 0; else { dp[i][J][k] = (dp[i][1 - J][k] + dp[i ^ (p2[j - 1])][1 - J][k - 1]); if (dp[i][J][k] >= mod) dp[i][J][k] -= mod; } } } J = 1 - J; } Matrix B; B.n = 1; B.m = M; for (int i = 0; i <= M; i++) B.val[0][i] = b[i]; Matrix c = Pow(B, T); long long MD = M % 2, ans; for (int i = 0; i < N; i++) { ans = 0; for (int j = 0; j <= M; j++) ans = (ans + (c.val[0][j] * dp[i][MD][j])) % mod; printf( %lld n , ans); } return 0; } |
#include <bits/stdc++.h> using namespace std; long double n, l, k, v1, v2; int main() { cout << fixed << setprecision(10); cin >> n >> l >> v1 >> v2 >> k; if (v2 <= v1) { cout << l / (v1 * 1.0) << endl; return 0; } if (n <= k) { cout << l / (v2 * 1.0) << endl; return 0; } int T = ceil(n / (k * 1.0)); long double K = ((T - 1) * (1 + (v2 - v1) / ((v2 + v1) * 1.0))) * v1; K += v2; K = l / K; long double ans = K * (T + (T - 1) * (v2 - v1) / (v2 + v1)); cout << ans << endl; } |
#include <bits/stdc++.h> using namespace std; int start[200010], finish[200010], cnt, n, m, a[200010], dis[200010]; long long tree[2][8 * 200010]; vector<int> adj[200010], nodes[2], starts[2]; void update(int v, int vl, int vr, int l, int r, int val, int k) { int mid = (vl + vr) / 2; if (l <= vl && vr <= r) { tree[k][v] += val; return; } if (vr < l || r < vl) return; update(2 * v, vl, mid, l, r, val, k); update(2 * v + 1, mid + 1, vr, l, r, val, k); } long long getVal(int v, int vl, int vr, int idx, int k) { int mid = (vl + vr) / 2; if (vl == vr) return tree[k][v]; if (idx <= mid) return tree[k][v] + getVal(2 * v, vl, mid, idx, k); else return tree[k][v] + getVal(2 * v + 1, mid + 1, vr, idx, k); } void dfs(int v, int f, int d) { cnt++; start[v] = cnt; nodes[d % 2].push_back(v); starts[d % 2].push_back(start[v]); dis[v] = d % 2; for (__typeof(((int)((adj[v]).size())) - 1) i = (0); i <= (((int)((adj[v]).size())) - 1); i++) if (adj[v][i] != f) dfs(adj[v][i], v, d + 1); finish[v] = cnt; } int main() { ios::sync_with_stdio(0); cin.tie(0); cin >> n >> m; for (__typeof(n) i = (1); i <= (n); i++) cin >> a[i]; for (__typeof(n - 1) i = (1); i <= (n - 1); i++) { int u, v; cin >> u >> v; adj[u].push_back(v); adj[v].push_back(u); } dfs(1, -1, 0); for (__typeof(n) i = (1); i <= (n); i++) { int k = dis[i]; int idx = lower_bound((starts[k]).begin(), (starts[k]).end(), start[i]) - starts[k].begin(); idx++; update(1, 1, n, idx, idx, a[i], k); } starts[0].push_back((1000 * 1000 * 1000)); starts[1].push_back((1000 * 1000 * 1000)); for (__typeof(m) i = (1); i <= (m); i++) { int q, x, v; cin >> q; if (q == 1) { cin >> x >> v; int k = dis[x]; int idx1 = lower_bound((starts[k]).begin(), (starts[k]).end(), start[x]) - starts[k].begin(); int idx2 = lower_bound((starts[k]).begin(), (starts[k]).end(), finish[x]) - starts[k].begin(); int idx3 = lower_bound((starts[1 - k]).begin(), (starts[1 - k]).end(), start[x]) - starts[1 - k].begin(); int idx4 = lower_bound((starts[1 - k]).begin(), (starts[1 - k]).end(), finish[x]) - starts[1 - k].begin(); if (idx2 >= ((int)((nodes[k]).size())) || finish[nodes[k][idx2]] != finish[x]) idx2--; if (idx4 >= ((int)((nodes[1 - k]).size())) || finish[nodes[1 - k][idx4]] != finish[x]) idx4--; idx1++; idx2++; idx3++; idx4++; if (idx1 <= idx2) update(1, 1, n, idx1, idx2, v, k); if (idx3 <= idx4) update(1, 1, n, idx3, idx4, -v, 1 - k); } else { cin >> x; int k = dis[x]; int idx = lower_bound((starts[k]).begin(), (starts[k]).end(), start[x]) - starts[k].begin(); idx++; cout << getVal(1, 1, n, idx, k) << endl; } } return 0; } |
#include <bits/stdc++.h> using namespace std; const int MAXN = 1e5 + 7; const long long INF = 1e18 + 7; int n, a[MAXN], d[MAXN] = {}, k, l = 1, r = 0; long long f[MAXN], g[MAXN], ans = 0; void add(long long &a, const long long &b) { a += b; if (a > INF) a = INF; } long long sum(long long a, long long b) { a += b; if (a > INF) a = INF; return a; } void cost(int newl, int newr) { while (r < newr) ans += 1LL * (d[a[++r]]++); while (r > newr) ans -= 1LL * (--d[a[r--]]); while (l > newl) ans += 1LL * (d[a[--l]]++); while (l < newl) ans -= 1LL * (--d[a[l++]]); } void calc(int l, int r, int mn, int mx) { if (l > r) return; int mid = (l + r) >> 1, opt = 0; for (int i = min(mx, mid - 1); i >= mn; --i) { cost(i + 1, mid); if (g[i] + ans < f[mid]) f[mid] = g[i] + ans, opt = i; } calc(l, mid - 1, mn, opt); calc(mid + 1, r, opt, mx); } int main() { ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0); cin >> n >> k; for (int i = 1; i <= n; ++i) cin >> a[i]; g[0] = f[0] = 0; for (int i = 1; i <= n; ++i) f[i] = g[i] = INF; for (int i = 1; i <= k; ++i) { calc(1, n, 0, n); for (int j = 1; j <= n; ++j) g[j] = f[j], f[j] = INF; } cout << g[n]; return 0; } |
#include <bits/stdc++.h> using namespace std; const long long mod = 1e9 + 7; const long long mx = 2e6 + 10; int posx[] = {1, -1, 0, 0}; int posy[] = {0, 0, 1, -1}; int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); long long t = 1, n, k, m, a, b, c, d, h; cin >> t; while (t--) { cin >> h >> c >> k; if (h + c >= 2 * k) { cout << 2 << endl; continue; } long long x = (c - k) / (h + c - (2 * k)); long long y = x + 1; long double xx = ((h * x) + (c * (x - 1))) / ((1.0) * 2 * x - 1); long double yy = ((h * y) + (c * (y - 1))) / ((1.0) * 2 * y - 1); if (abs(xx - k) <= abs(yy - k)) cout << 2 * x - 1 << endl; else cout << 2 * y - 1 << endl; } return 0; } |
#include <bits/stdc++.h> long long dx[8] = {0, 1, 0, -1, 1, 1, -1, -1}; long long dy[8] = {1, 0, -1, 0, -1, 1, 1, -1}; using namespace std; class pa3 { public: long long x; long long y, z; pa3(long long x = 0, long long y = 0, long long z = 0) : x(x), y(y), z(z) {} bool operator<(const pa3 &p) const { if (x != p.x) return x < p.x; if (y != p.y) return y < p.y; return z < p.z; } bool operator>(const pa3 &p) const { if (x != p.x) return x > p.x; if (y != p.y) return y > p.y; return z > p.z; } bool operator==(const pa3 &p) const { return x == p.x && y == p.y && z == p.z; } bool operator!=(const pa3 &p) const { return !(x == p.x && y == p.y && z == p.z); } }; class pa4 { public: long long x; long long y, z, w; pa4(long long x = 0, long long y = 0, long long z = 0, long long w = 0) : x(x), y(y), z(z), w(w) {} bool operator<(const pa4 &p) const { if (x != p.x) return x < p.x; if (y != p.y) return y < p.y; if (z != p.z) return z < p.z; return w < p.w; } bool operator>(const pa4 &p) const { if (x != p.x) return x > p.x; if (y != p.y) return y > p.y; if (z != p.z) return z > p.z; return w > p.w; } bool operator==(const pa4 &p) const { return x == p.x && y == p.y && z == p.z && w == p.w; } }; class pa2 { public: long long x, y; pa2(long long x = 0, long long y = 0) : x(x), y(y) {} pa2 operator+(pa2 p) { return pa2(x + p.x, y + p.y); } pa2 operator-(pa2 p) { return pa2(x - p.x, y - p.y); } bool operator<(const pa2 &p) const { return y != p.y ? y < p.y : x < p.x; } bool operator>(const pa2 &p) const { return x != p.x ? x < p.x : y < p.y; } bool operator==(const pa2 &p) const { return abs(x - p.x) == 0 && abs(y - p.y) == 0; } bool operator!=(const pa2 &p) const { return !(abs(x - p.x) == 0 && abs(y - p.y) == 0); } }; string itos(long long i) { ostringstream s; s << i; return s.str(); } long long gcd(long long v, long long b) { if (v > b) return gcd(b, v); if (v == b) return b; if (b % v == 0) return v; return gcd(v, b % v); } long long mod; long long extgcd(long long a, long long b, long long &x, long long &y) { if (b == 0) { x = 1; y = 0; return a; } long long d = extgcd(b, a % b, y, x); y -= a / b * x; return d; } pair<long long, long long> operator+(const pair<long long, long long> &l, const pair<long long, long long> &r) { return {l.first + r.first, l.second + r.second}; } pair<long long, long long> operator-(const pair<long long, long long> &l, const pair<long long, long long> &r) { return {l.first - r.first, l.second - r.second}; } long long pr[1001010]; long long inv[1001010]; long long beki(long long wa, long long rr, long long warukazu) { if (rr == 0) return 1 % warukazu; if (rr == 1) return wa % warukazu; wa %= warukazu; if (rr % 2 == 1) return ((long long)beki(wa, rr - 1, warukazu) * (long long)wa) % warukazu; long long zx = beki(wa, rr / 2, warukazu); return (zx * zx) % warukazu; } long long comb(long long nn, long long rr) { if (rr < 0 || rr > nn || nn < 0) return 0; long long r = pr[nn] * inv[rr]; r %= mod; r *= inv[nn - rr]; r %= mod; return r; } void gya(long long ert) { pr[0] = 1; for (long long i = 1; i <= ert; i++) { pr[i] = (pr[i - 1] * i) % mod; } inv[ert] = beki(pr[ert], mod - 2, mod); for (long long i = ert - 1; i >= 0; i--) { inv[i] = inv[i + 1] * (i + 1) % mod; } } struct edge { long long to, cap, num, moto; }; vector<edge> ZANYO[100020]; long long label[100020]; queue<pair<long long, long long> > qu_bfs; long long dokomade[100020]; void add_edge(long long s_point, long long t_point, long long capa) { ZANYO[s_point].push_back( (edge){t_point, capa, (long long)ZANYO[t_point].size(), 0}); ZANYO[t_point].push_back( (edge){s_point, 0, (long long)ZANYO[s_point].size() - 1, 1}); } void bfs_dinic(long long s_point, long long N) { for (long long i = 0; i < N; i++) label[i] = -1; while (qu_bfs.size()) qu_bfs.pop(); qu_bfs.push(make_pair(s_point, 0)); while (qu_bfs.size()) { pair<long long, long long> z = qu_bfs.front(); qu_bfs.pop(); if (label[z.first] >= 0) continue; label[z.first] = z.second; for (auto &v : ZANYO[z.first]) { if (v.cap == 0) continue; if (v.cap < 0) { cout << error << endl; exit(0); } if (label[v.to] >= 0) continue; qu_bfs.push(make_pair(v.to, z.second + 1)); } } return; } long long dfs_dinic(long long s_point, long long t_point, long long ima_flow) { if (s_point == t_point) return ima_flow; while (1) { if (dokomade[s_point] >= ZANYO[s_point].size()) break; long long edanum = dokomade[s_point]; if (ZANYO[s_point][edanum].cap < 0) { cout << minus << endl; exit(0); } if (ZANYO[s_point][edanum].cap <= 0 || label[s_point] + 1 != label[ZANYO[s_point][edanum].to]) { dokomade[s_point]++; continue; } long long W = dfs_dinic(ZANYO[s_point][edanum].to, t_point, min(ZANYO[s_point][edanum].cap, ima_flow)); if (W > 0) { ZANYO[s_point][edanum].cap -= W; ZANYO[ZANYO[s_point][edanum].to][ZANYO[s_point][edanum].num].cap += W; return W; } dokomade[s_point]++; } return 0; } long long max_flow_dinic(long long s_point, long long t_point, long long N) { long long jougen = 1000000007 * 1000000000ll; long long ans_flow = 0; while (1) { bfs_dinic(s_point, N); if (label[t_point] == -1) break; for (long long i = 0; i < N; i++) dokomade[i] = 0; while (1) { long long ima_flow = dfs_dinic(s_point, t_point, jougen + 1); if (ima_flow == 0) break; ans_flow += ima_flow; } } return ans_flow; } signed main() { cin.tie(0); ios::sync_with_stdio(false); vector<pa4> ve; long long n, q; cin >> n >> q; set<long long> sex, sey; sex.insert(0); sex.insert(n); sey.insert(0); sey.insert(n); for (long long i = 0; i < q; i++) { long long x1, y1, x2, y2; cin >> x1 >> y1 >> x2 >> y2; x1--, y1--; sex.insert(x1); sex.insert(x2); sey.insert(y1); sey.insert(y2); ve.push_back((pa4){x1, x2, y1, y2}); } vector<long long> vx, vy; for (auto it = sex.begin(); it != sex.end(); it++) vx.push_back(*it); for (auto it = sey.begin(); it != sey.end(); it++) vy.push_back(*it); long long a = vx.size() - 1; long long b = vy.size() - 1; set<pair<long long, long long> > se; for (long long i = 0; i < a; i++) for (long long j = 0; j < b; j++) { long long sx = vx[i], sy = vx[i + 1]; long long tx = vy[j], ty = vy[j + 1]; bool bo = 0; for (auto v : ve) { if (sx >= v.x && v.y >= sy && tx >= v.z && v.w >= ty) bo = 1; } if (bo) se.insert(make_pair(i, j)); } long long A[200], B[200]; for (long long i = 0; i < a; i++) { long long sx = vx[i], sy = vx[i + 1]; add_edge(0, 1 + i, sy - sx); A[i] = sy - sx; } for (long long j = 0; j < b; j++) { long long tx = vy[j], ty = vy[j + 1]; add_edge(a + 1 + j, a + b + 1, ty - tx); B[j] = ty - tx; } for (auto it = se.begin(); it != se.end(); it++) { pair<long long, long long> z = *it; add_edge(1 + z.first, a + 1 + z.second, min(A[z.first], B[z.second])); } cout << max_flow_dinic(0, a + b + 1, a + b + 5) << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; template <typename _T> inline void read(_T &f) { f = 0; _T fu = 1; char c = getchar(); while (c < 0 || c > 9 ) { if (c == - ) fu = -1; c = getchar(); } while (c >= 0 && c <= 9 ) { f = (f << 3) + (f << 1) + (c & 15); c = getchar(); } f *= fu; } template <typename T> void print(T x) { if (x < 0) putchar( - ), x = -x; if (x < 10) putchar(x + 48); else print(x / 10), putchar(x % 10 + 48); } template <typename T> void print(T x, char t) { print(x); putchar(t); } const int N = 1005; int a[N][N], ans[N][N], ans2[N][N], b[N]; int n, m; int main() { read(n); read(m); for (register int i = 1; i <= n; i++) { for (register int j = 1; j <= m; j++) { read(a[i][j]); } } for (register int i = 1; i <= n; i++) { for (register int j = 1; j <= m; j++) b[j] = a[i][j]; sort(b + 1, b + m + 1); int big = unique(b + 1, b + m + 1) - b - 1; for (register int j = 1; j <= m; j++) { int tmp = lower_bound(b + 1, b + big + 1, a[i][j]) - b; ans[i][j] = max(ans[i][j], tmp); ans2[i][j] = max(ans2[i][j], big - tmp); } } for (register int j = 1; j <= m; j++) { for (register int i = 1; i <= n; i++) b[i] = a[i][j]; sort(b + 1, b + n + 1); int big = unique(b + 1, b + n + 1) - b - 1; for (register int i = 1; i <= n; i++) { int tmp = lower_bound(b + 1, b + big + 1, a[i][j]) - b; ans[i][j] = max(ans[i][j], tmp); ans2[i][j] = max(ans2[i][j], big - tmp); } } for (register int i = 1; i <= n; i++) { for (register int j = 1; j <= m; j++) { print(ans[i][j] + ans2[i][j], j == m ? n : ); } } return 0; } |
#include <bits/stdc++.h> using namespace std; void optimise() { ios_base::sync_with_stdio(false); cin.tie(NULL); } long long int mod = 1e9 + 7; void normalize(long long int &a) { a = (a + mod) % mod; } long long int modmul(long long int a, long long int b) { a = a % mod; b = b % mod; normalize(a); normalize(b); return (a * b) % mod; } long long int modadd(long long int a, long long int b) { a = a % mod; b = b % mod; normalize(a); normalize(b); return (a + b) % mod; } long long int modsub(long long int a, long long int b) { a = a % mod; b = b % mod; normalize(a); normalize(b); return (a - b + mod) % mod; } long long int me(long long int x, long long int n) { x %= mod; if (n == 0) return 1; long long int u = me(x, n / 2) % mod; u = (u * u) % mod; if (n % 2) u = (u * x) % mod; return u; } long long int me1(long long int x, long long int n) { if (n == 0) return 1; long long int u = me1(x, n / 2); u = u * u; if (n % 2) u = u * x; return u; } inline long long int modInv(long long int a) { return me(a, mod - 2); } inline long long int modDiv(long long int a, long long int b) { return modmul(a, modInv(b)); } float power(float x, long long int y) { float temp; if (y == 0) return 1; temp = power(x, y / 2); if (y % 2 == 0) return temp * temp; else { if (y > 0) return x * temp * temp; else return (temp * temp) / x; } } long long int __gcd(long long int a, long long int b) { if (b == 0) return a; else return __gcd(b, a % b); } pair<long long int, long long int> operator+( pair<long long int, long long int> a, pair<long long int, long long int> b) { return {a.first + b.first, a.second + b.second}; } pair<long long int, long long int> operator-( pair<long long int, long long int> a, pair<long long int, long long int> b) { return {a.first - b.first, a.second - b.second}; } pair<long long int, long long int> operator*( pair<long long int, long long int> a, pair<long long int, long long int> b) { return {a.first * b.first, a.second * b.second}; } template <typename T> ostream &operator<<(ostream &os, const set<T> &v) { for (auto it : v) os << it << ; return os; } template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) { for (long long int i = 0; i < v.size(); ++i) os << v[i] << ; return os; } bool compare(string s1, string s2) { return s1.size() < s2.size(); } void solve() { long long int n, k; cin >> n >> k; vector<pair<long long int, long long int> > v; if (n > k * (k - 1)) { cout << No ; return; } cout << Yes << n ; for (long long int i = 0; i < k; i++) { for (long long int j = i + 1; j < k; j++) { n--; cout << i + 1 << << j + 1 << n ; if (n == 0) return; n--; cout << j + 1 << << i + 1 << n ; if (n == 0) return; } } } signed main() { optimise(); long long int t; t = 1; cout << fixed << setprecision(5); while (t--) { solve(); cout << n ; } cerr << n << Time Elasped : << 1.0 * clock() / CLOCKS_PER_SEC << n ; } |
#include <bits/stdc++.h> using namespace std; struct point { int x, y; inline bool operator<(const point &a) const { return x < a.x; } } arr[100005]; struct query_tp { int col, l, r, delta; query_tp() {} query_tp(int _col, int _l, int _r, int _delta) { col = _col; l = _l; r = _r; delta = _delta; } inline bool operator<(const query_tp &a) const { return col < a.col; } }; long long ans[100005]; int main() { int n, k; scanf( %d%d , &n, &k); for (int i = 0; i < n; i++) scanf( %d%d , &arr[i].x, &arr[i].y); sort(arr, arr + n); vector<query_tp> query; vector<int> app; for (int i = 0; i < n; i++) { int l = arr[i].x - k; if (app.size()) l = max(l, *app.rbegin()); for (int j = l + 1; j <= arr[i].x; j++) app.push_back(j); query.push_back(query_tp(arr[i].y - k + 1, arr[i].x - k + 1, arr[i].x, 1)); query.push_back(query_tp(arr[i].y + 1, arr[i].x - k + 1, arr[i].x, -1)); } sort(query.begin(), query.end()); int cnt = app.size(), q_cnt = query.size(); for (int i = 0; i < q_cnt; i++) { query[i].l = lower_bound(app.begin(), app.end(), query[i].l) - app.begin(); query[i].r = lower_bound(app.begin(), app.end(), query[i].r) - app.begin(); } app.clear(); vector<int>().swap(app); vector<int> lst(cnt, -1e9), num(cnt, 0); for (int i = 0; i < q_cnt; i++) { for (int j = query[i].l; j <= query[i].r; j++) { if (lst[j] != -1e9) ans[num[j]] += query[i].col - lst[j]; num[j] += query[i].delta; lst[j] = query[i].col; } } for (int i = 1; i <= n; i++) printf( %lld%c , ans[i], n [i == n]); return 0; } |
#include <bits/stdc++.h> using namespace std; const int lim = 200005; long long int n; vector<vector<long long int> > ans; vector<long long int> ed; void solve(int test) { cin >> n; for (int(i) = 0; (i) < n; (i)++) { long long int v; cin >> v; vector<long long int>::iterator ind = upper_bound((ed).begin(), (ed).end(), -v); if (ind == ed.end()) { ed.push_back(-v); ans.push_back(vector<long long int>(1, v)); } else { int x = ind - ed.begin(); ed[x] = -v; ans[x].push_back(v); } } for (int(i) = 0; (i) < int((ans).size()); (i)++) { for (int(j) = 0; (j) < int((ans[i]).size()); (j)++) { cout << ans[i][j] << ; } cout << endl; } } int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); long long int test = 1; for (int(i) = 0; (i) < test; (i)++) { solve(i + 1); } return 0; } |
#include <bits/stdc++.h> using namespace std; long long nxt(long long x) { long long mn = 10; long long mx = 0; long long xx = x; while (x > 0) { mn = min(mn, x % 10); mx = max(mx, x % 10); x /= 10; } return xx + mn * mx; } signed main() { long long t; cin >> t; while (t--) { long long a1, k; cin >> a1 >> k; k--; while (k--) { if (a1 == nxt(a1)) break; a1 = nxt(a1); } cout << a1 << n ; } } |
#include <bits/stdc++.h> const int MAX = 2000010, mod = 1000000007; int n, m, mp[MAX], c[MAX], d[MAX], ds[MAX]; bool ty[MAX]; void upd(int i, int x) { x > d[i] ? d[i] = x, ds[i] = 1 : x == d[i] ? ds[i]++ : 0; } int main() { scanf( %d , &n); for (int p; n--;) scanf( %d , &p), c[p > m ? m = p : p]++; for (int i = 2; i <= m; i++) if (!mp[i]) for (int j = i; j <= m; j += i) if (!mp[j]) mp[j] = i; int s = 1, t = 0; for (int i = m; i; i--) for (int j = c[i]; j--;) { if (d[i]) { for (int x = i - 1; x > 1;) { int p = mp[x], c = 0; for (; x % p == 0; x /= p) c++; for (int e = d[p]; e < c; e++) s = 1ll * s * p % mod; upd(p, c); } ty[i] = 1; } else upd(i, 1), s = 1ll * s * i % mod; } for (int i = m; i; i--) if (ty[i]) { bool fl = 1; for (int x = i - 1; x > 1;) { int p = mp[x], c = 0; for (; x % p == 0; x /= p) c++; if (c == d[p] && ds[p] == 1) fl = 0; } if (fl) t = 1; } printf( %d n , (s + t) % mod); } |
#include <bits/stdc++.h> using namespace std; const int maxn = 10e5; int minc, maxk = 0; long long int a[maxn], c[maxn]; int main() { ios::sync_with_stdio(0), cin.tie(0), cout.tie(0); cout << setprecision(30); int n, s; cin >> n >> s; for (int i = 0; i < n; i++) cin >> a[i]; int l = 0, r = n + 1; while (r - l > 1) { long long int mid = (l + r) / 2, tc = 0; for (int i = 0; i < n; i++) c[i] = mid * (i + 1) + a[i]; sort(c, c + n); for (int i = 0; i < mid; i++) tc += c[i]; if (tc > s) { r = mid; } if (tc <= s) { minc = tc; maxk = mid; l = mid; } } cout << maxk << << minc; return 0; } |
#include <bits/stdc++.h> using namespace std; const int NMax = 100005; vector<int> G[NMax]; long double Array[NMax]; int DP[NMax], N; void Read() { cin >> N; for (int i = 1; i < N; i++) { int x; cin >> x; G[x].push_back(i + 1); } } void buildDP(int node) { DP[node] = 1; for (int i = 0; i < G[node].size(); i++) { int neighb = G[node][i]; buildDP(neighb); DP[node] += DP[neighb]; } } void DFS(int node) { int sz = G[node].size(); for (int i = 0; i < G[node].size(); i++) { int neighb = G[node][i]; Array[neighb] = Array[node] + 0.5 * ((long double)DP[node] - 1.0 - DP[neighb]) + 1.0; DFS(neighb); } } void Print() { for (int i = 1; i <= N; i++) cout << fixed << setprecision(2) << Array[i] << ; cout << n ; } int main() { Read(); buildDP(1); Array[1] = 1.0; DFS(1); Print(); return 0; } |
#include <bits/stdc++.h> using namespace std; void no() { cout << IMPOSSIBLE << endl; exit(0); } int main() { cin.sync_with_stdio(false); int n, m; cin >> n >> m; int answer = 0; int last_day = 0, last_h = 0; for (int i = 0; i < m; i++) { int cur, h; cin >> cur >> h; if (i == 0) { answer = h + cur - 1; } else { answer = max(answer, h); int dif = abs(h - last_h); int days = cur - last_day; if (dif > days) no(); if (h >= last_h) { answer = max(answer, h + (days - dif) / 2); } else { answer = max(answer, last_h + (days - dif) / 2); } } last_day = cur; last_h = h; } answer = max(answer, last_h + n - last_day); cout << answer << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; set<pair<long long, long long> > s[17]; long long a[100002]; long long g[100002]; signed main() { ios ::sync_with_stdio(0), cin.tie(0), cout.tie(0); long long n, m; cin >> n >> m; for (long long i = 0; i <= n; i++) g[i] = (i * (i + 1)) / 2LL; long long ans = 0; for (long long i = 0; i <= n - 1; i++) cin >> a[i]; for (long long j = 0; j <= 16; j++) { for (long long i = 0; i <= n - 1; i++) { if (a[i] & (1LL << j)) { long long len = 1; long long st = i; i++; while (1) { if (i == n or !(a[i] & (1LL << j))) { s[j].insert({st, len}); ans += (g[len] * (1LL << j)); break; } len++; i++; } } } } while (m--) { long long idx, val, pval; cin >> idx >> val; idx--; pval = a[idx]; for (long long j = 0; j <= 16; j++) { if (val & (1LL << j) and !(pval & (1LL << j))) { auto it = s[j].lower_bound({idx, 1e9}); if (it == s[j].end() or (*it).first != idx + 1) s[j].insert({idx, 1}), ans += (1LL << j); else ans += (1LL << j) * ((*it).second + 1), s[j].insert({idx, (*it).second + 1}), s[j].erase(it); it = s[j].lower_bound({idx, -1}); if (it != s[j].begin()) { auto pt = prev(it); if ((*pt).second + (*pt).first - 1 == idx - 1) { ans -= (1LL << j) * (g[(*pt).second] + g[(*it).second]), ans += (1LL << j) * g[(*it).second + (*pt).second], s[j].insert({(*pt).first, (*pt).second + (*it).second}), s[j].erase(it), s[j].erase(pt); } } } else if (pval & (1LL << j) and !(val & (1LL << j))) { auto it = s[j].lower_bound({idx, -1}); if (it != s[j].end() and (*it).first == idx) { if ((*it).second == 1) ans -= (1LL << j), s[j].erase({idx, 1}); else ans -= (1LL << j) * ((*it).second), s[j].insert({idx + 1, (*it).second - 1}), s[j].erase(it); } else { it = prev(it); if ((*it).first + (*it).second - 1 == idx) ans -= (1LL << j) * ((*it).second), s[j].insert({(*it).first, (*it).second - 1}), s[j].erase(it); else { ans -= (1LL << j) * g[(*it).second], ans += (1LL << j) * g[idx - 1 - (*it).first + 1], ans += (1LL << j) * g[(*it).first + (*it).second - 1 - idx - 1 + 1]; s[j].insert({(*it).first, idx - 1 - (*it).first + 1}), s[j].insert( {idx + 1, (*it).first + (*it).second - 1 - idx - 1 + 1}), s[j].erase(it); } } } } a[idx] = val; cout << ans << n ; } } |
#include <bits/stdc++.h> using namespace std; long long aa[33]; long long a[33], b[33], k[33], p[33]; long long n, u, r; long long ans = -1e10; void dfs(long long d, long long pre) { if ((u - d) % 2 == 0) { long long t = 0; for (int i = 1; i <= n; i++) t = t + a[i] * k[i]; ans = max(ans, t); } if (d == u) return; long long tmp[33]; for (int i = 1; i <= n; i++) tmp[i] = a[i]; for (int i = 1; i <= n; i++) aa[i] = a[i]; if (pre != 1) { for (int i = 1; i <= n; i++) a[i] = a[i] ^ b[i]; dfs(d + 1, 1); for (int i = 1; i <= n; i++) a[i] = tmp[i]; } for (int i = 1; i <= n; i++) aa[i] = a[p[i]] + r; for (int i = 1; i <= n; i++) a[i] = aa[i]; dfs(d + 1, -1); for (int i = 1; i <= n; i++) a[i] = tmp[i]; } int main() { cin >> n >> u >> r; for (int i = 1; i <= n; i++) scanf( %I64d , &a[i]); for (int i = 1; i <= n; i++) scanf( %I64d , &b[i]); for (int i = 1; i <= n; i++) scanf( %I64d , &k[i]); for (int i = 1; i <= n; i++) scanf( %I64d , &p[i]); dfs(0, -1); cout << ans << endl; } |
#include <bits/stdc++.h> using namespace std; vector<int> e[300020]; int f[300020][3]; inline int Mod(int x) { return x + ((x >> 31) & 998244353); } void DFS(int x, int p) { int i, v; f[x][0] = 1; f[x][1] = 1; f[x][2] = 1; for (i = 0; i < (signed)e[x].size(); i++) if ((v = e[x][i]) != p) { DFS(v, x); f[x][0] = (long long)f[x][0] * Mod(f[v][1] + 2 * Mod(f[v][0] + f[v][2] - 998244353) % 998244353 - 998244353) % 998244353; f[x][1] = (long long)f[x][1] * Mod(f[v][0] + f[v][2] - 998244353) % 998244353; f[x][2] = (long long)f[x][2] * Mod(2 * f[v][0] % 998244353 + f[v][2] - 998244353) % 998244353; } f[x][2] = Mod(f[x][2] - f[x][1]); return; } int main(void) { int n, u, v; int i; scanf( %d , &n); for (i = 1; i < n; i++) { scanf( %d %d , &u, &v); e[--u].push_back(--v); e[v].push_back(u); } DFS(0, 0); printf( %d n , Mod(Mod(f[0][0] + f[0][2] - 998244353) - 1)); return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(0); int n; cin >> n; int a[n]; map<int, int> mp; for (int i = 0; i < n; i++) { cin >> a[i]; mp[a[i]]++; } long long ans = 0; for (int i = 0; i < n; i++) { for (int j = 0; j < 32; j++) { int p = 1 << j; if (p < a[i]) { continue; } ans += mp[p - a[i]]; if (a[i] == p - a[i]) { ans--; } } } ans /= 2; cout << ans; return 0; } |
#include <bits/stdc++.h> int main() { int n, m; scanf( %d %d , &n, &m); int msg1[n]; int msg2[m]; for (int i = 0; i < n; i++) { scanf( %d , &msg1[i]); } for (int i = 0; i < m; i++) { scanf( %d , &msg2[i]); } for (int i = 1; i < n; i++) { msg1[i] = msg1[i] + msg1[i - 1]; } for (int i = 1; i < m; i++) { msg2[i] = msg2[i] + msg2[i - 1]; } int count = 0; int i = 0, j = 0; while (i < n && j < m) { if (msg1[i] < msg2[j]) i++; else if (msg1[i] > msg2[j]) j++; else { i++; j++; count++; } } printf( %d , count); } |
#include <bits/stdc++.h> using namespace std; const double pi = 3.141592653589793238462; int n, m, r, w[70][70][70], d[70][70][2000], a, b, c; const int inf = 2000000000; void deb(int q) { for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) printf( %d , d[i][j][q]); printf( n ); } printf( n ); } int main() { scanf( %d%d%d , &n, &m, &r); for (int i = 1; i <= m; i++) for (int j = 1; j <= n; j++) for (int k = 1; k <= n; k++) scanf( %d , &w[j][k][i]); for (int t = 1; t <= m; t++) for (int k = 1; k <= n; k++) for (int i = 1; i <= n; i++) for (int j = 1; j <= n; j++) w[i][j][t] = min(w[i][j][t], w[i][k][t] + w[k][j][t]); for (int i = 1; i <= n; i++) for (int j = 1; j <= n; j++) { d[i][j][0] = inf; for (int t = 1; t <= m; t++) d[i][j][0] = min(d[i][j][0], w[i][j][t]); } for (int i = 1; i <= 1000; i++) for (int j = 1; j <= n; j++) for (int k = 1; k <= n; k++) { d[j][k][i] = inf; for (int q = 1; q <= n; q++) d[j][k][i] = min(d[j][k][i], d[j][q][i - 1] + d[q][k][0]); } for (int i = 1; i <= r; i++) { scanf( %d%d%d , &a, &b, &c); printf( %d n , d[a][b][c]); } return 0; } |
#include<bits/stdc++.h> using namespace std; const int N = 2000 + 10; int n; bool flag[N]; bool Query(int l1, int r1, int l2, int r2) { printf( ? %d %d n , r1 - l1 + 1, r2 - l2 + 1); for (int i = l1; i <= r1; i++) printf( %d%c , i, n [i == r1]); for (int i = l2; i <= r2; i++) printf( %d%c , i, n [i == r2]); fflush(stdout); int res; scanf( %d , &res); return res; } void Solve() { scanf( %d , &n); for (int i = 1; i <= n; i++) flag[i] = 0; for (int i = 2; i <= n; i++) { if (Query(1, i - 1, i, i)) { // printf( i = %d n , i); flag[i] = 1; for (int j = i + 1; j <= n; j++) { if (Query(i, i, j, j)) { flag[j] = 1; } } int L = 1, R = i - 1, ans = 0; while (L <= R) { // printf( L = %d, R = %d n , L, R); int M = (L + R) >> 1; if (Query(1, M, i, i)) R = M - 1, ans = M; else L = M + 1; } // printf( ans = %d n , ans); flag[ans] = 1; break; } } // puts( ans ); // for (int i = 1; i <= n; i++) { // } vector <int> ans; for (int i = 1; i <= n; i++) { if (!flag[i]) { ans.push_back(i); } } printf( ! %d n , ans.size()); for (auto x : ans) { printf( %d , x); } puts( ); fflush(stdout); } int main(){ srand(time(0)); #ifndef ONLINE_JUDGE // freopen( data.in , r , stdin); // freopen( tst.out , w , stdout); clock_t st = clock(); #endif int T = 1; scanf( %d , &T); while (T--) { Solve(); } #ifndef ONLINE_JUDGE clock_t ed = clock(); printf( time : %.6lfs n , 1.0 * (ed - st) / CLOCKS_PER_SEC); #endif return 0; } |
#include <bits/stdc++.h> using namespace std; long long mod = 1000000007; int m = 0; int block[5005]; long long f[5005]; int main() { int n, tmp; int num_of_for = 0; cin >> n; tmp = n; while (tmp--) { char c; cin >> c; if (c == s ) { block[m] = num_of_for; num_of_for = 0; m++; } else { num_of_for++; } } for (int k = 0; k < n; k++) { f[k] = 1; } for (int i = m - 1; i >= 0; i--) { f[0] = f[block[i]]; for (int k = 1; k < n; k++) { if (block[i] + k < n) { f[k] = f[k - 1] + f[block[i] + k]; } else { f[k] = f[k - 1]; } f[k] %= mod; } } cout << (f[0] + mod) % mod; return 0; } |
#include <bits/stdc++.h> using namespace std; const long long MOD = 1000000007LL; long long N; vector<long long> E[100000]; long long dp[100000][2]; long long ans = 0; long long mod_inv(long long n) { long long t = MOD - 2, p = 1, q = n; while (t > 0) { if (t % 2 == 1) p = (p * q) % MOD; q = (q * q) % MOD; t /= 2; } return p % MOD; } void dfs(long long v, long long p) { bool leaf = true; for (long long u : E[v]) if (u != p) { dfs(u, v); leaf = false; } if (leaf) { dp[v][0] = 1; dp[v][1] = 1; } else { long long ev = 1, od = 1; for (long long u : E[v]) if (u != p) { (ev *= dp[u][0]) %= MOD; (od *= dp[u][1]) %= MOD; } dp[v][0] = (ev + od) % MOD; dp[v][1] = (od + ev) % MOD; } } void dfs2(long long v, long long p, long long ev, long long od) { long long _ev = 1, _od = 1; for (long long u : E[v]) if (u != p) { (_ev *= dp[u][0]) %= MOD; (_od *= dp[u][1]) %= MOD; } if (p != -1) { long long d = _ev * ev % MOD + _od * od % MOD; ans += d; ans %= MOD; } else { ans += dp[v][0]; ans %= MOD; } long long cnt = 0; for (long long u : E[v]) if (u != p) { cnt++; } for (long long u : E[v]) if (u != p) { long long nev, nod, s; if (cnt == 1) { s = ev + od; nev = s; nod = s; } else if (p == -1) { s = _ev * mod_inv(dp[u][0]) % MOD + _od * mod_inv(dp[u][1]) % MOD; nev = s; nod = s; } else { s = _ev * mod_inv(dp[u][0]) % MOD * ev % MOD + _od * mod_inv(dp[u][1]) % MOD * od % MOD; nev = s; nod = s; } nev %= MOD; nod %= MOD; dfs2(u, v, nev, nod); } } int main(void) { cin >> N; for (long long i = ((long long)0); i < ((long long)N - 1); i++) { long long A, B; cin >> A >> B; A--; B--; E[A].push_back(B); E[B].push_back(A); } dfs(0, -1); dfs2(0, -1, 1, 0); cout << ans << endl; } |
#include <bits/stdc++.h> using namespace std; long long int Lpow(long long int a, long long int b) { long long int ans = 1; while (b > 0) { if (b % 2) ans = (ans * a); a = (a * a); b = b / 2; } return ans; } long long int Lpow(long long int a, long long int b, long long int M) { long long int ans = 1; while (b > 0) { if (b % 2) ans = (ans * a) % M; a = (a * a) % M; b = b / 2; } return ans; } int main() { ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL); int n; cin >> n; vector<int> brr; int f1 = 0; int f2 = 0; for (int i = 0; i < n; i++) { int x; cin >> x; int sum = 0; int y; int sum2 = 0; for (int j = 0; j < x; j++) { cin >> y; if (j > ((x - 1) / 2)) sum += y; if (j < (x / 2)) sum2 += y; if (x % 2 == 1 && j == x / 2) brr.push_back(y); } f1 += sum2; f2 += sum; } sort(brr.begin(), brr.end()); reverse(brr.begin(), brr.end()); for (int i = 0; i < brr.size(); i += 2) f1 += brr[i]; for (int i = 1; i < brr.size(); i -= -2) f2 += brr[i]; cout << f1 << << f2 << n ; return 0; } |
#include <bits/stdc++.h> const int MAX_N = 102; using namespace std; string s; int dp[52][11]; long long numberOfways(int i, int digit) { if (i == s.length()) return 1; if (dp[i][digit] != -1) return dp[i][digit]; dp[i][digit] = 0; int curDigit = s[i] - 0 ; int newDigit = curDigit + digit; if (newDigit % 2) { return dp[i][digit] += numberOfways(i + 1, newDigit / 2) + numberOfways(i + 1, newDigit / 2 + 1); } else { return dp[i][digit] += numberOfways(i + 1, newDigit / 2); } } int main() { { ios_base::sync_with_stdio(false); cin.tie(NULL); }; memset(dp, -1, sizeof(dp)); cin >> s; long long ans = 0; for (int i = 0; i <= 9; i++) { ans += numberOfways(1, i); } bool ownNumber = true; for (int i = 0; i < s.length() - 1; i++) { int digit = abs(s[i] - s[i + 1]); if (digit > 1) { ownNumber = false; break; } } if (ownNumber) ans--; cout << ans; return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int n, m; cin >> n >> m; vector<int> w(n); for (int i = 0; i < n; i++) cin >> w[i]; int x = 0; vector<int> ord(n); vector<int> rd(m); vector<bool> put(n, false); for (int i = 0; i < m; i++) { cin >> rd[i]; rd[i]--; if (put[rd[i]]) continue; else { ord[x] = rd[i]; put[rd[i]] = true; x++; } } for (int i = 0; i < n; i++) { if (!put[i]) { ord[x] = i; x++; } } int lift = 0; for (int i = 0; i < m; i++) { int in = 0; for (int j = 0; j < n; j++) { if (ord[j] == rd[i]) { in = j; } } for (int j = in; j > 0; j--) { ord[j] = ord[j - 1]; lift += w[ord[j]]; } ord[0] = rd[i]; } cout << lift << endl; } |
#include <bits/stdc++.h> using namespace std; using pii = pair<int, int>; const int rows[5] = {3, 4, 5, 4, 3}; bool dp[1 << 19], seen[1 << 19]; pii int_to_pair(int c) { pii res = {0, 0}; while (rows[res.first] <= c) { c -= rows[res.first]; res.first++; } res.second = c; return res; } int pair_to_int(pii p) { int res = 0; for (int i = 0; i < p.first; i++) res += rows[i]; res += p.second; return res; } pii next_coords(pii p, int dir) { if (dir == 0) { return {p.first, p.second - 1}; } else if (dir == 1) { if (p.first <= 2) { return {p.first - 1, p.second - 1}; } else { return {p.first - 1, p.second}; } } else if (dir == 2) { if (p.first <= 2) { return {p.first - 1, p.second}; } else { return {p.first - 1, p.second + 1}; } } else if (dir == 3) { return {p.first, p.second + 1}; } else if (dir == 4) { if (p.first >= 2) { return {p.first + 1, p.second}; } else { return {p.first + 1, p.second + 1}; } } else if (dir == 5) { if (p.first >= 2) { return {p.first + 1, p.second - 1}; } else { return {p.first + 1, p.second}; } } } void print_box(int box) { int b = 0; for (int i = 0; i < 5; i++) { for (int j = 0; j < 5 - rows[i]; j++) printf( ); for (int j = 0; j < rows[i]; j++) { printf( %c , .O [(box >> b) & 1]); b++; } printf( n ); } } bool getdp(int box) { if (box == 0) return false; if (seen[box]) { return dp[box]; } seen[box] = true; for (int i = 0; i < 19; i++) { if (!(box & (1 << i))) { continue; } for (int dir = 0; dir < 6; dir++) { int boxcpy = box; pii curr = int_to_pair(i); while (true) { if (curr.first < 0) break; if (curr.first > 4) break; if (curr.second < 0) break; if (curr.second >= rows[curr.first]) break; if (!(boxcpy & (1 << pair_to_int(curr)))) { break; } boxcpy ^= (1 << pair_to_int(curr)); if (!getdp(boxcpy)) { dp[box] = true; return true; } curr = next_coords(curr, dir); } } } return false; } int main() { int start_box = 0; for (int i = 0; i < 19; i++) { char c; cin >> c; if (c == O ) start_box |= 1 << i; } if (getdp(start_box)) { cout << Karlsson n ; } else { cout << Lillebror n ; } } |
#include <bits/stdc++.h> int n, u[1001], v[1001], dem[1001], ans = 0; using namespace std; void input() { cin >> n; for (int i = 1; i < n; i++) { cin >> u[i] >> v[i]; } } void output() { cout << ans << endl; } void solve() { for (int i = 1; i <= n; i++) { for (int j = 1; j < n; j++) { if (u[j] == i) dem[i]++; if (v[j] == i) dem[i]++; } } for (int i = 1; i <= n; i++) { if (dem[i] == 1) ans++; } } int main() { ios_base::sync_with_stdio(0); cin.tie(0); input(); solve(); output(); } |
#include <bits/stdc++.h> using namespace std; char s1[200005], s2[200005]; int len; bool judge(int p, char *s1, char *s2) { for (int i = 0; i < p; i++) { if (s1[i] != s2[i]) return 0; } return 1; } int check(int p, char *s1, char *s2) { if (p == 1) { if (s1[0] != s2[0]) return 0; return 1; } if (judge(p, s1, s2)) return 1; int len = p; if (len & 1) return 0; return (check(len / 2, s1, s2) && check(len / 2, s1 + len / 2, s2 + len / 2)) || (check(len / 2, s1 + len / 2, s2) && check(len / 2, s1, s2 + len / 2)); } int main(void) { int i, j; while (~scanf( %s%s , s1, s2)) { int len = strlen(s1); if (check(len, s1, s2)) puts( YES ); else puts( NO ); } return 0; } |
#include <bits/stdc++.h> using namespace std; vector<int> a; int main() { int n, x, ans; cin >> n >> x; ans = x; a.resize(n); for (int i = 0; i < (int)(n); i++) { cin >> a[i]; } for (int i = 0; i < (int)(n); i++) { for (int j = i; j < n; j++) { ans = max(ans, (x / a[i]) * a[j] + (x % a[i])); } } cout << ans; } |
#include <bits/stdc++.h> using namespace std; bool check(const pair<long long, long long> &a, const pair<long long, long long> &b) { if (a.first > b.first) return true; else if (a.first < b.first) return false; else { if (a.second < b.second) return true; else return false; } } int main() { long long n, k, a, b, i, ans = 0; cin >> n >> k; vector<pair<long long, long long>> v; for (i = 0; i < n; i++) { cin >> a >> b; v.push_back({a, b}); } sort(v.begin(), v.end(), check); for (i = 0; i < n; i++) { if (v[i].first == v[k - 1].first && v[i].second == v[k - 1].second) ans++; } cout << ans << n ; return 0; } |
#include <bits/stdc++.h> #pragma GCC optimize( Ofast ) #pragma GCC optimize( no-stack-protector ) #pragma GCC optimize( unroll-loops ) #pragma GCC target( sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,tune=native ) #pragma GCC optimize( fast-math ) #pragma warning(disable : 4996) using namespace std; const int MAXN = 100001; const int inf = 1000000000; const long double INF = 1.0 / 0.0; const long double EPS = 1e-7; const int mod = inf + 7; const long double PI = acos(-1.0); signed main() { ios_base::sync_with_stdio(0); cout.tie(0); cin.tie(0); ; long double d, l, v1, v2; cin >> d >> l >> v1 >> v2; cout << fixed << (l - d) / (v1 + v2); } |
#include <bits/stdc++.h> using namespace std; const long double PI = acos((long double)-1); namespace fft { template <class T> class comp { public: T real, img; comp(T a = (T)0, T b = (T)0) : real(a), img(b) {} comp conj() { return comp(this->real, -(this->img)); } comp operator=(const comp& a) { this->real = a.real, this->img = a.img; return *this; } comp operator+(const comp& b) { return comp(this->real + b.real, this->img + b.img); } comp operator-(const comp& b) { return comp(this->real - b.real, this->img - b.img); } comp operator*(const T& num) { return comp(this->real * num, this->img * num); } comp operator/(const T& num) { return comp(this->real / num, this->img / num); } comp operator*(const comp& b) { return comp(this->real * b.real - this->img * b.img, this->img * b.real + this->real * b.img); } comp operator/(const comp& b) { comp temp(b.real, -b.img); comp n = (*this) * temp; return n / (b.x * b.x + b.y * b.y); } }; comp<long double> w[1 << 20]; int rev[1 << 20]; void revbits(int newlim) { static int lim = -1; int t, j; if (newlim == lim) return; lim = newlim; int k = 0; while ((1 << k) < newlim) ++k; assert((1 << k) == newlim); for (int i = 1; i <= (int)(lim); ++i) { j = rev[i - 1]; t = k - 1; while (t >= 0 && ((j >> t) & 1)) j ^= (1 << t), --t; if (t >= 0) j ^= (1 << t), --t; rev[i] = j; } } void fft(vector<comp<long double> >& poly, int inv = false) { int len, l; revbits((int)(poly).size()); for (int i = 0; i < (int)((int)(poly).size()); ++i) if (rev[i] > i) swap(poly[i], poly[rev[i]]); comp<long double> u, v; for (len = 2, l = 1; len <= (int)(poly).size(); len += len, l += l) { if (w[l].real == 0 && w[l].img == 0) { long double ang = PI / l; comp<long double> ww(cos(ang), sin(ang)); if (l > 1) { for (int j = 0; j < l; ++j) { if (j & 1) w[l + j] = w[(l + j) >> 1] * ww; else w[l + j] = w[(l + j) >> 1]; } } else w[l] = comp<long double>(1.0, 0.0); } for (int i = 0; i < (int)(poly).size(); i += len) for (int j = 0; j < (int)(l); ++j) { u = poly[i + j], v = poly[i + j + l] * (inv ? w[l + j].conj() : w[l + j]); poly[i + j] = u + v, poly[i + j + l] = u - v; } } if (inv) for (auto& x : poly) x = x / (long double)(int)(poly).size(); } void fft2d(vector<vector<comp<long double> > >& A, bool inv = false) { for (auto& row : A) { fft(row, inv); } vector<comp<long double> > col((int)(A).size()); for (int j = 0; j < (int)((int)(A.front()).size()); ++j) { for (int i = 0; i < (int)((int)(A).size()); ++i) col[i] = A[i][j]; fft(col, inv); for (int i = 0; i < (int)((int)(A).size()); ++i) A[i][j] = col[i]; } } vector<vector<comp<long double> > > multiply( vector<vector<comp<long double> > >& x, vector<vector<comp<long double> > >& y) { int b_rows = 0, b_cols = 0; while ((1 << b_rows) <= max((int)(x).size(), (int)(y).size())) ++b_rows; ++b_rows; while ((1 << b_cols) <= max((int)(x.front()).size(), (int)(y.front()).size())) ++b_cols; ++b_cols; x.resize(1 << b_rows); y.resize(1 << b_rows); for (auto& row : x) row.resize(1 << b_cols, 0); for (auto& row : y) row.resize(1 << b_cols, 0); fft2d(x), fft2d(y); for (int i = 0; i < (int)((int)(x).size()); ++i) for (int j = 0; j < (int)((int)(x[i]).size()); ++j) x[i][j] = x[i][j] * y[i][j]; fft2d(x, 1); return x; } const int L = 805; string A[L], B[L]; int N, M, R, C, X, Y; void read() { cin >> N >> M; for (int i = 0; i < (int)(N); ++i) cin >> A[i]; cin >> R >> C; for (int i = 0; i < (int)(R); ++i) cin >> B[i]; } void solve() { X = N + R, Y = M + C; vector<vector<comp<long double> > > a(X, vector<comp<long double> >(Y)); for (int i = 0; i < (int)(N); ++i) for (int j = 0; j < (int)(M); ++j) { a[i][j].real = cos(2 * PI * (A[i][j] - a ) / 26.0), a[i][j].img = sin(2 * PI * (A[i][j] - a ) / 26.0); for (int ii = i; ii < X; ii += N) for (int jj = j; jj < Y; jj += M) a[ii][jj] = a[i][j]; } vector<vector<comp<long double> > > b(R, vector<comp<long double> >(C)); int valid = 0; for (int i = 0; i < (int)(R); ++i) for (int j = 0; j < (int)(C); ++j) { if (B[i][j] == ? ) continue; ++valid; b[R - i - 1][C - j - 1].real = cos(2 * PI * (B[i][j] - a ) / 26.0), b[R - i - 1][C - j - 1].img = -sin(2 * PI * (B[i][j] - a ) / 26.0); } vector<vector<comp<long double> > > c = multiply(a, b); for (int i = 0; i < (int)(N); ++i) { for (int j = 0; j < (int)(M); ++j) cout << ((int)(c[R - 1 + i][C - 1 + j].real + 1e-5) == valid); cout << n ; } } } // namespace fft int main() { std::ios::sync_with_stdio(false); fft::read(); fft::solve(); return 0; } |
#include <bits/stdc++.h> using namespace std; const int nax = 5005; const int mod = 1e9 + 7; const int inf = 1e9 + 120; int t[nax]; char sl[nax]; int pref[nax][nax]; int nxt[nax][nax]; int cmp(int i, int j) { if (t[i] < t[j]) return -1; if (t[i] > t[j]) return 1; return 0; } int dp(int a, int b) { int x = pref[a][b] - pref[a - 1][b]; if (x < 0) x += mod; return x; } int main() { int n; scanf( %d , &n); scanf( %s , sl); for (int i = (1); i <= ((n)); ++i) t[i] = sl[i - 1] - 0 ; for (int a = n; a >= 1; --a) for (int b = n; b > a; --b) { int& x = nxt[a][b]; if (t[a] != t[b]) x = a; else if (b == n) x = inf; else x = nxt[a + 1][b + 1]; } for (int i = (1); i <= ((n)); ++i) { for (int j = (1); j <= ((n)); ++j) pref[j][i] = 1; } for (int c = (2); c <= (n); ++c) for (int d = (c); d <= (n); ++d) { int& x = pref[c][d]; int b = c - 1; int a = b - (d - c); x = pref[b][b] - pref[max(a, 0)][b]; if (x < 0) x += mod; if (a >= 1) { int where = nxt[a][c]; if (where < c && t[where] < t[c + where - a]) { x += dp(a, b); if (x >= mod) x -= mod; } } if (t[c] == 0) x = 0; pref[c][d] = x + pref[c - 1][d]; if (pref[c][d] >= mod) pref[c][d] -= mod; } int ans = 0; for (int i = (1); i <= ((n)); ++i) ans = (ans + dp(i, n)) % mod; printf( %d n , ans); return 0; } |
#include <bits/stdc++.h> #pragma GCC optimize( O3 ) using namespace std; string to_string(string s) { return + s + ; } string to_string(const char* s) { return to_string((string)s); } string to_string(bool b) { return (b ? true : false ); } template <typename A, typename B> string to_string(pair<A, B> p) { return ( + to_string(p.first) + , + to_string(p.second) + ) ; } template <typename A> string to_string(A v) { bool first = true; string res = { ; for (const auto& x : v) { if (!first) { res += , ; } first = false; res += to_string(x); } res += } ; return res; } void debug_out() { cerr << endl; } template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) { cerr << << to_string(H); debug_out(T...); } const int N = 2e3 + 7, M = 1e4, OO = 0x3f3f3f3f; int vis[N][N]; int main() { int TCF = 1; while (TCF--) { int n; scanf( %d , &n); ; vector<pair<int, int>> p; int x, y; for (int i = 0; i < n; ++i) { scanf( %d %d , &x, &y); p.emplace_back(x, y); vis[x + 1000][y + 1000] = 1; } vector<pair<int, int>> mid; int ans = 0; for (int i = (0); i < (n); i++) { for (int j = (i + 1); j < (n); j++) { if (i == j) continue; int mx = p[i].first + p[j].first; int my = p[i].second + p[j].second; if (mx % 2 == 0 && my % 2 == 0) { mx /= 2; my /= 2; if (vis[mx + 1000][my + 1000]) { ans++; } } } } printf( %d n , ans); } } |
#include <bits/stdc++.h> using namespace std; const double eps = 1e-9; int main(void) { int n, q, a, b; scanf( %d%d%d%d , &n, &q, &a, &b); vector<int> x(n); for (int i = 0; i < n; ++i) { scanf( %d , &x[i]); } vector<double> y(n); vector<int> from(n, -1); y[0] = x[0]; for (int i = 1; i < n; ++i) { double shiftSum = 0.0; shiftSum = 0.0; double curPos = x[i]; int j; double shift = 0.0; double maxShift = q - curPos; double minShift = 1.0 - curPos; for (j = i - 1; j >= 0; j--) { shift = max(minShift, min(maxShift, shiftSum / (i - j))); double pos = curPos + shift; if (pos >= y[j] + a - eps && pos <= y[j] + b + eps) break; if (pos >= y[j] + b) { curPos -= b; } else { curPos -= a; } minShift = max(minShift, 1.0 - curPos); shiftSum += x[j] - curPos; } shift = max(minShift, min(maxShift, shiftSum / (i - j))); y[i] = x[i] + shift; from[i] = j; } vector<double> ry(n); for (int i = n - 1; i >= 0;) { double shift = y[i] - x[i]; ry[i] = y[i]; for (int j = i - 1; j > from[i]; --j) { if (ry[j + 1] >= y[j] + b) ry[j] = ry[j + 1] - b; else ry[j] = ry[j + 1] - a; } i = from[i]; } double res = 0.0; for (int i = 0; i < n; ++i) { double d = ry[i] - x[i]; res += d * d; printf( %.9lf , ry[i]); } printf( n%.9lf n , res); } |
#include <bits/stdc++.h> bool IsCircular(const std::string &s, const int n) { bool isCircular = true; for (int i = 0; i < n; i++) { int j = (i + 1) % n; isCircular &= ((s[i] == > || s[i] == - ) && (s[j] == > || s[j] == - )); } if (isCircular) return true; isCircular = true; for (int i = 0; i < n; i++) { int j = (i + 1) % n; isCircular &= ((s[i] == < || s[i] == - ) && (s[j] == < || s[j] == - )); } return isCircular; } int main() { int t; std::cin >> t; while (t--) { int n; std::string s; std::cin >> n >> s; if (IsCircular(s, n)) std::cout << n << std::endl; else { int ans = 0; for (int i = 0; i < n; i++) { int j = (i - 1 + n) % n; if (s[i] == - || s[j] == - ) ans++; } std::cout << ans << std::endl; } } return 0; } |
#include <bits/stdc++.h> using namespace std; const int N = (1 << 18) + 10; int n, m; long long tree[N], add[N]; int same[N]; int col[N]; void build(int x, int l, int r) { tree[x] = same[x] = col[x] = add[x] = 0; if (l == r) { same[x] = 1; col[x] = l + 1; return; } int s = (l + r) / 2; build(x + x + 1, l, s); build(x + x + 2, s + 1, r); } int push(int x, int l, int r) { if (add[x]) { tree[x] += (long long)(r - l + 1) * add[x]; if (l != r) { add[x * 2 + 1] += add[x]; add[x * 2 + 2] += add[x]; } add[x] = 0; } if (same[x]) { if (l != r) { same[x * 2 + 1] = same[x * 2 + 2] = 1; col[x * 2 + 1] = col[x * 2 + 2] = col[x]; } } return 0; } long long upd(int x, int l, int r, int lc, int rc, int y) { push(x, l, r); if (r < lc || l > rc) return tree[x]; if (lc <= l && r <= rc) { if (same[x]) { add[x] += abs(col[x] - y); col[x] = y; push(x, l, r); return tree[x]; } else same[x] = 1, col[x] = y; } else if (same[x] && col[x] != y) col[x] = same[x] = 0; int s = (l + r) / 2; return tree[x] = upd(x + x + 1, l, s, lc, rc, y) + upd(x + x + 2, s + 1, r, lc, rc, y); } long long get(int x, int l, int r, int lc, int rc) { push(x, l, r); if (r < lc || l > rc) return 0; if (lc <= l && r <= rc) return tree[x]; int s = (l + r) / 2; return get(x + x + 1, l, s, lc, rc) + get(x + x + 2, s + 1, r, lc, rc); } int main() { scanf( %d%d , &n, &m); build(0, 0, n - 1); int t, l, r, x; for (int i = 0; i < m; i++) { scanf( %d , &t); if (t == 1) { scanf( %d%d%d , &l, &r, &x); l--; r--; upd(0, 0, n - 1, l, r, x); } else { scanf( %d%d , &l, &r); l--; r--; printf( %I64d n , get(0, 0, n - 1, l, r)); } } return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { long long n; cin >> n; string s; cin >> s; for (long long i = 0; i < s.size(); i++) { if (s[i] == * && i + 4 <= s.size()) { for (long long j = 1; j < s.size(); j++) { if (i + 4 * j <= s.size()) { if (s[i] == * && s[i + j] == * && s[i + 2 * j] == * && s[i + 3 * j] == * && s[i + 4 * j] == * ) { cout << yes ; return 0; } } } } } cout << no ; return 0; } |
#include <bits/stdc++.h> using namespace std; const int N = 1E6 + 50; const long long p = 1E9 + 7; int n, k; long long ans, sum, f[N], s[N], fac[N], inv[N]; inline void upd(long long &a, long long b) { a += b; if (a >= p) a -= p; } inline void sub(long long &a, long long b) { a -= b; if (a < 0) a += p; } long long Pow(long long a, long long b = p - 2) { long long res = 1; for (; b; b >>= 1, a = a * a % p) if (b & 1) res = res * a % p; return res; } void init() { fac[0] = inv[0] = 1; for (register int i = 1; i <= n; ++i) fac[i] = fac[i - 1] * i % p; inv[n] = Pow(fac[n]); for (register int i = n - 1; i; --i) inv[i] = inv[i + 1] * (i + 1) % p; } int main() { scanf( %d%d , &n, &k); if (k >= n) return 0 * printf( 0 n ); init(); f[0] = s[0] = 1; for (register int i = 1; i <= k; ++i) { f[i] = fac[i], s[i] = 1; upd(sum, s[i]); } for (register int i = k + 1; i <= n; ++i) { f[i] = sum * fac[i - 1] % p; s[i] = f[i] * inv[i] % p; upd(sum, s[i]), sub(sum, s[i - k]); } for (int i = 0; i < n - k; ++i) sub(ans, s[i]); ans = ans * fac[n - 1] % p; sub(ans, f[n]); upd(ans, fac[n]); printf( %lld n , ans); return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr); cerr.tie(nullptr); int n, res = 0, t, b; cin >> n; while (n) { res++; t = n; b = -1; while (t) { b = max(b, t % 10); t /= 10; } n -= b; } cout << res << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; int N, a[55], P; double dp[55][55][55]; double fac(int n) { double ans = 1; for (int i = 0; i < (n); i++) ans *= (i + 1); return ans; } int main(int argc, char *argv[]) { scanf( %d , &N); for (int i = 0; i < (N); i++) scanf( %d , a + i); scanf( %d , &P); dp[0][0][0] = 1; for (int i = 0; i < (N); i++) for (int in = (0); in <= (N); in++) for (int p = (0); p <= (P); p++) if (dp[i][in][p]) { dp[i + 1][in][p] += dp[i][in][p]; if (p + a[i] <= P) dp[i + 1][in + 1][p + a[i]] += dp[i][in][p]; } double tmp = 0, ans = 0, sum; for (int in = (N); in >= (0); in--) { sum = 0; for (int p = (0); p <= (P); p++) sum += dp[N][in][p]; sum *= fac(in) * fac(N - in); ans += in * (sum - tmp); tmp = sum; } printf( %.9lf n , ans / fac(N)); return 0; } |
#include <bits/stdc++.h> using namespace std; const int N = 1e5 + 7; const int LG = 27; const int INF = 1e9 + 7; pair<int, int> seg[LG][N]; int mx[LG][N]; int r[N], a[N], sol[N]; pair<int, int> p[N]; int n, k; void build(int l = 0, int r = n, int d = 0) { if (r - l == 1) { seg[d][l] = make_pair(p[l].second, l); mx[d][l] = sol[l]; return; } int mid = (l + r) / 2; build(l, mid, d + 1); build(mid, r, d + 1); merge(seg[d + 1] + l, seg[d + 1] + mid, seg[d + 1] + mid, seg[d + 1] + r, seg[d] + l); int out = 0; for (int i = r - 1; i >= l; i--) { out = max(out, sol[seg[d][i].second]); mx[d][i] = out; } } pair<int, int> get(int l, int r, int val, int s = 0, int e = n, int d = 0) { if (l >= e || r <= s) return make_pair(0, 0); if (l <= s && e <= r) { int pos = lower_bound(seg[d] + s, seg[d] + e, make_pair(val, 0)) - seg[d]; int pos2 = lower_bound(seg[d] + s, seg[d] + e, make_pair(val + 1, 0)) - seg[d]; int ans1 = 0; if (pos < e) ans1 = mx[d][pos]; return make_pair(ans1, pos2 - s); } int mid = (s + e) / 2; pair<int, int> a = get(l, r, val, s, mid, d + 1); pair<int, int> b = get(l, r, val, mid, e, d + 1); return make_pair(max(a.first, b.first), a.second + b.second); } int main() { scanf( %d %d , &n, &k); for (int i = 0; i < n; i++) { scanf( %d , &r[i]); p[i].second = r[i]; } for (int i = 0; i < n; i++) { scanf( %d , &a[i]); p[i].first = a[i]; } sort(p, p + n); build(); int L = 0, R = 0; for (int i = 0; i < n; i++) { while (L < n && p[L].first + k < p[i].first) L++; while (R < n && p[i].first + k >= p[R].first) R++; sol[i] = get(L, R, p[i].second).second; } build(); int m; cin >> m; while (m--) { int x, y; scanf( %d %d , &x, &y); x--, y--; if (a[x] > a[y]) swap(x, y); int L = lower_bound(p, p + n, make_pair(a[y] - k, 0)) - p; int R = lower_bound(p, p + n, make_pair(a[x] + k + 1, 0)) - p; int ans = get(L, R, max(r[x], r[y])).first; if (ans < 2) printf( -1 n ); else printf( %d n , ans); } return 0; } |
#include <bits/stdc++.h> using namespace std; template <typename t> inline void read(t &x) { x = 0; char c = getchar(), f = 0; for (; c < 0 || c > 9 ; c = getchar()) if (c == - ) f = 1; for (; c >= 0 && c <= 9 ; c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48); if (f) x = -x; } int n, rs[100005], tp; char vs[100005]; inline void dfs(int x) { if (vs[x]) return; else vs[x] = 1, dfs(x * 2 % n), dfs((x * 2 + 1) % n), rs[++tp] = x; } int main() { read(n); if (n & 1) return puts( -1 ), 0; dfs(0); while (tp) printf( %d , rs[tp--]); return printf( 0 n ), 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int x, v, arr[1000], c = 0; cin >> x >> v; for (int i = 0; i < x - 1; i++) { cin >> arr[i]; } while (1) { sort(arr, arr + x - 1); if (v > arr[x - 2]) break; arr[x - 2]--; v++; c++; } cout << c; return 0; } |
#include <bits/stdc++.h> using namespace std; int f(char c) { return c - 48; } void soroban(int n, char *ans) { if (n < 5) { ans[0] = O ; ans[1] = - ; ans[2] = | ; for (int i = 3; i <= 7; i++) { if (i == n + 3) { ans[i] = - ; } else { ans[i] = O ; } } } else { ans[0] = - ; ans[1] = O ; ans[2] = | ; for (int i = 3; i <= 7; i++) { if (i == n - 2) { ans[i] = - ; } else { ans[i] = O ; } } } ans[8] = 0 ; } int main() { char ch[10], ans[10]; cin >> ch; for (int i = strlen(ch) - 1; i >= 0; i--) { soroban(f(ch[i]), ans); cout << ans << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; int A[5005], n, k, L[5005][5005], S[5005], E[5005]; void doc() { scanf( %d%d , &n, &k); for (int i = 1; i <= n; i++) { scanf( %d , &A[i]); } } void xuly() { sort(A + 1, A + n + 1); for (int i = 1; i <= n; i++) { S[i] = 1; E[i] = i; for (int j = i - 1; j > 0; j--) if (A[i] - A[j] <= 5) { S[i]++; E[i] = j; } else break; } for (int i = 1; i <= k; i++) { for (int j = 1; j <= n; j++) { L[i][j] = max(max(L[i][j - 1], L[i][j]), L[i - 1][E[j] - 1] + S[j]); } } cout << L[k][n]; } int main() { doc(); xuly(); return 0; } |
#include <bits/stdc++.h> using namespace std; const int INF = 1e9 + 7; const long long mod = 998244353; const int maxn = 3005; int dp[maxn][maxn]; int dp2[maxn][maxn]; long long add(long long a, long long b) { return (a + b) % mod; } long long mul(long long a, long long b) { return (a * b) % mod; } long long bin_pow(long long a, long long b) { long long res = 1; long long tmp = a; while (b) { if (b & 1) { res = mul(res, tmp); } tmp = mul(tmp, tmp); b >>= 1; } return res; } long long inv(long long a) { return bin_pow(a, mod - 2); } long long min(long long a, long long b) { if (a > b) return b; else return a; } void solve() { int n, m; cin >> n >> m; long long n_good = 0, n_bad = 0; vector<bool> flags(n); for (int i = 0; i < n; i++) { int ai; cin >> ai; flags[i] = ai == 1; } vector<long long> weights(n); for (int i = 0; i < n; i++) { int w; cin >> w; weights[i] = w; if (flags[i]) { n_good += w; } else { n_bad += w; } } for (int i = m; i >= 0; i--) { dp[i][m - i] = dp2[i][m - i] = 1; for (int j = min(m - i - 1, (long long)n_bad); j >= 0; j--) { long long total = inv(n_good + n_bad + i - j); long long tmp = mul(dp[i + 1][j], n_good + i + 1); long long tmp2 = mul(dp[i][j + 1], n_bad - j); long long tmp3 = add(tmp, tmp2); dp[i][j] = mul(tmp3, total); tmp = mul(dp2[i + 1][j], n_good + i); tmp2 = mul(dp2[i][j + 1], n_bad - j - 1); tmp3 = add(tmp, tmp2); dp2[i][j] = mul(tmp3, total); } } for (int i = 0; i < n; i++) { if (flags[i]) { cout << mul(weights[i], dp[0][0]); } else { cout << mul(weights[i], dp2[0][0]); } cout << endl; } } int main() { cin.tie(0); cout.tie(0); ios_base::sync_with_stdio(false); solve(); return 0; } |
#include <bits/stdc++.h> using namespace std; int oo = (1e9) + 7; int main() { long long n; cin >> n; vector<long long> b(n / 2 + 5, 0); for (int i = 1; i <= n / 2; i++) { scanf( %lld , &b[i]); } vector<long long> out(n + 5, 0); long long l = 0; long long r = 0; for (int i = 1; i <= n / 2; i++) { out[i] = 0; out[n - i + 1] = b[i]; if (i > 1) { if (b[i] > r) { out[i] = b[i] - r; out[n - i + 1] = r; } long long tmp = b[i]; if (out[i] < l) { out[i] = l; out[n - i + 1] = b[i] - l; } } l = out[i]; r = out[n - i + 1]; } for (int i = 1; i <= n; i++) { printf( %lld , out[i]); } return 0; } |
#include <bits/stdc++.h> using namespace std; template <typename T> inline T sqr(const T& a) { return a * a; } template <typename T> inline int sign(const T& a) { return a < 0 ? -1 : a > 0; } void task(); int main() { task(); return 0; } vector<int> z_function(string s) { int n = (int)s.length(); vector<int> z(n); for (int i = 1, l = 0, r = 0; i < n; ++i) { if (i <= r) z[i] = min(r - i + 1, z[i - l]); while (i + z[i] < n && s[z[i]] == s[i + z[i]]) ++z[i]; if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1; } return z; } int n, k; string s; int ans[int(2e6) + 10]; int add[int(2e6) + 10]; int sub[int(2e6) + 10]; void task() { ios_base::sync_with_stdio(0); cin >> n >> k; cin >> s; auto z = z_function(s); z[0] = s.length(); (void(1)); for (int len = 1; len <= n; ++len) { for (int i = 0, step = 0; i < n; i += len, ++step) { if (z[i] < len) break; if (step == k - 1) { (void(1)); add[i + len - 1]++; sub[i + len - 1 + min(len, z[i + len])]++; break; } } } int cur = 0; for (int i = 0; i < n; ++i) { cur += add[i]; ans[i] = cur > 0; cur -= sub[i]; } for (int i = 0; i < n; ++i) cout << ans[i]; } |
#include <bits/stdc++.h> using namespace std; ifstream fi( easy .inp ); ofstream fo( easy .out ); int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); int n, m; cin >> n >> m; vector<string> s; for (int i = 0; i < n; i++) { string x; cin >> x; s.push_back(x); } vector<string> a(n); for (int i = 0; i < n; i++) { string tmp = ; for (int j = 0; j < m; j++) { tmp += (j & 1 ? ( Z - s[i][j]) : (s[i][j] - A )) + A ; } a[i] = tmp; } vector<pair<string, int>> mp; for (int i = 0; i < n; i++) { mp.push_back({a[i], i}); } sort((mp).begin(), (mp).end()); for (int i = 0; i < n; i++) { cout << mp[i].second + 1 << ; } } |
#include <bits/stdc++.h> using namespace std; const long long maxn = 300000 + 10; long long n; long long ans[maxn], tot, vis[maxn], last; int main() { while (scanf( %lld , &n) != EOF) { memset(vis, 0, sizeof(vis)); memset(ans, 0, sizeof(ans)); for (int i = 0; i < n; i++) scanf( %lld , &ans[i]); last = n; tot = 0; printf( 1 ); for (int i = 0; i < n; i++) { vis[ans[i]] = 1; tot++; while (vis[last] > 0) { tot--; last--; } printf( %lld , tot + 1); } printf( n ); } return 0; } |
#include <bits/stdc++.h> #pragma GCC target( sse4,avx ) int getNimb(int c, int64_t forbidden_mask, std::map<std::pair<int, int64_t>, int>& map) { auto it = map.find(std::pair<int, int64_t>{c, forbidden_mask}); if (it != map.end()) { return it->second; } if (c == 0) { return 0; } std::vector<int> other; for (int i = 1; i <= c; i++) { if ((forbidden_mask & (1 << i)) == 0) { other.push_back(getNimb(c - i, forbidden_mask + (1 << i), map)); } } std::sort(other.begin(), other.end()); if (other.empty()) { return 0; } int j = 0; for (size_t i = 0; i < other.size(); i++) { if (j >= other.size() || other[j] != i) { map[std::pair<int, int64_t>(c, forbidden_mask)] = i; return i; } while (j < other.size() && other[j] == i) j++; } map[std::pair<int, int64_t>(c, forbidden_mask)] = other.size(); return other.size(); } int data[] = {0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10}; void run(std::istream& in, std::ostream& out) { int n; in >> n; int res = 0; for (int i = 0; i < n; i++) { int x; in >> x; res ^= data[x]; } if (res == 0) { out << YES << std::endl; } else { out << NO << std::endl; } } int main() { std::cin.sync_with_stdio(false); std::cin.tie(nullptr); run(std::cin, std::cout); return 0; } |
#include <bits/stdc++.h> using namespace std; int z[100001]; int main() { string s; int T, a, b; cin >> s; for (a = 1; a < s.size(); a++) { z[a] = z[a - 1] + (s[a] == s[a - 1]); } for (cin >> T; T--; cout << z[b - 1] - z[a - 1] << endl) cin >> a >> b; return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(0); int n; cin >> n; bool taken[n + 1]; for (int i = 0; i < n + 1; i++) taken[i] = 0; int cc = 0; for (int i = 1; i < n + 1; i++) { for (int j = 1; j <= n; j++) { int a; cin >> a; if (a == 2 && !taken[j]) taken[j] = 1, cc++; if (a == 3) { if (!taken[i]) taken[i] = 1, cc++; if (!taken[j]) taken[j] = 1, cc++; } } } cout << n - cc << endl; for (int i = 1; i < n + 1; i++) if (!taken[i]) cout << i << ; return 0; } |
#include <bits/stdc++.h> using namespace std; const long long MXN = 100 + 10; const long long Mod = 1e9 + 7; void mkay(long long &x) { if (x >= Mod) x -= Mod; } long long n, k; long long sub[MXN], DP[MXN]; long long dp[MXN][MXN][2], pd[MXN][2]; vector<long long> adj[MXN]; vector<pair<long long, long long>> A, B; void DFS(long long u, long long par) { sub[u] = dp[u][k][0] = dp[u][0][1] = 1; for (auto v : adj[u]) { if (v == par) continue; DFS(v, u); A.clear(), B.clear(); for (int i = 0; i < sub[u]; i++) A.emplace_back(i, 1); for (int i = 0; i < sub[v]; i++) B.emplace_back(i, 1); for (long long i = max(0ll, k - sub[u]); i <= k; i++) A.emplace_back(i, 0); for (long long i = max(0ll, k - sub[v]); i <= k; i++) B.emplace_back(i, 0); for (auto Pr0 : A) { long long x, a, f, s; tie(x, a) = Pr0; for (auto Pr1 : B) { long long y, b; tie(y, b) = Pr1; if (a == 0 && b == 0) { f = max(x, y - 1), s = 0; } else if (a == 0 && b == 1) { if (x - 1 >= y) f = x, s = 0; else f = y + 1, s = 1; } else if (a == 1 && b == 0) { if (y - 1 >= x) f = y - 1, s = 0; else f = x, s = 1; } else { f = max(x, y + 1), s = 1; } mkay(pd[f][s] += dp[u][x][a] * dp[v][y][b] % Mod); } } sub[u] += sub[v]; for (int f = 0; f <= sub[u]; f++) dp[u][f][1] = pd[f][1], pd[f][1] = 0; for (int f = max(0ll, k - sub[u]); f <= k; f++) dp[u][f][0] = pd[f][0], pd[f][0] = 0; } } int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); cin >> n >> k; for (int i = 1; i < n; i++) { long long u, v; cin >> u >> v; adj[u].push_back(v), adj[v].push_back(u); } DFS(1, 0); for (int f = 0; f <= k; f++) { mkay(DP[k] += dp[1][f][0]); } cout << DP[k] << n ; return 0; } |
#include <bits/stdc++.h> using namespace std; long long t, n, p[200100], c[200100], ans = 100100; bool hamin[200100]; vector<vector<long long> > cycle; bool same_color(long long ind, long long start, long long dist) { long long asdf = (start + dist) % cycle[ind].size(); while (asdf != start) { if (c[cycle[ind][start]] != c[cycle[ind][asdf]]) return false; asdf = (asdf + dist) % cycle[ind].size(); } return true; } int main() { ios::sync_with_stdio(false); cin.tie(NULL); cin >> t; while (t--) { ans = 100000000; cycle.clear(); cin >> n; for (int i = 1; i <= n; i++) hamin[i] = false; for (int i = 1; i <= n; i++) cin >> p[i]; for (int i = 1; i <= n; i++) cin >> c[i]; for (int i = 1; i <= n; i++) { if (hamin[i]) continue; long long start = i; vector<long long> fuck; fuck.push_back(start); hamin[start] = true; while (p[start] != fuck[0]) { start = p[start]; fuck.push_back(start); hamin[start] = true; } cycle.push_back(fuck); } for (long long i = 0; i < cycle.size(); i++) { for (long long j = 1; j <= cycle[i].size(); j++) { if (cycle[i].size() % j) continue; for (long long z = 0; z < j; z++) if (same_color(i, z, j)) ans = min(ans, j); } } cout << ans << n ; } } |
#include <bits/stdc++.h> using namespace std; bool comprobarNum(vector<int> aux, int num) { for (int i = 0; i < aux.size(); i++) { if (aux[i] == num) { return true; } } return false; } int main() { int n, aux; cin >> n; vector<int> s; vector<int> numR; int contador = 1; while (n--) { cin >> aux; if (comprobarNum(s, aux)) { numR.push_back(aux); } else { s.push_back(aux); } } int max = 1; for (int i = 0; i < numR.size(); i++) { for (int j = 0; j < numR.size(); j++) { if (numR[j] == numR[i]) { contador++; } } if (contador > max) max = contador; contador = 1; } cout << max << << s.size(); return 0; } |
#include <bits/stdc++.h> using namespace std; const double PI = acos(-1); int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); double n, R, r; cin >> n >> R >> r; if (r > R) return cout << NO , 0; if (2 * r == R) { if (n <= 2) return cout << YES , 0; else return cout << NO , 0; } if (2 * r > R) { if (n <= 1) return cout << YES , 0; else return cout << NO , 0; } if (2 * r < R) { double h = R - r; double t = atan2(r, (double)sqrt(h * h - r * r)); if (t * n - PI > 0.0000000000000001) cout << NO ; else cout << YES ; } return 0; } |
#include <bits/stdc++.h> using namespace std; int i, j, m, n, rev_dig[25], cnt, non_zero, anscnt; long long x, ans1[100005], ans2[100005], ans3[100005]; long long getinv(long long a, long long p) { if (a == 1) return 1; long long k = a - getinv(p % a, a); return (k * p + 1) / a; } void answer(long long a, long long b, int ty) { anscnt++; ans1[anscnt] = a; ans2[anscnt] = b; ans3[anscnt] = ty; } void getmul(int t, long long x) { long long temp = 1; long long xx = x; while (temp < t) { answer(xx, xx, 1); xx <<= 1; temp <<= 1; } temp = 1; long long now = 0; while (temp <= t) { if (temp & t) { if (now > 0) { answer(temp * x, now, 1); now += temp * x; } else { now = temp * x; } } temp <<= 1; } } int main() { anscnt = 0; scanf( %lld , &x); if (x % 4 == 1) { answer(x, x, 1); answer(x, x * 2, 1); x *= 3; } cnt = 0; long long xx = x; while (xx > 0) { cnt++; rev_dig[cnt] = xx & 1; xx >>= 1; } non_zero = 0; for (i = 1; i <= cnt; i++) { if (rev_dig[i] == 0) { non_zero = i; break; } } if (non_zero == 0) { cnt++; rev_dig[cnt] = 0; non_zero = cnt; } long long xinv = getinv(x, 1 << cnt); long long r1 = x - 1; long long t1 = r1 * xinv % (1 << cnt); getmul(t1, x); long long b = t1 * x; answer(b, x, 2); long long c = b ^ x; answer(x, c, 1); long long d = (x + c); answer(b, d, 2); long long e = b ^ d; if (e != 2) { long long r2 = x - 2; long long t2 = r2 * xinv % (1 << cnt); getmul(t2, x); long long b2 = t2 * x; answer(b2, x, 2); long long c2 = b2 ^ x; answer(x, c2, 1); long long d2 = (x + c2); answer(b2, d2, 2); long long e2 = b2 ^ d2; answer(e, e2, 2); } e = 2; while (e <= x) { answer(e, e, 1); if (e & x) { answer(e, x, 2); x = e ^ x; } e <<= 1; } printf( %d n , anscnt); for (i = 1; i <= anscnt; i++) { if (ans3[i] == 1) { printf( %lld + %lld n , ans1[i], ans2[i]); } else { printf( %lld ^ %lld n , ans1[i], ans2[i]); } } return 0; } |
#include <bits/stdc++.h> using namespace std; int ROW[] = {+1, -1, +0, +0}; int COL[] = {+0, +0, +1, -1}; int X[] = {+0, +0, +1, -1, -1, +1, -1, +1}; int Y[] = {-1, +1, +0, +0, +1, +1, -1, -1}; int KX[] = {-2, -2, -1, -1, 1, 1, 2, 2}; int KY[] = {-1, 1, -2, 2, -2, 2, -1, 1}; int basePrime[] = {1009, 1013, 1019, 1021, 1031, 1223, 1229, 1231, 1237, 1249, 1289, 1291, 1297, 1301, 1303, 353, 359, 367, 373, 379, 859, 863, 877, 881, 883, 1931, 1933, 1949, 1951, 1973, 401, 409, 419, 421, 431, 1709, 1721, 1723, 1733, 1741, 3499, 3511, 3517, 3527, 3529, 929, 937, 941, 947, 953}; template <class XXX> XXX GCD(XXX a, XXX b) { return b == 0 ? a : GCD(b, a % b); } template <class XXX> XXX LCM(XXX a, XXX b) { return a * (b / GCD(a, b)); } template <class XXX, class YYY> bool CMP(XXX a, YYY b) { return a > b; } template <class XXX> void fastread(XXX &number) { bool negative = false; register XXX c; number = 0; c = getchar(); if (c == - ) { negative = true; c = getchar(); } for (; (c > 47 && c < 58); c = getchar()) number = number * 10 + c - 48; if (negative) number *= -1; } void OPFILE() {} int main() { OPFILE(); long long int ans[600000]; ans[1] = 0LL; long long int cnt = 1; for (int i = 3; i <= 500000; i += 2) { ans[i] = ans[i - 2] + 8LL * cnt * cnt; cnt++; } int n; cin >> n; while (cin >> n) cout << ans[n] << endl; return 0; } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.