Datasets:
malteklaes
/
cpp-code-code_search_net-style

Dataset card Data Studio Files Community
1
func_code_string
stringlengths
59
71.4k
#include <bits/stdc++.h> using namespace std; int32_t main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); long long a; cin >> a; bitset<22> b(a); long long i, j, k; long long c = 0; vector<long long> v; for (i = 0; i <= 40; i++) { long long temp = a; temp++; if ((a & temp) == 0) { break; } if (i % 2) a++; else { bitset<22> z(a); for (j = 21; j >= 0; j--) { if (z[j] == 1) break; } for (; j >= 0; j--) if (z[j] == 0) break; v.push_back(j + 1); a = a ^ (long long)(pow(2, j + 1) - 1); } } cout << i << endl; for (auto g : v) cout << g << ; cout << endl; }
#include <bits/stdc++.h> using namespace std; const int INF = 1e9 + 7; vector<int> eum; int w[100005]; int Euler(int num) { int p = 2, ans = 1; while (p * p <= num) { int ct = 1; while (num % p == 0) { ct *= p; num /= p; } if (ct > 1) ct = ct / p * (p - 1); ans *= ct; p++; } if (num > 1) ans *= num - 1; return ans; } long long power(int x, int t, long long m) { if (t == 0) return 1; long long cc = power(x, t >> 1, m); cc = cc * cc % m; if (t & 1) cc = cc * x % m; return cc; } int gcd(int m, int n) { return n == 0 ? m : gcd(n, m % n); } int solve(int l, int r, int mid) { if (l > r) return 1; if (eum[mid] == 1) return 0; vector<int> cc; for (int k = l + 1; k <= r && k <= l + 4; k++) cc.push_back(w[k]); cc.push_back(1); for (int k = 0; k < (cc.size()); k++) if (cc[k] == 1) { long long cur = 1LL; for (int j = k - 1; j >= 0; j--) { if (cc[j] >= 30 || cc[j] >= 4 && cur >= 4) { cur = 30LL; break; } cur = power(cc[j], cur, 1LL << 62); if (cur > 30LL) { cur = 30LL; break; } } if (cur < 30LL) return power(w[l], cur, eum[mid]) % eum[mid]; else return power(w[l], solve(l + 1, r, mid + 1) + eum[mid + 1], eum[mid]); } } int main() { int n, m, q, x, l, r; scanf( %d%d , &n, &m); eum.push_back(m); while ((x = eum.back()) > 1) eum.push_back(Euler(x)); for (int k = 0; k < (n); k++) scanf( %d , &w[k]); scanf( %d , &q); for (int k = 0; k < (q); k++) { scanf( %d%d , &l, &r); l--; r--; printf( %d n , solve(l, r, 0)); } return 0; }
#include <bits/stdc++.h> #pragma comment(linker, /STACK:1000000000 ) #pragma GCC optimize( Ofast,no-stack-protector ) using namespace std; const int maxn = (int)5e5 + 10, maxlog = 19; vector<pair<int, int> > ed[maxn]; int par[maxlog][maxn]; int wup[maxn]; int h[maxn]; int pr[maxn]; int getp(int x) { return (pr[x] == x ? x : pr[x] = getp(pr[x])); } int x[maxn], y[maxn]; int inc[maxn], aksldal[maxn]; void dfs(int v, int p, int we, int hh) { h[v] = hh; par[0][v] = p; wup[v] = we; for (int i = 1; i < maxlog; i++) { par[i][v] = par[i - 1][par[i - 1][v]]; } for (auto [u, num] : ed[v]) { if (u != p) { if (v == 0 || num > we) { aksldal[u] = aksldal[v] + 1; } else { aksldal[u] = 1; } if (v == 0 || num < we) { inc[u] = inc[v] + 1; } else { inc[u] = 1; } dfs(u, v, num, hh + 1); } } } int lca(int x, int y) { if (h[x] < h[y]) { swap(x, y); } for (int i = 0; i < maxlog; i++) { if (((h[x] - h[y]) >> i) & 1) { x = par[i][x]; } } if (x == y) { return x; } for (int i = maxlog - 1; i >= 0; i--) { if (par[i][x] != par[i][y]) { x = par[i][x]; y = par[i][y]; } } return par[0][x]; } int up(int x, int d) { for (int i = 0; i < maxlog; i++) { if ((d >> i) & 1) { x = par[i][x]; } } return x; } bool tr[maxn]; int f[maxn]; int val[maxn]; int main() { int n, m; cin >> n >> m; for (int i = 0; i < n; i++) { pr[i] = i; } for (int i = 0; i < m; i++) { scanf( %d %d , &x[i], &y[i]); x[i]--; y[i]--; } for (int i = m - 1; i >= 0; i--) { int a = x[i]; int b = y[i]; int pa = getp(a); int pb = getp(b); if (pa != pb) { ed[a].push_back(make_pair(b, i)); ed[b].push_back(make_pair(a, i)); pr[pa] = pb; tr[i] = true; } } dfs(0, 0, -1, 0); for (int i = 0; i < n; i++) { val[i] = 1; } for (int i = m - 1; i >= 0; i--) { int a = x[i]; int b = y[i]; if (tr[i]) { f[i] = val[a] + val[b]; val[a] = val[b] = f[i]; continue; } else { int l = lca(a, b); int x = val[a] + val[b]; if (b == l) { swap(a, b); } if (a == l) { int d = inc[b]; if (h[b] - h[a] <= d) { d = h[b] - h[a]; } int m = up(b, d - 1); if (aksldal[m] >= h[m] - h[a]) { x -= f[wup[m]]; } } else { int da = inc[a]; int db = inc[b]; if (h[a] - h[l] <= da && h[b] - h[l] <= db) { int pa = up(a, h[a] - h[l] - 1); int pb = up(b, h[b] - h[l] - 1); x -= f[max(wup[pa], wup[pb])]; } else { if (h[a] - h[l] <= da) { swap(a, b); swap(da, db); } if (h[b] - h[l] <= db) { int m = up(a, da - 1); if (aksldal[m] >= h[m] - h[l]) { int pa = up(a, h[a] - h[l] - 1); int pb = up(b, h[b] - h[l] - 1); if (wup[pb] < wup[pa]) { x -= f[wup[m]]; } } } } } f[i] = x; val[a] = val[b] = x; } } for (int i = 0; i < n; i++) { printf( %d , val[i] - 1); } }
#include <bits/stdc++.h> using namespace std; const int N = 1e5 + 9, M = 998244353; int dp[2][205][2], n, a[N]; long long sum[2][205][2]; int f(int i, int x, int z) { if (a[i] > 0 && x != a[i]) return dp[i % 2][x][z] = 0; if (i == n - 1) return dp[i % 2][x][z] = z; long long ans = 0, l = 0, r = 200; i %= 2; ans = z * (sum[1 - i][x - 1][1] - sum[1 - i][l][1]) % M + dp[1 - i][x][1] + (sum[1 - i][r][0] - sum[1 - i][x][0]) % M + 2 * M; return dp[i][x][z] = ans % M; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); long long i, j; cin >> n; for (i = 0; i < n; i++) cin >> a[i]; for (i = n - 1; i >= 0; i--) for (j = 1; j < 201; j++) { sum[i % 2][j][0] = f(i, j, 0) + sum[i % 2][j - 1][0]; sum[i % 2][j][1] = f(i, j, 1) + sum[i % 2][j - 1][1]; } cout << sum[0][200][0] % M << endl; return 0; }
#include <bits/stdc++.h> #pragma comment(linker, /STACK:1024000000,1024000000 ) using namespace std; const int mxn = 400005, maxnn = 100005; const int mod = 1e9 + 7; long long ans; int n, m, num, cir, r, cnt; int head[maxnn], que[maxnn]; struct edge { int to, next; long long w; } f[mxn << 2]; long long p[70], circle[mxn], dis[maxnn], dig[2], pw[105]; inline void add(int u, int v, long long w) { f[++cnt].to = v, f[cnt].w = w, f[cnt].next = head[u], head[u] = cnt; } inline void dfs(int u, int fa, long long now) { dis[u] = now, que[++num] = u; for (int i = head[u]; i; i = f[i].next) { int v = f[i].to; if (v == fa) continue; if (dis[v] == -1) dfs(v, u, dis[u] ^ f[i].w); else circle[++cir] = dis[u] ^ dis[v] ^ f[i].w; } } inline void init() { int i, j; r = 0; memset(p, 0, sizeof p); for (i = 1; i <= cir; i++) { long long x = circle[i]; for (j = 62; j >= 0; j--) { if (!(x >> j)) continue; if (!p[j]) { p[j] = x; break; } x ^= p[j]; } } for (j = 0; j <= 62; j++) if (p[j]) r++; } inline void calc() { init(); int i, j; for (j = 0; j <= 62; j++) { bool flag = 0; dig[0] = dig[1] = 0; for (i = 1; i <= num; i++) dig[(dis[que[i]] >> j) & 1]++; for (i = 0; i <= 62; i++) if ((p[i] >> j) & 1) { flag = 1; break; } long long now = (dig[0] * (dig[0] - 1) / 2 + dig[1] * (dig[1] - 1) / 2) % mod; if (flag) { if (r) now = now * pw[r - 1] % mod; now = now * pw[j] % mod; ans = (ans + now) % mod; } now = dig[0] * dig[1] % mod; if (flag) { if (r) now = now * pw[r - 1] % mod; } else now = now * pw[r] % mod; now = now * pw[j] % mod; ans = (ans + now) % mod; } } int main() { int i, j, u, v; long long w; memset(dis, -1, sizeof dis); pw[0] = 1; for (j = 1; j <= 100; j++) pw[j] = pw[j - 1] * 2 % mod; scanf( %d%d , &n, &m); for (i = 1; i <= m; i++) { scanf( %d%d%lld , &u, &v, &w); add(u, v, w), add(v, u, w); } for (i = 1; i <= n; i++) if (dis[i] == -1) { num = cir = 0; dfs(i, 0, 0); calc(); } printf( %lld , ans); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); long long n; cin >> n; vector<long long> x(n); for (long long i = 0; i < n; i++) cin >> x[i]; unordered_map<int, int> m; for (auto num : x) { m[num]++; } if (m.size() < 3) { cout << 0; return 0; } int ans = INT_MAX; for (auto num : m) { if (ans > num.second) { ans = num.second; } } printf( %d n , ans); vector<vector<int>> v(4); for (int i = 0; i < n; i++) { if (x[i] == 1) v[1].push_back(i + 1); if (x[i] == 2) v[2].push_back(i + 1); if (x[i] == 3) v[3].push_back(i + 1); } for (long long i = 0; i < ans; i++) { printf( %d %d %d n , v[1][i], v[2][i], v[3][i]); } return 0; }
#include <bits/stdc++.h> using namespace std; struct pokr { double p1; double p2; double len; pokr(double _p1, double _p2, double _l) : p1(_p1), p2(_p2), len(_l) {} pokr() { p1 = p2 = len = 0; } } d[2100][2100]; int x[2100]; int c[2100][2100]; int a[2100]; int b[2100]; double p, q; int h; pokr get_ans(int l, int r) { pokr res; if (l > r) return pokr(0, 0, 0); if (l == r) return pokr(p, q, 0); if (c[l][r]) return d[l][r]; pokr temp = get_ans(l + 1, r); res.p1 += p / 2; res.p2 += temp.p2 * p / 2; res.len += p / 2 * temp.len; res.len += p / 2 * temp.p1 * min(x[l + 1] - x[l], h); int next = b[l]; if (next <= r) { pokr temp = get_ans(next, r); res.p2 += q / 2 * temp.p2; res.len += q / 2 * temp.len; res.len += q / 2 * (x[next - 1] + h - x[l]); res.len += q / 2 * temp.p1 * min(x[next] - x[next - 1] - h, h); } else { res.p2 += q / 2; res.len += q / 2 * (x[r] - x[l]); } temp = get_ans(l, r - 1); res.p2 += q / 2; res.p1 += temp.p1 * q / 2; res.len += q / 2 * temp.len; res.len += q / 2 * temp.p2 * min(x[r] - x[r - 1], h); int prev = a[r]; if (prev >= l) { pokr temp = get_ans(l, prev); res.p1 += p / 2 * temp.p1; res.len += p / 2 * temp.len; res.len += p / 2 * (x[r] - x[prev + 1] + h); res.len += p / 2 * temp.p2 * min(x[prev + 1] - x[prev] - h, h); } else { res.p1 += p / 2; res.len += p / 2 * (x[r] - x[l]); } c[l][r] = 1; d[l][r] = res; return res; } int main() { int n; cin >> n >> h; cin >> p; q = 1 - p; for (int i = 0; i < n; i++) cin >> x[i]; sort(x, x + n); a[0] = -1; for (int i = 1; i < n; i++) if (x[i] - x[i - 1] < h) a[i] = a[i - 1]; else a[i] = i - 1; b[n - 1] = n; for (int i = n - 2; i >= 0; i--) if (x[i + 1] - x[i] < h) b[i] = b[i + 1]; else b[i] = i + 1; pokr r = get_ans(0, n - 1); printf( %.12f , (r.p1 + r.p2) * h + r.len); return 0; }
#include <bits/stdc++.h> #pragma GCC optimize( Ofast,unroll-loops ) #pragma GCC target( avx,avx2,fma ) using namespace std; template <typename T> using vc = vector<T>; template <typename T> using uset = unordered_set<T>; template <typename A, typename B> using umap = unordered_map<A, B>; template <typename T> using pq = priority_queue<T>; template <typename T> using minpq = priority_queue<T, vc<T>, greater<T>>; template <typename T> inline void sort(vc<T>& v) { sort(v.begin(), v.end()); } template <typename T, typename Comp> inline void sort(vc<T>& v, Comp c) { sort(v.begin(), v.end(), c); } using ll = long long; using ull = unsigned long long; using pii = pair<ll, ll>; using vi = vc<ll>; using vii = vc<pii>; constexpr char el = n ; constexpr char sp = ; constexpr ll INF = 0x3f3f3f3f; constexpr ll LLINF = 0x3f3f3f3f3f3f3f3fLL; ll xh, yh, xs, ys, n; inline bool evan(ll a, ll b) { return a < 0 && b > 0 || a > 0 && b < 0; } signed main() { ios_base::sync_with_stdio(false); cin.tie(nullptr); cout << fixed; cin >> xh >> yh; cin >> xs >> ys; cin >> n; ll ans = 0; while (n--) { ll a, b, c; cin >> a >> b >> c; if (evan(a * xh + b * yh + c, a * xs + b * ys + c)) ans++; } cout << ans; }
#include <bits/stdc++.h> using namespace std; const int N = 26; vector<int> kmp; string txt, pattern; vector<vector<int> > nxt, dp; void build() { kmp.resize(pattern.size() + 10); kmp[0] = 0; for (int i = 1, j = 0; i < pattern.size();) { if (pattern[i] == pattern[j]) kmp[i++] = ++j; else if (!j) kmp[i++] = 0; else j = kmp[j - 1]; } nxt.resize(pattern.size() + 10); for (int i = 0; i < pattern.size(); ++i) nxt[i].resize(N + 10); for (int j = 0; j < N; ++j) nxt[0][j] = (pattern[0] - a == j); for (int i = 1; i < pattern.size(); ++i) for (int j = 0; j < N; ++j) nxt[i][j] = (pattern[i] - a == j) ? i + 1 : nxt[kmp[i - 1]][j]; dp.resize(txt.size() + 10); for (int i = 0; i < dp.size(); ++i) dp[i].resize(pattern.size() + 10); for (int i = 0; i < dp.size(); ++i) for (int j = 0; j < dp[i].size(); ++j) dp[i][j] = -1; } int solve(const int &i, const int &j) { if (i == txt.size()) return 0; if (dp[i][j] != -1) return dp[i][j]; int ans = 0; if (txt[i] == ? ) { for (int k = 0; k < N; ++k) { int new_j = nxt[j][k]; if (new_j == pattern.size()) ans = max(ans, 1 + solve(i + 1, kmp[new_j - 1])); else ans = max(ans, solve(i + 1, new_j)); } } else { int k = txt[i] - a ; int new_j = nxt[j][k]; if (new_j == pattern.size()) ans = max(ans, 1 + solve(i + 1, kmp[new_j - 1])); else ans = max(ans, solve(i + 1, new_j)); } return dp[i][j] = ans; } int main() { cin >> txt >> pattern; build(); printf( %d n , solve(0, 0)); return 0; }
#include <bits/stdc++.h> using namespace std; map<int, int> mp; set<int> s; int main(void) { int q; scanf( %d , &q); while (q--) { mp.clear(); int x; scanf( %d , &x); int t = x; int lim = sqrt(t); for (int i = 2; i <= lim; i++) { while (t % i == 0) { mp[i]++; t /= i; } } if (1 < t) mp[t]++; s.clear(); for (int i = 2; i <= lim; i++) { if (x % i == 0) { s.insert(i); s.insert(x / i); } } s.insert(x); vector<int> rep; for (auto e : mp) rep.push_back(e.first); if (rep.size() == 2) { int mult = 1; for (auto e : mp) mult *= e.first; vector<int> ds; if (mult == x) { printf( %d , mult); for (int p : rep) { for (int div : s) { if (div % p == 0) { if (div != mult) { printf( %d , div); } ds.push_back(div); } } for (int e : ds) s.erase(e); ds.clear(); } printf( n1 n ); } else { printf( %d , x); vector<int> ds; for (int p : rep) { for (int div : s) { if (div % p == 0) { if (div != mult) { if (div != x) { printf( %d , div); } } ds.push_back(div); } } for (int e : ds) s.erase(e); ds.clear(); if (p != rep.back()) printf( %d , mult); } printf( n0 n ); } } else if (rep.size() == 1) { for (int div : s) { printf( %d , div); } printf( n0 n ); } else { map<int, int> joint; for (int i = 0; i < rep.size(); i++) { joint[rep[i] * rep[(i + 1) % rep.size()]] = true; } vector<int> ds; for (int i = 0; i < rep.size(); i++) { for (int div : s) { if (div % rep[i] == 0) { if (joint.count(div) == 0) { printf( %d , div); } ds.push_back(div); } } printf( %d , rep[i] * rep[(i + 1) % rep.size()]); for (int e : ds) s.erase(e); ds.clear(); } printf( n0 n ); } } }
#include <bits/stdc++.h> using namespace std; bool isSquare(long long n) { const long long s = (long long)ceil(sqrt(n)); return (s * s) == n; } long long calcCostToSquare(long long n) { if (isSquare(n)) return 0; const auto f1 = (long long)ceil(sqrt(n)); const auto f2 = (long long)floor(sqrt(n)); return min((long long)abs(f1 * f1 - n), (long long)abs(f2 * f2 - n)); } long long calcCostToNonSquare(long long n) { if (n == 0) return 2; if (isSquare(n)) return 1; return 0; } int main() { long long n; cin >> n; long long numSquare = 0; multiset<long long> toMakeSquare; multiset<long long> toMakeNonSquare; for (long long i = 0; i < n; ++i) { long long a; cin >> a; if (isSquare(a)) ++numSquare; toMakeSquare.insert(calcCostToSquare(a)); toMakeNonSquare.insert(calcCostToNonSquare(a)); } n /= 2; long long result = 0; if (numSquare < n) { auto it = toMakeSquare.upper_bound(0); while (numSquare < n) { result += *it; ++it; ++numSquare; } } else { auto it = toMakeNonSquare.upper_bound(0); while (numSquare > n) { result += *it; ++it; --numSquare; } } cout << result << endl; }
#include <bits/stdc++.h> using namespace std; long long num_to_sig(long long x) { vector<int> v; while (x > 0) { v.push_back((x % 10) % 2); x /= 10; } int n = v.size(); long long ret = 0; for (int i = n - 1; i >= 0; i--) { ret *= 10; ret += v[i]; } return ret; } int main() { int Q; scanf( %d , &Q); map<long long, int> cnt; while (Q--) { char c; scanf( %c , &c); long long x; if (c == + ) { scanf( %lld , &x); cnt[num_to_sig(x)]++; } else if (c == - ) { scanf( %lld , &x); cnt[num_to_sig(x)]--; } else { scanf( %lld , &x); printf( %d n , cnt[num_to_sig(x)]); } } return 0; }
#include <bits/stdc++.h> using namespace std; vector<long long> sp; vector<pair<long long, long long>> bases; int main() { int s, b; cin >> s >> b; long long num, num2; for (int i = 0; i < s; i++) { cin >> num; sp.push_back(num); } for (int i = 0; i < b; i++) { cin >> num >> num2; bases.push_back({num, num2}); } sort(bases.begin(), bases.end()); long long sum[b + 5]; for (int i = 0; i < b; i++) { sum[i] = bases[i].second; if (i > 0) sum[i] += sum[i - 1]; } for (int i = 0; i < s; i++) { long long bas = 0; long long start = 0, end = b, mid, idx = -1; while (start <= end) { mid = (start + end) / 2; if (bases[mid].first <= sp[i]) { idx = mid; start = mid + 1; } else { end = mid - 1; } } if (idx == b) idx--; if (idx == -1) cout << 0 ; else cout << sum[idx] << ; } return 0; }
#include <bits/stdc++.h> using namespace std; const long long int mod = 1e9 + 7; const double pie = 3.14159265358979323846; const char nl = n ; template <typename Type> istream &operator>>(istream &in, vector<Type> &v) { long long int n = v.size(); for (int i = 0; i < n; i++) in >> v[i]; return in; } template <typename Type> ostream &operator<<(ostream &out, vector<Type> &v) { for (auto value : v) out << value << ; out << endl; return out; } void solve() { long long int n; cin >> n; vector<long long int> a(4 * n); cin >> a; sort(a.begin(), a.end()); long long int area = a[0] * a.back(); long long int c = 1, j = 4 * n - 1; for (long long int i = 0; c <= n;) { if (a[i] != a[i + 1] or a[j] != a[j - 1] or a[i] * a[j] != area) { cout << No n ; return; } ++c; i += 2; j -= 2; } cout << Yes n ; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); long long int t; cin >> t; while (t--) { solve(); } return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 1e5 + 5; int n, a[N], fa[N], head[N], p, deep[N]; long long Chuan1[N], Chuan2[N], Ans; queue<int> q; struct wfh { int to, last; } d[N << 1]; inline void add(int a, int b) { d[++p] = (wfh){b, head[a]}, head[a] = p; } inline long long max(long long A, long long B) { return A > B ? A : B; } inline long long min(long long A, long long B) { return A < B ? A : B; } void dfs(int u, int fa) { for (int i = head[u], v; i; i = d[i].last) { v = d[i].to; if (v == fa) continue; dfs(v, u); Chuan1[u] = max(Chuan1[u], Chuan1[v]); Chuan2[u] = max(Chuan2[u], Chuan2[v]); } a[u] += Chuan2[u] - Chuan1[u]; if (a[u] >= 0) Chuan1[u] += a[u]; else Chuan2[u] -= a[u]; } int main() { scanf( %d , &n); for (int i = 1, u, v; i < n; i++) scanf( %d%d , &u, &v), add(u, v), add(v, u); for (int i = 1; i <= n; i++) scanf( %d , &a[i]); dfs(1, -1); printf( %lld n , Chuan1[1] + Chuan2[1]); return 0; }
#include <bits/stdc++.h> using namespace std; int a[111111]; int b[111111]; int main() { int n, m, c; scanf( %d%d%d , &n, &m, &c); for (int i = 0; i < n; i++) scanf( %d , &a[i]); for (int i = 0; i < m; i++) scanf( %d , &b[i]); for (int i = 1; i < m; i++) { b[i] = (b[i] + b[i - 1]) % c; } for (int i = 0; i < n; i++) { int f = max(0, m - (n - i)); int t = min(i, m - 1); int s = b[t] - (f == 0 ? 0 : b[f - 1]); s = (s % c + c) % c; a[i] = (a[i] + s) % c; cout << a[i] << ; } return 0; }
#include <bits/stdc++.h> using namespace std; int n, a[22][1 << 18], b[22][1 << 18], c[1 << 18], ans[1 << 18]; int M1, M2, M3, M4, N1, N2; int add(int x, int y) { return (x + y) & M1; } int mult(int x, int y) { int z = 0; int xx = x & N1; xx |= xx << 1; z = xx & y; xx = x & N2; xx |= xx >> 1; z ^= (xx & y) << 1; return z & M1; } int zeta(int* a) { int i, j, k; for (i = 0; i < n; i++) { if (i < 3) { for (j = 0; j < (1 << max(n - 3, 0)); j++) { if (i == 0) a[j] = add(a[j], (a[j] & M2) << 4); else if (i == 1) a[j] = add(a[j], (a[j] & M3) << 8); else a[j] = add(a[j], (a[j] & M4) << 16); } } else { for (j = 0; j < (1 << (n - 3)); j += (1 << (i - 2))) { for (k = 0; k < (1 << (i - 3)); k++) a[j ^ k ^ (1 << (i - 3))] = add(a[j ^ k ^ (1 << (i - 3))], a[j ^ k]); } } } return 0; } int main() { int i; scanf( %d n , &n); for (i = 0; i < (1 << n); i++) a[__builtin_popcount(i)][i >> 3] |= ((getchar() - 0 ) << ((i & 7) << 2)); getchar(); for (i = 0; i < (1 << n); i++) b[__builtin_popcount(i)][i >> 3] |= ((getchar() - 0 ) << ((i & 7) << 2)); int j, k; for (i = 0; i < 32; i++) { if ((i & 3) < 2) M1 |= (1 << i); if ((i & 7) < 4) M2 |= (1 << i); if ((i & 15) < 8) M3 |= (1 << i); if ((i & 31) < 16) M4 |= (1 << i); if ((i & 3) == 0) N1 |= (1 << i); if ((i & 3) == 1) N2 |= (1 << i); } for (i = 0; i <= n; i++) zeta(a[i]), zeta(b[i]); for (i = 0; i <= n; i++) { memset(c, 0, sizeof(c)); for (j = 0; j <= i; j++) { for (k = 0; k < (1 << max(n - 3, 0)); k++) c[k] = add(c[k], mult(a[j][k], b[i - j][k])); } for (j = 0; j < (1 << n); j++) { if (__builtin_popcount(j) & 1) { if (c[j >> 3] & (1 << ((j & 7) << 2))) c[j >> 3] ^= (2 << ((j & 7) << 2)); } } zeta(c); for (j = 0; j < (1 << n); j++) { if (__builtin_popcount(j) & 1) { if (c[j >> 3] & (1 << ((j & 7) << 2))) c[j >> 3] ^= (2 << ((j & 7) << 2)); } if (__builtin_popcount(j) == i) ans[j >> 3] ^= c[j >> 3] & (3 << ((j & 7) << 2)); } } for (i = 0; i < (1 << n); i++) printf( %d , (ans[i >> 3] >> ((i & 7) << 2)) & 3); printf( n ); return 0; }
#include <bits/stdc++.h> using namespace std; long long score(long long a, long long b) { if (a == b) return 0; else if ((a == 3 && b == 2) || (a == 2 && b == 1) || (a == 1 && b == 3)) return 1; else return 0; } int main(void) { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); long long k, a, b, ca, cb, ncl, cl, csa, csb, pa, pb; long long d[4][4][4] = {}; long long ch[4][4][4]; long long sc[100][2] = {}; cin >> k >> a >> b; for (long long k = 1; k <= 2; k++) for (long long i = 1; i <= 3; i++) for (long long j = 1; j <= 3; j++) cin >> ch[i][j][k]; d[a][b][0] = 1; d[a][b][1] = score(a, b); d[a][b][2] = score(b, a); sc[1][0] = score(a, b); sc[1][1] = score(b, a); ca = a; cb = b; while (true) { long long na, nb; na = ch[ca][cb][1]; nb = ch[ca][cb][2]; if (d[na][nb][0] == 0) { d[na][nb][0] = d[ca][cb][0] + 1; d[na][nb][1] = d[ca][cb][1] + score(na, nb); d[na][nb][2] = d[ca][cb][2] + score(nb, na); sc[d[na][nb][0]][0] = d[na][nb][1]; sc[d[na][nb][0]][1] = d[na][nb][2]; ca = na; cb = nb; } else { ncl = d[na][nb][0] - 1; cl = d[ca][cb][0] - d[na][nb][0] + 1; csa = d[ca][cb][1] - d[na][nb][1] + score(na, nb); csb = d[ca][cb][2] - d[na][nb][2] + score(nb, na); break; } } if (k <= ncl) { pa = sc[k][0]; pb = sc[k][1]; } else { long long km = (k - ncl) % cl; pa = sc[ncl + km][0] + ((k - ncl) / cl) * csa; pb = sc[ncl + km][1] + ((k - ncl) / cl) * csb; } cout << pa << << pb << endl; return 0; }
#include <bits/stdc++.h> using namespace std; bool sortin(const pair<long long int, long long int> &e, const pair<long long int, long long int> &f) { return (e.first < f.first); } long long int i, j, k, l, m, n, c, p, q, ts, mn = 10e17; long long int a[200002], b[200002], x[200002]; int main() { { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); }; cin >> n; cin >> m; l = n - m; string s, t, u, v; cin >> s; cin >> t; v = s; for (long long int i = 0; i <= n - 1; i++) u += a ; for (long long int i = 0; i <= n - 1; i++) { if (!l) break; if (s[i] == t[i]) u[i] = s[i], v[i] = . , l--; else u[i] = a ; } if (l) { for (long long int i = 0; i <= n - 1; i++) { if (v[i] == . ) continue; if (c % 2) u[i] = s[i], v[i] = . ; else u[i] = t[i], v[i] = . ; c++; if (c % 2 == 0) l--; if (!l) break; } } if (l) { cout << -1; return 0; } for (long long int i = 0; i <= n - 1; i++) { if (v[i] == . ) { if (s[i] != u[i]) p++; if (t[i] != u[i]) q++; continue; } if (s[i] == a ) { u[i] = b ; if (t[i] == b ) u[i] = c ; } else if (t[i] == a ) { u[i] = b ; if (s[i] == b ) u[i] = c ; } if (s[i] != u[i]) p++; if (t[i] != u[i]) q++; } if (p != m || q != m) { cout << -1; return 0; } cout << u; }
#include <bits/stdc++.h> using namespace std; const long long N = 100000 + 10; long long n, K, a[N], b[N]; struct Node { long long v, id; } p[N]; bool cmp(Node x, Node y) { return x.v > y.v; } long long get(long long x, long long v) { return -3ll * (x * x + x) + v + 1; } long long func(long long v, long long y) { long long l = 0, r = v, mid, ret = 0; while (l <= r) { mid = (l + r) >> 1ll; if (get(mid, v) >= y) ret = mid, l = mid + 1; else r = mid - 1; } return ret; } long long calc(long long y) { long long sum = 0; for (long long i = 1; i <= n; ++i) sum += func(a[i], y); return sum; } long long ans, sum; void solve() { long long l = -4e18, r = 1e18, mid; while (l <= r) { mid = (l + r) >> 1ll; if (calc(mid) <= K) ans = mid, r = mid - 1; else l = mid + 1; } } signed main() { scanf( %lld%lld , &n, &K); for (long long i = 1; i <= n; ++i) scanf( %lld , &a[i]); solve(); sum = 0; for (long long i = 1; i <= n; ++i) { b[i] = func(a[i], ans); sum += b[i]; p[i].v = get(b[i], a[i]); p[i].id = i; } sort(p + 1, p + n + 1, cmp); for (long long i = 1; i <= n; ++i) if (sum < K && a[p[i].id] > b[p[i].id]) sum++, b[p[i].id]++; for (long long i = 1; i <= n; ++i) printf( %lld , b[i]); return 0; }
#include <bits/stdc++.h> using namespace std; long long arr[6]; int main() { for (int i = 0; i < 6; ++i) { cin >> arr[i]; } long long res = 0; for (int i = 0; i < 3; ++i) { res += arr[i]; } res *= res; for (int i = 0; i < 6; i += 2) { res -= arr[i] * arr[i]; } cout << res; }
#include <bits/stdc++.h> using namespace std; signed solve(); signed main() { ios_base::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr); int tests = 1; while (tests--) solve(); return 0; } signed solve() { int n, k; cin >> n >> k; if (n <= 1ll * k * (k - 1)) { cout << YES n ; for (int i = 0; i < n; ++i) { cout << (i % k) + 1 << << (i / k + i % k + 1) % k + 1 << n ; } } else { cout << NO n ; } return 0; }
#include <bits/stdc++.h> using namespace std; template <typename A, typename B> ostream &operator<<(ostream &os, const pair<A, B> &p) { return os << ( << p.first << , << p.second << ) ; } template <typename T_container, typename T = typename enable_if< !is_same<T_container, string>::value, typename T_container::value_type>::type> ostream &operator<<(ostream &os, const T_container &v) { os << { ; string sep; for (const T &x : v) os << sep << x, sep = , ; return os << } ; } void dbg_out() { cerr << endl; } template <typename Head, typename... Tail> void dbg_out(Head H, Tail... T) { cerr << << H; dbg_out(T...); } const int MAX_N = 1e5 + 5; const long long MOD = 1e9 + 7; const long long INF = 1e9; const long double EPS = 1e-9; void solve() { string str; cin >> str; int len = ((int)str.size()); if (len & 1) cout << NO << endl; else { for (int i = 0; i < len / 2; ++i) { if (str[i] != str[i + len / 2]) { cout << NO << endl; return; } } cout << YES << endl; } } int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); int tc = 1; cin >> tc; for (int t = 1; t <= tc; t++) { solve(); } }
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; int a[123456]; int avg[123456]; for (int i = 0; i < n; i++) cin >> a[i]; long long count = 0; for (int i = 0; i < n; i++) count += a[i]; int Max = count / n; int rem = count % n; long long c = 0; for (int i = 0; i < n; i++) avg[i] = Max; sort(a, a + n); for (int i = n - 1; i >= 0; i--) { if (!rem) continue; avg[i]++; rem--; } for (int i = 0; i < n; i++) if (a[i] > avg[i]) c += a[i] - avg[i]; cout << c << endl; return 0; }
#include <bits/stdc++.h> using std::min; const int MAXL = 3000000 + 9, MAXM = 5000 + 9, M = 4194304; int tr[M + M]; int ask(int k) { int i; for (i = 1; i < M;) if (k > tr[i + i]) { k -= tr[i + i]; i += i + 1; } else i += i; return i - M; } void change(int u, int v) { for (u += M; u; u >>= 1) tr[u] += v; } int l[MAXM], r[MAXM]; int fa[MAXL]; char s[MAXL], ans[MAXL]; int main() { int k, m, i, j, t, tot; int ll, rr, ori; char *p; scanf( %s%d%d , s + 1, &k, &m); for (i = 1; i <= m; ++i) scanf( %d%d , l + i, r + i); for (i = 1; i <= k; ++i) change(i, 1); tot = k; for (i = m; i; --i) { if (r[i] + 1 > tot) continue; ll = r[i] - l[i] + 1; rr = min(tot, r[i] + ll); for (j = 1; j <= rr - r[i]; ++j) { m = ll >> 1; ori = j <= m ? l[i] - 1 + j + j : l[i] - 2 + 2 * (j - m); fa[t = ask(r[i] + 1)] = ask(ori); change(t, -1); } tot -= rr - r[i]; } p = s; for (i = 1; i <= k; ++i) ans[i] = fa[i] ? ans[fa[i]] : *++p; puts(ans + 1); return 0; }
#include <bits/stdc++.h> using namespace std; inline int sn() { int n = 0; int ch = getchar(); while (ch < 48) ch = getchar(); while (ch > 47) n = (n << 3) + (n << 1) + ch - 0 , ch = getchar(); return n; } double dp[2005][2005]; int main() { int i, j, n, t; double p; scanf( %d %lf %d , &n, &p, &t); dp[0][0] = 1; for (i = 1; i <= t; i++) { dp[i][0] = pow(1 - p, i); dp[i][n] = dp[i - 1][n] + dp[i - 1][n - 1] * p; for (j = 1; j <= n - 1; j++) { dp[i][j] = dp[i - 1][j] * (1 - p) + dp[i - 1][j - 1] * p; } } double ans = 0; for (i = 1; i <= n; i++) { ans = ans + i * dp[t][i]; } printf( %0.6lf , ans); return 0; }
#include <bits/stdc++.h> #pragma GCC optimize( O3 ) using namespace std; const double EPS = 1e-8; const int mod = 1e9 + 7; const int N = 3e6 + 10; const long long INF = 1e18; long long power(long long x, long long y) { long long t = 1; while (y > 0) { if (y % 2) y -= 1, t = t * x % mod; else y /= 2, x = x * x % mod; } return t; } long long dis[N]; vector<pair<long long, long long> > G[N]; int n, s, q; void make(int C, int s, int e) { if (s == e) { G[C + n].push_back(make_pair(s, 0)); G[s].push_back(make_pair(C + n + 6 * n, 0)); return; } int m = (s + e) >> 1; make(C * 2, s, m); make(C * 2 + 1, m + 1, e); G[C + n].push_back(make_pair(C * 2 + n, 0)); G[C + n].push_back(make_pair(C * 2 + 1 + n, 0)); G[C * 2 + n + 6 * n].push_back(make_pair(C + n + 6 * n, 0)); G[C * 2 + 1 + n + 6 * n].push_back(make_pair(C + n + 6 * n, 0)); } void upd1(int C, int S, int E, int s, int e, int v, int w) { if (s > E || e < S) return; if (s <= S && E <= e) { G[v].push_back(make_pair(C + n, w)); return; } int m = (S + E) >> 1; upd1(C * 2, S, m, s, e, v, w); upd1(C * 2 + 1, m + 1, E, s, e, v, w); } void upd2(int C, int S, int E, int s, int e, int v, int w) { if (s > E || e < S) return; if (s <= S && E <= e) { G[C + n + 6 * n].push_back(make_pair(v, w)); return; } int m = (S + E) >> 1; upd2(C * 2, S, m, s, e, v, w); upd2(C * 2 + 1, m + 1, E, s, e, v, w); } priority_queue<pair<long long, long long> > P; int main() { scanf( %d%d%d , &n, &q, &s); s--; make(1, 0, n - 1); for (int i = 0; i < q; ++i) { int c; scanf( %d , &c); if (c == 1) { int v, u, w; scanf( %d%d%d , &v, &u, &w); v--; u--; G[v].push_back(make_pair(u, w)); } else if (c == 2) { int v, l, r, w; scanf( %d%d%d%d , &v, &l, &r, &w); v--; l--; r--; upd1(1, 0, n - 1, l, r, v, w); } else { int v, l, r, w; scanf( %d%d%d%d , &v, &l, &r, &w); v--; l--; r--; upd2(1, 0, n - 1, l, r, v, w); } } for (int i = 0; i < N; ++i) dis[i] = INF; dis[s] = 0; P.push(make_pair(0, s)); while (!P.empty()) { pair<long long, long long> nx = P.top(); P.pop(); nx.first = -nx.first; if (dis[nx.second] < nx.first) continue; for (int i = 0; i < G[nx.second].size(); ++i) { long long cst = nx.first + G[nx.second][i].second; int v = G[nx.second][i].first; if (dis[v] > cst) { dis[v] = cst; P.push(make_pair(-cst, v)); } } } for (int i = 0; i < n; ++i) { if (dis[i] >= INF) dis[i] = -1; printf( %lld%c , dis[i], (i + 1 == n) ? n : ); } return 0; }
#include <bits/stdc++.h> using namespace std; inline long long read() { char ch = getchar(); long long p = 1, data = 0; while (ch < 0 || ch > 9 ) { if (ch == - ) p = -1; ch = getchar(); } while (ch >= 0 && ch <= 9 ) { data = data * 10 + (ch ^ 48); ch = getchar(); } return p * data; } inline long long qpow(long long a, long long b) { long long r = 1; while (b) { if (b & 1) r = a * r; a = a * a; b >>= 1; } return r; } inline long long gcd(long long a, long long b) { while (b ^= a ^= b ^= a %= b) ; return a; } inline long long lcm(long long a, long long b) { return a * b / gcd(a, b); } void exgcd(long long a, long long b, long long &x, long long &y) { if (!b) x = 1, y = 0; else { exgcd(b, a % b, y, x); y -= x * (a / b); } } const int mod = 1e9 + 7, maxn = 1e5 + 5; char s[maxn], ans1[maxn], ans2[maxn]; int num[10]; int main() { scanf( %s , s + 1); int n = strlen(s + 1); for (int i = 1; i <= n; i++) num[s[i] - 0 ]++; int m = n; int mx = 0, t1 = 0, t2 = 0; for (int i = 1; i <= 5; i++) { int t = 10 - i, now = 0; if (!num[i] || !num[t]) continue; int tn[10][2]; for (int j = 0; j <= 9; j++) tn[j][1] = tn[j][0] = num[j]; tn[i][1]--, tn[t][0]--; for (int j = 0; j <= 9; j++) now += min(tn[j][1], tn[9 - j][0]); if (now >= mx) { t1 = i; t2 = t; mx = now; } } int tn[10][2]; for (int j = 0; j <= 9; j++) tn[j][1] = tn[j][0] = num[j]; int pre = 0; if (t1 || t2) { pre = 1; ans1[m] = t1 + 0 ; ans2[m] = t2 + 0 ; tn[t1][0]--; tn[t2][1]--; m--; } int flag = 0; for (int i = m; i >= 1 + flag; i--) { int OK = 0, f1 = 0, f2 = 0; if (mx) { mx--; for (int j = 0; j <= 9; j++) if (min(tn[j][0], tn[9 - j][1])) { tn[j][0]--; tn[9 - j][1]--; f1 = j; f2 = 9 - j; ans1[i] = j + 0 ; ans2[i] = 9 - j + 0 ; OK = 1; break; } pre = 1; } else { if (pre) { int vis[10][2]; for (int j = 0; j <= 9; j++) if (tn[j][0] && tn[9 - j][1]) vis[j][0] = vis[9 - j][1] = 1; int ok = 0; for (int j = 0; j <= 9; j++) if (tn[j][0] && !vis[j][0]) { f1 = j; ans1[i] = j + 0 ; ok++; break; } for (int j = 0; j <= 9; j++) if (tn[j][1] && !vis[j][1]) { f2 = j; ans2[i] = j + 0 ; ok++; break; } if (ok != 2) { ok = 0; for (int j = 0; j <= 9; j++) if (tn[j][0]) { f1 = j; ans1[i] = j + 0 ; ok++; break; } for (int j = 0; j <= 9; j++) if (tn[j][1]) { f2 = j; ans2[i] = j + 0 ; ok++; break; } } tn[f1][0]--; tn[f2][1]--; } else { int ok = 0; for (int j = 0; j <= 9; j++) { if (j == 0 && tn[j][0] && tn[j][1]) { f1 = 0, f2 = 0, ok = 1, OK = 1; tn[j][0]--, tn[j][1]--; ans1[i] = 0 , ans2[i] = 0 ; break; } else if (j != 0 && tn[j][0] && tn[10 - j][1]) { f1 = j, f2 = 10 - j, ok = 1, OK = 1; tn[j][0]--, tn[10 - j][1]--; ans1[i] = f1 + 0 , ans2[i] = f2 + 0 ; break; } } if (!ok) { for (int j = 0; j <= 9; j++) if (tn[j][0]) { tn[j][0]--; ans1[i] = j + 0 ; f1 = j; ok++; break; } for (int j = 0; j <= 9; j++) if (tn[j][1]) { tn[j][1]--; ans2[i] = j + 0 ; f2 = j; ok++; break; } } if (ok == 2) OK = 1; } pre = (f1 + f2 + 1 >= 10 ? 1 : 0); } if (f1 == 0 && f2 == 0) { flag++; i++; } } printf( %s , ans1 + flag + 1); for (int i = 1; i <= flag; i++) printf( 0 ); puts( ); printf( %s , ans2 + flag + 1); for (int i = 1; i <= flag; i++) printf( 0 ); return 0; }
#include <bits/stdc++.h> using namespace std; const int mx = 1e6; int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); int t; cin >> t; while (t--) { long long n, h; cin >> h >> n; long long arr[n]; for (int i = 0; i < n; i++) cin >> arr[i]; long long ans = 0, cp = h; for (int i = 1; i < n; i++) { if (cp == 0) break; if (cp == (arr[i] + 1)) { if ((i + 1) < n && cp == (arr[i + 1] + 2)) { cp = arr[i + 1]; ++i; } else { if ((i + 1) < n) { cp = arr[i + 1] + 1; ++ans; } else if (i == n - 1) { if (cp == 2) continue; else ++ans; } } } else { cp = arr[i] + 1; --i; } } cout << ans << endl; } }
#include <bits/stdc++.h> using namespace std; const int MAXN = 220000; const int MAXM = 2 * MAXN; const int MAXS = 26; struct SAM { struct Node { int nxt[MAXS], par; int len, siz; } st[MAXM]; int m, root, lst; inline int newNode(int l) { int x = ++m; memset(st[x].nxt, 0, sizeof st[x].nxt); st[x].par = 0; st[x].len = l; st[x].siz = 0; return x; } void extend(char c, bool k) { int x = c - a ; int p = lst, np = newNode(st[p].len + 1); lst = np; st[np].siz = k; while (p && !st[p].nxt[x]) st[p].nxt[x] = np, p = st[p].par; if (!p) { st[np].par = root; return; } int q = st[p].nxt[x]; if (st[q].len == st[p].len + 1) { st[np].par = q; return; } int nq = newNode(st[p].len + 1); memcpy(st[nq].nxt, st[q].nxt, sizeof st[q].nxt); st[nq].par = st[q].par; st[np].par = st[q].par = nq; while (p && st[p].nxt[x] == q) st[p].nxt[x] = nq, p = st[p].par; } void build(int n, char* s, char* t) { static int c[MAXN], d[MAXM]; m = 0; lst = root = newNode(0); for (int i = 0; i < n; i++) extend(s[i], t[i] ^ 1 ); memset(c, 0, sizeof c); for (int i = 1; i <= m; i++) c[st[i].len]++; for (int i = 1; i <= n; i++) c[i] += c[i - 1]; for (int i = 1; i <= m; i++) d[c[st[i].len]--] = i; for (int i = m; i >= 2; i--) st[st[d[i]].par].siz += st[d[i]].siz; } long long query() { long long r = 0; for (int i = 1; i <= m; i++) r = max(r, 1ll * st[i].len * st[i].siz); return r; } } sam; char s[MAXN], t[MAXN]; int main() { int n; scanf( %d , &n); scanf( %s%s , s, t); sam.build(n, s, t); printf( %lld n , sam.query()); return 0; }
#include <bits/stdc++.h> using namespace std; const long long maxn = 2e6 + 100; const long long inf = 0x3f3f3f3f; const long long iinf = 1 << 30; const long long linf = 2e18; const long long mod = 998244353; const double eps = 1e-7; template <class T = long long> T chmin(T &a, T b) { return a = min(a, b); } template <class T = long long> T chmax(T &a, T b) { return a = max(a, b); } template <class T = long long> inline void red(T &x) { x -= mod, x += x >> 31 & mod; } template <class T = long long> T read() { T f = 1, a = 0; char ch = getchar(); while (!isdigit(ch)) { if (ch == - ) f = -1; ch = getchar(); } while (isdigit(ch)) { a = (a << 3) + (a << 1) + ch - 0 ; ch = getchar(); } return a * f; } long long n, sqrt_n = 300; long long ans, val; long long a[maxn], cnt[maxn], sum[maxn], t[maxn], cnt1[maxn], cnt2[maxn]; vector<long long> pos; void modify(long long x, long long pos) { cnt2[cnt1[x]]--; cnt1[x] += pos; cnt2[cnt1[x]]++; } signed main() { n = read(); for (long long i = (1); i <= (n); ++i) a[i] = read(), cnt[a[i]]++; long long maxx = 0, tot = 0, val = 0; for (long long i = (1); i <= (n); ++i) { if (cnt[i] == maxx) tot++; if (cnt[i] > maxx) tot = 1, maxx = cnt[i], val = i; } if (tot > 1) { printf( %lld n , n); return 0; } for (long long i = (1); i <= (n); ++i) if (cnt[i] > sqrt_n && i != val) pos.push_back(i); for (long long i : pos) { for (long long j = (1); j <= (n); ++j) sum[j] = sum[j - 1] + (a[j] == i ? -1 : (a[j] == val ? 1 : 0)); for (long long j = (-n); j <= (n); ++j) t[j + n] = linf; t[n] = 0; for (long long j = (1); j <= (n); ++j) { if (t[sum[j] + n] != linf) chmax(ans, j - t[sum[j] + n]); else t[sum[j] + n] = j; } } for (long long i = (1); i <= (sqrt_n); ++i) { for (long long j = (1); j <= (n); ++j) cnt1[j] = cnt2[j] = 0; long long l = 1, r = 0; while (r < n) { modify(a[++r], 1); while (cnt1[a[r]] > i) modify(a[l++], -1); if (cnt2[i] >= 2) chmax(ans, r - l + 1); } } printf( %lld n , ans); return 0; }
#include <bits/stdc++.h> using namespace std; int n, a[100005], l = -1000000000, r = 1000000000; string b; int main() { cin >> n; for (int i = 0; i < n; ++i) cin >> a[i]; cin >> b; for (int i = 4; i < n; ++i) { if (b[i] == 0 && b[i - 1] == 1 ) { int minim = a[i]; for (int j = i - 4; j < i; ++j) minim = min(minim, a[j]); r = min(r, minim - 1); } else if (b[i] == 1 && b[i - 1] == 0 ) { int maxim = a[i]; for (int j = i - 4; j < i; ++j) maxim = max(maxim, a[j]); l = max(l, maxim + 1); } } cout << l << << r << n ; return 0; }
#include <bits/stdc++.h> using namespace std; vector<vector<int>> adj; bool vis[200000 + 9]; int cntnode; map<int, int> colorcnt; int c[200000 + 9]; int mx; void dfs(int node) { if (vis[node]) { return; } cntnode++; colorcnt[c[node]]++; mx = max(mx, colorcnt[c[node]]); vis[node] = 1; for (int i = 0; i < (int)adj[node].size(); i++) { int ch = adj[node][i]; dfs(ch); } } int main() { int n, m, k; cin >> n >> m >> k; adj.resize(n); for (int i = 0; i < n; i++) { cin >> c[i]; } for (int i = 0; i < m; i++) { int x, y; cin >> x >> y; adj[x - 1].push_back(y - 1); adj[y - 1].push_back(x - 1); } int sum = 0; for (int i = 0; i < n; i++) { cntnode = 0; colorcnt.clear(); mx = 0; if (!vis[i]) { dfs(i); } sum += (cntnode - mx); } cout << sum; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int m, n; cin >> m >> n; cout << min(m, n) + 1 << endl; for (int i = 0; i <= min(m, n); i++) { cout << i << << (min(m, n) - i) << endl; } }
#include <bits/stdc++.h> using namespace std; struct vertex { long long inside, edge; int size = 1; vector<int> child; }; int ans = 0; multiset<long long> st; vertex g[100009]; void dfs(int v, bool flag, long long deep) { if (flag) { for (int i = 0; i < g[v].child.size(); i++) { dfs(g[v].child[i], 1, 0); g[v].size += g[g[v].child[i]].size; } return; } if (deep - g[v].inside > *st.begin()) flag = 1; st.insert(deep); for (int i = 0; i < g[v].child.size(); i++) { dfs(g[v].child[i], flag, deep + g[g[v].child[i]].edge); g[v].size += g[g[v].child[i]].size; } if (flag) ans += g[v].size; flag = 0; st.erase(deep); } int main() { ios_base::sync_with_stdio(0); int n; st.insert(100000000000000000); cin >> n; for (int i = 1; i <= n; i++) cin >> g[i].inside; for (int i = 2, c; i <= n; i++) { cin >> c >> g[i].edge; g[c].child.push_back(i); } dfs(1, 0, 0); cout << ans; return 0; }
#include <bits/stdc++.h> using namespace std; int n, a[100001], b[100001], c[100001], x; map<int, int> a1, b1, c1; int main() { srand(time(NULL)); cin >> n; for (int i = 1; i <= n; ++i) cin >> a[i], a1[a[i]]++; for (int i = 1; i < n; ++i) cin >> b[i], b1[b[i]]++, a1[b[i]]--; for (int i = 1; i < n - 1; ++i) cin >> c[i], b1[c[i]]--; for (int i = 1; i <= n; ++i) if (a1[a[i]] != 0) cout << a[i] << endl, a1[a[i]]--; for (int i = 1; i < n; ++i) if (b1[b[i]] != 0) cout << b[i], b1[b[i]]--; }
#include <bits/stdc++.h> using namespace std; const long long MOD = 1000000007; const double pi = 3.141593; int main() { ios::sync_with_stdio(false); int n, t = 0, ans = 0; map<int, int> m; cin >> n; for (int i = 0; i < 2 * n; i++) { int x; cin >> x; m[x]++; t++; if (m[x] == 2) t -= 2; ans = max(ans, t); } cout << ans; }
#include <bits/stdc++.h> using namespace std; template <class c> struct rge { c b, e; }; template <class c> rge<c> range(c i, c j) { return rge<c>{i, j}; } template <class c> auto dud(c* x) -> decltype(cerr << *x, 0); template <class c> char dud(...); struct debug { template <class c> debug& operator<<(const c&) { return *this; } }; int main() { int n, m; cin >> n >> m; vector<vector<pair<int, int>>> mat(m, vector<pair<int, int>>(3)); set<int> white, red, blue; for (int i = 0; i < m; i++) { int x, y, z; cin >> x >> y >> z; mat[i][0].first = x; mat[i][1].first = y; mat[i][2].first = z; bool xWhite = (white.find(x) != white.end()); bool xRed = (red.find(x) != red.end()); bool xBlue = (blue.find(x) != blue.end()); bool yWhite = (white.find(y) != white.end()); bool yRed = (red.find(y) != red.end()); bool yBlue = (blue.find(y) != blue.end()); bool zWhite = (white.find(z) != white.end()); bool zRed = (red.find(z) != red.end()); bool zBlue = (blue.find(z) != blue.end()); if (xWhite) { white.insert(x); red.insert(y); blue.insert(z); } else if (xRed) { red.insert(x); white.insert(y); blue.insert(z); } else if (xBlue) { blue.insert(x); white.insert(y); red.insert(z); } else if (yWhite) { white.insert(y); red.insert(x); blue.insert(z); } else if (yRed) { red.insert(y); white.insert(x); blue.insert(z); } else if (yBlue) { blue.insert(y); white.insert(x); red.insert(z); } else if (zWhite) { white.insert(z); red.insert(x); blue.insert(y); } else if (zRed) { red.insert(z); blue.insert(x); white.insert(y); } else if (zBlue) { blue.insert(z); red.insert(x); white.insert(y); } else { debug() << [ << x : << (x) << ] [ << y : << (y) << ] [ << z : << (z) << ] ; white.insert(x); red.insert(y); blue.insert(z); } } for (int i = 1; i <= n; i++) { if (white.find(i) != white.end()) { cout << 1 ; } else if (red.find(i) != red.end()) { cout << 2 ; } else { cout << 3 ; } } cout << n ; }
#include <bits/stdc++.h> using namespace std; using ll = long long; template<typename A, typename B = A> using pr = pair<A, B>; #define vec vector #define ar array #define len(a) ((int)((a).size())) #define all(a) (a).begin(), (a).end() int q; vec<int> used; int timer; inline void merge(vec<pr<int>> &a, vec<pr<int>> &b, vec<pr<int>> &res) { timer++; int j = 0; auto insert = [&](pr<int> p) { if (used[p.first] == timer) return; used[p.first] = timer; res.push_back(p); }; for (int i = 0; i < len(a); i++) { while (len(res) <= q && j < len(b) && b[j].second >= a[i].second) { insert(b[j]); j++; } if (len(res) <= q) insert(a[i]); else break; } while (len(res) <= q && j < len(b)) { insert(b[j]); j++; } } struct my_stack { vec<pr<vec<pr<int>>>> st; my_stack() {} inline void pop_back() { assert(len(st)); st.pop_back(); } inline void push_back(vec<pr<int>> &a) { if (!len(st)) { st.emplace_back(a, a); return; } st.emplace_back(vec<pr<int>>{}, a); merge(st.end()[-2].first, a, st.back().first); } inline void rev() { assert(len(st)); reverse(all(st)); st[0].first = st[0].second; for (int i = 1; i < len(st); i++) { st[i].first.clear(); merge(st[i].second, st[i - 1].first, st[i].first); } } inline int get_min() { assert(len(st)); if (len(st.back().first) <= q) return -1; return st.back().first.back().second; } }; struct my_queue { my_stack front, back; my_queue() {} inline void pop() { if (!len(front.st)) { swap(front, back); front.rev(); } front.pop_back(); } inline void push(vec<pr<int>> &a) { back.push_back(a); } inline int get_min() { assert(len(front.st) + len(back.st)); if (!len(front.st)) return back.get_min(); if (!len(back.st)) return front.get_min(); vec<pr<int>> cur; merge(front.st.back().first, back.st.back().first, cur); if (len(cur) <= q) return -1; return cur.back().second; } }; int main() { ios::sync_with_stdio(false), cin.tie(nullptr); int n; cin >> n >> q; vec<vec<int>> a(n, vec<int>(n)); for (auto &xs : a) for (auto &x : xs) cin >> x; vec<vec<pr<int>>> left(n); used.resize(n * n + 1); vec<int> ans(n); for (int j = 0; j < n; j++) { my_queue que; int prev = 0; for (int i = 0; i < n; i++) { vec<pr<int>> nleft{{a[i][j], j}}; for (auto [x, pos] : left[i]) if (x != a[i][j] && len(nleft) <= q) nleft.emplace_back(x, pos); left[i] = nleft; que.push(left[i]); while (que.get_min() >= j - (i - prev)) { que.pop(); prev++; } // cerr << i << << j << : << i - prev << endl; ans[i - prev]++; } } for (int i = n - 2; i >= 0; i--) ans[i] += ans[i + 1]; for (auto x : ans) cout << x << n ; }
#include <bits/stdc++.h> using namespace std; void solve() { int n; string s, t, ss; cin >> n >> s; ss = s; t = abacaba ; int cnt = 0; for (int i = 0; i < n - 6; i++) { int j, k = 0; for (j = i; j < i + 7; j++) { if (s[j] != t[k]) break; k++; } if (j == i + 7) cnt++; } if (cnt == 1) { cout << Yes << n ; for (int i = 0; i < n; i++) { if (s[i] == ? ) s[i] = z ; } cout << s << n ; } else if (cnt > 1) { cout << No << n ; return; } else { cnt = 0; for (int i = 0; i < n - 6; i++) { cnt = 0; int j, k = 0; for (j = i; j < i + 7; j++) { if (s[j] != t[k] && s[j] != ? ) break; s[j] = t[k]; k++; } if (j == i + 7) { for (int x = 0; x < n - 6; x++) { int y, z = 0; for (y = x; y < x + 7; y++) { if (s[y] != t[z]) break; z++; } if (y == x + 7) cnt++; } if (cnt == 1) { cout << Yes << n ; for (int i = 0; i < n; i++) { if (s[i] == ? ) s[i] = z ; } cout << s << n ; return; } else { for (int i = 0; i < n; i++) s[i] = ss[i]; } } else { for (int i = 0; i < n; i++) s[i] = ss[i]; } } cout << No << n ; } } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); long long tt; cin >> tt; while (tt--) solve(); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(0); int n; cin >> n; vector<int> id(n + 1); for (int i = 0; i < n; i++) { int x; cin >> x; id[x] = i; } vector<int> dp(n + 1, 1); for (int i = 2; i <= n; i++) { if (id[i] > id[i - 1]) { dp[i] += dp[i - 1]; } } cout << n - *max_element(dp.begin(), dp.end()); }
#include <bits/stdc++.h> using namespace std; const long long MOD = 998244353; long long dp[1010][2100][4]; int main() { int n, k; scanf( %d%d , &n, &k); dp[1][1][0] = 1, dp[1][2][1] = 1, dp[1][2][2] = 1, dp[1][1][3] = 1; for (int i = 2; i <= n; i++) { for (int j = 1; j <= k; j++) { dp[i][j][0] = (dp[i - 1][j][0] + dp[i - 1][j][1] + dp[i - 1][j][2] + dp[i - 1][j - 1][3]) % MOD; dp[i][j][1] = (dp[i - 1][j - 1][0] + dp[i - 1][j][1] + dp[i - 1][j - 1][3]) % MOD; if (j >= 2) dp[i][j][1] = (dp[i][j][1] + dp[i - 1][j - 2][2]) % MOD; dp[i][j][2] = (dp[i - 1][j - 1][0] + dp[i - 1][j][2] + dp[i - 1][j - 1][3]) % MOD; if (j >= 2) dp[i][j][2] = (dp[i][j][2] + dp[i - 1][j - 2][1]) % MOD; dp[i][j][3] = (dp[i - 1][j - 1][0] + dp[i - 1][j][1] + dp[i - 1][j][2] + dp[i - 1][j][3]) % MOD; } } printf( %lld n , (dp[n][k][0] + dp[n][k][1] + dp[n][k][2] + dp[n][k][3]) % MOD); }
#include<bits/stdc++.h> #define fo(i,a,b) for(int i=a;i<=b;i++) #define fd(i,a,b) for(int i=a;i>=b;i--) using namespace std; typedef long long LL; typedef pair<int,int> pr; const int maxn=505; int n,m; char mp[maxn][maxn]; int T; int main() { scanf( %d ,&T); while (T--) { scanf( %d %d ,&n,&m); fo(i,1,n) scanf( %s ,mp[i]+1); fo(i,1,n) if (i%3==1) fo(j,1,m) mp[i][j]= X ; fo(i,1,n) if (i%3==1 && i+3<=n) { bool pd=0; fo(j,1,m) if (mp[i+1][j]== X ) { mp[i+2][j]= X ; pd=1; break; } if (pd) continue; fo(j,1,m) if (mp[i+2][j]== X ) { mp[i+1][j]= X ; pd=1; break; } if (pd) continue; mp[i+1][1]=mp[i+2][1]= X ; } if (n%3==0) { fo(j,1,m) if (mp[n][j]== X ) mp[n-1][j]= X ; } fo(i,1,n) printf( %s n ,mp[i]+1); } }
#include <bits/stdc++.h> using namespace std; template <class T> inline T sqr(T x) { return x * x; } const double EPS = 1e-6; const int INF = 0x3fffffff; const long long LINF = INF * 1ll * INF; const double PI = acos(-1.0); using namespace std; char g[505][505]; int cnt[505]; int dp[2][505][505]; int C[505][505]; int mod; void Add(int &ans, int v) { ans += v; if (ans >= mod) ans -= mod; } int main(void) { int n, m; scanf( %d %d %d , &n, &m, &mod); C[0][0] = 1; for (int i = 1; i <= n; i++) { C[i][0] = 1; for (int j = 1; j <= i; j++) C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod; } for (int i = 0; i < (m); ++i) { scanf( %s , g[i]); for (int j = 0; j < (n); ++j) cnt[j] += g[i][j] - 0 ; } int cnt0 = 0, cnt1 = 0; for (int i = 0; i < (n); ++i) { if (cnt[i] > 2) { puts( 0 ); return 0; } if (cnt[i] == 1) cnt1++; else if (cnt[i] == 0) cnt0++; } int now = 0; dp[now][cnt0][cnt1] = 1; for (int i = m; i < n; i++) { memset(dp[now ^ 1], 0, sizeof(dp[now ^ 1])); for (int j = 0; j <= n; j++) { for (int k = 0; k + j <= n; k++) { if (dp[now][j][k] == 0) continue; if (j >= 2) Add(dp[now ^ 1][j - 2][k + 2], 1ll * C[j][2] * dp[now][j][k] % mod); if (k >= 2) Add(dp[now ^ 1][j][k - 2], 1ll * C[k][2] * dp[now][j][k] % mod); if (j && k) Add(dp[now ^ 1][j - 1][k], 1ll * C[k][1] * C[j][1] % mod * dp[now][j][k] % mod); } } now ^= 1; } printf( %d n , dp[now][0][0]); return 0; }
#include <bits/stdc++.h> using namespace std; const int MAXN = 21; const long long MOD = 1000000007; int n; long long m; long long C[MAXN][MAXN]; long long g[MAXN], s[MAXN], ten[MAXN], eight[MAXN]; inline void update(long long& x, long long y) { y %= MOD, x += y, x %= MOD; } inline long long P(const long long& x, int y) { if (x < y) return 0; long long res = 1; for (long long i = x; i >= x - y + 1; --i) res = (res * i) % MOD; return res; } inline pair<int, int> get(long long num, int x) { int res4 = 0, res7 = 0; for (int i = 1; i <= x; ++i) num /= 10; for (long long i = num; i > 0; i /= 10) if (i % 10 == 4) res4++; else if (i % 10 == 7) res7++; return pair<int, int>(res4, res7); } inline long long F(const long long& num, int x, int a, int b) { pair<int, int> p = get(num, x); a -= p.first, b -= p.second; if (a < 0 || b < 0 || a + b > x) return 0; return (((C[x][a] * C[x - a][b]) % MOD) * eight[x - a - b]) % MOD; } inline long long G(long long num, int x, int a, int b) { long long res = 0; for (; num + ten[x] <= m; num += ten[x]) update(res, F(num, x, a, b)); if (x > 0) { if (num <= m) update(res, G(num, x - 1, a, b)); } else update(res, F(num, x, a, b)); return res; } inline void preProcess() { ten[0] = eight[0] = 1; for (int i = 1; i < MAXN; ++i) ten[i] = ten[i - 1] * 10, eight[i] = eight[i - 1] * 8; while (ten[n] <= m) n++; C[0][0] = 1; for (int i = 1; i < MAXN; ++i) { C[i][0] = C[i][i] = 1; for (int j = 1; j < i; ++j) C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % MOD; } for (int i = 0; i <= n; ++i) for (int j = 0; j <= i; ++j) update(g[i], G(0, n - 1, j, i - j)); g[0]--; } inline long long dp(int s, int x, int y, int z) { if (y < 0 || z < 0) return 0; if (x == s) return (y == 0) ? 1 : 0; long long res = 0; for (int i = 0; i <= y; ++i) { long long k = (C[y][i] * P(g[x], i)) % MOD; update(res, k * dp(s, x + 1, y - i, z - i * x)); } return res; } int main() { scanf( %I64d n , &m); preProcess(); long long res = 0; for (int s = 1; s <= n; ++s) update(res, g[s] * dp(s, 0, 6, s - 1)); printf( %I64d n , res); fclose(stdin); fclose(stdout); return 0; }
#include <bits/stdc++.h> #pragma GCC optimize(3) using namespace std; const int Mod = 1e9 + 7; const int N = 5e5 + 100; const int INF = 0x3f3f3f3f; const long long LINF = 0x3f3f3f3f3f3f3f3f; inline long long dpow(long long a, long long b) { long long r = 1, t = a; while (b) { if (b & 1) r = (r * t) % Mod; b >>= 1; t = (t * t) % Mod; } return r; } inline long long fpow(long long a, long long b) { long long r = 1, t = a; while (b) { if (b & 1) r = (r * t); b >>= 1; t = (t * t); } return r; } struct node { int id, w; bool operator<(const node &oth) const { return w > oth.w; } }; struct Ask { int op, x; } qi[N]; pair<int, int> eg[N]; set<node> s[N]; int fa[N], sz[N], n, m, q; int a[N]; bool vis[N]; stack<pair<int, int> > st; void Init() { for (int i = 1; i <= n; i++) fa[i] = i, sz[i] = 1; } int Find(int x) { while (x != fa[x]) x = fa[x]; return x; } void Merge(int x, int y) { x = Find(x); y = Find(y); if (x == y) { st.push({0, 0}); return; } if (sz[x] > sz[y]) swap(x, y); fa[x] = y; st.push({x, y}); sz[y] += sz[x]; for (auto it : s[x]) s[y].insert(it); } void Cancle() { int x = st.top().first, y = st.top().second; st.pop(); if (!x && !y) return; fa[x] = x; sz[y] -= sz[x]; for (auto it : s[x]) { if (s[y].find(it) != s[y].end()) s[y].erase(it); } } int main() { cin >> n >> m >> q; Init(); for (int i = 1; i <= n; i++) scanf( %d , &a[i]), s[i].insert({i, a[i]}); for (int i = 1; i <= m; i++) scanf( %d %d , &eg[i].first, &eg[i].second); for (int i = 1; i <= q; i++) { scanf( %d %d , &qi[i].op, &qi[i].x); if (qi[i].op == 2) vis[qi[i].x] = true; } for (int i = 1; i <= m; i++) if (!vis[i]) Merge(eg[i].first, eg[i].second); for (int i = q; i >= 1; i--) { if (qi[i].op == 1) continue; int u = eg[qi[i].x].first; int v = eg[qi[i].x].second; Merge(u, v); } for (int i = 1; i <= q; i++) { int op = qi[i].op, x = qi[i].x; if (op == 1) { int u = Find(x); while (!s[u].empty() && !a[s[u].begin()->id]) s[u].erase(s[u].begin()); if (s[u].empty()) puts( 0 ); else { printf( %d n , s[u].begin()->w); a[s[u].begin()->id] = 0; } } else Cancle(); } return 0; }
#include <bits/stdc++.h> using namespace std; const int Maxn = 1e6 + 1; const int Mod = 1e9 + 7; const long long int MOD = 1000000007LL; const long long int MAX = 100010LL; template <typename T> T gcd(T a, T b) { if (b == 0) return a; return gcd(b, a % b); } template <typename T> T power(T x, T y, long long int m = MOD) { T ans = 1; x %= m; while (y > 0) { if (y & 1ll) ans = (ans * x) % m; y >>= 1ll; x = (x * x) % m; } return ans % m; } template <typename T, typename T1> T mod(T x, T1 p) { x %= p; if (x < 0) x += p; return x; } void leastPrimeFactor(vector<int> &least_prime, int n) { least_prime[1] = 1; for (int i = 2; i <= n; i++) { if (least_prime[i] == 0) { least_prime[i] = i; for (int j = 2 * i; j <= n; j += i) if (least_prime[j] == 0) least_prime[j] = i; } } } bool dfs(vector<vector<int>> &graph, vector<int> &g, int i) { int prev = 0; queue<int> q; q.push(i); while (!q.empty()) { int n = q.size(); while (n--) { int t = q.front(); q.pop(); if (g[t] == -1) { g[t] = prev; for (int j : graph[t]) q.push(j); } if (g[t] != prev) return 0; } prev ^= 1; } return 1; } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); int n; cin >> n; vector<vector<int>> adj(n); vector<vector<int>> mat(n, vector<int>(n, 0)); int cnt = n; for (int j = 0; j < n; j++) { string s; cin >> s; for (int i = 0; i < s.size(); i++) if (s[i] == 1 ) adj[j].push_back(i); } int m; cin >> m; vector<int> p(m); for (int i = 0; i < m; i++) cin >> p[i], p[i]--; for (int i = 0; i < n; i++) { queue<int> q; q.push(i); int dis = 0; vector<int> vis(n, 0); vis[i] = 1; while (!q.empty()) { int nu = q.size(); while (nu--) { int no = q.front(); q.pop(); mat[i][no] = dis; for (int &ne : adj[no]) if (!vis[ne]) vis[ne] = 1, q.push(ne); } dis++; } } vector<int> ans; ans.push_back(p[0]); int i = 0; while (i < p.size()) { int next = i + 1; for (int j = 0; j < n; j++) if (i + mat[p[i]][j] < p.size() && p[i + mat[p[i]][j]] == j) next = max(next, i + mat[p[i]][j]); if (next < p.size()) ans.push_back(p[next]); i = next; } cout << ans.size() << endl; for (int &i : ans) cout << i + 1 << ; cout << endl; }
#include <bits/stdc++.h> using namespace std; int main() { int n, t; cin >> n; set<long long int> s; while (n--) { cin >> t; s.insert(t); } if (s.size() >= 4) cout << NO ; else { if (s.size() == 3) { auto it1 = s.begin(); auto it2 = it1; auto it3 = it2; it2++; it3++; it3++; if (2 * (*it2) == *it1 + *it3) cout << YES ; else cout << NO ; } else cout << YES ; } }
#include <bits/stdc++.h> using namespace std; long long exp(long long x, long long y, long long p) { long long res = 1; while (y) { if (y % 2) res = (res * x % p) % p; x = (x * x) % p; y /= 2; } return res; } long long exp(long long x, long long y) { long long res = 1; while (y) { if (y % 2) res = (res * x); x = (x * x); y /= 2; } return res; } int main() { long long a, b, c; long long sum1 = 0, sum2 = 0, sum3 = 0; long long t; cin >> t; while (t--) { cin >> a >> b >> c; sum1 += a; sum2 += b; sum3 += c; } if (!sum1 && !sum2 && !sum3) cout << YES << endl; else cout << NO << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int main(int argc, char const *argv[]) { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); int n, k, flag = 0; cin >> n >> k; if (3 * n > k) { cout << 3 * n - k << n ; } else { cout << 0 << n ; } return 0; }
#include <bits/stdc++.h> using namespace std; struct node { int a, ord; } p[10005]; int b[10005]; bool cmp(node a, node b) { return a.a < b.a; } int main() { int n; while (~scanf( %d , &n)) { memset(b, 0, sizeof(b)); for (int i = 0; i < n; i++) { scanf( %d , &p[i].a); b[p[i].a]++; p[i].ord = i + 1; } sort(p, p + n, cmp); int sum = 1; int ss[2], A = 0; int sss = -1; int flag = 1; int i; for (i = 1; i < n; i++) { if (p[i].a == p[i - 1].a) flag++; else { if (flag >= 3) { sss = p[i - 1].a; flag = -1; break; } else if (flag == 2) ss[A++] = p[i - 1].a; flag = 1; if (A == 2) { flag = -2; break; } } } if (flag >= 3) { sss = p[i - 1].a; flag = -1; } else if (flag == 2) ss[A++] = p[i - 1].a; flag = 1; if (A == 2) { flag = -2; } if (sss != -1) flag = -1; if (flag > 0) cout << NO << endl; else { cout << YES << endl; if (flag == -1) { for (int i = 0; i < 3; i++) { flag = 1; for (int j = 0; j < n; j++) { if (j != 0) printf( ); if (flag && p[j].a == sss) { if (i == 0) printf( %d %d %d , p[j].ord, p[j + 1].ord, p[j + 2].ord); else if (i == 1) printf( %d %d %d , p[j + 1].ord, p[j + 2].ord, p[j].ord); else printf( %d %d %d , p[j + 2].ord, p[j].ord, p[j + 1].ord); j += 2; flag = 0; } else printf( %d , p[j].ord); } printf( n ); } } else { for (int i = 0; i < 3; i++) { for (int j = 0; j < n; j++) { if (j != 0) printf( ); if (i == 0 && p[j].a == ss[0]) { printf( %d %d , p[j].ord, p[j + 1].ord); j++; } else if (i == 1 && p[j].a == ss[0]) { printf( %d %d , p[j + 1].ord, p[j].ord); j++; } else if (i == 2 && p[j].a == ss[1]) { printf( %d %d , p[j + 1].ord, p[j].ord); j++; } else printf( %d , p[j].ord); } printf( n ); } } } } return 0; }
#include <bits/stdc++.h> int check_year_age(int y1, int y2) { if (y1 - y2 > 18) return 2; if (y1 - y2 == 18) return 1; return 0; } bool check_month_day_age(int d1, int d2, int m1, int m2, int y1, int y2) { if (check_year_age(y1, y2) == 1) { if (m1 == m2) { if (d1 >= d2) return 1; return 0; } if (m1 > m2) return 1; return 0; } if (check_year_age(y1, y2) == 2) return 1; return 0; } bool check_day_month_year_valid(int d2, int m2, int y2) { if (m2 > 12) return 0; if (y2 % 4 != 0 || m2 != 2) { if (m2 == 2) { if (d2 > 28) return 0; } else { if (m2 == 1 || m2 == 3 || m2 == 5 || m2 == 7 || m2 == 8 || m2 == 10 || m2 == 12) { if (d2 > 31) return 0; } else if (d2 > 30) return 0; } } else if (d2 > 29) return 0; return 1; } int chartoint(char x1, char x2) { return (x1 - 0 ) * 10 + (x2 - 0 ); } char s[8]; int main() { int d1, m1, y1, d2, m2, y2; bool OK = 0; scanf( %s , s); d1 = chartoint(s[0], s[1]); m1 = chartoint(s[3], s[4]); y1 = chartoint(s[6], s[7]); scanf( %s , s); d2 = chartoint(s[0], s[1]); m2 = chartoint(s[3], s[4]); y2 = chartoint(s[6], s[7]); if (check_month_day_age(d1, d2, m1, m2, y1, y2) && check_day_month_year_valid(d2, m2, y2)) { OK = 1; } if (check_month_day_age(d1, m2, m1, d2, y1, y2) && check_day_month_year_valid(m2, d2, y2)) { OK = 1; } if (check_month_day_age(d1, y2, m1, m2, y1, d2) && check_day_month_year_valid(y2, m2, d2)) { OK = 1; } if (check_month_day_age(d1, y2, m1, d2, y1, m2) && check_day_month_year_valid(y2, d2, m2)) { OK = 1; } if (check_month_day_age(d1, d2, m1, y2, y1, m2) && check_day_month_year_valid(d2, y2, m2)) { OK = 1; } if (check_month_day_age(d1, m2, m1, y2, y1, d2) && check_day_month_year_valid(m2, y2, d2)) { OK = 1; } if (OK) printf( YES n ); else printf( NO n ); }
#include <bits/stdc++.h> using namespace std; int main() { int t; long long a, b; cin >> t; while (t--) { cin >> a >> b; long long temp = a + b; if (a - b == 1) { int flag = 0; long long i; int n = sqrt(temp); if (temp <= 1) { cout << NO << endl; continue; } if (temp <= 3) { cout << YES << endl; continue; } if (temp % 2 == 0) { cout << NO << endl; continue; } for (i = 3; i <= n + 1; i += 2) { if ((temp % (1ll * i)) == 0) { flag = 1; break; } } if (flag) cout << NO << endl; else cout << YES << endl; } else cout << NO << endl; } }
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr); ; string a; int n; cin >> a >> n; for (int i = 0; i < a.length() && n; ++i) { char x = a[i]; int y = i; for (int j = i + 1; j <= min((int)a.length() - 1, i + n) && n; ++j) if (x < a[j]) x = a[j], y = j; if (y != i) { n -= y - i; while (i != y) { swap(a[y - 1], a[y]); y--; } } } cout << a << endl; return 0; }
#include <bits/stdc++.h> using namespace std; const long long MOD = (long long)1e9 + 7; const int inf = (int)1e9 + 7; const double eps = 1e-7; const double pi = 3.14159265359; const int N = (int)1e4; const int K = 4; long long n, k; long long dp[N][K]; signed main() { scanf( %lld%lld , &n, &k); if (k == 1) printf( 1 ); if (k == 2) printf( %lld , n * (n - 1) / 2 + 1); if (k == 3) printf( %lld , n * (n - 1) * (n - 2) / 3 + n * (n - 1) / 2 + 1); if (k == 4) printf( %lld , n * (n - 1) * (n - 2) * (n - 3) / 8 * 3 + n * (n - 1) * (n - 2) / 3 + n * (n - 1) / 2 + 1); return 0; }
#include <bits/stdc++.h> using namespace std; int n, m; bool a[1001][1001]; bool used[1001][1001]; struct T { int i, j, d; T(int i, int j, int d) : i(i), j(j), d(d) {} }; int main() { cin >> n >> m; for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) { char ch; cin >> ch; if (ch == # ) a[i][j] = true; } queue<T> q; q.push(T(n, 0, 0)); used[n][0] = true; while (!q.empty()) { int i = q.front().i, j = q.front().j, d = q.front().d; q.pop(); if (i == 1) { cout << d; return 0; } if (i != 0) for (int k = 1; k <= m; k++) if (a[i][k] && !used[0][k]) { q.push(T(0, k, d + 1)); used[0][k] = true; } if (j != 0) for (int k = 1; k <= n; k++) if (a[k][j] && !used[k][0]) { q.push(T(k, 0, d + 1)); used[k][0] = true; } } cout << -1; return 0; }
#include <bits/stdc++.h> using namespace std; int nod(int a, int b) { while (a && b) { int c = a % b; a = b; b = c; } return a | b; } int Abs(int a) { return a >= 0 ? a : -a; } int main() { int n, m; cin >> n >> m; vector<vector<int> > e(n); for (int i = 0; i < m; ++i) { int a, b; scanf( %d%d , &a, &b); a--; b--; e[a].push_back(b); } vector<int> d(n, -1); queue<int> q; q.push(0); d[0] = 0; int r = 0; while (!q.empty()) { int i = q.front(); q.pop(); int dd = d[i] + 1; for (int j = 0; j < (int)e[i].size(); ++j) { int a = e[i][j]; if (d[a] >= 0) r = nod(r, Abs(d[a] - dd)); else { q.push(a); d[a] = dd; } } } int c = 0; for (int i = 0; i < n; ++i) if (d[i] >= 0 && d[i] % r == 0) c++; printf( %d n%d n , r, c); for (int i = 0; i < n; ++i) if (d[i] >= 0 && d[i] % r == 0) printf( %d , i + 1); return 0; }
#include <bits/stdc++.h> const int N = 500000; int n, k; char s[N + 1], t[N + 1]; int main() { scanf( %d%d%s%s , &n, &k, s, t); int r = 0; long long ans = 0; for (int i = 0; i < n; ++i) { if (r < k) { r *= 2; r += t[i] - s[i]; } r = std::min(r, k); ans += r == k ? r : r + 1; } printf( %lld n , ans); return 0; }
#include<bits/stdc++.h> #define inf 2000000000 #define eb emplace_back #define pb push_back #define fi first #define se second #define fastio ios::sync_with_stdio(false);cin.tie(NULL) #define rng_23 mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()) using namespace std; typedef long long ll; typedef pair<int,int> pii; typedef vector<int> vi; typedef vector<pair<int,int>> vii; typedef set<int> si; typedef multiset<int> msi; typedef map<int,int> mii; int ara[100][100],lcnt[100],wcnt[100]; int main() { int t; int i,j,k; int n,res; cin>>t; while(t--){ cin>>n; for(i=0;i<n;i++) for(j=0;j<n;j++) ara[i][j]=2; for(i=0;i<n;i++){ wcnt[i]=(n-1)/2; lcnt[i]=n-1-(n-1)/2; ara[i][i]=0; } if(n%2==0){ for(i=0;i<n;i++) lcnt[i]--; for(i=0;i<n;i+=2){ ara[i][i+1]=0; ara[i+1][i]=0; } } //for(i=0;i<n;i++){ // cout<<wcnt[i]<< <<lcnt[i]<<endl; //} for(i=0;i<n;i++){ //cout<<wcnt[i]<< <<lcnt[i]<<endl; for(j=0;j<n;j++){ if(ara[i][j]==2 && wcnt[i] && lcnt[j]){ wcnt[i]--; lcnt[j]--; ara[i][j]=1; ara[j][i]=-1; } } } for(i=0;i<n-1;i++){ for(j=i+1;j<n;j++){ cout<<ara[i][j]<< ; } } cout<< n ; } }
#include <bits/stdc++.h> using namespace std; constexpr int inf = 1e9 + 7; constexpr long long md = 1e6; void solve(int testi) { int n; cin >> n; if (n == 0) { cout << 1 << n ; ; return; } vector<int> digits = {6, 8, 4, 2}; cout << digits[n % digits.size()] << n ; ; } int main() { ios_base::sync_with_stdio(false); cin.tie(nullptr); long long testn = 1; for (long long testi = 1; testi <= testn; testi++) { solve(testi); } }
#include <bits/stdc++.h> using namespace std; template <class c> struct rge { c b, e; }; template <class c> rge<c> range(c i, c j) { return rge<c>{i, j}; } template <class c> auto dud(c* x) -> decltype(cerr << *x, 0); template <class c> char dud(...); struct debug { template <class c> debug& operator<<(const c&) { return *this; } }; void solve() { int n, m; cin >> n >> m; vector<vector<char> > v(n + 1, vector<char>(m + 1)); for (int i = 1; i <= n; ++i) { for (int j = 1; j <= m; ++j) { cin >> v[i][j]; } } vector<vector<int> > pf(n + 1, vector<int>(m + 1)); for (int i = 1; i <= n; ++i) { for (int j = 1; j <= m; ++j) { pf[i][j] = pf[i - 1][j] + pf[i][j - 1] - pf[i - 1][j - 1]; pf[i][j] += ((v[i][j] == X ) ? 1 : 0); } } auto get = [&](int x, int y, int x1, int y1) { return (pf[x1][y1] - pf[x1][y - 1] - pf[x - 1][y1] + pf[x - 1][y - 1]); }; auto check = [&](int side) { vector<vector<int> > add(n + 1, vector<int>(m + 1)); for (int i = 1; i + 2 * side <= n; ++i) { for (int j = 1; j + 2 * side <= m; ++j) { long long area = (2 * side + 1) * (2 * side + 1); if (get(i, j, i + 2 * side, j + 2 * side) == area) { ++add[i][j]; if (i + 2 * side < n) --add[i + 2 * side + 1][j]; if (j + 2 * side < m) --add[i][j + 2 * side + 1]; if (i + 2 * side < n && j + 2 * side < m) ++add[i + 2 * side + 1][j + 2 * side + 1]; } } } vector<vector<int> > pf1(n + 1, vector<int>(m + 1)); for (int i = 1; i <= n; ++i) { for (int j = 1; j <= m; ++j) { pf1[i][j] = pf1[i - 1][j] + pf1[i][j - 1] - pf1[i - 1][j - 1] + add[i][j]; int a = !!pf1[i][j], b = ((v[i][j] == X ) ? 1 : 0); if (a ^ b) return 0; } } return 1; }; int l = 0, r = min(n, m), mid, ans = 1; while (l <= r) { mid = l + r >> 1; if (check(mid)) ans = mid, l = mid + 1; else r = mid - 1; } cout << ans << n ; int side = ans; vector<vector<char> > res(n + 1, vector<char>(m + 1, . )); for (int i = 1; i <= n; ++i) { for (int j = 1; j <= m; ++j) { if (i + 2 * side <= n && j + 2 * side <= m) { long long area = (2 * side + 1) * (2 * side + 1); if (get(i, j, i + 2 * side, j + 2 * side) == area) res[i + side][j + side] = X ; } } } for (int i = 1; i <= n; ++i) { for (int j = 1; j <= m; ++j) cout << res[i][j]; cout << n ; } } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); int q = 1; while (q--) solve(); }
#include <bits/stdc++.h> using namespace std; inline bool EQ(double num4, double b) { return fabs(num4 - b) < 1e-9; } const int INF = 1 << 29; inline int two(int len) { return 1 << len; } inline int test(int len, int b) { return (len >> b) & 1; } inline void set_bit(int &len, int b) { len |= two(b); } inline void unset_bit(int &len, int b) { len &= ~two(b); } inline int last_bit(int len) { return len & (-len); } inline int ones(int len) { int res = 0; while (len && ++res) len -= len & (-len); return res; } template <class T> void chmax(T &num4, const T &b) { num4 = max(num4, b); } template <class T> void chmin(T &num4, const T &b) { num4 = min(num4, b); } inline void add(int &numx, int y) { numx += y; if (numx >= 1000000007) numx -= 1000000007; if (numx < 0) numx += 1000000007; } inline int mul(int numx, int y) { return ((long long)numx * y) % 1000000007; } int gcd(int num4, int b) { if (b) return gcd(b, num4 % b); return num4; } int power(int num4, int pex) { int ret = 1; while (pex) { if (pex & 1) ret = mul(ret, num4); num4 = mul(num4, num4); pex /= 2; } return ret; } int phi(int len) { int ret = len; int idxx = 2; if (len % idxx == 0) { ret -= ret / idxx; while (len % idxx == 0) len /= idxx; } for (idxx = 3; idxx * idxx <= len; idxx++) if (len % idxx == 0) { ret -= ret / idxx; while (len % idxx == 0) len /= idxx; } if (len > 1) ret -= ret / len; return ret; } using namespace std; int main() { bool flags = true; int num1, num2; cin >> num1 >> num2; int vals1 = num1 - 1, v2s = 0, v3s = 0, v4s = num2 - 1, bbs = 0; for (int i = 0; i < num1; ++i) for (int j = 0; j < num2; ++j) { char chh; cin >> chh; if (chh == B ) { vals1 = min(vals1, i); v2s = max(v2s, i); v4s = min(v4s, j); v3s = max(v3s, j); flags = false; ++bbs; } } if (flags) { cout << 1; return 0; } int weights = v3s - v4s + 1, h = v2s - vals1 + 1; if (weights > num1 || h > num2) { cout << -1; return 0; } int len = max(weights, h); cout << len * len - bbs << endl; return 0; }
#include <bits/stdc++.h> using namespace std; const double PI = acos(-1); const long long INF = 1LL << 62; const long long MINF = -(1LL << 62); template <typename T> T getint() { T val = 0; char c; bool neg = false; while ((c = getchar()) && !(c >= 0 && c <= 9 )) { neg |= c == - ; } do { val = (val * 10) + c - 0 ; } while ((c = getchar()) && (c >= 0 && c <= 9 )); return val * (neg ? -1 : 1); } const long long mod = 1e9 + 7; const long long MAXN = 300010; struct fenwick { long long arr[MAXN]; fenwick() { memset(arr, 0, sizeof arr); } void incr(int x, int by) { for (; x < MAXN; x += (x & (-x))) { arr[x] = (arr[x] + by) % mod; } } int sum(int x) { long long sum = 0; for (; x > 0; x -= (x & (-x))) { sum = (sum + arr[x]) % mod; } return sum; } }; int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); long long n, m; cin >> n >> m; vector<long long> c; vector<pair<long long, long long>> lst(m); for (int i = 0; i < m; ++i) cin >> lst[i].first >> lst[i].second; for (int i = 0; i < m; ++i) { c.push_back(lst[i].first); c.push_back(lst[i].second); } c.push_back(0); c.push_back(n); sort((c).begin(), (c).end()); c.resize(distance(c.begin(), unique((c).begin(), (c).end()))); for (int i = 0; i < m; ++i) { lst[i].first = lower_bound((c).begin(), (c).end(), lst[i].first) - c.begin(); lst[i].second = lower_bound((c).begin(), (c).end(), lst[i].second) - c.begin(); } int st = 0; st = lower_bound((c).begin(), (c).end(), st) - c.begin(); n = lower_bound((c).begin(), (c).end(), n) - c.begin(); fenwick f; sort((lst).begin(), (lst).end(), [&](pair<long long, long long>& egyik, pair<long long, long long>& masik) -> bool { return egyik.second < masik.second; }); f.incr(st + 1, 1); for (auto i : lst) { long long ways = f.sum(i.second) - f.sum(i.first); f.incr(i.second + 1, ways); } cout << (f.sum(n + 1) - f.sum(n) + mod) % mod << n ; return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 2002; int a[N][N], b[N][N], color[N / 2]; signed main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); int n; cin >> n; if (n & 1) { cout << NONE << endl; return 0; } for (int j = 0; j < n; j++) { a[0][j] = a[n - 1][n - j - 1] = a[j][0] = a[n - j - 1][n - 1] = j / 2; b[0][j] = b[n - 1][n - j - 1] = b[j][0] = b[n - j - 1][n - 1] = 1; if (j == 0 || j == n - 1) continue; a[1][j] = j & 1 ? (j + 1) / 2 : (j - 1) / 2; b[1][j] = 0; } for (int i = 2; i < n - 1; ++i) { for (int j = 1; j < n - 1; ++j) { if (a[i - 2][j] == a[i - 1][j - 1]) { a[i][j] = a[i - 1][j + 1]; } else { a[i][j] = a[i - 1][j - 1]; } } } memset(color, -1, sizeof(color)); bool flag = true; string s; for (int i = 0; i < n; ++i) { cin >> s; for (int j = 0; j < n; ++j) { int col = (s[j] == S ); if (i > 0 && i < n - 1 && j > 0 && j < n - 1) { if (a[i][j] == a[i - 1][j - 1] && a[i][j] == a[i + 1][j + 1]) { b[i][j] = 1 ^ b[i - 1][j - 1]; } else { b[i][j] = 1 ^ b[i - 1][j + 1]; } } if (s[j] == . ) continue; if (!b[i][j]) col ^= 1; int &prv = color[a[i][j]]; if (prv == -1 || prv == col) { prv = col; } else { flag = false; goto out; } } } out: if (flag) { int c = 0; for (int i = 0; i < n / 2; ++i) { c += color[i] != -1; } if (c == n / 2) { cout << UNIQUE << endl; for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) { if (color[a[i][j]] == b[i][j]) { cout << S ; } else { cout << G ; } } cout << endl; } } else { cout << MULTIPLE << endl; } } else { cout << NONE << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; int cur[100005]; int mark[100005]; int sol[400005]; int csol; int n, m; vector<int> E[100005]; inline void dfs(int u, int up) { mark[u] = 1; csol++; sol[csol] = u; cur[u] ^= 1; int last = 0; for (int i = 0; i < E[u].size(); i++) if (E[u][i] != up && mark[E[u][i]] == 0) { if (up == 0 && last != 0) { csol++; sol[csol] = u; cur[u] ^= 1; } dfs(E[u][i], u); last = 1; if (up != 0) { csol++; sol[csol] = u; cur[u] ^= 1; } } if (cur[u]) if (up != 0) { csol++; sol[csol] = up; csol++; sol[csol] = u; cur[u] ^= 1; cur[up] ^= 1; } else { csol++; sol[csol] = u; cur[u] ^= 1; } } int main() { scanf( %d%d , &n, &m); for (int i = 1; i <= m; i++) { int p, k; scanf( %d%d , &p, &k); E[p].push_back(k); E[k].push_back(p); } for (int i = 1; i <= n; i++) scanf( %d , &cur[i]); int st = 0; for (int i = 1; i <= n; i++) if (cur[i]) st = i; if (st == 0) { printf( 0 n ); return 0; } dfs(st, 0); int ok = 1; for (int i = 1; i <= n; i++) if (cur[i]) ok = 0; if (ok) { printf( %d n , csol); for (int i = 1; i <= csol; i++) printf( %d , sol[i]); } else printf( -1 n ); }
#include <bits/stdc++.h> using namespace std; int main() { long long n; cin >> n; long long a[n], b[n], c[n]; for (long long i = 0; i < n; i++) { cin >> a[i]; } map<long long, long long> m; map<long long, long long>::iterator it; map<long long, long long>::iterator it1; for (long long i = 0; i < n; i++) { cin >> b[i]; m[b[i]]++; } for (long long i = 0; i < n; i++) { it = m.lower_bound(n - a[i]); it1 = m.lower_bound(0); if (it != m.end()) { c[i] = (it->first + a[i]) % n; m[it->first]--; if (m[it->first] == 0) m.erase(it); } else if (it1 != m.end()) { c[i] = (it1->first + a[i]) % n; m[it1->first]--; if (m[it1->first] == 0) m.erase(it1); } } for (long long i = 0; i < n; i++) { cout << c[i] << ; } return 0; }
#include <bits/stdc++.h> using namespace std; mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); const int N = 2e5 + 100; int t[20 * N], ls[20 * N], rs[20 * N], a[N], root[N]; int cur_size = 1; void upd(int &v, int u, int l, int r, int pos, int x) { v = cur_size++; t[v] = t[u] + x, ls[v] = ls[u], rs[v] = rs[u]; if (l + 1 == r) { return; } int mid = (l + r) / 2; if (pos < mid) upd(ls[v], ls[u], l, mid, pos, x); else upd(rs[v], rs[u], mid, r, pos, x); t[v] = t[ls[v]] + t[rs[v]]; } int get(int v, int l, int r, int ql, int qr) { if (qr <= l || r <= ql) return 0; if (ql <= l && r <= qr) return t[v]; int mid = (l + r) / 2; return get(ls[v], l, mid, ql, qr) + get(rs[v], mid, r, ql, qr); } signed main() { ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0); int n, k; cin >> n >> k; vector<int> pos[N]; for (int i = 1; i <= n; i++) { cin >> a[i]; pos[a[i]].push_back(i); } for (int i = 1; i <= n; i++) { int p = lower_bound(pos[a[i]].begin(), pos[a[i]].end(), i) - pos[a[i]].begin(); upd(root[i], root[i - 1], 1, n + 1, i, 1); if (p >= k) { p -= k; upd(root[i], root[i], 1, n + 1, pos[a[i]][p], -1); } } int q; cin >> q; int ans = 0; while (q--) { int l, r; cin >> l >> r; l = (l + ans) % n + 1; r = (r + ans) % n + 1; if (l > r) swap(l, r); ans = get(root[r], 1, n + 1, l, r + 1); cout << ans << n ; } }
#include <bits/stdc++.h> using namespace std; int main() { long long int t; cin >> t; while (t--) { long long int n; cin >> n; long long int ans; long long int f = 0; for (long long int i = 3; i <= 360; i++) { if ((n * i) % 180 == 0 && (n * i) / 180 <= i - 2) { f = 1; ans = i; break; } } if (f == 1) cout << ans << endl; else cout << -1 << endl; } }
#include <bits/stdc++.h> using namespace std; const int maxn = 2e5 + 7; const int inf = 0x3f3f3f; char s[maxn]; char str[4] = RGB ; int main() { int q; scanf( %d , &q); while (q--) { int n, m; scanf( %d%d , &n, &m); scanf( %s , s); int minn = inf; n -= m; for (int i = 0; i <= n; i++) { for (int j = 0; j < 3; j++) { int jishu = 0, temp; temp = (j <= 1 ? j : 2); for (int k = 0; k < m; k++) { if (s[i + k] != str[(temp + k) % 3]) { jishu++; } } minn = min(minn, jishu); } } printf( %d n , minn); } }
#include <bits/stdc++.h> using namespace std; int N; int A[2000000], B[2000000]; int l[2000000], r[2000000], c[2000000]; int main() { scanf( %d , &N); int mxi = 0; for (int Ni = 0; Ni < N; Ni++) { scanf( %d , &A[Ni]); if (A[Ni] > A[mxi]) mxi = Ni; } for (int Ni = 0; Ni < N; Ni++) B[Ni] = A[(Ni + mxi) % N]; B[N] = B[0]; for (int Ni = N - 1; Ni >= 0; Ni--) { r[Ni] = Ni + 1; while (r[Ni] < N && B[Ni] > B[r[Ni]]) r[Ni] = r[r[Ni]]; if (r[Ni] < N && B[Ni] == B[r[Ni]]) c[Ni] = c[r[Ni]] + 1, r[Ni] = r[r[Ni]]; } for (int Ni = 1; Ni < N; Ni++) { l[Ni] = Ni - 1; while (l[Ni] > 0 && B[Ni] > B[l[Ni]]) l[Ni] = l[l[Ni]]; if (l[Ni] > 0 && B[Ni] == B[l[Ni]]) l[Ni] = l[l[Ni]]; } long long Ans = 0; for (int Ni = 0; Ni < N; Ni++) { if (B[Ni] == B[0]) ; else if (l[Ni] == 0 && r[Ni] == N) Ans++; else Ans += 2; Ans += c[Ni]; } printf( %I64d n , Ans); }
#include <bits/stdc++.h> using namespace std; void start() { ios_base::sync_with_stdio(false); cin.tie(NULL); } long long ans = INT_MAX; void solve(long long a, long long b, long long k, long long steps) { if (a == 1 && b == 1) { ans = min(ans, steps); return; } if (a - b > 0) solve(a - b, b, k, steps + 1); if (b - a > 0) solve(a, b - a, k, steps + 1); } int32_t main() { ios_base::sync_with_stdio(false); cin.tie(NULL); start(); long long n; cin >> n; for (long long i = 1; i < n; i++) { solve(i, n - i, n, 1); } if (ans == INT_MAX) cout << 0 << n ; else cout << ans << n ; }
#include <bits/stdc++.h> using namespace std; const long long N = 1e5 + 30, Mod = 1e9 + 7; const long long SQ = 330; const long long LOG = 20; long long n, q, Par[LOG][N], a[N], H[N], St[N], Fn[N], Lazy[N << 2], T, Fen[N], Seg[N << 2], root = 1; vector<long long> G[N]; void DFS(long long v = 1, long long par = 0) { St[v] = T++; Par[0][v] = par; for (int i = 1; i < LOG; i++) Par[i][v] = Par[i - 1][Par[i - 1][v]]; for (auto u : G[v]) { if (u == par) continue; H[u] = H[v] + 1; DFS(u, v); } Fn[v] = T; } void Shift(int id, int b, int e) { long long val = Lazy[id]; Seg[(id << 1)] += (((b + e) >> 1) - b) * val; Seg[((id << 1) | 1)] += (e - ((b + e) >> 1)) * val; Lazy[(id << 1)] += val; Lazy[((id << 1) | 1)] += val; Lazy[id] = 0; } void Add(int l, int r, long long val = 0, int id = 1, int b = 0, int e = n) { if (r <= b || e <= l) return; if (l <= b && e <= r) { Seg[id] += val * (e - b); Lazy[id] += val; return; } Shift(id, b, e); Add(l, r, val, (id << 1), b, ((b + e) >> 1)); Add(l, r, val, ((id << 1) | 1), ((b + e) >> 1), e); Seg[id] = Seg[(id << 1)] + Seg[((id << 1) | 1)]; } long long Get(int l, int r, int id = 1, int b = 0, int e = n) { if (r <= b || e <= l) return 0; if (l <= b && e <= r) return Seg[id]; Shift(id, b, e); return Get(l, r, (id << 1), b, ((b + e) >> 1)) + Get(l, r, ((id << 1) | 1), ((b + e) >> 1), e); } bool is_par(long long v, long long u) { return St[v] <= St[u] && Fn[u] <= Fn[v]; } long long Up(long long v, long long h) { for (int i = LOG - 1; ~i; i--) if (h & (1 << i)) v = Par[i][v]; return v; } long long LLCA(long long v, long long u) { if (H[v] < H[u]) swap(v, u); v = Up(v, H[v] - H[u]); if (v == u) return v; for (int i = LOG - 1; ~i; i--) { if (Par[i][v] ^ Par[i][u]) { v = Par[i][v]; u = Par[i][u]; } } return Par[0][v]; } long long LCA(long long v, long long u) { if (is_par(root, v) && is_par(root, u)) return LLCA(v, u); if (is_par(root, v) && !is_par(root, u)) return root; if (is_par(root, u) && !is_par(root, v)) return root; long long l = LLCA(v, u); if (is_par(v, u)) { long long x = LLCA(u, root); if (is_par(v, x)) return x; return v; } if (is_par(u, v)) { long long x = LLCA(v, root); if (is_par(u, x)) return x; return u; } if (is_par(l, root)) { long long f = LLCA(v, root); long long f2 = LLCA(u, root); if (H[f2] > H[f]) { return f2; } return f; } return l; } void Inp() { cin >> n >> q; for (int i = 1; i <= n; i++) { cin >> a[i]; } for (int i = 0; i < n - 1; i++) { long long v, u; cin >> v >> u; G[v].push_back(u); G[u].push_back(v); } DFS(1, 0); for (int i = 1; i <= n; i++) { Add(St[i], St[i] + 1, a[i]); } } void Add_Sub(long long v, long long val) { if (v == root) { Add(0, n, val); return; } if (is_par(root, v)) { Add(St[v], Fn[v], val); return; } if (is_par(v, root)) { long long dif = H[root] - H[v] - 1; long long rr = Up(root, dif); Add(0, n, val); Add(St[rr], Fn[rr], -val); return; } Add(St[v], Fn[v], val); } long long Get_Sub(long long v) { if (v == root) return Get(0, n); if (is_par(root, v)) { return Get(St[v], Fn[v]); } if (is_par(v, root)) { long long dif = H[root] - H[v] - 1; long long rr = Up(root, dif); return Get(0, n) - Get(St[rr], Fn[rr]); } return Get(St[v], Fn[v]); } int main() { ios::sync_with_stdio(0), cin.tie(0); Inp(); while (q--) { long long t; cin >> t; if (t == 1) { long long v; cin >> v; root = v; } if (t == 2) { long long v, u, x; cin >> v >> u >> x; long long l = LCA(v, u); Add_Sub(l, x); } if (t == 3) { long long v; cin >> v; cout << Get_Sub(v) << n ; } } }
#include <bits/stdc++.h> using namespace std; int main() { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); long long int n, m, k; cin >> n >> m >> k; vector<pair<long long int, long long int> > F(n), S(m); long long int maxDay = 0; for (long long int i = 0; i < n; i++) { cin >> F[i].first; F[i].second = i + 1; maxDay = max(maxDay, F[i].first); } for (long long int i = 0; i < m; i++) { cin >> S[i].first; S[i].second = i + 1; } long long int f_i = 0, s_i = 0; sort(F.begin(), F.begin() + F.size()); sort(S.begin(), S.begin() + S.size()); vector<long long int> res; for (long long int i = 0; i <= maxDay; i++) { long long int use = 0; while (use < k && f_i < F.size() && F[f_i].first == i) { f_i++; use++; } if (use == k && f_i < F.size() && F[f_i].first == i) { cout << -1 ; return 0; } while (s_i < S.size() && S[s_i].first < i) s_i++; while (use < k && s_i < S.size() && S[s_i].first >= i) { res.push_back(S[s_i].second); use++; s_i++; } while (use < k && f_i < F.size() && F[f_i].first > i) { use++; f_i++; } } for (long long int i = maxDay + 1; s_i < S.size(); i++) { long long int use = 0; while (s_i < S.size() && S[s_i].first < i) s_i++; while (use < k && s_i < S.size() && S[s_i].first >= i) { res.push_back(S[s_i].second); s_i++; use++; } } cout << res.size() << n ; for (auto x : res) cout << x << ; }
#include <bits/stdc++.h> using namespace std; #pragma comment(linker, /STACK:400000000 ) int n, m; struct space { int from, to, dist; space(int f, int t) : from(f), to(t) { if (f > t) { dist = 0; } else if (f == 1 || t == n) { dist = t - f + 1; } else { dist = (t - f) / 2 + 1; } } bool operator<(const space& b) const { return dist > b.dist || dist == b.dist && from < b.from; } }; set<space> S; int carP[1000010], carL[1000010], carR[1000010], posToCar[1000010]; int main() { cin >> n >> m; S.insert(space(1, n)); for (int i = 0; i < m + 1; i++) { if (i == m) break; int t, id; cin >> t >> id; if (t == 1) { space sp = *S.begin(); S.erase(S.begin()); int F = sp.from, T = sp.to, pos; if (F == 1 && T == n) pos = 1; else if (F == 1) pos = 1; else if (T == n) pos = n; else pos = (F + T) / 2; cout << pos << endl; carP[id] = pos; carL[id] = F - 1; carR[id] = T + 1; posToCar[pos] = id; carR[posToCar[F - 1]] = pos; carL[posToCar[T + 1]] = pos; S.insert(space(F, pos - 1)); S.insert(space(pos + 1, T)); } else { int F = carL[id], P = carP[id], T = carR[id]; S.erase(space(F + 1, P - 1)); S.erase(space(P + 1, T - 1)); carR[posToCar[F]] = T; carL[posToCar[T]] = F; S.insert(space(F + 1, T - 1)); } } }
#include <bits/stdc++.h> using namespace std; using ll = long long; struct dreapta { ll a, b; ll operator()(ll x) { return a * x + b; } }; bool useless(dreapta a, dreapta b, dreapta c) { assert(a.a >= b.a && b.a >= c.a); return (double)(b.b - a.b) / (a.a - b.a) > (double)(c.b - b.b) / (b.a - c.a); } class merging_batch { deque<dreapta> buf; public: merging_batch() {} ll query(ll x) { ll i = 0; for (ll step = 1 << 23; step; step /= 2) if (i + step < buf.size() && buf[i + step](x) <= buf[i + step - 1](x)) i += step; assert(i == buf.size() - 1 || buf[i](x) <= buf[i + 1](x)); return buf[i](x); } void add_right(dreapta x) { while (buf.size() > 1 && useless(buf.rbegin()[1], buf.back(), x)) buf.pop_back(); buf.push_back(x); } void add_left(dreapta x) { while (buf.size() > 1 && useless(x, buf[0], buf[1])) buf.pop_front(); buf.push_front(x); } void swap_with(merging_batch& rhs) { swap(buf, rhs.buf); } void merge_with(merging_batch& rhs) { if (buf.size() < rhs.buf.size()) { for (auto it = buf.rbegin(); it != buf.rend(); ++it) rhs.add_left(*it); swap(buf, rhs.buf); } else for (auto x : rhs.buf) add_right(x); } }; class undo_batch { ll top = 0; vector<dreapta> st = vector<dreapta>( 1000000 + 10, dreapta{1000ll * 1000 * 1000, 1000ll * 1000 * 1000 * 1000 * 1000}); struct modification { ll old_top, old_pos; dreapta d; }; vector<modification> undo_st; public: undo_batch() { top = 1; } void clear() { top = 1; } void print() { for (int i = 1; i < top; ++i) { cerr << ( << st[i].a << , << st[i].b << ) ; } cerr << endl; } ll query(ll x) { ll i = 0; for (ll step = 1 << 23; step; step /= 2) if (i + step < top && st[i + step](x) <= st[i + step - 1](x)) i += step; assert(i == top - 1 || st[i](x) <= st[i + 1](x)); return st[i](x); } void undo() { assert(!undo_st.empty()); top = undo_st.back().old_top; st[undo_st.back().old_pos] = undo_st.back().d; undo_st.pop_back(); } void add_right(dreapta d) { undo_st.push_back(modification{top, 0, 0}); ll ret = 0; for (ll step = 1 << 23; step; step /= 2) if (ret + step < top && (!useless(st[ret + step - 1], st[ret + step], d))) ret += step; top = ret + 2; undo_st.back().old_pos = ret + 1; undo_st.back().d = st[ret + 1]; st[ret + 1] = d; } }; void produce_state(const ll n, const vector<ll>& d, const vector<ll>& v, vector<ll>& ret) { static vector<ll> posz; static vector<merging_batch> mb; static undo_batch ub; posz.clear(); mb.clear(); ub.clear(); for (ll i = 0; i < n; ++i) { merging_batch x; x.add_right(dreapta{-i + 1, d[i]}); while (!posz.empty() && v[posz.back()] <= v[i]) { mb.back().merge_with(x); x.swap_with(mb.back()); mb.pop_back(); posz.pop_back(); ub.undo(); } posz.push_back(i); mb.push_back(move(x)); ub.add_right(dreapta{v[i], mb.back().query(v[i])}); ret[i + 1] = ub.query(i); } } int main() { ios::sync_with_stdio(false); cin.tie(0); ll n, k; cin >> n >> k; vector<ll> v(n); for (auto& x : v) cin >> x; vector<ll> state(n + 1, (ll)1e9 * (ll)1e9), tmp(n + 1, 0); state[0] = 0; tmp[0] = 0; for (ll i = 0; i < k; ++i) { produce_state(n, state, v, tmp); swap(state, tmp); } cout << state.back() << endl; return 0; }
#include <bits/stdc++.h> using namespace std; template <typename _T, typename _T2> string to_string(pair<_T, _T2> x) { return < + to_string(x.first) + , + to_string(x.second) + > ; } template <typename _T> string to_string(vector<_T> vec) { string s = [ ; for (auto el : vec) s += to_string(el) + , ; s[s.size() - 1] = ] ; s[s.size() - 2] = ; return s; } template <typename _T> string to_string(set<_T> vec) { string s = { ; for (auto el : vec) s += to_string(el) + , ; s[s.size() - 1] = } ; s[s.size() - 2] = ; return s; } template <typename _T, typename _T2> string to_string(map<_T, _T2> vec) { string s = { ; for (auto el : vec) s += mp[ + to_string(el.first) + ]= + to_string(el.second) + , ; s[s.size() - 1] = } ; s[s.size() - 2] = ; return s; } template <typename _T> inline void _DBG(const char *s, _T x) { cerr << s << = << to_string(x) << n ; } template <typename _T, typename... args> void _DBG(const char *s, _T x, args... a) { while (*s != , ) cerr << *s++; cerr << = << to_string(x) << n ; _DBG(s + 1, a...); } mt19937 rng___(chrono::steady_clock::now().time_since_epoch().count()); const long long MOD = 998244353; const long long LLINF = 1e18 + 7; const int N = 2e5 + 8; int main() { ios_base::sync_with_stdio(false); cin.tie(nullptr); ; int t; cin >> t; while (t--) { int n[3], len; cin >> n[0] >> n[1] >> n[2]; len = n[0] + n[1] + n[2] + 1; string ans; if (n[0] > 0) { ans += string(n[0] + 1, 0 ); if (n[2] > 0) { n[1]--; ans += string(n[2] + 1, 1 ); } while (n[1]--) { if (ans.back() == 1 ) ans += 0 ; else ans += 1 ; } cout << ans << n ; } else { ans += string(n[2] + 1, 1 ); while (n[1]--) { if (ans.back() == 1 ) ans += 0 ; else ans += 1 ; } cout << ans << n ; } } }
#include <bits/stdc++.h> using namespace std; typedef pair<int, int> PII; long long qpow(long long a, long long b, long long m) { long long ans = 1; while (b) { if (b & 1) ans = ans * a % m; a = a * a % m, b >>= 1; } return ans; } long long qpow(long long a, long long b) { long long ans = 1; while (b) { if (b & 1) ans = ans * a; a = a * a, b >>= 1; } return ans; } long long qmul(long long a, long long b, long long m) { long long res = 0; while (b > 0) { if (b & 1) res = (res + a) % m; a = (a + a) % m; b >>= 1; } return res; } long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); } long long lcm(long long a, long long b) { return a / gcd(a, b) * b; } long long inv(long long t, long long p) { return t == 1 ? 1 : (p - p / t) * inv(p % t, p) % p; } long long exgcd(long long a, long long b, long long &x, long long &y) { if (b == 0) { x = 1; y = 0; return a; } long long r = exgcd(b, a % b, y, x); y -= (a / b) * x; return r; } long long inv1(long long a, long long p) { long long d, x, y; d = exgcd(a, p, x, y); return d == 1 ? (x % p + p) % p : -1; } template <typename T, typename B> T Add(T a, B b, long long m) { return a + b >= m ? (a + b) % m : a + b; } template <typename T, typename B> T Sub(T a, B b, long long m) { return a - b < 0 ? (a - b + m) % m : a - b; } template <class T> void _sf(T &x) { cin >> x; } void _sf(int &x) { scanf( %d , &x); } void _sf(long long &x) { scanf( %lld , &x); } void _sf(double &x) { scanf( %lf , &x); } void _sf(char &x) { scanf( %c , &x); } void _sf(char *x) { scanf( %s , x); } void sf() {} template <class T, class... U> void sf(T &head, U &...tail) { _sf(head); sf(tail...); } template <class T> void _pf(const T &x) { cout << x; } void _pf(const int &x) { printf( %d , x); } void _pf(const long long &x) { printf( %lld , x); } void _pf(const double &x) { printf( %.16f , x); } void _pf(const char &x) { putchar(x); } void _pf(const char *x) { printf( %s , x); } template <class T, class U> void _pf(const pair<T, U> &x) { pf(x.first); putchar( ); pf(x.second); } template <class T> void _pf(const vector<T> &x) { for (auto i = x.begin(); i != x.end(); _pf(*i++)) if (i != x.cbegin()) putchar( ); } void pf() {} template <class T, class... U> void pf(const T &head, const U &...tail) { _pf(head); putchar(sizeof...(tail) ? : n ); pf(tail...); } template <typename T> inline void read(T &x) { x = 0; static int p; p = 1; static char c; c = getchar(); while (!isdigit(c)) { if (c == - ) p = -1; c = getchar(); } while (isdigit(c)) { x = (x << 1) + (x << 3) + (c - 48); c = getchar(); } x *= p; } const bool IOS = false; const double PI = acos(-1); const double eps = 1e-8; const long long linf = 0x3f3f3f3f3f3f3f3f; const long long INV2 = 500000004; const long long mod = 1e9 + 7; const int inf = 0x3f3f3f3f; const int maxn = 400050 + 10; bool vis[maxn]; int mi[maxn]; void Main(); int main() { if (IOS) std::ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); Main(); 0; return 0; } void Main() { int n, x; sf(n, x); for (int i = 0; i < x; ++i) mi[i] = i; int ans = 0; for (int i = 1; i <= n; ++i) { int d; sf(d); d = d % x; if (mi[d] <= n) { vis[mi[d]] = 1; while (vis[ans]) ans++; mi[d] += x; } pf(ans); } }
#include <bits/stdc++.h> using namespace std; int main() { int n, m; string s; cin >> n >> m; cin >> s; int pos = 0; for (int i = 1; i < n; i++) { if (s.substr(0, i) == s.substr(n - i, i)) { pos = i; } } cout << s; for (int i = 1; i < m; i++) { cout << s.substr(pos); } return 0; }
#include <bits/stdc++.h> using namespace std; template <typename T> istream& operator>>(istream& is, vector<T>& v) { for (auto& it : v) is >> it; return is; } template <class L, class R> ostream& operator<<(ostream& os, pair<L, R> P) { return os << ( << P.first << , << P.second << ) ; } template <class T> ostream& operator<<(ostream& os, vector<T> V) { os << [ ; for (auto v : V) os << v << ; return os << ] ; } template <class T> ostream& operator<<(ostream& os, set<T> second) { os << { ; for (auto s : second) os << s << ; return os << } ; } template <typename Arg1> void __f(const char* name, Arg1&& arg1) { cout << name << : << arg1 << n ; } template <typename Arg1, typename... Args> void __f(const char* names, Arg1&& arg1, Args&&... args) { const char* comma = strchr(names + 1, , ); cout.write(names, comma - names) << : << arg1 << | ; __f(comma + 1, args...); } vector<int> hungarianMethod(vector<vector<int>> W) { int n = ((int)(W).size()), m = ((int)(W[0]).size()), PHI = -1, NOL = -2, INF = 1e9; vector<vector<bool>> x(n, vector<bool>(m)); vector<bool> ss(n), st(m); int f = 0; for (int i = 0; i < n; i++) { f = max(f, (*max_element(W[i].begin(), W[i].end()))); } vector<int> u(n, f), v(m), p(m, INF), ls(n, PHI), lt(m, NOL), a(n, -1); while (true) { f = -1; for (int i = 0; i < n and f == -1; i++) { if (ls[i] != NOL and ss[i] == 0) { f = i; } } if (f != -1) { ss[f] = true; for (int j = 0; j < m; j++) { if (x[f][j] == 0 and u[f] + v[j] - W[f][j] < p[j]) { lt[j] = f; p[j] = u[f] + v[j] - W[f][j]; } } } else { for (int i = 0; i < m and f == -1; i++) { if (lt[i] != NOL and st[i] == 0 and p[i] == 0) { f = i; } } if (f == -1) { int d1 = INF, d2 = INF, d; for (int i : u) { d1 = min(d1, (i)); } for (int i : p) { if (i > 0) { d2 = min(d2, (i)); } } d = min(d1, d2); for (int i = 0; i < n; i++) { if (ls[i] != NOL) { u[i] -= d; } } for (int i = 0; i < m; i++) { if (p[i] == 0) { v[i] += d; } if (p[i] > 0 and lt[i] != NOL) { p[i] -= d; } } if (d2 >= d1) { break; } } else { st[f] = true; int s = -1; for (int i = 0; i < n and s == -1; i++) { if (x[i][f]) { s = i; } } if (s == -1) { for (int l, r;; f = r) { r = f; l = lt[r]; if (r >= 0 and l >= 0) { x[l][r] = !x[l][r]; } else { break; } r = ls[l]; if (r >= 0 and l >= 0) { x[l][r] = !x[l][r]; } else { break; } } fill(p.begin(), p.end(), INF); fill(lt.begin(), lt.end(), NOL); fill(ls.begin(), ls.end(), NOL); fill(ss.begin(), ss.end(), false); fill(st.begin(), st.end(), false); for (int i = 0; i < n; i++) { bool ex = true; for (int j = 0; j < m and ex; j++) { ex = !x[i][j]; } if (ex) { ls[i] = PHI; } } } else { ls[s] = f; } } } } for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if (x[i][j]) { a[j] = i; } } } return a; } void solve() { map<char, int> ind; map<int, char> revInd; for (char ch = a ; ch <= z ; ++ch) { ind[ch] = ch - a ; revInd[ind[ch]] = ch; } for (char ch = A ; ch <= Z ; ++ch) { ind[ch] = (ch - A ) + 26; revInd[ind[ch]] = ch; } int n, k; cin >> n >> k; string a, b; cin >> a >> b; vector<vector<int>> W(k, vector<int>(k, 1)); for (int i = 0; i < n; ++i) { W[ind[a[i]]][ind[b[i]]]++; } vector<int> matching = hungarianMethod(W); int ans = 0; string res(k, $ ); for (int i = 0; i < k; ++i) { ans += W[matching[i]][i] - 1; res[matching[i]] = revInd[i]; } cout << ans << n << res << n ; } int32_t main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); int T = 1; while (T--) { solve(); } return 0; }
#include <bits/stdc++.h> using namespace std; const int maxn = 7, n = 7, maxm = 101; int m, cntblk = maxn, f[maxn], deg[maxn]; bool used[maxm]; class ed { public: int target, id; char type; ed(int t, int i, char ty) : target(t), id(i), type(ty){}; }; class ans { public: int id; char type; ans(int i, char ty) : id(i), type(ty){}; }; vector<ed> edge[maxn]; vector<ans> answer; inline int getf(int x) { return f[x] == x ? x : f[x] = getf(f[x]); } void euler(int x, int in_id, char in_type) { for (vector<ed>::iterator vi = edge[x].begin(); vi != edge[x].end(); vi++) { if (used[(*vi).id]) continue; used[(*vi).id] = true; euler((*vi).target, (*vi).id, (*vi).type); } if (in_id >= 0) answer.push_back(ans(in_id, in_type)); } int main() { cin >> m; for (int i = 0; i < n; i++) f[i] = i, deg[i] = 0; for (int i = 1, x, y; i <= m; i++) { cin >> x >> y; deg[x]++; deg[y]++; edge[x].push_back(ed(y, i, + )); edge[y].push_back(ed(x, i, - )); if (getf(x) == getf(y)) continue; f[getf(x)] = getf(y); cntblk--; } int tmp = 0, s = -1; for (int i = 0; i < n; i++) { cntblk -= (deg[i] == 0); tmp += (deg[i] & 1); if (deg[i] > 0 && (s == -1 || deg[i] & 1)) s = i; } if (cntblk != 1 || !(tmp == 0 || tmp == 2)) { puts( No solution ); return 0; } memset(used, false, sizeof(used)); euler(s, -1, + ); for (vector<ans>::reverse_iterator vi = answer.rbegin(); vi < answer.rend(); vi++) { printf( %d %c n , (*vi).id, (*vi).type); } return 0; }
#include <bits/stdc++.h> using namespace std; priority_queue<int, vector<int>, less<int> > num; int main() { int n, x; cin >> n; for (int i = 1; i <= n; i++) { cin >> x; num.push(x); } cout << ((num.top()) xor (x)) << n ; }
#include <bits/stdc++.h> using namespace std; const int maxn = 200020; int a[maxn], b[maxn], pos[maxn], ans; unsigned long long hsh, qpow[200020] = {1}, sum; int n, m; struct node { unsigned long long a, tot; } tr[maxn << 2]; void pushup(int p) { tr[p].tot = tr[p << 1].tot + tr[p << 1 | 1].tot; tr[p].a = tr[p << 1].a * qpow[tr[p << 1 | 1].tot] + tr[p << 1 | 1].a; } void update(int l, int r, int pos, int p, int k) { if (l == r) { if (!k) tr[p].tot -= 1; else tr[p].tot += 1; tr[p].a = k; return; } int mid = l + r >> 1; if (pos <= mid) update(l, mid, pos, p << 1, k); if (pos > mid) update(mid + 1, r, pos, p << 1 | 1, k); pushup(p); } int main() { cin >> n >> m; for (int i = 1; i <= n; i++) { scanf( %lld , &a[i]); hsh = hsh * 23 + a[i]; qpow[i] = qpow[i - 1] * 23; sum += qpow[i - 1]; } for (int i = 1; i <= m; i++) scanf( %lld , &b[i]), pos[b[i]] = i; for (int i = 1; i <= m; i++) { if (i > n) update(1, m, pos[i - n], 1, 0); update(1, m, pos[i], 1, i); int d = i - n; if (d >= 0 && tr[1].a == d * sum + hsh) ++ans; } printf( %d , ans); }
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); ; long long int n; cin >> n; if (n % 2 == 0) cout << NO << endl; else { cout << YES << endl; long long int b[(2 * n) + 1]; b[1] = 1; b[2 * n] = 2 * n; long long int i = n + 1; long long int j = 2; long long int k = 2; long long int flag = 1; while (k < 2 * n) { if (flag == 1) { b[i] = k; b[i + 1] = k + 1; k = k + 2; i = i + 2; flag = 0; } else { b[j] = k; b[j + 1] = k + 1; k = k + 2; j = j + 2; flag = 1; } } for (long long int i = 1; i <= 2 * n; i++) cout << b[i] << ; } }
#include <bits/stdc++.h> using namespace std; const int N = 1e2 + 5; const int MOD = 1e9 + 7; long long cnt[N], x; int n, tmp; vector<vector<long long> > matMul(vector<vector<long long> > &A, vector<vector<long long> > &B) { vector<vector<long long> > C(N, vector<long long>(N, 0)); for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { for (int k = 0; k < N; k++) { C[i][j] = (C[i][j] + (A[i][k] * B[k][j]) % MOD) % MOD; } } } return C; } vector<vector<long long> > matPow(vector<vector<long long> > &A, int b) { if (b == 1) return A; vector<vector<long long> > ans = matPow(A, b >> 1); ans = matMul(ans, ans); if (b & 1) ans = matMul(ans, A); return ans; } int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); cin >> n >> x; for (int i = 0; i < n; i++) { cin >> tmp; cnt[tmp]++; } if (x == 0) { cout << 1 n ; return 0; } vector<vector<long long> > res(N, vector<long long>(N, 0)); for (int i = 1; i <= 100; i++) { res[0][i - 1] = cnt[i]; if (i < 100) res[i][i - 1] = 1; } res[0][100] = 1; res[100][100] = 1; res = matPow(res, x); long long ans = (res[0][0] + res[0][100]) % MOD; cout << ans << n ; return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 505; const long long inf = 1e18; inline int read() { int x = 0; char c = getchar(); while (!isdigit(c)) c = getchar(); while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar(); return x; } int n, m, now; long long ans, Pow[100]; bitset<N> f[2][64][N], g, tmp; int main() { n = read(); m = read(); int u, v, w; for (int i = 1; i <= m; ++i) { u = read(); v = read(); w = read(); f[w][0][u][v] = 1; } for (int i = 1; i <= 60; ++i) for (int u = 1; u <= n; ++u) for (int v = 1; v <= n; ++v) { if (f[0][i - 1][u][v]) f[0][i][u] |= f[1][i - 1][v]; if (f[1][i - 1][u][v]) f[1][i][u] |= f[0][i - 1][v]; } if (f[0][60][1].count()) { puts( -1 ); return 0; } now = 0; tmp[1] = 1; Pow[0] = 1; for (int i = 1; i <= 60; ++i) Pow[i] = Pow[i - 1] << 1; for (int i = 60; i >= 0; --i) { g.reset(); for (int j = 1; j <= n; ++j) if (tmp[j]) g |= f[now][i][j]; if (g.count()) { now ^= 1; tmp = g; ans += Pow[i]; } } if (ans > inf) puts( -1 ); else printf( %lld , ans); }
#include <bits/stdc++.h> using namespace std; const int mod = 1000000007; int n, fa[1200000], sf[1200000], len[1200000], f[1200000], g[1200000], diff[1200000], c[1200000][30], p, np, cnt; char s[1200000], a[1200000]; void upd(int &x, int y) { x = (x + y) % mod; } int main() { scanf( %s , s + 1); n = strlen(s + 1); for (int i = 1; i <= n / 2; ++i) { a[i * 2 - 1] = s[i]; a[i * 2] = s[n - i + 1]; } fa[0] = 1; len[0] = 0; fa[1] = 1; len[1] = -1; np = cnt = 1; f[0] = 1; for (int i = 1; i <= n; ++i) { int w = a[i] - a ; for (p = np; a[i] != a[i - len[p] - 1]; p = fa[p]) ; if (!c[p][w]) { int q = fa[p], now = ++cnt; len[now] = len[p] + 2; for (; a[i] != a[i - len[q] - 1]; q = fa[q]) ; fa[now] = c[q][w]; diff[now] = len[now] - len[fa[now]]; c[p][w] = np = now; sf[now] = diff[now] == diff[fa[now]] ? sf[fa[now]] : fa[now]; } else np = c[p][w]; for (int q = np; q; q = sf[q]) { g[q] = f[i - len[sf[q]] - diff[q]]; if (diff[q] == diff[fa[q]]) upd(g[q], g[fa[q]]); upd(f[i], g[q]); } if (i & 1) f[i] = 0; } printf( %d n , f[n]); return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 5000 + 5; const int inf = 0x3f3f3f3f; const int Max = 200000; template <class T> inline void getin(T& num) { char c; bool flag = 0; num = 0; while ((c = getchar()) < 0 || c > 9 ) if (c == - ) flag = 1; while (c >= 0 && c <= 9 ) { num = num * 10 + c - 48; c = getchar(); } if (flag) num = -num; } int n, k, a, x, y, m; queue<int> num[N]; set<pair<int, int> > output; vector<pair<int, int> > Ans; int main() { getin(n); int sum = 0, ans = 0; for (int i = 1; i <= n; i++) { getin(k), getin(a), sum += k; getin(x), getin(y), getin(m); num[i].push(a); int ret = 0; for (int j = 2; j <= k; j++) { int nxt = (1ll * a * x % m + y) % m; if (nxt < a) ret++; num[i].push(a = nxt); } ans = max(ans, ret); } printf( %d n , ans); if (sum > Max) return 0; for (int i = 1; i <= n; i++) { output.insert(make_pair(num[i].front(), i)); num[i].pop(); } int last = -inf, p; for (int i = 1; i <= sum; i++) { set<pair<int, int> >::iterator it = output.lower_bound(make_pair(last, -inf)); if (it == output.end()) ans++, it = output.begin(); Ans.push_back(*it); last = (*it).first; p = (*it).second; output.erase(it); if (!num[p].empty()) { output.insert(make_pair(num[p].front(), p)); num[p].pop(); } } for (int i = 0; i < sum; i++) printf( %d %d n , Ans[i].first, Ans[i].second); }
#include <bits/stdc++.h> using namespace std; const int N = 50 + 5; const int oo = 1000000000; bool u[N][N]; int n, m; int ans = -1; int a[N][N], l[N][N]; int d[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}}; char s[N]; struct pis { int x, y; pis() {} pis(int x, int y) : x(x), y(y) {} } f[10 * N * N]; inline int Solve(int x, int y) { for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) l[i][j] = oo; int front = 0, top = 1; f[1] = pis(x, y); l[x][y] = 0; while (front < top) { pis p = f[++front]; u[p.x][p.y] = 0; for (int i = 0; i < 4; i++) { int dx = p.x + d[i][0]; int dy = p.y + d[i][1]; if (dx >= 1 && dx <= n && dy >= 1 && dy <= m) { int dis = a[p.x][p.y] != a[dx][dy]; if (l[p.x][p.y] + dis < l[dx][dy]) { l[dx][dy] = l[p.x][p.y] + dis; if (!u[dx][dy]) { u[dx][dy] = 1; f[++top] = pis(dx, dy); } } } } } int MAX = 0; for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) if (a[i][j] && l[i][j] > MAX) MAX = l[i][j]; return MAX; } int main() { scanf( %d %d , &n, &m); for (int i = 1; i <= n; i++) { scanf( %s , s); for (int j = 1; j <= m; j++) { if (s[j - 1] == B ) ans = oo; a[i][j] = s[j - 1] == W ? 0 : 1; } } for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) ans = min(ans, Solve(i, j)); printf( %d n , ans + 1); return 0; }
#include <bits/stdc++.h> using namespace std; const int INF = 0x3f3f3f3f; const int maxn = 1e5 + 7; int n, x; int main() { cin >> n >> x; int ans = 0, num = 0; if (n == 2 && x == 0) { puts( NO ); return 0; } puts( YES ); if (n == 1) printf( %d , x); else if (n == 2) printf( %d %d , 0, x); else if (n == 3) { int t1 = 1 << 18; int t2 = 1 << 19; int t3 = x ^ t1 ^ t2; printf( %d %d %d , t1, t2, t3); } else { for (int i = 1;; i++) { if (i == x) continue; ans ^= i; printf( %d , i); num++; if (num == n - 3) break; } int t1 = 1 << 18; int t2 = 1 << 19; int t3 = x ^ ans ^ t1 ^ t2; printf( %d %d %d , t1, t2, t3); ans ^= t1 ^ t2 ^ t3; } return 0; }
#include <bits/stdc++.h> using namespace std; mt19937 mt_rand(time(0)); const int N = 105; int t, n; char a[N], b[N], c[N]; int main() { scanf( %d , &t); while (t--) { scanf( %s%s%s , a, b, c); n = 0; while (a[n]) n++; bool ok = 1; for (int i = 0; i < n; i++) { if (c[i] == a[i] || c[i] == b[i]) ; else ok = 0; } if (!ok) printf( NO n ); else printf( YES n ); } return 0; }
#include <bits/stdc++.h> using namespace std; string str; int memo[100005][3]; int dp(int Idx, int prev) { if (Idx == (int)str.size()) return 0; int choice1 = 1000000; if (memo[Idx][prev] != -1) return memo[Idx][prev]; if (prev == 0) { if (isupper(str[Idx])) choice1 = dp(Idx + 1, 0) + 1; else choice1 = dp(Idx + 1, 0); } else { if (isupper(str[Idx])) { choice1 = min(dp(Idx + 1, 0) + 1, dp(Idx + 1, 1)); } else choice1 = min(dp(Idx + 1, 0), dp(Idx + 1, 1) + 1); } return memo[Idx][prev] = choice1; } int main() { cin >> str; memset(memo, -1, sizeof(memo)); int ans = dp(0, 1); cout << ans << endl; return 0; }
#include <bits/stdc++.h> using namespace std; using ll = long long; double p; bool in_memo[200 + 1][230 + 1][2][1 << 8]; double memo[200 + 1][230 + 1][2][1 << 8]; double E(int k, int lead_count, bool lead_parity, int mask) { double& ans = memo[k][lead_count][lead_parity][mask]; if (not in_memo[k][lead_count][lead_parity][mask]) { if (k == 0) { ans = mask ? __builtin_ctz(mask) : 8 + (lead_parity ? 0 : lead_count); } else { ans = p / 100 * E(k - 1, bool((mask & (1 << 7)) >> 7) == lead_parity ? lead_count + 1 : 1, (mask & (1 << 7)) >> 7, (mask * 2) & 0b11111111) + (100 - p) / 100 * E(k - 1, mask == 0b11111111 ? (lead_parity ? lead_count : 1) : lead_count, lead_parity ^ (mask == 0b11111111), (mask + 1) & 0b11111111); } in_memo[k][lead_count][lead_parity][mask] = true; } return ans; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); int x, k; cin >> x >> k >> p; memset(in_memo, false, sizeof in_memo); cout << fixed << setprecision(7) << E(k, __builtin_ctz((x >> 8) & 1 ? (x >> 8) + 1 : x >> 8), (x >> 8) & 1, x & 0b11111111) << n ; return 0; }
#include <bits/stdc++.h> using namespace std; template <class S, class T> ostream& operator<<(ostream& st, pair<S, T> p) { st << ( << p.first << , << p.second << ) ; return st; } template <class T> ostream& operator<<(ostream& st, vector<T> v) { st << [ ; for (size_t i = 0; i < v.size(); ++i) { if (i != 0) { st << , ; } st << v[i]; } st << ] ; return st; } pair<int, int> get_parent_dsu(int v, vector<pair<int, int> >& parents) { if (parents[v].first != v) { pair<int, int> p = get_parent_dsu(parents[v].first, parents); parents[v] = make_pair(p.first, p.second ^ parents[v].second); } return parents[v]; } void union_dsu(int a, int b, int value, vector<int>& mass, vector<pair<int, int> >& parents) { pair<int, int> a_parent = get_parent_dsu(a, parents); pair<int, int> b_parent = get_parent_dsu(b, parents); a = a_parent.first; int a_dist = a_parent.second; b = b_parent.first; int b_dist = b_parent.second; if (a != b) { if (mass[a] > mass[b]) { swap(a, b); swap(a_dist, b_dist); } parents[a].first = b; parents[a].second = value ^ a_dist ^ b_dist; mass[b] += mass[a]; } } int perform_get_query(int a, int b, vector<pair<int, int> >& parents) { pair<int, int> a_parent = get_parent_dsu(a, parents); pair<int, int> b_parent = get_parent_dsu(b, parents); int result; if (a_parent.first == b_parent.first) { result = a_parent.second ^ b_parent.second; } else { result = -1; } return result; } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); srand(time(0)); int q; cin >> q; int mapper_size = 0; map<int, int> mapper; vector<int> mass; vector<pair<int, int> > parents_dsu; int last = 0; for (int i = 0; i < q; ++i) { int t; cin >> t; int l, r, value; cin >> l >> r; l = l ^ last; r = r ^ last; if (l > r) { swap(l, r); } --l; if (mapper.count(l) == 0) { mass.push_back(1); parents_dsu.push_back(make_pair(mapper_size, 0)); mapper[l] = mapper_size++; } if (mapper.count(r) == 0) { mass.push_back(1); parents_dsu.push_back(make_pair(mapper_size, 0)); mapper[r] = mapper_size++; } int a = mapper[l]; int b = mapper[r]; if (t == 1) { cin >> value; value = last ^ value; union_dsu(a, b, value, mass, parents_dsu); } else { last = perform_get_query(a, b, parents_dsu); cout << last << endl; if (last == -1) { last = 1; } } } return 0; }
#include <bits/stdc++.h> using namespace std; const int maxx = 1e5 + 7; const int Inf = 1 << 30; const long long INF = 1ll << 60; int n; int a[maxx]; vector<int> vec; int pos[maxx]; map<int, int> mp; int ans; int main() { cin >> n; for (int i = 1; i <= n; i++) cin >> a[i]; int cnt = 0; int t = 0; bool flg = 0; for (int i = 1; i <= n; i++) { if (a[i] == 1) { if (!flg) pos[++t] = i; flg = 1; cnt++; } else { if (cnt) vec.push_back(cnt); cnt = 0; flg = 0; } if (i == n && a[i] == 1) vec.push_back(cnt); } for (int i = 0; i < vec.size(); i++) mp[pos[i + 1]] = vec[i]; int pp = pos[1] - 1; int minx = min(pp, mp[pos[1]]); ans = max(ans, 2 * minx); for (int i = 1; i <= t; i++) { int tmp; if (i == 1) tmp = minx; else tmp = pos[i] - (pos[i - 1] + mp[pos[i - 1]]); int min1 = min(tmp, mp[pos[i]]); int min2 = min(tmp, mp[pos[i - 1]]); int minT = max(min1, min2); ans = max(ans, 2 * minT); } int dd = n - (pos[t] + mp[pos[t]] - 1); int min0 = min(dd, mp[pos[t]]); ans = max(ans, 2 * min0); cout << ans << endl; }
#include <bits/stdc++.h> using namespace std; const int MOD = 1e9 + 7; const int MAXN = 1e6 + 10; int fac[MAXN], infac[MAXN]; long long pow_mod(long long a, long long b) { long long res = 1; while (b) { if (b & 1) res = res * a % MOD; a = a * a % MOD; b >>= 1; } return res; } int add(int a, int b) { return (a + b) % MOD; } int mul(int a, int b) { return 1LL * a * b % MOD; } int C(int a, int b) { return mul(fac[a], mul(infac[b], infac[a - b])); } int A(int a, int b) { return mul(fac[a], infac[a - b]); } int F(int a, int b) { if (a == b) return 1; return mul(b, pow_mod(a, a - b - 1)); } int main() { int n, m, a, b; fac[0] = 1; for (int i = 1; i <= 1000000; i++) { fac[i] = mul(i, fac[i - 1]); } infac[1000000] = pow_mod(fac[1000000], MOD - 2); for (int i = 1000000; i >= 1; i--) { infac[i - 1] = mul(infac[i], i); } scanf( %d%d%d%d , &n, &m, &a, &b); int ans = 0; for (int i = 1; i <= n - 1; i++) { if (i > m) { continue; } ans = add(ans, mul(mul(pow_mod(m, n - 1 - i), F(n, i + 1)), mul(A(n - 2, i - 1), C(m - 1, i - 1)))); } printf( %d , ans); return 0; }
#include <bits/stdc++.h> using namespace std; int a[5000 + 10]; int main() { int n; cin >> n; for (int i = 1; i < n + 1; i++) cin >> a[i]; bool flag = false; for (int i = 1; i < n; i++) { if (a[a[a[i]]] == i) { flag = true; break; } } if (flag) cout << YES ; else cout << NO ; return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 100004; unsigned long long a, b, c = 0, x = 0, y = 0; bool f = 1; void solve() { int c = 0; for (int i = 0; i < 64; i++) { if (b >> i & 1) y |= 1ll << i; } a -= y; for (int i = 1; i < 64; i++) { int r = a >> i & 1, s = b >> (i - 1) & 1; if (r == 1) { if (s == 0) { x |= 1ll << (i - 1); y |= 1ll << (i - 1); } else { f = 0; break; } } } } int main() { cin >> a >> b; solve(); if (!f) puts( -1 ); else printf( %llu %llu , x, y); }
#include <bits/stdc++.h> using namespace std; long long nsd(long long a, long long b) { while (b != 0) { a = a % b; swap(a, b); } return a; } long long nsk(long long a, long long b) { return a / nsd(a, b) * b; } bool cmp(long long a, long long b) { return a > b; } void sorts(string& str) { sort(str.begin(), str.end()); } long long sumd(long long n) { if (n < 0) { n = -n; } long long s = 0; while (n != 0) { n /= 10; s++; } return s; } int suma(long long n) { int s = 0; while (n != 0) { s += n % 10; n /= 10; } return s; } long long fact(long long n) { if (n == 1) return 1; else return n * fact(n - 1); } int factnum(int n) { int c = 0; for (int i = 5; n / i >= 1; i *= 5) c += n / i; return c; } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); int n; cin >> n; string s; cin >> s; cout << abs(count(s.begin(), s.end(), 1 ) - count(s.begin(), s.end(), 0 )); }
#include <bits/stdc++.h> using namespace std; int main() { long long int i, j, n; cin >> n; long long int arr[n]; vector<long long int> vec[100010]; for (i = 0; i < n; i++) { cin >> arr[i]; vec[arr[i]].push_back(i); } long long int y = 0, d; for (i = 0; i < 100010; i++) { long long int x = 0; if (vec[i].size() >= 2) { d = vec[i][1] - vec[i][0]; for (j = 1; j < vec[i].size(); j++) { if (d == (vec[i][j] - vec[i][j - 1])) { ++x; } } if ((x + 1) == vec[i].size()) { ++y; } } else if (vec[i].size() == 1) { ++y; } else { continue; } } cout << y << endl; vector<long long int> vec1[100010]; long long int z = 0; for (i = 0; i < 100010; i++) { long long int x = 0; d = 0; if (vec[i].size() >= 2) { d = vec[i][1] - vec[i][0]; for (j = 1; j < vec[i].size(); j++) { if (d == (vec[i][j] - vec[i][j - 1])) { ++x; } } if ((x + 1) == vec[i].size()) { cout << i << << d << endl; } } else if (vec[i].size() == 1) { cout << i << << d << endl; } else { continue; } } return 0; }
#include <bits/stdc++.h> using namespace std; char s[1005]; int main() { int n, f = 1; char *p, *q; scanf( %s , s); n = strlen(s); p = s; q = s + n - 1; while (p <= q) { if (*p == *q) { p++; q--; } else { f = 0; break; } } printf( %s , s); if (!f) { for (int i = n - 1; i >= 0; i--) printf( %c , s[i]); } return 0; }