Datasets:
malteklaes
/
cpp-code-code_search_net-style

Dataset card Data Studio Files
xet
 Community
1
func_code_string
stringlengths
59
71.4k
#include <bits/stdc++.h> using namespace std; const long long mod = 1e9 + 7; const long long inf = 1e9; const long long N = (1 << 20); long long mod_expo(long long a, long long b, long long c) { long long ans = 1; while (b) { if (b & (long long)1) ans = (ans * a) % c; a = (a * a) % c; b = b >> 1; } return ans; } long long inverse(long long n) { return mod_expo(n, mod - 2, mod); } int n; int total; int a[N]; long long f[N]; int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); cin >> n; total = 1 << 20; for (int i = 0; i < n; i++) { int x; cin >> x; a[x]++; } n = 20; for (int i = 0; i < total; i++) f[i] = a[i]; for (int i = 0; i < n; i++) { for (int mask = total - 1; mask >= 0; mask--) { if ((mask & (1 << i)) == 0) f[mask] += f[mask ^ (1 << i)]; } } long long ans = 0; for (int i = 0; i < total; i++) { int bits = __builtin_popcount(i); if (bits % 2) ans -= mod_expo(2, f[i], mod); else ans += mod_expo(2, f[i], mod); ans %= mod; ans += mod; ans %= mod; } cout << ans; return 0; }
#include <bits/stdc++.h> #pragma GCC optimize( O3 ) using namespace std; vector<string> vec_splitter(string s) { s += , ; vector<string> res; while (!s.empty()) { res.push_back(s.substr(0, s.find( , ))); s = s.substr(s.find( , ) + 1); } return res; } void debug_out(vector<string> __attribute__((unused)) args, __attribute__((unused)) long long int idx, __attribute__((unused)) long long int LINE_NUM) { cout << n ; } template <typename Head, typename... Tail> void debug_out(vector<string> args, long long int idx, long long int LINE_NUM, Head H, Tail... T) { if (idx > 0) cout << , ; else cout << Line( << LINE_NUM << ) ; stringstream ss; ss << H; cout << args[idx] << = << ss.str(); debug_out(args, idx + 1, LINE_NUM, T...); } const long long int mod = 1000000007; const long long int inf = 1e18; const long long int N = 2e5 + 5; long long int dp[N][5]; string s; long long int n; string abc = abc ; long long int go(long long int idx, long long int pos) { if (pos > 3LL) { return 0; } if (idx == n) { return (pos == 3LL); } long long int &ans = dp[idx][pos]; if (ans != -1) return ans; ans = 0; if (s[idx] != ? ) { if (s[idx] == abc[pos]) { ans += go(idx + 1, pos + 1); ans %= mod; } ans += go(idx + 1, pos); ans %= mod; } else { for (char x = a ; x <= c ; x++) { if (x == abc[pos]) { ans += go(idx + 1, pos + 1); ans %= mod; } ans += go(idx + 1, pos); ans %= mod; } } return ans; } void HyperBeast() { memset(dp, -1, sizeof(dp)); cin >> n >> s; cout << go(0, 0); } int32_t main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); long long int T = 1; for (long long int ti = 1; ti <= T; ti++) { HyperBeast(); cout << n ; } }
#include <bits/stdc++.h> using namespace std; int num[100010]; int num1[100010]; int a[100010]; int main() { int n; cin >> n; int flag = 0; for (int i = 1; i <= n; i++) { cin >> num[i]; num1[i] = num[i]; } sort(num + 1, num + n + 1); sort(num1 + 1, num1 + n + 1); int tim = 0; for (int i = 1; i < n; i++) { int t = num[i + 1] - num[i]; if (t == 0) tim++; } if (tim >= 2) flag = 1; for (int i = 1; i < n; i++) { if (num1[i] == num1[i + 1]) { num1[i]--; break; } } sort(num1 + 1, num1 + n + 1); for (int i = 1; i < n; i++) { if (num1[i] == num1[i + 1] || num1[i] == -1) { flag = 1; break; } } if (flag == 1) cout << cslnb << endl; else { long long sum = 0; for (int i = 1; i <= n; i++) sum += num[i]; long long s = n * (n - 1) / 2; if ((sum - s) % 2 == 0) cout << cslnb << endl; else cout << sjfnb << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; map<int, int> nrs; for (int i = 0; i < n; i++) { int x; cin >> x; nrs[x]++; } int max_times = nrs.begin()->second; for (auto it : nrs) max_times = max(it.second, max_times); if (max_times > (n + 1) / 2) cout << NO << endl; else cout << YES << endl; }
#include <bits/stdc++.h> using namespace std; struct s { long long col, colf, flag; } node[100010 << 2]; void build(int l, int r, int tr) { node[tr].col = node[tr].colf = node[tr].flag = 0; if (l == r) { node[tr].col = l; return; } int mid = (l + r) >> 1; build(l, mid, tr << 1); build(mid + 1, r, tr << 1 | 1); } long long ABS(long long x) { if (x < 0) return -x; return x; } void pushdown(int tr, int m) { if (node[tr].flag) { node[tr << 1].flag += node[tr].flag; node[tr << 1 | 1].flag += node[tr].flag; node[tr << 1].colf += node[tr].flag * (m - (m >> 1)); node[tr << 1 | 1].colf += node[tr].flag * (m >> 1); node[tr].flag = 0; } if (node[tr].col) { node[tr << 1].col = node[tr << 1 | 1].col = node[tr].col; } } void pushup(int tr) { node[tr].colf = node[tr << 1].colf + node[tr << 1 | 1].colf; if (node[tr << 1].col == node[tr << 1 | 1].col) node[tr].col = node[tr << 1].col; else node[tr].col = 0; } void update(int L, int R, long long val, int l, int r, int tr) { if (L <= l && r <= R) { if (node[tr].col) { node[tr].colf += (r - l + 1) * ABS(node[tr].col - val); node[tr].flag += ABS(node[tr].col - val); node[tr].col = val; return; } } pushdown(tr, r - l + 1); int mid = (l + r) >> 1; if (L <= mid) update(L, R, val, l, mid, tr << 1); if (R > mid) update(L, R, val, mid + 1, r, tr << 1 | 1); pushup(tr); } long long query(int L, int R, int l, int r, int tr) { if (L <= l && r <= R) { return node[tr].colf; } pushdown(tr, r - l + 1); long long a, b; a = 0; b = 0; int mid = (l + r) >> 1; if (L <= mid) { a = query(L, R, l, mid, tr << 1); } if (R > mid) { b = query(L, R, mid + 1, r, tr << 1 | 1); } return (a + b); } int main() { int n, m; while (scanf( %d%d , &n, &m) != EOF) { build(1, n, 1); while (m--) { int op; scanf( %d , &op); if (op == 1) { int a, b; long long c; scanf( %d%d%lld , &a, &b, &c); update(a, b, c, 1, n, 1); } else { int a, b; scanf( %d%d , &a, &b); printf( %lld n , query(a, b, 1, n, 1)); } } } }
#include <bits/stdc++.h> using namespace std; template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) { os << { ; string sep; for (const auto &x : v) os << sep << x, sep = , ; return os << } ; } template <typename T> ostream &operator<<(ostream &os, const set<T> &v) { os << { ; string sep; for (const auto &x : v) os << sep << x, sep = , ; return os << } ; } template <typename T, size_t size> ostream &operator<<(ostream &os, const array<T, size> &arr) { os << { ; string sep; for (const auto &x : arr) os << sep << x, sep = , ; return os << } ; } template <typename A, typename B> ostream &operator<<(ostream &os, const pair<A, B> &p) { return os << ( << p.first << , << p.second << ) ; } template <typename A, typename B> ostream &operator<<(ostream &os, const map<A, B> &v) { os << { ; string sep; for (const auto &x : v) os << sep << x, sep = , ; return os << } ; } void dbg_out() { cerr << endl; } template <typename Head, typename... Tail> void dbg_out(Head H, Tail... T) { cerr << << H; dbg_out(T...); } mt19937 mt_rng(chrono::steady_clock::now().time_since_epoch().count()); long long rand(long long a, long long b) { return uniform_int_distribution<long long>(a, b)(mt_rng); } template <long long D, typename T> struct vec : public vector<vec<D - 1, T>> { static_assert(D >= 1, Dimensions invalid ); template <typename... Args> vec(long long n = 0, Args... args) : vector<vec<D - 1, T>>(n, vec<D - 1, T>(args...)) {} }; template <typename T> struct vec<1, T> : public vector<T> { vec(long long n = 0, const T &val = T()) : vector<T>(n, val) {} }; template <class T> bool cmin(T &a, const T &b) { return b < a ? a = b, 1 : 0; } template <class T> bool cmax(T &a, const T &b) { return a < b ? a = b, 1 : 0; } const long long N = 2e5 + 5, inf = 1e18; struct Point { long long x, y; Point operator-(Point p) { return {x - p.x, y - p.y}; } long long dist() { return x * x + y * y; } }; bool by_x(Point &a, Point &b) { return a.x < b.x; } bool by_y(Point &a, Point &b) { return a.y < b.y; } long long n, ans = 1e18; long long a[N], pref[N]; Point pt[N]; long long solve(long long L, long long R) { if (L == R) return 1e18; long long M = (L + R) / 2; sort(pt + L, pt + R + 1, by_x); long long d = min(solve(L, M), solve(M + 1, R)); long long midx = pt[L + (R - L + 1) / 2].x; vector<Point> v; for (long long i = L; i <= R; i++) { if (Point{pt[i].x - midx, 0}.dist() < d) { v.push_back(pt[i]); } } sort(v.begin(), v.end(), by_y); for (long long i = 0; i < v.size(); i++) { for (long long j = i + 1; j < v.size(); j++) { if (Point{0, v[i].y - v[j].y}.dist() > d) break; d = min(d, (v[i] - v[j]).dist()); } } return d; } int32_t main() { ios::sync_with_stdio(0); cin.tie(0); long long n; cin >> n; long long sum = 0; for (long long i = 1, u; i <= n; i++) { cin >> u; sum += u; pt[i].x = i; pt[i].y = sum; } cout << solve(1, n) << n ; }
#include <bits/stdc++.h> using namespace std; long double pi = 3.14159265358979323; int main() { int n, m, k; scanf( %d%d%d , &n, &m, &k); vector<int> a(100000, 0); vector<int> ans; for (int i = 0; i < (int)n + m; ++i) { if (a[i] < k) { for (int j = 0; j < (int)k - a[i]; ++j) ans.push_back(i); int t = a[i]; for (int j = i; j < n + i; ++j) a[j] += k - t; } else if (a[i + 1] == 0) { for (int j = i; j < n + i; ++j) a[j]++; ans.push_back(i); } } printf( %d n , ans.size()); for (int i = 0; i < (int)ans.size(); ++i) { printf( %d , ans[i] + 1); } return 0; }
#include <bits/stdc++.h> using namespace std; bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) { return (a.second < b.second); } long long gcd(long long a, long long b) { if (b == 0) return a; return gcd(b, a % b); } long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); } vector<long long> adj[1000000]; vector<bool> visited(1000000, 0); vector<long long> color(1000000, 0); long long n, k, x = 0; void DFSUtil(long long u) { visited[u] = true; x++; for (long long i = 0; i < adj[u].size(); i++) { if (visited[adj[u][i]] == false) { DFSUtil(adj[u][i]); } } } long long M = 1e9 + 7; long long DFS(long long n) { long long c = 0; for (long long u = 1; u <= n; u++) { if (visited[u] == false) { x = 0; DFSUtil(u); long long g = 1; for (long long i = 0; i < k; i++) { g *= x; g %= M; } c += g; c %= M; } } return c; } void aE(long long u, long long v) { adj[u].push_back(v); } vector<long long> v(1000000, 0); vector<long long> segTree(1000000, 0); void build(long long low, long long high, long long pos) { if (low == high) { segTree[pos] = v[low]; return; } long long mid = (low + high) / 2; build(low, mid, pos * 2); build(mid + 1, high, pos * 2 + 1); segTree[pos] = segTree[pos * 2] + segTree[pos * 2 + 1]; } long long querry(long long low, long long high, long long l, long long r, long long pos) { if (l <= low && r >= high) return segTree[pos]; else if (r < low || l > high) return 0; long long mid = (low + high) / 2; return querry(low, mid, l, r, 2 * pos) + querry(mid + 1, high, l, r, 2 * pos + 1); } void update(long long low, long long high, long long index, long long val, long long pos) { if (low == high) { v[index] = val; segTree[pos] = val; } else { long long mid = (low + high) / 2; if (low <= index && index <= mid) update(low, mid, index, val, 2 * pos); else update(mid + 1, high, index, val, 2 * pos + 1); segTree[pos] = segTree[2 * pos] + segTree[2 * pos + 1]; } } long long mes(string s1, string s2) { long long count = 0; for (long long i = 0; i < min(s1.size(), s2.size()); i++) { if (s1[i] != s2[i]) break; else count++; } return count; } int main() { cin.tie(0); cout.tie(0); ios_base::sync_with_stdio(false); cin.tie(NULL); long long n; cin >> n; vector<pair<long long, long long> > point(n); for (long long i = 0; i < n; i++) cin >> point[i].first >> point[i].second; vector<pair<long double, long double> > nonvert; vector<long long> vert; map<long long, long long> vertm; map<pair<long double, long double>, long long> nonvertm; for (long long i = 0; i < n - 1; i++) { for (long long j = i + 1; j < n; j++) { long long x1, x2, y1, y2; x1 = point[i].first; x2 = point[j].first; y1 = point[i].second; y2 = point[j].second; if (x1 == x2) { if (vertm[x1] == 0) { vert.push_back(x1); vertm[x1] = 1; } } else { long double m, c; m = (long double)(y2 - y1) / (long double)(x2 - x1); c = (long double)(x2 * y1 - x1 * y2) / (long double)(x2 - x1); if (nonvertm[make_pair(m, c)] == 0) { nonvert.push_back(make_pair(m, c)); nonvertm[make_pair(m, c)] = 1; } } } } sort((nonvert).begin(), (nonvert).end()); vector<long long> same; long double last = nonvert[0].first; for (long long i = 0; i < nonvert.size(); i++) { long long count = 0, j = i; while (1) { if (nonvert[j].first == last) { count++; j++; } else { if (count > 1) same.push_back(count); count = 0; last = nonvert[j].first; i = j - 1; break; } } } long long u = vert.size() + nonvert.size(); long long m = u * (u - 1) / 2; for (long long i = 0; i < same.size(); i++) m -= (same[i] * (same[i] - 1) / 2); if (vert.size() > 1) m -= (vert.size()) * (vert.size() - 1) / 2; cout << m << endl; }
#include <bits/stdc++.h> #pragma comment(linker, /STACK:66777216 ) using namespace std; struct node { int num, cnt; node *l, *r, *p, *path; }; typedef node *pnode; const int N = 100003; node tr[N + 1]; pnode tmp[100002]; const pnode pNull = tr + N; inline void upd(pnode v) { if (v == pNull) return; v->cnt = 1 + v->l->cnt + v->r->cnt; v->l->p = v; v->r->p = v; } pnode fnd(pnode v, int cnt) { if (v == pNull) return pNull; if (v->l->cnt >= cnt) return fnd(v->l, cnt); else if (v->l->cnt + 1 == cnt) return v; else return fnd(v->r, cnt - v->l->cnt - 1); } inline bool is_left_son(pnode v1, pnode v2) { return v1->l == v2; } void rotate(pnode v) { if (v->p == pNull) return; pnode f = v->p; if (is_left_son(f, v)) { pnode tmp = v->r; v->r = f; f->l = tmp; v->p = f->p; if (is_left_son(v->p, f)) v->p->l = v; else v->p->r = v; f->p = v; upd(f); upd(v); } else { pnode tmp = v->l; v->l = f; f->r = tmp; v->p = f->p; if (is_left_son(v->p, f)) v->p->l = v; else v->p->r = v; f->p = v; upd(f); upd(v); } v->path = f->path; } void splay(pnode v) { while (v->p != pNull) { if (v->p->p == pNull) { rotate(v); break; } if (is_left_son(v->p, v) == is_left_son(v->p->p, v->p)) { rotate(v->p); rotate(v); } else { rotate(v); rotate(v); } } } pnode merge(pnode l, pnode r) { if (l == pNull && r == pNull) return pNull; if (l == pNull) return r; if (r == pNull) return l; pnode q = fnd(r, 1); splay(q); q->l = l; upd(q); return q; } pnode getRoot(pnode v, int &cnt) { splay(v); cnt = v->l->cnt + 1; return v; } pnode expose(pnode v) { splay(v); if (v->r != pNull) { v->r->path = v; v->r->p = pNull; v->r = pNull; upd(v); } int tmp = 0; while (v->path != pNull) { pnode f = v->path; splay(f); if (f->r != pNull) { f->r->path = f; f->r->p = pNull; f->r = pNull; upd(f); } pnode old = f->path; v = merge(f, v); v->path = old; } return v; } pnode makeRoot(pnode v) { pnode root = expose(v); splay(v); return v; } int a, b, c, d, i, j, n, m, k; int mas[100004]; int main() { scanf( %d%d , &n, &m); for (int _n((n)-1), i(0); i <= _n; i++) { scanf( %d , &mas[i]); pnode q = &tr[k++]; q->l = q->r = q->p = pNull; q->cnt = 1; q->num = i; if (i + mas[i] < n) { q->path = &tr[i + mas[i]]; } else { q->path = &tr[n]; } } pnode q = &tr[k++]; q->l = q->r = q->p = q->path = pNull; q->cnt = 1; q->num = n; for (int _n((m)-1), i(0); i <= _n; i++) { scanf( %d , &a); if (a == 0) { scanf( %d%d , &a, &b); --a; pnode link = pNull; if (a + mas[a] < n) link = tr + a + mas[a]; else link = tr + n; pnode root = makeRoot(link); c = 0; pnode pa = expose(tr + a); expose(link); tr[a].path = pNull; mas[a] = b; if (a + mas[a] < n) link = tr + a + mas[a]; else link = tr + n; tr[a].path = link; } else { scanf( %d , &a); --a; makeRoot(tr + n); pnode root = expose(tr + a); pnode p = fnd(root, 2); printf( %d %d n , p->num + 1, root->cnt - 1); } } }
#include <bits/stdc++.h> using namespace std; int main() { int n, i; long long sz, ans, x, y; string s, str = ; cin >> n >> x >> y >> s; str += s[0]; for (i = 1; i < n; i++) if (s[i - 1] != s[i]) str += s[i]; sz = (long long)str.size(); if (str[0] == 0 ) sz = (sz >> 1LL) + (sz & 1); else sz = sz >> 1LL; ans = min((sz - 1) * x + y, sz * y); cout << max(0LL, ans) << endl; return 0; }
#include <bits/stdc++.h> using namespace std; long double dist(long double x1, long double y1, long double x2, long double y2) { long double D = ((x2 - x1) * (x2 - x1)) + ((y2 - y1) * (y2 - y1)); return sqrt(D); } int main() { const int inf = 1e9; int n; cin >> n; vector<pair<int, pair<pair<int, int>, long double>>> v; for (int i = 0; i < n; i++) { int x, y, t; long double p; cin >> x >> y >> t >> p; v.push_back({t, {{x, y}, p}}); } sort(v.begin(), v.end()); long double ans = 0.0; vector<long double> dp(n + 1, 0.0); for (int i = 1; i <= n; i++) dp[i] = v[i - 1].second.second; dp[0] = 0; for (int i = 0; i < n; i++) { for (int j = i - 1; j >= 0; j--) { long double x1 = (v[i].second.first.first), x2 = (v[j].second.first.first); long double y1 = v[i].second.first.second, y2 = v[j].second.first.second; if (dist(x1, y1, x2, y2) <= (long double)(v[i].first - v[j].first)) { dp[i + 1] = max(dp[i + 1], dp[j + 1] + v[i].second.second); } } ans = max(ans, dp[i + 1]); } cout << setprecision(14) << ans << n ; }
#include <bits/stdc++.h> #pragma GCC optimize( Ofast ) #pragma GCC optimize( no-stack-protector ) #pragma GCC optimize( unroll-loops ) #pragma GCC optimize( fast-math ) #pragma GCC target( sse,sse2,sse3,ssse3,popcnt,abm,mmx,tune=native ) using namespace std; int a, b, c, d, e, f, p = 1000000007, base = 157, mi = 1e9, id = 0, q, pos; int ind[300000], ans[300000], si[300000], si2[300000]; pair<int, int> reb_price[300000]; string s, s2; vector<int> vec[300000]; vector<pair<int, int>> rebra[300000]; vector<int> order; void dfs() { for (auto v : order) { int ma = 0, ma2 = 0; si[v] = 1; for (auto i : rebra[v]) { if (i.second == 0) { continue; } b += (si[i.first] + i.second - 1) / id; si[i.first] = (si[i.first] + i.second - 1) % id; if (si[i.first] > ma) { ma2 = ma; ma = si[i.first]; } else if (si[i.first] > ma2) { ma2 = si[i.first]; } } si[v] = ma + 1; if (si[v] + ma2 >= id) { si[v] = 0; b++; } } } pair<int, int> dfs2(int v, int pred, int pred2) { if (rebra[v].size() == 1 && v != 1) { rebra[v][0] = {pred2, 0}; order.push_back(v); return {v, 1}; } if (rebra[v].size() == 2 && v != 1) { if (rebra[v][0].first == pred) { auto pa = dfs2(rebra[v][1].first, v, pred2); return {pa.first, pa.second + 1}; } else { auto pa = dfs2(rebra[v][0].first, v, pred2); return {pa.first, pa.second + 1}; } } int j = 0; for (auto i : rebra[v]) { if (i.first == pred) { rebra[v][j] = {pred2, 0}; j++; continue; } rebra[v][j] = dfs2(i.first, v, v); j++; } order.push_back(v); return {v, 1}; } int readint() { int n = 0; char c; do { c = fgetc(stdin); } while (!(c == - || 0 <= c && c <= 9 )); int sign = 1; if (c == - ) { sign = -1; c = fgetc(stdin); } do { n = n * 10 + (c - 0 ); c = fgetc(stdin); } while ( 0 <= c && c <= 9 ); return n * sign; } signed main() { cin.tie(NULL); cout.tie(NULL); ios_base::sync_with_stdio(false); mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); auto seed = chrono::high_resolution_clock::now().time_since_epoch().count(); a = readint(); for (int i = 0; i < a - 1; i++) { b = readint(); c = readint(); rebra[b].push_back({c, 1}); rebra[c].push_back({b, 1}); } dfs2(1, -1, -1); for (int i = 0; i < a; i = i) { if (i == 0 || i < 500) { b = 0; id = i + 1; dfs(); cout << b << n ; ; i++; } else { b = 0; id = i + 1; dfs(); c = b; int l = i + 1, r = a / max(b, 1) + 1; b = 0; while (r - l > 1) { int res = (r + l) / 2; b = 0; id = res; dfs(); if (b == c) { l = res; } else { r = res; } } for (int j = i; j < l; j++) { cout << c << n ; ; } i = l; } } cin >> a; return 0; }
#include <bits/stdc++.h> #pragma GCC target( popcnt ) using namespace std; constexpr int siz = 1 << 9 | 1, INF = 0x7f7f7f7f; constexpr int fx[4][2] = {{1, 0}, {0, -1}, {-1, 0}, {0, 1}}; int n, m, sx, sy, cnt; long long val[9], sum[siz]; int f[21][21][siz]; char c[21][21]; pair<int, int> t[9]; queue<tuple<int, int, int> > q; inline bool check(char c) { return c == . || c == S ; } inline bool check(int first, int second, int xi, int yi, int k) { if (xi == t[k].first && yi < t[k].second) return first < xi; if (first == t[k].first && second < t[k].second) return first > xi; return false; } long long bfs(); signed main() { scanf( %d%d , &n, &m); for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) { cin >> c[i][j]; if (c[i][j] == S ) { sx = i; sy = j; } if (isdigit(c[i][j])) { cnt++; t[c[i][j] - 0 ] = make_pair(i, j); } } for (int i = 1; i <= cnt; i++) scanf( %lld , &val[i]); for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) if (c[i][j] == B ) { val[++cnt] = -INF; t[cnt] = make_pair(i, j); } for (int i = 1; i < (1 << cnt); i++) for (int j = 0; j < cnt; j++) if ((i >> j) & 1) sum[i] += val[j + 1]; printf( %lld n , bfs()); return 0; } long long bfs() { long long res(0); q.push(make_tuple(sx, sy, 0)); for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) for (int k = 0; k < (1 << cnt); k++) f[i][j][k] = -1; f[sx][sy][0] = 0; while (!q.empty()) { int first, second, s; tie(first, second, s) = q.front(); q.pop(); if (first == sx && second == sy) res = max(res, sum[s] - f[first][second][s]); for (int i = 0; i < 4; i++) { const int xi = first + fx[i][0]; const int yi = second + fx[i][1]; if (xi > 0 && xi <= n && yi > 0 && yi <= m && check(c[xi][yi])) { int si = s; for (int j = 0; j < cnt; j++) if (check(first, second, xi, yi, j + 1)) si ^= (1 << j); if (f[xi][yi][si] == -1) { f[xi][yi][si] = f[first][second][s] + 1; q.push(make_tuple(xi, yi, si)); } } } } return res; }
#include <bits/stdc++.h> using namespace std; int n, V, offset; int d[1005]; int u[1000005], v[1000005], cnt = 0; inline void print(int u, int v) { ::u[++cnt] = u + offset; ::v[cnt] = v + offset; } int main() { int i, j; scanf( %d , &n); for (i = 1; i <= n; ++i) scanf( %d , d + i); V = d[n] + 1; for (offset = 1;; ++offset) { if (!d[1]) { offset = V - d[n]; for (i = 1; i < n; ++i) d[i] = d[i + 1]; d[n--] = 0; } if (n <= 1) { for (i = 0; i < d[1]; ++i) for (j = i + 1; j <= d[1]; ++j) print(i, j); break; } for (i = 1; i <= d[n]; ++i) print(0, i); for (i = 1; i <= n; ++i) --d[i]; if (!d[1]) { d[n--] = 0; if (n <= 1) break; } } printf( %d n , cnt); for (i = 1; i <= cnt; ++i) printf( %d %d n , u[i], v[i]); return 0; }
#include <bits/stdc++.h> using namespace std; inline void boost() { ios_base::sync_with_stdio(); cin.tie(0); } const long long MAX = 1e5 + 111; const long long mod = 1e9 + 7; map<string, int> maap; vector<int> g[MAX]; int main() { boost(); int n; bool ans = false; cin >> n; string a[n + 1]; for (int i = 1; i <= n; i++) { cin >> a[i]; } for (int i = 1; i <= n; i++) { if (a[i][0] == O && a[i][1] == O ) { a[i].erase(0, 2); a[i].insert(0, ++ ); ans = true; break; } if (a[i][3] == O && a[i][4] == O ) { a[i].erase(3, 4); a[i].insert(3, ++ ); ans = true; break; } } if (ans == true) { cout << YES n ; for (int i = 1; i <= n; i++) { cout << a[i] << n ; } } else { cout << NO ; } exit(0); }
#include <bits/stdc++.h> using namespace std; template <class T, class S> ostream& operator<<(ostream& os, const pair<T, S>& v) { return os << ( << v.first << , << v.second << ) ; } template <class T> ostream& operator<<(ostream& os, const vector<T>& v) { os << [ ; for (int i = int(0); i <= int((static_cast<int>((v).size())) - 1); ++i) { if (i) os << , ; os << v[i]; } return os << ] ; } template <class T> bool setmax(T& _a, T _b) { if (_b > _a) { _a = _b; return true; } return false; } template <class T> bool setmin(T& _a, T _b) { if (_b < _a) { _a = _b; return true; } return false; } template <class T> T gcd(T _a, T _b) { return _b == 0 ? _a : gcd(_b, _a % _b); } struct Node { vector<Node*> ys; int h = -1; }; int main() { int n, k; cin >> n >> k; vector<string> ss(n); for (int i = int(0); i <= int((n)-1); ++i) cin >> ss[i]; sort((ss).begin(), (ss).end()); vector<int> height(n - 1); for (int i = int(0); i <= int((n - 1) - 1); ++i) { int j = 0; while (j < static_cast<int>((ss[i]).size()) && j < static_cast<int>((ss[i + 1]).size()) && ss[i][j] == ss[i + 1][j]) { ++j; } height[i] = j; } const function<Node*(int, int)> build = [&](int l, int r) { Node* x = new Node(); if (l + 1 == r) return x; int h = *min_element(height.begin() + l, height.begin() + r - 1); x->h = h; int i = l; for (int j = int(l); j <= int((r)-1); ++j) { if (j == r - 1 || height[j] == h) { x->ys.push_back(build(i, j + 1)); i = j + 1; } } return x; }; Node* root = build(0, n); const function<vector<int>(Node*)> solve = [&](Node* x) { if (x->h < 0) return vector<int>{0, 0}; vector<int> ans{0}; for (Node* y : x->ys) { vector<int> tmp = solve(y); vector<int> r(static_cast<int>((ans).size()) + static_cast<int>((tmp).size()) - 1); for (int i = int(0); i <= int((static_cast<int>((ans).size())) - 1); ++i) for (int j = int(0); j <= int((static_cast<int>((tmp).size())) - 1); ++j) { setmax(r[i + j], ans[i] + tmp[j] + i * j * x->h); } ans = r; } if (static_cast<int>((ans).size()) > k + 1) ans.resize(k + 1); return ans; }; vector<int> ans = solve(root); if (k < static_cast<int>((ans).size())) { cout << ans[k] << endl; } else { cout << 0 << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; const long long MOD = 1e9 + 7; long long power(long long a, long long b, long long p) { if (a == 0) return 0; long long res = 1; a %= p; while (b > 0) { if (b & 1) res = (res * a) % p; b >>= 1; a = (a * a) % p; } return res; } void solve() { long long n; cin >> n; string s; cin >> s; string t = ; for (long long i = 0; i < s.size(); i++) { if (i + 1 < s.size()) { if (s[i] == U && s[i + 1] == R ) { t += D ; i = i + 1; } else if (s[i] == R && s[i + 1] == U ) { t += D ; i = i + 1; } else { t += s[i]; } } else { t += s[i]; } } cout << t.size() << n ; } int32_t main() { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); solve(); return 0; }
#include <bits/stdc++.h> using namespace std; const int maxn = 1000010; struct Trie { int next[maxn][26], fail[maxn]; int depth[maxn]; vector<int> sons[maxn]; int _dp[maxn][2]; int root, L; int newnode() { for (int i = 0; i < 26; i++) next[L][i] = -1; return L++; } void init() { L = 0; root = newnode(); depth[root] = 0; } void insert(char buf[]) { int len = strlen(buf); int now = root; for (int i = 0; i < len; i++) { if (next[now][buf[i] - a ] == -1) next[now][buf[i] - a ] = newnode(); now = next[now][buf[i] - a ]; depth[now] = i + 1; } } void build() { queue<int> Q; fail[root] = root; for (int i = 0; i < 26; i++) if (next[root][i] == -1) next[root][i] = root; else { fail[next[root][i]] = root; Q.push(next[root][i]); } while (!Q.empty()) { int now = Q.front(); Q.pop(); for (int i = 0; i < 26; i++) if (next[now][i] == -1) next[now][i] = next[fail[now]][i]; else { fail[next[now][i]] = next[fail[now]][i]; Q.push(next[now][i]); } } } void build_edge() { for (int i = 0; i < L; i++) sons[i].clear(); for (int i = 1; i < L; i++) { int j = fail[i]; sons[j].push_back(i); } } int dp(int u) { _dp[u][0] = 0, _dp[u][1] = 1; for (int i = 0; i < sons[u].size(); i++) { int v = sons[u][i]; dp(v); _dp[u][0] += max(_dp[v][0], _dp[v][1]); _dp[u][1] += (depth[v] - depth[u] == 1) ? _dp[v][0] : max(_dp[v][0], _dp[v][1]); } return _dp[u][0]; } }; char buf[maxn]; Trie ac; int main() { int T; int n; scanf( %d , &T); while (T--) { scanf( %d , &n); ac.init(); for (int i = 0; i < n; i++) { scanf( %s , buf); ac.insert(buf); } ac.build(); ac.build_edge(); printf( %d n , ac.dp(0)); } return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 20; const int MOD = (int)1e9 + 7; const int dx[] = {0, -1, 0, 1, 0}; const int dy[] = {0, 0, 1, 0, -1}; struct Matrix { long long mat[N][N]; }; bool blocked[N][N]; int m, n, q; int size; Matrix operator*(const Matrix a, const Matrix b) { Matrix c; for (int i = 0; i < size; ++i) for (int j = 0; j < size; ++j) { c.mat[i][j] = 0; for (int k = 0; k < size; ++k) c.mat[i][j] = (c.mat[i][j] + a.mat[i][k] * b.mat[k][j]) % MOD; } return c; } Matrix power(Matrix a, int p) { Matrix ans; memset(ans.mat, 0, sizeof(ans.mat)); for (int i = 0; i < size; ++i) ans.mat[i][i] = 1; for (; p; p >>= 1) { if (p & 1) ans = ans * a; a = a * a; } return ans; } int getIndex(int x, int y) { return x * n + y; } void update(Matrix &a) { for (int i = 0; i < m; ++i) for (int j = 0; j < n; ++j) { int cur = getIndex(i, j); for (int k = 0; k < size; ++k) a.mat[cur][k] = 0; if (blocked[i][j]) continue; for (int d = 0; d < 5; ++d) { int x = i + dx[d], y = j + dy[d]; if (x < 0 || y < 0 || x >= m || y >= n || blocked[x][y]) continue; a.mat[cur][getIndex(x, y)] = 1; } } } void multiply(Matrix gap, long long ans[]) { int newAns[N]; for (int i = 0; i < size; ++i) { newAns[i] = 0; for (int j = 0; j < size; ++j) newAns[i] = (newAns[i] + ans[j] * gap.mat[i][j]) % MOD; } for (int i = 0; i < size; ++i) ans[i] = newAns[i]; } int main() { ios_base::sync_with_stdio(false); cin.tie(nullptr); cin >> m >> n >> q; size = m * n; Matrix a; update(a); long long ans[N]; memset(ans, 0, sizeof(ans)); ans[0] = 1; int lastT = 1; while (q--) { int type, x, y, t; cin >> type >> x >> y >> t; --x; --y; Matrix gap = power(a, t - lastT - 1); multiply(gap, ans); multiply(a, ans); if (type != 1) { blocked[x][y] ^= 1; update(a); } if (type == 1) cout << ans[getIndex(x, y)] << n ; lastT = t; } return 0; }
#include <bits/stdc++.h> using namespace std; const int MAXN = 110; int a[MAXN]; int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); } int main() { int n, i; while (scanf( %d , &n) == 1) { scanf( %d , &a[0]); int temp = a[0]; int mmax = a[0]; for (i = 1; i < n; i++) { scanf( %d , &a[i]); temp = gcd(temp, a[i]); mmax = max(a[i], mmax); } int ans = mmax / temp - n; if (ans & 1) printf( Alice n ); else printf( Bob n ); } return 0; }
#include <bits/stdc++.h> using namespace std; int n; vector<int> u[100005]; int d[100005]; int a[100005], b[100005], x[100005]; int p[18][100005]; int up[100005], down[100005]; void go(int i, int pr) { p[0][i] = pr; d[i] = d[pr] + 1; for (int j : u[i]) if (j != pr) { go(j, i); } } void go2(int i, int pr) { for (int j : u[i]) if (j != pr) { go2(j, i); up[i] += up[j]; down[i] += down[j]; } } int lca(int a, int b) { if (d[a] < d[b]) swap(a, b); for (int i = 17; i >= 0; i--) if (d[p[i][a]] >= d[b]) a = p[i][a]; if (a == b) return a; for (int i = 17; i >= 0; i--) if (p[i][a] != p[i][b]) { a = p[i][a]; b = p[i][b]; } return p[0][a]; } long long cof[1000005]; long long pw[1000005]; int main() { scanf( %d , &n); pw[0] = 1; for (int i = (1); i < (1000005); i++) { pw[i] = (pw[i - 1] * 2) % 1000000007ll; cof[i] = cof[i - 1] + pw[i - 1]; if (cof[i] >= 1000000007ll) cof[i] -= 1000000007ll; } for (int i = (0); i < (n - 1); i++) { int l, m, y; scanf( %d%d%d , &l, &m, &y); u[l].push_back(m); u[m].push_back(l); a[i] = l; b[i] = m; x[i] = y; } go(1, 0); for (int i = (1); i < (18); i++) for (int j = (1); j < (n + 1); j++) p[i][j] = p[i - 1][p[i - 1][j]]; int pos = 1; int k; scanf( %d , &k); for (int z = (0); z < (k); z++) { int nxt; scanf( %d , &nxt); int l = lca(pos, nxt); up[pos]++; up[l]--; down[nxt]++; down[l]--; pos = nxt; } go2(1, 0); long long res = 0; for (int i = (0); i < (n - 1); i++) if (x[i]) { if (d[a[i]] < d[b[i]]) { int r = up[b[i]]; res += cof[r]; } else { int r = down[a[i]]; res += cof[r]; } } res %= 1000000007ll; printf( %lld n , res % 1000000007ll); }
#include <bits/stdc++.h> using namespace std; const long long mod = 1e9 + 7; const int MAXX = 2e6 + 10; long long f(long long n) { long long ret = n; for (long long i = 2; i * i <= n; i++) { if (n % i == 0) { while (n % i == 0) n /= i; ret -= ret / i; } } if (n > 1) ret -= ret / n; return ret; } long long g(long long n) { return n; } long long F(long long n, long long k) { if (k == 1) return f(g(n)); if (n == 1) return 1ll; if (k & 1) return F(f(n), k - 1); else return F(g(n), k - 1); } int main() { long long n, k; scanf( %lld %lld , &n, &k); long long ans = F(n, k); printf( %lld , ans % mod); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; pair<int, int> a[105]; for (int i = 0; i < n; i++) { cin >> a[i].first; a[i].second = i + 1; } sort(a, a + n); for (int i = 0; i < n / 2; i++) cout << a[i].second << << a[n - i - 1].second << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int n, m; vector<string> checkWorks(vector<vector<bool>> arr) { vector<int> row = vector<int>(n, 2); vector<int> col = vector<int>(m, 2); row[0] = 0; for (int j = 0; j < m; j++) { col[j] = arr[0][j]; } bool works = true; for (int i = 1; i < n; i++) { for (int j = 0; j < m; j++) { bool shouldBe = arr[i][j] ^ col[j]; if (row[i] == 2) { row[i] = shouldBe; } else { if (row[i] != shouldBe) { works = false; break; } } } if (!works) break; } if (works) { string a; for (int i = 0; i < n; i++) { if (row[i]) a.push_back( 1 ); else a.push_back( 0 ); } string b; for (int j = 0; j < m; j++) { if (col[j]) b.push_back( 1 ); else b.push_back( 0 ); } vector<string> ans; ans.push_back(a); ans.push_back(b); return ans; } row[0] = 1; for (int j = 0; j < m; j++) { col[j] = !arr[0][j]; } works = true; for (int i = 1; i < n; i++) { for (int j = 0; j < m; j++) { bool shouldBe = arr[i][j] ^ col[j]; if (row[i] == 2) { row[i] = shouldBe; } else { if (row[i] != shouldBe) { works = false; break; } } } if (!works) break; } if (works) { string a; for (int i = 0; i < n; i++) { if (row[i]) a.push_back( 1 ); else a.push_back( 0 ); } string b; for (int j = 0; j < m; j++) { if (col[j]) b.push_back( 1 ); else b.push_back( 0 ); } vector<string> ans; ans.push_back(a); ans.push_back(b); return ans; } return vector<string>(); } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cin >> n >> m; vector<vector<bool>> arr = vector<vector<bool>>(n, vector<bool>(m)); vector<vector<bool>> arrCopy = vector<vector<bool>>(n, vector<bool>(m)); int x; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { cin >> x; if (x) { arr[i][j] = false; } else { arr[i][j] = true; } arrCopy[i][j] = arr[i][j]; } } vector<string> maybe = checkWorks(arr); if (maybe.size() > 0) { cout << YES << endl; cout << maybe[0] << endl; cout << maybe[1] << endl; return 0; } for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { arrCopy[i][j] = !arr[i][j]; maybe = checkWorks(arrCopy); if (maybe.size() > 0) { cout << YES << endl; cout << maybe[0] << endl; cout << maybe[1] << endl; return 0; } } } cout << NO << endl; }
#include <bits/stdc++.h> using namespace std; int n; int a[100001]; int pmid; int pfromside; char sideequal[50001]; int leftplenty, rightplenty; int ln[100001] = {0}, rn[100001] = {0}; int wn1[100001] = {0}, wn2[100001] = {0}; int possible(int l, int r) { int includemid; int left = l - 1; int right = n - r; int width = r - l + 1; if (n & 1) includemid = (l <= (n / 2 + 1) && r >= (n / 2 + 1)); else includemid = (l <= (n / 2) && r > (n / 2)); if (includemid) { if (left < right) return (left <= pfromside) && (right <= rightplenty); else return (right <= pfromside) && (left <= leftplenty); } else { int side; if (left < right) side = left; else side = right; return (side <= pfromside) && ((n - side - side - width - width) <= pmid) && (sideequal[side + width]); } } int findminr(int l) { int no, yes; if (!possible(l, n)) return 0; yes = n; if (possible(l, l)) return l; no = l; while (no != yes - 1) { int newmid = (yes + no) / 2; if (possible(l, newmid)) yes = newmid; else no = newmid; } return yes; } int main() { int i; int minr; long long total = 0; int lj, rj; cin >> n; for (i = 1; i <= n; i++) cin >> a[i]; for (i = 1; i <= n / 2; i++) { if (a[i] != a[n - i + 1]) break; } pfromside = i - 1; pmid = n & 1; lj = n / 2; rj = n / 2 + 1 + (n & 1); for (i = 0; i < n / 2; i++) { if (a[lj] != a[rj]) break; lj--; rj++; } pmid += i * 2; int wasequal, diffn = 0; lj = 1; rj = n; sideequal[0] = 1; for (i = 1; i <= n / 2; i++) { wasequal = (ln[a[lj]] == rn[a[lj]]); ln[a[lj]]++; if (ln[a[lj]] == rn[a[lj]]) diffn--; else if (wasequal) diffn++; wasequal = (ln[a[rj]] == rn[a[rj]]); rn[a[rj]]++; if (ln[a[rj]] == rn[a[rj]]) diffn--; else if (wasequal) diffn++; if (diffn == 0) sideequal[i] = 1; else sideequal[i] = 0; lj++; rj--; } int odds = 0; for (i = 1; i <= n; i++) { wn1[a[i]]++; wn2[a[i]]++; if (wn1[a[i]] & 1) odds++; else odds--; } if (odds > 1) { cout << 0; return 0; } lj = 1; for (i = 0; i < n / 2; i++) { wn1[a[lj]] -= 2; if (wn1[a[lj]] < 0) break; lj++; } leftplenty = i; rj = n; for (i = 0; i < n / 2; i++) { wn2[a[rj]] -= 2; if (wn2[a[rj]] < 0) break; rj--; } rightplenty = i; for (i = 1; i <= n; i++) { minr = findminr(i); if (minr) total = total + (long long)(n - minr + 1); } cout << total; return 0; }
#include <bits/stdc++.h> using namespace std; long long a[1003]; int main() { long long n, s; cin >> n >> s; long long miner = 0x3f3f3f3f3f3f3f3f; long long sumer = 0; for (long long i = 0; i < n; i++) { cin >> a[i]; sumer += a[i]; miner = min(miner, a[i]); } if (sumer < s) { cout << -1 << endl; return 0; } sumer = 0; for (long long i = 0; i < n; i++) { sumer += a[i] - miner; a[i] = miner; } if (sumer >= s) { cout << miner << endl; } else { long long need = s - sumer; miner -= need / n; if (need % n != 0) { miner--; } cout << miner << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; template <class T> inline T BMOD(T p, T e, T m) { T ret = 1; while (e) { if (e & 1) ret = (ret * p) % m; p = (p * p) % m; e >>= 1; } return (T)ret; } template <typename T> inline T POW(T B, T P) { if (P == 0) return 1; if (P & 1) return B * POW(B, P - 1); else return SQR(POW(B, P / 2)); } template <typename T> inline T ModInv(T b, T m) { return BMOD(b, m - 2, m); } template <typename T> inline T ABS(T a) { if (a < 0) return -a; else return a; } template <typename T> inline T gcd(T a, T b) { if (a < 0) return gcd(-a, b); if (b < 0) return gcd(a, -b); return (b == 0) ? a : gcd(b, a % b); } template <typename T> inline T lcm(T a, T b) { if (a < 0) return lcm(-a, b); if (b < 0) return lcm(a, -b); return a * (b / gcd(a, b)); } int dx[] = {-1, -1, -1, 0, 0, 1, 1, 1}; int dy[] = {-1, 0, 1, -1, 1, -1, 0, 1}; int n, x, trck[200005], arr[100005]; int main() { scanf( %d%d , &n, &x); for (int i = 1; i <= n; i++) { scanf( %d , &arr[i]); trck[arr[i]]++; } long long int res = 0; for (int i = 1; i <= 100000; i++) { int nm = i ^ x; if (trck[nm] && trck[i]) { long long int cnt = (long long int)trck[nm] * trck[i]; if (x == 0) cnt = (long long int)trck[nm] * (trck[i] - 1); res += cnt; } } res /= 2; printf( %lld , res), puts( ); 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; } char dp[21][1 << 5][161050 + 10]; char par[21][1 << 5][161050 + 10]; int n, m; int an[6], am[21]; vector<int> mask_by_cnt[6]; vector<int> to_11[161050 + 10]; int pw[11]; inline int to_number(vector<int>& v) { return v[0] + v[1] * 11 + v[2] * 11 * 11 + v[3] * 11 * 11 * 11 + v[4] * 11 * 11 * 11 * 11; } void task() { ios_base::sync_with_stdio(0); cin >> n >> m; for (int i = 0; i < n; ++i) cin >> an[i]; for (int i = 0; i < m; ++i) cin >> am[i]; pw[0] = 1; for (int i = 1; i < 11; ++i) pw[i] = pw[i - 1] * 11; for (int mask = 0; mask < (1 << n); ++mask) { vector<int> v; for (int j = 0; j < n; ++j) v.push_back((mask & (1 << j)) > 0); v.push_back(17); int cnt = 0; for (int i = v.size() - 2; i >= 0; --i) cnt += v[i] == 1 && v[i] != v[i + 1]; mask_by_cnt[cnt].push_back(mask); } for (int a = 0; a <= 10; ++a) for (int b = 0; b <= 10; ++b) for (int c = 0; c <= 10; ++c) for (int d = 0; d <= 10; ++d) for (int e = 0; e <= 10; ++e) { int number = e + d * 11 + c * 11 * 11 + b * 11 * 11 * 11 + a * 11 * 11 * 11 * 11; to_11[number] = {e, d, c, b, a}; } int limit_number = 1; for (int i = 0; i < n; ++i) limit_number *= 11; dp[0][0][0] = 1; par[0][0][0] = -1; for (int i = 0; i < m; ++i) for (int prev_mask : mask_by_cnt[i - 1 >= 0 ? am[i - 1] : 0]) for (int number = 0; number < limit_number; ++number) if (dp[i][prev_mask][number]) for (int cur_mask : mask_by_cnt[am[i]]) { int nb = number; int ok = 1; for (int j = 0; j < n; ++j) if ((prev_mask & (1 << j)) == 0 && (cur_mask & (1 << j)) > 0) { nb += pw[j]; if (to_11[number][j] == an[j]) { ok = 0; break; } } dp[i + 1][cur_mask][nb] = 1; par[i + 1][cur_mask][nb] = prev_mask; } vector<int> v = {an[0], an[1], an[2], an[3], an[4]}; int number = to_number(v); for (int mask = 0; mask < (1 << n); ++mask) { if (dp[m][mask][number]) { (void(1)); ; vector<string> ans(n, string(m, 0)); int cur_mask = mask; for (int i = m; i > 0; --i) { for (int j = 0; j < n; ++j) ans[j][i - 1] = (cur_mask & (1 << j)) > 0 ? * : . ; int prev_mask = par[i][cur_mask][number]; for (int j = 0; j < n; ++j) if ((prev_mask & (1 << j)) == 0 && (cur_mask & (1 << j)) > 0) { number -= pw[j]; } cur_mask = prev_mask; } for (int i = 0; i < n; ++i) cout << ans[i] << n ; return; } } (void(1)); ; }
#include <bits/stdc++.h> using namespace std; void magic() { int n; cin >> n; int arr[n]; for (int i = 0; i < n; ++i) { cin >> arr[i]; } sort(arr, arr + n); cout << min(arr[n - 1] - arr[1], arr[n - 2] - arr[0]) << endl; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); magic(); }
#include <bits/stdc++.h> using namespace std; long long int is_prime[1000500]; int main() { for (long long int i = 0; i < ((long long int)(1000500)); ++i) if (2 <= i) is_prime[i] = true; for (long long int i = 2; i * i < 1000500; i++) { if (!is_prime[i]) continue; for (long long int j = i * i; j < 1000500; j += i) is_prime[j] = false; } long long int a, b, k; cin >> a >> b >> k; queue<long long int> q; long long int res = -1; q.push(a - 1); for (long long int pos = a; pos <= b; pos++) { if (is_prime[pos]) q.push(pos); while (k < ((long long int)(q).size())) q.pop(); if (((long long int)(q).size()) == k) res = max(res, pos - q.front() + 1); } if (q.front() == a - 1) cout << -1 << endl; else cout << res << endl; }
#include <bits/stdc++.h> using namespace std; long long volume[100001][2]; vector<long long> sell, buy; int main() { long long n, s; cin >> n >> s; for (long long i = 0; i < n; i++) { char a; long long b, c, d; cin >> a >> b >> c; if (a == B ) d = 1; else d = 0; if (volume[b][d] == 0) { if (d == 0) sell.push_back(b); else buy.push_back(b); } volume[b][d] += c; } sort(buy.begin(), buy.end()); sort(sell.begin(), sell.end()); for (long long i = 0; i < s; i++) { if (s - i - 1 < sell.size() && s - i - 1 >= 0) cout << S << sell[s - i - 1] << << volume[sell[s - i - 1]][0] << endl; } for (long long i = 0; i < s; i++) { if (buy.size() - i - 1 >= 0) cout << B << buy[buy.size() - i - 1] << << volume[buy[buy.size() - i - 1]][1] << endl; } }
#include <bits/stdc++.h> using namespace std; long long p[2007], hs[2007]; string q, w; vector<int> k, st, st1, st2; long long hashing(long long z, long long x) { return (hs[x + 1] - hs[z]) * p[q.size() - x + 1]; } void kmp_process() { int g, h; g = 0, h = -1, k[0] = -1; while (g < w.length()) { while (h >= 0 && w[g] != w[h]) h = k[h]; g++, h++; k[g] = h; } } void kmp_matching() { int g, h; g = h = 0; while (g < q.length()) { while (h >= 0 && q[g] != w[h]) h = k[h]; g++, h++; if (h == w.length()) st.push_back(g - h), h = k[h]; } } int main() { int g, h, f; string a, s, as; vector<long long> sst; cin >> q >> a >> s; w = a; k.assign(2003, 0); kmp_process(); kmp_matching(); st1 = st; st.clear(), k.clear(); w = s; k.assign(2003, 0); kmp_process(); kmp_matching(); st2 = st; st.clear(); for (g = 0; g < st2.size(); g++) st2[g] += (s.length() - 1); p[0] = 1; for (g = 1; g <= 2003; g++) { p[g] = (p[g - 1] * 31); } for (g = 1; g <= q.length(); g++) { hs[g] = hs[g - 1] + q[g - 1] * p[g]; } long long xx = max(a.length(), s.length()); for (g = 0; g < st1.size(); g++) { h = lower_bound(st2.begin(), st2.end(), st1[g]) - st2.begin(); for (; h < st2.size(); h++) if (st2[h] - st1[g] + 1 >= xx) { long long m = hashing(st1[g], st2[h]); sst.push_back(m); } } sort(sst.begin(), sst.end()); sst.erase(unique(sst.begin(), sst.end()), sst.end()); printf( %d n , sst.size()); return 0; }
#include <bits/stdc++.h> using namespace std; struct vect { int h, p1, p2; }; struct point { int p1, p2; }; int n, mod, nr, t; long long solf; int viz[200005]; point poz[200005]; map<int, vect> h; vector<int> aib[200005]; void precalc() { int i, j, x; for (i = 0; i < n; i++) if (!viz[i]) { x = 1; j = i; nr++; do { viz[j] = nr; poz[j].p1 = x; x++; j = (j + mod) % n; } while (!viz[j]); j = i; do { poz[j].p2 = poz[j].p1 + x - 1; j = (j + mod) % n; } while (!poz[j].p2); for (j = 0; j <= 2 * x; j++) aib[nr].push_back(0); } } void update(int ind, int poz, int val) { while (poz < aib[ind].size()) { aib[ind][poz] += val; poz += poz & -poz; } } int query(int ind, int poz) { int sol = 0; while (poz > 0) { sol += aib[ind][poz]; poz -= poz & -poz; } return sol; } int find(int x) { int st = poz[x].p1, dr = poz[x].p2, m, sol = dr - 1; int nr = st - query(viz[x], st); while (st <= dr) { m = (st + dr) >> 1; if (m - query(viz[x], m) > nr) { sol = m; dr = m - 1; } else st = m + 1; } solf += sol - poz[x].p1; sol = ((1LL * (sol - poz[x].p1) * mod) % n + x) % n; return sol; } int main() { scanf( %d %d %d n , &n, &mod, &t); precalc(); vect x; char ch; int id, hash, y, z; while (t--) { scanf( %c , &ch); if (ch == - ) { scanf( %d n , &id); x = h[id]; update(x.h, x.p1, -1); update(x.h, x.p2, -1); h[id] = (vect){0, 0, 0}; } else { scanf( %d %d n , &id, &hash); x.h = viz[hash]; x.p1 = poz[hash].p1; x.p2 = poz[hash].p2; y = query(x.h, x.p1); z = query(x.h, x.p1 - 1); if (y != z) hash = find(hash); x.h = viz[hash]; x.p1 = poz[hash].p1; x.p2 = poz[hash].p2; h[id] = x; update(x.h, x.p1, 1); update(x.h, x.p2, 1); } } printf( %I64d n , solf); return 0; }
#include <bits/stdc++.h> using namespace std; int ans = 0; string searchS; map<string, int> mp; set<string> st; void getans(string s, int idx) { if (idx == searchS.size()) { if (!st.count(s)) { ans += mp[s]; st.insert(s); } return; } if (searchS[idx] == ? ) { for (int i = 0; i < 5; i++) getans(s + char(i + a ), idx + 1); getans(s, idx + 1); } else getans(s + searchS[idx], idx + 1); } void lets_hope_its_right() { int n, m; cin >> n >> m; while (n--) { string s; cin >> s; mp[s]++; } while (m--) { string s; cin >> s; ans = 0; searchS = s; st.clear(); getans( , 0); cout << ans << n ; } } int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); int tt = 1; while (tt--) lets_hope_its_right(); }
#include <bits/stdc++.h> using namespace std; const int N = 3050; int a[N]; int b[N]; long long dp[N][N]; int main() { int n, m, i, j; long long ans = 0, minPre; scanf( %d , &n); set<int> S; for (i = 1; i <= n; i++) { scanf( %d , &a[i]); a[i] -= i; S.insert(a[i]); } m = 0; for (set<int>::iterator iter = S.begin(); iter != S.end(); iter++) { b[++m] = *iter; } for (j = 1; j <= m; j++) { dp[1][j] = abs(a[1] - b[j]); } for (i = 2; i <= n; i++) { minPre = dp[i - 1][1]; for (j = 1; j <= m; j++) { minPre = min(minPre, dp[i - 1][j]); dp[i][j] = minPre + abs(a[i] - b[j]); } } ans = 1e18; for (j = 1; j <= m; j++) { ans = min(ans, dp[n][j]); } printf( %lld n , ans); return 0; }
#include <bits/stdc++.h> using namespace std; const int MAXN = 150 + 10; void remax(int& x, int y) { if (x < y) { x = y; } } int n; char s[MAXN]; int a[MAXN]; bool read() { if (scanf( %d n , &n) < 1) { return 0; } for (int i = 0; i < (int)n; ++i) { scanf( %d , &a[i + 1]); } scanf( n ); scanf( %s n , s); assert((int)strlen(s) == n); return 1; } int dp[MAXN][MAXN]; int dp_pal[MAXN][MAXN][MAXN]; int dp_full[MAXN][MAXN]; int solve() { memset(dp, 0, sizeof dp); memset(dp_full, -1, sizeof dp_full); memset(dp_pal, -1, sizeof dp_pal); for (int len = 1; len <= n; ++len) { for (int l = 0; l < (int)n - len + 1; ++l) { int r = l + len - 1; assert(r < n); { for (int m = l; m < r; ++m) { if (dp_full[l][m] != -1 && dp_full[m + 1][r] != -1) { remax(dp_full[l][r], dp_full[l][m] + dp_full[m + 1][r]); } } if (s[l] == s[r]) { if (len <= 2) { remax(dp_full[l][r], a[len]); } else { remax(dp_full[l][r], dp_pal[l + 1][r - 1][2]); } } } { for (int m = l; m < r; ++m) { remax(dp[l][r], dp[l][m] + dp[m + 1][r]); } remax(dp[l][r], dp_full[l][r]); } { for (int out = 2; out <= n - len; out += 2) { if (dp_full[l][r] != -1 && a[out] != -1) { remax(dp_pal[l][r][out], dp_full[l][r] + a[out]); } for (int m = l; m < r; ++m) { if (dp_pal[l][m][out] != -1 && dp_full[m + 1][r] != -1) { remax(dp_pal[l][r][out], dp_pal[l][m][out] + dp_full[m + 1][r]); } } for (int m = l + 1; m <= r; ++m) { if (dp_full[l][m - 1] != -1 && dp_pal[m][r][out] != -1) { remax(dp_pal[l][r][out], dp_full[l][m - 1] + dp_pal[m][r][out]); } } if (s[l] == s[r]) { if (len <= 2) { remax(dp_pal[l][r][out], a[out + len]); } else { remax(dp_pal[l][r][out], dp_pal[l + 1][r - 1][out + 2]); } } } } } } return dp[0][n - 1]; } int main() { while (read()) { printf( %d n , solve()); } return 0; }
#include <bits/stdc++.h> using namespace std; int main(void) { ios_base::sync_with_stdio(false); cin.tie(0); long long int q; cin >> q; while (q--) { long long int l1, r1, l2, r2; cin >> l1 >> r1 >> l2 >> r2; cout << l1 << << ((l1 != l2) ? l2 : r2) << n ; } }
#include <bits/stdc++.h> using namespace std; const long long INF = 1e9 + 7; const int N = 3e5 + 10; class SegmentTree { public: long long addv[N * 4]; int ql, qr, qx; void set(int l, int r, int x = 0) { ql = l, qr = r, qx = x; } void add(int l, int r, int o = 1) { if (ql <= l && r <= qr) { addv[o] += qx; return; } int mid = (l + r) >> 1; if (ql <= mid) add(l, mid, o << 1); if (mid < qr) add(mid + 1, r, o << 1 | 1); } long long query(int l, int r, int o = 1) { long long ret = addv[o]; if (l == r) { return ret; } int mid = (l + r) >> 1; if (ql <= mid) ret += query(l, mid, o << 1); if (mid < qr) ret += query(mid + 1, r, o << 1 | 1); return ret; } } st; vector<int> v[N]; vector<pair<int, int>> qr[N]; int depth[N]; int h = 0; long long ans[N]; void dfs(int x, int fa = 0) { depth[x] = depth[fa] + 1; h = max(h, depth[x]); for (auto &y : v[x]) { if (y == fa) continue; dfs(y, x); } } void solve(int x, int fa = 0) { int l = depth[x]; for (auto &p : qr[x]) { int r; int val; tie(r, val) = p; st.set(l, r, val); st.add(1, h); } st.set(l, l); ans[x] = st.query(1, h); for (auto &y : v[x]) { if (y == fa) continue; solve(y, x); } for (auto &p : qr[x]) { int r; int val; tie(r, val) = p; st.set(l, r, -val); st.add(1, h); } } int main() { int n; scanf( %d , &n); for (int i = 1; i < n; i++) { int x, y; scanf( %d%d , &x, &y); v[x].push_back(y); v[y].push_back(x); } dfs(1); int q; scanf( %d , &q); while (q--) { int x, d, val; scanf( %d%d%d , &x, &d, &val); d = min(h, depth[x] + d); qr[x].push_back({d, val}); } solve(1); for (int i = 1; i <= n; i++) printf( %lld , ans[i]); return 0; }
#include <bits/stdc++.h> using namespace std; const long long N = 2e5 + 7; const long long inf = 0x3f3f3f3f; signed main() { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); ; long long t; cin >> t; while (t--) { double pi = 3.1415926535897932384626433832795028841971, n; cin >> n; printf( %.10lf n , 1 / tan(pi / (n * 2))); } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { long long i, n, x, j, c = 0; cin >> n >> x; if (n >= x) { for (i = 2; i <= n; i++) { if (x % i == 0 && (x / i) <= n) c++; } cout << c + 1 << endl; } else { for (i = 2; i <= n; i++) { if (x % i == 0 && (x / i) <= n) c++; } cout << c << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int N; scanf( %d , &N); int P; scanf( %d , &P); vector<int> As, Bs; long long SA = 0, SB = 0; for (decltype(N) _i = 0, _n = (N); _i < _n; _i++) { int A; scanf( %d , &A); int B; scanf( %d , &B); As.push_back(A); Bs.push_back(B); SA += A; SB += B; } auto check = [&](double t) { double tmp = 0.0; for (decltype(N) i = 0, _n = (N); i < _n; i++) { tmp += max(As[i] * t - Bs[i], 0.0) / P; } return tmp <= t; }; if (SA <= P) { printf( -1 n ); } else { double l = 0.0, r = SB * 2.0; int cnt = 0; while (1e-10 < (r - l) and cnt < 1000) { cnt++; double c = (l + r) / 2; if (check(c)) { l = c; } else { r = c; } } printf( %f , l); } return 0; }
#include <bits/stdc++.h> using namespace std; const long long INF = 9e18; const long long N = 2e5 + 5; const long long M = 1e9 + 7; bool chk(vector<long long> a, long long x, long long y) { long long A = 0, B = 0; for (long long i = 2; i < a.size(); i++) if (a[i] > a[i - 1] && a[i] > a[i + 1]) A++; else if (a[i] < a[i - 1] && a[i] < a[i + 1]) B++; if (A == x && B == y) return 1; return 0; } signed main() { ios_base::sync_with_stdio(0), cin.tie(0); long long tests; cin >> tests; while (tests--) { vector<long long> a; long long n, x, y; bool ok = 0; cin >> n >> x >> y; if (abs(x - y) > 1 || x + y > n - 2) { cout << -1 n ; continue; } if (x >= y) { long long l = 1; long long r = n; while (l <= r) { a.push_back(l++); if (l > r) break; a.push_back(r--); } long long idx = 1 + 2 * y; if (x > y) idx++; sort(a.begin() + idx, a.begin() + n); if (x > y) reverse(a.begin() + idx, a.begin() + n); } else { long long l = 1; long long r = n; while (l <= r) { a.push_back(r--); if (l > r) break; a.push_back(l++); } long long idx = 2 * y; sort(a.begin() + idx, a.begin() + n); } for (auto h : a) cout << h << ; cout << n ; } }
#include <bits/stdc++.h> using namespace std; mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); int main() { ios::sync_with_stdio(0); cin.tie(0); int q; std::cin >> q; while (q--) { int n; std::cin >> n; std::cout << ((n + 6) / 7) << n ; } return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 2e3 + 10, mod = 11092019; int n, m[2], leaf[N][2], dep[N][2], p[16][2][N], pre[N][2], dist[N][N][2], dp[N][2]; vector<int> adj[N][2]; void predfs(int u, int pa, int lst, bool st) { p[0][st][u] = pa; dep[u][st] = dep[pa][st] + 1; pre[u][st] = lst; lst = (adj[u][st].size() > 1 ? u : lst); for (int v : adj[u][st]) { predfs(v, u, lst, st); } } pair<int, int> lca(int u, int v, bool st) { int dis = 0; if (dep[u][st] > dep[v][st]) swap(u, v); for (int j = 15; j >= 0; j--) { if (dep[v][st] - (1 << j) >= dep[u][st]) { dis += (1 << j); v = p[j][st][v]; } } if (u == v) return {u, dis}; dis += 2; for (int j = 15; j >= 0; j--) { if (p[j][st][u] != p[j][st][v]) { u = p[j][st][u]; v = p[j][st][v]; dis += (2 << j); } } return {p[0][st][u], dis}; } int main() { scanf( %d , &n); for (int s = 0; s < 2; s++) { scanf( %d , &m[s]); for (int i = 2; i <= m[s]; i++) { int x; scanf( %d , &x); adj[x][s].push_back(i); } for (int i = 1; i <= n; i++) { int x; scanf( %d , &x); leaf[i][s] = x; } } predfs(1, 1, 1, 0); predfs(1, 1, 1, 1); for (int j = 1; j < 16; j++) { for (int st = 0; st < 2; st++) { for (int i = 1; i <= m[st]; i++) p[j][st][i] = p[j - 1][st][p[j - 1][st][i]]; } } for (int st = 0; st < 2; st++) { for (int i = 1; i <= n; i++) { int dis = 0; vector<int> sum(m[st] + 1, 0); for (int j = i; j <= n; j++) { int v = leaf[j][st]; int u = pre[v][st]; dis += dep[v][st] - dep[u][st]; sum[u]++; while (sum[u] == adj[u][st].size()) { dis += dep[u][st] - dep[pre[u][st]][st]; u = pre[u][st]; sum[u]++; } dist[i][j][st] = dis; } } } for (int i = 1; i <= n; i++) { for (int st = 0; st < 2; st++) { for (int j = i; j >= 1; j--) dp[i][st] = max(dp[i][st], dp[j - 1][1 - st] + dist[j][i][st]); } } printf( %d n , max(dp[n][0], dp[n][1])); return 0; }
#include <bits/stdc++.h> int n, k, a[100001], is[100001], i, j, sum, ans; int main() { scanf( %d %d , &n, &k); for (i = 0; i < n; i++) scanf( %d , &a[i]); for (i = 0; i < n; i++) scanf( %d , &is[i]); for (i = 0; i < k; i++) sum += a[i]; for (i = k; i < n; i++) if (is[i]) sum += a[i]; ans = sum; for (i = 0; i < n - k + 1; i++) { if (is[i] == 0) sum -= a[i]; if (is[i + k] == 0) sum += a[i + k]; if (ans < sum) ans = sum; } printf( %d , ans); }
#include <bits/stdc++.h> using namespace std; int N, M, ans, S, T, C; pair<int, int> ap; struct edge { int u, v, w, i; bool operator<(const edge &o) const { return w < o.w; } } tmp[30300]; vector<edge> e; vector<pair<int, int>> adj[1100]; int id[1100], lo[1100], tp[1100], ep[1100]; bool art[1100]; struct uf { int p[1100]; void init() { for (int i = (1); i < (N + 1); i++) p[i] = i; } int g(int i) { return p[i] == i ? i : p[i] = g(p[i]); } bool c(int i, int j) { return g(i) == g(j); } void m(int i, int j) { p[g(i)] = g(j); } } a, b, c; void clr() { for (int i = (1); i < (N + 1); i++) { adj[i].clear(); id[i] = 0, lo[i] = 0, art[i] = 0; tp[i] = 0, ep[i] = 0; } C = 0; } void go(int i, int p) { id[i] = ++C; lo[i] = id[i]; for (auto j : adj[i]) { if (j.first == p) p = -1; else if (!id[j.first]) { tp[j.first] = i; ep[j.first] = j.second; go(j.first, i); lo[i] = min(lo[i], lo[j.first]); } else lo[i] = min(lo[i], id[j.first]); } if (lo[i] == id[i]) art[i] = 1; } int main() { scanf( %d %d %d %d , &N, &M, &S, &T); a.init(), b.init(), c.init(), ans = 2e9 + 7, ap = {-1, -1}; for (int i = (0); i < (M); i++) { scanf( %d %d %d , &tmp[i].u, &tmp[i].v, &tmp[i].w); tmp[i].i = i + 1; } sort(tmp, tmp + M); for (int i = (0); i < (M); i++) { if (!a.c(tmp[i].u, tmp[i].v)) { a.m(tmp[i].u, tmp[i].v); e.push_back(tmp[i]), e.back().i = i; } else if (!b.c(tmp[i].u, tmp[i].v)) { b.m(tmp[i].u, tmp[i].v); e.push_back(tmp[i]), e.back().i = i; } else if (!c.c(tmp[i].u, tmp[i].v)) { c.m(tmp[i].u, tmp[i].v); e.push_back(tmp[i]), e.back().i = i; } } if (!a.c(S, T)) return puts( 0 n0 ), 0; clr(); for (int i = (0); i < ((int)e.size()); i++) { adj[e[i].u].push_back({e[i].v, e[i].i}), adj[e[i].v].push_back({e[i].u, e[i].i}); } go(S, -1); int x = T; while (x != S) { if (art[x]) { if (tmp[ep[x]].w < ans) { ans = tmp[ep[x]].w; ap = {tmp[ep[x]].i, -1}; } } x = tp[x]; } for (int rem = (0); rem < ((int)e.size()); rem++) { int extra = 0, rid = -1; clr(); for (int i = (0); i < ((int)e.size()); i++) { if (i != rem) { adj[e[i].u].push_back({e[i].v, e[i].i}), adj[e[i].v].push_back({e[i].u, e[i].i}); } else extra = e[i].w, rid = tmp[e[i].i].i; } go(S, -1); if (!id[T]) continue; x = T; while (x != S) { if (art[x]) { if (tmp[ep[x]].w + extra < ans) { ans = tmp[ep[x]].w + extra; ap = {tmp[ep[x]].i, rid}; } } x = tp[x]; } } if (ans == 2e9 + 7) puts( -1 ); else { printf( %d n , ans); if (ap.second == -1) { printf( 1 n%d n , ap.first); } else { printf( 2 n%d %d n , ap.first, ap.second); } } return 0; }
#include <bits/stdc++.h> using namespace std; const int inf = 0x3f3f3f3f; const int N = 1e6 + 100; int n, m, q; struct Qu { int op, x; } qu[N]; struct Edge { int u, v, w; bool operator<(const Edge& t) const { return w < t.w; } } edge[N]; struct Max { int val, pos; Max() {} Max(int val, int pos) : val(val), pos(pos) {} static Max inf() { return Max(-0x3f3f3f3f, 0); } bool operator<(const Max& t) const { return val < t.val; } }; struct Node { int l, r; Max mmax; } tree[N << 2]; int a[N], f[N], val[N], dp[N][25], L[N], R[N], id[N], tot; vector<int> node[N]; void pushup(int k) { tree[k].mmax = max(tree[k << 1].mmax, tree[k << 1 | 1].mmax); } void build(int k, int l, int r) { tree[k].l = l; tree[k].r = r; if (l == r) { tree[k].mmax.val = a[id[l]]; tree[k].mmax.pos = l; return; } int mid = l + r >> 1; build(k << 1, l, mid); build(k << 1 | 1, mid + 1, r); pushup(k); } void update(int k, int pos) { if (tree[k].l == tree[k].r) { tree[k].mmax.val = 0; return; } int mid = tree[k].l + tree[k].r >> 1; if (pos <= mid) update(k << 1, pos); else update(k << 1 | 1, pos); pushup(k); } Max query(int k, int l, int r) { if (tree[k].l > r || tree[k].r < l) return Max::inf(); if (tree[k].l >= l && tree[k].r <= r) return tree[k].mmax; return max(query(k << 1, l, r), query(k << 1 | 1, l, r)); } void dfs(int u, int fa) { dp[u][0] = fa; for (int i = 1; i <= 20; i++) dp[u][i] = dp[dp[u][i - 1]][i - 1]; L[u] = ++tot; id[tot] = u; for (auto v : node[u]) dfs(v, u); R[u] = tot; } int get_pos(int u, int up) { for (int i = 20; i >= 0; i--) if (dp[u][i] != 0 && val[dp[u][i]] <= up) u = dp[u][i]; return u; } int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); } int Ex_Kruskal() { for (int i = 1; i <= n << 1; i++) f[i] = i; int index = n; sort(edge + 1, edge + 1 + m); for (int i = 1; i <= m; i++) { int xx = find(edge[i].u), yy = find(edge[i].v); if (xx != yy) { f[xx] = f[yy] = ++index; val[index] = edge[i].w; node[index].push_back(xx); node[index].push_back(yy); } } int last = 1; for (int i = 1; i <= n; i++) { int xx = find(last), yy = find(i); if (xx != yy) { f[xx] = f[yy] = ++index; val[index] = inf; node[index].push_back(xx); node[index].push_back(yy); last = index; } } return index; } int main() { scanf( %d%d%d , &n, &m, &q); for (int i = 1; i <= n; i++) scanf( %d , a + i); for (int i = 1; i <= m; i++) { scanf( %d%d , &edge[i].u, &edge[i].v); edge[i].w = 0; } int val = inf; for (int i = 1; i <= q; i++) { scanf( %d%d , &qu[i].op, &qu[i].x); if (qu[i].op == 2) edge[qu[i].x].w = --val; } int root = Ex_Kruskal(); dfs(root, 0); build(1, 1, root); val = inf - 1; for (int i = 1; i <= q; i++) { if (qu[i].op == 1) { int x = get_pos(qu[i].x, val); Max ans = query(1, L[x], R[x]); printf( %d n , ans.val); update(1, ans.pos); } else val--; } return 0; }
#include <bits/stdc++.h> using namespace std; unsigned long long part[4001]; unsigned long long pmod(unsigned long long n, int exp) { unsigned long long x = 1, y = n; while (exp > 0) { if (1 == (exp % 2)) { x = x * y; if (x > 1000000007) x = x % 1000000007; } y = y * y; if (y > 1000000007) y = y % 1000000007; exp /= 2; } return x; } unsigned long long inv(unsigned long long x) { return pmod(x, 1000000007 - 2); } unsigned long long Rfact[4001]; unsigned long long Ifact[4001]; unsigned long long fact(int x) { if (!Rfact[x]) { unsigned long long ret = 1; for (int i = x; i >= 2; i--) { ret = (ret * i) % 1000000007; } Rfact[x] = ret; } return Rfact[x]; } unsigned long long inv_fact(int x) { if (!Ifact[x]) { Ifact[x] = inv(fact(x)); } return Ifact[x]; } unsigned long long com(int n, int r) { unsigned long long ret = fact(n); ret = (ret * inv_fact(n - r)) % 1000000007; ret = (ret * inv_fact(r)) % 1000000007; return ret; } int main() { part[0] = part[1] = 1; for (int i = 2; i <= 4000; i++) { for (int j = 0; j < i; j++) { unsigned long long tadd = (com(i - 1, j) * part[j]) % 1000000007; part[i] = (part[i] + tadd) % 1000000007; } } int n; cin >> n; unsigned long long ret = 0; for (int i = 1; i <= n; i++) { unsigned long long tadd = (com(n, i) * part[n - i]) % 1000000007; ret = (ret + tadd) % 1000000007; } cout << ret << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int n, a, b, last = 1; cin >> n >> a >> b; if (a > 0 && a > n - 2) { cout << -1; return 0; } cout << last; for (int i = 1; i < n; i++) { cout << ; if (b) { last <<= 1; cout << last; b--; } else if (a && i >= 2) { last++; cout << last; a--; } else cout << last; } cin >> n; }
#include <bits/stdc++.h> using namespace std; int sz[100005]; long long pw[100005]; int main() { ios_base::sync_with_stdio(false); int n; cin >> n; for (int i = 0; i < n - 1; i++) { int a, b; cin >> a >> b; sz[a]++; sz[b]++; } int lf = 0; for (int i = 1; i <= n; i++) if (sz[i] == 1) lf++; pw[0] = 1LL; for (int i = 1; i <= 100000; i++) pw[i] = (pw[i - 1] * 2) % 1000000007; long long res = lf * pw[n - lf + 1] + (n - lf) * pw[n - lf]; res %= 1000000007; cout << res; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(0); cin.tie(0), cout.tie(0); long long ss4 = 0, ss7 = 0, swap = 0; string s, t; cin >> s >> t; for (long long i = 0; i < s.length(); i++) { if (s[i] != t[i] && s[i] == 4 ) { if (ss7) ss7--, swap++; else ss4++; } else if (s[i] != t[i] && s[i] == 7 ) if (ss4) ss4--, swap++; else ss7++; } cout << swap + ss7 + ss4 << endl; }
#include <bits/stdc++.h> using namespace std; int main() { int n, x; set<int> ase; scanf( %d , &n); for (int i = 1; i <= n; i++) { scanf( %d , &x); if (ase.size() >= x) { ase.insert(x); } else { cout << i << endl; return 0; } } cout << -1 << endl; }
#include <bits/stdc++.h> using namespace std; int n, m, half; long long k, ans = 0, a[25][25]; map<long long, int> mp[20][20]; void calcf(int x, int y, long long val, int cnt) { val ^= a[x][y]; if (cnt == half) { mp[x][y][val]++; return; } if (x + 1 < n) calcf(x + 1, y, val, cnt + 1); if (y + 1 < m) calcf(x, y + 1, val, cnt + 1); } void calcb(int x, int y, long long val, int cnt) { if (cnt == n + m - 2 - half) { if (mp[x][y].count(val ^ k)) ans += mp[x][y][val ^ k]; return; } val ^= a[x][y]; if (x > 0) calcb(x - 1, y, val, cnt + 1); if (y > 0) calcb(x, y - 1, val, cnt + 1); } int main() { int i, j; cin >> n >> m >> k; half = (n + m - 2) / 2; for (i = 0; i < n; i++) for (j = 0; j < m; j++) cin >> a[i][j]; calcf(0, 0, 0, 0); calcb(n - 1, m - 1, 0, 0); cout << ans; }
#include <bits/stdc++.h> using namespace std; template <typename T> T sqr(T x) { return x * x; } inline unsigned long long bit(int num) { return 1ull << num; } long long FindXor(long long r) { long long rem = r % 4; switch (rem) { case 0: return r; case 1: return 1; case 2: return r + 1; case 3: return 0; } } long long FindXor(long long l, long long r) { return FindXor(r) ^ FindXor(l - 1); } int main() { int n; cin >> n; long long res = 0; for (int i = 0; i < int(n); ++i) { long long x, m; cin >> x >> m; res ^= FindXor(x, x + m - 1); } cout << (res ? tolik : bolik ) << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int gi() { char ch = ! ; int res = 0, f = 0; while (ch < 0 || ch > 9 ) { ch = getchar(); if (ch == - ) f = 1; } while (ch >= 0 && ch <= 9 ) res = res * 10 + ch - 0 , ch = getchar(); return f ? -res : res; } const int N = 1e5 + 7; int n, Q, arr[N], cur[N]; double f[N][110], ans; int main() { n = gi(); for (int i = 1; i <= n; ++i) { arr[i] = gi(), f[i][arr[i]] = 1, cur[i] = arr[i]; ans += f[i][0]; } Q = gi(); for (int i = 1; i <= Q; ++i) { int u = gi(), v = gi(), x = gi(); ans -= f[u][0]; for (int k = 1; k <= x; ++k) { for (int j = 0; j <= arr[u]; ++j) { if (j > cur[u]) f[u][j] = 0; else { f[u][j] = (cur[u] - j) / (double)cur[u] * f[u][j]; if (j + 1 <= cur[u]) f[u][j] += (j + 1) / (double)cur[u] * f[u][j + 1]; } } --cur[u]; } cur[v] += x; ans += f[u][0]; printf( %.10lf n , ans); } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { long long int n; cin >> n; long long int ar[100000], br[10000]; memset(br, 0, sizeof(br)); for (long long int i = 1; i <= n; i++) { cin >> ar[i]; br[ar[i]]++; } sort(ar + 1, ar + n + 1); if (n == 1) { cout << YES << endl; } else if (ar[1] == ar[n]) { cout << NO << endl; } else { int f = 0; sort(br + 1, br + 10000, greater<long long int>()); for (long int i = 1; i <= n; i++) { if (br[i] > (n + 1) / 2) { f = 1; } } if (f == 0) { cout << YES << endl; } else cout << NO << endl; } }
#include <bits/stdc++.h> using namespace std; template <class TH> void _dbg(const char *sdbg, TH h) { cerr << sdbg << = << h << n ; } template <class TH, class... TA> void _dbg(const char *sdbg, TH h, TA... a) { while (*sdbg != , ) cerr << *sdbg++; cerr << = << h << , ; _dbg(sdbg + 1, a...); } long long test; long long n, maybe, maks = 1000000007; void solve() { cin >> n; for (long long i = 1; i <= (n); ++i) { long long a, b; cin >> a >> b; if (a != b) { cout << rated ; return; } if (maks < a) { maybe = 1; } maks = min(maks, a); } if (maybe) { cout << unrated ; } else { cout << maybe ; } return; } int32_t main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.precision(10); cout << fixed; test = 1; while (test--) { solve(); } return 0; }
#include <bits/stdc++.h> using namespace std; void solve() { int x1, y1, x2, y2, x3, y3; cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3; cout << 3 << endl; cout << x2 - x1 << << y3 - y1 << endl; cout << x1 - x2 << << y3 - y2 << endl; cout << x2 - x3 << << y1 - y3 << endl; } void solveexpr(double a, double b, double c, double d, double e, double f) { double determinant = a * d - b * c; if (determinant != 0) { double x = (e * d - b * f) / determinant; double y = (a * f - e * c) / determinant; printf( %0.0f %0.0f n , x, y); } } void solve1() { int x1, y1, x2, y2, x3, y3, x, y; cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3; cout << 3 << endl; int val1 = x1 + x2; int val2 = y1 + y2; x = val1 - x3; y = val2 - y3; cout << x << << y << endl; val1 = x3 + x1; val2 = y3 + y1; x = val1 - x2; y = val2 - y2; cout << x << << y << endl; val1 = x3 + x2; val2 = y3 + y2; x = val1 - x1; y = val2 - y1; cout << x << << y << endl; } int main() { int t = 1; while (t--) { solve1(); } }
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); string s; cin >> s; long long n = s.length(); char ch = z ; for (long long i = 0; i < n; i++) { if (ch < s[i]) cout << Ann n ; else { ch = s[i]; cout << Mike n ; } } return 0; }
#include <bits/stdc++.h> using namespace std; int abslt(int n) { if (n < 0) return -n; else return n; } int main() { int t; cin >> t; while (t--) { int n; cin >> n; int arr[n + 1]; int i; for (i = 1; i <= n; i++) cin >> arr[i]; arr[0] = arr[1]; arr[n + 1] = arr[n]; int mx = INT_MIN; int mn = INT_MAX; for (i = 1; i <= n; i++) { if ((arr[i] != -1 && arr[i + 1] == -1) || (arr[i] != -1 && arr[i - 1] == -1)) { mx = max(mx, arr[i]); mn = min(mn, arr[i]); } } int ans = (mn + mx) / 2; if (mx == INT_MIN) { cout << 0 << << 0 << endl; continue; } int k = INT_MIN; for (i = 1; i < n; i++) { if (arr[i] == -1) arr[i] = ans; if (arr[i + 1] == -1) arr[i + 1] = ans; k = max(k, abslt(arr[i] - arr[i + 1])); } cout << k << << ans << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int n, s, cnt = 0; cin >> n >> s; int arr[100]; for (int i = 0; i < n; i++) { cin >> arr[i]; } sort(arr, arr + n); for (int i = 0; i < n - 1; i++) s -= arr[i]; if (s >= 0) { cout << YES << endl; } else { cout << NO << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int q; long long int a, b, c; cin >> q; while (q--) { cin >> a >> b >> c; cout << (a + b + c) / 2 << n ; } }
#include <bits/stdc++.h> using namespace std; const int maxn = 1e5 + 9; struct node { int id; long long t; bool operator<(const node &A) const { return id > A.id; } } e[maxn]; bool cmp(node a, node b) { return a.t < b.t || a.t == b.t && a.id < b.id; } long long ans[maxn]; int tr[maxn]; void update(int p, int v) { while (p < maxn) tr[p] += v, p += p & -p; } int query(int p) { int res = 0; while (p > 0) { res += tr[p]; p -= p & -p; } return res; } int main() { int n; long long p; scanf( %d%lld , &n, &p); for (int i = 1; i <= n; i++) e[i].id = i, scanf( %lld , &e[i].t); sort(e + 1, e + 1 + n, cmp); priority_queue<node> W; queue<node> Q; int ar = 1; long long t = 0; while (ar <= n || !Q.empty() || !W.empty()) { if (Q.empty() && W.empty()) { t = e[ar].t; update(e[ar].id, 1); Q.push(e[ar++]); } if (Q.empty() && !W.empty()) { update(W.top().id, 1); Q.push(W.top()); W.pop(); } if (!Q.empty()) { node tmp = Q.front(); Q.pop(); t += p; ans[tmp.id] = t; while (ar <= n && e[ar].t <= t) { if (query(e[ar].id - 1) == 0) update(e[ar].id, 1), Q.push(e[ar++]); else W.push(e[ar++]); } update(tmp.id, -1); while (!W.empty() && query(W.top().id - 1) == 0) { tmp = W.top(); W.pop(); update(tmp.id, 1); Q.push(tmp); } } } for (int i = 1; i <= n; i++) { printf( %lld%c , ans[i], n [i == n]); } }
#include <bits/stdc++.h> using namespace std; int n, m, mon_cost; vector<tuple<int, int, int>> friends; const long long oo = 1LL << 60; void solve() { cin >> n >> m >> mon_cost; friends.resize(n); for (int i = 0; i < n; ++i) { int x, k, num; cin >> x >> k >> num; int mask = 0; for (int j = 0; j < num; ++j) { int y; cin >> y; y--; mask = mask | (1 << y); } friends[i] = tie(x, k, mask); } sort(friends.begin(), friends.end(), [](tuple<int, int, int> lhs, tuple<int, int, int> rhs) { return get<1>(lhs) < get<1>(rhs); }); vector<vector<long long>> dp(2, vector<long long>(1 << m, oo)); int x, k, tasks; tie(x, k, tasks) = friends[0]; dp[1][0] = 0; dp[1][tasks] = x; long long ans = oo; for (int i = 0; i < n; ++i) { int cur = i % 2; int prev = cur ^ 1; tie(x, k, tasks) = friends[i]; for (int mask = 0; mask < (1 << m); ++mask) { dp[cur][mask | tasks] = min(dp[cur][mask | tasks], dp[prev][mask] + x); dp[cur][mask] = min(dp[cur][mask], dp[prev][mask]); } long long val = dp[cur][(1 << m) - 1] + 1LL * k * mon_cost; ans = min(ans, val); } if (ans < oo) { cout << ans << n ; } else { cout << -1 << n ; } } int main() { solve(); }
#include <bits/stdc++.h> using namespace std; using vi = vector<int>; using vvi = vector<vi>; using ll = long long; using vll = vector<ll>; using vvll = vector<vll>; using pii = pair<int, int>; using pll = pair<ll, ll>; void solve() { int n; cin >> n; vi a(n), b(n); vector<pii> p, q; for (int& x : a) cin >> x; for (int& x : b) cin >> x; if (n % 2 == 1) { if (a[n / 2] != b[n / 2]) { puts( No ); return; } } for (int i = 0; i < n / 2; i++) { p.push_back(make_pair(min(a[i], a[n - 1 - i]), max(a[i], a[n - 1 - i]))); } for (int i = 0; i < n / 2; i++) { q.push_back(make_pair(min(b[i], b[n - 1 - i]), max(b[i], b[n - 1 - i]))); } sort(p.begin(), p.end()); sort(q.begin(), q.end()); if (p == q) { puts( Yes ); } else { puts( No ); } } int main() { ios::sync_with_stdio(false); cin.tie(NULL); int n; cin >> n; while (n--) { solve(); } }
#include <bits/stdc++.h> using namespace std; int main() { int n = 1000 + 1000 + 1; printf( %d n , n); for (int i = (int)(1); i <= (int)(1000); ++i) printf( %d %d %d %d n , i, 1, i, 2); puts( 1 1 1 2 ); for (int i = (int)(1); i <= (int)(1000); ++i) printf( %d %d %d %d n , i, 1, i, 2); return 0; }
#include <bits/stdc++.h> using namespace std; int n, m; long double x; int a[5005]; int mem[5005][5005]; int lis(int ind, int ant) { if (ind >= n) return 0; if (mem[ind][ant] != -1) return mem[ind][ant]; int op1, op2; op1 = op2 = 0; if (ant <= a[ind]) op1 = lis(ind + 1, a[ind]) + 1; op2 = lis(ind + 1, ant); return mem[ind][ant] = max(op1, op2); } int main() { ; ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); ; memset(mem, -1, sizeof mem); cin >> n >> m; for (int i = 0; i < n; i++) cin >> a[i] >> x; cout << n - lis(0, 0) << n ; return 0; }
#include <bits/stdc++.h> using namespace std; long long bigmod(long long b, long long p, long long n) { if (p == 0) return 1; else if (p % 2 == 0) { long long half1 = bigmod(b, p / 2, n); return ((half1 * half1) % n); } else if (p % 2 == 1) { long long p1 = b % n; long long p2 = bigmod(b, p - 1, n); return ((p1 * p2) % n); } } long long pre11[1000010], pre21[1000010]; string s, s1; const int p = 31; const int m1 = 1e9 + 7; long long MMI[1000010]; void com() { MMI[0] = 1; MMI[1] = bigmod(31, m1 - 2, m1); for (long long i = 2; i <= s.size() + 3; i++) MMI[i] = (MMI[i - 1] * MMI[1]) % m1; } void compute_hash() { long long hash_value1 = 0, hash_value2 = 0; long long p_pow1 = 1, p_pow2 = 1; for (int i = 0; i < s.size(); i++) { hash_value1 = (hash_value1 + (s[i] - a + 1) * p_pow1) % m1; if (i < s1.size()) hash_value2 = (hash_value2 + (s1[i] - a + 1) * p_pow1) % m1; p_pow1 = (p_pow1 * p) % m1; pre11[i] = hash_value1; if (i < s1.size()) pre21[i] = hash_value2; } } void compute_hash2() { long long hash_value1 = 0, hash_value2 = 0; long long p_pow1 = 1, p_pow2 = 1; for (int i = 0; i < s1.size(); i++) { hash_value1 = (hash_value1 + (s1[i] - a + 1) * p_pow1) % m1; p_pow1 = (p_pow1 * p) % m1; pre21[i] = hash_value1; } } int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); ; cin >> s >> s1; com(); compute_hash(); vector<int> V; for (int i = 0; i < s.size(); i++) { long long p1, p2; long long t1, t2; if (i == 0) { p2 = pre11[s.size() - 1] - pre11[0]; if (p2 < 0) p2 += m1; p2 = ((p2 % m1) * MMI[i + 1]) % m1; if (p2 == pre21[s1.size() - 1]) V.push_back(i + 1); } else if (i == s.size() - 1) { if (pre21[i - 1] == pre11[i - 1]) V.push_back(i + 1); } else { p2 = pre11[s.size() - 1] - pre11[i]; if (p2 < 0) p2 += m1; p2 = ((p2 % m1) * MMI[i + 1]) % m1; t2 = pre21[s1.size() - 1] - pre21[i - 1]; if (t2 < 0) t2 += m1; t2 = ((t2 % m1) * MMI[i]) % m1; if (p2 == t2 && pre21[i - 1] == pre11[i - 1]) V.push_back(i + 1); } } cout << V.size() << endl; for (int i = 0; i < V.size(); i++) cout << V[i] << ; }
#include <bits/stdc++.h> using namespace std; int main() { ios::sync_with_stdio(false); int c, r; cin >> c >> r; bool flag = true; for (int i = 1; i <= c; i++) { if (i & 1) { for (int j = 1; j <= r; j++) { cout << # ; } cout << endl; } else { if (flag) { for (int j = 1; j <= r - 1; j++) { cout << . ; } cout << # << endl; flag = false; } else { cout << # ; for (int j = 1; j <= r - 1; j++) { cout << . ; } cout << endl; flag = true; } } } return 0; }
#include <bits/stdc++.h> using namespace std; const int sMAX = 10010; const int MAX = 114514; const long long bMAX = 1919180; int main() { int t; cin >> t; while (t--) { string zs; cin >> zs; int ans = zs.size() + 1; int m[4] = {0, 0, 0, 0}; for (int i = 0; i < zs.size(); i++) { m[zs[i] - 0 ] = i + 1; if (m[1] && m[2] && m[3]) { int gsb = min(m[1], m[2]); ans = min(ans, max(m[1], max(m[2], m[3])) - min(gsb, m[3]) + 1); } } if (ans == zs.size() + 1) { cout << 0 << endl; } else cout << ans << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; int n, k; int f[3001][3001], vis[3001][3001]; char s[3001][3001]; int main() { scanf( %d%d , &n, &k); for (int i = 1; i <= n; i++) scanf( %s , s[i] + 1); memset(f, 0x3f, sizeof(f)); f[0][1] = f[1][0] = 0; for (int i = 1; i <= n; i++) for (int j = 1; j <= n; j++) { f[i][j] = min(f[i - 1][j], f[i][j - 1]); if (s[i][j] != a ) f[i][j]++; } int max0 = 1; for (int i = 1; i <= n; i++) for (int j = 1; j <= n; j++) if (f[i][j] <= k) max0 = max(max0, i + j); for (int i = 2; i <= max0; i++) putchar( a ); for (int i = 1; i <= n; i++) for (int j = 1; j <= n; j++) if (i + j == max0 && f[i][j] <= k) vis[i][j] = 1; if (max0 == 1) vis[0][1] = vis[1][0] = 1; for (int kx = max0 + 1; kx <= n * 2; kx++) { for (int i = 1; i < kx; i++) if (i <= n && kx - i <= n) vis[i][kx - i] = vis[i - 1][kx - i] | vis[i][kx - i - 1]; char minc = z ; for (int i = 1; i < kx; i++) if (i <= n && kx - i <= n && vis[i][kx - i]) minc = min(minc, s[i][kx - i]); for (int i = 1; i < kx; i++) if (i <= n && kx - i <= n && s[i][kx - i] != minc) vis[i][kx - i] = 0; putchar(minc); } putchar( n ); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int n, pos, l, r; while (cin >> n >> pos >> l >> r) { if (l == 1 && r == n) cout << 0 << endl; else if (l == 1) cout << (abs(r - pos) + 1) << endl; else if (r == n) cout << (abs(l - pos) + 1) << endl; else if (pos < l || pos > r) cout << (max(abs(r - pos), abs(l - pos)) + 2) << endl; else cout << (r - l + min(abs(r - pos), abs(l - pos)) + 2) << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; const int MOD = 786433, MAXN = 2000005, LOGN = 18, MAXM = 5005; inline void S(int& n) { n = 0; int ch = getchar(); int sign = 1; while (ch < 0 || ch > 9 ) { if (ch == - ) sign = -1; ch = getchar(); } while (ch >= 0 && ch <= 9 ) { n = (n << 3) + (n << 1) + ch - 0 , ch = getchar(); } n = n * sign; } const int SHIFT = 30, ETF = MOD - 1, LIM = (int)1e9; const long long int INF = (long long int)1e18 + 1; const double PI = (double)acos(-1), EPSILON = 1e-10; long long int recurse(long long int n) { long long int group_size = 1, gcnt = 0; long long int ans = 0; while (n >= group_size) { long long int temp = 1; temp <<= gcnt; ans += temp; ans += gcnt * (group_size) / 2; n -= group_size; group_size <<= 1; gcnt++; } if (n) { long long int temp = 1; ans += recurse(n - 1) + (temp << gcnt); } return ans; } int main() { long long int n; cin >> n; cout << recurse(n - 1) << endl; return 0; }
#include <bits/stdc++.h> using namespace std; const int MOD = 1e9 + 7; long long dp[21][2001]; long long fact[200001]; long long tcaf[200001]; int pow1(int n, int p) { long long cur, res; cur = n; res = 1; while (p) { if (p & 1) { res *= cur; res %= MOD; } p /= 2; cur *= cur; cur %= MOD; } return res; } void init() { fact[0] = tcaf[0] = 1; for (int i = 1; i < 200001; i++) { fact[i] = 1LL * fact[i - 1] * i % MOD; tcaf[i] = pow1(fact[i], MOD - 2); } } int ways(pair<int, int> p1, pair<int, int> p2) { int n, m; n = p2.first - p1.first; m = p2.second - p1.second; if (n < 0 || m < 0) return 0; return 1LL * fact[n + m] * tcaf[n] % MOD * tcaf[m] % MOD; } long long calc(int s, int num, int tot) { for (int i = 0; i < num; i++) s = (s + 1) / 2; return 1LL * tot * s; } int main() { init(); int n, m, k, s; cin >> n >> m >> k >> s; init(); vector<pair<int, int>> points(k + 1); for (int i = 1; i <= k; i++) { scanf( %d %d , &points[i].first, &points[i].second); points[i].first--; points[i].second--; } points.push_back({n - 1, m - 1}); sort(points.begin(), points.end()); dp[0][0] = 1; for (int i = 1; i <= k + 1; i++) { dp[0][i] = ways({0, 0}, points[i]); for (int j = 1; j < i; j++) { dp[0][i] -= 1LL * dp[0][j] * ways(points[j], points[i]), dp[0][i] %= MOD; } } for (int i = 1; i <= 20; i++) { for (int j = 1; j <= k + 1; j++) { dp[i][j] = ways({0, 0}, points[j]); for (int s = 1; s < j; s++) { dp[i][j] -= 1LL * dp[i][s] * ways(points[s], points[j]) % MOD; dp[i][j] %= MOD; } for (int s = i - 1; s >= 0; s--) dp[i][j] -= dp[s][j], dp[i][j] %= MOD; } } long long res = 0; long long tot = ways({0, 0}, {n - 1, m - 1}); for (int i = 0; i <= 20; i++) { res += calc(s, i, dp[i][k + 1]); res %= MOD; tot -= dp[i][k + 1]; } res += tot; res *= pow1(ways({0, 0}, {n - 1, m - 1}), MOD - 2); res %= MOD; res = (res + MOD) % MOD; cout << res; return 0; }
#include <bits/stdc++.h> using namespace std; int dp[15][105][105]; int main() { int n, q, c; int x, y, s; int t, x1, y1, x2, y2; memset(dp, 0, sizeof dp); scanf( %d%d%d , &n, &q, &c); while (n--) { scanf( %d%d%d , &x, &y, &s); dp[s][x][y]++; } for (int i = 0; i < c + 1; i++) { for (int x = 1; x <= 100; x++) { for (int y = 1; y <= 100; y++) { dp[i][x][y] += dp[i][x - 1][y] + dp[i][x][y - 1] - dp[i][x - 1][y - 1]; } } } int cnt; while (q--) { scanf( %d%d%d%d%d , &t, &x1, &y1, &x2, &y2); int ans = 0; for (int i = 0; i < c + 1; i++) { int light = (i + t) % (c + 1); cnt = dp[i][x2][y2] + dp[i][x1 - 1][y1 - 1] - dp[i][x1 - 1][y2] - dp[i][x2][y1 - 1]; ans += light * cnt; } printf( %d n , ans); } return 0; }
#include <bits/stdc++.h> using namespace std; int n, m, k; int a[100010]; int p[100010]; int cnt; int ans; int main() { scanf( %d%d%d , &n, &m, &k); for (int i = 1; i <= n; i++) scanf( %d , &a[i]); for (int i = 2; i <= n; i++) { p[++cnt] = (a[i] - a[i - 1] - 1); } sort(p + 1, p + cnt + 1); for (int i = 1; i <= n - k; i++) { ans += p[i]; } printf( %d , ans + n); }
#include <bits/stdc++.h> using namespace std; const int MX = 3e5; const int LG = 20; struct Query { int i, x, y; bool operator<(Query q) const { if (x != q.x) return x > q.x; return i < q.i; } }; int N, Q; Query query[MX + 10]; int A[MX + 10]; int dp[MX + 10][LG + 10]; int last[MX + 10]; void init() {} void calc_dp() { for (int i = 1; i <= N; i++) { for (int b = 0; b < LG; b++) { if (A[i] & (1 << b)) { dp[i][b] = i; } else { for (int c = 0; c < LG; c++) { if (~A[i] & (1 << c)) continue; dp[i][b] = max(dp[i][b], dp[last[c]][b]); } } } for (int b = 0; b < LG; b++) { if (~A[i] & (1 << b)) continue; last[b] = i; } } } bool solve(int x, int y) { for (int b = 0; b < LG; b++) { if ((A[x] & (1 << b))) { } if ((A[x] & (1 << b)) && (dp[y][b] >= x)) { return true; } } return false; } int main() { init(); scanf( %d%d , &N, &Q); for (int i = 1; i <= N; i++) { scanf( %d , &A[i]); } for (int q = 1; q <= Q; q++) { scanf( %d%d , &query[q].x, &query[q].y); query[q].i = q; } calc_dp(); for (int q = 1; q <= Q; q++) { if (solve(query[q].x, query[q].y)) printf( Shi n ); else printf( Fou n ); } }
#include <bits/stdc++.h> using namespace std; long long int powmod(long long int a, long long int e) { if (e == 0) return 1; long long int x = powmod(a * a % 1000000007, e >> 1); return e & 1 ? x * a % 1000000007 : x; } set<int> unvis; set<pair<long long int, long long int> > forbid; void dfs(int v) { int ver = -1; auto it = unvis.begin(); while (it != unvis.end()) { ver = *it; if (forbid.find({min(ver, v), max(ver, v)}) != forbid.end()) { it++; continue; } unvis.erase(it); dfs(ver); it = unvis.upper_bound(ver); } } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); int n, m, k; cin >> n >> m >> k; for (long long int i = 0; i < m; i++) { int a, b; cin >> a >> b; a--; b--; forbid.insert({min(a, b), max(a, b)}); } for (long long int i = 0; i < n - 1; i++) unvis.insert(i + 1); dfs(0); if (!unvis.empty()) { cout << impossible ; return 0; } int cnt = 0; for (auto i : forbid) { if (i.first == 0) cnt++; else break; } for (long long int i = 1; i < n; i++) unvis.insert(i); int conn = 0; while (!unvis.empty()) { int x = *unvis.begin(); unvis.erase(unvis.begin()); dfs(x); conn++; } if (k >= conn and k <= n - 1 - cnt) cout << possible ; else cout << impossible ; }
#include <bits/stdc++.h> using namespace std; int main() { int n, sum_even = 0, sum_odd = 0; scanf( %d , &n); for (int i = 1; i <= n; i++) { int val; scanf( %d , &val); if (val & 1) return puts( First ), 0; } puts( Second ); }
#include <bits/stdc++.h> using namespace std; long long bigmod(long long a, long long b) { if (b == 0) return 1; if (!(b & 1)) { long long ret = bigmod(a, b / 2); return ((ret % 1000000007) * (ret % 1000000007)) % 1000000007; } else return ((a % 1000000007) * (bigmod(a, b - 1) % 1000000007)) % 1000000007; } bool cmp(pair<int, int> p1, pair<int, int> p2) { if (p1.first != p2.first) return p1.first < p1.first; return p1.second < p2.second; } bool approximatelyEqual(float a, float b, float epsilon) { return fabs(a - b) <= ((fabs(a) < fabs(b) ? fabs(b) : fabs(a)) * epsilon); } bool essentiallyEqual(float a, float b, float epsilon) { return fabs(a - b) <= ((fabs(a) > fabs(b) ? fabs(b) : fabs(a)) * epsilon); } bool definitelyGreaterThan(float a, float b, float epsilon) { return (a - b) > ((fabs(a) < fabs(b) ? fabs(b) : fabs(a)) * epsilon); } bool definitelyLessThan(float a, float b, float epsilon) { return (b - a) > ((fabs(a) < fabs(b) ? fabs(b) : fabs(a)) * epsilon); } bool cmp1(pair<int, int> p1, pair<int, int> p2) { return p1.second < p2.second; } bool cmp2(pair<int, int> p1, pair<int, int> p2) { return p1.second > p2.second; } int main() { int t, tc = 1, a, b, c, m, n, i, j, k, p, q; char s[500000]; vector<pair<int, int> > u, v; scanf( %d , &n); for (i = 0; i < n; i++) { scanf( %d , &c); u.push_back(pair<int, int>(i, c)); v.push_back(pair<int, int>(i, c)); } getchar(); scanf( %s , s); sort(u.begin(), u.end(), cmp1); k = 0, b = 0; vector<int> ans; stack<int> st; int oc[200001] = {0}; int pp; for (i = 0; s[i]; i++) { if (s[i] == 0 ) { ans.push_back(u[k].first + 1); st.push(k); k++; } else { int xx = st.top(); st.pop(); ans.push_back(u[xx].first + 1); } } for (i = 0; i < ans.size(); i++) { i != ans.size() - 1 ? printf( %d , ans[i]) : printf( %d n , ans[i]); } return 0; }
#include <bits/stdc++.h> using namespace std; int II() { int q; scanf( %d , &q); return q; } long long LII() { long long q; scanf( %lld , &q); return q; } const long long Mx = 100005, K = 22; long long step, jump; long long Rank[K][Mx]; struct info { long long tup[2], indx; bool operator<(const info &a) const { return (tup[0] == a.tup[0] ? tup[1] < a.tup[1] : tup[0] < a.tup[0]); } } ar[Mx]; info temp[Mx]; long long cnt[Mx]; void Counting_Sort(long long N) { long long mi = -2; memset(cnt, 0, sizeof(cnt)); for (long long i = 0; i < N; i++) { cnt[ar[i].tup[1] - mi]++; } for (long long i = 1; i < Mx; i++) cnt[i] += cnt[i - 1]; for (long long i = N - 1; i >= 0; i--) { temp[--cnt[ar[i].tup[1] - mi]] = ar[i]; } for (long long i = 0; i < N; i++) ar[i] = temp[i]; memset(cnt, 0, sizeof(cnt)); for (long long i = 0; i < N; i++) { cnt[ar[i].tup[0] - mi]++; } for (long long i = 1; i < Mx; i++) cnt[i] += cnt[i - 1]; for (long long i = N - 1; i >= 0; i--) { temp[--cnt[ar[i].tup[0] - mi]] = ar[i]; } for (long long i = 0; i < N; i++) ar[i] = temp[i]; } void Build_Suffix_Array(string s) { long long N = s.size(); for (long long i = 0; i < N; i++) { Rank[0][i] = s[i]; } step = 1, jump = 1; for (step = 1, jump = 1; jump <= N; step++, jump <<= 1) { for (long long i = 0; i < N; i++) { ar[i].indx = i; ar[i].tup[0] = Rank[step - 1][i]; ar[i].tup[1] = ((i + jump < N) ? Rank[step - 1][i + jump] : -1); } Counting_Sort(N); Rank[step][ar[0].indx] = 0; for (long long i = 1; i < N; i++) { Rank[step][ar[i].indx] = (ar[i].tup[0] == ar[i - 1].tup[0] && ar[i].tup[1] == ar[i - 1].tup[1]) ? Rank[step][ar[i - 1].indx] : i; } } } vector<long long> LCP(long long N) { vector<long long> ans(N, 0); for (long long i = 1; i < N; i++) { long long x = ar[i].indx, y = ar[i - 1].indx; ans[i] = 0; for (long long j = step - 1; j >= 0; j--) { if (Rank[j][x] == Rank[j][y] && x < N && y < N) { ans[i] += (1 << j); x += (1 << j); y += (1 << j); } } } return ans; } long long st[K][Mx]; void build(vector<long long> lcp) { long long N = lcp.size(); for (long long i = 0; i < N; i++) { st[0][i] = lcp[i]; } for (long long k = 1; k < K; k++) { for (long long i = 0; i < N; i++) { long long next = i + (1 << k - 1); if (next > N) continue; st[k][i] = min(st[k - 1][i], st[k - 1][next]); } } } long long get(long long l, long long r) { l++; long long lg = log2(r - l + 1); return min(st[lg][l], st[lg][r - (1 << lg) + 1]); } long long find_left(long long l, long long r, long long val) { long long re = r, lo = l, hi = r; while (lo < hi) { long long mid = (lo + hi) / 2; if (get(mid, r) >= val) { re = mid; hi = mid; } else lo = mid + 1; } return re; } pair<long long, long long> find_right(long long l, long long r, long long val) { long long re = l, lo = l, hi = r; while (lo < hi) { long long mid = (lo + hi + 1) / 2; if (get(l, mid) >= val) { re = mid; lo = mid; } else hi = mid - 1; } if (re == l) return {l, -1}; return {re, get(l, re)}; } void reset() { memset(ar, 0, sizeof(ar)); memset(st, 0, sizeof(st)); memset(Rank, 0, sizeof(Rank)); } void solve() { reset(); string s; cin >> s; long long N = s.size(); Build_Suffix_Array(s); vector<long long> lcp = LCP((long long)s.size()); build(lcp); long long ans = 0; for (long long i = 0; i < N; i++) { long long len = N - ar[i].indx; long long cur = lcp[i] + 1; while (cur <= len) { long long RR = Rank[step - 1][ar[i].indx]; pair<long long, long long> pr = find_right(RR, N - 1, cur); if (pr.second == -1) { ans += len - cur + 1; break; } else { long long q = pr.first - RR + 1; long long qq = pr.second - cur + 1; ans += (1LL * (q * (q + 1)) / 2 * qq); cur = pr.second + 1; } } } cout << ans << endl; } int32_t main() { long long tt; tt = 1; long long cas = 1; while (tt--) { solve(); } }
#include <bits/stdc++.h> using namespace std; int fact[100005]; bitset<100005> p; int cnt[100005]; int best[100005]; int arr[100005]; int bestFactor(int n) { if (fact[n] == 0) { return n; } int curFactor = fact[n]; int bestChildFactor = bestFactor(n / curFactor); if (best[curFactor] == -1) { return bestChildFactor; } if (best[bestChildFactor] == -1) { return curFactor; } if (cnt[best[curFactor]] > cnt[best[bestChildFactor]]) { return curFactor; } return bestChildFactor; } void updateFactors(int n, int idx) { if (fact[n] == 0) { best[n] = idx; return; } best[fact[n]] = idx; return updateFactors(n / fact[n], idx); } int main() { memset(best, -1, sizeof best); p.set(); p[0] = p[1] = false; for (int i = 2, to = sqrt(100005) + 1; i <= to; i++) { if (p[i]) { for (int j = i * i; j < 100005; j += i) { if (fact[j] == 0) fact[j] = i; p[j] = false; } } } int n; scanf( %d , &n); for (int i = 0; i < n; i++) { scanf( %d , &arr[i]); cnt[i] = 1; } updateFactors(arr[0], 0); int maxi = 1; for (int i = 1; i < n; i++) { int bestFact = bestFactor(arr[i]); if (best[bestFact] != -1) { cnt[i] = cnt[best[bestFact]] + 1; maxi = max(maxi, cnt[i]); } updateFactors(arr[i], i); } cout << maxi; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); ; long long int t = 1; cin >> t; while (t--) { string n, k; cin >> n >> k; string A, B, C, other; for (int i = 0; i < n.size(); i++) { if (n[i] == a ) A.push_back( a ); else if (n[i] == b ) B.push_back( b ); else if (n[i] == c ) C.push_back( c ); else other.push_back(n[i]); } sort(n.begin(), n.end()); sort(other.begin(), other.end()); if (A.size() == 0 || B.size() == 0 || C.size() == 0) cout << n; else { if (k[0] == a ) { if (k[1] == b ) cout << A << C << B; else cout << A << B << C; } else { cout << A << B << C; } if (other.size() != 0) cout << other; } cout << n ; } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; for (int i = 1; i <= n; i++) { for (int j = i; j <= n; j++) { if (j % i == 0 && i * j > n && j < n * i) return cout << j << << i, 0; } } cout << -1; }
#include <bits/stdc++.h> using namespace std; const int MOD = 1e9 + 7; int main() { int n; cin >> n; vector<long long> v(2 * n); for (int i = 0; i < 2 * n; i++) cin >> v[i]; sort(v.begin(), v.end()); long long ans = (v[n - 1] - v[0]) * (v[2 * n - 1] - v[n]); long long minx = 1e9 + 10; for (int i = 0; i < n; i++) { long long k = v[n + i - 1] - v[i]; minx = min(minx, k); } long long k = (v[2 * n - 1] - v[0]) * minx; cout << (long long)min(ans, k); }
#include <bits/stdc++.h> using namespace std; int facts[1002][3], v[1002]; int main() { int n, m; cin >> n >> m; for (int i = 1; i <= m; ++i) { cin >> facts[i][0] >> facts[i][1] >> facts[i][2]; if (facts[i][0] == 1) { for (int j = facts[i][1]; j < facts[i][2]; ++j) v[j] = 1; } } for (int i = 1; i <= m; ++i) { bool verif = false; if (facts[i][0] == 0) { for (int j = facts[i][1]; j < facts[i][2]; ++j) if (v[j] == 0) { verif = true; break; } if (verif == false) { cout << NO << endl; return 0; } } } int y = n + 1; cout << YES << endl; for (int i = 1; i <= n; ++i) { if (v[i - 1] == 1) cout << y << ; else cout << --y << ; } return 0; }
#include <bits/stdc++.h> using namespace std; void solve(int cases) { int n; cin >> n; int a[n]; for (int i = 0; i < n; i++) cin >> a[i]; int su = 0; for (int i = 0; i < n; i++) su += a[i]; sort(a, a + n); if (su == 0) { cout << NO n ; return; } cout << YES n ; if (su > 0) { for (int i = 0; i < n; i++) cout << a[n - 1 - i] << ; cout << n ; return; } for (int i = 0; i < n; i++) cout << a[i] << ; cout << n ; } int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); int cases = 1; int t = 1; cin >> t; while (t--) { solve(cases++); } }
#include <bits/stdc++.h> using namespace std; void solve() { int a, b, c; cin >> a >> b >> c; if (a + c <= b) puts( 0 ); else { int a2 = max(((a + b + c) >> 1) + 1, a); a += c; cout << a - a2 + 1 << endl; } return; } int main() { int T; cin >> T; while (T--) { solve(); } }
#include <bits/stdc++.h> using namespace std; const int NN = 111 * 1000; int n, a, d; int t[NN], v[NN]; int main() { ios::sync_with_stdio(false); cin >> n >> a >> d; for (int i = 0; i < n; i++) { cin >> t[i] >> v[i]; } double Max = -1.; for (int i = 0; i < n; i++) { double v2 = (double)v[i] * v[i]; double dx = v2 / a / 2.; dx = min((double)d, dx); double tl = sqrt(dx * 2. / a); double tr = (d - dx) / v[i]; double t_cur = t[i] + tl + tr; Max = max(Max, t_cur); printf( %.16f n , Max); } }
#include <bits/stdc++.h> using namespace std; using ld = long double; using ll = long long; using pii = pair<int, int>; using pll = pair<ll, ll>; using vi = vector<int>; const int oo = 1e9 + 7; const ll loo = 1e18; ll modpow(ll a, ll b) { ll res = 1; while (b) { if (b & 1) res = res * a % oo; a = a * a % oo; b /= 2; } return res; } ll gcd(ll a, ll b) { return a == 0 ? b : gcd(b % a, a); } mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); const int N = 5e5 + 7; int n, k, m; using point = complex<ll>; point p[N]; ld dist[N]; vector<int> arms[N]; int gr[N]; int num; ld cross(point a, point b) { return (conj(a) * b).imag(); } ld dot(point a, point b) { return (conj(a) * b).real(); } void input() { map<pair<ll, ll>, int> id; m = 0; for (int i = 0; i < n; i++) { ll a, b; cin >> a >> b; p[i] = point(a, b); dist[i] = sqrt(dot(p[i], p[i])); if (a == 0 && b == 0) continue; ll g = gcd(abs(a), abs(b)); pair<ll, ll> ash = make_pair(a / g, b / g); if (!id.count(ash)) id[ash] = m++; arms[id[ash]].push_back(i); gr[i] = id[ash]; } for (int i = 0; i < m; i++) { sort(begin(arms[i]), end(arms[i]), [&](int i, int j) { return dist[i] < dist[j]; }); } } ld option1() { priority_queue<pair<ld, int>> pq; for (int i = 0; i < m; i++) { for (int t = 0; t < min(k / 2, (int)arms[i].size()); t++) { ld wei = (k - 2 * t - 1) * dist[arms[i][arms[i].size() - 1 - t]]; pq.push(make_pair(wei, arms[i][arms[i].size() - 1 - t])); } } for (int i = 0; i < n; i++) if (p[i] == point(0)) { pq.push(make_pair(0, i)); } ld ans = 0; while (pq.size() && num < k) { auto pp = pq.top(); pq.pop(); ans += pp.first; num++; } return ans; } ld option2(int i, ld ans) { int half = k / 2; int s = num - half; for (int t = 0; t < arms[i].size() - half; t++) { ans += dist[arms[i][t]] * ((t + s) - (k - 1 - t - s)); if (t + 1 + num == k) break; } return ans; } int main() { ios_base::sync_with_stdio(0); cin.tie(0); cin >> n >> k; input(); ld ans = option1(); if (num < k) { ld res = 0; for (int i = 0; i < m; i++) if (2 * (n - arms[i].size()) <= k) { res = max(res, option2(i, ans)); } ans = res; } cout << setprecision(40) << ans << endl; return 0; }
#include <bits/stdc++.h> using namespace std; const int Size = 1024; const int mod = 998244353; const int INF = 2147483647; const int maxn = 1e5 + 15; int a[maxn]; int main() { int n, x, y, i, f, j; scanf( %d%d%d , &n, &x, &y); for (i = 1; n >= i; i++) { scanf( %d , &a[i]); } for (i = 1; n >= i; i++) { f = 0; for (j = 1; x >= j && i - j >= 1; j++) { if (a[i] < a[i - j]) continue; else f = 1; } for (j = 1; y >= j && i + j <= n; j++) { if (a[i] < a[i + j]) continue; else f = 1; } if (f == 0) { printf( %d n , i); return 0; } } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int n, m; cin >> n >> m; long long ans = 0; for (int i = (0); i < (n); ++i) { long long t, T, x, cost; cin >> t >> T >> x >> cost; if (t >= T) { ans += cost + m * x; continue; } long long aux1 = cost; if (m > (T - t)) aux1 += m * x; long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1; aux2 *= cost; ans += min(aux1, aux2); } cout << ans << endl; return 0; }
#include <bits/stdc++.h> using namespace std; static const int INF = 500000000; template <class T> void debug(T a, T b) { for (; a != b; ++a) cerr << *a << ; cerr << endl; } int n, w, b; const long long int mod = 1000000009; int C[4005][4005]; int main() { for (int i = 0; i < 4003; ++i) { C[i][0] = 1; for (int j = 0; j < i; ++j) C[i][j + 1] = (C[i - 1][j + 1] + C[i - 1][j]) % mod; } cin >> n >> w >> b; long long int res = 0; for (int l = 1; l < n - 1; ++l) for (int r = l + 1; r < n; ++r) { int len = r - l, wlen = n - len; if (b - len < 0 || w - wlen < 0) continue; res += C[b - 1][b - len] * (long long int)C[w - 1][w - wlen] % mod; res %= mod; } for (int i = 0; i < w; ++i) res = res * (i + 1) % mod; for (int i = 0; i < b; ++i) res = res * (i + 1) % mod; cout << res << endl; return 0; }
#include<bits/stdc++.h> #define fo(i,a,b) for(int i=(a);i<=(b);++i) #define fd(i,a,b) for(int i=(a);i>=(b);--i) #define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0) using namespace std; typedef long long ll; const int maxn = 1e6 + 5; const ll mod = 1e9 + 7; int t, m, n, k; vector<int>e[maxn]; int d[maxn], val[maxn]; void D() { queue<int>q; q.push(1); while (!q.empty()) { int u = q.front(); q.pop(); for (auto& v : e[u]) { if (d[v] == -1) { d[v] = d[u] + 1; q.push(v); } } } } int f(int u) { if (val[u] != -1)return val[u]; val[u] = d[u]; for (auto& v : e[u]) { if (d[v] > d[u])val[u] = min(val[u], f(v)); else val[u] = min(val[u], d[v]); } return val[u]; } int main() { IOS; cin >> t; while (t--) { cin >> n >> m; fo(i, 1, n)e[i].clear(), d[i] = val[i] = -1; fo(i, 1, m) { int u, v; cin >> u >> v; e[u].push_back(v); } d[1] = 0; D(); fo(i, 1, n)cout << f(i) << ; cout << endl; } return 0; } /* */
#include <bits/stdc++.h> using namespace std; struct IO { char buf[(1 << 20)], *p1, *p2; char pbuf[(1 << 20)], *pp; IO() : p1(buf), p2(buf), pp(pbuf) {} inline char gc() { return getchar(); if (p1 == p2) p2 = (p1 = buf) + fread(buf, 1, (1 << 20), stdin); return p1 == p2 ? : *p1++; } inline bool blank(char ch) { return ch == || ch == n || ch == r || ch == t ; } template <class T> inline void read(T &x) { register double tmp = 1; register bool sign = 0; x = 0; register char ch = gc(); for (; !(ch >= 0 && ch <= 9 ); ch = gc()) if (ch == - ) sign = 1; for (; (ch >= 0 && ch <= 9 ); ch = gc()) x = x * 10 + (ch - 0 ); if (ch == . ) for (ch = gc(); (ch >= 0 && ch <= 9 ); ch = gc()) tmp /= 10.0, x += tmp * (ch - 0 ); if (sign) x = -x; } inline void read(char *s) { register char ch = gc(); for (; blank(ch); ch = gc()) ; for (; !blank(ch); ch = gc()) *s++ = ch; *s = 0; } inline void read(char &c) { for (c = gc(); blank(c); c = gc()) ; } template <class t> inline void write(t x) { if (x < 0) putchar( - ), write(-x); else { if (x > 9) write(x / 10); putchar( 0 + x % 10); } } } io; const int mod = 1e9 + 7; const int mo = 998244353; const int N = 5e5 + 5; int n, m, a[N], b[N], c[N], stak[N], gs, ans; inline int get(int l, int r) { int top = 0; for (int i = (l); i <= (r); i++) { if (a[i] < a[l] || a[i] > a[r]) continue; if (!top || a[i] >= stak[top]) stak[++top] = a[i]; else { int p = upper_bound(stak + 1, stak + top + 1, a[i]) - stak; stak[p] = a[i]; } } return top; } int main() { io.read(n), io.read(m); for (int i = (1); i <= (n); i++) io.read(a[i]), a[i] = a[i] - i + 1; for (int i = (1); i <= (n); i++) b[i] = a[i]; a[++n] = 2e9, b[n] = 2e9; sort(b + 1, b + n + 1); gs = unique(b + 1, b + n + 1) - b - 1; for (int i = (1); i <= (n); i++) a[i] = lower_bound(b + 1, b + gs + 1, a[i]) - b; for (int i = (1); i <= (m); i++) io.read(b[i]); for (int i = (2); i <= (m); i++) if (a[b[i - 1]] > a[b[i]]) ans = -1; if (ans == -1) return puts( -1 ), 0; b[0] = 0, b[m + 1] = n; ans = 0; for (int i = (0); i <= (m); i++) ans += b[i + 1] - b[i] + 1 - get(b[i], b[i + 1]); io.write(ans), puts( ); return 0; }
#include <bits/stdc++.h> using namespace std; const int mxN = 1e6; int n, k, a[mxN], l[mxN]; struct dsu { int p[mxN], ld[mxN], lb[mxN]; void init() { iota(p, p + n, 0); iota(lb, lb + n, 0); } int find(int x) { return x == p[x] ? x : (p[x] = find(p[x])); } void join(int x, int y) { x = find(x), y = find(y); p[x] = y; lb[y] = lb[x]; ld[y] += ld[x]; } void upd(int i, int j) { i = find(i); ++ld[i]; if (j < n) --ld[j]; while (ld[i] >= 0 && lb[i]) join(lb[i] - 1, i); } void upd2(int i) { if (i < k) return; int j = find(i - k + 1); while (lb[j] > i - k) join(lb[j] - 1, j); } int qry() { return ld[find(0)]; } } d; int main() { ios::sync_with_stdio(0); cin.tie(0); cin >> n >> k; for (int i = 0; i < n; ++i) cin >> a[i]; d.init(); for (int i = 0; i < n; ++i) { d.upd2(i); l[i] = i - 1; while (l[i] >= 0 && a[l[i]] < a[i]) { l[i] = l[l[i]]; } d.upd(l[i] + 1, i + 1); if (i >= k - 1) cout << d.qry() << ; } return 0; }
#include <bits/stdc++.h> using namespace std; int n; void result() { set<int> s; s.insert(0); int i = 1; while (i * i <= n) { int d = n / i; s.insert(d); s.insert(n / d); i++; } cout << s.size() << n ; for (auto v : s) { cout << v << ; } cout << n ; } int main() { ios_base::sync_with_stdio(0); cin.tie(NULL); cout.tie(NULL); int t; cin >> t; while (t--) { cin >> n; result(); } return 0; }
#include <bits/stdc++.h> using namespace std; const int INF = (int)2E9; const long long LINF = (long long)9E18; const long double PI = acos(-1.0); const long double EPS = 1E-11; template <typename T> inline T sqr(const T x) { return x * x; } template <typename T> T gcd(T a, T b) { return (b == 0) ? a : gcd(b, a % b); } template <typename T> T lcm(T a, T b) { return a / gcd(a, b) * b; } template <typename T> T mod(T a, T b) { a %= b; if (a < 0) a += b; return a; } template <typename T> inline T rad(const T x) { return x * PI / 180; } template <typename T> inline string toString(T x) { ostringstream oss; oss << x; return oss.str(); } inline long long toInt(const string& st) { istringstream istringstream(st); long long x; istringstream >> x; return x; } inline long double toDouble(const string& st) { istringstream istringstream(st); long double x; istringstream >> x; return x; } inline string toLower(string st) { for (int i = 0; i < (((int)(st).size())); ++i) st[i] = tolower(st[i]); return st; } inline string toUpper(string st) { for (int i = 0; i < (((int)(st).size())); ++i) st[i] = toupper(st[i]); return st; } const int dx[] = {-1, 0, 0, 1}; const int dy[] = {0, -1, 1, 0}; int DEBUG = false; const char DEBUG_PARAM[] = __LOCAL_TESTING ; const int MAXCLOCK = 100; int aClock[MAXCLOCK], mClock[MAXCLOCK], nClock = 0, iClock = 0; inline void tick(int maxTime = 10000) { if (DEBUG) { mClock[nClock] = maxTime; aClock[nClock++] = clock(); } } inline void untick(string name = Execution Time ) { if (DEBUG) { int numClock = clock() - aClock[--nClock]; cout << @ << name << : [ << (int)((double)(numClock) / CLOCKS_PER_SEC * 1000) << ms] ; if (numClock > (int)(mClock[nClock])) cout << [TLE] ; else if (numClock > (int)(mClock[nClock] * 0.9)) cout << [almost TLE] ; cout << endl; } } const char IN[] = _.in ; const char OUT[] = _.out ; int ntest = 1, test = 1; int N; inline void run() { for (test = 1; test <= ntest; ++test) { tick((int)2E3); cin >> N; if (N == 1) { cout << a << endl << a << endl << b << endl << b << endl; } else { if (N & 1) { int N2 = N / 2; for (int i = (1); i <= (N2); ++i) { if (i & 1) { cout << aa ; } else { cout << bb ; } } cout << c << endl; for (int i = (1); i <= (N2); ++i) { if (i & 1) { cout << bb ; } else { cout << aa ; } } cout << c << endl << d ; for (int i = (1); i <= (N2); ++i) { if (i & 1) { cout << ee ; } else { cout << ff ; } } cout << endl << d ; for (int i = (1); i <= (N2); ++i) { if (i & 1) { cout << ff ; } else { cout << ee ; } } cout << endl; } else { int N2 = N / 2; for (int i = (1); i <= (N2); ++i) { if (i & 1) { cout << aa ; } else { cout << bb ; } } cout << endl << c ; for (int i = (1); i <= (N2 - 1); ++i) { if (i & 1) { cout << dd ; } else { cout << ee ; } } cout << f << endl << c ; for (int i = (1); i <= (N2 - 1); ++i) { if (i & 1) { cout << gg ; } else { cout << hh ; } } cout << f << endl; for (int i = (1); i <= (N2); ++i) { if (i & 1) { cout << ii ; } else { cout << kk ; } } cout << endl; } } untick( # + toString(test)); } } int main(int argc, char* argv[]) { if (argc > 1 && strcmp(argv[1], DEBUG_PARAM) == 0) { DEBUG = true; } if (DEBUG) { tick((int)1E4); freopen(IN, r , stdin); } run(); if (DEBUG) { untick( TOTAL ); } return 0; }
#include <bits/stdc++.h> using namespace std; int sub_tern(int c, int a) { int temp_c; int temp_a; int diff; long sum = 0; int three_power = 1; while (c > 0 || a > 0) { temp_c = c % 3; c = c / 3; temp_a = a % 3; a = a / 3; diff = temp_c - temp_a; if (diff < 0) { diff += 3; } sum += (long)diff * (long)three_power; three_power *= 3; } return sum; } int main() { int a; int c; cin >> a >> c; if (a == c) { cout << 0 n ; return 0; } cout << sub_tern(c, a) << n ; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { long n, m; while (cin >> n >> m) { long c = 0; if (n * 2 >= m) { for (int i = 0; i < m; i++) { cout << i + 1 << ; } } else { c = 1; for (int i = 2 * n + 1; i <= m; i++) { cout << i << << c << ; c++; } for (int i = c; i <= 2 * n; i++) { cout << i << ; } } } return 0; }