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; struct edge { long long a, b, index; long long u, v; }; bool compare(edge i, edge j) { if (i.a == j.a) return i.b > j.b; return i.a < j.a; } bool compare2(edge i, edge j) { return i.index < j.index; } int main() { ios::sync_with_stdio(false); cin.tie(0); long long n, m; cin >> n >> m; edge a[m]; for (long long i = 0; i < m; i++) { cin >> a[i].a >> a[i].b; a[i].index = i; } long long suc = 0, unsuc = 0; sort(a, a + m, compare); long long u1 = 2, v1 = 3; for (long long i = 0; i < m; i++) { if (a[i].b == 1) { a[i].u = 1; a[i].v = suc + 2; suc++; } else { unsuc++; long long edges = ((suc + 1) * (suc)) / 2 - (suc); if (edges < unsuc) { cout << -1 << n ; return 0; } a[i].u = u1; a[i].v = v1; if (u1 + 1 == v1) { u1 = 2; v1++; } else { u1++; } } } sort(a, a + m, compare2); for (long long i = 0; i < m; i++) cout << a[i].u << << a[i].v << n ; return 0; }
#include <bits/stdc++.h> using namespace std; const int MAXN = 1086; const int MAXT = 1586; const long long R = 1000000; struct query { long long ts, tl; long double ss, sl, p; query() {} query(long double _ss, long double _sl, long long _ts, long long _tl, long double _p) : ss(_ss), sl(_sl), ts(_ts), tl(_tl), p(_p) {} void init() { cin >> ss >> sl >> ts >> tl >> p; ss *= R, sl *= R; } } Q[MAXN]; pair<long double, long double> dp[MAXN][MAXT]; inline bool cmp(const query &a, const query &b) { return a.tl * (1 - b.p) * a.p < b.tl * (1 - a.p) * b.p; } void update(pair<long double, long double> &a, pair<long double, long double> b) { if (b.first > a.first || a.first == b.first && a.second > b.second) a = b; } int main() { int i, j; int m, n; scanf( %d%d , &n, &m); for (i = 0; i < n; ++i) Q[i].init(); sort(Q, Q + n, cmp); for (i = 0; i < n; ++i) for (j = 0; j <= m; ++j) dp[i][j].first = dp[i][j].second = -1; dp[0][0].first = dp[0][0].second = 0; for (i = 0; i < n; ++i) { long long ts = Q[i].ts, tl = Q[i].tl; long double ss = Q[i].ss, sl = Q[i].sl, p = Q[i].p; for (j = 0; j <= m; ++j) if (dp[i][j].first != -1) { long double cs = dp[i][j].first, cp = dp[i][j].second; update(dp[i + 1][j], dp[i][j]); if (j + ts <= m) update(dp[i + 1][j + ts], pair<long double, long double>(cs + ss, cp + ts)); if (j + ts + tl <= m) update(dp[i + 1][j + ts + tl], pair<long double, long double>( cs + ss + (1 - p) * sl, ts + (j + tl) * (1 - p) + p * cp)); } } pair<long double, long double> res(0, 0); for (i = 0; i <= m; ++i) update(res, dp[n][i]); cout << setprecision(20) << res.first / R << << res.second << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { ios::sync_with_stdio(0); cin.tie(0); int n, d; cin >> n; unordered_set<int> s; int mx = n; int c = 0; for (int i = 0; i < n; i++) { cin >> d; if (d == mx) { for (int i = 0; i < c; i++) cout << n ; cout << mx; c = 0; int k = mx - 1; while (s.find(k) != s.end()) { cout << << k; s.erase(k); k--; } cout << n ; mx = k; } else { s.insert(d); c++; } } return 0; }
#include <bits/stdc++.h> using namespace std; bool a[2][100010]; int n, q, nr, x, y; int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); cin >> n >> q; for (int i = 1; i <= q; i++) { cin >> x >> y; x--; if (a[x][y]) nr -= a[(x + 1) % 2][y - 1] + a[(x + 1) % 2][y] + a[(x + 1) % 2][y + 1], a[x][y] = 0; else nr += a[(x + 1) % 2][y - 1] + a[(x + 1) % 2][y] + a[(x + 1) % 2][y + 1], a[x][y] = 1; if (!nr) cout << YES n ; else cout << NO n ; } return 0; }
#include <bits/stdc++.h> using namespace std; double n, h; char c[10]; double ans; double ksm(double x, long long y) { double maretu = 1.0; for (; y; y >>= 1) { if (y & 1) { maretu *= x; } x *= x; } return maretu; } int main() { scanf( %s , c); if (c[0] == A ) { scanf( %lf%lf , &n, &h); ans = n; for (double i = 1; i <= h; ++i) { for (double j = 1; j <= n; ++j) { ans += (n - j) * (1.0 / (double)(1LL << (long long)(2 * i))) * ksm(1.0 - (1.0 / (double)(1LL << (long long)i)), (long long)(j - 1.0)) * ((double)(1LL << ((long long)i)) - (double)(1LL << (long long)(i - 1)) * (1.0 + (j - 1.0) / ((double)(1LL << (long long)(i)) - 1.0))); } } printf( %.10lf , ans); } else { scanf( %lf%lf , &n, &h); printf( %lf , n); } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int n, t, cont[8] = {0}, i; cin >> n; for (int i = 0; i < n && cin >> t; i++) cont[t]++; if (cont[1] != n / 3 || cont[5] + cont[7] || cont[4] > cont[2] || cont[3] > cont[6] || cont[2] + cont[3] != cont[4] + cont[6]) cout << -1; else { for (i = 0; i < cont[3]; i++) cout << 1 << << 3 << << 6 << endl; for (i = 0; i < cont[4]; i++) cout << 1 << << 2 << << 4 << endl; for (i = 0; i < cont[2] - cont[4]; i++) cout << 1 << << 2 << << 6 << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; const long long maxm = 2e5 + 5; vector<long long> g[maxm]; long long mark[maxm]; long long p[maxm]; long long c[maxm]; long long ans; long long n; void solve(long long x) { vector<long long> s; while (!mark[x]) { s.push_back(x); mark[x] = 1; x = p[x]; } long long len = s.size(); for (long long i = 1; i <= len; i++) { if (len % i == 0) { for (long long j = 0; j < i; j++) { long long ok = 1; for (long long k = j; k + i < len; k += i) { if (c[s[k]] != c[s[k + i]]) { ok = 0; break; } } if (ok) { ans = min(ans, i); return; } } } } } signed main() { long long T; cin >> T; while (T--) { cin >> n; ans = n; for (long long i = 1; i <= n; i++) cin >> p[i]; for (long long i = 1; i <= n; i++) cin >> c[i]; for (long long i = 1; i <= n; i++) mark[i] = 0; for (long long i = 1; i <= n; i++) if (!mark[i]) solve(i); cout << ans << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { string s; cin >> s; int n = s.size(); int pref = 0; int kol = 0; for (int i = 0; i < n; i++) { if (s[i] == # ) kol++; if (s[i] == ( ) pref++; else pref--; if (pref < 0) { cout << -1 ; return 0; } } string t; int sz = 0; int r = 0; while (sz < kol) { if (s[r] == # ) { sz++; t += ) ; if (sz == kol) { for (int j = 0; j < pref; j++) t += ) ; } } else { t += s[r]; } r++; } while (r < n) { t += s[r]; r++; } n = t.size(); int preff = 0; for (int i = 0; i < n; i++) { if (t[i] == ( ) preff++; else preff--; if (preff < 0) { cout << -1 ; return 0; } } for (int i = 0; i < kol - 1; i++) { cout << 1 << endl; } cout << pref + 1; }
#include <bits/stdc++.h> using namespace std; map<long long, long long> dist; int main() { long long n, m; cin >> n >> m; long long x; queue<long long> q; for (long long i = 0; i < n; i++) { cin >> x; dist[x] = 0; q.push(x); } long long total = 0; vector<long long> ans; while (!q.empty()) { x = q.front(); q.pop(); if (dist[x] != 0) { ans.push_back(x); total += (dist[x]); if (ans.size() == m) break; } if (dist.find(x - 1) == dist.end()) { q.push(x - 1); dist[x - 1] = dist[x] + 1; } if (dist.find(x + 1) == dist.end()) { q.push(x + 1); dist[x + 1] = dist[x] + 1; } } cout << total << n ; for (long long i = 0; i < ans.size(); i++) { cout << ans[i] << ; } return 0; }
#include <bits/stdc++.h> using namespace std; int n, A, B; long long toi(string s) { istringstream is(s); long long x; is >> x; return x; } string tos(long long t) { stringstream st; st << t; return st.str(); } long long F[1000005], FP[1000005]; bool f(long long x) { while (x > 0) { if (x % 10 != A && x % 10 != B) return 0; x /= 10; } return 1; } long long pow(long long a, long long b, long long c) { long long x = 1, y = a; while (b > 0) { if (b & 1) x = (x * y) % c; y = (y * y) % c; b >>= 1; } return x; } int main() { F[0] = 1; for (int i = 1; i < 1000005; ++i) { F[i] = i * F[i - 1]; if (F[i] >= 1000000007) F[i] %= 1000000007; } FP[1000005 - 1] = pow(F[1000005 - 1], 1000000007 - 2, 1000000007); for (int i = 1000005 - 2; i >= 0; --i) { FP[i] = FP[i + 1] * (i + 1); if (FP[i] >= 1000000007) FP[i] %= 1000000007; } while (cin >> A >> B >> n) { long long cnt = 0; for (int i = 0; i <= n; ++i) if (f(i * A + (n - i) * B)) { long long num = F[n], den = FP[i] * FP[n - i]; if (den >= 1000000007) den %= 1000000007; num *= den; if (num >= 1000000007) num %= 1000000007; cnt += num; if (cnt >= 1000000007) cnt -= 1000000007; } cout << cnt << endl; } }
#include <bits/stdc++.h> using namespace std; class qry { public: int l, r, idx; qry(int l, int r, int idx) : l(l), r(r), idx(idx) {} }; int a[500001], n, m, res[500001]; vector<qry> q; int getans(vector<int> b) { int res = 0; for (int i = 0; i < b.size(); i++) { if ((res ^ b[i]) > res) res ^= b[i]; } return res; } void ins(vector<int>& b, int x) { for (int i = 0; i < b.size(); i++) { if ((b[i] ^ x) < x) x ^= b[i]; } if (!x) return; int t = 31 - __builtin_clz(x); for (int i = 0; i < b.size(); i++) { if (b[i] & (1 << t)) b[i] ^= x; } b.push_back(x); } vector<int> merge(vector<int>& a, vector<int>& b) { vector<int> ret = a; for (int i = 0; i < b.size(); i++) ins(ret, b[i]); return ret; } void solve(vector<qry>& q, int L, int R) { if (q.empty()) return; if (q.size() <= 3 || R - L <= 3) { for (int i = 0; i < q.size(); i++) { int l = q[i].l, r = q[i].r; vector<int> bs; for (int j = l; j <= r; j++) ins(bs, a[j]); res[q[i].idx] = getans(bs); } return; } vector<qry> l, r, my; int mid = (L + R) / 2; for (int i = 0; i < q.size(); i++) { if (q[i].r <= mid) l.push_back(q[i]); else if (q[i].l >= mid + 1) r.push_back(q[i]); else my.push_back(q[i]); } solve(l, L, mid); solve(r, mid + 1, R); sort(my.begin(), my.end(), [](const qry& i, const qry& j) { if (i.l != j.l) return i.l > j.l; else return i.r < j.r; }); vector<int> lb; int cur = 0, pt = mid; vector<vector<int> > rb; vector<int> t; for (int i = mid + 1; i <= R; i++) { ins(t, a[i]); rb.push_back(t); } while (cur < my.size()) { bool found = false; while (my[cur].l <= pt) { found = true; ins(lb, a[pt--]); } res[my[cur].idx] = getans(merge(lb, rb[my[cur].r - mid - 1])); cur++; } } int main() { scanf( %d , &n); for (int i = 1; i <= n; i++) scanf( %d , &a[i]); scanf( %d , &m); for (int i = 1; i <= m; i++) { int l, r; scanf( %d %d , &l, &r); q.push_back(qry(l, r, i)); } solve(q, 1, n); for (int i = 1; i <= m; i++) printf( %d n , res[i]); return 0; }
#include <bits/stdc++.h> int main(int argc, const char* argv[]) { int n, k; scanf( %d%d , &n, &k); if (k > n / 2) k = n / 2; printf( %I64d n , k * (2 * n - 2 * k - 1ll)); return 0; }
#include <bits/stdc++.h> using namespace std; const int MAXN = 1005, MAXM = 200005; int n, m, q, f[MAXN][MAXN], head[MAXM], nxt[MAXM], x[MAXM], y[MAXM]; struct Q { int l, r, s, t; } s[MAXM]; bool ans[MAXM]; int main() { scanf( %d%d%d , &n, &m, &q); for (register int i = 1; i <= m; ++i) scanf( %d%d , x + i, y + i); for (register int i = 1; i <= q; ++i) { scanf( %d%d%d%d , &s[i].l, &s[i].r, &s[i].s, &s[i].t); nxt[i] = head[s[i].r]; head[s[i].r] = i; } for (register int u, v, k = 1; k <= m; ++k) { u = x[k]; v = y[k]; f[u][v] = f[v][u] = k; for (register int i = 1; i <= n; ++i) f[u][i] = f[v][i] = max(f[u][i], f[v][i]); for (register int i = head[k]; i; i = nxt[i]) ans[i] = s[i].l <= f[s[i].t][s[i].s]; } for (register int i = 1; i <= q; ++i) puts(ans[i] ? Yes : No ); }
#include <bits/stdc++.h> using namespace std; const int inf = (int)1e9; const long long int INF = (long long int)1e18; const int N = 100005; const long long int MOD = 1000000007; const double EPS = 1e-7; const double PI = acos(-1.0); const int dx[] = {+1, -1, +0, +0}; const int dy[] = {+0, +0, +1, -1}; const int hx[] = {-2, -2, -1, -1, +1, +1, +2, +2}; const int hy[] = {+1, -1, +2, -2, +2, -2, +1, -1}; const int fx[] = {-1, +0, +1, +0, +1, +1, -1, -1, +0}; const int fy[] = {+0, -1, +0, +1, +1, -1, +1, -1, +0}; template <typename T> inline T GCD(T a, T b) { a = abs(a), b = abs(b); return !b ? a : GCD(b, a % b); } template <typename T> inline T LCM(T x, T y) { T g = GCD(x, y); return x * y / g; } template <typename T> inline T BigMod(T b, T p, T mod) { T res = 1 % mod, x = b % mod; while (p) { if (p & 1) res = (res * x) % mod; x = (x * x) % mod; p >>= 1; } return res; } template <typename T> inline T ModInv(T val, T mod) { return BigMod(val, mod - 2, mod); } template <typename T> inline T bigmod(T b, T p, T mod) { if (p == 0) return 1; T x = bigmod(b, p / 2, mod); x = (x * x) % mod; if (p % 2 == 1) x = (b * x) % mod; return x; } template <typename T> inline T NumDigit(T num, T base) { return ((T)(log10((num)) / log10((base)))) + 1; } template <typename T> inline T Power(T b, T p) { T res = 1, x = b; while (p) { if (p & 1) res = (res * x); x = (x * x); p >>= 1; } return res; } template <typename T> inline T IsPrime(T x) { if (x < 2) return false; for (T i = 2; i * i <= x; i++) { if (x % i == 0) return false; } return true; } template <typename T> inline T SumDigit(T x) { T ret = 0; while (x) { ret += x % 10, x /= 10; } return ret; } int main(int argc, char const *argv[]) { int n; scanf( %d , &n); for (int i = 0; i * 4 <= n; i++) { for (int j = 0; i * 4 + j * 7 <= n; j++) { if (4 * i + j * 7 == n) { for (int m = 1; m <= i; m++) printf( 4 ); for (int m = 1; m <= j; m++) printf( 7 ); return 0; } } } printf( -1 n ); return 0; }
#include <bits/stdc++.h> using namespace std; set<int> E[100005]; vector<int> L[100005]; int True = 0; int vst[100005]; int main() { int n, m, h, t, i, u, v, _h, _t, j, k; cin >> n >> m >> h >> t; for (i = 0; i < (m); i++) { scanf( %d%d , &u, &v); L[u].push_back(v); L[v].push_back(u); E[u].insert(v); E[v].insert(u); } for (i = (1); i <= (n); i++) { u = i; if (((int)(E[u]).size()) < h + 1) continue; for (j = 0; j < (((int)(L[i]).size())); j++) { v = L[i][j]; if (((int)(E[u]).size()) + ((int)(E[v]).size()) < h + t + 2) continue; if (((int)(E[v]).size()) < t + 1) continue; bool sp = 0; if (((int)(E[u]).size()) > ((int)(E[v]).size())) { swap(u, v); sp = 1; } set<int>::iterator it = E[u].begin(); _h = 0; vector<int> cmn; True++; for (k = 0; k < (((int)(L[u]).size())); k++) vst[L[u][k]] = True; for (k = 0; k < (((int)(L[v]).size())); k++) { if (vst[L[v][k]] == True) { _h++; cmn.push_back(L[v][k]); } } if (sp) swap(u, v); if (((int)(E[u]).size()) + ((int)(E[v]).size()) - _h < h + t + 2) continue; printf( YES n ); printf( %d %d n , u, v); it = E[u].begin(); while (it != E[u].end()) { if (E[v].find(*it) == E[v].end()) { if (*it == v) { it++; continue; } h--; printf( %d , *it); } if (!h) break; it++; } while (h--) { printf( %d , cmn[((int)(cmn).size()) - 1]); cmn.pop_back(); } printf( n ); it = E[v].begin(); while (it != E[v].end()) { if ((E[u].find(*it) == E[u].end())) { if (*it == u) { it++; continue; } t--; printf( %d , *it); } if (!t) break; it++; } while (t--) { printf( %d , cmn[((int)(cmn).size()) - 1]); cmn.pop_back(); } printf( n ); return 0; } } printf( NO n ); return 0; }
#include <bits/stdc++.h> using namespace std; const int mod = 1e9 + 7; const int mod2 = 1e9 + 9; inline int pow_(long long a, int n, int p = mod) { int r = 1; while (n) { if (n & 1) r = r * a % p; n >>= 1; a = a * a % p; } return r; } int main(void) { int n, l; long long s; cin >> n >> l >> s; int w[n + 1], p[n + 1]; memset(p, 0, sizeof(p)); memset(w, 0, sizeof(w)); for (int i = 1; i <= n; i++) cin >> w[i]; for (int i = 2; i <= n; i++) cin >> p[i]; bool done[n + 1]; memset(done, false, sizeof(done)); for (int i = 1; i <= n; i++) if (w[i] > s) return 0 * printf( -1 n ); int ans = 0; for (int i = n; i >= 1; i--) { if (done[i]) continue; ans++; int cur = i; int L = l; long long S = s; while (cur and L > 0 and S >= w[cur]) { done[cur] = true; S -= w[cur]; L--; cur = p[cur]; } } cout << ans << n ; }
#include <bits/stdc++.h> using namespace std; int x, y, n, m, i, k, ans; string s[30], s1[30]; int main() { cin >> n >> m; for (i = 0; i < n; i++) { cin >> s[i]; } for (i = 0; i < m; i++) { cin >> s1[i]; } cin >> k; for (i = 0; i < k; i++) { cin >> x; if (x % n == 0) cout << s[n - 1]; else cout << s[x % n - 1]; if (x % m == 0) cout << s1[m - 1]; else cout << s1[x % m - 1]; cout << endl; } }
#include <bits/stdc++.h> const int MAXN = 1e9 + 7; const int INF = 1e9 + 7; const signed long long MOD = 1e9 + 7; using namespace std; bool comp1(signed long long a, signed long long b) { return (sin(a) < sin(b)); } signed long long binpow(signed long long a, signed long long b) { signed long long res = 1; while (b) { if (b & 1) res = (res * a); a = (a * a); b >>= 1; } return res; } signed long long phi(signed long long n) { signed long long result = n; for (signed long long i = 2; i * i <= n; ++i) if (n % i == 0) { while (n % i == 0) n /= i; result -= result / i; } if (n > 1) result -= result / n; return result; } signed long long gcd(signed long long a, signed long long b) { if (a == 0) return b; return gcd(b % a, a); } int main() { ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); int t; cin >> t; for (size_t jj = 0; jj < t; jj++) { signed long long n, k; cin >> n >> k; vector<signed long long> mas(n); signed long long mx = -1e9 - 47; for (size_t i = 0; i < n; i++) { cin >> mas[i]; mx = max(mx, mas[i]); } signed long long mx1 = -1e9 - 47; for (size_t i = 0; i < n; i++) { mas[i] = mx - mas[i]; mx1 = max(mx1, mas[i]); } k--; if (k % 2) { for (size_t i = 0; i < n; i++) { mas[i] = mx1 - mas[i]; } } for (size_t i = 0; i < n; i++) { cout << mas[i] << ; } cout << n ; } return 0; }
#include <bits/stdc++.h> using namespace std; vector<pair<int, int> > ans; bool is_prime(int v) { if (v == 1 || v == 0) return 0; for (int i = 2; i * i <= v; i++) { if (v % i == 0) return 0; } return 1; } int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); ; long long n; cin >> n; long long cnt = n - 1; ans.push_back(make_pair(n, 1)); for (int i = 2; i <= n; i++) { ans.push_back(make_pair(i, i - 1)); } for (int i = 1; i <= n / 2; i++) { if (is_prime(ans.size())) break; ans.push_back(make_pair(i, i + n / 2)); ++cnt; } cout << ans.size() << endl; for (int i = 0; i < ans.size(); i++) { cout << ans[i].first << << ans[i].second << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; const long long INF = 1e9 + 7; const int N = 3e5 + 10; int flag[N]; set<int> s[N]; int a[N]; int pos[N]; int main() { int n, m; scanf( %d%d , &n, &m); for (int i = 1; i <= n; i++) { scanf( %d , &a[i]); pos[a[i]] = i; } while (m--) { int x, y; scanf( %d%d , &x, &y); if (x == a[n]) continue; if (y == a[n]) { flag[x] = 1; } s[x].emplace(y); } int ans = n; for (int i = n - 1; i > 0; i--) { if (flag[a[i]]) { int cnt = 0; for (auto& x : s[a[i]]) { if (pos[x] < i) continue; if (pos[x] >= ans) continue; cnt++; } if (cnt != ans - i - 1) flag[a[i]] = 0; else { for (int j = i; j < ans; j++) { int x = a[j], y = a[j + 1]; swap(a[j], a[j + 1]); swap(pos[x], pos[y]); } ans--; } } } printf( %d n , n - ans); return 0; }
#include <bits/stdc++.h> using namespace std; mt19937 rd(time(0)); vector<long long> v(100010), val(100010), con[100010], st(100010, 0), en(100010, 0), d(100010, 0); pair<long long, long long> t[20][100010]; long long cur = 0; void dfs(long long node, long long par, long long dep) { st[node] = ++cur; d[st[node]] = dep; for (auto i : con[node]) { if (i != par) dfs(i, node, dep + 1); } en[node] = cur; } void build(long long c, long long l, long long r) { if (l == r) t[c][l] = {d[l], val[l]}; else { long long mid = (l + r) / 2; build(c + 1, l, mid); build(c + 1, mid + 1, r); long long i = l, j = mid + 1, k = l; while (i <= mid && j <= r) { if (t[c + 1][i].first < t[c + 1][j].first) t[c][k++] = t[c + 1][i++]; else t[c][k++] = t[c + 1][j++]; } while (i <= mid) t[c][k++] = t[c + 1][i++]; while (j <= r) t[c][k++] = t[c + 1][j++]; for (i = l + 1; i <= r; i++) t[c][i].second = min(t[c][i].second, t[c][i - 1].second); } } long long query(long long c, long long l, long long r, long long l1, long long r1, long long k) { if (r1 < l || l1 > r) return 1000000007; if (l >= l1 && r <= r1) { pair<long long, long long> temp = {k, 1000000007}; long long w = upper_bound(t[c] + l, t[c] + r + 1, temp) - (t[c]); if (w == l) return 1000000007; return t[c][w - 1].second; } else { long long mid = (l + r) / 2; return min(query(c + 1, l, mid, l1, r1, k), query(c + 1, mid + 1, r, l1, r1, k)); } } signed main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); long long n, r, m, l, x, k; cin >> n >> r; for (long long i = 1; i < n + 1; i++) cin >> v[i]; for (long long i = 0; i < n - 1; i++) { long long u, v; cin >> u >> v; con[u].push_back(v); con[v].push_back(u); } dfs(r, -1, 0); for (long long i = 1; i <= n; i++) val[st[i]] = v[i]; build(1, 1, cur); cin >> m; l = 0; while (m--) { cin >> x >> k; x = (x + l) % n + 1; k = (k + l) % n; l = query(1, 1, cur, st[x], en[x], k + d[st[x]]); cout << l << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; struct edge { short to, cap, rev; edge(int _a = 0, int _b = 0, int _c = 0) { to = _a; cap = _b; rev = _c; } }; int S, T; int dist[30010]; int cur[30010]; vector<edge> adj[30010]; int q[30010]; int hd, tl; inline void addedge(int u, int v, int cap) { adj[u].push_back(edge(v, cap, adj[v].size())); adj[v].push_back(edge(u, 0, adj[u].size() - 1)); } int dfs(int i, short fl) { if (i == T) return fl; short lf = fl; for (int &j = cur[i]; ~j; --j) { edge &e = adj[i][j]; if (e.cap && dist[e.to] == dist[i] + 1) { short d = dfs(e.to, min(lf, e.cap)); e.cap -= d; adj[e.to][e.rev].cap += d; lf -= d; if (!lf) return fl; } } dist[i] = -1; return fl - lf; } int Dinic() { int res = 0; while (true) { memset(dist, 0, sizeof(dist)); dist[q[hd = tl = 0] = S] = 1; while (hd <= tl) { int i = q[hd++]; cur[i] = adj[i].size() - 1; for (int j = cur[i]; ~j; --j) { edge &e = adj[i][j]; if (e.cap && !dist[e.to]) { dist[e.to] = dist[i] + 1; q[++tl] = e.to; } } } if (!dist[T]) break; int fl; while (fl = dfs(S, 10000)) res += fl; } return res; } int bel[5010]; int tpe[5010]; int main(void) { int n, m; scanf( %d%d , &n, &m); S = 0; T = 30000; vector<pair<pair<int, int>, int> > v; for (int i = 1; i <= 8191; ++i) { addedge(n + i, n + (i << 1), 10000); addedge(n + i, n + (i << 1 | 1), 10000); } for (int i = 1; i <= n; ++i) { int a, b, c; scanf( %d%d , &tpe[i], &a); switch (tpe[i]) { case 0: { while (a--) { scanf( %d , &b); addedge(i, b + 8191 + n, 1); } break; } case 1: { scanf( %d , &b); v.push_back(make_pair(make_pair(a, b), i)); int l = a + 8191, r = b + 8191; while (l <= r) { if (l & 1) addedge(i, n + l, 1), l++; if (!(r & 1)) addedge(i, n + r, 1), r--; l >>= 1; r >>= 1; } break; } case 2: { scanf( %d%d , &b, &c); addedge(i, a + 8191 + n, 1); addedge(i, b + 8191 + n, 1); addedge(i, c + 8191 + n, 1); break; } } } sort(v.begin(), v.end()); for (int i = 1; i <= n; ++i) { if (tpe[i] != 2) { addedge(S, i, 1); } } for (int i = 1; i <= n; ++i) { if (tpe[i] == 2) { addedge(S, i, 2); } } for (int i = 1; i <= m; ++i) { addedge(n + 8191 + i, T, 1); } printf( %d n , Dinic()); for (int i = 1; i <= m; ++i) { for (int j = adj[i + 8191 + n].size() - 1; ~j; --j) { edge &e = adj[i + 8191 + n][j]; if (e.cap && e.to != T) { bel[i] = e.to; } } } multiset<pair<pair<int, int>, int> > s; int pnt = 0, vs = v.size(); for (int i = 1; i <= m; ++i) { if (bel[i] <= n && tpe[bel[i]] != 1) continue; while (pnt < vs && v[pnt].first.first <= i) { s.insert(make_pair(make_pair(v[pnt].first.second, v[pnt].first.first), v[pnt].second)); ++pnt; } while (!s.empty() && s.begin()->first.first < i) s.erase(s.begin()); if (!s.empty()) bel[i] = s.begin()->second, s.erase(s.begin()); } for (int i = 1; i <= m; ++i) { if (bel[i]) printf( %d %d n , bel[i], i); } return 0; }
#include <bits/stdc++.h> using namespace std; using ll = long long; using ld = long double; template <class S, class T> ostream &operator<<(ostream &os, const pair<S, T> v) { os << ( << v.first << , << v.second << ) ; return os; } template <class T> ostream &operator<<(ostream &os, const vector<T> &v) { for (int i = 0; i < v.size(); i++) { if (i > 0) { os << ; } os << v[i]; } return os; } template <class T> ostream &operator<<(ostream &os, const vector<vector<T>> &v) { for (int i = 0; i < v.size(); i++) { if (i > 0) { os << endl; } os << v[i]; } return os; } template <class T> ostream &operator<<(ostream &os, const vector<set<T>> &v) { for (int i = 0; i < v.size(); i++) { if (i > 0) { os << endl; } os << v[i]; } return os; } template <class T> ostream &operator<<(ostream &os, const set<T> &v) { int i = 0; for (auto it : v) { if (i > 0) { os << ; } os << it; i++; } return os; } using Graph = vector<vector<int>>; const ll MAX_S = 2e5; vector<ll> check(vector<ll> &x) { vector<ll> anss(x.size()); for (int i = 0; i < int(x.size()) - 1; ++i) { anss[i + 1] = x[i + 1] - x[i]; } anss[0] = x[0]; return anss; } using Value = ll; const Value ini = ll(1e18); Value connect(Value al, const Value ar) { return min(al, ar); } Value dat[1100001]; struct segtree { int N; segtree() {} segtree(int n) { N = 1; while (N < n) N *= 2; for (int x = 0; x < N; ++x) { dat[x + N - 1] = ini; } for (int x = N - 2; x >= 0; --x) { dat[x] = connect(dat[x * 2 + 1], dat[x * 2 + 2]); } } void update(int k, const Value &a) { k += N - 1; dat[k] = a; while (k > 0) { k = (k - 1) >> 1; dat[k] = connect(dat[k * 2 + 1], dat[k * 2 + 2]); } } Value query(int a, int b) { return query(a, b, 0, 0, N); } Value query(int a, int b, int k, int l, int r) { if (r <= a || b <= l) return ini; if (a <= l && r <= b) return dat[k]; const int m = (l + r) / 2; return connect(query(a, b, k * 2 + 1, l, m), query(a, b, k * 2 + 2, m, r)); } }; vector<int> nums(int(3e5)); ll to_n(string st) { ll num = 0; for (auto c : st) { num *= 2; num += c - 0 ; } return num; } string to_s(int sz, ll num) { string st; for (int i = 0; i < sz; ++i) { st.push_back( 0 + (num % 2)); num /= 2; } reverse(st.begin(), st.end()); return st; } const int mod = 998244353; struct Mod { public: int num; Mod() : Mod(0) { ; } Mod(long long int n) : num((n % mod + mod) % mod) {} Mod(int n) : Mod(static_cast<long long int>(n)) { ; } operator int() { return num; } }; Mod operator+(const Mod a, const Mod b) { return Mod((a.num + b.num) % mod); } Mod operator+(const long long int a, const Mod b) { return Mod(a) + b; } Mod operator+(const Mod a, const long long int b) { return b + a; } Mod operator++(Mod &a) { return a + Mod(1); } Mod operator-(const Mod a, const Mod b) { return Mod((mod + a.num - b.num) % mod); } Mod operator-(const long long int a, const Mod b) { return Mod(a) - b; } Mod operator--(Mod &a) { return a - Mod(1); } Mod operator*(const Mod a, const Mod b) { return Mod(((long long)a.num * b.num) % mod); } Mod operator*(const long long int a, const Mod b) { return Mod(a) * b; } Mod operator*(const Mod a, const long long int b) { return Mod(b) * a; } Mod operator*(const Mod a, const int b) { return Mod(b) * a; } Mod operator+=(Mod &a, const Mod b) { return a = a + b; } Mod operator+=(long long int &a, const Mod b) { return a = a + b; } Mod operator-=(Mod &a, const Mod b) { return a = a - b; } Mod operator-=(long long int &a, const Mod b) { return a = a - b; } Mod operator*=(Mod &a, const Mod b) { return a = a * b; } Mod operator*=(long long int &a, const Mod b) { return a = a * b; } Mod operator*=(Mod &a, const long long int &b) { return a = a * b; } Mod operator^(const Mod a, const int n) { if (n == 0) return Mod(1); Mod res = (a * a) ^ (n / 2); if (n % 2) res = res * a; return res; } Mod mod_pow(const Mod a, const long long n) { if (n == 0) return Mod(1); Mod res = mod_pow((a * a), (n / 2)); if (n % 2) res = res * a; return res; } Mod inv(const Mod a) { return a ^ (mod - 2); } Mod operator/(const Mod a, const Mod b) { assert(b.num != 0); return a * inv(b); } Mod operator/(const long long int a, const Mod b) { return Mod(a) / b; } Mod operator/=(Mod &a, const Mod b) { return a = a / b; } Mod fact[1024000], factinv[1024000]; void init(const int amax = 1024000) { fact[0] = Mod(1); factinv[0] = 1; for (int i = 0; i < amax - 1; ++i) { fact[i + 1] = fact[i] * Mod(i + 1); factinv[i + 1] = factinv[i] / Mod(i + 1); } } Mod comb(const int a, const int b) { return fact[a] * factinv[b] * factinv[a - b]; } int main() { int N; cin >> N; vector<Mod> pers(int(1e6)); vector<int> cnts(int(1e6)); for (int i = 0; i < N; ++i) { int k; scanf( %d , &k); for (int j = 0; j < k; ++j) { int a; scanf( %d , &a); a--; cnts[a]++; pers[a] += Mod(1) / Mod(N) / Mod(k); } } Mod answer = Mod(0); for (int i = 0; i < int(1e6); ++i) { answer += pers[i] * Mod(cnts[i]) / Mod(N); } cout << answer.num << endl; return 0; }
#include <bits/stdc++.h> using namespace std; template <typename T> void print(T v) { cout << v << n ; } template <typename T> void print(vector<T> a) { for (int i = 0; i < a.size(); i++) { cout << a[i] << ; } cout << n ; } long long help(long long a, long long b, long long x, long long y, long long n) { long long da = min(n, a - x); a -= da; n -= da; long long db = min(n, b - y); b -= db; return a * b; } void solve() { long long a, b, x, y, n; cin >> a >> b >> x >> y >> n; print(min(help(a, b, x, y, n), help(b, a, y, x, n))); } int main() { ios_base::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 n, m; char ch[201][201]; int main() { cin >> m >> n; n *= 2; m *= 2; for (int i = 1; i <= n; i += 2) for (int j = 1; j <= m; j += 2) { cin >> ch[i][j]; ch[i + 1][j] = ch[i][j + 1] = ch[i + 1][j + 1] = ch[i][j]; } for (int j = 1; j <= m; j++) { for (int i = 1; i <= n; i++) cout << ch[i][j]; cout << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { string s; int n; int arr[26]; int arr2[26]; cin >> s; int value; int sum = 0; int add; int length = s.size(); cin >> n; for (int i = 0; i < 26; i++) { cin >> arr[i]; arr2[i] = arr[i]; } sort(arr2, arr2 + 26); int largest = arr2[25]; for (int i = 0; i < length; i++) { value = s[i]; int x = abs(97 - value); sum = sum + ((i + 1) * arr[x]); } int last = length + n; int sum1 = 0; for (int i = length + 1; i <= last; i++) { sum1 = sum1 + (i * largest); } cout << sum1 + sum; }
#include <bits/stdc++.h> using namespace std; template <typename T, typename U> std::istream& operator>>(std::istream& i, pair<T, U>& p) { i >> p.first >> p.second; return i; } template <typename T> std::istream& operator>>(std::istream& i, vector<T>& t) { for (auto& v : t) { i >> v; } return i; } template <typename T, typename U> std::ostream& operator<<(std::ostream& o, const pair<T, U>& p) { o << p.first << << p.second; return o; } template <typename T> std::ostream& operator<<(std::ostream& o, const vector<T>& t) { if (t.empty()) o << n ; for (size_t i = 0; i < t.size(); ++i) { o << t[i] << n [i == t.size() - 1]; } return o; } template <typename T> using minheap = priority_queue<T, vector<T>, greater<T>>; template <typename T> using maxheap = priority_queue<T, vector<T>, less<T>>; template <typename T> bool in(T a, T b, T c) { return a <= b && b < c; } unsigned int logceil(int first) { return first ? 8 * sizeof(int) - __builtin_clz(first) : 0; } namespace std { template <typename T, typename U> struct hash<pair<T, U>> { hash<T> t; hash<U> u; size_t operator()(const pair<T, U>& p) const { return t(p.first) ^ (u(p.second) << 7); } }; } // namespace std template <typename T, typename F> T bsh(T l, T h, const F& f) { T r = -1, m; while (l <= h) { m = (l + h) / 2; if (f(m)) { l = m + 1; r = m; } else { h = m - 1; } } return r; } template <typename F> double bshd(double l, double h, const F& f, double p = 1e-9) { unsigned int r = 3 + (unsigned int)log2((h - l) / p); while (r--) { double m = (l + h) / 2; if (f(m)) { l = m; } else { h = m; } } return (l + h) / 2; } template <typename T, typename F> T bsl(T l, T h, const F& f) { T r = -1, m; while (l <= h) { m = (l + h) / 2; if (f(m)) { h = m - 1; r = m; } else { l = m + 1; } } return r; } template <typename F> double bsld(double l, double h, const F& f, double p = 1e-9) { unsigned int r = 3 + (unsigned int)log2((h - l) / p); while (r--) { double m = (l + h) / 2; if (f(m)) { h = m; } else { l = m; } } return (l + h) / 2; } template <typename T> T gcd(T a, T b) { if (a < b) swap(a, b); return b ? gcd(b, a % b) : a; } template <typename T> class vector2 : public vector<vector<T>> { public: vector2() {} vector2(size_t a, size_t b, T t = T()) : vector<vector<T>>(a, vector<T>(b, t)) {} }; template <typename T> class vector3 : public vector<vector2<T>> { public: vector3() {} vector3(size_t a, size_t b, size_t c, T t = T()) : vector<vector2<T>>(a, vector2<T>(b, c, t)) {} }; template <typename T> class vector4 : public vector<vector3<T>> { public: vector4() {} vector4(size_t a, size_t b, size_t c, size_t d, T t = T()) : vector<vector3<T>>(a, vector3<T>(b, c, d, t)) {} }; template <typename T> class vector5 : public vector<vector4<T>> { public: vector5() {} vector5(size_t a, size_t b, size_t c, size_t d, size_t e, T t = T()) : vector<vector4<T>>(a, vector4<T>(b, c, d, e, t)) {} }; class TaskD { public: vector<int> P; void fact(int a, vector<int>& f) { while (a != 1) { int b = P[a], c = 0; while (P[a] == b) { c++; a /= b; } f.push_back(c + 1); } sort(f.begin(), f.end()); reverse(f.begin(), f.end()); while (f.size() < Prm.size()) f.push_back(1); } vector<vector<int>> HH; vector<int> Used, CNT; map<vector<int>, int> J; vector<int> X; void genAll(int p, int m, int c, int d) { if (p == Prm.size()) { HH.push_back(X); CNT.push_back(d); int second = J.size(); if (c <= 1e6) Used.push_back(second); J[X] = second; } else { X[p] = 1; genAll(p + 1, 1, c, d * X[p]); while (true) { X[p]++; c *= Prm[p]; if (c > 55050240) return; if (X[p] > m) return; genAll(p + 1, X[p], c, d * X[p]); } } } vector<int> Prm; void solve(istream& cin, ostream& cout) { Prm = {2, 3, 5, 7, 11, 13, 17}; P.assign(1e6 + 5, 0); for (int i = 2; i < 1e6 + 3; ++i) { if (P[i] == 0) { for (int j = i; j < 1e6 + 3; j += i) P[j] = i; } } map<vector<int>, int> IDX{ {{1, 1, 1, 1, 1, 1, 1}, 0}, {{2, 1, 1, 1, 1, 1, 1}, 1}, {{2, 2, 1, 1, 1, 1, 1}, 2}, {{2, 2, 2, 1, 1, 1, 1}, 3}, {{2, 2, 2, 2, 1, 1, 1}, 4}, {{2, 2, 2, 2, 2, 1, 1}, 5}, {{2, 2, 2, 2, 2, 2, 1}, 6}, {{2, 2, 2, 2, 2, 2, 2}, 7}, {{3, 1, 1, 1, 1, 1, 1}, 8}, {{3, 2, 1, 1, 1, 1, 1}, 9}, {{3, 2, 2, 1, 1, 1, 1}, 10}, {{3, 2, 2, 2, 1, 1, 1}, 11}, {{3, 2, 2, 2, 2, 1, 1}, 12}, {{3, 2, 2, 2, 2, 2, 1}, 13}, {{3, 3, 1, 1, 1, 1, 1}, 14}, {{3, 3, 2, 1, 1, 1, 1}, 15}, {{3, 3, 2, 2, 1, 1, 1}, 16}, {{3, 3, 2, 2, 2, 1, 1}, 17}, {{3, 3, 2, 2, 2, 2, 1}, 18}, {{3, 3, 3, 1, 1, 1, 1}, 19}, {{3, 3, 3, 2, 1, 1, 1}, 20}, {{3, 3, 3, 2, 2, 1, 1}, 21}, {{3, 3, 3, 2, 2, 2, 1}, 22}, {{3, 3, 3, 3, 1, 1, 1}, 23}, {{3, 3, 3, 3, 2, 1, 1}, 24}, {{4, 1, 1, 1, 1, 1, 1}, 25}, {{4, 2, 1, 1, 1, 1, 1}, 26}, {{4, 2, 2, 1, 1, 1, 1}, 27}, {{4, 2, 2, 2, 1, 1, 1}, 28}, {{4, 2, 2, 2, 2, 1, 1}, 29}, {{4, 2, 2, 2, 2, 2, 1}, 30}, {{4, 3, 1, 1, 1, 1, 1}, 31}, {{4, 3, 2, 1, 1, 1, 1}, 32}, {{4, 3, 2, 2, 1, 1, 1}, 33}, {{4, 3, 2, 2, 2, 1, 1}, 34}, {{4, 3, 2, 2, 2, 2, 1}, 35}, {{4, 3, 3, 1, 1, 1, 1}, 36}, {{4, 3, 3, 2, 1, 1, 1}, 37}, {{4, 3, 3, 2, 2, 1, 1}, 38}, {{4, 3, 3, 3, 1, 1, 1}, 39}, {{4, 3, 3, 3, 2, 1, 1}, 40}, {{4, 4, 1, 1, 1, 1, 1}, 41}, {{4, 4, 2, 1, 1, 1, 1}, 42}, {{4, 4, 2, 2, 1, 1, 1}, 43}, {{4, 4, 2, 2, 2, 1, 1}, 44}, {{4, 4, 3, 1, 1, 1, 1}, 45}, {{4, 4, 3, 2, 1, 1, 1}, 46}, {{4, 4, 3, 2, 2, 1, 1}, 47}, {{4, 4, 3, 3, 1, 1, 1}, 48}, {{4, 4, 4, 1, 1, 1, 1}, 49}, {{4, 4, 4, 2, 1, 1, 1}, 50}, {{5, 1, 1, 1, 1, 1, 1}, 51}, {{5, 2, 1, 1, 1, 1, 1}, 52}, {{5, 2, 2, 1, 1, 1, 1}, 53}, {{5, 2, 2, 2, 1, 1, 1}, 54}, {{5, 2, 2, 2, 2, 1, 1}, 55}, {{5, 2, 2, 2, 2, 2, 1}, 56}, {{5, 3, 1, 1, 1, 1, 1}, 57}, {{5, 3, 2, 1, 1, 1, 1}, 58}, {{5, 3, 2, 2, 1, 1, 1}, 59}, {{5, 3, 2, 2, 2, 1, 1}, 60}, {{5, 3, 2, 2, 2, 2, 1}, 61}, {{5, 3, 3, 1, 1, 1, 1}, 62}, {{5, 3, 3, 2, 1, 1, 1}, 63}, {{5, 3, 3, 2, 2, 1, 1}, 64}, {{5, 3, 3, 3, 1, 1, 1}, 65}, {{5, 4, 1, 1, 1, 1, 1}, 66}, {{5, 4, 2, 1, 1, 1, 1}, 67}, {{5, 4, 2, 2, 1, 1, 1}, 68}, {{5, 4, 2, 2, 2, 1, 1}, 69}, {{5, 4, 3, 1, 1, 1, 1}, 70}, {{5, 4, 3, 2, 1, 1, 1}, 71}, {{5, 4, 3, 2, 2, 1, 1}, 72}, {{5, 4, 3, 3, 1, 1, 1}, 73}, {{5, 4, 4, 1, 1, 1, 1}, 74}, {{5, 4, 4, 2, 1, 1, 1}, 75}, {{5, 5, 1, 1, 1, 1, 1}, 76}, {{5, 5, 2, 1, 1, 1, 1}, 77}, {{5, 5, 2, 2, 1, 1, 1}, 78}, {{5, 5, 2, 2, 2, 1, 1}, 79}, {{5, 5, 3, 1, 1, 1, 1}, 80}, {{5, 5, 3, 2, 1, 1, 1}, 81}, {{5, 5, 4, 1, 1, 1, 1}, 82}, {{5, 5, 5, 1, 1, 1, 1}, 83}, {{6, 1, 1, 1, 1, 1, 1}, 84}, {{6, 2, 1, 1, 1, 1, 1}, 85}, {{6, 2, 2, 1, 1, 1, 1}, 86}, {{6, 2, 2, 2, 1, 1, 1}, 87}, {{6, 2, 2, 2, 2, 1, 1}, 88}, {{6, 2, 2, 2, 2, 2, 1}, 89}, {{6, 3, 1, 1, 1, 1, 1}, 90}, {{6, 3, 2, 1, 1, 1, 1}, 91}, {{6, 3, 2, 2, 1, 1, 1}, 92}, {{6, 3, 2, 2, 2, 1, 1}, 93}, {{6, 3, 3, 1, 1, 1, 1}, 94}, {{6, 3, 3, 2, 1, 1, 1}, 95}, {{6, 3, 3, 2, 2, 1, 1}, 96}, {{6, 3, 3, 3, 1, 1, 1}, 97}, {{6, 4, 1, 1, 1, 1, 1}, 98}, {{6, 4, 2, 1, 1, 1, 1}, 99}, {{6, 4, 2, 2, 1, 1, 1}, 100}, {{6, 4, 2, 2, 2, 1, 1}, 101}, {{6, 4, 3, 1, 1, 1, 1}, 102}, {{6, 4, 3, 2, 1, 1, 1}, 103}, {{6, 4, 4, 1, 1, 1, 1}, 104}, {{6, 4, 4, 2, 1, 1, 1}, 105}, {{6, 5, 1, 1, 1, 1, 1}, 106}, {{6, 5, 2, 1, 1, 1, 1}, 107}, {{6, 5, 2, 2, 1, 1, 1}, 108}, {{6, 5, 2, 2, 2, 1, 1}, 109}, {{6, 5, 3, 1, 1, 1, 1}, 110}, {{6, 5, 3, 2, 1, 1, 1}, 111}, {{6, 5, 4, 1, 1, 1, 1}, 112}, {{6, 6, 1, 1, 1, 1, 1}, 113}, {{6, 6, 2, 1, 1, 1, 1}, 114}, {{6, 6, 2, 2, 1, 1, 1}, 115}, {{6, 6, 3, 1, 1, 1, 1}, 116}, {{6, 6, 4, 1, 1, 1, 1}, 117}, {{7, 1, 1, 1, 1, 1, 1}, 118}, {{7, 2, 1, 1, 1, 1, 1}, 119}, {{7, 2, 2, 1, 1, 1, 1}, 120}, {{7, 2, 2, 2, 1, 1, 1}, 121}, {{7, 2, 2, 2, 2, 1, 1}, 122}, {{7, 2, 2, 2, 2, 2, 1}, 123}, {{7, 3, 1, 1, 1, 1, 1}, 124}, {{7, 3, 2, 1, 1, 1, 1}, 125}, {{7, 3, 2, 2, 1, 1, 1}, 126}, {{7, 3, 2, 2, 2, 1, 1}, 127}, {{7, 3, 3, 1, 1, 1, 1}, 128}, {{7, 3, 3, 2, 1, 1, 1}, 129}, {{7, 3, 3, 3, 1, 1, 1}, 130}, {{7, 4, 1, 1, 1, 1, 1}, 131}, {{7, 4, 2, 1, 1, 1, 1}, 132}, {{7, 4, 2, 2, 1, 1, 1}, 133}, {{7, 4, 2, 2, 2, 1, 1}, 134}, {{7, 4, 3, 1, 1, 1, 1}, 135}, {{7, 4, 3, 2, 1, 1, 1}, 136}, {{7, 4, 4, 1, 1, 1, 1}, 137}, {{7, 5, 1, 1, 1, 1, 1}, 138}, {{7, 5, 2, 1, 1, 1, 1}, 139}, {{7, 5, 2, 2, 1, 1, 1}, 140}, {{7, 5, 3, 1, 1, 1, 1}, 141}, {{7, 5, 3, 2, 1, 1, 1}, 142}, {{7, 5, 4, 1, 1, 1, 1}, 143}, {{7, 6, 1, 1, 1, 1, 1}, 144}, {{7, 6, 2, 1, 1, 1, 1}, 145}, {{7, 6, 2, 2, 1, 1, 1}, 146}, {{7, 6, 3, 1, 1, 1, 1}, 147}, {{7, 7, 1, 1, 1, 1, 1}, 148}, {{7, 7, 2, 1, 1, 1, 1}, 149}, {{8, 1, 1, 1, 1, 1, 1}, 150}, {{8, 2, 1, 1, 1, 1, 1}, 151}, {{8, 2, 2, 1, 1, 1, 1}, 152}, {{8, 2, 2, 2, 1, 1, 1}, 153}, {{8, 2, 2, 2, 2, 1, 1}, 154}, {{8, 3, 1, 1, 1, 1, 1}, 155}, {{8, 3, 2, 1, 1, 1, 1}, 156}, {{8, 3, 2, 2, 1, 1, 1}, 157}, {{8, 3, 2, 2, 2, 1, 1}, 158}, {{8, 3, 3, 1, 1, 1, 1}, 159}, {{8, 3, 3, 2, 1, 1, 1}, 160}, {{8, 4, 1, 1, 1, 1, 1}, 161}, {{8, 4, 2, 1, 1, 1, 1}, 162}, {{8, 4, 2, 2, 1, 1, 1}, 163}, {{8, 4, 3, 1, 1, 1, 1}, 164}, {{8, 4, 3, 2, 1, 1, 1}, 165}, {{8, 4, 4, 1, 1, 1, 1}, 166}, {{8, 5, 1, 1, 1, 1, 1}, 167}, {{8, 5, 2, 1, 1, 1, 1}, 168}, {{8, 5, 2, 2, 1, 1, 1}, 169}, {{8, 5, 3, 1, 1, 1, 1}, 170}, {{8, 6, 1, 1, 1, 1, 1}, 171}, {{8, 6, 2, 1, 1, 1, 1}, 172}, {{8, 6, 3, 1, 1, 1, 1}, 173}, {{8, 7, 1, 1, 1, 1, 1}, 174}, {{8, 7, 2, 1, 1, 1, 1}, 175}, {{8, 8, 1, 1, 1, 1, 1}, 176}, {{9, 1, 1, 1, 1, 1, 1}, 177}, {{9, 2, 1, 1, 1, 1, 1}, 178}, {{9, 2, 2, 1, 1, 1, 1}, 179}, {{9, 2, 2, 2, 1, 1, 1}, 180}, {{9, 2, 2, 2, 2, 1, 1}, 181}, {{9, 3, 1, 1, 1, 1, 1}, 182}, {{9, 3, 2, 1, 1, 1, 1}, 183}, {{9, 3, 2, 2, 1, 1, 1}, 184}, {{9, 3, 2, 2, 2, 1, 1}, 185}, {{9, 3, 3, 1, 1, 1, 1}, 186}, {{9, 3, 3, 2, 1, 1, 1}, 187}, {{9, 4, 1, 1, 1, 1, 1}, 188}, {{9, 4, 2, 1, 1, 1, 1}, 189}, {{9, 4, 2, 2, 1, 1, 1}, 190}, {{9, 4, 3, 1, 1, 1, 1}, 191}, {{9, 4, 4, 1, 1, 1, 1}, 192}, {{9, 5, 1, 1, 1, 1, 1}, 193}, {{9, 5, 2, 1, 1, 1, 1}, 194}, {{9, 5, 2, 2, 1, 1, 1}, 195}, {{9, 5, 3, 1, 1, 1, 1}, 196}, {{9, 6, 1, 1, 1, 1, 1}, 197}, {{9, 6, 2, 1, 1, 1, 1}, 198}, {{9, 7, 1, 1, 1, 1, 1}, 199}, {{9, 7, 2, 1, 1, 1, 1}, 200}, {{9, 8, 1, 1, 1, 1, 1}, 201}, {{10, 1, 1, 1, 1, 1, 1}, 202}, {{10, 2, 1, 1, 1, 1, 1}, 203}, {{10, 2, 2, 1, 1, 1, 1}, 204}, {{10, 2, 2, 2, 1, 1, 1}, 205}, {{10, 2, 2, 2, 2, 1, 1}, 206}, {{10, 3, 1, 1, 1, 1, 1}, 207}, {{10, 3, 2, 1, 1, 1, 1}, 208}, {{10, 3, 2, 2, 1, 1, 1}, 209}, {{10, 3, 3, 1, 1, 1, 1}, 210}, {{10, 3, 3, 2, 1, 1, 1}, 211}, {{10, 4, 1, 1, 1, 1, 1}, 212}, {{10, 4, 2, 1, 1, 1, 1}, 213}, {{10, 4, 2, 2, 1, 1, 1}, 214}, {{10, 4, 3, 1, 1, 1, 1}, 215}, {{10, 5, 1, 1, 1, 1, 1}, 216}, {{10, 5, 2, 1, 1, 1, 1}, 217}, {{10, 6, 1, 1, 1, 1, 1}, 218}, {{10, 6, 2, 1, 1, 1, 1}, 219}, {{10, 7, 1, 1, 1, 1, 1}, 220}, {{11, 1, 1, 1, 1, 1, 1}, 221}, {{11, 2, 1, 1, 1, 1, 1}, 222}, {{11, 2, 2, 1, 1, 1, 1}, 223}, {{11, 2, 2, 2, 1, 1, 1}, 224}, {{11, 3, 1, 1, 1, 1, 1}, 225}, {{11, 3, 2, 1, 1, 1, 1}, 226}, {{11, 3, 2, 2, 1, 1, 1}, 227}, {{11, 3, 3, 1, 1, 1, 1}, 228}, {{11, 4, 1, 1, 1, 1, 1}, 229}, {{11, 4, 2, 1, 1, 1, 1}, 230}, {{11, 4, 2, 2, 1, 1, 1}, 231}, {{11, 4, 3, 1, 1, 1, 1}, 232}, {{11, 5, 1, 1, 1, 1, 1}, 233}, {{11, 5, 2, 1, 1, 1, 1}, 234}, {{11, 6, 1, 1, 1, 1, 1}, 235}, {{11, 7, 1, 1, 1, 1, 1}, 236}, {{12, 1, 1, 1, 1, 1, 1}, 237}, {{12, 2, 1, 1, 1, 1, 1}, 238}, {{12, 2, 2, 1, 1, 1, 1}, 239}, {{12, 2, 2, 2, 1, 1, 1}, 240}, {{12, 3, 1, 1, 1, 1, 1}, 241}, {{12, 3, 2, 1, 1, 1, 1}, 242}, {{12, 3, 2, 2, 1, 1, 1}, 243}, {{12, 3, 3, 1, 1, 1, 1}, 244}, {{12, 4, 1, 1, 1, 1, 1}, 245}, {{12, 4, 2, 1, 1, 1, 1}, 246}, {{12, 5, 1, 1, 1, 1, 1}, 247}, {{12, 5, 2, 1, 1, 1, 1}, 248}, {{12, 6, 1, 1, 1, 1, 1}, 249}, {{13, 1, 1, 1, 1, 1, 1}, 250}, {{13, 2, 1, 1, 1, 1, 1}, 251}, {{13, 2, 2, 1, 1, 1, 1}, 252}, {{13, 2, 2, 2, 1, 1, 1}, 253}, {{13, 3, 1, 1, 1, 1, 1}, 254}, {{13, 3, 2, 1, 1, 1, 1}, 255}, {{13, 3, 3, 1, 1, 1, 1}, 256}, {{13, 4, 1, 1, 1, 1, 1}, 257}, {{13, 4, 2, 1, 1, 1, 1}, 258}, {{13, 5, 1, 1, 1, 1, 1}, 259}, {{13, 6, 1, 1, 1, 1, 1}, 260}, {{14, 1, 1, 1, 1, 1, 1}, 261}, {{14, 2, 1, 1, 1, 1, 1}, 262}, {{14, 2, 2, 1, 1, 1, 1}, 263}, {{14, 2, 2, 2, 1, 1, 1}, 264}, {{14, 3, 1, 1, 1, 1, 1}, 265}, {{14, 3, 2, 1, 1, 1, 1}, 266}, {{14, 4, 1, 1, 1, 1, 1}, 267}, {{14, 5, 1, 1, 1, 1, 1}, 268}, {{15, 1, 1, 1, 1, 1, 1}, 269}, {{15, 2, 1, 1, 1, 1, 1}, 270}, {{15, 2, 2, 1, 1, 1, 1}, 271}, {{15, 3, 1, 1, 1, 1, 1}, 272}, {{15, 3, 2, 1, 1, 1, 1}, 273}, {{15, 4, 1, 1, 1, 1, 1}, 274}, {{16, 1, 1, 1, 1, 1, 1}, 275}, {{16, 2, 1, 1, 1, 1, 1}, 276}, {{16, 2, 2, 1, 1, 1, 1}, 277}, {{16, 3, 1, 1, 1, 1, 1}, 278}, {{16, 4, 1, 1, 1, 1, 1}, 279}, {{17, 1, 1, 1, 1, 1, 1}, 280}, {{17, 2, 1, 1, 1, 1, 1}, 281}, {{17, 2, 2, 1, 1, 1, 1}, 282}, {{17, 3, 1, 1, 1, 1, 1}, 283}, {{18, 1, 1, 1, 1, 1, 1}, 284}, {{18, 2, 1, 1, 1, 1, 1}, 285}, {{19, 1, 1, 1, 1, 1, 1}, 286}, {{19, 2, 1, 1, 1, 1, 1}, 287}, {{20, 1, 1, 1, 1, 1, 1}, 288}}; vector<string> DIST{ 0 , 10 , 210 , 3210 , 43210 , 543210 , 6543210 , 76543210 , 211234560 , 3211234510 , 43211234210 , 543211233210 , 6543211243210 , 76543211543210 , 432223452112340 , 5432223432112310 , 65432223432112210 , 765432225432113210 , 8765432265432143210 , 65433334432223211230 , 765433335432223211210 , 8765433365432243211210 , 98765433765432543213210 , 876544446543334322221120 , 9876544476543354322321110 , 21012345112345234564567670 , 321012342112342234534565610 , 4321012332112322234334545210 , 54321012432112322233334443210 , 654321015432114322233334443210 , 7654321065432154322433344543210 , 43211234210123112342345452112340 , 543211233210122112322343432112310 , 6543211243210132112222333432112210 , 76543211543210432113222335432113210 , 876543216543215432143223365432143210 , 6543222343211221012112323432223211230 , 76543222543211321012112225432223211210 , 876543226543214321032112265432243211210 , 8765433365432243211210111654333432222110 , 98765433765432543213210217654335432232110 , 432101233211232223433454521012311234234450 , 5432101243211232223333444321012211232233410 , 65432101543211432223333444321013211222233210 , 765432106543215432243334454321043211322333210 , 6543211243210132112222333432112210121122321120 , 76543211543210432113222335432113210121122321110 , 876543216543215432143223365432143210321224321210 , 8765432265432143210321122654322432112101143222110 , 65432101543211432223333444321013211222233210111220 , 765432106543215432243334454321043211322333210211210 , 3212345621234523456456767123456234564566734564566560 , 43212345321234223453456562123451234534556234534554510 , 543212344321233223433454532123421234234451234234434210 , 6543212354321243223333444432123321232233421231233233210 , 76543212654321543224333445432124321232233321221221243210 , 876543217654326543254334465432154321432334321321221543210 , 5432234532123421234234545322345123452344523453454452112340 , 65432234432123321232234344322342123412334223423433432112310 , 765432235432124321232233354322332123212233223123223432112210 , 8765432265432154321432233654322432123212243222121225432113210 , 98765432765432654325432437654325432143232543232123265432143210 , 765433345432233212321232354333432234123233334234334432223211230 , 8765433365432243212321222654333432232121243332232335432223211210 , 98765433765432543214321327654335432232121543332213365432243211210 , 987654447654335432232122176544454333322125444333244654333432222110 , 5432123443212332234334545321234212342344512342344342101231123423440 , 65432123543212432233334444321233212322334212312332332101221123223310 , 765432126543215432243334454321243212322333212212212432101321122223210 , 876543217654326543254334465432154321432334321321221543210432113223321 0 , 7654322354321243212322333543223321232122332231232234321122101211222112 0 , 8765432265432154321432233654322432123212243222121225432113210121123211 10 , 9876543276543265432543243765432543214323254323212326543214321032124321 210 , 9876543376543254321432132765433543223212154333221336543224321121014322 2110 , 7654321265432154322433344543212432123223332122122124321013211222232101 11220 , 8765432176543265432543344654321543214323343213212215432104321132233210 211210 , 6543234554323443234334545432345323452344523453454453212342123423441234 2344340 , 7654323465432354323433444543234432343233432342343344321233212322332123 12332310 , 8765432376543265432543344654323543234323343233232235432124321232233212 212212210 , 9876543287654376543654354765432654325434354324323326543215432143234321 3212213210 , 8765433465432354323432333654334432343232343342343345432233212321223223 12322321120 , 9876543376543265432543243765433543234323254333232336543224321232124322 212122321110 , 8765432376543265432543344654323543234323343233232235432124321232233212 2122122101110 , 9876543487654376543654354765434654345434354344343346543235432343234323 32322332122110 , 3212345610123412345345656212345123453455623453455451234562345645663456 456656456756670 , 4321234521012311234234545211234012342344512342344342123451234534552345 3455453456455610 , 5432123432101221123223434321123101231233421231233233212342123423441234 23443423453445210 , 6543212343210132112222333432112210121122321120122124321233212322332123 123323323423343210 , 7654321254321043211322233543211321012112232111011215432124321232233212 2122124323322343210 , 8765432165432154321432233654321432103212243212101216543215432143234321 32122154324334543210 , 5432234532112310123123434322234112341233422342343343223451234523442345 345445345645562112340 , 6543223443211221012112323432223211230122332231232234322342123412332234 2343342345344532112310 , 7654322354321132101211222543222321121011232221121225432233212321223223 12322332342334432112210 , 8765432265432143210321122654322432112101143222110326543224321232124322 212122432332235432113210 , 7654333454322232112101212543333322231121243332232335433343223412323334 2343343345344543222321120 , 8765433365432243211210111654333432222110143332221336543334322321214333 22323343342334543222321110 , 9876543376543254321321021765433543223211054333221437654335432232125433 322133543332336543224321210 , 9876544476543354322321110765444543333221154443332447654445433332215444 3332445444334465433343222110 , 5432123432101221123223434321123101231233421231233233212342123423441234 23443423453445210123112323440 , 6543212343210132112222333432112210121122321120122124321233212322332123 123323323423343210122112223310 , 7654321254321043211322233543211321012112232111011215432124321232233212 2122124323322343210132112223210 , 8765432165432154321432233654321432103212243212101216543215432143234321 32122154324334543210432132233210 , 7654322354321132101211222543222321121011232221121225432233212321223223 123223323423344321122101112221120 , 8765432265432143210321122654322432112101143222110326543224321232124322 2121224323322354321132102112321110 , 7654321254321043211322233543211321012112232111011215432124321232233212 21221243233223432101321122232101110 , 8765432165432154321432233654321432103212243212101216543215432143234321 321221543243345432104321322332102110 , 6543234543212332123223434432234212341233432342343343212341012312332123 1233231234233432123421232344123423340 , 7654323454321243212322333543223321232122332231232234321232101211222112 01221221231223432123321222332123122310 , 8765432365432154321432233654322432123212243222121325432123210121123211 101121321221125432124321322332122112210 , 9876543276543265432543243765432543214323254323212326543214321032124321 2101214321322365432154324323432132213210 , 8765433465432243212321222654333432232121243332232335432233211210113222 11212232231223543223321221223223122321120 , 9876543376543254321432132765433543223212154333221436543224321121014322 211032432221226543224321321243222122321110 , 8765432365432154321432233654322432123212243222121325432123210121123211 1011213212211254321243213223321221122101110 , 6543234543212321012112323432234211230122332231232234323452123412333234 23433423453445321234101212332123122312342330 , 7654323454321232101211222543223321121011243222121325432343212321223223 123223323423344321232101112221120112212312210 , 8765432365432143210321122654322432112101143222110326543234321232124322 2121324323322354321232102112321110213212211210 , 8765433465432243211210111654333432222110154333221436543344322321214333 22323343342334543223321110113222112232231222110 , 8765432365432143210321122654322432112101143222110326543234321232124322 212132432332235432123210211232111021321221121010 , 4321234521234523456456767212345234564566723454566452234563456756773456 5677564567676712345634565677345656564567676456660 , 5432123432123422345345656321234123453455612343455343223452345645662345 45664534565656212345234545662345454534565653455510 , 6543212343212332234334545432123212342344521232344234322343234534552234 345534334545453212342234345512343434234545423444210 , 7654321254321243223333444543212321232233432121233125432234323433443223 2344234334343443212332233344212323233234343323333210 , 8765432165432154322433344654321432123223343212122216543225432343344322 32332254334334543212432233343212221243233324323243210 , 9876543276543265432543344765432543214323354323212327654326543254345432 432332654354456543215432433443213221543243354343543210 , 6543223443212321234234545432234212342344522342344344323452234534552345 3455453456455632123412343455123434342345454234442112340 , 7654322354321232123223434543223321231233432231233235432343223423443234 23443433453445432123212323442123232322343431233332112310 , 8765432265432143212322333654322432122122343222122226543234322332334323 223323433433345432123212223332121212322323221222432112210 , 9876543276543254321432233765432543213212254323211327654325432243235432 3222325433433465432143213223432121214322322321215432113210 , 8765433365432243212212323654333432232122343332232336543344323422334334 23433443453445543223321212333223122332342332122243222321120 , 9876543376543254321321222765433543223211254333221337654335432332225433 323233543433346543224321212243222122432322232111543222321110 , :987654487654365432432121876544654334322165444332448765446543343226544 4332446544434476543354323211543332335433323432226543334322210 , 6543212343212332234334545432123212342344521232344234322343234534552234 34553433454545321234223434551234343423454542344421012311232340 , 7654321254321243223333444543212321232233432121233125432234323433443223 234423433434344321233223334421232323323434322333321012211222310 , 8765432165432154322433344654321432123223343212122216543225432343344322 3233225433433454321243223334321222124323332322324321013211223210 , 9876543276543265432543344765432543214323354323212327654326543254345432 43233265435445654321543243344321322154324334323254321043213233210 , 8765432265432143212322333654322432122122343222122226543234322332334323 223323433433345432123212223332121212322323221222432112210111221120 , 9876543276543254321432233765432543213212254323211327654325432243235432 3222325433433465432143213223432121214322322321215432113210212321110 , 8765432165432154322433344654321432123223343212122216543225432343344322 32332254334334543212432233343212221243233323223243210132112232101110 , 7654323454322343234334545543234322342344532342344344321232123423442123 234423223434344322343234345522343434123434323444321234212323412342330 , 8765432365432254323433444654323432233233443232233235432123212322333212 123312322323235432234323334432232323212323232333432123321222321231221 0 , 9876543276543265432543344765432543224323354323222326543214321232234321 2122214322322365432254324334432232223212221432325432124321323321221121 0 , 9876543376543254322432333765433543233222354333232336543224321221224322 2122224323222365432343223233432322233212121322225432233212212322312221 10 , :987654387654365432543243876543654324323265434322437654325432132125432 3211325432323376543254324323543232324321212432326543224321322432221232 110 , 9876543276543265432543344765432543224323354323222326543214321232234321 2122214322322365432254324334432232223212221432325432124321323321221121 0110 , 7654323454321232123223434543223321231233432231233235432343223423443234 2344343345344543212321232344212323232234343123333212341012123212312212 32330 , 8765432365432143212322333654322432122122343222122326543234322332334323 2233234334333454321232122233321212123223232212224321232101112211201121 212210 , 9876543276543254321432233765432543213212254323211327654325432243235432 3222325433433465432143213223432121214322322321215432123210212321110232 1211210 , 9876543376543254321321222765433543223211254333221437654335432332225433 3232335434333465432243212122432221224323222321115432233211101322211232 21222110 , 8765432365432343234334545654323432342344543232344236543344334534554334 3455344445454554323432343455323434343345454234444321232123234212323222 334312330 , 9876543276543254323433444765432543233233454323233327654335433443445433 3344335444444565432343233344432323234334343323335432123212223321212132 2232212210 , 3210123421123412345345656101234123453455612343455342123452345645662345 4566453456565622234523454566234545453456565345551234563456567345656545 66764566560 , 4321012332112321234234545210123112342344501232344233212342234534551234 3455342345454532123412343455123434342345454234442123452345456234545434 556534554510 , 5432101243211232123223434321012211231233410121233124321233223423442123 2344233234343443212321232344212323232234343123333212342234345123434323 4454234434210 , 6543210154321143212322333432101321122122321011122015432124322332333212 2233124323332354321232122233321212123223232212224321233223234212323232 33433233233210 , 7654321065432154321432233543210432113212232102111106543215432243234321 3222215432433465432143213223432121214322322321215432124322323321222143 233243223243210 , 5432112332101221123123434321123101231233411231233233212342123423441234 2344342345344521012311232344012323231234343223333212341234345123434323 4454234434211230 , 6543211243210132112212323432112210121122321120122124321233212322332123 1233233234233432101221121233101212122123232212224321232123234212323222 33431233233211210 , 7654321154321043211321222543211321012111232111011115432124321232223212 2122124323322343210132112122210111013212221321115432123212223321212132 223221223243211210 , 8765432165432154321432132654321432103212143212101216543215432143234321 3212215432433454321043213212321021104321322432226543214321322432121243 2322321243543213210 , 7654322254321132101211212543222321121011232221121225432233212321223223 1232233234233443211221011122211201122123122101115432233212123322312232 32332122324321221120 , 8765432265432143210321121654322432112101143222110226543224321232124322 2121224323322354321132102111321110113212211210106543224321212432221243 222232114354321321110 , 5432101243211232123223434321012211231233410121233124321233223423442123 2344233234343432122321232344122323232334343123333212342234345123434323 4454234434210121123230 , 6543210154321143212322333432101321122122321011122015432124322332333212 2233124323332343211232122233211212123223232212224321233223234212323232 33432233233210121121210 , 7654321065432154321432233543210432113212232102111106543215432243234321 3222215432433454321143213223321121114322322321215432124322323321222143 233232223243210321121210 , 7654321154321043211321222543211321012111232111011115432124321232223212 2122124323322343210132112122210111013212221212125432123212223321212132 2232212232432112101112110 , 8765432165432154321432132654321432103212143212101216543215432143234321 3212215432433454321043213212321021104321322321216543214321322432121243 23223212435432132102132110 , 7654321065432154321432233543210432113212232102111106543215432243234321 3222215432433454321243213223321221124323322321215432124322323321222143 233232223243210321121210110 , 6543212354321243223323434432123321232233421231233233210122112312331012 1233122123232343212332232344212323232223232233334322343234345223434312 3343234434321232123231232330 , 7654321265432154322432333543212432123222332122122124321013211221222101 1122013212221254321243223233321222123212121322225432234323334322323221 22323233334321232122221212210 , 8765432176543265432543243654321543214323243213212215432104321132123210 2111104321322365432154324323432132214321212432326543225432433432232232 122143234354321432132321211210 , 8765432265432154321432232654322432123212243222121225432113210121113211 1011113212211254321243213222321221122101110321216543234322323432322232 1121322243543223212213221222110 , 6543212343210132112212323432112210121122321120122124321233212322332123 1233233234233432101221121233101212122123232222224321232123234212323222 33431233233212310121221212212320 , 7654321254321043211321222543211321012111232111011215432124321232223212 2122124323322343210132112122210111013212221321115432123212223321212132 223221223243212210111211011212110 , 8765432265432143210321121654322432112101143222110326543224321232124322 2121224323322354321132102111321110113212211210106543224321212432221243 2222321143543213211103211113221210 , 7654321254321243223323434543212321232233432121233125432234323433443223 2344234334343443212332232344212323233234343323333210122112123101212121 22322222124321221232321223222331230 , 8765432165432154322432333654321432123222343212122216543225432343334322 3233225433433454321243223233321222124323332432224321013211212210111032 122132112154321321222321121322221210 , 6543210154321143212322323432101321122122321011122015432124322332333212 2233124323332354322232122233322212223233233212224321233223234212323232 3343323323321012112121011212122222120 , 4321234521234501234234545212345123452344523453454452123452345634552345 4565453456565632345612343455234534453456455234442345672345456345645545 65663455451234534563434545534554545640 , 5432123432123410123123434321234212341233412342343343212341234523441234 3454342345454521234501232344123423342345344123333234561234345234534434 545523443421234234523234344234434345310 , 6543212343212321012112323432123211230122321231232234321232123412332123 2343232234343432123410121233212312231234233012224323452123234223423323 4344123323321232234121232331233232342210 , 7654321254321232101211222543212321121011232122121125432123212321223212 1232123223232343212321011122211201122123122101115432343212123322312232 32332122324321221230121212221223212313210 , 8765432165432143210321122654321432112101143212110216543214321232124321 2121214322322354321232102112321110213212211210106543234321212432221243 222232114354321321210321211321121032243210 , 6543223443212321123012323432234212341232322342343344322342123423432234 2344342345344532123411231233123423341234343123234323452234234234534423 4454234334322341234232343442343233343211230 , 7654322354321232112101212543223321231121232231232235432233212312323223 1233233234233443212321120122212312232123232112125432343223123323423332 33432232334322321231222323322321222323211210 , 8765432265432143211210111654322432122110143222121226543224321221214322 2122224323222354321232111011321211123212121211016543234322212432322243 223232214354322321211322122322121132243211210 , 9876543276543254321321021765432543213211054323211327654325432132125432 3211325432323365432143212101432121214321212321117654325432321543232354 3323432254654324321214322124322321433543213210 , 8765433365432243212211201654333432232121243332232336543334322321224333 2232334334233454322332121121322312233223122212126543344323222433423343 32333232435432332231232323332322223324321221120 , 9876543376543254321321110765433543223211154333221337654335432232115433 3221335433323365432243212110432221224322212321117654335432321543332354 332343225465432432221432222432232143354321321110 , 6543212343212321012112323432123211230122321231232234321232123412332123 2343232234343432123410121233212312231234233012224323452123234223423323 4344123323321232234121232331233232342210121123230 , 7654321254321232101211222543212321121011232122121125432123212321223212 1232123223232343212321011122211201122123122101115432343212123322312232 32332122324321221230121212221222212313210121121210 , 8765432165432143210321122654321432112101143212110216543214321232124321 2121214322322354321232102112321110213212211210106543234321212432221243 222232114354321321210321211321121032243210321121210 , 8765432265432143211210111654322432122110143222121226543224321221214322 2122224323222354321232111011321211123212121211016543234322212432322243 2232322143543223212113221223221211322432112101112110 , 8765432165432143210321122654321432112101143212110216543214321232124321 2121214322322354321232102112321110213212211210106543234321212432221243 22223211435432132121032121132112103224321032112121010 , 7654323454322332123212323543234322341232332342343344321232123401222123 1232232123232343223421231233323423342234122123235433453234234334534423 423323433443234323423234344123323334332123212323123230 , 8765432365432243212321222654323432232121243233232235432123212310113212 2121123212121254322332122122322312232123011212126543344323223433423332 3122323243543233223123232332122322332432123212122121210 , 9876543276543254321432132765432543223212154323221326543214321221014321 2110214321212265432243213212432221323212102321217654335432322543332343 22124322546543243222143232232123214335432143212132121210 , 9876543376543254322321221765433543233221254333232336543224321221104322 2121224322212265432343222121432322233212111322127654345433322543433343 222243325465433432322433233322132243354322321221322122110 , 7654323454321232123101212543223321232121232231232235432343212312323223 1233233234233443212321230122212312232123232223125432343234123323423332 3343234234432342123233232332342123233321231012122121212320 , 8765432365432143212210111654322432122110143222121326543234321221214322 2122224323222354321232121011321221123212121212016543234323212432322243 22323231435432332122232212232312123234321221011121101212110 , 8765432365432343212212323654323432232122343232232236543234323422334323 2343234334343454323432121233322312233234233212224321232123012212312221 223232312354323323412323233323323212243212212323212222233120 , 9876543276543254321321222765432543223211254323221327654325432332225432 3232325433333465432343212122432221224323222321115432123212101321221132 1121212032654324323214322224322321213543213212223211132222110 , 7654321254321232101211212543212321121011232122121125432123212321223212 1232123223232343212321011122211201122123122101115432343212123322312232 32332122324321221230121212221223212313210121121210111212222120 , 5432345632234512345345656212345234563455623454565451012341234534551234 3455342345454521234523454566234545452345454345553234563456567345656534 556545665623456345645345565234434545512345345656345553455455640 , 6543234543223421234234545321234223452344512343454342101231123423440123 2344231234343432123412343455123434341234343234444323452345456234545423 4454345545323452345342344541233234344212342345452344423443445310 , 7654323454322332123223434432123322341233421232343233210122112322331012 1233122123232343212321232344212323232123232123335432343234345223434312 33432344344323422342312334301221232333212322343412333123323342210 , 8765432365432243212322333543212432232122332122232124321013211222232101 1122013212221254321232122233321212123212221212226543234323234322323221 223232334354323322312212232101121232243212322323212222122322313210 , 9876543276543254321432233654321543223212243213221215432104321132233210 2112104321322365432143213223432121214321322321217654325432323432232232 1221432254654324322213212212101321433543214322323212132124332243210 , 7654334554323432234123434432234212342343422342344343211231012312331123 1233231234233443223421232344123423340123232123335433453234345234534412 33432344344334523453423434412322333443223412343423434223323343211230 , 8765433465432343223212323543223321232232332231233234321122101211222112 0122122123122354322332121233212312231012121212226543344323234323423321 223232334354334323423223233112122233343223212323223232122122323211210 , 9876543376543254322321222654322432123221243222122225432113210121123211 1011113212211265432243212122321221122101110321117654335432323432322232 112143225465433432322322122211032143354322321222322123211213224321121 0 , 9876544476543354323322312654333432232122343332232335432223211210113222 1121223223122365433343222122322312232112011322127654445433323433423332 2122433254654344334233232332121322433543233223122122210112132243222211 0 , :987654487654365432432221765433543223212254333221336543224321121014322 2110224322212276543354323211432221223211101432218765446543432543332343 2212543365765435433324322223211432544654324322213212121013243354322321 10 , 7654323454322332123223434432123322341233421232343233210122112322331012 1233122123232343212321232344212323231223332123335432343234345223434312 3343234434432342234231233430122123233321232234341233312332334221012112 230 , 8765432365432243212322333543212432232122332122232124321013211222232101 1122013212221254321232122233321212122112221212226543234323234322323221 2232323343543233223122122321011212322432123223232122221222223132101211 2210 , 9876543276543254321432233654321543223212243213221215432104321132233210 2112104321322365432143213223432121213211221321217654325432323432232232 1221432254654324322213212212101321433543214322323212132123232243210321 22210 , 9876543376543254322321222654322432123221243222122225432113210121123211 1011113212211265432243212122321221122101110321117654335432323432322232 1121432254654334323223221222110321433543223212223221221212132243211210 112110 , 8765434565433443234323434543234432342343432342344344321233212312332123 1233231012121254323432232344323423342123232223336543454334345334534422 3343334444543453345342343441232233344432343234342343412332334332123212 2312320 , 9876543476543354323432333654323543233232343233233235432124321221223212 2122122101110165432343223233432322233212121322227654345433334433433332 2232433354654344334233232332121322433543234323233232321223233243212321 12212110 , 8765434565432343223212323543234321232232332231233234321232101211222112 0122122123122354323432121233212312231012121212226543454323234323423321 2232323343543343234233342332231232343432232123233232323221223232123101 122121120 , 9876543476543254322321222654323432123221243222122325432123210121123211 1011213212211265432343212122321221122101110321117654345432323432322232 1121432254654334323223231222120321434543223212223221232112132343212210 1121102110 , 9876543476543354323323434654323432343233443232343235432123212322333212 1233123223232365432343232344322323232123232323335432343223123212323210 1121212232654344334233233432122323233543233234343233332332312243212212 23212222120 , 5432345632123422345345656322345123453455623453455452123452345645662345 4566453456565621234523454566234545453456565345553234563456567345656545 6676456656334562345453454553455345455233453456563455545664556412345345 563455454550 , 6543234543212332234334545432234212342344522342344343212342234534551234 3455342345454532123422343455123434342345454234444323452345456234545434 5565345545323451234342343442344234344322342345452344434553445321234234 4523443434410 , 7654323454321243223333444543223321232233432231233234321233223433442123 2344233234343443212332233344212323233234343223335432343234345323434323 4454234434432342123232232331233123233432233234342233323442334232123223 34123323233210 , 8765432365432154322433344654322432123223343222122225432124322333343212 2233124323332354321243223334321222124323332322326543234323334432323232 3343323343543233212223221222122212323543224323333222232333233243212322 332122323223210 , 7654334554322332123223434543334322341233433342343344322342123423442234 2344342345344543223421232344223423341234343123335433453234345334534423 4454234434432342234232343442343233343321232234341233323443334232234123 3423433423321120 , 8765433465432243212322333654333432232122343332232335432233212322333223 1233233234233454322332122233322312232123232212226543344323234433423332 3343323343543233223123232332232222332432123223232122232332223143223212 23223223122321110 , 9876543376543254321432233765433543223212254333221336543224321232234322 2122224323322365432243213223432221223212221321217654335432323543332343 2232432254654324322214322223221321433543214322323212143223232254322321 223221322134321210 , 9876544476543354322321222765444543333221254443332446543334322321224333 2232334334233465433343222122433322333223122322127654445433323544433443 3233433254654334323224332333232322433543223212223221221222132254333322 1233323222343222110 , 7654323454321243223333444543223321232233432231233234321233223433442123 2344233234343443212332233344212323232234343233435432343234345323434323 4454234434432342123232232331233123233432333234342333323442334332123223 34123323233210111220 , 8765432365432154322433344654322432123223343222122225432124322333343212 2233124323332354321243223334321222123223332322326543234323334432323232 3343323343543233212223221222122212323543224323333222232333233243212322 332122322223210211210 , 9876543276543265432543344765432543214323354323212326543215432243344321 3223215432433465432154324334432132214322332432327654325432434543232343 2332432354654324321324322123212322433654325432434323243234343354321432 3332124332343213212210 , 9876543376543254321432233765433543223212254333221336543224321232234322 2122224323322365432243213223432221223212221321217654335432323543332343 2232432254654324322214322223221321433543214322323212132223232254322321 22322132213432121012110 , 8765434565432354323433444654334432343233443342343345432343212322333223 1233232123232354323443233344323423342123232323336543454334345434534432 3343334444543343234233343442342233343543233234343233323332334243234212 232232121223212212212320 , 9876543476543265432543344765433543234323354333232336543234321232234322 2122223212221265432354324334432332233212221432327654345433434543433343 2232433354654334323324332333231322434654324323334322232223243354323321 2232212121343213212212110 , 8765434565432343212322333654334432232122343332232335432343212322333223 1233233234233454323432122233322312232123232212226543454323234433423332 3343323343543233234123232333342332342432123223232122232332323143223212 23323223122321210112121120 , 9876543476543254323433444765433543233233454333233336543234323433444323 2344234334343465432343233344432323233234343323335432343212223322312221 2232212232654344323234332333233323333543234334343233343443323254323323 343233332314321212221222210 , 4321234521012311234234545211234012342344512342344342123451234534552345 3455453456455610123412343455123434342345454234442123452345456234545434 5565345545323451234342343443454234344332342345452344434553445323345345 5634554545512343455345545450 , 5432123432101221123223434321123101231233421231233233212342123423441234 2344342345344521012311232344012323231234343123333212341234345123434323 4454234434212340123231232332343123233321231234341233323442334232234234 45234434344212323442344343410 , 6543212343210132112222333432112210121122321120122124321233212322332123 1233233234233432101221122233101212122123232212224321232123234212323222 3343123323321231012122121221232012122432122123232122222331223143223323 342233332333212223312332323210 , 7654321254321043211322233543211321012112232111011215432124321232233212 2122124323322343210132112223210111013212221321215432123212223321212132 2232212232432122101112110112121101213543213212223211132222132254322432 3332224332343213223212232323210 , 6543223443211221012112323432223211230122332231232234322342123412332234 2343342345344532112310121233112312231234233012224322342123234223423323 4344123323321231123121232332343122232210121123230122212332223132123223 34123323233322312332343342321120 , 7654322354321132101211222543222321121011232221121225432233212321223223 1232233234233443211221011122211201122123122101115432233212123322312232 3233212232432122112012121222232111221321012112121011121222112043212322 232122322224322212222322312321110 , 8765432265432143210321122654322432112101143222110326543224321232124322 2121224323322354321132102112321110113212211210106543224321212432221243 2222321143543213211103211113221210322432103211212101032123221154321432 3232124332354323212322132234321210 , 8765433365432243211210111654333432222110143332221336543334322321214333 2232334334233454322232111011322211223223122211016543334322212433322343 3233322143543223212113221223232211322432112101112110121211021154322321 22322132213543332213332332343222110 , 6543212343210132112222333432112210121122321120122124321233212322332123 1233233234233432101221122233101212122123232122324321232123234212323222 3343123323321231012122121221232012122321222123231222223331223243233212 232232231223212223312332323210111220 , 7654321254321043211322233543211321012112232111011215432124321232233212 2122124323322343210132112223210111013212221211215432123212223321212132 2232212232432122101112110112121101212432113212222111132222122154322321 2232213221343213223212232223210211210 , 7654323454321243212322333543223321232122332231232234321232101211222112 0122122123122343212332122233212312231012121212225432343223234323423321 2232223333432232123123232332231122232432122123232122222221223132123101 12212112011432321222232121232122122120 , 8765432365432154321432233654322432123212243222121325432123210121123211 1011213212211254321243213223321221122101110321216543234322323432322232 1121322243543223212213221222120211323543213212223211132112132243212210 112110211025432321232212123432132122110 , 7654323454321232101211222543223321121011243222121325432343212321223223 1232233234233443212321011122211201122123122101115432343212123322312232 3233212232432122123012121223232221231321012112121011121222212043212212 2321222212243222122323223123212101121120 , 5432345632123422345345656322345123453455623453455453234562345645663456 4566564567566721234523454566234545453456565345552123452345456234545434 5565345545323452345453454554565345344433453456563455545664545434456345 56456556455234545664566565512343455344540 , 6543234543212332234334545432234212342344532342344344323453234534552345 3455453456455632123422343455123434342345454234443212342234345123434323 4454234434322341234342343443454234233432342345452344434553434343345234 453454453443234345534554544212323442334310 , 7654323454321243223333444543223321232233432231233235432344323433443234 2344344345344543212332233344212323233234343323334321233223334212323232 3343223323432232123233232332343123122543233234343233333442323254334323 3433433423343233344234434333212223312232210 , 8765432365432154322433344654322432123223343222122326543235432343344323 3233235434433454321243223334321222124323332432325432124322334321222143 2332322332543223212223221223232212213654324323334322243333232365433432 33433243324543243343233434343213223213233210 , 7654334554322332123223434543334322341233443342343345433453234523443345 3454453456455643223421232344223423342345344123334322342123234223423323 4344123323432342234232343443454233233321232234341233323443333243234334 342344343434334234434544533322312332334221120 , 8765433465432243212322333654333432232122343332232336543344323432334334 2343344345344554322332122233322312233234233212225432233212223322312232 3233212232543233223123232333343222222432123223232122232333222154323433 2332334333354333233334334224322212222231321110 , 9876544476543354322321222765444543333221254443332447654445433432325444 3343445445344565433343222122433322334334233322126543334322212433322343 3233322143654334323224332334343322323543223212223221232322121265433432 33433243323654443324443443354333221333324322210 , 7654323454321243223333444543223321232233432231233235432344323433443234 2344344345344543212332233344212323233234343233434321233223334212323232 3343233423432232123233232332343123122432333234342333334442323354344323 343343342324323334423443433321222331223321011120 , 8765432365432154322433344654322432123223343222122326543235432343344323 3233235434433454321243223334321222124323332322325432124322334321222143 2332322332543223212223221223232212213543224323333222243333232265433432 3343324332354324334323343334321322321322321021210 , 8765434565432354323433444654334432343233443342343345432343212322333223 1233233234233454323443233344323423342123232323335432344323334323423321 2232323333543343234234343443232233233543233234343233333332323243234212 23323223121543432333343232243233233231223212212120 , 8765434565432343212322333654334432232122354333232436543454323432334334 2343344345344554323432122233322312233234233212225432343212223322312232 3233212232543233223123232334343322332432123223232122232333323154323323 233233332325433323343433422432321223223132121012110 , 6543234543234533456456767432345234564566723454566453234561234534552345 3455453456455621234523454566234545452345454345551012341234345123434323 4454234434212342345452344543454345233323453456563455534554534443456234 4534544534434563455456545442345456645344123434534440 , 7654323454323443345445656543234323453455632343455344323452123423442234 2344342345344532123422343455123434341234343234442101231123234012323212 3343123323321232234341233432343234122432342345452344423443423332345123 34234334233434523443454343332343455342332123234233310 , 8765432365432354334444555654323432343344543232344235432343212322333223 1233233234233443212332233344212323232123232323333210122112223101212121 2232212212432123223332122322232123011543233234343233332332312243234212 233232231225434323333432322432333442312232122231222210 , 9876543276543265433544455765432543234334454323233326543234321232234322 2122224323322354321243223334321222123212221432324321013211223210111032 1221321221543214322333212213221212102654324323334322243223221354323321 2232213221365434323433232335432433432213432132321333210 , 8765433465432343234334545654334432342344543342344345433453223412333334 2343343345344543223421232344223423342234233123333211231012123112312212 3233012212432232123232232332343123122432343234342343412332322343345223 23334323232543433433454343243232344232323223123233221120 , 9876543376543254323433444765433543233233454333233336543344322321224333 2232334334233454322332122233322312233223122212224321122101112211201121 2122101121543223212223221223232212112543234323233232321223221254334322 124332322226543433243433321543232333222143222122221321110 , 8765432365432354334444555654323432343344543232344235432343212322333223 1233233234233443212332233344212323232123232223333210122112223101212121 2232122312432123223332122322232123011543233234343233323332312243234212 2332322312154343233334323224323334423122321222312232101110 , 9876543476543365434544555765434543344344554343344346543234323432334323 2343233234122354323443233344323423342123232323334321233212223212312210 1121212222543234323333232332122223122654344334344343432332312254323323 23323323120654343434344342154334344332324323323231232122110 , 5432123443223423345445656321234123453455612343455342123450123423441234 2344342345344532334512343455234534451234343234442123452345456234545423 4454345545212342345452344543453344343323452345453454523443445432345123 342343342334345234434543434343434553423323454564534123434340 , 6543212354322332334344555432123212342344521232344233212341012312332123 1233231234233443223421232344123423340123232123333212342234345123434312 3343234434321232234341233432342233232322341234342343412332334321234012 2312322312232341233234323234323234423122323434534232123232310 , 7654321265432243233334445543212321232233432121233124321232101211222112 0122122123122354322332122233212312231012121212224321233223334212323221 2232323323432123223332122323231222121432232123233232321221223232123101 12212112011432321222232121243322233120114323334231232122212210 , 7654322354321243223233444543223321231233432231233234322342112301223223 1232232234233443212332231233212323231123122223234322342123234223423322 3233123323432232123232232331232123232433332234231233301221223332234112 122232121224323223223432323321222331212243232342323322312232110 , 8765432265432154322323334654322432122122343222122225432233211210113222 1121223223122354321243222122321212122112011322125432233212223322312232 2122212232543223212223221222121212222543323223122122210112132243223211 0132212111254323221323222224321322221112543232332224322212232110 , 7654321265432243233334445543212321232233432121233124321232101211222112 0122122123122354323332122233212312231012121212224321233223334212323221 2232223323432123223332122322231232121432232123232232312221223232123101 12212112011432321222232121243232233120114323334231232122212210110 , 4321012332112322234334545210123112342344501232344233212341234534551234 3455342345454532223423344455223434342345454344542123452345456234545434 5565345545101231234341233432344234342212342345452344434553445332345234 453454453444334345534554545432333442334434344453445234545451233430 , 5432101243211232223333444321012211232233410121233124321232123423442123 2344232234343443212332233344212323231234343233433212342234345123434323 4454234434210121123230122321233123231321232234341233323442334232234123 3423433423343232344234434343212223312233432333423343234343421223210 , 6543210154321143222333344432101321122223321011122015432123212322333212 1233123223232354321243223334321222122123232322324321233223334212323232 3343323323321012112221011212122212120432123223332122232332223143223212 23323223122543232333233232343213223211225432434322343233323321221210 , 6543211243210132112222333432112210121122321120122124321233212312332123 1233233234233432101221122233101212122123232222324321232123234212323222 3343123323321121012121121221232012121432222123232222212331223243223223 232233232333212223312332333210111220112232122231223432323233221222110 , 6543210154321143222333344432101321122223321011122015432123212322333212 1233123223232343212232233344212223222123232323334321233223334212323232 3343233423321012112221011212122123120432123223332122222332323143212212 232122221224322323322332323321222331212243233342323432333233212212101 0 , 5432123443223421234234545321234223452344512343454344323452345634552345 4565453456565632334512343455234534453456455234443234562345456345645545 6566345545212342345342344543455344453212342345452344434553445332345345 5634554545543453455456556454334234434453444534545543456455623445412333 0 , 6543212354322332123223434432123322341233421232343235432343234523443234 3454343345454543223421232344323423342345344123334323453234345234534434 5455234434321232234231233432344233342321232234341233323442334243234234 4523443434443342344345445343223123323342433423434434345344532334321222 10 , 7654321265432243212322333543212432232122332122232126543234323432334323 2343234334343454322332122233322312233234233212225432344323234323423343 4344323333432123223122122323233322231432123223232122232333223154323323 3432333323354333233434334234322212232231543332343325434433443233232121 210 , 7654322354321243223212323543223321232232332231233235432344323423433234 2344344345344543212332231233212323233234343223235432343234234323434333 4454234334432232123232232332343123232432232123232232323431223254334323 3433433423343233343234434343212223212232432333323335434343443323332212 2110 , 5432234532123410123123434432345212341233422342343343223451234523442345 3454453456455621234501232344123423342345344123333234561234345234534434 5455234434212342345232343443454343453101231234341233323442334221234234 4523443434432342344345445343234123323342434523434434456344534444423444 12330 , 6543223443212321012112323432234211230122332231232234322342123412333234 2343342345344532123410121233212312231234233012224323452123234223423323 4344123323321232234121232332343232342210121123230122212331223132123223 3412332323332231233234334232123012212231323412323324345233443333332333 212210 , 6543345643234521234234545432345323452344523453454453212342234534551234 3455342345454532234512343455234534453345454234444334562345456345645534 5565345545323453456343454552344344454212342345452344434553445321234234 4523443434432343455345545454345234434343545634545445445344544344334454 2344120 , 7654334554323432123223434543234322341233432342343344321233223423442123 2344233234343443223421232344323423342234343123335433453234345334534423 4454234434432343345232343441233233343321232234341233323442334232123223 3412332323343232344234434343234123323232434523434334334233443233243343 32332110 , 6543456743234532345345656321234223453455612343455342101231123423440123 2344231234343432123422343455123434342234343334443223451234345234534423 4454234434323452345452344541233234344212342345452344423443434310123123 3412332323321232344234434343234345534233434534545344334233443233244343 344523120 }; int T; cin >> T; for (int t = 0; t < T; ++t) { int a, b; cin >> a >> b; vector<int> F, G; fact(a, F); fact(b, G); int i = IDX[F], j = IDX[G]; if (i < j) swap(i, j); cout << (DIST[i][j] - 0 ) << n ; } } }; int main() { ios_base::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr); TaskD solver; std::istream& in(std::cin); std::ostream& out(std::cout); solver.solve(in, out); return 0; }
#include <bits/stdc++.h> using namespace std; int n, m; vector<pair<int, int>> G[262144]; int d1[26][262144]; pair<int, int> d2[2][262144]; int vis[2][262144]; long long mod = 998244353ll; long long qpow(long long x, long long y) { long long a = x, ans = 1; while (y) { if (y & 1) ans = (ans * a) % mod; y >>= 1; a = (a * a) % mod; } return ans; } int main() { ios::sync_with_stdio(false); cin.tie(0); cin >> n >> m; for (int i = 0; i < m; i++) { int u, v; cin >> u >> v; G[u].push_back(make_pair(v, 0)); G[v].push_back(make_pair(u, 1)); } queue<pair<int, int>> q; q.push(make_pair(0, 1)); for (int i = 1; i <= n; i++) for (int j = 0; j <= 25; j++) d1[j][i] = -1; d1[0][1] = 0; while (!q.empty()) { pair<int, int> top = q.front(); q.pop(); int flips = top.first, u = top.second; for (auto i : G[u]) { int v = i.first, f = i.second; int flip = ((flips & 1) ^ f); if (flips + flip > 25) continue; if (d1[flips + flip][v] == -1) { d1[flips + flip][v] = d1[flips][u] + 1; q.push(make_pair(flips + flip, v)); } } } int ans = 2100000000; for (int j = 0; j <= 25; j++) if (d1[j][n] != -1) { ans = min(ans, (1 << j) - 1 + d1[j][n]); } if (ans < 2100000000) { cout << ans << endl; return 0; } priority_queue<pair<pair<int, int>, pair<int, int>>> q2; q2.push(make_pair(make_pair(0, 0), make_pair(0, 1))); for (int i = 1; i <= n; i++) for (int j = 0; j <= 1; j++) d2[j][i] = make_pair(2100000000, 2100000000); d2[0][1] = make_pair(0, 0); while (!q2.empty()) { pair<pair<int, int>, pair<int, int>> top = q2.top(); q2.pop(); int flipsbit = top.second.first, u = top.second.second; if (vis[flipsbit][u]) continue; vis[flipsbit][u] = 1; int flips = d2[flipsbit][u].first, dist = d2[flipsbit][u].second; for (auto i : G[u]) { int v = i.first, f = i.second; int flip = (flipsbit ^ f); int vflipsbit = ((flips + flip) & 1); pair<int, int> dv = make_pair(flips + flip, dist + 1); if (d2[vflipsbit][v] > dv) { d2[vflipsbit][v] = dv; q2.push(make_pair(make_pair(-dv.first, -dv.second), make_pair(vflipsbit, v))); } } } int flips = d2[0][n].first, dist = d2[0][n].second; if (d2[1][n].first < d2[0][n].first) { flips = d2[1][n].first, dist = d2[1][n].second; } long long ans2 = (qpow(2, flips) + dist - 1) % mod; cout << ans2 << endl; }
#include <bits/stdc++.h> using namespace std; int main() { int n, m; cin >> n >> m; long long ans = 0; for (int i = (0); i < (n); ++i) { long long t, T, x, cost; cin >> t >> T >> x >> cost; if (t >= T) { ans += cost + m * x; continue; } long long aux1 = cost; if (m > (T - t)) aux1 += m * x; long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1; aux2 *= cost; ans += min(aux1, aux2); } cout << ans << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int n, m; scanf( %d %d , &n, &m); vector<int> att, def, my(m); for (int i = 0; i < n; i++) { char a, b, c; int s; scanf( %c%c%c %d , &a, &b, &c, &s); if (a == A ) att.push_back(s); else def.push_back(s); } for (int i = 0; i < m; i++) { scanf( %d , &my[i]); } sort(att.begin(), att.end()); sort(def.begin(), def.end()); sort(my.begin(), my.end()); int res = 0; vector<int> used(m, 0); int pres = 0; int cm = 0; for (int i = 0; i < def.size(); i++) { while (my[cm] <= def[i] || used[cm]) { cm++; if (cm >= m) { pres = -1023456789; break; } } if (cm < m) { used[cm] = 1; } else break; } if (pres > -1023456789) { cm = 0; for (int i = 0; i < att.size(); i++) { while (my[cm] < att[i] || used[cm]) { cm++; if (cm >= m) { pres = -1023456789; break; } } if (cm < m) { used[cm] = 1; pres += my[cm] - att[i]; } else break; } } if (pres > -1023456789) { for (int i = 0; i < m; i++) if (!used[i]) pres += my[i]; } res = max(res, pres); for (int i = 1; i <= min(m, (int)(att.size())); i++) { int suc = 0; for (int j = 0; j < i; j++) { if (my[m - i + j] >= att[j]) { suc += my[m - i + j] - att[j]; } else suc = -1023456789; } res = max(res, suc); } printf( %d n , res); return 0; }
#include <bits/stdc++.h> using namespace std; int n; long long a[1010]; long long ans; long long vis[1010]; map<long long, long long> mp; void dfs(long long x, long long y, long long cnt) { ans = max(cnt, ans); if (mp[x + y]) { mp[x + y]--; dfs(y, x + y, cnt + 1); mp[x + y]++; } } int main() { while (cin >> n) { for (int i = 1; i <= n; i++) cin >> a[i]; for (int i = 1; i <= n; i++) mp[a[i]]++; long long kk = 0; for (int i = 1; i <= n; i++) if (a[i] == 0) kk++; ans = 0; for (int i = 0; i <= n; i++) vis[i] = 0; for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { if (i != j) { if (a[i] == 0 && a[j] == 0) { ans = max(ans, kk); continue; } mp[a[i]]--; mp[a[j]]--; dfs(a[i], a[j], 2); mp[a[i]]++, mp[a[j]]++; } } } cout << ans << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; int t[24], n; bool ok(int n) { set<int> u; int e = 0; for (int(i) = (0); (i) < (n); (i)++) for (int(j) = (0); (j) < (i); (j)++) { e++; u.insert(abs(t[i] + t[j])); } return (e == u.size()); } int main() { scanf( %d , &n); for (int(i) = (0); (i) < (n); (i)++) { t[i] = i; while (!ok(i + 1)) t[i]++; } for (int(i) = (0); (i) < (n); (i)++) { for (int(j) = (0); (j) < (n); (j)++) printf( %d , i == j ? 0 : abs(t[i] + t[j])); puts( ); } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int sum; cin >> sum; int a, b, c = -1; for (int i = 0; i * 7 <= sum; i++) { if ((sum - i * 7) % 4 == 0) { int j = (sum - i * 7) / 4; if (c == -1 || i + j < c) { c = i + j; a = j; b = i; } } } if (c == -1) cout << -1; else { for (int i = 0; i < a; i++) cout << 4 ; for (int j = 0; j < b; j++) cout << 7 ; cout << n ; } return 0; }
#include <bits/stdc++.h> using namespace std; long long n, m, l, r; vector<long long> A[200001]; set<pair<int, int> > se; void add(long long y) { for (auto b : A[y]) se.insert({b, y}); } void del(long long y) { for (auto b : A[y]) se.erase({b, y}); } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cin >> n >> m >> l >> r; for (long long i = 1; i <= 200000; ++i) for (long long j = i; j <= 200000; j += i) if (j <= 200000) A[j].push_back(i); long long L = m + 1; long long R = m; for (long long x = 1; x <= n; ++x) { long long L_ = (l + x - 1) / x; long long R_ = min(m, r / x); if (L_ > R_) goto L1; while (L > L_) add(--L); while (R > R_) del(R--); for (long long a : A[x]) { auto it = se.upper_bound({a + 1, 0}); if (it != se.end()) { long long b = it->first; long long y = it->second; if (x * b <= n * a) { cout << x << << y << << x * b / a << << y * a / b; goto L2; } } else goto L1; } L1: cout << -1; L2: cout << n ; } return 0; }
#include <bits/stdc++.h> int main() { static int vv[100][100], tt[100][100], kk[100]; int n, s, h, i, j, k, t, t_, d1, d2, cnt, lead; scanf( %d%d , &n, &s); for (i = 0; i < n; i++) { scanf( %d , &kk[i]); for (j = 0; j < kk[i]; j++) scanf( %d%d , &vv[i][j], &tt[i][j]); for (j = 1; j < kk[i]; j++) tt[i][j] += tt[i][j - 1]; } cnt = 0; for (h = 0; h < n; h++) for (i = 0; i < n; i++) if (h != i) for (lead = 1, d1 = d2 = 0, j = k = 0, t = 0; j < kk[h] && k < kk[i];) { if (tt[h][j] < tt[i][k]) t_ = tt[h][j]; else t_ = tt[i][k]; if (t != t_) { if ((d1 < d2 || (d1 == d2 && !lead)) && d1 + vv[h][j] * (t_ - t) > d2 + vv[i][k] * (t_ - t)) cnt++; d1 += vv[h][j] * (t_ - t); d2 += vv[i][k] * (t_ - t); if (d1 != d2) lead = d1 > d2; } if (tt[h][j] < tt[i][k]) j++; else k++; t = t_; } printf( %d n , cnt); return 0; }
#include <bits/stdc++.h> using namespace std; const double eps = 1e-8; long long ii = 1; vector<long long> prime; bitset<1000000> bs; void sieve() { bs.set(); bs[0] = bs[1] = 0; prime.push_back(2); for (long long i = 3; i <= 1000000; i += 2) { if (bs[i]) { for (long long j = i * i; j <= 1000000; j += i) bs[j] = 0; prime.push_back(i); } } } void solve() { long long n; cin >> n; long long l = 0; long long r = prime.size() - 1; long long p = sqrt(n); while (l <= r) { long long mid = (l + r) / 2; if (prime[mid] <= p) l = mid + 1; else r = mid - 1; } long long cn = l - 1; l = 0; r = prime.size() - 1; while (l <= r) { long long mid = (l + r) / 2; if (prime[mid] <= n) l = mid + 1; else r = mid - 1; } cout << r - cn + 1 << n ; } int32_t main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); long long TestCase; sieve(); cin >> TestCase; while (TestCase--) solve(); return 0; }
#include <bits/stdc++.h> using namespace std; struct Lem { int m, v, id; bool operator<(Lem b) const { return m < b.m || (m == b.m && v < b.v); } }; int n, k, h; Lem a[(100000 + 10)]; bool can(long double t) { int j = k; for (int i(n - 1), _l(0); i >= _l; --i) { if (j > 0 && (long double)j * h / a[i].v - t <= -1e-7) j--; } return j == 0; } void putAns(long double t) { int ans[(100000 + 10)]; int j = k; for (int i(n - 1), _l(0); i >= _l; --i) { if (j > 0 && (long double)j * h / a[i].v - t <= -1e-7) ans[--j] = a[i].id; } for (int i(0), _n(k - 1); i < _n; ++i) printf( %d , ans[i]); printf( %d n , (ans[k - 1])); } int main() { scanf( %d , &(n)), scanf( %d , &(k)), scanf( %d , &(h)); for (int i(0), _n(n); i < _n; ++i) scanf( %d , &(a[i].m)), a[i].id = i + 1; for (int i(0), _n(n); i < _n; ++i) scanf( %d , &(a[i].v)); sort(a, a + n); long double l = 0, r = 1e10; int cnt = 100; while (cnt--) { long double mid = (l + r) / 2.0; if (can(mid)) r = mid; else l = mid; } putAns(r); return 0; }
#include <bits/stdc++.h> using namespace std; int n, m, k, l, r; int rd() { int re = 0, f = 1; char c = getchar(); while ((c < 0 ) || (c > 9 )) { if (c == - ) f = -f; c = getchar(); } while ((c >= 0 ) && (c <= 9 )) { re = re * 10 + c - 0 ; c = getchar(); } return re * f; } int main() { cin >> m >> k; cin >> n; l = (n > k) ? (n - k) : 0; r = (m < n) ? m : n; cout << (r - l + 1) << n ; return 0; }
#include <bits/stdc++.h> using namespace std; const int MAXN = 130; int a[MAXN]; int main() { int N; cin >> N; for (int i = 1; i < (N + 1); ++i) cin >> a[i]; bool ok = 0; if ((a[N] & 1) == 0 || (a[1] & 1) == 0) ok = 0; else if (N & 1) ok = 1; if (ok) cout << Yes << endl; else cout << No << endl; }
#include <bits/stdc++.h> using namespace std; struct segment_tree { long long a[1 << 20][5]; int sz[1 << 20]; int N; void initi(int x) { N = 1; while (N < x) N <<= 1; } void pushup(int x) { int pos = x + N - 1; while (x > 0) { x = (x - 1) >> 1; sz[x] = sz[(x << 1) + 1] + sz[(x << 1) + 2]; for (int i = 0; i < 5; i++) a[x][i] = 0; for (int i = 0; i < 5; i++) { a[x][i] += a[(x << 1) + 1][i]; a[x][(i + sz[(x << 1) + 1]) % 5] += a[(x << 1) + 2][i]; } } } void ins(int x, int y) { int pos = x + N - 1; sz[pos]++; a[pos][0] = y; pushup(pos); } void del(int x) { int pos = x + N - 1; sz[pos]--; a[pos][0] = 0; pushup(pos); } } tr; int n; int s[100010]; vector<int> v; vector<int> vc; map<int, int> mp; int l; int main() { cin >> n; for (int i = 0; i < n; i++) { string t; int x; cin >> t; if (t == add ) { cin >> x; v.push_back(x); vc.push_back(x); } else if (t == del ) { cin >> x; v.push_back(-x); } else { v.push_back(0); } } sort(vc.begin(), vc.end()); tr.initi((int)vc.size()); for (int i = 0; i < vc.size(); i++) { mp[vc[i]] = i; } for (int i = 0; i < v.size(); i++) { if (!v[i]) { printf( %lld n , tr.a[0][2]); } else if (v[i] < 0) { tr.del(mp[-v[i]]); } else { tr.ins(mp[v[i]], v[i]); } } return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 100010; void answer(int u) { printf( ! %d n , u); fflush(stdout); } int ask(int u) { printf( ? %d n , u); fflush(stdout); int res; scanf( %d , &res); return res; } bool inside(int u, pair<int, int> v) { return ((u > v.first) ^ (u >= v.second)) == 1; } bool check(pair<int, int> u, pair<int, int> v) { if (inside(u.first, v) && inside(u.second, v)) { return 1; } if (inside(v.first, u) && inside(v.second, u)) { return 1; } if (inside(u.first, v) && inside(v.first, u)) { return 1; } if (inside(u.second, v) && inside(v.second, u)) { return 1; } return 0; } int main() { int n; scanf( %d , &n); if ((n / 2) % 2 != 0) { answer(-1); return 0; } int x = ask(1); int y = ask(1 + n / 2); if (x == y) { answer(1); return 0; } pair<int, int> u(x, y); pair<int, int> v(y, x); int low = 1, high = n / 2 + 1; while (high - low > 1) { int mid = (high + low) / 2; int foo = ask(mid); int bar = ask(mid + n / 2); if (foo == bar) { answer(mid); return 0; } pair<int, int> a(u.first, foo); pair<int, int> b(v.first, bar); if (check(a, b)) { high = mid; u = a; v = b; } else { low = mid; u = make_pair(foo, u.second); v = make_pair(bar, v.second); } } answer(low); return 0; }
#include <bits/stdc++.h> using namespace std; const int INFL = (int)1e9; const long long int INFLL = (long long int)1e18; const double INFD = numeric_limits<double>::infinity(); const double PI = 3.14159265358979323846; bool nearlyeq(double x, double y) { return abs(x - y) < 1e-9; } bool inrange(int x, int t) { return x >= 0 && x < t; } long long int rndf(double x) { return (long long int)(x + (x >= 0 ? 0.5 : -0.5)); } long long int floorsqrt(long long int x) { long long int m = (long long int)sqrt((double)x); return m + (m * m <= x ? 0 : -1); } long long int ceilsqrt(long long int x) { long long int m = (long long int)sqrt((double)x); return m + (x <= m * m ? 0 : 1); } long long int rnddiv(long long int a, long long int b) { return (a / b + (a % b * 2 >= b ? 1 : 0)); } long long int ceildiv(long long int a, long long int b) { return (a / b + (a % b == 0 ? 0 : 1)); } long long int gcd(long long int m, long long int n) { if (n == 0) return m; else return gcd(n, m % n); } long long int lcm(long long int m, long long int n) { return m * n / gcd(m, n); } class Max_Queue { private: stack<pair<long long int, long long int> > stk0, stk1; void rebuffer() { while (stk1.size()) { long long int x = stk1.top().first; long long int y = stk0.size() ? stk0.top().second : LLONG_MIN; stk0.push({x, max(x, y)}); stk1.pop(); } } public: void push(long long int x) { long long int y = stk1.size() ? stk1.top().second : LLONG_MIN; stk1.push({x, max(x, y)}); } long long int front() { if (stk0.empty()) rebuffer(); return stk0.top().first; } void pop() { if (stk0.empty()) rebuffer(); stk0.pop(); } size_t size() { return stk0.size() + stk1.size(); } void clear() { while (stk0.size()) stk0.pop(); while (stk1.size()) stk1.pop(); } long long int get_max() { long long int x = LLONG_MIN, y = LLONG_MIN; if (stk0.size()) x = stk0.top().second; if (stk1.size()) y = stk1.top().second; return max(x, y); } }; long long int dist(long long int s, long long int t, long long int n) { if (s <= t) return t - s; else return t + n - s; } int main() { int n, m; cin >> n >> m; vector<long long int> a(n, LLONG_MAX); vector<long long int> cnt(n, 0); for (int i = 0; i < (int)(m); i++) { long long int s, t; cin >> s >> t; s--; t--; a[s] = min(a[s], dist(s, t, n)); cnt[s]++; } vector<long long int> ans(n, 0); Max_Queue mq; for (int j = 0; j < (int)(n); j++) { long long int buf = -n; if (cnt[j] > 0) buf = dist(0, j, n) + (cnt[j] - 1) * n + a[j]; mq.push(buf); } for (int i = 0; i < (int)(n); i++) { ans[i] = mq.get_max() - i; long long int x = mq.front(); mq.pop(); mq.push(x + n); } for (int extra_i = 0; extra_i < (int)(ans.size()); extra_i++) { cout << ans[extra_i] << ; } cout << endl; ; }
#include <bits/stdc++.h> using namespace std; int main() { int t; cin >> t; while (t--) { int n; cin >> n; for (int i = 0; i < n; i++) { cout << 1 << ; } cout << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; void display(vector<int> v1) { for (long long int i = 0; i < v1.size(); i++) { cout << v1[i] << ; } cout << endl; } long long int dx[8] = {0, 1, 0, -1, 1, 1, -1, -1}; long long int dy[8] = {1, 0, -1, 0, 1, -1, 1, -1}; int n, dp[9000][2]; vector<int> v1[2]; int main() { ios_base::sync_with_stdio(false); cin.tie(0); cin >> n; memset(dp, -1, sizeof(dp)); for (int p = 0, k; p < 2; p += 1) { cin >> k; v1[p].resize(k); for (long long int i = 0; i < k; i++) { cin >> v1[p][i]; } } dp[1][0] = 0; dp[1][1] = 0; bool flag = true; while (flag) { flag = false; for (int i = n; i >= 2; i--) for (int p = 0; p < 2; p++) if (dp[i][p] == -1) { bool can = false; for (int x : v1[p]) { int nxt = (i + x) % n + n * !bool((i + x) % n); if (!dp[nxt][p ^ 1]) { dp[i][p] = 1; flag = true; can = true; break; } else if (dp[nxt][p ^ 1] == -1) can = true; } if (!can) dp[i][p] = 0, flag = true; } } for (int p = 0; p < 2; p++) { for (int i = 2; i <= n; i++) { if (dp[i][p] == -1) { cout << Loop ; } else if (dp[i][p] == 1) { cout << Win ; } else { cout << Lose ; } } cout << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; const int mod = 998244353; const int N = 5e5 + 5; long long l[N], r[N], x[N], d[N], s[N], pre[N], dp[N]; int n, m; inline long long solve(int u) { for (int i = 1; i <= n; i++) d[i] = s[i] = pre[i] = 0; for (int i = 1; i <= m; i++) { if (x[i] >> u & 1) { d[r[i] + 1]--; d[l[i]]++; } else { pre[r[i]] = max(pre[r[i]], l[i]); } } dp[0] = s[0] = 1; for (int i = 1; i <= n; i++) { d[i] += d[i - 1]; pre[i] = max(pre[i], pre[i - 1]); if (d[i] > 0) dp[i] = 0; else if (pre[i - 1] > 0) dp[i] = (s[i - 1] - s[pre[i - 1] - 1]) % mod; else dp[i] = s[i - 1]; s[i] = (s[i] + s[i - 1] + dp[i]) % mod; } return pre[n] == 0 ? s[n] % mod : (s[n] - s[pre[n] - 1]) % mod; } int main() { int k; scanf( %d%d%d , &n, &k, &m); for (int i = 1; i <= m; i++) scanf( %lld%lld%lld , &l[i], &r[i], &x[i]); long long ans = 1; for (int i = 0; i < k; i++) ans = ans * solve(i) % mod; printf( %lld n , (ans + mod) % mod); return 0; }
#include <bits/stdc++.h> using namespace std; long long mod = 1e9 + 7; int inf = 1e9; double eps = 1e-6; int main() { int n, k; cin >> n >> k; vector<int> a; for (int i = 0; i < n; i++) { int t; cin >> t; a.push_back(t); } if (k == 1) { int ans = a[0]; for (int i = 1; i < n; i++) { ans = min(ans, a[i]); } cout << ans; } else if (k > 2) { int ans = a[0]; for (int i = 1; i < n; i++) { ans = max(ans, a[i]); } cout << ans; } else { int ans = INT_MIN; multiset<int> p; multiset<int> q; p.insert(a[0]); for (int i = 1; i < n; i++) { q.insert(a[i]); } ans = max(ans, max(*q.begin(), *p.begin())); for (int i = 1; i < n - 1; i++) { p.insert(a[i]); q.erase(q.find(a[i])); ans = max(ans, max(*q.begin(), *p.begin())); } cout << ans; } return 0; }
#include <bits/stdc++.h> int a[100005] = {}; int p[100005] = {}; int mbuy[100005] = {}; int main() { std::ios_base::sync_with_stdio(false); std::cin.tie(NULL); std::cout.tie(NULL); int n, currmin = 1000000, buy = 0, last = 0; std::cin >> n; for (int i = 0; i < n; i++) std::cin >> a[i] >> p[i]; for (int i = 0; i < n; i++) { if (p[i] < currmin) { mbuy[last] = buy; currmin = p[i]; last = i; buy = 0; } buy += a[i]; } mbuy[last] = buy; long long int ans = 0; for (int i = 0; i < n; i++) { ans += mbuy[i] * p[i]; } std::cout << ans << n ; }
#include <bits/stdc++.h> using namespace std; const int N = 1e5; const int inf = 1e7; int tree[4 * N + 100], ans[2 * N + 100]; vector<int> R[N + 100], C[N + 100]; vector<pair<pair<int, int>, pair<int, int> > > qr[N + 100], qc[N + 100]; void update(int v, int tl, int tr, int idx, int val) { if (tl == tr) { tree[v] = val; } else { int tm = (tl + tr) / 2; if (idx <= tm) { update(v * 2, tl, tm, idx, val); } else { update(v * 2 + 1, tm + 1, tr, idx, val); } tree[v] = min(tree[v * 2], tree[v * 2 + 1]); } } int getMin(int v, int tl, int tr, int l, int r) { if (l > r) { return inf; } if (l == tl && r == tr) { return tree[v]; } int tm = (tl + tr) / 2; return min(getMin(v * 2, tl, tm, l, min(r, tm)), getMin(v * 2 + 1, tm + 1, tr, max(tm + 1, l), r)); } int main() { int n, m, k, q; scanf( %d%d%d%d , &n, &m, &k, &q); for (int i = 1; i <= k; i++) { int x, y; scanf( %d%d , &x, &y); R[y].push_back(x); C[x].push_back(y); } for (int i = 1; i <= q; i++) { int x1, y1, x2, y2; scanf( %d%d%d%d , &x1, &y1, &x2, &y2); qc[x2].push_back(make_pair(make_pair(y1, y2), make_pair(x1, i))); qr[y2].push_back(make_pair(make_pair(x1, x2), make_pair(y1, i))); } memset(tree, 0, sizeof tree); for (int i = 1; i <= n; i++) { for (auto it : C[i]) { update(1, 1, m, it, i); } for (auto it : qc[i]) { int mn = getMin(1, 1, m, it.first.first, it.first.second); if (mn >= it.second.first) { ans[it.second.second] = 1; } } } memset(tree, 0, sizeof tree); for (int i = 1; i <= m; i++) { for (auto it : R[i]) { update(1, 1, n, it, i); } for (auto it : qr[i]) { int mn = getMin(1, 1, n, it.first.first, it.first.second); if (mn >= it.second.first) { ans[it.second.second] = 1; } } } for (int i = 1; i <= q; i++) { if (ans[i]) { printf( YES n ); } else { printf( NO n ); } } }
#include <bits/stdc++.h> using namespace std; const int inf = 1 << 30; const long long INF = 1ll << 60; const double Inf = 1e20; const double eps = 1e-9; void gmax(int &a, int b) { a = (a > b ? a : b); } void gmin(int &a, int b) { a = (a < b ? a : b); } const int P = 1e9 + 7; const int maxn = 1000050; int n, m, x[5], y[5], sz[maxn], Ans; set<int> key; map<int, int> id, g; vector<int> adj[maxn]; bool vis[maxn]; int calc(int x) { int l = x, r = x, ret = 0; while (l <= n) { ret = (ret + min(r, n) - l + 1) % P; l = l << 1; r = r << 1 | 1; } return ret; } void dfs(int x, int t) { Ans = (Ans + 1ll * sz[x] * t) % P; vis[x] = true; for (auto p : adj[x]) if (!vis[p]) dfs(p, t); vis[x] = false; } int main() { scanf( %d%d , &n, &m); for (int i = 1; i <= m; ++i) { scanf( %d%d , &x[i], &y[i]); int t = x[i]; while (t) { key.insert(t); t >>= 1; } t = y[i]; while (t) { key.insert(t); t >>= 1; } } key.insert(1); for (auto p : key) { if (key.find(p << 1) == key.end() && key.find(p << 1 | 1) == key.end()) g[p] = calc(p); else { g[p] = 1; if (key.find(p << 1) == key.end() && (p << 1) <= n) g[p << 1] = calc(p << 1); if (key.find(p << 1 | 1) == key.end() && (p << 1 | 1) <= n) g[p << 1 | 1] = calc(p << 1 | 1); } } for (pair<int, int> p : g) { id[p.first] = ((int)(id).size()); sz[id[p.first]] = p.second; } for (pair<int, int> p : id) if (p.first != 1) { adj[id[p.first >> 1]].push_back(p.second); adj[p.second].push_back(id[p.first >> 1]); } for (int i = 1; i <= m; ++i) adj[id[x[i]]].push_back(id[y[i]]), adj[id[y[i]]].push_back(id[x[i]]); for (pair<int, int> p : id) dfs(p.second, sz[p.second]); printf( %d n , Ans); return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 5e5 + 7; const int MX = 1e9 + 7; const long long int INF = 1e18 + 9LL; int n, m, k; long long int value[N]; pair<long long int, pair<int, int> > edge[N]; int pt[N]; int rep[N]; int res = 0; int Find(int a) { if (rep[a] == a) return a; return rep[a] = Find(rep[a]); } bool Union(int a, int b) { a = Find(a), b = Find(b); if (a == b) return false; rep[a] = b; return true; } void solve(int from, int to) { int cnt = n; for (int i = from; i <= to; ++i) if (Union(edge[i].second.first, edge[i].second.second)) --cnt; res = (res + pt[cnt]) % MX; for (int i = from; i <= to; ++i) rep[edge[i].second.first] = edge[i].second.first, rep[edge[i].second.second] = edge[i].second.second; } int main() { scanf( %d %d %d , &n, &m, &k); for (int i = 1; i <= n; ++i) { scanf( %lld , &value[i]); rep[i] = i; } pt[0] = 1; for (int i = 1; i < N; ++i) pt[i] = (pt[i - 1] + pt[i - 1]) % MX; for (int i = 1; i <= m; ++i) { int u, v; scanf( %d %d , &u, &v); edge[i] = {value[u] ^ value[v], {u, v}}; } long long int ok = pt[k]; sort(edge + 1, edge + m + 1); for (int i = 1; i <= m; ++i) { int t = i; while (t < m && edge[t + 1].first == edge[t].first) ++t; solve(i, t); i = t; --ok; } res = (res + 1LL * pt[n] * (ok % MX)) % MX; printf( %d n , res); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int n, m; cin >> n >> m; string s; while (n--) cin >> s; bool wall = false; int segments = 0, i = 0; while (i < s.size()) { if (!wall && s[i] == B ) { segments++; wall = true; } else if (wall && s[i] == . ) { wall = false; } i++; } cout << segments << endl; return 0; }
#include <bits/stdc++.h> using namespace std; const long long INF = (long long)1e18; const int mod = (int)1e9 + 7; const int MAXN = (int)3e5 + 5; long long n; string s; bool vr[27]; int main() { ios_base::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr); cin >> s; for (int i = 0; i < s.length(); i++) { if (s[i] == a ) { vr[0] = 1; cout << Mike << n ; } else { bool cnt = 1; for (int j = 0; j < s[i] - a ; j++) { if (vr[j]) { cnt = 0; cout << Ann << n ; break; } } if (cnt) { vr[s[i] - a ] = true; cout << Mike << n ; } } } }
#include <bits/stdc++.h> using namespace std; const int nax = 200005; const int mod = 998244353; vector<int> graph[nax]; vector<int> degree(nax); vector<int> level(nax); vector<int> vis(nax); vector<int> parent(nax); vector<int> str[nax]; void dfs(int node, int l) { vis[node] = 1; level[node] = l + 1; str[l + 1].push_back(node); int d = 0; for (auto i : graph[node]) { if (vis[i] == 0) { dfs(i, l + 1); parent[i] = node; d++; } } degree[node] = d; return; } void solve() { int n; cin >> n; for (int i = 1; i < n + 1; i++) degree[i] = 0; for (int i = 1; i < n + 1; i++) level[i] = 0; for (int i = 1; i < n + 1; i++) parent[i] = 0; for (int i = 1; i < n + 1; i++) vis[i] = 0; for (int i = 1; i <= n; ++i) { graph[i].clear(); str[i].clear(); } for (int i = 0; i < n - 1; i++) { int a, b; cin >> a >> b; graph[a].push_back(b); graph[b].push_back(a); } dfs(1, 0); int ans = 0; for (int i = 1; i < n + 1; i++) if (degree[i] == 0) ans++; vector<int> rem(n + 1); for (int i = n; i >= 2; i--) { for (auto item : str[i]) { if (degree[item] == 0) continue; int check = 1; for (auto child : graph[item]) { if (level[child] > level[item] && rem[child] == 0) { check = check & (!degree[child]); } } if (check) { rem[item] = 1; degree[parent[item]]--; if (degree[parent[item]] > 0) ans--; } } } cout << ans << endl; return; } int main() { int T; T = 1; scanf( %d , &T); while (T--) { solve(); } }
#include <bits/stdc++.h> int main() { int t; scanf( %d , &t); while (t--) { int n; scanf( %d , &n); int flag; if (n & 1) { flag = 2; for (int i = 1, tmp; i <= n; i++) { scanf( %1d , &tmp); if ((i & 1) && (tmp & 1)) flag = 1; } printf( %d n , flag); } else { flag = 1; for (int i = 1, tmp; i <= n; i++) { scanf( %1d , &tmp); if (!(i & 1) && !(tmp & 1)) flag = 2; } printf( %d n , flag); } } }
#include <bits/stdc++.h> using namespace std; const string T = abacaba ; bool check(string s) { int cnt = 0; for (int i = 0; i < s.length() - 6; i++) if (s.substr(i, 7) == T) cnt++; return (cnt == 1); } int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); int t; cin >> t; while (t--) { int n, f = 0, q = 0, qq = 0, p = 0; cin >> n; string s; cin >> s; bool flag = true; for (int i = 0; i < n - 6; i++) { string ss = s; bool f = true; for (int j = 0; j < 7; j++) { if (s[i + j] != T[j] && s[i + j] != ? ) { f = false; break; } ss[i + j] = T[j]; } if (f && check(ss)) { flag = false; cout << Yes << endl; for (int i = 0; i < n; i++) cout << ((ss[i] == ? ) ? z : ss[i]); cout << endl; break; } } if (flag) cout << No n ; } return 0; }
#include <bits/stdc++.h> int main() { int i = 0, j = 0, l, k; char a[100], s[100], shift; scanf( %c , &shift); scanf( %s , a); l = strlen(a); for (k = 0; k < l; k++) { if (shift == R && i <= l && a[i] == w ) { a[i] = q ; i++; } else if (shift == R && i <= l && a[i] == e ) { a[i] = w ; i++; } else if (shift == L && j < l && a[j] == w ) { a[j] = e ; j++; } else if (shift == R && i <= l && a[i] == r ) { a[i] = e ; i++; } else if (shift == L && j < l && a[j] == e ) { a[j] = r ; j++; } else if (shift == R && i <= l && a[i] == t ) { a[i] = r ; i++; } else if (shift == L && j < l && a[j] == r ) { a[j] = t ; j++; } else if (shift == R && i <= l && a[i] == y ) { a[i] = t ; i++; } else if (shift == L && j < l && a[j] == t ) { a[j] = y ; j++; } else if (shift == R && i <= l && a[i] == u ) { a[i] = y ; i++; } else if (shift == L && j < l && a[j] == y ) { a[j] = u ; j++; } else if (shift == R && i <= l && a[i] == i ) { a[i] = u ; i++; } else if (shift == L && j < l && a[j] == u ) { a[j] = i ; j++; } else if (shift == R && i <= l && a[i] == o ) { a[i] = i ; i++; } else if (shift == L && j < l && a[j] == i ) { a[j] = o ; j++; } else if (shift == R && i <= l && a[i] == p ) { a[i] = o ; i++; } else if (shift == L && j < l && a[j] == o ) { a[j] = p ; j++; } else if (shift == R && i <= l && a[i] == s ) { a[i] = a ; i++; } else if (shift == L && j < l && a[j] == a ) { a[j] = s ; j++; } else if (shift == R && i <= l && a[i] == d ) { a[i] = s ; i++; } else if (shift == L && j < l && a[j] == s ) { a[j] = d ; j++; } else if (shift == R && i <= l && a[i] == f ) { a[i] = d ; i++; } else if (shift == L && j < l && a[j] == d ) { a[j] = f ; j++; } else if (shift == R && i <= l && a[i] == g ) { a[i] = f ; i++; } else if (shift == L && j < l && a[j] == f ) { a[j] = g ; j++; } else if (shift == R && i <= l && a[i] == h ) { a[i] = g ; i++; } else if (shift == L && j < l && a[j] == g ) { a[j] = h ; j++; } else if (shift == R && i <= l && a[i] == j ) { a[i] = h ; i++; } else if (shift == L && j < l && a[j] == h ) { a[j] = j ; j++; } else if (shift == R && i <= l && a[i] == k ) { a[i] = j ; i++; } else if (shift == L && j < l && a[j] == j ) { a[j] = k ; j++; } else if (shift == R && i <= l && a[i] == l ) { a[i] = k ; i++; } else if (shift == L && j < l && a[j] == k ) { a[j] = l ; j++; } else if (shift == R && i <= l && a[i] == ; ) { a[i] = l ; i++; } else if (shift == L && j < l && a[j] == l ) { a[j] = ; ; j++; } else if (shift == R && i <= l && a[i] == x ) { a[i] = z ; i++; } else if (shift == L && j < l && a[j] == z ) { a[j] = x ; j++; } else if (shift == R && i <= l && a[i] == c ) { a[i] = x ; i++; } else if (shift == L && j < l && a[j] == x ) { a[j] = c ; j++; } else if (shift == R && i <= l && a[i] == v ) { a[i] = c ; i++; } else if (shift == L && j < l && a[j] == c ) { a[j] = v ; j++; } else if (shift == R && i <= l && a[i] == b ) { a[i] = v ; i++; } else if (shift == L && j < l && a[j] == v ) { a[j] = b ; j++; } else if (shift == R && i <= l && a[i] == n ) { a[i] = b ; i++; } else if (shift == L && j < l && a[j] == b ) { a[j] = n ; j++; } else if (shift == R && i <= l && a[i] == m ) { a[i] = n ; i++; } else if (shift == L && j < l && a[j] == n ) { a[j] = m ; j++; } else if (shift == R && i <= l && a[i] == , ) { a[i] = m ; i++; } else if (shift == L && j < l && a[j] == m ) { a[j] = , ; j++; } else if (shift == R && i <= l && a[i] == . ) { a[i] = , ; i++; } else if (shift == L && j < l && a[j] == , ) { a[j] = . ; j++; } else if (shift == R && i <= l && a[i] == / ) { a[i] = . ; i++; } else if (shift == L && j < l && a[j] == . ) { a[j] = / ; j++; } else if (shift == L && j < l && a[j] == q ) { a[j] = w ; j++; } } printf( %s , a); return 0; }
#include <bits/stdc++.h> using namespace std; int cnt[26]; bool work() { char ch; while (isalpha(ch = getchar())) ++cnt[ch - a ]; int c = 0; for (int x = 0; x < 26; ++x) if (cnt[x] & 1) ++c; return c == 0 || (c & 1); } int main() { puts(work() ? First : Second ); }
#include <bits/stdc++.h> const int mod = 998244353; using namespace std; long long gcd(long long a, long long b) { if (a == 0) return b; return gcd(b % a, a); } long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); } long long power(long long x, long long y) { long long res = 1; while (y > 0) { if (y & 1) res = res * x; y = y >> 1; x = x * x; } return res; } long long pwr(long long a, long long b) { if (b == 0) { return 1; } long long p = pwr(a, b / 2); p = (p * p) % mod; if (b % 2 != 0) { p = (p * a) % mod; } return p; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); long long n, m; cin >> n >> m; string a, b; cin >> a >> b; reverse(a.begin(), a.end()); reverse(b.begin(), b.end()); while (m > n) { a += 0 ; n++; } while (n > m) { b += 0 ; m++; } reverse(a.begin(), a.end()); reverse(b.begin(), b.end()); long long ans = 0; long long settillnow = 0; for (long long i = 0; i < n; i++) { if (b[i] == 1 ) { settillnow++; } if (a[i] == 1 ) { long long c = pwr(2, n - 1 - i); c = (c * settillnow) % mod; ans += c; ans %= mod; } } cout << ans << endl; }
#include <bits/stdc++.h> using namespace std; signed main() { long long t, n, m, xa, ya, xb, yb; scanf( %lld , &t); while (t--) { scanf( %lld%lld%lld%lld%lld%lld , &n, &m, &xa, &ya, &xb, &yb); long long miny = min(ya, yb), minx = min(xa, xb), maxy = max(ya, yb), maxx = max(xa, xb); long long s = (m - (maxy - miny)) * (n - (maxx - minx)) * 2; long long lx = n - (maxx - minx), ly = m - (maxy - miny); long long len1 = max(0ll, lx - (maxx - minx + 1) + 1), len2 = max(0ll, ly - (maxy - miny + 1) + 1); printf( %lld n , max(0ll, n * m - (s - len1 * len2))); } return 0; }
#include <bits/stdc++.h> using namespace std; const long long int N = 5e3 + 7; vector<vector<long long int> > v(N); long long int cl[N]; void dfs(long long int s, long long int c) { if (cl[s] == -1 || cl[s] == c) return; cl[s] = c; for (auto it = v[s].begin(); it != v[s].end(); it++) { if (cl[*it] != c) dfs(*it, c); } } int main() { long long int n, m, s, i, j, k; cin >> n >> m >> s; memset(cl, 0, sizeof cl); for (i = 0; i < m; i++) { scanf( %lld%lld , &j, &k); v[j].push_back(k); } dfs(s, -1); for (i = 1; i <= n; i++) { if (!cl[i]) dfs(i, i); } set<long long int> se; for (i = 1; i <= n; i++) se.insert(cl[i]); cout << se.size() - 1 << endl; return 0; }
#include <bits/stdc++.h> using namespace std; const int maxn = 1e18; const int INF = 0x3f3f3f3f; int a[200010]; int dp[1000010]; int main() { int n, m, k; cin >> n >> m >> k; for (int i = 0; i < n; i++) { cin >> a[i]; dp[a[i]] = 1; } int t = 0, p = 0; int res = 0; for (int i = 1; i <= 1e6; i++) { t += dp[i]; if (i > m) t -= dp[i - m]; if (t == k) { dp[i] = 0; res++; t--; } } cout << res << endl; }
#include <bits/stdc++.h> using namespace std; long long n, W, B, X, dp[1001][10001], c[1001], cum[1001], cost[1001]; int main() { ios_base::sync_with_stdio(0); cin.tie(NULL); cin >> n >> W >> B >> X; for (int i = 0; i < n; i++) { cin >> c[i]; if (i == 0) cum[i] = c[i]; else cum[i] = cum[i - 1] + c[i]; } for (int i = 0; i < n; i++) cin >> cost[i]; for (int i = 0; i < 1001; i++) for (int j = 0; j < 10001; j++) dp[i][j] = 10000000000; dp[0][0] = W; for (int i = 0; i <= c[0]; i++) { if (W >= i * cost[0]) dp[0][i] = W - i * cost[0]; } for (int i = 1; i < n; i++) { for (int j = 0; j <= cum[i]; j++) { for (int k = 0; k <= min((long long)j, c[i]); k++) { if (dp[i - 1][j - k] != 10000000000) { if (min(dp[i - 1][j - k] + X, W + (j - k) * B) - k * cost[i] >= 0) { dp[i][j] = max((dp[i][j] == 10000000000 ? 0 : dp[i][j]), min(dp[i - 1][j - k] + X, W + (j - k) * B) - k * cost[i]); } } } } } for (int i = cum[n - 1]; i >= 0; i--) { if (dp[n - 1][i] != 10000000000) return cout << i, 0; } return 0; }
#include <bits/stdc++.h> using namespace std; long long int temp; vector<long long int> v; long long int n; int32_t main() { ios_base::sync_with_stdio(false); cin.tie(NULL); long long int t = 1; cin >> t; while (t--) { long long int n, strt, cnst, lwr = 0, upr = 0, t, l, r, pt = 0, flag = 0; cin >> n >> strt; lwr = strt, upr = strt; for (long long int i = 0; i < n; i++) { cin >> t >> l >> r; temp = t - pt; lwr = lwr - temp; upr = upr + temp; if (lwr <= l && upr >= r) lwr = l, upr = r; else if (lwr <= l && upr <= r && upr >= l) lwr = l; else if (lwr >= l && upr >= r && lwr <= r) upr = r; else if (lwr > l && upr < r) lwr = lwr, upr = upr; else flag = 1; pt = t; } if (flag == 1) cout << NO ; else cout << YES ; cout << n ; } }
#include <bits/stdc++.h> using namespace std; #pragma optimize( O3 ) const int N = 200005; int arr[N]; int fst[1000000], lst[1000000]; int minVal(int x, int y) { return (x < y) ? x : y; } int getMid(int s, int e) { return s + (e - s) / 2; } int RMQUtil(int *st, int ss, int se, int qs, int qe, int index) { if (qs <= ss && qe >= se) return st[index]; if (se < qs || ss > qe) return INT_MAX; int mid = getMid(ss, se); return minVal(RMQUtil(st, ss, mid, qs, qe, 2 * index + 1), RMQUtil(st, mid + 1, se, qs, qe, 2 * index + 2)); } int RMQ(int *st, int n, int qs, int qe) { if (qs < 0 || qe > n - 1 || qs > qe) { printf( Invalid Input ); return -1; } return RMQUtil(st, 0, n - 1, qs, qe, 0); } int constructSTUtil(int arr[], int ss, int se, int *st, int si) { if (ss == se) { st[si] = arr[ss]; return arr[ss]; } int mid = getMid(ss, se); st[si] = minVal(constructSTUtil(arr, ss, mid, st, si * 2 + 1), constructSTUtil(arr, mid + 1, se, st, si * 2 + 2)); return st[si]; } int *constructST(int arr[], int n) { int x = (int)(ceil(log2(n))); int max_size = 2 * (int)pow(2, x) - 1; int *st = new int[max_size]; constructSTUtil(arr, 0, n - 1, st, 0); return st; } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); int n, q; cin >> n >> q; for (int i = 1; i <= q; i++) fst[i] = lst[i] = -1; for (int i = 0; i < n; i++) { cin >> arr[i]; fst[arr[i]] = (fst[arr[i]] == -1 ? i : fst[arr[i]]); lst[arr[i]] = i; if (arr[i] == 0) arr[i] = INT_MAX; } int *st = constructST(arr, n); for (int i = 1; i <= q; i++) { if (fst[i] == -1) continue; int a = RMQ(st, n, fst[i], lst[i]); if (a < i) { cout << NO << ( n ); return 0; } } if (lst[q] == -1) { bool b = false; for (int i = 0; i < n; i++) { if (arr[i] == INT_MAX) { b = true, arr[i] = q; break; } } if (!b) { cout << NO << ( n ); return 0; } } vector<int> pos; for (int i = 0; i < n; i++) if (arr[i] != INT_MAX) pos.push_back(i); for (auto i : pos) { int s = i - 1, e = i + 1; bool poss = true; while (poss) { if (s >= 0 && arr[s] != INT_MAX) s = -1; if (e < n && arr[e] != INT_MAX) e = n; if (s >= 0) arr[s] = arr[i]; if (e < n) arr[e] = arr[i]; s--; e++; if (s < 0 && e >= n) poss = false; } } cout << YES << ( n ); for (int i = 0; i < n; i++) cout << arr[i] << ; cout << ( n ); }
#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; } int arr[100009], val[100009], n, k; int ok(int x) { long long res = 0; for (int i = 1; i <= n; i++) res += (arr[i] + x - 1) / x; return (res <= k); } long long f(int x, int y) { int a = x % y, aa = x / y + 1; int b = y - a, bb = x / y; return aa * 1LL * aa * a + bb * 1LL * bb * b; } set<pair<long long, int> > s; int main() { scanf( %d%d , &n, &k); for (int i = 1; i <= n; i++) { scanf( %d , &arr[i]); val[i] = 1; if (arr[i] > 1) s.insert(make_pair(f(arr[i], val[i] + 1) - f(arr[i], val[i]), i)); } for (int j = 0; j < k - n; j++) { pair<long long, int> nd = *s.begin(); s.erase(nd); int i = nd.second; val[i]++; if (val[i] < arr[i]) s.insert(make_pair(f(arr[i], val[i] + 1) - f(arr[i], val[i]), i)); } long long res = 0; for (int i = 1; i <= n; i++) res += f(arr[i], val[i]); printf( %lld n , res); return 0; }
#include <bits/stdc++.h> using namespace std; bool check[41][41]; int above[41][41]; int dp[41][41][41][41]; int main() { int n, m, q, s1, s2, s3, s4; char s[42]; scanf( %d %d %d , &n, &m, &q); for (int i = 1; i <= n; i++) { scanf( %s , s + 1); for (int j = 1; j <= m; j++) if (s[j] == 0 ) check[i][j] = 1, above[i][j] = above[i - 1][j] + 1; } for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) for (int k = i; k <= n; k++) for (int l = j; l <= m; l++) { dp[i][j][k][l] = dp[i][j][k - 1][l] + dp[i][j][k][l - 1] - dp[i][j][k - 1][l - 1]; int temp = min(k - i + 1, above[k][l]); for (int p = l; p >= j; p--) { temp = min(temp, above[k][p]); if (temp == 0) break; else dp[i][j][k][l] += temp; } } for (int i = 0; i < q; i++) scanf( %d %d %d %d , &s1, &s2, &s3, &s4), printf( %d n , dp[s1][s2][s3][s4]); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int t; cin >> t; while (t--) { long long n; cin >> n; set<int> used; for (int i = 2; i * i <= n; i++) { if (n % i == 0 && !used.count(i)) { used.insert(i); n /= i; break; } } for (int i = 2; i * i <= n; i++) { if (n % i == 0 && !used.count(i)) { used.insert(i); n /= i; break; } } if (used.size() < 2 || used.count(n) || n == 1) { cout << NO << endl; } else { cout << YES << n ; used.insert(n); for (auto it : used) cout << it << ; cout << endl; } } }
#include <bits/stdc++.h> using namespace std; int main() { int q; cin >> q; for (int i = 0; i < q; ++i) { int n; cin >> n; vector<int> a(n); for (int j = 0; j < n; ++j) { cin >> a[j]; --a[j]; } int pos = 0; while (pos < n) { int nxt = min_element(a.begin() + pos, a.end()) - a.begin(); int el = a[nxt]; a.erase(a.begin() + nxt); a.insert(a.begin() + pos, el); if (pos == nxt) pos = nxt + 1; else pos = nxt; } for (auto it : a) cout << it + 1 << ; cout << endl; } }
#include <bits/stdc++.h> using namespace std; int ar[1000000], br[1000000]; int main() { int t; cin >> t; while (t--) { int a, b, c, d; cin >> a >> b >> c; int ans = 0; if (a > 0) { ans++; a--; } if (b > 0) { ans++; b--; } if (c > 0) { ans++; c--; } ar[0] = a; ar[1] = b; ar[2] = c; sort(ar, ar + 3); if (ar[2] > 0 && ar[1] > 0) { ans++; ar[2]--; ar[1]--; } if (ar[2] > 0 && ar[0] > 0) { ans++; ar[2]--; ar[0]--; } if (ar[0] > 0 && ar[1] > 0) { ans++; ar[0]--; ar[1]--; } if (ar[2] > 0 && ar[1] > 0 && ar[0] > 0) { ans++; ar[2]--; ar[1]--; } cout << ans << endl; } }
#include<bits/stdc++.h> using namespace std; typedef long long ll; typedef pair<int,int> PII; const int maxn=111111,mod=998244353; const double PI=3.141592653589793; #define MP make_pair #define PB push_back #define lson o<<1,l,mid #define rson o<<1|1,mid+1,r #define FOR(i,a,b) for(int i=(a);i<=(b);i++) #define ROF(i,a,b) for(int i=(a);i>=(b);i--) #define MEM(x,v) memset(x,v,sizeof(x)) inline ll read(){ char ch=getchar();ll x=0,f=0; while(ch< 0 || ch> 9 ) f|=ch== - ,ch=getchar(); while(ch>= 0 && ch<= 9 ) x=x*10+ch- 0 ,ch=getchar(); return f?-x:x; } inline int qpow(int a,int b){ int ans=1; for(;b;b>>=1,a=1ll*a*a%mod) if(b&1) ans=1ll*ans*a%mod; return ans; } int n,at,id[maxn],a[maxn],cnt,ans[maxn][2],al; bool vis[maxn]; struct point{ int x,y,id; point operator-(const point &p)const{return (point){x-p.x,y-p.y,id};} double ang()const{return atan2(y,x);} bool operator<(const point &p)const{ if(p.id==at) return false; if(id==at) return true; return ang()<p.ang(); } }p[maxn],q[maxn]; inline void add(int x,int y){ ans[++al][0]=x; ans[al][1]=y; swap(a[x],a[y]); } void dfs(int x){ id[x]=cnt; if(!id[a[x]]) dfs(a[x]); } int main(){ n=read(); FOR(i,1,n) p[i].x=read(),p[i].y=read(),a[i]=read(),p[i].id=i; FOR(i,1,n) if(i!=a[i]){ if(!at || MP(p[i].x,p[i].y)<MP(p[at].x,p[at].y)) at=i; } if(!at) return puts( 0 ),0; FOR(i,1,n) if(!id[i]) cnt++,dfs(i); FOR(i,1,n) if(i!=at) p[i]=p[i]-p[at]; sort(p+1,p+n+1); if(p[n].ang()-p[2].ang()>PI){ ROF(i,n,2) if(p[i].ang()-p[2].ang()<PI){ q[1]=p[1]; FOR(j,i+1,n) q[j-i+1]=p[j]; FOR(j,2,i) q[n-i+j]=p[j]; break; } } else FOR(i,1,n) q[i]=p[i]; vis[id[q[2].id]]=true; FOR(i,3,n) if(!vis[id[q[i].id]]){ add(q[i].id,q[i-1].id); vis[id[q[i].id]]=true; } while(a[at]!=at) add(a[at],at); printf( %d n ,al); FOR(i,1,al) printf( %d %d n ,ans[i][0],ans[i][1]); }
#ifndef _MY #pragma GCC optimize( Ofast ) #pragma GCC optimize( unroll-loops ) #pragma GCC target( sse,sse2,sse3,ssse3,abm,mmx,tune=native ) #endif #include bits/stdc++.h #define int ll #define all(x) (x).begin(), (x).end() using namespace std; typedef long long ll; typedef long double ld; const int64_t INF = (int64_t)(2e18); const int inf = (int)(1e9 + 7); const int maxn = 500 * 1000 + 100; chrono::time_point<chrono::steady_clock> cl; double current_time() { return (double)(chrono::steady_clock::now() - cl).count() / 1e9; } //------------------------------------------// int32_t main(){ cl = chrono::steady_clock::now(); ios_base::sync_with_stdio(false); cout << fixed << setprecision(10); cin.tie(nullptr); #ifdef _MY freopen( VimProject/input.txt , r , stdin); freopen( VimProject/output.txt , w , stdout); #endif int n, k; cin >> n >> k; if (k == 1) { cout << 0; return 0; } vector<int> a(n); vector<int> sieve(1300000, 1); sieve[0] = sieve[1] = 0; vector<int> primes; map<int, vector<int>> ma; vector<pair<int, vector<int>>> gen; for (int i = 2; i < (int)sieve.size(); ++i){ if (sieve[i] == 0) continue; primes.push_back(i); for (int j = 2*i; j < (int)sieve.size(); j += i) sieve[j] = 0; } auto isprime = [&](int aa)->bool{ if (aa > ll(100000)*ll(100000)) return false; if (aa == 1) return false; for (int i = 2; i * i <= aa; ++i){ if (aa % i == 0) return false; } return true; }; for (auto& it : a) cin >> it; for (auto& it : a){ int cur = it; int rt = (int)sqrt((double)cur+0.1); if (rt*rt == cur && isprime(rt)) ma[rt].push_back(cur); else{ //cout << cur << endl; map<int, int> dec; for (auto& p : primes){ if (p*p > cur) break; while(cur % p == 0) { dec[p]++; cur /= p; } } if (isprime(cur)) { dec[cur]++; cur = 1; } //for (auto& it : dec) cout << it.first << << it.second << endl; if (cur != 1) continue; if (dec.size() == 0) continue; if (dec.size() == 1) ma[dec.begin()->first].push_back(it); if (dec.size() >= 2) { gen.push_back(make_pair(it, vector<int>())); for (auto& itt : dec) gen.back().second.push_back(itt.first); } } } //for (auto& it : ma) { // cout << it.first << : ; // for (auto& itt : it.second) cout << itt << ; // cout << endl; //} vector<int> bad; for (auto& it : ma){ sort(all(it.second)); if (it.second.size() == 1) bad.push_back(it.first); } for (auto& it : bad) ma.erase(it); vector<int> res; int cnt = 0; for (auto& it : ma) cnt += (int)it.second.size(); if (cnt <= k){ for (auto& it : ma){ for (auto& itt : it.second) res.push_back(itt); } for (auto& it : gen){ if ((int)res.size() == k) break; bool good = true; for (auto& itt : it.second) if (ma.count(itt) == 0) good = false; if (good) res.push_back(it.first); } if ((int)res.size() != k) cout << 0; else for (auto& it : res) cout << it << ; return 0; } else{ for (auto& it : ma) reverse(all(it.second)); if (k % 2 == 0){ for (auto& it : ma) { if ((int)res.size() == k) break; for (int i = 0; i < 2; ++i){ res.push_back(it.second.back()); it.second.pop_back(); } } for (auto& it : ma){ for (auto& itt : it.second){ if ((int)res.size() == k) break; res.push_back(itt); it.second.pop_back(); } } for (auto& it: res) cout << it << ; return 0; } else { int ok = -1; for (auto& it : ma){ if (ok != -1) break; if (it.second.size() > 2) ok = it.first; } if (ok != -1){ for (int i = 0; i < 3; ++i){ res.push_back(ma[ok].back()); ma[ok].pop_back(); } for (auto& it : ma){ if (it.first == ok) continue; if ((int)res.size() == k) break; for (int i = 0; i < 2; ++i){ res.push_back(it.second.back()); it.second.pop_back(); } } for (auto& it : ma){ for (auto& itt : it.second){ if ((int)res.size() == k) break; res.push_back(itt); } } for (auto& it : res) cout << it << ; } else{ pair<int, vector<int>> fine(-1, vector<int>()); for (auto& it : gen){ bool good = true; for (auto& itt : it.second) if (ma.count(itt) == 0) good = false; if (!good) continue; if (fine.first == -1 || fine.second.size() > it.second.size()) fine = it; } if (fine.first == -1) { cout << 0; return 0; } res.push_back(fine.first); set<int> used; for (auto& it : fine.second){ used.insert(it); for (int i = 0; i < 2; ++i){ res.push_back(ma[it].back()); ma[it].pop_back(); } } if ((int)res.size() > k){ cout << 0; return 0; } for (auto& it : ma){ if (used.count(it.first)) continue; if ((int)res.size() == k) break; for (int i = 0; i < 2; ++i){ res.push_back(it.second.back()); it.second.pop_back(); } } for (auto& it : ma){ for (auto& itt : it.second){ if ((int)res.size() == k) break; res.push_back(itt); } } for (auto& it : res) cout << it << ; } } } return 0; }
#include <bits/stdc++.h> using namespace std; const long long mod = 1000000007; const int inf = 1e9 + 10; const long long INF = 1e18; const long double EPS = 1e-10; const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1}; const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1}; template <class T> bool chmax(T &a, const T &b) { if (a < b) { a = b; return 1; } return 0; } template <class T> bool chmin(T &a, const T &b) { if (a > b) { a = b; return 1; } return 0; } int main() { ios::sync_with_stdio(0); cin.tie(0); cout << fixed << setprecision(25); int t; cin >> t; while (t--) { int n; string s; cin >> n >> s; string ans = ; int idx = 0; while (idx < n && s[idx] == 0 ) { ans += s[idx]; idx++; } s = s.substr(idx); reverse(s.begin(), s.end()); n = s.size(); string ans2 = ; idx = 0; while (idx < n && s[idx] == 1 ) { ans2 += s[idx]; idx++; } s = s.substr(idx); n = s.size(); if (n) ans += 0 ; ans += ans2; cout << ans << n ; } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int test; cin >> test; for (int t = 0; t < test; t++) { int n; cin >> n; int k = 2; while (n % (int)(pow(2, k) - 1) != 0) { k++; } int ans = n / (pow(2, k) - 1); cout << ans << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; const int Max = 1e5 + 5; struct node { int x, y; } Node1[Max], Node2[Max]; int hash1[Max], hash2[Max]; bool cmp(const node a, const node b) { if (a.y == b.y) return a.x < b.x; return a.y < b.y; } int main() { int n, m; while (scanf( %d%d , &n, &m) != EOF) { memset(hash1, 0, sizeof(hash1)); memset(hash2, 0, sizeof(hash2)); for (int i = 0; i < n; ++i) { scanf( %d%d , &Node1[i].x, &Node1[i].y); hash1[Node1[i].y]++; } for (int i = 0; i < m; ++i) { scanf( %d%d , &Node2[i].x, &Node2[i].y); hash2[Node2[i].y]++; } int coun = 0; for (int i = 0; i <= 1000; ++i) { if (hash1[i] > 0 && hash2[i] > 0) coun += (max(hash1[i], hash2[i]) - abs(hash1[i] - hash2[i])); } sort(Node1, Node1 + n, cmp); sort(Node2, Node2 + m, cmp); int i = 0, j = 0, cou = 0; while (i < n && j < m) { if (Node1[i].y == Node2[j].y) { if (Node1[i].x == Node2[j].x) { cou++; i++; j++; } else if (Node1[i].x < Node2[j].x) i++; else j++; } else if (Node1[i].y < Node2[j].y) i++; else j++; } printf( %d %d n , coun, cou); } return 0; }
#include <bits/stdc++.h> using namespace std; signed main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); int n, m; cin >> n >> m; string a, b; cin >> a >> b; if (a.size() - 1 > b.size()) { cout << NO n ; return 0; } if (a == b) { cout << YES n ; return 0; } int l = 0, r = m - 1; while (a[l] == b[l] && l < min(n, m)) l++; while (a.back() == b.back() && min(a.size(), b.size()) > l) a.pop_back(), b.pop_back(); if (a.size() - l == 1 && a.back() == * ) { cout << YES ; } else { cout << NO n ; } return 0; }
#include <bits/stdc++.h> using namespace std; const int MAXN = 100010; char str[MAXN]; int k1, k0, k2; int main() { scanf( %s , str); int n = strlen(str); k1 = k2 = k0 = 0; for (int i = 0; i < n; i++) { if (str[i] == 0 ) k0++; if (str[i] == 1 ) k1++; if (str[i] == ? ) k2++; } if (k2 + k0 >= (n - 2) / 2 + 2) cout << 00 << endl; if (k0 + k2 > (n - 2) / 2 && k1 + k2 > (n - 1) / 2) { if (str[n - 1] == 1 || (str[n - 1] == ? && k0 + k2 - 1 > (n - 2) / 2)) cout << 01 << endl; if (str[n - 1] == 0 || (str[n - 1] == ? && k1 + k2 - 1 > (n - 1) / 2)) cout << 10 << endl; } if (k2 + k1 >= (n - 1) / 2 + 2) cout << 11 << endl; return 0; }
#include <bits/stdc++.h> using namespace std; unsigned int dp[100010][400]; vector<int> nima[100010]; int a[100010], b[100010]; int n, m, s, e; int main() { while (cin >> n >> m >> s >> e) { memset(dp, -1, sizeof(dp)); for (int i = 0; i < n; ++i) { scanf( %d , &a[i]); } for (int i = 0; i < m; ++i) { scanf( %d , &b[i]); nima[b[i]].push_back(i + 1); } int ans = 0; int cnt = s / e; for (int i = 0; i < n; ++i) { dp[i][0] = 0; if (nima[a[i]].size()) dp[i][1] = nima[a[i]][0]; else dp[i][1] = -1; if (i == 0) continue; for (int j = 1; j <= cnt; ++j) { unsigned int now = -1; int w = a[i]; int last = dp[i - 1][j - 1]; now = upper_bound(nima[w].begin(), nima[w].end(), last) - nima[w].begin(); if (now == nima[w].size() || dp[i - 1][j - 1] == -1) { now = -1; } else { now = nima[w][now]; } dp[i][j] = min(dp[i - 1][j], now); } } for (int i = 0; i < n; ++i) for (int j = 0; j < cnt + 1; ++j) { if (dp[i][j] != -1) { if (i + dp[i][j] + 1 + j * e <= s) ans = max(ans, j); } } cout << ans << endl; return 0; } }
#include <bits/stdc++.h> using namespace std; struct compleks { double x, y; }; compleks operator*(compleks a, compleks b) { compleks c; c.x = a.x * b.x - a.y * b.y; c.y = a.x * b.y + a.y * b.x; return c; } compleks operator-(compleks a, compleks b) { compleks c; c.x = a.x - b.x, c.y = a.y - b.y; return c; } compleks operator+(compleks a, compleks b) { compleks c; c.x = a.x + b.x, c.y = a.y + b.y; return c; } int pos[65536 * 8]; void fft(compleks a[], int typ) { for (int i = 0; i < 65536 * 8; i++) if (pos[i] > i) swap(a[i], a[pos[i]]); for (int p = 1; p < 65536 * 8; p <<= 1) { int m = p + p; compleks wx; wx.x = cos(2 * 3.141592653589793 / m * typ), wx.y = sin(2 * 3.141592653589793 / m * typ); for (int i = 0; i < 65536 * 8; i += m) { compleks w; w.x = 1, w.y = 0; for (int j = 0; j < p; j++, w = w * wx) { compleks e = a[i + j], f = a[i + j + p] * w; a[i + j] = e + f, a[i + j + p] = e - f; } } } if (typ == -1) for (int i = 0; i < 65536 * 8; i++) a[i].x /= 65536 * 8, a[i].y /= 65536 * 8; } void getpos() { for (int i = 0; i < 65536 * 8; i++) pos[i] = (pos[i >> 1] >> 1) | ((i & 1) << 16 + 3 - 1); } int a[65536 * 8]; int n; int x; int pre[65536 * 8]; int cnt[65536 * 8]; compleks c[65536 * 8], d[65536 * 8]; int main() { cin >> n >> x; cnt[0]++; long long di = 0; for (int i = 1; i <= n; i++) scanf( %d , &a[i]), pre[i] = pre[i - 1] + (a[i] < x), di += cnt[pre[i]], cnt[pre[i]]++; getpos(); for (int i = 0; i <= n; i++) c[i].x = cnt[i], d[-i + 65536 * 8 / 2].x = cnt[i]; fft(c, 1); fft(d, 1); for (int i = 0; i < 65536 * 8; i++) c[i] = c[i] * d[i]; fft(c, -1); for (int i = 0; i <= n; i++) { long long ai = (long long)(c[i + 65536 * 8 / 2].x + 0.5); if (i == 0) ai = di; printf( %lld , ai); } return 0; }
#include <bits/stdc++.h> using namespace std; int n, m, deg[8012], ans1, ans2, ans3, cn = 0, mx[8012], X[8012]; bool w[8012][8012], vis[8012]; queue<int> q; long long ans = 0; int main() { scanf( %d , &n); m = n >> 2; int i, j, k, v, x, y, o; char ch; for (i = 0, getchar(); i < n; ++i, getchar()) for (x = j = 0; j < m; ++j) { ch = getchar(); v = (ch <= 9 ) ? (ch - 0 ) : (10 + ch - A ); for (k = 3; ~k; --k, ++x) if ((v >> k) & 1) { w[i][x] = 1; ++deg[x]; } } for (i = 0; i < n; i++) if (!deg[i]) q.push(i); while (!q.empty()) { vis[x = q.front()] = 1; q.pop(); ++cn; bool *p = w[x]; for (y = 0; y < n; y++) if (p[y]) { p[y] = 0; if (!(--deg[y])) q.push(y); } } ans = 1ll * cn * (cn - 1) / 2 * (1 + 614 * n) + 1ll * cn * (n - cn) * (1 + 614 * n); ans1 = (n - cn) * (n - cn - 1) / 2; for (x = 0; x < n; ++x) X[x] = x; for (x = 0; x < n; ++x) if (!vis[x]) { bool *p = w[x]; v = deg[x]; for (y = 0; y < n; ++y) if (p[y]) mx[y] = max(mx[y], v - deg[y] + 1), o = X[y], X[y] = p[o] ? x : o; } for (x = 0; x < n; ++x) ans2 += max(mx[x], deg[X[x]]); ans3 = (n - cn) * (n - cn - 1) - ans1 - ans2; ans += ans1 + ans2 * 2 + ans3 * 3; printf( %lld , ans); return 0; }
#include <bits/stdc++.h> using namespace std; long long i, n, m, k, x, z, c, a[500007], b[500007], ans, bad, total; int main() { cin >> n; for (i = 1; i <= n; i++) cin >> a[i]; set<long long> st; for (i = 1; i <= n; i++) { st.insert(a[i]); if (st.find(i) != st.end()) st.erase(i); if (st.size() == 0) c++; } cout << c << endl; return 0; }
#include <bits/stdc++.h> using namespace std; vector<long long int> primes; void Sieve(long long int n) { vector<bool> prime(n + 1, true); for (long long int p = 2; p * p <= n; p++) { if (prime[p] == true) { for (long long int i = p * p; i <= n; i += p) prime[i] = false; } } for (long long int p = 2; p <= n; p++) if (prime[p]) primes.push_back(p); } vector<bool> vis; long long int dia = 0; long long int dfs(long long int x, vector<vector<long long int>>& vec) { vis[x] = true; priority_queue<long long int> pq; for (auto it : vec[x]) { if (vis[it] != true) pq.push(dfs(it, vec) + 1); } if (pq.size() == 0) return 0; else if (pq.size() == 1) { long long int p = pq.top(); dia = max(dia, p); return p; } else { long long int p = pq.top(); pq.pop(); long long int y = pq.top(); dia = max(dia, p + y); return p; } } int main() { long long int t; cin >> t; while (t--) { long long int n, a, b, da, db; cin >> n; cin >> a; cin >> b; cin >> da; cin >> db; vector<vector<long long int>> vec(n + 1); for (long long int i = 0; i < n - 1; i++) { long long int x, y; cin >> x; cin >> y; vec[x].push_back(y); vec[y].push_back(x); } vector<bool> visited(n + 1, 0); queue<pair<long long int, long long int>> q; q.push({a, 0}); long long int dis = 0; while (!q.empty()) { pair<long long int, long long int> p = q.front(); q.pop(); if (p.first == b) { dis = p.second; break; } for (auto it : vec[p.first]) { if (!visited[it]) { q.push({it, p.second + 1}); visited[it] = true; } } } vis = vector<bool>(n + 1, 0); dfs(1, vec); cout << (2 * da >= min(dia, db) || dis <= da ? Alice : Bob ) << n ; dia = 0; } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int d; cin >> d; for (int i = 0; i < d; ++i) { long long n; cin >> n; if (n * (n - 4) >= 0) { cout << Y << fixed << setprecision(9) << (n + sqrt(n * n - 4 * n)) / 2 << << n - (n + sqrt(n * n - 4 * n)) / 2; cout << n ; } else { cout << N n ; } } }
#include <bits/stdc++.h> using namespace std; const int N = 2e5 + 10; char s[N], t[N]; int vis[N], vs[N]; int main() { cin >> s + 1 >> t + 1; int j = 1; int n = strlen(s + 1); int m = strlen(t + 1); for (int i = 1; i <= n && j <= m; ++i) { if (s[i] == t[j]) { vis[j] = i; ++j; } } j = m; for (int i = n; i >= 1 && j >= 1; --i) { if (s[i] == t[j]) { vs[j] = i; --j; } } int ans = max(vis[1] - 1, n - vis[m]); ans = max(ans, vs[1] - 1); ans = max(ans, n - vs[m]); for (int i = 1; i <= m; ++i) { ans = max(ans, vs[i] - vis[i - 1] - 1); } printf( %d n , ans); }
#include <bits/stdc++.h> using namespace std; long long modexpo(long long x, long long p) { long long res = 1; x = x % 1000000007; while (p) { if (p % 2) res = res * x; p >>= 1; x = x * x % 1000000007; res %= 1000000007; } return res; } struct compare { bool operator()(const pair<long long, long long> a, const pair<long long, long long> b) const { return a.first < b.first; } }; void __solve__(long long testCase) { long long x, y, ans = 2e18 + 7; cin >> y >> x; vector<long long> c(6); for (long long &e : c) cin >> e; for (long long i = 0; i < 3; i++) for (long long j = 0; j < 3; j++) { long long s = 0; if (i == j) { if (i == 0 && y == 0) if (x > 0) s += c[1] * x; else s += c[4] * -x; if (i == 1 && x == 0) if (y > 0) s += c[5] * y; else s += c[2] * -y; if (i == 2 && x == y) if (x > 0) s += c[0] * x; else s += c[3] * -x; if (s) ans = min(ans, s); continue; } else if (i != 2 && j != 2) { if (x > 0) s += c[1] * x; else s += c[4] * -x; if (y > 0) s += c[5] * y; else s += c[2] * -y; } else { if (j == 0 || i == 0) { if (y > 0) s += c[0] * y; else s += c[3] * -y; if (x - y > 0) s += c[1] * (x - y); else s += c[4] * -(x - y); } else { if (x > 0) s += c[0] * x; else s += c[3] * -x; if (y - x > 0) s += c[5] * (y - x); else s += c[2] * -(y - x); } } ans = min(ans, s); } cout << ans << n ; } int32_t main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); long long testCase = 1; cin >> testCase; for (long long tc = 1; tc <= testCase; tc++) { __solve__(tc); } }
#include <bits/stdc++.h> using namespace std; const int MAXN = 1 << 18; const long long INF = 0x3f3f3f3f; int n, k; bool fav[MAXN]; long long dp[MAXN][18][2][2]; inline void get_max(long long &, long long); int main() { scanf( %d%d , &n, &k); for (register int i = 1; i <= k; ++i) { int tmp; scanf( %d , &tmp); fav[tmp - 1] = true; } for (int k = 0; k < (1 << n); ++k) for (int t = 1; t <= n; ++t) for (int a = 0; a <= 1; ++a) for (int b = 0; b <= 1; ++b) dp[k][t][a][b] = -INF; for (int i = 0; i < (1 << n - 1); ++i) dp[i][1][fav[i << 1]][fav[i << 1 | 1]] = dp[i][1][fav[i << 1 | 1]][fav[i << 1]] = fav[i << 1] | fav[i << 1 | 1]; for (int t = 2; t <= n; ++t) for (int k = 0; k < (1 << n - t); ++k) { for (register int a = 0; a <= 1; ++a) for (register int b = 0; b <= 1; ++b) for (register int c = 0; c <= 1; ++c) for (register int d = 0; d <= 1; ++d) { get_max(dp[k][t][a][c], dp[k << 1][t - 1][a][b] + dp[k << 1 | 1][t - 1][c][d] + (a | c) + (b | d) + max(c | b, c | d)); get_max(dp[k][t][a][b], dp[k << 1][t - 1][a][b] + dp[k << 1 | 1][t - 1][c][d] + (a | c) + (b | d) + (b | c)); get_max(dp[k][t][a][d], dp[k << 1][t - 1][a][b] + dp[k << 1 | 1][t - 1][c][d] + (a | c) + (b | d) + (d | c)); get_max(dp[k][t][c][a], dp[k << 1][t - 1][a][b] + dp[k << 1 | 1][t - 1][c][d] + (a | c) + (b | d) + max(a | b, a | d)); get_max(dp[k][t][c][b], dp[k << 1][t - 1][a][b] + dp[k << 1 | 1][t - 1][c][d] + (a | c) + (b | d) + (a | b)); get_max(dp[k][t][c][d], dp[k << 1][t - 1][a][b] + dp[k << 1 | 1][t - 1][c][d] + (a | c) + (b | d) + (a | d)); } } printf( %lld n , max(max(dp[0][n][0][0], dp[0][n][0][1] + 1), max(dp[0][n][1][0] + 1, dp[0][n][1][1] + 1))); return 0; } inline void get_max(long long &a, long long b) { a = max(a, b); }
#include <bits/stdc++.h> using namespace std; const int MAXN = 3e5 + 7; const int inf = 1e9; char s[60][60]; char s1[60]; int l; int n; int num[60]; int check(char *s) { for (int i = 0; i < l; ++i) { int j; for (j = 0; j < l; ++j) { if (s1[j] != s[(j + i) % l]) break; } if (j >= l) return i; } return -1; } int main() { scanf( %d , &n); for (int i = 0; i < n; ++i) scanf( %s , s[i]); l = strlen(s[0]); int ans = inf; for (int i = 0; i < l; ++i) { int sum = 0; for (int j = 0; j < l; ++j) s1[j] = s[0][(j + i) % l]; for (int j = 0; j < n; ++j) { int t = check(s[j]); if (t == -1) { puts( -1 ); return 0; } sum += t; } ans = min(ans, sum); } printf( %d n , ans); return 0; }
#include <bits/stdc++.h> using namespace std; char s[2][100]; int fun(char a, char b) { if (a == 8 ) { if (b == [ ) return 1; else if (b == ( ) return -1; else return 0; } if (a == [ ) { if (b == 8 ) return -1; else if (b == ( ) return 1; else return 0; } if (a == ( ) { if (b == [ ) return -1; else if (b == 8 ) return 1; else return 0; } } int main() { while (cin >> s[0] >> s[1]) { int sum1 = 0, sum2 = 0; for (int i = 0; s[0][i]; i += 2) sum1 += fun(s[0][i], s[1][i]); if (sum1 > 0) printf( TEAM 1 WINS n ); else if (sum1 < 0) printf( TEAM 2 WINS n ); else printf( TIE n ); } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { char c1, c2; cin >> c1 >> c2; int n; cin >> n; if (n % 2 == 0) { cout << undefined << endl; } else { int n1, n2; switch (c1) { case ^ : n1 = 1; break; case > : n1 = 2; break; case v : n1 = 3; break; case < : n1 = 4; break; } switch (c2) { case ^ : n2 = 1; break; case > : n2 = 2; break; case v : n2 = 3; break; case < : n2 = 4; break; } n %= 4; if (n1 != 4) { if (n2 - n1 == 1) { if (n == 1) cout << cw << endl; else cout << ccw << endl; } else { if (n == 1) cout << ccw << endl; else cout << cw << endl; } } else { if (n1 - n2 == 3) { if (n == 1) cout << cw << endl; else cout << ccw << endl; } else { if (n == 1) cout << ccw << endl; else cout << cw << endl; } } } return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 2e5 + 5; const int MOD = 1000000007; long long power(long long a, long long n, long long m) { if (n == 0) return 1; long long p = power(a, n / 2, m); p = (p * p) % m; if (n % 2) p = (p * a) % m; return p; } int fact[N]; int ifact[N]; int main() { fact[0] = 1; for (int i = 1; i < N; i++) { fact[i] = ((long long)i * fact[i - 1]) % MOD; } ifact[N - 1] = power(fact[N - 1], MOD - 2, MOD); for (int i = N - 1; i >= 1; i--) { ifact[i - 1] = ((long long)i * ifact[i]) % MOD; } int n; scanf( %d , &n); int ans = fact[2 * n - 1]; ans = ((long long)ans * ifact[n]) % MOD; ans = ((long long)ans * ifact[n - 1]) % MOD; ans = (2 * ans) % MOD; ans = (ans - n + MOD) % MOD; printf( %d n , ans); return 0; }
#include <bits/stdc++.h> using namespace std; long long power(long long x, long long y) { long long res = 1; while (y > 0) { if (y & 1) res = (res * x); y = y >> 1; x = (x * x); } return res; } long long summ(long long a) { long long ans = 0; while (a) { ans += a % 10; a = a / 10; } return ans; } long long digit(int n) { int count = 0; while (n) { n = n / 10; count++; } return count; } long long sum(long long a) { long long ans = 0; while (a) { ans += (a % 10); a = a / 10; } return ans; } int main() { long long n; cin >> n; long long a = n; long long b; long long count = 0; while (a) { b = a % 10; a = a / 10; count++; } count--; b--; b = b * pow(10, count); long long c = 0; for (int i = 0; i < count; i++) { c = (10 * c) + 9; } b = b + c; c = n - b; cout << sum(b) + sum(c); return 0; }
#include <bits/stdc++.h> using namespace std; int n; long long k, x; long long a[200010]; int main() { int n; while (cin >> n >> k >> x) { int negative = 0; for (int i = 0; i < n; i++) { cin >> a[i]; if (a[i] < 0) ++negative; } if (negative % 2 == 0) { int minId = 0; for (int i = 1; i < n; i++) { if (abs(a[i]) < abs(a[minId])) minId = i; } long long num = abs(a[minId]) / x + 1; if (a[minId] >= 0) a[minId] -= min(num, k) * x; else a[minId] += min(num, k) * x; k = max(k - num, 0LL); } priority_queue<pair<long long, int>, vector<pair<long long, int> >, greater<pair<long long, int> > > que; for (int i = 0; i < n; i++) { que.push(make_pair(abs(a[i]), i)); } while (k--) { pair<int, int> cur = que.top(); que.pop(); int id = cur.second; if (a[id] >= 0) a[id] += x; else a[id] -= x; que.push(make_pair(abs(a[id]), id)); } for (int i = 0; i < n; i++) { if (i != n - 1) cout << a[i] << ; else cout << a[i] << endl; } } return 0; }
#include <bits/stdc++.h> using namespace std; template <class T> inline T sqr(T x) { return x * x; } const double PI = acos(-1.0); using namespace std; double dp[1005][1005]; int main(void) { int n, m; scanf( %d %d , &n, &m); if (n == 1) { puts( 1.0000000 ); return 0; } dp[0][0] = 1; for (int i = 1; i <= n - 1; i++) { dp[i][0] = dp[i - 1][0] * (1 - (m - 1.0) / (n * m - i)); for (int j = 1; j <= i && j <= m; j++) { dp[i][j] = dp[i - 1][j - 1] * (m - j + 0.0) / (n * m - i) + dp[i - 1][j] * (1 - (m - j - 1.0) / (n * m - i)); } } double ans = 0; for (int i = 0; i <= n - 1; i++) { ans += dp[n - 1][i] * (i + 1.0) / n; } printf( %.10lf n , ans); return 0; }
#include <bits/stdc++.h> int main() { int n; scanf( %d , &n); std::vector<std::pair<int, int> > a(n + 1); for (int p = 0; p < n; p++) { int x; scanf( %d , &x); a[p] = std::make_pair(x, p + 1); } sort(++a.begin(), a.end(), std::greater<std::pair<int, int> >()); int ind(0); std::vector<std::pair<int, int> > comm; for (int p = 0; p < n; p++) { for (int q = ind + 1; q <= ind + a[p].first; q++) { if (q >= n) { break; } comm.push_back(std::make_pair(a[p].second, a[q].second)); } ind += a[p].first; if (ind <= p) { break; } } if (comm.size() < n - 1) { puts( -1 ); } else { printf( %d n , n - 1); for (int p = 0; p < comm.size(); p++) { printf( %d %d n , comm[p].first, comm[p].second); } } return 0; }
#include <bits/stdc++.h> using namespace std; const long long N = 200005; int main() { long long n, z, x, y; cin >> n; z = (n * (n - 1) * (n - 2) * (n - 3) * (n - 4)) / 120; x = (z * (n - 5)) / 6; y = (x * (n - 6)) / 7; cout << z + x + y << n ; return 0; }
#include <bits/stdc++.h> using namespace std; using ll = int64_t; int main(int argc, char* argv[]) { std::ios::sync_with_stdio(false); cin.tie(nullptr); cout.precision(10); int n; cin >> n; auto g = vector<vector<ll>>(n, vector<ll>(n, 2000000000)); for (int i = 0; i < (n - 1); ++i) for (int j = 0; j < (n - i - 1); ++j) { int d; cin >> d; g[i][i + j + 1] = g[i + j + 1][i] = d; } auto min_adj = vector<ll>(n); for (int i = 0; i < (n); ++i) min_adj[i] = *min_element((g[i]).begin(), (g[i]).end()); auto smallest = *min_element((min_adj).begin(), (min_adj).end()); for (int i = 0; i < (n); ++i) for (int j = 0; j < (n); ++j) g[i][j] -= smallest; auto dist = move(min_adj); for (int i = 0; i < (n); ++i) dist[i] = 2 * (dist[i] - smallest); auto done = vector<char>(n, false); for (int _ = 0; _ < (n); ++_) { int v = -1; for (int i = 0; i < (n); ++i) if (!done[i] && (v == -1 || dist[i] < dist[v])) v = i; done[v] = true; for (int i = 0; i < (n); ++i) dist[i] = min(dist[i], dist[v] + g[i][v]); } for (int i = 0; i < (n); ++i) cout << dist[i] + (n - 1) * smallest << n ; return 0; }
#include <bits/stdc++.h> using namespace std; const int maxn = 1e5 + 99; int n, m, pre[maxn], nxt[maxn], vst[maxn], flag[maxn]; vector<int> G[maxn]; void del(int i) { nxt[pre[i]] = nxt[i]; if (~nxt[i]) pre[nxt[i]] = pre[i]; } void bfs(int id) { queue<int> que; que.push(id); while (!que.empty()) { int now = que.front(); que.pop(); for (int x : G[now]) if (!vst[x]) flag[x] = 1; for (int i = nxt[0]; ~i; i = nxt[i]) { if (flag[i]) flag[i] = 0; else vst[i] = 1, que.push(i), del(i); } } } int main() { ios::sync_with_stdio(false); cin.tie(nullptr); cin >> n >> m; for (int i = 0; i < m; i++) { int a, b; cin >> a >> b; G[a].push_back(b); G[b].push_back(a); } nxt[0] = 1; nxt[n] = -1; for (int i = 1; i < n; i++) pre[i + 1] = i, nxt[i] = i + 1; int ans = 0; for (int i = 1; i <= n; i++) { if (vst[i]) continue; ans++; bfs(i); } cout << ans - 1; return 0; }
#include <bits/stdc++.h> using namespace std; int t[200001]; int main() { memset(t, 0x3f, sizeof(t)); int n, k; string str; cin >> n >> k >> str; for (int x = 0; x < n; x++) if (str[x] == str[(x + 1) % n] || str[x] == str[(x - 1 + n) % n]) t[x] = 0; for (int x = 0; x < 2 * n; x++) t[x % n] = min(t[x % n], t[(x - 1 + n) % n] + 1); for (int x = 2 * n - 1; x >= 0; x--) t[x % n] = min(t[x % n], t[(x + 1) % n] + 1); for (int x = 0; x < n; x++) if (min(t[x], k) % 2) str[x] = 153 - str[x]; cout << str << endl; }
#include <bits/stdc++.h> using namespace std; int arr[1000000]; int main() { int n; while (scanf( %d , &n) != -1) { if (n == 1) { printf( 1 n ); continue; } if ((n & 1) && (n - 1) % 4) { printf( -1 n ); continue; } if (!(n & 1) && n % 4) { printf( -1 n ); continue; } for (int i = 1; i + i <= n; i += 2) arr[i] = i + 1, arr[i + 1] = n - i + 1, arr[n - i + 1] = n - i, arr[n - i] = i; if (n % 2) arr[n / 2 + 1] = n / 2 + 1; for (int i = 1; i <= n; ++i) printf(i > 1 ? %d : %d , arr[i]); printf( n ); } return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 2e5 + 5; const int INF = 1e9; const long long mod = 1e9 + 7; bool dp[105][55][2][2][205]; string s; int n, sz, realans; int offset(int x) { return x + 100; } bool f(int idx, int sisa, bool flip, bool arah, int ans) { if (idx == sz + 1) { if (sisa == 0) { realans = max(realans, abs(ans)); } return 1; } bool &res = dp[idx][sisa][flip][arah][offset(ans)]; if (res == 1) return res; char now = s[idx - 1]; if (flip) { if (now == F ) now = T ; else now = F ; } if (now == F ) { res = f(idx + 1, sisa, 0, arah, ans + (arah ? 1 : -1)); if (sisa) res = f(idx, sisa - 1, !flip, arah, ans); } else if (now == T ) { res = f(idx + 1, sisa, 0, !arah, ans); if (sisa) res = f(idx, sisa - 1, !flip, arah, ans); } return res = 1; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); cin >> s; cin >> n; sz = s.size(); f(1, n, 0, 1, 0); cout << realans << endl; }
#include <bits/stdc++.h> using namespace std; int n, a[500005], tot, s[500005], c[500005], tmp[1500005], num; priority_queue<int> q; bool cmp(int x, int y) { return x > y; } int main() { long long ans = 0; scanf( %d , &n); for (int i = 1; i <= n; i++) scanf( %d , &a[i]), ans += a[i]; sort(a + 1, a + n + 1, cmp); for (int i = 1; i <= n; i++) { if (i == 1 || a[i] != a[i - 1]) s[++tot] = a[i], c[tot]++; else c[tot]++; } int sum = 0; for (int i = 1; i <= tot; i++) { int pt = min((int)(sum - (int)2 * q.size()), c[i]); int rst = min(c[i] - pt, sum - pt); num = 0; for (int j = 1; j <= pt; j++) tmp[++num] = s[i]; for (int j = 1; j <= rst; j += 2) { int k = -q.top(); q.pop(); if (k < s[i]) { tmp[++num] = s[i]; if (j < rst) tmp[++num] = s[i]; } else { tmp[++num] = k; if (j < rst) tmp[++num] = 2 * s[i] - k; } } for (int j = 1; j <= num; j++) if (tmp[j] >= 0) q.push(-tmp[j]); sum += c[i]; } while (!q.empty()) ans += q.top(), q.pop(); printf( %lld n , ans); }