func_code_string stringlengths 59 71.4k |
|---|
#include <bits/stdc++.h> using namespace std; const long long INF = (long long)(1e9 + 7); bool check(pair<int, int> a, pair<int, int> b) { return (a.first < b.first); } int main() { int t; cin >> t; while (t--) { int m, n; cin >> m >> n; int a[31][31]; pair<int, int> x[65]; for (int i = 0; i < 65; i++) { x[i] = {0, 0}; } for (int i = 1; i <= m; i++) { for (int j = 1; j <= n; j++) { cin >> a[i][j]; } } for (int i = 1; i <= m; i++) { for (int j = 1; j <= n; j++) { x[i + j].first += a[i][j]; x[i + j].second++; } } int sum = 0; for (int i = 2; 2 * i <= m + n + 1; i++) { sum += min(x[i].first + x[m + n + 2 - i].first, x[i].second + x[m + n + 2 - i].second - (x[i].first + x[m + n + 2 - i].first)); } cout << sum << endl; } } |
#include <bits/stdc++.h> using namespace std; int n, a[100010], new_arr[100010], new_arr1[100010], arr[100010]; int x = 1000000; int main() { cin >> n; for (int i = 0; i < n; i++) { cin >> a[i]; } for (int i = 0; i < n; i++) { new_arr[i] = min((i + 1), (n - i)); new_arr1[i] = a[i] - new_arr[i]; if (new_arr1[i] >= 0) { arr[new_arr1[i]]++; } } for (int i = 0; i < 100000; i++) { x = min(x, n - arr[i]); } cout << x; } |
#include <bits/stdc++.h> #pragma warning(disable : 4996) using namespace std; const int mod = 1000000007; const int inf = 2012345678; const long long infl = 9012345678901234567; const double pi = 3.1415926535897932384626433832795; struct rat { long long a, b; rat(long long _a = 0, long long _b = 1) { if (_b < 0) _a = -_a, _b = -_b; a = _a; b = _b; } bool operator<(const rat& ot) const { return a * ot.b < ot.a * b; } rat operator-() const { return rat(-a, b); } bool operator==(const rat& ot) const { return a * ot.b == ot.a * b; } }; const int N = 100000; const int LG = 17; vector<int> adj[N]; int rnk[N], up[N], anc[N][LG], down[N], hvc[N], cnt[N]; void dfs0(int u) { cnt[u] = 1; hvc[u] = -1; for (auto& x : adj[u]) { if (x == anc[u][0]) continue; rnk[x] = rnk[u] + 1; anc[x][0] = u; dfs0(x); cnt[u] += cnt[x]; if (hvc[u] == -1 || cnt[x] > cnt[hvc[u]]) hvc[u] = x; } } void dfs1(int u, bool hv) { if (hv) up[u] = u; else up[u] = up[anc[u][0]]; if (hvc[u] == -1) { down[u] = u; } else { dfs1(hvc[u], false); down[u] = down[hvc[u]]; } for (auto& x : adj[u]) { if (x == anc[u][0] || x == hvc[u]) continue; dfs1(x, true); } } int lca(int u, int v) { if (rnk[u] < rnk[v]) swap(u, v); int d = rnk[u] - rnk[v]; for (int i = 0; i < (LG); i++) if (d & (1 << i)) u = anc[u][i]; if (u == v) return u; for (int i = LG - 1; i >= 0; i--) if (anc[u][i] != anc[v][i]) u = anc[u][i], v = anc[v][i]; return anc[u][0]; } struct Query { int X, Y; int s, c; Query() {} Query(int a, int b, int x, int y) : X(a), Y(b), s(x), c(y) {} }; vector<Query> qs[N]; double ans = 1e12; int chk[N]; void solve(int u) { priority_queue<tuple<rat, int, int, int> > pq; auto cmp = [&](int i, int j) -> bool { if (rat(qs[u][i].X, qs[u][i].c) < rat(qs[u][j].X, qs[u][j].c)) { return rat((long long)qs[u][i].c * qs[u][j].X, qs[u][j].c) < qs[u][j].s - qs[u][i].s + qs[u][i].X; } else { return rat(qs[u][i].s - qs[u][j].s + qs[u][j].X, 1) < rat((long long)qs[u][i].X * qs[u][j].c, qs[u][i].c); } }; set<int, decltype(cmp)> st(cmp); int sz = qs[u].size(); for (int i = 0; i < (sz); i++) { pq.push(make_tuple(rat(-qs[u][i].X, qs[u][i].c), 2, i, 0)); pq.push(make_tuple(rat(-qs[u][i].Y, qs[u][i].c), 1, i, 0)); chk[i] = 0; } while (!pq.empty()) { auto T = pq.top(); pq.pop(); int tp = get<1>(T); rat time = -get<0>(T); if (tp == 1) { int i = get<2>(T); chk[i] = 0; auto it = st.find(i); it = st.erase(it); auto it2 = it; if (it != st.begin()) { it2--; if (it != st.end()) { int i = *it; int j = *it2; if (qs[u][i].c != qs[u][j].c) { rat ntime = rat(qs[u][i].X - qs[u][j].X - qs[u][i].s + qs[u][j].s, qs[u][i].c - qs[u][j].c); if (!(ntime < time)) { pq.push(make_tuple(-ntime, 3, i, j)); } } } } } else if (tp == 2) { int i = get<2>(T); chk[i] = 1; auto P = st.insert(i); if (!P.second) { ans = min(ans, (double)time.a / time.b); return; } auto it2 = P.first; auto it = it2; if (it != st.begin()) { it2--; int j = *it2; if (qs[u][i].c != qs[u][j].c) { rat ntime = rat(qs[u][i].X - qs[u][j].X - qs[u][i].s + qs[u][j].s, qs[u][i].c - qs[u][j].c); if (!(ntime < time)) { pq.push(make_tuple(-ntime, 3, i, j)); } } } it2 = it; it2++; if (it2 != st.end()) { int j = *it2; if (qs[u][i].c != qs[u][j].c) { rat ntime = rat(qs[u][i].X - qs[u][j].X - qs[u][i].s + qs[u][j].s, qs[u][i].c - qs[u][j].c); if (!(ntime < time)) { pq.push(make_tuple(-ntime, 3, i, j)); } } } } else { int u = get<2>(T); int v = get<3>(T); if (!chk[u] || !chk[v]) continue; ans = min(ans, (double)time.a / time.b); return; } } } int main() { freopen( input.txt , r , stdin); int n, m; scanf( %d%d , &(n), &(m)); for (int i = 0; i < (n - 1); i++) { int a, b; scanf( %d%d , &(a), &(b)); a--; b--; adj[a].push_back(b); adj[b].push_back(a); } anc[0][0] = -1; dfs0(0); dfs1(0, true); for (int j = 1; j <= (LG - 1); j++) for (int i = 0; i < (n); i++) { int a = anc[i][j - 1]; if (a == -1) anc[i][j] = -1; else anc[i][j] = anc[a][j - 1]; } for (int i = 0; i < (m); i++) { int t, c, u, v; scanf( %d%d , &(t), &(c)); scanf( %d%d , &(u), &(v)); u--; v--; bool good = false; int L = lca(u, v); int ou = u; while (up[u] != up[L]) { int uu = up[u]; qs[uu].emplace_back(-(c * t + rnk[ou] - rnk[u]), -(c * t + rnk[ou] - rnk[uu] + 1), rnk[u], -c); u = anc[uu][0]; } if (u != L) { qs[up[u]].emplace_back(-(c * t + rnk[ou] - rnk[u]), -(c * t + rnk[ou] - rnk[L]), rnk[u], -c); good = true; } int d = rnk[ou] - rnk[L]; while (up[v] != up[L]) { int vv = up[v]; qs[vv].emplace_back(t * c + rnk[vv] - 1 - rnk[L] + d, t * c + rnk[v] - rnk[L] + d, rnk[vv] - 1, c); v = anc[vv][0]; } if (v != L) { good = true; qs[up[v]].emplace_back(t * c + d, t * c + rnk[v] - rnk[L] + d, rnk[L], c); } if (!good) { qs[up[L]].emplace_back(t * c + d, t * c + d, rnk[L], c); } } for (int i = 0; i < (n); i++) { if (up[i] == i) { solve(i); } } if (ans > 1e11) { puts( -1 ); } else printf( %.15f n , ans); return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { string pixels; getline(cin, pixels); getline(cin, pixels); int len = 0, flen = 0, last = pixels.at(0) - 0 ; bool first = false; for (int i = (0); i < (pixels.size()); i += (2)) { if ((pixels.at(i) == 0 && last == 0) || (pixels.at(i) == 1 && last == 1)) len++; else { if (!first) { flen = len; first = true; } else if (flen != len) { printf( NO ); return 0; } len = 1; last = 1 - last; } } if (!flen || flen == len) printf( YES ); else printf( NO ); return 0; } |
#include <bits/stdc++.h> using namespace std; int cnt[200010]; long long num[200010]; struct P { int x, y, fl; bool operator<(const P &hs) const { if (x != hs.x) return x < hs.x; else return y < hs.y; } } p[200010]; int row[200010]; int pre[200010]; int n, k; int main() { scanf( %d %d , &n, &k); for (int i = 0; i < n; i++) { scanf( %d %d , &p[i].x, &p[i].y); p[i].fl = 1; p[i + n].x = p[i].x + k; p[i + n].y = p[i].y; p[i + n].fl = -1; row[i] = p[i].y; row[i + n] = row[i] + k; } sort(row, row + 2 * n); int ro = 0; for (int i = 1; i < 2 * n; i++) if (row[i] != row[ro]) row[++ro] = row[i]; sort(p, p + 2 * n); for (int i = 0; i < 2 * n; i++) { int y = lower_bound(row, row + ro, p[i].y) - row; for (int j = y; row[j] < row[y] + k; j++) { if (cnt[j] > 0) num[cnt[j]] += (long long)(row[j + 1] - row[j]) * (p[i].x - pre[j]); cnt[j] += p[i].fl; pre[j] = p[i].x; } } for (int i = 1; i <= n; i++) printf( %I64d%c , num[i], i == n ? n : ); return 0; } |
#include <bits/stdc++.h> using namespace std; const long long MM = 10000000000000001; int n; long long a[200005]; int rs[200005]; long long lazy[4 * 200005]; pair<long long, int> it[4 * 200005]; pair<long long, int> minp(pair<long long, int> A, pair<long long, int> B) { if (A.first < B.first) return A; if (A.first > B.first) return B; if (A.second > B.second) return A; return B; } void build(int x, int l, int r) { if (l == r) { it[x] = make_pair(a[l], l); return; } int mid = (l + r) / 2; build(2 * x, l, mid); build(2 * x + 1, mid + 1, r); it[x] = minp(it[2 * x], it[2 * x + 1]); } void lazy_upd(int x, int l, int r) { it[x].first += lazy[x]; if (l != r) { lazy[2 * x] += lazy[x]; lazy[2 * x + 1] += lazy[x]; } lazy[x] = 0; } void update(int x, int l, int r, int u, int v, long long val) { lazy_upd(x, l, r); if ((r < u) || (v < l)) return; if ((u <= l) && (r <= v)) { lazy[x] += val; lazy_upd(x, l, r); return; } int mid = (l + r) / 2; update(2 * x, l, mid, u, v, val); update(2 * x + 1, mid + 1, r, u, v, val); it[x] = minp(it[2 * x], it[2 * x + 1]); } int main() { ios::sync_with_stdio(0); cin >> n; for (int i = 1; i <= n; i++) cin >> a[i]; build(1, 1, n); for (int i = 1; i <= n; i++) { pair<long long, int> p = it[1]; int id = p.second; rs[id] = i; update(1, 1, n, id, id, MM); update(1, 1, n, id + 1, n, -i); } for (int i = 1; i <= n; i++) cout << rs[i] << ; return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(0); cin.tie(0); int n; cin >> n; vector<int> v(n); for (int i = 0; i < n; i++) { cin >> v[i]; } int mx = *max_element(v.begin(), v.end()); int mn = *min_element(v.begin(), v.end()); int ind1 = 0, ind2 = 0; for (int i = 0; i < n; i++) { if (v[i] == mx && ind1 == 0) ind1 = i + 1; else if (v[i] == mn) ind2 = i + 1; } ind2--; ind1--; if (ind1 > ind2) ind2++; long long result = ind1 + n - ind2 - 1; cout << result; } |
#include <bits/stdc++.h> using namespace std; int main() { int n, k, l, i, j = 0, s = 0, a, b, x, y; cin >> n >> a >> x >> b >> y; while (a != x && b != y) { a++; b--; if (b == 0 && b != y) b = n; if (a == n + 1 && a != x) a = 1; if (a == b) { cout << yes ; j = 1; break; } if (a == x || b == y) break; } if (j != 1) cout << no ; return 0; } |
#include <bits/stdc++.h> using namespace std; const int maxn = 1e5 + 5; int n; long long k; long long a[maxn]; long long b[maxn], c[maxn], d[maxn]; int main() { scanf( %d%lld , &n, &k); for (int i = 1; i <= n; i++) scanf( %lld , a + i); sort(a + 1, a + n + 1); int m = 0; for (int i = 1; i <= n; i++) { if (a[i] == a[m]) { ++b[m]; } else { a[++m] = a[i]; b[m] = 1; } } n = m; for (int i = 1; i <= n; i++) { c[i] = c[i - 1] + b[i]; } for (int i = n; i; i--) { d[i] = d[i + 1] + b[i]; } int l = 1, r = n; long long L = a[l], R = a[r]; while (l != r) { if (c[l] <= d[r]) { if (c[l] * (a[l + 1] - a[l]) > k) { L = a[l] + k / c[l]; break; } else { k -= c[l] * (a[l + 1] - a[l]); L = a[++l]; } } else { if (d[r] * (a[r] - a[r - 1]) > k) { R = a[r] - k / d[r]; break; } else { k -= d[r] * (a[r] - a[r - 1]); R = a[--r]; } } } printf( %lld n , R - L); return 0; } |
#include <bits/stdc++.h> using namespace std; int dx[] = {1, -1, 0, 0}; int dy[] = {0, 0, 1, -1}; double PI = 3.1415926535897932384626433832795; const long long oo = (long long)1e9 + 1; const double eps = 1e-9; const long long mod = 1000000007; string s; long long nb, ns, nc, pb, ps, pc, R; int main() { cin >> s; cin >> nb >> ns >> nc; cin >> pb >> ps >> pc; cin >> R; int cb = 0, cs = 0, cc = 0; for (int i = 0; s[i]; i++) if (s[i] == B ) cb++; else if (s[i] == S ) cs++; else cc++; long long l = 0, r = 1e15, ret = 0; while (l <= r) { long long mid = (l + r) >> 1; if (max(cb * mid - nb, 0ll) * pb + max(cs * mid - ns, 0ll) * ps + max(cc * mid - nc, 0ll) * pc <= R) ret = mid, l = mid + 1; else r = mid - 1; } cout << ret << endl; return 0; } |
#include <bits/stdc++.h> int main() { long long palite, primeite; std::cin >> palite >> primeite; long long primes = 0, palindromes = 0, max; static bool prime[12000001]; for (long long i = 0; i <= 12000000; i++) { prime[i] = true; } prime[1] = false; std::string str = 0 ; for (long long i = 1; i <= 12000000; i++) { if (prime[i]) { primes += primeite; for (long long j = i * i; j <= 12000000; j += i) { prime[j] = false; } } long long pos; for (pos = str.length() - 1; pos >= 0; pos--) { if (str[pos] == 9 ) { str[pos] = 0 ; } else { str[pos]++; break; } } if (pos == -1) { str.insert(str.begin(), 1 ); } palindromes += palite; for (long long j = 0, back = str.length() - 1; back > j; j++, back--) { if (str[j] != str[back]) { palindromes -= palite; break; } } if (primes <= palindromes) { max = i; } } if (max == 12000000) { std::cout << Palindromic tree is better than splay tree ; } else { std::cout << max; } return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int n, i, j; string s; cin >> n; cin >> s; n = s.size(); for (i = 0; i < n - 1; i++) { if (s[i] > s[i + 1]) break; } if (i != n - 1) { cout << YES << n ; cout << i + 1 << << i + 2 << n ; } else { cout << NO << n ; } } |
#include <bits/stdc++.h> int main() { char s[512]; scanf( %s , s); int length = strlen(s); int i; int alpha_cnt = 0; for (i = 0; i < length; i++) { if (s[i] - a > alpha_cnt) { puts( NO ); return 0; } if (s[i] - a == alpha_cnt) { alpha_cnt++; } } puts( YES ); return 0; } |
#include <bits/stdc++.h> using namespace std; using ll = long long; using ld = double; using pll = pair<ll, ll>; using vll = vector<ll>; using vpll = vector<pll>; using vvll = vector<vll>; vector<vector<ll>> g; vector<bool> v; ll res; pair<bool, bool> dfs(int u, int depth) { v[u] = true; if (depth > 2 && g[u].size() == 1) return make_pair(false, false); bool inSet = false; bool isDominated = false; for (ll i = 0; i < (ll)g[u].size(); ++i) { if (v[g[u][i]]) continue; auto t = dfs(g[u][i], depth + 1); inSet |= !t.first; isDominated |= t.second; } if (depth <= 1) return make_pair(true, true); if (inSet) res++; return make_pair(isDominated || inSet, inSet); } int main() { ios::sync_with_stdio(0); cout.tie(0); cin.tie(0); ll n; cin >> n; g = vector<vector<ll>>(n); v = vector<bool>(n); for (ll i = 0; i < (ll)n - 1; ++i) { ll u, v; cin >> u >> v; u--; v--; g[u].push_back(v); g[v].push_back(u); } dfs(0, 0); cout << res << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); void solve() { long long n; cin >> n; vector<long long> a(n), b; for (long long i = 0; i < n; i++) { cin >> a[i]; } b = a; sort(b.begin(), b.end()); b.resize(unique(b.begin(), b.end()) - b.begin()); for (long long i = 0; i < n; i++) { a[i] = lower_bound(b.begin(), b.end(), a[i]) - b.begin(); } vector<long long> dp(n, -1e9); dp[a[0]] = 1; for (long long i = 1; i < n; i++) { dp[a[i]] = 1; if (a[i]) dp[a[i]] = max(dp[a[i]], dp[a[i] - 1] + 1); } long long ans = n - *max_element(dp.begin(), dp.end()); cout << ans << n ; } signed main() { ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0); long long q; cin >> q; while (q--) { solve(); } } |
#include <bits/stdc++.h> int n, up, s; int a[20], ans[5][5], s1[5], s2[5], s3, s4, idx[1 << 16], cnt[1 << 16]; bool ans_u, vis[1 << 16]; void dfs(int sta) { if (sta == up) { if (ans_u) return; printf( %d n , s); for (int i = 0, j; i < n; ++i) { for (j = 0; j < n; ++j) { if (j) putchar( ); printf( %d , ans[i][j]); } puts( ); } ans_u = 1; return; } int x = cnt[sta] / n, y = cnt[sta] % n; for (int ts = up ^ sta, t, u; ts && !ans_u; ts ^= ts & (-ts)) { t = a[idx[ts & (-ts)]]; s1[x] += t; s2[y] += t; if (x == y) s3 += t; if (x + y == n - 1) s4 += t; u = 1; if (y == n - 1 && s1[x] != s) u = 0; if (x == n - 1 && s2[y] != s) u = 0; if (x == n - 1 && y == n - 1 && s3 != s) u = 0; if (x == n - 1 && y == 0 && s4 != s) u = 0; if (u) { ans[x][y] = t, dfs(sta ^ ((ts & (-ts)))); } s1[x] -= t; s2[y] -= t; if (x == y) s3 -= t; if (x + y == n - 1) s4 -= t; } } int main() { scanf( %d , &n); for (int i = 0; i < n * n; ++i) { scanf( %d , &a[i]); s += a[i]; } s /= n; up = (1 << (n * n)) - 1; idx[1] = 0; for (int i = 1, j = 1; i < up; idx[i <<= 1] = j++) ; cnt[0] = 0; for (int i = 1; i <= up; ++i) cnt[i] = cnt[i >> 1] + (i & 1); dfs(0); return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { ios::sync_with_stdio(0), cin.tie(0); int n, j = 0; cin >> n; int a[n], b[n]; pair<int, int> s[n]; for (auto &i : s) cin >> i.first, i.second = j++; sort(s, s + n); map<int, int> mp; for (int i = 0; i < n; i++) mp[s[i].second] = i; for (int i = 0; i < (n + 2) / 3; i++) a[i] = i; for (int i = (n + 2) / 3; i < (2 * n + 2) / 3; i++) b[i] = i; for (int i = n - 1; i >= (2 * n + 2) / 3; i--) b[i] = n - 1 - i; for (int i = (n + 2) / 3; i < n; i++) a[i] = s[i].first - b[i]; for (int i = 0; i < (n + 2) / 3; i++) b[i] = s[i].first - a[i]; cout << YES << n ; for (int i = 0; i < n; i++) cout << a[mp[i]] << ; cout << n ; for (int i = 0; i < n; i++) cout << b[mp[i]] << ; } |
#include <bits/stdc++.h> using namespace std; void populate(string& s, char c, int n) { for (int i = 0; i < n; ++i) s[s.find_first_of( ? )] = c; } int main() { ios::sync_with_stdio(0); int n; cin >> n; string s; cin >> s; auto na = count(s.begin(), s.end(), A ); auto nc = count(s.begin(), s.end(), C ); auto ng = count(s.begin(), s.end(), G ); auto nt = count(s.begin(), s.end(), T ); auto nq = count(s.begin(), s.end(), ? ); auto m = max(na, max(nc, (max(ng, nt)))); auto da = m - na; auto dc = m - nc; auto dg = m - ng; auto dt = m - nt; if (nq < da + dc + dg + dt) { cout << === << endl; } else if ((nq - (da + dc + dg + dt)) % 4 != 0) { cout << === << endl; } else { populate(s, A , da); populate(s, C , dc); populate(s, G , dg); populate(s, T , dt); for (int i = 0; i < (nq - (da + dc + dg + dt)); i += 4) { populate(s, A , 1); populate(s, C , 1); populate(s, G , 1); populate(s, T , 1); } cout << s << endl; } } |
#include <bits/stdc++.h> using namespace std; using Real = long double; Real g_err = 1e-9; bool r_eq(Real x, Real y, Real err = g_err) { return abs(x - y) <= err || abs(x - y) <= abs(x) * err; } bool r_le(Real x, Real y, Real err = g_err) { return x - y <= err || x - y <= abs(x) * err; } bool r_ge(Real x, Real y, Real err = g_err) { return r_le(y, x, err); } bool r_gt(Real x, Real y, Real err = g_err) { return !r_le(x, y, err); } bool r_lt(Real x, Real y, Real err = g_err) { return !r_le(y, x, err); } bool r_ne(Real x, Real y, Real err = g_err) { return !r_eq(x, y, err); } bool rp_eq(Real x, Real y, Real err = g_err) { return abs(x - y) <= err; } bool rp_le(Real x, Real y, Real err = g_err) { return x - y <= err; } bool rp_ge(Real x, Real y, Real err = g_err) { return rp_le(y, x, err); } bool rp_gt(Real x, Real y, Real err = g_err) { return !rp_le(x, y, err); } bool rp_lt(Real x, Real y, Real err = g_err) { return !rp_le(y, x, err); } bool rp_ne(Real x, Real y, Real err = g_err) { return !rp_eq(x, y, err); } template <typename T> bool updMax(T& tmax, const T& x) { if (x > tmax) { tmax = x; return true; } else { return false; } } template <typename T> bool updMin(T& tmin, const T& x) { if (x < tmin) { tmin = x; return true; } else { return false; } } struct Point { Real x; Real y; Point() : x(0), y(0) {} Point(Real x_, Real y_) : x(x_), y(y_) {} bool operator==(const Point& p) const { return x == p.x && y == p.y; } bool operator!=(const Point& p) const { return !(*this == p); } bool sim(const Point& p, Real err = g_err) const { return r_eq(x, p.x, err) && r_eq(y, p.y, err); } static bool sim(const Point& p1, const Point& p2, Real err = g_err) { return p1.sim(p2, err); } Point& operator+=(const Point& p) { x += p.x; y += p.y; return *this; } Point& operator-=(const Point& p) { x -= p.x; y -= p.y; return *this; } Point& operator*=(Real k) { x *= k; y *= k; return *this; } Point& operator/=(Real k) { x /= k; y /= k; return *this; } Point operator+(const Point& p) const { return Point(*this) += p; } Point operator-(const Point& p) const { return Point(*this) -= p; } Point operator*(Real k) const { return Point(*this) *= k; } Point operator/(Real k) const { return Point(*this) /= k; } Point operator-() const { return (*this) * (-1); } Real len() const { return hypot(x, y); } static Point polar(Real r, Real th) { return Point(r * cos(th), r * sin(th)); } Point rotate(Real th) const { return polar(len(), atan2(y, x) + th); } Point rotateQ() const { return Point(-y, x); } bool parallel(const Point& p, Real err = g_err) const { return r_eq(x * p.y, y * p.x, err); } Real innerProd(const Point& p) const { return x * p.x + y * p.y; } Real outerProd(const Point& p) const { return x * p.y - y * p.x; } Real arg() const { return atan2(y, x); } Real angle(const Point& p) const { Real th = atan2(p.y, p.x) - atan2(y, x); return th > 3.141592653589793238462643383279502884L ? th - 2 * 3.141592653589793238462643383279502884L : th <= -3.141592653589793238462643383279502884L ? th + 2 * 3.141592653589793238462643383279502884L : th; } }; Point operator*(Real k, const Point& p) { return p * k; } ostream& operator<<(ostream& os, const Point& p) { return os << ( << p.x << , << p.y << ) ; } struct Line; ostream& operator<<(ostream& os, const Line& l); struct Line { Point dir; Point base; static Line x_axis; static Line y_axis; static constexpr int SIDE_ON = 1; static constexpr int SIDE_P = 2; static constexpr int SIDE_N = 4; static constexpr int IST_NONE = -1; static constexpr int IST_ALL = -2; static constexpr int IST_ONE = 0; Line() : dir(0, 0), base(0, 0) {} Line(const Point& d, const Point& b) : dir(d), base(b) {} bool operator==(const Line& l) const { return dir == l.dir && base == l.base; } bool operator!=(const Line& l) const { return !(*this == l); } bool sim(const Line& l1, Real err = g_err) const { return dir.sim(l1.dir, err) && dir.sim(l1.base - base, err); } static bool sim(const Line& l1, const Line& l2, Real err = g_err) { return l1.sim(l2, err); } static Line connect(const Point& p1, const Point& p2) { return Line(p2 - p1, p1); } bool parallel(const Line& l, Real err = g_err) const { return dir.parallel(l.dir, err); } int ptSide(const Point& p, Real err = g_err) const { Real t1 = dir.y * (p.x - base.x); Real t2 = dir.x * (p.y - base.y); if (r_eq(t1, t2, err)) return SIDE_ON; if (r_lt(t1, t2, err)) return SIDE_P; return SIDE_N; } bool ptOn(const Point& p, Real err = g_err) const { return ptSide(p, err) == SIDE_ON; } tuple<int, Real, Real> intersect_coeff(const Line& l) const { if (dir.parallel(l.dir)) { if (ptOn(l.base)) return make_tuple(IST_ALL, 0, 0); else return make_tuple(IST_NONE, 0, 0); } else { Real d = dir.x * (-l.dir.y) - (-l.dir.x) * dir.y; Point z = l.base - base; Real t1 = ((-l.dir.y) * z.x + l.dir.x * z.y) / d; Real t2 = ((-dir.y) * z.x + dir.x * z.y) / d; return {IST_ONE, t1, t2}; } } Point unsafe_intersect(const Line& l) const { auto [rc, t1, t2] = intersect_coeff(l); assert(rc == IST_ONE); return base + t1 * dir; } Point perpend_foot(const Point& p) const { Real t1 = perpend_foot_coeff(p); return base + t1 * dir; } Real perpend_foot_coeff(const Point& p) const { auto [rc, t1, t2] = intersect_coeff(Line(dir.rotateQ(), p)); return t1; } Real len(const Point& p) const { return (p - perpend_foot(p)).len(); } }; ostream& operator<<(ostream& os, const Line& l) { return os << [d << l.dir << , b << l.base << ) ; } Line Line::x_axis(Point(1, 0), Point(0, 0)); Line Line::y_axis(Point(0, 1), Point(0, 0)); struct Circle { Point c; Real r; Circle() : c(0, 0), r(0) {} Circle(const Point& c_, Real r_) : c(c_), r(r_) {} bool operator==(const Circle& o) const { return c == o.c && r == o.r; } bool operator!=(const Circle& o) const { return !(*this == o); } bool sim(const Circle& o, Real err = g_err) const { return c.sim(o.c, err) && r_eq(r, o.r, err); } static bool sim(const Circle& c1, const Circle& c2, Real err = g_err) { return c1.sim(c2, err); } bool ptOn(const Point& p, Real err = g_err) const { return r_eq((p - c).len(), r, err); } tuple<bool, Point, Point> intersect(const Line& o) const { Point f = o.perpend_foot(c); Real d = (f - c).len(); if (d > r) return make_tuple(false, Point(), Point()); Real t = sqrt(r * r - d * d); Point e = o.dir / o.dir.len(); return make_tuple(true, f + t * e, f - t * e); } tuple<bool, Point, Point> intersect(const Circle& o) const { Real d = (o.c - c).len(); if (d + r < o.r || d + o.r < r || r + o.r < d) { return make_tuple(false, Point(), Point()); } Point v = (o.c - c) / d; Real t = (r * r - o.r * o.r + d * d) / (2 * d); Line l(v.rotateQ(), c + t * v); return intersect(l); } }; ostream& operator<<(ostream& os, const Circle& circ) { return os << [c << circ.c << , << circ.r << ] ; } Point circumcenter(const Point& z1, const Point& z2, const Point& z3) { Line l12((z2 - z1).rotateQ(), (z1 + z2) / 2); Line l23((z3 - z2).rotateQ(), (z2 + z3) / 2); return l12.unsafe_intersect(l23); } vector<Point> convex_hull(const vector<Point>& pts) { vector<Point> spts(pts); int n = pts.size(); if (n == 0) return vector<Point>(); auto sub = [&]() -> vector<Point> { vector<Point> ret; for (int i = 0; i < n; i++) { Point pt = spts.at(i); if (i > 0 && spts.at(i - 1).sim(spts.at(i))) continue; while (true) { int rs = ret.size(); if (rs - 2 < 0) break; Point q0 = ret.at(rs - 2); Point q1 = ret.at(rs - 1); if ((q0 - q1).outerProd(pt - q1) < 0) break; ret.pop_back(); } ret.push_back(pt); } ret.pop_back(); return ret; }; sort(spts.begin(), spts.end(), [](const Point& a, const Point& b) -> bool { if (a.x != b.x) return a.x < b.x; return a.y < b.y; }); auto vec1 = sub(); reverse(spts.begin(), spts.end()); auto vec2 = sub(); vec1.insert(vec1.end(), vec2.begin(), vec2.end()); if (vec1.empty()) return vector<Point>({pts.at(0)}); return vec1; } tuple<Real, int, int> convex_diameter(const vector<Point>& pts) { int n = pts.size(); if (n <= 1) { cerr << diameter is called with <=1 points. n ; exit(1); } auto conn = [&](long long int i, long long int j) -> Point { return pts.at(j % n) - pts.at(i % n); }; auto edge = [&](long long int i) -> Point { return conn(i, i + 1); }; if (n == 2) return make_tuple(conn(0, 1).len(), 0, 1); int k = -1; int m = -1; for (int i = 0, cnt = 0; cnt < 2; i++) { if (edge(i).y <= 0 && edge(i + 1).y > 0) { m = i + 1; cnt++; } if (edge(i).y >= 0 && edge(i + 1).y < 0) { k = i + 1; cnt++; } } Real vmax = 0; int k0 = -1, m0 = -1; bool run_k = true; bool run_m = true; while (run_k || run_m) { if (!run_m || (run_k && edge(k).arg() - (-3.141592653589793238462643383279502884L) <= edge(m).arg())) { if (updMax(vmax, conn(k + 1, m).len())) { k0 = k + 1, m0 = m; } k++; if (edge(k).y > 0) run_k = false; } else { if (updMax(vmax, conn(k, m + 1).len())) { k0 = k, m0 = m + 1; } m++; if (edge(m).y < 0) run_m = false; } } return make_tuple(vmax, k0 % n, m0 % n); } int in_triangle(const Point& pt, const Point& tr0, const Point& tr1, const Point& tr2) { auto chk = [&](const Point& b, const Point& e, const Point& p) -> bool { Point be = e - b; Point bp = p - b; Real r = r_eq(be.x, 0.0) ? bp.y / be.y : bp.x / be.x; return 0.0 <= r && r <= 1.0; }; Line l01 = Line::connect(tr0, tr1); Line l12 = Line::connect(tr1, tr2); Line l20 = Line::connect(tr2, tr0); int side = l01.ptSide(tr2); if (side == Line::SIDE_ON) { if (!l01.ptOn(pt)) return Line::SIDE_N; return chk(tr0, tr1, pt) || chk(tr1, tr2, pt) || chk(tr2, tr0, pt) ? Line::SIDE_ON : Line::SIDE_N; } int other = side ^ (Line::SIDE_P | Line::SIDE_N); if (l01.ptSide(pt) == other || l12.ptSide(pt) == other || l20.ptSide(pt) == other) return Line::SIDE_N; if (l01.ptSide(pt) == Line::SIDE_ON || l12.ptSide(pt) == Line::SIDE_ON || l20.ptSide(pt) == Line::SIDE_ON) return Line::SIDE_ON; return Line::SIDE_P; } template <typename T1, typename T2> ostream& operator<<(ostream& os, const pair<T1, T2>& p) { os << ( << p.first << , << p.second << ) ; return os; } template <typename T1, typename T2, typename T3> ostream& operator<<(ostream& os, const tuple<T1, T2, T3>& t) { os << ( << get<0>(t) << , << get<1>(t) << , << get<2>(t) << ) ; return os; } template <typename T1, typename T2, typename T3, typename T4> ostream& operator<<(ostream& os, const tuple<T1, T2, T3, T4>& t) { os << ( << get<0>(t) << , << get<1>(t) << , << get<2>(t) << , << get<3>(t) << ) ; return os; } template <typename T> ostream& operator<<(ostream& os, const vector<T>& v) { os << [ ; for (auto it = v.begin(); it != v.end(); it++) { if (it != v.begin()) os << , ; os << *it; } os << ] ; return os; } template <typename T, typename C> ostream& operator<<(ostream& os, const set<T, C>& v) { os << { ; for (auto it = v.begin(); it != v.end(); it++) { if (it != v.begin()) os << , ; os << *it; } os << } ; return os; } template <typename T, typename C> ostream& operator<<(ostream& os, const unordered_set<T, C>& v) { os << { ; for (auto it = v.begin(); it != v.end(); it++) { if (it != v.begin()) os << , ; os << *it; } os << } ; return os; } template <typename T, typename C> ostream& operator<<(ostream& os, const multiset<T, C>& v) { os << { ; for (auto it = v.begin(); it != v.end(); it++) { if (it != v.begin()) os << , ; os << *it; } os << } ; return os; } template <typename T1, typename T2, typename C> ostream& operator<<(ostream& os, const map<T1, T2, C>& mp) { os << [ ; for (auto it = mp.begin(); it != mp.end(); it++) { if (it != mp.begin()) os << , ; os << it->first << : << it->second; } os << ] ; return os; } template <typename T1, typename T2, typename C> ostream& operator<<(ostream& os, const unordered_map<T1, T2, C>& mp) { os << [ ; for (auto it = mp.begin(); it != mp.end(); it++) { if (it != mp.begin()) os << , ; os << it->first << : << it->second; } os << ] ; return os; } template <typename T, typename T2> ostream& operator<<(ostream& os, const queue<T, T2>& orig) { queue<T, T2> que(orig); bool first = true; os << [ ; while (!que.empty()) { T x = que.front(); que.pop(); if (!first) os << , ; os << x; first = false; } return os << ] ; } template <typename T, typename T2> ostream& operator<<(ostream& os, const deque<T, T2>& orig) { deque<T, T2> que(orig); bool first = true; os << [ ; while (!que.empty()) { T x = que.front(); que.pop_front(); if (!first) os << , ; os << x; first = false; } return os << ] ; } template <typename T, typename T2, typename T3> ostream& operator<<(ostream& os, const priority_queue<T, T2, T3>& orig) { priority_queue<T, T2, T3> pq(orig); bool first = true; os << [ ; while (!pq.empty()) { T x = pq.top(); pq.pop(); if (!first) os << , ; os << x; first = false; } return os << ] ; } template <typename T> ostream& operator<<(ostream& os, const stack<T>& st) { stack<T> tmp(st); os << [ ; bool first = true; while (!tmp.empty()) { T& t = tmp.top(); if (first) first = false; else os << , ; os << t; tmp.pop(); } os << ] ; return os; } ostream& operator<<(ostream& os, int8_t x) { os << (int32_t)x; return os; } template <class... Args> string dbgFormat(const char* fmt, Args... args) { size_t len = snprintf(nullptr, 0, fmt, args...); char buf[len + 1]; snprintf(buf, len + 1, fmt, args...); return string(buf); } template <class Head> void dbgLog(bool with_nl, Head&& head) { cerr << head; if (with_nl) cerr << endl; } template <class Head, class... Tail> void dbgLog(bool with_nl, Head&& head, Tail&&... tail) { cerr << head << ; dbgLog(with_nl, forward<Tail>(tail)...); } int main() { ios_base::sync_with_stdio(false); cin.tie(nullptr); cout << setprecision(20); long long int n, q; cin >> n >> q; vector<Point> P(n); for (long long int i = 0; i < n; i++) { long long int x, y; cin >> x >> y; P[i] = Point(x, y); } Point g(0, 0); Real tots = 0; for (long long int i = 1; i < n - 1; i++) { Point lg = (P[0] + P[i] + P[i + 1]) / 3.0; Point v0i = P[i] - P[0]; Point v0j = P[i + 1] - P[0]; Real s = abs(v0i.x * v0j.y - v0i.y * v0j.x); tots += s; g += s * lg; } g = g / tots; vector<Real> L(n), Th(n); for (long long int i = 0; i < n; i++) { L[i] = (P[i] - g).len(); Th[i] = (P[0] - g).angle(P[i] - g); }; ; ; Real th0 = (P[0] - g).arg(); ; long long int pinA = 0, pinB = 1; for (long long int _q = 0; _q < q; _q++) { long long int tp; cin >> tp; if (tp == 1) { long long int f, t; cin >> f >> t; f--; t--; if (f == pinA) { pinA = pinB; pinB = t; } else { pinB = t; }; Point e(L[pinA], 0); Point pa = g + e.rotate(th0 + Th[pinA]); g = pa + e.rotate(3 * 3.141592653589793238462643383279502884L / 2); ; th0 += 3.141592653589793238462643383279502884L / 2.0 - (th0 + Th[pinA]); ; } else if (tp == 2) { long long int v; cin >> v; v--; Point e(L[v], 0); Point pv = g + e.rotate(th0 + Th[v]); cout << pv.x << << pv.y << n ; } } return 0; } |
#include <bits/stdc++.h> using namespace std; signed main() { long long t; cin >> t; while (t--) { long long n; cin >> n; long long k; vector<long long> ans; if (n > 3) { if (n % 2 == 1) k = n - 1; else k = n; while (k > 0) { if (k == 4) ans.push_back(2); if (k == 2) ans.push_back(4); if (k != 4 && k != 2) ans.push_back(k); k -= 2; } k = 1; while (k <= n) { ans.push_back(k); k += 2; } for (auto u : ans) cout << u << ; cout << endl; } else { cout << -1 << endl; } } return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { ios::sync_with_stdio(false); int n, r; cin >> n >> r; double alpha = 90.0 - 180.0 / n; double val = cos(alpha * 3.14159265 / 180.0); double ans = val * (double)r / (1 - val); cout << fixed << setprecision(6) << ans << endl; return 0; } |
#include <bits/stdc++.h> int d[3000], g[3000], q[3000]; int i, j, k, m, n, r, t; int main() { scanf( %d%d , &n, &m); for (i = 1; i <= n; i++) { scanf( %d , &g[i]); if (g[i] <= m) d[g[i]]++; else r++; } for (k = 0;; k++) { t = 1; for (i = 2; i <= m; i++) if (d[i] < d[t]) t = i; if (d[t] == n / m) break; d[t]++; if (r) r--; else { t = 1; for (i = 2; i <= m; i++) if (d[i] > d[t]) t = i; d[t]--; } } printf( %d %d n , n / m, k); for (i = 1; i <= n; i++) if ((g[i] <= m) && (d[g[i]])) { q[i] = g[i]; d[g[i]]--; } else if ((g[i] > m) && (r)) { q[i] = g[i]; r--; } for (i = 1; i <= n; i++) if (q[i]) printf( %d , q[i]); else for (j = 1; j <= m; j++) if (d[j]) { printf( %d , j); d[j]--; break; } return 0; } |
#include <bits/stdc++.h> using namespace std; const int MAXN = 100009; int acc[MAXN], sav[MAXN]; int extr(string &s) { int num = 0; for (int i = 1; i < s.length(); i++) { num *= 10; num += (s[i] - 0 ); } return num; } int main() { int n, m; scanf( %d , &n); scanf( %d , &m); int pl = 0, mn = 0; vector<string> statements; for (int i = 0; i < n; i++) { string s; cin >> s; statements.push_back(s); int z = extr(s); if (s[0] == + ) acc[z]++, pl++; else sav[z]++, mn++; } set<int> Suspects; for (int i = 1; i < n + 1; i++) { int tr = acc[i] + mn - sav[i]; if (tr == m) { Suspects.insert(i); } } for (int i = 0; i < n; i++) { string s = statements[i]; int z = extr(s); if (s[0] == + ) { if (Suspects.find(z) == Suspects.end()) { cout << Lie << n ; continue; } if (Suspects.size() == 1) { cout << Truth << n ; } else { cout << Not defined << n ; } } else { if (Suspects.size() == 1 && Suspects.find(z) != Suspects.end()) { cout << Lie << n ; continue; } if (Suspects.find(z) == Suspects.end()) { cout << Truth << n ; continue; } else cout << Not defined << n ; } } return 0; } |
#include <bits/stdc++.h> using namespace std; const int maxN = 1e6 + 1e5 + 5; struct Node { int len, pa; int trans[26]; } st[maxN + 1]; int n, m, last, cnt; int L[11], R[11]; int sum[11][maxN + 1]; char s[maxN + 1]; vector<int> son[maxN + 1]; inline int insert(int c) { if (st[last].trans[c] && st[st[last].trans[c]].len == st[last].len + 1) return st[last].trans[c]; int np = ++cnt, p = last, f = np; st[np].len = st[p].len + 1; while (p && !st[p].trans[c]) st[p].trans[c] = np, p = st[p].pa; if (!p) st[np].pa = 1; else { int q = st[p].trans[c]; if (st[q].len == st[p].len + 1) st[np].pa = q; else { int nq = ++cnt; if (p == last) f = nq; st[nq] = st[q]; st[nq].len = st[p].len + 1; st[np].pa = st[q].pa = nq; while (p && st[p].trans[c] == q) st[p].trans[c] = nq, p = st[p].pa; } } return f; } inline void calc(int u) { for (int i = 0; i < son[u].size(); i++) { int v = son[u][i]; calc(v); for (int j = 0; j <= m; j++) sum[j][u] += sum[j][v]; } } int main() { scanf( %s , s + 1); n = strlen(s + 1); last = cnt = 1; for (int i = 1; i <= n; i++) last = insert(s[i] - a ), sum[0][last]++; scanf( %d , &m); for (int i = 1; i <= m; i++) { scanf( %s %d %d , s + 1, &L[i], &R[i]); int len = strlen(s + 1); last = 1; for (int j = 1; j <= len; j++) last = insert(s[j] - a ), sum[i][last]++; } for (int i = 1; i <= cnt; i++) son[st[i].pa].push_back(i); calc(1); long long ans = 0; for (int i = 2; i <= cnt; i++) { if (!sum[0][i]) continue; bool flag = true; for (int j = 1; j <= m; j++) if (sum[j][i] < L[j] || sum[j][i] > R[j]) { flag = false; break; } if (flag) ans += st[i].len - st[st[i].pa].len; } printf( %lld , ans); return 0; } |
#include <bits/stdc++.h> using namespace std; const long long linf = 4000000000000000000LL; const long long inf = 1000000007; void pv(vector<int> a) { for (auto& x : a) cout << x << ; cout << endl; } void pv(vector<long long> a) { for (auto& x : a) cout << x << ; cout << endl; } void pv(vector<vector<int>> a) { for (int i = (0); i < (int(a.size())); ++i) { cout << i << endl; pv(a[i]); cout << endl; } } void pv(vector<vector<long long>> a) { for (int i = (0); i < (int(a.size())); ++i) { cout << i << endl; pv(a[i]); } cout << endl; } void pv(vector<string> a) { for (auto& x : a) cout << x << endl; cout << endl; } void setIO(string second) { ios_base::sync_with_stdio(0); cin.tie(0); } int n, k; vector<pair<long long, long long>> a; void init() { vector<pair<long long, long long>> t; for (auto& x : a) if (x.first == 0 && x.second == 0) k--, n--; else t.push_back(x); a = t; } bool check(long double r) { long double pi = acos(-1); vector<pair<long double, int>> ranges; for (int i = (0); i < (n); ++i) { long double d = sqrt(a[i].first * a[i].first + a[i].second * a[i].second); if (d > 2 * r) continue; long double theta = acos(d / (2 * r)); long double theta1 = atan((long double)a[i].second / a[i].first); if (theta1 < 0 || (theta1 == 0 && a[i].first < 0)) theta1 += pi; if (a[i].second < 0) theta1 += pi; long double x = theta1 - theta, y = theta1 + theta; if (x < 0 && y >= 0) { ranges.push_back({x + 2 * pi, 1}); ranges.push_back({2 * pi, -1}); ranges.push_back({0, 1}); ranges.push_back({y, -1}); } else if (x < 2 * pi && y >= 2 * pi) { ranges.push_back({x, 1}); ranges.push_back({2 * pi, -1}); ranges.push_back({0, 1}); ranges.push_back({y - 2 * pi, -1}); } else { ranges.push_back({x, 1}); ranges.push_back({y, -1}); } } sort(ranges.begin(), ranges.end(), [](pair<long double, int> x, pair<long double, int> y) { if (x.first == y.first) return x.second > y.second; return x.first < y.first; }); int m = 0; int cur = 0; for (auto& x : ranges) { cur += x.second; m = max(m, cur); } return m >= k; } int main() { setIO( test1 ); cin >> n >> k; a.resize(n); for (auto& x : a) cin >> x.first >> x.second; init(); long double l = 0, r = 222222; for (int i = (0); i < (31); ++i) { long double m = (l + r) / 2; if (check(m)) r = m; else l = m; } cout << setprecision(20) << l << endl; } |
#include <bits/stdc++.h> #pragma GCC optimize( Ofast ) using namespace std; mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count()); const long long G = 300005, BASE = 666667, M1 = 2e9 + 11, M2 = 1e9 + 9; long long IB1, IB2; long long a, o; long long m[G], pwb1[G], pwb2[G]; long long binpow(long long x, long long k, long long mod) { long long res = 1; for (; k; k >>= 1) { if (k & 1) res = res * x % mod; x = x * x % mod; } return res; } long long modInv(long long x, long long mod) { return binpow(x, mod - 2, mod); } void rec(long long l, long long r) { long long d = r - l + 1; if (d < 2) return; long long md = (l + r) / 2; vector<pair<long long, long long> > hl, hr; vector<long long> stq; for (long long q = md, hs1 = 0, hs2 = 0; q >= l; q--) { if (stq.size() && stq.back() == m[q]) { hs1 = (hs1 - m[q] + M1) % M1; hs1 = hs1 * IB1 % M1; hs2 = (hs2 - m[q] + M2) % M2; hs2 = hs2 * IB2 % M2; stq.pop_back(); } else { stq.push_back(m[q]); hs1 = (hs1 * BASE + m[q]) % M1; hs2 = (hs2 * BASE + m[q]) % M2; } hl.push_back({hs1, hs2}); } stq.clear(); for (long long q = md + 1, hs1 = 0, hs2 = 0; q <= r; q++) { if (stq.size() && stq.back() == m[q]) { hs1 = (hs1 - m[q] + M1) % M1; hs1 = hs1 * IB1 % M1; hs2 = (hs2 - m[q] + M2) % M2; hs2 = hs2 * IB2 % M2; stq.pop_back(); } else { stq.push_back(m[q]); hs1 = (hs1 * BASE + m[q]) % M1; hs2 = (hs2 * BASE + m[q]) % M2; } hr.push_back({hs1, hs2}); } sort(hl.begin(), hl.end()); sort(hr.begin(), hr.end()); for (pair<long long, long long> i : hl) { o += upper_bound(hr.begin(), hr.end(), i) - lower_bound(hr.begin(), hr.end(), i); } rec(l, md); rec(md + 1, r); } long long solve() { cin >> a; for (int q = 0; q < a; q++) cin >> m[q]; o = 0; rec(0, a - 1); return o; } int main() { cin.tie(0); cout.tie(0); cin.sync_with_stdio(0); cout.sync_with_stdio(0); ; IB1 = modInv(BASE, M1); IB2 = modInv(BASE, M2); pwb1[0] = 1; pwb2[0] = 1; for (int q = 1; q < G; q++) pwb1[q] = pwb1[q - 1] * BASE % M1; for (int q = 1; q < G; q++) pwb2[q] = pwb2[q - 1] * BASE % M2; int z; cin >> z; for (; z--;) { cout << solve() << n ; } } |
#include <bits/stdc++.h> using namespace std; long long unorder(int n) { if (n == 0) return 1; if (n == 1) return 0; bool good; long long ans = 0; vector<int> V(n); for (int i = 0; i < n; i++) V[i] = i; do { good = true; for (int i = 0; i < n && good; i++) good = (V[i] != i); if (good) ans++; } while (next_permutation(V.begin(), V.end())); return ans; } long long newton(int n, int k) { if (k > n) return 0; if (2 * k > n) k = n - k; long long ans = 1; for (int i = n - k + 1; i <= n; i++) ans *= i; for (int i = 1; i <= k; i++) ans /= i; return ans; } int main() { int n, k; long long ans = 0; cin >> n >> k; for (int i = 0; i <= k; i++) { long long unorders = unorder(i), combinations = newton(n, n - i); ans += combinations * unorders; } cout << ans << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; int dist[100010], n; vector<pair<int, int> > gr[100010]; void dfs() { memset(dist, -1, sizeof(dist)); dist[1] = 0; queue<int> q; q.push(1); while (!q.empty()) { int u = q.front(); q.pop(); for (int i = 0; i < gr[u].size(); i++) { int next = gr[u][i].first; if (dist[next] == -1) { dist[next] = dist[u] + 1; q.push(next); } } } } vector<pair<int, pair<int, int> > > ans; int v_ans = 0; int dp[100010]; map<pair<int, int>, int> mark; int calc_dp(int u) { if (dp[u] != -1) return dp[u]; if (u == 1) return dp[u] = 0; for (int i = 0; i < gr[u].size(); i++) { int next = gr[u][i].first; if (dist[next] == dist[u] - 1) dp[u] = max(dp[u], calc_dp(next) + gr[u][i].second); } return dp[u]; } void calc_ans(int u) { if (u == 1) { return; } for (int i = 0; i < gr[u].size(); i++) { int next = gr[u][i].first; if (dist[next] == dist[u] - 1 && dp[next] == dp[u] - gr[u][i].second) { calc_ans(next); mark[{min(next, u), max(next, u)}] = 1; break; } } } int main() { ios::sync_with_stdio(false); memset(dp, -1, sizeof(dp)); int m; cin >> n >> m; int cont = 0; vector<pair<int, pair<int, int> > > edges; for (int i = 0; i < m; i++) { int a, b, z; cin >> a >> b >> z; cont += z; gr[a].push_back({b, z}); gr[b].push_back({a, z}); edges.push_back({z, {min(a, b), max(a, b)}}); } dfs(); int v = calc_dp(n); cout << (cont - v) + (dist[n] - v) << endl; calc_ans(n); for (int i = 0; i < m; i++) { if (edges[i].first == 1 && !mark[edges[i].second]) cout << edges[i].second.first << << edges[i].second.second << 0 n ; if (edges[i].first == 0 && mark[edges[i].second]) cout << edges[i].second.first << << edges[i].second.second << 1 n ; } return 0; } |
#include <bits/stdc++.h> using namespace std; int n, a, b; vector<pair<int, int> > x[255][4005]; int main() { scanf( %d n , &n); for (int i = 0; i < n; i++) { scanf( %d %d n , &a, &b); x[a / 4000][b / 250].push_back(make_pair(a, i + 1)); } for (int i = 0; i < 252; i++) { for (int j = 0; j < 4002; j++) if (!x[i][j].empty()) { sort(x[i][j].begin(), x[i][j].end()); for (size_t k = 0; k < x[i][j].size(); k++) printf( %d , x[i][j][k].second); } i++; for (int j = 4001; j >= 0; j--) if (!x[i][j].empty()) { sort(x[i][j].begin(), x[i][j].end()); for (size_t k = 0; k < x[i][j].size(); k++) printf( %d , x[i][j][k].second); } } return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int k; cin >> k; vector<vector<int> > v = {{1}}; for (int i = 0; i < k; i++) { int current = v.size(); for (int j = 0; j < current; j++) { vector<int> vnew(2 * current); for (int l = 0; l < current; l++) { vnew[l] = v[j][l]; vnew[current + l] = v[j][l]; v[j].push_back(-v[j][l]); } v.push_back(vnew); } } for (int i = 0; i < v.size(); i++) { for (int j = 0; j < v[i].size(); j++) { cout << ((v[i][j] == 1) ? + : * ); } cout << endl; } } |
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; cout << --n / 2 << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; namespace IO { template <typename t> inline void read(t& x) { x = 0; bool f = 1; char ch; for (ch = getchar(); ch < 0 || 9 < ch; ch = getchar()) if (ch == - ) f ^= 1; for (; 0 <= ch && ch <= 9 ; ch = getchar()) x = (x << 3) + (x << 1) + (ch ^ 48); x = f ? x : -x; } } // namespace IO const int MAXN = 50 + 10; const int CHAR_RANGE = 26 + 10; int n, len[2], f[MAXN][MAXN]; bool can[2][MAXN][MAXN][CHAR_RANGE]; char str[2][MAXN], tmp[10]; vector<int> trans[CHAR_RANGE], rtrans[CHAR_RANGE * CHAR_RANGE + 100]; void calc(int _) { for (int i = (1), iend = (len[_]); i <= iend; ++i) can[_][i][i][str[_][i] - a ] = true; for (int l = (2), lend = (len[_]); l <= lend; ++l) { for (int i = (1), iend = (len[_] - l + 1); i <= iend; ++i) { int j = i + l - 1; for (int k = (i), kend = (j - 1); k <= kend; ++k) for (int ch1 = (0), ch1end = (25); ch1 <= ch1end; ++ch1) if (can[_][i][k][ch1]) for (int ch2 = (0), ch2end = (25); ch2 <= ch2end; ++ch2) { if (can[_][k + 1][j][ch2]) { for (int x : rtrans[26 * ch1 + ch2]) can[_][i][j][x] = true; } } } } } int main() { scanf( %s , str[0] + 1), scanf( %s , str[1] + 1); len[0] = strlen(str[0] + 1), len[1] = strlen(str[1] + 1); IO::read(n); for (int i = (1), iend = (n); i <= iend; ++i) { scanf( %s , tmp + 1); rtrans[26 * (tmp[4] - a ) + tmp[5] - a ].push_back(tmp[1] - a ); } memset(f, -1, sizeof f); f[0][0] = 0; calc(0), calc(1); for (int i = (1), iend = (len[0]); i <= iend; ++i) for (int j = (1), jend = (len[1]); j <= jend; ++j) { f[i][j] = 1e9; for (int i2 = (0), i2end = (i - 1); i2 <= i2end; ++i2) for (int j2 = (0), j2end = (j - 1); j2 <= j2end; ++j2) if (f[i2][j2] != -1) for (int ch1 = (0), ch1end = (25); ch1 <= ch1end; ++ch1) { if (can[0][i2 + 1][i][ch1] && can[1][j2 + 1][j][ch1]) { f[i][j] = min(f[i2][j2] + 1, f[i][j]); } } if (f[i][j] == 1e9) f[i][j] = -1; } printf( %d n , f[len[0]][len[1]]); return 0; } |
#include <bits/stdc++.h> using namespace std; int main(int argc, char **argv) { int n, h; cin >> n >> h; bool flag; for (int k = 0; k < n; k++) { flag = false; for (int j = 0; j < n; j++) { if (flag) cout << ; flag = true; if (j == k) cout << h; else cout << 0 ; } cout << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int n, p, q, ans = 0; cin >> n; for (int i = 0; i < n; i++) { cin >> p; cin >> q; if (q - p >= 2) ans++; } cout << ans << endl; } |
#include <bits/stdc++.h> using namespace std; struct vals { bool vd; char val[1010]; bool cur; int idx[2]; string nome, op; } s[5020]; bool valdef(bool k, int vv, int curidx) { if (s[curidx].idx[vv] == -1) return k; return s[s[curidx].idx[vv]].cur; } bool value(string op, bool k, int curidx) { if (op == XOR ) { return valdef(k, 0, curidx) ^ valdef(k, 1, curidx); } else if (op == OR ) { return valdef(k, 0, curidx) | valdef(k, 1, curidx); } else if (op == AND ) { return valdef(k, 0, curidx) & valdef(k, 1, curidx); } } int main() { int n, m; char c; char aux1[12], aux2[1010], aux3[5], aux4[12]; map<string, int> mpi; cin >> n >> m; for (int i = 0; i < (n); ++i) { scanf( %s := %s%c , aux1, aux2, &c); mpi[string(aux1)] = i; if (c == ) { scanf( %s %s , aux3, aux4); if (string(aux2) != ? ) s[i].idx[0] = mpi[string(aux2)]; else s[i].idx[0] = -1; s[i].op = string(aux3); if (string(aux4) != ? ) s[i].idx[1] = mpi[string(aux4)]; else s[i].idx[1] = -1; s[i].vd = false; } else if (c == n or c == r ) { strcpy(s[i].val, aux2); s[i].vd = true; } else cout << erro << endl; } string sauxmax = ; string sauxmin = ; for (int i = 0; i < (m); ++i) { vector<int> vsoma(2, 0); for (int k = 0; k < (2); ++k) { for (int j = 0; j < (n); ++j) { bool baux; if (s[j].vd) { baux = s[j].val[i] - 0 ; s[j].cur = baux; } else { baux = value(s[j].op, k, j); s[j].cur = baux; } vsoma[k] += baux; } } if (vsoma[1] > vsoma[0]) sauxmax += 1 , sauxmin += 0 ; else if (vsoma[1] == vsoma[0]) sauxmax += 0 , sauxmin += 0 ; else if (vsoma[1] < vsoma[0]) sauxmax += 0 , sauxmin += 1 ; } cout << sauxmin << endl << sauxmax << endl; } |
#include <bits/stdc++.h> using namespace std; string A[8]; int dx[9] = {-1, -1, -1, 0, 1, 1, 1, 0, 0}; int dy[9] = {-1, 0, 1, 1, 1, 0, -1, -1, 0}; bool dfs(int x, int y, int tour) { if (x == 0 && y == 7) return 1; if (tour > 8) return true; for (int k = 0; k <= 8; k++) { int nx = x + dx[k], ny = y + dy[k]; if (nx < 0 || ny < 0 || nx > 7 || ny > 7) continue; if (nx - tour >= 0 && A[nx - tour][ny] == S ) continue; if (nx - tour - 1 >= 0 && A[nx - tour - 1][ny] == S ) continue; if (dfs(nx, ny, tour + 1)) return 1; } return 0; } int main() { vector<pair<int, int> > S; for (int i = 0; i < 8; i++) { cin >> A[i]; } if (dfs(7, 0, 0)) cout << WIN << endl; else cout << LOSE << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; void io() { freopen( input.txt , r , stdin); freopen( output.txt , w , stdout); } const int N = 2e5 + 9; const long long MOD = 1e9 + 7; const int INF = 1e9; int dx[5] = {0, -1, 1, 0, 0}; int dy[5] = {0, 0, 0, -1, 1}; char dc[5] = { 0 , U , D , L , R }; int main() { int test; test = 1; while (test--) { int x, y; cin >> x >> y; int ans = 0; while (x > 0 && y > 0) { if (x > y) swap(x, y); if (x < 100) x++; y -= 2; if (y < 0) break; ans++; } cout << ans; } return 0; } |
#include <bits/stdc++.h> using namespace std; const int N = 1e5 + 5; int n, m, d[N], a[N]; bool flag[N]; bool check(int x) { memset(flag, 0, sizeof(flag)); int cur = x - 1; for (int i = x; i >= 1; i--) { cur = min(cur, i - 1); if (d[i] && !flag[d[i]] && a[d[i]] <= cur) { flag[d[i]] = 1; cur -= a[d[i]] + 1; } } for (int i = 1; i <= m; i++) { if (!flag[i]) return 0; } return 1; } int main() { int ans = -1; scanf( %d %d , &n, &m); for (int i = 1; i <= n; i++) scanf( %d , d + i); for (int i = 1; i <= m; i++) scanf( %d , a + i); int l = 1, r = n, mid; while (l <= r) { mid = (l + r) >> 1; if (check(mid)) r = mid - 1, ans = mid; else l = mid + 1; } printf( %d n , ans); } |
#include <bits/stdc++.h> using namespace std; template <typename T, size_t N> struct ma : array<T, N> { T &operator[](size_t n) { return (*static_cast<array<T, N> *>(this))[n]; } }; template <class T> string to_str(const T &a) { ostringstream os; os << a; return os.str(); } template <> string to_str<long double>(const long double &a) { ostringstream os; os.precision(10); os.setf(ios::fixed); os << a; return os.str(); } template <class T> T from_str(const string &s) { istringstream is; T val; is >> val; return val; } int cond = (long long)0; void solve() { int n, m; scanf( %d%d , &n, &m); vector<int> co(n); for (auto i = (0); i < (n); ++i) scanf( %d , &co[i]); long long ret = 0; for (auto i = (0); i < (m); ++i) { int a, b; scanf( %d%d , &a, &b); a--; b--; ret += min(co[a], co[b]); } cout << ret << endl; } void brute() {} void gen(int i, int n, int k) {} int main(int argc, char **argv) { ios::sync_with_stdio(false); vector<string> args; int nr_test = -1; int t = 1; for (auto i = (1); i <= (argc - 1); ++i) args.push_back(argv[i]); for (auto &it : (args)) if (it == q ) cond = 10000000; for (auto &it : (args)) if (it == all ) t = 1000; for (auto &it : (args)) if (atoi(it.c_str()) > 0) nr_test = atoi(it.c_str()); for (auto &it : (args)) if (it == b ) { brute(); return 0; } for (auto &it : (args)) if (it == g && args.size() >= 4) { gen(atoi(args[1].c_str()), atoi(args[2].c_str()), atoi(args[3].c_str())); return 0; } for (auto i = (1); i <= (t); ++i) { if (nr_test == -1 || i <= nr_test) solve(); } return 0; } |
#include <bits/stdc++.h> using namespace std; int dx8[8] = {-1, -1, 0, 1, 1, 1, 0, -1}, dx4[4] = {-1, 0, 1, 0}; int dy8[8] = {0, -1, -1, -1, 0, 1, 1, 1}, dy4[4] = {0, -1, 0, 1}; inline void open(string name) { freopen((name + .in ).c_str(), r , stdin); freopen((name + .out ).c_str(), w , stdout); } inline void close() { fclose(stdin); fclose(stdout); } inline int io() { register char c; while (1) { c = getchar_unlocked(); if (c != n && c != ) break; } int res = 0, sign = 1; if (c == - ) sign = -1; else res = c - 0 ; while (1) { c = getchar_unlocked(); if (c == || c == n || c == EOF) break; res = (res << 3) + (res << 1) + c - 0 ; } return res * sign; } const int N = 100005; struct Bullet { int x; int y; int idx; Bullet() {} bool operator<(Bullet other) const { if (x == other.x) { if (y == other.y) return idx < other.idx; else return y < other.y; } else return x < other.x; } }; Bullet origin[N], arr[N]; struct Node { vector<pair<int, int> > bullet_list; vector<int> RMQ; Node() { bullet_list.clear(); RMQ.clear(); } void Build() { RMQ.resize(4 * bullet_list.size()); Build(1, 0, bullet_list.size() - 1); } void Build(int id, int l, int r) { if (l == r) RMQ[id] = bullet_list[l].second; else { int chld = id << 1, m = (l + r) >> 1; Build(chld, l, m); Build(chld + 1, m + 1, r); RMQ[id] = min(RMQ[chld], RMQ[chld + 1]); } } int Query(int ya, int yb) { int st = lower_bound(bullet_list.begin(), bullet_list.end(), make_pair(ya, 0)) - bullet_list.begin(); int en = upper_bound(bullet_list.begin(), bullet_list.end(), make_pair(yb, 1000000000)) - bullet_list.begin(); en--; if (st > en) return 1000000000; else return Query(1, 0, bullet_list.size() - 1, st, en); } int Query(int id, int l, int r, int x, int y) { if (x <= l && r <= y) return RMQ[id]; else { int chld = (id << 1), m = (l + r) >> 1; int res = 1000000000; if (x <= m) res = min(res, Query(chld, l, m, x, y)); if (y > m) res = min(res, Query(chld + 1, m + 1, r, x, y)); return res; } } void Del(int id) { int ya = origin[id].y; int st = lower_bound(bullet_list.begin(), bullet_list.end(), make_pair(ya, id)) - bullet_list.begin(); Del(1, 0, bullet_list.size() - 1, st); } void Del(int id, int l, int r, int x) { if (l == r) { RMQ[id] = 1000000000; } else { int chld = id << 1, m = (l + r) >> 1; if (x <= m) Del(chld, l, m, x); else Del(chld + 1, m + 1, r, x); RMQ[id] = min(RMQ[chld], RMQ[chld + 1]); } } }; Node rtree[4 * N]; vector<int> X; int n, q; int ans[N]; void BuildRangeTree(int id, int l, int r) { if (l == r) { rtree[id].bullet_list.push_back(make_pair(arr[l].y, arr[l].idx)); } else { int chld = id << 1, m = (l + r) >> 1; BuildRangeTree(chld, l, m); BuildRangeTree(chld + 1, m + 1, r); int i = 0, j = 0; while (i < rtree[chld].bullet_list.size() && j < rtree[chld + 1].bullet_list.size()) { if (rtree[chld].bullet_list[i] < rtree[chld + 1].bullet_list[j]) rtree[id].bullet_list.push_back(rtree[chld].bullet_list[i++]); else rtree[id].bullet_list.push_back(rtree[chld + 1].bullet_list[j++]); } while (i < rtree[chld].bullet_list.size()) rtree[id].bullet_list.push_back(rtree[chld].bullet_list[i++]); while (j < rtree[chld + 1].bullet_list.size()) rtree[id].bullet_list.push_back(rtree[chld + 1].bullet_list[j++]); } rtree[id].Build(); } void UpdateRangeTree(int pos) { int idpos = lower_bound(arr, arr + q, origin[pos]) - arr; int id = 1, l = 0, r = q - 1; while (1) { rtree[id].Del(pos); if (l == r) break; int chld = id << 1, m = (l + r) >> 1; if (idpos <= m) r = m, id = chld; else l = m + 1, id = chld + 1; } } int QueryRangeTree(int id, int l, int r, int x, int y, int ya, int yb) { int res = 1000000000; if (x <= l && r <= y) res = rtree[id].Query(ya, yb); else { int chld = (id << 1), m = (l + r) >> 1; res = 1000000000; if (x <= m) res = min(res, QueryRangeTree(chld, l, m, x, y, ya, yb)); if (y > m) res = min(res, QueryRangeTree(chld + 1, m + 1, r, x, y, ya, yb)); } return res; } struct Target { int xa; int ya; int xb; int yb; int z; int idx; Target() {} bool operator<(Target other) const { if (z == other.z) return idx < other.idx; return z < other.z; } }; Target arr2[N]; int main() { scanf( %d , &n); for (int i = 0; i < n; i++) { scanf( %d %d %d %d %d , &arr2[i].xa, &arr2[i].xb, &arr2[i].ya, &arr2[i].yb, &arr2[i].z); arr2[i].idx = i; } sort(arr2, arr2 + n); scanf( %d , &q); for (int i = 0; i < q; i++) { scanf( %d %d , &origin[i].x, &origin[i].y); origin[i].idx = i; X.push_back(origin[i].x); arr[i] = origin[i]; } sort(arr, arr + q); sort(X.begin(), X.end()); BuildRangeTree(1, 0, q - 1); memset(ans, -1, sizeof ans); for (int i = 0; i < n; i++) { int x1 = lower_bound(X.begin(), X.end(), arr2[i].xa) - X.begin(); int x2 = upper_bound(X.begin(), X.end(), arr2[i].xb) - X.begin(); x2--; if (x1 <= x2) { int res = QueryRangeTree(1, 0, q - 1, x1, x2, arr2[i].ya, arr2[i].yb); if (res != 1000000000) { ans[res] = arr2[i].idx; UpdateRangeTree(res); } } } for (int i = 0; i < q; i++) printf( %d n , ans[i] + 1); return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { string str; char tmp = z ; cin >> str; for (int i = 0; i < str.length(); i++) { if (str[i] <= tmp) { tmp = str[i]; cout << Mike << endl; } else { cout << Ann << endl; } } return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); long long int n, m, a, b; cin >> n >> m >> a >> b; long long int res, ans; res = n / m; if (n % m) res++; res = (res * m - n) * a; ans = (n % m) * b; cout << min(res, ans) << n ; return 0; } |
#include <bits/stdc++.h> using namespace std; long long mod = 1e9 + 7; long long min(long long a, long long b) { return (a < b) ? a : b; } long long max(long long a, long long b) { return (a > b) ? a : b; } long long fp(long long a, long long b) { if (b == 0) return 1; long long x = fp(a, b / 2); x = (x * x) % mod; if (b & 1) x = (x * a) % mod; return x; } const long long N = 2e5 + 5; long long a[N]; long long n; signed main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); cin >> n; long long cnt[60] = {0}; for (long long i = 1; i <= n; i++) { cin >> a[i]; for (long long b = 0; b < 20; b++) { if ((a[i] >> b) & 1) { cnt[b]++; } } } long long ans = 0; for (long long i = 1; i <= n; i++) { long long x = 0; for (long long b = 0; b < 20; b++) { if (cnt[b]) { cnt[b]--; x |= (1ll << b); } } ans += x * x; } cout << ans; } |
#include <bits/stdc++.h> using namespace std; int n, m, x; vector<pair<int, int> > leti[26]; vector<pair<int, int> > shift; vector<int> dis[26]; int main() { cin >> n >> m >> x; int d = x * x; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { char t; cin >> t; if (t == S ) shift.push_back(pair<int, int>(i, j)); else leti[t - a ].push_back(pair<int, int>(i, j)); } } for (int i = 0; i < 26; i++) { for (int j = 0; j < leti[i].size(); j++) { int mn = 0x7fffffff; for (int k = 0; k < shift.size(); k++) { int dx = shift[k].first - leti[i][j].first; int dy = shift[k].second - leti[i][j].second; mn = min(mn, dx * dx + dy * dy); } dis[i].push_back(mn); } } int q; cin >> q; int cnt = 0; for (int i = 0; i < q; i++) { char t; cin >> t; if (((t - a ) >= 0) && leti[t - a ].empty()) { cout << -1 << endl; return 0; } if (((t - a ) < 0) && leti[t - A ].empty()) { cout << -1 << endl; return 0; } if (((t - a ) < 0) && shift.empty()) { cout << -1 << endl; return 0; } if ((t - a ) < 0) { int flag = true; for (int j = 0; j < leti[t - A ].size(); j++) { if (dis[t - A ][j] <= d) { flag = false; break; } } if (flag) cnt++; else flag = true; } } cout << cnt << endl; } |
#include <bits/stdc++.h> using namespace std; const long long int Maxn3 = 1e3 + 10; const long long int Maxn4 = 1e4 + 10; const long long int Maxn5 = 1e5 + 10; const long long int Maxn6 = 1e6 + 10; const long long int Maxn7 = 1e7 + 10; const long long int Maxn8 = 1e8 + 10; const long long int Maxn9 = 1e9 + 10; const long long int Maxn18 = 1e18 + 10; const long long int Mod1 = 1e7 + 7; const long long int Mod2 = 1e9 + 7; const long long int LLMax = LLONG_MAX; const long long int LLMin = LLONG_MIN; const long long int INTMax = INT_MAX; const long long int INTMin = INT_MIN; long long int mn = LLMax, mx = LLMin; bool prime(int x) { for (int i = 2; i * i <= x; i++) if (x % i == 0) return 0; return 1; } int main() { ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL); int n; cin >> n; if (prime(n) == 1) return cout << 1 n << n, 0; else { cout << 3 n3 ; n -= 3; for (int i = 3; i < n; i += 2) if (prime(n - i) and prime(i)) return cout << i << << n - i, 0; } return 0; } |
#include <bits/stdc++.h> #pragma warning(disable : 4996) FILE *in = stdin, *out = stdout; using namespace std; #pragma comment(linker, /stack:36777216 ) int n; char a[300005]; int D[300005]; void input() { fscanf(in, %d , &n); fscanf(in, %s , &a[1]); } bool isSame(int x) { if (x & 1) return false; for (int i = (1); i <= (x / 2); i++) { if (a[i] != a[i + x / 2]) return false; } return true; } void pro() { int ans = n; for (int i = (1); i <= (n); i++) { if (isSame(i)) ans = min(ans, i / 2 + 1 + (n - i)); } fprintf(out, %d , ans); } int main() { input(); pro(); return 0; } |
#include <bits/stdc++.h> using namespace std; int n, m; int main() { cin >> n >> m; if (m / n == 2) cout << n - m % n; else if (m / n == 1) cout << m % n; else cout << 0; return 0; } |
#include <bits/stdc++.h> using namespace std; const int N = 110, M = 10010; int n; long double x; int c[N], all; long double binom[N][N]; long double f[N][M]; int main() { cin >> n >> x; for (int i = 1; i <= n; i++) scanf( %d , &c[i]), all += c[i]; f[0][0] = 1; for (int i = 0; i <= n; i++) { binom[i][0] = binom[i][i] = 1; for (int j = 1; j < i; j++) binom[i][j] = binom[i - 1][j] + binom[i - 1][j - 1]; } f[0][0] = 1; for (int id = 1; id <= n; id++) { for (int i = id; i; i--) { for (int j = all; j >= c[id]; j--) { f[i][j] += f[i - 1][j - c[id]]; } } } long double ans = 0; for (int i = 1; i <= n; i++) { for (int j = 1; j <= all; j++) { long double v = f[i][j]; v /= binom[n][i]; v *= min(x / 2 + x / 2 * n / i, (long double)j / (long double)i); ans += v; } } printf( %.15Lf n , ans); } |
#include <bits/stdc++.h> using namespace std; long long k, l, g = 0, h = 0; int a, b, p[3][3], q[3][3], t, u, v, c; vector<pair<int, int> > s; bool con; int gg(int a, int b) { if (a == b + 1 || a == b - 2) return 1; return 0; } void sim(int x, int t, int u) { while (x > 0) { g += gg(t, u); h += gg(u, t); v = t; t = p[t][u]; u = q[v][u]; x--; } } int main() { ios_base::sync_with_stdio(false); cin >> k >> a >> b; a--, b--; for (int i = 0; i < (3); i++) for (int j = 0; j < (3); j++) cin >> p[i][j]; for (int i = 0; i < (3); i++) for (int j = 0; j < (3); j++) cin >> q[i][j]; for (int i = 0; i < (3); i++) for (int j = 0; j < (3); j++) q[i][j]--, p[i][j]--; s.push_back({a, b}); t = p[a][b], u = q[a][b]; while (true) { con = false; for (int i = 0; i < (s.size()); i++) { if (s[i].first == t && s[i].second == u) con = true; } if (con) break; else { s.push_back({t, u}); v = t; t = p[t][u]; u = q[v][u]; } con = false; } for (int i = 0; i < (s.size()); i++) { if (s[i].first == t && s[i].second == u) c = s.size() - i; } if (k < 10000) { sim(k, a, b); } else { l = (k - s.size() + c) / c; sim(c, t, u); g *= l; h *= l; sim(s.size() - c, a, b); sim((k - s.size() + c) % c, t, u); } cout << g << << h << endl; } |
#include <bits/stdc++.h> using namespace std; const int N = 1e3 + 3; const int inf = 1e8; int n, m; char str[N][N]; int sx, sy; int tx, ty; struct data { int up; int down; int rgt; int lft; data() { up = 0; down = 0; rgt = 0; lft = 0; } void rotate() { int _up = lft; int _rgt = up; int _down = rgt; int _lft = down; up = _up; rgt = _rgt; down = _down; lft = _lft; } }; data mat[N][N]; queue<int> qx; queue<int> qy; queue<int> qr; int dist[N][N][4]; inline void relax(int nx, int ny, int nr, int ndist) { if (dist[nx][ny][nr] > ndist) { dist[nx][ny][nr] = ndist; qx.push(nx); qy.push(ny); qr.push(nr); } } int main() { scanf( %d %d , &n, &m); for (int i = 1; i <= n; ++i) { scanf( %s , str[i] + 1); } for (int i = 0; i <= m + 1; ++i) { str[0][i] = * ; str[n + 1][i] = * ; } for (int i = 0; i <= n + 1; ++i) { str[i][0] = * ; str[i][m + 1] = * ; } for (int i = 1; i <= n; ++i) { for (int j = 1; j <= m; ++j) { if (str[i][j] == + ) { mat[i][j].up = 1; mat[i][j].lft = 1; mat[i][j].rgt = 1; mat[i][j].down = 1; } if (str[i][j] == - ) { mat[i][j].up = 0; mat[i][j].lft = 1; mat[i][j].rgt = 1; mat[i][j].down = 0; } if (str[i][j] == | ) { mat[i][j].up = 1; mat[i][j].lft = 0; mat[i][j].rgt = 0; mat[i][j].down = 1; } if (str[i][j] == ^ ) { mat[i][j].up = 1; mat[i][j].lft = 0; mat[i][j].rgt = 0; mat[i][j].down = 0; } if (str[i][j] == > ) { mat[i][j].up = 0; mat[i][j].lft = 0; mat[i][j].rgt = 1; mat[i][j].down = 0; } if (str[i][j] == < ) { mat[i][j].up = 0; mat[i][j].lft = 1; mat[i][j].rgt = 0; mat[i][j].down = 0; } if (str[i][j] == v ) { mat[i][j].up = 0; mat[i][j].lft = 0; mat[i][j].rgt = 0; mat[i][j].down = 1; } if (str[i][j] == L ) { mat[i][j].up = 1; mat[i][j].lft = 0; mat[i][j].rgt = 1; mat[i][j].down = 1; } if (str[i][j] == R ) { mat[i][j].up = 1; mat[i][j].lft = 1; mat[i][j].rgt = 0; mat[i][j].down = 1; } if (str[i][j] == U ) { mat[i][j].up = 0; mat[i][j].lft = 1; mat[i][j].rgt = 1; mat[i][j].down = 1; } if (str[i][j] == D ) { mat[i][j].up = 1; mat[i][j].lft = 1; mat[i][j].rgt = 1; mat[i][j].down = 0; } if (str[i][j] == * ) { mat[i][j].up = 0; mat[i][j].lft = 0; mat[i][j].rgt = 0; mat[i][j].down = 0; } } } scanf( %d %d , &sx, &sy); scanf( %d %d , &tx, &ty); for (int i = 0; i <= n + 1; ++i) { for (int j = 0; j <= m + 1; ++j) { for (int k = 0; k < 4; ++k) { dist[i][j][k] = inf; } } } relax(sx, sy, 0, 0); while (!qx.empty()) { int x = qx.front(); int y = qy.front(); int r = qr.front(); int d = dist[x][y][r]; qx.pop(); qy.pop(); qr.pop(); relax(x, y, (r + 1) % 4, d + 1); data tmp = mat[x][y]; data tmprgt = mat[x][y + 1]; data tmpdown = mat[x + 1][y]; data tmplft = mat[x][y - 1]; data tmpup = mat[x - 1][y]; for (int i = 0; i < r; ++i) { tmp.rotate(); tmprgt.rotate(); tmpdown.rotate(); tmplft.rotate(); tmpup.rotate(); } if (tmp.rgt && tmprgt.lft) { relax(x, y + 1, r, d + 1); } if (tmp.lft && tmplft.rgt) { relax(x, y - 1, r, d + 1); } if (tmp.up && tmpup.down) { relax(x - 1, y, r, d + 1); } if (tmp.down && tmpdown.up) { relax(x + 1, y, r, d + 1); } } int ans = inf; for (int i = 0; i < 4; ++i) { ans = min(ans, dist[tx][ty][i]); } if (ans >= inf) { ans = -1; } printf( %d n , ans); } |
#include <bits/stdc++.h> using namespace std; bool sortbysecdesc(const pair<long long, long long> &a, const pair<long long, long long> &b) { if (a.first == b.first) return a.second > b.second; else return 0; } const long long N = 100010; bool prime[N]; void SieveOfEratosthenes() { long long n = N - 3; memset(prime, true, sizeof(prime)); for (long long p = 2; p * p <= n; p++) { if (prime[p] == true) { for (long long i = p * p; i <= n; i += p) prime[i] = false; } } } long long i, j; int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); SieveOfEratosthenes(); long long t; cin >> t; while (t--) { long long n; cin >> n; if (n == 1 || n == 2 || n == 3 || n == 5 || n == 7 || n == 11) { cout << -1 << n ; } else if (n % 4 == 0) { cout << n / 4 << n ; } else if (n == 6) { cout << 1 << n ; } else { long long temp = n / 4; long long x = n - temp * 4; if (x == 1) { cout << 1 + (n - 9) / 4 << n ; } else if (x == 2) { cout << 1 + (n - 6) / 4 << n ; } else if (x == 3) { cout << 2 + (n - 15) / 4 << n ; } } } return 0; } |
#include <bits/stdc++.h> using namespace std; long long fastpower(long long power, long long base) { if (power == 0) return (1 % 1000000007); long long sum; sum = fastpower(power / 2, base) % 1000000007; sum = ((sum % 1000000007) * (sum % 1000000007)) % 1000000007; if (power & 1) sum = ((sum % 1000000007) * (base % 1000000007)) % 1000000007; return (sum % 1000000007); } int main() { ios::sync_with_stdio(0), ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0); ; string s; long long k, sum = 0; cin >> s >> k; long long rn = (fastpower((long long)s.size() * k, 2) - 1 + 1000000007) % 1000000007; long long r = (fastpower((long long)s.size(), 2) - 1 + 1000000007) % 1000000007; long long d = fastpower(1000000007 - 2, r); for (int i = 0; i < (int)s.size(); ++i) { if (s[i] == 0 || s[i] == 5 ) { long long a = fastpower(i, 2); sum = (sum % 1000000007 + a * rn % 1000000007 * d % 1000000007) % 1000000007; } } cout << sum << n ; return 0; } |
#include <bits/stdc++.h> #pragma GCC optimize( Ofast,no-stack-protector ) #pragma GCC target( sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx ) #pragma GCC target( avx,tune=native ) using namespace std; class CodeHash { public: string precise(double number, int prec) { stringstream ss; ss << fixed << setprecision(prec) << number; return ss.str(); } }; class ScanReader { private: FILE *stream; char buffer[1 << 11]; bool is_digit[1 << 8]; int index, total; int scan() { if (index >= total) { index = 0; total = fread(buffer, 1, 1 << 11, stream); if (total <= 0) return -1; } return buffer[index++]; } bool iswhitespace(int n) { if (n == || n == n || n == t || n == r || n == -1) return true; return false; } public: ScanReader(FILE *stream) { this->stream = stream; index = total = 0; for (int i = 0; i < 1 << 8; i++) is_digit[i] = isdigit(i); } int scanInt() { int integer = 0, temp = scan(); while (iswhitespace(temp)) temp = scan(); int neg = 1; if (temp == - ) neg *= -1, temp = scan(); while (!iswhitespace(temp)) if (is_digit[temp]) integer *= 10, integer += (temp - 0 ), temp = scan(); return neg * integer; } long long scanLong() { long long integer = 0; int temp = scan(); while (iswhitespace(temp)) temp = scan(); int neg = 1; if (temp == - ) neg *= -1, temp = scan(); while (!iswhitespace(temp)) if (is_digit[temp]) integer *= 10, integer += (temp - 0 ), temp = scan(); return neg * integer; } string scanString() { string ss = ; int temp = scan(); while (iswhitespace(temp)) temp = scan(); while (!iswhitespace(temp)) ss += temp, temp = scan(); return ss; } double scanDouble() { int c = scan(); while (iswhitespace(c)) c = scan(); int sgn = 1; if (c == - ) sgn = -1, c = scan(); double res = 0; while (!iswhitespace(c) && c != . ) { if (c == e || c == E ) return res * pow(10, scanInt()); res *= 10; res += c - 0 ; c = scan(); } if (c == . ) { c = scan(); double m = 1; while (!iswhitespace(c)) { if (c == e || c == E ) { return res * pow(10, scanInt()); } m /= 10; res += (c - 0 ) * m; c = scan(); } } return res * sgn; } }; class PrintWriter { private: FILE *stream; static const int BUFFER_SIZE = (1 << 11) - 1; static const int MAX_OUT_SIZE = 23; int size; char buffer[BUFFER_SIZE]; void write(long long v) { if (v < 0) buffer[size++] = - , v *= -1; if (v < 10) buffer[size++] = v + 48; else { write(v / 10); buffer[size++] = v % 10 + 48; } } public: PrintWriter(FILE *stream) { this->size = 0; this->stream = stream; } void close() { if (size) fwrite(buffer, 1, size, stream); } void println(long long s) { if ((size ^ BUFFER_SIZE) < MAX_OUT_SIZE) { fwrite(buffer, 1, size, stream); size = 0; } write(s); buffer[size++] = n ; } void print(long long s) { if ((size ^ BUFFER_SIZE) < MAX_OUT_SIZE) { fwrite(buffer, 1, size, stream); size = 0; } write(s); buffer[size++] = ; } void println(string s) { if ((size ^ BUFFER_SIZE) < MAX_OUT_SIZE) { fwrite(buffer, 1, size, stream); size = 0; } for (int i = 0; i < s.length(); i++) { buffer[size++] = s[i]; if ((size ^ BUFFER_SIZE) < MAX_OUT_SIZE) { fwrite(buffer, 1, size, stream); size = 0; } } buffer[size++] = n ; } void print(string s) { if ((size ^ BUFFER_SIZE) < MAX_OUT_SIZE) { fwrite(buffer, 1, size, stream); size = 0; } for (int i = 0; i < s.length(); i++) { buffer[size++] = s[i]; if ((size ^ BUFFER_SIZE) < MAX_OUT_SIZE) { fwrite(buffer, 1, size, stream); size = 0; } } buffer[size++] = ; } }; FILE *fi = stdin; FILE *fo = stdout; ScanReader *in = new ScanReader(fi); PrintWriter *out = new PrintWriter(fo); CodeHash *ch = new CodeHash(); int main() { multiset<int> mt; multiset<int> mt1; multiset<int> mt2; int n = in->scanInt(); long long ans = 1; long long mod = 1000000007; while (n--) { string s = in->scanString(); int tt = in->scanInt(); if (s.length() == 3) { if (!mt.empty() && *mt.begin() < tt) mt.insert(tt); else if (!mt1.empty() && *mt1.rbegin() > tt) mt1.insert(tt); else mt2.insert(tt); } else { if ((!mt.empty() && *mt.begin() < tt) || (!mt1.empty() && *mt1.rbegin() > tt)) { out->println(0); out->close(); return 0; } if ((!mt.empty() && *mt.begin() == tt)) mt.erase(mt.begin()); if ((!mt1.empty() && *mt1.rbegin() == tt)) mt1.erase(--mt1.end()); while (!mt2.empty()) { int tl = *mt2.begin(); mt2.erase(mt2.begin()); if (tl < tt) { mt1.insert(tl); } else if (tl > tt) { mt.insert(tl); } else { ans = (ans * 2) % mod; } } } } out->println((ans * (mt2.size() + 1)) % mod); out->close(); return 0; } |
#include <bits/stdc++.h> using namespace std; int getn() { int h; scanf( %d , &h); return h; } template <class T, class U> ostream& operator<<(ostream& out, const pair<T, U>& par) { cout << [ << par.first << ; << par.second << ] ; return out; } vector<vector<int> > mini; int n; int nacitaj(int i, int j) { mini[i][j] = getn(); i = (i != n - 1 ? i + 1 : 0); j = (i != 0 ? j : j + 1); return (j != n ? nacitaj(i, j) : 1); } int floydwardshal(int i, int j, int l) { mini[i][j] = min(mini[i][j], mini[i][l] + mini[l][j]); i = (i != n - 1 ? i + 1 : 0); j = (i != 0 ? j : j + 1); j = (j >= n ? 0 : j); l = (i == 0 && j == 0 ? l + 1 : l); return (l != n ? floydwardshal(i, j, l) : 0); } int maxi(int i, int j) { int mx = mini[i][j]; i = (i != n - 1 ? i + 1 : 0); j = (i != 0 ? j : j + 1); return (j != n ? max(maxi(i, j), mx) : mx); } int main() { n = getn(); mini.resize(n, vector<int>(n, 0)); nacitaj(0, 0); floydwardshal(0, 0, 0); cout << maxi(0, 0) << endl; } |
#include <bits/stdc++.h> using namespace std; int main() { int l, r; cin >> l >> r; int k = r - l; if (k >= 1) cout << 2 << endl; else cout << l << endl; return 0; } |
#include <bits/stdc++.h> int main() { int sum = 0, a, n, m, i; scanf( %d %d , &n, &m); for (i = 1; i <= n; i++) { sum = sum + i; if (m > sum && i == n) { i = 0; } a = m - sum; if (a < i + 1) { printf( %d , a); break; } } return 0; } |
#include <bits/stdc++.h> using namespace std; const int N = 2000000 + 10; int a[N], b[N]; int n, m; int main() { int x, y; scanf( %d%d , &n, &m); { for (int i = 0; i < m; i++) { scanf( %d%d , &x, &y); x--; y--; a[x]++; a[y]++; } for (int i = 0; i < n; i++) b[i] = n - 1 - a[i]; long long total = 0; for (int i = 0; i < n; i++) total += (long long)a[i] * b[i]; total /= 2; cout << (long long)n * (n - 1) / 2 * (n - 2) / 3 - total << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; long long mult(long long a, long long b, long long p = 1000000007) { return ((a % p) * (b % p)) % p; } long long add(long long a, long long b, long long p = 1000000007) { return (a % p + b % p) % p; } long long sub(long long a, long long b, long long p = 1000000007) { return (a % p - b % p + p) % p; } long long fpow(long long n, long long k, long long p = 1000000007) { long long r = 1; for (; k; k >>= 1) { if (k & 1) r = mult(r, n, p); n = mult(n, n, p); } return r; } long long inv(long long a, long long p = 1000000007) { return fpow(a, p - 2, p); } map<long long, vector<long long> > m; int main() { long long n, k; cin >> n >> k; long long a[n], c[n]; for (int i = 0; i < n; i++) { cin >> a[i]; m[a[i]].push_back(i); } bool f = 1; long long mx = 1; long long it = 1; for (auto i : m) { if (i.second.size() > k) f = 0; for (auto j : i.second) { c[j] = it; mx = max(mx, it); ++it; if (it > k) { it = 1; mx = k; } } } if (f && mx == k) { cout << YES n ; for (int i = 0; i < n; i++) cout << c[i] << ; } else cout << NO n ; } |
#include <bits/stdc++.h> using namespace std; const int N = 2 * 100 * 1000; long double l[N]; long double Maks(long double dod, int n) { int i; long double as, mi, w; mi = 0; w = -10000000000000; as = 0; for (i = 1; i <= n; ++i) { as += (l[i] - dod); w = max(w, as - mi); mi = min(mi, as); } return w; } long double Minim(long double dod, int n) { int i; long double as, ma, w; ma = 0; w = 10000000000000; as = 0; for (i = 1; i <= n; ++i) { as += (l[i] - dod); w = min(w, as - ma); ma = max(ma, as); } return w; } long double TS(long double p, long double k, int n) { int i; long double s1, s2, w1, w2; for (i = 1; i <= 100; ++i) { s1 = p + ((k - p) / 3); s2 = k - ((k - p) / 3); w1 = max(abs(Maks(s1, n)), abs(Minim(s1, n))); w2 = max(abs(Maks(s2, n)), abs(Minim(s2, n))); if (w1 < w2) k = s2; else p = s1; } return p; } void WczytajLiczby(int &n) { int i; cin >> n; for (i = 1; i <= n; ++i) cin >> l[i]; } void Weakness() { int n; long double w; WczytajLiczby(n); w = TS(-10000, 10000, n); w = max(abs(Minim(w, n)), abs(Maks(w, n))); cout << fixed << setprecision(10) << w << n ; } int main() { ios_base::sync_with_stdio(false); cin.tie(nullptr); Weakness(); return 0; } |
#include <bits/stdc++.h> using namespace std; int a[100005], lg[100005]; int rmq[100005][20]; struct trie { struct node { node *edge[2]; vector<int> ps[2]; node() { for (int i = 0; i < 2; i++) edge[i] = 0; ps[0].clear(); ps[1].clear(); } } * root; trie() { root = new node(); } void insert(int v, int p) { node *t = root; for (int po = 29; po >= 0; po--) { int x = (bool)(v & (1 << po)); if (!t->edge[x]) t->edge[x] = new node(); t->ps[x].push_back(p); t = t->edge[x]; } } void remove(int v) { node *t = root; for (int po = 29; po >= 0; po--) { int x = (bool)(v & (1 << po)); t->ps[x].pop_back(); t = t->edge[x]; } } long long query(int v, int last) { node *t = root; int res = 0; for (int po = 29; po >= 0; po--) { int x = (bool)(v & (1 << po)); x = !x; if (!t->ps[x].empty() && t->ps[x].back() > last) { res += (1 << po); t = t->edge[x]; } else t = t->edge[!x]; } return res; } }; int q(int l, int r) { if (l > r) swap(l, r); int po = lg[r - l + 1]; return max(rmq[l][po], rmq[r - (1 << po) + 1][po]); } int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); lg[0] = -1; for (int i = 1; i < 100005; i++) lg[i] = lg[i - 1] + !(i & (i - 1)); int n; cin >> n; for (int i = 0; i < n; i++) cin >> a[i]; for (int i = 0; i < n; i++) rmq[i][0] = a[i]; for (int i = 1; i <= lg[n]; i++) for (int j = 0; j + (1 << i) <= n; j++) rmq[j][i] = max(rmq[j][i - 1], rmq[j + (1 << (i - 1))][i - 1]); long long res = 0; trie t; t.insert(a[0], 0); stack<pair<long long, long long> > ms; ms.push(pair<long long, long long>(a[0], 0)); for (int i = 1; i < n; i++) { int p1 = -1; for (int po = (1 << 17); po; po >>= 1) if (p1 + po < i && q(p1 + po, i) > a[i]) p1 += po; int p2 = -1; if (p1 > 0) for (int po = (1 << 17); po; po >>= 1) if (p2 + po <= p1 - 1 && q(p2 + po, p1 - 1) > a[i]) p2 += po; res = max(res, t.query(a[i], p2)); while (!ms.empty() && ms.top().second > p1) { t.remove(ms.top().first); ms.pop(); } t.insert(a[i], i); ms.push(pair<long long, long long>(a[i], i)); } cout << (res) << n ; return 0; } |
#include <bits/stdc++.h> using namespace std; int n, g[20][20], r, c, k, ans = 0, x, y; bool chk(int a, int b, int c, int d) { int cnt = 0; for (int i = a; i <= a + c; i++) { for (int j = b; j <= b + d; j++) { cnt += g[i][j]; if (cnt >= k) return 1; } } return 0; } int main() { scanf( %d%d%d%d , &r, &c, &n, &k); for (int i = 0; i < n; i++) { scanf( %d%d , &x, &y); g[x][y] = 1; } for (int i = 1; i <= r; i++) { for (int j = 1; j <= c; j++) { for (int e = 0; e + i <= r; e++) { for (int f = 0; f + j <= c; f++) { ans += chk(i, j, e, f); } } } } cout << ans; return 0; } |
#include <bits/stdc++.h> using namespace std; void printVec(vector<int> v2, string s = ) { cout << s; for (int i = 0; i < (int)v2.size(); ++i) cout << v2[i] << ; cout << n ; } bool isOdd(int a) { return (a % 2 == 1); } void initMem(int n, int mem[]) { for (int i = 0; i < n; i++) mem[i] = -1; } bool lucky(long long n) { n = abs(n); while (n) { if (n % 10 == 8) { return true; } n /= 10; } return false; } int main() { int k; int d; cin >> k >> d; string s = ; s += ( 0 + d); for (int i = 1; i < k; i++) s += 0 ; if (d == 0) { if (k == 1) cout << 0; else cout << No solution ; return 0; } cout << s; return 0; } |
#include <bits/stdc++.h> using namespace std; void solve() { long long a, b; cin >> a >> b; long long ans = abs(a - b) / 5; a = abs(a - b) % 5; if (a == 4) cout << ans + 2; if (a == 3) cout << ans + 2; if (a == 2) cout << ans + 1; if (a == 1) cout << ans + 1; if (a == 0) cout << ans; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.precision(20); long long t = 1; cin >> t; while (t--) { solve(); cout << n ; } cin.get(); return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; int gizzly; cin >> gizzly; priority_queue<int> scoreList; for (int i = 1; i < n; i++) { int x; cin >> x; scoreList.push(x); } int candy = 0; while (gizzly <= scoreList.top()) { int opponent = scoreList.top(); scoreList.pop(); opponent -= 1; gizzly += 1; candy += 1; scoreList.push(opponent); } cout << candy << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; int n, k, a[((int)1001 * 1000)], maxi, mini; vector<int> v; int jaghool; bitset<((int)1001 * 1000)> dp, mark; int main() { scanf( %d%d , &n, &k); int k2 = k; for (int i = 1; i <= n; i++) scanf( %d , &a[i]); for (int i = 1; i <= n; i++) if (!mark[i]) { int x = a[i], p = 1; while (x != i) p++, mark[x] = 1, x = a[x]; v.push_back(p); maxi += min(k2, p / 2) * 2, k2 -= min(k2, p / 2); if (p % 2) jaghool++; } maxi += min(k2, jaghool); dp[0] = 1; sort(v.begin(), v.end()); v.push_back(-1); vector<int> v2; for (int i = 0, cnt = 1; i < v.size(); i++) { if (v[i] != v[i + 1]) { int x = v[i]; while (cnt) { dp |= (dp << v[i]); for (int j = 0; j < ((int)20); j++) { if ((1 << j) <= cnt && cnt < (1 << (j + 1))) { cnt -= (1 << j); break; } dp |= (dp << (v[i] << j)); } } cnt = 1; } else cnt++; } cout << k + 1 - dp[k] << << maxi << n ; return 0; } |
#include <bits/stdc++.h> using namespace std; int Q, cnt = 1; int par[400010][21], nxt[400010][21], len[400010]; long long w[400010], sum[400010][21]; long long mx[400010][21]; int find_first_bigger(int u, int W) { if (mx[u][0] >= W) return u; for (int i = 18; i >= 0; i--) if (mx[u][i + 1] >= W && mx[u][i] < W) u = par[u][i]; return mx[u][0] >= W ? u : 0; } void add(int R, int W) { int u = ++cnt; w[u] = W; int fb = find_first_bigger(R, W); len[u] = len[fb] + 1; nxt[u][0] = fb; sum[u][0] = W; par[u][0] = R; mx[u][0] = w[u]; for (int i = 1; i < 21; i++) { nxt[u][i] = nxt[nxt[u][i - 1]][i - 1]; sum[u][i] = sum[nxt[u][i - 1]][i - 1] + sum[u][i - 1]; par[u][i] = par[par[u][i - 1]][i - 1]; mx[u][i] = max(mx[par[u][i - 1]][i - 1], mx[u][i - 1]); } } long long getsum(long long u, long long k) { if (!k) return 0; long long ret = 0; for (int i = 0; k; i++, k >>= 1) if (k & 1) { ret += sum[u][i]; u = nxt[u][i]; } return ret; } long long query(long long u, long long x) { long long lo = 1, hi = len[u]; while (lo < hi) { long long mid = (lo + hi) >> 1; long long s = getsum(u, mid); if (s > x) hi = mid; else lo = mid + 1; } if (getsum(u, lo) <= x) return lo; else if (getsum(u, lo - 1) > x) return 0; return lo - 1; } int main() { for (int i = 0; i < 400010; i++) for (int j = 0; j < 21; j++) mx[i][j] = -4e18; for (int i = 0; i < 21; i++) mx[1][0] = 0; len[1] = 1; scanf( %d , &Q); long long last = 0; while (Q--) { long long tt, p, q; scanf( %lld%lld%lld , &tt, &p, &q); if (tt == 1) { long long R = p ^ last, W = q ^ last; add(R, W); } else { long long R = p ^ last, X = q ^ last; printf( %lld n , last = query(R, X)); } } return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; vector<int> vec; set<int> st; for (int i = 0; i < int(n); ++i) { int a; cin >> a; st.insert(i); vec.push_back(a); } queue<int> tok; int ans = 0; int killed = 0; for (int i = n - 1; i > 0; i--) { if (vec[i] < vec[i - 1]) { st.erase(i); ++killed; tok.push(i - 1); } } if (killed) ans++; queue<int> qtok; while (killed) { killed = 0; while (!tok.empty()) { int tp = tok.front(); tok.pop(); auto it = st.find(tp); if (it == st.end()) continue; auto itn = st.find(tp); itn++; if (itn == st.end()) continue; if (vec[*it] > vec[*itn]) { qtok.push(*it); ++killed; st.erase(itn); } } while (!qtok.empty()) { tok.push(qtok.front()); qtok.pop(); } if (killed) ans++; } cout << ans << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; const long double pie = 3.14159265358979; const long long mod = 1e9 + 7; string vow = aeiou ; void solve(int test_case) { string f, m, s; cin >> f >> m >> s; map<string, string> beat; beat[ rock ] = scissors ; beat[ scissors ] = paper ; beat[ paper ] = rock ; if (beat[f] == m && beat[f] == s) cout << F ; else if (beat[m] == f && beat[m] == s) cout << M ; else if (beat[s] == f && beat[s] == m) cout << S ; else cout << ? ; cout << n ; } int main() { int t = 1; for (int i = 0; i < t; i++) solve(i); return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int n, t, k, d; cin >> n >> t >> k >> d; int curr = 0; while (curr <= d) { n -= k; curr += t; } if (n > 0) { cout << YES ; } else { cout << NO ; } } |
#include <bits/stdc++.h> using namespace std; int n, ls[310]; int dp[110][310][310]; pair<int, int> p[110]; int L[110], R[110], x[110]; int main() { scanf( %d , &n); for (int i = 1; i <= n; i++) { scanf( %d%d , &p[i].first, &p[i].second); ls[i * 3 - 2] = p[i].first - p[i].second; ls[i * 3 - 1] = p[i].first; ls[i * 3] = p[i].first + p[i].second; } sort(p + 1, p + n + 1); sort(ls + 1, ls + n * 3 + 1); int ex = unique(ls + 1, ls + n * 3 + 1) - ls; for (int i = 1; i <= n; i++) { L[i] = lower_bound(ls + 1, ls + ex, p[i].first - p[i].second) - ls; x[i] = lower_bound(ls + 1, ls + ex, p[i].first) - ls; R[i] = lower_bound(ls + 1, ls + ex, p[i].first + p[i].second) - ls; } for (int i = 1; i <= n; i++) { for (int j = 1; j < ex; j++) { for (int k = j; k < ex; k++) { dp[i][j][max(k, R[i])] = max( dp[i][j][max(k, R[i])], dp[i - 1][j][k] + max(0, ls[R[i]] - ls[k])); if (L[i] <= j) dp[i][0][max(k, x[i])] = max(dp[i][0][max(k, x[i])], dp[i - 1][j][k] + max(0, ls[x[i]] - ls[k])); } } for (int k = 1; k < ex; k++) { if (k >= x[i]) dp[i][0][max(k, R[i])] = max( dp[i][0][max(k, R[i])], dp[i - 1][0][k] + max(0, ls[R[i]] - ls[k])); else dp[i][0][R[i]] = max(dp[i][0][R[i]], dp[i - 1][0][k] + ls[R[i]] - ls[x[i]]); for (int j = k; j < x[i]; j++) dp[i][j][R[i]] = max(dp[i][j][R[i]], dp[i - 1][0][k] + ls[R[i]] - ls[j]); if (k >= L[i]) dp[i][0][max(k, x[i])] = max( dp[i][0][max(k, x[i])], dp[i - 1][0][k] + max(0, ls[x[i]] - ls[k])); else dp[i][0][x[i]] = max(dp[i][0][x[i]], dp[i - 1][0][k] + ls[x[i]] - ls[L[i]]); for (int j = k; j < L[i]; j++) dp[i][j][x[i]] = max(dp[i][j][x[i]], dp[i - 1][0][k] + ls[x[i]] - ls[j]); } } int ans = 0; for (int i = 1; i < ex; i++) ans = max(ans, dp[n][0][i]); printf( %d n , ans); return 0; } |
#include <bits/stdc++.h> using namespace std; inline int read() { int x = 0, f = 1; char c = getchar(); for (; !isdigit(c); c = getchar()) if (c == - ) f = -1; for (; isdigit(c); c = getchar()) x = x * 10 + c - 0 ; return x * f; } const int MAXN = 200010; const int INF = 1e9; const int Mod = 998244353LL; int mx; int N; int tms = 0; pair<int, int> sta[MAXN * 10 + 1]; int top; int Node[MAXN << 1], Next[MAXN << 1], Root[MAXN + 1], cnt; int deg[MAXN + 1]; inline void insert(int u, int v) { Node[++cnt] = v; Next[cnt] = Root[u]; Root[u] = cnt; return; } inline void solve(int k, int Fa, int val) { if (k != 1) --deg[k]; int last = deg[k]; sta[++top] = make_pair(k, tms); bool flag = 0; if (tms == mx && val != -1) { tms = max(val - last, 0); if (tms + last != val) flag = 1; sta[++top] = make_pair(k, tms); } for (int x = Root[k]; x; x = Next[x]) { int v = Node[x]; if (v == Fa) continue; ++tms; --last; solve(v, k, ((tms == val && flag) ? tms : tms - 1)); ++tms; sta[++top] = make_pair(k, tms); if (tms == mx && val != -1) { tms = max(val - last, 0); if (tms + last != val) flag = 1; sta[++top] = make_pair(k, tms); } } if (val != -1 && tms > val) { sta[++top] = make_pair(k, val); tms = val; } return; } int main() { N = read(); for (int i = 1; i < N; i++) { int u = read(), v = read(); insert(u, v); insert(v, u); ++deg[u]; ++deg[v]; } mx = 0; for (int i = 1; i <= N; i++) mx = max(mx, deg[i]); solve(1, 0, -1); printf( %d n , top); for (int i = 1; i <= top; i++) printf( %d %d n , sta[i].first, sta[i].second); return 0; } |
#include <bits/stdc++.h> using namespace std; const int N = 600000; const int MOD = (int)1e9 + 7; int n, m, k, u, v, g[N]; long long c[N], w[N]; set<long long> s; vector<pair<long long, pair<int, int> > > e; int find(int cur) { return cur == g[cur] ? g[cur] : g[cur] = find(g[cur]); } int main() { scanf( %d %d %d , &n, &m, &k); w[0] = 1; for (int i = 1; i <= n; i++) { w[i] = 2LL * w[i - 1] % MOD; } for (int i = 0; i < n; i++) { scanf( %lld , &c[i]); } for (int i = 0; i < m; i++) { scanf( %d %d , &u, &v); u--; v--; s.insert(c[u] ^ c[v]); e.push_back({c[u] ^ c[v], make_pair(u, v)}); } long long ans = (((1LL << k) - s.size()) % MOD) * w[n] % MOD; sort(e.begin(), e.end()); for (int i = 0; i < e.size();) { int j = i; while (j < e.size() && e[i].first == e[j].first) { j++; } for (int p = i; p < j; p++) { int u = e[p].second.first; int v = e[p].second.second; g[u] = u; g[v] = v; } int c = n; for (int p = i; p < j; p++) { int u = e[p].second.first; int v = e[p].second.second; u = find(u); v = find(v); if (u != v) { c--; g[v] = u; } } ans += w[c]; ans %= MOD; i = j; } printf( %lld n , ans); return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int n, m, lamps[2002], sol = 0, cs; memset(lamps, 0, sizeof(lamps)); cin >> n >> m; string s[2002]; for (int i = 0; i < n; i++) { cin >> s[i]; } for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) if (s[i][j] == 1 ) lamps[j]++; for (int i = 0; i < n; i++) { cs = 1; for (int j = 0; j < m; j++) { if (s[i][j] == 1 && lamps[j] < 2) { cs = 0; break; } } if (cs == 1) { sol = 1; break; } } if (sol) cout << YES ; else cout << NO ; return 0; } |
#include <bits/stdc++.h> using namespace std; const int MAXN = 200000 + 100; const int M = 30; vector<int> G[MAXN]; int deep[MAXN], fa[MAXN][M]; void DFS(int cur, int pre) { fa[cur][0] = pre; for (int i = 1; i < 20; ++i) fa[cur][i] = fa[fa[cur][i - 1]][i - 1]; for (int i = 0; i < G[cur].size(); i++) { int to = G[cur][i]; if (to == pre) continue; deep[to] = deep[cur] + 1; DFS(to, cur); } } int LCA(int v, int u) { if (deep[v] > deep[u]) swap(v, u); for (int i = 0; i < 20; ++i) if (deep[u] - deep[v] >> i & 1) u = fa[u][i]; for (int i = 19; i >= 0; --i) if (fa[v][i] != fa[u][i]) v = fa[v][i], u = fa[u][i]; return v == u ? v : fa[v][0]; } int cal(int s, int t, int f) { int ans = 0, sf = LCA(s, f) == f, tf = LCA(t, f) == f; if (sf != tf) return 1; else if (sf) ans = deep[LCA(s, t)] - deep[f]; else if (LCA(s, f) != LCA(t, f)) ans = deep[f] - max(deep[LCA(f, s)], deep[LCA(f, t)]); else ans = deep[LCA(s, t)] + deep[f] - 2 * deep[LCA(s, f)]; return ans + 1; } int main() { int n, q; scanf( %d%d , &n, &q); for (int i = 2; i <= n; ++i) { int x; scanf( %d , &x); G[i].push_back(x); G[x].push_back(i); } DFS(1, 0); while (q--) { int a, b, c; scanf( %d%d%d , &a, &b, &c); printf( %d n , max(cal(a, b, c), max(cal(b, c, a), cal(c, a, b)))); } return 0; } |
#include <bits/stdc++.h> using namespace std; bool check(int i, int n, set<pair<int, int> >& st) { for (auto it : st) { pair<int, int> t(it.first + i, it.second + i); if (t.first > n) t.first %= n; if (t.second > n) t.second %= n; if (t.first > t.second) swap(t.first, t.second); if (!st.count(t)) return false; } return true; } int main() { int n, m, a, b; while (cin >> n >> m) { set<pair<int, int> > st; for (int i = 1; i <= m; i++) { cin >> a >> b; st.insert(make_pair(min(a, b), max(a, b))); } bool flg = false; for (int i = 1; i * i <= n; i++) { if (n % i == 0) { if (check(i, n, st)) { flg = true; break; } else if (i != 1 && check(n / i, n, st)) { flg = true; break; } } } cout << (flg ? Yes : No ) << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; int i, j, k, l, n, m, s, an, K, X; const int N = 5100; int a[1100000], g[1100000]; long long f[N][N]; int main() { scanf( %d%d , &n, &K); for (int i = 1; i <= n; i++) scanf( %d , &a[i]); sort(&a[1], &a[n + 1]); int v1 = n / K + 1; int v2 = n / K; if (n % K == 0) v1--; int ss = n % K; if (!ss) ss = K; ss = K - ss; memset(f, 120, sizeof(f)); f[0][0] = 0; for (int i = 0; i <= K; i++) for (int j = 0; j <= ss; j++) { int now = j * v2 + (i - j) * v1; f[i + 1][j] = min(f[i + 1][j], f[i][j] + a[now + v1] - a[now + 1]); f[i + 1][j + 1] = min(f[i + 1][j + 1], f[i][j] + a[now + v2] - a[now + 1]); } printf( %I64d n , f[K][ss]); return 0; } |
#include <bits/stdc++.h> using namespace std; void fun(long long a[], long long remain, long long total, long long n, long long m) { vector<long long> ans; long long i, j; for (i = 0; i < n && total > 0; i++) { if (a[i] % m == remain) { ans.push_back(a[i]); total--; } } sort(ans.begin(), ans.end()); for (i = 0; i < ans.size(); i++) cout << ans[i] << ; } int main() { long long t, n, i, j, k, m; t = 1; while (t--) { cin >> n >> k >> m; map<long long, long long> x; long long a[n], flag = 0; for (i = 0; i < n; i++) { cin >> a[i]; x[a[i] % m]++; } for (auto itr = x.begin(); itr != x.end(); itr++) { if (itr->second >= k) { flag = 1; cout << Yes << endl; fun(a, itr->first, k, n, m); break; } } if (flag == 0) cout << No << endl; } } |
#include <bits/stdc++.h> using namespace std; bool isprime(long long int n) { if (n <= 1) return false; if (n <= 3) return true; if (n % 2 == 0 || n % 3 == 0) return false; for (long long int i = 5; i * i <= n; i = i + 6) if (n % i == 0 || n % (i + 2) == 0) return false; return true; } int main() { int t; cin >> t; string y = YES n , z = NO n ; while (t--) { long long int a, b, i, j; cin >> a >> b; if (a - b != 1) cout << z; else { if (isprime(a + b)) cout << y; else cout << z; } } } |
#include <bits/stdc++.h> using namespace std; int main() { int n, m; cin >> n >> m; long long ans = 0; for (int i = (0); i < (n); ++i) { long long t, T, x, cost; cin >> t >> T >> x >> cost; if (t >= T) { ans += cost + m * x; continue; } long long aux1 = cost; if (m > (T - t)) aux1 += m * x; long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1; aux2 *= cost; ans += min(aux1, aux2); } cout << ans << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { string s; cin >> s; int n = 0; while (s.at(n) != . ) n++; if (s.at(n - 1) == 9 ) cout << GOTO Vasilisa. ; else { if (s.at(n + 1) < 53) cout << s.substr(0, n); else { cout << s.substr(0, n - 1); cout << (char)(s.at(n - 1) + 1); } } } |
#include <bits/stdc++.h> using namespace std; int main() { long long n; while (scanf( %I64d , &n) != EOF) { long long x, y, l, h, mid; l = 0, h = 1e18 + 7; while (l < h - 1) { mid = (l + h) >> 1; if (n / (3 * mid) >= mid + 1) l = mid; else h = mid; } x = 2 * l; y = 0; long long ret = n - 3 * l * (l + 1); l++; if (ret >= 1) { x++; y += 2; if (ret <= l) { x -= ret - 1; y += 2 * (ret - 1); } else { x -= l - 1; y += 2 * (l - 1); if (ret <= 2 * l) { x -= 2 * (ret - l); } else { x -= 2 * l; if (ret <= 3 * l) { x -= ret - 2 * l; y -= 2 * (ret - 2 * l); } else { x -= l; y -= 2 * l; if (ret <= 4 * l) { x += ret - 3 * l; y -= 2 * (ret - 3 * l); } else { x += l; y -= 2 * l; if (ret <= 5 * l) { x += 2 * (ret - 4 * l); } else { x += 2 * l; x += ret - 5 * l; y += 2 * (ret - 5 * l); } } } } } } printf( %I64d %I64d n , x, y); } return 0; } |
#include <bits/stdc++.h> using namespace std; const int M = 4e5 + 10; int n, a[M], b[M], ans, cnt; int f(int x, int i) { return n - (x >> i) - (lower_bound(b, b + n, (1 << (i + 1)) - x) - b); } int32_t main() { scanf( %d , &n); for (int i = 0; i < n; i++) scanf( %d , a + i); for (int i = 0; i < 28; i++) { for (int j = 0; j < n; j++) b[j] = (a[j] & ((1 << (i + 1)) - 1)); sort(b, b + n); cnt = 0; for (int j = 0; j < n; j++) cnt += f(b[j], i); ans += (((cnt >> 1) & 1) << (i + 1)); } if (n % 2 == 0) for (int i = 0; i < n; i++) ans ^= a[i]; cout << ans << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; const long double PI = acos(-1); const long long MOD = 1000000007; const long long FMOD = 998244353; long long cnt1, cnt2, x, y; bool isSafe(long long mid) { long long div1 = mid / x; long long div2 = mid / y; long long div3 = mid / (x * y); long long no = mid - (div1 + div2 - div3); long long p = div1 - div3; long long q = div2 - div3; long long ans1 = cnt1 - q; long long ans2 = cnt2 - p; if (ans1 < 0) ans1 = 0; if (ans2 < 0) ans2 = 0; return (ans1 + ans2) <= no; } signed main() { cin >> cnt1 >> cnt2 >> x >> y; long long beg = 0, end = 1e10; long long ans = 0; while (beg <= end) { long long mid = (beg + end) / 2; if (isSafe(mid)) { ans = mid; end = mid - 1; } else { beg = mid + 1; } } cout << ans; } |
/*/ Author: Aniruddh Lawande /*/ #include<bits/stdc++.h> using namespace std; /*/---------------------------Defines----------------------/*/ #define ll long long #define F first #define S second #define pb push_back #define endl n #define all(v) (v).begin(),(v).end() typedef pair<ll,ll> pii; /*/-----------------------Modular Arithmetic---------------/*/ const long long INF = 1ll << 32; const int mod=1e9+7; inline int add(int x,int y){ x+=y; if (x>=mod) return x-mod; return x; } inline int sub(int x,int y){ x-=y; if (x<0) return x+mod; return x; } inline int mul(int x,int y){ return (x*1ll*y)%mod; } inline int power(int x,int y){ int ans=1; while(y){ if (y&1) ans=mul(ans,x); x=mul(x,x); y>>=1; } return ans; } inline int inv(int x){ return power(x,mod-2); } const ll FACTORIAL_SIZE = 1.1e6; ll fact[FACTORIAL_SIZE], ifact[FACTORIAL_SIZE]; void gen_factorial(ll n) { fact[0] = fact[1] = ifact[0] = ifact[1] = 1; for (ll i = 2; i <= n; i++) { fact[i] = (i * fact[i - 1]) % mod; } ifact[n] = inv(fact[n]); for (ll i = n - 1; i >= 2; i--) { ifact[i] = ((i + 1) * ifact[i + 1]) % mod; } } ll nck(ll n, ll k) { ll den = (ifact[k] * ifact[n - k]) % mod; return (den * fact[n]) % mod; } /*/-----------------------------Code begins----------------------------------/*/ const int N=2e5+5; void solve() { ll d,k; cin>>d>>k; ll x=0,y=0; ll i=0; while(x*x+y*y<=d*d) { if(i%2==0) { if((x+k)*(x+k)+y*y<=d*d) x+=k; else break; } else { if(x*x+(y+k)*(y+k)<=d*d) y+=k; else break; } i++; } if(i%2!=0) { cout<< Ashish <<endl; } else { cout<< Utkarsh <<endl; } } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); int tc=1; cin>>tc; int i=1; while(tc--) { //cout<< CASE # <<i<< : ; solve(); i++; } return 0; } |
#include <bits/stdc++.h> using namespace std; using ll = long long; const int N = 2e5L + 11, M = N * 2; int a[M], b[M], c[M]; int back[M]; struct SegTree { ll flag[N * 8]; ll val[N * 4]; void push(int x) { val[x] += flag[x]; flag[2 * x] += flag[x]; flag[2 * x + 1] += flag[x]; flag[x] = 0; } void change(int l, int r, int ql, int qr, int c, int x = 1) { push(x); if (ql == l && qr == r) { flag[x] = c; push(x); } else { if (qr <= (l + r) / 2) { change(l, (l + r) / 2, ql, qr, c, 2 * x); push(2 * x + 1); } else if (ql >= (l + r) / 2) { push(2 * x); change((l + r) / 2, r, ql, qr, c, 2 * x + 1); } else { change(l, (l + r) / 2, ql, (l + r) / 2, c, 2 * x); change((l + r) / 2, r, (l + r) / 2, qr, c, 2 * x + 1); } val[x] = min(val[2 * x], val[2 * x + 1]); } } ll query(int l, int r, int ql, int qr, int x = 1) { push(x); if (ql == l && qr == r) return val[x]; if (qr <= (l + r) / 2) return query(l, (l + r) / 2, ql, qr, 2 * x); else if (ql >= (l + r) / 2) return query((l + r) / 2, r, ql, qr, 2 * x + 1); else return min(query(l, (l + r) / 2, ql, (l + r) / 2, 2 * x), query((l + r) / 2, r, (l + r) / 2, qr, 2 * x + 1)); } } st; vector<int> e[N]; int cnt = 0; int in[N], out[N], id[N]; void dfs(int x) { id[x] = ++cnt; in[x] = cnt; for (int i : e[x]) dfs(i); out[x] = cnt; } int n; ll query(int x) { return st.query(1, n + 1, id[x], id[x] + 1) - back[x]; } int main() { int q; cin >> n >> q; for (int i = 1; i <= 2 * n - 2; i++) { scanf( %d%d%d , a + i, b + i, c + i); if (i <= n - 1) e[a[i]].push_back(b[i]); else back[a[i]] = c[i]; } dfs(1); for (int i = 1; i <= n - 1; i++) st.change(1, n + 1, in[b[i]], out[b[i]] + 1, c[i]); for (int i = 2; i <= n; i++) st.change(1, n + 1, id[i], id[i] + 1, back[i]); while (q--) { int t, u, v; scanf( %d%d%d , &t, &u, &v); if (t == 1) { int i = u, w = v; if (i <= n - 1) { st.change(1, n + 1, in[b[i]], out[b[i]] + 1, w - c[i]); c[i] = w; } else { st.change(1, n + 1, id[a[i]], id[a[i]] + 1, w - c[i]); back[a[i]] = w; c[i] = w; } } else { ll ans = st.query(1, n + 1, in[u], out[u] + 1) - query(u) + query(v); if (id[v] >= in[u] && id[v] <= out[u]) ans = min(ans, query(v) - query(u)); printf( %lld n , ans); } } } |
#include <bits/stdc++.h> using namespace std; const long long INF = 1e17 + 7; const long long maxn = 5e5 + 700; const int mod = 998244353; const int up = 1e9; template <typename T> inline void read(T &a) { char c = getchar(); T x = 0, f = 1; while (!isdigit(c)) { if (c == - ) f = -1; c = getchar(); } while (isdigit(c)) { x = (x << 1) + (x << 3) + c - 0 ; c = getchar(); } a = f * x; } long long n, m, p; int num[maxn], b[maxn]; struct Dinic { long long cnt = 2; struct Edge { int e, next; long long w; }; int _S, _T, N; int head[maxn], d[maxn], cur[maxn]; Edge edge[maxn]; void _inint(int s, int t, int n) { memset(head, 0, sizeof(head)); cnt = 2; _S = s, _T = t, N = n; } void addedge(int u, int v, long long w) { edge[cnt] = Edge{v, head[u], w}; head[u] = cnt++; } void Add(int u, int v, long long w) { addedge(u, v, w); addedge(v, u, 0); } bool bfs() { for (int k = 0; k <= N; k++) d[k] = 0; queue<int> q; q.push(_S); d[_S] = 1; while (!q.empty()) { int u = q.front(); q.pop(); for (int i = head[u]; i; i = edge[i].next) { int e = edge[i].e; if (edge[i].w <= 0 || d[e]) continue; d[e] = d[u] + 1; q.push(e); } } for (int k = 0; k <= N; k++) cur[k] = head[k]; return (d[_T] != 0); } long long dfs(int u, long long flow) { if (u == _T) return flow; for (int &i = cur[u]; i; i = edge[i].next) { int e = edge[i].e; if (d[e] != d[u] + 1 || edge[i].w <= 0) continue; long long temp = dfs(e, min(flow, edge[i].w)); if (temp <= 0) continue; edge[i].w -= temp; edge[i ^ 1].w += temp; return temp; } return 0; } long long MaxFlow() { long long maxflow = 0, delta = 0; while (bfs()) { while (delta = dfs(_S, INF)) maxflow += delta; } return maxflow; } vector<int> v[maxn]; int col[maxn]; vector<vector<int>> res; void dfs(int u, vector<int> &a) { col[u] = 1; a.push_back(u); for (int e : v[u]) { if (col[e]) continue; dfs(e, a); } } void AC() { long long temp = MaxFlow(); if (temp == N - 1) { for (int i = 1; i <= n; i++) { if (!(num[i] & 1)) continue; for (int k = head[i]; k; k = edge[k].next) { int e = edge[k].e; if (edge[k ^ 1].w) { v[e].push_back(i); v[i].push_back(e); } } } for (int i = 1; i <= n; i++) { if (!col[i]) { vector<int> temp; dfs(i, temp); res.push_back(temp); } } printf( %d n , res.size()); for (auto x : res) { printf( %d , x.size()); for (int y : x) printf( %d , y); printf( n ); } } else printf( Impossible n ); } } g; int judge(int x) { for (int i = 2; i * i <= x; i++) if (x % i == 0) return 0; return 1; } int main() { read(n); g._inint(0, n + 1, n + 1); for (int i = 1; i <= n; i++) { read(num[i]); if (num[i] & 1) g.Add(0, i, 2); else g.Add(i, n + 1, 2); } for (int i = 1; i <= n; i++) { for (int k = i + 1; k <= n; k++) { if (judge(num[i] + num[k])) { if (num[i] & 1) g.Add(i, k, 1); else g.Add(k, i, 1); } } } g.AC(); return 0; } |
#include <bits/stdc++.h> using namespace std; const long long N = 2e5 + 30, Mod = 1e9 + 7; const long long SQ = 330; map<long long, vector<long long> > mp; pair<long long, long long> E[N]; long long p[N], sz[N], M[N], cnt[N]; vector<long long> G[N]; long long r[N], ans[N]; void DFS(long long v, long long R) { cnt[v] = sz[v]; M[v] = 1; r[v] = R; for (auto u : G[v]) { if (!M[u]) { DFS(u, R); cnt[v] += cnt[u]; } } } long long get(long long x) { return (p[x] ? p[x] = get(p[x]) : x); } void add(long long x, long long y) { x = get(x); y = get(y); if (x == y) return; if (rand() % 2) swap(x, y); p[x] = y; sz[y] += sz[x]; } int main() { ios::sync_with_stdio(0), cin.tie(0); long long n; cin >> n; fill(sz, sz + N, 1); for (int i = 1; i < n; i++) { long long v, u, w; cin >> v >> u >> w; mp[w].push_back(i); E[i] = {v, u}; } for (auto R : mp) { vector<long long> V = R.second; set<long long> second; for (auto x : V) { second.insert(get(E[x].first)); second.insert(get(E[x].second)); } for (auto x : second) G[x].clear(), M[x] = false, cnt[x] = 0; for (auto x : V) { G[get(E[x].first)].push_back(get(E[x].second)); G[get(E[x].second)].push_back(get(E[x].first)); } for (auto u : second) if (!M[u]) DFS(u, u); for (auto x : V) { long long v = E[x].first, u = E[x].second; v = get(v); u = get(u); if (cnt[v] > cnt[u]) swap(v, u); ans[x] = cnt[v] * (cnt[r[v]] - cnt[v]); } for (auto x : V) add(E[x].first, E[x].second); } long long mx = 0; for (int i = 1; i < n; i++) mx = max(mx, ans[i]); long long C = 0; for (int i = 1; i < n; i++) if (ans[i] == mx) C++; cout << 2 * mx << << C << n ; for (int i = 1; i < n; i++) if (ans[i] == mx) cout << i << ; return (0); } |
#include <bits/stdc++.h> using namespace std; int main() { int n, l = 0, r = 0; cin >> n; for (int i = 0; i < n; i++) { bool a, b; cin >> a >> b; l += a; r += b; } int left = 2 * l > n ? (n - l) : l; int right = 2 * r > n ? (n - r) : r; int count = left + right; cout << count; } |
#include <bits/stdc++.h> using namespace std; using ll = long long; const ll MOD = 1e9 + 7; class SegTree { private: const ll NEUT = 0; vector<ll> seg, tag; int h = 1; ll len(int i) { return h >> (31 - __builtin_clz(i)); } void apply(int i, ll v) { seg[i] = (seg[i] + v * len(i)) % MOD; if (i < h) tag[i] = (tag[i] + v) % MOD; } void push(int i) { if (tag[i] == 0) return; apply(2 * i, tag[i]); apply(2 * i + 1, tag[i]); tag[i] = 0; } ll combine(ll a, ll b) { return (a + b) % MOD; } ll recGet(int a, int b, int i, int ia, int ib) { if (ib <= a || b <= ia) return NEUT; if (a <= ia && ib <= b) return seg[i]; push(i); int im = (ia + ib) >> 1; return combine(recGet(a, b, 2 * i, ia, im), recGet(a, b, 2 * i + 1, im, ib)); } void recApply(int a, int b, ll v, int i, int ia, int ib) { if (ib <= a || b <= ia) return; if (a <= ia && ib <= b) apply(i, v); else { push(i); int im = (ia + ib) >> 1; recApply(a, b, v, 2 * i, ia, im); recApply(a, b, v, 2 * i + 1, im, ib); seg[i] = combine(seg[2 * i], seg[2 * i + 1]); } } public: SegTree(int n) { while (h < n) h *= 2; seg.resize(2 * h, NEUT); tag.resize(h, 0); } ll rangeSum(int a, int b) { return recGet(a, b + 1, 1, 0, h); } void rangeAdd(int a, int b, ll v) { recApply(a, b + 1, v, 1, 0, h); } }; class HLD { private: vector<int> par, siz, cmp, ind; void dfs1(int i, vector<vector<int>>& g) { for (auto& t : g[i]) { if (t == par[i]) continue; par[t] = i; dfs1(t, g); siz[i] -= siz[t]; if (siz[t] > siz[g[i][0]]) swap(t, g[i][0]); } siz[i] *= -1; } void dfs2(int i, int& x, const vector<vector<int>>& g) { ind[i] = x; ++x; for (auto t : g[i]) { if (t == par[i]) continue; cmp[t] = (x == ind[i] + 1 ? cmp[i] : t); dfs2(t, x, g); } } public: HLD(vector<vector<int>> g, int r = 0) : par(g.size(), -1), siz(g.size(), -1), cmp(g.size(), r), ind(g.size()) { dfs1(r, g); int x = 0; dfs2(r, x, g); } const vector<pair<int, int>>& path(int a, int b) const { static vector<pair<int, int>> res; res.clear(); for (;; b = par[cmp[b]]) { if (ind[b] < ind[a]) swap(a, b); if (ind[cmp[b]] <= ind[a]) { res.push_back({ind[a], ind[b]}); return res; } res.push_back({ind[cmp[b]], ind[b]}); } } pair<int, int> subtree(int i) const { return {ind[i], ind[i] + siz[i] - 1}; } int lca(int a, int b) const { for (;; b = par[cmp[b]]) { if (ind[b] < ind[a]) swap(a, b); if (ind[cmp[b]] <= ind[a]) return a; } } bool deeper(int a, int b) { return siz[a] < siz[b]; } }; ll modPow(ll a, ll b) { if (b & 1) return a * modPow(a, b - 1) % MOD; if (b == 0) return 1; return modPow(a * a % MOD, b / 2); } int main() { ios_base::sync_with_stdio(false); cin.tie(0); int n; cin >> n; ll colc = 1; vector<ll> weight(n); vector<pair<int, int>> evs; for (int i = 0; i < n; ++i) { int a, b; cin >> a >> b; evs.push_back({a, i + 1}); evs.push_back({b + 1, -(i + 1)}); colc = (colc * (b - a + 1)) % MOD; weight[i] = modPow(b - a + 1, MOD - 2); } sort(evs.begin(), evs.end()); vector<vector<int>> g(n); for (int i = 0; i < n - 1; ++i) { int a, b; cin >> a >> b; --a; --b; g[a].push_back(b); g[b].push_back(a); } HLD hld(g); ll cur = 0; ll res = 0; SegTree above(n), below(n); int c = 0; for (int j = 0; j < evs.size(); ++j) { int nc = evs[j].first; res = (res + cur * (nc - c)) % MOD; c = nc; int i = abs(evs[j].second) - 1; ll v = (evs[j].second < 0 ? MOD - 1 : 1) * weight[i] % MOD; vector<pair<int, int>> path = hld.path(i, 0); int pi = n - 1; for (auto pr : path) { cur = (cur + v * below.rangeSum(pr.second + 1, pi)) % MOD; above.rangeAdd(pr.second + 1, pi, v); cur = (cur + v * above.rangeSum(pr.first, pr.second)) % MOD; below.rangeAdd(pr.first, pr.second, v); pi = pr.first - 1; } } res = (res * colc) % MOD; if (res < 0) res += MOD; cout << res << n ; } |
#include <bits/stdc++.h> using namespace std; const int MOD = 1e9 + 7, NMAX = 100010; int N, M; int color[NMAX]; vector<int> Left[NMAX], Right[NMAX]; void DFS(int node, int current_color) { if (color[node] && color[node] != current_color) { cout << 0 n ; exit(0); } if (color[node] == 0) { color[node] = current_color; for (int i = 0; i < int(Left[node].size()); ++i) DFS(Left[node][i], current_color); for (int i = 0; i < int(Right[node].size()); ++i) DFS(Right[node][i], 3 - current_color); } } int FastExponentiation(int exponent) { int base = 2, ret = 1; while (exponent) { if (exponent & 1) ret = (int64_t(ret) * base) % MOD; base = (int64_t(base) * base) % MOD; exponent >>= 1; } return ret; } int main() { ios_base::sync_with_stdio(false); int i, x, y, c; cin >> N >> M; while (M--) { cin >> x >> y >> c; c == 1 ? (Left[x].push_back(y), Left[y].push_back(x)) : (Right[x].push_back(y), Right[y].push_back(x)); } int components = 0; for (i = 1; i <= N; ++i) { if (color[i]) continue; DFS(i, 1); ++components; } cout << FastExponentiation(components - 1) << n ; return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; int current = 0; int i = 1, i2 = 2; int ans = 0; while (current + i <= n) { current += i; ans++; i += i2; i2++; } cout << ans; } |
#include <bits/stdc++.h> using namespace std; int n = 0, m = 0; char** values; bool** values1; void PrintArray() { cout << Values n ; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { cout << values[i][j] << ; } cout << endl; } cout << Values1 n ; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { cout << values1[i][j] << ; } cout << endl; } } void Check(int i, int j) { char valueToCheck = values[i][j]; if (i == n - 1) goto second; for (int i1 = i + 1; i1 < n; i1++) { if (valueToCheck == values[i1][j]) { values1[i][j] = true; values1[i1][j] = true; } } second: if (j == m - 1) return; for (int j1 = j + 1; j1 < m; j1++) { if (valueToCheck == values[i][j1]) { values1[i][j] = true; values1[i][j1] = true; } } } void ConstructString() { string result = ; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if (values1[i][j] != true) result += values[i][j]; } } cout << result; } int main() { string str, temp; cin >> n >> m; values = new char*[n + 1]; values1 = new bool*[n + 1]; for (int i = 0; i < n; i++) { values[i] = new char[m + 1]; values1[i] = new bool[m + 1]; memset(values1[i], 0, m + 1); cin >> values[i]; } for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if (values[i][j] == * ) continue; Check(i, j); } } ConstructString(); for (int i = 0; i < n; ++i) { delete[] values[i]; delete[] values1[i]; } delete[] values; return 0; } |
#include <bits/stdc++.h> using namespace std; const int Imx = 2147483647; const long long Lbig = 2e18; const int mod = 1e9 + 7; struct fastio { char s[100000]; int it, len; fastio() { it = len = 0; } inline char get() { if (it < len) return s[it++]; it = 0; len = fread(s, 1, 100000, stdin); if (len == 0) return EOF; else return s[it++]; } bool notend() { char c = get(); while (c == || c == n ) c = get(); if (it > 0) it--; return c != EOF; } } _buff; inline long long getnum() { long long r = 0; bool ng = 0; char c; c = _buff.get(); while (c != - && (c < 0 || c > 9 )) c = _buff.get(); if (c == - ) ng = 1, c = _buff.get(); while (c >= 0 && c <= 9 ) r = r * 10 + c - 0 , c = _buff.get(); return ng ? -r : r; } template <class T> inline void putnum(T x) { if (x < 0) putchar( - ), x = -x; register short a[20] = {}, sz = 0; while (x) a[sz++] = x % 10, x /= 10; if (sz == 0) putchar( 0 ); for (int i = sz - 1; i >= 0; i--) putchar( 0 + a[i]); } inline char getreal() { char c = _buff.get(); while (c <= 32) c = _buff.get(); return c; } long long qpow(long long x, long long k) { return k == 0 ? 1 : 1ll * qpow(1ll * x * x % mod, k >> 1) * (k & 1 ? x : 1) % mod; } char s[100111]; bitset<100005> ch[26], A, all; char t[100111]; int main() { scanf( %s , s); int n = strlen(s); for (int i = 0; i < n; i++) ch[s[i] - a ][i] = 1, all[i] = 1; int q; scanf( %d , &q); while (q--) { int op, x; scanf( %d%d , &op, &x); x--; if (op == 1) { char c = getchar(); while (c < a || c > z ) c = getchar(); ch[s[x] - a ][x] = 0; s[x] = c; ch[s[x] - a ][x] = 1; } else { int y; scanf( %d , &y); y--; scanf( %s , t); int l = strlen(t); A = (all >> (n - (y - x + 1) + l - 1)) << x; for (int i = 0; i < l; i++) A = (A & ch[t[i] - a ]) << 1; printf( %d n , A.count()); } } return 0; } |
#include <bits/stdc++.h> using namespace std; long long int dig(long long int n) { long long int r = 0; while (n) { ++r; n = n / 10; } return (r - 1); } long long int func(long long int n) { if (n <= 9) return (n + 1); long long int lt = dig(n); lt = pow(10, lt); long long int ret = lt - 1; long long int mul = ret / 10; long long int mid = (n % lt) / 10; lt = n / lt; long long int rt = n % 10; if (rt >= lt) { return (lt * (mul + 1) + func(ret)); } else { return (lt * (mul + 1) + func(ret)); } } long long int fun(long long int n) { if (n <= 9) return (n + 1); long long int lt = dig(n); lt = pow(10, lt); long long int ret = lt - 1; long long int mul = ret / 10; long long int mid = (n % lt) / 10; lt = n / lt; long long int rt = n % 10; if (rt >= lt) { return ((mid + 1) + (lt - 1) * (mul + 1) + func(ret)); } else { return (mid + (lt - 1) * (mul + 1) + func(ret)); } } int main() { long long int l, r; cin >> l >> r; cout << fun(r) - fun(l - 1); return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { long long int a, b, c; cin >> a >> b >> c; cout << a * b + (a + b - 1) * (c - 1); return 0; } |
#include <bits/stdc++.h> using namespace std; const double inf = 1e14; const double pi = acos(-1); const double eps = 1e-10; const int maxn = 25010; int n, x[maxn], y[maxn], dx[maxn], dy[maxn], s[maxn]; double ans = inf, ddx[maxn], ddy[maxn], K[maxn], B[maxn]; inline double solve(int a, int b) { double b1, k1, b2, k2; k1 = K[a]; b1 = B[a]; k2 = K[b]; b2 = B[b]; if (k1 == k2) { double kk = sqrt((x[a] - x[b]) * (x[a] - x[b]) + (y[a] - y[b]) * (y[a] - y[b])); double X, Y, XX, YY, t; t = kk / double(s[a] + s[b]); X = (double)x[a] + (double)ddx[a] * t * s[a]; Y = (double)y[a] + (double)ddy[a] * t * s[a]; XX = (double)x[b] + (double)ddx[b] * t * s[b]; YY = (double)y[b] + (double)ddy[b] * t * s[b]; if (abs(X - XX) <= eps && abs(Y - YY) <= eps) return t; if (s[a] == s[b]) return inf; t = kk / double(s[a]); X = (double)x[a] + (double)ddx[a] * t * s[a]; Y = (double)y[a] + (double)ddy[a] * t * s[a]; if (abs(X - x[b]) <= eps && abs(Y - y[b]) <= eps) return t; t = kk / double(s[b]); X = (double)x[b] + (double)ddx[b] * t * s[b]; Y = (double)y[b] + (double)ddy[b] * t * s[b]; if (abs(X - x[a]) <= eps && abs(Y - y[a]) <= eps) return t; return inf; } double X = (b2 - b1) / (k1 - k2), Y; Y = k1 * X + b1; if ((Y - y[a]) * dy[a] < 0) return inf; if ((Y - y[b]) * dy[b] < 0) return inf; if ((X - x[a]) * dx[a] < 0) return inf; if ((X - x[b]) * dx[b] < 0) return inf; double now1 = sqrt((X - x[a]) * (X - x[a]) + (Y - y[a]) * (Y - y[a])) / s[a]; double now2 = sqrt((X - x[b]) * (X - x[b]) + (Y - y[b]) * (Y - y[b])) / s[b]; return max(now1, now2); } int main() { scanf( %d , &n); for (int i = 1; i <= n; ++i) { scanf( %d%d%d%d%d , &x[i], &y[i], &dx[i], &dy[i], &s[i]); double v = sqrt(dx[i] * dx[i] + dy[i] * dy[i]); ddx[i] = dx[i] / v; ddy[i] = dy[i] / v; K[i] = (double)dy[i] / dx[i]; B[i] = y[i] - (double)dy[i] / dx[i] * x[i]; } for (int i = 1; i <= n; ++i) for (int j = i + 1; j <= n; ++j) { ans = min(ans, solve(i, j)); } if (ans > 1e12) printf( No show :( n ); else printf( %.15f n , ans); return 0; } |
#include<iostream> typedef long long ll; using namespace std; const int maxn =1e5+5; int n,q; ll sum[maxn]; string s; int main() { cin>>n>>q; cin>>s; s = # +s; for(int i=1;i<=n;i++) sum[i] = sum[i-1]+s[i]- a +1; while (q--) { int l,r; cin>>l>>r; cout<<sum[r]-sum[l-1]<<endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; int n, a[100010]; int la, ra; void update(int i, int delta) { for (; i < n; i = i | (i + 1)) { a[i] += delta; } } int get(int fr, int to) { int res = 0; for (int i = to; i >= 0; i = (i & (i + 1)) - 1) { res += a[i]; } for (int i = fr - 1; i >= 0; i = (i & (i + 1)) - 1) { res -= a[i]; } return res; } int main(void) { int q; scanf( %d%d , &n, &q); for (int i = 0; i < n; ++i) { update(i, 1); } int la = 0; int ra = n; for (int i = 0; i < q; ++i) { int t; scanf( %d , &t); if (t == 1) { int p, len, mid; scanf( %d , &p); if (la < ra) { len = ra - la; mid = la + p; } else { len = la - ra; mid = la - p; } if (p > len / 2) { swap(la, ra); p = len - p; } if (la < ra) { for (int i = 0; i < p; ++i) { update(mid + i, get(mid - 1 - i, mid - 1 - i)); } } else { for (int i = 0; i < p; ++i) { update(mid - 1 - i, get(mid + i, mid + i)); } } la = mid; } else { int l, r; scanf( %d%d , &l, &r); if (la < ra) { l += la; r += la; } else { l = la - l; r = la - r; swap(l, r); } printf( %d n , get(l, r - 1)); } } return 0; } |
#include <bits/stdc++.h> using namespace std; const short maxn = 5000 + 5; const int mod = 1000000000 + 7; int n; short x[maxn], y[maxn]; short d[maxn][maxn]; short md; char col[maxn]; void dfs(int x) { for (int i = 0, _n = (int)(n); i < _n; i++) if (d[x][i] > md) { if (col[x] == col[i]) throw 0; if (col[i]) continue; col[i] = 3 - col[x]; dfs(i); } } int cnt() { memset(col, 0, sizeof col); int r = 1; for (int i = 0, _n = (int)(n); i < _n; i++) if (col[i] == 0) { col[i] = 1; try { dfs(i); } catch (...) { return 0; } (r += r) >= mod ? r -= mod : 0; } return r; } int main() { ios::sync_with_stdio(false); cin >> n; for (int i = 0, _n = (int)(n); i < _n; i++) cin >> x[i] >> y[i]; for (int i = 0, _n = (int)(n); i < _n; i++) for (int j = (int)(i + 1), _n = (int)(n); j < _n; j++) d[i][j] = d[j][i] = abs(x[i] - x[j]) + abs(y[i] - y[j]); short lo = -1, hi = 10000; while (lo + 1 < hi) { md = (lo + hi) / 2; if (cnt() != 0) hi = md; else lo = md; } md = hi; cout << hi << endl << cnt() << endl; { int _; cin >> _; } } |
#include <bits/stdc++.h> using namespace std; long long n, A, B; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cin >> n; while (n--) { cin >> A >> B; cout << A * (long long)log10(B + 1) << endl; } } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.