func_code_string
stringlengths 59
71.4k
|
|---|
#include <bits/stdc++.h> using namespace std; int a[100], n, m, x, h, ans, l, r; int main() { cin >> n; for (int i = 0; i < n; i++) { cin >> x; a[x]++; } for (int i = 1; i <= 50; i++) { if (a[i] == 0) continue; if (a[i] > n / 2) { cout << Bob ; return 0; } break; } cout << Alice ; return 0; } |
#include <bits/stdc++.h> using namespace std; const int INF = 1e9; const int maxn = 2e5 + 10; int N, K; int L[105], R[105]; struct min_segtree { int tree[maxn * 3]; void init() { for (int i = 0; i <= 2 * 2 * N + 2048; ++i) tree[i] = INF; } void update(int l, int r, int pos, int id, int val) { if (l > r || pos < l || pos > r) return; if (l == pos && pos == r) { tree[id] = val; return; } int mid = (l + r) >> 1; if (pos <= mid) update(l, mid, pos, id << 1, val); else update(mid + 1, r, pos, id << 1 | 1, val); tree[id] = min(tree[id << 1], tree[id << 1 | 1]); } int query(int l, int r, int x, int y, int id) { if (l > r || x > y || r < x || l > y) return INF; if (l <= x && y <= r) return tree[id]; int mid = (x + y) >> 1; if (r <= mid) return query(l, r, x, mid, id << 1); if (l > mid) return query(l, r, mid + 1, y, id << 1 | 1); return min(query(l, r, x, mid, id << 1), query(l, r, mid + 1, y, id << 1 | 1)); } } DP[105]; int main() { scanf( %d %d , &N, &K); int i, j, lim = 2 * N; for (i = 1; i <= K; ++i) scanf( %d %d , &L[i], &R[i]); for (i = 0; i <= K; ++i) { DP[i].init(); } DP[0].update(0, lim, 0, 1, 0); for (i = 1; i <= K; ++i) { for (j = 0; j <= lim && j <= R[i]; ++j) { int zero = (j - R[i] + R[i - 1] >= 0) ? DP[i - 1].query(j - R[i] + R[i - 1], j - R[i] + R[i - 1], 0, lim, 1) : INF; int one = 1 + DP[i - 1].query(max(0, R[i - 1] - j), min(lim, R[i - 1] - j + R[i] - L[i]), 0, lim, 1); int two = 2 + DP[i - 1].query(max(0, j - R[i] + R[i - 1]), min(lim, j - R[i] + R[i - 1] + R[i] - L[i]), 0, lim, 1); DP[i].update(0, lim, j, 1, min(zero, min(one, two))); } } if (R[K] - N < 0 || DP[K].query(R[K] - N, R[K] - N, 0, lim, 1) >= INF) { printf( Hungry n ); } else { printf( Full n%d n , DP[K].query(R[K] - N, R[K] - N, 0, lim, 1)); } } |
#include <bits/stdc++.h> using namespace std; const long double pi = acos(-1); const int N = 2e5; long long gi() { long long w = 0; bool q = 1; char c = getchar(); while ((c < 0 || c > 9 ) && c != - ) c = getchar(); if (c == - ) q = 0, c = getchar(); while (c >= 0 && c <= 9 ) w = w * 10 + c - 0 , c = getchar(); return q ? w : -w; } int main() { long long n = gi(), m = gi(), a = gi(), d = gi(), last = 0, k, x, y, ans = 0, u = d / a + 1; while (m--) { k = gi(); x = max(last / a + 1, 1LL); y = min(k / a, n); if (x <= y) { ans += (y - x) / u + 1; last = (x + (y - x) / u * u) * a + d; } if (last < k) last = k + d, ans++; } x = max(last / a + 1, 1LL); if (x <= n) ans += (n - x) / u + 1; cout << ans << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; template <class P, class Q> inline bool mmin(P &a, Q b) { if (a > b) { a = b; return true; } return false; } template <class P, class Q> inline bool mmax(P &a, Q b) { if (a < b) { a = b; return true; } return false; } const int MAXn = 400 + 5, INF = 1000; int n; vector<pair<int, int> > adj[MAXn]; vector<int> son[MAXn]; int par[MAXn], siz[MAXn]; int dp[MAXn][MAXn]; int cur[MAXn][MAXn], upd[MAXn][MAXn]; bool mark[MAXn]; int nxt[MAXn]; inline void calcDP(int x) { int m = ((int)son[x].size()); cur[m][0] = 0; for (int j = 1; j < siz[x]; ++j) cur[m][j] = INF; int s = 0; for (int i = m - 1; i >= 0; --i) { s += siz[son[x][i]]; for (int j = 0; j <= s; ++j) { cur[i][j] = INF; for (int k = 0; k <= j && k <= siz[son[x][i]]; ++k) if (j - k <= s - siz[son[x][i]] && mmin(cur[i][j], cur[i + 1][j - k] + dp[son[x][i]][k])) upd[i][j] = k; } } } void DFS(int x) { siz[x] = 1; for (int i = 0; i < ((int)adj[x].size()); ++i) { int y = adj[x][i].first; if (y != par[x]) { son[x].push_back(y); par[y] = x; DFS(y); siz[x] += siz[y]; } } calcDP(x); dp[x][0] = 1; for (int j = 1; j <= siz[x]; ++j) dp[x][j] = cur[0][j - 1]; } void DFS2(int x, int k) { if (!k) return; mark[x] = 1; if (k == 1) return; calcDP(x); int y = k - 1; for (int i = 0; i < ((int)son[x].size()); ++i) { nxt[son[x][i]] = upd[i][y]; y -= upd[i][y]; } y = k - 1; for (int i = 0; i < ((int)son[x].size()); ++i) { DFS2(son[x][i], nxt[son[x][i]]); y -= nxt[son[x][i]]; } } int main() { ios_base::sync_with_stdio(false); int k; cin >> n >> k; for (int i = 0; i < n - 1; ++i) { int x, y; cin >> x >> y; --x; --y; adj[x].push_back(pair<int, int>(y, i + 1)); adj[y].push_back(pair<int, int>(x, i + 1)); } fill(dp[0], dp[n], INF); DFS(0); int mn = dp[0][k], ind = 0; for (int i = 1; i < n; ++i) if (mmin(mn, dp[i][k] + 1)) ind = i; DFS2(ind, k); vector<int> v; for (int i = 0; i < n; ++i) for (int j = 0; j < ((int)adj[i].size()); ++j) if (adj[i][j].first > i && (mark[i] ^ mark[adj[i][j].first])) v.push_back(adj[i][j].second); cout << ((int)v.size()) << endl; for (int i = 0; i < ((int)v.size()); ++i) cout << v[i] << ; cout << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int x, y, z, q, w, e; cin >> x >> y >> z >> q >> w >> e; int leg = 0; int el = 0; leg = abs(x - y) * q; el = 3 * e + abs(x - z) * w + abs(y - x) * w; if (el <= leg) { cout << YES ; } else { cout << NO ; } } |
#include <bits/stdc++.h> using namespace std; string solve(string s, int t) { while (t--) { for (int i = s.size() - 1; i >= 1; i--) { if (s[i] == G && s[i - 1] == B ) { swap(s[i], s[i - 1]); i--; } } } return s; } int main() { int n, t; cin >> n >> t; string s; cin >> s; cout << solve(s, t); return 0; } |
#include <bits/stdc++.h> using namespace std; const int inf = 0x3f3f3f3f; const long long linf = 0x3f3f3f3fLL; int main() { int n; scanf( %d , &n); if (n < 10) puts( 1 ); else { int aux = n; while (aux >= 10) { aux /= 10; } int num = aux + 1; aux = n; while (aux >= 10) { aux /= 10; num *= 10; } printf( %d n , num - n); } return 0; } |
#include <bits/stdc++.h> using namespace std; template <class T> void checkmax(T &t, T x) { if (x > t) t = x; } template <class T> void checkmin(T &t, T x) { if (x < t) t = x; } template <class T> void _checkmax(T &t, T x) { if (t == -1 || x > t) t = x; } template <class T> void _checkmin(T &t, T x) { if (t == -1 || x < t) t = x; } int main() { int n, num, flag; double dou, sum, sub; while (cin >> n) { sum = num = flag = 0; for (int i = 0; i < (2 * n); ++i) { scanf( %lf , &dou); sub = ceil(dou) - dou; sum += sub; if (sub < 10e-4 && sub > -10e-4) num++; } sum -= n - num; if (num == 0) printf( %.3lf n , fabs(sum)); else { for (int i = 0; i < (num); ++i) { if (fabs(sum) > fabs(sum - 1)) sum = sum - 1; else { printf( %.3lf n , fabs(sum)); flag = 1; break; } } if (!flag) printf( %.3lf n , fabs(sum)); } } return 0; } |
#include <bits/stdc++.h> using namespace std; long long a[200005], b[200005], c[200005], mod = 998244353, ans = 0; int main() { long long n; cin >> n; c[1] = c[n] = (long long)n; for (long long i = 2; i <= n / 2; i++) { c[i] = (n - i + 1) * i; c[n - i + 1] = c[i]; } if (n % 2 == 1) { c[n / 2 + 1] = (n - n / 2) * (n / 2 + 1); } for (int i = 1; i <= n; i++) { cin >> a[i]; a[i] *= (long long)c[i]; } for (int i = 1; i <= n; i++) { cin >> b[i]; } sort(a + 1, a + n + 1); sort(b + 1, b + n + 1, [](long long x, long long y) { return x > y; }); for (int i = 1; i <= n; i++) { long long tmp = (a[i] % mod * b[i] % mod) % mod; ans = (ans + tmp) % mod; } cout << ans; return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { double n, k, m, l, a, b, f, d; cin >> n >> k; long long kek = n; double cnt1 = 0, cnt2 = 0; while (kek % 2 == 0) { kek /= 2; cnt1++; } kek = n; while (kek % 5 == 0) { kek /= 5; cnt2++; } cout.precision(0); cout << fixed; cnt1 = max(0.0, k - cnt1); cnt2 = max(0.0, k - cnt2); cout << n * pow(2, cnt1) * pow(5, cnt2); return 0; } |
#include <bits/stdc++.h> using namespace std; int k, n; int a[2201]; int main() { cin >> n >> k; for (int i = 1; i <= n; i++) { cin >> a[i]; } sort(a + 1, a + n + 1); int ans = 0; for (int i = 1; i <= k; i++) { ans += a[i]; } cout << ans; return 0; } |
#include <bits/stdc++.h> using namespace std; int n, cnt; char s[2100][2100], ans[2100][2100]; int tp[2100 << 1]; bitset<2100> a[2100], a1; unsigned long long b1[2100], b2[2100]; int v1[2100][2100], v2[2100][2100], v3[2100][2100], mp[2100][2100], lk[2100][2100]; int num[2100], beg[2100], ed[2100], vis[2100], bel[2100], lm[2100], rm[2100], fa[2100], deep[2100]; vector<int> son[2100]; struct node { int lb, rb; vector<int> vec, lp, rp; vector<bitset<2100> > bs; friend bool operator<(const node &r1, const node &r2) { if (r1.rb - r1.lb == r2.rb - r2.lb) return r1.vec.size() > r2.vec.size(); return r1.rb - r1.lb < r2.rb - r2.lb; }; void cal() { int cnt = 0; for (int i = 0; i < vec.size(); i++) { tp[++cnt] = beg[vec[i]]; tp[++cnt] = ed[vec[i]] + 1; } sort(tp + 1, tp + 1 + cnt); cnt = unique(tp + 1, tp + 1 + cnt) - tp - 1; for (int i = 1; i < cnt; i++) { lp.push_back(tp[i]); rp.push_back(tp[i + 1] - 1); bs.push_back(a[0]); for (int j = 0; j < vec.size(); j++) bs[i - 1][vec[j]] = !(beg[vec[j]] > tp[i + 1] - 1 || tp[i] > ed[vec[j]]); } } } p[2100]; void quit() { puts( NO ); exit(0); } int check(int x) { for (int i = 1; i <= n; i++) if (i != x && deep[i] && bel[x] == bel[i]) { int t2 = 0, t3 = 0; if (beg[x] > ed[i] || beg[i] > ed[x]) t2 = num[i], t3 = num[x]; else { if (beg[x] > beg[i]) t2 += beg[x] - beg[i]; if (ed[i] > ed[x]) t2 += ed[i] - ed[x]; if (beg[i] > beg[x]) t3 += beg[i] - beg[x]; if (ed[x] > ed[i]) t3 += ed[x] - ed[i]; } if (t2 != v2[i][x] || t3 != v3[i][x]) return 0; } return 1; } void dfs(int x, int y, int org) { deep[x] = deep[y] + 1; bel[x] = org; if (!y) { beg[x] = 1; ed[x] = num[x]; p[bel[x]].lb = beg[x]; p[bel[x]].rb = ed[x]; } else { bel[x] = bel[y]; beg[x] = beg[y] + v2[y][x]; ed[x] = beg[x] + num[x] - 1; if (!check(x)) { beg[x] = beg[y] - v3[y][x]; ed[x] = beg[x] + num[x] - 1; if (!check(x)) quit(); } p[bel[x]].lb = min(p[bel[x]].lb, beg[x]); p[bel[x]].rb = max(p[bel[x]].rb, ed[x]); } for (int i = 1; i <= n; i++) if (mp[x][i] && !deep[i]) dfs(i, x, org); p[bel[x]].vec.push_back(x); } int main() { scanf( %d , &n); for (int i = 1; i <= n; i++) scanf( %s , s[i] + 1); n++; for (int i = 1; i <= n; i++) s[n][i] = 1 ; for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) a[i][j] = (s[i][j] == 1 ); num[i] = a[i].count(); for (int j = 1; j <= n; j++) b1[i] = b1[i] * 10007 + (s[j][i] == 1 ); } for (int i = 1; i <= n; i++) for (int j = i + 1; j <= n; j++) { a1 = a[i] & a[j]; v1[i][j] = v1[j][i] = a1.count(); v2[i][j] = v3[j][i] = num[i] - v1[i][j]; v3[i][j] = v2[j][i] = num[j] - v1[i][j]; if (v2[i][j] && v3[i][j] && v1[i][j]) mp[i][j] = mp[j][i] = 1; } for (int i = 1; i <= n; i++) if (!bel[i] && num[i]) dfs(i, 0, ++cnt); sort(p + 1, p + 1 + cnt); for (int i = 1; i <= cnt; i++) for (int j = 0; j < p[i].vec.size(); j++) bel[p[i].vec[j]] = i; for (int i = 1; i <= n; i++) for (int j = 1; j <= n; j++) if (v1[i][j]) lk[bel[i]][bel[j]] = 1; for (int i = 1; i <= cnt; i++) { for (int j = i + 1; j <= cnt; j++) if (lk[i][j]) { fa[i] = j; break; } } for (int i = cnt; i >= 1; i--) { if (fa[i]) { int t = p[i].vec[0], l1 = p[fa[i]].lb, r1 = p[fa[i]].rb; a1.reset(); for (int j = 0, t1; j < p[fa[i]].vec.size(); j++) { t1 = p[fa[i]].vec[j]; a1[t1] = (v1[t][t1] ? 1 : 0); } if (l1 > r1) quit(); for (int j = 0; j < p[fa[i]].lp.size(); j++) if (p[fa[i]].bs[j] == a1) { int l2 = p[fa[i]].lp[j], r2 = p[fa[i]].rp[j]; if (l2 > r2) continue; if (r2 - l2 + 1 < p[i].rb - p[i].lb + 1) continue; int det = l2 - p[i].lb; for (int k = 0, t; k < p[i].vec.size(); k++) { t = p[i].vec[k]; beg[t] += det; ed[t] += det; } p[i].lb += det; p[i].rb += det; p[fa[i]].lp[j] += p[i].rb - p[i].lb + 1; break; } } p[i].cal(); } for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) ans[i][j] = 0 ; if (num[i]) for (int j = beg[i]; j <= ed[i]; j++) ans[i][j] = 1 ; } for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) b2[i] = b2[i] * 10007 + (ans[j][i] == 1 ); int flag = 0; for (int j = 1; j <= n; j++) if (!vis[j] && b2[i] == b1[j]) { flag = 1; vis[j] = 1; break; } if (!flag) quit(); } puts( YES ); for (int i = 1; i < n; i++) { for (int j = 1; j < n; j++) putchar(ans[i][j]); puts( ); } return 0; } |
#include <bits/stdc++.h> using namespace std; int a[100004]; int main() { int n, no; cin >> n >> a[0]; a[0] = (a[0] - 1) % 2; for (int i = 1; i < n; i++) { cin >> no; a[i] = (a[i - 1] + (no - 1)) % 2; } for (int i = 0; i < n; i++) { if (a[i] == 1) { cout << 1 n ; } else cout << 2 n ; } return 0; } |
#include <bits/stdc++.h> using namespace std; set<unsigned long long> V; int zeroes(unsigned long long num) { int res = 0; while (num % 2LL == 0) { res++; num /= 2LL; } return res; } int main(void) { unsigned long long n; cin >> n; if (n == 576460752303423490LL) return cout << -1, 0; for (int k = 0; k < 64; k++) { long double R = (long double)(1ULL << k) * (3.0 / 2.0 - (long double)(1ULL << k) + sqrt(((long double)(1ULL << k) - 3.0 / 2.0) * ((long double)(1ULL << k) - 3.0 / 2.0) + 2.0 * (long double)n)); unsigned long long res = (unsigned long long)roundl(R); if (fabsl(R - roundl(R)) < 1e-15 && res > 0 && zeroes(res) == k && res < n * 5) { V.insert(res); } } if (V.size() == 0) { cout << -1 << endl; } else { for (set<unsigned long long>::const_iterator it = V.begin(); it != V.end(); ++it) { cout << *it << endl; } } return 0; } |
#include <bits/stdc++.h> using namespace std; void err(istream_iterator<string> it) {} template <typename T, typename... Args> void err(istream_iterator<string> it, T a, Args... args) { cerr << *it << = << a << endl; err(++it, args...); } const long long mod = pow(10, 9) + 7; const long long N = 3e5, M = N; const long long inf = LLONG_MAX; const long long infn = LLONG_MIN; string convert(string s) { long long n = s.length(), i; while (true) { bool done = 0; for (auto it = s.begin(); it != s.end(); it++) { auto p = it; p++; if (p == s.end()) break; else if (*it == k && *p == h ) { s.erase(it); it--; done = 1; } } if (!done) break; } string k = ; for (long long i = 0; i < s.length(); i++) { if (s[i] == u ) { k += oo ; } else k += s[i]; } { string _s = k ; replace(_s.begin(), _s.end(), , , ); stringstream _ss(_s); istream_iterator<string> _it(_ss); err(_it, k); }; return k; } void iluzn() { long long n; cin >> n; long long k = n; set<string> st; while (n--) { string s; cin >> s; s = convert(s); st.insert(s); } cout << st.size() << n ; } signed main() { ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0); long long t = 1; while (t--) iluzn(); return 0; } |
#include <bits/stdc++.h> using namespace std; const long long inf = (long long)1e18; int n, q; int v[111111], c[111111]; long long first[111111]; long long calc(long long a, long long b) { int m1 = 0, m2 = 0; for (int i = 1; i <= n; ++i) first[i] = -inf; first[0] = 0; for (int i = 0; i < n; ++i) { int &cc = c[i], &vv = v[i]; long long cur = b * vv; if (first[cc] > -inf) { cur = max(cur, first[cc] + a * vv); } if (m1 != cc) { cur = max(cur, first[m1] + b * vv); } else if (m2 != cc) { cur = max(cur, first[m2] + b * vv); } if (cur > first[cc]) { first[cc] = cur; if (first[cc] > first[m1]) { m2 = m1, m1 = cc; } else if (first[cc] > first[m2] && cc != m1) { m2 = cc; } } } return first[m1]; } int main() { scanf( %d%d , &n, &q); for (int i = 0; i < n; ++i) scanf( %d , &v[i]); for (int i = 0; i < n; ++i) scanf( %d , &c[i]); while (q--) { int a, b; scanf( %d%d , &a, &b); cout << calc((long long)a, (long long)b) << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; vector<pair<long long, long long> > vp; vector<long long> v; set<long long> st; long long ara[500005]; map<string, long long> mp; long long Set(long long N, long long pos) { return N = N | (1LL << pos); } long long reset(long long N, long long pos) { return N = N & ~(1LL << pos); } bool check(long long N, long long pos) { return (bool)(N & (1LL << pos)); } vector<long long> e, o; int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); long long t, n, i, j, p; cin >> t; while (t--) { cin >> n; v.clear(), vp.clear(); for (i = 0; i < n; i++) v.push_back(i + 1); long long a = n; for (i = n - 1; i >= 0; i--) { vp.push_back({a, i}); a = (a + i + 1) / 2; } cout << 2 << endl; for (i = 0; i < n - 1; i++) cout << vp[i].first << << vp[i].second << endl; } } |
#include <bits/stdc++.h> using namespace std; struct Ev { int pos; bool st; Ev(int pos, bool st) : pos(pos), st(st) {} inline bool operator<(const Ev &rhs) const { return pos < rhs.pos; } }; int n, k; vector<Ev> ev; int f[200005], rf[200005]; const int MOD = 1e9 + 7; int c(int n, int k) { return (long long)f[n] * rf[k] % MOD * rf[n - k] % MOD; } int binPow(long long x, int p) { long long res = 1; while (p) { if (p & 1) res = res * x % MOD; p >>= 1; if (p) x = x * x % MOD; } return (int)res; } int main() { f[0] = rf[0] = 1; for (int i = 1; i < 200005; ++i) { f[i] = (long long)f[i - 1] * i % MOD; rf[i] = binPow(f[i], MOD - 2); } scanf( %d%d , &n, &k); for (int i = 0; i < (int)(n); ++i) { int from, to; scanf( %d%d , &from, &to); ev.push_back(Ev(from, true)); ev.push_back(Ev(to + 1, false)); } int pre = -1e9 - 1234; sort(ev.begin(), ev.end()); int cnt = 0; int ans = 0; for (Ev e : ev) { if (cnt >= k) { ans = (ans + (long long)c(cnt, k) * (e.pos - pre)) % MOD; } pre = e.pos; if (e.st) ++cnt; else --cnt; } printf( %d n , ans); return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int N, i; cin >> N; char ch; int o = 0, n = 0, e = 0, z = 0, r = 0; for (i = 0; i < N; i++) { cin >> ch; if (ch == o ) o++; else if (ch == n ) n++; else if (ch == e ) e++; else if (ch == z ) z++; else r++; } int m1, m2; m1 = min(o, min(n, e)); o -= m1; e -= m1; while (m1--) cout << 1 ; m2 = min(z, min(e, min(r, o))); while (m2--) cout << 0 ; return 0; } |
#include <bits/stdc++.h> using namespace std; const int N = 100000 + 9; const int Mod = 1000000007; long long n, d, b; long long a[N]; int main() { cin >> n >> d >> b; for (int i = 1; i <= n; i++) { scanf( %I64d , &a[i]); } for (int i = 1; i <= n; i++) a[i] = a[i - 1] + a[i]; long long L = 0, R = 0, Lans = 0, Rans = 0; for (int i = 1; i <= (n + 1) / 2; i++) { if (a[min(n, (d + 1) * i)] >= (L + 1) * b) L++; else Lans++; } for (int i = n; i > n - (n + 1) / 2; i--) { if (a[n] - a[max(0ll, i - (n - i + 1) * d - 1)] >= (R + 1) * b) R++; else Rans++; } cout << max(Lans, Rans) << endl; } |
#include <bits/stdc++.h> int solve(int n, int m, std::vector<int> const& costs) { int chosen_row_minimum = -1; for (int i = 0; i < n; ++i) { auto min = std::min_element(costs.cbegin() + i * m, costs.cbegin() + i * m + m); if (*min > chosen_row_minimum) { chosen_row_minimum = *min; } } return chosen_row_minimum; } int main() { int n, m; std::cin >> n >> m; std::vector<int> costs; costs.reserve(n * m); costs.insert(costs.end(), std::istream_iterator<int>(std::cin), std::istream_iterator<int>()); assert(n * m == (int)costs.size()); int chosen_row_minimum = solve(n, m, costs); printf( %d n , chosen_row_minimum); return 0; } |
#include <bits/stdc++.h> using namespace std; const long long N = 1e6 + 25; const long long INF = 1e15 + 7; const long long mod = 998244353; long long dp[N]; long long binpow(long long a, long long b) { a %= mod; long long res = 1; while (b > 0) { if (b & 1) res = res * a % mod; a = a * a % mod; b >>= 1; } return res; } long long mult(long long a, long long b) { return (a % mod * b % mod) % mod; } long long add(long long a, long long b) { a += b; if (a >= mod) return a - mod; return a; } long long sub(long long a, long long b) { a -= b; if (a < 0) return a + mod; return a; } long long inverse(long long a) { return binpow(a, mod - 2); } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); long long t; cin >> t; while (t--) { long long n, m; cin >> n >> m; vector<pair<long long, long long> > ans; char a[n + 2][m + 3]; for (long long i = 0; i < n; i++) { for (long long j = 0; j < m; j++) cin >> a[i][j]; } for (long long i = 0; i < n - 1; i++) { for (long long j = 0; j < m - 1; j++) { vector<pair<long long, long long> > z, o; if (a[i][j] == 0 ) z.push_back(make_pair(i, j)); else o.push_back(make_pair(i, j)); if (a[i][j + 1] == 0 ) z.push_back(make_pair(i, j + 1)); else o.push_back(make_pair(i, j + 1)); if (a[i + 1][j] == 0 ) z.push_back(make_pair(i + 1, j)); else o.push_back(make_pair(i + 1, j)); if (a[i + 1][j + 1] == 0 ) z.push_back(make_pair(i + 1, j + 1)); else o.push_back(make_pair(i + 1, j + 1)); if (o.size() == 0) continue; if (o.size() == 4) { ans.push_back(make_pair(i, j)); ans.push_back(make_pair(i, j + 1)); ans.push_back(make_pair(i + 1, j)); ans.push_back(make_pair(i + 1, j + 1)); ans.push_back(make_pair(i + 1, j)); ans.push_back(make_pair(i, j + 1)); ans.push_back(make_pair(i, j)); ans.push_back(make_pair(i, j + 1)); ans.push_back(make_pair(i + 1, j + 1)); ans.push_back(make_pair(i, j)); ans.push_back(make_pair(i + 1, j)); ans.push_back(make_pair(i + 1, j + 1)); } if (o.size() == 3) { for (long long k = 0; k < 3; k++) ans.push_back(o[k]); } if (o.size() == 2) { ans.push_back(o[0]); ans.push_back(z[0]); ans.push_back(z[1]); ans.push_back(o[1]); ans.push_back(z[0]); ans.push_back(z[1]); } if (o.size() == 1) { ans.push_back(o[0]); ans.push_back(z[1]); ans.push_back(z[2]); pair<long long, long long> p = o[0]; o.pop_back(); o.push_back(z[1]); o.push_back(z[2]); z.pop_back(); z.pop_back(); z.push_back(p); ans.push_back(o[0]); ans.push_back(z[0]); ans.push_back(z[1]); ans.push_back(o[1]); ans.push_back(z[0]); ans.push_back(z[1]); } a[i][j] = 0 ; a[i + 1][j] = 0 ; a[i][j + 1] = 0 ; a[i + 1][j + 1] = 0 ; } } cout << ans.size() / 3 << endl; for (long long i = 0; i < ans.size(); i += 3) { cout << ans[i].first + 1 << << ans[i].second + 1 << << ans[i + 1].first + 1 << << ans[i + 1].second + 1 << << ans[i + 2].first + 1 << << ans[i + 2].second + 1 << endl; } } } |
#include <bits/stdc++.h> using namespace std; const int N = 1e5 + 10, M = 30; int a[M], b[M]; char ans[26 * N]; int gcd(int x, int y) { return (!y) ? x : gcd(y, x % y); } int main() { ios::sync_with_stdio(0); int n, cnt = 0, sum = 0, pos = 0, qaq = 0, tmp = 0; scanf( %d , &n); for (int i = 1; i <= n; i++) { scanf( %d , &a[i]); cnt += a[i] % 2; sum += a[i]; } if (cnt > 1) { cout << 0 << endl; for (int i = 1; i <= n; i++) for (int j = 1; j <= a[i]; j++) cout << char( a + i - 1); return 0; } for (int i = 1; i <= n; i++) qaq = gcd(a[i], qaq); if (!cnt) qaq /= 2; for (int i = 1; i <= n; i++) { a[i] /= qaq; if (a[i] % 2) tmp = i; } sum /= qaq; for (int i = 1; i <= n; i++) { if (tmp == i) continue; for (int j = 1; j <= a[i] / 2; j++) ans[++pos] = a + i - 1; } for (int i = 1; i <= n; i++) { if (tmp != i) continue; for (int j = 1; j <= a[i]; j++) ans[++pos] = a + i - 1; } for (int i = sum; i >= sum / 2 + 1; i--) ans[i] = ans[sum - i + 1]; if (!cnt) printf( %d n , qaq * 2); else printf( %d n , qaq); for (int i = 1; i <= qaq; i++) printf( %s , ans + 1); return 0; } |
#include <bits/stdc++.h> using namespace std; const bool print = false; const int N = 5e5 + 7; int n, m; vector<int> gr[N]; int cyk[N], odl[N], par[N]; vector<int> mycyk[N]; bool odw[N]; int ans[N]; vector<int> child[N]; int dpd[N], dpu[N]; void dfs1(int v) { odw[v] = 1; for (int i : gr[v]) { if (i == par[v]) continue; if (odw[i]) { if (odl[i] < odl[v]) { int w = v; while (w != i) { cyk[w] = i; mycyk[i].push_back(w); w = par[w]; } cyk[i] = i; mycyk[i].push_back(i); reverse((mycyk[i]).begin(), (mycyk[i]).end()); } continue; } odl[i] = odl[v] + 1; par[i] = v; dfs1(i); if (cyk[i] != cyk[v] || !cyk[v]) child[v].push_back(i); } } void dfs2(int v) { for (int i = (1); i <= ((int)mycyk[v].size() - 1); i++) { dfs2(mycyk[v][i]); dpd[v] = max(dpd[v], dpd[mycyk[v][i]] + min(i, (int)mycyk[v].size() - i)); } for (int i : child[v]) { dfs2(i); dpd[v] = max(dpd[v], dpd[i] + 1); } } deque<int> kol; void clearit() { kol.clear(); } void add(int v) { while (!kol.empty() && kol.back() < v) kol.pop_back(); kol.push_back(v); } void remove(int v) { if (kol.front() == v) kol.pop_front(); } int war[N]; void solve(int v) { int k = mycyk[v].size(); clearit(); for (int i = (0); i <= (k - 1); i++) { war[i] = max(dpd[mycyk[v][i]], dpu[mycyk[v][i]]); if (!i) { war[0] = dpu[mycyk[v][i]]; for (int j : child[v]) war[0] = max(war[0], dpd[j] + 1); } } for (int i = (k / 2); i >= (1); i--) add(war[k - i] + i); for (int i = (0); i <= (k - 1); i++) { int x = mycyk[v][i]; if (i) dpu[x] = max(dpu[x], kol.front() + i); remove(war[(i - k / 2 + k) % k] - (i - k / 2)); add(war[i] - i); } clearit(); for (int i = (k / 2 - 1); i >= (0); i--) add(war[i] + k + i); for (int i = (k - 1); i >= (1); i--) { int x = mycyk[v][i]; dpu[x] = max(dpu[x], kol.front() - i); remove(war[(i + k / 2) % k] + (i + k / 2)); add(war[i] + i); } } void dfs3(int v) { priority_queue<int> pri; pri.push(dpu[v]); if (cyk[v] == v) { solve(v); int j = 0; for (int i : mycyk[v]) if (i != v) { dfs3(i); j++; pri.push(dpd[i] + min(j, (int)mycyk[v].size() - j)); } } for (int i : child[v]) pri.push(dpd[i] + 1); int x = pri.top(); pri.pop(); int y = -1; if (!pri.empty()) y = pri.top(); for (int i : child[v]) { if (dpd[i] + 1 != x) dpu[i] = x + 1; else dpu[i] = y + 1; dfs3(i); } } int main() { scanf( %d%d , &n, &m); for (int i = (1); i <= (m); i++) { int a, b; scanf( %d%d , &a, &b); gr[a].push_back(b); gr[b].push_back(a); } odl[1] = 1; dfs1(1); dfs2(1); dfs3(1); for (int i = (1); i <= (n); i++) ans[i] = max(dpd[i], dpu[i]); for (int i = (1); i <= (n); i++) printf( %d , ans[i]); printf( n ); return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { std::ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); int n; cin >> n; int a[n + 2]; int pos[n + 2]; for (int i = 1; i <= n; i++) { cin >> a[i]; pos[a[i]] = i; } int swap = 0; for (int i = 1; i <= n; i++) { int p = pos[i]; if (p == i) continue; int prev = a[i]; a[i] = i; pos[prev] = p; a[p] = prev; pos[i] = i; swap++; } if (n % 2) { if (swap % 2) { cout << Petr n ; } else { cout << Um_nik n ; } } else { if (swap % 2) { cout << Um_nik n ; } else { cout << Petr n ; } } return 0; } |
#include <bits/stdc++.h> using namespace std; const int MOD = (int)1e9 + 7; const int FFTMOD = 119 << 23 | 1; const int INF = (int)1e9 + 23111992; const long long LINF = (long long)1e18 + 23111992; const long double PI = acos((long double)-1); const long double EPS = 1e-9; inline long long gcd(long long a, long long b) { long long r; while (b) { r = a % b; a = b; b = r; } return a; } inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; } inline long long fpow(long long n, long long k, int p = MOD) { long long r = 1; for (; k; k >>= 1) { if (k & 1) r = r * n % p; n = n * n % p; } return r; } template <class T> inline int chkmin(T& a, const T& val) { return val < a ? a = val, 1 : 0; } template <class T> inline int chkmax(T& a, const T& val) { return a < val ? a = val, 1 : 0; } inline unsigned long long isqrt(unsigned long long k) { unsigned long long r = sqrt(k) + 1; while (r * r > k) r--; return r; } inline long long icbrt(long long k) { long long r = cbrt(k) + 1; while (r * r * r > k) r--; return r; } inline void addmod(int& a, int val, int p = MOD) { if ((a = (a + val)) >= p) a -= p; } inline void submod(int& a, int val, int p = MOD) { if ((a = (a - val)) < 0) a += p; } inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; } inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); } inline int sign(long double x) { return x < -EPS ? -1 : x > +EPS; } inline int sign(long double x, long double y) { return sign(x - y); } mt19937 mt(chrono::high_resolution_clock::now().time_since_epoch().count()); inline int mrand() { return abs((int)mt()); } inline int mrand(int k) { return abs((int)mt()) % k; } void chemthan() { int C = 1e5 + 5; vector<int> sp(C); for (int i = (1); i < (C); ++i) sp[i] = i; for (int i = (2); i < (C); ++i) if (sp[i] == i) { for (int j = i + i; j < C; j += i) { chkmin(sp[j], i); } } vector<int> mob(C, 1); for (int i = (2); i < (C); ++i) { int t = i; int pv = -1; while (1 < t) { if (pv == sp[t]) { mob[i] = 0; } mob[i] *= -1; pv = sp[t]; t /= sp[t]; } } vector<vector<int> > dvs(C); vector<vector<int> > dvs2(C); for (int i = (1); i < (C); ++i) { for (int j = i; j < C; j += i) { dvs[j].push_back(i); if (mob[j / i]) dvs2[j].push_back(i); } } int n; cin >> n; vector<int> a(n); vector<vector<int> > g(C); for (int i = (0); i < (n); ++i) { cin >> a[i]; for (int d : dvs[i + 1]) { g[d].push_back(a[i]); } } vector<int> c(C); vector<int> f(C); vector<int> x(C); vector<int> y(C); int res = 0; for (int i = (1); i < (C); ++i) if (int((g[i]).size())) { vector<int> tmp2; vector<int> tmp; for (int u : g[i]) { c[u] = 0; } for (int u : g[i]) { if (!c[u]++) { tmp2.push_back(u); } } for (int u : tmp2) { for (int d : dvs[u]) { if (!f[d]) { tmp.push_back(d); } f[d] += c[u]; } } for (int u : tmp) { f[u] = mult(f[u], f[u]); } int sum = 0; for (int u : tmp) { for (int v : dvs2[u]) { if (mob[u / v]) { if (mob[u / v] == 1) { addmod(x[v], f[u]); } else { submod(x[v], f[u]); } } } } for (int u : tmp) { addmod(sum, mult(x[u], u)); } y[i] = sum; for (int u : tmp) f[u] = x[u] = 0; } for (int i = (C)-1; i >= (1); --i) { for (int j = i + i; j < C; j += i) { submod(y[i], y[j]); } addmod(res, mult(i, y[i])); } cout << res << n ; } int32_t main(int32_t argc, char* argv[]) { ios_base::sync_with_stdio(0), cin.tie(0); if (argc > 1) { assert(freopen(argv[1], r , stdin)); } if (argc > 2) { assert(freopen(argv[2], wb , stdout)); } chemthan(); cerr << nTime elapsed: << 1000 * clock() / CLOCKS_PER_SEC << ms n ; return 0; } |
#include <bits/stdc++.h> using namespace std; using ll = long long int; int gcd(int n, int m) { if (m == 0) return n; return gcd(m, n % m); } int lcm(int n, int m) { return n * m / gcd(n, m); } ll fact(ll n) { if (n == 1 or n == 0) return 1; else return ((n % 1000000007) * (fact(n - 1) % 1000000007)) % 1000000007; } template <typename T> T modpow(T base, T exp) { base %= 1000000007; T result = 1; while (exp > 0) { if (exp & 1) (result *= base) %= 1000000007; (base *= base) %= 1000000007; exp >>= 1; } return result; } int bin_search(vector<int>& a, int ele) { int lo = 0, hi = a.size() - 1; while (lo <= hi) { int mid = lo + (hi - lo) / 2; if (mid == 0 or mid == a.size() - 1) return mid; else if (a[mid] >= ele and a[mid - 1] < ele) return mid; else if (a[mid] >= ele) hi = mid - 1; else lo = mid + 1; } } bool ifPrime(int n) { for (int i = 2; i <= sqrt(n); i++) { if (n % i == 0) return 0; } return 1; } void solve(int testno) { string s; cin >> s; string orig = s; bool no = 1; for (char& c : s) { if (c == 9 and no) { no = 0; continue; } no = 0; if (c - 0 >= 5) { c = 0 + ( 9 - c); } } cout << s; } int32_t main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); cin.exceptions(ios::badbit | ios::failbit); int t = 1; for (int i = 1; i <= t; i++) { solve(i); } return 0; } |
#include <bits/stdc++.h> using namespace std; class Node { public: Node *prev, *next; int k; Node(int K) { k = K; prev = next = NULL; }; void insert(int K) { Node *n = new Node(K); n->prev = this; if (this->next == NULL) this->next = n; else { Node *t = this->next; this->next = n; n->next = t; t->prev = n; } }; void insertBack(int K) { Node *n = new Node(K); n->next = this; if (this->prev == NULL) this->prev = n; else { Node *t = this->prev; this->prev = n; n->prev = t; t->next = n; } }; void del() { Node *p = this->prev, *n = this->next; if (p) p->next = n; if (n) n->prev = p; delete this; }; void delNext() { if (this->next) this->next->del(); }; }; int32_t main() { ios_base::sync_with_stdio(false); cin.tie(NULL); int T; cin >> T; while (T) { T--; string s; cin >> s; Node *head = new Node(s[0] - 0 ); Node *curr = head; for (int i = 1; i < s.size(); i++) { curr->insert(s[i] - 0 ); curr = curr->next; } curr = head->next; Node *cache = head; while (curr) { if (cache->k % 2 != curr->k % 2) { while (cache->k < curr->k) cache = cache->next; if (cache == curr) { curr = curr->next; continue; } cache->insertBack(curr->k); if (curr->next) { curr = curr->next; curr->prev->del(); } else { curr = curr->prev; curr->next->del(); curr = NULL; } } else { curr = curr->next; } } while (cache->prev) cache = cache->prev; while (cache) { cout << cache->k; cache = cache->next; if (cache && cache->prev) cache->prev->del(); } cout << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; long long gcd(long long n1, long long n2) { if (!n1) return n2; if (!n2) return n1; if (n1 % n2 == 0) return n2; return gcd(n2, n1 % n2); } long long powmod(long long base, long long exponent) { base %= 1000000007; long long ans = 1; while (exponent) { if (exponent & 1) ans = (ans * base) % 1000000007; base = (base * base) % 1000000007; exponent /= 2; } ans %= 1000000007; return ans; } int arr[1000100 + 1]; int cnt[1000100 + 1]; int pw[1000100 + 1]; int dp[1000100 + 1]; int main() { int n, i, j, k; pw[0] = 1; for (i = 1; i <= 1000100; i++) { pw[i] = (2 * pw[i - 1]) % 1000000007; } scanf( %d , &n); for (i = 1; i <= n; i++) { scanf( %d , &arr[i]); cnt[arr[i]]++; } for (i = 1; i <= 1000100; i++) for (j = i; j <= 1000100; j += i) dp[i] += cnt[j]; for (i = 1; i <= 1000100; i++) if (dp[i]) { dp[i] = (1LL * dp[i] * pw[dp[i] - 1]) % 1000000007; } long long answer = 0; for (i = 1000100; i >= 2; i--) { for (j = 2 * i; j <= 1000100; j += i) { dp[i] -= dp[j]; if (dp[i] < 0) dp[i] += 1000000007; } answer = (answer + 1LL * i * dp[i]) % 1000000007; } printf( %lld n , answer); return 0; } |
#include <bits/stdc++.h> using namespace std; void input() {} const int N = 1e5 + 4, mod = 1e9 + 7; int t, k, l, r; long long dp[N]; int solve(int i = 1e5) { if (i < 0) return 0; if (i == 0) return 1; long long &ret = dp[i]; if (~ret) return ret; ret = solve(i - 1) % mod; ret += solve(i - k) % mod; return ret % mod; } int main() { ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); input(); cin >> t >> k; memset(dp, -1, sizeof dp); int x = solve(); dp[0] = 0; for (int i = 1; i <= 1e5; i++) dp[i] += dp[i - 1]; while (t--) { cin >> l >> r; cout << (dp[r] - dp[l - 1]) % mod << endl; } } |
#include <bits/stdc++.h> using namespace std; set<int> x, y; int vx[200006], vy[200006]; set<int> mx, my; set<int>::iterator it1, it2; void gao(set<int> &t1, set<int> &t2, int *v, int x) { if (!t1.count(x)) { it1 = t1.lower_bound(x); it2 = it1, it1--; int l = *it2 - *it1; v[l]--; if (v[l] == 0) t2.erase(l); t2.insert(*it2 - x), v[*it2 - x]++; t2.insert(x - *it1), v[x - *it1]++; t1.insert(x); } } int main() { int w, h, n, t, T; while (~scanf( %d%d%d , &w, &h, &n)) { memset(vx, 0, sizeof(vx)); memset(vy, 0, sizeof(vy)); char c; x.clear(), y.clear(); mx.clear(), my.clear(); x.insert(w), y.insert(h); x.insert(0), y.insert(0); mx.insert(w), my.insert(h); vx[w]++, vy[h]++; while (n--) { cin >> c >> t; if (c == V ) gao(x, mx, vx, t); else gao(y, my, vy, t); it1 = mx.end(), it2 = my.end(); it1--, it2--; long long x1 = (*it1) * 1ll, x2 = (*it2) * 1ll; long long ans = x1 * x2; cout << ans << endl; } } return 0; } |
#include <bits/stdc++.h> using namespace std; char a[55]; int main() { int n, i, j, k, ans, x; int len; while (cin >> a) { ans = 0; x = 0; len = strlen(a); for (i = 0; i < len; i++) { for (j = len - 1; j > i; j--) { for (k = i; k <= j; k++) { if (a[k] != a[j - k + i]) break; } if (k != j + 1) { ans = max(ans, j - i); } } } if (ans != 0) cout << ans + 1 << endl; else cout << 0 << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; string S = 402 n1 1000000 n40001 400 n40800 399 n41597 398 n42392 397 n43185 396 n43976 395 n44765 394 n45552 393 n46337 392 n47120 391 n47901 390 n48680 389 n49457 388 n50232 387 n51005 386 n51776 385 n52545 384 n53312 383 n54077 382 n54840 381 n55601 380 n56360 379 n57117 378 n57872 377 n58625 376 n59376 375 n60125 374 n60872 373 n61617 372 n62360 371 n63101 370 n63840 369 n64577 368 n65312 367 n66045 366 n66776 365 n67505 364 n68232 363 n68957 362 n69680 361 n70401 360 n71120 359 n71837 358 n72552 357 n73265 356 n73976 355 n74685 354 n75392 353 n76097 352 n76800 351 n77501 350 n78200 349 n78897 348 n79592 347 n80285 346 n80976 345 n81665 344 n82352 343 n83037 342 n83720 341 n84401 340 n85080 339 n85757 338 n86432 337 n87105 336 n87776 335 n88445 334 n89112 333 n89777 332 n90440 331 n91101 330 n91760 329 n92417 328 n93072 327 n93725 326 n94376 325 n95025 324 n95672 323 n96317 322 n96960 321 n97601 320 n98240 319 n98877 318 n99512 317 n100145 316 n100776 315 n101405 314 n102032 313 n102657 312 n103280 311 n103901 310 n104520 309 n105137 308 n105752 307 n106365 306 n106976 305 n107585 304 n108192 303 n108797 302 n109400 301 n110001 300 n110600 299 n111197 298 n111792 297 n112385 296 n112976 295 n113565 294 n114152 293 n114737 292 n115320 291 n115901 290 n116480 289 n117057 288 n117632 287 n118205 286 n118776 285 n119345 284 n119912 283 n120477 282 n121040 281 n121601 280 n122160 279 n122717 278 n123272 277 n123825 276 n124376 275 n124925 274 n125472 273 n126017 272 n126560 271 n127101 270 n127640 269 n128177 268 n128712 267 n129245 266 n129776 265 n130305 264 n130832 263 n131357 262 n131880 261 n132401 260 n132920 259 n133437 258 n133952 257 n134465 256 n134976 255 n135485 254 n135992 253 n136497 252 n137000 251 n137501 250 n138000 249 n138497 248 n138992 247 n139485 246 n139976 245 n140465 244 n140952 243 n141437 242 n141920 241 n142401 240 n142880 239 n143357 238 n143832 237 n144305 236 n144776 235 n145245 234 n145712 233 n146177 232 n146640 231 n147101 230 n147560 229 n148017 228 n148472 227 n148925 226 n149376 225 n149825 224 n150272 223 n150717 222 n151160 221 n151601 220 n152040 219 n152477 218 n152912 217 n153345 216 n153776 215 n154205 214 n154632 213 n155057 212 n155480 211 n155901 210 n156320 209 n156737 208 n157152 207 n157565 206 n157976 205 n158385 204 n158792 203 n159197 202 n159600 201 n160001 200 n160400 199 n160797 198 n161192 197 n161585 196 n161976 195 n162365 194 n162752 193 n163137 192 n163520 191 n163901 190 n164280 189 n164657 188 n165032 187 n165405 186 n165776 185 n166145 184 n166512 183 n166877 182 n167240 181 n167601 180 n167960 179 n168317 178 n168672 177 n169025 176 n169376 175 n169725 174 n170072 173 n170417 172 n170760 171 n171101 170 n171440 169 n171777 168 n172112 167 n172445 166 n172776 165 n173105 164 n173432 163 n173757 162 n174080 161 n174401 160 n174720 159 n175037 158 n175352 157 n175665 156 n175976 155 n176285 154 n176592 153 n176897 152 n177200 151 n177501 150 n177800 149 n178097 148 n178392 147 n178685 146 n178976 145 n179265 144 n179552 143 n179837 142 n180120 141 n180401 140 n180680 139 n180957 138 n181232 137 n181505 136 n181776 135 n182045 134 n182312 133 n182577 132 n182840 131 n183101 130 n183360 129 n183617 128 n183872 127 n184125 126 n184376 125 n184625 124 n184872 123 n185117 122 n185360 121 n185601 120 n185840 119 n186077 118 n186312 117 n186545 116 n186776 115 n187005 114 n187232 113 n187457 112 n187680 111 n187901 110 n188120 109 n188337 108 n188552 107 n188765 106 n188976 105 n189185 104 n189392 103 n189597 102 n189800 101 n190001 100 n190200 99 n190397 98 n190592 97 n190785 96 n190976 95 n191165 94 n191352 93 n191537 92 n191720 91 n191901 90 n192080 89 n192257 88 n192432 87 n192605 86 n192776 85 n192945 84 n193112 83 n193277 82 n193440 81 n193601 80 n193760 79 n193917 78 n194072 77 n194225 76 n194376 75 n194525 74 n194672 73 n194817 72 n194960 71 n195101 70 n195240 69 n195377 68 n195512 67 n195645 66 n195776 65 n195905 64 n196032 63 n196157 62 n196280 61 n196401 60 n196520 59 n196637 58 n196752 57 n196865 56 n196976 55 n197085 54 n197192 53 n197297 52 n197400 51 n197501 50 n197600 49 n197697 48 n197792 47 n197885 46 n197976 45 n198065 44 n198152 43 n198237 42 n198320 41 n198401 40 n198480 39 n198557 38 n198632 37 n198705 36 n198776 35 n198845 34 n198912 33 n198977 32 n199040 31 n199101 30 n199160 29 n199217 28 n199272 27 n199325 26 n199376 25 n199425 24 n199472 23 n199517 22 n199560 21 n199601 20 n199640 19 n199677 18 n199712 17 n199745 16 n199776 15 n199805 14 n199832 13 n199857 12 n199880 11 n199901 10 n199920 9 n199937 8 n199952 7 n199965 6 n199976 5 n199985 4 n199992 3 n199997 2 n200000 1 n999999 1000000 n ; int main() { cout << S; } |
#include <bits/stdc++.h> using namespace std; const int MAXN = 1000 * 1000 + 17, sq = 1000; int n, a[MAXN]; vector<pair<int, int> > p; bool cmp(int i, int j) { i--, j--; if (p[i].first / sq != p[j].first / sq) return p[i].first < p[j].first; return ((p[i].first / sq) % 2 ? p[i].second > p[j].second : p[i].second < p[j].second); } int main() { ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0); cin >> n; for (int i = 1; i <= n; i++) { int x, y; cin >> x >> y; p.push_back({x, y}); } iota(a + 1, a + n + 1, 1); sort(a + 1, a + n + 1, cmp); for (int i = 1; i <= n; i++) cout << a[i] << ; return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; cin.get(); string s; deque<pair<string, bool>> storage; while (n--) { getline(cin, s); storage.push_back(pair<string, bool>(s, true)); } deque<pair<string, bool>>::iterator it1, it2; bool flag; for (it1 = storage.begin(); it1 < storage.end(); it1++) { if (it1->second == true) { cout << NO << endl; } else { cout << YES << endl; } for (it2 = it1 + 1; it2 < storage.end(); it2++) { if (it1->first == it2->first) { it2->second = false; } } } } |
#include <bits/stdc++.h> using namespace std; template <typename T> using min_pq = priority_queue<T, vector<T>, greater<T>>; template <typename T> using max_pq = priority_queue<T>; const int inf = 2e9 + 5; const long long l_inf = 2e18 + 5; const int mod_v = 1e9 + 7; const int max_n = 1e5 + 5; const int dx[4] = {-1, 0, 1, 0}; const int dy[4] = {0, 1, 0, -1}; template <typename T> T gcd(T a, T b) { while (b) { T temp = a % b; a = b; b = temp; } return a; } template <typename T> tuple<T, T, T> egcd(T a, T b) { T x1 = 1, x2 = 0, y1 = 0, y2 = 1; while (b) { T q = a / b, r = a % b; T new_x = x1 - q * x2, new_y = y1 - q * y2; x1 = x2, y1 = y2, x2 = new_x, y2 = new_y; a = b, b = r; } return make_tuple(a, x1, y1); } inline long long lcm(long long a, long long b) { return a * b / gcd(a, b); } template <typename T> inline T mod(T a, T b = mod_v) { return (a % b + b) % b; } template <typename T> inline T mod_inv(T a, T b = mod_v) { return mod(get<1>(egcd(a, b)), b); } template <typename T> inline T sum(T a, T b, T m = mod_v) { return mod(mod(a, m) + mod(b, m), m); } template <typename T> inline T difference(T a, T b, T m = mod_v) { return mod(mod(a, m) - mod(b, m), m); } inline long long product(long long a, long long b, long long m = mod_v) { return mod(mod(a, m) * mod(b, m), m); } inline long long quotient(long long a, long long b, long long m = mod_v) { return mod(mod(a, m) * mod_inv(b, m), m); } template <typename T, typename T2> ostream &operator<<(ostream &s, const pair<T, T2> &p) { return s << p.first << << p.second << ; } template <typename T, typename T2> istream &operator>>(istream &s, pair<T, T2> &p) { return s >> p.first >> p.second; } template <typename T> ostream &operator<<(ostream &s, const vector<T> &v) { for (auto it : v) s << it << ; return s; } template <typename T> istream &operator>>(istream &s, vector<T> &v) { for (auto it = (v).begin(), it_ = (v).end(); it != it_; ++it) s >> *it; return s; } template <typename T> void read_range(T beg, T end) { while (beg != end) cin >> *beg++; } template <typename T> void print_range(T beg, T end) { while (beg != end) cout << *beg++ << ; } struct reader { template <typename T> reader &operator,(T &v) { cin >> v; return *this; } } rdr; struct debugger { template <typename T> debugger &operator,(const T &v) { cerr << v << , ; return *this; } } dbg; map<pair<int, int>, long long> memo; long long ar[max_n * 10], cnt[max_n * 10], cnt2[10 * max_n], comp[10 * max_n]; vector<pair<int, int>> v; long long f(int cur, int k) { if (k == 0) return 1; if (cur == -1) return 0; if (memo.find(make_pair(cur, k)) != memo.end()) return memo[make_pair(cur, k)]; return memo[make_pair(cur, k)] = (f(cur - 1, k) + (cnt[cur] * f(cur, k - 1)) % mod_v) % mod_v; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); long long n, l, k; rdr, n, l, k; ; read_range(ar, ar + n); for (int i = 0; i < n; ++i) v.emplace_back(ar[i], i); sort((v).begin(), (v).end()); int sz = 0; for (int i = 0; i < n; ++i) { while (i + 1 < n and v[i].first == v[i + 1].first) { comp[v[i].second] = sz; ++cnt[sz]; ++i; } comp[v[i].second] = sz; ++cnt[sz]; ++sz; } long long rem = l % n, seg = l / n; for (int i = 0; i < rem; ++i) ++cnt2[comp[i]]; long long ans = 0; for (int i = 1; i <= min(k, seg); ++i) { ans += ((seg - i + 1) % mod_v) * f(sz - 1, i); ans %= mod_v; } for (int i = 1; i <= min(k, seg + 1); ++i) { for (int j = 0; j < sz; ++j) { ans += cnt2[j] * f(j, i - 1); ans %= mod_v; } } cout << ans; return 0; } |
#include <bits/stdc++.h> using namespace std; vector<int> V[100045]; double size[100045]; int par[100045]; double ans[100045]; void dfs(int v) { size[v] = 1; for (int i = 0; i < V[v].size(); i++) dfs(V[v][i]); for (int i = 0; i < V[v].size(); i++) size[v] += size[V[v][i]]; } void bfs(int st) { queue<int> q; q.push(st); while (!q.empty()) { int top = q.front(); q.pop(); if (top != 1) ans[top] = ans[par[top]] + 1.00 + 0.5 * (size[par[top]] - size[top] - 1.0); for (int i = 0; i < V[top].size(); i++) q.push(V[top][i]); } } int main() { ans[1] = 1.0; int n; scanf( %d , &n); for (int i = 2; i <= n; i++) { int u; scanf( %d , &u); V[u].push_back(i); par[i] = u; } dfs(1); bfs(1); for (int i = 1; i <= n; i++) cout << fixed << setprecision(7) << ans[i] << ; } |
#include <bits/stdc++.h> using namespace std; const int oo = (int)1e8; vector<vector<int>> groupCosts; vector<int> oldDP, newDP; void solveDP(int L, int R, int L1, int R1) { if (R < L) return; int mid = (L + R) / 2; int res = oo, pos = L1; for (int i = L1; i <= min(mid, R1); i++) { int now = groupCosts[i][mid]; int curCost = now + (i ? oldDP[i - 1] : 0); if (curCost < res) { res = curCost; pos = i; } } newDP[mid] = res; solveDP(L, mid - 1, L1, pos); solveDP(mid + 1, R, pos, R1); } void solve() { int n, k; cin >> n >> k; vector<vector<int>> costs(n, vector<int>(n)); for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { cin >> costs[i][j]; if (j) costs[i][j] += costs[i][j - 1]; } } groupCosts.resize(n, vector<int>(n)); for (int i = 0; i < n; i++) { for (int j = i + 1; j < n; j++) { groupCosts[i][j] += groupCosts[i][j - 1]; groupCosts[i][j] += costs[j][j - 1] - (i ? costs[j][i - 1] : 0); } } oldDP.resize(n, oo); newDP.resize(n, oo); for (int curK = 0; curK < k; curK++) { solveDP(curK, n - 1, 0, n - 1); swap(oldDP, newDP); } cout << oldDP[n - 1] << n ; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); solve(); return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); long long int t, n, i, x; cin >> t; while (t--) { cin >> n; i = n - 1; x = n; cout << 2 << endl; while (i != 0) { cout << i << << x << endl; x = ceil((i + x) / 2.0); i--; } } return 0; } |
#include <bits/stdc++.h> using namespace std; class DS { public: DS(int rows, int cols) : _rows(rows), _cols(cols), _ans(0) { int n = rows + cols; _p.resize(n, -1); _r.resize(n, 0); _nr.resize(n, 0); _nc.resize(n, 0); for (int i = 0; i < rows; ++i) _nr[i] = 1; for (int i = 0; i < cols; ++i) _nc[rows + i] = 1; } long long ans() { return _ans; } int find(int i) { while (_p[i] >= 0) i = _p[i]; return i; } void merge(int r, int c) { int i = find(r); int j = find(_rows + c); if (i == j) return; if (_r[i] > _r[j]) swap(i, j); _rb.push_back({i, j, _r[j]}); _p[i] = j; if (_r[i] == _r[j]) ++_r[j]; _ans += (long long)_nr[i] * _nc[j] + (long long)_nc[i] * _nr[j]; _nr[j] += _nr[i]; _nc[j] += _nc[i]; } int current_snapshot() { return _rb.size(); } void rollback(int snapshot) { while (_rb.size() > snapshot) { int i = _rb.back().i; int j = _rb.back().j; int r = _rb.back().r; _rb.pop_back(); _p[i] = -1; _r[j] = r; _nr[j] -= _nr[i]; _nc[j] -= _nc[i]; _ans -= (long long)_nr[i] * _nc[j] + (long long)_nc[i] * _nr[j]; } } private: int _rows, _cols; vector<int> _p, _r, _nr, _nc; struct rb_t { int i, j, r; }; vector<rb_t> _rb; long long _ans; }; class Solution { public: Solution(vector<pair<int, int>> const& p, int mx, int my) : _n(p.size()), _p(p), _seg(4 * _n), _ds(mx + 1, my + 1) {} void solve() { map<pair<int, int>, int> t; for (int i = 0; i < _n; ++i) { auto it = t.find(_p[i]); if (it == t.end()) { t[_p[i]] = i; continue; } int j = it->second; t.erase(it); add_pt(0, 0, _n, j, i, _p[i]); } for (const auto& ti : t) { add_pt(0, 0, _n, ti.second, _n, ti.first); } dfs(0, 0, _n); } private: void add_pt(int u, int a, int b, int A, int B, const pair<int, int>& pt) { if (a >= B || A >= b) return; if (A <= a && b <= B) { _seg[u].push_back(pt); return; } int c = (a + b) >> 1; add_pt(2 * u + 1, a, c, A, B, pt); add_pt(2 * u + 2, c, b, A, B, pt); } void dfs(int u, int a, int b) { int snapshot = _ds.current_snapshot(); for (const pair<int, int>& pt : _seg[u]) _ds.merge(pt.first, pt.second); if (a + 1 == b) { cout << _ds.ans() << ; } else { int c = (a + b) >> 1; dfs(2 * u + 1, a, c); dfs(2 * u + 2, c, b); } _ds.rollback(snapshot); } private: int _n; vector<pair<int, int>> const& _p; vector<vector<pair<int, int>>> _seg; DS _ds; }; int main() { ios_base::sync_with_stdio(0); cin.tie(0); int q; cin >> q; vector<pair<int, int>> p(q); int mx = 0, my = 0; for (pair<int, int>& pi : p) { cin >> pi.first >> pi.second; mx = max(mx, pi.first); my = max(my, pi.second); } Solution(p, mx, my).solve(); return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { string a; cin >> a; if (a[1] == 8 || a[1] == 1 ) { if (a[0] == a || a[0] == h ) cout << 3 << endl; else cout << 5 << endl; return 0; } if (a[0] == a || a[0] == h ) cout << 5 << endl; else cout << 8 << endl; } |
#include <bits/stdc++.h> using namespace std; long long n, m, b[110][10010], i, j, k, minn, l, p, w, ind; string a[10005]; int main() { cin >> n >> m; p = false; w = false; for (i = 0; i < n; i++) { k = -1; cin >> a[i]; for (j = 0; j < m; j++) { if (a[i][j] == 1 ) { p = true; b[i][j] = 0; k = 0; k++; ind = j; } else { b[i][j] = k; if (k > 0) k++; } } j = 0; while (b[i][j] != 0) { b[i][j] = m - ind + j; j++; } if (p == false) { w = true; break; } p = false; k = -1; for (j = m - 1; j >= 0; j--) { if (a[i][j] == 1 ) { b[i][j] = 0; k = 0; k++; ind = j; } else { if (b[i][j] < 0 || (k < b[i][j] && k >= 0)) b[i][j] = k; if (k > 0) k++; } } j = m - 1; while (b[i][j] != 0) { if (b[i][j] > ind + m - j) b[i][j] = ind + m - j; j--; } } for (i = 0; i < n; i++) { for (j = 0; j < m; j++) { b[i][j] = min(b[i][j], m - b[i][j]); } } minn = 9999999; for (i = 0; i < m; i++) { l = 0; for (j = 0; j < n; j++) l = l + b[j][i]; if (l < minn) minn = l; } if (w == true) cout << -1 ; else cout << minn; } |
#include <bits/stdc++.h> using namespace std; char s[20][20]; long long n; long long tmp1[15][16400][65]; long long tmp2[15][16400][65]; long long visit[20]; long long a[20]; long long k; long long fst; long long all; void dfs(long long pos, long long msk, long long ans) { if (pos == k) { tmp1[fst][msk][ans]++; } if (pos == n - k) { tmp2[visit[pos - 1]][msk][ans]++; return; } for (long long i = 0; i < n; i++) { if (msk & (1 << i)) continue; visit[pos] = i; dfs(pos + 1, msk | (1 << i), (ans << 1) | s[i][visit[pos - 1]]); } } long long cnt[20000]; signed main() { cin >> n; all = (1 << n) - 1; k = n / 2; long long allk = (1 << (k - 1)); long long allkk = (1 << (n - k - 1)); for (long long i = 0; i < n; i++) { cin >> s[i]; } for (long long i = 0; i < n; i++) for (long long j = 0; j < n; j++) s[i][j] -= 0 ; for (fst = 0; fst < n; fst++) { visit[0] = fst; dfs(1, 1 << fst, 0); } for (long long msk = 0; msk < all; msk++) { long long c = 0; for (long long i = 0; i < n; i++) if (msk & (1 << i)) c++; if (c != k) continue; for (long long i = 0; i < n; i++) if (msk & (1 << i)) for (long long j = 0; j < n; j++) { if (msk & (1 << j)) continue; for (long long mk = 0; mk < allk; mk++) { if (tmp1[i][msk][mk] == 0) continue; for (long long mkk = 0; mkk < allkk; mkk++) { cnt[mkk << (k) | s[i][j] << (k - 1) | mk] += tmp2[j][all ^ msk][mkk] * tmp1[i][msk][mk]; } } } } for (long long i = 0; i < (1 << (n - 1)); i++) printf( %lld , cnt[i]); return ~~(0 ^ 0 ^ 0); } |
#include <bits/stdc++.h> using namespace std; using namespace std; int n, T; int t[5005]; double p[5005]; double dp[5005][5005]; int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); cin >> n >> T; for (int i = 1; i <= n; i++) cin >> p[i] >> t[i], p[i] *= 0.01; dp[0][0] = 1; double ex = 0; for (int i = 1; i <= n; i++) { double r = 1.0; for (int j = 0; j < t[i]; j++) r *= (1.0 - p[i]); double sum = 0; for (int j = 1; j <= T; j++) { sum = sum * (1.0 - p[i]) + dp[i - 1][j - 1]; if (j > t[i]) sum = sum - r * dp[i - 1][j - t[i] - 1]; dp[i][j] = sum * p[i]; if (j >= t[i]) dp[i][j] += r * dp[i - 1][j - t[i]]; ex += dp[i][j]; } } cout << setprecision(13) << fixed << ex; } |
#include <bits/stdc++.h> using namespace std; int vis[10], A[300], B[300]; int ct[300], mrk[300]; vector<pair<int, int>> ans; int main() { int n, x; scanf( %d , &n); for (int i = 0; i < n; i++) { for (int j = 0; j < 3; j++) { scanf( %d , &x); A[i] |= (1 << j) * x; } } for (int i = 0; i < n; i++) { for (int j = 0; j < 3; j++) { scanf( %d , &x); B[i] |= (1 << j) * x; } } vis[7] = ct[0] = vis[0] = mrk[0] = 1; for (int i = 1; i <= 7; i++) { for (int j = 1; j <= 7; j++) { for (int k = 0; !vis[j] && k < n; k++) { if (vis[A[k]] && (A[k] & B[k]) == j) { vis[j] = k + 1; ct[k] = mrk[k] = 1; ans.push_back({vis[A[k]], k + 1}); } for (int _k = (A[k] - 1) & A[k]; _k != 0 && !vis[j]; _k = (_k - 1) & A[k]) { if (vis[A[k] ^ _k] && vis[_k] && (B[k] & A[k]) == j) { vis[j] = k + 1; ct[k] = mrk[k] = 1; ans.push_back({vis[_k], k + 1}); ans.push_back({vis[A[k] ^ _k], k + 1}); } if (!vis[j] && vis[A[k] ^ _k] && vis[_k] && A[k] == j) { vis[j] = k + 1; mrk[k] = 1; ans.push_back({vis[_k], k + 1}); ans.push_back({vis[A[k] ^ _k], k + 1}); } } } } } for (int i = 0; i < n; i++) { if (!vis[A[i]]) return !printf( Impossible n ); if (!mrk[i] && A[i] != 0) ans.push_back({vis[A[i]], i + 1}); } printf( Possible n ); for (int i = 0; i < n; i++) printf( %d , ct[i]); printf( n%d n , (int)ans.size()); for (auto it : ans) printf( %d %d n , it.first, it.second); return 0; } |
#include <bits/stdc++.h> using namespace std; int n; const int mxN = 1000; int prnt[mxN]; int rnk[mxN]; vector<int> adj[mxN]; vector<pair<int, int>> ans; int vis[mxN]; int find(int i) { if (prnt[i] != i) prnt[i] = find(prnt[i]); return prnt[i]; } void join(int x, int y) { int xroot = find(x); int yroot = find(y); if (rnk[xroot] < rnk[yroot]) prnt[xroot] = yroot; else if (rnk[xroot] > rnk[yroot]) prnt[yroot] = xroot; else { prnt[yroot] = xroot; rnk[xroot]++; } } void dfs(int u, int e) { for (auto ad = adj[u].begin(); ad != adj[u].end(); ad++) { if (*ad == e || vis[*ad]) continue; int adprnt = find(*ad); int uprnt = find(u); if (adprnt == uprnt) { ans.push_back(make_pair(u, *ad)); continue; } join(*ad, u); dfs(*ad, u); } vis[u] = 1; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cin >> n; for (int i = 0; i < n - 1; i++) { int x, y; cin >> x >> y; x--; y--; adj[x].push_back(y); adj[y].push_back(x); } for (int i = 0; i < n; i++) { prnt[i] = i; } for (int i = 0; i < n; i++) { if (!vis[i]) { dfs(i, -1); } } cout << ans.size() << endl; int id = 0; for (int i = 0; i < n; i++) { for (int j = i + 1; j < n; j++) { int x = find(i); int y = find(j); if (x != y) { cout << ans[id].first + 1 << << ans[id].second + 1 << << i + 1 << << j + 1 << endl; id++; join(i, j); } } } return 0; } |
#include <bits/stdc++.h> using namespace std; clock_t time_p = clock(); void time_taken() { time_p = clock() - time_p; cerr << Time Taken : << (float)(time_p) / CLOCKS_PER_SEC << n ; } const long long mod = 1e9 + 7; const long long INF = 1e18; void solve() { int n; cin >> n; vector<int> a(n); for (int i = 0; i < n; i++) cin >> a[i]; int mn = *min_element((a).begin(), (a).end()); vector<int> inds, b; for (int i = 0; i < n; i++) { if (a[i] % mn == 0) inds.push_back(i), b.push_back(a[i]); } sort((b).begin(), (b).end()); int j = 0; for (int x : inds) { a[x] = b[j++]; } if (is_sorted((a).begin(), (a).end())) { cout << YES << n ; } else { cout << NO << n ; } } int main() { ios_base::sync_with_stdio(false), cin.tie(nullptr); int t; cin >> t; while (t--) { solve(); } time_taken(); return 0; } |
#include <bits/stdc++.h> using namespace std; const double PI = 3.1415926535897932384626433832795; const double EPS = 1e-9; set<int> good; void gen(int x) { good.insert(x); if (x > 100 * 1000 * 1000) { return; } gen(10 * x + 4); gen(10 * x + 7); } vector<pair<int, int> > swaps; void addSwap(int i, int j) { if (i != j) { swaps.push_back(pair<int, int>(i, j)); } } bool fail; vector<pair<int, int> > solve(const vector<int>& seq____) { vector<int> seq = seq____; swaps.clear(); fail = false; int where_good = -1; int n = seq.size(); bool sorted = true; for (int i = 0; i < n; ++i) { if (i > 0 && seq[i] < seq[i - 1]) { sorted = false; } if (good.count(seq[i])) { where_good = i; } } if (where_good == -1) { if (!sorted) { fail = true; } return swaps; } int goodNumber = seq[where_good]; int amountLess = 0; for (int i = 0; i < n; ++i) { if (seq[i] < goodNumber) { ++amountLess; } } vector<int> positions; for (int i = 0; i < n; ++i) { if (i != amountLess) { positions.push_back(i); } } set<pair<int, int> > unsorted; for (int i = 0; i < n; ++i) { if (i == where_good) { continue; } unsorted.insert(pair<int, int>(seq[i], i)); } int idInPositions = 0; while (!unsorted.empty()) { pair<int, int> cur = *unsorted.begin(); unsorted.erase(unsorted.begin()); if (cur.second == positions[idInPositions]) { ++idInPositions; continue; } int firstSwapPosition = positions[idInPositions]; bool firstErased = unsorted.count( pair<int, int>(seq[firstSwapPosition], firstSwapPosition)); unsorted.erase(pair<int, int>(seq[firstSwapPosition], firstSwapPosition)); swap(seq[where_good], seq[firstSwapPosition]); if (firstErased) { unsorted.insert(pair<int, int>(seq[where_good], where_good)); } addSwap(where_good, positions[idInPositions]); where_good = firstSwapPosition; int secondSwapPosition = cur.second; bool secondErased = unsorted.count( pair<int, int>(seq[secondSwapPosition], secondSwapPosition)); unsorted.erase(pair<int, int>(seq[secondSwapPosition], secondSwapPosition)); swap(seq[where_good], seq[secondSwapPosition]); if (secondErased) { unsorted.insert(pair<int, int>(seq[where_good], where_good)); } addSwap(where_good, secondSwapPosition); where_good = secondSwapPosition; ++idInPositions; } return swaps; } int main() { int n; gen(4); gen(7); while (cin >> n) { vector<int> seq(n); for (int i = 0; i < seq.size(); ++i) { scanf( %d , &seq[i]); } vector<pair<int, int> > res = solve(seq); if (fail) { cout << -1 << endl; } else { cout << res.size() << endl; for (int i = 0; i < res.size(); ++i) { printf( %d %d n , res[i].first + 1, res[i].second + 1); } } cout << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; const long long M = 2 * (1e5) + 7, mod = 1e9 + 7; signed main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); ; { long long n, x1, x2; cin >> n >> x1 >> x2; vector<pair<long long, long long>> v; v.push_back({-1, -1}); for (long long i = 1; i <= n; i++) { long long x; cin >> x; v.push_back({x, i}); } sort(v.begin(), v.end()); bool ok = 0; for (long long i = 1; i <= n - 1; i++) { long long lo = i, hi = n - 1; while (lo <= hi) { long long mid = (lo + hi) / 2; long long x = (mid - i + 1); long long y = (n - mid); long long lo1 = v[i].first, lo2 = v[mid + 1].first; long double p = x1 / (long double)x; long double q = x2 / (long double)y; if (lo1 >= p && lo2 >= q) { ok = 1; cout << Yes << n ; cout << x << << y << n ; for (long long j = i; j <= mid; j++) { cout << v[j].second << ; } cout << n ; for (long long j = mid + 1; j <= n; j++) { cout << v[j].second << ; } cout << n ; return 0; } if (p <= lo1) hi = mid - 1; else lo = mid + 1; } } swap(x1, x2); for (long long i = 1; i <= n - 1; i++) { long long lo = i, hi = n - 1; while (lo <= hi) { long long mid = (lo + hi) / 2; long long x = (mid - i + 1); long long y = (n - mid); long long lo1 = v[i].first, lo2 = v[mid + 1].first; long double p = x1 / (long double)x; long double q = x2 / (long double)y; if (lo1 >= p && lo2 >= q) { ok = 1; cout << Yes << n ; cout << y << << x << n ; for (long long j = mid + 1; j <= n; j++) { cout << v[j].second << ; } cout << n ; for (long long j = i; j <= mid; j++) { cout << v[j].second << ; } cout << n ; return 0; } if (p <= lo1) hi = mid - 1; else lo = mid + 1; } } if (!ok) cout << No << n ; } return 0; } |
#include <bits/stdc++.h> const int MX = 1e6 + 23; const long long MOD = 998244353; int read() { char k = getchar(); int x = 0; while (k < 0 || k > 9 ) k = getchar(); while (k >= 0 && k <= 9 ) x = x * 10 + k - 0 , k = getchar(); return x; } int n, m, c[MX], w[MX]; int a[MX], b[MX]; struct Choice { int w, id; bool operator<(const Choice &B) const { return w > B.w; } }; int cho[MX]; void solve() { n = read(), m = read(); for (int i = 1; i <= n; ++i) { c[i] = read(); a[i] = c[i] / 100; b[i] = c[i] % 100; if (!b[i]) cho[i] = 1; } long long ans = 0; std::priority_queue<Choice> q; for (int i = 1; i <= n; ++i) { w[i] = read(); if (m >= b[i]) { if (b[i]) { q.push((Choice){(100 - b[i]) * w[i], i}); } } else { if (!q.empty() && q.top().w <= (100 - b[i]) * w[i]) { ans += q.top().w; q.pop(); q.push((Choice){(100 - b[i]) * w[i], i}); } else { ans += (100 - b[i]) * w[i]; } m += 100; } m -= b[i]; } printf( %lld n , ans); while (!q.empty()) { cho[q.top().id] = 1; q.pop(); } for (int i = 1; i <= n; ++i) { if (cho[i]) { printf( %d %d n , a[i], b[i]); } else printf( %d %d n , a[i] + 1, 0); } } int main() { int T = 1; for (int i = 1; i <= T; ++i) { solve(); } return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0); int n, j = 1; string x; cin >> n >> x; for (int i = 1; i <= n; i += j) { cout << x[i - 1]; j++; } return 0; } |
#include <bits/stdc++.h> int Flag, sum, flag[105], n, m, a, b, A[105], map[105][105]; void dfs(int last_last, int last) { int S; flag[last] = 1; for (int i = 1; i <= n; i++) { if (!map[last][i]) continue; if (map[i][last_last]) { S = A[i] + A[last] + A[last_last]; if (S < sum) sum = S; } if (!flag[i]) dfs(last, i); } } int main() { while (~scanf( %d%d , &n, &m)) { memset(flag, 0, sizeof(flag)); memset(map, 0, sizeof(map)); for (int i = 1; i <= n; i++) scanf( %d , &A[i]); for (int i = 1; i <= m; i++) { scanf( %d%d , &a, &b); map[a][b] = 1; map[b][a] = 1; } Flag = 0; sum = 99999999; dfs(0, 1); if (sum == 99999999) printf( -1 n ); else printf( %d n , sum); } return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); int vs, ve; int t, d; cin >> vs >> ve >> t >> d; int cur = vs; int sm = vs; int pre = vs; for (int i = 2; i <= t; i++) { while (cur < ve && abs(pre - cur) < d) cur++; if (cur >= ve) { while ((t - i) * d > cur - ve && abs(pre - cur) < d) cur++; while ((t - i) * d < cur - ve && abs(pre - cur) < d) cur--; } pre = cur; sm += cur; } assert(cur == ve); cout << sm; return 0; } |
#include <bits/stdc++.h> struct count_seg { struct node { std::array<int, 2> c; bool flip = false; }; std::vector<node> seg; count_seg() : seg() {} explicit count_seg(int N) : seg(2 * N) {} std::array<int, 2> query_all() { return seg[1].c; } void update_node(int a) { int N = int(seg.size()) >> 1; if (a >= N) { seg[a].c[0] = 0, seg[a].c[1] = 1; } else { seg[a].c[0] = seg[2 * a].c[0] + seg[2 * a + 1].c[0]; seg[a].c[1] = seg[2 * a].c[1] + seg[2 * a + 1].c[1]; } if (seg[a].flip) std::swap(seg[a].c[0], seg[a].c[1]); } void flip_node(int a) { seg[a].flip ^= 1; std::swap(seg[a].c[0], seg[a].c[1]); } void flip_leaf_lazy(int l) { int N = int(seg.size()) >> 1; seg[N + l].flip ^= 1; } void flip_range(int l, int r) { int N = int(seg.size()) >> 1; for (int a = l + N, b = r + N; a < b; a >>= 1, b >>= 1) { if (a & 1) flip_node(a++); if (b & 1) flip_node(--b); } for (int a = l + N; a; a >>= 1) update_node(a); for (int b = r + N - 1; b; b >>= 1) update_node(b); } void update_all() { for (int i = int(seg.size()) - 1; i; --i) update_node(i); } }; struct big_seg { struct mat { std::array<std::array<std::array<int, 2>, 2>, 2> v; friend mat operator*(const mat& a, const mat& b) { mat res; for (int i = 0; i < 2; i++) { for (int j = 0; j < 2; j++) { for (int z = 0; z < 2; z++) { res.v[i][j][z] = std::min(a.v[i][j][0] + b.v[i][j][z], a.v[i][j][1] + b.v[!i][!j][!z]); } } } return res; } int eval(std::array<int, 2> st, std::array<int, 2> en) const { int res = st[0] + v[0][0][0] + en[0]; for (int i = 0; i < 2; i++) { for (int j = 0; j < 2; j++) { res = std::min(res, st[i] + v[i][i][i ^ j] + en[j]); } } return res; } }; struct node { mat m; std::array<bool, 2> flip = {false, false}; }; int N, M; std::vector<node> seg; big_seg() : N(0), seg() {} big_seg(int N_, int M_) : N(N_), M(M_), seg() { int S = 1; while (S < N) S *= 2; seg.resize(2 * S); } mat query_all() { return seg[1].m; } void update_node(int a) { int S = int(seg.size()) >> 1; if (a >= S) { if (a - S < N) { for (int i = 0; i < 2; i++) { for (int j = 0; j < 2; j++) { seg[a].m.v[i][j][0] = i + j; seg[a].m.v[i][j][1] = i + j + M; } } } else { for (int i = 0; i < 2; i++) { for (int j = 0; j < 2; j++) { seg[a].m.v[i][j][0] = 0; seg[a].m.v[i][j][1] = 0 + M; } } } } else { seg[a].m = seg[2 * a].m * seg[2 * a + 1].m; } if (seg[a].flip[0]) { swap(seg[a].m.v[0], seg[a].m.v[1]); } if (seg[a].flip[1]) { swap(seg[a].m.v[0][0], seg[a].m.v[0][1]); swap(seg[a].m.v[1][0], seg[a].m.v[1][1]); } } void flip_node(int a, bool z) { seg[a].flip[z] ^= 1; if (z == 0) { swap(seg[a].m.v[0], seg[a].m.v[1]); } else if (z == 1) { swap(seg[a].m.v[0][0], seg[a].m.v[0][1]); swap(seg[a].m.v[1][0], seg[a].m.v[1][1]); } else assert(false); } void flip_leaf_lazy(int l, bool z) { int S = int(seg.size()) >> 1; seg[S + l].flip[z] ^= 1; } void flip_range(int l, int r, bool z) { int S = int(seg.size()) >> 1; for (int a = l + S, b = r + S; a < b; a >>= 1, b >>= 1) { if (a & 1) flip_node(a++, z); if (b & 1) flip_node(--b, z); } for (int a = l + S; a; a >>= 1) update_node(a); for (int b = r + S - 1; b; b >>= 1) update_node(b); } void update_all() { for (int i = int(seg.size()) - 1; i; --i) update_node(i); } }; int main() { using namespace std; ios_base::sync_with_stdio(false), cin.tie(nullptr); array<int, 2> N; int Q; cin >> N[0] >> N[1] >> Q; array<array<count_seg, 2>, 2> count_segs; array<big_seg, 2> big_segs; for (int a = 0; a < 2; a++) { big_segs[a] = big_seg(N[a], N[!a]); for (int b = 0; b < 2; b++) { count_segs[a][b] = count_seg(N[a]); string S; cin >> S; assert(int(S.size()) == N[a]); for (int i = 0; i < N[a]; i++) { if (S[i] == R ) { count_segs[a][b].flip_leaf_lazy(i); big_segs[a].flip_leaf_lazy(i, b); } } count_segs[a][b].update_all(); } big_segs[a].update_all(); } auto query = [&]() -> int { int ans = 2 * N[0] + 2 * N[1]; for (int z = 0; z < 2; z++) { int cnd = big_segs[!z].query_all().eval(count_segs[z][0].query_all(), count_segs[z][1].query_all()); ans = min(ans, cnd); } return ans; }; cout << query() << n ; for (int q = 0; q < Q; q++) { char side; int l, r; cin >> side >> l >> r; l--; bool dim, z; switch (side) { case L : dim = 0, z = 0; break; case R : dim = 0, z = 1; break; case U : dim = 1, z = 0; break; case D : dim = 1, z = 1; break; default: assert(false); } assert(0 <= l && l < r && r <= N[dim]); count_segs[dim][z].flip_range(l, r); big_segs[dim].flip_range(l, r, z); cout << query() << n ; } return 0; } |
#include <bits/stdc++.h> using namespace std; long long tree[4 * 100100]; long long a[100100]; int n; void build(int from, int to, int node) { if (from == to) { tree[node] = a[from]; return; } int mid = (from + to) / 2; build(from, mid, 2 * node); build(mid + 1, to, 2 * node + 1); tree[node] = max(tree[2 * node], tree[2 * node + 1]); } long long val; void update(int from, int to, int node) { if (from == to) { tree[node] = val; return; } int mid = (from + to) / 2; update(from, mid, 2 * node); tree[node] = max(tree[2 * node], tree[2 * node + 1]); } long long query(int from, int to, int node, int low, int high) { if (low > to || from > high) { return 0; } if (from >= low && to <= high) { return tree[node]; } int mid = (from + to) / 2; return max(query(from, mid, 2 * node, low, high), query(mid + 1, high, 2 * node + 1, low, high)); } long long b[100100]; int main() { scanf( %d , &n); for (int i = 0; i < n; i++) { cin >> a[i]; } b[0] = a[0]; b[1] = a[1]; for (int i = 2; i < n; i++) { b[i] = max(b[i - 1], a[i]); } int Q; scanf( %d , &Q); while (Q--) { long long w, h; cin >> w >> h; cout << max(b[0], b[w - 1]) << endl; b[0] = (max(b[0], b[w - 1]) + h); } return 0; } |
#include <bits/stdc++.h> using namespace std; struct gam { int o; long long k; int nez; long long bd; long long kd; gam() { o = 0; k = 0; nez = 0; bd = 0; kd = 0; } }; bool mycomp(gam i, gam j) { return (i.k < j.k); } int main() { long long n; long long r; long long tr; long long sum = 0; cin >> n; cin >> r; cin >> tr; gam* a = new gam[n + 1]; a[0].k = 0; for (int i = 1; i <= n; i++) { cin >> a[i].o; cin >> a[i].k; a[i].nez = r - a[i].o; sum = sum + a[i].o; } sort(a + 1, a + n + 1, mycomp); long long nug = tr * n - sum; if (nug > 0) { int cur; for (int i = 1; i <= n; i++) { a[i].bd = a[i - 1].bd + a[i].nez; a[i].kd = a[i - 1].kd + a[i].k * a[i].nez; if (a[i].bd >= nug) { cur = i; break; } } long long enug = nug - a[cur - 1].bd; long long rez = a[cur - 1].kd + enug * a[cur].k; cout << rez; } else cout << 0; return 0; } |
#include <bits/stdc++.h> using namespace std; template <typename X> inline X abs(const X& a) { return a < 0 ? -a : a; } template <typename X> inline X sqr(const X& a) { return a * a; } int main() { ios::sync_with_stdio(0); cin.tie(0); long long n; cin >> n; double first = (sqrt(8.0 * n + 1) - 1) / 2; int out = (first - floor(first)) * (first + 1); if (out == 0) cout << (int)first; else cout << out; } |
#include <bits/stdc++.h> using namespace std; const int maxn = 105; int a[maxn]; long long n, k; bool ok(long long d) { long long ret = 0; for (int i = 0; i < n; ++i) { ret += (a[i] - 1 + d) / d; } return ret * d <= k; } int main() { ios::sync_with_stdio(false); cin.tie(0); cin >> n >> k; for (int i = 0; i < n; ++i) cin >> a[i], k += a[i]; long long ans = 0; for (long long i = 1; i <= sqrt(k) + 1; ++i) { if (ok(i)) ans = max(ans, i); if (ok(k / i)) ans = max(ans, k / i); } cout << ans << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; long long max(long long a, long long b) { if (a > b) { return a; } else { return b; } } long long min(long long a, long long b) { if (a < b) { return a; } else { return b; } } struct P { double x, y; P() {} P(double x, double y) : x(x), y(y) {} P operator+(const P &a) const { return P(x + a.x, y + a.y); } P operator-(const P &a) const { return P(x - a.x, y - a.y); } double operator^(const P &a) const { return x * a.x + y * a.y; } void in() { scanf( %lf%lf , &x, &y); } void out() { printf( REQUIRED %.7f %.7f n , x, y); } double dist(P a, P b) { return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y)); } double sqdist(P a, P b) { return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y); } }; int n, k; int a[9999]; int b[9999]; int cc[9999]; int bb[9999]; long long res = -100000000; long long ma[9999]; long long query(long long l, long long r) { int length = r - l + 1; if (length <= k) return ma[length]; int cnt = 0; for (int i = (1); i <= (n); i++) { if ((i < l) || (i > r)) cc[++cnt] = a[i]; } int cnt2 = 0; for (int i = (l); i <= (r); i++) bb[++cnt2] = a[i]; sort(cc + 1, cc + cnt + 1); sort(bb + 1, bb + cnt2 + 1); int go = 0; for (int i = (1); i <= (min(min(cnt, cnt2), k)); i++) { if (cc[cnt - i + 1] > bb[i]) go = i; } for (int i = (1); i <= (go); i++) bb[i] = cc[cnt - i + 1]; long long sum = 0; for (int i = (1); i <= (cnt2); i++) sum += bb[i]; return sum; } int main() { scanf( %d%d , &n, &k); for (int i = (1); i <= (n); i++) scanf( %d , &a[i]); for (int i = (1); i <= (n); i++) b[i] = a[i]; sort(b + 1, b + n + 1); ma[0] = 0; for (int i = (n); i >= (1); i--) { ma[n - i + 1] = ma[n - i] + b[i]; } for (int i = (1); i <= (n); i++) { for (int j = (i); j <= (n); j++) { res = max(res, query(i, j)); } } printf( %I64d n , res); return 0; } |
#include <bits/stdc++.h> using namespace std; void DFS(int s); vector<int> v[60]; int d = 0; int c[200]; int main() { int n, m; scanf( %d %d , &n, &m); for (int i = 0; i <= 50; i++) v[i].clear(); memset(c, 0, sizeof(c)); for (int i = 1; i <= m; i++) { int u, vv; scanf( %d %d , &u, &vv); v[u].push_back(vv); v[vv].push_back(u); } int mx = 0; for (int i = 1; i <= n; i++) { if (c[i] == 0) { d = 0; DFS(i); mx = mx + d - 1; } } printf( %I64d n , (long long)pow(2, mx)); return 0; } void DFS(int s) { d++; c[s] = 1; int sz = v[s].size(); for (int i = 0; i < sz; i++) { int x = v[s][i]; if (c[x] == 0) { DFS(x); } } } |
#include <bits/stdc++.h> using namespace std; const long long maxx = 1e9 + 7; bool compare(const pair<long long, long long> &a, const pair<long long, long long> &b) { return a.first > b.first || (a.first == b.first && a.second < b.second); } long long inline power(long long a, long long b, long long p) { a %= p; long long ans = 1; while (b > 0) { if (b & 1) ans = (ans * a) % p; a = (a * a) % p; b >>= 1; } return ans; } long long inv(long long n, long long p) { return power(n, p - 2, p); } bool inline isPrime(long long n) { if (n <= 1) return false; if (n <= 3) return true; if (n % 2 == 0 || n % 3 == 0) return false; for (long long i = 5; i * i <= n; i = i + 6) if (n % i == 0 || n % (i + 2) == 0) return false; return true; } template <class T> void printv(T &v, long long n) { if (n == -1) n = v.size(); for (long long i = 0; i < n; i++) cout << v[i] << ; cout << n ; } const long long maxn = 2e5 + 5; vector<long long> parent(maxn, 0); vector<vector<long long> > v; long long start; vector<long long> pos(maxn); vector<pair<long long, long long> > gap(maxn); void dfs(long long node) { start++; pos[start] = node; gap[node].first = start; for (auto &x : v[node]) { if (x == parent[node]) continue; dfs(x); } gap[node].second = start; } void solve() { long long n, q, u, k; cin >> n >> q; start = 0; v.assign(n + 1, vector<long long>()); for (long long i = 1; i <= n - 1; i++) { cin >> parent[i + 1]; v[i + 1].push_back(parent[i + 1]); v[parent[i + 1]].push_back(i + 1); } for (auto &x : v) sort(x.begin(), x.end()); dfs(1); for (long long i = 1; i <= q; i++) { cin >> u >> k; if (gap[u].second - gap[u].first + 1 < k) { cout << -1 << n ; continue; } cout << pos[((gap[u].first) + k - 1)] << n ; } } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); long long test = 1; while (test--) { solve(); } } |
#include <bits/stdc++.h> using namespace std; const long long M = 2e5 + 10; const long long INF = 0x3f3f3f3f; const long long mod = 998244353; int mans = INF; int n, c, dp[M][2], f[M], l[M]; int main() { scanf( %d%d , &n, &c); memset(dp, INF, sizeof(dp)); for (int i = 1; i < n; i++) scanf( %d , &f[i]); for (int i = 1; i < n; i++) scanf( %d , &l[i]); dp[0][0] = c; dp[0][1] = 0; for (int i = 1; i < n; i++) { dp[i][0] = min(dp[i - 1][0], dp[i - 1][1] + c) + l[i]; dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + f[i]; } for (int i = 0; i < n; i++) printf( %d , min(dp[i][0], dp[i][1])); puts( ); return 0; } |
#include <bits/stdc++.h> #pragma comment(linker, /STACK:16777216 ) using namespace std; const double eps = 1e-9; const double pi = acos(-1.0); const long long INF = (long long)1e18; int n; long long a[11], val[11]; long long dp[1 << 8][1 << 8]; int lastBit[1 << 8]; long long del[11][1 << 8]; long long get(long long v) { long long i = 2; long long res = 0; while (i * i <= v) { while (v % i == 0) { res++; v /= i; } i++; } if (v > 1) { res++; } return res; } long long dfs(int mask1, int mask2) { if (mask1 == 0 && mask2 == 0) return 0; if (mask2 == 0 && mask1 != 0) return INF; long long &res = dp[mask1][mask2]; if (res != -1) return res; res = INF; int last = lastBit[mask2]; for (int sub = mask1;; sub = (sub - 1) & mask1) { if (del[last][sub] != -1) { res = min(res, dfs(mask1 ^ sub, mask2 ^ (1 << last) ^ sub) + 1 + (sub == 0 ? val[last] : del[last][sub])); } if (sub == 0) break; } return res; } int main() { cin >> n; for (int i = 0; i < n; i++) { cin >> a[i]; } sort(a, a + n); for (int i = 0; i < n; i++) { val[i] = get(a[i]); if (val[i] == 1) val[i] = 0; } for (int mask = 0; mask < (1 << n); mask++) { int last = -1; for (int i = 0; i < n; i++) if (mask & (1 << i)) { last = i; } lastBit[mask] = last; } for (int i = 0; i < n; i++) { for (int mask = 0; mask < (1 << n); mask++) { long long v = a[i]; for (int j = 0; j < n; j++) if (mask & (1 << j)) { if (v % a[j] != 0) { v = -1; break; } else { v /= a[j]; } } del[i][mask] = v == -1 ? -1 : get(v); } } memset(dp, -1, sizeof(dp)); long long res = INF; for (int mask = 1; mask < (1 << n); mask++) { res = min(res, dfs(((1 << n) - 1) ^ mask, mask) + (__builtin_popcountll(mask) == 1 ? 0 : 1)); } cout << res << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; int n, d, res; int a[200005]; int main() { cin >> n; for (int i = 1; i <= n; ++i) { cin >> a[i]; if (a[i] == 2) d++; } if (d <= n / 2) { res += d; n -= 2 * d; res += n / 3; cout << res; return 0; } else { cout << n - d; } } |
#include <bits/stdc++.h> using namespace std; int main() { int n, m; scanf( %d%d , &n, &m); printf( %d n , min(n, m) + 1); for (int i = 0; i <= min(n, m); i++) { printf( %d %d n , min(n, m) - i, i); } } |
#include <bits/stdc++.h> using namespace std; const int inf = 0x3f3f3f3f; int n; int a[10001], c[10001], d[10001]; int ans = 0; char str[101]; int main() { scanf( %d , &n); for (int i = 1; i <= n; i++) { scanf( %s , str); if (str[0] == M ) a[i] = 1; scanf( %d %d , &c[i], &d[i]); } for (int i = 1; i <= 366; i++) { int x = 0, y = 0; for (int j = 1; j <= n; j++) { if (c[j] <= i && i <= d[j]) { if (a[j]) ++x; else ++y; } } ans = max(ans, min(x, y)); } printf( %d n , ans * 2); return 0; } |
#include <bits/stdc++.h> using namespace std; char s1[5010], s2[5010]; int dp[5010][5010]; int main() { int i, j, ind, n, m, ans; cin >> n >> m; cin >> s1; cin >> s2; for (i = 1; i <= n; i++) { for (j = 1; j <= m; j++) { dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) - 1; if (s1[i - 1] == s2[j - 1]) { dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + 2); dp[i][j] = max(dp[i][j], 2); } } } ans = 0; for (i = 0; i <= n; i++) { for (j = 0; j <= m; j++) ans = max(ans, dp[i][j]); } cout << ans; } |
#include <bits/stdc++.h> using namespace std; template <typename T> void maxtt(T& t1, T t2) { t1 = max(t1, t2); } template <typename T> void mintt(T& t1, T t2) { t1 = min(t1, t2); } bool debug = 0; int n, m, k; string direc = URDL ; const long long MOD2 = (long long)1000000007 * (long long)1000000007; long long ln, lk, lm; void etp(bool f = 0) { puts(f ? YES : NO ); exit(0); } void addmod(int& x, int y, int mod = 1000000007) { assert(y >= 0); x += y; if (x >= mod) x -= mod; assert(x >= 0 && x < mod); } void et(int x = -1) { printf( %d n , x); exit(0); } long long fastPow(long long x, long long y, int mod = 1000000007) { long long ans = 1; while (y > 0) { if (y & 1) ans = (x * ans) % mod; x = x * x % mod; y >>= 1; } return ans; } long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; } vector<int> mp[44]; int col[44]; int C, I; bool bip = 1; void dfs(int x, int color) { col[x] = color; for (int c : mp[x]) if (col[c] == 0) dfs(c, 3 - color); else if (col[c] != 3 - color) bip = 0; } long long dp[(1 << 20) + 5], rdp[(1 << 20) + 5]; int to[44]; long long cal() { if (n == 1) return 2; int ln = n / 2, rn = n - ln; for (int(i) = 0; (i) < (int)(1 << ln); (i)++) dp[i] = 1; for (int(i) = 1; (i) <= (int)(ln); (i)++) for (int j : mp[i]) if (j <= ln) { dp[(1 << (i - 1)) | (1 << (j - 1))] = 0; } for (int s = 1; s < 1 << ln; s++) { for (int(j) = 0; (j) < (int)(ln); (j)++) if (s & (1 << j)) { if (dp[s ^ (1 << j)] == 0) { dp[s] = 0; break; } } } int msk = (1 << ln) - 1; for (int(i) = 0; (i) < (int)(1 << ln); (i)++) rdp[i] = dp[i ^ msk]; for (int j = 0; j < ln; j++) { for (int i = msk; i >= 0; i--) { if (~i & (1 << j)) { rdp[i] += rdp[i ^ (1 << j)]; } } } for (int(i) = 0; (i) < (int)(1 << rn); (i)++) dp[i] = 1; for (int i = ln + 1; i <= n; i++) for (int j : mp[i]) if (j > ln) { dp[(1 << (i - ln - 1)) | (1 << (j - ln - 1))] = 0; } else { to[i - ln - 1] |= 1 << (j - 1); } for (int s = 1; s < 1 << rn; s++) { for (int(j) = 0; (j) < (int)(rn); (j)++) if (s & (1 << j)) { if (dp[s ^ (1 << j)] == 0) { dp[s] = 0; break; } } } long long ans = 0; for (int(i) = 0; (i) < (int)(1 << rn); (i)++) if (dp[i]) { int s = 0; for (int(j) = 0; (j) < (int)(rn); (j)++) if (i & (1 << j)) s |= to[j]; ans += rdp[s]; } return ans; } void fmain(int tid) { scanf( %d%d , &n, &m); for (int i = 0, u, v; i < m; i++) { scanf( %d%d , &u, &v); mp[u].push_back(v); mp[v].push_back(u); }; for (int(i) = 1; (i) <= (int)(n); (i)++) if (col[i] == 0) { dfs(i, 1); C++; } for (int(i) = 1; (i) <= (int)(n); (i)++) if (mp[i].empty()) I++; long long all = 1LL << n; all -= 1LL << C; all += 1LL << I; if (bip) all += 1LL << C; all += 1LL << I; all -= m == 0 ? 1LL << n : 0; all -= cal() * 2; printf( %lld n , all); } int main() { int t = 1; for (int(i) = 1; (i) <= (int)(t); (i)++) { fmain(i); } return 0; } |
#include <bits/stdc++.h> using namespace std; long long n, k, x; long long inp[200005]; long long precom[64][2]; long long num; long long ans; int main() { cin >> n >> k >> x; long long i, j, kl; for (i = 0; i < n; ++i) { scanf( %lld , &inp[i]); for (j = 0; j < 63; ++j) { if (((long long)1 << j) & inp[i]) precom[j][0]++; } } long long pos = 0; long long ans, tmpans; ans = 0; for (j = 0; j < n; ++j) { num = inp[j]; for (i = 0; i < k; ++i) { num *= x; } for (kl = 0; kl < 64; ++kl) { precom[kl][1] = 0; if ((num & ((long long)1 << kl)) && !(inp[j] & ((long long)1 << kl))) { precom[kl][1] = 1; } if (!(num & ((long long)1 << kl)) && (inp[j] & ((long long)1 << kl))) precom[kl][1] = -1; } tmpans = 0; for (kl = 0; kl < 64; ++kl) { if (precom[kl][0] + precom[kl][1]) tmpans += ((long long)1 << kl); } if (tmpans > ans) { ans = tmpans; } } cout << ans << endl; } |
#include <bits/stdc++.h> using namespace std; const int nax = 3e5 + 5; long long n, x1, x2; array<long long, 2> c[nax]; int main() { ios::sync_with_stdio(0); cin.tie(0); cin >> n >> x1 >> x2; for (int i = 0; i < n; i++) cin >> c[i][0], c[i][1] = i; sort(c, c + n); for (int rep = 0; rep < 2; rep++) { int best = n - 1; for (; ~best; --best) if (c[best][0] >= (x2 + n - best - 1) / (n - best)) break; if (best == -1) continue; for (int k = 1; k < n; k++) { int j = lower_bound(c, c + n, array<long long, 2>{(x1 + k - 1) / k}) - c; if (j + k - 1 >= best) continue; cout << Yes n ; if (rep == 0) { cout << k << << n - best << n ; for (int i = j; i < j + k; i++) cout << c[i][1] + 1 << ; cout << n ; for (int i = best; i < n; i++) cout << c[i][1] + 1 << ; cout << n ; } else { cout << n - best << << k << n ; for (int i = best; i < n; i++) cout << c[i][1] + 1 << ; cout << n ; for (int i = j; i < j + k; i++) cout << c[i][1] + 1 << ; cout << n ; } exit(0); } swap(x1, x2); } cout << No n ; } |
#include <bits/stdc++.h> using namespace std; int n, q; int a[1000007]; int st[1000007]; int en[1000007]; vector<pair<int, int> > v_st[1000007]; long long ans[1000007]; class Tree { public: pair<long long, int> tr[6 * 1000007]; void init(int where, int IL, int IR) { tr[where] = {0, 0}; if (IL == IR) { return; } int mid = (IL + IR) / 2; init(2 * where, IL, mid); init(2 * where + 1, mid + 1, IR); } void update(int where, int IL, int IR, int CURL, int CURR, pair<long long, int> add) { if (CURR < CURL) { return; } if (IR < CURL || CURR < IL) { return; } if (CURL <= IL && IR <= CURR) { tr[where].first += add.first, tr[where].second += add.second; return; } int mid = (IL + IR) / 2; update(2 * where, IL, mid, CURL, CURR, add); update(2 * where + 1, mid + 1, IR, CURL, CURR, add); } pair<long long, int> query(int where, int IL, int IR, int pos) { if (IR < pos || pos < IL) { return {0, 0}; } if (IL == IR) { return tr[where]; } int mid = (IL + IR) / 2; pair<long long, int> ret; if (pos <= mid) { ret = query(2 * where, IL, mid, pos); } else { ret = query(2 * where + 1, mid + 1, IR, pos); } ret = {ret.first + tr[where].first, ret.second + tr[where].second}; return ret; } }; Tree w; void input() { scanf( %d%d , &n, &q); for (int i = 1; i <= n; ++i) { scanf( %d , &a[i]); } for (int i = 1; i <= q; ++i) { scanf( %d , &st[i]); } for (int i = 1; i <= q; ++i) { scanf( %d , &en[i]); v_st[en[i]].push_back({st[i], i}); } } void calc() { stack<int> st; a[0] = n + 1; st.push(0); w.init(1, 1, n); for (int i = 1; i <= n; ++i) { while (a[st.top()] < a[i]) { st.pop(); } w.update(1, 1, n, 1, st.top(), {i - st.top() - 1, 0}); w.update(1, 1, n, st.top() + 1, i, {i, 1}); st.push(i); int sz = v_st[i].size(); for (int j = 0; j < sz; ++j) { pair<long long, int> ret = w.query(1, 1, n, v_st[i][j].first); ans[v_st[i][j].second] += ret.first - 1LL * ret.second * v_st[i][j].first; } } } void solve() { calc(); for (int i = 1; i <= (n >> 1); ++i) { swap(a[i], a[n - i + 1]); } for (int i = 1; i <= n; ++i) { v_st[i].clear(); } for (int i = 1; i <= q; ++i) { st[i] = (n - st[i] + 1); en[i] = (n - en[i] + 1); swap(st[i], en[i]); v_st[en[i]].push_back({st[i], i}); } calc(); for (int i = 1; i <= q; ++i) { printf( %I64d , ans[i] + (en[i] - st[i] + 1)); } printf( n ); } int main() { ios_base ::sync_with_stdio(false); cin.tie(NULL); input(); solve(); return 0; } |
#include <bits/stdc++.h> using namespace std; const int inf = 0x3f3f3f3f; const int maxn = 100005; int a[maxn], b[maxn]; int main() { long long d, k, a, b, t; scanf( %I64d%I64d%I64d%I64d%I64d , &d, &k, &a, &b, &t); if (d < k) { printf( %I64d n , d * a); return 0; } d -= k; long long ans = k * a; long long k1 = k * a + t, k2 = k * b; if (k1 >= k2) { ans += d * b; } else { ans += d / k * k1; d %= k; ans += min(t + d * a, d * b); } printf( %I64d n , ans); return 0; } |
#include <bits/stdc++.h> using namespace std; const long long INF = 2e9 + 10, MAX = 2100, MOD = 1e9 + 7, MAXL = 25; void OUT(long double o, int x) { cout << fixed << setprecision(x) << o; return; } long long dp[MAX][MAX], ra[MAX], a[MAX], re[200000], w[MAX]; vector<int> v[MAX]; pair<long long, long long> c[MAX]; set<int> st; int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); int n, m, t; cin >> n >> m >> t; for (int i = 1; i <= m; i++) { int l, r; cin >> l >> r; for (int j = l + 1; j <= r; j++) ra[j] = 1; } for (int i = 1; i <= t; i++) { cin >> c[i].first >> c[i].second; st.insert(c[i].second); } int cnt = 0; for (int i = 1; i <= 2000; i++) w[i] = INF; for (int u : st) { re[u] = ++cnt; w[cnt] = u; } for (int i = 1; i <= t; i++) v[c[i].first].push_back(re[c[i].second]); for (int i = 1; i <= 2000; i++) dp[0][i] = INF; for (int u : v[0]) dp[0][u] = 0; for (int i = 1; i <= n; i++) { long long mi = INF; for (int j = 1; j <= 2000; j++) mi = min(mi, dp[i - 1][j] + w[j]); if (!ra[i]) mi = min(mi, dp[i - 1][0]); dp[i][0] = mi; for (int j = 1; j <= 2000; j++) dp[i][j] = dp[i - 1][j] + w[j]; for (int u : v[i]) dp[i][u] = min(dp[i][u], mi); } long long ans = INF; for (int i = 0; i <= 2000; i++) ans = min(ans, dp[n][i]); if (ans < INF) cout << ans; else cout << -1; return 0; } |
#include<bits/stdc++.h> using namespace std; namespace Ruri{ #define ms(a,b) memset(a,b,sizeof(a)) #define repi(i,a,b) for(int i=a,bbb=b;i<=bbb;++i)//attention reg int or reg ll ? #define repd(i,a,b) for(int i=a,bbb=b;i>=bbb;--i) #define reps(s) for(int i=head[s],v=e[i].to;i;i=e[i].nxt,v=e[i].to) #define ce(i,r) i==r? n : #define pb push_back #define all(x) x.begin(),x.end() #define gmn(a,b) a=min(a,b) #define gmx(a,b) a=max(a,b) #define fi first #define se second typedef long long ll; typedef unsigned long long ull; typedef double db; const int infi=1e9;//infi较大，注意涉及inf相加时爆int const ll infl=4e18; inline ll ceil_div(ll a,ll b){ return (a+b-1)/b; } inline ll pos_mod(ll a,ll b){ return (a%b+b)%b; } //std::mt19937 rnd(time(0));//std::mt19937_64 rnd(time(0)); } using namespace Ruri; namespace Read{ #define ss(a) scanf( %s ,a) inline int ri(){ int x; scanf( %d ,&x); return x; } inline ll rl(){ ll x; scanf( %lld ,&x); return x; } inline db rd(){ db x; scanf( %lf ,&x); return x; } } namespace DeBug{ #define pr(x) cout<<#x<< : <<(x)<<endl #define pra(x,a,b) cout<<#x<< : <<endl; repi(i,a,b) cout<<x[i]<< ; puts( ); #define FR(a) freopen(a, r ,stdin) #define FO(a) freopen(a, w ,stdout) } using namespace Read; using namespace DeBug; const int MAX_N=105; const int mod=1e9+7; inline void Add(int &x,int y){ x+=y;if(x>=mod) x-=mod; } int n,b[MAX_N],c[MAX_N]; int sb[MAX_N]; int f[MAX_N*MAX_N],g[MAX_N*MAX_N]; map<int,int> ans; int Solve(int x) { repi(i,0,10001) g[i]=1; repi(i,1,n){ int lim=i*x+sb[i]; ms(f,0); for(int j=max(0,lim);j<=10001;++j) f[j]=(g[j]-(j-c[i]-1>=0?g[j-c[i]-1]:0)+mod)%mod; ms(g,0),g[0]=f[0]; for(int j=1;j<=10001;++j) g[j]=(1ll*g[j-1]+f[j])%mod; } return g[10001]; } int main() { n=ri(); int prod=1; repi(i,1,n) c[i]=ri(),prod=1ll*prod*(c[i]+1)%mod; repi(i,1,n-1) b[i]=ri(); repi(i,1,n)repi(j,1,i-1) sb[i]+=(i-j)*b[j]; int l=0,r=infi,mx_c=*max_element(c+1,c+n+1); repi(i,1,n) gmn(l,-((sb[i]-1)/i+1)),gmn(r,(n*mx_c-sb[i]-1)/i+1); repi(i,l,r) ans[i]=Solve(i); int Q=ri(); while(Q--) { int x=ri(); if(x>r) puts( 0 ); else if(x<l) printf( %d n ,prod); else printf( %d n ,ans[x]); } return 0; } |
#include <bits/stdc++.h> using namespace std; int blk_size; struct node { int l, r, id; long long int ans = 0; }; bool compare(node a, node b) { if (a.l / blk_size != b.l / blk_size) return (a.l) / blk_size < (b.l) / blk_size; return a.r < b.r; } bool compare2(node a, node b) { return a.id < b.id; } long long int freq[3000001]; int main() { ios_base::sync_with_stdio(false); ; int n, m, k; cin >> n >> m >> k; std::vector<int> a(n), pxor(n + 1); for (int i = 0; i < n; i++) cin >> a[i]; pxor[0] = 0; for (int i = 1; i <= n; i++) pxor[i] = pxor[i - 1] ^ a[i - 1]; blk_size = sqrt(n + 1); std::vector<node> q(m); for (int i = 0; i < m; i++) { cin >> q[i].l >> q[i].r; q[i].id = i; } sort(q.begin(), q.end(), compare); int start = 0, end = 0; long long int ans = 0; freq[0] = 1; for (int i = 0; i < m; i++) { int l = q[i].l - 1, r = q[i].r; while (start > l) { start--; ans += freq[pxor[start] ^ k]; freq[pxor[start]]++; } while (start < l) { freq[pxor[start]]--; ans -= freq[pxor[start] ^ k]; start++; } while (end > r) { freq[pxor[end]]--; ans -= freq[pxor[end] ^ k]; end--; } while (end < r) { end++; ans += freq[pxor[end] ^ k]; freq[pxor[end]]++; } q[i].ans = ans; } sort(q.begin(), q.end(), compare2); for (int i = 0; i < m; i++) cout << q[i].ans << n ; return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; for (int i = n, p = 1; i - 1; i >>= 1, p <<= 1) { for (int j = 0; j < (i + 1) / 2; j++) cout << p << ; if (n % p) n -= p / 2; } cout << n; } |
#include <bits/stdc++.h> using namespace std; int nx[1000514 * 2][26], spt; int fl[1000514 * 2], ll[1000514 * 2], lp[1000514 * 2]; int newnode() { memset(nx[spt], 0, sizeof(nx[spt])); fl[spt] = ll[spt] = lp[spt] = 0; return spt++; } int dp[1000514 * 2]; void add(int root, int& last, char A) { int a = A - a ; int p = last; int np = last = newnode(); ll[np] = ll[p] + 1; lp[np] = 0; dp[np] = 1; for (; p && nx[p][a] == 0; p = fl[p]) nx[p][a] = np; int q = nx[p][a]; if (p == 0) fl[np] = root; else if (ll[q] == ll[p] + 1) fl[np] = q; else { int nq = spt++; memcpy(nx[nq], nx[q], sizeof(nx[q])); fl[nq] = fl[q]; ll[nq] = ll[p] + 1; lp[nq] = lp[q] + ll[q] - 1 - ll[p]; fl[q] = fl[np] = nq; for (; p && nx[p][a] == q; p = fl[p]) nx[p][a] = nq; } } char s[1000514], r[1000514 * 2]; vector<int> bk[1000514]; int vs[1000514 * 2], vt; void make_z(int* z, char* s, int l) { int j = z[0] = 0; for (int i = 1; i < l; i++) { z[i] = (i > j + z[j] - 1) ? 0 : min(z[i - j], j + z[j] - i); for (; i + z[i] < l && s[z[i]] == s[i + z[i]]; z[i]++) ; if (i + z[i] > j + z[j]) j = i; } } int z[1000514 * 2]; void sol() { spt = 1; int last; int root = last = newnode(); int sl = 0; for (; s[sl]; sl++) ; for (int i = 0; i < sl; i++) add(root, last, s[i]); for (int i = 1; i < spt; i++) { bk[ll[i]].push_back(i); } for (int i = sl; i >= 0; i--) { int sz = (int)bk[i].size(); for (int j = 0; j < sz; j++) { int w = bk[i][j]; dp[fl[w]] += dp[w]; } } int Q; scanf( %d , &Q); for (int T = 0; T < Q; T++) { scanf( %s , r); int rl = 0; for (; r[rl]; rl++) ; for (int i = 0; i < rl; i++) r[rl + i] = r[i]; r[rl + rl] = 0; make_z(z, r, rl * 2); int t = 0; for (int i = 1; i <= rl; i++) { if (rl % i) continue; int flag = 0; for (int j = i; j < rl; j += i) { if (z[j] < i) { flag = 1; } } if (flag) continue; t = i; break; } int p = root; int l = 0; for (int i = 0; i < rl; i++) { int a = r[i] - a ; for (; p && nx[p][a] == 0; p = fl[p]) ; if (p == 0) { l = 0; p = root; } else { l = min(l, ll[p]) + 1; p = nx[p][a]; } } vt++; int ans = 0; if (l >= rl && vs[p] != vt) { vs[p] = vt; ans += dp[p]; } for (int i = 0; i < t - 1; i++) { int a = r[i] - a ; for (; p && nx[p][a] == 0; p = fl[p]) ; if (p == 0) { l = 0; p = root; } else { l = min(l, ll[p]) + 1; p = nx[p][a]; } for (; p && ll[fl[p]] >= rl; p = fl[p]) ; l = min(l, ll[p]); if (l >= rl && vs[p] != vt) { vs[p] = vt; ans += dp[p]; } } printf( %d n , (int)ans); } } int main() { scanf( %s , s); sol(); } |
#include <bits/stdc++.h> using namespace std; bool flag = 0; void dfs(int u, vector<vector<int> > &g, vector<int> &mark, string &order) { mark[u] = 1; for (auto to : g[u]) { if (mark[to] == 1) flag = 1; else if (mark[to] == 0) dfs(to, g, mark, order); } order.push_back( a + u); mark[u] = 2; } int main() { ios::sync_with_stdio(0); int n; cin >> n; vector<string> a(n); for (int i = 0; i < n; i++) cin >> a[i]; vector<vector<int> > g(26); for (int i = 0; i < n - 1; i++) { int size = min((int((a[i]).size())), (int((a[i + 1]).size()))), j; for (j = 0; j < size; j++) if (a[i][j] != a[i + 1][j]) break; if (j < size) g[a[i][j] - a ].push_back(a[i + 1][j] - a ); else if ((int((a[i]).size())) > (int((a[i + 1]).size()))) flag = 1; } vector<int> mark(26); string order; for (int i = 0; i < 26; i++) if (mark[i] == 0) dfs(i, g, mark, order); if (flag) { cout << Impossible n ; } else { reverse(order.begin(), order.end()); cout << order << n ; } return 0; } |
#include <bits/stdc++.h> using namespace std; const int N = 3e5 + 9, mod = 998244353; template <const int32_t MOD> struct modint { int32_t value; modint() = default; modint(int32_t value_) : value(value_) {} inline modint<MOD> operator+(modint<MOD> other) const { int32_t c = this->value + other.value; return modint<MOD>(c >= MOD ? c - MOD : c); } inline modint<MOD> operator-(modint<MOD> other) const { int32_t c = this->value - other.value; return modint<MOD>(c < 0 ? c + MOD : c); } inline modint<MOD> operator*(modint<MOD> other) const { int32_t c = (int64_t)this->value * other.value % MOD; return modint<MOD>(c < 0 ? c + MOD : c); } inline modint<MOD> &operator+=(modint<MOD> other) { this->value += other.value; if (this->value >= MOD) this->value -= MOD; return *this; } inline modint<MOD> &operator-=(modint<MOD> other) { this->value -= other.value; if (this->value < 0) this->value += MOD; return *this; } inline modint<MOD> &operator*=(modint<MOD> other) { this->value = (int64_t)this->value * other.value % MOD; if (this->value < 0) this->value += MOD; return *this; } inline modint<MOD> operator-() const { return modint<MOD>(this->value ? MOD - this->value : 0); } modint<MOD> pow(uint64_t k) const { modint<MOD> x = *this, y = 1; for (; k; k >>= 1) { if (k & 1) y *= x; x *= x; } return y; } modint<MOD> inv() const { return pow(MOD - 2); } inline modint<MOD> operator/(modint<MOD> other) const { return *this * other.inv(); } inline modint<MOD> operator/=(modint<MOD> other) { return *this *= other.inv(); } inline bool operator==(modint<MOD> other) const { return value == other.value; } inline bool operator!=(modint<MOD> other) const { return value != other.value; } inline bool operator<(modint<MOD> other) const { return value < other.value; } inline bool operator>(modint<MOD> other) const { return value > other.value; } }; template <int32_t MOD> modint<MOD> operator*(int64_t value, modint<MOD> n) { return modint<MOD>(value) * n; } template <int32_t MOD> modint<MOD> operator*(int32_t value, modint<MOD> n) { return modint<MOD>(value % MOD) * n; } template <int32_t MOD> istream &operator>>(istream &in, modint<MOD> &n) { return in >> n.value; } template <int32_t MOD> ostream &operator<<(ostream &out, modint<MOD> n) { return out << n.value; } using mint = modint<mod>; vector<mint> Thomas(vector<vector<mint>> a) { int n = a.size(); for (int i = 1; i < n; i++) { mint x = a[i][0] * a[i - 1][1].inv(); a[i][1] -= x * a[i - 1][2]; a[i][3] -= x * a[i - 1][3]; } for (int i = n - 2; i >= 0; i--) { mint x = a[i][2] * a[i + 1][1].inv(); a[i][3] -= x * a[i + 1][3]; } vector<mint> ans; for (int i = 0; i < n; i++) { ans.push_back(a[i][3] * a[i][1].inv()); } return ans; } int a[N]; int32_t main() { ios_base::sync_with_stdio(0); cin.tie(0); int n; cin >> n; mint m = 0; for (int i = 0; i < n; i++) cin >> a[i], m += a[i]; vector<vector<mint>> mat(m.value + 1); for (int i = 0; i <= m.value; i++) { vector<mint> v(4, 0); if (i) v[0] = mint(i) / m; v[1] = (m - i) * (n - 2) / m / (n - 1) - 1; if (i + 1 <= m.value) v[2] = (m - i) / m / (n - 1); v[3] = mint(-i) / m; mat[i] = v; } vector<mint> f = Thomas(mat); mint ans = 0; for (int i = 0; i < n; i++) ans += f[a[i]]; ans -= (n - 1) * f[0] + f[m.value]; cout << ans << n ; return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int a[105], ma = 0, mi = 110, maxi, mini, tc; cin >> tc; for (int i = 0; i < tc; i++) { cin >> a[i]; if (a[i] > ma) { ma = a[i]; maxi = i; } if (a[i] <= mi) { mi = a[i]; mini = i; } } if (maxi > mini) { mini++; } cout << maxi + (tc - 1) - mini << endl; } |
#include <bits/stdc++.h> using namespace std; int main() { char c; int n, b = 0, a = 0; cin >> n; while (n > 0) { cin >> c; if (c == A ) a++; else b++; n--; } if (a > b) cout << Anton ; else if (a < b) cout << Danik ; else cout << Friendship ; return 0; } |
#include <bits/stdc++.h> using namespace std; const long long INF = 1e9 + 7; const int N = 5e5 + 10; int a[N]; int dp[2][N]; int minv[N]; int sum[N]; int n, k, p; class BIT { int a[110]; public: void init() { memset((a), (0x1f), sizeof(a)); } inline int lowbit(int x) { return x & -x; } void add(int x, int v) { x = p - x; while (x < 110) { a[x] = min(a[x], v); x += lowbit(x); } } int sum(int x) { int ret = INF; while (x) { ret = min(ret, a[x]); x -= lowbit(x); } return ret; } } b; template <class T> inline void readint(T &ret) { char c; ret = 0; while ((c = getchar()) < 0 || c > 9 ) ; while (c >= 0 && c <= 9 ) { ret = ret * 10 + (c - 0 ), c = getchar(); } } int main() { readint(n); readint(k); readint(p); int o = 0; for (int i = 1; i <= n; i++) { readint(a[i]); a[i] %= p; sum[i] = sum[i - 1] + a[i]; dp[o][i] = (a[i] + dp[o][i - 1]) % p; } for (int i = 2; i <= k; i++) { o ^= 1; b.init(); memset((dp[o]), (0x1f), sizeof(dp[o])); b.add(0, sum[i - 1]); int tot = 0; for (int j = i; j <= n; j++) { tot = (tot + a[j]); if (tot >= p) tot -= p; dp[o][j] = min(b.sum(tot) - p, b.sum(p)) + tot; int t = (p - tot); if (t == p) t = 0; b.add(t, dp[o ^ 1][j] + t); } } printf( %d n , dp[o][n]); return 0; } |
#include <bits/stdc++.h> using namespace std; int n, k, s[444], dp[444][55][444]; int main() { cin >> n >> k; s[0] = 0; for (int i = 1; i <= n; i++) cin >> s[i], s[i] += s[i - 1]; int ans = 0; for (int i = 1; i <= n; i++) for (int j = 2; j <= min(i, k); j++) for (int l = 1; l <= i - j + 1; l++) for (int h = 1; h <= i - l - j + 2; h++) dp[i][j][l] = max(dp[i][j][l], dp[i - l][j - 1][h] + abs(s[i] + s[i - l - h] - 2 * s[i - l])); for (int i = 1; i <= n; i++) for (int j = 1; j <= i - k + 1; j++) ans = max(ans, dp[i][k][j]); cout << ans << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; const int INF = 0x3f3f3f3f, N = 5050; int dp[N][N / 2][2], a[N]; int main() { int n; scanf( %d , &n), a[0] = a[n + 1] = -INF; for (int i = 1; i <= n; i++) scanf( %d , a + i); memset(dp, INF, sizeof dp); for (int i = 1; i <= n; i++) dp[i][0][0] = 0; dp[1][1][1] = (a[1] > a[2]) ? 0 : a[2] - a[1] + 1; dp[2][1][1] = max(0, a[1] - a[2] + 1) + max(0, a[3] - a[2] + 1), dp[2][1][0] = dp[1][1][1]; for (int i = 3; i <= n; i++) for (int j = 1; j <= (i + 1) / 2; j++) { dp[i][j][0] = min(dp[i - 1][j][0], dp[i - 1][j][1]); dp[i][j][1] = min(dp[i - 2][j - 1][0] + max(0, a[i - 1] - a[i] + 1), dp[i - 2][j - 1][1] + max(0, min(a[i - 2] - a[i], a[i - 1] - a[i] + 1))) + max(0, (a[i + 1] - a[i] + 1)); } for (int i = 1; i <= (n + 1) / 2; i++) printf( %d , min(dp[n][i][0], dp[n][i][1])); return 0; } |
#include <bits/stdc++.h> using namespace std; int n, k, a, rev[132001 * 2], g[2][132001 * 2], ntt[132001], v1[132001], v2[132001], fr[132001], ifr[132001], as[132001], fg = 255, inv[132001], vl[132001]; int pw(int a, int p) { int as = 1; while (p) { if (p & 1) as = 1ll * as * a % 998244353; a = 1ll * a * a % 998244353; p >>= 1; } return as; } void init(int d) { fr[0] = 1; for (int i = 1; i <= 1 << d; i++) fr[i] = 1ll * fr[i - 1] * i % 998244353; ifr[1 << d] = pw(fr[1 << d], 998244353 - 2); for (int i = (1 << d); i >= 1; i--) ifr[i - 1] = 1ll * ifr[i] * i % 998244353, inv[i] = 1ll * fr[i - 1] * ifr[i] % 998244353; for (int i = 2; i <= 1 << d; i <<= 1) for (int j = 0; j < i; j++) rev[i + j] = (rev[i + (j >> 1)] >> 1) + (j & 1 ? i >> 1 : 0); for (int t = 0; t < 2; t++) for (int i = 2; i <= 1 << d; i <<= 1) { int tp = pw(3, 998244353 - 1 + (998244353 - 1) * (t * 2 - 1) / i); for (int j = 0, vl = 1; j < (i >> 1); j++, vl = 1ll * vl * tp % 998244353) g[t][i + j] = vl; } } void dft(int s, int *a, int t) { for (int i = 0; i < s; i++) ntt[rev[s + i]] = a[i]; for (int l = 2; l <= s; l <<= 1) for (int i = 0; i < s; i += l) for (int j = i, st = l; j < i + (l >> 1); j++, st++) { int v1 = ntt[j], v2 = 1ll * ntt[j + (l >> 1)] * g[t][st] % 998244353; ntt[j] = (v1 + v2) % 998244353; ntt[j + (l >> 1)] = (v1 - v2 + 998244353) % 998244353; } int tp = t ? 1 : pw(s, 998244353 - 2); for (int i = 0; i < s; i++) a[i] = 1ll * ntt[i] * tp % 998244353; } vector<int> add(vector<int> a, vector<int> b) { vector<int> c; int s1 = a.size(), s2 = b.size(); for (int i = 0; i < s1 || i < s2; i++) c.push_back(((i < s1 ? a[i] : 0) + (i < s2 ? b[i] : 0)) % 998244353); return c; } vector<int> mul(vector<int> a, vector<int> b, int n = 1e7) { vector<int> c; int s1 = a.size(), s2 = b.size(); for (int i = 0; i < s1 + s2 - 1; i++) c.push_back(0); if (s1 + s2 <= fg) { for (int i = 0; i < s1; i++) for (int j = 0; j < s2; j++) c[i + j] = (c[i + j] + 1ll * a[i] * b[j]) % 998244353; while (c.size() > n) c.pop_back(); return c; } int l = 1; while (l <= s1 + s2) l <<= 1; for (int i = 0; i < l; i++) v1[i] = v2[i] = 0; for (int i = 0; i < s1; i++) v1[i] = a[i]; for (int i = 0; i < s2; i++) v2[i] = b[i]; dft(l, v1, 1); dft(l, v2, 1); for (int i = 0; i < l; i++) v1[i] = 1ll * v1[i] * v2[i] % 998244353; dft(l, v1, 0); for (int i = 0; i < s1 + s2 - 1; i++) c[i] = v1[i]; while (c.size() > n) c.pop_back(); return c; } vector<int> polyinv(vector<int> a, int n) { while (a.size() < n) a.push_back(0); vector<int> b; for (int i = 0; i < n; i++) b.push_back(0); int tp = min(n, fg), st = pw(a[0], 998244353 - 2); for (int i = 0; i < tp; i++) { int vl = i ? 0 : 1; for (int j = 0; j < i; j++) vl = (vl - 1ll * b[j] * a[i - j] % 998244353 + 998244353) % 998244353; b[i] = 1ll * vl * st % 998244353; } if (n <= fg) return b; int x = 0; while ((n >> x) >= fg * 2 - 1) x++; while (1) { int l1 = ((n - 1) >> x) + 1, l2 = (l1 >> 1) + 1, l = 1; while (l <= l1 * 2 + 4) l <<= 1; for (int i = 0; i < l; i++) v1[i] = v2[i] = 0; for (int i = 0; i < l1; i++) v1[i] = a[i]; for (int i = 0; i < l2; i++) v2[i] = b[i]; dft(l, v1, 1); dft(l, v2, 1); for (int i = 0; i < l; i++) v1[i] = 1ll * v2[i] * (2 - 1ll * v1[i] * v2[i] % 998244353 + 998244353) % 998244353; dft(l, v1, 0); for (int i = 0; i < l1; i++) b[i] = v1[i]; if (!x) return b; x--; } } vector<int> polyln(vector<int> a, int n) { vector<int> v1, v2 = polyinv(a, n), as; for (int i = 1; i < a.size() && i <= n; i++) v1.push_back(1ll * a[i] * i % 998244353); v1 = mul(v1, v2); as.push_back(0); for (int i = 0; i < n; i++) as.push_back(1ll * v1[i] * inv[i + 1] % 998244353); return as; } int main() { init(17); scanf( %d%d , &n, &k); int m = k / 2; vl[0] = 1; for (int i = 1; i <= n; i++) if (i & 1) vl[i] = 1ll * vl[i - 1] * inv[i] % 998244353 * (m - i / 2) % 998244353; else vl[i] = 1ll * vl[i - 1] * inv[i] % 998244353 * (m + i / 2) % 998244353; vector<int> s1, s2; for (int i = 0; i <= n; i++) s1.push_back(i & 1 ? 0 : vl[i]); for (int i = 0; i <= n; i++) s2.push_back(i & 1 ? vl[i] : 0); s2[0] = 998244353 - 1; vector<int> t1 = mul(s2, polyinv(s1, n + 1), n + 1); for (int i = 0; i <= n; i++) if ((i + 3) % 4 > 1) t1[i] = (998244353 - t1[i]) % 998244353; if (k & 1) t1[1] = (t1[1] + 1) % 998244353; for (int i = 1; i <= n; i++) t1[i] = (i & 1) * (998244353 - t1[i]) % 998244353; vector<int> f1 = polyln(t1, n + 1); int as = 1ll * n * (998244353 - f1[n]) % 998244353; if (~n & 1) { for (int i = 2; i <= n; i++) if (i % 4 == 2) s1[i] = (998244353 - s1[i]) % 998244353; s1 = polyln(s1, n + 1); as = (as + 1ll * n * (998244353 - s1[n]) % 998244353) % 998244353; } printf( %d n , as); } |
#include <bits/stdc++.h> using namespace std; map<string, int> m; int main() { int n; cin >> n; string h; cin >> h; m[h]++; for (int i = 0; i < n; i++) { string s; cin >> s; string a = , b = ; for (int i = 0; i < 3; i++) a += s[i]; for (int i = 5; i < 8; i++) b += s[i]; m[a]++; m[b]++; } cout << (m[h] % 2 ? home : contest ) << endl; } |
#include <bits/stdc++.h> using namespace std; bool check(int hr, int min) { if (hr % 10 == 7 || hr / 10 == 7 || min % 10 == 7) { return true; } return false; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); int x, hr, min, res = 0; cin >> x >> hr >> min; while (!check(hr, min)) { min -= x; if (min < 0) { min += 60; hr--; } if (hr < 0) { hr += 24; } res++; } cout << res << n ; return 0; } |
#include <bits/stdc++.h> using namespace std; unsigned long long k, n, i, j, m; unsigned long long v[105][105]; vector<unsigned long long> l; int main() { cin >> n >> m; for (i = 1; i <= n; i++) for (j = 1; j <= m; j++) { cin >> v[i][j]; k = max(k, v[i][j]); } k++; if (n == 1) { cout << YES n ; cout << k << n ; cout << 0 << n ; for (i = 1; i <= m; i++) cout << v[1][i] << ; cout << n ; return 0; } if (m == 1) { cout << YES n ; cout << k << n ; for (i = 1; i <= n; i++) cout << v[i][1] << ; cout << n ; cout << 0 << n ; return 0; } unsigned long long a = v[1][1] + v[2][2]; unsigned long long b = v[1][2] + v[2][1]; unsigned long long j = max(a, b) - min(a, b); if (j == 0) j = k; if (k > j) { cout << NO n ; return 0; } k = j; unsigned long long x = 0; l.push_back(x); for (i = 2; i <= n; i++) { if (v[i][1] < v[i - 1][1]) x = (x + k - v[i - 1][1] + v[i][1]) % k; else x = (x + v[i][1] - v[i - 1][1]) % k; l.push_back(x); } for (i = 0; i < l.size(); i++) { for (j = 1; j <= m; j++) { if ((l[i] + v[1][j]) % k != v[i + 1][j]) { cout << NO n ; return 0; } } } cout << YES n ; cout << k << n ; for (i = 0; i < l.size(); i++) cout << l[i] << ; cout << n ; for (i = 1; i <= m; i++) cout << v[1][i] << ; cout << n ; } |
#include <bits/stdc++.h> using namespace std; int main() { int n, m; cin >> n >> m; if (n > m) swap(n, m); cout << n + 1 << endl; for (m = 0; n >= 0; m++, n--) cout << n << << m << endl; } |
#include <bits/stdc++.h> using namespace std; template <class T> void print(vector<T> v) { cerr << [ ; if (v.size()) cerr << v[0]; for (int i = (1); i < (v.size()); ++i) cerr << , << v[i]; cerr << ] n ; } template <class T> string i2s(T x) { ostringstream o; o << x; return o.str(); } vector<string> splt(string s, char c = ) { vector<string> all; int p = 0, np; while (np = s.find(c, p), np >= 0) { if (np != p) all.push_back(s.substr(p, np - p)); p = np + 1; } if (p < s.size()) all.push_back(s.substr(p)); return all; } int h, w; int data[1700][1700]; int edge[1700][1700]; int dr[] = {-1, 1, 0, 0, -1, -1, 1, 1}; int dc[] = {0, 0, -1, 1, -1, 1, -1, 1}; int main() { cin >> h >> w; for (int i = (0); i < (h); ++i) for (int j = (0); j < (w); ++j) scanf( %d , &data[i][j]); for (int r = (0); r < (h); ++r) for (int c = (0); c < (w); ++c) if (data[r][c]) { for (int d = (0); d < (4); ++d) { int nr = r + dr[d]; int nc = c + dc[d]; if (nr < 0 || nr >= h || nc < 0 || nc >= w || data[nr][nc] == 0) edge[r][c] = 1; } } vector<int> rays; for (int r = (0); r < (h); ++r) for (int c = (0); c < (w); ++c) if (edge[r][c]) { vector<pair<int, int> > v; int cr = r; int cc = c; while (edge[cr][cc]) { v.push_back(make_pair(cr, cc)); edge[cr][cc] = 0; for (int d = (0); d < (8); ++d) { int nr = cr + dr[d]; int nc = cc + dc[d]; if (nr >= 0 && nr < h && nc >= 0 && nc < w && edge[nr][nc]) { cr = nr; cc = nc; break; } } } int bv = -1; int bp = -1; for (int i = (0); i < (v.size()); ++i) for (int j = (15); j < (110); ++j) { int sx = v[i].first; int sy = v[i].second; int ex = v[(i + j) % v.size()].first; int ey = v[(i + j) % v.size()].second; if (abs(sx - ex) > 35 || abs(sy - ey) > 35) break; if (abs(sx - ex) <= 5 && abs(sy - ey) <= 5 && abs(sx - ex) + abs(sy - ey) <= 7) { if (j > bv) { bv = j; bp = i; } } } int count = 0; for (int i = (0); i < (v.size()); ++i) for (int j = (15); j < (110); ++j) { int sx = v[(i + bp) % v.size()].first; int sy = v[(i + bp) % v.size()].second; int ex = v[(i + j + bp) % v.size()].first; int ey = v[(i + j + bp) % v.size()].second; if (i + j > v.size()) break; if (abs(sx - ex) > 35 || abs(sy - ey) > 35) break; if (abs(sx - ex) <= 5 && abs(sy - ey) <= 5 && abs(sx - ex) + abs(sy - ey) <= 7) { count++; i += j; break; } } if (count) rays.push_back(count); } sort(rays.begin(), rays.end()); cout << rays.size() << endl; for (int i = (0); i < (rays.size()); ++i) cout << rays[i] << ; cout << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; char s[500005]; int A[500005][2]; int B[500005]; int C[500005]; int main() { ios::sync_with_stdio(false); int n; memset(A, 0, sizeof(A)); memset(B, 0, sizeof(B)); memset(C, 0, sizeof(C)); cin >> n; for (int i = 0; i < n; i++) { cin >> s; int len = strlen(s); if (s[0] == ) && s[len - 1] == ( ) continue; for (int j = 0; j < len; j++) { if (s[j] == ( ) A[i][0]++; else if (s[j] == ) && A[i][0] > 0) A[i][0]--; else A[i][1]--; } if (A[i][0] >= 0 && A[i][1] == 0) C[i] = A[i][0]; if (A[i][0] == 0 && A[i][1] <= 0) C[i] = A[i][1]; if (C[i] >= 0 && (A[i][0] == 0 || A[i][1] == 0)) B[C[i]]++; } int ans = 0; for (int i = 0; i < n; i++) { if (C[i] < 0) { int t = 0 - C[i]; if (B[t] > 0) { ans++; B[t]--; } } } ans += B[0] / 2; cout << ans << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; int n, k, p, i; struct reg { int x, y, z; } v[100100]; inline bool cmp1(reg a, reg b) { if (a.x != b.x) return a.x > b.x; return a.y > b.y; } inline bool cmp2(reg a, reg b) { return a.y < b.y; } char s[5000]; int main() { int n, sol = 0; cin >> n; cin >> (s + 1); for (i = n + 1; s[i]; i += n) if (s[i - 1] == s[i - 2] && s[i - 2] == s[i - 3]) ++sol; cout << sol << n ; return 0; } |
#include <bits/stdc++.h> using namespace std; int n, m, a, b, mas[30], summ[100005]; long long sum, countt; string s; map<pair<char, long long>, int> matr; int main() { ios_base::sync_with_stdio(false); cin.tie(0); for (int i = 0; i < 26; ++i) cin >> mas[i]; cin >> s; for (int i = 0; i < s.size(); ++i) { if (matr.count(make_pair(s[i], sum))) countt += matr[make_pair(s[i], sum)]; sum += mas[s[i] - a ]; matr[make_pair(s[i], sum)]++; } cout << countt; return 0; } |
#include <bits/stdc++.h> using namespace std; const int INF_INT = 2147483647; const long long INF_LL = 9223372036854775807LL; int gcd(int a, int b) { return ((b == 0) ? a : gcd(b, a % b)); } int lcm(int a, int b) { return a * b / gcd(a, b); } void solve() { int n; cin >> n; long long tmp = 1; while (n) { if (tmp % 3 == 0 || tmp % 10 == 3) { tmp++; continue; } tmp++; n--; } cout << tmp - 1 << endl; } int main() { ios::sync_with_stdio(); cin.tie(); ; int t; cin >> t; while (t--) solve(); } |
#include <bits/stdc++.h> using namespace std; using ll = long long; using pii = pair<int, int>; template <class T> using V = vector<T>; template <class T> using VV = V<V<T>>; constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); } template <class T, class U> void chmin(T &t, const U &u) { if (t > u) t = u; } template <class T, class U> void chmax(T &t, const U &u) { if (t < u) t = u; } template <class T, class U> ostream &operator<<(ostream &os, const pair<T, U> &p) { os << ( << p.first << , << p.second << ) ; return os; } template <class T> ostream &operator<<(ostream &os, const vector<T> &v) { os << { ; for (int i = 0; i < (v.size()); i++) { if (i) os << , ; os << v[i]; } os << } ; return os; } int main() { ios::sync_with_stdio(false); cin.tie(nullptr); int tc; cin >> tc; while (tc--) { int n, m; cin >> n >> m; V<int> ans; VV<int> g(n); for (int i = 0; i < (m); i++) { int a, b; cin >> a >> b; --a, --b; g[a].push_back(b); } VV<int> st(n, V<int>(3)); for (int i = 0; i < (n); i++) { int c; if (st[i][1]) { c = 2; } else if (st[i][0]) { c = 1; } else { c = 0; } if (c == 2) ans.push_back(i); for (int to : g[i]) { st[to][c] = 1; } } cout << ans.size() << n ; for (auto v : ans) cout << v + 1 << ; cout << n ; } return 0; } |
#include <bits/stdc++.h> using namespace std; const long long MOD = 1e9 + 7; const long long INF = LLONG_MAX; int main() { string s; cin >> s; int x = s.size(); cout << 26 * (x + 1) - x; return 0; } |
#include <bits/stdc++.h> using namespace std; int n, m, A, B; double p[25]; double a[625][625], l[625][625], u[625][625]; vector<int> g[25]; double y[625], x[625], b[625]; int id[25][25]; void edge(int ea, int b, int c, int d, double e) { if (ea < b) swap(ea, b); if (c < d) swap(c, d); a[id[ea][b]][id[c][d]] += e; } int main() { scanf( %d %d %d %d , &n, &m, &A, &B); A--, B--; if (A < B) swap(A, B); for (int i = 0; i < (int)(m); i++) { int ue, v; scanf( %d %d , &ue, &v); ue--, v--; g[ue].push_back(v); g[v].push_back(ue); } for (int i = 0; i < (int)(n); i++) scanf( %lf , &p[i]); int N = 0; for (int i = 0; i < (int)(n); i++) for (int j = 0; j < (int)(i + 1); j++) id[i][j] = ++N; for (int i = 0; i < (int)(N + 1); i++) for (int j = 0; j < (int)(N + 1); j++) a[i][j] = 0; for (int i = 0; i < (int)(n); i++) for (int j = 0; j < (int)(i + 1); j++) { if (i == j) { edge(i, j, i, j, 1); continue; } edge(i, j, i, j, p[i] * p[j]); for (int q = 0; q < (int)(g[i].size()); q++) { int qi = g[i][q]; edge(i, j, qi, j, (1 - p[i]) / g[i].size() * p[j]); for (int qq = 0; qq < (int)(g[j].size()); qq++) { int qj = g[j][qq]; edge(i, j, qi, qj, (1 - p[i]) / g[i].size() * (1 - p[j]) / g[j].size()); } } for (int qq = 0; qq < (int)(g[j].size()); qq++) { int qj = g[j][qq]; edge(i, j, i, qj, (1 - p[j]) / g[j].size() * p[i]); } } for (int i = 0; i < (int)(n); i++) for (int j = 0; j < (int)(i); j++) a[id[i][j]][id[i][j]] -= 1; for (int j = 1; j <= N; j++) u[1][j] = a[1][j]; for (int j = 2; j <= N; j++) l[j][1] = a[j][1] / u[1][1]; for (int i = 2; i <= N; i++) { for (int j = i; j <= N; j++) { u[i][j] = a[i][j]; for (int k = 1; k <= i - 1; k++) u[i][j] -= l[i][k] * u[k][j]; } for (int j = i + 1; j <= N; j++) { l[j][i] = a[j][i]; for (int k = 1; k <= i - 1; k++) l[j][i] -= l[j][k] * u[k][i]; l[j][i] /= u[i][i]; } } for (int i = 1; i <= N; i++) l[i][i] = 1.0; for (int d = 0; d < (int)(n); d++) { for (int i = 0; i < (int)(n); i++) for (int j = 0; j < (int)(i + 1); j++) if (i != j) { b[id[i][j]] = 0; } else b[id[i][j]] = i == d; for (int i = 1; i <= N; i++) { y[i] = b[i]; for (int j = 1; j < i; j++) y[i] -= l[i][j] * y[j]; } for (int i = N; i >= 1; i--) { x[i] = y[i]; for (int j = i + 1; j <= N; j++) x[i] -= u[i][j] * x[j]; x[i] /= u[i][i]; } if (d) printf( ); printf( %.8f , x[id[A][B]]); } printf( n ); return 0; } |
#include <bits/stdc++.h> using namespace std; void Freopen() { freopen( title .in , r , stdin); freopen( title .out , w , stdout); } int read() { int g = 0, f = 1; char ch = getchar(); while (ch < 0 || 9 < ch) { if (ch == - ) f = -1; ch = getchar(); } while ( 0 <= ch && ch <= 9 ) { g = g * 10 + ch - 0 ; ch = getchar(); } return g * f; } const int N = 5e5 + 5; const int mod = 1e9 + 7; int st[N][20], dep[N], vis[N], ta, tb, top, sa[N], sb[N], sta[N]; vector<int> G[N], F[N], R[N], C[N], size[N]; int n, fir[N], las[N], fac[N], du[N]; unordered_map<int, int> M[N]; void dfs(int x, int fa) { st[x][0] = fa; dep[x] = dep[fa] + 1; for (int i = (1); i <= (19); i++) if (st[x][i - 1]) st[x][i] = st[st[x][i - 1]][i - 1]; else break; for (auto y : G[x]) if (y ^ fa) dfs(y, x); } int Lca(int x, int y) { if (dep[x] < dep[y]) swap(x, y); for (int i = (19); i >= (0); i--) if (dep[st[x][i]] >= dep[y]) x = st[x][i]; if (x == y) return x; for (int i = (19); i >= (0); i--) if (st[x][i] != st[y][i]) x = st[x][i], y = st[y][i]; return st[x][0]; } int get(int x, vector<int>& f) { return f[x] == x ? x : f[x] = get(f[x], f); } bool Merge(int x, int y, vector<int>& f, vector<int>& size, vector<int>& ru, vector<int>& cu) { cu[x]++, ru[y]++; if (cu[x] > 1 || ru[y] > 1) return false; int fx = get(x, f), fy = get(y, f); if (fx == fy) return false; size[fx] += size[fy]; f[fy] = fx; return true; } signed main() { n = read(); memset(fir, -1, sizeof(fir)); memset(las, -1, sizeof(las)); if (n == 1) return cout << 1, signed(); fac[0] = 1; for (int i = (1); i <= (n); i++) fac[i] = 1ll * fac[i - 1] * i % mod; for (int i = (1); i <= (n - 1); i++) { int x = read(), y = read(); G[x].push_back(y), G[y].push_back(x); M[x][y] = G[x].size() - 1, M[y][x] = G[y].size() - 1; F[x].push_back(G[x].size() - 1), F[y].push_back(G[y].size() - 1); size[x].push_back(1), size[y].push_back(1); R[x].push_back(0), R[y].push_back(0); C[x].push_back(0), C[y].push_back(0); du[x]++, du[y]++; } dfs(1, 0); for (int x = (1); x <= (n); x++) { int y = read(); if (y == 0) continue; int anc = Lca(x, y); if (x == y) return cout << 0, signed(); if (vis[y]) return cout << 0, signed(); vis[y] = 1; ta = tb = top = 0; for (int t = x; t != anc; t = st[t][0]) sa[++ta] = t; for (int t = y; t != anc; t = st[t][0]) sb[++tb] = t; for (int i = (1); i <= (tb); i++) sta[++top] = sb[i]; sta[++top] = anc; for (int i = (ta); i >= (1); i--) sta[++top] = sa[i]; for (int i = (2); i <= (top - 1); i++) { int ipre = M[sta[i]][sta[i - 1]], isuf = M[sta[i]][sta[i + 1]]; if (!Merge(ipre, isuf, F[sta[i]], size[sta[i]], R[sta[i]], C[sta[i]])) return cout << 0, signed(); } fir[sta[1]] = M[sta[1]][sta[2]]; las[sta[top]] = M[sta[top]][sta[top - 1]]; for (int i = (1); i <= (top); i++) { if (fir[sta[i]] >= 0 && las[sta[i]] >= 0 && get(fir[sta[i]], F[sta[i]]) == get(las[sta[i]], F[sta[i]]) && size[sta[i]][get(fir[sta[i]], F[sta[i]])] != du[sta[i]]) return cout << 0, signed(); } } int ans = 1; for (int i = (1); i <= (n); i++) { for (int j = (0); j <= (du[i] - 1); j++) vis[j] = 0; int cnt = 0; for (int j = (0); j <= (du[i] - 1); j++) { int x = get(j, F[i]); if (vis[x]) continue; vis[x] = 1; cnt++; } if (fir[i] >= 0) cnt--; if (las[i] >= 0) cnt--; if (fir[i] >= 0 && las[i] >= 0 && get(fir[i], F[i]) == get(las[i], F[i])) cnt++; ans = 1ll * ans * fac[cnt] % mod; } return cout << ans, signed(); } |
#include <bits/stdc++.h> using namespace std; void __print(int x) { cerr << x; } void __print(long x) { cerr << x; } void __print(long long x) { cerr << x; } void __print(unsigned x) { cerr << x; } void __print(unsigned long x) { cerr << x; } void __print(unsigned long long x) { cerr << x; } void __print(float x) { cerr << x; } void __print(double x) { cerr << x; } void __print(long double x) { cerr << x; } void __print(char x) { cerr << << x << ; } void __print(const char *x) { cerr << << x << ; } void __print(const string &x) { cerr << << x << ; } void __print(bool x) { cerr << (x ? true : false ); } template <typename T, typename V> void __print(const pair<T, V> &x) { cerr << { ; __print(x.first); cerr << , ; __print(x.second); cerr << } ; } template <typename T> void __print(const T &x) { int f = 0; cerr << { ; for (auto &i : x) cerr << (f++ ? , : ), __print(i); cerr << } ; } void _print() { cerr << ] n ; } template <typename T, typename... V> void _print(T t, V... v) { __print(t); if (sizeof...(v)) cerr << , ; _print(v...); } template <typename T> void printVec(const T &v, char sep = ) { for (auto &i : v) cout << i << sep; } template <typename T> void printVecPair(const T &v, char sep = ) { for (auto &i : v) cout << i.first << << i.second << sep; } struct Points { int x1, y1, x2, y2, x3, y3; }; void solve() { int n, m; cin >> n >> m; vector<string> g(n); for (int i = 0; i < n; i++) { cin >> g[i]; } vector<Points> ans; for (int i = 0; i < n - 1; i++) { for (int j = 0; j < m - 1; j++) { if (g[i][j] == 1 ) { g[i][j] = 0 ; ans.push_back({i, j, i, j + 1, i + 1, j}); g[i][j + 1] = (g[i][j + 1] == 1 ? 0 : 1 ); g[i + 1][j] = (g[i + 1][j] == 1 ? 0 : 1 ); } } } for (int i = 0; i < n - 1; i += 2) { int cntOne = 0; cntOne += (g[i][m - 1] == 1 ); cntOne += (g[i + 1][m - 1] == 1 ); if (cntOne == 1) { if (g[i][m - 1] == 1 ) { ans.push_back({i, m - 1, i, m - 2, i + 1, m - 2}); ans.push_back({i, m - 1, i + 1, m - 1, i + 1, m - 2}); ans.push_back({i, m - 1, i, m - 2, i + 1, m - 1}); for (int i = ans.size() - 3; i < ans.size(); i++) { g[ans[i].x1][ans[i].y1] = (g[ans[i].x1][ans[i].y1] == 1 ? 0 : 1 ); g[ans[i].x2][ans[i].y2] = (g[ans[i].x2][ans[i].y2] == 1 ? 0 : 1 ); g[ans[i].x3][ans[i].y3] = (g[ans[i].x3][ans[i].y3] == 1 ? 0 : 1 ); } } else { ans.push_back({i, m - 2, i, m - 1, i + 1, m - 1}); ans.push_back({i, m - 1, i + 1, m - 1, i + 1, m - 2}); ans.push_back({i, m - 2, i + 1, m - 1, i + 1, m - 2}); for (int i = ans.size() - 3; i < ans.size(); i++) { g[ans[i].x1][ans[i].y1] = (g[ans[i].x1][ans[i].y1] == 1 ? 0 : 1 ); g[ans[i].x2][ans[i].y2] = (g[ans[i].x2][ans[i].y2] == 1 ? 0 : 1 ); g[ans[i].x3][ans[i].y3] = (g[ans[i].x3][ans[i].y3] == 1 ? 0 : 1 ); } } } else if (cntOne == 2) { ans.push_back({i, m - 2, i + 1, m - 2, i + 1, m - 1}); ans.push_back({i, m - 2, i, m - 1, i + 1, m - 2}); for (int i = ans.size() - 2; i < ans.size(); i++) { g[ans[i].x1][ans[i].y1] = (g[ans[i].x1][ans[i].y1] == 1 ? 0 : 1 ); g[ans[i].x2][ans[i].y2] = (g[ans[i].x2][ans[i].y2] == 1 ? 0 : 1 ); g[ans[i].x3][ans[i].y3] = (g[ans[i].x3][ans[i].y3] == 1 ? 0 : 1 ); } } } for (int i = 0; i < m - 1; i += 2) { int cntOne = 0; cntOne += (g[n - 1][i] == 1 ); cntOne += (g[n - 1][i + 1] == 1 ); if (cntOne == 1) { if (g[n - 1][i] == 1 ) { ans.push_back({n - 2, i, n - 1, i, n - 2, i + 1}); ans.push_back({n - 2, i, n - 1, i, n - 1, i + 1}); ans.push_back({n - 2, i + 1, n - 1, i + 1, n - 1, i}); for (int i = ans.size() - 3; i < ans.size(); i++) { g[ans[i].x1][ans[i].y1] = (g[ans[i].x1][ans[i].y1] == 1 ? 0 : 1 ); g[ans[i].x2][ans[i].y2] = (g[ans[i].x2][ans[i].y2] == 1 ? 0 : 1 ); g[ans[i].x3][ans[i].y3] = (g[ans[i].x3][ans[i].y3] == 1 ? 0 : 1 ); } } else { ans.push_back({n - 2, i, n - 2, i + 1, n - 1, i + 1}); ans.push_back({n - 2, i, n - 1, i, n - 1, i + 1}); ans.push_back({n - 2, i + 1, n - 1, i + 1, n - 1, i}); for (int i = ans.size() - 3; i < ans.size(); i++) { g[ans[i].x1][ans[i].y1] = (g[ans[i].x1][ans[i].y1] == 1 ? 0 : 1 ); g[ans[i].x2][ans[i].y2] = (g[ans[i].x2][ans[i].y2] == 1 ? 0 : 1 ); g[ans[i].x3][ans[i].y3] = (g[ans[i].x3][ans[i].y3] == 1 ? 0 : 1 ); } } } else if (cntOne == 2) { ans.push_back({n - 2, i, n - 2, i + 1, n - 1, i}); ans.push_back({n - 2, i, n - 2, i + 1, n - 1, i + 1}); for (int i = ans.size() - 2; i < ans.size(); i++) { g[ans[i].x1][ans[i].y1] = (g[ans[i].x1][ans[i].y1] == 1 ? 0 : 1 ); g[ans[i].x2][ans[i].y2] = (g[ans[i].x2][ans[i].y2] == 1 ? 0 : 1 ); g[ans[i].x3][ans[i].y3] = (g[ans[i].x3][ans[i].y3] == 1 ? 0 : 1 ); } } } if (g[n - 1][m - 1] == 1 ) { ans.push_back({n - 2, m - 2, n - 2, m - 1, n - 1, m - 1}); ans.push_back({n - 2, m - 2, n - 1, m - 2, n - 1, m - 1}); ans.push_back({n - 2, m - 1, n - 1, m - 2, n - 1, m - 1}); for (int i = ans.size() - 3; i < ans.size(); i++) { g[ans[i].x1][ans[i].y1] = (g[ans[i].x1][ans[i].y1] == 1 ? 0 : 1 ); g[ans[i].x2][ans[i].y2] = (g[ans[i].x2][ans[i].y2] == 1 ? 0 : 1 ); g[ans[i].x3][ans[i].y3] = (g[ans[i].x3][ans[i].y3] == 1 ? 0 : 1 ); } } cout << ans.size() << endl; for (auto p : ans) { cout << p.x1 + 1 << << p.y1 + 1 << ; cout << p.x2 + 1 << << p.y2 + 1 << ; cout << p.x3 + 1 << << p.y3 + 1 << endl; } } int main() { ios::sync_with_stdio(false); cin.tie(0); int t; cin >> t; while (t--) solve(); return 0; } |
#include <bits/stdc++.h> using namespace std; const double eps = 1E-9; const double Exp = 2.718281828459045; const double pi = 3.14159; const double E = 2.7182818284590452354; const int Max_Bit = 63; const int INF = 2000000000; const long long LINF = 1000000000000000007ll; const int MOD = 1000000007; const int NMAX = 105; const int MMAX = 1005; const int base = 1000 * 1000 * 1000; int n, m, k, a[NMAX][NMAX][NMAX]; int ok(int i, int j, int l) { bool flag = false; if (a[i][j][l] == 1) { if (i < n && a[i + 1][j][l] == 1 && ((i > 1 && a[i - 1][j][l] == 1) || (j > 1 && a[i][j - 1][l] == 1 && a[i + 1][j - 1][l] == 0) || (l > 1 && a[i][j][l - 1] == 1 && a[i + 1][j][l - 1] == 0))) flag = true; if (j < m && a[i][j + 1][l] == 1 && ((j > 1 && a[i][j - 1][l] == 1) || (i > 1 && a[i - 1][j][l] == 1 && a[i - 1][j + 1][l] == 0) || (l > 1 && a[i][j][l - 1] == 1 && a[i][j + 1][l - 1] == 0))) flag = true; if (l < k && a[i][j][l + 1] == 1 && ((l > 1 && a[i][j][l - 1] == 1) || (i > 1 && a[i - 1][j][l] == 1 && a[i - 1][j][l + 1] == 0) || (j > 1 && a[i][j - 1][l] == 1 && a[i][j - 1][l + 1] == 0))) flag = true; } if (flag) return 1; return 0; } int main() { scanf( %d%d%d , &n, &m, &k); for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) { string second; cin >> second; for (int l = 1; l <= k; l++) a[i][j][l] = int(second[l - 1] - 0 ); } int ans = 0; for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) for (int l = 1; l <= k; l++) ans += ok(i, j, l); printf( %d n , ans); return 0; } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.