func_code_string
stringlengths 59
71.4k
|
|---|
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; string s1; cin >> s1; for (int i = 0; i < s1.size() - 1; i++) { while ((s1[i] == a || s1[i] == o || s1[i] == y || s1[i] == e || s1[i] == u || s1[i] == i ) && (s1[i + 1] == a || s1[i + 1] == o || s1[i + 1] == y || s1[i + 1] == e || s1[i + 1] == u || s1[i + 1] == i )) { s1.erase(i + 1, 1); } } cout << s1 << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; const int N = 1e3 + 3; int n, l; double ans, a[N]; int main() { scanf( %d %d , &n, &l); for (int i = 0; i < n; ++i) scanf( %lf , a + i); sort(a, a + n); if (a[0] != 0) ans = a[0]; if (a[n - 1] != l) ans = max(ans, l - a[n - 1]); for (int i = 0; i < n - 1; ++i) { ans = max(ans, (a[i + 1] - a[i]) / 2); } printf( %.10lf n , ans); }
|
#include <bits/stdc++.h> using namespace std; int CC; long long f[109]; int v[109]; long long d0[109], d1[109]; int main() { f[1] = 1; f[2] = 2; CC = 2; while (f[CC - 1] + f[CC] < 1000 * 1000 * 1000LL * 1000LL * 1000 * 1000) { f[CC + 1] = f[CC] + f[CC - 1]; CC++; } int T; for (scanf( %d , &T); T > 0; T--) { long long n; scanf( %lld , &n); memset(v, 0, sizeof v); int cnt = 0; for (int i = CC; i > 0 && n > 0; i--) { if (n - f[i] >= 0) n -= f[i], v[++cnt] = i; } reverse(v + 1, v + cnt + 1); d0[0] = 1, d1[0] = 0; for (int k = 1; k <= cnt; k++) { d0[k] = d0[k - 1] + d1[k - 1]; d1[k] = 0; d1[k] += d0[k - 1] * ((v[k] - v[k - 1] - 1) / 2); d1[k] += d1[k - 1] * ((v[k] - v[k - 1]) / 2); } printf( %lld n , d1[cnt] + d0[cnt]); } return 0; }
|
#include <bits/stdc++.h> int main() { char str[100], i, a; scanf( %s , str); a = strlen(str); if (a % 2 == 0) { printf( %c , str[(a - 1) / 2]); for (i = 1; i < ((a - 1) / 2) + 1; i++) { printf( %c , str[((a - 1) / 2) + i]); printf( %c , str[((a - 1) / 2) - i]); } printf( %c , str[a - 1]); } else { printf( %c , str[a / 2]); for (i = 1; i < (a / 2) + 1; i++) { printf( %c , str[(a / 2) + i]); printf( %c , str[(a / 2) - i]); } } printf( n ); return 0; }
|
#include <bits/stdc++.h> using namespace std; const int INF = 1e9; const int MOD = 1e9 + 7; const int MAXN = 1e6 + 5; const double eps = 1e-14; int a[MAXN]; void solve() { int n; cin >> n; for (int i = 1; i <= 9; i++) { cin >> a[i]; } int mn = a[1], ciph = 1; for (int i = 2; i <= 9; i++) { if (a[i] <= mn) { mn = min(mn, a[i]); ciph = i; } } char c = ciph + 0 ; int q = n / mn; int r = n % mn; string s = ; for (int i = 0; i < q; i++) s += c; for (int i = 0; i < q; i++) { for (int j = 9; j >= 1; j--) { if (r >= a[j] - mn) { r -= (a[j] - mn); s[i] = j + 0 ; break; } } } if (s.empty()) cout << -1; else cout << s; } int main() { if (!1) { freopen( 474 .in , r , stdin); freopen( 474 .out , w , stdout); } ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); int t = (228 & 322) >> 6; while (t--) solve(); return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { double x1, y1, x2, y2; cin >> x1 >> y1 >> x2 >> y2; double vmax, t0, vx, vy, wx, wy; cin >> vmax >> t0 >> vx >> vy >> wx >> wy; double dx = (x2 - x1); double dy = (y2 - y1); double l = 0, r = 1e16; double ans = 1e16; for (int i = 0; i < 200; i++) { double t = (l + r) / 2; double xx = vx * (t0 < t ? t0 : t); double yy = vy * (t0 < t ? t0 : t); if (t > t0) { xx += wx * (t - t0); yy += wy * (t - t0); } if ((xx - dx) * (xx - dx) + (yy - dy) * (yy - dy) > vmax * vmax * t * t) l = t; else { r = t; ans = t; } } printf( %.12f n , ans); }
|
#include <bits/stdc++.h> using namespace std; const int MAX_N = 1e5 + 10, MOD = 1e9 + 7; int n, x[MAX_N], y[MAX_N], ordered_x[MAX_N], ordered_y[MAX_N], x_n, y_n, ans = 1; int fa[MAX_N * 2], node_cnt[MAX_N * 2], edge_cnt[MAX_N * 2]; void init() { scanf( %d , &n); for (int i = 1; i <= n; i++) { scanf( %d%d , &x[i], &y[i]); ordered_x[i] = x[i]; ordered_y[i] = y[i]; } sort(ordered_x + 1, ordered_x + n + 1); x_n = unique(ordered_x + 1, ordered_x + n + 1) - ordered_x - 1; for (int i = 1; i <= n; i++) x[i] = lower_bound(ordered_x + 1, ordered_x + x_n + 1, x[i]) - ordered_x; sort(ordered_y + 1, ordered_y + n + 1); y_n = unique(ordered_y + 1, ordered_y + n + 1) - ordered_y - 1; for (int i = 1; i <= n; i++) y[i] = lower_bound(ordered_y + 1, ordered_y + y_n + 1, y[i]) - ordered_y; for (int i = 1; i <= x_n + y_n; i++) fa[i] = i; } int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); } void merge(int a, int b) { fa[find(a)] = find(b); } void solve() { for (int i = 1; i <= n; i++) merge(x[i], x_n + y[i]); for (int i = 1; i <= x_n; i++) node_cnt[find(i)]++; for (int i = 1; i <= y_n; i++) node_cnt[find(x_n + i)]++; for (int i = 1; i <= n; i++) edge_cnt[find(x[i])]++; for (int i = 1; i <= x_n + y_n; i++) { if (fa[i] != i) continue; int fac = 1; for (int j = 1; j <= node_cnt[i]; j++) fac = fac * 2 % MOD; if (edge_cnt[i] < node_cnt[i]) fac--; ans = (long long)ans * fac % MOD; } printf( %d n , ans); } int main() { init(); solve(); }
|
#include <bits/stdc++.h> using namespace std; const int INF = 1000000001; template <class T, class U> ostream &operator<<(ostream &out, const pair<T, U> &p) { return out << p.first << << p.second; } template <class T> ostream &operator<<(ostream &out, const vector<T> &v) { for (typeof((v).begin()) i = ((v).begin()); i != (v).end(); ++i) { out << *i << ; } return out; } template <class T, class U> istream &operator>>(istream &in, pair<T, U> &p) { return in >> p.first >> p.second; } template <class T> istream &operator>>(istream &in, vector<T> &v) { for (typeof((v).begin()) i = ((v).begin()); i != (v).end(); ++i) { in >> (*i); } return in; } template <class T> ostream &operator,(ostream &out, const T &t) { return out << t; } template <class T> istream &operator,(istream &in, T &t) { return in >> t; } int io_init() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); cout, fixed, setprecision(9); return 1; } int _io_dummy = io_init(); template <class T, class U> bool remin(T &a, const U &b) { return b < a ? a = b, true : false; } template <class T, class U> bool remax(T &a, const U &b) { return b > a ? a = b, true : false; } const int N = 1000000; int D[N]; void calcPrimes(int n = N) { for (int i = 2; i * i < n; ++i) { if (D[i]) { continue; } for (int j = i * i; j < n; j += i) { D[j] = i; } } } bool isPrime(int x) { return x > 1 && D[x] == 0; } int rev(int x) { ostringstream oss; oss, x; string s = oss.str(); reverse((s).begin(), (s).end()); istringstream iss(s); iss, x; return x; } int main() { calcPrimes(); string s = qd ucyhf yi q fhycu dkcruh mxeiu huluhiu yi q tyvvuhudj fhycu dkcruh. oekh jqia yi je vydt jxu djx ucyhf. n ; s += jxu ydfkj sediyiji ev q iydwbu ydjuwuh d (1 <= d <= 11184) - jxu edu-rqiut ydtun ev jxu ucyhf je vydt n ; s += ekjfkj q iydwbu dkcruh. ; for (int i = 0; i < (10); ++i) { for (typeof((s).begin()) c = ((s).begin()); c != (s).end(); ++c) { if (!isalpha(*c)) continue; if ((*c)++ == z ) *c = a ; } } cerr, s, n ; int x; cin, x; int n = 0, r; for (int i = 13; i < N; i += 2) { if (isPrime(i) && (r = rev(i)) != i && isPrime(r)) { ++n; if (n == x) { cout, i, n ; break; } } } }
|
#include <bits/stdc++.h> using namespace std; int n, m; const int MAXN = 1e6 + 10; pair<int, pair<int, int> > A[MAXN]; int HX[MAXN], HY[MAXN]; int fa[MAXN]; int X[MAXN], Y[MAXN]; int ans[MAXN]; int Find(int x) { return fa[x] == x ? x : fa[x] = Find(fa[x]); } void uni(int x, int y) { int fx = Find(x), fy = Find(y); if (fx != fy) { fa[fx] = fy; } } int main() { while (scanf( %d%d , &n, &m) != EOF) { for (int i = 0; i < n * m; i++) { fa[i] = i; } for (int i = 0; i < n * m; i++) { scanf( %d , &A[i].first); A[i].second.first = i / m; A[i].second.second = i % m; } sort(A, A + n * m); memset(ans, 0, sizeof(ans)); int j = -1; for (int i = j + 1; i < n * m; i++) { if (i + 1 < n * m && A[i].first == A[i + 1].first) continue; for (int k = j + 1; k <= i; k++) { int p = A[k].second.first * m + A[k].second.second; int x = A[k].second.first, y = A[k].second.second; HX[x] = p; HY[y] = p; } for (int k = j + 1; k <= i; k++) { int p = A[k].second.first * m + A[k].second.second; int x = A[k].second.first, y = A[k].second.second; uni(HX[x], p); uni(HY[y], p); } for (int k = j + 1; k <= i; k++) { int p = A[k].second.first * m + A[k].second.second; int x = A[k].second.first, y = A[k].second.second; int fp = Find(p); ans[fp] = max(ans[fp], max(X[x], Y[y]) + 1); } for (int k = j + 1; k <= i; k++) { int p = A[k].second.first * m + A[k].second.second; int x = A[k].second.first, y = A[k].second.second; int fp = Find(p); X[x] = max(X[x], ans[fp]); Y[y] = max(Y[y], ans[fp]); } j = i; } for (int i = 0; i < n * m; i++) { printf( %d , ans[Find(i)]); if (i % m == m - 1) puts( ); } } }
|
#include <bits/stdc++.h> using namespace std; int n, i; int main() { ios::sync_with_stdio(0); cin.tie(0); cin >> n; for (i = 2; i <= n; i++) cout << i << ; cout << 1 << n ; return 0; }
|
#include <bits/stdc++.h> using namespace std; int p2[203]; int p5[203]; int dpcur[203][5003][2]; int dpnxt[203][5003][2]; int main() { ios_base::sync_with_stdio(0); cin.tie(NULL); cout.tie(NULL); int n, k; cin >> n >> k; for (int i = 1; i <= n; i++) { long long int x; cin >> x; while (x % 2 == 0) { x /= 2; p2[i]++; } while (x % 5 == 0) { x /= 5; p5[i]++; } } memset(dpcur, -1, sizeof(dpcur)); memset(dpnxt, -1, sizeof(dpnxt)); dpcur[k][0][0] = 0; if (p2[1] >= p5[1]) { dpcur[k - 1][p2[1] - p5[1]][0] = p5[1]; } else { dpcur[k - 1][p5[1] - p2[1]][1] = p2[1]; } for (int i = 2; i <= n; i++) { for (int K = k; K >= max(0, k - (i - 1)); K--) { for (int excess_cnt = 0; excess_cnt <= min(5000, 60 * (i - 1)); excess_cnt++) { if (dpcur[K][excess_cnt][0] != -1) { dpnxt[K][excess_cnt][0] = max(dpnxt[K][excess_cnt][0], dpcur[K][excess_cnt][0]); int cnt2 = p2[i] + excess_cnt; int cnt5 = p5[i]; if (cnt2 >= cnt5 && K - 1 >= 0) { dpnxt[K - 1][min(cnt2 - cnt5, 5000)][0] = max(dpnxt[K - 1][min(cnt2 - cnt5, 5000)][0], dpcur[K][excess_cnt][0] + cnt5); } else if (cnt5 > cnt2 && K - 1 >= 0) { dpnxt[K - 1][min(cnt5 - cnt2, 5000)][1] = max(dpnxt[K - 1][min(cnt5 - cnt2, 5000)][1], dpcur[K][excess_cnt][0] + cnt2); } } if (dpcur[K][excess_cnt][1] != -1) { dpnxt[K][excess_cnt][1] = max(dpnxt[K][excess_cnt][1], dpcur[K][excess_cnt][1]); int cnt2 = p2[i]; int cnt5 = p5[i] + excess_cnt; if (cnt2 >= cnt5 && K - 1 >= 0) { dpnxt[K - 1][min(cnt2 - cnt5, 5000)][0] = max(dpnxt[K - 1][min(cnt2 - cnt5, 5000)][0], dpcur[K][excess_cnt][1] + cnt5); } else if (cnt5 > cnt2 && K - 1 >= 0) { dpnxt[K - 1][min(cnt5 - cnt2, 5000)][1] = max(dpnxt[K - 1][min(cnt5 - cnt2, 5000)][1], dpcur[K][excess_cnt][1] + cnt2); } } } } for (int K = k; K >= max(0, k - i); K--) { for (int excess_cnt = 0; excess_cnt <= min(5000, 60 * i); excess_cnt++) { for (int excess = 0; excess <= 1; excess++) { dpcur[K][excess_cnt][excess] = dpnxt[K][excess_cnt][excess]; } } } memset(dpnxt, -1, sizeof(dpnxt)); } int ans = 0; for (int excess_cnt = 0; excess_cnt <= 5000; excess_cnt++) { for (int excess = 0; excess <= 1; excess++) { ans = max(ans, dpcur[0][excess_cnt][excess]); } } cout << ans << n ; }
|
#include <bits/stdc++.h> #pragma GCC optimize( Ofast ) #pragma GCC target( sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx ) using namespace std; const long long mod = 998244353; long long binpow(long long a, long long n) { if (n == 0) return 1; if (n % 2 == 1) { return (binpow(a, n - 1) * a) % mod; ; } else { long long b = binpow(a, n / 2); return (b * b) % mod; } } long long f[500]; long long f_obr[500]; signed main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); f[0] = 1; f_obr[0] = 1; for (long long i = 1; i < 500; ++i) { f[i] = f[i - 1] * i; f[i] %= mod; f_obr[i] = binpow(f[i], mod - 2); } long long d; cin >> d; vector<long long> pr; pr.reserve(1e7 + 5); for (long long i = 2; i * i <= d; ++i) { if (d % i == 0) { pr.push_back(i); while (d % i == 0) d /= i; } } if (d > 1) pr.push_back(d); int q; cin >> q; for (int i = 0; i < q; ++i) { long long v[2]; cin >> v[0] >> v[1]; vector<long long> vc[2]; vector<int> cnt[2]; for (int j = 0; j < 2; ++j) for (int k = 0; k < int(pr.size()); ++k) if (v[j] % pr[k] == 0) { vc[j].push_back(pr[k]); cnt[j].push_back(0); while (v[j] % pr[k] == 0) { cnt[j].back()++; v[j] /= pr[k]; } } int uk = 0; vector<int> res[2]; for (int j = 0; j < int(cnt[0].size()); ++j) { while (uk < int(cnt[1].size()) && vc[1][uk] <= vc[0][j]) { if (vc[1][uk] == vc[0][j]) { if (cnt[0][j] > cnt[1][uk]) res[0].push_back(cnt[0][j] - cnt[1][uk]); else res[1].push_back(cnt[1][uk] - cnt[0][j]); } else res[1].push_back(cnt[1][uk]); ++uk; } if (!(uk > 0 && vc[1][uk - 1] == vc[0][j])) res[0].push_back(cnt[0][j]); } while (uk < int(cnt[1].size())) { res[1].push_back(cnt[1][uk]); ++uk; } int sum[2]; sum[0] = 0; sum[1] = 0; long long ans = 1; for (int j = 0; j < 2; ++j) for (int k = 0; k < int(res[j].size()); ++k) { sum[j] += res[j][k]; ans *= f_obr[res[j][k]]; ans %= mod; } ans *= f[sum[0]]; ans %= mod; ans *= f[sum[1]]; ans %= mod; cout << ans << n ; } return 0; }
|
#include <bits/stdc++.h> using namespace std; long long n, m, a[1000001], mx[1000001], cnt, maxi, ans; int main() { cin >> n; for (long long i = 1; i <= n; ++i) { cin >> a[i]; mx[i] = -1; for (long long j = 1; j <= a[i]; ++j) { long long k; cin >> k; mx[i] = max(mx[i], k); } } for (long long i = 1; i <= n; ++i) { maxi = max(maxi, mx[i]); } for (long long i = 1; i <= n; ++i) { cnt += (maxi - mx[i]) * a[i]; } cout << cnt; }
|
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0); long long int n, i, x; cin >> n; long long int a[2 * n]; for (i = 0; i < 2 * n; i++) { cin >> a[i]; } sort(a, a + 2 * n); x = (a[n - 1] - a[0]) * (a[2 * n - 1] - a[n]); for (i = 0; i < n; i++) { x = min(x, (a[i + n - 1] - a[i]) * (a[2 * n - 1] - a[0])); } cout << x; }
|
#include <bits/stdc++.h> using namespace std; char a[300099]; char ans[300099]; int c[200000]; int b; int main() { while (~scanf( %s , a)) { memset(c, 0, sizeof(c)); scanf( %d , &b); int len = strlen(a); for (int i = 0; i < b; i++) { int pt; scanf( %d , &pt); pt--; c[pt]++; } for (int i = 0; i < len / 2; i++) { if (i == 0) { if (c[i] % 2) ans[i] = a[len - 1 - i], ans[len - 1 - i] = a[i]; else ans[i] = a[i], ans[len - 1 - i] = a[len - 1 - i]; } else { c[i] += c[i - 1]; if (c[i] % 2) ans[i] = a[len - 1 - i], ans[len - 1 - i] = a[i]; else ans[i] = a[i], ans[len - 1 - i] = a[len - 1 - i]; } } if (len % 2) ans[len / 2] = a[len / 2]; ans[len] = 0 ; printf( %s n , ans); } return 0; }
|
#include <bits/stdc++.h> const int P = 998244353; using namespace std; template <typename T> inline void ckmax(T &a, T b) { (a < b) && (a = b); } template <typename T> inline void ckmin(T &a, T b) { (a > b) && (a = b); } inline int mul(int a, int b) { return 1ll * a * b % P; } inline int add(int a, int b) { return a + b >= P ? a + b - P : a + b; } inline int sub(int a, int b) { return a - b >= 0 ? a - b : a - b + P; } inline void mulmod(int &a, int b) { a = mul(a, b); } inline void addmod(int &a, int b) { ((a += b) >= P) && (a -= P); } inline void submod(int &a, int b) { ((a -= b) < 0) && (a += P); } inline int ksm(int a, int b) { int ans = 1; for (; b; b >>= 1) { if (b & 1) ans = 1ll * ans * a % P; a = 1ll * a * a % P; } return ans; } inline int inv(int a) { return ksm(a, P - 2); } namespace FastIO { const int SIZE = 1 << 16; char buf[SIZE], obuf[SIZE], str[64]; int bi = SIZE, bn = SIZE, opt; int read(char *s) { while (bn) { for (; bi < bn && buf[bi] <= ; bi++) ; if (bi < bn) break; bn = fread(buf, 1, SIZE, stdin), bi = 0; } int sn = 0; while (bn) { for (; bi < bn && buf[bi] > ; bi++) s[sn++] = buf[bi]; if (bi < bn) break; bn = fread(buf, 1, SIZE, stdin), bi = 0; } s[sn] = 0; return sn; } bool read(int &x) { if (x) x = 0; int bf = 0, n = read(str); if (!n) return 0; int i = 0; if (str[i] == - ) bf = 1, i = 1; for (x = 0; i < n; i++) x = x * 10 + str[i] - 0 ; if (bf) x = -x; return 1; } void write(int x) { if (!x) obuf[opt++] = 0 ; else { if (x < 0) obuf[opt++] = - , x = -x; int sn = 0; while (x) str[sn++] = x % 10 + 0 , x /= 10; for (int i = sn - 1; i >= 0; i--) obuf[opt++] = str[i]; } if (opt >= (SIZE >> 1)) { fwrite(obuf, 1, opt, stdout); opt = 0; } } void write(char x) { obuf[opt++] = x; if (opt >= (SIZE >> 1)) { fwrite(obuf, 1, opt, stdout); opt = 0; } } void Fflush() { if (opt) fwrite(obuf, 1, opt, stdout); opt = 0; } }; // namespace FastIO inline int read() { int x; FastIO::read(x); return x; } const int MN = 1e5 + 5; int n, dis[MN], dx, dy; vector<pair<int, int> > e[MN]; void dfs1(int op, int u, int fa) { if (op == 0 && dis[u] > dis[dx]) dx = u; if (op == 1 && dis[u] > dis[dy]) dy = u; for (auto it : e[u]) { int v = it.first, w = it.second; if (v == fa) continue; dis[v] = dis[u] + w; dfs1(op, v, u); } } struct Tr { int f[MN][21], g[MN][21], len[MN], top[MN], rk[MN], rt, lf[MN], s[MN], cnt, sum[MN], lson[MN]; void dfs1(int u, int fa, int fr) { f[u][0] = fa, g[u][0] = fr; for (int i = 1; i <= 20; i++) f[u][i] = f[f[u][i - 1]][i - 1], g[u][i] = g[f[u][i - 1]][i - 1] + g[u][i - 1]; for (auto it : e[u]) { int v = it.first, w = it.second; if (v == fa) continue; dfs1(v, u, w); ckmax(len[u], len[v] + w); } } void dfs2(int u, int tp) { top[u] = tp; lson[u] = 0; for (auto it : e[u]) { int v = it.first, w = it.second; if (v != f[u][0] && len[v] + w == len[u]) lson[u] = v; } if (!lson[u]) return void(); dfs2(lson[u], tp); for (auto it : e[u]) { int v = it.first; if (v != f[u][0] && v != lson[u]) s[lf[++cnt] = v] = len[v] + it.second, dfs2(v, v); } } void init() { dfs1(rt, 0, 0); dfs2(rt, rt); s[lf[++cnt] = rt] = len[rt]; sort(lf + 1, lf + 1 + cnt, [&](int i, int j) { return s[i] > s[j]; }); for (int i = (1); i <= (cnt); i++) { int u = lf[i]; sum[i] = sum[i - 1] + s[u]; while (u) rk[u] = i, u = lson[u]; } } int qry(int x, int y) { y = 2 * y - 1; if (rk[x] <= y) return sum[y]; else { int z = len[x]; for (int i = 20; i >= 0; i--) { if (rk[f[x][i]] > y) z += g[x][i], x = f[x][i]; } return max(sum[y - 1] + z + g[x][0], sum[y] - len[f[x][0]] + z + g[x][0]); } } } t[2]; signed main() { int q, k = 0, s = 0; n = read(), q = read(); for (int i = (1); i <= (n - 1); i++) { int u = read(), v = read(), w = read(); e[u].push_back(make_pair(v, w)), e[v].push_back(make_pair(u, w)); s += w; } for (int i = (1); i <= (n); i++) k += e[i].size() == 1; dfs1(0, 1, 0); memset(dis, 0, sizeof(dis)); dfs1(1, dx, 0); t[0].rt = dx, t[1].rt = dy; t[0].init(); t[1].init(); int lstans = 0; while (q--) { int x = (read() + lstans - 1) % n + 1, y = (read() + lstans - 1) % n + 1; if (2 * y >= k) printf( %d n , lstans = s); else printf( %d n , lstans = max(t[0].qry(x, y), t[1].qry(x, y))); } return 0; }
|
#include <bits/stdc++.h> long long int a, b; int main() { scanf( %lld %lld , &a, &b); if (a % 2 == 0) { if (2 * b - 1 < a) { printf( %lld , 2 * b - 1); } else { printf( %lld , (b - a / 2) * 2); } } else { if (2 * b - 1 <= a) { printf( %lld , 2 * b - 1); } else { printf( %lld , ((b - a / 2) - 1) * 2); } } return 0; }
|
#include <bits/stdc++.h> using namespace std; const int maxn = 300100; int n, m, a[maxn], ans = -1; int f[maxn][30], du[maxn], Time; char s[maxn]; int dfn[maxn], low[maxn]; vector<int> g[maxn]; vector<int>::iterator it; bool loop = 0, in[maxn]; stack<int> q; void dfs(int x) { dfn[x] = low[x] = ++Time; in[x] = 1; q.push(x); for (int i = 0; i < g[x].size(); ++i) { int k = g[x][i]; if (!dfn[k]) { dfs(k); low[x] = min(low[x], low[k]); } else if (in[k] && dfn[k] < low[x]) { low[x] = min(low[x], dfn[k]); } for (int j = 0; j < 26; ++j) { f[x][j] = max(f[x][j], f[k][j]); } } if (dfn[x] == low[x]) { int cnt = 0; while (1) { int tem = q.top(); q.pop(); cnt++; in[tem] = 0; if (tem == x) break; } if (cnt > 1) loop = 1; } ++f[x][a[x]]; } int main() { scanf( %d%d , &n, &m); scanf( %s , s + 1); for (int i = 1; i <= n; ++i) { a[i] = s[i] - a ; } for (int i = 1, x, y; i <= m; ++i) { scanf( %d%d , &x, &y); if (x == y) loop = 1; g[x].push_back(y), du[y]++; } if (loop) { printf( -1 n ); return 0; } for (int i = 1; i <= n; ++i) { if (!du[i]) { dfs(i); if (loop == 1) { printf( -1 n ); return 0; } for (int j = 0; j < 26; ++j) { ans = max(f[i][j], ans); } } } printf( %d n , ans); return 0; }
|
#include <bits/stdc++.h> using namespace std; int n, m, cnt, ans[200009], sum[200009], dp[200009][26], s1[200009], s2[200009], f[200009]; char a[200009], b[200009]; void solve(int u, int v) { int i; for (i = 1; i <= n; i++) s1[i] = (a[i] == a + u); for (i = 1; i <= m; i++) { s2[i] = (b[i] == a + v); if (i > 1) { f[i] = f[i - 1]; for (; f[i] && s2[f[i] + 1] != s2[i]; f[i] = f[f[i]]) ; f[i] += (s2[f[i] + 1] == s2[i]); } } int k = 1; for (i = 1; i <= n; i++) { for (; k && s2[k + 1] != s1[i]; k = f[k]) ; k += (s2[k + 1] == s1[i]); if (k == m) { dp[i - m + 1][u] = v; k = f[k]; } } } int main() { scanf( %d%d%s%s , &n, &m, a + 1, b + 1); int i, j; memset(dp, -1, sizeof(dp)); for (i = 0; i < 26; i++) { for (j = 0; j < 26; j++) solve(i, j); for (j = 1; j <= n; j++) { sum[j] = sum[j - 1] + (a[j] == a + i); if (j >= m && sum[j] == sum[j - m]) dp[j - m + 1][i] = -2; } } for (i = 1; i <= n - m + 1; i++) { for (j = 0; j < 26; j++) { if (dp[i][j] == -1) break; if (dp[i][j] == -2) continue; if (dp[i][dp[i][j]] == -2) dp[i][dp[i][j]] = j; if (dp[i][dp[i][j]] != j) break; } if (j == 26) ans[++cnt] = i; } printf( %d n , cnt); for (i = 1; i <= cnt; i++) printf( %d%c , ans[i], i < cnt ? : n ); return 0; }
|
#include <bits/stdc++.h> using namespace std; long long int P; long long int a[501]; long long int dp[501][501]; void solve() { long long int n, m, b, P, i, j, k; cin >> n >> m >> b >> P; for (i = 1; i <= n; i++) { cin >> a[i]; } memset(dp, 0, sizeof(dp)); long long int ans = 0; dp[0][0] = 1; for (i = 1; i <= n; i++) { for (j = 0; j < m; j++) { for (k = 0; k + a[i] <= b; k++) { dp[j + 1][k + a[i]] = (dp[j + 1][k + a[i]] + dp[j][k]) % P; } } } for (i = 0; i <= b; i++) { ans += dp[m][i]; ans %= P; } cout << ans % P; } int main() { long long int t = 1; while (t--) { solve(); } return 0; }
|
#include <bits/stdc++.h> using namespace std; const int maxp = 22; const long double EPS = 1e-18; const long long INF = 2e18; const int MOD = 1e9 + 7; const int N = 2e5 + 1; string s, t = hard ; long long dp[N][4]; long long arr[N]; int n; long long solve(int x, int idx) { if (idx == 4) return INF; if (x == n) return 0; if (dp[x][idx] != -1) return dp[x][idx]; int nxt = idx; if (s[x] == t[idx]) nxt++; return dp[x][idx] = min(solve(x + 1, idx) + arr[x], solve(x + 1, nxt)); } int main() { ios_base::sync_with_stdio(false); cin.tie(nullptr); cin >> n >> s; int i, j; for (i = 0; i < n; i++) cin >> arr[i]; for (i = 0; i < n; i++) for (j = 0; j < 4; j++) dp[i][j] = -1; cout << solve(0, 0) << n ; }
|
#include <bits/stdc++.h> using namespace std; const int N = 4e5 + 10; int mod = 1e9 + 7; int qpow(int a, int b) { int ans = 1; for (; b >= 1; b >>= 1, a = (long long)a * a % mod) if (b & 1) ans = (long long)ans * a % mod; return ans; } long long ans[32]; int main() { int t; scanf( %d , &t); while (t--) { int d, m, c; scanf( %d%d , &d, &mod); fill(ans, ans + 30, 0); for (c = 0; (1 << (c + 1)) <= d; c++) ; for (int i = 0; i < c; i++) ans[i] = (1ll << i) % mod; ans[c] = (d - (1ll << c) + 1) % mod; long long res = 1; for (int i = 0; i <= c; i++) res = res * (ans[i] + 1ll) % mod; res = (res + mod - 1) % mod; printf( %lld n , res); } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { long long r, g, b; cin >> r >> g >> b; long long ans = min(r, min(g, b)); long long mini = ans; if (r <= 3 && g <= 3 && b <= 3) { cout << ans << endl; return 0; } long long count = 0; r = r - ans; g = g - ans; b = b - ans; if (r % 3 == 2) { ++count; } if (g % 3 == 2) { ++count; } if (b % 3 == 2) { ++count; } ans += (r / 3) + (g / 3) + (b / 3); if (count == 2 && mini != 0) { ++ans; } cout << ans << endl; }
|
#include <bits/stdc++.h> using namespace std; int const M = 4e5 + 20; int a[M], ans[M], l[M], r[M], ty[M], cnt[M], sv[M]; vector<pair<int, int> > qu[M]; int main() { int n, q; cin >> n >> q; for (int i = 1; i <= n; i++) cin >> a[i]; for (int i = 1; i <= q; i++) { int ind, nu; cin >> ind >> nu; qu[ind].push_back(make_pair(nu, i)); sv[i] = ind; } vector<int> lis; for (int i = 1; i <= n; i++) { qu[i].push_back(make_pair(a[i], 0)); for (int j = 0; j < qu[i].size(); j++) { int now = qu[i][j].first; if (lis.size() == 0 || now > lis.back()) { ans[qu[i][j].second] = (int)lis.size() + 1; } else { int ind = lower_bound(lis.begin(), lis.end(), now) - lis.begin(); ans[qu[i][j].second] = ind + 1; } if (j == (int)qu[i].size() - 1) { l[i] = ans[0]; if (ans[0] == (int)lis.size() + 1) lis.push_back(a[i]); else lis[ans[0] - 1] = a[i]; } } } int best = lis.size(); lis.clear(); for (int i = n; i >= 1; i--) { for (int j = 0; j < qu[i].size(); j++) { int now = qu[i][j].first; now = -now; if (lis.size() == 0 || now > lis.back()) { ans[qu[i][j].second] += (int)lis.size(); if (j == (int)qu[i].size() - 1) { r[i] = (int)lis.size() + 1; lis.push_back(now); } } else { int ind = lower_bound(lis.begin(), lis.end(), now) - lis.begin(); ans[qu[i][j].second] += ind; if (j == (int)qu[i].size() - 1) { r[i] = ind + 1; lis[ind] = now; } } } } for (int i = 1; i <= n; i++) { if (l[i] + r[i] != best + 1) { ty[i] = 3; } else cnt[l[i]]++; } for (int i = 1; i <= n; i++) { if (ty[i] != 3 && cnt[l[i]] > 1) ty[i] = 2; else if (ty[i] != 3) ty[i] = 1; } for (int i = 1; i <= q; i++) { int tmp = ans[i]; if (ty[sv[i]] == 1) tmp = max(tmp, best - 1); else tmp = max(tmp, best); cout << tmp << n ; } }
|
#include <bits/stdc++.h> using namespace std; int v[4005], d[14005]; long long int p[4005]; bool done[4005]; vector<int> vec; int main() { int n, val, ans = 0; cin >> n; for (int i = 0; i < n; i++) { cin >> v[i] >> d[i] >> p[i]; } for (int i = 0; i < n; i++) { if (done[i]) continue; vec.push_back(i + 1); ans++; val = 0; for (int j = i + 1; j < n; j++) { if (!done[j]) { if (val == v[i]) break; p[j] -= v[i] - val; val++; } } long long int val = 0; for (int j = i + 1; j < n; j++) { if (done[j] == 1) continue; p[j] -= val; if (p[j] < 0) { val += d[j]; done[j] = 1; } } } sort(vec.begin(), vec.end()); cout << ans << endl; for (int i = 0; i < vec.size(); i++) cout << vec[i] << ; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n; string s; int total = 0; cin >> n; for (int i = 0; i < n; i++) { cin >> s; if (s == ++X || s == X++ ) { total++; } else { total--; } } cout << total; }
|
#include <bits/stdc++.h> using namespace std; long long cnt[200010]; void f(long long x) { while (x) { cnt[x]++; x /= 2; } cnt[0]++; } long long count(long long x, long long y) { long long sol = INT32_MAX, cnt = 0; while (x != y) { if (!x) break; ++cnt; x /= 2; } if (!x && y) return sol; return cnt; } signed main() { ios_base::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr); cerr.tie(nullptr); long long n, k; cin >> n >> k; vector<long long> a(n); long long maxi = 0; for (auto& i : a) { cin >> i; f(i); maxi = max(maxi, i); } long long sol = INT32_MAX; for (long long i = 0; i <= maxi; ++i) { if (cnt[i] < k) continue; long long res = 0; vector<long long> t; for (long long j = 0; j < n; ++j) { t.push_back(count(a[j], i)); } sort(t.begin(), t.end()); for (long long j = 0; j < k; ++j) res += t[j]; sol = min(sol, res); } cout << sol << n ; }
|
#include <bits/stdc++.h> using namespace std; struct comp { bool operator()(const vector<int>& lhs, const vector<int>& rhs) const { return lhs.size() > rhs.size(); } }; struct comps { bool operator()(const string& lhs, const string& rhs) const { return lhs > rhs; } }; bool ff(pair<int, int> a, pair<int, int> b) { return a.first < b.first; } double dis(double x1, double y1, double x2, double y2) { return sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1)); } int gcd(long long unsigned int a, long long unsigned int b) { return (b == 0) ? a : gcd(b, a % b); } int comb(int a, int b) { if (a == 0) return 1; if (a < b) return 1; if (a == b) return 1; if (b == 1) return a; if (b == 0) return 1; long long unsigned int aa = 1, bb = 1; for (int i = b; i > 0; i--, a--) { aa *= a; bb *= i; int gc = gcd(aa, bb); if (gc > 1) { aa /= gc; bb /= gc; } } return aa % 1000000007; } bool isprime(long long unsigned int n) { for (int i = 2; i <= sqrt(n); i++) if (n % i == 0) return false; return true; } bool f(pair<int, int> p1, pair<int, int> p2) { if (p1.first < p2.first) return true; else if ((p1.first == p2.first) && (p1.second > p2.second)) return true; else return false; } int t[100005]; int x[100005]; int v[100005]; int main() { int n, m; scanf( %d%d , &n, &m); for (int i = 0; i < n; i++) cin >> t[i] >> x[i]; int i = 0; int nn = n; int kalkis = 0; int delay = 0; while (n > 0) { int p = (n >= m) ? m : n; n -= p; kalkis = (t[i + p - 1] > (kalkis + delay)) ? t[i + p - 1] : (kalkis + delay); map<int, int> mapp; map<int, vector<int> > duranlar; for (int j = i; j < i + p; j++) { mapp[x[j]]++; duranlar[x[j]].push_back(j); } map<int, int>::iterator it; delay = 0; for (it = mapp.begin(); it != mapp.end(); it++) { for (int k = 0; k < duranlar[it->first].size(); k++) { v[duranlar[it->first][k]] = kalkis + delay + (it->first); } delay += 1 + (it->second) / 2; } it--; delay += 2 * (it->first); i += p; } for (int i = 0; i < nn; i++) cout << v[i] << ; return 0; }
|
#include <bits/stdc++.h> using namespace std; vector<int> edge[20]; int n, t; string a, b; bitset<20> used; void DFS(int h) { used[h] = true; for (auto &i : edge[h]) if (!used[i]) DFS(i); } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); cin >> t; while (t--) { cin >> n; cin >> a >> b; for (auto &i : edge) i.clear(); bool check = false; for (int i = 0; i <= n - 1; i++) { if (a[i] == b[i]) continue; if (a[i] > b[i]) { check = true; break; } edge[a[i] - a ].push_back(b[i] - a ); edge[b[i] - a ].push_back(a[i] - a ); } if (check) { cout << -1 << n ; continue; } used.reset(); int ans = 20; for (int i = 0; i <= 19; i++) { if (!used[i]) { DFS(i); ans--; } } cout << ans << n ; } return 0; }
|
#include<bits/stdc++.h> #define rep(i,st,en) for(int i=st;i<=en;i++) using namespace std; typedef long long ll; int t,x,y,i,n; int main() { scanf( %d ,&t); while(t--) { scanf( %d ,&n); rep(i,1,n)scanf( %d ,&x); printf( %d n ,3*n); rep(i,1,n/2) { x=2*i-1; y=2*i; printf( 2 %d %d n ,x,y); printf( 2 %d %d n ,x,y); printf( 1 %d %d n ,x,y); printf( 2 %d %d n ,x,y); printf( 2 %d %d n ,x,y); printf( 1 %d %d n ,x,y); } //TODO } return 0; }
|
#include <bits/stdc++.h> using namespace std; const int MAXN = 1e5 + 10; int n, sz; vector<int> vec[MAXN]; int main() { ios::sync_with_stdio(false); cin.tie(0); cin >> n; cout << n - 1 << n ; for (int i = 0; i < n - 1; i++) { int a, b; cin >> a >> b; a--, b--; vec[a].push_back(sz); vec[b].push_back(sz++); cout << 2 << << a + 1 << << b + 1 << n ; } for (int i = 0; i < n; i++) for (int j = 1; j < vec[i].size(); j++) cout << vec[i][j - 1] + 1 << << vec[i][j] + 1 << n ; return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; vector<char> a; char x; for (int i = 0; i < n; i++) { cin >> x; a.push_back(x); } for (int i = 0; i < a.size(); i++) { if (a[i] == U && a[i + 1] == R ) { a.erase(a.begin() + i); a[i] = D ; } if (a[i] == R && a[i + 1] == U ) { { a.erase(a.begin() + i); a[i] = D ; } } } cout << a.size(); return 0; }
|
#include <bits/stdc++.h> using namespace std; long long p[1100000], r[1100000], cnt; int main() { long long n, bac; cin >> n; if (n == 1) { printf( 1 n ); return 0; } bac = n; long long i; for (i = 2; i * i <= n; i++) { if (bac % i == 0) { cnt++; p[cnt] = i; while (bac % i == 0) { bac /= i; r[cnt]++; } } } if (bac != 1) { cnt++; p[cnt] = bac; } if (cnt == 1) cout << p[1] << endl; else printf( 1 n ); return 0; }
|
#include <bits/stdc++.h> using namespace std; const int N = 100100; const int LOGN = 15; struct TreeGraph { vector<int> *graph; vector<int> heights; vector<int> *d; vector<int> weights; vector<int> mapNodes; int n, nAritculationPoints; ; TreeGraph(){}; TreeGraph(int nArtiPoints) : nAritculationPoints(nArtiPoints) { graph = new vector<int>[N * 2]; d = new vector<int>[LOGN]; } ~TreeGraph() { delete[] graph; heights.clear(); delete[] d; weights.clear(); mapNodes.clear(); } void addEdge(int u, int v) { if (u >= N * 2) cerr << u; if (v >= N * 2) cerr << v; graph[u].push_back(v); graph[v].push_back(u); } void print() { for (int i = 0; i < n; i++) { printf( n%d: , i); for (auto v : graph[i]) printf( %d , v); } printf( n______ n ); } void setN(int n, vector<int> mapNodes) { this->n = n; this->mapNodes = mapNodes; heights = vector<int>(n); weights = vector<int>(n); for (int i = 0; i < LOGN; i++) d[i] = vector<int>(n); } void preprocess() { dfs(0, -1, 0, 0); } int lca(int u, int v) { if (heights[v] > heights[u]) swap(u, v); int nSteps = heights[u] - heights[v]; while (nSteps > 0) { int step = log2(nSteps); u = d[step][u], nSteps -= 1 << step; } while (u != v) { int i = log2(heights[u]); for (; i >= 0; i--) if (d[i][u] != d[i][v]) break; if (i < 0) u = d[0][u], v = d[0][v]; else u = d[i][u], v = d[i][v]; } return u; } int sumPath(int u, int v) { int lcaAndU = lca(u, v); return weights[u] + weights[v] - 2 * weights[lcaAndU] + (lcaAndU >= nAritculationPoints); } void dfs(int u, int parent, int weight, int height) { weight += u < nAritculationPoints ? 0 : 1; weights[u] = weight, heights[u] = height; d[0][u] = parent; for (int i = 1; 1 << i <= height; i++) d[i][u] = d[i - 1][d[i - 1][u]]; for (auto v : graph[u]) { if (v == parent) continue; dfs(v, u, weight, height + 1); } } int solve(int u, int v) { u = mapNodes[u], v = mapNodes[v]; if (u == v) return 1; return sumPath(u, v); } }; struct GraphSolver { vector<int> *graph; vector<int> low, ids; vector<bool> isArticulationPoint; vector<int> stacks; vector<vector<int>> comps; int n, id; GraphSolver(); ~GraphSolver() { ids.clear(); delete[] graph; isArticulationPoint.clear(); low.clear(); stacks.clear(); } GraphSolver(int n) : low(n), ids(n, -1), isArticulationPoint(n, false), id(0), n(n) { graph = new vector<int>[n]; }; void addEdge(int u, int v) { graph[u].push_back(v), graph[v].push_back(u); } void dfs(int u, int parent) { low[u] = ids[u] = id++; stacks.push_back(u); int children = 0; for (auto v : graph[u]) { if (v == parent) continue; if (ids[v] != -1) { low[u] = min(low[u], ids[v]); } else { dfs(v, u); low[u] = min(low[v], low[u]); children++; if ((low[v] >= ids[u] && parent != -1) || (parent == -1 && children > 1)) { isArticulationPoint[u] = true; vector<int> comp = vector<int>{u}; while (comp.back() != v) { comp.push_back(stacks.back()); stacks.pop_back(); } comps.push_back(comp); } } } } TreeGraph buildBlockCutTree() { dfs(0, -1); if (!stacks.empty()) { vector<int> comp; while (!stacks.empty()) { comp.push_back(stacks.back()); stacks.pop_back(); } comps.push_back(comp); } vector<int> mapNodes = vector<int>(n); int nNodes = 0; for (int i = 0; i < n; i++) if (isArticulationPoint[i]) mapNodes[i] = nNodes++; auto tree = TreeGraph(nNodes); for (auto comp : comps) { for (auto v : comp) { if (!isArticulationPoint[v]) mapNodes[v] = nNodes; else tree.addEdge(mapNodes[v], nNodes); } nNodes++; } tree.setN(nNodes, mapNodes); return tree; } }; int main() { int n, m, q; scanf( %d %d %d n , &n, &m, &q); int u, v; GraphSolver *solver = new GraphSolver(n); for (int i = 0; i < m; i++) { scanf( %d %d n , &u, &v); solver->addEdge(u - 1, v - 1); } auto tree = solver->buildBlockCutTree(); delete (solver); tree.preprocess(); for (int i = 0; i < q; i++) { scanf( %d %d n , &u, &v); printf( %d n , tree.solve(u - 1, v - 1)); } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n; scanf( %d , &n); vector<int> r(7, 0); string den; for (int i = 0; i < n; i++) { cin >> den; for (int j = 0; den[j] != 0 ; j++) { r[j] += den[j] == 1 ; } } int m = 0; for (int i = 0; i < 7; i++) { m = max(m, r[i]); } printf( %d n , m); getchar(); getchar(); }
|
#include <bits/stdc++.h> using namespace std; static const int len = 1000010; struct event { int t, x, y, tip, num; event() {} event(int _t, int _x, int _y, int _tip, int _num) : t(_t), x(_x), y(_y), tip(_tip), num(_num) {} }; bool compar(event one, event two) { return ((one.x < two.x) || (one.x == two.x && one.tip > two.tip)); } int n, m, globans; int s[len], f[len], t[len]; int l[len], r[len], b[len], ans[len]; int tt[len * 4], xx[len * 4], tint[len * 4], xint[len * 4]; int tnum, xnum; vector<event> a; int tree[len * 4], number[len * 4]; int _count; inline int findcord(int x) { int left = 1, right = xnum; while (left < right) { int midle = (left + right + 1) / 2; if (xx[midle] <= x) left = midle; else right = midle - 1; } return xint[left]; } inline int findtime(int x) { int left = 1, right = tnum; while (left < right) { int midle = (left + right + 1) / 2; if (tt[midle] <= x) left = midle; else right = midle - 1; } return tint[left]; } void update(int root, int l, int r, int x0, int len, int num) { if (l == r) { if (tree[root] < len) { tree[root] = len; number[root] = num; } return; } int m = (l + r) / 2; if (x0 <= m) update(root * 2, l, m, x0, len, num); else update(root * 2 + 1, m + 1, r, x0, len, num); if (tree[root * 2] > tree[root]) { tree[root] = tree[root * 2]; number[root] = number[root * 2]; } if (tree[root * 2 + 1] > tree[root]) { tree[root] = tree[root * 2 + 1]; number[root] = number[root * 2 + 1]; } } pair<int, int> _max(pair<int, int> a, pair<int, int> b) { if (a.first >= b.first) return a; else return b; } pair<int, int> getmax(int root, int l, int r, int L, int R) { if (r < l || R < L) return make_pair(0, 0); if (l == L && r == R) { pair<int, int> t = make_pair(tree[root], number[root]); return t; } int m = (l + r) / 2; return _max(getmax(root * 2, l, m, L, min(m, R)), getmax(root * 2 + 1, m + 1, r, max(m + 1, L), R)); } int findans(int root, int l, int r, int L, int R, int lim) { if (r < l || R < L) return -1; if (l == r) { return number[root]; } int m = (l + r) / 2; pair<int, int> one = getmax(root * 2, l, m, L, min(m, R)); pair<int, int> two = getmax(root * 2 + 1, m + 1, r, max(m + 1, L), R); if (one.first >= lim) return findans(root * 2, l, m, L, min(m, R), lim); else if (two.first >= lim) return findans(root * 2 + 1, m + 1, r, max(m + 1, L), R, lim); else return -1; } int main() { scanf( %d%d , &n, &m); xnum = tnum = 0; for (int i = (1); (i) <= (n); (i)++) { scanf( %d%d%d , &s[i], &f[i], &t[i]); tt[++tnum] = t[i]; xx[++xnum] = s[i]; xx[++xnum] = f[i]; } for (int i = (1); (i) <= (m); (i)++) { scanf( %d%d%d , &l[i], &r[i], &b[i]); tt[++tnum] = b[i]; xx[++xnum] = l[i]; xx[++xnum] = r[i]; ans[i] = -1; } sort(xx + 1, xx + 1 + xnum); sort(tt + 1, tt + 1 + tnum); xint[1] = 1; for (int i = (2); (i) <= (xnum); (i)++) xint[i] = xint[i - 1] + int(xx[i] != xx[i - 1]); tint[1] = 1; for (int i = (2); (i) <= (tnum); (i)++) tint[i] = tint[i - 1] + int(tt[i] != tt[i - 1]); for (int i = (1); (i) <= (n); (i)++) { s[i] = findcord(s[i]); f[i] = findcord(f[i]); t[i] = findtime(t[i]); a.push_back(event(t[i], s[i], f[i], 1, i)); } for (int i = (1); (i) <= (m); (i)++) { l[i] = findcord(l[i]); r[i] = findcord(r[i]); b[i] = findtime(b[i]); a.push_back(event(b[i], l[i], r[i], 0, i)); } _count = tint[tnum]; sort(a.begin(), a.end(), compar); for (int i = 0; i < a.size(); i++) { if (a[i].tip == 0) { int q = findans(1, 1, _count, a[i].t, _count, a[i].y); ans[a[i].num] = q; } else { update(1, 1, _count, a[i].t, a[i].y, a[i].num); } } for (int i = (1); (i) <= (m); (i)++) printf( %d n , ans[i]); return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n, i, res = 0, j, mid, a[6] = {}, b[6] = {}; cin >> n; for (i = 0; i < n; i++) { cin >> j; a[j]++; } for (i = 0; i < n; i++) { cin >> j; b[j]++; } for (i = 1; i < 6; i++) { mid = a[i] + b[i]; if (mid % 2) { cout << -1 << endl; return 0; } res += abs(a[i] - mid / 2); } cout << res / 2 << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; const int INFint = 2147483647; const long long INF = 9223372036854775807ll; const long long MOD = 1000000007ll; const long double EPS = 1e-9; int p[1000]; int a[1000]; int b[1000]; int cnt; void dfs(int v) { p[v] = 1; for (int i = 1; i <= cnt; i++) { if (!p[i]) { if ((a[v] > a[i] && a[v] < b[i]) || (b[v] > a[i] && b[v] < b[i])) dfs(i); } } } int main() { ios_base::sync_with_stdio(0); int n; cin >> n; for (int i = 0; i < n; i++) { int t, x, y; cin >> t >> x >> y; if (t == 1) { cnt++; a[cnt] = x; b[cnt] = y; } else { memset(p, 0, sizeof(p)); dfs(x); if (p[y]) { cout << YES << endl; } else cout << NO << endl; } } fprintf(stderr, nTIME = %lf n , 1.0 * clock() / CLOCKS_PER_SEC); return 0; }
|
#include <bits/stdc++.h> using namespace std; double dp[100002]; int main() { double res = 0, prob = 0; int n; cin >> n; dp[0] = 0; for (int i = 0; i < n; i++) { double p; cin >> p; dp[i] = dp[i - 1] * p; res = res + p + dp[i] * 2.0; dp[i] += p; } printf( %.7lf n , res); return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n, m; cin >> n >> m; vector<int> a(n), b(n), c(n); for (int i = 0; i < n; i++) cin >> a[i]; for (int i = 0; i < n; i++) cin >> b[i]; int ans = INT_MAX; sort(a.begin(), a.end()); sort(b.begin(), b.end()); for (int i = 0; i < n; i++) { int x = (b[i] - a[0] + m) % m; for (int j = 0; j < n; j++) c[j] = (a[j] + x) % m; sort(c.begin(), c.end()); if (c == b) ans = min(ans, x); } cout << ans << endl; }
|
#include <bits/stdc++.h> const int INF = 0x3f3f3f3f; const long long LINF = 0x3f3f3f3f3f3f3f3fll; using namespace std; const double eps = 1e-6; const long long mod = 1e9 + 7; const int maxn = 1e5 + 100; const int maxe = 1e6 + 100; struct node { int to; int next; }; bool dp[maxn][2], cir; vector<int> V[maxn]; int vis[maxn][2]; int Next[maxn][2], n, m; inline bool dfs(int x, int s) { if (!V[x].size()) return s == 1; if (vis[x][s] == 2) return dp[x][s]; vis[x][s] = 1; bool t = 0; for (int i = 0; i < V[x].size(); i++) { int v = V[x][i]; if (vis[v][s ^ 1] == 1) { cir = 1; continue; } if (dfs(v, s ^ 1)) { t = 1; Next[x][s] = v; } } vis[x][s] = 2; return dp[x][s] = t; } inline void print(int x, int s) { printf( %d , x); if (Next[x][s]) { print(Next[x][s], s ^ 1); } } void Solve() { cin >> n >> m; int xx, v; for (int i = 1; i <= n; i++) { cin >> xx; for (int j = 0; j < xx; j++) { cin >> v; V[i].push_back(v); } } int st; cin >> st; if (dfs(st, 0)) { puts( Win ); print(st, 0); } else if (cir) puts( Draw ); else puts( Lose ); } int main() { int Case = 1, cases; while (Case--) { Solve(); } return 0; }
|
#include <bits/stdc++.h> using namespace std; using db = long double; using pll = pair<long long, long long>; int32_t main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); long long t, i, x, j, y, z, k, n; long long tt; cin >> tt; for (long long _tt = 0; _tt < tt; _tt++) { cin >> n; z = 0; while (n != 1) { if (n % 6 == 0) n /= 6; else if ((n * 2) % 6 == 0) n *= 2; else { z = -1; break; } z++; } cout << z << n ; } }
|
#include <bits/stdc++.h> #pragma comment(linker, /STACK:16000000 ) using namespace std; const int inf = 0x3f3f3f3f; const long long inf2 = 0x3f3f3f3f3f3f3f3f; const double eps = 1e-6; const int mod = 1000000007; namespace fastio { char in[100000]; int itr = 0, llen = 0; char get() { if (itr == llen) llen = fread(in, 1, 100000, stdin), itr = 0; if (llen == 0) return EOF; return in[itr++]; } char out[100000]; int itr2 = 0; void put(char c) { out[itr2++] = c; if (itr2 == 100000) { fwrite(out, 1, 100000, stdout); itr2 = 0; } } int clear() { fwrite(out, 1, itr2, stdout); itr2 = 0; return 0; } int getint() { int r = 0; bool ng = 0; char c; c = get(); while (c != - && (c < 0 || c > 9 )) c = get(); if (c == - ) ng = 1, c = get(); while (c >= 0 && c <= 9 ) r = r * 10 + c - 0 , c = get(); return ng ? inf : r; } string getstr() { string ret = ; char ch = get(); while (ch == || ch == n ) ch = get(); while (ch != && ch != n ) ret.push_back(ch), ch = get(); return ret; } void putstr(string s) { for (int i = 0; i < s.size(); i++) put(s[i]); } void putint(int x) { if (x == 0) { put( 0 ); return; } char c[20]; int pos = 0; while (x) { c[pos++] = 0 + x % 10; x /= 10; } for (int i = pos - 1; i >= 0; i--) put(c[i]); } void getarr(int arrname[], int size) { for (int i = 0; i < size; i++) arrname[i] = getint(); } } // namespace fastio using namespace fastio; int n, m; bool used[111111 * 5]; vector<int> g[111111 * 5]; int deg[111111 * 5]; vector<pair<int, int> > edges; vector<int> ans; void dfs(int x, int par) { used[x] = true; ans.push_back(x); for (auto p : g[x]) { deg[p]--; if (deg[p] == 0) dfs(p, x); } } int main() { n = getint(); m = getint(); vector<vector<int> > vec(n, vector<int>(m)); for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) vec[i][j] = getint(); int pre = m; for (int i = 0; i < n; i++) { bool buff = (i == 0); vector<pair<int, int> > V; for (int j = 0; j < m; j++) V.push_back(make_pair(vec[i][j], j)); sort(V.begin(), V.end()); while (V.back().first == inf) V.pop_back(); if (!V.size()) continue; int pos = 0; set<int> Set; Set.clear(); for (int ii = 0; ii < V.size(); ii++) { Set.insert(V[ii].first); } bool first = true; for (set<int>::iterator itr = Set.begin(); itr != Set.end(); itr++) { int p = *itr; set<int>::iterator itr2 = itr; itr2++; bool last = itr2 == Set.end(); for (int &t = pos; t < V.size() && V[t].first == p; t++) { if (!first) g[pre].push_back(V[t].second), deg[V[t].second]++, cerr << V[t].second << endl; if (Set.size() != 1 && !last) g[V[t].second].push_back(pre + 1), deg[pre + 1]++, cerr << pre << endl; } if (Set.size() != 1) pre++; first = false; } } cerr << Start top sort: n ; for (int i = 0; i < pre; i++) if (!used[i] && !deg[i]) dfs(i, -1); vector<int> ans2; ans2.clear(); for (int i = 0; i < ans.size(); i++) if (ans[i] < m) ans2.push_back(ans[i]); if (ans2.size() < m) { puts( -1 ); return 0; } else { for (int i = 0; i < ans2.size(); i++) putint(ans2[i] + 1), put( ); return clear(); } return 0; }
|
#include <bits/stdc++.h> using namespace std; const int INF = 0x3f3f3f3f; const long long INFLL = 0x3f3f3f3f3f3f3f3fLL; inline long long read() { long long x = 0, f = 1; char ch = getchar(); while (ch < 0 || ch > 9 ) { if (ch == - ) f = -1; ch = getchar(); } while (ch >= 0 && ch <= 9 ) { x = x * 10 + ch - 0 ; ch = getchar(); } return x * f; } const int maxn = 1e5 + 10; const int mod = 1e9 + 7; string s; int len, match[1005]; long long dp[1000][1000][3][3]; void get_match() { stack<int> sta; for (int i = 0; i < len; i++) { if (s[i] == ( ) sta.push(i); else { int t = sta.top(); sta.pop(); match[i] = t; match[t] = i; } } } void dfs(int l, int r) { if (l + 1 == r) { dp[l][r][0][1] = 1; dp[l][r][1][0] = 1; dp[l][r][0][2] = 1; dp[l][r][2][0] = 1; return; } if (match[l] == r) { dfs(l + 1, r - 1); for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++) { if (j != 1) dp[l][r][0][1] = (dp[l][r][0][1] + dp[l + 1][r - 1][i][j]) % mod; if (i != 1) dp[l][r][1][0] = (dp[l][r][1][0] + dp[l + 1][r - 1][i][j]) % mod; if (j != 2) dp[l][r][0][2] = (dp[l][r][0][2] + dp[l + 1][r - 1][i][j]) % mod; if (i != 2) dp[l][r][2][0] = (dp[l][r][2][0] + dp[l + 1][r - 1][i][j]) % mod; } return; } else { int k = match[l]; dfs(l, k); dfs(k + 1, r); for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++) for (int x = 0; x < 3; x++) for (int y = 0; y < 3; y++) { if ((x == 1 && y == 1) || (x == 2 && y == 2)) continue; dp[l][r][i][j] = (dp[l][r][i][j] + dp[l][k][i][x] * dp[k + 1][r][y][j]) % mod; } return; } } int main() { memset(dp, 0, sizeof(dp)); cin >> s; len = s.size(); get_match(); dfs(0, len - 1); long long ans = 0; for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++) ans = (ans + dp[0][len - 1][i][j]) % mod; cout << ans << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; long long dp[5050][505]; pair<long long, long long> pre[5050][505]; signed main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); long long d, s; cin >> d >> s; queue<pair<long long, long long>> q; for (long long i = 1; i < 10; i++) { dp[i][i % d] = 1; q.push({i, i % d}); } while (q.size()) { pair<long long, long long> curr = q.front(); q.pop(); long long sum = curr.first; long long div = curr.second; for (long long i = 0; i <= 9; i++) { long long curr_sum = sum + i; long long curr_div = (div * 10 + i) % d; if (curr_sum <= s and !dp[curr_sum][curr_div]) { dp[curr_sum][curr_div] = dp[sum][div] + 1; q.push({curr_sum, curr_div}); pre[curr_sum][curr_div] = {sum, div}; } } } if (!dp[s][0]) { cout << -1; } else { vector<long long> ans; long long sum = s, div = 0; while (true) { if (dp[sum][div] == 1) { ans.push_back(sum); break; } else { pair<long long, long long> curr = pre[sum][div]; ans.push_back(sum - curr.first); sum = curr.first; div = curr.second; } } reverse(ans.begin(), ans.end()); for (auto x : ans) { cout << x; } } }
|
#include <bits/stdc++.h> using namespace std; const int MAXN = 1010; struct Modify { bool add; int a, b; }; int n, m, t; vector<int> x[MAXN]; map<int, int> h; vector<int> s; vector<Modify> ans; int losestate[1 << 20]; int winstate[1 << 20]; void BuildBase() { int out[MAXN]; vector<int> y[MAXN]; for (int i = 1; i <= n; ++i) { out[i] = x[i].size(); y[i].clear(); } for (int i = 1; i <= n; ++i) { for (int b : x[i]) y[b].push_back(i); } queue<int> q; for (int i = 1; i <= n; ++i) { if (out[i] == 0) { q.push(i); } } while (!q.empty() && s.size() < 20) { int a = q.front(); q.pop(); s.push_back(a); h[a] = s.size() - 1; for (int b : y[a]) { --out[b]; if (out[b] == 0) q.push(b); } } int z[20][20]; memset(z, 0, sizeof(z)); for (int i = 0; i < s.size(); ++i) { for (int b : x[s[i]]) z[i][h[b]] = true; } for (int i = 0; i < s.size(); ++i) { for (int j = 0; j < s.size(); ++j) { if (z[i][j] && i <= j) { ans.push_back({false, s[i], s[j]}); } if (!z[i][j] && i > j) { ans.push_back({true, s[i], s[j]}); } } } for (int i = 0; i < s.size(); ++i) { losestate[1 << i] = s[i]; } } void ModifyGraph() { bool sz[1 << 20]; memset(sz, 0, sizeof(sz)); sz[0] = true; for (int i = 1; i <= n; ++i) { if (h.find(i) != h.end()) continue; ans.push_back({true, i, i}); int state = 0; for (int b : x[i]) { if (h.find(b) == h.end()) continue; state |= (1 << h[b]); } if (!sz[state]) { sz[state] = true; winstate[state] = i; continue; } bool finished = false; for (int p = 0; p < 20; ++p) { int newst = state ^ (1 << p); if (sz[newst]) continue; finished = true; sz[newst] = true; winstate[newst] = i; if (state & (1 << p)) { ans.push_back({false, i, s[p]}); } else { ans.push_back({true, i, s[p]}); } if (finished) break; } if (finished) continue; for (int p = 0; p < 20; ++p) { for (int q = p + 1; q < 20; ++q) { int newst = state ^ (1 << p) ^ (1 << q); if (sz[newst]) continue; finished = true; sz[newst] = true; winstate[newst] = i; for (int o : {p, q}) { if (state & (1 << o)) { ans.push_back({false, i, s[o]}); } else { ans.push_back({true, i, s[o]}); } } if (finished) break; } if (finished) break; } if (finished) continue; for (int p = 0; p < 20; ++p) { for (int q = p + 1; q < 20; ++q) { for (int r = q + 1; r < 20; ++r) { int newst = state ^ (1 << p) ^ (1 << q) ^ (1 << r); if (sz[newst]) continue; finished = true; sz[newst] = true; winstate[newst] = i; for (int o : {p, q, r}) { if (state & (1 << o)) { ans.push_back({false, i, s[o]}); } else { ans.push_back({true, i, s[o]}); } } if (finished) break; } if (finished) break; } if (finished) break; } } } int main() { ios::sync_with_stdio(false); cin >> n >> m >> t; for (int i = 0; i < m; ++i) { int a, b; cin >> a >> b; x[a].push_back(b); } BuildBase(); ModifyGraph(); cout << ans.size() << endl; for (int i = 0; i < ans.size(); ++i) { if (ans[i].add) cout << + ; else cout << - ; cout << ans[i].a << << ans[i].b << endl; } cout << flush; while (t--) { int win = 0, lose = 0, draw = 0; for (int i = 0; i < s.size(); ++i) { cout << ? 1 << s[i] << endl << flush; string st; cin >> st; if (st == Win ) { win |= (1 << i); } else if (st == Lose ) { lose |= (1 << i); } else { draw |= (1 << i); } } int ans = 0; if (lose > 0) { ans = losestate[lose]; } else { ans = winstate[win]; } cout << ! << ans << endl << flush; string st; cin >> st; if (st != Correct ) return 0; } return 0; }
|
#include <bits/stdc++.h> using namespace std; template <int MOD, int RT> struct Mint { static const int mod = MOD; static constexpr Mint rt() { return RT; } int v; explicit operator int() const { return v; } Mint() { v = 0; } Mint(long long _v) { v = int((-MOD < _v && _v < MOD) ? _v : _v % MOD); if (v < 0) v += MOD; } friend bool operator==(const Mint& a, const Mint& b) { return a.v == b.v; } friend bool operator!=(const Mint& a, const Mint& b) { return !(a == b); } friend bool operator<(const Mint& a, const Mint& b) { return a.v < b.v; } friend bool operator>(const Mint& a, const Mint& b) { return a.v > b.v; } friend bool operator<=(const Mint& a, const Mint& b) { return a.v <= b.v; } friend bool operator>=(const Mint& a, const Mint& b) { return a.v >= b.v; } friend istream& operator>>(istream& in, Mint& a) { long long x; cin >> x; a = Mint(x); return in; } friend ostream& operator<<(ostream& os, const Mint& a) { return os << a.v; } Mint& operator+=(const Mint& m) { if ((v += m.v) >= MOD) v -= MOD; return *this; } Mint& operator-=(const Mint& m) { if ((v -= m.v) < 0) v += MOD; return *this; } Mint& operator*=(const Mint& m) { v = (long long)v * m.v % MOD; return *this; } Mint& operator/=(const Mint& m) { return (*this) *= inv(m); } friend Mint pow(Mint a, long long p) { Mint ans = 1; assert(p >= 0); for (; p; p /= 2, a *= a) if (p & 1) ans *= a; return ans; } friend Mint inv(const Mint& a) { assert(a.v != 0); return pow(a, MOD - 2); } Mint operator-() const { return Mint(-v); } Mint& operator++() { return *this += 1; } Mint& operator--() { return *this -= 1; } friend Mint operator+(Mint a, const Mint& b) { return a += b; } friend Mint operator-(Mint a, const Mint& b) { return a -= b; } friend Mint operator*(Mint a, const Mint& b) { return a *= b; } friend Mint operator/(Mint a, const Mint& b) { return a /= b; } }; namespace FFT { template <class T> void fft(vector<T>& A, bool inv = 0) { int n = (int)A.size(); assert((T::mod - 1) % n == 0); vector<T> B(n); for (int b = n / 2; b; b /= 2, A.swap(B)) { T w = pow(T::rt(), (T::mod - 1) / n * b); T m = 1; for (int i = 0; i < n; i += b * 2, m *= w) for (int j = 0; j < b; j++) { T u = A[i + j]; T v = A[i + j + b] * m; B[i / 2 + j] = u + v; B[i / 2 + j + n / 2] = u - v; } } if (inv) { reverse(1 + A.begin(), A.end()); T z = T(1) / T(n); for (auto& t : A) t *= z; } } template <class T> vector<T> multiply(vector<T> A, vector<T> B) { int sa = (int)A.size(); int sb = (int)B.size(); if (!min(sa, sb)) return {}; int s = sa + sb - 1; int n = 1; for (; n < s; n *= 2) ; bool eq = A == B; A.resize(n); fft(A); if (eq) B = A; else B.resize(n), fft(B); for (int i = 0; i < n; i++) A[i] *= B[i]; fft(A, 1); A.resize(s); return A; } template <class T> vector<T> operator*(const vector<T>& a, const vector<T>& b) { auto c = multiply(a, b); return c; } template <class T> vector<T> operator+(const vector<T>& a, const vector<T>& b) { vector<T> c = a; c.resize(max(a.size(), b.size())); for (int i = 0; i < b.size(); ++i) { c[i] += b[i]; } return c; } template <class M, class T> vector<M> multiply_mod(vector<T> x, vector<T> y) { auto convert = [](const vector<T>& v) { vector<M> w((int)v.size()); for (int i = 0; i < (int)v.size(); i++) w[i] = (int)v[i]; return w; }; return multiply(convert(x), convert(y)); } template <class T> vector<T> general_multiply(const vector<T>& A, const vector<T>& B) { using m0 = Mint<(119 << 23) + 1, 62>; using m1 = Mint<(5 << 25) + 1, 62>; using m2 = Mint<(7 << 26) + 1, 62>; auto c0 = multiply_mod<m0>(A, B); auto c1 = multiply_mod<m1>(A, B); auto c2 = multiply_mod<m2>(A, B); int n = (int)c0.size(); vector<T> res(n); m1 r01 = 1 / m1(m0::mod); m2 r02 = 1 / m2(m0::mod); m2 r12 = 1 / m2(m1::mod); for (int i = 0; i < n; i++) { int a = c0[i].v; int b = ((c1[i] - a) * r01).v; int c = (((c2[i] - a) * r02 - b) * r12).v; res[i] = (T(c) * m1::mod + b) * m0::mod + a; } return res; } } // namespace FFT using namespace FFT; using mi = Mint<998244353, 5>; int main() { ios::sync_with_stdio(false); cin.tie(nullptr); auto fail = []() { cout << 0 << n ; exit(0); }; int n; cin >> n; vector<int> a(n); for (int i = 0; i < n; ++i) { cin >> a[i]; } vector<int> blocks; while (!a.empty()) { int x = a.back(); if (a.size() < x) { fail(); } blocks.push_back(x == 1); for (int i = 0; i < x; ++i) { if (a.back() != x) { fail(); } a.pop_back(); } } reverse(blocks.begin(), blocks.end()); int sz = blocks.size(); const mi HALF = 1 / mi(2); function<vector<vector<mi>>(int, int)> solve = [&](int l, int r) { vector<vector<mi>> res(4); if (r - l + 1 == 1) { res[0] = vector<mi>{1}; res[1] = vector<mi>{0, 2}; res[2] = vector<mi>{1}; if (blocks[l]) { res[3] = vector<mi>{0, 1}; } else { res[3] = vector<mi>{0, 2}; } return res; } int m = (l + r) >> 1; auto x = solve(l, m); auto y = solve(m + 1, r); res[0] = x[0] * y[0] + x[1] * y[2]; res[1] = x[0] * y[1] + x[1] * y[3]; res[2] = x[2] * y[0] + x[3] * y[2]; res[3] = x[3] * y[3] + x[2] * y[1]; return res; }; auto res = solve(0, sz - 1)[3]; vector<mi> fact(n + 1); fact[0] = 1; for (int i = 1; i <= n; ++i) { fact[i] = fact[i - 1] * i; } mi ans = 0; for (int i = 1; i < res.size(); ++i) { ans += res[i] * fact[i] * (i % 2 == res.size() % 2 ? -1 : 1); } cout << ans << n ; return 0; }
|
#include <bits/stdc++.h> using namespace std; int n, a, am, duong, zero; unsigned long long t; int main() { scanf( %d n , &n); for (int i = 1; i <= n; i++) { scanf( %d , &a); if (a < 0) am++; else if (a > 0) duong++; else zero++; t += abs(abs(a) - 1); } if (am % 2 == 1) { if (zero == 0) t += 2; } printf( %llu , t); }
|
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; int sum = 0, a; for (int i = 0; i < n; i++) { cin >> a; sum += a; } int m; cin >> m; vector<char> good(1e5 + 1, false); int l, r; for (int i = 0; i < m; i++) { cin >> l >> r; for (int j = l; j <= r; j++) { good[j] = true; } } for (int i = sum; i <= 1e5; i++) { if (good[i]) { cout << i << endl; return 0; } } cout << -1 << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { string a; cin >> a; int i, flag = 0; for (i = 1; i < a.size(); i++) { if (a[i] == 1 ) { flag = 1; break; } } i = (a.size()) / 2; if (flag == 1 && a.size() % 2 == 1) i++; cout << i; }
|
#include <bits/stdc++.h> using namespace std; template <typename T> T sqr(T x) { return x * x; } template <typename T> T abs(T x) { return x < 0 ? -x : x; } template <typename T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; } const int MAXN = 8009; const int MAXX = (int)1e+6 + 7; struct triple { int x, l, r; triple(int x = 0, int l = 0, int r = 0) : x(x), l(l), r(r) {} }; int s[MAXN]; vector<triple> v[MAXN]; int lg[MAXX]; int upd[MAXX], cnt; int n, m; int cpwr[MAXX]; int count_power(int l, int r) { return lg[r] - lg[l - 1]; } int main(int argc, char **argv) { ios_base::sync_with_stdio(false); lg[0] = -1; lg[1] = 0; for (int i = 2; i < MAXX; ++i) { lg[i] = lg[i >> 1] + 1; } cin >> n >> m; s[1] = 1; for (int i = 2; i <= n; ++i) { s[i] = s[i - 1] + lg[s[i - 1]] + 1; } while (m--) { int t; cin >> t; if (t == 1) { int l, r, x; cin >> t >> l >> r >> x; v[t].push_back(triple(x, l, r)); } else { int l, r, ans = 0; cin >> t >> l; r = l; ++cnt; for (; t <= n; ++t) { for (size_t i = 0; i < v[t].size(); ++i) { if (l <= v[t][i].r && v[t][i].l <= r && upd[v[t][i].x] != cnt) { upd[v[t][i].x] = cnt; ++ans; } } int len = r - l + 1; int k = count_power(l, r); l += count_power(1, l - 1); r = l + len - 1 + k; } cout << ans << n ; } } return 0; }
|
#include <bits/stdc++.h> int n; int sum = 0; int a[16]; int mat[4][4]; int rows[4], cols[4]; int gotx[4], goty[4], gotd[2]; int x[16], y[16]; int diag[2]; bool dfs(int state, int mask) { for (int i = 0; i < 2; i++) { if (gotd[i] == n && diag[i] != sum) { return false; } } if (state == n * n) return true; int row = x[state]; int col = y[state]; bool d1 = row == col; bool d2 = row + col == n - 1; for (int i = 0; i < n * n; i++) { if ((mask & (1 << i)) != 0 && rows[row] + a[i] <= sum && cols[col] + a[i] <= sum && (!d1 || diag[0] + a[i] <= sum) && (!d2 || diag[1] + a[i] <= sum)) { if (gotx[row] + 1 == n && rows[row] + a[i] < sum) { continue; } if (goty[col] + 1 == n && cols[col] + a[i] < sum) { continue; } gotx[row]++; goty[col]++; rows[row] += a[i]; cols[col] += a[i]; if (d1) { gotd[0]++; diag[0] += a[i]; } if (d2) { gotd[1]++; diag[1] += a[i]; } if (dfs(state + 1, mask ^ (1 << i))) { mat[row][col] = a[i]; return true; } gotx[row]--; goty[col]--; if (d1) { gotd[0]--; diag[0] -= a[i]; } if (d2) { gotd[1]--; diag[1] -= a[i]; } rows[row] -= a[i]; cols[col] -= a[i]; } } return false; } int main() { std::ios_base::sync_with_stdio(false); std::cin.tie(NULL); std::cin >> n; int mn = 1e9; long long ans = 0; for (int i = 0; i < n * n; i++) { std::cin >> a[i]; mn = std::min(mn, a[i]); ans += a[i]; } std::cout << ans / n << std::endl; if (n == 1) { std::cout << a[0] << std::endl; return 0; } else if (n == 2) { x[0] = 0; x[1] = 1; x[2] = 0; x[3] = 1; y[0] = 0; y[1] = 1; y[2] = 1; y[3] = 0; } else if (n == 3) { x[0] = 0; x[1] = 1; x[2] = 2; x[3] = 0; x[4] = 2; x[5] = 0; x[6] = 1; x[7] = 1; x[8] = 2; y[0] = 0; y[1] = 1; y[2] = 2; y[3] = 2; y[4] = 0; y[5] = 1; y[6] = 0; y[7] = 2; y[8] = 1; } else if (n == 4) { int wtfx[] = {0, 1, 2, 3, 0, 1, 2, 3, 0, 0, 1, 1, 2, 2, 3, 3}; int wtfy[] = {0, 1, 2, 3, 3, 2, 1, 0, 1, 2, 0, 3, 0, 3, 1, 2}; for (int i = 0; i < 16; i++) { x[i] = wtfx[i]; y[i] = wtfy[i]; } } long long cur = 0; for (int i = 0; i < n * n; i++) { a[i] -= mn; cur += a[i]; } srand(time(0)); std::random_shuffle(a, a + n * n); sum = cur / n; dfs(0, (1 << (n * n)) - 1); for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { std::cout << mat[i][j] + mn << (j + 1 == n ? n : ); } } }
|
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; int a[n]; for (int i = 0; i < n; i++) { cin >> a[i]; } sort(a, a + n); int c = 0; for (int i = 0; i < n; i++) { if (i == 0 && a[0] > 0) { c++; } if (i > 0 && a[i] != 0 && a[i] != a[i - 1]) { c++; } } cout << c << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { long l; cin >> l; int div = 0; for (int i = 5; i < 1 + pow(l, 0.5); i++) { if (l % i == 0) { div = i; break; } } if (div == 0 || (l / div) < 5) { cout << -1 << endl; } else { char a[div][int(l / div)]; a[0][0] = a ; a[0][1] = e ; a[0][2] = i ; a[0][3] = o ; a[0][4] = u ; a[1][0] = e ; a[1][1] = i ; a[1][2] = o ; a[1][3] = u ; a[1][4] = a ; a[2][0] = i ; a[2][1] = o ; a[2][2] = u ; a[2][3] = a ; a[2][4] = e ; a[3][0] = o ; a[3][1] = u ; a[3][2] = a ; a[3][3] = e ; a[3][4] = i ; a[4][0] = u ; a[4][1] = a ; a[4][2] = e ; a[4][3] = i ; a[4][4] = o ; for (int i = 0; i < 5; i++) { for (int j = 5; j < (l / div); j++) { a[i][j] = a[i][j - 5]; } } for (int i = 5; i < div; i++) { for (int j = 0; j < (l / div); j++) { a[i][j] = a[i - 5][j]; } } for (int i = 0; i < div; i++) { for (int j = 0; j < (l / div); j++) { cout << a[i][j]; } } cout << endl; } }
|
#include <bits/stdc++.h> using namespace std; int arr[98]; int main() { string s; vector<long long> v(4); for (int i = 0; i < 4; i++) cin >> v[i]; sort(v.begin(), v.end()); char c1, c2, c3; cin >> c1 >> c2 >> c3; if (c1 == * && c2 == * && c3 == * ) cout << v[0] * v[1] * v[2] * v[3] << endl; else if (c1 == + && c2 == + && c3 == + ) cout << v[0] + v[1] + v[2] + v[3] << endl; else if (c1 == * && c2 == + && c3 == + ) { if (c1 == 0) cout << (v[0] * v[3]) + v[1] + v[2] << endl; cout << (v[0] * v[1]) + v[2] + v[3] << endl; } else if (c1 == * && c2 == * && c3 == + ) cout << min(min((v[0] * v[1] * v[2]) + v[3], (v[0] * v[1]) + (v[2] * v[3])), (v[0] * v[3]) + (v[1] * v[2])) << endl; else if (c1 == + && c2 == * && c3 == * ) cout << (v[2] + v[3]) * v[0] * v[1] << endl; else if (c1 == + && c2 == + && c3 == * ) cout << (v[1] + v[2] + v[3]) * v[0] << endl; else if (c1 == + && c2 == * && c3 == + ) cout << (v[0] * v[1]) + v[2] + v[3] << endl; else if (c1 == * && c2 == + && c3 == * ) cout << (((v[1] * v[2]) + v[3]) * v[0]) << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { long long n; cin >> n; vector<long long> a(n), b(n); for (long long i = 0; i < n; ++i) cin >> a[i]; for (long long i = 0; i < n; ++i) cin >> b[i]; map<long long, vector<long long> > mp; long long m; cin >> m; for (long long i = 0; i < n; ++i) { mp[a[i]].push_back(i + 1); mp[b[i]].push_back(i + 1); } long long ans = 1; for (auto it = mp.begin(); it != mp.end(); ++it) { long long den = 0; long long num = it->second.size(); sort(it->second.begin(), it->second.end()); for (long long i = 1; i < (it->second.size()); ++i) { if ((it->second[i]) == (it->second[i - 1])) den++; } long long nn = 1; for (long long i = num; i > 0; --i) { if (i & 1 || den == 0) nn *= i; else { nn *= (i / 2); den--; } if (nn > m) nn %= m; } ans *= nn; if (ans > m) ans %= m; } cout << ans % m; return 0; }
|
#include <bits/stdc++.h> using namespace std; int t, n, doc[100010], doc1[100010], p[100010]; vector<vector<int> > g; vector<pair<int, pair<int, int> > > q; vector<int> tin, tout; int par(int u) { if (p[u] == u) return u; return p[u] = par(p[u]); } void dfs(int u) { tin[u] = t; for (int i = 0; i < g[u].size(); i++) if (tin[g[u][i]] == -1) { t++; dfs(g[u][i]); } tout[u] = ++t; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); int m, d = 0; cin >> n >> m; g.resize(n); tin.resize(n, -1); tout.resize(n); for (int i = 0; i < n; i++) p[i] = i; for (int i = 0; i < m; i++) { int type, x, y; cin >> type; if (type == 1) { cin >> x >> y; x--; y--; p[x] = y; g[y].push_back(x); } else if (type == 2) { cin >> x; x--; doc1[d] = par(x); doc[d++] = x; } else { cin >> x >> y; x--; y--; int a = 0; if (par(x) == par(doc[y])) a = 1; q.push_back(make_pair(a, make_pair(x, y))); } } t = 0; for (int i = 0; i < n; i++) if (p[i] == i) dfs(i); for (int i = 0; i < q.size(); i++) { if (q[i].first == 0) { cout << NO n ; continue; } int u = q[i].second.first, v = doc[q[i].second.second], x = doc1[q[i].second.second]; if (tin[u] <= tin[v] && tout[u] >= tout[v] && tin[x] <= tin[u] && tout[x] >= tout[u]) cout << YES n ; else cout << NO n ; } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { unsigned long long int counter = 0, a, b, t; cin >> a >> b; while (true) { if (b > a) { t = a; a = b; b = t; } counter = counter + (a / b); a = (a % b); if (a == 0) break; } cout << counter; return 0; }
|
#include <bits/stdc++.h> using namespace std; const int N = 1000; int ans[N], l[N], r[N]; int main() { ios_base::sync_with_stdio(false); cin.tie(nullptr); int n; cin >> n; for (int i = 0; i < n; ++i) { cin >> l[i]; } for (int i = 0; i < n; ++i) { cin >> r[i]; } for (int k = n; k > 0; --k) { for (int i = 0; i < n; ++i) { if (l[i] == 0 && r[i] == 0 && ans[i] == 0) { ans[i] = k; } } int prefix = 0; for (int i = 0; i < n; ++i) { if (ans[i] == k) { ++prefix; } else if (ans[i] == 0) { l[i] -= prefix; } } int suffix = 0; for (int i = n - 1; i >= 0; --i) { if (ans[i] == k) { ++suffix; } else if (ans[i] == 0) { r[i] -= suffix; } } } if (count(ans, ans + n, 0) == 0) { cout << YES n ; for (int i = 0; i < n; ++i) { cout << ans[i] << ; } cout << n ; } else { cout << NO n ; } }
|
#include <bits/stdc++.h> using namespace std; bool boy[1000], girl[1000]; int n, m, b, g, x, y, q[1000][2], h, t; int main() { memset(boy, false, sizeof(boy)); scanf( %d%d%d , &n, &m, &b); for (int i = 1; i <= b; i++) { scanf( %d , &x); boy[x] = true; } memset(girl, false, sizeof(girl)); scanf( %d , &g); for (int i = 1; i <= g; i++) { scanf( %d , &y); girl[y] = true; } h = t = 0; for (int i = 0; i < n; i++) if (boy[i]) { t++; q[t][1] = 0; q[t][2] = i; } for (int i = 0; i < m; i++) if (girl[i]) { t++; q[t][1] = 1; q[t][2] = i; } while (h < t) { h++; if (q[h][1]) { int u = q[h][2] % n; for (int i = 1; i <= n; i++) { if (!boy[u]) { boy[u] = true; t++; q[t][1] = 0; q[t][2] = u; } u = (u + m) % n; } } else { int u = q[h][2] % m; for (int i = 1; i <= m; i++) { if (!girl[u]) { girl[u] = true; t++; q[t][1] = 1; q[t][2] = u; } u = (u + n) % m; } } } if (t == n + m) puts( Yes ); else puts( No ); return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n, a[1000]; cin >> n; for (int i = 0; i < n; i++) { cin >> a[i]; if (!(a[i] & 1)) --a[i]; } for (int i = 0; i < n; i++) { cout << a[i] << ; } cout << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; int n; string a; constexpr char t[4] = { A , C , T , G }; int best = INT_MAX; int main() { cin >> n; cin >> a; for (int i = 0; i < n - 3; ++i) { int cur = 0; for (int j = 0; j < 4; ++j) { int temp = min(abs(t[j] - a[i + j]), abs(t[j] + 26 - a[i + j])); temp = min(temp, abs(t[j] - a[i + j] - 26)); cur += temp; } best = min(best, cur); } cout << best; return 0; }
|
#include <bits/stdc++.h> using namespace std; template <typename T> void prn(T first) { cout << first << n ; } int main() { int a[4]; cin >> a[0] >> a[1] >> a[2] >> a[3]; sort(a, a + 4); if (a[0] + a[3] == a[1] + a[2] || a[3] == a[0] + a[1] + a[2]) { cout << YES ; } else { cout << NO ; } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { long long n, h, v[1100]; multiset<long long> s; cin >> n >> h; for (int i = 0; i < n; i++) cin >> v[i]; long long k, ht; for (int i = 0; i < n; i++) { s.insert(v[i]); k = 0; ht = 0; for (multiset<long long>::reverse_iterator rit = s.rbegin(); rit != s.rend(); ++rit) { if (k % 2 == 0) ht += *rit; k++; } if (ht > h) { cout << i << n ; return 0; } } cout << n << n ; return 0; }
|
#include <bits/stdc++.h> using namespace std; string s; pair<int, int> st[3000002]; void build(int v, int l, int r) { if (l == r) { st[v] = make_pair(s[l] == ( , s[l] == ) ); return; } int lv, rv, mid; lv = 2 * v; rv = 2 * v + 1; mid = (l + r) / 2; build(lv, l, mid); build(rv, mid + 1, r); st[v].first = st[rv].first + max(0, st[lv].first - st[rv].second); st[v].second = st[lv].second + max(0, st[rv].second - st[lv].first); } pair<int, int> query(int v, int l, int r, int L, int R) { if (r < L || R < l) return make_pair(0, 0); if (L <= l && r <= R) return st[v]; pair<int, int> L1 = query(2 * v, l, (l + r) / 2, L, R); pair<int, int> R1 = query(2 * v + 1, (l + r) / 2 + 1, r, L, R); return make_pair(R1.first + max(0, L1.first - R1.second), L1.second + max(0, R1.second - L1.first)); } int main() { cin >> s; int n = s.length(); build(1, 0, n - 1); int m; cin >> m; for (int i = 0; i < m; ++i) { int l, r; cin >> l >> r; l--; r--; pair<int, int> q = query(1, 0, n - 1, l, r); cout << r - l + 1 - (q.first + q.second) << n ; } return 0; }
|
#include <bits/stdc++.h> using namespace std; long double k, d, t, g, c, p, ilec, ilep, cp, zos; long long dzielup(long long x, long long y) { if (x % y == 0) return x / y; return x / y + 1; } int main() { ios_base::sync_with_stdio(0); cin.tie(NULL); cout.tie(NULL); cin >> k >> d >> t; cout.precision(10); g = dzielup(k, d); c = g * d; p = k + (c - k) / 2; ilep = floor(t / p); cp = ilep * p; zos = t - cp; if (zos <= k) { cout << fixed << ilep * c + zos << n ; } else { zos -= k; cout << fixed << ilep * c + k + 2 * zos << n ; } return 0; }
|
#include <iostream> using namespace std; const int MOD = 1e9+7, N = 1e5+5; long long inv(long long a) { long long b = 1; int k = MOD-2; while(k) { if(k%2) b = b * a % MOD; a = a * a % MOD; k /= 2; } return b; } long long fact[N], ifact[N]; long long binom(long long x, long long y) { if(x < 0 || y < 0 || x < y) return 0; return fact[x] * ifact[x-y] % MOD * ifact[y] % MOD; } int t, n, k; int main() { ios_base::sync_with_stdio(false); cin.tie(0); fact[0] = ifact[0] = 1; for (int i = 1; i < N; i++) fact[i] = fact[i-1] * i % MOD; ifact[N-1] = inv(fact[N-1]); for (int i = N-2; 0 < i; i--) ifact[i] = ifact[i+1] * (i+1) % MOD; cin >> t; while(t--) { cin >> n >> k; long long sol = 0; for (long long l = 1; l <= n; l++) sol = (sol + binom(n-(l-1)*(k-1), l) * fact[l] % MOD * fact[n-l]) % MOD; sol = (sol + fact[n]) * ifact[n] % MOD; cout << sol << n ; } return 0; }
|
#include <bits/stdc++.h> using namespace std; void debug_out() { cerr << endl; } template <class T> ostream& prnt(ostream& out, T v) { out << v.size() << n ; for (auto e : v) out << e << ; return out; } template <class T> ostream& operator<<(ostream& out, vector<T> v) { return prnt(out, v); } template <class T> ostream& operator<<(ostream& out, set<T> v) { return prnt(out, v); } template <class T1, class T2> ostream& operator<<(ostream& out, map<T1, T2> v) { return prnt(out, v); } template <class T1, class T2> ostream& operator<<(ostream& out, pair<T1, T2> p) { return out << ( << p.first << << p.second << ) ; } template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) { cerr << << H; debug_out(T...); } const int N = 1001; const int MOD = 998244353; int n, dp[2][N], a[N], k, f[100100], r[N]; int solve(int x) { for (int i = 1; i <= n; i++) { int j = upper_bound(a + 1, a + n + 1, a[i] - x) - a; j--; r[i] = j; } for (int j = 1; j <= k; j++) { for (int i = 1; i <= n; i++) if (j == 1) dp[1][i] = 1; else dp[j % 2][i] = dp[1 - j % 2][r[i]]; for (int i = 2; i <= n; i++) dp[j % 2][i] += dp[j % 2][i - 1], dp[j % 2][i] %= MOD; } return dp[k % 2][n]; } int main() { ios_base::sync_with_stdio(false); cin >> n >> k; for (int i = 1; i <= n; i++) cin >> a[i]; sort(a + 1, a + n + 1); int mx = a[n] / (k - 1) + 1; for (int x = 0; x <= mx; x++) f[x] = solve(x); long long ans = 0; for (int x = 0; x < mx; x++) { f[x] -= f[x + 1]; if (f[x] < 0) f[x] += MOD; ans += (1LL * x * f[x]) % MOD; ans %= MOD; } cout << ans << n ; }
|
#include <bits/stdc++.h> using namespace std; int Set(int N, int pos) { return N = N | (1 << pos); } int reset(int N, int pos) { return N = N & ~(1 << pos); } bool check(int N, int pos) { return (bool)(N & (1 << pos)); } inline int addmod(int x, int y) { return (x % 1000000007 + y % 1000000007) % 1000000007; } inline int submod(int x, int y) { return (x % 1000000007 - y % 1000000007 + 1000000007) % 1000000007; } inline int mulmod(int x, int y) { return (x % 1000000007 * 1LL * y % 1000000007) % 1000000007; } inline int nextSubMask(int i, int mask) { return (i - 1) & mask; } template <typename T> void we_r_done(T mssg) { cout << mssg; exit(0); } vector<char> chick; string s[102]; int n, m, c; int row, col; bool vis[111][111]; void fixrc(int i, int j) { row = i; col = j; } char who; void fun(int i, int j, int baki) { if (s[i][j] == R && baki == 0) { fixrc(i, j); return; } baki -= (s[i][j] == R ); s[i][j] = who; vis[i][j] = true; if (j && vis[i][j - 1] == false) { fun(i, j - 1, baki); } else if ((j + 1) < m && vis[i][j + 1] == false) { fun(i, j + 1, baki); } else if (i) fun(i - 1, j, baki); } int main() { for (char i = 0 ; i <= 9 ; i++) chick.push_back(i); for (char i = A ; i <= Z ; i++) chick.push_back(i); for (char i = a ; i <= z ; i++) chick.push_back(i); int t; cin >> t; while (t--) { cin >> n >> m >> c; int tot = 0; for (int i = 0; i < n; i++) { cin >> s[i]; for (int j = 0; j < m; j++) { tot += (s[i][j] == R ); vis[i][j] = false; } } row = n - 1; col = m - 1; char last; for (int i = 0; i < c; i++) { who = chick[i]; int cc = c - i; cc = tot / cc + (tot % cc != 0); tot -= cc; fun(row, col, cc); } for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { cout << s[i][j]; } cout << endl; } } return 0; }
|
#include <bits/stdc++.h> using namespace std; int t, zero, cur; long long ans; string s; int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); cin >> t; while (t--) { cin >> s; ans = zero = 0; for (int i = 0; i < s.size(); i++) { if (s[i] == 0 ) { if (i == 0 || s[i - 1] == 1 ) { zero = 1; } else { zero++; } } else { cur = 0; if (i == 0 || s[i - 1] == 1 ) { zero = 0; } int b = min(i + 18, (int)s.size()); for (int j = i; j < b; j++) { cur = cur * 2 + (s[j] - 0 ); if ((j - i + 1) + min(zero, cur - (j - i + 1)) == cur) { ans++; } } } } cout << ans << n ; } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { std::ios::sync_with_stdio(false); int n; cin >> n; string sign[n]; long long x[n]; char ans[n]; long long low = -2e9, up = 2e9; for (int i = 0; i < n; i++) { cin >> sign[i] >> x[i] >> ans[i]; if (sign[i] == >= ) { if (ans[i] == Y ) low = max(low, x[i]); else up = min(x[i] - 1, up); } else if (sign[i] == > ) { if (ans[i] == Y ) low = max(low, x[i] + 1); else up = min(x[i], up); } else if (sign[i] == <= ) { if (ans[i] == Y ) up = min(x[i], up); else low = max(low, x[i] + 1); } else { if (ans[i] == Y ) up = min(x[i] - 1, up); else low = max(low, x[i]); } } if (low > up) cout << Impossible ; else cout << low; return 0; }
|
#include <bits/stdc++.h> using namespace std; int n, m, l, r; int main() { scanf( %d%d , &n, &m); for (int i = 0; i < m; i++) { scanf( %d%d , &l, &r); } for (int i = 0; i < n; i++) { if (i & 1) printf( 0 ); else printf( 1 ); } puts( ); }
|
#include <bits/stdc++.h> using namespace std; int fir[200010], to[200010 << 1], nxt[200010 << 1], cnt; long long f[200010], fac[200010]; void add(int u, int v) { nxt[++cnt] = fir[u]; fir[u] = cnt; to[cnt] = v; } void dfs(int x, int fa) { f[x] = 1; int i, s = (x != 1); for (i = fir[x]; i; i = nxt[i]) if (to[i] != fa) { dfs(to[i], x); f[x] *= f[to[i]]; f[x] %= 998244353; s++; } f[x] *= fac[s]; f[x] %= 998244353; } int main() { int n, i, u, v; cin >> n; fac[0] = 1; for (i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % 998244353; for (i = 1; i < n; i++) scanf( %d%d , &u, &v), add(u, v), add(v, u); dfs(1, 0); cout << f[1] * n % 998244353; }
|
#include <bits/stdc++.h> using namespace std; int main() { int a[1000]; int n; cin >> n; for (int i = 0; i < n; i++) cin >> a[i]; sort(a, a + n); int res = 0; int sum = 10; int ress = 0; for (int i = 0; i < n; i++) { sum += a[i]; if (sum <= 720) { res++; if (sum > 360) { ress += sum - 360; } } } cout << res << << ress; return 0; }
|
#include <bits/stdc++.h> using namespace std; const int M = (119 << 23) + 1; int add(int a, int b) { return (a += b) < M ? a : a - M; } int sub(int a, int b) { return (a -= b) < 0 ? a + M : a; } int mul(int a, int b) { return 1LL * a * b % M; } int mod_pow(int a, int b) { int res = 1; while (b) { if (b % 2) { res = mul(res, a); } a = mul(a, a); b /= 2; } return res; } int mod_inv(int a) { return mod_pow(a, M - 2); } int main() { ios_base::sync_with_stdio(0); cin.tie(0); int n; cin >> n; vector<int> a(n); for (auto& i : a) { cin >> i; } sort(a.rbegin(), a.rend()); for (int i = 1; i < n; ++i) { a[i] = add(a[i], a[i - 1]); } for (int k = 1; k <= n; ++k) { int ans = 0; for (int i = 0; i < n; i += k) { int sum = a[min(i + k - 1, n - 1)]; sum = sub(sum, i ? a[i - 1] : 0); ans = add(ans, mul(i / k, sum)); } ans = mul(ans, mod_inv(n)); cout << ans << ; } cout << n ; }
|
#include <bits/stdc++.h> using namespace std; inline long long read(void) { long long x = 0, f = 1; char ch = getchar(); while (ch < 0 || ch > 9 ) { if (ch == - ) f = -1; ch = getchar(); } while (ch >= 0 && ch <= 9 ) { x = x * 10 + ch - 0 ; ch = getchar(); } return f * x; } int n; int main() { n = read(); int l = 0, r = 1000000000; cout << 1 << << 0 << endl; fflush(stdout); char ch[10]; scanf( %s , ch + 1); bool flag = false; if (ch[1] == b ) { flag = true; } for (register int i = 1; i < n; ++i) { int mid = (l + r + 1) >> 1; cout << 1 << << mid << endl; fflush(stdout); scanf( %s , ch + 1); if (flag) { ch[1] = (ch[1] == w ) ? b : w ; } if (ch[1] == w ) { l = mid; } else { r = mid; } } printf( 0 %d 2 %d , l, l + 1); return 0; }
|
#include <bits/stdc++.h> int main() { std::ios::sync_with_stdio(false); std::string name; std::cin >> name; bool atFlag = false; std::string result = ; result += name[0]; for (int i = 1; i < name.length(); i++) { if (!atFlag && name.substr(i, 2) == at ) { result += @ ; ++i; atFlag = true; } else if (i + 3 < name.length() && name.substr(i, 3) == dot ) { result += . ; i += 2; } else { result += name[i]; } } std::cout << result; return 0; }
|
#include <bits/stdc++.h> using namespace std; int n, mm, s, it; int a[200005], r[200005], so[200005], ne[200005]; bool u[200005]; string ss, na[200005]; vector<int> v[200005]; queue<int> q; map<string, int> m; inline string sb(string v) { for (int i = 0; i < v.size(); i++) if (v[i] < a ) v[i] += 32; return v; } inline void ope(string &x) { x = sb(x); if (m[x]) return; m[x] = ++s; for (int i = 0; i < x.size(); i++) r[s] += (x[i] == r ); na[s] = x; so[s] = s; return; } inline bool cmp(int x, int y) { if (r[x] != r[y]) return r[x] < r[y]; return na[x].size() < na[y].size(); } inline bool same(int x, int y) { return r[x] == r[y] && na[x].size() == na[y].size(); } inline void dfs(int x, int y) { if (u[x]) return; u[x] = 1; ne[x] = y; for (int i = 0; i < v[x].size(); i++) dfs(v[x][i], y); } int main() { cin >> n; for (int i = 1; i <= n; i++) { cin >> ss; ope(ss); a[i] = m[ss]; } m[ ] = 200002; r[200002] = 2147483640; cin >> mm; for (int i = 1; i <= mm; i++) { string p, q; cin >> p >> q; ope(p); ope(q); v[m[q]].push_back(m[p]); } sort(so + 1, so + s + 1, cmp); for (int i = 1; i <= s; i++) dfs(so[i], so[i]); long long rr = 0, ll = 0; for (int i = 1; i <= n; i++) rr += r[ne[a[i]]], ll += na[ne[a[i]]].size(); cout << rr << << ll << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; const int maxN(1e3 + 10); int N, M, P[maxN], A[maxN][maxN], C; void dfs(const int u) { C++; for (int v = 1; v <= N; v++) if (A[u][v] && !P[v]) { P[v] = u; dfs(v); } } int main() { cin >> N >> M; if (M != N - 1) { cout << no ; return 0; } for (int i = 0; i < M; i++) { int u, v; cin >> u >> v; A[u][v] = A[v][u] = 1; } P[1] = -1; dfs(1); cout << (C == N ? yes : no ); }
|
#include <bits/stdc++.h> using namespace std; int32_t main() { ios_base::sync_with_stdio(false); cin.tie(NULL); long long a, x, y; cin >> a >> x >> y; if (y % a == 0) cout << -1; else { long long ratio = (long long)(y / a); if (ratio > 0) { if (((long long)(y / a)) % 2 == 1) { if (2 * abs(x) < a) cout << 2 * ratio - (long long)(ratio / 2); else cout << -1; } else { if (x != 0 && abs(x) < a && x < 0) cout << 2 * ratio - (ratio / 2); else if (x != 0 && abs(x) < a && x > 0) cout << 2 * ratio - (ratio / 2) + 1; else cout << -1; } } else if (2 * abs(x) < a) cout << 1; else cout << -1; } }
|
#include <bits/stdc++.h> using namespace std; int tmp; string s; char a[3][10] = {{ q , w , e , r , t , y , u , i , o , p }, { a , s , d , f , g , h , j , k , l , ; }, { z , x , c , v , b , n , m , , , . , / }}; char Tinh(char c) { for (int i = 0; i < 3; i++) for (int j = 0; j < 10; j++) if (a[i][j] == c) return a[i][j + tmp]; } int main() { char ss; cin >> ss; if (ss == R ) tmp = -1; else tmp = 1; cin >> s; string res = ; for (int i = 0; i < s.length(); i++) { res += Tinh(s[i]); } cout << res; return 0; }
|
#include <bits/stdc++.h> using namespace std; const int N = 5e4 + 100; int n, k; struct node { int sz; int mn[15], mx[15]; void init(int a) { sz = 0; for (int i = 1; i <= k; i++) { mx[i] = mn[i] = a; } } void unit(node a) { sz += a.sz; for (int i = 1; i <= k; i++) { mn[i] = min(mn[i], a.mn[i]); mx[i] = max(mx[i], a.mx[i]); } } bool operator<(const node& p) const { for (int i = 1; i <= k; i++) { if (mx[i] > p.mn[i]) return false; } return true; } }; set<node> s; vector<set<node>::iterator> del; int main() { scanf( %d %d , &n, &k); node now; for (int i = 1; i <= n; i++) { for (int j = 1; j <= k; j++) scanf( %d , &now.mn[j]), now.mx[j] = now.mn[j]; now.sz = 1; set<node>::iterator l, r, iter; r = s.upper_bound(now); l = s.lower_bound(now); for (iter = l; iter != r; iter++) { now.unit(*iter); del.push_back(iter); } for (int j = 0; j < del.size(); j++) { s.erase(del[j]); } del.clear(); s.insert(now); iter = s.end(); iter--; printf( %d n , iter->sz); } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); int TESTS = 1; while (TESTS--) { int n; cin >> n; int a[n], f[1005] = {0}; for (int i = 0; i < n; i++) { cin >> a[i]; f[a[i]]++; } int h = 0, t = 0; for (int i = 0; i < 1005; i++) { if (f[i]) t++; h = max(h, f[i]); } cout << h << << t; } return 0; }
|
#include <bits/stdc++.h> const int S = 200003; int n, m, h[S], nx[S], v[S], eg = 1, s[S], e[S], _ = 0, t[S], fa[S], dep[S], f[S], rk[S], root, a[S]; inline void egadd(int uu, int vv) { nx[++eg] = h[uu]; h[uu] = eg; v[eg] = vv; } void dfs_1(int x) { s[x] = 1; for (int i = h[x]; i; i = nx[i]) if (v[i] != fa[x]) { fa[v[i]] = x; dep[v[i]] = dep[x] + 1; dfs_1(v[i]); s[x] += s[v[i]]; if (s[e[x]] < s[v[i]]) e[x] = v[i]; } } void dfs_2(int x, int top) { f[x] = ++_; rk[_] = x; t[x] = top; if (!e[x]) return; dfs_2(e[x], top); for (int i = h[x]; i; i = nx[i]) if (v[i] != fa[x] && v[i] != e[x]) dfs_2(v[i], v[i]); } long long sg[S << 2], add[S << 2]; inline void down(int w, int l, int r) { if (add[w]) { int mid = (l + r) >> 1; add[(w << 1)] += add[w]; add[(w << 1) | 1] += add[w]; sg[(w << 1)] += add[w] * (mid - l + 1); sg[(w << 1) | 1] += add[w] * (r - mid); add[w] = 0; } } inline void sgadd(int l, int r, int ll, int rr, int k, int w) { if (ll <= l && r <= rr) { sg[w] += 1ll * (r - l + 1) * k; add[w] += k; return; } int mid = (l + r) >> 1; down(w, l, r); if (ll <= mid) sgadd(l, mid, ll, rr, k, (w << 1)); if (rr > mid) sgadd(mid + 1, r, ll, rr, k, (w << 1) | 1); sg[w] = sg[(w << 1)] + sg[(w << 1) | 1]; } inline void sgb(int l, int r, int w) { if (l == r) { sg[w] = a[rk[l]]; return; } int mid = (l + r) >> 1; sgb(l, mid, (w << 1)); sgb(mid + 1, r, (w << 1) | 1); sg[w] = sg[(w << 1)] + sg[(w << 1) | 1]; } inline long long sgcal(int l, int r, int ll, int rr, int w) { if (ll <= l && r <= rr) return sg[w]; int mid = (l + r) >> 1; down(w, l, r); long long ret = 0; if (ll <= mid) ret += sgcal(l, mid, ll, rr, (w << 1)); if (rr > mid) ret += sgcal(mid + 1, r, ll, rr, (w << 1) | 1); return ret; } inline int hang(int x, int y) { while (true) { if (fa[t[y]] == x) return t[y]; if (f[t[y]] <= f[x] && f[x] <= f[y]) return e[x]; y = fa[t[y]]; } } inline int lca(int x, int y) { while (t[x] != t[y]) { if (dep[t[x]] < dep[t[y]]) x ^= y ^= x ^= y; x = fa[t[x]]; } if (x == y) return x; if (dep[x] > dep[y]) return y; else return x; } int main() { scanf( %d%d , &n, &m); for (int i = 1; i <= n; i++) scanf( %d , a + i); for (int i = 1; i < n; i++) { int uu, vv; scanf( %d%d , &uu, &vv); egadd(uu, vv); egadd(vv, uu); } root = 1; dfs_1(1); dfs_2(1, 1); sgb(1, n, 1); int o, x, y, z; while (m--) { scanf( %d%d , &o, &x); if (o == 1) root = x; else if (o == 2) { scanf( %d%d , &y, &z); int o1, o2, o3; o1 = lca(x, y); if (o1 != root && (f[o1] <= f[root] && f[root] <= f[o1] + s[o1] - 1)) { o2 = lca(x, root); o3 = lca(y, root); if (dep[o1] < dep[o2]) o1 = o2; if (dep[o1] < dep[o3]) o1 = o3; if (o1 == root) sgadd(1, n, 1, n, z, 1); else { o2 = hang(o1, root); sgadd(1, n, 1, n, z, 1); sgadd(1, n, f[o2], f[o2] + s[o2] - 1, -z, 1); } } else if (o1 == root) sgadd(1, n, 1, n, z, 1); else sgadd(1, n, f[o1], f[o1] + s[o1] - 1, z, 1); } else { if (x != root && (f[x] <= f[root] && f[root] <= f[x] + s[x] - 1)) { int o = hang(x, root); printf( %lld n , sgcal(1, n, 1, n, 1) - sgcal(1, n, f[o], f[o] + s[o] - 1, 1)); } else if (x == root) printf( %lld n , sgcal(1, n, 1, n, 1)); else printf( %lld n , sgcal(1, n, f[x], f[x] + s[x] - 1, 1)); } } return 0; }
|
#include <bits/stdc++.h> using namespace std; int n, k; string s; pair<int, int> fff(const string &s, char x) { pair<int, int> res; int cc = 0; for (int i = 0; i < s.length(); i++) if (s[i] == x) cc++; if (cc >= k) { res.first = 0; res.second = 0; return res; } int cost = 0; for (int i = 1; i <= 9; i++) for (int j = 0; j < s.length(); j++) if (abs(s[j] - x) == i) { cc++; cost += abs(s[j] - x); if (cc == k) { res.first = cost; res.second = i; return res; } } } string change(string s, char x, int d) { int cc = 0; for (int i = 0; i < s.length(); i++) if (abs(s[i] - x) < d) { cc++; s[i] = x; } if (cc == k) return s; for (int i = 0; i < s.length(); i++) if (s[i] - x == d) { s[i] = x; cc++; if (cc == k) return s; } for (int i = s.length(); i-- > 0;) if (x - s[i] == d) { s[i] = x; cc++; if (cc == k) return s; } } const string &min(const string &s, const string &t) { if (s > t) return t; return s; } int main() { scanf( %d%d , &n, &k); cin >> s; int cost = 1000000000; string res = ; for (char x = 0 ; x <= 9 ; x++) { pair<int, int> a = fff(s, x); if (cost > a.first) { cost = a.first; res = change(s, x, a.second); } else if (cost == a.first) res = min(res, change(s, x, a.second)); } cout << cost << endl << res; }
|
#include <bits/stdc++.h> using namespace std; using ll = long long; template <typename T> using v = vector<T>; const ll K = 1000; const ll N = 1e5; const ll B = N / K + 1; ll n; ll arr[N + 1]; ll cnt[N + 1]; ll bin[B + 1]; ll greedy(ll k) { fill(begin(cnt), end(cnt), 0); v<ll> dif; ll bits = 0; for (ll i = 1; i <= n; i++) { ll val = arr[i]; if (cnt[val] == 0) { if ((ll)dif.size() == k) { for (const auto& color : dif) { cnt[color] = 0; } dif.clear(); bits++; } dif.push_back(val); } cnt[val]++; } if (dif.size() > 0) { bits++; } return bits; } int main(int argc, char const* argv[]) { ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr); cin >> n; for (ll i = 0; i < n; i++) { cin >> arr[i + 1]; } v<ll> resarr(n + 1, -1); for (ll k = 1; k <= min(K, n); k++) { resarr[k] = greedy(k); } fill(begin(bin), end(bin), 1); for (ll b = 1; b <= B; b++) { ll lo = 1; ll hi = (b > 1) ? bin[b - 1] : n; while (lo != hi) { ll mid = (lo + hi) / 2; ll curbits = greedy(mid); if (curbits <= b) { hi = mid; } else { lo = mid + 1; } } bin[b] = lo; } for (ll k = K + 1; k <= n; k++) { ll lo = 1; ll hi = resarr[k - 1]; while (lo != hi) { ll mid = (lo + hi) / 2; if (bin[mid] <= k) { hi = mid; } else { lo = mid + 1; } } resarr[k] = lo; } for (ll i = 1; i <= n; i++) { cout << resarr[i] << ; } cout << n ; return 0; }
|
#include <bits/stdc++.h> using namespace std; const double eps = 1e-8; const long long mod = 1e9 + 7; const int inf = 1 << 30; const int maxn = 600500; const double EPS = 1e-7; void solve() { int q; scanf( %d , &q); while (q--) { long long n; scanf( %lld , &n); int a, b; scanf( %d%d , &a, &b); if (b < 2LL * a) { printf( %lld n , (n / 2LL) * 1LL * b + a * (n % 2)); } else printf( %lld n , a * 1LL * n); } } int main() { int tc = 1; for (int tt = 0; tt < (int)(tc); ++tt) { solve(); } }
|
#include <bits/stdc++.h> using namespace std; template <typename T> void print_array(T arr[], int size_arr) { for (int i = (0); i < (size_arr); i++) { cout << arr[i]; if (i == size_arr - 1) cout << endl; else cout << ; } } template <typename T> void print_vector(vector<T> v) { for (int i = (0); i < (v.size()); i++) { cout << v[i]; if (i == v.size() - 1) cout << endl; else cout << ; } } template <typename T> void memset_array(T arr[], T value, int size_arr) { for (int i = (0); i < (size_arr); i++) { arr[i] = value; } } bool compare_lexical_string(string a, string b) { for (int i = (0); i < (min(a.length(), b.length())); i++) { if (a[i] != b[i]) return a[i] < b[i]; } return a.length() < b.length(); } struct lex_string { bool operator()(string a, string b) { return compare_lexical_string(a, b); } }; int main() { ios_base::sync_with_stdio(0); cin.tie(0); long long b, d, s; cin >> b >> d >> s; long long max_num, min_num; max_num = max(b, max(d, s)); min_num = min(b, min(d, s)); if (max_num == min_num) cout << 0 << endl; else { if (max_num == b) { long long count = 0; if (d < b) count += b - 1 - d; if (s < b) count += b - 1 - s; cout << count << endl; } else if (max_num == d) { if (d == s) cout << d - 1 - b << endl; else { cout << 2 * d - 2 - b - s << endl; } } else { cout << s - 1 - b + s - 1 - d << endl; } } return 0; }
|
#include <bits/stdc++.h> using namespace std; const int MOD = 1000000007; const double EPS = 1e-8; const double PI = 2 * acos(0); const int MAXN = 2006; struct Node { int x, y; bool operator<(Node b) const { if (x != b.x) return x < b.x; return y < b.y; } }; struct Math { int n; int MOD; int SMALL_N; long long *r; long long *fac, *ifac; long long **A, **C; long long *twop, *iv_twop; Math() { n = -1; MOD = 1; SMALL_N = 3030; } void prepare(int n_, int MOD_) { n = n_; MOD = MOD_; r = new long long[n + 1]; r[1] = 1; for (int i = 2; i <= n; ++i) r[i] = (MOD - (MOD / i) * r[MOD % i] % MOD) % MOD; fac = new long long[n + 1]; fac[0] = 1; for (int i = 1; i <= n; ++i) fac[i] = fac[i - 1] * i % MOD; ifac = new long long[n + 1]; ifac[0] = ifac[1] = 1; for (int i = 2; i <= n; ++i) ifac[i] = ifac[i - 1] * r[i] % MOD; twop = new long long[n + 1]; iv_twop = new long long[n + 1]; twop[0] = iv_twop[0] = 1; twop[1] = 2; iv_twop[1] = (MOD + 1) / 2; for (int i = 2; i <= n; ++i) { twop[i] = twop[i - 1] * 2 % MOD; iv_twop[i] = iv_twop[i - 1] * iv_twop[1] % MOD; } if (n <= SMALL_N) { A = new long long *[n + 1]; for (int i = 0; i <= n; ++i) A[i] = new long long[n + 1]; memset(A, 0, sizeof(A)); for (int i = 0; i <= n; ++i) A[i][0] = 1; for (int i = 1; i <= n; ++i) for (int j = 1; j <= i; ++j) A[i][j] = A[i][j - 1] * (i - j + 1) % MOD; } if (n <= SMALL_N) { C = new long long *[n + 1]; for (int i = 0; i <= n; ++i) C[i] = new long long[n + 1]; memset(C, 0, sizeof(C)); for (int i = 0; i <= n; ++i) C[i][0] = C[i][i] = 1; for (int i = 1; i <= n; ++i) for (int j = 1; j < i; ++j) C[i][j] = (C[i][j - 1] + C[i - 1][j - 1]) % MOD; } } long long getA(int n_, int k_) { if (k_ < 0 || n_ < 0) return 0; if (n_ <= n && n <= SMALL_N) return A[n_][k_]; return fac[n_] * ifac[n_ - k_] % MOD; } long long getC(int n_, int k_) { if (k_ < 0 || n_ < 0) return 0; if (n_ <= n && n <= SMALL_N) return C[n_][k_]; return fac[n_] * ifac[n_ - k_] % MOD * ifac[k_] % MOD; } }; int n, m, k; Node node[MAXN]; long long dp[MAXN]; Math toan; bool input() { int u, v, x, y; cin >> n >> m >> k; for (int i = 1; i <= k; ++i) cin >> node[i].x >> node[i].y; return !cin.fail(); } void clear_input() { k = 0; } void preprocess() { sort(node + 1, node + k + 1); toan.prepare(200005, MOD); } void process(int itest) { int u, v, x, y; node[k + 1].x = n, node[k + 1].y = m; for (int i = 1; i <= k + 1; ++i) { x = node[i].x; y = node[i].y; dp[i] = toan.getC(x + y - 2, x - 1); for (int j = 1; j < i; ++j) if (node[j].x <= x && node[j].y <= y) dp[i] = ((dp[i] - dp[j] * toan.getC(x - node[j].x + y - node[j].y, x - node[j].x)) % MOD + MOD) % MOD; } cout << dp[k + 1] << endl; } void oneTest() { while (input()) { preprocess(); process(0); clear_input(); } } void multiTest() { int t; cin >> t; for (int it = 1; it <= t; ++it) { input(); preprocess(); process(it); } } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); oneTest(); return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int t; cin >> t; while (t--) { int x = 0, y = 0, z = 0; int ar[4]; for (int i = 0; i < 4; i++) { cin >> ar[i]; } x = ar[1]; y = ar[2]; z = ar[2]; cout << x << << y << << z << endl; } return 0; }
|
#include <bits/stdc++.h> const int N = (int)3e5 + 2; int n; bool a[N << 1]; int ans, ansl, ansr; inline long long read() { long long x = 0; char ch = getchar(); for (; ch > 9 || ch < 0 ; ch = getchar()) ; for (; ch >= 0 && ch <= 9 ; ch = getchar()) x = (x << 1) + (x << 3) + (ch ^ 48); return x; } int main() { n = read(); int cnt = 0, mn = 0, pos = -1; for (int i = 0; i < n; ++i) { char ch = getchar(); if (ch == ( ) ++cnt; else a[i] = a[i + n] = 1, --cnt; if (mn > cnt) mn = cnt, pos = i, ans = 1; else if (mn == cnt) ++ans; } if (cnt) { printf( 0 n1 1 ); return 0; } int I = n + ++pos, num[2] = {0, 0}, l[2], tmp = ans; for (int i = pos; i < I; ++i) { if (!a[i]) { ++cnt; if (cnt == 1) ++num[0], l[0] = i; else if (cnt == 2) ++num[1], l[1] = i; } else { --cnt; if (!cnt) { if (num[0] > ans) { ans = num[0]; ansl = l[0]; ansr = i; } num[0] = 0; } else if (cnt == 1) { if (tmp + num[1] > ans) { ans = tmp + num[1]; ansl = l[1]; ansr = i; } ++num[0]; num[1] = 0; } else if (cnt == 2) ++num[1]; } } printf( %d n%d %d , ans, ansl % n + 1, ansr % n + 1); return 0; }
|
#include <bits/stdc++.h> using namespace std; template <typename A> ostream &operator<<(ostream &cout, vector<A> const &v); template <typename A, typename B> ostream &operator<<(ostream &cout, pair<A, B> const &p) { return cout << ( << p.first << , << p.second << ) ; } template <typename A> ostream &operator<<(ostream &cout, vector<A> const &v) { cout << [ ; for (int i = 0; i < v.size(); i++) { if (i) cout << , ; cout << v[i]; } return cout << ] ; } template <typename A, typename B> istream &operator>>(istream &cin, pair<A, B> &p) { cin >> p.first; return cin >> p.second; } mt19937_64 rng(61378913); void usaco(string filename) { freopen((filename + .in ).c_str(), r , stdin); freopen((filename + .out ).c_str(), w , stdout); } const long double pi = 3.14159265358979323846; long long n, m, k, q, l, r, x, y, z; const long long template_array_size = 1e6 + 8432; long long a[template_array_size]; long long b[template_array_size]; long long c[template_array_size]; string second, t; long long ans = 0; void solve(int tc = 0) { bool dead[10] = {0}; long long v = 0; cin >> n; for (long long i = 0; i < n; i++) { char c; cin >> c >> x; if (c == | ) { for (long long j = 0; j < 10; j++) { if (x & (1 << j)) dead[j] = 1; } v |= x; } else if (c == & ) { for (long long j = 0; j < 10; j++) { if (!(x & (1 << j))) dead[j] = 1; } v &= x; } else { v ^= x; } } long long ov = 0; for (long long i = 0; i < 10; i++) { if (!dead[i]) ov += (1 << i); } cout << 2 << n ; cout << & << ov << n ; cout << ^ << v << n ; } int main() { { ios_base::sync_with_stdio(false); } { cin.tie(NULL); } cout << setprecision(12) << fixed; int tc = 1; for (int t = 0; t < tc; t++) solve(t); }
|
#include <bits/stdc++.h> using namespace std; int n, maxim, a; int main() { cin >> n; for (int i = 1; i <= n; i++) { cin >> a; if (a > maxim) maxim = a; } cout << (maxim ^ a); return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { ios::sync_with_stdio(0); cin.tie(0); int a, b, t; cin >> t; int arr[t]; for (int i = 0; i < t; i++) { cin >> a >> b; arr[i] = a + b; } for (int i = 0; i < t; i++) { cout << arr[i] << endl; } }
|
#include <bits/stdc++.h> using namespace std; int main() { string a, b; cin >> a >> b; string a1(b.size(), 0 ); string b1(a.size(), 0 ); a1 = a1 + a; b1 = b1 + b; if (a1 > b1) cout << > << endl; if (a1 == b1) cout << = << endl; if (a1 < b1) cout << < << endl; return 0; }
|
#include <iostream> #include <vector> using namespace std; const int MAXN = 2e5 + 5; struct Info { int maxPref, maxSuff; Info(){} Info(int x) : maxPref(x), maxSuff(x) {} Info(int maxPref, int maxSuff) { this->maxPref = maxPref; this->maxSuff = maxSuff; } void modifyPref(int x) { maxPref += x; } void modifySuff(int x) { maxSuff += x; } }; Info operator +(const Info A, const Info B) { return Info(max(A.maxPref, B.maxPref), max(A.maxSuff, B.maxSuff)); } struct SegmentTree { Info x; int lazyPref, lazySuff; int l, r; SegmentTree *L, *R; SegmentTree() : L(nullptr), R(nullptr), lazyPref(0), lazySuff(0) {} SegmentTree(int l, int r) : SegmentTree() { this->l = l; this->r = r; } void build(int val, int n) { if(l==r) { x = Info((l+1)*val, (n-r)*val); return; } L = new SegmentTree(l, (l+r)/2); R = new SegmentTree((l+r)/2+1, r); L->build(val, n); R->build(val, n); x = L->x + R->x; } void updateLazy() { x.modifyPref(lazyPref); x.modifySuff(lazySuff); if(l!=r) { L->lazyPref += lazyPref; L->lazySuff += lazySuff; R->lazyPref += lazyPref; R->lazySuff += lazySuff; } lazyPref = lazySuff = 0; } Info query(int ql, int qr) { updateLazy(); if(l>=ql && r<=qr) return x; if(r<ql || l>qr) return Info(-MAXN, -MAXN); return L->query(ql, qr) + R->query(ql, qr); } void updatePref(int ql, int qr, int change) { updateLazy(); if(l>=ql && r<=qr) { lazyPref += change; updateLazy(); return; } if(r<ql || l>qr) return; L->updatePref(ql, qr, change); R->updatePref(ql, qr, change); x = L->x + R->x; } void updateSuff(int ql, int qr, int change) { updateLazy(); if(l>=ql && r<=qr) { lazySuff += change; updateLazy(); return; } if(r<ql || l>qr) return; L->updateSuff(ql, qr, change); R->updateSuff(ql, qr, change); x = L->x + R->x; } void update(int q, int change) { updatePref(q, r, change); updateSuff(l, q, change); } }; int n; int a[MAXN]; vector <int> num2Pos[MAXN]; int answer[MAXN]; void updateWithBiggerThanMiddle() { SegmentTree *T = new SegmentTree(0, n-1); T->build(-1, n); for(int x = 1;x<=n;x++) { for(int i: num2Pos[x]) T->update(i, +2); for(int i: num2Pos[x]) { int sum = 0; sum += T->query(i, n-1).maxPref - T->query(i, i).maxPref; sum += T->query(0, i).maxSuff - T->query(i, i).maxSuff; answer[i] = max(answer[i], sum/2); } } } void updateWithSmallerThanMiddle() { SegmentTree *T = new SegmentTree(0, n-1); T->build(-1, n); for(int x = n;x>=1;x--) { for(int i: num2Pos[x]) T->update(i, +2); for(int i: num2Pos[x]) { int sum = 0; sum += T->query(i, n-1).maxPref - T->query(i, i).maxPref; sum += T->query(0, i).maxSuff - T->query(i, i).maxSuff; answer[i] = max(answer[i], (sum+1)/2); } } } int main() { ios::sync_with_stdio(false); cin.tie(nullptr); cin >> n; for(int i = 0;i<n;i++) { cin >> a[i]; num2Pos[a[i]].push_back(i); } updateWithBiggerThanMiddle(); updateWithSmallerThanMiddle(); for(int i = 0;i<n;i++) cout << answer[i] << ; cout << n ; }
|
#include <bits/stdc++.h> namespace algo { using namespace std; const long double PI = 3.141592653589793238462643383279502884L; const long double E = 2.718281828459045235360287471352662498L; const long double EPS = 1e-12L; template <typename T1, typename T2> T1 bin_pow(T1 a, T2 n) { T1 r = 1; while (n > 0) { if (n & 1) r *= a; a *= a; n /= 2; } return r; } template <typename T1, typename T2> T1 bin_pow(T1 a, T2 n, const T1& m) { if (m == 1) return 0; T1 r = 1; while (n > 0) { if (n & 1) { r *= a; r %= m; } a *= a; a %= m; n /= 2; } return r; } template <typename T> T gcd(const T& a, const T& b) { if (b == 0) return abs(a); return gcd(b, a % b); } template <typename T> T gcd(const T& a, const T& b, T& x, T& y) { if (b == 0) { x = a < 0 ? -1 : 1; y = 0; return x * a; } T d = gcd(b, a % b, y, x); y -= (a / b) * x; return d; } template <typename T> T lcm(const T& a, const T& b) { return abs(a / gcd(a, b) * b); } template <typename T> T mod_add(const T& a, const T& b, const T& m) { if (a < m - b) return a + b; return a - (m - b); } template <typename T> T mod_sub(const T& a, const T& b, const T& m) { if (a < b) return a + (m - b); return a - b; } template <typename T> T mod_mul(T a, T b, const T& m) { if (b > a) swap(a, b); T r = 0; while (b > 0) { if (b & 1) r = mod_add(r, a, m); a = mod_add(a, a, m); b /= 2; } return r; } template <typename T1, typename T2> T1 mod_pow(T1 a, T2 n, const T1& m) { if (m == 1) return 0; T1 r = 1; while (n > 0) { if (n & 1) r = mod_mul(r, a, m); a = mod_mul(a, a, m); n /= 2; } return r; } template <typename T> T mod_inv(const T& a, const T& m) { T x, y; T d = gcd(a, m, x, y); if (d != 1) return 0; if (x < 0) x += m; return x; } struct Sieve { int* lpf = nullptr; int* phi = nullptr; int size; vector<int> primes; Sieve(bool calcPhi = false, int n = 0xfffff) : size(n) { lpf = new int[size + 1]; fill(lpf, lpf + size + 1, 0); lpf[1] = 1; if (calcPhi) { phi = new int[size + 1]; phi[1] = 1; for (int i = 2; i <= size; ++i) { if (lpf[i] == 0) { phi[i] = i - 1; lpf[i] = i; primes.push_back(i); } for (int j = 0, t; j < primes.size() && (t = i * primes[j]) <= size; ++j) { lpf[t] = primes[j]; if (primes[j] == lpf[i]) { phi[t] = phi[i] * primes[j]; break; } phi[t] = phi[i] * (primes[j] - 1); } } } else { for (int i = 2; i <= size; ++i) { if (lpf[i] == 0) { lpf[i] = i; primes.push_back(i); } for (int j = 0, t; j < primes.size() && (t = i * primes[j]) <= size; ++j) { lpf[t] = primes[j]; if (primes[j] == lpf[i]) break; } } } } Sieve(int n) : Sieve(false, n) {} ~Sieve() { delete[] lpf; lpf = nullptr; delete[] phi; phi = nullptr; } }; template <typename T> T phi(T n) { T r = n; for (T i = 2; i * i <= n; ++i) { if (n % i == 0) { r -= r / i; do { n /= i; } while (n % i == 0); } } if (n > 1) r -= r / n; return r; } } // namespace algo using namespace std; using namespace algo; namespace task { struct Widget; map<string, Widget*> widgets; struct Widget { char type; int64_t width = -1; int64_t height = -1; int64_t border = 0; int64_t spacing = 0; vector<string> children; Widget(char type, int64_t width = -1, int64_t height = -1) : type(type), width(width), height(height) {} void pack(const string& name) { children.push_back(name); } pair<int64_t, int64_t> size() { if (width == -1 || height == -1) { if (type == W ) { exit(3); } else if (children.size() == 0) { width = 0; height = 0; } else if (type == H ) { int64_t t_width = (children.size() - 1) * spacing; int64_t t_height = 0; for (int i = 0; i < children.size(); ++i) { pair<int64_t, int64_t> t_size = widgets[children[i]]->size(); t_width += t_size.first; t_height = max(t_height, t_size.second); } width = t_width + 2 * border; height = t_height + 2 * border; } else if (type == V ) { int64_t t_width = 0; int64_t t_height = (children.size() - 1) * spacing; for (int i = 0; i < children.size(); ++i) { pair<int64_t, int64_t> t_size = widgets[children[i]]->size(); t_width = max(t_width, t_size.first); t_height += t_size.second; } width = t_width + 2 * border; height = t_height + 2 * border; } } return {width, height}; } }; int n, x, y; string s, name1, name2; int main() { cin >> n; for (int i = 0; i < n; ++i) { cin >> s; if (s == Widget ) { cin >> s; char name[16]; int64_t width, height; sscanf(s.c_str(), %[a-z](%lli,%lli) , name, &width, &height); name1 = string(name); widgets[name1] = new Widget( W , width, height); } else if (s == VBox ) { cin >> name1; widgets[name1] = new Widget( V ); } else if (s == HBox ) { cin >> name1; widgets[name1] = new Widget( H ); } else { char name_1[16]; char name_2[16]; char method[16]; sscanf(s.c_str(), %[a-z].%[a-z_](%[a-z0-9]) , name_1, method, name_2); name1 = string(name_1); if (string(method) == pack ) { name2 = string(name_2); widgets[name1]->pack(name2); } else if (string(method) == set_border ) { int64_t border; sscanf(name_2, %lli , &border); widgets[name1]->border = border; } else if (string(method) == set_spacing ) { int64_t spacing; sscanf(name_2, %lli , &spacing); widgets[name1]->spacing = spacing; } } } for (auto& it : widgets) { pair<int64_t, int64_t> size = it.second->size(); cout << it.first << << size.first << << size.second << n ; } return 0; } } // namespace task int main() { ios_base::sync_with_stdio(false); cin.tie(nullptr); cout.precision(11); cout.setf(ios::fixed); return task::main(); }
|
#include <bits/stdc++.h> using namespace std; const int mod = 1000000009; map<pair<int, int>, int> in, id; set<int> S; int X[100010], Y[100010]; bool check(pair<int, int> P) { int x = P.first, y = P.second + 1; for (int dx = x - 1; dx <= x + 1; dx++) { if (in.count(make_pair(dx, y)) && in[make_pair(dx, y)] == 1) return 0; } return 1; } int main() { int n; cin >> n; for (int i = 0; i < n; i++) { int x, y; cin >> x >> y; X[i] = x, Y[i] = y; in[make_pair(x, y)] = 0, id[make_pair(x, y)] = i; } for (map<pair<int, int>, int>::iterator it = in.begin(); it != in.end(); it++) { int x = it->first.first, y = it->first.second - 1; for (int dx = x - 1; dx <= x + 1; dx++) { if (in.count(make_pair(dx, y))) { in[it->first]++; } } } for (map<pair<int, int>, int>::iterator it = in.begin(); it != in.end(); it++) { if (check(it->first)) S.insert(id[it->first]); } long long ans = 0; for (int it = 0; it < n; it++) { if (it & 1) { int v = *S.begin(); S.erase(S.begin()); int y = Y[v] + 1; id.erase(make_pair(X[v], Y[v])); in[make_pair(X[v], Y[v])] = 0; for (int x = X[v] - 1; x <= X[v] + 1; x++) { if (!id.count(make_pair(x, y))) continue; in[make_pair(x, y)]--; } y--; for (int x = X[v] - 2; x <= X[v] + 2; x++) { if (!id.count(make_pair(x, y))) continue; if (check(make_pair(x, y))) S.insert(id[make_pair(x, y)]); else S.erase(id[make_pair(x, y)]); } y--; for (int x = X[v] - 2; x <= X[v] + 2; x++) { if (!id.count(make_pair(x, y))) continue; if (check(make_pair(x, y))) S.insert(id[make_pair(x, y)]); else S.erase(id[make_pair(x, y)]); } ans = (ans * n + v) % mod; } else { int v = *(--S.end()); S.erase(--S.end()); int y = Y[v] + 1; id.erase(make_pair(X[v], Y[v])); in[make_pair(X[v], Y[v])] = 0; for (int x = X[v] - 1; x <= X[v] + 1; x++) { if (!id.count(make_pair(x, y))) continue; in[make_pair(x, y)]--; } y--; for (int x = X[v] - 2; x <= X[v] + 2; x++) { if (!id.count(make_pair(x, y))) continue; if (check(make_pair(x, y))) S.insert(id[make_pair(x, y)]); else S.erase(id[make_pair(x, y)]); } y--; for (int x = X[v] - 2; x <= X[v] + 2; x++) { if (!id.count(make_pair(x, y))) continue; if (check(make_pair(x, y))) S.insert(id[make_pair(x, y)]); else S.erase(id[make_pair(x, y)]); } ans = (ans * n + v) % mod; } } cout << ans << endl; return 0; }
|
#include<bits/stdc++.h> #include<algorithm> #include<iostream> #include<cstdio> #include<cmath> #include<cstring> #include<stack> #include<queue> using namespace std; typedef long long ll; const ll INF=0x7f7f7f7f; const int maxn=2e5+7; const ll mod=1e9+7; ll read(){ ll f=0,x=0;char ch=getchar(); while(!isdigit(ch)){if(ch== - ) f=1;ch=getchar();} while(isdigit(ch)){x=x*10+ch- 0 ;ch=getchar();} return !f?x:-x; } int tt,n,s[maxn]; bool check(int x,int y){ if(x==3){ if(s[y]>=s[y+1]&&s[y+1]>=s[y+2]) return false; if(s[y]<=s[y+1]&&s[y+1]<=s[y+2]) return false; return true; } else{ for(int i=0;i<4;i++){ for(int j=i+1;j<4;j++){ for(int k=j+1;k<4;k++){ if(s[y+i]>=s[y+j]&&s[y+j]>=s[y+k]) return false; if(s[y+i]<=s[y+j]&&s[y+j]<=s[y+k]) return false; } } } return true; } } int main(){ scanf( %d ,&tt); while(tt--){ ll ans=0; scanf( %d ,&n); for(int i=1;i<=n;i++){ scanf( %d ,&s[i]); } ans+=2*n-1; for(int i=3;i<=4;i++){ for(int j=1;j<=n-i+1;j++){ if(check(i,j)) ans++; } } printf( %lld n ,ans); } return 0; }
|
#include <bits/stdc++.h> const int N = 1e5 + 5, M = 2e5 + 5, logN = 17 + 1; int n, m, root, idx, a[N], f[N][logN], dfn[N], seq[N], sz[N], dep[N]; int tot, lnk[N], ter[M], nxt[M]; long long seg[N << 2], tag[N << 2]; void pushup(int rt) { seg[rt] = seg[rt << 1] + seg[rt << 1 | 1]; } void build(int rt, int l, int r) { if (l == r) { seg[rt] = a[seq[l]]; return; } int mid = (l + r) >> 1; build(rt << 1, l, mid); build(rt << 1 | 1, mid + 1, r); pushup(rt); } void update(int rt, int l, int r, long long k) { seg[rt] += 1LL * (r - l + 1) * k; tag[rt] += k; } void pushdown(int rt, int l, int r) { if (!tag[rt]) return; int mid = (l + r) >> 1; update(rt << 1, l, mid, tag[rt]); update(rt << 1 | 1, mid + 1, r, tag[rt]); tag[rt] = 0; } void modify(int x, int y, int rt, int l, int r, int k) { if (x <= l && r <= y) { update(rt, l, r, k); return; } pushdown(rt, l, r); int mid = (l + r) >> 1; if (x <= mid) modify(x, y, rt << 1, l, mid, k); if (mid < y) modify(x, y, rt << 1 | 1, mid + 1, r, k); pushup(rt); } long long query(int x, int y, int rt, int l, int r) { if (x <= l && r <= y) return seg[rt]; pushdown(rt, l, r); int mid = (l + r) >> 1; long long ret = 0; if (x <= mid) ret += query(x, y, rt << 1, l, mid); if (mid < y) ret += query(x, y, rt << 1 | 1, mid + 1, r); return ret; } void add(int u, int v) { ter[++tot] = v, nxt[tot] = lnk[u], lnk[u] = tot; } void dfs(int u, int fa) { dep[u] = dep[fa] + 1, f[u][0] = fa, dfn[u] = ++idx, seq[idx] = u, sz[u] = 1; for (int i = 1; (1 << i) <= dep[u]; ++i) f[u][i] = f[f[u][i - 1]][i - 1]; for (int i = lnk[u]; i; i = nxt[i]) { int v = ter[i]; if (v == fa) continue; dfs(v, u), sz[u] += sz[v]; } } int lca(int u, int v) { if (dep[u] > dep[v]) u ^= v ^= u ^= v; for (int i = 17; ~i; --i) if (dep[f[v][i]] >= dep[u]) v = f[v][i]; if (u == v) return u; for (int i = 17; ~i; --i) if (f[u][i] ^ f[v][i]) u = f[u][i], v = f[v][i]; return f[u][0]; } int getlca(int u, int v, int p) { int x = lca(u, v), y = lca(u, p), z = lca(v, p); if (dep[y] > dep[x]) x = y; if (dep[z] > dep[x]) x = z; return x; } int jump(int u, int d) { for (int i = 17; ~i; --i) if (d & (1 << i)) u = f[u][i]; return u; } void treeModify(int u, int k) { int l = dfn[u], r = dfn[u] + sz[u] - 1; if (u == root) modify(1, n, 1, 1, n, k); else if (dfn[root] < l || dfn[root] > r) modify(l, r, 1, 1, n, k); else { int son = jump(root, dep[root] - dep[u] - 1); modify(1, n, 1, 1, n, k), modify(dfn[son], dfn[son] + sz[son] - 1, 1, 1, n, -k); } } long long treeQuery(int u) { int l = dfn[u], r = dfn[u] + sz[u] - 1; if (u == root) return query(1, n, 1, 1, n); else if (dfn[root] < l || dfn[root] > r) return query(l, r, 1, 1, n); else { int son = jump(root, dep[root] - dep[u] - 1); return query(1, n, 1, 1, n) - query(dfn[son], dfn[son] + sz[son] - 1, 1, 1, n); } } int main() { scanf( %d%d , &n, &m); for (int i = 1; i <= n; ++i) scanf( %d , &a[i]); for (int i = 1; i < n; ++i) { int u, v; scanf( %d%d , &u, &v); add(u, v), add(v, u); } dfs(1, 0); build(1, 1, n); root = 1; while (m--) { int opt; scanf( %d , &opt); if (opt == 1) { scanf( %d , &root); } else if (opt == 2) { int u, v, x; scanf( %d%d%d , &u, &v, &x); treeModify(getlca(u, v, root), x); } else { int x; scanf( %d , &x); printf( %lld n , treeQuery(x)); } } return 0; }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.