func_code_string
stringlengths 59
71.4k
|
|---|
#include <bits/stdc++.h> using namespace std; unordered_map<long long int, long long int> mp; long long int n, m, k, ans; long long int a[22][22]; int dx[] = {1, -1, 0, 0}; int dy[] = {0, 0, 1, -1}; void dfs1(int ex, int ey, int sx, int sy, long long int cur) { if (sx == ex and sy == ey) mp[cur]++; if (sx < ex) dfs1(ex, ey, sx + 1, sy, cur ^ (a[sx][sy])); if (sy < ey) dfs1(ex, ey, sx, sy + 1, cur ^ (a[sx][sy])); } void dfs(int x, int y, long long int cur) { if (x == n - 1 and y == m - 1) cur ^= a[x][y], ans += mp[cur ^ k]; if (x < n - 1) dfs(x + 1, y, cur ^ (a[x][y])); if (y < m - 1) dfs(x, y + 1, cur ^ (a[x][y])); } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cin >> n >> m >> k; for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) cin >> a[i][j]; int mid = (n + m - 2) / 2; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if (i + j == mid) { dfs1(i, j, 0, 0, 0); dfs(i, j, 0); mp.clear(); } } } cout << ans << n ; return 0; }
|
#include <bits/stdc++.h> const int inf = 0x3f3f3f3f, Inf = 0x7fffffff; const long long INF = 0x7fffffffffffffff; template <typename _Tp> _Tp gcd(const _Tp &a, const _Tp &b) { return (!b) ? a : gcd(b, a % b); } template <typename _Tp> __inline__ __attribute__((always_inline)) _Tp abs(const _Tp &a) { return a >= 0 ? a : -a; } template <typename _Tp> __inline__ __attribute__((always_inline)) _Tp max(const _Tp &a, const _Tp &b) { return a < b ? b : a; } template <typename _Tp> __inline__ __attribute__((always_inline)) _Tp min(const _Tp &a, const _Tp &b) { return a < b ? a : b; } template <typename _Tp> __inline__ __attribute__((always_inline)) void chmax(_Tp &a, const _Tp &b) { (a < b) && (a = b); } template <typename _Tp> __inline__ __attribute__((always_inline)) void chmin(_Tp &a, const _Tp &b) { (b < a) && (a = b); } template <typename _Tp> __inline__ __attribute__((always_inline)) void read(_Tp &x) { char ch(getchar()); bool f(false); while (ch < 48 || ch > 57) f |= ch == 45, ch = getchar(); x = ch & 15, ch = getchar(); while (ch >= 48 && ch <= 57) x = (((x << 2) + x) << 1) + (ch & 15), ch = getchar(); if (f) x = -x; } template <typename _Tp, typename... Args> __inline__ __attribute__((always_inline)) void read(_Tp &t, Args &...args) { read(t); read(args...); } __inline__ __attribute__((always_inline)) int read_str(char *s) { char ch(getchar()); while (ch == || ch == r || ch == n ) ch = getchar(); char *tar = s; *tar = ch, ch = getchar(); while (ch != && ch != r && ch != n && ch != EOF) *(++tar) = ch, ch = getchar(); return tar - s + 1; } const int N = 200005; const int mod = 998244353; template <typename _Tp1, typename _Tp2> __inline__ __attribute__((always_inline)) void add(_Tp1 &a, _Tp2 b) { (a += b) >= mod && (a -= mod); } template <typename _Tp1, typename _Tp2> __inline__ __attribute__((always_inline)) void sub(_Tp1 &a, _Tp2 b) { (a -= b) < 0 && (a += mod); } long long ksm(long long a, long long b = mod - 2) { long long res = 1; while (b) { if (b & 1) res = res * a % mod; a = a * a % mod, b >>= 1; } return res; } long long fac[N], inv[N]; void init() { fac[0] = fac[1] = inv[0] = inv[1] = 1; for (int i = 2; i < N; ++i) { fac[i] = fac[i - 1] * i % mod; inv[i] = inv[mod % i] * (mod - mod / i) % mod; } for (int i = 2; i < N; ++i) { inv[i] = inv[i - 1] * inv[i] % mod; } } __inline__ __attribute__((always_inline)) long long C(int n, int m) { return fac[n] * inv[m] % mod * inv[n - m] % mod; } long long S(int n, int m) { long long ans = 0; for (int i = 0; i <= m; ++i) { if ((m - i) & 1) sub(ans, C(m, i) * ksm(i, n) % mod); else add(ans, C(m, i) * ksm(i, n) % mod); } ans = ans * inv[m] % mod; return ans; } int main() { init(); int n; long long k; read(n, k); if (k == 0) printf( %lld n , fac[n]); else if (k >= n) printf( %lld n , 0ll); else printf( %lld n , 2ll * C(n, n - k) * fac[n - k] % mod * S(n, n - k) % mod); return 0; }
|
#include <bits/stdc++.h> using namespace std; int a[2000050]; int b[2000050]; int c[2000050]; struct node { int x, y; node() {} node(int xx, int yy) { x = xx, y = yy; } } q[2000050]; int main() { int n; scanf( %d , &n); for (int i = 1; i <= n; ++i) scanf( %d , &a[i]); for (int i = 1; i <= n; ++i) { scanf( %d , &b[i]); c[b[i]] = i; } for (int i = 1; i <= n; ++i) a[i] = c[a[i]]; int tail = 0; int ans = 0; for (int i = n; i > 0; --i) { int p = -1; for (int j = n; j > 0; --j) if (a[j] == i) { p = j; break; } if (p == i) continue; int now = p + 1; while (p != i) { while (now < n && a[now] > p) now++; q[tail++] = node(p, now); swap(a[p], a[now]); ans += now - p; p = now; now++; } } printf( %d n , ans); printf( %d n , tail); for (int i = 0; i < tail; ++i) { printf( %d %d n , q[i].x, q[i].y); } }
|
#include <bits/stdc++.h> using namespace std; int main(int argc, char const *argv[]) { int bags[4]; int flag = 0; for (int i = 0; i < 4; i++) { cin >> bags[i]; } if (bags[0] + bags[1] == bags[2] + bags[3]) { cout << YES n ; } else if (bags[0] + bags[2] == bags[1] + bags[3]) { cout << YES n ; } else if (bags[0] + bags[3] == bags[1] + bags[2]) { cout << YES n ; } else if (bags[0] + bags[1] + bags[2] == bags[3] || bags[0] + bags[2] + bags[3] == bags[1] || bags[0] + bags[1] + bags[3] == bags[2] || bags[3] + bags[1] + bags[2] == bags[0]) { cout << YES n ; } else { cout << NO n ; } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main(void) { string s, t; cin >> s >> t; int ind = -1; for (int i = 0; i < s.length(); i++) { if (s[i] != 0 ) break; else ind = i; } s = s.substr(ind + 1); ind = -1; for (int i = 0; i < t.length(); i++) { if (t[i] != 0 ) break; else ind = i; } t = t.substr(ind + 1); if (s.length() != t.length()) { if (s.length() > t.length()) cout << > n ; else cout << < n ; return 0; } for (int i = 0; i < s.length(); i++) { if (s[i] != t[i]) { if (s[i] > t[i]) cout << > n ; else cout << < n ; return 0; } } cout << = n ; return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n, h; cin >> n >> h; vector<pair<int, int>> zeros; int a, b; for (int i = 0; i < n; i++) { cin >> a >> b; zeros.push_back(make_pair(a, b)); } int sol = 0; int pa, pb, ib, c1; pa = zeros[0].first; pb = zeros[0].second; ib = 0; c1 = 0; while (c1 < h) { int d = h - c1; if (ib + 1 >= n) { pb = pb + d; c1 = h; break; } if (d <= zeros[ib + 1].first - pb) { pb = pb + d; c1 = h; break; } c1 += zeros[ib + 1].first - pb; pb = zeros[ib + 1].second; ib++; } sol = pb - pa; for (int i = 1; i < n; i++) { int ci1 = zeros[i].first - zeros[i - 1].second; pa = zeros[i].first; if (h < ci1) { pb = zeros[i].second; ib = i; c1 = 0; while (c1 < h) { int d = h - c1; if (ib + 1 >= n) { pb = pb + (h - c1); c1 = h; break; } if (d <= zeros[ib + 1].first - pb) { pb = pb + (h - c1); c1 = h; break; } c1 += zeros[ib + 1].first - pb; pb = zeros[ib + 1].second; ib++; } } else { c1 = h - ci1; while (c1 < h) { int d = h - c1; if (ib + 1 >= n) { pb = pb + (h - c1); c1 = h; break; } if (d <= zeros[ib + 1].first - pb) { pb = pb + (h - c1); c1 = h; break; } c1 += zeros[ib + 1].first - pb; pb = zeros[ib + 1].second; ib++; } } sol = max(sol, pb - pa); } cout << sol; }
|
#include <bits/stdc++.h> const int INF = 0x3f3f3f3f; using namespace std; int a[105], n, dp[105][105][2], cnt = 0; int main() { scanf( %d , &n); cnt = (n + 1) / 2; for (int i = 1; i <= n; ++i) { scanf( %d , &a[i]); if (a[i]) { if (a[i] & 1) --cnt; } } memset(dp, INF, sizeof(dp)); dp[0][0][0] = 0; dp[0][0][1] = 0; for (int i = 1; i <= n; ++i) { if (a[i]) { int t = a[i] & 1; for (int j = 0; j <= min(cnt, i - 1); ++j) dp[i][j][t] = min(dp[i - 1][j][t], dp[i - 1][j][1 - t] + 1); } else { for (int j = 1; j <= min(cnt, i); ++j) dp[i][j][1] = min(dp[i - 1][j - 1][1], dp[i - 1][j - 1][0] + 1); for (int j = 0; j <= min(cnt, i - 1); ++j) dp[i][j][0] = min(dp[i - 1][j][1] + 1, dp[i - 1][j][0]); } } printf( %d n , min(dp[n][cnt][0], dp[n][cnt][1])); }
|
#include <bits/stdc++.h> using namespace std; int n; string s; int main() { cin >> n; cin >> s; for (int i = 0; i < n; ++i) { int c1 = 0, c2 = 0; for (int j = i - 1; j >= 0; --j) { if (s[j] == L ) { break; } if (s[j] == R ) { ++c1; } } for (int j = i; j < n - 1; ++j) { if (s[j] == R ) { break; } if (s[j] == L ) { ++c2; } } cout << max(c1, c2) + 1 << ; } cout << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { ios::sync_with_stdio(false); cin.tie(0); int n, m; cin >> n >> m; vector<long long> x(n), y(n); for (int i = 0; i < n; i++) { cin >> x[i] >> y[i]; y[i] -= x[i]; } vector<vector<int>> g(n); for (int i = 0; i < m; i++) { int foo, bar; cin >> foo >> bar; foo--; bar--; g[foo].push_back(bar); g[bar].push_back(foo); } long long sum_x = accumulate(x.begin(), x.end(), 0LL); vector<long long> sorted_y = y; sort(sorted_y.begin(), sorted_y.end()); vector<long long> pref(n + 1); for (int i = 0; i < n; i++) { pref[i + 1] = pref[i] + sorted_y[i]; } for (int i = 0; i < n; i++) { long long ans = x[i] * (n - 1) + (sum_x - x[i]); int pos = (int)(lower_bound(sorted_y.begin(), sorted_y.end(), y[i]) - sorted_y.begin()); ans += pref[pos] + y[i] * (n - pos - 1); for (int j : g[i]) { long long cur = x[i] + x[j] + min(y[i], y[j]); ans -= cur; } if (i > 0) { cout << ; } cout << ans; } cout << n ; return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int m, n; scanf( %d%d , &n, &m); printf( %d n , m * n / 2); return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int boxes; cin >> boxes; int arr[boxes]; for (int i = 0; i < boxes; i++) cin >> arr[i]; int shots; cin >> shots; int x, y; for (int i = 0; i < shots; i++) { cin >> x >> y; if (x == 1) { arr[x] += (arr[x - 1] - y); arr[0] = 0; } else if (x == boxes) { arr[boxes - 1] = 0; arr[x - 2] += (y - 1); } else { arr[x] += (arr[x - 1] - y); arr[x - 2] += (y - 1); arr[x - 1] = 0; } } for (int i = 0; i < boxes; i++) cout << arr[i] << endl; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; long long int a[2 * n]; for (int i = 0; i < 2 * n; i++) cin >> a[i]; sort(a, a + (2 * n)); long long int s = 2e19; ; for (int i = 1; i < n; i++) { s = min(s, (a[n * 2 - 1] - a[0]) * (a[n + i - 1] - a[i])); } s = min(s, (a[n - 1] - a[0]) * (a[n * 2 - 1] - a[n])); cout << s; return 0; }
|
#include <bits/stdc++.h> using namespace std; using ll = long long; struct node { char type; vector<node*> children; ll dp = 0; ll r = 0; }; node* get(string& s, int& idx) { node* v = new node(); if (s[idx] == * ) { v->type = * ; idx++; return v; } else if (s[idx] == ( ) { idx++; while (true) { v->children.push_back(get(s, idx)); if (s[idx] == P || s[idx] == S ) { v->type = s[idx]; idx++; } else if (s[idx] == ) ) { idx++; break; } else assert(false); } } else assert(false); return v; } const ll Z = 2e18; ll sq(ll r) { if (r > Z / r) return Z; return min(r * r, Z); } void make_dp(node* v) { if (v->type == * ) { v->dp = 1; } else { for (node* w : v->children) { make_dp(w); } if (v->type == S ) { v->dp = Z; for (node* w : v->children) v->dp = min(v->dp, w->dp); } else if (v->type == P ) { v->dp = 0; for (node* w : v->children) v->dp += w->dp; } else assert(false); } } ll res = 0; void make_resistances(node* v, bool good) { if (v->type == * ) { cout << << (good ? res : 0); } else if (v->type == P ) { for (node* w : v->children) { make_resistances(w, good); } } else if (v->type == S ) { for (node* w : v->children) { if (w->dp == v->dp) { make_resistances(w, good); good = false; } else { make_resistances(w, false); } } } else assert(false); } void solve() { string s; getline(cin, s); auto g = s.find( ); ll R = stoll(s.substr(0, g)); s = s.substr(g + 1); s.resize(remove_if(s.begin(), s.end(), [&](char a) { return a == ; }) - s.begin()); int idx = 0; node* z = get(s, idx); make_dp(z); res = R * z->dp; cout << REVOLTING ; make_resistances(z, true); cout << n ; } int main() { ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0); int T; string s; getline(cin, s); T = stoi(s); while (T--) solve(); }
|
#include <bits/stdc++.h> using namespace std; const int maxn = 3e5 + 10; int n, b[maxn]; pair<int, int> a[maxn]; int main() { scanf( %d , &n); for (int i = 1; i <= n; i++) { scanf( %d , &a[i].first); a[i].second = i; } sort(a + 1, a + 1 + n); reverse(a + 1, a + 1 + n); for (int i = 1; i <= n; i++) { b[i] = a[i].second * 2 - 1; if (i > 1) printf( %d %d n , b[i], b[i - 1]); } int res, cur = n, des; for (int i = 1; i <= n; i++) { res = a[i].second * 2; des = i + a[i].first - 1; if (des >= cur) { b[++cur] = res; printf( %d %d n , res, b[cur - 1]); } else printf( %d %d n , res, b[des]); } }
|
#include <bits/stdc++.h> int main() { int n, x, y, z, sum1 = 0, sum2 = 0, sum3 = 0; scanf( %d , &n); while (n--) { scanf( %d %d %d , &x, &y, &z); sum1 = sum1 + x; sum2 = sum2 + y; sum3 = sum3 + z; } if (sum1 == 0 && sum2 == 0 && sum3 == 0) printf( YES ); else printf( NO ); return 0; }
|
#include <bits/stdc++.h> using namespace std; const long long N = 22; long long a[N]; long long dp[N][N][N]; long long DP(long long pos, long long sum, long long limit) { if (!pos) return 1; if (!limit && dp[pos][sum][limit] != -1) return dp[pos][sum][limit]; long long high = limit ? a[pos] : 9; long long ans = 0; for (long long i = 0; i <= high; i++) { if (sum == 3 && i != 0) continue; ans += DP(pos - 1, sum + (i != 0), limit && (i == high)); } if (!limit) dp[pos][sum][limit] = ans; return ans; } long long slove(long long n) { long long len = 0; while (n) { a[++len] = n % 10; n = n / 10; } return DP(len, 0, 1); } signed main() { memset(dp, -1, sizeof(dp)); long long T; cin >> T; while (T--) { long long L, R; cin >> L >> R; cout << slove(R) - slove(L - 1) << n ; } return 0; }
|
#include <bits/stdc++.h> using namespace std; long long a[101000]; long long pre[101000]; map<long long, long long> Hash; int main() { int n, k; scanf( %d%d , &n, &k); for (int i = 1; i <= n; i++) scanf( %I64d , &a[i]); for (int i = 1; i <= n; i++) pre[i] = pre[i - 1] + a[i]; Hash[0] = 1; long long count = 0; for (int i = 1; i <= n; i++) { if (abs(k) > 1) { for (long long p = 1; (p > 0 ? p : -p) <= 1e15; p *= k) { if (Hash[pre[i] - p]) count += Hash[pre[i] - p]; } } else { if (k == 1 || k == -1) { if (Hash[pre[i] - 1]) count += Hash[pre[i] - 1]; if (k == -1) { if (Hash[pre[i] + 1]) count += Hash[pre[i] + 1]; } } else { if (Hash[pre[i]]) count += Hash[pre[i]]; } } Hash[pre[i]] += 1; } cout << count << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; int mat[4005][4005]; int acum[4005][4005]; int dp[4005][805]; int step(int n, int k, int min_i, int max_i) { dp[n][k] = dp[min_i - 1][k - 1] + (acum[n][n] + acum[min_i - 1][min_i - 1] - acum[n][min_i - 1] - acum[min_i - 1][n]) / 2; for (int i = min_i + 1; i <= max_i; i++) { if (dp[i - 1][k - 1] + (acum[n][n] + acum[i - 1][i - 1] - acum[n][i - 1] - acum[i - 1][n]) / 2 < dp[n][k]) { dp[n][k] = dp[i - 1][k - 1] + (acum[n][n] + acum[i - 1][i - 1] - acum[n][i - 1] - acum[i - 1][n]) / 2; min_i = i; } } return min_i; } void conquer(int min_n, int max_n, int k, int min_i, int max_i) { if (min_n > max_n) return; max_i = min(max_n, max_i); if (min_n == max_n) { step(min_n, k, min_i, max_i); return; } if (min_i == max_i) { for (int i = min_n; i <= max_n; i++) step(i, k, min_i, max_i); return; } int mid = (min_n + max_n) / 2; int i = step(mid, k, min_i, min(max_i, mid)); conquer(min_n, mid - 1, k, min_i, i); conquer(mid + 1, max_n, k, i, max_i); } char buff[100005]; int main() { int n, k; scanf( %d %d n , &n, &k); for (int i = 1; i <= n; i++) { int acum2 = 0; gets(buff); for (int j = 1; j <= n; j++) { acum2 += buff[j * 2 - 2] - 0 ; acum[i][j] = acum[i - 1][j] + acum2; } } for (int i = 1; i <= n; i++) { dp[i][1] = acum[i][i] / 2; } for (int j = 2; j <= k; j++) { conquer(1, n, j, j - 1, n); } printf( %d n , dp[n][k]); return 0; }
|
#include <bits/stdc++.h> using namespace std; set<int> si; int n, k; bool solve(set<int> &cands, vector<int> &chosen) { if (cands.empty()) { if (chosen.empty()) { return false; } for (int i = 0; i < k; ++i) { int cnt = 0; for (const int num : chosen) { cnt += (((num >> i) & 0x1) ? -1 : 1); } if (cnt < 0) { return false; } } return true; } int val = *cands.begin(); bool ok = false; cands.erase(val); ok |= solve(cands, chosen); chosen.push_back(val); ok |= solve(cands, chosen); chosen.pop_back(); cands.insert(val); return ok; } int main(int argc, char **argv) { std::ios::sync_with_stdio(false); cin >> n >> k; for (int i = 0; i < n; ++i) { int val = 0; for (int j = 0; j < k; ++j) { int t; cin >> t; val |= (t << j); } si.insert(val); } vector<int> chosen; cout << (solve(si, chosen) ? YES n : NO n ); }
|
#include <bits/stdc++.h> using namespace std; int a[5005], cnt, tmp, nxt, V[5005], j, n, i; long long dp[2][5005], ans; struct LS { int pos, val; } ls[5005]; inline bool cmp(LS aa, LS bb) { return aa.val < bb.val; } int main() { cin >> n; for (i = 1; i <= n; ++i) cin >> a[i], ls[i].val = a[i], ls[i].pos = i; sort(ls + 1, ls + n + 1, cmp); ls[0].val = -1000000001; for (i = 1; i <= n; ++i) { if (ls[i].val != ls[i - 1].val) ++cnt, V[cnt] = ls[i].val; a[ls[i].pos] = cnt; } for (i = 1; i <= a[1]; ++i) dp[0][i] = V[a[1]] - V[i]; for (i = a[1] + 1; i <= cnt; ++i) dp[0][i] = 0; for (i = 2; i <= n; tmp ^= 1, ++i) { nxt = tmp ^ 1; dp[nxt][0] = 1e16; for (j = 1; j <= cnt; ++j) dp[nxt][j] = min(dp[nxt][j - 1], dp[tmp][j] + abs(V[a[i]] - V[j])); } for (ans = 1e16, j = 1; j <= cnt; ++j) ans = min(ans, dp[tmp][j]); cout << ans; }
|
#include <bits/stdc++.h> using namespace std; int main() { long long int n, d; cin >> n >> d; int t; cin >> t; while (t--) { long long int x, y; cin >> x >> y; long long int eq1 = y * (n - d) - ((n - d) * (x - d)); long long int eq2 = (y - (n - d)) + (x - (n)); long long int eq3 = ((y - n) - (x - (n - d))); long long int eq4 = (y - d) + (x); if (eq1 >= 0 && eq2 <= 0 && eq3 <= 0 && eq4 >= 0) cout << YES n ; else cout << NO n ; } }
|
#include <bits/stdc++.h> using namespace std; int main() { bool flag = 0, flag2 = 0; long long n, m, c = 0; cin >> n >> m; for (long long i = 0; i < n; i++) { for (long long j = 0; j < m; j++) { if (i % 2 != 0 && c % 2 == 0 && j != m - 1) { cout << . ; flag = 1; } else if (i % 2 != 0 && c % 2 != 0 && j != 0) { cout << . ; flag2 = 1; } else cout << # ; } cout << endl; if (flag || flag2) c++; flag = 0, flag2 = 0; } return 0; }
|
#include<bits/stdc++.h> using namespace std; typedef long long int ll; ll mod=1e9+7; int main() { int t; cin>>t; while(t--) { ll n,k; cin>>n>>k; ll ans=1; for(ll i=0;i<k;i++) { ans=(ans*n)%mod; } cout<<ans<<endl; } }
|
#include <bits/stdc++.h> using namespace std; int _I() { int x; scanf( %d , &x); return x; } const int lmt = 10000000; bool prime[lmt + 5]; int rng = 1, v[lmt + 5]; void sv() { v[0] = 2; for (int i = 4; i <= lmt; i += 2) prime[i] = 1; for (int i = 3; i <= lmt; i += 2) { if (!prime[i]) { v[rng++] = i; for (int j = i * 3; j <= lmt; j += i << 1) prime[j] = 1; } } prime[1] = 1; } int rev(int n) { int num = 0; while (n) { num *= 10; num += (n % 10); n /= 10; } return num; } void solve() { int n = _I(); int ans[100001]; for (int i = 13, j = 1; j <= 11184; i++) { if (i != rev(i) && !prime[i] && !prime[rev(i)]) ans[j++] = i; } cout << ans[n] << n ; } int main() { sv(); solve(); return 0; }
|
#include <bits/stdc++.h> using namespace std; const long double radian = 180 / acos(-1); int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); long long x, mini = LLONG_MAX, p; cin >> x; x %= 360; if (x < 0) x = 360 + x; for (int i = 0; i < 4; i++) { if (min(x, 360 - x) < mini) { mini = min(x, 360 - x); p = i; } x = (x + 270) % 360; } cout << p; 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 nread(vector<T> &a) { int n; cin >> n; a.clear(); a.resize(n); for (int i = 0; i < n; i++) cin >> a[i]; return n; } template <typename T> inline void nwread(int n, vector<T> &a) { a.clear(); a.resize(n); for (int i = 0; i < n; i++) cin >> a[i]; } int main() { int n, k; cin >> n >> k; vector<int> a(n); for (int i = 0; i < n; i++) cin >> a[i]; for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { if (a[j] != 0) continue; cout << j + 1 << ; a[j] = -1; for (int l = 0; l <= j - k; l++) a[l]--; break; } } }
|
#include <bits/stdc++.h> using namespace std; const int N = 1e5 + 100; long long t; long long n; long long a[N]; long long b[N]; map<long long, long long> ma; int main() { scanf( %lld , &t); while (t--) { ma.clear(); memset(a, 0, sizeof(a)); memset(b, 0, sizeof(b)); scanf( %lld , &n); for (long long i = 1; i <= n; i++) scanf( %lld , &a[i]); for (long long i = 1; i <= n; i++) scanf( %lld , &b[i]); if (a[1] != b[1]) { printf( NO n ); continue; } ma[a[1]] = 1; bool f = false; for (long long i = 2; i <= n; i++) { if (a[i] == b[i]) { ma[a[i]] = 1; continue; } if (f) break; long long cha = b[i] - a[i]; if (cha < 0) { if (ma[-1] > 0) { } else { f = true; break; } } if (cha > 0) { if (ma[1] > 0) { } else { f = true; break; } } if (f) break; ma[a[i]] = 1; } if (f) { printf( NO n ); } else { printf( YES n ); } } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { string a, b, c, d; cin >> a >> b >> c >> d; int c1 = 0, c2 = 0, c3 = 0, c4 = 0; if ((a.size() - 2) >= (b.size() - 2) * 2 && (a.size() - 2) >= (c.size() - 2) * 2 && (a.size() - 2) >= (d.size() - 2) * 2) { c1 = 1; } else if ((a.size() - 2) * 2 <= (b.size() - 2) && (a.size() - 2) * 2 <= (c.size() - 2) && (a.size() - 2) * 2 <= (d.size() - 2)) { c1 = 1; } if ((b.size() - 2) >= (a.size() - 2) * 2 && (b.size() - 2) >= (c.size() - 2) * 2 && (b.size() - 2) >= (d.size() - 2) * 2) { c2 = 1; } else if ((b.size() - 2) * 2 <= (a.size() - 2) && (b.size() - 2) * 2 <= (c.size() - 2) && (b.size() - 2) * 2 <= (d.size() - 2)) { c2 = 1; } if ((c.size() - 2) >= (a.size() - 2) * 2 && (c.size() - 2) >= (b.size() - 2) * 2 && (c.size() - 2) >= (d.size() - 2) * 2) { c3 = 1; } else if ((c.size() - 2) * 2 <= (a.size() - 2) && (c.size() - 2) * 2 <= (b.size() - 2) && (c.size() - 2) * 2 <= (d.size() - 2)) { c3 = 1; } if ((d.size() - 2) >= (a.size() - 2) * 2 && (d.size() - 2) >= (b.size() - 2) * 2 && (d.size() - 2) >= (c.size() - 2) * 2) { c4 = 1; } else if ((d.size() - 2) * 2 <= (a.size() - 2) && (d.size() - 2) * 2 <= (b.size() - 2) && (d.size() - 2) * 2 <= (c.size() - 2)) { c4 = 1; } if (c1 + c2 + c3 + c4 > 1 || c1 + c2 + c3 + c4 == 0) cout << c[0] << endl; else { if (c1 == 1) cout << a[0] << endl; else if (c2 == 1) cout << b[0] << endl; else if (c3 == 1) cout << c[0] << endl; else if (c4 == 1) cout << d[0] << endl; } return 0; }
|
#include <bits/stdc++.h> using namespace std; inline long long read() { long long x; cin >> x; return x; } const int MAX_N = 15; const int MAX_F = (1 << (MAX_N - 2)) + 4; int n, m, nQ, id[MAX_N]; bool isEdge[MAX_N][MAX_N], isParent[MAX_N][MAX_N], isNotParent[MAX_N][MAX_N], isLCA[MAX_N][MAX_N][MAX_N]; bool ok1[MAX_F][MAX_N], ok2[MAX_F][MAX_N], ok3[MAX_F][MAX_N][MAX_N], ok4[MAX_F][MAX_F], ok5[MAX_F][MAX_N]; long long f[MAX_F][MAX_N]; inline bool check_0(int u, int v, int r) { if (u == v && r != u) return 0; if ((u == 1 || v == 1) && r != 1) return 0; return 1; } void init(int nMask) { memset(ok1, 0, sizeof(ok1)); memset(ok2, 0, sizeof(ok2)); memset(ok3, 0, sizeof(ok3)); memset(ok4, 0, sizeof(ok4)); memset(ok5, 0, sizeof(ok5)); for (long long x = (0); x <= (nMask); ++x) for (long long i = (1); i <= (n); ++i) if (x & id[i]) { ok1[x][i] = 1; for (long long j = (1); j <= (n); ++j) if (j != i && (x & id[j])) if (isParent[j][i] || isNotParent[i][j]) { ok1[x][i] = 0; break; } } for (long long x = (0); x <= (nMask); ++x) for (long long i = (1); i <= (n); ++i) if (!(x & id[i])) { ok2[x][i] = 1; for (long long j = (1); j <= (n); ++j) if (x & id[j]) if (isParent[j][i] || isParent[i][j] || isEdge[j][i] || isEdge[i][j]) { ok2[x][i] = 0; break; } } for (long long x = (0); x <= (nMask); ++x) for (long long i = (1); i <= (n); ++i) if (x & id[i]) for (long long r = (1); r <= (n); ++r) if (!(x & id[r])) { ok3[x][i][r] = 1; for (long long j = (1); j <= (n); ++j) if (j != i && (x & id[j])) if (isEdge[r][j]) { ok3[x][i][r] = 0; break; } } for (long long x = (0); x <= (nMask); ++x) { for (long long y = (0); y <= (nMask); ++y) if (!(x & y)) { ok4[x][y] = 1; for (long long i = (1); i <= (n); ++i) if (x & id[i]) { for (long long j = (1); j <= (n); ++j) if (y & id[j]) if (isParent[i][j] || isParent[j][i] || isEdge[i][j] || isEdge[j][i]) { ok4[x][y] = 0; break; } if (!ok4[x][y]) break; } } } for (long long x = (0); x <= (nMask); ++x) for (long long r = (1); r <= (n); ++r) if (!(x & id[r])) { ok5[x][r] = 1; for (long long i = (1); i <= (n); ++i) if (ok5[x][r]) if (x & id[i]) for (long long j = (1); j <= (n); ++j) if (x & id[j]) if (i != j) if (isLCA[r][i][j]) { ok5[x][r] = 0; break; } } } inline bool check(int mask, int r, int newMask, int newR) { int x = mask - newMask; return ok1[newMask][newR] && ok2[x][newR] && ok3[newMask][newR][r] && ok4[newMask][x] && ok5[newMask][r]; } long long solve(int mask, int par) { if (mask == 0) return 1; if (f[mask][par] > -1) return f[mask][par]; long long ans = 0; int x = 0; do { if (x > 0 && __builtin_clz(x) == __builtin_clz(mask)) for (long long r = (1); r <= (n); ++r) if (x & id[r]) { if (!check(mask, par, x, r)) continue; long long t = solve(x - id[r], r) * solve(mask - x, par); ans += t; } x = (x + 1 + (~mask)) & mask; } while (x); return f[mask][par] = ans; } int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.precision(9); cout.setf(ios::fixed, ios::floatfield); memset(isEdge, 0, sizeof(isEdge)); memset(isParent, 0, sizeof(isParent)); memset(isNotParent, 0, sizeof(isNotParent)); memset(isLCA, 0, sizeof(isLCA)); cin >> n >> m >> nQ; for (long long i = (1); i <= (n); ++i) id[i] = 1 << (i - 1); while (m--) { int u, v; cin >> u >> v; isEdge[u][v] = isEdge[v][u] = 1; } while (nQ--) { int u, v, r; cin >> u >> v >> r; if (!check_0(u, v, r)) { cout << 0 << n ; return 0; } if (r != u) isNotParent[u][v] = 1; if (r != v) isNotParent[v][u] = 1; isParent[r][u] = isParent[r][v] = 1; if (r != u && r != v) isLCA[r][u][v] = isLCA[r][v][u] = 1; } for (long long i = (1); i <= (n); ++i) isParent[i][i] = isNotParent[i][i] = 0; memset(f, -1, sizeof(f)); int mask = 0; for (long long i = (2); i <= (n); ++i) mask |= id[i]; init(mask); cout << solve(mask, 1) << n ; return 0; }
|
#include <bits/stdc++.h> using namespace std; int n, k; char playLog[1111]; char posLet[3] = { W , D , L }; int delta[3] = {1, 0, -1}; int val[256]; char dp[1111][2222]; void clearArray() { for (int i = 0; i <= n + 1; i++) { for (int j = -k; j <= k; j++) dp[i][j + k] = X ; } } void printAnswer() { int currentState = 0; for (int i = 0; i < n; i++) { char thisOne = dp[i][currentState + k]; printf( %c , thisOne); currentState += val[thisOne]; } printf( n ); } int main() { val[ W ] = 1; val[ D ] = 0; val[ L ] = -1; scanf( %d%d , &n, &k); scanf( %s , playLog); clearArray(); dp[n][k + k] = P ; for (int i = n - 1; i >= 0; i--) { for (int j = -(k - 1); j <= (k - 1); j++) { for (int q = 0; q < 3; q++) { if (playLog[i] != ? && (playLog[i] != posLet[q])) continue; int target = j + delta[q]; if (dp[i + 1][target + k] == X ) continue; dp[i][j + k] = posLet[q]; break; } } } if (dp[0][0 + k] != X ) { printAnswer(); return 0; } clearArray(); dp[n][0] = P ; for (int i = n - 1; i >= 0; i--) { for (int j = -(k - 1); j <= (k - 1); j++) { for (int q = 0; q < 3; q++) { if (playLog[i] != ? && (playLog[i] != posLet[q])) continue; int target = j + delta[q]; if (dp[i + 1][target + k] == X ) continue; dp[i][j + k] = posLet[q]; break; } } } if (dp[0][0 + k] != X ) { printAnswer(); return 0; } printf( NO n ); return 0; }
|
#include <bits/stdc++.h> using namespace std; const int shape[4][4][2] = {{{1, 0}, {2, 0}, {1, 1}, {1, 2}}, {{1, 0}, {2, 0}, {2, -1}, {2, 1}}, {{0, 1}, {0, 2}, {-1, 2}, {1, 2}}, {{0, 1}, {0, 2}, {1, 1}, {2, 1}}}; int x, y; struct node { char g[9][9]; int num; int sx, sy; node() { sx = sy = 0; memset(g, 0, sizeof(g)); num = 0; } void printNode() { for (int i = 0; i < y; i++) { for (int j = 0; j < x; j++) printf( %c , g[i][j] ? g[i][j] : . ); cout << << endl; } } }; stack<node> q; int ans; node ansNode; void bfs() { while (true) { The_End_Where_I_Began: if (q.empty()) break; node now = q.top(); q.pop(); if (now.num > ans) { ans = now.num; ansNode = now; } now.num++; char ch = A + now.num - 1; bool flag = true; for (int i = now.sy; i < y; i++) { int j = (now.sy == i ? now.sx : 0); for (; j < x; j++) { if (!now.g[i][j]) { flag = true; for (int k = 3; k >= 0; k--) { flag = true; for (int l = 0; l < 4; l++) { int tx = j + shape[k][l][1]; int ty = i + shape[k][l][0]; if (tx < 0 || tx >= x || ty < 0 || ty >= y || now.g[ty][tx]) { flag = false; break; } } if (flag) { node tNode = now; tNode.g[i][j] = ch; for (int l = 0; l < 4; l++) { int tx = j + shape[k][l][1]; int ty = i + shape[k][l][0]; tNode.g[ty][tx] = ch; } tNode.sx = j + 1; tNode.sy = i; q.push(tNode); } } if (flag) goto The_End_Where_I_Began; } } } } } int main() { ans = -1; cin >> y >> x; while (!q.empty()) q.pop(); q.push(node()); bfs(); cout << ans << endl; ansNode.printNode(); return 0; }
|
#include <bits/stdc++.h> using namespace std; using ll = long long; using pii = pair<int, int>; using pll = pair<ll, ll>; const ll inf = 1; const ll mod = 1E9; int main() { int n, m; scanf( %d %d , &n, &m); int colors = 1; vector<vector<int> > mset(n, vector<int>()); vector<vector<int> > G(n, vector<int>()); for (int i = 0; i < n; i++) { int lim; scanf( %d , &lim); for (int j = 0; j < lim; j++) { int x; scanf( %d , &x); mset[i].push_back(x - 1); } colors = max(colors, lim); } for (int i = 0; i < n - 1; i++) { int u, v; scanf( %d %d , &u, &v); G[u - 1].push_back(v - 1); G[v - 1].push_back(u - 1); } set<int> ms; vector<int> col(m, 0); vector<bool> vis(n, false); queue<int> Q; Q.push(0); vis[0] = true; while (!Q.empty()) { int u = Q.front(); Q.pop(); for (auto j : mset[u]) { if (col[j] != 0) ms.insert(col[j]); } int now = 1; for (auto j : mset[u]) { if (col[j] == 0) { while (ms.find(now) != ms.end()) now++; col[j] = now; now++; } } for (auto v : G[u]) { if (!vis[v]) { vis[v] = true; Q.push(v); } } ms.clear(); } printf( %d n , colors); for (int i = 0; i < m; i++) { if (col[i] == 0) col[i] = 1; printf( %d , col[i]); } printf( n ); return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { string s; cin >> s; cout << s; reverse(s.begin(), s.end()); cout << s; }
|
#include <bits/stdc++.h> using namespace std; template <typename T> inline T Max(T a, T b) { return a > b ? a : b; } template <typename T> inline T Min(T a, T b) { return a < b ? a : b; } template <typename T> inline void checkMax(T &a, T b) { if (a < b) a = b; } template <typename T> inline void checkMin(T &a, T b) { if (a > b) a = b; } template <typename T> inline T Abs(T a) { return a > 0 ? a : -a; } int a; string s; int num[4005]; int SumR[4005]; int Cnt[50000]; long long ans; void work() { cin >> s; int len = s.length(); for (int i = 0; i < len; i++) { num[i] = s[i] - 0 ; } for (int i = 0; i < len; i++) { if (i == 0) SumR[i] = num[i]; else SumR[i] = SumR[i - 1] + num[i]; } memset(Cnt, 0, sizeof(Cnt)); for (int i = 0; i < len; i++) { for (int j = i; j < len; j++) { int tmp = SumR[j]; if (i != 0) tmp -= SumR[i - 1]; Cnt[tmp]++; } } ans = 0; for (int i = 0; i < len; i++) { for (int j = i; j < len; j++) { int tmp = SumR[j]; if (i != 0) tmp -= SumR[i - 1]; if (tmp != 0) { if (a % tmp == 0) { long long div = a / tmp; if (div <= SumR[len - 1]) { ans += Cnt[div]; } } } else { if (a == 0) { ans += len * (len + 1) / 2; } } } } cout << ans << endl; } int main() { while (cin >> a) { work(); } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int t; cin >> t; while (t--) { int n, k; cin >> n >> k; string s; cin >> s; sort(s.begin(), s.end()); map<char, int> store; for (int i = 0; i < n; i++) { store[s[i]]++; } if (store.size() == 1) { int temp = n / k; if (n % k != 0) temp++; for (int i = 0; i < temp; i++) cout << s[0]; } else if (store.size() == 2 && store[s[0]] == k) { cout << s[0]; int temp = n / k; if (n % k != 0) temp++; for (int i = 0; i < temp - 1; i++) cout << s[k]; } else { if (s[0] != s[k - 1]) cout << s[k - 1]; else { for (int i = k - 1; i < n; i++) cout << s[i]; } } cout << n ; } return 0; }
|
#include <bits/stdc++.h> using namespace std; set<int> v; multiset<int> diff; void clean() { if (v.size() < 2) { cout << 0 << endl; return; } cout << *v.rbegin() - *v.begin() - *diff.rbegin() << endl; } int main() { v.clear(); diff.clear(); int n, q; cin >> n >> q; for (int i = 0; i < n; i++) { int x; cin >> x; v.insert(x); } for (auto it = v.begin(); next(it) != v.end(); it++) diff.insert(*next(it) - *it); clean(); while (q--) { int t, x; cin >> t >> x; if (t == 1) { v.insert(x); set<int>::iterator it = v.find(x); if (it == v.begin()) diff.insert(*next(it) - *it); else if (next(it) == v.end()) diff.insert(*it - *prev(it)); else { diff.erase(diff.find(*next(it) - *prev(it))); diff.insert(*next(it) - *it); diff.insert(*it - *prev(it)); } } else { set<int>::iterator it = v.find(x); if (v.size() >= 2) { if (it == v.begin()) diff.erase(diff.find(*next(it) - *it)); else if (next(it) == v.end()) diff.erase(diff.find(*it - *prev(it))); else { diff.erase(diff.find(*it - *prev(it))); diff.erase(diff.find(*next(it) - *it)); diff.insert(*next(it) - *prev(it)); } } v.erase(it); } clean(); } return 0; }
|
#include <bits/stdc++.h> using namespace std; int const oo = 1e9, bound = 1e6, mod = oo + 7; long long const OO = 1e18; int n, m, k, aa[20]; int cc[20][20]; long long dp[18][1 << 18]; long long rec(int idx, int msk) { long long &ret = dp[idx][msk]; if (ret != -1) return ret; int cop = msk, e = 0; while (cop) { if (cop & 1) e++; cop >>= 1; } if (e == m) return ret = 0; for (int(i) = 0; (i) < (n); (i)++) { if (!((msk >> i) & 1)) ret = max(ret, rec(i, (1 << i) | msk) + aa[i] + (msk != 0 ? cc[idx][i] : 0)); } return ret; } int main() { memset(dp, -1, sizeof dp); scanf( %d , &n), scanf( %d , &m), scanf( %d , &k); for (int(i) = 0; (i) < (n); (i)++) scanf( %d , &aa[i]); for (int(i) = 0; (i) < (k); (i)++) { int a, b, c; scanf( %d , &a), scanf( %d , &b), scanf( %d , &c); a--, b--; cc[a][b] = c; } long long mx = rec(0, 0); printf( %lld n , mx); return 0; }
|
#include <bits/stdc++.h> using namespace std; const long long int INF = 98769876987698889LL; const int MOD = 1e9 + 7; const int dx8[] = {1, 1, 0, -1, -1, -1, 0, 1}; const int dy8[] = {0, 1, 1, 1, 0, -1, -1, -1}; const int dx4[] = {1, -1, 0, 0}; const int dy4[] = {0, 0, 1, -1}; const int N = 2e5 + 5; long long int dp1[N], a[N], f[N], dp2[N], s[N]; int n; vector<int> G[N]; void dfs(int x, int pa) { if (G[x].size() == 1 and G[x][0] == pa) { s[x] = a[x]; return; } s[x] = a[x]; for (auto k : G[x]) { if (k == pa) continue; dfs(k, x); s[x] += s[k]; } } void dfs2(int x, int pa) { if (G[x].size() == 1 and G[x][0] == pa) { f[x] = 0; return; } f[x] = 0; vector<long long int> v; for (auto k : G[x]) { if (k == pa) continue; dfs2(k, x); if (s[k] >= dp1[k]) { v.push_back(s[k]); } else { v.push_back(dp1[k]); } } sort(v.begin(), v.end()); dp1[x] = v[v.size() - 1]; if (v.size() > 1) { f[x] = 1; dp2[x] = v[v.size() - 2]; } } int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); ; cin >> n; for (int i = 1; i <= n; i++) cin >> a[i]; for (int i = 0; i < N; i++) { dp1[i] = -INF; dp2[i] = -INF; } for (int i = 2; i <= n; i++) { int x, y; cin >> x >> y; G[x].push_back(y); G[y].push_back(x); } if (n == 1) { cout << Impossible << endl; return 0; } dfs(1, 0); dfs2(1, 0); int fl = 0; for (int i = 1; i <= n; i++) { if (f[i]) fl = 1; } if (!fl) { cout << Impossible << endl; return 0; } long long int ans = -INF; for (int i = 1; i <= n; i++) { if (f[i]) { ans = max(ans, dp1[i] + dp2[i]); } } cout << ans; }
|
#include <bits/stdc++.h> using namespace std; int main() { int t; cin >> t; for (int i = 0; i < t; ++i) { int n, m, h; cin >> n >> m; long long int sum = 0; for (int j = 0; j < n; ++j) { int x; cin >> x; if (j != 0) sum = sum + x; if (j == 0) h = x; } if (m - h < sum) h = m; else h = h + sum; cout << h << n ; } }
|
#include <bits/stdc++.h> using namespace std; long long n, k, p; string s; vector<long long> mem; long long solve(int i) { if (mem[i] != -1) return mem[i]; if (i == 0) return 0; long long tmp = stoll(s.substr(i - 1, 1)); long long res = 1ll << 62; for (int j = i - 1; tmp < n; --j) { if (s[j] != 0 || j == i - 1) { long long tmptmp = solve(j); if (tmptmp < ((1ll << 62) - tmp) / n && tmptmp > -1) res = min(res, tmp + n * tmptmp); } if (j - 1 < 0) break; tmp = stoll(s.substr(j - 1, i - j + 1)); } mem[i] = res; return res; } int main(int argc, char const *argv[]) { cin >> n; cin >> s; k = s.length(); if (n < 11) { long long res = 0; for (int i = 0; i < k; ++i) { res *= n; res += stoi(s.substr(i, 1)); } cout << res << endl; return 0; } mem = vector<long long>(k + 1, -1); cout << solve(k) << endl; return 0; }
|
#include <bits/stdc++.h> #pragma GCC optimize( Ofast ) #pragma GCC target( avx,avx2,fma ) #pragma GCC optimization( unroll-loops ) using namespace std; const int MX = 2000006; char a[MX], b[MX]; char arb[MX], abr[MX], ba[MX]; int parb[MX], zabr[MX], zba[MX], pos[MX]; void compute_pi(int n, char s[], int pi[]) { pi[0] = 0; for (int i = 1; i < n; i++) { int j = pi[i - 1]; while (j) { if (s[j] == s[i]) { pi[i] = j + 1; break; } j = pi[j - 1]; } if (j == 0) pi[i] = (s[i] == s[0]) ? 1 : 0; } } void compute_z(int n, char s[], int z[]) { int l = 0, r = 0; for (int i = 1; i < n; i++) { if (i <= r) z[i] = min(z[i - l], r - i + 1); for (int j = i + z[i], p = z[i]; j < n; j++, p++) { if (s[p] == s[j]) z[i]++; else break; } if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1; } } void calc(int n, int m) { compute_pi(n + m + 1, arb, parb); compute_z(n + m + 1, abr, zabr); compute_z(n + m + 1, ba, zba); memset(pos, -1, sizeof(pos)); for (int i = n + 1, p = 0; i <= n + m; i++, p++) { if (parb[i] < 1) continue; int j = p - parb[i] + 1; if (pos[p] == -1) pos[p] = j; } } void make(int n, int m) { char sep[] = ; sep[0] = 31; strcpy(ba, b); strcat(ba, sep); strcat(ba, a); strcpy(arb, a); reverse(arb, arb + n); strcat(arb, sep); strcat(arb, b); strcpy(abr, a); reverse(b, b + m); strcat(abr, sep); strcat(abr, b); } int main() { gets(a), gets(b); int n = strlen(a), m = strlen(b); make(n, m); calc(n, m); int x = -1, y = -1; for (int i = m + 2; (i <= n + m && n == m); i++) { int p = pos[n + m - i]; if (p < 0 || p > zba[i]) continue; if (zabr[n + 1] >= i - m - 1) x = i - m - 2, y = i - m - 1 + p; } printf( %d %d n , x, y); return 0; }
|
#include <bits/stdc++.h> #pragma GCC target( avx2 ) #pragma GCC optimization( O3 ) #pragma GCC optimization( unroll-loops ) using namespace std; inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; } inline int msbp(int x) { return 31 - __builtin_clz(x); } inline int msb(int x) { return 1 << msbp(x); } const int INF = 0x3f3f3f3f; struct hash_pair { template <class T1, class T2> size_t operator()(const pair<T1, T2>& p) const { auto hash1 = hash<T1>{}(p.first); auto hash2 = hash<T2>{}(p.second); return hash1 ^ hash2; } }; const int N = 1e6 + 10; int parent[N], rnk[N]; int find(int x) { return parent[x] = (x == parent[x] ? x : find(parent[x])); } bool disjoint(int x, int y) { return find(x) != find(y); } void join(int x, int y) { if (!disjoint(x, y)) return; int xPar = find(x), yPar = find(y); int newPar, newChild; if (rnk[xPar] > rnk[yPar]) { newPar = xPar, newChild = yPar; } else if (rnk[xPar] < rnk[yPar]) { newPar = yPar, newChild = xPar; } else { newPar = xPar, newChild = yPar; ++rnk[xPar]; } parent[newChild] = newPar; } int n, m, b[N]; pair<int, int> a[N]; vector<pair<int, int>> all_vals; map<int, vector<int>> s; vector<int> g[N]; int d[N], dp[N]; void process_eq(vector<pair<int, int>>& cur) { map<int, int> val_map; for (auto [val, id] : cur) { if (val_map.count(val)) { join(id, val_map[val]); } else { val_map[val] = id; } } } void process(vector<int>& cur) { sort(cur.begin(), cur.end()); for (int i = 0; i < (cur.size() - 1); ++i) { if (cur[i] != cur[i + 1]) { g[cur[i]].push_back(cur[i + 1]); ++d[cur[i + 1]]; } } } signed main() { ios::sync_with_stdio(false); std::iota(parent, parent + N, 0); scanf( %d %d , &n, &m); for (int i = 0; i < (n); ++i) { for (int j = 0; j < (m); ++j) { scanf( %d , &a[i * m + j].first); s[a[i * m + j].first].push_back(i * m + j); } } vector<pair<int, int>> curm(m), curn(n); for (int i = 0; i < (n); ++i) { for (int j = 0; j < (m); ++j) curm[j] = {a[i * m + j].first, i * m + j}; process_eq(curm); } for (int j = 0; j < (m); ++j) { for (int i = 0; i < (n); ++i) curn[i] = {a[i * m + j].first, i * m + j}; process_eq(curn); } for (auto [val, ids] : s) { int cur = 1; for (int id : ids) { if (a[find(id)].second == 0) { all_vals.push_back({val, cur}); a[find(id)].second = cur++; } a[id].second = a[find(id)].second; } } sort(all_vals.begin(), all_vals.end()); map<pair<int, int>, int> id_map; for (int i = 0; i < (all_vals.size()); ++i) id_map[all_vals[i]] = i; for (int i = 0; i < (n); ++i) for (int j = 0; j < (m); ++j) b[i * m + j] = id_map[a[i * m + j]]; vector<int> ccurm(m), ccurn(n); for (int i = 0; i < (n); ++i) { for (int j = 0; j < (m); ++j) ccurm[j] = b[i * m + j]; process(ccurm); } for (int j = 0; j < (m); ++j) { for (int i = 0; i < (n); ++i) ccurn[i] = b[i * m + j]; process(ccurn); } queue<int> nxt; for (int x = 0; x < (all_vals.size()); ++x) { if (d[x] == 0) { nxt.push(x); dp[x] = 1; } } while (!nxt.empty()) { int cur = nxt.front(); nxt.pop(); for (auto v : g[cur]) { dp[v] = max(dp[v], dp[cur] + 1); --d[v]; if (d[v] == 0) { nxt.push(v); } } } for (int i = 0; i < (n); ++i) { for (int j = 0; j < (m); ++j) cout << dp[b[i * m + j]] << ; cout << n ; } return 0; }
|
#include <bits/stdc++.h> #pragma comment(linker, /STACK:64777216 ) using namespace std; const long long maxn = 100001; const long long maxk = 200001; const long long maxx = 10001; const long long secret_number = 87468267; const long long inf = 1e18; const int iinf = 2147483647 / 2; const double pi = 3.141592653589793238462643383279502884; const double eps = 1e-7; const string something_very_long = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaa ; const string govno = g ; const int maxp = 101; int n, p, q; int pr[maxp]; int main() { cin.sync_with_stdio(0); cin >> n >> p >> q; string s; cin >> s; for (int i = 0; i < maxp; ++i) pr[i] = -2; pr[0] = 0; queue<int> qq; qq.push(0); while (!qq.empty()) { int cur = qq.front(); qq.pop(); if ((cur + p <= s.length()) && (pr[cur + p] == -2)) pr[cur + p] = cur, qq.push(cur + p); if ((cur + q <= s.length()) && (pr[cur + q] == -2)) pr[cur + q] = cur, qq.push(cur + q); } stack<string> v; int cur = s.length(); if (pr[cur] == -2) { cout << -1; return 0; } while (true) { if (cur != 0) { v.push(s.substr(pr[cur], cur - pr[cur])); cur = pr[cur]; } else break; } cout << v.size() << n ; while (!v.empty()) { string aa = v.top(); v.pop(); cout << aa << n ; } return 0; }
|
#include <bits/stdc++.h> using namespace std; using ll = long long; struct p { ll v; int i; } pp[3]; bool cmp(p x, p y) { return x.v < y.v; } void dd() { sort(pp, pp + 3, cmp); ll y = 2 * pp[2].v - pp[0].v - pp[1].v; cout << y << endl; cout.flush(); int x; cin >> x; if (x == 0) { return; } else { if (pp[0].i == x) { cout << pp[2].v - pp[1].v << endl; cout.flush(); int g; cin >> g; return; } else if (pp[1].i == x) { cout << pp[2].v - pp[0].v << endl; cout.flush(); int g; cin >> g; } else { pp[2].v += y; dd(); } } } int main() { ll a, b, c; cin >> a >> b >> c; pp[0].v = a; pp[0].i = 1; pp[1].v = b; pp[1].i = 2; pp[2].v = c; pp[2].i = 3; cout << First << endl; cout.flush(); dd(); return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n; scanf( %d , &n); vector<vector<int>> g(n); for (int i = 0; (i) < (int)(n - 1); (i)++) { int a, b; scanf( %d%d , &a, &b); a--, b--; g[a].push_back(b); g[b].push_back(a); } int ans = 0; for (int s = 0; (s) < (int)(n); (s)++) { for (int t = s + 1; t < n; t++) { vector<int> tmp, path; function<void(int, int)> dfs = [&](int u, int prev) { if (u == t) { path = tmp; return; } for (auto v : g[u]) if (v != prev) { tmp.push_back(v); dfs(v, u); tmp.pop_back(); } }; tmp.push_back(s); dfs(s, -1); vector<bool> ng(n); for (int p : path) ng[p] = true; int len = (int)path.size() - 1; vector<int> dp1(n), dp2(n); function<void(int, int)> dfs2 = [&](int u, int prev) { vector<int> pro; for (auto v : g[u]) if (v != prev) { dfs2(v, u); dp1[u] = max(dp1[u], dp1[v]); dp1[u] = max(dp1[u], dp2[v]); if (!ng[v]) pro.push_back(dp2[v]); } if (pro.size() == 0 || ng[u]) return; sort(pro.rbegin(), pro.rend()); dp2[u] = pro[0] + 1; if (pro.size() > 1) { dp1[u] = max(dp1[u], pro[0] + pro[1] + 2); } }; dfs2(s, -1); ans = max(ans, len * dp1[s]); } } printf( %d n , ans); return 0; }
|
#include <bits/stdc++.h> const double pi = acos(-1.0); int main() { int n; double s, f, r, v, t; scanf( %d %lf %lf , &n, &r, &v); double p = 2 * pi * r; double tp = p / v; while (n--) { scanf( %lf %lf , &s, &f); double x = f - s; double cyc = floor(x / p); double rem = (x - cyc * p) / r / 2; double lo = 0, hi = pi; for (int i = 0; i < 60; ++i) { double mid = (lo + hi) / 2; if (mid + sin(mid) < rem) lo = mid; else hi = mid; } t = cyc * tp + 2 * lo * r / v; printf( %.8lf n , t); } }
|
#include <bits/stdc++.h> using namespace std; int a[11000][4]; int ans[110][110]; int main() { cin.sync_with_stdio(false); cin.tie(0); int n, m, q; cin >> n >> m >> q; for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) ans[i][j] = 0; for (int i = 0; i < q; i++) { int x1; cin >> x1; if (x1 != 3) { int x2; cin >> x2; x2--; a[i][0] = x1; a[i][1] = x2; a[i][2] = 0; a[i][3] = 0; } else { int x2, x3, x4; cin >> x2 >> x3 >> x4; x2--; x3--; a[i][0] = x1; a[i][1] = x2; a[i][2] = x3; a[i][3] = x4; } } for (int i = q - 1; i >= 0; i--) { if (a[i][0] == 3) { ans[a[i][1]][a[i][2]] = a[i][3]; } if (a[i][0] == 1) { int x = ans[a[i][1]][m - 1]; for (int j = m - 1; j > 0; j--) { ans[a[i][1]][j] = ans[a[i][1]][j - 1]; } ans[a[i][1]][0] = x; } if (a[i][0] == 2) { int x = ans[n - 1][a[i][1]]; for (int j = n - 1; j > 0; j--) { ans[j][a[i][1]] = ans[j - 1][a[i][1]]; } ans[0][a[i][1]] = x; } } for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) cout << ans[i][j] << ; cout << n ; } return 0; }
|
#include <bits/stdc++.h> using namespace std; const int N = 1e5 + 10; const int K = 18; long long a[N], tree[N << 2], lazy[N << 2]; vector<int> v[N]; int anc[N][K], h[N], sz[N]; int c[N], pos[N]; int ct; void build(int node, int st, int end) { if (st == end) { tree[node] = c[st]; return; } long long mid = st + end >> 1LL; build(node << 1, st, mid); build((node << 1) + 1, mid + 1, end); tree[node] = tree[node << 1] + tree[(node << 1) + 1]; } void update(int node, int st, int end, int l, int r, long long val) { if (lazy[node]) { tree[node] += (end - st + 1) * lazy[node]; if (st != end) { lazy[node << 1] += lazy[node]; lazy[(node << 1) + 1] += lazy[node]; } lazy[node] = 0; } if (st > end || r < st || end < l) return; if (l <= st && end <= r) { tree[node] += (end - st + 1) * val; if (st != end) { lazy[node << 1] += val; lazy[(node << 1) + 1] += val; } return; } long long mid = st + end >> 1LL; update(node << 1, st, mid, l, r, val); update((node << 1) + 1, mid + 1, end, l, r, val); tree[node] = tree[node << 1] + tree[(node << 1) + 1]; } long long query(int node, int st, int end, int l, int r) { if (st > end || r < st || end < l) return 0; if (lazy[node]) { tree[node] += (end - st + 1) * lazy[node]; if (st != end) { lazy[node << 1] += lazy[node]; lazy[(node << 1) + 1] += lazy[node]; } lazy[node] = 0; } if (l <= st && end <= r) return tree[node]; long long mid = st + end >> 1LL; return (query(node << 1, st, mid, l, r) + query((node << 1) + 1, mid + 1, end, l, r)); } void dfs(int s, int P) { c[ct + 1] = a[s]; pos[s] = ++ct; anc[s][0] = P; h[s] = h[P] + 1; sz[s]++; for (int i = 1; i < K; i++) anc[s][i] = anc[anc[s][i - 1]][i - 1]; for (auto i : v[s]) if (i != P) dfs(i, s), sz[s] += sz[i]; } int LCA(int x, int y) { int d = h[y] - h[x]; if (d < 0) swap(x, y); d = abs(d); for (int i = K - 1; i >= 0; i--) if ((1 << i) & d) y = anc[y][i]; if (x == y) return x; for (int i = K - 1; i >= 0; i--) if (anc[x][i] != anc[y][i]) x = anc[x][i], y = anc[y][i]; return anc[x][0]; } int lift(int x, int d) { for (int i = K - 1; i >= 0; i--) if ((1 << i) & d) x = anc[x][i]; return x; } int main() { ios_base ::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); int n, q; cin >> n >> q; for (int i = 1; i <= n; i++) cin >> a[i]; for (int i = 1; i < n; i++) { int x, y; cin >> x >> y; v[x].push_back(y); v[y].push_back(x); } dfs(1, 0); build(1, 1, n); int t, val, l, r, x, ro = 1, yo, vo, go; long long ho; for (int i = 0; i < q; i++) { cin >> t; if (t == 1) cin >> ro; else if (t == 2) { cin >> l >> r >> x; yo = LCA(l, r), vo = LCA(l, ro), go = LCA(r, ro); if (h[yo] < h[vo]) yo = vo; if (h[yo] < h[go]) yo = go; if (yo == ro) { update(1, 1, n, 1, n, x); } else if (LCA(yo, ro) == yo) { update(1, 1, n, 1, n, x); yo = lift(ro, h[ro] - h[yo] - 1); update(1, 1, n, pos[yo], pos[yo] + sz[yo] - 1, -x); } else { update(1, 1, n, pos[yo], pos[yo] + sz[yo] - 1, x); } } else { cin >> l; if (l == ro) { cout << query(1, 1, n, 1, n) << n ; } else if (LCA(ro, l) == l) { ho = query(1, 1, n, 1, n); yo = lift(ro, h[ro] - h[l] - 1); cout << ho - query(1, 1, n, pos[yo], pos[yo] + sz[yo] - 1) << n ; } else { cout << query(1, 1, n, pos[l], pos[l] + sz[l] - 1) << n ; } } } return 0; }
|
#include <bits/stdc++.h> using namespace std; const int MAXN = 1e5 + 50; const int LOG = 19; const int INF = 1e9; int m, p[MAXN], par[12][MAXN], nxt[MAXN], id[MAXN], ss[MAXN], ans, l[MAXN], r[MAXN]; int tt[LOG][MAXN], lc[LOG][MAXN]; string s[14]; pair<pair<int, int>, int> vec[MAXN]; int lcp(int a, int b) { int ta = a, tb = b; for (int i = LOG - 1; i >= 0 && a < nxt[ta] && b < nxt[tb]; i--) if (a + (1 << i) <= nxt[ta] && b + (1 << i) <= nxt[tb] && tt[i][a] == tt[i][b]) a += 1 << i, b += 1 << i; return a - ta; } bool ok(int sz, int ind) { int tl = ind, tr = ind; for (int w = LOG - 1; w >= 0; w--) if (tr + (1 << w) < p[m] && lc[w][tr] >= sz) tr += 1 << w; tr++; for (int w = LOG - 1; w >= 0; w--) if (tl - (1 << w) >= 0 && lc[w][tl - (1 << w)] >= sz) tl -= (1 << w); for (int i = 1; i < m; i++) if (par[i][tr] - par[i][tl] > r[i]) return false; return true; } bool ok2(int sz, int ind) { int tl = ind, tr = ind; for (int w = LOG - 1; w >= 0; w--) if (tr + (1 << w) < p[m] && lc[w][tr] >= sz) tr += 1 << w; tr++; for (int w = LOG - 1; w >= 0; w--) if (tl - (1 << w) >= 0 && lc[w][tl - (1 << w)] >= sz) tl -= (1 << w); for (int i = 1; i < m; i++) if (par[i][tr] - par[i][tl] < l[i]) return false; return true; } int main() { ios::sync_with_stdio(false); cin.tie(0); cin >> s[0] >> m; m++; for (int i = 1; i < m; i++) cin >> s[i] >> l[i] >> r[i], p[i] = p[i - 1] + (int)s[i - 1].size(); p[m] = p[m - 1] + (int)s[m - 1].size(); for (int i = 0; i < m; i++) for (int j = 0; j < (int)s[i].size(); j++) tt[0][p[i] + j] = s[i][j]; for (int w = 1; w < LOG; w++) { for (int i = 0; i < m; i++) for (int j = 0; j < (int)s[i].size(); j++) if (j + (1 << (w - 1)) >= (int)s[i].size()) vec[p[i] + j] = {{tt[w - 1][p[i] + j], -1}, p[i] + j}; else vec[p[i] + j] = { {tt[w - 1][p[i] + j], tt[w - 1][p[i] + j + (1 << (w - 1))]}, p[i] + j}; sort(vec, vec + p[m]); for (int i = 1; i < p[m]; i++) if (vec[i].first == vec[i - 1].first) tt[w][vec[i].second] = tt[w][vec[i - 1].second]; else tt[w][vec[i].second] = i; } for (int i = 0; i < p[m]; i++) ss[i] = vec[i].second; for (int i = 0; i < m; i++) for (int j = 0; j < (int)s[i].size(); j++) id[p[i] + j] = i, nxt[p[i] + j] = p[i + 1]; for (int i = 0; i < p[m]; i++) for (int j = 1; j < m; j++) par[j][i + 1] = par[j][i] + bool(id[ss[i]] == j); for (int i = 0; i < p[m] - 1; i++) lc[0][i] = lcp(ss[i], ss[i + 1]); for (int i = 1; i < LOG; i++) for (int j = 0; j < p[m] - 1; j++) if (j + (1 << (i - 1)) >= p[m] - 1) lc[i][j] = lc[i - 1][j]; else lc[i][j] = min(lc[i - 1][j], lc[i - 1][j + (1 << (i - 1))]); int mn = 0; for (int i = 0; i < p[m]; i++) { if (id[ss[i]]) { mn = min(mn, lc[0][i]); continue; } int sz = nxt[ss[i]] - ss[i]; int cur = ss[i]; for (int w = LOG - 1; w >= 0 && cur < nxt[ss[i]]; w--) if (cur + (1 << w) <= nxt[ss[i]] && !ok(cur + (1 << w) - ss[i], i)) cur += (1 << w); int cur2 = ss[i]; for (int w = LOG - 1; w >= 0 && cur2 < nxt[ss[i]]; w--) if (cur2 + (1 << w) <= nxt[ss[i]] && ok2(cur2 + (1 << w) - ss[i], i)) cur2 += (1 << w); cur = max(cur, ss[i] + mn); ans += max(0, cur2 - cur); mn = lc[0][i]; } cout << ans << n ; return 0; }
|
#include <bits/stdc++.h> using namespace std; int n, arr[110], c1, c0; int main() { scanf( %d , &n); for (int i = 0; i < n; ++i) scanf( %d , &arr[i]), c1 += arr[i]; int out = 0; for (int i = 0; i < n; ++i) { c0 += (!arr[i]); out = max(out, c0 + c1); c1 -= arr[i]; } cout << out; }
|
#include <bits/stdc++.h> using namespace std; struct node { int a; int b; int index; }; bool compare(node &n1, node &n2) { if (n1.a < n2.a) return true; else return false; } bool compare1(node &n1, node &n2) { if (n1.b < n2.b) return true; else return false; } int main() { int n; cin >> n; vector<node> pq(n); for (int i = 0; i < n; i++) { cin >> pq[i].a >> pq[i].b; pq[i].index = i; } int num = 0; for (int i = 0; i < n; i++) { if (pq[i].a < pq[i].b) num++; } vector<node> track; if (num >= n / 2) { for (int i = 0; i < n; i++) { if (pq[i].a < pq[i].b) track.push_back(pq[i]); } sort(track.begin(), track.end(), compare); cout << track.size() << endl; for (int i = track.size() - 1; i >= 0; i--) { cout << track[i].index + 1 << ; } } else { for (int i = 0; i < n; i++) { if (pq[i].a > pq[i].b) track.push_back(pq[i]); } sort(track.begin(), track.end(), compare1); cout << track.size() << endl; for (int i = 0; i < track.size(); i++) { cout << track[i].index + 1 << ; } } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int hy, ay, dy; int hm, am, dm; int h, a, d; cin >> hy >> ay >> dy; cin >> hm >> am >> dm; cin >> h >> a >> d; int res = 1e9; for (int atk = dm + 1; atk <= 200; ++atk) { for (int def = dy; def <= 100; ++def) { int rnd = (hm + atk - dm - 1) / (atk - dm); int h_add = max(0, rnd * max(0, am - def) - hy + 1); int a_add = max(0, atk - ay); int d_add = max(0, def - dy); res = min(res, h_add * h + a_add * a + d_add * d); } } cout << res << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; int N, br[20][200200], d[20][200200], lev[200200]; vector<int> in, adj[200200], myc[200200], ans; bool dead[200200]; vector<multiset<int>> m[200200]; multiset<int> sub, best[200200], outofall; int go(int l, int i, int p = -1) { in.push_back(i); for (int j : adj[i]) if (j != p && !dead[j]) { d[l][i] += go(l, j, i); } return ++d[l][i]; } void dfs(int l, int i, int p) { for (int j : adj[i]) if (j != p && !dead[j]) { br[l][j] = br[l][i]; d[l][j] = d[l][i] + 1; dfs(l, j, i); } } void rec(int l, int i) { in.clear(), go(l, i); int C = -1; for (int k : in) { int mx = d[l][i] - d[l][k]; for (int j : adj[k]) if (d[l][j] < d[l][k]) { mx = max(mx, d[l][j]); } if (mx <= d[l][i] / 2) { C = k; break; } } lev[C] = l; for (int k : in) { myc[k].push_back(C); } for (int k : in) { d[l][k] = 0; } for (int j : adj[C]) if (!dead[j]) { sub.clear(), d[l][j] = 1; br[l][j] = (int)m[C].size(); dfs(l, j, C), m[C].push_back(sub); } dead[C] = 1; for (int j : adj[C]) if (!dead[j]) { rec(l + 1, j); } } int main() { scanf( %d , &N); for (int i = (2); i < (N + 1); i++) { int p; scanf( %d , &p); adj[i].push_back(p), adj[p].push_back(i); } rec(0, 1); for (int i = (1); i < (N + 1); i++) { for (int c : myc[i]) { if ((int)best[c].size() >= 2) { auto it = --best[c].end(); int t = *it + *prev(it); if (outofall.find(t) != outofall.end()) { outofall.erase(outofall.find(t)); } } if (c == i) { best[c].insert(0); } else { int myb = br[lev[c]][i], myd = d[lev[c]][i]; if (m[c][myb].size() && best[c].find(*m[c][myb].rbegin()) != best[c].end()) { best[c].erase(best[c].find(*m[c][myb].rbegin())); } m[c][myb].insert(myd); while ((int)m[c][myb].size() > 2) m[c][myb].erase(m[c][myb].begin()); best[c].insert(*m[c][myb].rbegin()); while ((int)best[c].size() > 2) best[c].erase(best[c].begin()); } if ((int)best[c].size() >= 2) { auto it = --best[c].end(); outofall.insert(*it + *prev(it)); while ((int)outofall.size() > 2) outofall.erase(outofall.begin()); } } if (i >= 2) printf( %d , *outofall.rbegin()); } return 0; }
|
#include <bits/stdc++.h> using namespace std; map<pair<long long, long long>, long long> m; int main() { long long t, ai, bi, dr = 1; cin >> t; vector<pair<long long, long long>> v(t); for (int i = 0; i < t; i++) { cin >> ai >> bi; v[i] = {ai, bi}; } m[{0, 0}] = 1; dr += min(v[0].first, v[0].second); m[{v[0].first, v[0].second}] = 1; for (int i = 1; i < t; i++) { if (v[i].first > v[i - 1].first && v[i].second > v[i - 1].second && m[{v[i].first, v[i].second}] == 0 && min(v[i].first, v[i].second) >= max(v[i - 1].second, v[i - 1].first)) { if ((v[i - 1].first != 0 || v[i - 1].second != 0) && v[i - 1].first != v[i - 1].second) { dr += min(v[i].first, v[i].second) - max(v[i - 1].first, v[i - 1].second) + 1; } else { dr += min(v[i].first, v[i].second) - max(v[i - 1].first, v[i - 1].second); } m[{v[i].first, v[i].second}] = 1; } else if ((v[i].first > v[i].second && v[i].second == v[i - 1].second && v[i - 1].first < v[i - 1].second) || (v[i].second > v[i].first && v[i].first == v[i - 1].first && v[i - 1].second < v[i - 1].first) && m[{v[i].first, v[i].second}] == 0) { dr++; m[{v[i].first, v[i].second}] = 1; } else if (v[i].first == v[i].second && m[{v[i].first, v[i].second}] == 0) { dr++; m[{v[i].first, v[i].second}] = 1; } } cout << dr; }
|
#include <bits/stdc++.h> using namespace std; template <typename T> inline T qmin(const T a, const T b) { return a < b ? a : b; } template <typename T> inline T qmax(const T a, const T b) { return a > b ? a : b; } template <typename T> inline void getmin(T &a, const T b) { if (a > b) a = b; } template <typename T> inline void getmax(T &a, const T b) { if (a < b) a = b; } inline void fileio(string s) { freopen((s + .in ).c_str(), r , stdin); freopen((s + .out ).c_str(), w , stdout); } const int inf = 1e9 + 7; const long long linf = 1e17 + 7; const int N = 2e5 + 7; int q[N], st, ed; int n, deg[N], s[N]; int tot, ans[N][2]; void dfs(int u) { int v = s[u]; ++tot, ans[tot][0] = u, ans[tot][1] = v; --deg[v], s[v] ^= u; --deg[u], s[u] = 0; if (deg[v] == 1) dfs(v); } int main() { scanf( %d , &n); for (int i = 0; i < n; ++i) { scanf( %d%d , deg + i, s + i); } for (int i = 0; i < n; ++i) { if (deg[i] == 1) dfs(i); } printf( %d n , tot); for (int i = 1; i <= tot; ++i) printf( %d %d n , ans[i][0], ans[i][1]); return 0; }
|
#include <bits/stdc++.h> using namespace std; const long long mod = 1000000007; const int MAXN = 1500907; vector<vector<long long>> adj; bool visited[MAXN]; long long n_nodes; long long n_edges; void dfs(int node) { visited[node] = 1; n_nodes++; for (auto i : adj[node]) { n_edges++; if (!visited[i]) { dfs(i); } } } int main() { ios::sync_with_stdio(false); cin.tie(NULL); long long n, m, a, b; cin >> n >> m; adj.resize(n + 5); while (m--) { cin >> a >> b; a--; b--; adj[a].push_back(b); adj[b].push_back(a); } for (long long i = 1; i <= n; i++) { if (!visited[i]) { n_nodes = 0; n_edges = 0; dfs(i); if (n_edges != n_nodes * (n_nodes - 1)) { cout << NO << endl; return 0; } } } cout << YES << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; set<long long> num; void f(int x, int a, int b, long long now) { if (x == 0) { num.insert(now); return; } if (a) f(x - 1, a - 1, b, now * 10 + 4); if (b) f(x - 1, a, b - 1, now * 10 + 7); } void init() { int i; for (i = 1; i <= 5; i++) f(i * 2, i, i, 0LL); } int main() { long long n; init(); scanf( %I64d , &n); printf( %I64d , *num.upper_bound(n - 1)); }
|
#include <bits/stdc++.h> using namespace std; int main(void) { int n; scanf( %d , &n); long a[n]; long long s = 0, ss = 0; for (int i = 0; i < n; i++) { scanf( %ld , &a[i]); s += a[i]; } if (s % 3 != 0) { printf( 0 n ); return 0; } s = s / 3; vector<int> sum1; vector<int> sum2; for (int i = 0; i < n - 1; i++) { ss += a[i]; if (ss == s) sum1.push_back(i); if (ss == 2 * s) sum2.push_back(i); } long long ans = 0; for (int i = 0; i < sum1.size(); i++) { ans += sum2.end() - lower_bound(sum2.begin(), sum2.end(), sum1[i] + 1); } printf( %I64d n , ans); return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n, m, i, j, a[110], b[110], a1, b1; cin >> n >> m; for (i = 0; i <= n; i++) cin >> a[i]; for (i = 0; i <= m; i++) cin >> b[i]; a1 = a[0], b1 = b[0]; if (n > m) { if (a1 * b1 > 0) cout << Infinity << endl; else cout << -Infinity << endl; } else if (n < m) { printf( 0/1 n ); } else if (n == m) { for (i = 1; i <= min(abs(a1), abs(b1)); i++) { if (a1 % i == 0 && b1 % i == 0) j = i; } a1 /= j, b1 /= j; if (a1 * b1 > 0) printf( %d/%d n , abs(a1), abs(b1)); else printf( -%d/%d n , abs(a1), abs(b1)); } return 0; }
|
#include <bits/stdc++.h> using namespace std; long long int MOD = 1e9 + 7; const long long int INF = 1e18; long long int sub(long long int a, long long int b, long long int p = MOD) { return ((a % p) - (b % p) + p) % p; } long long int mult(long long int a, long long int b, long long int p = MOD) { return ((a % p) * (b % p)) % p; } long long int add(long long int a, long long int b, long long int p = MOD) { return (a % p + b % p) % p; } long long int fpow(long long int n, long long int k, long long int p = MOD) { long long int r = 1; while (k > 0) { if (k & 1) r = r * n % p; n = n * n % p; k = k >> 1; } return r; } long long int inv(long long int a, long long int p = MOD) { return fpow(a, p - 2, p); } long long int fdiv(long long int a, long long int b, long long int p = MOD) { long long int yinv = inv(b); long long int ans = (a * yinv) % p; return ans; } unsigned long long int I1018 = 1000000000000000000; const unsigned long long int I10e5 = 100000; const long long int I10e6 = 1e6; long long int ZERO = 0; unsigned long long int I10e9 = 1000000000; long long int ONE = 1; void printVecpll(std::vector<pair<long long int, long long int> > v) { for (auto p : v) { cout << (char)p.first << << p.second << endl; } } void printVec(std::vector<long long int> v) { for (long long int i = 0; i < v.size(); i++) { cout << v[i] << ; } cout << endl; } std::vector<long long int> read_vec(long long int n) { long long int i; std::vector<long long int> v(n); for (i = 0; i < n; i++) { cin >> v[i]; } return v; } void print_um(unordered_map<long long int, long long int> m) { for (pair<long long int, long long int> p : m) { cout << p.first << << p.second << endl; } } std::vector<bool> is_prime; std::vector<long long int> primes; void sieve(long long int n) { is_prime.resize(n + 2, true); primes.clear(); long long int p; for (p = 2; p * p <= n; p++) { if (is_prime[p]) { long long int i; for (i = p * p; i <= n; i += p) { is_prime[i] = false; } } } is_prime[0] = is_prime[1] = false; long long int i; for (i = 2; i <= n; i++) { if (is_prime[i]) { primes.emplace_back(i); } } } class Sol { public: long long int n; vector<std::vector<long long int> > graph; map<long long int, long long int> lc; std::vector<bool> visited; Sol() { cin >> n; graph.resize(n); visited.resize(n, false); long long int i; for (i = 1; i < n; i++) { long long int v; cin >> v; v--; graph[i].emplace_back(v); graph[v].emplace_back(i); } dfs(0, -1); std::vector<long long int> ans; long long int temp = lc[0]; for (i = 0; i < temp; i++) { ans.emplace_back(1); } for (auto p : lc) { if (p.first == 0) continue; for (i = 0; i < p.second; i++) { ans.emplace_back(p.first); } } printVec(ans); } long long int dfs(long long int src, long long int par) { long long int lt = 0; if (graph[src].size() == 1 && src != 0) { lc[0]++; return 1; } for (auto p : graph[src]) { if (p != par) { lt += dfs(p, src); } } lc[lt]++; return lt; } }; int main() { ios::sync_with_stdio(false); cin.tie(0); Sol sol; return 0; }
|
#include <bits/stdc++.h> using namespace std; template <int V, class T = long long> class max_flow { static const T INF = numeric_limits<T>::max(); struct edge { int t, rev; T cap, f; }; vector<edge> adj[V]; int dist[V]; int ptr[V]; bool bfs(int s, int t) { memset(dist, -1, sizeof dist); dist[s] = 0; queue<int> q({s}); while (!q.empty() && dist[t] == -1) { int n = q.front(); q.pop(); for (auto& e : adj[n]) { if (dist[e.t] == -1 && e.cap != e.f) { dist[e.t] = dist[n] + 1; q.push(e.t); } } } return dist[t] != -1; } T augment(int n, T amt, int t) { if (n == t) return amt; for (; ptr[n] < adj[n].size(); ptr[n]++) { edge& e = adj[n][ptr[n]]; if (dist[e.t] == dist[n] + 1 && e.cap != e.f) { T flow = augment(e.t, min(amt, e.cap - e.f), t); if (flow != 0) { e.f += flow; adj[e.t][e.rev].f -= flow; return flow; } } } return 0; } public: void add(int u, int v, T cap = 1, T rcap = 0) { adj[u].push_back({v, (int)adj[v].size(), cap, 0}); adj[v].push_back({u, (int)adj[u].size() - 1, rcap, 0}); } T calc(int s, int t) { T flow = 0; while (bfs(s, t)) { memset(ptr, 0, sizeof(ptr)); while (T df = augment(s, INF, t)) flow += df; } return flow; } void clear() { for (int n = 0; n < V; n++) adj[n].clear(); } }; set<int> xsw; set<int> ysw; bool adj[105][105]; int x1arr[50]; int x2arr[50]; int y1arr[50]; int y2arr[50]; int xswa[105]; int yswa[105]; int main() { int n, m; cin >> n >> m; xsw.insert(0); xsw.insert(n); ysw.insert(0); ysw.insert(n); for (int i = 0; i < m; i++) { cin >> x1arr[i] >> y1arr[i] >> x2arr[i] >> y2arr[i]; xsw.insert(x1arr[i] - 1); xsw.insert(x2arr[i]); ysw.insert(y1arr[i] - 1); ysw.insert(y2arr[i]); } int idx = 0; for (auto x : xsw) { xswa[idx++] = x; } idx = 0; for (auto y : ysw) { yswa[idx++] = y; } for (int i = 0; i < m; i++) { int xmin = 0; for (int j = 0; j < xsw.size(); j++) { if (xswa[j] == x1arr[i] - 1) { xmin = j; break; } } int xmax = 0; for (int j = 0; j < xsw.size(); j++) { if (xswa[j] == x2arr[i]) { xmax = j; break; } } int ymin = 0; for (int j = 0; j < ysw.size(); j++) { if (yswa[j] == y1arr[i] - 1) { ymin = j; break; } } int ymax = 0; for (int j = 0; j < ysw.size(); j++) { if (yswa[j] == y2arr[i]) { ymax = j; break; } } for (int j = xmin; j < xmax; j++) { for (int k = ymin; k < ymax; k++) { adj[j][k] = true; } } } max_flow<500> network; for (int i = 0; i < xsw.size() - 1; i++) { network.add(0, i + 1, xswa[i + 1] - xswa[i]); } for (int i = 0; i < xsw.size() - 1; i++) { for (int j = 0; j < ysw.size() - 1; j++) { if (adj[i][j]) { network.add(i + 1, xsw.size() + j, n); } } } for (int j = 0; j < ysw.size() - 1; j++) { network.add(xsw.size() + j, xsw.size() + ysw.size(), yswa[j + 1] - yswa[j]); } cout << network.calc(0, xsw.size() + ysw.size()) << endl; }
|
#include <bits/stdc++.h> using namespace std; int main() { long long int n; scanf( %lld , &n); long long int i; for (i = 2; i * i <= n; i++) { while (n % (i * i) == 0) n /= i; } printf( %lld n , n); return 0; }
|
#include <bits/stdc++.h> using namespace std; int n, m, s, i, j, k; bool A[301][301]; char str[301]; int main() { scanf( %d%d%d , &n, &m, &s); for (i = 0; i < n; i++) { scanf( %s , str); for (j = 0; j < m; j++) A[i][j] = str[j] == * ; } for (i = 1; 2 * i + 1 <= min(n, m); i++) { for (j = i; j + i < n; j++) { for (k = i; k + i < m; k++) if (A[j][k] && A[j][k + i] && A[j][k - i] && A[j + i][k] && A[j - i][k]) { s--; if (!s) break; } if (!s) break; } if (!s) break; } if (s) printf( -1 n ); else { j++; k++; printf( %d %d n%d %d n%d %d n%d %d n%d %d n , j, k, j - i, k, j + i, k, j, k - i, j, k + i); } return 0; }
|
#include <bits/stdc++.h> using namespace std; const int nm = 100002; int n, d; long long x; int a[nm], b[nm], vt[nm]; int c[nm]; int nc; int getNextX() { x = (x * 37 + 10007) % 1000000007; return x; } void init() { int i; for (i = 0; i < n; i = i + 1) { a[i] = i + 1; } for (i = 0; i < n; i = i + 1) { swap(a[i], a[getNextX() % (i + 1)]); } for (i = 0; i < n; i = i + 1) { if (i < d) b[i] = 1; else b[i] = 0; } for (i = 0; i < n; i = i + 1) { swap(b[i], b[getNextX() % (i + 1)]); } } int main() { scanf( %d%d%I64d , &n, &d, &x); init(); int i, j, k; for (i = 0; i < n; ++i) { vt[a[i]] = i; if (b[i]) c[++nc] = i; } for (i = 0; i < n; ++i) { for (j = n; j > n - 100 && j > 0; --j) if (vt[j] <= i && b[i - vt[j]]) break; if (j > n - 100 && j > 0) { printf( %d n , j); continue; } k = 0; for (j = 1; j <= nc && c[j] <= i; ++j) k = max(k, a[i - c[j]]); printf( %d n , k); } }
|
#include<cstdio> int t,n; int vx[13][2003]; int vy[13][2003]; int fx[13][2003]; int lx[13][2003]; int fy[13][2003]; int ly[13][2003]; int a[2003][2003]; int main() { scanf( %d ,&t); while(t--) { scanf( %d ,&n); for(int i=1;i<=n;++i) { for(int j=1;j<=n;++j) { scanf( %1d ,&a[i][j]); } } for(int d=0;d<10;++d) { int ans=0; for(int j=1;j<=n;++j) { fx[d][j]=lx[d][j]=0; for(int i=1;i<=n;++i) { if(a[i][j]!=d)continue; if(!fx[d][j]) { fx[d][j]=i; break; } } for(int i=n;i;--i) { if(a[i][j]!=d)continue; if(!lx[d][j]) { lx[d][j]=i; break; } } if(fx[d][j])vx[d][j]=((n-fx[d][j]>lx[d][j]-1)?(n-fx[d][j]):(lx[d][j]-1)); else vx[d][j]=0; } for(int i=1;i<=n;++i) { fy[d][i]=ly[d][i]=0; for(int j=1;j<=n;++j) { if(a[i][j]!=d)continue; if(!fy[d][i]) { fy[d][i]=j; break; } } for(int j=n;j;--j) { if(a[i][j]!=d)continue; if(!ly[d][i]) { ly[d][i]=j; break; } } if(fy[d][i])vy[d][i]=((n-fy[d][i]>ly[d][i]-1)?(n-fy[d][i]):(ly[d][i]-1)); else vy[d][i]=0; } for(int i=1;i<=n;++i) { if(!vx[d][i])continue; for(int j=1;j<i;++j) { if(!vx[d][j])continue; if(vx[d][j]*(i-j)>ans)ans=vx[d][j]*(i-j); if(vx[d][i]*(i-j)>ans)ans=vx[d][i]*(i-j); } } for(int i=1;i<=n;++i) { if(!vy[d][i])continue; for(int j=1;j<i;++j) { if(!vy[d][j])continue; if(vy[d][j]*(i-j)>ans)ans=vy[d][j]*(i-j); if(vy[d][i]*(i-j)>ans)ans=vy[d][i]*(i-j); } } printf( %d ,ans); } puts( ); } return 0; }
|
#include <bits/stdc++.h> using namespace std; const long long PR = 1000000009; int n, m, premin[100009], sufmax[100009]; char A[100009], B[100009]; int main() { ios::sync_with_stdio(false); cin >> A >> B; n = strlen(A); m = strlen(B); for (int i = 0; i < m; i++) premin[i] = n, sufmax[i] = -1; int st = 0; for (int i = 0; i < m && st < n; i++) { while (A[st] != B[i]) { st++; if (st >= n) break; } premin[i] = st; st++; } st = n - 1; for (int i = m - 1; i >= 0 && st >= 0; i--) { while (A[st] != B[i]) { st--; if (st < 0) break; } sufmax[i] = st; st--; } int ans = m, i1 = -1, j1 = -1; for (int i = 0; i < m; i++) { if (premin[i] != n) { int mid, st = i + 1, end = m - 1; while (st < end) { mid = (st + end) / 2; if (sufmax[mid] >= premin[i] + 1) end = mid; else st = mid + 1; } if (sufmax[st] < premin[i] + 1) st = m; int now = st - i - 1; if (now < ans) { i1 = i + 1; j1 = st - 1; ans = now; } } } for (int i = m - 1; i >= 0; i--) { if (sufmax[i] == -1) break; int now = i - 1; if (now < ans) { j1 = i - 1; i1 = 0; ans = now; } } if (i1 == -1 || j1 - i1 + 1 == m) { cout << - << endl; return 0; } for (int i = 0; i < i1; i++) cout << B[i]; for (int j = j1 + 1; j < m; j++) cout << B[j]; cout << endl; return 0; };
|
#include <bits/stdc++.h> using namespace std; int main() { long long n, m; cin >> n >> m; long long mod = 1; int k = 0; while (k < n) { if (mod > m) { break; } mod *= 2; k++; } cout << m % mod << endl; }
|
#include <bits/stdc++.h> using namespace std; int n, k; string a; int change(char c) { int j = 0, i = 0, ans = 0, cont = 0; for (i = 0; i < n; i++) { if (a[i] == c) cont++; if (cont > k) { while (cont > k) if (a[j++] == c) cont--; } ans = max(ans, i - j + 1); } return ans; } int main() { ios::sync_with_stdio(0); while (cin >> n >> k) { a = ; int suma = 0, sumb = 0; for (int i = 0; i < n; ++i) { char c; cin >> c; if (c == a ) suma++; else sumb++; a += c; } int ans; if (suma > sumb) ans = change( b ); else if (sumb > suma) ans = change( a ); else ans = max(change( a ), change( b )); cout << ans << endl; } return 0; }
|
#include <bits/stdc++.h> using namespace std; vector<pair<int, int> > g[100100]; int fa[100100][18], typ[100100], n; int sum[100100][2], dep[100100]; void dfs(int u) { for (int i = 1; i < 18; ++i) fa[u][i] = fa[fa[u][i - 1]][i - 1]; for (auto v : g[u]) { int A = v.first, tp = v.second; sum[A][0] = sum[u][0]; sum[A][1] = sum[u][1]; ++sum[A][tp]; dep[A] = dep[u] + 1; dfs(A); } } int LCA(int u, int v) { if (dep[u] > dep[v]) swap(u, v); int hu = dep[u], hv = dep[v]; int tu = u, tv = v; for (int det = hv - hu, i = 0; det; det >>= 1, i++) if (det & 1) tv = fa[tv][i]; if (tu == tv) return tu; for (int i = 17; i >= 0; --i) { if (fa[tu][i] == fa[tv][i]) continue; tu = fa[tu][i]; tv = fa[tv][i]; } return fa[tu][0]; } int tmp[2]; int main() { scanf( %d , &n); for (int i = 1; i <= n; ++i) { scanf( %d%d , &fa[i][0], &typ[i]); if (fa[i][0] == -1) fa[i][0] = typ[i] = 0; } for (int i = 1; i <= n; ++i) g[fa[i][0]].push_back(pair<int, int>(i, typ[i])); dfs(0); int q; scanf( %d , &q); while (q--) { int tp, u, v; scanf( %d%d%d , &tp, &u, &v); int lca = LCA(u, v); if (!lca || lca == v) { puts( NO ); continue; } if (tp == 1) { if (lca != u) { puts( NO ); continue; } tmp[0] = sum[v][0] - sum[u][0]; tmp[1] = sum[v][1] - sum[u][1]; if (tmp[1]) { puts( NO ); continue; } puts( YES ); } else { tmp[0] = sum[u][0] - sum[lca][0]; tmp[1] = sum[u][1] - sum[lca][1]; if (tmp[1]) { puts( NO ); continue; } tmp[0] = sum[v][0] - sum[lca][0]; tmp[1] = sum[v][1] - sum[lca][1]; if (tmp[0]) { puts( NO ); continue; } puts( YES ); } } return 0; }
|
#include <bits/stdc++.h> using namespace std; int a[32]; int n, k; double dp[32][32][205]; int main() { memset(dp, 0, sizeof(dp)); cin >> n >> k; for (int i = 0; i < n; ++i) cin >> a[i]; for (int i = 0; i < n; ++i) { for (int j = i; j < n; ++j) { if (a[i] > a[j]) { dp[i][j][0] = 1; } } } double prob = (double)2 / (n * (n + 1)); for (int op = 1; op <= k; ++op) { for (int start = 0; start < n; ++start) { for (int end = start; end < n; ++end) { for (int x = 0; x < n; ++x) { for (int y = x; y < n; ++y) { int nx = x; if (start <= x && x <= end) nx = end - x + start; int ny = y; if (start <= y && y <= end) ny = start + end - y; if (ny >= nx) dp[x][y][op] += dp[nx][ny][op - 1] * prob; else dp[x][y][op] += (1 - dp[ny][nx][op - 1]) * prob; } } } } } double ans = 0; for (int i = 0; i < n; ++i) for (int j = i + 1; j < n; ++j) ans += dp[i][j][k]; cout << fixed << setprecision(9) << ans << endl; return 0; }
|
#include <bits/stdc++.h> int cicle[300] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; int main() { int n; scanf( %d , &n); if (n == 1) { int b; scanf( %d , &b); if (b == 15) printf( DOWN n ); else if (b == 0) { printf( UP n ); } else printf( -1 n ); return 0; } int a[n]; for (int i = 0; i < n; ++i) { scanf( %d , a + i); } for (int i = 0; i < 100; ++i) { if (a[n - 1] == cicle[i + 1] && a[n - 2] == cicle[i]) { if (cicle[i + 2] > cicle[i + 1]) printf( UP n ); else printf( DOWN n ); return 0; } } return 0; }
|
#include <bits/stdc++.h> const int mod = 1e9 + 7; const int N = 3e5 + 1; using namespace std; void err(istream_iterator<string> it) {} template <typename T, typename... Args> void err(istream_iterator<string> it, T a, Args... args) { cerr << *it << = << a << ; err(++it, args...); } long long arr[N], brr[N]; long long n, m, k, q, a, b; long long binpow(long long a, long long n) { long long res = 1; while (n) { if (n & 1) res = res * a; a = a * a; n /= 2; } return res; } void solve() { cin >> n; vector<long long> arr(n); vector<long long> v; for (int i = 0; i < n; i++) cin >> arr[i]; long long x = arr[0]; arr[0] = 0; for (int k = 0; k + 1 < n; k++) { x = min(max(0LL, arr[k + 1] - arr[k]), x); arr[k + 1] -= x; } bool ok = true; for (int k = 0; k + 1 < n; k++) { if (arr[k + 1] - arr[k] < 0) ok = false; } n = v.size(); for (int i = 0; i < n; i++) if (v[i] < 0) ok = false; if (ok) cout << yes ; else cout << no ; cout << n ; cerr << n ; } int main() { int t; t = 1; cin >> t; int a = 0; while (t--) { solve(); } return 0; }
|
#include <bits/stdc++.h> using namespace std; long long n, q; struct interv { long long l, r, ubonus, lbonus; interv(long long L, long long R, long long UBONUS, long long LBONUS) { l = L; r = R; ubonus = UBONUS; lbonus = LBONUS; } bool operator<(const interv& x) const { return r < x.r; } }; set<interv> s; set<interv>::iterator it; long long x, y, to; char dir[3]; long long ans; int main() { scanf( %lld %lld , &n, &q); s.insert(interv(1, n, 0, 0)); for (int i = 1; i <= q; i++) { scanf( %lld %lld , &x, &y); scanf( %s , dir); it = s.lower_bound(interv(0, x, 0, 0)); if (it == s.end()) { printf( 0 n ); continue; } long long b = (*it).r; long long a = (*it).l; long long ubonus = (*it).ubonus; long long lbonus = (*it).lbonus; if (x < a) { printf( 0 n ); continue; } if (dir[0] == U ) { ans = (b - a + 1) - (x - a) + ubonus; printf( %lld n , ans); s.erase(it); if (x - 1 >= 1 && a <= x - 1) s.insert(interv(a, x - 1, ans, lbonus)); if (x + 1 <= n && x + 1 <= b) s.insert(interv(x + 1, b, ubonus, 0)); } else { ans = (b - a + 1) - (b - x) + lbonus; printf( %lld n , ans); s.erase(it); if (x - 1 >= 1 && a <= x - 1) s.insert(interv(a, x - 1, 0, lbonus)); if (x + 1 <= n && x + 1 <= b) s.insert(interv(x + 1, b, ubonus, ans)); } } return 0; }
|
#include <bits/stdc++.h> using namespace std; inline void solve() { long long n; cin >> n; vector<bool> isp(n + 1, 1); vector<long long> maxx(n + 1, -1); isp[0] = isp[1] = 0; for (long long i = 2; i <= n; i++) { if (isp[i]) { if (i * 2 <= n) { for (long long j = i * 2; j <= n; j += i) { isp[j] = 0; maxx[j] = max(maxx[j], i); } } } } long long best = 1, now = n; for (long long j = 2; j * j <= n; j++) { while (now % j == 0) { now /= j; best = max(best, j); } } best = max(best, now); long long ans = n - best + 1; for (long long i = n - best + 1; i < n; i++) { ans = min(ans, i - maxx[i] + 1); } cout << ans; } signed main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); solve(); return 0; }
|
#include <bits/stdc++.h> using namespace std; long long n, m, k, y, a, b, c; long long A[2005]; bool B[2005]; int main() { cin >> n >> k; priority_queue<pair<int, int> > pq; for (int i = int(0); i < int(n); i++) { cin >> A[i]; pq.push({A[i], i}); } int ans = 0; for (int i = int(0); i < int(k); i++) { B[pq.top().second] = true; ans += pq.top().first; pq.pop(); } cout << ans << n ; m = -1; int t = 0; for (int i = int(0); i < int(n); i++) { if (B[i] && t + 1 < k) { cout << i - m << ; m = i; t++; } } cout << n - 1 - m << n ; }
|
#include <bits/stdc++.h> using namespace std; const int N = 1e5 + 5; int n; int seq[N]; vector<int> zli[N]; int res[N]; int main() { scanf( %d , &n); for (int i = 1; i <= n; ++i) { scanf( %d , seq + i); seq[i] = n - seq[i]; zli[seq[i]].push_back(i); } int rodzaj = 0; for (int ile = 1; ile <= n; ++ile) { if ((int)(zli[ile]).size() % ile) { puts( Impossible ); exit(0); } for (int i = 0; i < (int)(zli[ile]).size(); i += ile) { rodzaj++; for (int j = i; j < i + ile; ++j) { res[zli[ile][j]] = rodzaj; } } } puts( Possible ); for (int i = 1; i <= n; ++i) { printf( %d , res[i]); } puts( ); }
|
#include <bits/stdc++.h> int find_min(int pos, int target) { int right = -1; for (int i = 0; right == -1; i++) if ((pos + i) % 26 == target) right = i; int left = -1; for (int i = 0; left == -1; i++) if ((pos - i + 26 * 2) % 26 == target) left = i; return std::min(right, left); } int main() { int n; std::cin >> n; std::string s; std::cin >> s; std::string genome = ACTG ; int min_moves = INT_MAX; for (int i = 0; i < n - 3; i++) { int min_temp = 0; for (int j = 0; j < 4; j++) min_temp += find_min(s[i + j] - A , genome[j] - A ); min_moves = std::min(min_moves, min_temp); } std::cout << min_moves << n ; return 0; }
|
#include <bits/stdc++.h> using namespace std; const double PI = acos(-1); const long long MOD = 998244353; struct node { int v; node *d, *r; }; node a[1050][1050]; long long n, m, q; void solve() { cin >> n >> m >> q; for (int i = (int)(1); i <= (int)(n); i += 1) { for (int j = (int)(1); j <= (int)(m); j += 1) { cin >> a[i][j].v; } } for (int i = (int)(0); i <= (int)(n); i += 1) { for (int j = (int)(0); j <= (int)(m); j += 1) { a[i][j].r = &a[i][j + 1]; a[i][j].d = &a[i + 1][j]; } } while (q--) { long long e, b, c, d, h, w; cin >> e >> b >> c >> d >> h >> w; node *x, *y, *j, *k; x = y = &a[0][0]; for (int i = (int)(1); i <= (int)(e - 1); i += 1) x = x->d; for (int i = (int)(1); i <= (int)(b - 1); i += 1) x = x->r; for (int i = (int)(1); i <= (int)(c - 1); i += 1) y = y->d; for (int i = (int)(1); i <= (int)(d - 1); i += 1) y = y->r; j = x, k = y; for (int i = (int)(1); i <= (int)(h); i += 1) { x = x->d, y = y->d; swap(x->r, y->r); } for (int i = (int)(1); i <= (int)(w); i += 1) { x = x->r, y = y->r; swap(x->d, y->d); } for (int i = (int)(1); i <= (int)(w); i += 1) { j = j->r, k = k->r; swap(j->d, k->d); } for (int i = (int)(1); i <= (int)(h); i += 1) { j = j->d, k = k->d; swap(j->r, k->r); } } node *x = &a[0][0]; for (int i = (int)(1); i <= (int)(n); i += 1) { x = x->d; node *y = x; for (int j = (int)(1); j <= (int)(m); j += 1) { y = y->r; cout << y->v << ; } cout << endl; } } int main() { ios::sync_with_stdio(0); cin.tie(0); int t = 1; while (t--) { solve(); } }
|
#include <bits/stdc++.h> using namespace std; const int maxn = 50, maxm = 5e3 + 100; int n, lim, f[maxn + 3], s[maxn + 3]; double p[maxn + 3], q[maxn + 3], dp[maxn + 3][maxm + 3]; bool check(double x) { for (int i = n; i; i--) { for (int j = lim + 1; j <= lim + 100; j++) { dp[i + 1][j] = x; } for (int j = 0; j <= lim; j++) { dp[i][j] = min(x, (dp[i + 1][j + f[i]] + f[i]) * p[i] + (dp[i + 1][j + s[i]] + s[i]) * q[i]); } } return dp[1][0] == x; } int main() { scanf( %d %d , &n, &lim); for (int i = 1, x; i <= n; i++) { scanf( %d %d %d , &f[i], &s[i], &x); p[i] = x / 100., q[i] = (100 - x) / 100.; } double l = 0, r = 1e9, mid; for (int k = 0; k < 70; k++) { mid = (l + r) / 2; if (check(mid)) { l = mid; } else { r = mid; } } printf( %.12lf n , (l + r) / 2); return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n, ans = 0; bool flag = false; int a[105]; cin >> n; for (int i = 0; i < n; i++) cin >> a[i]; for (int i = 1; i < n; i++) { if (a[i] == 2) { if (a[i - 1] == 1) { if (i >= 2 && a[i - 2] == 3) ans += 2; else ans += 3; } else { flag = true; break; } } else if (a[i] == 1) { if (a[i - 1] == 2) ans += 3; else if (a[i - 1] == 3) ans += 4; else { flag = true; break; } } else { if (a[i - 1] == 1) ans += 4; else { flag = true; break; } } } if (flag) puts( Infinite ); else { puts( Finite ); cout << ans << endl; } return 0; }
|
#include <bits/stdc++.h> using namespace std; const int matmul[][6] = {{2, 1, 1, 1, 0, 0}, {1, 2, 1, 1, 0, 0}, {1, 0, 1, 0, 0, 0}, {0, 1, 0, 1, 0, 0}, {1, 1, 1, 1, 1, 0}, {2, 2, 2, 2, 1, 1}}; long long N, sx, sy, dx, dy, t; struct matrix { int m, n; long long d[13][13]; matrix() { m = 0; n = 0; memset(d, 0, sizeof d); } matrix(int m, int n) { this->m = m; this->n = n; memset(d, 0, sizeof d); } matrix operator*(const matrix &a) const { int x = m; int y = n; int z = a.n; matrix res = matrix(x, z); for (int i = 0; i < (x); i = i + 1) for (int j = 0; j < (z); j = j + 1) for (int k = 0; k < (y); k = k + 1) res.d[i][j] = (res.d[i][j] + d[i][k] * a.d[k][j]) % N; return (res); } matrix operator^(long long k) const { matrix res = matrix(m, n); matrix mul = (*this); for (int i = 0; i < (m); i = i + 1) res.d[i][i] = 1; while (k > 0) { if (k % 2 == 1) res = res * mul; mul = mul * mul; k = k >> 1; } return (res); } void print(void) const { for (int i = 0; i < (m); i = i + 1) { for (int j = 0; j < (n); j = j + 1) cout << d[i][j] << ; cout << n ; } cout << n ; } }; matrix fst, mul; void process(void) { cin >> N >> sx >> sy >> dx >> dy >> t; if (N == 1) { cout << 1 1 ; return; } fst = matrix(1, 6); mul = matrix(6, 6); for (int i = 0; i < (6); i = i + 1) for (int j = 0; j < (6); j = j + 1) mul.d[i][j] = matmul[i][j] % N; fst.d[0][0] = sx - 1; fst.d[0][1] = sy - 1; fst.d[0][2] = (dx % N + N) % N; fst.d[0][3] = (dy % N + N) % N; fst.d[0][4] = 0; fst.d[0][5] = 1; fst = fst * (mul ^ t); cout << fst.d[0][0] + 1 << << fst.d[0][1] + 1; } int main(void) { process(); return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { ios::sync_with_stdio(0); int n, m; cin >> n >> m; int ver[n + 1]; ver[n] = 1e9; for (int i = 0; i < n; i++) cin >> ver[i]; int hor[m]; for (int i = 0; i < m; i++) { int x1, x2, y; cin >> x1 >> x2 >> y; if (x1 > 1) hor[i] = 0; else hor[i] = x2; } if (m == 0) { cout << 0 << endl; return 0; } sort(ver, ver + n); sort(hor, hor + m); int wy = 10000000; int poz = m; int a = 0; for (int i = 0; i < n + 1; i++) { while (a < m and hor[a] < ver[i]) { poz--; a++; } wy = min(wy, poz + i); } cout << wy << endl; return 0; }
|
#include <bits/stdc++.h> const int md = 1e9 + 7; const long long hs = 199; using namespace std; int n, x; set<int> a; int main() { ios::sync_with_stdio(0), cin.tie(0), cout.tie(0); cin >> n; for (int i = 1; i <= n; i++) a.insert(i); cout << 1 ; while (--n) { cin >> x; a.erase(x); auto it = a.end(); it--; cout << 1 + *it - n << n ; } cout << 1 << n ; }
|
#include <bits/stdc++.h> using namespace std; int setBite(int r, int pos) { return r | (1 << pos); } int resetBit(int r, int pos) { return r & ~(1 << pos); } bool checkBit(int r, int pos) { return (r & (1 << pos)); } bool leap(long long x) { if ((x % 4 == 0 && x % 100 != 0) || x % 400 == 0) return true; return false; } long long bigmod(long long a, long long b, long long mod) { if (b == 0) return 1; if (b % 2 == 0) { long long ret = bigmod(a, b / 2, mod); return ((ret % mod) * (ret % mod)) % mod; } else return ((a % mod) * (bigmod(a, b - 1, mod) % mod)) % mod; } template <class 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 <class 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)); } template <class T> inline T sqr(T x) { return x * x; } template <class T> inline T power(T r, T p) { T ans = 1; for (T i = 0; i < p; i++) { ans *= r; } return ans; } int main() { ios_base::sync_with_stdio(0); cin.tie(0); int n; cin >> n; int g[2 * n + 5][2 * n + 5]; for (int i = 0; i < 2 * n + 5; i++) { for (int j = 0; j < 2 * n + 5; j++) { g[i][j] = 0; } } for (int i = 1; i <= n - 1; i++) { int a; cin >> a; g[i][i + 1] = a; g[i + 1][i] = a; } for (int i = n + 1; i <= 2 * n - 1; i++) { int a; cin >> a; g[i][i + 1] = a; g[i + 1][i] = a; } for (int i = 1; i <= n; i++) { int a; cin >> a; g[i][i + n] = a; g[i + n][i] = a; } vector<int> v; for (int i = 1; i <= n; i++) { int ans = 0; for (int j = 1; j <= i - 1; j++) { ans += g[j][j + 1]; } ans += g[i][i + n]; for (int j = i + n; j <= 2 * n - 1; j++) { ans += g[j][j + 1]; } v.push_back(ans); } sort(v.begin(), v.end()); cout << v[0] + v[1]; return 0; }
|
#include <bits/stdc++.h> using namespace std; long long int m; long long int a; long long int b; set<int> s; long long int im(long long int val, int dv) { long long int z = 0; long long int U = (1LL + val / dv) * (val / dv) / 2LL; U *= dv; U -= (val / dv) * (dv - (val % dv) - 1); return U; for (int i = 0; i <= val; i++) { z += i / dv; } return z; } long long int cn(int star, int ds) { long long int ret = im(m - ds, b) - im(star - ds - 1, b); ret += m - star + 1; return ret; } int main() { cin >> m >> a >> b; long long int mx = 0; long long int cur = 0; swap(a, b); long long int ans = cn(0, 0); s.insert(0); while (true) { if (cur < a) { cur += b * ((a - cur + b - 1) / b); } mx = max(mx, cur); cur -= a; cur %= b; if (mx > m) break; if (s.count(cur)) break; s.insert(cur); ans += cn(mx, cur); } printf( %lld n , ans); return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { long long n; int a = 0; cin >> n; long long tp = n; for (long long i = 2; i <= sqrt(tp); i++) { if (tp % i == 0) { while (tp % i == 0) tp /= i; a = i; break; } } if (a == 0) cout << n; else if (tp != 1) { printf( 1 ); } else printf( %d , a); return 0; }
|
#include <bits/stdc++.h> using namespace std; map<string, int> Map; char str[2200][22]; int p[2200], q[2200]; int main() { int num, n, k1, k2, cnt; char s1[22], s2[22]; while (scanf( %d , &n) != EOF) { memset(p, 0, sizeof(p)); memset(q, 0, sizeof(q)); cnt = 1; num = 0; while (n--) { scanf( %s %s , s1, s2); if (Map[s2] > 0) continue; if ((k1 = Map[s1]) > 0) { Map[s1] = 0; strcpy(str[cnt++], s2); p[q[k1]] = cnt - 1; q[cnt - 1] = q[k1]; Map[s2] = cnt - 1; } else { strcpy(str[cnt++], s1); strcpy(str[cnt++], s2); p[cnt - 2] = cnt - 1; q[cnt - 1] = cnt - 2; Map[s2] = cnt - 1; num++; } } printf( %d n , num); int i; for (i = 0; i < cnt; i++) if (p[i]) printf( %s %s n , str[i], str[p[i]]); } return 0; }
|
#include <bits/stdc++.h> using namespace std; int a[100002]; int gcd(int a, int b) { int c; while (a != 0) { c = a; a = b % a; b = c; } return b; } int main() { int n; int mina = 2000000009; cin >> n; cin >> a[1]; int ucln; ucln = a[1]; for (long long int i = 2; i <= n; i++) { scanf( %d , a + i); ucln = gcd(ucln, a[i]); } int res0 = 1; for (long long int i = 1; i <= n; i++) { if (a[i] % ucln != 0) { res0 = 0; } } if (ucln == 1) { res0 = 0; } if (res0 == 1) { cout << YES n ; cout << 0; } else { a[n + 1] = 2; int res = 0; for (int i = 1; i <= n;) { if (a[i] % 2 == 0) { i++; } else { if (a[i + 1] % 2 == 1) { res += 1; i += 2; } else { res += 2; i += 2; } } } cout << YES n ; cout << res; } }
|
#include <bits/stdc++.h> using namespace std; int maxx = 1e6 + 10; int up(int a, int b) { if (a % b) return a / b + 1; else return a / b; } int main() { int t; scanf( %d , &t); while (t--) { int n, d; scanf( %d%d , &n, &d); bool flag = 0; for (int x = 0; x < maxx; x++) { if ((x + up(d, x + 1)) <= n) { flag = 1; break; } } if (flag) printf( YES n ); else printf( NO n ); } return 0; }
|
#include <bits/stdc++.h> using namespace std; long long int mod = 998244353; long long int expo(long long int base, long long int exponent, long long int mod) { long long int ans = 1; while (exponent != 0) { if (exponent & 1) ans = (1LL * ans * base) % mod; base = (1LL * base * base) % mod; exponent >>= 1; } return ans % mod; } vector<long long int> g[100005]; long long int val[100005], dist[100005]; void dfs(long long int node, long long int par, long long int d) { dist[node] = d; if (g[node].size() == 1) val[par]++; for (auto x : g[node]) { if (x != par) dfs(x, node, d + 1); } } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); int tests = 1; while (tests--) { long long int i, j, u, v, n; cin >> n; for (long long int i = 1; i <= n - 1; i++) { cin >> u >> v; g[u].push_back(v); g[v].push_back(u); } long long int root = -1; for (long long int i = 1; i <= n; i++) { if (g[i].size() > 1) { root = i; break; } } dfs(root, 0, 0); long long int mx = n - 1, mn; long long int odd = 0, even = 0; for (long long int i = 1; i <= n; i++) { if (g[i].size() > 1) continue; if (dist[i] % 2) odd++; else even++; } if (odd == 0 || even == 0) mn = 1; else mn = 3; for (long long int i = 1; i <= n; i++) { mx -= max(0LL, val[i] - 1); } cout << mn << << mx; } cerr << nTime elapsed: << 1000 * clock() / CLOCKS_PER_SEC << ms n ; return 0; }
|
#include <bits/stdc++.h> using namespace std; const int Maxn = 55; long long dp[Maxn][10]; int main() { string k; cin >> k; int n = k.length(); for (int i = 0; i < 10; i++) { dp[0][i] = 1; } for (int i = 1; i < n; i++) { int t = k[i] - 0 ; for (int j = 0; j < 10; j++) { int l = (t + j) / 2, r = (t + j + 1) / 2; dp[i][l] += dp[i - 1][j]; if (l != r) dp[i][r] += dp[i - 1][j]; } } bool flag = false; for (int i = 1; i < n; i++) { int t = k[i] - 0 , j = k[i - 1] - 0 ; if ((t + j + 1) / 2 != t && (t + j) / 2 != t) flag = true; } long long ans = (long long)-1 + flag; for (int i = 0; i <= 9; i++) { ans = (long long)ans + (long long)dp[n - 1][i]; } cout << ans << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; const long long M = 1000000007; const double pi = acos(-1); const int N = 2e5 + 10; int main() { ios_base::sync_with_stdio(0); cin.tie(NULL); cout.tie(NULL); ; long long n, k, m, d, q = 1, ans = 0; cin >> n >> k >> m >> d; for (long long i = 1; i < d + 1; i++) { long long mx1 = m; long long mx2 = n / q; long long w = min(mx1, mx2) * i; ans = max(ans, w); q += k; if (q > n) break; } cout << ans; }
|
#include <bits/stdc++.h> using namespace std; const int N = 105; const int M = 1005; int n, m, x[N], s; double p[N * M], tmp[N * M]; int main() { scanf( %d%d , &n, &m); for (int i = 1; i <= n; ++i) scanf( %d , &x[i]); for (int i = 1; i <= n; ++i) s += x[i]; if (m == 1) { puts( 1.0000000000 ); return 0; } p[0] = 1; for (int i = 1; i <= n; ++i) { double now = 0; for (int j = 1; j < s; ++j) { now += p[j - 1]; if (x[i] <= j) now -= p[j - x[i]]; if (x[i] < j) now += p[j - x[i] - 1]; if (m < j) now -= p[j - m - 1]; tmp[j] = now / (m - 1); } for (int j = 0; j <= s; ++j) p[j] = tmp[j]; copy(tmp, tmp + s, p); } double ans = 0; for (int i = 1; i <= s; ++i) ans += p[i]; ans = ans * (m - 1) + 1; printf( %.10f n , ans); return 0; }
|
#include <bits/stdc++.h> using namespace std; const int N = 2e5 + 10; const int M = 1e6 + 10; int n, m, x, y, a[N], f[M]; bitset<N> ans, tmp; int main() { scanf( %d%d%d , &n, &x, &y); for (int i = 1; i <= n + 1; i++) { scanf( %d , &a[i]); tmp.set(a[i]); } for (int i = 1; i <= n + 1; i++) { ans |= tmp >> a[i]; } for (int i = 1; i <= x; i++) if (ans[i]) f[2 * (i + y)] = 2 * (i + y); for (int i = 1; i < M; i++) for (int j = i; j < M; j += i) f[j] = max(f[j], f[i]); scanf( %d , &m); while (m--) { scanf( %d , &x); if (f[x]) printf( %d , f[x]); else printf( -1 ); } }
|
#include <bits/stdc++.h> using namespace std; int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1}; long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); } using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); long long int n, m; cin >> n >> m; string s; char x, y; cin >> s; char ch[26]; for (long long int i = 0; i < 26; i++) { ch[i] = i + a ; } for (long long int i = 0; i < m; i++) { cin >> x >> y; for (long long int j = 0; j < 26; j++) { if (x == ch[j]) { ch[j] = y; } else if (y == ch[j]) { ch[j] = x; } } } for (long long int i = 0; i < s.size(); i++) { cout << ch[s[i] - a ]; } return 0; }
|
#include <bits/stdc++.h> const int N = 200010; std::vector<int> e[N]; int color[N], dep[N]; bool vis[N]; int n, k; int max = 0; void dfs(int u, int fa) { max = std::max(max, dep[u]); for (auto v : e[u]) { if (vis[v] || v == fa) { continue; } dep[v] = dep[u] + 1; dfs(v, u); } } std::vector<int> stack; std::vector<int> diameter; void find_diameter(int u, int fa, int t) { stack.push_back(u); if (u == t) { diameter = stack; } for (auto v : e[u]) { if (v == fa) { continue; } find_diameter(v, u, t); } stack.pop_back(); } void solve(int u, int fa, int add) { for (auto v : e[u]) { if (vis[v] || v == fa) { continue; } color[v] = (color[u] + add + k) % k; solve(v, u, add); } } int main() { scanf( %d%d , &n, &k); for (int i = 0, u, v; i < n - 1; ++i) { scanf( %d%d , &u, &v); e[u].push_back(v); e[v].push_back(u); } if (k == 2) { solve(1, 0, 1); puts( Yes ); for (int i = 1; i <= n; ++i) { printf( %d%c , color[i] + 1, n [i == n]); } return 0; } dfs(1, 0); int s = std::max_element(dep + 1, dep + n + 1) - dep; dep[s] = 0; dfs(s, 0); int t = std::max_element(dep + 1, dep + n + 1) - dep; find_diameter(s, 0, t); int sz = diameter.size(); for (int i = 0; i < sz; ++i) { color[diameter[i]] = i % k; vis[diameter[i]] = true; } for (int i = 0; i < sz; ++i) { dep[diameter[i]] = 0; max = 0; dfs(diameter[i], 0); if (max == 0) { continue; } if (max + i + 1 < k) { solve(diameter[i], 0, -1); } else if (max + sz - i < k) { solve(diameter[i], 0, 1); } else { puts( No ); return 0; } } puts( Yes ); for (int i = 1; i <= n; ++i) { printf( %d%c , color[i] + 1, n [i == n]); } 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 n1, m; cin >> n1 >> m; string s; cin >> s; long long n; n = s.size(); long long lps[n]; lps[0] = 0; long long i, j; if (m == 0) { long long ans3 = 1; for (i = 1; i <= n1; i++) { ans3 = (ans3 * 26) % 1000000007; } cout << ans3 << endl; return 0; } i = 0; i++; long long len = 0; j = 0; while (i < n) { if (s[i] == s[len]) { len++; lps[i] = len; i++; } else { if (len != 0) { len = lps[len - 1]; } else { lps[i] = 0; i++; } } } vector<long long> v; for (i = 0; i < m; i++) { long long x; cin >> x; v.push_back(x); } if (s.size() == 1) { long long ans3 = 1; for (i = 1; i <= n1 - m; i++) { ans3 = (ans3 * 26) % 1000000007; } cout << ans3 << endl; return 0; } if (s.size() == 1 && m == 1) { cout << 1 << endl; return 0; } long long vis[n1]; for (i = 0; i < n1; i++) { vis[i] = 0; } long long r; r = -1; for (i = 0; i < m; i++) { long long x; x = v[i]; x--; if (x > r) { if (x + n - 1 >= n1) { cout << 0 << endl; return 0; } for (j = x; j < x + n; j++) { vis[j] = 1; } r = x + n - 1; } else { if (r + (n - (r - x + 1)) >= n1) { cout << 0 << endl; return 0; } for (j = r + 1; j <= r + (n - (r - x + 1)); j++) { vis[j] = 1; } r = r + (n - (r - x + 1)); } } long long c = 0LL; for (i = 0; i < n1; i++) { if (vis[i] == 0) c++; } long long arr[c + 1]; arr[0] = 1; for (i = 1; i <= c; i++) { arr[i] = (arr[i - 1] * 26) % 1000000007; } map<long long, long long> m1; long long k1; k1 = lps[n - 1]; while (k1 > 0) { m1[n - k1] = 1; k1 = lps[k1 - 1]; } if (m == 1) { cout << arr[c] << endl; return 0; } r = v[0] - 1; for (i = 1; i < m; i++) { long long x; x = v[i]; x--; if (r + n - 1 < x) { r = x; } else { long long pos; pos = x - r; if (m1.find(pos) == m1.end()) { cout << 0 << endl; return 0; } else r = x; } } cout << arr[c] << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; const int MAXN = 100010; const int INF = 0x7f7f7f7f; const double pi = 4.0 * atan(1.0); int cases; struct Segment_Tree { long long lazy[MAXN << 2]; long long data[MAXN << 2]; long long flag[MAXN << 2]; void pushup(int o) { data[o] = data[(o << 1)] + data[(o << 1) | 1]; if (flag[(o << 1)] != flag[(o << 1) | 1]) { flag[o] = 0; } else { flag[o] = flag[(o << 1)]; } } void setlazy(int o, int m, long long v) { lazy[o] += v; data[o] += m * v; } void pushdown(int o, int m) { if (lazy[o]) { setlazy((o << 1), m - (m >> 1), lazy[o]); setlazy((o << 1) | 1, m >> 1, lazy[o]); flag[(o << 1)] = flag[(o << 1) | 1] = flag[o]; lazy[o] = 0; } } void build_tree(int o, int l, int r) { if (l == r) { flag[o] = l; return; } int mid = (l + r) >> 1; build_tree((o << 1), l, mid); build_tree((o << 1) | 1, mid + 1, r); pushup(o); } void update(int o, int l, int r, int x, int y, long long v) { if (x <= l && r <= y && flag[o] != 0) { lazy[o] += abs(flag[o] - v); data[o] += (long long)(r - l + 1) * abs(flag[o] - v); flag[o] = v; return; } pushdown(o, r - l + 1); int mid = (l + r) >> 1; if (x <= mid) update((o << 1), l, mid, x, y, v); if (y > mid) update((o << 1) | 1, mid + 1, r, x, y, v); pushup(o); } long long query(int o, int l, int r, int x, int y) { if (x <= l && r <= y) { return data[o]; } pushdown(o, r - l + 1); int mid = (l + r) >> 1; if (y <= mid) return query((o << 1), l, mid, x, y); if (x > mid) return query((o << 1) | 1, mid + 1, r, x, y); return query((o << 1), l, mid, x, y) + query((o << 1) | 1, mid + 1, r, x, y); } } segtree; int main() { int n, m, op, x, y; long long z; scanf( %d%d , &n, &m); segtree.build_tree(1, 1, n); for (int i = 0; i < m; i++) { scanf( %d , &op); if (op == 1) { scanf( %d%d%lld , &x, &y, &z); segtree.update(1, 1, n, x, y, z); } else if (op == 2) { scanf( %d%d , &x, &y); printf( %lld n , segtree.query(1, 1, n, x, y)); } } }
|
#include <bits/stdc++.h> using namespace std; int n, a[100001], c[100001]; int main() { cin >> n; for (int i = 0; i < n; i++) cin >> a[i]; int s = 0; for (int i = n - 1; i >= 0; i--) if (s > 0) s -= a[i]; else { c[i] = 1; s += a[i]; } if (s < 0) for (int i = 0; i < n; i++) c[i] ^= 1; for (int i = 0; i < n; i++) cout << (c[i] ? + : - ); cout << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; struct num2 { static const int MB = 1e9 + 9; int b; num2() {} num2(int x) : b(x) {} num2 operator+(const num2& x) const { return num2((b + x.b) % MB); } num2 operator-(const num2& x) const { return num2((b + MB - x.b) % MB); } num2 operator*(int x) const { return num2(((long long)b * x) % MB); } num2 operator*(const num2& x) const { return num2(((long long)b * x.b) % MB); } bool operator==(const num2& x) const { return b == x.b; } }; const int MODP = 701; template <class T> struct StringOps { StringOps() {} StringOps(const string& s) : s(s) { n = s.length(); deg.resize(n + 1); hashes.resize(n); deg[0] = T(1); for (int i = 1; i <= n; ++i) { deg[i] = deg[i - 1] * T(MODP); } T curhash = T(0); for (int i = 0; i < n; ++i) { curhash = curhash * T(MODP) + T(s[i]); hashes[i] = curhash; } } char get(int idx) { return s[idx]; } T get_hash(int l, int r) { T cur(0); if (l > 0) { cur = hashes[l - 1]; } return hashes[r] - cur * deg[r - l + 1]; } int string_lcp(int l, int r, int lim = 1e9) { int cleft = 1, cright = min(n - r, n - l); cright = min(lim, cright); int res = 0; while (cleft <= cright) { int key = (cleft + cright) / 2; if (s[l + key - 1] != s[r + key - 1]) { cright = key - 1; } else if (get_hash(l, l + key - 1) == get_hash(r, r + key - 1)) { res = key; cleft = key + 1; } else { cright = key - 1; } } return res; } vector<T> hashes; vector<T> deg; string s; int n; }; const int maxN = 1000100; const int MOD = 1e9 + 7; int len1, len2; int u, v; StringOps<num2> sops; int get_nlength(const pair<int, int>& a) { if (a.first == u) { if (a.second != len1) { return len1 - 1; } else { return len1; } } if (a.second != len2) { return len2 - 1; } else { return len2; } } void fill_segs(int& l1, int& r1, int& l2, int& r2, const pair<int, int>& a) { if (a.first == u) { l2 = r2 = -1; if (a.second == 0) { l1 = 1, r1 = len1 - 1; } else if (a.second >= len1 - 1) { l1 = 0, r1 = a.second - 1; } else { l1 = 0, r1 = a.second - 1; l2 = a.second + 1, r2 = len1 - 1; } return; } l2 = r2 = -1; if (a.second == 0) { l1 = 1, r1 = len2 - 1; } else if (a.second >= len2 - 1) { l1 = 0, r1 = a.second - 1; } else { l1 = 0, r1 = a.second - 1; l2 = a.second + 1, r2 = len2 - 1; } l1 += len1, r1 += len1; if (l2 != -1) { l2 += len1, r2 += len1; } } int cmp2(vector<pair<int, int>>& a, vector<pair<int, int>>& b, int p1 = 0, int p2 = 0) { if (p1 == a.size() && p2 < b.size()) { return -1; } if (p1 == a.size() && p2 == b.size()) { return 0; } if (p2 == b.size() && p1 < a.size()) { return 1; } if (p1 + 1 == a.size() && p2 + 1 == b.size() && a[0] == b[0]) { return 0; } if (p1 + 2 == a.size() && p2 + 2 == b.size() && a[0] == b[0] && a[1] == b[1]) { return 0; } if (sops.get(a[p1].first) != sops.get(b[p2].first)) { char c1 = sops.get(a[p1].first); char c2 = sops.get(b[p2].first); if (c1 < c2) { return -1; } return 1; } int lcp = sops.string_lcp( a[p1].first, b[p2].first, min(a[p1].second - a[p1].first + 1, b[p2].second - b[p2].first + 1)); lcp = min( lcp, min(a[p1].second - a[p1].first + 1, b[p2].second - b[p2].first + 1)); int nx = a[p1].first + lcp - 1, ny = b[p2].first + lcp - 1; if (nx >= a[p1].second) { ++p1; } else { a[p1].first = nx + 1; } if (ny >= b[p2].second) { ++p2; } else { b[p2].first = ny + 1; } return cmp2(a, b, p1, p2); } bool cmp(const pair<int, int>& a, const pair<int, int>& b) { int nlen1 = get_nlength(a); int nlen2 = get_nlength(b); if (nlen1 == 0 && nlen2 == 0) { if (a.first == u & b.first == v) { return true; } return false; } if (nlen1 == 0) { return true; } if (nlen2 == 0) { return false; } int l1, r1, l2, r2; fill_segs(l1, r1, l2, r2, a); int p1, q1, p2, q2; fill_segs(p1, q1, p2, q2, b); vector<pair<int, int>> na; vector<pair<int, int>> nb; na.push_back(make_pair(l1, r1)); if (l2 != -1) { na.push_back(make_pair(l2, r2)); } nb.push_back(make_pair(p1, q1)); if (p2 != -1) { nb.push_back(make_pair(p2, q2)); } int val = cmp2(na, nb); if (val == 0) { if (a.first == u && b.first == v) { return true; } return false; } return val == -1; } struct Node { Node() { left = right = nullptr; } int idxleft, idxright; Node* left; Node* right; }; int curorder[maxN]; int lenorder; void dfs(Node* root) { if (!root) { return; } if (root->left) { dfs(root->left); } for (int i = root->idxleft; i <= root->idxright; ++i) { curorder[lenorder] = i; ++lenorder; } if (root->right) { dfs(root->right); } } pair<int, int> order[2][maxN]; int clen[2]; void get_order(const string& s, int p) { int n = s.length(); Node* root = new Node(); Node* curnode = root; for (int i = 0; i < n;) { int cur = i; while (cur < n && s[cur] == s[i]) { ++cur; } curnode->idxleft = i, curnode->idxright = cur - 1; if (cur == n) { break; } if (s[i] < s[cur]) { Node* left = new Node(); curnode->left = left; curnode = curnode->left; } else { Node* right = new Node(); curnode->right = right; curnode = curnode->right; } i = cur; } lenorder = 0; dfs(root); int ps = n; for (int i = 0; i < n; ++i) { if (curorder[i] == n - 1) { ps = i + 1; break; } } vector<pair<int, int>> result; clen[p] = 0; for (int i = 0; i < ps; ++i) { order[p][clen[p]] = make_pair(v, curorder[i]); ++clen[p]; } order[p][clen[p]] = make_pair(v, n); ++clen[p]; for (int i = ps; i < n; ++i) { order[p][clen[p]] = make_pair(v, curorder[i]); ++clen[p]; } } int dp[2][maxN]; int main() { ios_base::sync_with_stdio(false); cin.tie(nullptr); int n; cin >> n; vector<string> s(n); for (int i = 0; i < n; ++i) { cin >> s[i]; } for (int i = 0; i <= s[0].length(); ++i) { dp[u][i] = 1; } sops = StringOps<num2>(s[0]); len1 = 0, len2 = s[0].length(); u = 1, v = 0; get_order(s[0], 0); swap(u, v); for (int i = 0; i + 1 < n; ++i) { string& s1 = s[i]; string& s2 = s[i + 1]; string nw = s1 + s2; len1 = s1.length(), len2 = s2.length(); sops = StringOps<num2>(nw); get_order(s[i + 1], v); int cadd = 0; int head1 = 0, head2 = 0; while (head1 < clen[u] || head2 < clen[v]) { if (head1 == clen[u]) { dp[v][order[v][head2].second] = cadd; ++head2; } else if (head2 == clen[v]) { break; } else { if (cmp(order[u][head1], order[v][head2])) { int nhead1 = head1; while (nhead1 < clen[u] && s1[order[u][nhead1].second] == s1[order[u][head1].second] && order[u][nhead1].second - order[u][head1].second == nhead1 - head1) { ++nhead1; } for (int j = head1; j < nhead1; ++j) { cadd += dp[u][order[u][j].second]; if (cadd >= MOD) { cadd -= MOD; } } head1 = nhead1; } else { int nhead2 = head2; while (nhead2 < clen[v] && s2[order[v][nhead2].second] == s2[order[v][head2].second] && order[v][nhead2].second - order[v][head2].second == nhead2 - head2) { ++nhead2; } for (int j = head2; j < nhead2; ++j) { dp[v][order[v][j].second] = cadd; } head2 = nhead2; } } } swap(u, v); } int res = 0; int res2 = 0; for (int i = 0; i <= s.back().length(); ++i) { res += dp[u][i]; if (res >= MOD) { res -= MOD; } } cout << res << endl; return 0; }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.