Datasets:
malteklaes
/
cpp-code-code_search_net-style

Dataset card Data Studio Files Community
1
func_code_string
stringlengths
59
71.4k
#include <bits/stdc++.h> using namespace std; int n, k; pair<int, int> d[3] = {{0, 1}, {1, 0}, {1, 1}}; int b[550][550]; void rec(int k) { if (k == 1) { b[0][0] = 1; return; } rec(k /= 2); for (int c = 0; c < 3; c++) { for (int i = 0; i < k; i++) { for (int j = 0; j < k; j++) { b[i + d[c].first * k][j + d[c].second * k] = !b[i][j]; } } } } int main() { cin >> k; n = pow(2, k); rec(n); for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) cout << (b[i][j] ? + : * ); cout << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; const int inf = 0x7FFFFFFF; template <class T> T gcd(T a, T b) { return b == 0 ? a : gcd(b, a % b); } template <typename T> T lcm(T a, T b) { return a / gcd(a, b) * b; } template <class T> T big_mod(T n, T p, T m) { if (p == 0) return (T)1; T x = big_mod(n, p / 2, m); x = (x * x) % m; if (p & 1) x = (x * n) % m; return x; } template <class T> T my_pow(T n, T p) { if (p == 0) return 1; T x = my_pow(n, p / 2); x = (x * x); if (p & 1) x = (x * n); return x; } template <class T> inline T Mod(T n, T m) { return (n % m + m) % m; } template <class T> T MIN(T a, T b, T c) { return min(a, min(b, c)); } template <class T> T MAX(T a, T b, T c) { return max(a, max(b, c)); } int n, m, segment[10000]; int main() { cin >> n >> m; for (int i = 1; i <= m; i++) { int x, y; cin >> x >> y; for (int j = x; j <= y; j++) { segment[j]++; } } for (int i = 1; i <= n; i++) { if (segment[i] != 1) { printf( %d %d n , i, segment[i]); return 0; } } printf( OK n ); return 0; }
#include <bits/stdc++.h> #pragma GCC optimize( Ofast ) using namespace std; long long cp[200010]; long long find(long long x) { return cp[x] = cp[x] == x ? x : find(cp[x]); } void union_(long long x, long long y) { cp[find(x)] = find(y); } int32_t main() { ios::sync_with_stdio(false); cin.tie(0); for (long long j = 0; j < 200010; ++j) cp[j] = j; long long m, n; cin >> m >> n; vector<long long> A(m); vector<long long> B(n); for (long long i = 0; i < m; ++i) cin >> A[i]; for (long long i = 0; i < n; ++i) cin >> B[i]; vector<pair<long long, pair<long long, long long>>> edg; for (long long u = 0; u < m; ++u) { long long s; cin >> s; for (long long i = 0; i < s; ++i) { long long v; cin >> v; edg.push_back({B[v - 1] + A[u], {u, v - 1ll}}); } } sort((edg).begin(), (edg).end()); reverse((edg).begin(), (edg).end()); long long ans = 0; for (long long k = 0; k < edg.size(); ++k) { long long u = edg[k].second.first, v = edg[k].second.second + m; if (find(u) == find(v)) { ans += edg[k].first; } else { union_(u, v); } } cout << ans << n ; }
#include <bits/stdc++.h> using namespace std; const int DIM = 1e5 + 5; int szt[DIM], ans[DIM]; vector<int> edg[DIM]; map<int, int> son, par, out; void dfs1(int x, int sz) { szt[x] = 1; for (int y : edg[x]) { dfs1(y, sz); szt[x] += szt[y]; } out[szt[x]]++; ans[x] = sz - 1; return; } void add(map<int, int> &mmp, int x, int val) { mmp[x] += val; out[x] -= val; if (!mmp[x]) mmp.erase(x); if (!out[x]) out.erase(x); return; } void bns(map<int, int> &mmp, int x, int le, int ri, int mnm, int aux) { int val = ri, sol = ri; while (le <= ri) { int md = (le + ri) >> 1; map<int, int>::iterator it = mmp.lower_bound(val - md + aux); if (it == mmp.end() || it->first + mnm > md + aux) le = md + 1; else ri = md - 1, sol = min(sol, md); } ans[x] = min(ans[x], sol); return; } void dfs3(int x, int val, int pos) { add(son, szt[x], val); for (int y : edg[x]) if (y != pos) dfs3(y, val, pos); return; } void dfs2(int x, int sz, bool oki) { int mxm1(-1), mxm2(-1), pos(-1), mnm(sz - 1); add(par, szt[x], 1); for (int y : edg[x]) { mnm = min(mnm, szt[y]); if (mxm1 < szt[y]) mxm2 = mxm1, mxm1 = szt[y], pos = y; else mxm2 = max(mxm2, szt[y]); } if (szt[x] != sz) mnm = min(mnm, sz - szt[x]); for (int y : edg[x]) if (y != pos) dfs2(y, sz, false); if (pos != -1) dfs2(pos, sz, true); if (mxm1 >= sz - szt[x]) { mxm2 = max(mxm2, sz - szt[x]); if (mnm != sz - 1) bns(son, x, mxm2, mxm1, mnm, 0); } dfs3(x, 1, pos); add(par, szt[x], -1); if (mxm1 <= sz - szt[x] && mnm != sz - 1) { bns(par, x, mxm1, sz - szt[x], mnm, szt[x]); bns(out, x, mxm1, sz - szt[x], mnm, 0); } if (!oki) dfs3(x, -1, -1); return; } int main(void) { int n, r(-1); scanf( %d , &n); for (int i = 1; i <= n; ++i) { int x, y; scanf( %d %d , &x, &y); if (x == 0) r = y; else edg[x].push_back(y); } dfs1(r, n); dfs2(r, n, true); for (int i = 1; i <= n; ++i) printf( %d n , ans[i]); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { long n; while (cin >> n) { string s; cin >> s; long a[10010] = {0}, x = 0, c = 0, l; l = s.size(); for (int i = 0; i < l; i++) { if (i % 2 == 0) { a[s[i]]++; } else { x = s[i] + 32; if (a[x] > 0) { a[x]--; } else c++; } } cout << c << n ; } return 0; }
#include <bits/stdc++.h> using namespace std; const long long maxN = 1e6 + 5; const long long inf = 1e10; const long long mod = 1e9 + 7; long long n; long long x[maxN]; long long a, b; int main() { ios_base::sync_with_stdio(0); cin >> n; for (long long i = 1; i <= n; i++) cin >> x[i]; cin >> a >> b; sort(x + 1, x + 1 + n); n = unique(x + 1, x + 1 + n) - (x + 1); long long res = 0; while (a > b) { long long next = a - 1; for (long long i = 1; i <= n; i++) { long long tmp = a - a % x[i]; if (tmp < b) { x[i--] = x[--n]; } else if (tmp < next) next = tmp; } a = next; res++; } cout << res; return 0; }
/// By: CooloTran #include <bits/stdc++.h> using namespace std; using ll = long long; using ull = unsigned long long; using str = string; #define st first #define nd second #define pb push_back #define pf push_front #define lb lower_bound #define ub upper_bound #define er equal_range #define file TEST ll gcd(ll a, ll b) { if (b == 0) return a; return gcd(b, a % b); } ll lcm(ll a, ll b) { return a / gcd(a, b) * b; } ll MULMOD(ll a, ll b, ll n) { if (b == 0) return 0; ll tmp = MULMOD(a, b >> 1, n); if (b & 1) return (tmp * 2 % n + a) % n; return tmp * 2 % n; } int n; ll a[200005], cur = 0; signed main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); // freopen(file .INP , r , stdin); // freopen(file .OUT , w , stdout); cin >> n; for (int i = 1; i <= n; ++i) cin >> a[i]; priority_queue<int, vector<int>, greater<int> > pq; for (int i = 1; i <= n; ++i) { if (cur + a[i] >= 0) { cur += a[i]; pq.push(a[i]); } else { if (pq.empty()) continue; ll tmp = pq.top(); pq.pop(); if (tmp < a[i]) { pq.push(a[i]); cur += a[i] - tmp; } else pq.push(tmp); } } cout << pq.size() << n ; return 0; }
#include <bits/stdc++.h> int cmp(const void* a, const void* b); int main() { long long t = 1; while (t--) { long long n, n1, n2; scanf( %lld%lld%lld , &n, &n1, &n2); long long arr[n]; for (long long i = 0; i < n; i++) { scanf( %lld , &arr[i]); } qsort(arr, n, sizeof(arr[0]), cmp); double s1 = 0, s2 = 0; if (n2 < n1) { long long x = n2; n2 = n1; n1 = x; } if (1) { for (long long i = 0; i < n1; i++) s1 += arr[i]; for (long long i = n1; i < n1 + n2; i++) s2 += arr[i]; } printf( %f n , s1 / n1 + s2 / n2); } return 0; } int cmp(const void* a, const void* b) { return (*(int*)b - *(int*)a); }
#include <bits/stdc++.h> using namespace std; int main() { long long n, k; cin >> n >> k; long long a[k + 1]; for (long long i = 0; i < k; i++) { cin >> a[i]; } long long c4 = n, c2 = 2 * n; long long o1 = 0; for (long long i = 0; i < k; i++) { while (c4 > 0 && a[i] > 3) { c4 -= 1; a[i] -= 4; } while (c2 >= 2 && a[i] > 3) { c2 -= 2; a[i] -= 4; } if (a[i] >= 3) { while (c4 > 0 && a[i] > 0) { c4 -= 1; a[i] -= 3; } while (c2 >= 2 && a[i] > 0) { c2 -= 2; a[i] -= 3; } } if (a[i] >= 2) { while (c2 > 0 && a[i] > 0) { c2 -= 1; a[i] -= 2; } while (c4 > 0 && a[i] > 0) { c4 -= 1; o1++; a[i] -= 2; } } if (a[i] > 0) { while (o1 > 0 && a[i] > 0) { o1--; a[i]--; } while (c4 > 0 && a[i] > 0) { c4 -= 1; a[i] -= 1; c2++; } while (a[i] > 0 && c2 > 0) { c2 -= 1; a[i] -= 1; } } if (a[i] > 0) { cout << NO << endl; return 0; } } cout << YES << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int i, num = 0; for (i = 1; i <= 5; i++) { int temp; scanf( %d , &temp); num += temp; } if (num % 5 || num == 0) { printf( -1 n ); } else { printf( %d n , num / 5); } return 0; }
#include <bits/stdc++.h> using namespace std; string s; int main() { ios_base::sync_with_stdio(false); cin >> s; bool f = false; for (int i = 0; i < s.size() / 2; i++) if (s[0] != s[i] or s[0] != s[s.size() - i - 1]) { f = true; break; } if (!f) { cout << Impossible << endl; return 0; } for (int i = 1; i < s.size() - 1; i++) { string v = s.substr(i, s.size() - i) + s.substr(0, i); string w = v; reverse(w.begin(), w.end()); if (v == w and v != s) { cout << 1 << endl; return 0; } } cout << 2 << endl; return 0; }
#include <bits/stdc++.h> static const int MaxSize = 1e5; int tree[4 * MaxSize][2]; static void build(std::vector<int> &v, int vertex, int tl, int tr) { if (tl == tr) tree[vertex][0] = v[tl]; else { int tm = (tl + tr) / 2; build(v, 2 * vertex + 1, tl, tm + 0); build(v, 2 * vertex + 2, tm + 1, tr); tree[vertex][0] = std::min(tree[2 * vertex + 1][0], tree[2 * vertex + 2][0]); } } static void update(int vertex, int tl, int tr, int l, int r, int x) { if (l > r) return; if (l == tl && tr == r) tree[vertex][1] += x; else { int tm = (tl + tr) / 2; update(2 * vertex + 1, tl, tm + 0, l, std::min(r, tm + 0), x); update(2 * vertex + 2, tm + 1, tr, std::max(l, tm + 1), r, x); tree[vertex][0] = std::min(tree[2 * vertex + 1][0] + tree[2 * vertex + 1][1], tree[2 * vertex + 2][0] + tree[2 * vertex + 2][1]); } } static int get(int vertex, int tl, int tr, int l, int r, int x) { if (l == tl && tr == r) return tree[vertex][0] + tree[vertex][1]; x += tree[vertex][1]; int tm = (tl + tr) / 2; return std::min( x + get(2 * vertex + 1, tl, tm + 0, l, std::min(r, tm + 0), x), x + get(2 * vertex + 2, tm + 1, tr, std::max(l, tm + 1), r, x)); } static void build(std::vector<int> &v, int n) { build(v, 0, 0, n - 1); } static void update(int n, int l, int r, int x) { update(0, 0, n - 1, l, r, x); } static int get(int n, int l, int r) { return get(0, 0, n - 1, l, r, 0); } int main(int argc, const char *argv[]) { std::ios_base::sync_with_stdio(false); std::cin.tie(NULL); int n, m; std::cin >> n >> m; std::vector<int> v(n), tree(4 * n); for (int i = 0; i < n; i++) std::cin >> v[i]; std::vector<std::pair<int, int>> p(m); for (int i = 0; i < m; i++) { std::cin >> p[i].first >> p[i].second; p[i].first--; p[i].second--; } build(v, n); std::vector<bool> used(m); std::vector<int> t(4 * n), r; int result = 0; for (int i = 0; i < n; i++) { std::vector<int> intervals; for (int j = 0; j < m; j++) { if (p[j].first <= i && i <= p[j].second) { if (used[j]) { used[j] = false; update(n, p[j].first, p[j].second, 1); } } else { if (!used[j]) update(n, p[j].first, p[j].second, -1); intervals.push_back(j + 1); used[j] = true; } } int curr = v[i] - get(n, 0, n - 1); if (result < curr) { result = curr; std::swap(r, intervals); } } std::cout << result << std::endl; std::cout << r.size() << std::endl; if (r.size() > 0) { for (int number : r) std::cout << number << ; std::cout << std::endl; } return 0; }
#include <bits/stdc++.h> using namespace std; int solveA(pair<pair<int, int>, int> x, pair<pair<int, int>, int> y, pair<pair<int, int>, int> z) { pair<int, int> a = x.first; pair<int, int> b = y.first; pair<int, int> c = z.first; int n = a.first + b.first + c.first; if (n != a.second) return -1; if (n != b.second) return -1; if (n != c.second) return -1; cout << n << n ; for (int i = 1; i <= a.first; ++i) { for (int j = 1; j <= a.second; ++j) { cout << (char)( A + x.second); } cout << n ; } for (int i = 1; i <= b.first; ++i) { for (int j = 1; j <= b.second; ++j) { cout << (char)( A + y.second); } cout << n ; } for (int i = 1; i <= c.first; ++i) { for (int j = 1; j <= c.second; ++j) { cout << (char)( A + z.second); } cout << n ; } return n; } int solveB(pair<pair<int, int>, int> x, pair<pair<int, int>, int> y, pair<pair<int, int>, int> z) { pair<int, int> a = x.first; pair<int, int> b = y.first; pair<int, int> c = z.first; int n = a.first; if (n != b.first + c.first) return -1; if (n != b.second + a.second) return -1; if (n != c.second + a.second) return -1; cout << n << n ; for (int i = 1; i <= a.second; ++i) { for (int j = 1; j <= n; ++j) { cout << (char)( A + x.second); } cout << n ; } for (int i = 1; i <= b.second; ++i) { for (int j = 1; j <= b.first; ++j) { cout << (char)( A + y.second); } for (int j = 1; j <= c.first; ++j) { cout << (char)( A + z.second); } cout << n ; } return n; } int main(int argc, const char* argv[]) { pair<int, int> a[3]; cin >> a[0].first >> a[0].second; cin >> a[1].first >> a[1].second; cin >> a[2].first >> a[2].second; pair<pair<int, int>, int> b[3]; for (int i = 0; i < 8; ++i) { if (i & 1) b[0].first = a[0]; else b[0].first = make_pair(a[0].second, a[0].first); if (i >> 1 & 1) b[1].first = a[1]; else b[1].first = make_pair(a[1].second, a[1].first); if (i >> 2 & 1) b[2].first = a[2]; else b[2].first = make_pair(a[2].second, a[2].first); for (int i = 0; i <= 2; ++i) { b[i].second = i; } sort(b, b + 3); do { int n; n = solveA(b[0], b[1], b[2]); if (n != -1) { return 0; } n = solveB(b[0], b[1], b[2]); if (n != -1) { return 0; } } while (next_permutation(b, b + 3)); } cout << -1; return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 3005; const int inf = 5e8; vector<int> to[N], from[N]; int d[N][N], b[N][N]; vector<pair<int, int>> go[N], back[N]; bool done[N]; int n; void bfs(vector<int>* edge, int dist[N][N], vector<pair<int, int>>* ret) { for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { dist[i][j] = -inf; } } for (int i = 1; i <= n; i++) { memset(done, 0, sizeof(done)); queue<int> q; done[i] = 1; q.push(i); dist[i][i] = 0; while (!q.empty()) { int now = q.front(); q.pop(); for (auto it : edge[now]) { if (!done[it]) { done[it] = 1; dist[i][it] = dist[i][now] + 1; q.push(it); } } } } for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { if (i != j) { ret[i].emplace_back(dist[i][j], j); } } sort(ret[i].begin(), ret[i].end()); reverse(ret[i].begin(), ret[i].end()); } } pair<int, int> get(int p, vector<pair<int, int>>* ret, vector<int>& ojo) { for (auto it : ret[p]) { bool ada = 0; for (auto j : ojo) { if (it.second == j) { ada = 1; break; } } if (!ada) return it; } return {-inf, -inf}; } int main() { int m; scanf( %d %d , &n, &m); while (m--) { int u, v; scanf( %d %d , &u, &v); to[u].push_back(v); from[v].push_back(u); } bfs(to, d, go); bfs(from, b, back); int ans = -inf, ai, aj, ak, al; for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { assert(d[i][j] == b[j][i]); if (i == j) continue; vector<int> ojo = {i, j}; pair<int, int> lef = get(i, back, ojo); pair<int, int> rig = get(j, go, ojo); vector<int> tmp; if (lef.second == rig.second) { tmp = {i, j, lef.second}; pair<int, int> l = get(i, back, tmp); int cur = d[i][j] + l.first + rig.first; if (cur > ans) { ans = cur; ai = l.second; aj = i; ak = j; al = rig.second; } pair<int, int> r = get(j, go, tmp); cur = d[i][j] + lef.first + r.first; if (cur > ans) { ans = cur; ai = lef.second; aj = i; ak = j; al = r.second; } } else { int cur = d[i][j] + lef.first + rig.first; if (cur > ans) { ans = cur; ai = lef.second; aj = i; ak = j; al = rig.second; } } } } printf( %d %d %d %d n , ai, aj, ak, al); return 0; }
#include <bits/stdc++.h> using namespace std; int dr[] = {-1, -1, -1, 0, 0, 1, 1, 1}; int dc[] = {-1, 0, 1, -1, 1, -1, 0, 1}; struct node { int r, c, dist; node() {} node(int _r, int _c, int _dist) : r(_r), c(_c), dist(_dist) {} }; set<pair<int, int> > valid, visited; int main() { int r0, c0, r1, c1, n; int i, j, r, a, b; scanf( %d%d%d%d%d , &r0, &c0, &r1, &c1, &n); for (i = 1; i <= n; ++i) { scanf( %d%d%d , &r, &a, &b); for (j = a; j <= b; ++j) valid.insert(make_pair(r, j)); } int ans = -1; queue<node> Q; Q.push(node(r0, c0, 0)); visited.insert(make_pair(r0, c0)); while (Q.size() > 0) { node cur = Q.front(); Q.pop(); if (cur.c == c1 && cur.r == r1) { ans = cur.dist; break; } for (i = 0; i < 8; ++i) { int r2 = cur.r + dr[i]; int c2 = cur.c + dc[i]; if (valid.find(make_pair(r2, c2)) != valid.end() && visited.find(make_pair(r2, c2)) == visited.end()) { visited.insert(make_pair(r2, c2)); Q.push(node(r2, c2, cur.dist + 1)); } } } printf( %d , ans); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int a, b; cin >> a >> b; vector<int> arr; arr.push_back(b); while (b > a) { if (b % 10 == 1) arr.push_back(b /= 10); else if (b % 2 == 1) { cout << NO << endl; return 0; } else arr.push_back(b /= 2); } if (arr.back() != a) { cout << NO << endl; return 0; } cout << YES n << arr.size() << endl; for (auto it = arr.rbegin(); it != arr.rend(); ++it) cout << *it << ; }
#include <bits/stdc++.h> using namespace std; template <class T> inline bool chmax(T &a, T b) { if (a < b) { a = b; return true; } return false; } template <class T> inline bool chmin(T &a, T b) { if (a > b) { a = b; return true; } return false; } const long long INF = 1e18; int N, K; vector<int> vertex; vector<int> d[200]; set<pair<int, int>> st; vector<int> g[30000]; int dist[200][30000]; void dfs(int idx, int now, int from) { for (auto to : g[now]) { if (to == from) continue; dist[idx][to] = dist[idx][now] + 1; dfs(idx, to, now); } } set<int> appear; map<int, vector<pair<int, int>>> children; struct UnionFind { vector<int> par; vector<int> rank; vector<long long> Size; UnionFind(int n = 1) { init(n); } void init(int n = 1) { par.resize(n + 1); rank.resize(n + 1); Size.resize(n + 1); for (int i = 0; i <= n; ++i) par[i] = i, rank[i] = 0, Size[i] = 1; } int root(int x) { if (par[x] == x) { return x; } else { int r = root(par[x]); return par[x] = r; } } bool issame(int x, int y) { return root(x) == root(y); } bool merge(int x, int y) { x = root(x); y = root(y); if (x == y) return false; if (rank[x] < rank[y]) swap(x, y); if (rank[x] == rank[y]) ++rank[x]; par[y] = x; Size[x] += Size[y]; return true; } long long size(int x) { return Size[root(x)]; } }; int match[30000]; int TL = 2980; int main() { cin.tie(0); ios::sync_with_stdio(false); auto start = chrono::steady_clock::now(); int nowtimer; cin >> N >> K; vertex.resize(K, -1); for (int k = 0; k < K; k++) { d[k].resize(N); for (int i = 0; i < N; i++) { cin >> d[k][i]; if (d[k][i] == 0) { if (vertex[k] != -1) { cout << -1 << endl; return 0; } else { vertex[k] = i; } } } if (vertex[k] == -1) { cout << -1 << endl; return 0; ; } appear.insert(vertex[k]); } for (int k = 1; k < K; k++) { int mini = d[0][vertex[k]]; vector<int> v(mini + 1, -1); for (int i = 0; i < N; i++) { if (d[0][i] + d[k][i] < mini) { cout << -1 << endl; } if (d[0][i] + d[k][i] == mini) { if (v[d[0][i]] != -1) { cout << -1 << endl; return 0; ; } v[d[0][i]] = i; } } for (int i = 0; i <= mini; i++) { if (v[i] == -1) { cout << -1 << endl; return 0; ; } } for (int i = 0; i < mini; i++) { int a = v[i]; int b = v[i + 1]; if (a > b) swap(a, b); st.insert({a, b}); } } UnionFind uni(N); for (auto tmp : st) { if (!uni.merge(tmp.first, tmp.second)) { cout << -1 << endl; return 0; } else { g[tmp.first].push_back(tmp.second); g[tmp.second].push_back(tmp.first); appear.insert(tmp.first); appear.insert(tmp.second); } } vector<pair<vector<int>, int>> mp; for (int i = 0; i < N; i++) { if (appear.find(i) == appear.end()) continue; vector<int> v(K); int mini = 1e9; for (int j = 0; j < K; j++) { v[j] = d[j][i]; chmin(mini, v[j]); } for (int j = 0; j < K; j++) { v[j] -= mini; } mp.push_back({v, i}); } mp.push_back({{999999999}, -1}); sort(mp.begin(), mp.end()); vector<pair<vector<int>, int>> sub; for (int i = 0; i < N; i++) { if (appear.find(i) != appear.end()) continue; vector<int> v(K); int mini = 1e9; for (int j = 0; j < K; j++) { v[j] = d[j][i]; chmin(mini, v[j]); } for (int j = 0; j < K; j++) { v[j] -= mini; } sub.push_back({v, i}); } sort(sub.begin(), sub.end()); int idx = 0; if ((nowtimer = chrono::duration_cast<chrono::milliseconds>( chrono::steady_clock::now() - start) .count()) > TL) { assert(0); } for (int i = 0; i < sub.size(); i++) { if ((nowtimer = chrono::duration_cast<chrono::milliseconds>( chrono::steady_clock::now() - start) .count()) > TL) { return 0; } while (mp[idx].first < sub[i].first) idx++; if (mp[idx].first == sub[i].first) { match[sub[i].second] = mp[idx].second; } else { cout << -1 << endl; return 0; } } for (int i = 0; i < N; i++) { if (appear.find(i) != appear.end()) continue; int p = match[i]; int len = d[0][i] - d[0][p]; if (len <= 0) { cout << -1 << endl; return 0; } children[p].push_back({len, i}); } for (int i = 0; i < N; i++) { if (children[i].empty()) continue; auto v = children[i]; sort(v.begin(), v.end()); if (v[0].first != 1) { cout << -1 << endl; return 0; } int Last = i; st.insert({i, v[0].second}); g[Last].push_back(v[0].second); g[v[0].second].push_back(Last); for (int i = 1; i < v.size(); i++) { if (v[i].first > v[i - 1].first + 1) { cout << -1 << endl; return 0; } else if (v[i].first == v[i - 1].first) { st.insert({Last, v[i].second}); g[Last].push_back(v[i].second); g[v[i].second].push_back(Last); } else { Last = v[i - 1].second; st.insert({Last, v[i].second}); g[Last].push_back(v[i].second); g[v[i].second].push_back(Last); } } } for (int i = 0; i < K; i++) { dfs(i, vertex[i], -1); for (int j = 0; j < N; j++) { if (dist[i][j] != d[i][j]) { cout << -1 << endl; return 0; } } } for (auto e : st) { cout << e.first + 1 << << e.second + 1 << endl; } return 0; }
#include <bits/stdc++.h> int main() { int num; scanf( %d , &num); int res = 0; for (int i = 0; i < num; i++) { char shape[30]; scanf( %s , shape); switch (shape[0]) { case T : res += 4; break; case C : res += 6; break; case O : res += 8; break; case D : res += 12; break; case I : res += 20; break; } } printf( %d n , res); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { long long n, len, vf, va, k; cin >> n >> len >> vf >> va >> k; long long bl = (n + k - 1) / k; double eff = static_cast<double>(va - vf) / (va + vf); double koef = (va + (bl + (bl - 1) * eff - 1) * vf); double ta = len / koef; double ans = ta * (bl + (bl - 1) * eff); cout << setprecision(15) << ans << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int a[] = { 0, 4784, 4194, 4003, 3920, 3831, 3791, 3726, 3667, 3669, 3591, 3642, 3612, 3532, 3554, 3507, 3500, 3517, 3449, 3496, 3432, 3462, 3406, 3394, 3376, 3378, 3445, 3362, 3368, 3371, 3305, 3369, 3386, 3336, 3320, 3302, 3273, 3356, 3286, 3307, 3284, 3327, 3291, 3247, 3251, 3306, 3241, 3278, 3231, 3271, 3248, 3239, 3184, 3227, 3204, 3235, 3210, 3216, 3191, 3211, 3222, 3193, 3206, 3234, 3157, 3149, 3191, 3188, 3193, 3225, 3192, 3182, 3138, 3152, 3135, 3106, 3167, 3211, 3130, 3141, 3137, 3125, 3129, 3135, 3122, 3125, 3160, 3154, 3168, 3106, 3117, 3076, 3149, 3118, 3135, 3063, 3171, 3091, 3103, 3099, 3075, 3087, 3126, 3071, 3086, 3114, 3074, 3101, 3069, 3091, 3080, 3080, 3101, 3067, 3111, 3079, 3117, 3093, 3089, 3103, 3073, 3040, 3054, 3122, 3079, 3021, 3024, 3098, 3068, 3057, 3013, 3014, 3077, 3020, 3073, 3038, 3027, 3039, 3044, 3061, 3012, 2998, 3043, 3054, 3066, 3018, 3025, 3037, 3035, 3015, 3010, 3004, 3014, 3018, 2931, 2994, 3015, 3025, 3032, 3075, 3031, 2990, 2994, 3030, 2994, 3050, 2997, 2973, 3008, 3017, 3034, 2998, 2962, 3052, 2980, 2996, 3025, 3000, 2994, 2973, 3022, 2961, 2981, 3039, 2964, 2968, 2941, 3016, 2992, 3014, 2978, 2983, 3006, 2970, 2968, 2999, 2936, 2985, 2983, 2950, 3034, 2953, 2964, 2930, 2950, 2965, 2996, 2968, 2960, 2962, 2952, 2972, 2933, 3012, 2982, 3002, 2904, 2965, 2963, 2974, 3012, 2915, 2921, 2947, 2908, 2934, 2998, 2925, 2951, 2971, 2936, 2986, 2949, 2951, 2958, 2936, 2930, 2957, 2895, 2926, 2934, 2899, 2971, 3011, 2951, 2937, 2925, 2916, 2968, 2931, 2927, 2944, 2913, 2902, 2936, 2912, 2925, 2955, 2939, 2936, 2912, 2935, 2905, 2928, 2956, 2968, 2923, 2953, 2902, 2938, 2928, 2928, 2902, 2886, 2942, 2873, 2980, 2886, 2911, 2920, 2922, 2968, 2876, 2924, 2904, 2952, 2885, 2910, 2924, 2901, 2928, 2887, 2887, 2961, 2911, 2882, 2896, 2897, 2874, 2941, 2958, 2898, 2926, 2916, 2933, 2873, 2969, 2886, 2907, 2938, 2845, 2855, 2898, 2883, 2900, 2902, 2887, 2889, 2877, 2905, 2879, 2901, 2891, 2867, 2867, 2869, 2906, 2888, 2893, 2870, 2921, 2878, 2910, 2914, 2864, 2879, 2898, 2841, 2919, 2943, 2856, 2817, 2837, 2899, 2823, 2901, 2878, 2824, 2888, 2880, 2906, 2855, 2854, 2907, 2902, 2862, 2859, 2918, 2890, 2835, 2847, 2898, 2844, 2923, 2857, 2884, 2917, 2840, 2875, 2831, 2880, 2907, 2916, 2859, 2861, 2831, 2841, 2871, 2854, 2898, 2849, 2905, 2896, 2903, 2868, 2835, 2845, 2853, 2926, 2874, 2849, 2832, 2876, 2859, 2885, 2887, 2853, 2913, 2828, 2842, 2820, 2900, 2805, 2866, 2860, 2877, 2834, 2852, 2923, 2817, 2850, 2840, 2884, 2796, 2860, 2885, 2826, 2842, 2842, 2843, 2799, 2817, 2871, 2909, 2841, 2853, 2791, 2809, 2854, 2815, 2832, 2818, 2866, 2800, 2872, 2877, 2865, 2774, 2846, 2881, 2890, 2847, 2805, 2869, 2789, 2850, 2828, 2844, 2850, 2846, 2827, 2821, 2783, 2882, 2855, 2823, 2845, 2853, 2821, 2840, 2792, 2822, 2788, 2859, 2846, 2819, 2805, 2890, 2830, 2846, 2881, 2755, 2890, 2829, 2813, 2862, 2820, 2835, 2828, 2871, 2810, 2840, 2826, 2778, 2865, 2835, 2837, 2809, 2800, 2840, 2826, 2836, 2807, 2829, 2834, 2822, 2843, 2815, 2806, 2861, 2805, 2786, 2842, 2792, 2813, 2841, 2840, 2817, 2827, 2795, 2816, 2780, 2799, 2796, 2897, 2789, 2820, 2738, 2852, 2791, 2818, 2863, 2787, 2765, 2826, 2773, 2820, 2823, 2817, 2784, 2812, 2770, 2814, 2856, 2793, 2778, 2781, 2822, 2779, 2809, 2850, 2793, 2835, 2765, 2790, 2760, 2869, 2785, 2801, 2769, 2866, 2861, 2767, 2812, 2767, 2790, 2765, 2841, 2805, 2816, 2811, 2808, 2894, 2762, 2769, 2810, 2756, 2848, 2802, 2760, 2762, 2776, 2802, 2837, 2832, 2802, 2813, 2785, 2757, 2828, 2785, 2791, 2765, 2781, 2835, 2755, 2835, 2779, 2784, 2802, 2765, 2765, 2800, 2756, 2746, 2808, 2797, 2802, 2800, 2830, 2795, 2793, 2772, 2783, 2822, 2839, 2768, 2826, 2800, 2797, 2776, 2769, 2727, 2790, 2774, 2821, 2716, 2761, 2788, 2755, 2812, 2854, 2782, 2796, 2789, 2746, 2762, 2767, 2807, 2770, 2774, 2784, 2805, 2744, 2805, 2772, 2761, 2768, 2844, 2807, 2778, 2792, 2812, 2842, 2775, 2773, 2728, 2792, 2757, 2783, 2777, 2831, 2752, 2829, 2711, 2844, 2745, 2803, 2774, 2780, 2752, 2791, 2809, 2749, 2806, 2771, 2777, 2801, 2768, 2725, 2786, 2728, 2779, 2792, 2809, 2820, 2767, 2745, 2771, 2768, 2815, 2729, 2783, 2791, 2766, 2807, 2753, 2769, 2811, 2743, 2764, 2783, 2807, 2713, 2813, 2769, 2777, 2820, 2728, 2741, 2748, 2765, 2791, 2760, 2745, 2781, 2788, 2755, 2741, 2739, 2746, 2767, 2767, 2808, 2735, 2778, 2787, 2766, 2695, 2826, 2731, 2794, 2743, 2777, 2765, 2769, 2780, 2801, 2754, 2789, 2751, 2768, 2691, 2752, 2778, 2740, 2795, 2771, 2750, 2779, 2710, 2718, 2741, 2764, 2799, 2749, 2788, 2741, 2785, 2768, 2735, 2761, 2728, 2759, 2777, 2809, 2775, 2738, 2771, 2786, 2776, 2731, 2760, 2702, 2774, 2749, 2760, 2765, 2724, 2747, 2798, 2763, 2766, 2758, 2767, 2749, 2717, 2700, 2758, 2733, 2747, 2734, 2766, 2764, 2765, 2728, 2757, 2705, 2792, 2683, 2754, 2773, 2739, 2720, 2747, 2781, 2726, 2769, 2756, 2734, 2698, 2765, 2732, 2771, 2769, 2752, 2724, 2721, 2765, 2766, 2733, 2806, 2754, 2717, 2729, 2773, 2737, 2774, 2734, 2757, 2797, 2772, 2680, 2716, 2745, 2736, 2758, 2746, 2748, 2776, 2777, 2723, 2669, 2760, 2689, 2758, 2748, 2750, 2718, 2809, 2824, 2664, 2749, 2717, 2774, 2775, 2713, 2685, 2758, 2725, 2767, 2724, 2710, 2719, 2785, 2782, 2755, 2715, 2762, 2700, 2695, 2778, 2724, 2706, 2752, 2740, 2747, 2702, 2700, 2739, 2716, 2792, 2717, 2765, 2704, 2700, 2783, 2750, 2743, 2771, 2747, 2744, 2710, 2765, 2729, 2760, 2638, 2781, 2735, 2739, 2725, 2708, 2779, 2769, 2706, 2729, 2717, 2718, 2690, 2762, 2688, 2692, 2720, 2759, 2756, 2727, 2739, 2683, 2736, 2710, 2697, 2731, 2724, 2806, 2707, 2693, 2649, 2741, 2725, 2700, 2751, 2724, 2765, 2710, 2749, 2752, 2714, 2760, 2747, 2754, 2670, 2699, 2730, 2717, 2736, 2731, 2699, 2677, 2697, 2714, 2789, 2778, 2702, 2705, 2677, 2701, 2761, 2749, 2699, 2781, 2755, 2697, 2699, 2733, 2710, 2769, 2736, 2699, 2701, 2727, 2757, 2706, 2747, 2669, 2727, 2700, 2722, 2754, 2726, 2714, 2734, 2735, 2687, 2730, 2669, 2725, 2745, 2688, 2729, 2722, 2737, 2691, 2722, 2728, 2683, 2699, 2772, 2725, 2659, 2731, 2676, 2769, 2683, 2680, 2721, 2697, 2737, 2704, 2708, 2709, 2735, 2721, 2714, 2721, 2663, 2718, 2695, 2745, 2691, 2684, 2749, 2713, 2707, 2723, 2704, 2712, 2669, 2763, 2668, 2701, 2737, 2719, 2696, 2749, 2769, 2676, 2723, 2729, 2683, 2746, 2688, 2735, 2624, 2698, 2700, 2729, 2684, 2704, 2676, 2692, 2779, 2710, 2719, 2744, 2724, 2705, 2699, 2697, 2697, 2727, 2685, 2734, 2674, 2712, 2714, 2699, 2716, 2680, 2709, 2679, 2696, 2732, 2704, 2712, 2661, 2702, 2735, 2695, 2663, 2726, 2645, 2758, 2735, 2696, 2755, 2696, 2668, 2744, 2717, 2695, 2622, 2708, 2712, 2711, 2715, 2747, 2700, 2745, 2701, 2684, 2720, 2688, 2749, 2726, 2652, 2759, 2665, 2714, 2716, 2700, 2764, 2701, 2644, 2677, 2656, 2727, 2658, 2743, 2695, 2723, 2693, 2705, 2698, 2657, 2731, 2674, 2698, 2705, 2761, 2728, 2717, 2743, 2722, 2699, 2698, 2633, 2686, 2703, 2750, 2680, 2662, 2714, 2716, 2656, 2696, 2685, 2655, 2694, 2652, 2671, 2653, 2668, 2713, 2685, 2697, 2685, 2642, 2782, 2694, 2664, 2675, 2710, 2689, 2736, 2651, 2702, 2698, 2673, 2705, 2632, 2732, 2707, 2682, 2684, 2726, 2622, 2688, 2670, 2657, 2680, 2711, 2694, 2654, 2722, 2697, 2681, 2730, 2674, 2673, 2666, 2701, 2717, 2717, 2692, 2681, 2698, 2710, 2670, 2626, 2674, 2696, 2719, 2689, 2699, 2690, 2674, 2727, 2675, 2688, 2687, 2677, 2688, 2640, 2709, 2627, 2691, 2664, 2714, 2664, 2724, 2675, 2733, 2680, 2641, 2684, 2706, 2717, 2611, 2696, 2662, 2693, 2712, 2636, 2651, 2719, 2685, 2673, 2689, 2708, 2729, 2677, 2678, 2735, 2693, 2703, 2661, 2710, 2680, 2686, 2656, 2732, 2674, 2674, 2713, 2699, 2670, 2640, 2689, 2709, 2646, 2717, 2646, 2705, 2690, 2677, 2660, 2660, 2664, 2721, 2676, 2689, 2675, 2697, 2709, 2616, 2671, 2714, 2675, 2653, 2661, 2717, 2742, 2662, 2656, 2688, 2716, 2658, 2701, 2675, 2681, 2678, 2725, 2649, 2679, 2656, 2641, 2720, 2708, 2735, 2734, 2665, 2643, 2719, 2659, 2670, 2718, 2679, 2676, 2742, 2578, 2697, 2638, 2646, 2626, 2720, 2656, 2628, 2697, 2719, 2666, 2710, 2658, 2678, 2715, 2704, 2688, 2683, 2702, 2658, 2630, 2700, 2665, 2684, 2711, 2646, 2670, 2707, 2655, 2673, 2690, 2613, 2737, 2674, 2584, 2703, 2695, 2667, 2643, 2651, 2645, 2710, 2661, 2671, 2699, 2691, 2720, 2641, 2677, 2670, 2659, 2695, 2709, 2646, 2677, 2631, 2709, 2585, 2655, 2687, 2638, 2653, 2637, 2667, 2635, 2686, 2732, 2672, 2695, 2658, 2631, 2658, 2643, 2629, 2693, 2671, 2705, 2686, 2665, 2707, 2629, 2577, 2650, 2669, 2590, 2681, 2662, 2688, 2649, 2647, 2705, 2684, 2653, 2705, 2636, 2693, 2726, 2693, 2684, 2680, 2639, 2727, 2724, 2652, 2609, 2662, 2643, 2669, 2656, 2619, 2598, 2707, 2612, 2648, 2696, 2710, 2609, 2703, 2671, 2698, 2657, 2664, 2699, 2642, 2671, 2706, 2635, 2615, 2669, 2659, 2671, 2639, 2707, 2627, 2709, 2687, 2657, 2649, 2654, 2690, 2657, 2680, 2672, 2671, 2681, 2701, 2645, 2652, 2704, 2605, 2653, 2655, 2684, 2647, 2678, 2649, 2669, 2639, 2646, 2654, 2694, 2672, 2663, 2667, 2676, 2652, 2670, 2650, 2653, 2671, 2662, 2678, 2697, 2616, 2647, 2687, 2675, 2678, 2603, 2630, 2639, 2687, 2683, 2618, 2646, 2652, 2661, 2667, 2639, 2652, 2670, 2611, 2641, 2669, 2623, 2690, 2642, 2670, 2625, 2704, 2671, 2628, 2643, 2655, 2632, 2650, 2668, 2629, 2641, 2667, 2615, 2617, 2664, 2636, 2658, 2655, 2646, 2633, 2628, 2703, 2639, 2693, 2641, 2604, 2596, 2601, 2666, 2623, 2663, 2670, 2633, 2641, 2687, 2627, 2609, 2669, 2642, 2706, 2688, 2670, 2701, 2618, 2679, 2643, 2645, 2637, 2628, 2658, 2649, 2602, 2682, 2654, 2660, 2614, 2679, 2584, 2662, 2711, 2637, 2617, 2640, 2652, 2730, 2665, 2639, 2663, 2658, 2651, 2670, 2666, 2645, 2655, 2599, 2608, 2677, 2652, 2698, 2651, 2620, 2617, 2634, 2659, 2678, 2590, 2653, 2667, 2648, 2535, 2634, 2616, 2632, 2686, 2653, 2650, 2596, 2645, 2672, 2691, 2602, 2667, 2659, 2648, 2588, 2695, 2645, 2641, 2673, 2653, 2634, 2603, 2717, 2621, 2725, 2641, 2626, 2588, 2653, 2646, 2635, 2639, 2621, 2625, 2611, 2657, 2662, 2673, 2648, 2648, 2649, 2663, 2634, 2623, 2645, 2631, 2678, 2642, 2628, 2692, 2710, 2639, 2667, 2661, 2612, 2611, 2695, 2629, 2616, 2652, 2671, 2597, 2648, 2621, 2587, 2639, 2644, 2632, 2679, 2610, 2602, 2632, 2647, 2682, 2559, 2641, 2671, 2658, 2697, 2604, 2614, 2647, 2604, 2650, 2646, 2646, 2636, 2610, 2706, 2584, 2628, 2629, 2673, 2640, 2632, 2628, 2644, 2636, 2631, 2626, 2708, 2594, 2651, 2628, 2703, 2671, 2641, 2672, 2683, 2635, 2597, 2638, 2646, 2583, 2677, 2662, 2624, 2648, 2644, 2618, 2607, 2583, 2660, 2623, 2671, 2630, 2665, 2643, 2641, 2621, 2603, 2666, 2628, 2604, 2665, 2652, 2638, 2644, 2624, 2638, 2632, 2644, 2631, 2622, 2627, 2694, 2621, 2681, 2641, 2660, 2658, 2572, 2626, 2654, 2635, 2636, 2625, 2640, 2648, 2620, 2558, 2675, 2651, 2618, 2629, 2651, 2668, 2619, 2646, 2662, 2613, 2605, 2621, 2645, 2628, 2599, 2649, 2657, 2616, 2613, 2654, 2640, 2605, 2670, 2652, 2635, 2604, 2691, 2610, 2617, 2614, 2647, 2652, 2668, 2660, 2647, 2621, 2604, 2629, 2623, 2649, 2630, 2706, 2579, 2672, 2618, 2629, 2657, 2641, 2614, 2652, 2697, 2659, 2630, 2645, 2610, 2622, 2607, 2623, 2645, 2600, 2634, 2599, 2583, 2645, 2587, 2671, 2646, 2613, 2604, 2649, 2635, 2599, 2693, 2620, 2667, 2622, 2545, 2597, 2604, 2640, 2635, 2593, 2605, 2656, 2627, 2587, 2623, 2633, 2631, 2654, 2618, 2605, 2624, 2623, 2631, 2670, 2639, 2629, 2648, 2645, 2655, 2615, 2635, 2625, 2669, 2625, 2647, 2603, 2584, 2608, 2612, 2620, 2658, 2653, 2637, 2584, 2617, 2641, 2602, 2630, 2617, 2668, 2619, 2626, 2671, 2618, 2635, 2663, 2576, 2557, 2642, 2603, 2650, 2646, 2688, 2567, 2614, 2627, 2614, 2674, 2616, 2562, 2615, 2640, 2691, 2630, 2635, 2638, 2614, 2620, 2625, 2621, 2681, 2622, 2607, 2588, 2649, 2553, 2606, 2592, 2568, 2565, 2591, 2665, 2600, 2595, 2623, 2640, 2596, 2578, 2617, 2571, 2625, 2611, 2602, 2605, 2640, 2629, 2633, 2666, 2626, 2668, 2613, 2665, 2619, 2558, 2603, 2629, 2635, 2676, 2599, 2623, 2619, 2632, 2611, 2613, 2627, 2634, 2583, 2631, 2627, 2640, 2649, 2618, 2640, 2565, 2616, 2620, 2627, 2623, 2648, 2597, 2629, 2630, 2587, 2588, 2621, 2645, 2620, 2580, 2596, 2648, 2584, 2606, 2572, 2656, 2548, 2598, 2602, 2584, 2610, 2628, 2630, 2570, 2623, 2592, 2653, 2630, 2635, 2654, 2635, 2555, 2592, 2598, 2584, 2638, 2697, 2592, 2614, 2606, 2566, 2610, 2685, 2664, 2686, 2616, 2547, 2628, 2632, 2562, 2638, 2607, 2588, 2679, 2650, 2604, 2637, 2614, 2562, 2613, 2620, 2632, 2657, 2626, 2654, 2589, 2640, 2577, 2635, 2566, 2606, 2645, 2569, 2610, 2630, 2616, 2670, 2630, 2565, 2646, 2601, 2626, 2629, 2592, 2598, 2551, 2627, 2661, 2621, 2654, 2576, 2643, 2614, 2591, 2583, 2618, 2596, 2586, 2585, 2590, 2664, 2601, 2587, 2629, 2608, 2635, 2576, 2620, 2625, 2530, 2660, 2628, 2634, 2562, 2598, 2640, 2621, 2636, 2628, 2596, 2609, 2543, 2619, 2562, 2625, 2591, 2584, 2619, 2585, 2615, 2639, 2587, 2592, 2605, 2573, 2563, 2662, 2659, 2607, 2673, 2641, 2578, 2607, 2596, 2664, 2614, 2625, 2557, 2613, 2617, 2555, 2603, 2594, 2615, 2681, 2632, 2633, 2644, 2561, 2636, 2581, 2631, 2611, 2595, 2572, 2635, 2632, 2620, 2615, 2641, 2593, 2590, 2675, 2620, 2589, 2600, 2623, 2609, 2606, 2624, 2561, 2594, 2631, 2622, 2623, 2577, 2581, 2603, 2574, 2639, 2616, 2620, 2640, 2642, 2627, 2587, 2637, 2612, 2603, 2621, 2599, 2606, 2639, 2645, 2617, 2633, 2618, 2596, 2596, 2592, 2600, 2616, 2581, 2590, 2606, 2598, 2646, 2576, 2545, 2591, 2636, 2556, 2604, 2636, 2635, 2599, 2575, 2527, 2616, 2607, 2610, 2572, 2589, 2643, 2545, 2650, 2608, 2615, 2585, 2627, 2536, 2603, 2587, 2612, 2643, 2597, 2654, 2544, 2610, 2605, 2558, 2618, 2553, 2616, 2604, 2688, 2559, 2577, 2581, 2642, 2619, 2550, 2609, 2642, 2613, 2616, 2544, 2599, 2675, 2639, 2594, 2547, 2645, 2595, 2618, 2602, 2551, 2637, 2667, 2596, 2600, 2590, 2515, 2615, 2577, 2635, 2647, 2605, 2590, 2568, 2592, 2657, 2672, 2627, 2578, 2544, 2563, 2560, 2609, 2593, 2617, 2660, 2562, 2638, 2567, 2575, 2599, 2599, 2593, 2636, 2649, 2665, 2569, 2608, 2638, 2585, 2626, 2563, 2547, 2525, 2543, 2581, 2597, 2595, 2608, 2572, 2570, 2555, 2581, 2648, 2624, 2545, 2632, 2578, 2625, 2564, 2578, 2629, 2569, 2579, 2576, 2568, 2637, 2630, 2598, 2566, 2595, 2598, 2625, 2614, 2621, 2578, 2531, 2608, 2580, 2594, 2595, 2611, 2568, 2640, 2577, 2612, 2635, 2571, 2602, 2606, 2588, 2624, 2567, 2611, 2638, 2590, 2604, 2549, 2585, 2550, 2576, 2601, 2619, 2600, 2604, 2541, 2600, 2590, 2599, 2578, 2553, 2573, 2606, 2610, 2599, 2637, 2594, 2587, 2571, 2644, 2591, 2621, 2633, 2570, 2563, 2578, 2592, 2601, 2644, 2581, 2595, 2577, 2598, 2586, 2658, 2609, 2596, 2578, 2595, 2587, 2594, 2578, 2663, 2561, 2584, 2609, 2576, 2622, 2624, 2583, 2614, 2583, 2551, 2651, 2613, 2579, 2588, 2544, 2591, 2601, 2582, 2641, 2540, 2623, 2542, 2584, 2560, 2632, 2564, 2631, 2621, 2618, 2631, 2558, 2556, 2615, 2587, 2561, 2664, 2597, 2603, 2597, 2599, 2524, 2594, 2593, 2606, 2552, 2564, 2520, 2597, 2599, 2555, 2526, 2599, 2628, 2572, 2602, 2503, 2642, 2538, 2596, 2598, 2623, 2578, 2635, 2568, 2525, 2635, 2589, 2562, 2594, 2618, 2617, 2581, 2673, 2595, 2572, 2616, 2616, 2590, 2605, 2597, 2577, 2579, 2587, 2561, 2512, 2621, 2566, 2574, 2584, 2601, 2571, 2575, 2611, 2579, 2573, 2604, 2519, 2590, 2620, 2570, 2532, 2579, 2558, 2615, 2538, 2613, 2631, 2623, 2585, 2571, 2596, 2593, 2602, 2591, 2578, 2604, 2565, 2600, 2518, 2591, 2576, 2585, 2570, 2596, 2570, 2601, 2597, 2567, 2556, 2561, 2626, 2613, 2635, 2627, 2563, 2540, 2566, 2585, 2555, 2590, 2597, 2547, 2579, 2545, 2645, 2584, 2537, 2548, 2599, 2578, 2506, 2602, 2605, 2552, 2587, 2594, 2621, 2607, 2585, 2665, 2548, 2564, 2577, 2567, 2567, 2600, 2615, 2574, 2607, 2582, 2636, 2556, 2621, 2605, 2585, 2560, 2534, 2645, 2589, 2559, 2602, 2592, 2557, 2601, 2583, 2603, 2588, 2559, 2557, 2566, 2583, 2545, 2610, 2664, 2557, 2633, 2632, 2579, 2561, 2573, 2560, 2531, 2582, 2625, 2598, 2546, 2595, 2580, 2608, 2603, 2611, 2602, 2612, 2550, 2559, 2586, 2620, 2578, 2593, 2597, 2548, 2523, 2576, 2549, 2597, 2585, 2576, 2598, 2607, 2582, 2582, 2600, 2582, 2642, 2580, 2620, 2575, 2572, 2585, 2590, 2561, 2551, 2569, 2567, 2579, 2628, 2589, 2607, 2670, 2572, 2547, 2571, 2615, 2593, 2617, 2612, 2560, 2588, 2563, 2533, 2568, 2614, 2581, 2531, 2573, 2616, 2597, 2598, 2556, 2562, 2583, 2545, 2651, 2578, 2528, 2611, 2613, 2626, 2587, 2587, 2583, 2607, 2572, 2614, 2555, 2598, 2565, 2530, 2584, 2514, 2575, 2550, 2613, 2543, 2600, 2559, 2584, 2566, 2555, 2630, 2571, 2532, 2594, 2576, 2637, 2525, 2525, 2588, 2594, 2644, 2581, 2547, 2601, 2621, 2561, 2580, 2582, 2606, 2529, 2541, 2537, 2561, 2567, 2559, 2521, 2590, 2595, 2622, 2597, 2584, 2592, 2540, 2587, 2544, 2535, 2554, 2568, 2569, 2530, 2610, 2603, 2621, 2591, 2525, 2556, 2564, 2589, 2597, 2596, 2557, 2548, 2533, 2579, 2538, 2577, 2524, 2554, 2618, 2604, 2598, 2570, 2577, 2580, 2604, 2582, 2608, 2563, 2589, 2533, 2610, 2622, 2566, 2523, 2623, 2517, 2561, 2610, 2569, 2542, 2625, 2566, 2561, 2577, 2596, 2565, 2534, 2620, 2601, 2516, 2568, 2553, 2598, 2562, 2595, 2560, 2544, 2614, 2525, 2592, 2595, 2599, 2584, 2531, 2591, 2545, 2525, 2575, 2561, 2529, 2613, 2555, 2559, 2525, 2600, 2555, 2574, 2554, 2571, 2518, 2596, 2583, 2646, 2518, 2611, 2521, 2589, 2558, 2544, 2589, 2647, 2557, 2524, 2557, 2520, 2556, 2586, 2625, 2539, 2619, 2554, 2598, 2580, 2569, 2554, 2478, 2581, 2583, 2580, 2559, 2573, 2543, 2564, 2551, 2585, 2562, 2568, 2558, 2612, 2543, 2631, 2578, 2565, 2570, 2556, 2554, 2569, 2610, 2571, 2527, 2584, 2553, 2596, 2603, 2537, 2492, 2529, 2567, 2641, 2560, 2573, 2555, 2591, 2527, 2580, 2586, 2526, 2556, 2574, 2510, 2574, 2552, 2555, 2608, 2551, 2643, 2599, 2567, 2564, 2588, 2557, 2556, 2541, 2577, 2578, 2606, 2524, 2557, 2603, 2543, 2562, 2617, 2547, 2598, 2578, 2532, 2463, 2549, 2566, 2583, 2589, 2604, 2588, 2545, 2569, 2540, 2573, 2540, 2637, 2546, 2537, 2577, 2596, 2608, 2601, 2611, 2585, 2546, 2571, 2520, 2516, 2543, 2603, 2584, 2601, 2557, 2567, 2597, 2577, 2555, 2515, 2547, 2550, 2524, 2530, 2600, 2570, 2615, 2543, 2556, 2552, 2583, 2552, 2564, 2557, 2570, 2599, 2573, 2547, 2605, 2551, 2559, 2594, 2544, 2595, 2533, 2541, 2538, 2574, 2568, 2585, 2553, 2570, 2539, 2551, 2570, 2516, 2531, 2553, 2575, 2600, 2642, 2566, 2516, 2547, 2562, 2541, 2616, 2557, 2544, 2528, 2567, 2564, 2525, 2635, 2538, 2576, 2541, 2591, 2596, 2582, 2476, 2567, 2543, 2511, 2537, 2530, 2511, 2570, 2599, 2531, 2544, 2620, 2530, 2558}; int ans = 0; int powmod(int a, int b, int p) { int res = 1; while (b) if (b & 1) { res = int(res * 1ll * a % p); --b; } else { a = int(a * 1ll * a % p); b >>= 1; } return res; } bool check(int m) { int s = 0, t = m - 1, x, a = ((rand() * rand()) % (m - 3)) + 2; while (!(t & 1)) { ++s; t >>= 1; } x = powmod(a, t, m); if (x == 1 || x == m - 1) return true; --s; while (s--) { x = (x * 1ll * x) % m; if (x == 1) return false; if (x == m - 1) return true; } return false; } bool test(int x, int r = 30) { if (x == 2 || x == 3) return true; if (x == 1 || !(x & 1)) return false; bool ok = true; while (r-- && ok) ok &= check(x); return ok; } int main() { int l, r; cin >> l >> r; if (l == 1 && r >= 2 || l == 2) ++ans; int b1 = l / 100000 + 1; for (int i = l; i <= b1 * 100000 && i <= r; i++) if (test(i) && (i % 4 == 1)) ++ans; for (int i = b1 + 1; i * 100000 <= r; i++) { ans += a[i]; b1 = i; } for (int i = b1 * 100000; i <= r; i++) if (test(i) && (i % 4 == 1)) ++ans; cout << ans; return 0; }
#include <bits/stdc++.h> #pragma GCC optimize trapv using namespace std; void solveEachTest(long long int T35TC453N = 1) { unsigned long long int a, b; cin >> a >> b; bool ok = true; bitset<64> xandy((a - b) / 2); bitset<64> xxory(b); unsigned long long int x = (a - b) / 2; unsigned long long int y = x + b; if (a < b) ok = false; for (auto i = (0); (((1) < 0) ? (i) > (64) : (i) < (64)); (i) += (1)) { if (xandy[i] == 1 and xxory[i] == 1) { ok = false; break; } } if (!ok) cout << -1 ; else cout << x << << y; cout << n ; return; } signed main() { ios_base::sync_with_stdio(false); cin.tie(0); long long int T3X0 = 0, T353 = 1; solveEachTest(T353 - T3X0); return 0; }
#include <bits/stdc++.h> using namespace std; int k; string res; int c[500]; int main(void) { for (int i = 2; i < 449; i++) { c[i] = i * (i - 1) / 2; } scanf( %d , &k); if (k == 0) { cout << a << endl; } char cur = a ; while (k > 0) { int takeind = upper_bound(c + 2, c + 449, k) - c - 1; k -= c[takeind]; for (int i = 0; i < takeind; i++) { res += cur; } cur++; } cout << res << endl; }
#include <bits/stdc++.h> int main() { double n2, a, b, c, n1; scanf( %lf %lf %lf , &a, &b, &c); n1 = ((-b + pow((b * b - 4 * a * c), 0.5)) / (a * 2)); n2 = ((-b - pow((b * b - 4 * a * c), 0.5)) / (a * 2)); if (n1 >= n2) printf( %lf %lf , n1, n2); else printf( %lf %lf , n2, n1); return 0; }
#include <bits/stdc++.h> const int inf = 1e9 + 7; const int md = 1e9 + 7; const double eps = -1e5; using namespace std; int n, ans, x, y; bool a[1001][1001]; bool isin(int x, int y) { return x > 0 && x <= 1000 && y > 0 && y <= 1000; } int main() { cin >> n; for (int i = 0; i < n; i++) { cin >> x >> y; a[x][y] = true; } for (int x = 1; x <= 1000; x++) for (int y = 1; y <= 1000; y++) if (a[x][y]) { for (int xx = x, yy = y; isin(xx, yy); xx--, yy--) ans += a[xx][yy]; ans--; for (int xx = x, yy = y; isin(xx, yy); xx++, yy--) ans += a[xx][yy]; ans--; for (int xx = x, yy = y; isin(xx, yy); xx--, yy++) ans += a[xx][yy]; ans--; for (int xx = x, yy = y; isin(xx, yy); xx++, yy++) ans += a[xx][yy]; ans--; } cout << ans / 2; }
#include <bits/stdc++.h> using namespace std; const double eps = 1e-9; const int maxn = 1e5 + 5; long long h[maxn], l[maxn], r[maxn]; int main() { int n; scanf( %d , &n); for (int i = 1; i <= n; ++i) scanf( %lld , &h[i]); l[1] = r[n] = 1; for (int i = 2; i <= n; ++i) l[i] = min(h[i], l[i - 1] + 1); for (int i = n - 1; i >= 1; --i) r[i] = min(h[i], r[i + 1] + 1); long long ans = 0; for (int i = 1; i <= n; ++i) { long long now = min(l[i], r[i]); if (now > ans) ans = now; } printf( %lld n , ans); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { long long n, k, tot, i; cin >> n >> k; tot = n * (n - 1) / 2; if (tot <= k) { cout << no solution ; } else { for (i = 0; i < n; i++) { cout << 0 << << i << endl; } } return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 300000; int parent[N], size[N]; vector<pair<int, pair<int, int>>> v; pair<int, int> q[N]; long long ans[N]; int Find(int a) { if (parent[a] == a) return a; return parent[a] = Find(parent[a]); } void Union(int a, int b) { parent[Find(b)] = Find(a); } long long doit(int a, int b) { int x = Find(a); int y = Find(b); long long p = size[x]; long long qq = size[y]; long long anss = p * qq; size[x] += size[y]; Union(x, y); return anss; } int main(int argc, char const *argv[]) { for (int i = 0; i < N; i++) parent[i] = i, size[i] = 1; int n, m, a, b, c; scanf( %d%d , &n, &m); for (int i = 0; i < n - 1; ++i) { scanf( %d%d%d , &a, &b, &c); v.push_back({c, {a, b}}); } sort(v.begin(), v.end()); for (int i = 0; i < m; i++) { scanf( %d , &a); q[i] = {a, i}; } sort(q, q + m); int at = 0; long long sum = 0; for (int i = 0; i < m; i++) { if (at < v.size()) { while (v[at].first <= q[i].first) { if (at >= v.size()) break; long long kk = doit(v[at].second.first, v[at].second.second); sum += kk; at++; if (at >= v.size()) break; } } ans[q[i].second] = sum; } for (int i = 0; i < m; i++) { printf( %lld , ans[i]); } return 0; }
#include <bits/stdc++.h> using namespace std; int main(int argc, char *argv[]) { ios_base::sync_with_stdio(false); cin.tie(NULL); string line; while (getline(cin, line)) { map<int, vector<string> > answer; line += , ; istringstream iss(line); string s; stack<int> stk; string tmp; while (getline(iss, s, , )) { getline(iss, tmp, , ); int children = stoi(tmp); answer[stk.size()].push_back(s); if (stk.size() && stk.top() > 0) { stk.top()--; } stk.push(children); while (stk.size() && stk.top() <= 0) stk.pop(); } cout << answer.size() << endl; for (auto i = 0; i < answer.size(); i++) { for (auto &word : answer[i]) cout << word << ; cout << endl; } } return 0; }
#include <bits/stdc++.h> using namespace std; int n, k; long long sum, s[1000005], ans = -(1LL << 62); struct el { long long val; int poz; bool operator<(const el &A) const { return val < A.val; } }; el a[1000005]; int main() { int i, poz; cin.sync_with_stdio(0); cin >> n; for (i = 1; i <= n; ++i) { cin >> a[i].val; a[i].poz = i; } cin >> k; sort(a + 1, a + n + 1); for (i = 1; i <= n; ++i) s[i] = s[i - 1] + a[i].val; for (i = 1, sum = 0; i <= k; ++i) sum += a[i].val * (2 * i - 1 - k); ans = sum; poz = 1; for (i = k + 1; i <= n; ++i) { sum = sum - a[i - k].val * (1 - k) + a[i].val * (k - 1) - 2 * (s[i - 1] - s[i - k]); if (sum < ans) { ans = sum; poz = i - k + 1; } } for (i = poz; i < poz + k; ++i) cout << a[i].poz << ; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { long long int a, b, x, y, aa; scanf( %I64d %I64d , &x, &y); if (y > x) { printf( -1 n ); return 0; } a = x / y; if ((x % y) && (a % 2)) a++; if (!(a % 2)) aa = a - 1; else aa = a; double cc = (double)(x - aa * y); double c = cc / (double)a; double res = y + c; printf( %0.11lf n , res); return 0; }
#include <bits/stdc++.h> using namespace std; const int MAXN = 100010; int N, M; int ar[MAXN]; char s[MAXN]; int dn[MAXN][2]; int used[MAXN][2]; int f(int k, int flag) { if (k == -1) return 0; if (used[k][flag]) return dn[k][flag]; used[k][flag] = 1; if (!flag) return dn[k][flag] = f(k - 1, 0) + ar[k]; if (s[k] == 0 ) return dn[k][flag] = f(k - 1, 1); if (s[k] == 1 ) return dn[k][flag] = max(f(k - 1, 1) + ar[k], f(k - 1, 0)); } int main() { cin >> N; for (int i = 0; i < N; i++) scanf( %d , &ar[i]); scanf( %s , s); cout << f(N - 1, 1) << endl; return 0; }
#include <bits/stdc++.h> using namespace std; char a[15]; char rr[15]; char ans[15]; int main() { int maxx = -99; cin >> a; int len = strlen(a); for (int i = 1; i < 1 << len; i++) { int cnt = 0; for (int j = 0; j <= len - 1; j++) { if (i >> j & 1) rr[++cnt] = a[j]; } int flag = 0; for (int l = 1, r = cnt; l <= r; l++, r--) { if (rr[l] != rr[r]) { flag = 1; break; } } if (flag == 0) { if (strcmp(ans + 1, rr + 1) < 0) { for (int i = 1; i <= 14; i++) { if (i <= cnt) ans[i] = rr[i]; else ans[i] = 0 ; } } } } cout << ans + 1 << endl; }
#include <bits/stdc++.h> using namespace std; int dist(int a, int b) { return min(abs(a - b), 360 - abs(a - b)); } long long d; int main() { scanf( %I64d , &d); d = (d % 360 + 360) % 360; int ans = 1000; for (int i = 0; i < 4; i++) ans = min(ans, dist(d, 90 * i)); for (int i = 0; i < 4; i++) { if (dist(d, 90 * i) == ans) { printf( %d n , i); return 0; } } return 0; }
#include <bits/stdc++.h> using namespace std; const int MAXN = 1e5 + 5; const int MOD = 1e9 + 7; int a[MAXN]; class Matrix { public: void prinf() { for (int i = 0; i < 2; i++) { for (int j = 0; j < 2; j++) { cout << a[i][j]; } cout << endl; } } long long a[2][2]; Matrix() { memset(a, 0, sizeof a); } void init() { for (int i = 0; i < 2; i++) for (int j = 0; j < 2; j++) a[i][j] = (i == j); } Matrix operator+(const Matrix &B) const { Matrix C; for (int i = 0; i < 2; i++) for (int j = 0; j < 2; j++) C.a[i][j] = (a[i][j] + B.a[i][j]) % MOD; return C; } Matrix operator*(const Matrix &B) const { Matrix C; for (int i = 0; i < 2; i++) for (int k = 0; k < 2; k++) for (int j = 0; j < 2; j++) C.a[i][j] = (C.a[i][j] + 1LL * a[i][k] * B.a[k][j]) % MOD; return C; } Matrix operator^(const int &t) const { Matrix A = (*this), res; res.init(); int p = t; while (p) { if (p & 1) res = res * A; A = A * A; p >>= 1; } return res; } }; Matrix sum[MAXN << 2], add[MAXN << 2], f; void pushdown(int rt) { sum[rt << 1] = sum[rt << 1] * add[rt]; sum[rt << 1 | 1] = sum[rt << 1 | 1] * add[rt]; add[rt << 1] = add[rt << 1] * add[rt]; add[rt << 1 | 1] = add[rt << 1 | 1] * add[rt]; add[rt].init(); } void pushup(int rt) { sum[rt] = sum[rt << 1] + sum[rt << 1 | 1]; } void build(int l, int r, int rt) { sum[rt].init(); add[rt].init(); if (l == r) { sum[rt] = f ^ (a[l] - 1); return; } int m = (l + r) >> 1; build(l, m, rt << 1); build(m + 1, r, rt << 1 | 1); pushup(rt); } void update(int L, int R, Matrix v, int l, int r, int rt) { if (L <= l && R >= r) { sum[rt] = sum[rt] * v; add[rt] = add[rt] * v; return; } pushdown(rt); int m = (l + r) >> 1; if (L <= m) update(L, R, v, l, m, rt << 1); if (R > m) update(L, R, v, m + 1, r, rt << 1 | 1); pushup(rt); } long long query(int L, int R, int l, int r, int rt) { if (L <= l && R >= r) { return sum[rt].a[0][0]; } pushdown(rt); int m = (l + r) >> 1; int cnt = 0; if (L <= m) cnt = (cnt + query(L, R, l, m, rt << 1)) % MOD; if (R > m) cnt = (cnt + query(L, R, m + 1, r, rt << 1 | 1)) % MOD; return cnt; } int main() { int m, n; f.a[0][0] = 1; f.a[0][1] = 1; f.a[1][0] = 1; f.a[1][1] = 0; scanf( %d %d , &n, &m); for (int i = 1; i <= n; i++) scanf( %d , &a[i]); build(1, n, 1); int a1, b, c; for (int i = 0; i < m; i++) { scanf( %d %d %d , &a1, &b, &c); if (a1 == 1) { int s; scanf( %d , &s); update(b, c, f ^ s, 1, n, 1); } else { cout << query(b, c, 1, n, 1) % MOD << endl; } } }
#include <bits/stdc++.h> using namespace std; vector<int> v[100146]; int val[100146], a[100146], b[100146]; long long cnt[1 << 18], sum[1 << 18]; int leftError[100146], rightError[100146]; void countDps(int e) { if (v[e].size() == 0) leftError[e] = rightError[e] = val[e]; else { countDps(v[e][0]); countDps(v[e][1]); if (val[v[e][0]] < val[v[e][1]]) { leftError[e] = leftError[v[e][0]]; rightError[e] = rightError[v[e][1]]; } else { leftError[e] = leftError[v[e][1]]; rightError[e] = rightError[v[e][0]]; } } } void add(long long* tree, int cur, int l, int r, int cl, int cr, long long c) { if (r < cl || cr < l) return; if (cl <= l && r <= cr) tree[cur] += c; else { int mid = (l + r) / 2; add(tree, cur * 2, l, mid, cl, cr, c); add(tree, cur * 2 + 1, mid + 1, r, cl, cr, c); } } void addToSegment(long long* tree, int l, int r, long long c) { if (l > r) return; add(tree, 1, 0, (1 << 17) - 1, l, r, c); } void dfs(int e, int l, int r) { if (v[e].size() == 0) return; int mid = lower_bound(a + l, a + r, val[e]) - a; if (val[v[e][0]] < val[v[e][1]]) { dfs(v[e][0], l, mid); dfs(v[e][1], mid, r); addToSegment(cnt, l, mid - 1, 1); addToSegment(sum, l, mid - 1, leftError[v[e][1]]); addToSegment(cnt, mid, r - 1, 1); addToSegment(sum, mid, r - 1, rightError[v[e][0]]); } else { dfs(v[e][1], l, mid); dfs(v[e][0], mid, r); addToSegment(cnt, l, mid - 1, 1); addToSegment(sum, l, mid - 1, leftError[v[e][0]]); addToSegment(cnt, mid, r - 1, 1); addToSegment(sum, mid, r - 1, rightError[v[e][1]]); } } long long getValue(long long* tree, int el) { long long cur = el + (1 << 17); long long ans = 0; while (cur) { ans += tree[cur]; cur /= 2; } return ans; } int main() { int n; scanf( %d , &n); int root = -1; for (int i = 0; i < n; i++) { int p; scanf( %d%d , &p, &val[i]); if (p != -1) v[p - 1].push_back(i); else root = i; } int m; scanf( %d , &m); for (int i = 0; i < m; i++) { scanf( %d , &a[i]); b[i] = a[i]; } sort(a, a + m); countDps(root); memset(sum, 0, sizeof(sum)); memset(cnt, 0, sizeof(cnt)); dfs(root, 0, m); for (int i = 0; i < m; i++) { int ind = lower_bound(a, a + m, b[i]) - a; double ans = (double)getValue(sum, ind) / getValue(cnt, ind); printf( %.9lf n , ans); } }
#include <bits/stdc++.h> using namespace std; int n; vector<vector<int> > G; vector<vector<int> > ID; vector<vector<int> > ans; void addp(int id, int t) { while (ans.size() <= t) ans.push_back(vector<int>()); ans[t].push_back(id); } void solve(int from, int lab, int v) { int ctr = 0; for (int i = 0; i < G[v].size(); ++i) { if (ctr == lab) ++ctr; if (G[v][i] == from) continue; addp(ID[v][i], ctr); solve(v, ctr++, G[v][i]); } } int main() { ios::sync_with_stdio(0); cin >> n; G = vector<vector<int> >(n, vector<int>()); ID = vector<vector<int> >(n, vector<int>()); for (int i = 1; i < n; ++i) { int a, b; cin >> a >> b; G[--a].push_back(--b); G[b].push_back(a); ID[a].push_back(i); ID[b].push_back(i); } solve(-1, -1, 0); cout << ans.size() << n ; for (int i = 0; i < ans.size(); ++i) { cout << ans[i].size(); for (int j = 0; j < ans[i].size(); ++j) cout << << ans[i][j]; cout << n ; } return 0; }
#include <bits/stdc++.h> using namespace std; char s[705]; int match[705]; int tmp[705]; long long dp[705][705][3][3]; void getmatch(int len) { int kk = 0; for (kk = 0; kk <= 10000; kk++) ; int p = 0; for (int i = 0; i < len; i++) { if (s[i] == ( ) tmp[p++] = i; else { match[i] = tmp[p - 1]; match[tmp[p - 1]] = i; p--; } } } void dfs(int l, int r) { int kk = 0; for (kk = 0; kk <= 10000; kk++) ; if (l + 1 == r) { dp[l][r][0][1] = 1; dp[l][r][1][0] = 1; dp[l][r][0][2] = 1; dp[l][r][2][0] = 1; return; } if (match[l] == r) { dfs(l + 1, r - 1); for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { if (j != 1) dp[l][r][0][1] = (dp[l][r][0][1] + dp[l + 1][r - 1][i][j]) % 1000000007; if (i != 1) dp[l][r][1][0] = (dp[l][r][1][0] + dp[l + 1][r - 1][i][j]) % 1000000007; if (j != 2) dp[l][r][0][2] = (dp[l][r][0][2] + dp[l + 1][r - 1][i][j]) % 1000000007; if (i != 2) dp[l][r][2][0] = (dp[l][r][2][0] + dp[l + 1][r - 1][i][j]) % 1000000007; } } return; } else { int p = match[l]; dfs(l, p); dfs(p + 1, r); for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { for (int k = 0; k < 3; k++) { for (int q = 0; q < 3; q++) { if (!((k == 1 && q == 1) || (k == 2 && q == 2))) dp[l][r][i][j] = (dp[l][r][i][j] + (dp[l][p][i][k] * dp[p + 1][r][q][j]) % 1000000007) % 1000000007; } } } } } } int main() { while (scanf( %s , s) != EOF) { int len = strlen(s); getmatch(len); int kk = 0; for (kk = 0; kk <= 10000; kk++) ; memset(dp, 0, sizeof(dp)); dfs(0, len - 1); long long ans = 0; for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { ans = (ans + dp[0][len - 1][i][j]) % 1000000007; } } printf( %ld n , ans); } return 0; }
#include <bits/stdc++.h> using namespace std; vector<string> split(const string& s, char c) { vector<string> v; stringstream second(s); string x; while (getline(second, x, c)) v.emplace_back(x); return move(v); } template <typename T, typename... Args> inline string arrStr(T arr, int n) { stringstream s; s << [ ; for (int i = 0; i < n - 1; i++) s << arr[i] << , ; s << arr[n - 1] << ] ; return s.str(); } inline void __evars_begin(int line) { cerr << # << line << : ; } template <typename T> inline void __evars_out_var(vector<T> val) { cerr << arrStr(val, val.size()); } template <typename T> inline void __evars_out_var(T* val) { cerr << arrStr(val, 10); } template <typename T> inline void __evars_out_var(T val) { cerr << val; } inline void __evars(vector<string>::iterator it) { cerr << n ; } template <typename T, typename... Args> inline void __evars(vector<string>::iterator it, T a, Args... args) { cerr << it->substr((*it)[0] == , it->length()) << = ; __evars_out_var(a); cerr << ; ; __evars(++it, args...); } mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); int dx[8] = {1, -1, 0, 0, 1, 1, -1, -1}; int dy[8] = {0, 0, -1, 1, 2, -2, 2, -2}; int myrandom(int i) { return std::rand() % i; } const int MAX = 200010; const unsigned long long inf = 1000000007; int ans = 0, maxi = 0; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); long long n, m; cin >> n >> m; long long x, k, y; cin >> x >> k >> y; vector<long long> v(n), t(m); for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n)); i += 1 - 2 * ((0) > (n))) { cin >> v[i]; } for (__typeof(m) j = (0) - ((0) > (m)); j != (m) - ((0) > (m)); j += 1 - 2 * ((0) > (m))) { cin >> t[j]; } vector<long long> vis(n, 0); int i = 0, j = 0, cnt = 0; while (i < n && j < m) { if (v[i] == t[j]) { vis[i] = 1; i++; j++; cnt++; } else { i++; } } if (cnt != m) { cout << -1 << n ; return 0; } i = 0; long long ans = 0; while (i < n) { while (i < n && vis[i] == 1) { i++; } if (i == n) break; int l = i; vector<long long> temp; while (i < n && vis[i] == 0) { temp.push_back(v[i]); i++; } sort((temp).begin(), (temp).end()); if (y * k > x) { if ((int)temp.size() >= k) { ans += ((long long)temp.size() % k) * y; ans += ((long long)temp.size() / k) * x; } else { long long left = l - 1 >= 0 ? v[l - 1] : 0; long long right = i < n ? v[i] : 0; if (temp.back() < max(left, right)) { ans += (long long)temp.size() * y; } else { cout << -1 << n ; return 0; } } } else { long long left = l - 1 >= 0 ? v[l - 1] : 0; long long right = i < n ? v[i] : 0; if ((long long)temp.size() >= k) { if (temp.back() < max(left, right)) { ans += (long long)temp.size() * y; } else { ans += ((long long)temp.size() - k) * y + x; } } else { if (temp.back() < max(left, right)) { ans += (long long)temp.size() * y; } else { cout << -1 << n ; return 0; } } } } cout << ans << n ; }
#include <bits/stdc++.h> using namespace std; vector<int> s[10]; int n1, n2; int ok(int a, int b) { int sum = a + b * 2; int len = 0; for (int i = 0; i < n1 - a; i++) len += s[1][i]; for (int i = 0; i < n2 - b; i++) len += s[2][i]; return len <= sum; } int main() { int a, b, n, m, i, j, ans = 99999999; ; scanf( %d , &n); for (i = 0; i < n; i++) { scanf( %d%d , &a, &b); s[a].push_back(b); } sort(s[1].begin(), s[1].end()); sort(s[2].begin(), s[2].end()); n1 = s[1].size(); n2 = s[2].size(); for (i = 0; i <= n1; i++) for (j = 0; j <= n2; j++) { if (ok(i, j)) { if (i + j * 2 < ans) ans = i + j * 2; } } printf( %d n , ans); }
#include <bits/stdc++.h> using namespace std; const int inf = (1 << 30) - 1; const int maxn = 100010; char s[maxn]; int calc(char a, char b) { int mx = 30; mx = min(mx, a > b ? a - b : b - a); mx = min(mx, a > b ? b + 26 - a : a + 26 - b); return mx; } int main() { scanf( %s , s); int len = strlen(s); int ans = 0; ans += calc( a , s[0]); for (int i = 0; i < len - 1; i++) ans += calc(s[i], s[i + 1]); printf( %d , ans); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int n, m; cin >> n >> m; int q = 30; if (n == 1 || n == 3 || n == 5 || n == 7 || n == 8 || n == 10 || n == 12) q++; if (n == 2) q = 28; q = q - 8 + m; if (q % 7 == 0) cout << (q / 7) + 1; else cout << (q / 7) + 2; }
#include <bits/stdc++.h> using namespace std; const int N = 1000010; int gcd(int a, int b) { return b ? gcd(b, a % b) : a; } int lcm(int a, int b) { return a * b / gcd(a, b); } struct data { int num; int init; }; bool byNum(const data &left, const data &right) { return left.num > right.num; } bool descend(const int &left, const int &right) { return left > right; } data total[105]; pair<int, int> pile[105]; int sisa[105], card[105]; int main(void) { int temp, n, i, j; scanf( %d , &n); for (i = 0; i <= n - 1; i++) { scanf( %d , &card[i]); sisa[i] = 0; for (j = 0; j <= card[i] / 2 - 1; j++) { scanf( %d , &temp); pile[i].first += temp; } if (card[i] % 2) { scanf( %d , &temp); sisa[i] = temp; } for (j = 0; j <= card[i] / 2 - 1; j++) { scanf( %d , &temp); pile[i].second += temp; } total[i].num = pile[i].first + sisa[i] + pile[i].second; total[i].init = i; } sort(total, total + n, byNum); sort(sisa, sisa + n, descend); long long a = 0, b = 0; for (i = 0; i <= n - 1; i++) { a += pile[total[i].init].first; b += pile[total[i].init].second; } for (i = 0; i <= n - 1; i++) { if (i % 2) b += sisa[i]; else a += sisa[i]; if (!sisa[i]) break; } cout << a << << b << endl; return 0; }
#include <bits/stdc++.h> using namespace std; vector<int> caps, full; int main() { int w, l; cin >> w >> l; caps = vector<int>(w + 1, 0); caps[w] = 2e9; full = vector<int>(w + 1, 0); full[0] = 2e9; for (int i = 1; i < w; i++) cin >> caps[i]; int from = 0; int to = 1; while (from != w) { ; if (to == from) to++; else if (to - from > l) { ; from++; } else if (full[to] == caps[to]) { ; to++; } else if (full[from] == 0) { ; from++; } else { int k = min(full[from], caps[to] - full[to]); full[from] -= k; full[to] += k; ; } } cout << full[w] << endl; }
#include <bits/stdc++.h> using namespace std; signed main() { long long T; cin >> T; while (T--) { string s; cin >> s; long long ans = (long long)s.size(), curr = 0; for (long long i = 0; i < s.size(); i++) { if (s[i] == + ) { curr++; } else { curr--; } if (curr < 0) { ans += (i + 1); curr++; } } cout << ans << endl; } }
#include <bits/stdc++.h> using namespace std; int main() { int event, ghotona; cin >> event; int hired = 0, untreated = 0; for (int i = 0; i < event; i++) { cin >> ghotona; hired += ghotona; if (hired < 0) { untreated++; hired = 0; } } cout << untreated << endl; }
#include <bits/stdc++.h> #pragma comment(linker, /STACK:102400000,102400000 ) using namespace std; int bit[1100]; int tot = 0; void GetBinary(int n) { memset(bit, 0, sizeof bit); while (n) { bit[tot++] = n & 1; n >>= 1; } } int layer[1100][2]; void Construct() { layer[1][0] = 1; layer[2][0] = 3; layer[3][0] = 4; layer[3][1] = 5; for (int i = 4; i <= 60; i += 2) { layer[i][0] = layer[i - 2][0] + 3; layer[i + 1][0] = layer[i - 1][0] + 3; layer[i + 1][1] = layer[i - 1][1] + 3; } } int g[1100][1100]; int main() { ios::sync_with_stdio(false); int n; cin >> n; GetBinary(n); Construct(); memset(g, 0, sizeof g); int total = tot << 1; layer[total + 1][0] = 2; for (int i = 2; i <= total; ++i) { if (i == 2) { g[layer[i - 1][0]][layer[i][0]] = 1; continue; } if (i % 2 == 1) { g[layer[i - 1][0]][layer[i][0]] = 1; g[layer[i - 1][0]][layer[i][1]] = 1; } else { g[layer[i - 1][0]][layer[i][0]] = 1; g[layer[i - 1][1]][layer[i][0]] = 1; } } g[2][layer[total][0]] = 1; int PathLength = total; int ind = tot * 3, indd = tot * 3, end = tot * 3; for (int i = 0; i < tot - 1; ++i) { if (bit[i]) { int pre = layer[(i + 1) * 2][0]; indd = ind; for (int j = 1; j <= PathLength - (i + 1) * 2 - 1; ++j) { g[pre][j + indd] = 1; pre = j + indd; ind++; } g[pre][end] = 1; } } cout << ind << endl; for (int i = 1; i <= ind; ++i) { for (int j = 1; j <= ind; ++j) { if (i == j) cout << N ; else if (g[i][j] || g[j][i]) cout << Y ; else cout << N ; } cout << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; void solve() { long long int n; string s; cin >> n >> s; for (long long int i = 0; i < n; i++) cout << s[n - 1]; cout << endl; } int main() { int test; cin >> test; for (int TEST = 1; TEST <= test; TEST++) solve(); }
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; char arr[n][n]; for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { cin >> arr[i][j]; } } pair<int, int> p[n * n]; int in = 0; for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { if (arr[i][j] == C ) { p[in] = make_pair(i, j); in++; } } } int cnt = 0; for (int i = 0; i < in; i++) { for (int j = i + 1; j < in; j++) { if (p[i].first == p[j].first || p[i].second == p[j].second) { cnt++; } } } cout << cnt << endl; }
#include <bits/stdc++.h> using namespace std; const int MAXN = 103; int p[MAXN], c[MAXN]; int main() { int t; cin >> t; while (t--) { int n; cin >> n; bool check = true; for (int i = 1; i <= n; i++) { cin >> p[i] >> c[i]; if (c[i] > p[i] || c[i] < c[i - 1] || p[i] < c[i] || p[i] - p[i - 1] < c[i] - c[i - 1]) check = false; } if (check) cout << YES << n ; else cout << NO << n ; } }
#include <bits/stdc++.h> using namespace std; double const pi = 3.14159265358979; int const MAXN = 2000000; long long const MOD = 1000000007; long long const INF = 1000000000000000000ll; int a[2000000], d[2000000]; bool is[2000000]; int main() { int n, res = 0; scanf( %d , &n); for (int i = 0; i < (int)(n); i++) { scanf( %d , &a[i]); is[a[i]] = 1; } for (int i = (int)1; i <= (int)(1000000); i++) { d[i] = 1; } for (int i = 0; i < (int)(n); i++) { int k = 2; while (a[i] * k <= 1000000) { d[a[i] * k] = max(d[a[i] * k], d[a[i]] + 1); k++; } res = max(res, d[a[i]]); } printf( %d n , res); return 0; }
#include <bits/stdc++.h> using namespace std; const int maxn = 100005, mod = 998244353; inline int gi() { char c = getchar(); while (c < 0 || c > 9 ) c = getchar(); int sum = 0; while ( 0 <= c && c <= 9 ) sum = sum * 10 + c - 48, c = getchar(); return sum; } inline int add(int a, int b) { return a + b >= mod ? a + b - mod : a + b; } inline int sub(int a, int b) { return a >= b ? a - b : a - b + mod; } inline int fpow(int x, int k) { int res = 1; while (k) { if (k & 1) res = (long long)res * x % mod; k >>= 1; x = (long long)x * x % mod; } return res; } int n, k, ans, s1, s2, fac[maxn], ifac[maxn]; struct edge { int to, next; } e[maxn * 2]; int h[maxn], siz[maxn], tot; int f[maxn], fs[maxn]; vector<pair<int, int> > vec; vector<int> _F[maxn], _G[maxn]; int N, L, R[maxn << 2], w[maxn << 2], F[maxn << 2], Fl[maxn << 2], Fr[maxn << 2], G[maxn << 2], Gl[maxn << 2], Gr[maxn << 2]; inline void adde(int u, int v) { e[++tot] = (edge){v, h[u]}; h[u] = tot; e[++tot] = (edge){u, h[v]}; h[v] = tot; } void init(int n) { for (N = 1, L = -1; N <= n; N <<= 1) ++L; for (int i = 0; i < N; ++i) R[i] = (R[i >> 1] >> 1) | ((i & 1) << L); w[N >> 1] = 1; int wn = fpow(3, (mod - 1) / N); for (int i = (N >> 1) + 1; i < N; ++i) w[i] = (long long)w[i - 1] * wn % mod; for (int i = (N >> 1) - 1; i; --i) w[i] = w[i << 1]; } void dft(int *a) { for (int i = 0; i < N; ++i) if (i < R[i]) swap(a[i], a[R[i]]); for (int d = 1; d < N; d <<= 1) for (int i = 0; i < N; i += d << 1) for (int j = 0; j < d; ++j) { int t = (long long)w[d + j] * a[i + d + j] % mod; a[i + d + j] = sub(a[i + j], t); a[i + j] = add(a[i + j], t); } } void idft(int *a) { dft(a); reverse(a + 1, a + N); int inv = fpow(N, mod - 2); for (int i = 0; i < N; ++i) a[i] = (long long)a[i] * inv % mod; } void solve(int l, int r, int u) { if (l == r) { vector<int> &F = _F[l], &G = _G[l]; F.resize(2); G.resize(2); F[0] = 1; F[1] = vec[l].second; G[0] = add(f[vec[l].first], fs[vec[l].first]); G[1] = (long long)add(f[vec[l].first], fs[vec[l].first]) * (n - siz[u]) % mod; return; } int mid = (l + r) >> 1, l1 = mid - l + 1, l2 = r - mid; solve(l, mid, u); solve(mid + 1, r, u); init(r - l + 1); for (int i = 0; i <= l1; ++i) Fl[i] = _F[l][i], Gl[i] = _G[l][i]; memset(Fl + l1 + 1, 0, sizeof(int) * (N - l1)); memset(Gl + l1 + 1, 0, sizeof(int) * (N - l1)); for (int i = 0; i <= l2; ++i) Fr[i] = _F[mid + 1][i], Gr[i] = _G[mid + 1][i]; memset(Fr + l2 + 1, 0, sizeof(int) * (N - l2)); memset(Gr + l2 + 1, 0, sizeof(int) * (N - l2)); dft(Fl); dft(Gl); dft(Fr); dft(Gr); for (int i = 0; i < N; ++i) F[i] = (long long)Fl[i] * Fr[i] % mod; for (int i = 0; i < N; ++i) G[i] = ((long long)Fl[i] * Gr[i] + (long long)Fr[i] * Gl[i]) % mod; idft(F); idft(G); _F[l].resize(r - l + 2); _G[l].resize(r - l + 2); for (int i = 0; i <= r - l + 1; ++i) _F[l][i] = F[i], _G[l][i] = G[i]; } void dfs(int u, int fa) { siz[u] = 1; for (int i = h[u], v; v = e[i].to, i; i = e[i].next) if (v != fa) dfs(v, u); vec.clear(); for (int i = h[u], v; v = e[i].to, i; i = e[i].next) if (v != fa) { fs[u] = add(fs[u], add(f[v], fs[v])); siz[u] += siz[v]; vec.emplace_back(v, siz[v]); } if (vec.empty()) return f[u] = 1, s1 = add(s1, f[u]), s2 = add(s2, f[u]), void(); solve(0, vec.size() - 1, u); vector<int> &F = _F[0], &G = _G[0]; int s = F.size() - 1; for (int i = 0; i <= s; ++i) f[u] = (f[u] + (long long)fac[k] * ifac[k - i] % mod * F[i]) % mod; s1 = add(s1, f[u]); s2 = (s2 + (long long)f[u] * f[u]) % mod; for (int i = 0; i <= s; ++i) ans = (ans + (long long)fac[k] * ifac[k - i] % mod * G[i]) % mod; ans = (ans + (long long)(mod - f[u]) * fs[u]) % mod; } int main() { n = gi(); k = gi(); if (k == 1) return printf( %lld n , (long long)n * (n - 1) / 2 % mod), 0; fac[0] = 1; for (int i = 1; i <= k; ++i) fac[i] = (long long)fac[i - 1] * i % mod; ifac[k] = fpow(fac[k], mod - 2); for (int i = k - 1; ~i; --i) ifac[i] = (long long)ifac[i + 1] * (i + 1) % mod; for (int i = 1; i < n; ++i) adde(gi(), gi()); dfs(1, 0); printf( %d n , add(ans, (long long)sub((long long)s1 * s1 % mod, s2) * (mod + 1) / 2 % mod)); return 0; }
#include <bits/stdc++.h> using namespace std; int m[100][100]; int main(int argc, char const *argv[]) { ios_base::sync_with_stdio(0); long n, suma = 0; cin >> n; for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) { m[i][j] = 1; } } for (int i = 1; i < n; ++i) { for (int j = 1; j < n; ++j) { int x = m[i - 1][j], y = m[i][j - 1]; m[i][j] = x + y; } } cout << m[n - 1][n - 1] << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int a, b, c, d; scanf( %i %i %i %i , &a, &b, &c, &d); int sum1 = max(3 * a / 10, a - a / 250 * c); int sum2 = max(3 * b / 10, b - b / 250 * d); if (sum1 > sum2) { printf( Misha n ); } else if (sum1 == sum2) { printf( Tie n ); } else { printf( Vasya n ); } return 0; }
#include <bits/stdc++.h> using namespace std; const int maxn = 3e5 + 10; const long long INF = 1e18 + 10; struct node { int next, v; } edge[maxn * 2 + 10]; int cnt, head[maxn], vis[maxn], pa[maxn]; long long sum[maxn], cost[maxn], a[maxn], ss[maxn]; queue<int> q; int find(int x) { if (x == pa[x]) return x; return pa[x] = find(pa[x]); } void add2(int x, int y) { x = find(x); y = find(y); pa[x] = y; ss[y] += ss[x]; } void dfs(int u, int fa) { int i, v; sum[u] = a[u]; for (i = head[u]; i != -1; i = edge[i].next) { v = edge[i].v; if (v == fa) continue; dfs(v, u); if (sum[v] > 0) sum[u] += sum[v]; } } void dfs2(int u, int fa) { int i, v; if (u == 1) { cost[u] = sum[u]; for (i = head[1]; i != -1; i = edge[i].next) { v = edge[i].v; dfs2(v, u); } return; } if (sum[u] <= 0) { cost[u] = max(sum[u], sum[u] + cost[fa]); } else { long long tmp = cost[fa] - sum[u]; if (tmp > 0) { cost[u] = sum[u] + tmp; add2(u, fa); } else { cost[u] = sum[u]; } } for (i = head[u]; i != -1; i = edge[i].next) { v = edge[i].v; if (fa == v) continue; dfs2(v, u); } } void add(int x, int y) { edge[cnt].next = head[x]; edge[cnt].v = y; head[x] = cnt++; } int main() { int i, n; long long ans, ret, s, u, v; scanf( %d , &n); for (i = 1; i <= n; i++) { scanf( %I64d , &a[i]); } cnt = 0; memset(head, -1, sizeof(head)); for (i = 1; i <= n - 1; i++) { scanf( %d%d , &u, &v); add(u, v); add(v, u); } for (i = 1; i <= n; i++) { pa[i] = i; ss[i] = a[i]; } dfs(1, -1); dfs2(1, -1); ans = -INF; for (i = 1; i <= n; i++) ans = max(ans, cost[i]); if (ans <= 0) { ret = 0; s = 0; for (i = 1; i <= n; i++) { if (ans == cost[i]) { ret++; s += ans; } } printf( %I64d %I64d n , s, ret); } else { ret = 0; s = 0; memset(vis, 0, sizeof(vis)); for (i = 1; i <= n; i++) { if (ans == cost[i]) { int tt = find(i); if (!vis[tt] && ss[tt] == ans) { ret++; s += ans; vis[tt] = 1; } } } printf( %I64d %I64d n , s, ret); } return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 1e3 + 10; const char character[] = ./ ; int n, a[N], tag[N], type[N][N]; int main() { scanf( %d , &n); for (register int i = 1; i <= n; ++i) { scanf( %d , &a[i]); } int o = 0, r = 0; for (register int i = 1; i <= n; ++i) { if (tag[i] || a[i] == i) { continue; } vector<int> cycle; for (int j = i; !tag[j]; j = a[j]) { cycle.push_back(j), tag[j] = 1; } cycle.push_back(i); if (!o) { o = i; for (register int j = 1; j + 1 < cycle.size(); ++j) { int a = cycle[j], b = cycle[j + 1]; ++r; type[r][a] = type[r][b] = 2 - (a < b); } } else { ++r; type[r][o] = type[r][cycle[1]] = 1; for (register int j = 1; j + 1 < cycle.size(); ++j) { int a = cycle[j], b = cycle[j + 1]; ++r; type[r][a] = type[r][b] = 2 - (a < b); } type[r][o] = 2; } } printf( %d n , o ? n - 1 : n); for (register int i = 1; i <= n; ++i) { for (register int j = 1; j <= n; ++j) { printf( %c , character[type[i][j]]); } puts( ); } return 0; }
#include <bits/stdc++.h> using namespace std; int n, r; int x[105], y[105]; vector<pair<int, int> > pos, neg; bool cmp(pair<int, int> p1, pair<int, int> p2) { return p1.first + p1.second > p2.first + p2.second; } int main() { cin >> n >> r; for (int i = 0; i < n; i++) { scanf( %d%d , &x[i], &y[i]); if (y[i] >= 0) pos.push_back(pair<int, int>(x[i], y[i])); else neg.push_back(pair<int, int>(x[i], y[i])); } sort(pos.begin(), pos.end()); sort(neg.begin(), neg.end(), cmp); for (int i = 0; i < pos.size(); i++) { if (pos[i].first <= r) r += pos[i].second; else { printf( NO n ); return 0; } } for (int i = 0; i < neg.size(); i++) { if (neg[i].first <= r) r += neg[i].second; else { printf( NO n ); return 0; } if (r < 0) { printf( NO n ); return 0; } } printf( YES n ); return 0; return 0; }
#include <bits/stdc++.h> using namespace std; long long p; map<long long, int> m[123]; int main() { int characters_value[26]; long long i; for (i = 0; i < 26; i++) cin >> characters_value[i]; string s; cin >> s; long long ans = 0; for (i = 0; i < s.size(); i++) { ans += m[s[i]][p]; p += characters_value[s[i] - a ]; m[s[i]][p]++; } cout << ans; }
#include <bits/stdc++.h> using namespace std; const long long mod = 811287553; long long powmod(long long a, long long b) { long long res = 1; a %= mod; for (; b; b >>= 1) { if (b & 1) res = res * a % mod; a = a * a % mod; } return res; } int n, m, s, t, a, b, d; vector<long long> dist, dist1; vector<pair<int, int> > grh[2][100000]; vector<pair<pair<int, int>, int> > queries; set<pair<int, int> > absEdges; map<pair<int, int>, int> minEdges; long long reachableCnt[2][100000]; const long long INF = 1000000000000; void dijkstra(int src, vector<long long>& d, int mode) { d.resize(n, INF); d[src] = 0; priority_queue<pair<long long, int> > pq; pq.push(make_pair(0, src)); while (!pq.empty()) { long long topD = -pq.top().first; int topIdx = pq.top().second; pq.pop(); if (d[topIdx] < topD) continue; int sz = grh[mode][topIdx].size(); for (int i = 0; i < (int)sz; i++) { int nIdx = grh[mode][topIdx][i].first; int nD = grh[mode][topIdx][i].second; long long nD1 = topD + nD; if (d[nIdx] > nD1) { d[nIdx] = nD1; pq.push(make_pair(-nD1, nIdx)); } } } } int calReachable(int idx, vector<long long>& d, bool rev) { if (rev && idx == s) { reachableCnt[!rev][idx] = 1; return 1; } if (!rev && idx == t) { reachableCnt[!rev][idx] = 1; return 1; } long long& ret = reachableCnt[!rev][idx]; if (ret != -1) return ret; int ret1 = 0; int sz = grh[rev][idx].size(); for (int i = 0; i < (int)sz; i++) { int nIdx = grh[rev][idx][i].first; int nD = grh[rev][idx][i].second; if (d[nIdx] == d[idx] + nD) { ret1 += calReachable(nIdx, d, rev); ret1 %= mod; } } return ret = (ret1 % mod); } int main() { cin >> n >> m >> s >> t; s--, t--; for (int i = 0; i < (int)m; i++) { cin >> a >> b >> d; a--, b--; grh[0][a].push_back(make_pair(b, d)); grh[1][b].push_back(make_pair(a, d)); queries.push_back(make_pair(make_pair(a, b), d)); if (minEdges.count(make_pair(a, b))) minEdges[make_pair(a, b)] = min(minEdges[make_pair(a, b)], d); else minEdges[make_pair(a, b)] = d; } memset(reachableCnt, -1, sizeof(reachableCnt)); dijkstra(s, dist, 0); dijkstra(t, dist1, 1); calReachable(t, dist1, 1); calReachable(s, dist, 0); for (int i = 0; i < (int)m; i++) { int x = queries[i].first.first, y = queries[i].first.second, d = queries[i].second; if ((((reachableCnt[0][x] * reachableCnt[1][y]) % mod) == reachableCnt[0][t]) && minEdges[make_pair(x, y)] < d) { if (minEdges[make_pair(x, y)] == 1) cout << NO << endl; else cout << CAN << d - minEdges[make_pair(x, y)] + 1 << endl; } else { long long d1 = dist[x] + dist1[y]; if ((((reachableCnt[0][x] * reachableCnt[1][y]) % mod) == reachableCnt[0][t])) { if (d1 + d == dist[t]) cout << YES << endl; else { if (d > 1 && d1 + 1 < dist[t]) cout << CAN << d + d1 - (dist[t] - 1) << endl; else cout << NO << endl; } } else { if (d > 1 && d1 + 1 < dist[t]) cout << CAN << d + d1 - (dist[t] - 1) << endl; else cout << NO << endl; } } } return 0; }
#include <bits/stdc++.h> using namespace std; template <typename T, typename U> std::pair<T, U> operator+(const std::pair<T, U>& l, const std::pair<T, U>& r) { return {l.first + r.first, l.second + r.second}; } typedef void (*callback_function)(void); const long long ZERO = 0LL; const long long INF64 = 1e18; const long long INF32 = 1e9; const long long MOD = 1e9 + 7; const long double PI = acos(-1.0L); const long double EPS = static_cast<long double>(1e-9); long long inv(long long a, long long b) { if (a != 1) { return b - (inv(b % a, a) * b) / a; } return 1; } inline long long Pow(long long a, long long k) { long long s = 1; for (; k; k >>= 1) { k& 1 ? s = 1LL * s * a % MOD : 0; a = 1LL * a * a % MOD; } return s; } const long long N = 1e6 + 7; void input() {} void output() {} void preprocess() {} void debug() { if (true) { } } void solve() { preprocess(); long long n; cin >> n; pair<long long, long long> a[n]; for (long long i = (0); i < (n); i++) { long long m; cin >> m; long long b[m]; for (long long i = (0); i < (m); i++) { cin >> b[i]; } a[i] = pair<long long, long long>(*max_element(b, b + m), m); } long long mx = (*max_element(a, a + n)).first; long long res = 0; for (long long i = (0); i < (n); i++) { res += (mx - a[i].first) * a[i].second; } cout << res << endl; } int main() { ios_base::sync_with_stdio(false); cin.tie(); { input(); solve(); output(); } return 0; }
#include <bits/stdc++.h> using namespace std; bool compare(pair<int, int> a, pair<int, int> b) { return a.second < b.second; } int main() { int n, k; cin >> n >> k; pair<int, int> power[n]; for (int i = 0; i < n; ++i) { pair<int, int> a; int p; cin >> p; a.first = p; if (p % 10 == 0) a.second = 0; else a.second = 10 - p % 10; power[i] = a; } sort(power, power + n, compare); for (int i = 0; i < n; ++i) { if (power[i].first != 100) { k = k - power[i].second; if (k < 0) break; power[i].first = power[i].first + power[i].second; } } if (k > 0) { for (int i = 0; i < n; ++i) { while (power[i].first < 100 && k >= 10) { k = k - 10; power[i].first += 10; } if (k < 10) break; } } int res = 0; for (int i = 0; i < n; ++i) { res += power[i].first / 10; } cout << res << endl; }
#include <bits/stdc++.h> using namespace std; int main() { int n, a[200005]; scanf( %d , &n); for (int i = 0; i < n; i++) { scanf( %d , &a[i]); } int flag = 0; for (int i = 0; i < n; i++) { if (a[i] >= 2) a[i] %= 2; if (a[i] == 0) continue; if (i == n - 1) { flag = 1; break; } else { if (a[i + 1] > 0) a[i + 1] -= 1; else flag = 1; } } if (flag == 1) printf( NO n ); else printf( YES n ); return 0; }
#include <bits/stdc++.h> using namespace std; const int maxn = (1 << 18); struct segment { private: static const int maxn = (1 << 18); int arr[2 * maxn]; int private_sum(int node, int first, int last, int a, int b) { if (first >= a && last <= b) return arr[node]; if (a >= last || b <= first) return 0; int mid = (first + last) / 2; return private_sum(2 * node, first, mid, a, b) + private_sum(2 * node + 1, mid, last, a, b); } public: void add(int ja, int megh) { ja += maxn; while (ja > 0) { arr[ja] += megh; ja /= 2; } } int sum(int first, int last) { return private_sum(1, maxn, 2 * maxn, maxn + first, maxn + last); } int nth(int n) { int node = 1, zir = maxn; while (zir > 1) { if (n < zir / 2 - arr[2 * node]) { node *= 2; } else { n -= zir / 2 - arr[2 * node]; node = 2 * node + 1; } zir /= 2; } return node - maxn; } } p_fir, p_sec, s; int a[maxn], b[maxn], out[maxn]; void find_ab(int x, int n) { int fir = a[x], sec = b[x]; p_fir.add(fir, 1); p_sec.add(sec, 1); a[x] -= p_fir.sum(0, fir); b[x] -= p_sec.sum(0, sec); } void find_out(int n) { for (int i = 0; i < n; i++) { find_ab(i, n); } int bgh = 0; for (int i = n - 1; i >= 0; i--) { out[i] = bgh + a[i] + b[i]; if (out[i] >= n - i) { bgh = 1; out[i] -= (n - i); } else bgh = 0; } for (int i = 0; i < n; i++) { out[i] = s.nth(out[i]); s.add(out[i], 1); } } int main() { int n; cin >> n; for (int i = 0; i < n; i++) cin >> a[i]; for (int i = 0; i < n; i++) cin >> b[i]; find_out(n); for (int i = 0; i < n; i++) cout << out[i] << ; cout << endl; return 0; }
#include <bits/stdc++.h> using namespace std; void FastIO() { ios_base::sync_with_stdio(0); cin.tie(NULL); cout.tie(NULL); } long long int mod = 2e9 + 10; class SegmentTree { public: vector<int> st; vector<int> lazy; vector<int> A; int n; int left(int p) { return (p << 1) + 1; } int right(int p) { return (p << 1) + 2; } void build(int p, int l, int r) { if (l == r) st[p] = A[l]; else { build(left(p), l, (l + r) / 2); build(right(p), (l + r) / 2 + 1, r); st[p] = st[left(p)] + st[right(p)]; } } SegmentTree(vector<int> a) { A = a; n = (int)A.size(); st.assign(4 * n, 0); lazy.assign(4 * n, 0); build(0, 0, n - 1); } void lazyUpdate(int pos, int l, int r) { st[pos] += lazy[pos] * (r - l + 1); if (l != r) { lazy[left(pos)] += lazy[pos]; lazy[right(pos)] += lazy[pos]; } lazy[pos] = 0; } int query(int pos, int l, int r, int i, int j) { lazyUpdate(pos, l, r); if (i > r || j < l || l > r) return 0; if (i <= l && r <= j) { return st[pos]; } long long int q1 = query(left(pos), l, (l + r) / 2, i, j); long long int q2 = query(right(pos), (l + r) / 2 + 1, r, i, j); return (q1 + q2) % mod; } void update(int pos, int l, int r, int i, int j, int val) { lazyUpdate(pos, l, r); if (i > r || j < l || l > r) return; if (i <= l && r <= j) { st[pos] += val * (r - l + 1); if (l != r) { lazy[left(pos)] += val; lazy[right(pos)] += val; } return; } update(left(pos), l, (l + r) / 2, i, j, val); update(right(pos), (l + r) / 2 + 1, r, i, j, val); st[pos] = (st[left(pos)] + st[right(pos)]); } }; int main() { FastIO(); int n, k, a, b, q, d, x, p, type; cin >> n >> k >> a >> b >> q; vector<int> V1(n, 0), V2(n, 0), V3(n, 0); SegmentTree ST2(V2); SegmentTree ST3(V3); while (q--) { cin >> type; if (type == 1) { cin >> d >> x; d--; V1[d] += x; ST2.update(0, 0, n - 1, d, d, min(b, V1[d]) - V2[d]); V2[d] = min(b, V1[d]); ST3.update(0, 0, n - 1, n - d - 1, n - d - 1, min(a, V1[d]) - V3[n - d - 1]); V3[n - d - 1] = min(a, V1[d]); } else { cin >> p; p--; int temp1 = 0, temp2 = 0; if (p) { temp1 = ST2.query(0, 0, n - 1, 0, p - 1); } p += k - 1; p = n - p - 1; if (p) { temp2 = ST3.query(0, 0, n - 1, 0, p - 1); } cout << temp1 + temp2 << n ; } } return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 1e5 + 5; const double eps = 1e-8; const int mod = 1e9 + 7; int jia[N], jian[N], x[N], yes[N]; int out[N][3]; int abbs(int x) { if (x > 0) return x; else return -x; } int main() { int n, m, t; scanf( %d%d , &n, &m); memset(out, 0, sizeof(out)); memset(yes, 0, sizeof(yes)); memset(jia, 0, sizeof(jia)); memset(jian, 0, sizeof(jian)); int alljia = 0, alljian = 0, all = 0; for (int i = 1; i <= n; i++) { scanf( %d , &x[i]); if (x[i] > 0) jia[x[i]]++, alljia++; else jian[-x[i]]++, alljian++; } for (int i = 1; i <= n; i++) { int numzhen = jia[i] + alljian - jian[i]; if (numzhen == m) { yes[i] = 1; all++; } } for (int i = 1; i <= n; i++) { int xx = abbs(x[i]); if (yes[xx]) { if (all == 1) { if (x[i] > 0) out[i][0] = 1; else out[i][1] = 1; } else { out[i][2] = 1; } } else { if (x[i] > 0) out[i][1] = 1; else out[i][0] = 1; } } for (int i = 1; i <= n; i++) { if (out[i][2]) printf( Not defined n ); else if (out[i][0]) printf( Truth n ); else if (out[i][1]) printf( Lie n ); } return 0; }
#include <bits/stdc++.h> using namespace std; void c_p_c() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); } bool prime(long long c) { for (long long i = 2; i * i <= c; i++) { if (c % i == 0) return 0; } return 1; } int32_t main() { c_p_c(); long long n; cin >> n; while (n--) { long long a, b, s = 0; cin >> a >> b; while (a > 0 && b > 0) { if (a > b) { s += (a / b); a -= (a / b) * b; } else { s += (b / a); b -= (b / a) * a; } } cout << s << n ; } return 0; }
#include <bits/stdc++.h> int main() { int m, n, i, j, k, p, l; scanf( %d %d , &m, &n); p = m + n; int a[m], b[n], c[p]; for (i = 0; i < m; i++) { scanf( %d , &a[i]); } for (i = 0; i < n; i++) { scanf( %d , &b[i]); } k = 0; for (i = 0; i < m; i++) { for (j = 0; j < n; j++) { if (a[i] == b[j]) { c[k] = a[i]; k++; } } } l = k; for (k = 0; k < l; k++) { printf( %d , c[k]); } return 0; }
#include <bits/stdc++.h> #pragma GCC optimize( O1 ) #pragma GCC optimize( O2 ) #pragma GCC optimize( Ofast ) #pragma GCC target( avx,avx2,fma ) using namespace std; void input() { return; } template <typename T1, typename... T2> void input(T1 &x, T2 &...args) { ((cin >> x), input(args...)); } void wrt() { cout << n ; return; } template <typename T1, typename... T2> void wrt(T1 x, T2... args) { ((cout << x << ), wrt(args...)); } template <typename T> void inputlst(T &lst, int x, int y) { for (int i = x; i < y; i++) cin >> lst[i]; } template <typename T> void printlst(T &lst, int x, int y) { for (int i = x; i < y; i++) cout << lst[i] << ; wrt(); } const long long inf = INT64_MAX, MOD = 1e9 + 7, N = 10; int main(int argc, char const *argv[]) { ios_base::sync_with_stdio(false); cin.tie(nullptr); ; int test; cin >> test; while (test--) { int n, k, ans; input(n, k); vector<int> lst(n + 1); inputlst(lst, 1, n + 1); vector<vector<int> > dp(n + 1, vector<int>(n + 1, 0)); ans = n; for (long long move = 0; move < n + 1; ++move) { for (long long i = 1; i < n + 1; ++i) { dp[i][move] = max(dp[i][move], dp[i - 1][move] + (lst[i] == (i - move))); dp[i][move + 1] = max(dp[i - 1][move], dp[i][move + 1]); if (i == n) { if (dp[i][move] >= k) ans = min(ans, (int)move); if (dp[i][move + 1] >= k) ans = min(ans, (int)move + 1); } } } wrt(ans == n ? -1 : ans); } return 0; }
#include <bits/stdc++.h> using namespace std; void debug() { cout << endl; } template <class T, class... R> void debug(T f, R... r) { cout << [ << f << ] ; debug(r...); } template <class T> T mmin(T a, T b) { return min(a, b); } template <class T, class... R> T mmin(T a, R... b) { return min(a, mmin(b...)); } template <class T> T mmax(T a, T b) { return max(a, b); } template <class T, class... R> T mmax(T a, R... b) { return max(a, mmax(b...)); } template <class T> T mgcd(T a, T b) { return __gcd(a, b); } template <class T, class... R> T mgcd(T a, R... b) { return __gcd(a, mgcd(b...)); } void myin() { freopen( 1.in , r , stdin); freopen( 1.out , w , stdout); } namespace IO { const int MX = 4e7; char buf[MX]; int c, sz; void begin() { c = 0; sz = fread(buf, 1, MX, stdin); } inline bool read(int &t) { while (c < sz && buf[c] != - && (buf[c] < 0 || buf[c] > 9 )) c++; if (c >= sz) return false; bool flag = 0; if (buf[c] == - ) flag = 1, c++; for (t = 0; c < sz && 0 <= buf[c] && buf[c] <= 9 ; c++) t = t * 10 + buf[c] - 0 ; if (flag) t = -t; return true; } } // namespace IO const int N = 1e5 + 5; const int M = 1e5 + 5; long long a[100005], e[200][200]; vector<long long> v, sz[100]; int main() { long long n; scanf( %lld , &n); for (long long i = 1; i <= n; ++i) { long long tmp; scanf( %lld , &a[i]); if (a[i]) v.push_back(a[i]); for (long long j = 0; j < 63; ++j) { if ((1ll << j) & a[i]) sz[j].push_back(a[i]); } } for (long long i = 0; i < 63; ++i) if (sz[i].size() > 2) { return !printf( 3 ); } memset(e, 0x3f, sizeof(e)); long long ans = 0x3f3f3f3f3f3f3f3f; for (long long i = 0; i < v.size(); ++i) { for (long long j = 0; j < v.size(); ++j) { if (i != j && (v[i] & v[j])) e[i][j] = 1; } } for (long long k = 0; k < v.size(); ++k) { for (long long i = 0; i < v.size(); ++i) { for (long long j = 0; j < v.size(); ++j) { if (i == j || i == k || j == k) continue; if ((v[i] & v[k] && v[k] & v[j])) ans = min(ans, e[i][j] + 2); } } for (long long i = 0; i < v.size(); ++i) { for (long long j = 0; j < v.size(); ++j) { e[i][j] = min(e[i][j], e[i][k] + e[k][j]); } } } if (ans == 0x3f3f3f3f3f3f3f3f) ans = -1; printf( %lld n , ans); return 0; }
#include <bits/stdc++.h> const long double PI = acos(-1.0); using namespace std; int n, m; long long dp[505][505]; int a[505]; long long cal(int l, int r) { if (l >= r) return 1; long long &ret = dp[l][r]; if (ret != -1) return ret; ret = 0; int mn = n + 1, idx = 0; for (int i = l; i <= r; i++) { if (a[i] < mn) { mn = a[i]; idx = i; } } long long lft = cal(l, idx - 1); long long rgh = cal(idx + 1, r); for (int i = l; i < idx; i++) { lft += cal(l, i) * cal(i + 1, idx - 1); lft %= 998244353; } for (int i = idx + 1; i <= r; i++) { rgh += cal(idx + 1, i) * cal(i + 1, r); rgh %= 998244353; } lft %= 998244353; rgh %= 998244353; ret = rgh * lft; ret %= 998244353; return ret; } void init() { memset(dp, -1, sizeof dp); } void read_input() { cin >> n >> m; for (int i = 0; i < n; i++) cin >> a[i]; } void solve() { init(); cal(0, n - 1); } void print_ans() { cout << cal(0, n - 1) << n ; } int main() { int t = 1; while (t--) { read_input(); solve(); print_ans(); if (t) init(); } }
#include <bits/stdc++.h> using namespace std; int main() { int n, i, j, k, l, m[1100]; char s[1100][34]; scanf( %d , &n); map<string, int> mp, mp2; for (i = 0; i < n; i++) { scanf( %s%d , s[i], &m[i]); mp[s[i]] += m[i]; } string name; int max = 0; for (map<string, int>::iterator it = mp.begin(); it != mp.end(); it++) { if (it->second > max) max = it->second; } for (i = 0; i < n; i++) { mp2[s[i]] += m[i]; if (mp[s[i]] >= max && mp2[s[i]] >= max) break; } puts(s[i]); scanf( %*d ); }
#include <bits/stdc++.h> using namespace std; struct node { int st, ed; } ch[100010]; bool cmp(node a, node b) { return a.st < b.st; } int main() { ios::sync_with_stdio(false); cin.tie(0); int n, l, a; cin >> n >> l >> a; for (int i = 0; i < n; i++) { cin >> ch[i].st >> ch[i].ed; ch[i].ed += ch[i].st; } sort(ch, ch + n, cmp); int num = 0; num += (ch[0].st) / a; for (int i = 0; i < n - 1; i++) { if (ch[i + 1].st - ch[i].ed >= a) { num += (ch[i + 1].st - ch[i].ed) / a; } } if (ch[n - 1].ed < l) { num += (l - ch[n - 1].ed) / a; } cout << num << endl; return 0; }
#include <bits/stdc++.h> using namespace std; long long int x2, y2, x3, y3; bool check(long long int x, long long int y) { long long int xx = x3 * x3 + y3 * y3, tx = x2 + x, ty = y2 + y; if (xx == 0) return x == x2 && y == y2; long long int ret1 = tx * x3 + ty * y3, ret2 = tx * y3 - ty * x3; if (ret1 % xx != 0 || ret2 % xx != 0) return false; return true; } int main() { long long int x1, y1; cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3; if (check(x1, y1) || check(-x1, -y1) || check(-y1, x1) || check(y1, -x1)) cout << YES n ; else cout << NO n ; }
#include <bits/stdc++.h> using namespace std; struct debugger { template <typename T> debugger& operator,(const T& v) { cerr << v << ; return *this; } } dbg; vector<int> aa(200); vector<int> bb(200); int n, k; int count(int i, int j) { for (int h = i; h < n; h++) { bb[h - i] = aa[h]; } for (int h = 0; h < i; h++) { bb[n - i + h] = aa[h]; } int m = j - i; sort(bb.begin(), bb.begin() + m); sort(bb.begin() + m, bb.begin() + n); int sum = 0; for (int h = 0; h < m; h++) { sum += bb[h]; } for (int s = 0; s < k; s++) { int p = s; int q = n - 1 - s; if (p >= m || q < m || bb[p] >= bb[q]) { break; } sum += bb[q] - bb[p]; } return sum; } int main() { cin >> n >> k; for (int i = 0; i < n; i++) { int a; cin >> a; aa[i] = a; } int maxVal = INT_MIN; for (int i = 0; i < n; i++) { for (int j = i + 1; j <= n; j++) { int cnt = count(i, j); maxVal = max(maxVal, cnt); } } cout << maxVal << endl; }
#include <bits/stdc++.h> using namespace std; int main() { int t, n; cin >> t; for (int l = 0; l < t; l++) { cin >> n; int k; k = 0; int c; c = 0; char arr[n][5]; for (int i = 0; i < n; i++) { for (int j = 0; j < 5; j++) { cin >> arr[i][j]; } } for (int j = 0; j < 5; j++) { k = 0; for (int m = j + 1; m < 5; m++) { int first = 0; int second = 0; int tie = 0; for (int n1 = 0; n1 < n; n1++) { if (arr[n1][j] == 1 && arr[n1][m] == 1 ) { tie++; } else { if (arr[n1][j] == 1 ) { second++; } if (arr[n1][m] == 1 ) { first++; } } } if (first + second + tie == n && second + tie >= n / 2 && first + tie >= n / 2) { c = 1; } } } if (c == 0) { cout << NO << endl; } else { cout << YES << endl; } } return 0; }
#include <bits/stdc++.h> #pragma GCC optimize( Ofast ) #pragma GCC optimize( unroll-loops ) #pragma GCC target( sse2 ) using namespace std; template <typename Arg1> void __f(const char* name, Arg1&& arg1) { std::cerr << name << : << arg1 << n ; } template <typename Arg1, typename... Args> void __f(const char* names, Arg1&& arg1, Args&&... args) { const char* comma = strchr(names + 1, , ); std::cerr.write(names, comma - names) << : << arg1 << | ; __f(comma + 1, args...); } long long max(long long a, long long b) { return (a > b) ? a : b; } long long min(long long a, long long b) { return (a < b) ? a : b; } void amax(long long& a, long long b) { a = max(a, b) % 1000000007; } void amin(long long& a, long long b) { a = min(a, b) % 1000000007; } void inc(long long& a, long long b) { a = (a + b) % 1000000007; } void dec(long long& a, long long b) { a = (a - b + 1000000007) % 1000000007; } long long n, a, b; long long ans = 1e9; void find(long long la, long long lb, long long level = 0) { if (la == 0 && lb == 0) { amin(ans, level); return; } for (long long i = 0; i <= la; i++) { long long n2 = n - i * a; if (n2 < 0) break; long long usedb = min(n2 / b, lb); n2 -= usedb * b; long long ii = i; ii += n2 / a; long long temp = n2 / a; n2 -= temp * a; ii = min(la, ii); if (usedb == 0 && ii == 0) continue; find(la - ii, lb - usedb, level + 1); } } long long solve() { cin >> n >> a >> b; find(4, 2); cout << ans; return 0; } signed main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); long long t = 1; while (t--) { solve(); } }
#include <bits/stdc++.h> using namespace std; int main() { int n, k; cin >> n >> k; int *arr = new int[2 * n + 1]; cin >> arr[0]; for (int i = 1; i < 2 * n + 1; i += 2) { cin >> arr[i] >> arr[i + 1]; if (k > 0 && arr[i] > arr[i - 1] + 1 && arr[i] > arr[i + 1] + 1) { k -= 1; arr[i] -= 1; } } for (int i = 0; i < 2 * n + 1; i++) cout << arr[i] << ; cout << n ; }
#include <bits/stdc++.h> using namespace std; const int maxn = 105; int no[maxn][maxn][15], sum[maxn][maxn][15]; int main() { int n, q, c, ans, i, j, k, x, y, s, ss, t, x1, x2, y1, y2, tt, num; while (scanf( %d%d%d , &n, &q, &c) != EOF) { memset(no, 0, sizeof(no)); memset(sum, 0, sizeof(sum)); for (i = 1; i <= n; i++) { scanf( %d%d%d , &x, &y, &s); no[x][y][s]++; } for (j = 1; j <= 100; j++) { for (i = 1; i <= 100; i++) { for (k = 0; k <= c; k++) { sum[i][j][k] = sum[i - 1][j][k] + no[i][j][k]; } } } while (q--) { ans = 0; scanf( %d%d%d%d%d , &t, &x1, &y1, &x2, &y2); for (j = y1; j <= y2; j++) { for (k = 0; k <= c; k++) { num = sum[x2][j][k] - sum[x1][j][k] + no[x1][j][k]; if (num > 0) { if (t <= c - k) ss = k + t; else { x = t - (c - k); tt = x % (c + 1); if (tt) ss = tt - 1; else ss = c; } ans += num * ss; } } } printf( %d n , ans); } } return 0; }
#include <bits/stdc++.h> const int MaxN = 52, mod_v = 1000000007; long long f[MaxN][MaxN >> 1][2], C[MaxN][MaxN]; void init_comb(int n) { for (int i = 0; i <= n; ++i) { C[i][i] = C[i][0] = 1; for (int j = 1; j < i; ++j) { C[i][j] = C[i - 1][j] + C[i - 1][j - 1]; if (C[i][j] >= mod_v) C[i][j] -= mod_v; } } } int main() { int n0, k0; std::cin >> n0 >> k0; if (k0 << 1 > n0) { std::cout << 0 n ; return 0; } init_comb(n0); f[1][0][0] = 1; f[0][0][1] = 1; for (int n = 2; n <= n0; ++n) { for (int k = 1; k <= std::min(k0, n >> 1); ++k) { for (int g = 0; g <= 1; ++g) { long long& val = f[n][k][g]; for (int n1 = 0, n2 = n - 1; n1 <= n2; ++n1, --n2) { long long ways; if (n1 != n2) ways = C[n - 1][n1]; else ways = C[n - 2][n1 - 1]; if (n1) ways = ways * n1 * n2 % mod_v; else ways = ways * n2 % mod_v; for (int k1 = 0; k1 + g <= k; ++k1) { int k2 = k - k1 - g; if (g == 0) { val += f[n1][k1][1] * f[n2][k2][1] % mod_v * ways % mod_v; } else { val += (f[n1][k1][1] * f[n2][k2][0] + f[n1][k1][0] * f[n2][k2][1] + f[n1][k1][0] * f[n2][k2][0]) % mod_v * ways % mod_v; } } val %= mod_v; } } } } std::cout << (f[n0][k0][0] + f[n0][k0][1]) % mod_v << std::endl; return 0; }
#include <bits/stdc++.h> using namespace std; vector<int> v1; int status[(100000007 / 32) + 10]; bool check1(int n, int pos) { return (bool)(n & (1 << pos)); } int set1(int n, int pos) { return n = n | (1 << pos); } void sieve() { int i, j, k; k = int(sqrt(100000007)); for (i = 3; i <= k; i += 2) { if (check1(status[i / 32], i % 32) == 0) { for (j = i * i; j <= 100000007; j += 2 * i) { status[j / 32] = set1(status[j / 32], j % 32); } } } v1.push_back(2); for (i = 3; i < 100000007; i += 2) { if (check1(status[i / 32], i % 32) == 0) v1.push_back(i); } } vector<long long int> v2; void factor(long long int k) { long long int i, a; v2.clear(); for (i = 0; i < v1.size(); i++) { if (k == 1) break; a = v1[i]; while (k % a == 0) { if (k == 1) break; v2.push_back(a); k /= a; } } if (k != 1) v2.push_back(k); } int main() { sieve(); long long int a, b, c, d, i, j, k, l, m, n; cin >> n; factor(n); if (v2.size() == 1 || v2.size() == 0) { cout << 1 << endl; cout << 0 << endl; return 0; } if (v2.size() == 2) { cout << 2 << endl; return 0; } cout << 1 << endl; cout << v2[0] * v2[1] << endl; return 0; }
#include <bits/stdc++.h> using namespace std; const int MAXN = 100 + 5; const int inf = 1e9 + 7; int n, m; int num[MAXN]; map<int, int> q; int main() { scanf( %d , &n); for (int i = 1; i <= n; ++i) scanf( %d , &num[i]); for (int i = 2; i <= n; ++i) { q[num[i] - num[i - 1]]++; } if (q.size() == 1) printf( %d n , num[n] + num[2] - num[1]); else printf( %d n , num[n]); return 0; }
#include <bits/stdc++.h> using namespace std; string ulaz, jed = 1 , dva = 14 , tri = 144 ; bool je[10]; int main() { cin >> ulaz; int l = ulaz.size(); for (int i = 0; i < l; i++) je[i] = false; for (int i = 0; i < l; i++) { if (je[i] == true) continue; if (i + 2 < l) { string nov; nov = ulaz[i]; nov += ulaz[i + 1]; nov += ulaz[i + 2]; if (nov == tri) { je[i] = true; je[i + 1] = true; je[i + 2] = true; i += 2; continue; } } if (i + 1 < l) { string nov; nov = ulaz[i]; nov += ulaz[i + 1]; if (nov == dva) { je[i] = true; je[i + 1] = true; i += 1; continue; } } if (ulaz[i] == jed[0]) { je[i] = true; continue; } } for (int i = 0; i < l; i++) if (je[i] == false) { cout << NO << endl; return 0; } cout << YES << endl; return 0; }
#include <bits/stdc++.h> using namespace std; using ll = long long; const ll P = 1e9 + 7; ll N, M, K, R, C; ll Dx, Dy; ll mult(ll a, ll b) { return (a * b) % P; } ll exp(ll num_classes) { if (num_classes == 0) { return 1; } ll temp = exp(num_classes / 2); return (num_classes % 2) ? mult(K, mult(temp, temp)) : mult(temp, temp); } void input() { ll Ax, Ay, Bx, By; cin >> N >> M >> K >> R >> C; cin >> Ax >> Ay >> Bx >> By; Dx = (Ax > Bx) ? Ax - Bx : Bx - Ax; Dy = (Ay > By) ? Ay - By : By - Ay; } ll count_classes() { ll overlap = ((R > Dx) ? R - Dx : 0) * ((C > Dy) ? C - Dy : 0); ll classes = N * M - (2 * R * C - overlap); if (overlap == 0) { return classes + R * C; } if (Dx == 0 && Dy == 0) { return classes + R * C; } return classes + (R * Dy) + (C * Dx) - Dx * Dy; } int main() { input(); cout << exp(count_classes()) << endl; }
#include <bits/stdc++.h> using namespace std; int main() { int num; scanf( %d , &num); printf( %d , num + 1); }
#include <bits/stdc++.h> using namespace std; const long long mod = (1e9 + 7); const long long inf = (1e18 + 3); const long long N = 1e7 + 5; void no() { cout << -1 ; exit(0); } void yes() { cout << YES ; exit(0); } long long powmod(long long a, long long b) { long long res = 1; a %= mod; assert(b >= 0); for (; b; b >>= 1) { if (b & 1) res = res * a % mod; a = a * a % mod; } return res; } long long inv(long long a) { return powmod(a, mod - 2); } long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; } long long mul(long long a, long long b) { return a * b % mod; } long long add(long long a, long long b) { return (a + b) % mod; } long long sub(long long a, long long b) { return (a - b + mod) % mod; } int main() { string s; cin >> s; long long cnt = 1, res = 0; for (auto i : s) { if (i == a ) cnt <<= 1, cnt %= mod; else res = add(res, cnt - 1); } cout << res; return 0; }
#include <bits/stdc++.h> using namespace std; bool checkC(int n) { for (int i = 2; i * i <= n; i++) { if (n % i == 0) return 1; } return 0; } void per(string s, int i, int &num, string &ans) { if (i == s.length()) { if (num != 0 && checkC(num)) { int x = num; int d = 0; while (x != 0) { x /= 10; d++; } if (d > 0) { if (d < ans.length() || ans.length() == 0) ans = to_string(num); } } } else { int k = num; num = num * 10 + (s[i] - 0 ); per(s, i + 1, num, ans); num = k; per(s, i + 1, num, ans); } } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); int test; cin >> test; while (test--) { int k; cin >> k; string s; cin >> s; vector<int> c(10, 0); int ans = -1; for (int i = 0; i < k; i++) { int vl = s[i] - 0 ; if (vl == 1 || vl == 4 || vl == 6 || vl == 8 || vl == 9) { ans = vl; break; } c[vl]++; } if (ans != -1) { cout << 1 n ; cout << ans << n ; } else { if (c[2] >= 2) { cout << 2 n ; cout << 22 n ; } else if (c[3] >= 2) { cout << 2 n ; cout << 33 n ; } else if (c[5] >= 2) { cout << 2 n ; cout << 55 n ; } else if (c[7] >= 2) { cout << 2 n ; cout << 77 n ; } else { string pa = ; int num = 0; per(s, 0, num, pa); cout << pa.length() << n ; cout << pa << n ; } } } }
#include <bits/stdc++.h> using namespace std; const int Maxn = 500010; const int inf = 2147483647; const double pi = acos(-1.0); int read() { int x = 0, f = 1; char ch = getchar(); while (ch < 0 || ch > 9 ) { if (ch == - ) f = -1; ch = getchar(); } while (ch >= 0 && ch <= 9 ) x = x * 10 + ch - 0 , ch = getchar(); return x * f; } int n, m, k, a[Maxn]; long long ans, rest; bool del[Maxn]; struct Edge { int x, y; } e[Maxn]; int fa[Maxn << 1], dep[Maxn << 1]; int findfa(int x) { return ((fa[x] == x) ? x : findfa(fa[x])); } int top = 0, sta[Maxn << 1], o, fa1[Maxn << 1], dep1[Maxn << 1]; void merge(int x, int y) { int fx = findfa(x), fy = findfa(y); if (dep[fx] < dep[fy]) swap(fx, fy); sta[++top] = fy; fa1[top] = fa[fy], dep1[top] = dep[fx]; fa[fy] = fx; dep[fx] = max(dep[fx], dep[fy] + 1); } void resume() { while (top > o) { int fy = sta[top]; dep[fa[fy]] = dep1[top]; fa[fy] = fa1[top]; --top; } } vector<pair<int, int> > g[Maxn]; int tot = 0; map<int, map<int, int> > mp; int main() { memset(dep, 0, sizeof(dep)); memset(del, false, sizeof(del)); n = read(), m = read(), k = read(); ans = (long long)k * (k - 1ll) / 2ll; rest = k - 1; for (int i = 1; i <= n; i++) a[i] = read(); for (int i = 1; i <= m; i++) e[i].x = read(), e[i].y = read(); for (int i = 1; i <= n * 2; i++) fa[i] = i; for (int i = 1; i <= m; i++) if (!del[a[e[i].x]] && a[e[i].x] == a[e[i].y]) { int fx = findfa(e[i].x), fy = findfa(e[i].y); if (fx == fy) del[a[e[i].x]] = true, ans -= rest, rest--; else merge(e[i].x, e[i].y + n), merge(e[i].y, e[i].x + n); } o = top; for (int i = 1; i <= m; i++) if (a[e[i].x] != a[e[i].y] && !del[a[e[i].x]] && !del[a[e[i].y]]) { int cx = a[e[i].x], cy = a[e[i].y]; if (cx > cy) swap(cx, cy); if (!mp[cx][cy]) mp[cx][cy] = ++tot; g[mp[cx][cy]].push_back(make_pair(e[i].x, e[i].y)); } for (int i = 1; i <= tot; i++) { for (int j = 0; j < g[i].size(); j++) { int x = g[i][j].first, y = g[i][j].second; int fx = findfa(x), fy = findfa(y); if (fx == fy) { ans--; break; } merge(x, y + n); merge(y, x + n); } resume(); } printf( %lld , ans); }
#include <bits/stdc++.h> using namespace std; int main() { long long a, b, c, l; cin >> a >> b >> c >> l; long long cnt = (l + 1) * (l + 2) * (l + 3) / 6; for (int i = 0; i <= l; i++) { long long x = min(l - i, c + i - a - b); if (x < 0) continue; cnt -= (x + 1) * (x + 2) / 2; } for (int i = 0; i <= l; i++) { long long x = min(l - i, b + i - a - c); if (x < 0) continue; cnt -= (x + 1) * (x + 2) / 2; } for (int i = 0; i <= l; i++) { long long x = min(l - i, a + i - b - c); if (x < 0) continue; cnt -= (x + 1) * (x + 2) / 2; } cout << cnt << endl; }
#include <bits/stdc++.h> using namespace std; const int INF = 1000000007; const long long INFLL = 1000000000000000007; const long long MOD = 998244353; bool comp(long long a, long long b) { return a > b; } int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); ; int n, k; cin >> n >> k; vector<long long> v; for (int i = 0; i < n; i++) { long long x; cin >> x; v.push_back(x); } long long ans = 0, ans1 = 1, licz = -INFLL; for (int i = 0; i < n; i++) { if (v[i] <= n - k) licz++; else { if (licz > 0) ans1 *= (licz + 1); ans1 %= MOD; ans += v[i]; licz = 0; } } cout << ans << << ans1; return 0; }
#include <bits/stdc++.h> #pragma GCC optimize( Ofast ) #pragma GCC target( avx,avx2,fma ) using namespace std; const int MOD = 1e9 + 7; const long long INF = 1e18; long long add(long long a, long long b) { a = a % MOD; b = b % MOD; return (a + b) % MOD; } long long sub(long long a, long long b) { a = a % MOD; b = b % MOD; return (a - b + MOD) % MOD; } long long mul(long long a, long long b) { a = a % MOD; b = b % MOD; return ((a * b) % MOD + MOD) % MOD; } long long mod_pow(long long n, long long x) { int res = 1; while (x > 0) { if (x % 2 == 1) res = (res * n) % MOD; n = (n * n) % MOD; x /= 2; } return res; } void solve() { string t, order = ; cin >> t; map<char, int> m; int n = 0; for (int i = t.size() - 1; i >= 0; i--) { if (m[t[i]] == 0) { order = t[i] + order; } m[t[i]]++; } for (int i = 0; i < order.size(); i++) { m[order[i]] /= (i + 1); n += m[order[i]]; } string s = t.substr(0, n); string sc = s; bool temp = true; int ind = n; for (int i = 0; i < order.size(); i++) { string temp = ; for (int j = 0; j < s.size(); j++) { if (s[j] == order[i]) continue; temp += s[j]; } s = temp; for (int j = 0; j < s.size(); j++) { if (ind == t.size() || t[ind] != s[j]) { cout << -1 n ; return; } ind++; } } if (ind != t.size()) temp = false; if (temp) { cout << sc << << order << n ; } else { cout << -1 n ; } } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); int tc = 1; cin >> tc; while (tc--) { solve(); } }
#include <bits/stdc++.h> using namespace std; void c_p_c() {} int main(int argc, char const *argv[]) { c_p_c(); ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); ; int n; string arr; cin >> n >> arr; int cnt = 0; if (n == 1) { cout << cnt << endl; cout << arr << endl; return 0; } for (int i = 1; i < n; i++) { if (arr[i] == arr[i - 1] && arr[i] == arr[i + 1]) { cnt++; if (arr[i] == R ) arr[i] = G ; else if (arr[i] == G ) arr[i] = R ; else { arr[i] = G ; } i++; } else if (arr[i] == arr[i - 1]) { cnt++; if (arr[i] == R && arr[i + 1] == B ) { arr[i] = G ; i++; } else if (arr[i] == R && arr[i + 1] == G ) { arr[i] = B ; i++; } else if (arr[i] == G && arr[i + 1] == R ) { arr[i] = B ; i++; } else if (arr[i] == G && arr[i + 1] == B ) { arr[i] = R ; i++; } else if (arr[i] == B && arr[i + 1] == G ) { arr[i] = R ; i++; } else if (arr[i] == B && arr[i + 1] == R ) { arr[i] = G ; i++; } else { if (arr[i - 1] == R ) arr[i] = G ; else if (arr[i - 1] == G ) arr[i] = R ; else arr[i] = R ; } } } cout << cnt << endl; cout << arr << endl; }
#include <bits/stdc++.h> using namespace std; const long long infll = powl(2, 62) - 1; const long long mod = pow(10, 9) + 7; int64_t extGcd(int64_t a, int64_t b, int64_t& x, int64_t& y) { if (!a) { x = 0; y = 1; return b; } int64_t x1, y1; int64_t d = extGcd(b % a, a, x1, y1); x = y1 - (b / a) * x1; y = x1; return d; } inline long long addMod(long long a, long long b, long long m = mod) { return ((int64_t)a + b) % m; } inline long long mulMod(long long a, long long b, long long m = mod) { return ((int64_t)a * b) % m; } inline long long divMod(long long a, long long b, long long m = mod) { int64_t x, y; int64_t g = extGcd(b, m, x, y); if (g != 1) { cerr << Bad gcd! << endl; for (;;) ; } x = (x % m + m) % m; return mulMod(a, x, m); } const long long factRange = 1000000; long long fact[factRange]; inline void precalcFactorials() { fact[0] = 1; for (long long i = 1; i < factRange; i++) { fact[i] = mulMod(fact[i - 1], i); } } inline long long F(long long n) { return (n < 0) ? 0 : fact[n]; } inline long long C(long long n, long long k) { return divMod(F(n), mulMod(F(n - k), F(k))); } int32_t main() { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); precalcFactorials(); string bracket; cin >> bracket; vector<long long> open(bracket.size()), close(bracket.size()); long long count = 0; for (long long i = 0; i < (long long)(bracket.size()); ++i) { if (bracket[i] == ( ) count++; open[i] = count; } count = 0; for (long long i = (long long)(bracket.size()) - 1; i >= 0; --i) { if (bracket[i] == ) ) count++; close[i] = count; } long long ans = 0; for (long long i = 0; i < (long long)(bracket.size()); ++i) { if (bracket[i] != ( || close[i] == 0) continue; if (bracket[i] == ( ) { ans += C(open[i] + close[i] - 1, open[i]); ans %= mod; } } cout << ans << endl; return 0; }
#include <bits/stdc++.h> using namespace std; void Input_Preparing() {} void Processing() { int a, b; cin >> a >> b; cout << min(a, b) << << (max(a, b) - min(a, b)) / 2; } int main() { std::cin.tie(0)->sync_with_stdio(0); ; Processing(); return 0; }
#include <bits/stdc++.h> using namespace std; int l[(100000 + 10)], size = 0; int fa[(100000 + 10)], son[(100000 + 10)], n, x, spec, specp; bool b[(100000 + 10)] = {0}, f[(100000 + 10)] = {0}; int main() { scanf( %d%d , &n, &x); for (int i = 1; i <= n; i++) scanf( %d , &fa[i]); for (int i = 1; i <= n; i++) if (fa[i]) son[fa[i]] = i; for (int i = 1; i <= n; i++) if (fa[i] == 0) { int tot = 1, j = i; bool flag = b[x]; b[i] = 1; j = i; if (i == x) spec = 1; while (son[j]) { b[son[j]] = 1, tot++, j = son[j]; if (j == x) spec = tot; } if (b[x] == flag) l[++size] = tot; else specp = spec; } f[0] = 1; for (int i = 1; i <= size; i++) { for (int j = n; j >= 0; j--) { if (f[j]) f[j + l[i]] = 1; } } for (int j = 0; j < n + 1; j++) if (f[j]) cout << j + specp << endl; return 0; }
#include <bits/stdc++.h> using namespace std; string to_string(string s) { return + s + ; } string to_string(const char* s) { return to_string((string)s); } template <typename A, typename B> string to_string(pair<A, B> p) { return ( + to_string(p.first) + , + to_string(p.second) + ) ; } template <typename A> string to_string(A v) { bool first = true; string res = { ; for (const auto& x : v) { if (!first) { res += , ; } first = false; res += to_string(x); } res += } ; return res; } void debug_out() { cerr << endl; } template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) { cerr << << to_string(H); debug_out(T...); } const long double eps = 1e-12; const int N = 2e6 + 9; long long ans[N]; pair<pair<int, int>, int> a[N]; int main() { ios::sync_with_stdio(false); cin.tie(0); int n, m; cin >> n >> m; for (int i = 0; i < n; i++) { cin >> a[i].first.first; a[i].second = i; } for (int i = 0; i < n; i++) { cin >> a[i].first.second; a[i].first.second *= -1; } sort(a, a + n); multiset<int> ss; for (int i = 0; i < n; i++) { 42; int j = 0; auto it = ss.begin(); ans[a[i].second] = a[i].first.second; while (j < m && it != ss.end()) { ans[a[i].second] += (*it); it++; j++; } ss.insert(a[i].first.second); } for (int i = 0; i < n; i++) cout << -ans[i] << ; cout << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int a[200001]; int main() { int n, w; cin >> n >> w; for (int i = 0; i < 2 * n; i++) { cin >> a[i]; } sort(a, a + 2 * n); double x = min((double)a[0], (double)a[n] / 2); double ans = min((double)w, (double)3 * n * x); cout.precision(10); cout << fixed; cout << ans << endl; return 0; }
#include <bits/stdc++.h> using namespace std; const int maxn = 1e5 + 5; const int mod = 1e9 + 7; void solve() { long long v1, v2, t, d; cin >> v1 >> v2 >> t >> d; long long ans = 0; for (int i = 0; i < t; i++) ans += min(v1 + d * i, v2 + (t - i - 1) * d); cout << ans << endl; } int main() { ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); int t = 1; while (t--) solve(); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { long long n; cin >> n; for (long long i = 0; i < n; i++) { for (long long j = 0; j < n; j++) { if (i % 2 == 0 && j % 2 == 0 || i % 2 == 1 && j % 2 == 1) cout << W ; else cout << B ; } cout << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; vector<pair<long long, long long> > v(3000); int main() { std::ios::sync_with_stdio(false); long long n, x1, y1, x2, y2, x, y; cin >> n; cin >> x1 >> y1 >> x2 >> y2; long long d1, d2; for (long long i = (long long)(0); i <= (long long)(n - 1); i++) { cin >> x >> y; v[i].first = abs(x - x1) * abs(x - x1) + abs(y - y1) * abs(y - y1); v[i].second = abs(x - x2) * abs(x - x2) + abs(y - y2) * abs(y - y2); } v.push_back(make_pair(0, 0)); long long ans = LLONG_MAX; for (long long i = (long long)(0); i <= (long long)(n); i++) { long long d1 = v[i].first; long long d2 = 0; for (long long j = (long long)(0); j <= (long long)(n); j++) { if (v[j].first > d1) d2 = max(v[j].second, d2); } ans = min(ans, d1 + d2); } cout << ans << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int rbq[505][505]; int score[505]; int main() { int n, m, q; while (~scanf( %d%d%d , &n, &m, &q)) { for (int i = 1; i <= n; i++) { for (int j = 1; j <= m; j++) { scanf( %d , &rbq[i][j]); } } for (int i = 1; i <= n; i++) { int max = 0; for (int j = 1; j <= m; j++) { int count = 0; while (j <= m && rbq[i][j] == 1) { j++; count++; } if (count > max) max = count; } score[i] = max; } for (int i = 0; i < q; i++) { int r, l; scanf( %d%d , &r, &l); if (rbq[r][l] == 0) rbq[r][l] = 1; else rbq[r][l] = 0; int max = 0; for (int j = 1; j <= m; j++) { int count = 0; while (j <= m && rbq[r][j] == 1) { j++; count++; } if (count > max) max = count; } score[r] = max; int max_score = 0; for (int j = 1; j <= n; j++) { if (score[j] > max_score) max_score = score[j]; } printf( %d n , max_score); } } return 0; }
#include <bits/stdc++.h> #define f(c,a,b) for(int c=a; c<=b; c++) #define N 5000010 #define pii pair<int,int> #define mp make_pair #define fi first #define se second #define sl (u<<1) #define sr ((u<<1)+1) #define pb push_back using namespace std; typedef double db; typedef long long ll; struct node{ int u,v,x; bool operator < (const node& a) const{ return x<a.x; } }b[N]; int k[N]; bool ask(int i,int j){ cout<< ? <<i<< <<j<<endl; string ans; cin>>ans; if(ans== Yes ) return true; else return false; } int main(){ // freopen( owo.in , r ,stdin); // ios::sync_with_stdio(false); // cin.tie(nullptr); int n; cin >> n; f(i,1,n) cin>>k[i]; int id=0; f(i,1,n){ f(j,i+1,n){ b[++id] = (node){ i,j,abs(k[i]-k[j]) }; } } sort(b+1,b+id+1); for(int i=id; i>=1; i--) { int ti=b[i].u, tj=b[i].v; if(k[ti]>k[tj]) { if(ask(ti,tj)){ cout<< ! <<ti<< <<tj<<endl; return 0; } }else{ if(ask(tj,ti)){ cout<< ! <<ti<< <<tj<<endl; return 0; } } } cout<< ! <<0<< <<0<<endl; return 0; }