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 main() { int n; cin >> n; int x = 0, y = 0; char s[n]; for (int i = 0; i < n; i++) { cin >> s[i]; if (s[i] == 0 ) y++; else x++; } if (x == y) { cout << 2 << endl << s[0] << ; for (int i = 1; i < n; i++) cout << s[i]; } else { cout << 1 << endl; for (int i = 0; i < n; i++) cout << s[i]; } return 0; }
#include <bits/stdc++.h> using namespace std; long long n, k; long long a[100010]; signed main() { scanf( %lld%lld , &n, &k); long long cnt = 1; long long l = 1; long long ans = 0; for (long long i = 1; i <= n; i++) { scanf( %lld , &a[i]); cnt = cnt * a[i] % k; if (!cnt) { cnt = 1; long long j; for (j = i; j >= 1 && cnt * a[j] % k; j--) cnt = cnt * a[j] % k; ans += (n - i + 1) * (j - l + 1); l = j + 1; } } cout << ans; return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 200001; int n; vector<pair<int, int> > a[N * 2]; vector<int> odd; int used[N * 2], cur[N * 2]; char res[N]; void dfs(int u) { while (cur[u] < a[u].size()) { int v = a[u][cur[u]].first; int pos = a[u][cur[u]].second; if (used[pos]) { cur[u]++; continue; } if (pos <= n) { if (u < N) { res[pos] = b ; } else { res[pos] = r ; } } used[pos] = 1; dfs(v); cur[u]++; } } int main() { ios_base::sync_with_stdio(0); cin >> n; for (int i = 1; i <= n; i++) { int x, y; cin >> x >> y; a[x].push_back(make_pair(y + N, i)); a[y + N].push_back(make_pair(x, i)); } for (int i = 1; i < N * 2; i++) { if (a[i].size() % 2) { odd.push_back(i); } used[i] = cur[i] = 0; } int cnt = n; for (int i = 0; i < odd.size(); i += 2) { cnt++; a[odd[i]].push_back(make_pair(odd[i + 1], cnt)); a[odd[i + 1]].push_back(make_pair(odd[i], cnt)); } for (int i = 1; i < N * 2; i++) { dfs(i); } cout << (res + 1); return 0; }
#include <bits/stdc++.h> using namespace std; const long long linf = 1e18 + 5; const int mod = (int)1e9 + 7; const int logN = 17; const int inf = 1e9; const int N = 2e5 + 5; int n, a[N], s; vector<pair<long long, long long> > T[N << 2], g[N << 2]; pair<long long, long long> line[N]; long long pre[N]; int P[N << 2]; double intersect(pair<long long, long long> x, pair<long long, long long> y) { return (y.second - x.second) * 1.0 / (x.first - y.first); } void add(vector<pair<long long, long long> > &T, pair<long long, long long> x) { int s = T.size() - 1; while (s > 0 && intersect(T[s], T[s - 1]) >= intersect(T[s], x)) { T.pop_back(); s--; } T.push_back(x); } void init(int k, int bas, int son) { P[k] = 0; if (bas == son) { T[k].clear(); g[k].clear(); T[k].push_back(line[bas]); g[k].push_back(line[bas]); return; } init((k + k), bas, (bas + son >> 1)); init((k + k + 1), (bas + son >> 1) + 1, son); g[k].resize(g[(k + k)].size() + g[(k + k + 1)].size()); merge(g[(k + k)].begin(), g[(k + k)].end(), g[(k + k + 1)].begin(), g[(k + k + 1)].end(), g[k].begin()); for (__typeof(g[k].begin()) it = g[k].begin(); it != g[k].end(); it++) add(T[k], *it); P[k] = 0; } long long query(int k, int bas, int son, int x, int y, long long t) { if (bas > y || son < x) return -linf; if (x <= bas && son <= y) { while (P[k] < T[k].size() - 1 && intersect(T[k][P[k]], T[k][P[k] + 1]) <= t) P[k]++; return T[k][P[k]].first * t + T[k][P[k]].second; } return max(query((k + k), bas, (bas + son >> 1), x, y, t), query((k + k + 1), (bas + son >> 1) + 1, son, x, y, t)); } int main() { scanf( %d , &n); long long ans = 0; for (int i = 1; i <= n; i++) { scanf( %d , &a[i]); pre[i] = pre[i - 1] + a[i]; ans += a[i] * (long long)i; } for (int i = 0; i <= n; i++) line[i] = make_pair(i, pre[n] - pre[i]); init(1, 0, n); long long res = -linf; vector<pair<int, int> > look; for (int i = 1; i <= n; i++) look.push_back(make_pair(a[i], i)); sort(look.begin(), look.end()); for (__typeof(look.begin()) it = look.begin(); it != look.end(); it++) { long long left = query(1, 0, n, 0, it->second, it->first); res = max(res, ans + left - (pre[n] - pre[it->second]) - it->second * (long long)it->first); left = query(1, 0, n, it->second + 2, n, it->first); res = max(res, ans + left - (pre[n] - pre[it->second]) - it->second * (long long)it->first); } cout << res << n ; return 0; }
#include <bits/stdc++.h> using namespace std; int n; char a[22][22], b[22][22], c[22][22]; bool chk() { for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) if (a[i][j] != b[i][j]) return false; return true; } void flip() { for (int i = 0; i < n; i++) for (int j = 0; j < n - j - 1; j++) swap(a[i][j], a[i][n - j - 1]); } void rotate() { for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) c[j][n - i - 1] = a[i][j]; for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) a[i][j] = c[i][j]; } int main() { scanf( %d , &n); for (int i = 0; i < n; i++) scanf( %s , a[i]); for (int i = 0; i < n; i++) scanf( %s , b[i]); bool f = false; for (int i = 0; i < 2 && !f; i++) { for (int j = 0; j < 4 && !f; j++) { if (chk()) f = true; rotate(); } flip(); } puts(f ? Yes : No ); return 0; }
#include <bits/stdc++.h> using namespace std; inline int getc() { char ch = getchar(); while (ch != 0 && ch != 1 ) { ch = getchar(); } return ch - 0 ; } int main() { int n; scanf( %d , &n); int cnt1 = 0, cnt2 = 0; for (int i = 0; i < n; ++i) { if (getc() == i % 2) cnt1++; else cnt2++; } printf( %d n , min(cnt1, cnt2)); ; ; ; }
#include <bits/stdc++.h> using namespace std; template <typename T> struct Segtree { int n; T e; vector<T> dat; typedef function<T(T a, T b)> Func; Func f; Segtree() {} Segtree(int n_input, Func f_input, T e_input) { initialize(n_input, f_input, e_input); } void initialize(int n_input, Func f_input, T e_input) { f = f_input; e = e_input; n = 1; while (n < n_input) n <<= 1; dat.resize(2 * n - 1, e); } void update(int k, T a) { k += n - 1; dat[k] = a; while (k > 0) { k = (k - 1) / 2; dat[k] = f(dat[2 * k + 1], dat[2 * k + 2]); } } T get(int k) { return dat[k + n - 1]; } T between(int a, int b) { return query(a, b + 1, 0, 0, n); } T query(int a, int b, int k, int l, int r) { if (r <= a || b <= l) return e; if (a <= l && r <= b) return dat[k]; T vl = query(a, b, 2 * k + 1, l, (l + r) / 2); T vr = query(a, b, 2 * k + 2, (l + r) / 2, r); return f(vl, vr); } }; void chmin(int64_t& a, int64_t b) { a = min(a, b); } int main() { int N, C, A[100000]; cin >> N >> C; for (int i = 0; i < N; i++) cin >> A[i]; Segtree<int> st( N, [](int a, int b) { return min(a, b); }, 1e9); Segtree<int64_t> sum( N, [](int64_t a, int64_t b) { return a + b; }, 0); for (int i = 0; i < N; i++) { st.update(i, A[i]); sum.update(i, A[i]); } vector<int64_t> dp(N + 1, 1e18); dp[0] = 0; for (int i = 0; i < N; i++) { chmin(dp[i + 1], dp[i] + A[i]); if (i + C <= N) chmin(dp[i + C], dp[i] + sum.between(i, i + C - 1) - st.between(i, i + C - 1)); } cout << dp[N] << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int dp[2][1 << 16]; char art[7][1008]; int n; int c[5]; vector<int> modi[1008]; void upd(int &x, int y) { x = min(x, y); } int main() { scanf( %d , &n); for (int i = 1; i <= 4; i++) scanf( %d , &c[i]); for (int i = 1; i <= 4; i++) scanf( %s , art[i] + 1); int now = 0; memset(dp[now], 0x3f, sizeof dp[now]); dp[now][0] = 0; for (int i = 1; i <= 4; i++) { for (int j = 1; j <= 4 - i + 1; j++) { int mas = (1 << 16) - 1; for (int x = 0; x < i; x++) for (int y = j - 1; y < j - 1 + i; y++) { mas ^= (1 << (x * 4 + y)); } modi[i].push_back(mas); } } for (int i = 1; i <= n + 4; i++) { now ^= 1; memset(dp[now], 0x3f, sizeof dp[now]); int nm = 0; for (int j = 1; j <= 4; j++) if (art[j][i] == * ) nm |= (1 << 11 + j); for (int j = (1 << 16) - 1; j >= 0; j--) if (dp[now ^ 1][j] < 1e9) { for (int k = 1; k <= 4; k++) for (int l = 0; l < modi[k].size(); l++) upd(dp[now ^ 1][j & modi[k][l]], dp[now ^ 1][j] + c[k]); if (j & 15) continue; upd(dp[now][(j >> 4) | nm], dp[now ^ 1][j]); } } printf( %d n , dp[now][0]); return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 106; long long d, A[N], f[N]; bool vs[N]; int X[N], Y[N], n; queue<int> q; inline long long dis(int a, int b) { return abs(X[a] - X[b]) + abs(Y[a] - Y[b]); } bool judge(long long init) { memset(f, -1, sizeof f); while (!q.empty()) q.pop(); memset(vs, 0, sizeof vs); q.push(1), f[1] = init, vs[1] = 1; while (!q.empty()) { int u = q.front(); q.pop(), vs[u] = 0; for (int i = 1; i <= n; i++) { if (dis(i, u) * d > f[u] || i == u) continue; if (f[u] - dis(i, u) * d + A[i] > f[i]) { f[i] = f[u] - dis(i, u) * d + A[i]; if (!vs[i]) q.push(i), vs[i] = 1; } } } if (f[n] == -1) return false; return true; } int main() { scanf( %d%I64d , &n, &d); for (int i = 2; i < n; i++) scanf( %I64d , &A[i]); for (int i = 1; i <= n; i++) scanf( %d%d , &X[i], &Y[i]); long long L = 0, R = ((1LL) << 60); while (L < R) { long long mid = (L + R) >> 1; if (judge(mid)) R = mid; else L = mid + 1; } if (!judge(L)) L++; printf( %I64d n , L); return 0; }
#include <bits/stdc++.h> using namespace std; void RI() {} template <typename... T> void RI(int &head, T &...tail) { scanf( %d , &head); RI(tail...); } struct Maxflow { struct E { int to, cap, rev, rcap, ucap; E() {} E(int _to, int _cap, int _rev) : to(_to), cap(_cap), rev(_rev), rcap(_cap) {} }; int n; vector<vector<E> > e; vector<vector<E>::iterator> cur; vector<int> dis; void init(int _n) { n = _n; e.resize(n); cur.resize(n); dis.resize(n); for (int i = 0; i < int(n); i++) e[i].clear(); } void add(int a, int b, int c) { if (a == b) return; e[a].push_back(E(b, c, e[b].size())); e[b].push_back(E(a, 0, e[a].size() - 1)); } bool bfs() { fill(dis.begin(), dis.end(), -1); queue<int> q; dis[0] = 0; q.push(0); while (!q.empty() && dis[n - 1] == -1) { int p = q.front(); q.pop(); for (auto it = (e[p]).begin(); it != (e[p]).end(); it++) { if (it->cap == 0 || dis[it->to] != -1) continue; dis[it->to] = dis[p] + 1; q.push(it->to); } } return dis[n - 1] != -1; } long long go(int p, long long c) { if (p == n - 1) return c; long long ret = 0; for (; cur[p] != e[p].end(); cur[p]++) { if (cur[p]->cap == 0 || dis[cur[p]->to] != dis[p] + 1) continue; long long now = go(cur[p]->to, min((long long)cur[p]->cap, c - ret)); ret += now; cur[p]->cap -= now; e[cur[p]->to][cur[p]->rev].cap += now; if (ret == c) break; } if (ret == 0) dis[p] = -1; return ret; } long long maxflow() { long long ret = 0; while (bfs()) { for (int i = 0; i < int(n); i++) cur[i] = e[i].begin(); ret += go(0, 1LL << 60); } return ret; } bool _addPath(int wh, vector<vector<int> > &ans) { if (wh == n - 1) { ans.push_back(vector<int>()); ans.back().push_back(wh); return true; } for (auto it = (e[wh]).begin(); it != (e[wh]).end(); it++) if (it->ucap > 0 && _addPath(it->to, ans)) { it->ucap--; ans.back().push_back(wh); return true; } return false; } vector<vector<int> > getPath() { vector<vector<int> > ans; for (auto it = (e).begin(); it != (e).end(); it++) for (auto jt = (*it).begin(); jt != (*it).end(); jt++) jt->ucap = max(0, jt->rcap - jt->cap); while (_addPath(0, ans)) reverse(ans.back().begin(), ans.back().end()); return ans; } } flow; bool pt[51400]; void predo() { for (int i = 2; i < 51400; i++) if (!pt[i]) for (int j = i + i; j < 51400; j += i) pt[j] = 1; } int n, a[210]; vector<int> e[210], sol; bool vis[210]; void dfs(int p) { sol.push_back(p); vis[p] = 1; for (auto it = (e[p]).begin(); it != (e[p]).end(); it++) if (!vis[*it]) { dfs(*it); break; } } int main() { predo(); RI(n); for (int i = (1); i <= int(n); i++) RI(a[i]); int sink = n + 1; flow.init(sink + 1); for (int i = (1); i <= int(n); i++) { if (a[i] % 2 == 0) flow.add(0, i, 2); else flow.add(i, sink, 2); } for (int i = (1); i <= int(n); i++) if (a[i] % 2 == 0) for (int j = (1); j <= int(n); j++) if (!pt[a[i] + a[j]]) flow.add(i, j, 1); int mf = flow.maxflow(); if (mf != n) { puts( Impossible ); return 0; } auto ps = flow.getPath(); for (auto it = (ps).begin(); it != (ps).end(); it++) { assert(((int)(*it).size()) == 4); int x = it->at(1); int y = it->at(2); e[x].push_back(y); e[y].push_back(x); } for (int i = (1); i <= int(n); i++) assert(((int)(e[i]).size()) == 2); vector<vector<int> > sols; for (int i = (1); i <= int(n); i++) if (!vis[i]) { sol.clear(); dfs(i); assert(((int)(sol).size()) % 2 == 0 && ((int)(sol).size()) >= 4); sols.push_back(sol); } printf( %d n , ((int)(sols).size())); for (auto &s : sols) { printf( %d , ((int)(s).size())); for (auto it = (s).begin(); it != (s).end(); it++) printf( %d , *it); puts( ); } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int i, j, n, t, x; string s = ; cin >> t; for (i = 0; i < t; i++) { s += o ; } int ara[t + 5]; ara[0] = 1; ara[1] = 1; s[0] = O ; s[1] = O ; for (i = 2; i <= t; i++) { ara[i] = ara[i - 1] + ara[i - 2]; if (ara[i] <= t) s[ara[i] - 1] = O ; if (ara[i] > t) break; else continue; } cout << s << n ; return 0; }
#include <bits/stdc++.h> const int INF = 0x3f3f3f3f; const int maxn = 1e6 + 50; const int Mod = 1e9 + 7; using namespace std; int n, m, sx, sy, dx, dy; int get(int sx, int sy, int ex, int ey) { int cx = abs(sx - ex), cy = abs(sy - ey); if (cx == 0 && cy == 0) return 0; if (cx % dx != 0 || cy % dy != 0) return INF; if (sx == ex) { if (!(sx - dx >= 1 || sx + dx <= n)) return INF; } else if (sy == ey) { if (!(sy - dy >= 1 || sy + dy <= m)) return INF; } int t1 = cx / dx, t2 = cy / dy; int cha = abs(t1 - t2); if (cha & 1) return INF; return max(t1, t2); } int main() { while (scanf( %d %d %d %d %d %d , &n, &m, &sx, &sy, &dx, &dy) != EOF) { int ans = INF; ans = min(get(sx, sy, 1, 1), ans); ans = min(get(sx, sy, 1, m), ans); ans = min(get(sx, sy, n, 1), ans); ans = min(get(sx, sy, n, m), ans); if (ans == INF) puts( Poor Inna and pony! ); else printf( %d n , ans); } return 0; }
#include <bits/stdc++.h> using namespace std; char op[] = { R , G , B , Y , W , 1 , 2 , 3 , 4 , 5 }; string s[555]; int main() { int n, i, j, k; ios_base::sync_with_stdio(0), cin.tie(0); cin >> n; for (i = 1; i <= n; i++) { cin >> s[i]; } map<char, bool> mp; int mn = 100000; for (int msk = 0; msk < (1024); msk++) { mp.clear(); for (i = 0; i < 10; i++) { if (msk & (1 << i)) { mp[op[i]] = 1; } } bool f = 1; for (i = 1; i <= n; i++) { for (j = i + 1; j <= n; j++) { if (s[i] == s[j]) continue; if (s[i][0] == s[j][0]) { if (!mp[s[i][1]] && !mp[s[j][1]]) { f = 0; break; } } else if (s[i][1] == s[j][1]) { if (!mp[s[i][0]] && !mp[s[j][0]]) { f = 0; break; } } else { if (!mp[s[i][1]] && !mp[s[j][1]] && !mp[s[i][0]] && !mp[s[j][0]]) { f = 0; break; } } } if (!f) break; } if (f == 1) mn = min(mn, __builtin_popcount(msk)); } cout << mn << endl; }
#include <bits/stdc++.h> using namespace std; int main() { int n, k; cin >> n >> k; vector<pair<long long, long long>> v(n); for (int i = 0; i < n; i++) cin >> v[i].second >> v[i].first; sort(v.rbegin(), v.rend()); long long ans = 0, sum = 0; priority_queue<long long, vector<long long>, greater<long long>> pq; for (int i = 0; i < n; i++) { pq.push(v[i].second); sum += v[i].second; if (pq.size() > k) { sum -= pq.top(); pq.pop(); } ans = max(ans, v[i].first * sum); } cout << ans << endl; return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 2e2; int i, a[N], n; int main() { cin >> n; for (i = 0; i < n; i++) cin >> a[i]; sort(a, a + n); cout << a[n - 1] << ; for (i = 1; i < n - 1; i++) cout << a[i] << ; cout << a[0]; return 0; }
#include <bits/stdc++.h> using namespace std; int TEST, CASE = 1; int n, m, a, b, c, k, x, y, z, len, total = 0; string s, temp, ans; vector<string> v; bool cmp(string &a, string &b) { if (a.size() < b.size()) return true; else return false; } int main(void) { cin >> n; for (int i = 0; i < n; i++) cin >> s, v.push_back(s); sort(v.begin(), v.end(), cmp); for (int i = 1; i < n; i++) { if (v[i].find(v[i - 1]) > v[i].size()) { cout << NO << endl; return 0; } } cout << YES << endl; for (int i = 0; i < n; i++) cout << v[i] << endl; return 0; }
#include <bits/stdc++.h> using namespace std; void ga(int N, int *A) { for (int i(0); i < N; i++) scanf( %d , A + i); } unordered_map<int, int> dp; int N, S[(4000)]; int dyn(int a, int b, int K, bool x) { if (b - a + 1 < K) return 0; if (b - a + 1 == K) return (S[b] - (a ? S[a - 1] : 0)); if (dp.count( (a + (4000) * b + (4000) * (4000) * K + x * (4000) * (4000) * 100))) return dp[(a + (4000) * b + (4000) * (4000) * K + x * (4000) * (4000) * 100)]; if (!x) return dp[(a + (4000) * b + (4000) * (4000) * K + x * (4000) * (4000) * 100)] = max(-dyn(a + K, b, K, 1) + (S[a + K - 1] - (a ? S[a - 1] : 0)), -dyn(a + K + 1, b, K + 1, 1) + (S[a + K] - (a ? S[a - 1] : 0))); return dp[(a + (4000) * b + (4000) * (4000) * K + x * (4000) * (4000) * 100)] = max(-dyn(a, b - K, K, 0) + (S[b] - (b - K + 1 ? S[b - K + 1 - 1] : 0)), -dyn(a, b - K - 1, K + 1, 0) + (S[b] - (b - K ? S[b - K - 1] : 0))); } int main(void) { dp.max_load_factor(.4); scanf( %d , &N), ga(N, S); for (int k(1); k < N; k++) S[k] += S[k - 1]; printf( %d n , dyn(0, N - 1, 1, 0)); return 0; }
#include <bits/stdc++.h> using namespace std; int Set(int N, int pos) { return N |= (1LL << pos); } int Reset(int N, int pos) { return N &= ~(1LL << pos); } bool Check(int N, int pos) { return N & (1LL << pos); } int dx[] = {0, 0, 1, -1, 1, -1, 1, -1}, dy[] = {1, -1, 0, 0, 1, -1, -1, 1}; inline void cn(long &n) { n = 0; long ch = getchar(); int sign = 1; while (ch < 0 || ch > 9 ) { if (ch == - ) sign = -1; ch = getchar(); } while (ch >= 0 && ch <= 9 ) n = (n << 3) + (n << 1) + ch - 0 , ch = getchar(); n = n * sign; } template <class T> void cmin(T &a, T b) { if (b < a) a = b; } template <class T> void cmax(T &a, T b) { if (b > a) a = b; } template <class T> int len(const T &c) { return (int)c.size(); } template <class T> int len(char c[]) { return (int)strlen(c); } long stoi(string s) { long n = 0; for (int i(0), _n(len(s)); i < _n; ++i) n = n * 10 + (s[i] - 48); return n; } int main() { ios_base::sync_with_stdio(false); long m, t, r, w, k, ww, res = 0, ls; cin >> m >> t >> r; vector<int> v, tem; int f = 1; for (int i(0), _n(m); i < _n; ++i) { cin >> w; ls = -100000000000000000LL; if (!f) continue; for (int j = len(v) - 1; j >= 0; j--) { if (v[j] >= w) tem.push_back(v[j]); else break; } if (len(tem) < r) { k = r - len(tem); ww = w; for (int j(0), _n(k); j < _n; ++j) { if (ww + t - 1 >= w) { res++; tem.push_back(ww + t - 1); ww -= 1; } else { f = 0; break; } } } v = tem; tem.clear(); sort(v.begin(), v.end()); } if (f == 0) res = -1; cout << res; return 0; }
#include <bits/stdc++.h> using namespace std; const double pi = acos(-1); double a, b, c[100005], mx; int n; int main() { scanf( %d , &n); for (int i = 0; i < n; i++) { scanf( %lf %lf , &a, &b); c[i] = (atan2(b, a) * 180) / pi; } sort(c, c + n); for (int i = 0; i < n - 1; i++) { mx = max(mx, c[i + 1] - c[i]); } mx = max(mx, 360 - c[n - 1] + c[0]); printf( %0.08lf n , 360 - mx); return 0; }
#include <bits/stdc++.h> using namespace std; int n, ans = 1e9; pair<int, int> p[1005]; void solve(int height) { int width = 0, remain = n / 2; vector<int> priority; for (int i = 1; i <= n; i++) if (p[i].second > height) if (p[i].first > height) return; else if (remain) { remain--; width += p[i].second; } else return; else if (p[i].first > height) width += p[i].first; else if (p[i].first > p[i].second) { width += p[i].second; priority.push_back(p[i].first - p[i].second); } else width += p[i].first; sort(priority.rbegin(), priority.rend()); for (int i = remain; i < priority.size(); i++) width += priority[i]; ans = min(ans, width * height); } int main() { scanf( %d , &n); for (int i = 1; i <= n; i++) scanf( %d %d , &p[i].first, &p[i].second); for (int i = 1; i <= 1000; i++) solve(i); printf( %d n , ans); return 0; }
#include <bits/stdc++.h> using namespace std; struct node { int x, num; } s[100009]; int mark[100009]; int cmp(node a, node b) { return a.x < b.x; } int main() { int n, m; while (scanf( %d %d , &n, &m) == 2) { int l, h; scanf( %d %d , &l, &h); for (int i = 0; i < n; i++) { int a, b; scanf( %d %d , &a, &b); s[i].x = a * l + b * h; s[i].num = i + 1; } sort(s, s + n, cmp); int ans = 0; int k = 0; for (int i = 0; i < n; i++) { m -= s[i].x; if (m < 0) break; ans++; mark[k++] = s[i].num; } printf( %d n , ans); for (int i = 0; i < ans; i++) { if (i == 0) printf( %d , mark[i]); else printf( %d , mark[i]); } printf( n ); } return 0; }
#include <bits/stdc++.h> using namespace std; const long long N = 2000 * 100 + 1000; vector<long long> adj[N]; long long a[N], h[N], t[N]; bool mark[N]; long long f(long long p) { mark[p] = true; long long ans = h[p] * a[p]; t[p] = a[p]; for (auto q : adj[p]) if (mark[q] == false) { h[q] = h[p] + 1; ans += f(q); t[p] += t[q]; } return ans; } long long ans = 0, sum = 0; void calc(long long val, long long p) { mark[p] = true; ans = max(ans, val); for (auto q : adj[p]) if (mark[q] == false) { long long k = sum - 2 * t[q]; calc(val + k, q); } } int32_t main() { ios::sync_with_stdio(false); long long n; cin >> n; for (long long i = 0; i < n; i++) { cin >> a[i]; sum += a[i]; } for (long long i = 0; i < n - 1; i++) { long long u, v; cin >> u >> v; u--; v--; adj[u].push_back(v); adj[v].push_back(u); } long long val = f(0); for (long long i = 0; i < N; i++) mark[i] = false; calc(val, 0); cout << ans << n ; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { string s; cin >> s; for (int i = 0; i < s.size(); i++) { if (s[i] == 1 ) continue; if (s[i] == 4 && s[i - 1] == 1 ) continue; if (s[i] == 4 && i > 1 && s[i - 1] == 4 && s[i - 2] == 1 ) continue; return cout << NO , 0; } cout << YES ; }
#include <bits/stdc++.h> using namespace std; const int N = 5010; int n, m, s; vector<int> e[N]; int low[N], dfn[N], idx; bool vis[N]; stack<int> st; bool in_stack[N]; int color[N], color_tot; int indeg[N]; int ans; void AddEdge(int u, int v) { e[u].push_back(v); } void Dfs(int u) { low[u] = dfn[u] = ++idx; in_stack[u] = true; st.push(u); for (int v : e[u]) { if (!dfn[v]) { Dfs(v); low[u] = min(low[u], low[v]); } else if (in_stack[v]) { low[u] = min(low[u], dfn[v]); } } if (low[u] == dfn[u]) { ++color_tot; int v; do { v = st.top(); st.pop(); in_stack[v] = false; color[v] = color_tot; } while (v != u); } } void Tarjan() { for (int i = 1; i <= n; ++i) if (!color[i]) Dfs(i); } int main() { scanf( %d%d%d , &n, &m, &s); for (int i = 1; i <= m; ++i) { int u, v; scanf( %d%d , &u, &v); AddEdge(u, v); } Tarjan(); for (int i = 1; i <= n; ++i) ; for (int i = 1; i <= n; ++i) for (int j : e[i]) if (color[i] != color[j]) ++indeg[color[j]]; for (int i = 1; i <= color_tot; ++i) ; for (int i = 1; i <= color_tot; ++i) if (indeg[i] == 0) ++ans; if (indeg[color[s]] == 0) --ans; printf( %d n , ans); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { long long n, m, a; cin >> n >> m >> a; long long v = n / a; long long t = m / a; if (n % a != 0) v++; if (m % a != 0) t++; cout << v * t; }
#include <bits/stdc++.h> using namespace std; struct Edge { int v; char c; } edge[220]; vector<Edge> ans; vector<int> Chain[10]; int N; bool flag[110]; void dfs(int x) { for (int i = 0; i < Chain[x].size(); i++) { int v = edge[Chain[x][i]].v, id = Chain[x][i] >> 1; if (!flag[id]) { flag[id] = 1; dfs(v); ans.push_back((Edge){id, edge[Chain[x][i]].c}); } } } void print() { for (int i = N - 1; i >= 0; i--) printf( %d %c n , ans[i].v + 1, ans[i].c); } int main() { scanf( %d , &N); for (int i = 0; i < N; i++) { int a, b; scanf( %d%d , &a, &b); edge[2 * i] = (Edge){b, + }; Chain[a].push_back(2 * i); edge[2 * i + 1] = (Edge){a, - }; Chain[b].push_back(2 * i + 1); } int u = edge[0].v, sum = 0; for (int i = 0; i <= 6; i++) if (1 & Chain[i].size()) u = i, sum++; if (sum == 0 || sum == 2) { dfs(u); if (ans.size() == N) print(); else printf( No solution ); } else printf( No solution ); return 0; }
#include <bits/stdc++.h> using namespace std; template <class T> bool umin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; } template <class T> bool umax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; } const int N = 1e3 + 9; double dp[N][N], prob[N]; bool vis[N][N]; long long sum[22], pw[22]; double rec(int x, int y) { umax(y, 0); if (!x) { if (!y) return 1.0; return 0.0; } double& ret = dp[x][y]; if (vis[x][y]) return ret; vis[x][y] = 1; return ret = rec(x - 1, y - 1) * prob[x] + rec(x - 1, y) * (1 - prob[x]); } long long f(long long x) { if (!x) return 0; vector<int> v; while (x >= 1) { v.push_back(x % 10); x /= 10; } reverse(v.begin(), v.end()); if (v[0] > 1) return sum[v.size()]; long long res = sum[v.size() - 1]; for (int i = 1; i < int(v.size()); i++) { if (v[i] == 0) continue; res += (v[i]) * 1LL * pw[v.size() - i - 1]; } return res + 1; } int main() { pw[0] = 1; for (int i = 1; i <= 18; i++) { pw[i] = pw[i - 1] * 10; sum[i] = sum[i - 1] + pw[i - 1]; } int n, k; scanf( %d , &n); for (int i = 1; i <= n; i++) { long long x, y; scanf( %lld%lld , &x, &y); long long res = f(y) - f(x - 1); prob[i] = double(res) / double(y - x + 1); } scanf( %d , &k); printf( %.12lf n , rec(n, (k * n + 99) / 100)); return 0; }
#include <bits/stdc++.h> using namespace std; long long spf[3000001]; long long fac[3000001]; void sieve() { spf[1] = 1; for (long long i = 2; i < 3000001; i++) spf[i] = i; for (long long i = 4; i < 3000001; i += 2) spf[i] = 2; for (long long i = 3; i * i < 3000001; i++) { if (spf[i] == i) { for (long long j = i * i; j < 3000001; j += i) if (spf[j] == j) spf[j] = i; } } } map<long long, long long> getfactor(long long a) { map<long long, long long> m; while (a > 1) { m[spf[a]]++; a /= spf[a]; } return m; } long long power(long long x, long long y, long long p) { long long res = 1; x = x % p; while (y > 0) { if (y & 1) res = (res * x) % p; y = y >> 1; x = (x * x) % p; } return res; } long long gcd(long long a, long long b) { if (a == 0) return b; return gcd(b % a, a); } long long inverse(long long a, long long p) { return power(a, p - 2, p); } long long ncr(long long n, long long r, long long p) { if (r > n) return 0; if (r == 0) return 1; return (fac[n] * inverse(fac[r], p) % p * inverse(fac[n - r], p) % p) % p; } void solve() { long long n, k; cin >> n >> k; map<long long, long long> m; for (long long i = 1; i <= n; i++) { long long l, r; cin >> l >> r; m[l]++; m[r + 1]--; } long long pre = 0; for (auto it : m) { pre += m[it.first]; m[it.first] = pre; } long long prev = -1e18, val = 0; long long ans = 0; for (auto it : m) { if (prev == -1e18) { prev = it.first; val = it.second; } else { ans = (ans + (ncr(val, k, 1000000007) * (it.first - prev) % 1000000007) % 1000000007 + 1000000007) % 1000000007; prev = it.first; val = it.second; } } cout << ans << n ; } signed main() { ios_base::sync_with_stdio(false); cin.tie(NULL); long long test = 1; fac[0] = 1; for (long long i = 1; i <= 300000; i++) fac[i] = (fac[i - 1] * i) % 1000000007; while (test--) { solve(); } }
#include <bits/stdc++.h> using namespace std; long long int pow_mod(long long int a, long long int b) { long long int res = 1; while (b != 0) { if (b & 1) { res = (res * a) % 1000000007; } a = (a * a) % 1000000007; b /= 2; } return res; } long long int inv(long long int x) { return pow_mod(x, 1000000007 - 2); } void solve() { long long int n; cin >> n; long long int x = 2 * n - 1; long long int y = n; long long int res1 = 1; for (long long int i = 0; i < y; i++) res1 = (res1 * (x - i)) % 1000000007; long long int res2 = 1; for (long long int i = 1; i <= y; i++) res2 = (res2 * i) % 1000000007; long long int ans = (res1 * inv(res2)) % 1000000007; ans *= 2; ans %= 1000000007; ans -= n; ans += 1000000007; ans %= 1000000007; cout << ans << endl; } int32_t main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); long long int t; t = 1; while (t--) solve(); return 0; }
#include <bits/stdc++.h> using namespace std; const unsigned long long INF = ~0ll; unsigned long long prime[16] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53}; int n; unsigned long long ans; void dfs(int deepth, unsigned long long v, unsigned long long num) { if (num > n || deepth > 15) return; if (num == n && v < ans) { ans = v; return; } for (unsigned long long i = 1; i <= 63; i++) { if (ans / prime[deepth] < v) break; dfs(deepth + 1, v *= prime[deepth], num * (i + 1)); } } int main() { while (cin >> n) { ans = INF; dfs(0, 1, 1); cout << ans << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int t; cin >> t; while (t--) { long long n, a, b; cin >> n >> a >> b; if (2 * a < b) { long long ans = n * a; cout << ans << endl; } else { long long cou = n % 2; long long ans = (n / 2) * b; if (cou == 1) { ans += a; } cout << ans << endl; } } }
#include <bits/stdc++.h> using namespace std; const long long p = 1000000007LL; long long power(long long x, long long n) { long long ret = 1LL; while (n > 0LL) { if (n & 1LL) ret = ret * x % p; x = x * x % p; n >>= 1LL; } return ret; } long long n, m; long long dp; int main() { cin >> n >> m; dp = 1; for (long long i = 1LL; i <= n; i++) dp = (dp * (m * 2LL - 1LL) + power(m, i - 1LL)) % p; cout << dp << endl; }
#include <bits/stdc++.h> using namespace std; typedef pair<int, int> pii; typedef long long ll; typedef unsigned long long ull; template <typename T> bool umax(T& a, const T& b) { return b <= a ? false : (a = b, true); } template <typename T> bool umin(T& a, const T& b) { return b >= a ? false : (a = b, true); } template <typename T> void V2A(T a[], const vector<T>& b) { for (int i = 0; i < b.size(); i++) a[i] = b[i]; } template <typename T> void A2V(vector<T>& a, const T b[]) { for (int i = 0; i < a.size(); i++) a[i] = b[i]; } const double PI = acos(-1.0); const int INF = 1e9 + 7; const int maxn = 2e3 + 7; bool plot[maxn][maxn]; int r[maxn][maxn]; int n, m, k; int check(int row, int col) { if (col >= 0 && col < m) return true; return false; } int main() { cin >> n >> m >> k; for (int i = 0; i < k; i++) { int x, y; scanf( %d%d , &x, &y); x--; y--; if (!plot[x][y]) { printf( %d %d n , x + 1, y + 1); plot[x][y] = true; continue; } for (int d = 1; d <= 3; d++) { int Max = min(n, x + d + 1); for (int row = max(0, x - d); row < Max; row++) { int t = d - abs(x - row), col1 = y - t, col2 = y + t; if (check(row, col1)) umax(r[x][y], r[row][col1] - d); if (check(row, col2)) umax(r[x][y], r[row][col2] - d); } } for (int d = r[x][y] + 1;; d++) { int Max = min(n, x + d + 1); bool ok = false; for (int row = max(0, x - d); row < Max; row++) { int t = d - abs(x - row), col1 = y - t, col2 = y + t; if (check(row, col1) && !plot[row][col1]) { ok = true; printf( %d %d n , row + 1, col1 + 1); plot[row][col1] = true; break; } if (check(row, col2) && !plot[row][col2]) { ok = true; printf( %d %d n , row + 1, col2 + 1); plot[row][col2] = true; break; } } if (ok) { r[x][y] = d - 1; break; } } } return 0; }
#include <bits/stdc++.h> using namespace std; void solve() { int n, t; cin >> n >> t; for (int i = 1; i <= n; i++) { int val; cin >> val; t -= (86400 - val); if (t <= 0) { cout << i << n ; return; } } } int main() { solve(); return 0; }
#include <bits/stdc++.h> using namespace std; void desperate_optimization(int precision) { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); cout.setf(ios::fixed); cout.setf(ios::showpoint); cout.precision(precision); } const int N = 2e5; long long arrA[N + 5], arrB[N + 5]; long long posA[N + 5], posB[N + 5]; long long res[N + 5]; long long bit[N + 5]; int n; int query(int x) { int tot = 0; for (; x; x -= (x & -x)) tot += bit[x]; return tot; } void update(int x) { for (; x <= n; x += (x & -x)) bit[x]++; } void hora(int tc) { cin >> n; for (int i = 0; i < n; i++) cin >> arrA[i]; for (int i = 0; i < n; i++) cin >> arrB[i]; for (int i = 0; i < n; i++) { int val = query(arrA[i] + 1); posA[i] = arrA[i] - val; update(arrA[i] + 1); } memset(bit, 0, sizeof bit); for (int i = 0; i < n; i++) { int val = query(arrB[i] + 1); posB[i] = arrB[i] - val; update(arrB[i] + 1); } long long cur = 0; long long sisa = 0; for (int i = n - 1; i >= 0; i--) { res[i] = posA[i] + posB[i] + sisa; sisa = res[i] / (cur + 1); res[i] %= (cur + 1); cur += 1; } memset(bit, 0, sizeof bit); for (int i = 0; i < n; i++) { int lo = 0; int hi = n; int ans = -1; while (lo <= hi) { int mid = (lo + hi) / 2; if (mid - query(mid + 1) >= res[i]) { ans = mid; hi = mid - 1; } else lo = mid + 1; } update(ans + 1); cout << ans << ; } } int main() { desperate_optimization(10); int ntc = 1; for (int tc = 1; tc <= ntc; tc++) hora(tc); return 0; }
#include <bits/stdc++.h> using namespace std; long long maxm = -1e18; long long minm = 1e18; long long mod = 1e9 + 7; long long mod1 = 1e9 + 9; const long double Pi = 3.141592653; long long int fact(long long int n) { if (n == 0) { return 1; } else if (n == 1) { return 1; } long long int res = 1; for (long long int i = 2; i <= n; i++) res = res * i; return res; } long long int nCr(long long int n, long long int r) { return fact(n) / (fact(r) * fact(n - r)); } bool isint(double n) { long long int j = n; double w = n - j; if (w > 0) { return false; } return true; } long long int count3(long long int x) { long long int ret = 0; while (x % 3 == 0) { ret++; x /= 3; } return ret; } long long int sqr(long long int a) { return a * a; } int32_t main() { ios_base::sync_with_stdio(false), cin.tie(NULL); long long t = 1; cin >> t; while (t--) { long long int n; cin >> n; long long int ans = 1; if (n == 1) { cout << 1 << n ; continue; } for (long long int i = 1; i <= 2 * n - 1; i++) { ans = (ans * i); ans = (ans) % mod; } ans = (ans * n) % mod; cout << ans << n ; } return 0; }
#include <bits/stdc++.h> using namespace std; const int M = 4e3 + 44; const int F = 4000; int n; int s[M]; int main() { scanf( %d , &n); for (int i = 1; i <= n; i++) scanf( %d , &s[i]); printf( %d n , n + 1); int tmp, tmp1, tmp2, sum = 0; for (int i = n; i >= 1; i--) { tmp = (F + i - ((sum + s[i]) % F)) % F; sum += tmp; printf( %d %d %d n , 1, i, tmp); } printf( %d %d %d n , 2, n, F); return 0; }
#include <bits/stdc++.h> using namespace std; static const int maxn = 2e5 + 5; struct Node { bool ok; int val; int pos, rpos; Node(bool ok = 0, int val = 0, int pos = 0, int rpos = 0) : ok(ok), val(val), pos(pos), rpos(rpos) {} bool operator<(const Node &other) const { if (ok and other.ok) { if (val == other.val) return pos > other.pos; return val < other.val; } return ok > other.ok; } }; signed main() { ios_base::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr); int n; cin >> n; vector<int> arr(n + 2); for (int i = 1; i <= n; i++) cin >> arr[i]; vector<int> rgt(n + 1); rgt[n] = -1; for (int i = n - 1; i >= 1; i--) rgt[i] = i + 1; multiset<Node> ms; arr[n + 1] = 1e9 + 9; for (int i = 1; i <= n; i++) { bool ok = arr[i] > arr[i + 1]; ms.insert(Node(ok, arr[i], i, i + 1)); } int min_time = 0; map<int, int> mp; while (ms.size()) { int cnt = 0; mp.clear(); while (ms.size()) { auto it = *ms.begin(); if (it.ok == false) break; ++cnt; ms.erase(it); rgt[it.pos] = rgt[it.rpos]; mp[rgt[it.rpos]] = it.pos; } if (cnt == 0) break; ++min_time; for (auto it : mp) { if (it.first == -1) continue; int pos = it.second; int rpos = it.first; bool ok = arr[pos] > arr[rpos]; ms.insert(Node(ok, arr[pos], pos, rpos)); } } cout << min_time << n ; }
#include <bits/stdc++.h> using namespace std; long long rdtsc() { long long tmp; asm( rdtsc : =A (tmp)); return tmp; } inline int myrand() { return abs((rand() << 15) ^ rand()); } inline int rnd(int x) { return myrand() % x; } const int INF = (int)1e9 + 1; const long double EPS = 1e-9; void precalc() {} const int maxn = (int)1e5 + 10; int a[2 * maxn]; int n, w; bool read() { if (scanf( %d%d , &n, &w) < 2) { return 0; } for (int i = 0; i < 2 * n; ++i) { scanf( %d , &a[i]); } return 1; } void solve() { sort(a, a + 2 * n); printf( %.18f n , min((double)w, min((double)a[n] / 2, (double)a[0]) * 3 * n)); } int main() { srand(rdtsc()); precalc(); while (1) { if (!read()) { break; } solve(); } return 0; }
#include <bits/stdc++.h> #pragma comment(linker, /STACK:100000000,100000000 ) using namespace std; const long long inf = 1e9 + 7; const long long mod = 1e9 + 7; const double eps = 1e-9; const double PI = 2 * acos(0.0); const double E = 2.71828; int main(void) { long long n; cin >> n; double ans = 0, e = 0; for (int i = 0; i < n; i++) { double temp; cin >> temp; ans += temp * (2.0 * e + 1); e = temp * (e + 1); } cout << setprecision(8) << fixed << ans << endl; return 0; }
#include <bits/stdc++.h> using namespace std; string norm(string s) { string res = s; for (int i = 0; i < 2; i++) { for (int j = 0; j < 4; j++) { for (int k = 0; k < 4; k++) { res = min(s, res); swap(s[0], s[1]); swap(s[1], s[2]); swap(s[2], s[3]); } swap(s[0], s[4]); swap(s[4], s[2]); swap(s[2], s[5]); } swap(s[0], s[1]); swap(s[1], s[2]); swap(s[2], s[3]); } return res; } int main() { set<string> myS; string S; cin >> S; sort(S.begin(), S.end()); do { myS.insert(norm(S)); } while (next_permutation(S.begin(), S.end())); cout << myS.size() << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int t; cin >> t; while (t--) { int n; cin >> n; vector<int> a(n + 1); for (int i = 1; i <= n; i++) cin >> a[i]; vector<vector<int> > dp(201); for (int i = 1; i <= n; i++) { dp[a[i]].push_back(i); } int maximum = 0; for (int i = 1; i <= n; i++) { int p = a[i]; int l = lower_bound(dp[p].begin(), dp[p].end(), i) - begin(dp[p]); int r = dp[p].size() - l - 1; if (l >= r) continue; int lval = dp[p][l]; int rval = dp[p][r]; int maxi = 0; for (int j = 1; j <= 200; j++) { if (j == p) { maxi = max(maxi, r - l - 1); continue; } int xx = upper_bound(dp[j].begin(), dp[j].end(), rval) - dp[j].begin(); int yy = upper_bound(dp[j].begin(), dp[j].end(), lval) - dp[j].begin(); maxi = max(maxi, xx - yy); } maximum = max(maximum, maxi + (2 * (l + 1))); } cout << max(1, maximum) << endl; } }
#include <bits/stdc++.h> using namespace std; int n, m; int s, t, ds, dt; struct edge { int u, v; } E[400005]; vector<int> vecr[200005]; int pre[200005]; int find(int x) { if (x != pre[x]) pre[x] = find(pre[x]); return pre[x]; } void Union(int x, int y) { pre[find(x)] = find(y); } int cpts[200005]; int tot; int conts[200005]; int contt[200005]; map<int, int> to; vector<int> dhas; vector<int> ans; void output(int pos) { int siz = vecr[pos].size(); for (int i = 0; i < siz; i++) { int u = E[vecr[pos][i]].u; int v = E[vecr[pos][i]].v; if (find(u) == find(v)) continue; else { Union(u, v); ans.push_back(vecr[pos][i]); } } } int main() { scanf( %d%d , &n, &m); for (int i = 1; i <= n; i++) pre[i] = i; for (int i = 0; i < m; i++) scanf( %d%d , &E[i].u, &E[i].v); scanf( %d%d%d%d , &s, &t, &ds, &dt); for (int i = 0; i < m; i++) { if (E[i].u == s || E[i].u == t || E[i].v == s || E[i].v == t) continue; else if (find(E[i].u) != find(E[i].v)) { Union(E[i].u, E[i].v); } } for (int i = 1; i <= n; i++) if (i != s && i != t) cpts[tot++] = find(i); sort(cpts, cpts + tot); tot = unique(cpts, cpts + tot) - cpts; cpts[tot++] = s; cpts[tot++] = t; for (int i = 0; i < tot; i++) to[cpts[i]] = i; memset(conts, -1, sizeof(conts)); memset(contt, -1, sizeof(contt)); for (int i = 0; i < m; i++) { if (E[i].u == s) conts[to[find(E[i].v)]] = i; if (E[i].v == s) conts[to[find(E[i].u)]] = i; if (E[i].u == t) contt[to[find(E[i].v)]] = i; if (E[i].v == t) contt[to[find(E[i].u)]] = i; if (find(E[i].u) == find(E[i].v)) vecr[to[find(E[i].u)]].push_back(i); } for (int i = 1; i <= n; i++) pre[i] = i; for (int i = 0; i < tot - 2; i++) { output(i); if (conts[i] >= 0 && contt[i] >= 0) dhas.push_back(i); else if (conts[i] >= 0) { ans.push_back(conts[i]); ds--; } else if (contt[i] >= 0) { ans.push_back(contt[i]); dt--; } } if (dhas.size() == 0) { ds--; dt--; ans.push_back(conts[tot - 1]); if (ds < 0 || dt < 0) printf( No n ); else { printf( Yes n ); for (int i = 0; i < ans.size(); i++) { printf( %d %d n , E[ans[i]].u, E[ans[i]].v); } } } else { for (int i = 0; i < dhas.size(); i++) { if (i == 0) { ans.push_back(conts[dhas[i]]); ans.push_back(contt[dhas[i]]); ds--; dt--; } else { if (ds < dt) { ans.push_back(contt[dhas[i]]); dt--; } else { ans.push_back(conts[dhas[i]]); ds--; } } } if (ds < 0 || dt < 0) printf( No n ); else { printf( Yes n ); for (int i = 0; i < ans.size(); i++) { printf( %d %d n , E[ans[i]].u, E[ans[i]].v); } } } return 0; }
#include <bits/stdc++.h> using namespace std; double power(float x, int y) { float temp; if (y == 0) return 1; temp = power(x, y / 2); if (y % 2 == 0) return temp * temp; else { if (y > 0) return x * temp * temp; else return (temp * temp) / x; } } bool isPrime(int n) { if (n <= 1) return false; if (n <= 3) return true; if (n % 2 == 0 || n % 3 == 0) return false; for (int i = 5; i * i <= n; i = i + 6) if (n % i == 0 || n % (i + 2) == 0) return false; return true; } void solve() { long long int n; cin >> n; vector<long long int> a(n); for (long long int i = 0; i < n; i++) cin >> a[i]; ; long long int ans = a[0]; long long int t = a[0]; for (long long int i = 1; i < n; i++) { t += a[i]; ans = min(ans, t); } cout << abs(ans) << endl; } int main() { long long int t; cin >> t; while (t--) solve(); }
#include <bits/stdc++.h> using namespace std; int64_t calc(int64_t l, int64_t r, int64_t ln) { if (ln < 2) return 1; int64_t mx = max(l, r); int64_t mn = min(l, r); int64_t ans = (int64_t)pow(201, (ln - 2)); cout << ans << endl; ans += (int64_t)pow((201 - mx + 1), (ln - 1)); cout << ans << endl; int64_t to = 201 - mn; int64_t fr = to - mx + mn + 1; cout << fr << << to << endl; ans += (to * (to + 1)) / 2; ans -= (fr * (fr + 1)) / 2; cout << ANS: << l << << r << << ln << = << ans << endl; return ans; } int main() { int n; cin >> n; int a[n + 2]; for (int i = 0; i < n; ++i) { scanf( %d , &a[i + 1]); } a[0] = 1; a[n + 1] = 1; n += 2; int64_t *dp[2][201], ps[2][201]; for (int i = 0; i < 2; ++i) { for (int j = 0; j < 201; ++j) { dp[i][j] = (int64_t *)calloc(n, sizeof(int64_t)); ps[i][j] = 0; } } dp[0][1][0] = 1; ps[0][0] = dp[0][0][0]; ps[1][0] = dp[1][0][0]; for (int j = 1; j < 201; ++j) { ps[0][j] = ps[0][j - 1] + dp[0][j][0]; ps[1][j] = ps[1][j - 1] + dp[1][j][0]; ps[0][j] %= 998244353; ps[1][j] %= 998244353; } for (int i = 1; i < n; ++i) { if (a[i] == -1) { for (int j = 1; j < 201; ++j) { dp[0][j][i] = ps[1][j - 1] + ps[0][j - 1]; dp[0][j][i] %= 998244353; dp[1][j][i] = dp[0][j][i - 1] + ((ps[1][201 - 1] - ps[1][j - 1] + 998244353) % 998244353); dp[1][j][i] %= 998244353; } } else { dp[1][a[i]][i] = dp[0][a[i]][i - 1]; for (int j = a[i]; j < 201; ++j) { dp[1][a[i]][i] += dp[1][j][i - 1]; dp[1][a[i]][i] %= 998244353; } dp[0][a[i]][i] = 0; for (int j = 1; j < a[i]; ++j) { dp[0][a[i]][i] += dp[0][j][i - 1] + dp[1][j][i - 1]; dp[0][a[i]][i] %= 998244353; } } ps[0][0] = dp[0][0][i]; ps[1][0] = dp[1][0][i]; for (int j = 1; j < 201; ++j) { ps[0][j] = ps[0][j - 1] + dp[0][j][i]; ps[1][j] = ps[1][j - 1] + dp[1][j][i]; ps[0][j] %= 998244353; ps[1][j] %= 998244353; } } int64_t ans = 0; for (int i = 1; i < 201; ++i) { ans += dp[0][i][n - 1]; ans %= 998244353; ans += dp[1][i][n - 1]; ans %= 998244353; } cout << ans << endl; }
#include <bits/stdc++.h> using namespace std; const double PI = acos(-1.0); const double EPS = 1e-6; int main() { { ; }; int n; scanf( %d , &n); vector<pair<int, int> > V(n); int totalW = 0; for (int i = 0; i < n; i++) { scanf( %d %d , &V[i].first, &V[i].second); totalW += V[i].first; } int res = ((1 << 30) - 1); for (int maxH = 1; maxH <= 1000; maxH++) { bool testOK = true; int coda = n / 2; int nowW = totalW; vector<int> candidate; for (int i = 0; i < n && testOK; i++) { if (V[i].second > maxH) { if (V[i].first > maxH) testOK = false; else { if (coda == 0) testOK = false; else nowW += V[i].second - V[i].first; coda--; } } else { if (V[i].first > V[i].second && V[i].first <= maxH) { candidate.emplace_back(V[i].second - V[i].first); } } } if (testOK) { sort((candidate).begin(), (candidate).end()); nowW += accumulate( candidate.begin(), candidate.begin() + min(((int)(candidate).size()), coda), 0); res = min(res, nowW * maxH); } } printf( %d n , res); return 0; }
#include <bits/stdc++.h> int findMaximalK(int n); using namespace std; int main() { int n, b, p, x, y; cin >> n >> b >> p; y = n * p; x = 0; int remaining = n; while (remaining > 1) { int doingMatch = pow(2, findMaximalK(remaining)); x += doingMatch * b + doingMatch / 2; int passToNextRound = remaining - doingMatch / 2; remaining = passToNextRound; } cout << x << << y; } int findMaximalK(int n) { int count = 0; while (n > 1) { n /= 2; count++; } return count; }
#include <bits/stdc++.h> using namespace std; using LL = long long; const int M = 1e7 + 5; const int N = 3e5 + 5; struct node { vector<int> h, c; node() { h.clear(); c.clear(); } void read(int n) { int ans; for (int i = 0; i < n; i++) { scanf( %d , &ans); h.push_back(ans); } for (int i = 0; i < n; i++) { scanf( %d , &ans); c.push_back(ans); } } }; vector<node> a; int h[M]; LL c[M]; int tl[M], tr[M]; LL dp[M]; stack<int> sk; void reads(int &n) { int m, k, q; LL mul; scanf( %d%d , &m, &n); for (int i = 1; i <= m; i++) { scanf( %d , &k); node tmp; tmp.read(k); a.push_back(tmp); } scanf( %d , &q); n = 0; while (q--) { scanf( %d%I64d , &k, &mul); k--; for (int i = 0; i < a[k].h.size(); i++) { h[++n] = a[k].h[i]; c[n] = mul * a[k].c[i]; } } } void make_tl(int n) { for (int i = n; i >= 1; i--) { while (!sk.empty() && h[sk.top()] <= sk.top() - i) { tl[sk.top()] = i + 1; sk.pop(); } sk.push(i); } while (!sk.empty()) { tl[sk.top()] = 1; sk.pop(); } } void make_tr(int n) { for (int i = 1; i <= n; i++) { while (!sk.empty() && h[sk.top()] <= i - sk.top()) { tr[sk.top()] = i - 1; sk.pop(); } sk.push(i); } while (!sk.empty()) { tr[sk.top()] = n; sk.pop(); } } int main() { int n; reads(n); make_tl(n); make_tr(n); for (int i = 1; i <= n; i++) { dp[i] = dp[tl[i] - 1] + c[i]; while (!sk.empty() && tr[sk.top()] < i) sk.pop(); if (!sk.empty()) dp[i] = min(dp[i], dp[sk.top() - 1] + c[sk.top()]); if (sk.empty() || dp[sk.top() - 1] + c[sk.top()] > dp[i - 1] + c[i]) sk.push(i); } printf( %I64d n , dp[n]); return 0; }
#include <bits/stdc++.h> long long Max(const long long x, const long long y) { if (x > y) return x; return y; } const long long mo = 1e9 + 7, M = 1005; char s[M]; long long k, a[M], len, dp[M][M][2]; long long dfs(const long long pos, const long long dis, const bool pd, const bool lim) { if (!pos) return pd; if (!lim && ~dp[pos][dis][pd]) return dp[pos][dis][pd]; long long res = 0, up = lim ? a[pos] : 9; for (long long i = 0; i <= up; ++i) if (i != 4 && i != 7) res = (res + dfs(pos - 1, Max(dis - 1, 0), pd, lim && i == up)) % mo; else res = (res + dfs(pos - 1, k, dis || pd, lim && i == up)) % mo; if (!lim) dp[pos][dis][pd] = res; return res; } long long check() { long long last = 0x3f3f3f3f; for (long long i = len; i; --i) if (a[i] == 4 || a[i] == 7) { if (last - i <= k) return 1; last = i; } return 0; } signed main() { memset(dp, -1, sizeof dp); long long T; scanf( %lld%lld , &T, &k); while (T--) { scanf( %s , s); len = strlen(s); for (long long i = 0; i < len; ++i) a[len - i] = s[i] ^ 48; long long ans = (dfs(len, 0, 0, 1) - check() + mo) % mo; scanf( %s , s); len = strlen(s); for (long long i = 0; i < len; ++i) a[len - i] = s[i] ^ 48; ans = (dfs(len, 0, 0, 1) - ans + mo) % mo; printf( %lld n , ans); } return 0; }
#include <bits/stdc++.h> template <class Class> void Print(Class instance) { std::cout << instance << std::endl; } void Print() { std::cout << std::endl; } int main() { std::ios_base::sync_with_stdio(false); size_t n; std::cin >> n; std::vector<int> time(n + 1); std::vector<int> paid(n + 1); size_t hour_pointer = 0; size_t day_pointer = 0; int hour_paid = 0; int day_paid = 0; for (size_t index = 1; index < n + 1; ++index) { std::cin >> time[index]; while (time[hour_pointer] + 90 <= time[index]) { hour_paid -= paid[hour_pointer]; ++hour_pointer; } while (time[day_pointer] + 1440 <= time[index]) { day_paid -= paid[day_pointer]; ++day_pointer; } paid[index] = std::min({20, 50 - hour_paid, 120 - day_paid}); hour_paid += paid[index]; day_paid += paid[index]; Print(paid[index]); } return 0; }
#include <bits/stdc++.h> using namespace std; multiset<int> s1; struct node { char s; int a1; } p1[int(1e6 + 50)]; char s[50]; int main() { int n, a; while (~scanf( %d , &n)) { int cnt = 0; s1.clear(); for (int i = 0; i < n; i++) { scanf( %s , s); if (s[0] != r ) { scanf( %d , &a); if (s[0] == i ) { s1.insert(a); p1[cnt].s = i ; p1[cnt++].a1 = a; } else if (s[0] == g ) { while (!s1.empty() && (*s1.begin()) < a) { s1.erase(s1.begin()); p1[cnt++].s = r ; } if (s1.empty() || (!s1.empty() && (*s1.begin()) > a)) { s1.insert(a); p1[cnt].s = i ; p1[cnt++].a1 = a; } p1[cnt].s = g ; p1[cnt++].a1 = a; } } else { if (!s1.empty()) { s1.erase(s1.begin()); } else { p1[cnt].s = i ; p1[cnt++].a1 = 0; } p1[cnt++].s = r ; } } printf( %d n , cnt); for (int i = 0; i < cnt; i++) { if (p1[i].s == i ) { printf( insert %d n , p1[i].a1); } else if (p1[i].s == g ) { printf( getMin %d n , p1[i].a1); } else if (p1[i].s == r ) { printf( removeMin n ); } } puts( ); } }
#include <bits/stdc++.h> using namespace std; using vi = vector<int>; using vll = vector<long long>; using vvll = vector<vll>; using vpii = vector<pair<int, int> >; using vpll = vector<pair<long long, long long> >; using vld = vector<long double>; using vb = vector<bool>; const int inf = (int)1e9 + 7; const long long llinf = (long long)1e18 + 7; void solve() { long long n; cin >> n; vll a[n]; for (long long i = 0; i < n; i++) { long long ki; cin >> ki; for (long long j = 0; j < ki; j++) { long long x; cin >> x; a[i].push_back(x); } sort(a[i].begin(), a[i].end()); } long long ans = 0; for (long long i = 0; i < n; i++) { long long l, r; l = (i - 1 + n) % n; r = (i + 1 + n) % n; for (long long j = 1; j <= (a[i].size()) - 1; j++) { ans += (upper_bound(a[r].begin(), a[r].end(), a[i][j]) - upper_bound(a[r].begin(), a[r].end(), a[i][j - 1]) != upper_bound(a[l].begin(), a[l].end(), a[i][j]) - upper_bound(a[l].begin(), a[l].end(), a[i][j - 1])); } } cout << ans << n ; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); int ttt = 1; while (ttt--) { solve(); } }
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; vector<int> yarr(51, 0); vector<int> xarr(51, 0); int q = 4 * n + 1; vector<pair<int, int>> trav; for (int i = 0; i < q; i++) { int x, y; cin >> x >> y; trav.push_back(make_pair(x, y)); xarr[x]++; yarr[y]++; } int maxy = 0; int maxx = 0; int minx = 1000, miny = 1000; int indexx = 0, indexy = 0; for (int i = 0; i < 51; i++) { if (yarr[i] >= n && i > maxy) { maxy = i; } if (xarr[i] >= n && i > maxx) { maxx = i; } if (yarr[i] >= n && i < miny) { miny = i; } if (xarr[i] >= n && i < minx) { minx = i; } } for (int i = 0; i < trav.size(); i++) { if (trav[i].first == minx && trav[i].second >= miny && trav[i].second <= maxy) continue; if (trav[i].first == maxx && trav[i].second >= miny && trav[i].second <= maxy) continue; if (trav[i].second == miny && trav[i].first >= minx && trav[i].first <= maxx) continue; if (trav[i].second == maxy && trav[i].first >= minx && trav[i].first <= maxx) continue; cout << trav[i].first << << trav[i].second << n ; break; } }
#include <bits/stdc++.h> using namespace std; long long s[10], m[10]; const long long md = 1e9 + 7; string str; int n; vector<int> v[100010]; int main() { for (int i = 0; i <= 9; i++) { m[i] = 10; s[i] = i; } cin >> str; scanf( %d , &n); for (int i = 1; i <= n; i++) { string st; cin >> st; v[i].push_back(st[0] - 0 ); for (int j = 3; j < st.size(); j++) v[i].push_back(st[j] - 0 ); } for (int i = n; i >= 1; i--) { int cur = v[i][0]; long long mm = 1, ss = 0; for (int j = 1; j < v[i].size(); j++) { ss = (ss * m[v[i][j]]) % md; mm = (mm * m[v[i][j]]) % md; ss += s[v[i][j]]; if (ss >= md) ss -= md; } s[cur] = ss; m[cur] = mm; } long long ans = 0; for (int i = 0; i < str.size(); i++) { ans = (ans * m[str[i] - 0 ]) % md; ans += s[str[i] - 0 ]; if (ans >= md) ans -= md; } printf( %lld , ans); return 0; }
#include <bits/stdc++.h> using namespace std; const long long MOD = 1e9 + 7; long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); } long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); } const int MAXN = 600010; set<int> g[MAXN]; int n, t, m, k; int visited[MAXN]; void dfs(int i) { visited[i] = 1; for (auto x : g[i]) if (!visited[x]) dfs(x); return; } int main() { cin >> n; pair<int, int> a[n]; for (long long i = 0; i < n; i++) cin >> a[i].first >> a[i].second; sort(a, a + n); int res = 0; set<pair<int, pair<int, int> > > s; for (long long i = 0; i < n; i++) { auto x = s.lower_bound({a[i].first, {-((long long)1e15), -((long long)1e15)}}); while (x != s.begin()) { s.erase(s.begin()); } auto it = s.upper_bound({a[i].second, {-((long long)1e15), -((long long)1e15)}}); x = s.begin(); while (x != it) { g[i].insert(x->second.second); g[x->second.second].insert(i); res++; if (res >= n) { cout << NO << n ; return 0; } x++; } s.insert({a[i].second, {a[i].first, i}}); } dfs(0); for (long long i = 0; i < n; i++) { if (!visited[i]) { cout << NO ; return 0; } } if (res == n - 1) cout << YES ; else cout << NO ; return 0; }
#include <bits/stdc++.h> using namespace std; int n, m; int a, b, c; vector<pair<int, int> > v[200005], e[200005]; int p[200005]; int fin(int x) { if (p[x] != x) p[x] = fin(p[x]); return p[x]; } void onion(int x, int y) { if (fin(x) == fin(y)) return; p[fin(y)] = fin(x); } priority_queue<pair<long long, pair<int, int> > > q; int lca[200005][25], maxi[200005][25]; int depth[200005]; long long sum = 0; long long cen[200005]; void dfs(int node, int prev) { for (auto it : e[node]) { if (it.first == prev) continue; depth[it.first] = depth[node] + 1; lca[it.first][0] = node; maxi[it.first][0] = it.second; dfs(it.first, node); } } int plz(int x, int y) { if (depth[x] < depth[y]) swap(x, y); int res = 0; for (int i = 20; i >= 0; i--) { if (depth[x] - (1 << i) >= depth[y]) { res = max(res, maxi[x][i]); x = lca[x][i]; } } if (x == y) return res; for (int i = 20; i >= 0; i--) { if (lca[x][i] != lca[y][i]) { res = max(res, maxi[x][i]); res = max(res, maxi[y][i]); x = lca[x][i]; y = lca[y][i]; } } res = max(res, maxi[x][0]); res = max(res, maxi[y][0]); return res; } pair<int, int> rr[200005]; map<pair<int, int>, int> mapa; int main() { scanf( %d%d , &n, &m); for (int i = 1; m >= i; i++) { scanf( %d%d%d , &a, &b, &c); rr[i] = {a, b}; cen[i] = c; v[a].push_back({b, c}); v[b].push_back({a, c}); q.push({-c, {a, b}}); } for (int i = 1; n >= i; i++) p[i] = i; while (!q.empty()) { int cost = -q.top().first; int u = q.top().second.first; int uu = q.top().second.second; q.pop(); if (fin(u) == fin(uu)) continue; onion(u, uu); e[u].push_back({uu, cost}); e[uu].push_back({u, cost}); mapa[{u, uu}] = 1; sum += cost; } dfs(1, -1); for (int j = 1; 20 >= j; j++) for (int i = 1; n >= i; i++) { lca[i][j] = lca[lca[i][j - 1]][j - 1]; maxi[i][j] = max(maxi[i][j - 1], maxi[lca[i][j - 1]][j - 1]); } int qq; qq = m; for (int i = 1; m >= i; i++) { int a = rr[i].first; int b = rr[i].second; if (mapa[{a, b}] == 1) { printf( %lld n , sum); continue; } long long wynik = 1LL * sum + cen[i] - plz(a, b); printf( %lld n , wynik); } }
#include <bits/stdc++.h> using namespace std; const int MAXN = 3010; const int INF = 0x3f3f3f3f; int d[MAXN], e[MAXN]; int main() { memset(d, INF, sizeof d); memset(e, INF, sizeof e); int n; cin >> n; string s; cin >> s; int at = INF; for (int i = 0; i < n; i++) { if (s[i] == R ) at = 0; else if (s[i] == L ) at = INF; d[i] = at; if (at < INF) at++; } at = INF; for (int i = n - 1; i >= 0; i--) { if (s[i] == R ) at = INF; else if (s[i] == L ) at = 0; e[i] = at; if (at < INF) at++; } int cont = 0; for (int i = 0; i < n; i++) { if (d[i] == e[i]) cont++; } cout << cont << endl; }
#include <bits/stdc++.h> using namespace std; inline void Rd(int &res) { char c; res = 0; while (c = getchar(), c < 0 ) ; do { res = (res << 1) + (res << 3) + (c ^ 48); } while (c = getchar(), c >= 0 ); } const int S = 200; long long n, s, ans; int work(long long x) { int rs = 0; while (x) { rs += x % 10; x /= 10; } return rs; } int main() { cin >> n >> s; for (int i = 1; i <= n && i <= S; i++) { int sum = work(i); if (abs(sum - i) >= s) ans++; } if (n > S) { ans += max((long long)0, n - (s + S) + 1); if (s < S) { for (long long i = S + 1; i < s + S && i <= n; i++) { int sum = work(i); if (abs(sum - i) >= s) ans++; } } else { for (long long i = s; i < s + S && i <= n; i++) { int sum = work(i); if (abs(sum - i) >= s) ans++; } } } cout << ans << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { long long a, b, c, i, fuck = 0; scanf( %lld , &a); scanf( %lld , &b); scanf( %lld , &c); for (i = a; i >= 1; i--) { if ((2 * i) <= b && (4 * i) <= c) { fuck = 1; break; } } if (fuck == 0) printf( 0 n ); else printf( %lld , i + 2 * i + 4 * i); return 0; }
#include <bits/stdc++.h> using namespace std; unsigned long long pw[1020304], iv[1020304]; unsigned long long h[1020304], f[1020304]; int check(int l, int r) { unsigned long long p1 = (h[r] + 1000000007 - h[l - 1] * pw[r - l + 1] % 1000000007) % 1000000007, p2 = (f[r] + 1000000007 - f[l - 1]) * iv[l - 1] % 1000000007; return p1 == p2; } int n, d; char s[1020304]; bool dfs(int i, bool w) { if (i == 4) { int z = i; } if (i > n && w) cout << s + 1 << endl; if (i > n) return w; char t = s[i]; for (char c = (w) ? a : s[i]; c <= z ; c++) { if (i >= d) if (check(i - d + 2, i - 1) && s[i - d + 1] == c) continue; if (i > d) if (check(i - d + 1, i - 1) && s[i - d] == c) continue; h[i] = (h[i - 1] * 10007 + c) % 1000000007; f[i] = (f[i - 1] + pw[i - 1] * c) % 1000000007; s[i] = c; if (dfs(i + 1, c > t || w)) return true; } s[i] = t; return false; } int main() { unsigned long long t = 1; pw[0] = iv[0] = 1; for (int i = 1; i <= 400000; ++i) pw[i] = pw[i - 1] * 10007 % 1000000007, iv[i] = iv[i - 1] * 820925358 % 1000000007; cin >> d; scanf( %s , s + 1); n = strlen(s + 1); if (d == 1) { puts( Impossible ); return 0; } if (!dfs(1, 0)) { puts( Impossible ); return 0; } return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 150000; const int L = 19; vector<int> edges[N]; long long x[N], y[N]; int anc[N][L], tin[N], tout[N], s[N], moment; void dfs(int x, int last) { tin[x] = ++moment; anc[x][0] = last; for (int i = 1; i < L; i++) anc[x][i] = anc[anc[x][i - 1]][i - 1]; for (int i = 0; i < edges[x].size(); i++) if (edges[x][i] != last) dfs(edges[x][i], x); tout[x] = ++moment; } long long coef(int i, int j, int k) { long long a = y[i] - y[j], b = x[j] - x[i], c = x[i] * y[j] - x[j] * y[i]; return (a * x[k] + b * y[k] + c); } bool father(int x, int y) { return (tin[x] <= tin[y] && tout[y] <= tout[x]); } int lca(int a, int b) { if (father(a, b)) return a; if (father(b, a)) return b; for (int i = L - 1; i >= 0; i--) if (!father(anc[a][i], b)) a = anc[a][i]; return anc[a][0]; } int main() { int n; scanf( %d , &n); for (int i = 1; i <= n; i++) scanf( %I64d %I64d , &x[i], &y[i]); int cnt = 1; s[cnt] = n; for (int i = n - 1; i >= 1; i--) { s[++cnt] = i; while (cnt > 2 && coef(s[cnt], s[cnt - 2], s[cnt - 1]) < 0) swap(s[cnt - 1], s[cnt]), cnt--; edges[s[cnt]].push_back(s[cnt - 1]); edges[s[cnt - 1]].push_back(s[cnt]); } moment = 0, dfs(n, n); int quests; scanf( %d , &quests); for (int i = 1; i <= quests; i++) { int x, y; scanf( %d %d , &x, &y); printf( %d , lca(x, y)); } return 0; }
#include <bits/stdc++.h> #pragma GCC optimize( Ofast,no-stack-protector,unroll-loops,fast-math ) using namespace std; const double inf = 1e121; const double eps = 1e-10; mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); long long randint(long long l, long long r) { long long out = rng() % (r - l + 1) + l; return out >= l ? out : out + r - l + 1; } template <typename A, typename B> string to_string(pair<A, B> p); template <typename A, typename B, typename C> string to_string(tuple<A, B, C> p); template <typename A, typename B, typename C, typename D> string to_string(tuple<A, B, C, D> p); string to_string(const string& s) { return + s + ; } string to_string(const char* s) { return to_string((string)s); } string to_string(bool b) { return (b ? true : false ); } string to_string(vector<bool> v) { bool first = true; string res = { ; for (long long i = 0; i < static_cast<long long>(v.size()); i++) { if (!first) { res += , ; } first = false; res += to_string(v[i]); } res += } ; return res; } template <size_t N> string to_string(bitset<N> v) { string res = ; for (size_t i = 0; i < N; i++) { res += static_cast<char>( 0 + v[i]); } return res; } 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; } template <typename A, typename B> string to_string(pair<A, B> p) { return ( + to_string(p.first) + , + to_string(p.second) + ) ; } template <typename A, typename B, typename C> string to_string(tuple<A, B, C> p) { return ( + to_string(get<0>(p)) + , + to_string(get<1>(p)) + , + to_string(get<2>(p)) + ) ; } template <typename A, typename B, typename C, typename D> string to_string(tuple<A, B, C, D> p) { return ( + to_string(get<0>(p)) + , + to_string(get<1>(p)) + , + to_string(get<2>(p)) + , + to_string(get<3>(p)) + ) ; } template <typename A, typename B, typename C, typename D, typename E> string to_string(tuple<A, B, C, D, E> p) { return ( + to_string(get<0>(p)) + , + to_string(get<1>(p)) + , + to_string(get<2>(p)) + , + to_string(get<3>(p)) + , + to_string(get<4>(p)) + ) ; } void debug_out() { cerr << endl; } template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) { cerr << << to_string(H); debug_out(T...); } template <typename T> struct is_pair { static const bool value = false; }; template <typename T, typename U> struct is_pair<std::pair<T, U>> { static const bool value = true; }; const long long INF = 0x3f3f3f3f3f3f3f3fll; template <typename T> typename enable_if<!is_integral<T>::value && !is_pair<T>::value, void>::type read(T& x) { cin >> x; } long long read() { char c; long long out = 0, f = 1; for (c = getchar(); !isdigit(c) && c != - ; c = getchar()) { } if (c == - ) { f = -1; c = getchar(); } for (; isdigit(c); c = getchar()) out = (out << 3) + (out << 1) + c - 0 ; return out * f; } template <typename T> typename enable_if<is_integral<T>::value, T>::type read(T& x) { char c; T f = 1; x = 0; for (c = getchar(); !isdigit(c) && c != - ; c = getchar()) { } if (c == - ) { f = -1; c = getchar(); } for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + c - 0 ; return x *= f; } char read(char& x) { for (x = getchar(); isspace(x); x = getchar()) { } return x; } double read(double& x) { scanf( %lf , &x); return x; } template <typename T> typename enable_if<!is_integral<T>::value && !is_pair<T>::value, void>::type write(const T& x) { cout << x; } template <typename T> typename enable_if<is_integral<T>::value, void>::type write(const T& x) { if (x < 0) { putchar( - ); write(-x); return; } if (x > 9) write(x / 10); putchar(x % 10 + 0 ); } void write(const char& x) { putchar(x); } void write(const double& x) { printf( %.10lf , x); } template <typename T> typename enable_if<is_pair<T>::value, void>::type read(T& x) { read(x.first); read(x.second); } template <typename T> typename enable_if<is_pair<T>::value, void>::type write(const T& x) { write(x.first); putchar( ); write(x.second); } template <typename T, typename... Args> void read(T& x, Args&... args) { read(x); read(args...); } template < typename OutputIt, typename = typename enable_if< is_same<output_iterator_tag, typename iterator_traits<OutputIt>::iterator_category>::value || (is_base_of<forward_iterator_tag, typename iterator_traits<OutputIt>:: iterator_category>::value && !is_const<OutputIt>::value)>::type> void read(OutputIt __first, OutputIt __last) { for (; __first != __last; ++__first) read(*__first); } template < typename InputIt, typename = typename enable_if<is_base_of< input_iterator_tag, typename iterator_traits<InputIt>::iterator_category>::value>::type> void wts(InputIt __first, InputIt __last) { bool isFirst = true; for (; __first != __last; ++__first) { if (isFirst) isFirst = false; else putchar( ); write(*__first); } putchar( n ); } template < typename InputIt, typename = typename enable_if<is_base_of< input_iterator_tag, typename iterator_traits<InputIt>::iterator_category>::value>::type> void wtb(InputIt __first, InputIt __last) { for (; __first != __last; ++__first) { write(*__first); putchar( n ); } } template <typename T> void wts(const T& x) { write(x); putchar( ); } template <typename T> void wtb(const T& x) { write(x); putchar( n ); } template <typename T> void wte(const T& x) { write(x); exit(0); } template <typename T, typename... Args> void wts(const T& x, Args... args) { wts(x); wts(args...); } template <typename T, typename... Args> void wtb(const T& x, Args... args) { wts(x); wtb(args...); } template <typename T, typename... Args> void wte(const T& x, Args... args) { wts(x); wte(args...); } template <typename T1, typename T2> inline bool up(T1& x, const T2& y) { return x < y ? x = y, 1 : 0; } template <typename T1, typename T2> inline bool dn(T1& x, const T2& y) { return y < x ? x = y, 1 : 0; } template <typename T1, typename T2, typename T3> inline bool inRange(const T1& x, const T2& l, const T3& r) { return !(x < l) && !(r < x); } template <typename T1, typename T2> inline auto minOfDifferentTypes(const T1& x, const T2& y) -> decltype(x < y ? x : y) { return x < y ? x : y; } template <typename T1, typename T2> inline auto maxOfDifferentTypes(const T1& x, const T2& y) -> decltype(x < y ? y : x) { return x < y ? y : x; } template <typename T1, typename T2, typename T3> inline T1& madd(T1& x, const T2& y, const T3& modulo) { return x = (long long)(x + y + modulo) % modulo; } template <typename T1, typename T2, typename T3> inline T1& mmul(T1& x, const T2& y, const T3& modulo) { return x = (long long)x * y % modulo; } template <typename T1, typename T2, typename T3> inline long long modadd(long long x, long long y, long long modulo) { return (x += y) >= modulo ? x - modulo : x; } inline long long isinf(long long x) { return x < INF ? x : -1; } inline void yesno(bool x) { wtb(x ? Yes : No ); } signed main() { long long t = read(); while (t--) { long long n = read(); long long k = read(); if (n >= k && ((n - (k - 1)) & 1)) { wtb( YES ); for (long long i = (1), iend = (k - 1); i <= iend; ++i) wts(1); wtb(n - k + 1); } else if (n >= 2 * k && !(n & 1)) { wtb( YES ); for (long long i = (1), iend = (k - 1); i <= iend; ++i) wts(2); wtb(n - 2 * k + 2); } else wtb( NO ); } return 0; }
#include <bits/stdc++.h> using namespace std; int n, tot, d[105]; int read() { int _ = 0, ___ = 1; char __ = getchar(); while (__ > 9 || __ < 0 ) { if (__ == - ) ___ = -1; __ = getchar(); } while (__ >= 0 && __ <= 9 ) { _ = _ * 10 + __ - 0 ; __ = getchar(); } return _ * ___; } int get(int x) { int sum = 0; while (x) { sum += x % 10; x /= 10; } return sum; } int main() { n = read(); for (int i = max(n - 81, 0); i <= n; i++) { int x = get(i); if (x + i == n) d[++tot] = i; } printf( %d n , tot); for (int i = 1; i <= tot; i++) printf( %d , d[i]); return 0; }
#include <bits/stdc++.h> using namespace std; int prime(int n) { if (n == 1) { return 0; } for (int i = 2; i * i <= n; i++) { if (n % i == 0) { return 0; } } return 1; } int main() { int n; cin >> n; int cnt = n; while (!prime(cnt)) { cnt++; } cout << cnt << endl; for (int i = 1; i <= n; i++) { cout << i << << i % n + 1 << endl; } int now = 1; while (cnt != n) { cout << now << << n - now << endl; now++; cnt--; } return 0; }
#include <bits/stdc++.h> using namespace std; const long long mod = 1e9 + 7; long double PI = acosl(-1); const long long inf = 3e18; const int nmax = 1e5 + 5; const int MAXLG = log2(nmax) + 1; vector<int> g[nmax]; long long val[nmax], chein[nmax], path[nmax]; long long dfs(int u, int p = 0) { chein[u] = path[u] = val[u]; vector<long long> mxcheins; for (int v : g[u]) if (v != p) { mxcheins.push_back(dfs(v, u)); chein[u] = max(chein[u], chein[v] + val[u]); path[u] = max(path[u], path[v]); } path[u] = max(path[u], chein[u]); sort(mxcheins.rbegin(), mxcheins.rend()); if (mxcheins.size() > 1) path[u] = max(path[u], val[u] + mxcheins[0] + mxcheins[1]); else if (mxcheins.size() > 0) path[u] = max(path[u], val[u] + mxcheins[0]); return chein[u]; } long long dfs2(int u, long long mxpath, long long mxchein, int p = 0) { multiset<long long> alpath; multiset<long long> alchein; for (int v : g[u]) if (v != p) alpath.insert(path[v]), alchein.insert(chein[v]); alchein.insert(mxchein), alpath.insert(mxpath); long long ret = mxpath + path[u]; for (int v : g[u]) if (v != p) { alpath.erase(alpath.find(path[v])); alchein.erase(alchein.find(chein[v])); long long mxp2 = *alpath.rbegin(), mxc2 = *alchein.rbegin() + val[u]; if (alchein.size() > 1) { long long tmp = *alchein.rbegin(); alchein.erase(alchein.find(tmp)); long long tmp2 = *alchein.rbegin(); mxp2 = max(mxp2, val[u] + tmp + tmp2); alchein.insert(tmp); } else if (alchein.size() > 0) { mxp2 = max(mxp2, val[u] + *alchein.rbegin()); } mxp2 = max(mxp2, mxc2); ret = max(ret, dfs2(v, mxp2, mxc2, u)); alpath.insert(path[v]), alchein.insert(chein[v]); } return ret; } int main() { ios::sync_with_stdio(false); cin.tie(0); int n; cin >> n; for (int i = 1; i <= n; i++) cin >> val[i]; for (int i = 1; i < n; i++) { int u, v; cin >> u >> v; g[u].push_back(v); g[v].push_back(u); } dfs(1); cout << dfs2(1, 0, 0); }
#include <bits/stdc++.h> using namespace std; int main() { long long n, x, k; cin >> n >> k; vector<long long> v; set<long long> s; map<long long, long long> m; for (long long i = 0; i < n; i++) { cin >> x; if (m[x] == 0) { m[x]++; v.insert(v.begin(), x); } if (v.size() > k) { m[v.back()] = 0; v.pop_back(); } } long long a = v.size(); cout << min((a), k) << endl; for (long long i = 0; i < v.size(); i++) { cout << v[i] << ; } }
#include <bits/stdc++.h> using namespace std; int md = 1e9 + 7; int __gcd(int a, int b) { if (b == 0) return a; return __gcd(b, a % b); } int poww(int a, int b) { int res = 1; while (b) { if (b & 1) { res *= a; res %= md; } a *= a; a %= md; b >>= 1; } return res; } void ainp(int arr[], int n) { for (int i = 1; i <= n; i++) cin >> arr[i]; } const int N = 1e5 + 5; void fun() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); } int n; int a[N], cache[N][10]; int dp(int idx, int cur) { if (idx == n) return 1; int &ans = cache[idx][cur]; if (ans != -1) return ans; ans = 0; if (a[idx + 1] > a[idx]) { for (int i = cur + 1; i <= 5; i++) ans |= dp(idx + 1, i); } else if (a[idx + 1] == a[idx]) { for (int i = 1; i <= 5; i++) { if (i == cur) continue; ans |= dp(idx + 1, i); } } else { for (int i = 1; i < cur; i++) ans |= dp(idx + 1, i); } return ans; } void path(int idx, int cur) { cout << cur << ; if (idx == n) return; if (a[idx + 1] > a[idx]) { for (int i = cur + 1; i <= 5; i++) if (dp(idx + 1, i)) return path(idx + 1, i); } else if (a[idx + 1] == a[idx]) { for (int i = 1; i <= 5; i++) { if (i == cur) continue; if (dp(idx + 1, i)) return path(idx + 1, i); } } else { for (int i = 1; i < cur; i++) if (dp(idx + 1, i)) return path(idx + 1, i); } } signed main() { fun(); memset(cache, -1, sizeof(cache)); cin >> n; for (int i = 1; i <= n; i++) cin >> a[i]; for (int i = 1; i <= 5; i++) { if (dp(1, i)) { path(1, i); return 0; } } cout << -1 ; return 0; }
#include <bits/stdc++.h> using namespace std; #define ar array #define ll long long const int MAX_N = 1e5 + 1; const int m = 1e9 + 7; const int INF = 1e9; const ll LINF = 1e18; int main() { int t=1; cin>>t; int n; while(t--) { cin>>n; int A[n]; for(int i=0;i<n;i++)cin>>A[i]; int x=0,y=n-1; while(x<=y){ cout<<A[x]<< ; if(x!=y)cout<<A[y--]<< ; x++; } cout<<endl; } return 0; }
#include <bits/stdc++.h> using namespace std; long long dp[2000010], v[2000010]; int main() { for (int i = 3; i <= 2000000; i++) { dp[i] = (dp[i - 1] + 2 * dp[i - 2] + 4 * (!v[i - 1] && !v[i - 2])) % 1000000007; v[i] = !v[i - 1] && !v[i - 2]; } int t; scanf( %d , &t); while (t--) { int n; scanf( %d , &n); printf( %I64d n , dp[n]); } return 0; }
#include <bits/stdc++.h> using namespace std; const int maxn = 3e3; int r, c, n, k, tot, bound[maxn + 2], vis[maxn + 2], suc[maxn + 2], pre[maxn + 2], rest[maxn + 2]; bool exist[maxn + 2][maxn + 2]; long long ans; struct vertex { int x, y; } a[maxn + 1]; vector<int> t[maxn + 1]; int main() { scanf( %d%d%d%d , &r, &c, &n, &k); for (int i = 1; i <= n; ++i) { scanf( %d%d , &a[i].x, &a[i].y); exist[a[i].x][a[i].y] = true; } for (int i = 1; i <= r; ++i) { memset(vis, 0, sizeof vis); memset(suc, 0, sizeof suc); memset(pre, 0, sizeof pre); memset(rest, 0, sizeof rest); tot = 0; suc[c + 1] = c + 1; for (int j = 1; j <= c + 1; ++j) bound[j] = c + 1; for (int j = 1; j <= n; ++j) if (a[j].x >= i) { ++vis[a[j].y]; t[a[j].x].push_back(a[j].y); } for (int j = 1, l = 0, sum = 0; j <= c; ++j) { while (l <= c && sum < k) sum += vis[++l]; if (l > c) break; bound[j] = l; rest[j] = sum; sum -= vis[j]; } for (int j = 1, last = 0; j <= c; ++j) { if (vis[j]) { suc[last] = j; pre[j] = last; last = j; } if (j == c) { suc[last] = c + 1; pre[c + 1] = last; } } long long sum = 0; for (int j = c + 1; j; j = pre[j]) sum += (long long)(c - bound[j] + 1) * (j - pre[j]); for (int j = r; j >= i; --j) { ans += sum; for (int l = 0; l < t[j].size(); ++l) { int lt = t[j][l]; --vis[lt]; for (int cnt = vis[lt], now = lt; now && bound[now] >= lt; now = pre[now]) { --rest[now]; if (rest[now] < k) { sum -= (long long)(c - bound[now] + 1) * (now - pre[now]); bound[now] = suc[bound[now]]; rest[now] += vis[bound[now]]; sum += (long long)(c - bound[now] + 1) * (now - pre[now]); } } if (!vis[lt]) { sum += (long long)(c - bound[suc[lt]] + 1) * (suc[lt] - pre[lt]) - (long long)(c - bound[lt] + 1) * (lt - pre[lt]) - (long long)(c - bound[suc[lt]] + 1) * (suc[lt] - lt); pre[suc[lt]] = pre[lt]; suc[pre[lt]] = suc[lt]; } } t[j].clear(); } } printf( %lld , ans); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int t; cin >> t; while (t--) { int n, a, b; string s = ; cin >> n >> a >> b; s += a ; for (int i = 1; i < b; i++) { s += s[i - 1] + 1; } string s2 = s; for (int i = 0; i < n / b - 1; i++) { s += s2; } for (int i = 0; i < n % b; i++) { s += s[i]; } cout << s << endl; } }
#include <bits/stdc++.h> using namespace std; set<int> cn[10000]; int nx[10000]; string xm[10000]; int main() { int m; cin >> m; ; map<string, int> mx; int n = 0; for (int i = (0); i < m; i++) { string a, b; cin >> a >> b; if (!mx.count(a)) mx[a] = n, xm[n++] = a; if (!mx.count(b)) mx[b] = n, xm[n++] = b; cn[mx[a]].insert(mx[b]); cn[mx[b]].insert(mx[a]); } cout << n << endl; for (int i = (0); i < n; i++) { memset(nx, 0, sizeof(nx)); int my = -1, cmy = 0; for (auto f : cn[i]) { for (auto fx : cn[f]) { if (fx == i || cn[fx].count(i)) continue; nx[fx]++; if (nx[fx] > my) my = nx[fx], cmy = 1; else if (nx[fx] == my) cmy++; } } if (cmy == 0) { cmy = n - 1 - cn[i].size(); } cout << xm[i] << << cmy << endl; } return 0; }
#include <bits/stdc++.h> enum { WHITE, GREY, BLACK }; using namespace std; long long int inf = 1e18; 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 <typename T> T last_bit(T n) { return n & 1; } 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 modInv(T a, T m) { T x, y; extgcd(a, m, x, y); x %= m; while (x < 0) { x += m; } return x; } template <class T> T extgcd(T a, T b, T& x, T& y) { if (b == 0) { x = 1; y = 0; return a; } else { int g = extgcd(b, a % b, y, x); y -= a / b * x; return g; } } template <class T> T multiplication(T n, T p, T m) { if (p == 0) return (T)0; T x = multiplication(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> double getdist(T a, T b) { return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y)); } template <class T> T extract(string s, T ret) { stringstream ss(s); ss >> ret; return ret; } template <class T> string tostring(T n) { stringstream ss; ss << n; return ss.str(); } template <class T> T Mod(T n, T m) { return (n % m + m) % m; } template <class T> T MIN3(T a, T b, T c) { return min(a, min(b, c)); } template <class T> T MAX3(T a, T b, T c) { return max(a, max(b, c)); } template <class T> void print_vector(T& v) { int sz = v.size(); if (sz) cout << v[0]; for (int i = 1; i < sz; i++) cout << << v[i]; cout << n ; } bool isVowel(char ch) { ch = toupper(ch); if (ch == A || ch == U || ch == I || ch == O || ch == E ) return true; return false; } bool isConsonant(char ch) { if (isalpha(ch) && !isVowel(ch)) return true; return false; } template <class R> R Josephus(R n, R k) { R ans = 1; for (R i = 2; i <= n; i++) ans = (ans + k - 1) % i + 1; return ans; } template <class R> R toitent_Phi2(R a) { R result = a; for (R i = 2; i * i <= a; i++) { if (a % i == 0) result = result - result / i; while (a % i == 0) a = a / i; } if (a > 1) result = result - result / a; return result; } template <typename T> T Angle(T x1, T y1, T x2, T y2) { return atan(double(y1 - y2) / double(x1 - x2)); } long long int a[102]; int main() { cin.sync_with_stdio(false); cin.tie(); ; long long int T, t; long long int i, j, k; long long int n, m, q; scanf( %lld , &n); for (i = 1; i <= 2 * n; i++) { scanf( %lld , &a[i]); } sort(a + 1, a + 1 + 2 * n); long long int f = 1; j = n; for (i = 2 * n; i > n; i--) { for (j = n; j >= 1; j--) { if (a[i] <= a[j]) f = 0; } } if (f) printf( YES n ); else printf( NO n ); return 0; }
#include <bits/stdc++.h> using namespace std; int n, m, k, ans, s, e, in[100020], pre[100020], vis[100020], ff[100020]; long long len[100020]; struct node { int v, f; long long w; }; vector<node> adj[100020]; bool operator<(const node &x, const node &y) { if (x.w > y.w) return true; return false; } int dijk(int s) { priority_queue<node> q; node now, newnode; now.w = 0; now.v = s; q.push(now); int i, u, v; memset(ff, 0, sizeof(ff)); memset(vis, 0, sizeof(vis)); memset(len, 123, sizeof(len)); len[s] = 0; int cnt = 0; while (!q.empty()) { if (cnt == n) break; u = q.top().v; q.pop(); if (vis[u]) continue; vis[u] = 1; for (i = 0; i < adj[u].size(); i++) { now = adj[u][i]; v = now.v; if (now.w + len[u] < len[v] || (now.w + len[u] == len[v] && !now.f)) { len[v] = now.w + len[u]; newnode.w = len[v]; newnode.v = v; if (now.f) ff[v] = 1; else ff[v] = 0; pre[v] = u; q.push(newnode); } } cnt++; } return 0; } void addnode(int u, int v, int w, int f) { node nn; nn.v = v; nn.w = w; nn.f = f; adj[u].push_back(nn); } int main() { ans = 0; int t, i, u, v, w, cnt = 0; node now, nn; scanf( %d%d%d , &n, &m, &k); for (i = 0; i < m; i++) { scanf( %d%d%d , &u, &v, &w); addnode(u, v, w, 0); addnode(v, u, w, 0); } for (i = 0; i < k; i++) { scanf( %d%d , &v, &w); addnode(1, v, w, 1); addnode(v, 1, w, 1); } dijk(1); ans = 0; for (int i = 2; i <= n; i++) { if (ff[i]) ans++; } printf( %d n , k - ans); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); long long int n; cin >> n; long long int mc[6]; mc[0] = mc[5] = 0; for (long long int i = 0, k = 0; i < n; i++) { cin >> k; mc[k] += 1; } if (mc[0] < 1) cout << -1; else if (mc[5] < 9) cout << 0; else { for (long long int i = 0; i < mc[5] / 9 * 9; i++) cout << 5; for (long long int i = 0; i < mc[0]; i++) cout << 0; } return 0; }
#include <bits/stdc++.h> using namespace std; const int MOD = 32768, N = 109; char ch; string s[N], t; int ans, v, f[MOD + 9], num, p, pos; int ex(); int gt() { int ret = 0; if (t[pos] == n ) return pos++, v; if (t[pos] == f ) return pos += 2, ret = f[ex()], pos++, ret; while (t[pos] >= 0 && t[pos] <= 9 ) ret = ret * 10 + (t[pos] - 0 ), pos++; return ret; } int nex() { int ret = gt(); while (t[pos] == * || t[pos] == / ) { char tp = t[pos]; pos++; int t1 = gt(); if (tp == * ) ret = (int)((1ll * ret * t1) % MOD); else ret = (ret / t1) % MOD; } return ret; } int ex() { int ret = nex(); while (t[pos] == + || t[pos] == - ) { char tp = t[pos]; pos++; int t1 = nex(); if (tp == + ) ret = (ret + t1) % MOD; else ret = (ret + MOD - t1) % MOD; } return ret; } bool iex() { int p1, p2, tp; p1 = ex(); if (t[pos] == = ) tp = 0, pos += 2; else if (t[pos] == < ) tp = -1, pos++; else tp = 1, pos++; p2 = ex(); if (tp == 0) return p1 == p2; if (tp == -1) return p1 < p2; if (tp == 1) return p1 > p2; return 0; } int getans() { for (int i = 0; i < num; i++) { t = s[i]; if (t[0] == i ) { pos = 3; if (iex()) return pos += 7, ex(); } else return pos = 6, ex(); } return -1; } int main() { cin >> ans >> ch; while (ch != { ) cin >> ch; num = 0; while (true) { cin >> ch; if (ch == } ) break; if (ch == ; ) num++; else s[num] += ch; } int anst = -1; for (int i = 0; i < MOD; i++) { v = i, f[i] = getans(); if (f[i] == ans) anst = i; } cout << anst; }
#include <bits/stdc++.h> using namespace std; int n, m, l; vector<vector<int>> adj; int timer; vector<int> tin, tout; vector<vector<int>> up; vector<int> dist; vector<int> down; void dfs(int v, int p) { dist[v] = dist[p] + 1; down[v] = 1; tin[v] = ++timer; up[v][0] = p; for (int i = 1; i <= l; ++i) up[v][i] = up[up[v][i - 1]][i - 1]; for (int u : adj[v]) { if (u != p) { dfs(u, v); down[v] += down[u]; } } tout[v] = ++timer; } bool is_ancestor(int u, int v) { return tin[u] <= tin[v] && tout[u] >= tout[v]; } int lca(int u, int v) { if (is_ancestor(u, v)) return u; if (is_ancestor(v, u)) return v; for (int i = l; i >= 0; --i) { if (!is_ancestor(up[u][i], v)) u = up[u][i]; } return up[u][0]; } int pre(int u, int v) { for (int i = l; i >= 0; --i) { if (!is_ancestor(up[u][i], v)) u = up[u][i]; } return u; } void preprocess(int root) { tin.resize(n + 1); tout.resize(n + 1); timer = 0; l = ceil(log2(n + 1)); up.assign(n + 1, vector<int>(l + 2)); dfs(root, root); } void trav(int x, int d) { int to = x; for (int i = l; i >= 0; i--) { if (dist[x] - dist[up[to][i]] < d) { to = up[to][i]; } } cout << down[up[to][0]] - down[to] << n ; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cin >> n; adj.resize(n + 1); dist.resize(n + 1); down.resize(n + 1); for (int i = 0; i < n - 1; i++) { int x, y; cin >> x >> y; adj[x].push_back(y); adj[y].push_back(x); } preprocess(1); cin >> m; for (int i = 0; i < m; i++) { int x, y; cin >> x >> y; int L = lca(x, y); if (x == y) { cout << n << n ; continue; } int d = (dist[x] - dist[L] + dist[y] - dist[L] + 1); if (d % 2 == 0) { cout << 0 << n ; } else { if (dist[x] - dist[L] == dist[y] - dist[L]) { cout << n - down[pre(x, L)] - down[pre(y, L)] << n ; } else { d = (dist[x] - dist[L] + dist[y] - dist[L]); if (dist[x] < dist[y]) swap(x, y); int z = d / 2; trav(x, z); } } } return 0; }
#include <bits/stdc++.h> using namespace std; int fp(int abc, int parent[]) { if (parent[abc] == abc) return abc; int def = fp(parent[abc], parent); parent[abc] = def; return def; } void cycledmerge(vector<int> hub[], int n, int parent[]) { stack<int> urutan; for (int i = 0; i < n; i++) parent[i] = i; stack<pair<int, int> > ngurut; vector<int> sudah(n, 0); vector<int> adadiurutan(n, 0); vector<int> dari(n, -1); for (int i = 0; i < n; i++) { if (sudah[i]) continue; urutan.push(i); ngurut.push(make_pair(i, 0)); adadiurutan[i] = 1; sudah[i] = 1; while (!ngurut.empty()) { int id = ngurut.top().first; int val = ngurut.top().second; ngurut.pop(); if (val == (int)hub[id].size()) { while (!urutan.empty() && urutan.top() == id) urutan.pop(); adadiurutan[id] = 0; continue; } ngurut.push(make_pair(id, val + 1)); int next = hub[id][val]; if (dari[id] == next) continue; if (sudah[next] && !adadiurutan[fp(next, parent)]) continue; if (!sudah[next]) { sudah[next] = 1; urutan.push(next); ngurut.push(make_pair(next, 0)); adadiurutan[next] = 1; dari[next] = id; continue; } if (parent[fp(id, parent)] == fp(next, parent)) continue; parent[fp(id, parent)] = fp(next, parent); while (!urutan.empty() && urutan.top() != fp(next, parent)) { parent[fp(urutan.top(), parent)] = fp(next, parent); urutan.pop(); } } } return; } int main() { int p[200]; vector<int> hub[200]; int n, m; cin >> n >> m; for (int(i) = 0; (i) < (m); ++(i)) { int a, b; cin >> a >> b; --a; --b; hub[a].push_back(b); hub[b].push_back(a); } cycledmerge(hub, n, p); vector<int> ukuran(n, 0); for (int(i) = 0; (i) < (n); ++(i)) ukuran[p[i]]++; int numcyc = 0; for (int(i) = 0; (i) < (n); ++(i)) if (ukuran[i] >= 3) ++numcyc; if (numcyc != 1) { cout << NO << endl; return 0; } int besar = 0; for (int(i) = 0; (i) < (n); ++(i)) if (ukuran[i] >= 3) besar = ukuran[i]; int yesadj = 0; int noadj = 0; for (int(i) = 0; (i) < (n); ++(i)) for (int(j) = 0; (j) < (((int)hub[i].size())); ++(j)) { int k = hub[i][j]; if (k < i) continue; if (p[i] != p[k]) ++noadj; else ++yesadj; } if (yesadj != besar || noadj != (n - besar + 1) - 1) { cout << NO << endl; } else { cout << FHTAGN! << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; int n, resmax = -round(1e9), resmin = round(1e9); int main() { cin >> n; for (int i = 1; i <= 7; i++) { int j = i, dem1 = 0; for (int dem = 1; dem <= n; dem++) { if ((j % 7 == 0) || (j % 7 == 6)) dem1++; j++; if (j > 7) j = 1; } resmax = max(resmax, dem1); resmin = min(resmin, dem1); } cout << resmin << << resmax; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { string st; cin >> st; for (int i = 0; i < st.length(); i++) { if (st[i] == H || st[i] == Q || st[i] == 9 ) { cout << YES << endl; return 0; } } cout << NO << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int solve() { int n; cin >> n; if (n == 1) return cout << -1 << endl, 0; string s = ; for (int i = 0; i < n - 1; i++) s += 3 ; cout << 2 + s << endl; return 0; } int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); int t; cin >> t; while (t--) solve(); return 0; }
#include <bits/stdc++.h> using namespace std; int gi() { int res = 0, w = 1; char ch = getchar(); while (ch != - && !isdigit(ch)) ch = getchar(); if (ch == - ) w = -1, ch = getchar(); while (isdigit(ch)) res = res * 10 + ch - 0 , ch = getchar(); return res * w; } const int Mod = 1e9 + 7, K = 1e9; int upd(int x) { return x + (x >> 31 & Mod); } const int MAX_N = 3e5 + 5; int N, M, a[MAX_N], b[MAX_N], c[MAX_N]; char s[MAX_N]; int d[MAX_N], m; void Div(int x, int &v) { long long now = 0; for (int i = m; i; i--) { now = now * K + d[i]; d[i] = now / x, now %= x; } v = now; for (; m > 1 && !d[m]; m--) ; } int f[2][MAX_N * 20], mx[2]; void add(int o, int x, int v) { f[o][x] = upd(f[o][x] + v - Mod); mx[o] = max(mx[o], x); } int main() { N = gi(); a[1] = 1; for (int i = 2; i <= N; i++) a[i] = gi(); for (int i = 1; i <= N; i++) b[i] = gi(); scanf( %s , s + 1), M = strlen(s + 1); reverse(&s[1], &s[M + 1]); for (int i = 1; i <= M; i += 9) { ++m; for (int j = min(M, i + 8); j >= i; j--) d[m] = d[m] * 10 + s[j] - 0 ; } a[N + 1] = K; for (int i = 1; i <= N; i++) if (a[i + 1] > 1) Div(a[i + 1], c[i]); if (m != 1 || d[1] != 0) return puts( 0 ) & 0; f[0][0] = 1, f[0][1] = Mod - 1, mx[0] = 1; for (int i = 1, o = 0; i <= N; i++, o ^= 1) { for (int j = 1; j <= mx[o]; j++) f[o][j] = upd(f[o][j] + f[o][j - 1] - Mod); for (int j = 0; j <= mx[o]; j++) if (f[o][j]) { int k = (c[i] - j % a[i + 1] + a[i + 1]) % a[i + 1]; int l = (j + k - c[i]) / a[i + 1], r = b[i] / a[i + 1] + 1 - (b[i] % a[i + 1] < k); add(o ^ 1, l, f[o][j]), add(o ^ 1, l + r, Mod - f[o][j]); f[o][j] = 0; } mx[o] = 0; } printf( %d n , f[N & 1][0]); return 0; }
#include <bits/stdc++.h> using namespace std; map<int, int> cnt, b; vector<int> ans; int a[200010], x; int n, m, p; int main() { cin >> n >> m >> p; for (int i = 0; i < n; i++) cin >> a[i]; for (int i = 0; i < m; i++) { cin >> x; b[x]++; } for (int i = 0; i < p; i++) { if (i + (long long)(m - 1) * p >= n) break; long long j; cnt = b; for (j = i; j <= i + (long long)(m - 1) * p; j += p) if (--cnt[a[j]] == 0) cnt.erase(a[j]); if (cnt.size() == 0) ans.push_back(i + 1); for (long long k = i; j < n; j += p, k += p) { if (--cnt[a[j]] == 0) cnt.erase(a[j]); if (++cnt[a[k]] == 0) cnt.erase(a[k]); if (cnt.size() == 0) ans.push_back(k + p + 1); } } sort(ans.begin(), ans.end()); cout << ans.size() << endl; for (int i = 0; i < ans.size(); i++) cout << ans[i] << ; return 0; }
#include <bits/stdc++.h> using namespace std; int k[5] = {100, 20, 10, 5, 1}; int main() { ios_base::sync_with_stdio(0); cin.tie(0); int n; while (cin >> n) { long long ans = 0; for (int i = 0; i < 5; i++) { ans += n / k[i]; n %= k[i]; } cout << ans << n ; } return 0; }
#include <bits/stdc++.h> #pragma optimize( Ofast ) using namespace std; using ll = long long int; using ull = unsigned long long int; using dd = double; using ldd = long double; using si = short int; using pii = pair<int, int>; using pll = pair<ll, ll>; int _size = 1 << 20; vector<ll> tree(_size << 1), cnt(_size << 1); vector<ll> pos; vector<ll> x; vector<ll> price; vector<ll> if_now; vector<ll> to_pay; vector<vector<pll>> gr; vector<ll> ans; int n; void upd(int v, ll cn) { ll c = cn; cn *= price[v]; v = pos[v]; v += _size; cnt[v] += c; tree[v] += cn; v >>= 1; while (v) { tree[v] += cn; cnt[v] += c; v >>= 1; } } int find_f(ll t, int v = 1) { if (v >= _size) return v - _size; if (tree[v << 1] > t) return find_f(t, v << 1); else return find_f(t - tree[v << 1], v << 1 | 1); } ll get_cnt(ll rr, int v = 1, int l = 0, int r = _size) { if (r <= rr) return cnt[v]; if (l >= rr) return 0; return get_cnt(rr, v << 1, l, (r + l) >> 1) + get_cnt(rr, v << 1 | 1, (r + l) >> 1, r); } ll get_pay(ll rr, int v = 1, int l = 0, int r = _size) { if (r <= rr) return tree[v]; if (l >= rr || r <= l) return 0; return get_pay(rr, v << 1, l, (r + l) >> 1) + get_pay(rr, v << 1 | 1, (r + l) >> 1, r); } ll get_now(ll t) { 0; if (t >= tree[1]) { return get_cnt(_size); } 0; int ind = find_f(t); 0; ll ans = get_cnt(ind); 0; t -= get_pay(ind); 0; if (ind >= to_pay.size() || to_pay[ind] == 0) { return ans; } return ans + t / to_pay[ind]; } void dfs(int v, ll t) { 0; upd(v, x[v]); 0; if_now[v] = get_now(t); 0; for (pll i : gr[v]) { t -= i.second * 2; if (t >= 0) dfs(i.first, t); t += i.second * 2; } upd(v, -x[v]); } void afs(int v) { ans[v] = if_now[v]; vector<ll> ch; for (pii i : gr[v]) { afs(i.first); ch.push_back(ans[i.first]); } sort((ch).begin(), (ch).end()); reverse((ch).begin(), (ch).end()); ans[v] = max(ans[v], (ch.size() >= 2 ? ch[1] : 0)); } int main() { ios_base::sync_with_stdio(0); cout.tie(0); cin.tie(0); ll t; cin >> n >> t; x.resize(n); pos.resize(n); price.resize(n); if_now.resize(n); gr.resize(n); to_pay.resize(n); ans.resize(n); for (int i = 0; i < n; ++i) cin >> x[i]; map<ll, ll> ttt; int s = 0; for (int i = 0; i < n; ++i) { cin >> price[i]; ttt[price[i]] = 0; } for (auto& i : ttt) { i.second = s; to_pay[s] = i.first; ++s; } 0; for (int i = 0; i < n; ++i) pos[i] = ttt[price[i]]; 0; vector<pair<ll, ll>> tt; for (int i = 0; i < n - 1; ++i) { ll a, b; cin >> a >> b; tt.push_back({a, b}); gr[a - 1].push_back({i + 1, b}); } 0; dfs(0, t); 0; 0; afs(0); 0; for (pll i : gr[0]) { ans[0] = max(ans[0], ans[i.first]); } cout << ans[0]; }
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); int TESTS = 1; cin >> TESTS; while (TESTS--) { long long n, x, y, d; cin >> n >> x >> y >> d; if (abs(y - x) % d == 0) { cout << abs(y - x) / d << n ; continue; } long long l = 1000000007, r = 1000000007; if ((n - y) % d == 0) { l = (n - y) / d + (n - x + d - 1) / d; } if ((y - 1) % d == 0) { r = (y - 1) / d + (x - 1 + d - 1) / d; } long long ans = min(l, r); if (ans != 1000000007) cout << ans << n ; else cout << -1 n ; } return 0; }
#include <bits/stdc++.h> using namespace std; long long nch(long long n) { long long ans = 0, tmp = 1, k = 1; while (n) { ans += min(n, tmp * 9) * k; n -= min(n, tmp * 9); tmp *= 10; k++; } return ans; } char get(long long n, long long d) { string s; stringstream ss; ss << n; ss >> s; return s[d - 1]; } char kth(long long n) { long long s = 0, nine = 9, d = 0, len; for (len = 1;; len++) { s += nine * len; d += nine; if (s >= n) { s -= nine * len; d -= nine; n -= s; break; } nine *= 10; } long long diff = ceil((double)n / len); long long dd = n % len; if (dd == 0) dd = len; return get(d + diff, dd); } int32_t main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); long long q; cin >> q; while (q--) { long long k, n = 1; cin >> k; for (n = 1; nch(n) < k; n++) k -= nch(n); cout << kth(k) << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 5e5 + 7; vector<int> g[N]; int used[N]; int pos[N]; vector<vector<int>> cycles; vector<int> st; void dfs(int u, int p = -1) { st.push_back(u); pos[st.back()] = (int)st.size() - 1; used[u] = 1; for (auto v : g[u]) { if (!used[v]) { dfs(v, u); } else if (v != p && used[v] == 1) { int x = pos[v]; cycles.push_back({}); for (int i = x; i < (int)st.size(); ++i) { cycles.back().push_back(st[i]); } } } st.pop_back(); used[u] = 2; } int main() { ios_base::sync_with_stdio(false); cin.tie(0); int n, m; cin >> n >> m; vector<pair<int, int>> edges; map<pair<int, int>, int> id; for (int i = 0; i < m; ++i) { int u, v; cin >> u >> v; --u, --v; g[u].push_back(v); g[v].push_back(u); edges.push_back({u, v}); id[{u, v}] = id[{v, u}] = i; } dfs(0); vector<int> res(m); vector<int> who(m, -1); vector<int> cmp(n, -1); for (int i = 0; i < (int)cycles.size(); ++i) { vector<int> ce; for (int j = 0; j < (int)cycles[i].size(); ++j) { cmp[cycles[i][j]] = i; ce.push_back( id[{cycles[i][j], cycles[i][(j + 1) % (int)cycles[i].size()]}]); } rotate(ce.begin(), min_element(ce.begin(), ce.end()), ce.end()); int mx = max_element(ce.begin(), ce.end()) - ce.begin(); bool ok = true; for (int i = 1; i <= mx; ++i) ok &= ce[i] > ce[i - 1]; for (int i = mx + 1; i < ce.size(); ++i) ok &= ce[i] < ce[i - 1]; if (ok) who[ce[0]] = ce[mx]; } vector<int> ans(n, 1); for (int i = m - 1; i >= 0; --i) { int a = edges[i].first; int b = edges[i].second; int sum = ans[a] + ans[b]; if (who[i] != -1) sum -= res[who[i]]; res[i] = sum; ans[a] = ans[b] = sum; } for (int i = 0; i < n; ++i) cout << ans[i] - 1 << ; }
#include <bits/stdc++.h> using namespace std; const int MAXN = 200015; const int MOD = 1000000007; int a[MAXN]; bool F(int len, int num) { bool flag; int pres; for (int i = 0; i <= num - 1; i++) { flag = true; pres = i; for (int j = 0; j <= len - 1; j++) { if (a[pres] == 0) flag = false; pres += num; } if (flag == true) return flag; } return false; } int main() { int n; scanf( %d , &n); for (int i = 0; i <= n - 1; i++) scanf( %d , &a[i]); bool ok = false; for (int i = 1; i <= sqrt(n); i++) { if (n % i == 0) { if (i >= 3) ok = ok | F(i, n / i); if (i != sqrt(n) && n / i >= 3) ok = ok | F(n / i, i); } } if (ok) cout << YES n ; else cout << NO n ; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int n; int s; cin >> n; s = n; int k = 2; while (k <= n) { if (n % k == 0) { s += n / k; n = n / k; } else k++; } cout << s; return 0; }
#include <bits/stdc++.h> using namespace std; int signum(long long a) { return (a == 0 ? 0 : (a > 0 ? 1 : -1)); } int dir(pair<long long, long long>& a, pair<long long, long long>& b, pair<long long, long long>& c) { return signum((b.first - a.first) * (c.second - a.second) - (b.second - a.second) * (c.first - a.first)); } bool inside(vector<pair<long long, long long> >& hull, pair<long long, long long>& p) { if (dir(hull[0], hull[1], p) != 1) return false; if (dir(hull[0], hull[hull.size() - 1], p) != -1) return false; int l = 1, r = hull.size() - 2; while (l < r) { int m = (l + r) / 2 + 1; if (dir(hull[0], hull[m], p) == -1) r = m - 1; else l = m; } return dir(hull[l], hull[l + 1], p) == 1; } int main() { cin.sync_with_stdio(false); cin.tie(0); int n, m; cin >> n; vector<pair<long long, long long> > A(n); for (pair<long long, long long>& a : A) cin >> a.first >> a.second; reverse(A.begin(), A.end()); cin >> m; vector<pair<long long, long long> > B(m); bool sol = true; for (pair<long long, long long>& a : B) { cin >> a.first >> a.second; sol &= inside(A, a); } cout << (sol ? YES : NO ) << endl; }
#include <bits/stdc++.h> using namespace std; int main() { int a, b, y = 0; cin >> a >> b; while (a <= b) { a *= 3; b *= 2; y++; } cout << y; return 0; }
#include <bits/stdc++.h> using namespace std; const int inf = 2e9; const long long Inf = 1e10; const int P = 1e9 + 7; const int N = 100005; const int M = 1000005; inline long long IN() { long long x = 0; int ch = 0, f = 0; for (ch = getchar(); ch != -1 && (ch < 48 || ch > 57); ch = getchar()) f = (ch == - ); for (; ch >= 48 && ch <= 57; ch = getchar()) x = (x << 1) + (x << 3) + ch - 0 ; return f ? (-x) : x; } template <typename T> inline int chkmin(T &a, const T &b) { if (b < a) return a = b, 1; return 0; } template <typename T> inline int chkmax(T &a, const T &b) { if (b > a) return a = b, 1; return 0; } void renew(int &x, const int &y) { x += y; if (x >= P) x -= P; if (x < 0) x += P; } int Pow(int x, int y, int p) { int a = 1; for (; y; y >>= 1, x = (long long)x * x % p) if (y & 1) a = (long long)a * x % p; return a; } vector<pair<int, int> > in[M], ou[M]; int n, m, K; int cov[M << 2], sum[M << 2], len[M << 2]; int ql, qr, qv, qans; void Cov(int x, int y) { cov[x] = y; sum[x] = 1LL * len[x] * y % P; } void sep(int x) { if (cov[x] == -1) return; Cov(x << 1, cov[x]); Cov(x + x + 1, cov[x]); cov[x] = -1; } void A(int x, int L, int R) { if (ql <= L && R <= qr) { Cov(x, qv); return; } sep(x); int md = (L + R) >> 1; if (ql <= md) A(x << 1, L, md); if (md < qr) A(x + x + 1, md + 1, R); sum[x] = sum[x + x + 1]; renew(sum[x], sum[x << 1]); } void Add(int l, int r, int v) { if (l > r) return; ql = l; qr = r; qv = v; A(1, 1, m); } void Q(int x, int L, int R) { if (ql <= L && R <= qr) { renew(qans, sum[x]); return; } sep(x); int md = (L + R) >> 1; if (ql <= md) Q(x << 1, L, md); if (md < qr) Q(x + x + 1, md + 1, R); } int Ask(int l, int r) { if (l > r) return 0; ql = l; qr = r; qans = 0; Q(1, 1, m); return qans; } void B(int x, int L, int R) { len[x] = R - L + 1; if (L == R) return; int md = (L + R) / 2; B(x << 1, L, md); B(x + x + 1, md + 1, R); } set<pair<int, int> > st; int main() { scanf( %d%d%d , &n, &m, &K); for (int i = (int)(1); i <= (int)(K); i++) { int x1, y1, x2, y2; scanf( %d%d%d%d , &x1, &y1, &x2, &y2); in[x1].push_back(make_pair(y1, y2)); ou[x2 + 1].push_back(make_pair(y1, y2)); } B(1, 1, m); Add(1, 1, 1); for (auto v : in[1]) { st.insert(v); Add(v.first, v.second, 0); } for (int i = (int)(2); i <= (int)(n); i++) { static int tot, vx[N], vc[N]; tot = 0; for (auto v : in[i]) { if (v.second + 1 > m) continue; auto w = st.lower_bound(make_pair(v.second + 2, 0)); int Low = 0; if (w != st.begin()) { --w; Low = w->second; } ++tot; vc[tot] = Ask(Low + 1, v.second + 1); vx[tot] = v.second + 1; } for (int j = (int)(1); j <= (int)(tot); j++) Add(vx[j], vx[j], vc[j]); for (auto v : ou[i]) st.erase(v); for (auto v : in[i]) { st.insert(v); Add(v.first, v.second, 0); } } int Low = (st.empty()) ? (0) : ((--st.end())->second); cout << Ask(Low + 1, m) << endl; return 0; }
#include <bits/stdc++.h> using namespace std; const int Maxn = 500010; const int Maxk = 110; const int Maxp = 110; const int inf = 2147483647; 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 << 3) + (x << 1) + (ch ^ 48), ch = getchar(); return x * f; } int n, k, p, s[Maxn], f[Maxn][Maxk]; int mn[2][Maxp], v[Maxp]; void modify(int o, int x, int y) { for (; x <= p; x += (x & -x)) mn[o][x] = min(mn[o][x], y); } int query(int o, int x) { int re = inf; for (; x; x -= (x & -x)) re = min(re, mn[o][x]); return re; } int main() { memset(f, 63, sizeof(f)); n = read(), k = read(), p = read(); s[0] = 0; for (int i = 1; i <= n; i++) s[i] = (read() % p + s[i - 1]) % p, f[i][1] = s[i]; for (int j = 2; j <= k; j++) { memset(v, 63, sizeof(v)); memset(mn, 63, sizeof(mn)); v[s[j - 1]] = f[j - 1][j - 1] - s[j - 1]; modify(0, s[j - 1] + 1, v[s[j - 1]]); modify(1, p - s[j - 1], v[s[j - 1]]); for (int i = j; i <= n; i++) { f[i][j] = min(s[i] + query(0, s[i] + 1), s[i] + p + query(1, p - s[i])); if (f[i][j - 1] - s[i] < v[s[i]]) { v[s[i]] = f[i][j - 1] - s[i]; modify(0, s[i] + 1, v[s[i]]); modify(1, p - s[i], v[s[i]]); } } } printf( %d , f[n][k]); }
#include <bits/stdc++.h> using namespace std; long long gcd(long long a, long long b) { while (b) { a %= b; swap(a, b); } return a; } int main() { int t; cin >> t; while (t--) { long long x, y; cin >> x >> y; if (gcd(x, y) == 1) { cout << FINITE << endl; } else { cout << INFINITE << endl; } } }
#include <bits/stdc++.h> using namespace std; const int N = 200005; int cycl[N], set_val[N], cycl_size[N]; int main() { int h, m, n; cin >> h >> m >> n; vector<int> strt; bool vis[h]; memset(vis, false, sizeof vis); int kk = 0; set<int> dmm[h + 1]; for (long long i = 0; i < m; i++) { if (vis[i]) { continue; } int ii = i; int jp = 0; while (1) { if (vis[ii]) { break; } set_val[ii] = jp; cycl[ii] = kk; dmm[kk].insert(jp); vis[ii] = true; ii += m; ii %= h; jp++; } cycl_size[kk] = jp; kk++; } map<int, int> hash; map<int, int> final; long long cnt = 0; while (n--) { char ch; scanf( %c , &ch); if (ch == + ) { int id, t; scanf( %d%d , &id, &t); hash[id] = t; if (dmm[cycl[t]].find(set_val[t]) != dmm[cycl[t]].end()) { final[id] = set_val[t]; dmm[cycl[t]].erase(set_val[t]); continue; } set<int>::iterator it, it1; it = dmm[cycl[t]].lower_bound(set_val[t]); int xx1; if (it == dmm[cycl[t]].end()) { it = dmm[cycl[t]].begin(); xx1 = cycl_size[cycl[t]] + *it - set_val[t]; int jj = *it; final[id] = jj; dmm[cycl[t]].erase(jj); } else { xx1 = *it - set_val[t]; int jj = *it; final[id] = jj; dmm[cycl[t]].erase(jj); } cnt += (long long)xx1; } else { int id; scanf( %d , &id); dmm[cycl[hash[id]]].insert(final[id]); } } cout << cnt << endl; }
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; long long int a[n], p[n], s[n]; for (int i = 0; i < n; i++) { cin >> a[i]; } int blocks = 0; p[0] = a[0]; for (int i = 1; i < n; i++) { p[i] = max(p[i - 1], a[i]); } s[n - 1] = a[n - 1]; for (int i = n - 2; i >= 0; i--) { s[i] = min(s[i + 1], a[i]); } for (int i = 0; i < n - 1; i++) { if (p[i] <= s[i + 1]) { blocks++; } } cout << blocks + 1 << endl; }
#include <bits/stdc++.h> using namespace std; int main() { int n, m, k, i, j; cin >> n >> m >> k; int a[n][m]; for (i = 0; i < n; i++) { for (j = 0; j < m; j++) { cin >> a[i][j]; } } int x; for (i = 0; i < k; i++) { cin >> x; x--; int v = 0; while (v < n) { if (a[v][x] == 2) { v++; } else if (a[v][x] == 1) { a[v][x] = 2; x++; } else { a[v][x] = 2; x--; } } cout << x + 1 << ; } cout << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int n, i = 0; cin >> n; long long a; vector<long long> vc; while (n--) { cin >> a; vc.push_back(a); } sort(vc.begin(), vc.end()); i = vc.size(); long long ans = vc[i - 1]; for (int j = i - 2; j >= 0; j--) { if (vc[j] >= vc[j + 1]) { vc[j] = vc[j + 1] - 1; } if (vc[j] > 0) ans += vc[j]; } cout << ans << endl; }
#include <bits/stdc++.h> using namespace std; int q, n; long long s, cur; char str[100100]; int main() { scanf( %lld%d , &s, &q); while (q--) { scanf( %lld , &cur); scanf( %s , str); n = strlen(str); for (int i = 0; i < n; i++) { long long t = 1; while (cur % (t << 1) == 0) t <<= 1; if (str[i] == U ) { if ((t << 1) > s) continue; cur ^= t; cur |= (t << 1); } else if (str[i] == L ) { if (t == 1) continue; cur ^= t; cur |= (t >> 1); } else { if (t == 1) continue; cur |= (t >> 1); } } printf( %lld n , cur); } return 0; }