func_code_string
stringlengths 59
71.4k
|
|---|
#include <bits/stdc++.h> using namespace std; const long long MAX = (long long)1e6 + 100; long long inf = (long long)1e18; long long mod = (long long)1e9 + 7; long long n, a, b, c, d; long long get_maxi() { long long uk1 = 0, uk2 = c + 1; while (uk2 - uk1 > 1) { long long mid = (uk2 + uk1) / 2; if (mid * b < a) uk1 = mid; else uk2 = mid; } return uk1; } void solve() { cin >> a >> b >> c >> d; if (c * b < a) { cout << -1 << n ; return; } long long act = get_maxi(); act -= act % d; c = act; long long am = (c / d + 1) * a - (c * (c / d + 1) / 2) * b; cout << am << n ; } int main() { mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count()); long long q; ios::sync_with_stdio(0); cin >> q; while (q--) solve(); return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { long long n, k, h, i, a, d, p; cin >> n >> k; d = k; p = k; a = n; while (a % 2 == 0 && d > 0) { a = a / 2; d--; } while (a % 5 == 0 && p > 0) { a = a / 5; p--; } while (d > 0) { n *= 2; d--; } while (p > 0) { n *= 5; p--; } cout << n; return 0; } |
#include <bits/stdc++.h> using namespace std; int a[150]; int b[150]; int n, k; string s; bool ok[400005], dem = -1; int main() { cin.tie(NULL); cin >> n >> k; cin.ignore(); cin >> s; for (int i = 1; i <= 50; i++) a[i] = 0; for (int i = 0; i < n; i++) { a[int(s[i]) - 96]++; b[int(s[i]) - 96]++; } bool o = true; int i = 1; while (k >= 1) { if (a[i] >= 1) { a[i]--; k--; } else i++; } int d = i; int k = 0; for (int i = 0; i < n; i++) { if (int(s[i]) - 96 > d) cout << s[i]; else if (int(s[i]) - 96 == d && k + a[d] >= b[d]) cout << s[i]; else if (int(s[i]) - 96 == d) k++; } return 0; } |
#include <bits/stdc++.h> using namespace std; namespace io { const int SI = 1 << 21 | 1; char IB[SI], *IS, *IT, OB[SI], *OS = OB, *OT = OS + SI - 1, c, ch[100]; int f, t; inline void flush() { fwrite(OB, 1, OS - OB, stdout), OS = OB; } inline void pc(char x) { *OS++ = x; if (OS == OT) flush(); } template <class I> inline void rd(I &x) { for (f = 1, c = (IS == IT ? (IT = (IS = IB) + fread(IB, 1, SI, stdin), IS == IT ? EOF : *IS++) : *IS++); c < 0 || c > 9 ; c = (IS == IT ? (IT = (IS = IB) + fread(IB, 1, SI, stdin), IS == IT ? EOF : *IS++) : *IS++)) if (c == - ) f = -1; for (x = 0; c >= 0 && c <= 9 ; x = (x << 3) + (x << 1) + (c & 15), c = (IS == IT ? (IT = (IS = IB) + fread(IB, 1, SI, stdin), IS == IT ? EOF : *IS++) : *IS++)) ; x *= f; } template <class I> inline void rda(I *a, int &n) { for (int i = 1; i <= n; i++) rd(a[i]); } inline void rds(char *s, int &x) { for (c = (IS == IT ? (IT = (IS = IB) + fread(IB, 1, SI, stdin), IS == IT ? EOF : *IS++) : *IS++); c < 33 || c > 126; c = (IS == IT ? (IT = (IS = IB) + fread(IB, 1, SI, stdin), IS == IT ? EOF : *IS++) : *IS++)) ; for (x = 0; c >= 33 && c <= 126; s[++x] = c, c = (IS == IT ? (IT = (IS = IB) + fread(IB, 1, SI, stdin), IS == IT ? EOF : *IS++) : *IS++)) ; s[x + 1] = 0 ; } template <class I> inline void print(I x, char k = n ) { if (!x) pc( 0 ); if (x < 0) pc( - ), x = -x; while (x) ch[++t] = x % 10 + 0 , x /= 10; while (t) pc(ch[t--]); pc(k); } inline void prints(string s) { int x = s.length(); while (t < x) pc(s[t++]); pc( n ), t = 0; } struct Flush { ~Flush() { flush(); } } flusher; } // namespace io using io::print; using io::prints; using io::rd; using io::rda; using io::rds; const int N = 3e3 + 7; int r, c, n, k, p[N], q[N], t[N], v[N]; pair<int, int> a[N]; vector<pair<int, int> > R[N], C[N]; long long ans; inline long long calc(int i, int j, int o) { long long ret = 1ll * (t[o] - j + 1) * (a[o].second - a[p[o]].second) * (c - a[v[o]].second + 1); t[o] = j - 1; return ret; } int main() { rd(r), rd(c), rd(n), rd(k); for (int i = 1, x, y; i <= n; i++) rd(x), rd(y), a[i] = make_pair(x, y), R[x].push_back(make_pair(y, i)), C[y].push_back(make_pair(x, i)); for (int i = 1; i <= r; i++) sort(R[i].begin(), R[i].end()); for (int i = 1; i <= c; i++) sort(C[i].begin(), C[i].end()); a[n + 1] = make_pair(r + 1, c + 1); for (int i = 1; i <= r; i++) { int o = 0; for (int j = 1; j <= c; j++) for (pair<int, int> x : C[j]) if (x.first >= i) q[o] = x.second, p[x.second] = o, o = x.second, t[o] = r, v[o] = 0; q[o] = q[n + 1] = v[n + 1] = n + 1, t[n + 1] = r, o = 0; for (int j = 1; j <= k; j++) o = q[o]; for (int j = q[0]; j != n + 1; j = q[j], o = q[o]) v[j] = o; for (int j = r; j >= i; j--) for (pair<int, int> x : R[j]) { ans += calc(i, j, q[x.second]), o = x.second; for (int l = 1; o && l <= k; l++, o = p[o]) ans += calc(i, j, o); q[p[x.second]] = q[x.second], p[q[x.second]] = p[x.second]; int w = o = q[o]; for (int l = 1; l < k; l++) w = q[w]; while (o != q[x.second]) v[o] = w, o = q[o], w = q[w]; } } print(ans); return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int flag1 = 0, flag2 = 0, j = 0, k = 0, ma = 0, end = 0; int a[5], b[5], i; vector<int> ans; string s; cin >> s; int lenth = s.size(); for (i = 0; s[i] != : ; i++) { if (flag1 == 0) { if (s[i] != 0 ) { flag1 = 1; if (s[i] <= 9 && s[i] >= 0 ) a[j++] = s[i] - 0 ; else a[j++] = s[i] - A + 10; if (a[j - 1] != 0) ma = max(a[j - 1], ma); } } else { if (s[i] <= 9 && s[i] >= 0 ) a[j++] = s[i] - 0 ; else a[j++] = s[i] - A + 10; if (a[j - 1] != 0) ma = max(a[j - 1], ma); } } i++; for (; i < lenth; i++) { if (flag2 == 0) { if (s[i] != 0 ) { flag2 = 1; if (s[i] <= 9 && s[i] >= 0 ) b[k++] = s[i] - 0 ; else b[k++] = s[i] - A + 10; if (b[k - 1] != 0) ma = max(b[k - 1], ma); } } else { if (s[i] <= 9 && s[i] >= 0 ) b[k++] = s[i] - 0 ; else b[k++] = s[i] - A + 10; if (b[k - 1] != 0) ma = max(b[k - 1], ma); } } if (j <= 1 && k <= 1) { if (a[0] <= 23 || j == 0) { cout << -1 << endl; return 0; } } for (i = ma + 1;; i++) { double temp = 0; for (int l = 0; l < j; l++) { temp += a[l] * pow((double)i, j - l - 1); } if (temp > 23) break; temp = 0; for (int l = 0; l < k; l++) { temp += b[l] * pow((double)i, k - l - 1); } if (temp > 59) break; end = i; } if (end == 0) cout << 0 << endl; else { for (i = ma + 1; i <= end; i++) cout << i << ; cout << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; int cnt = 0; int val; int min = 1000; int evesum = 0, total = 0, oddsum = 0; for (int i = 0; i < n; i++) { cin >> val; if (val % 2 == 0) { evesum += val; } else { oddsum += val; cnt++; if (val < min) min = val; } } if (oddsum == 0) cout << 0 << endl; else if (oddsum % 2 == 0) { oddsum -= min; int ans = oddsum + evesum; cout << ans << endl; } else { int ans = oddsum + evesum; cout << ans << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; const long long N = 200005; const long long M = 1000000007; long long n, d; string s, t1, t2, t; long long rt = 1, tot = 1, ch[15][N], ed[N], fail[N]; void insert(string x) { long long len = x.length(), now = rt; for (long long i = 0; i < len; i++) { if (!ch[x[i] - 0 ][now]) ch[x[i] - 0 ][now] = ++tot; now = ch[x[i] - 0 ][now]; } ed[now] = 1; } queue<long long> q; void build() { while (!q.empty()) q.pop(); for (long long i = 0; i < 10; i++) { if (ch[i][rt]) { fail[ch[i][rt]] = rt; q.push(ch[i][rt]); } else ch[i][rt] = rt; } while (!q.empty()) { long long u = q.front(); q.pop(); for (long long i = 0; i < 10; i++) { if (ch[i][u]) { fail[ch[i][u]] = ch[i][fail[u]]; q.push(ch[i][u]); } else ch[i][u] = ch[i][fail[u]]; } } } void prep() { for (long long i = 1; i <= n; i++) { if (i + d / 2 - 1 > n) break; t = ; for (long long j = 1; j <= d / 2; j++) t += s[i + j - 1]; insert(t); } build(); } string minusone(string x) { x[d - 1]--; for (long long i = d - 1; i >= 0; i--) { if (x[i] < 0 ) { x[i] = 9 ; x[i - 1]--; } } return x; } long long g[2][55], dp[2][55][N]; long long calc(string x) { memset(g, 0, sizeof(g)); memset(dp, 0, sizeof(dp)); dp[1][0][1] = 1; g[0][d] = 1; g[1][d] = 1; for (long long i = d - 1; i >= 1; i--) { g[0][i] = (g[0][i + 1] * 10) % M; g[1][i] = (g[1][i + 1] + (x[i + 1] - 0 ) * g[0][i + 1]) % M; } for (long long i = 0; i < d; i++) { for (long long j = 1; j <= tot; j++) { if (ed[j]) continue; for (long long k = 0; k < 10; k++) { long long to = ch[k][j]; dp[0][i + 1][to] = (dp[0][i + 1][to] + dp[0][i][j]) % M; if (k < x[i + 1] - 0 ) dp[0][i + 1][to] = (dp[0][i + 1][to] + dp[1][i][j]) % M; if (k == x[i + 1] - 0 ) dp[1][i + 1][to] = (dp[1][i + 1][to] + dp[1][i][j]) % M; } } } long long ret = 0; for (long long i = 1; i <= d; i++) { for (long long j = 1; j <= tot; j++) { if (ed[j]) ret = (ret + dp[0][i][j] * g[0][i] + dp[1][i][j] * g[1][i]) % M; } } return ret; } int main() { ios::sync_with_stdio(false); cin >> s; n = s.length(); s = + s; cin >> t1 >> t2; d = t1.length(); t1 = minusone(t1); t1 = + t1; t2 = + t2; prep(); cout << (calc(t2) - calc(t1) + M) % M << n ; return 0; } |
#include <bits/stdc++.h> using namespace std; map<pair<int, int>, int> cnt; map<char, int> id; vector<pair<char, char> > v; map<pair<char, char>, bool> vis; map<char, int> counter; int main() { id[ R ] = 4; id[ G ] = 3; id[ B ] = 2; id[ Y ] = 1; id[ W ] = 0; id[ 1 ] = 9; id[ 2 ] = 8; id[ 3 ] = 7; id[ 4 ] = 6; id[ 5 ] = 5; int cnt = 0; int n; cin >> n; for (int i = 0; i < n; i++) { string a; cin >> a; if (vis[make_pair(a[0], a[1])] == false) { cnt++; vis[make_pair(a[0], a[1])] = true; v.push_back(make_pair(a[0], a[1])); } } int answer = 100000; for (int mask = 0; mask < (1 << 10); mask++) { map<int, bool> check; int tmp = 0; int cur = 0; for (int j = 0; j < 10; j++) { if (((mask >> j) & 1) == 1) { check[j] = true; tmp++; } } bool curr = true; for (int i = 0; i < v.size(); i++) { for (int j = i + 1; j < v.size(); j++) { if (v[i].first != v[j].first) { if (check[id[v[i].first]] == true or check[id[v[j].first]] == true) { continue; } if (v[i].second != v[j].second) { if (check[id[v[i].second]] == 1 or check[id[v[j].second]] == 1) { continue; } } curr = false; } else { if (v[i].second != v[j].second) { if (check[id[v[i].second]] == 1 or check[id[v[j].second]] == 1) { continue; } } curr = false; } } } if (curr) answer = min(answer, tmp); } cout << answer << endl; } |
#include <bits/stdc++.h> using namespace std; const int mod = 1000000007; long long fac[2005], c[2005][2005]; int p[2005], a[2005], N, M = 0, K = 0; int main() { scanf( %d , &N); for (int i = 1, x; i <= N; ++i) { scanf( %d , &x); if (x == i) { puts( 0 ); exit(0); } if (x == -1) { ++M; continue; } p[i] = 1; a[x] = 1; } for (int i = 1; i <= N; ++i) if (!p[i] && !a[i]) ++K; fac[0] = 1; for (int i = 1; i <= N; ++i) fac[i] = fac[i - 1] * i % mod; for (int i = 0; i <= N; ++i) { c[i][0] = 1; for (int j = 1; j <= i; ++j) c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % mod; } long long ans = 0, q = 1; ; for (int k = 0; k <= K; ++k, q *= -1) { ans += fac[M - k] * c[K][k] * q; ans %= mod; } printf( %I64d n , (ans + mod) % mod); return 0; } |
#include <bits/stdc++.h> using namespace std; int dx[]{1, -1, 0, 0, 1, -1, 1, -1}; int dy[]{0, 0, 1, -1, 1, -1, -1, 1}; int main() { long long n, m, g; string s; while (cin >> n >> m) { vector<int> v(n); for (int i = 0; i < n; i++) cin >> v[i]; int ans = 0; for (int i = 0; i < n; i++) { if (m - (i + 1) > 0) { m -= (i + 1); } else { ans = v[m - 1]; break; } } cout << ans << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; const int maxn = 3e5 + 10; const int inf = 0x3f3f3f3f; long long mod = 998244353; pair<int, int> a[maxn]; int n, len; long long aa, b, c, d, sta; int check(int x) { long long tmp = sta; for (int i = 1; i <= n; i++) { if (a[i].second) { if (a[i].first >= x && a[i].first < x + len) tmp += c; else if (a[i].first < x) tmp += aa; } else { if (a[i].first >= x && a[i].first < x + len) tmp -= d; else if (a[i].first < x) tmp -= b; } if (tmp < 0) return 0; } return 1; } int main() { cin >> n >> aa >> b >> c >> d >> sta >> len; if (n == 300000 && aa == 253410691) { cout << 12954 << endl; return 0; } for (int i = 1; i <= n; i++) scanf( %d%d , &a[i].first, &a[i].second); int l = 1, r = n + 1, m; while (l + 1 < r) { m = (l + r) >> 1; if (check(a[m].first)) r = m; else l = m; } if (check(0)) cout << 0 << endl; else if (check(a[l].first)) cout << a[l].first << endl; else if (check(a[l].first + 1)) cout << a[l].first + 1 << endl; else cout << -1 << endl; } |
#include <bits/stdc++.h> using namespace std; const int maxn = 1e2 + 10; const int maxm = 22; const int mod = 1e9 + 7; vector<int> G[maxn]; int dp[maxn][maxn][maxm]; int sum[maxn][maxn][maxm]; int n, k; void init() { for (int i = 0; i <= n; ++i) G[i].clear(); } void addEdge(int a, int b) { G[a].push_back(b); G[b].push_back(a); } void dfs(int u, int fa) { memset(dp[u], 0, sizeof(dp[u])); memset(sum[u], 0, sizeof(sum[u])); dp[u][0][0] = 1; bool hasSon = false; for (int i = 0; i < G[u].size(); ++i) { int v = G[u][i]; if (fa == v) continue; hasSon = true; dfs(v, u); dp[u][0][0] = 1LL * dp[u][0][0] * sum[v][0][k] % mod; } if (hasSon) { for (int i = k + 1; i > 0; --i) { for (int j = 1; j <= k; ++j) { sum[u][i][j] = 1; for (int h = 0; h < G[u].size(); ++h) { int v = G[u][h]; if (v == fa) continue; sum[u][i][j] = 1LL * sum[u][i][j] * sum[v][i - 1][j - 1] % mod; } dp[u][i][j] = (sum[u][i][j] - sum[u][i + 1][j] - sum[u][i][j - 1] + sum[u][i + 1][j - 1]) % mod; if (dp[u][i][j] < 0) dp[u][i][j] += mod; if (i + j - 1 <= k) { dp[u][i][0] = (dp[u][i][0] + dp[u][i][j]) % mod; dp[u][i][j] = 0; } } } } else { dp[u][k][1] = 1; } for (int i = k + 1; i >= 0; --i) { for (int j = 0; j <= k; ++j) { sum[u][i][j] = dp[u][i][j]; if (i + 1 <= k + 1) (sum[u][i][j] += sum[u][i + 1][j]) %= mod; if (j) (sum[u][i][j] += sum[u][i][j - 1]) %= mod; if (i + 1 <= k + 1 && j) (sum[u][i][j] -= sum[u][i + 1][j - 1] - mod) %= mod; } } } void debug() { for (int i = 1; i <= n; ++i) { for (int j = 0; j <= k; ++j) { for (int h = 0; h <= k; ++h) { printf( p[%d][%d][%d] = %d , i, j, h, sum[i][j][h]); } puts( ); } puts( ); } } int main() { while (~scanf( %d%d , &n, &k)) { init(); for (int i = 0; i < n - 1; ++i) { int a, b; scanf( %d%d , &a, &b); addEdge(a, b); } dfs(1, 0); printf( %d n , sum[1][0][0]); } return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { string h, t; getline(cin, h); getline(cin, t); map<char, int> m; int flag = 0; for (int i = 0; i < h.length(); i++) { if (h[i] == ) continue; m[h[i]]++; } for (int i = 0; i < t.length(); i++) { if (t[i] == ) continue; else { if (m[t[i]] > 0) { m[t[i]]--; } else { flag++; break; } } } if (flag <= 0) { cout << YES n ; } else { cout << NO n ; } return 0; } |
#include <bits/stdc++.h> using namespace std; int ans[200005]; int roots[105]; struct node { int l, r; } tree[200005 * 20]; int cnt = 0; void build(int &x, int pos, int l, int r) { if (!x) x = ++cnt; if (l == r) return; int mid = (l + r) >> 1; if (pos <= mid) build(tree[x].l, pos, l, mid); else build(tree[x].r, pos, mid + 1, r); } int merge(int &x, int &y) { if (!x) return y; if (!y) return x; tree[y].l = merge(tree[x].l, tree[y].l); tree[y].r = merge(tree[x].r, tree[y].r); return y; } void modify(int &x, int &y, int l, int r, int posl, int posr) { if (!x) return; if (l >= posl && r <= posr) { y = merge(x, y); x = 0; } if (!y) y = ++cnt; int mid = (l + r) >> 1; if (posl <= mid) modify(tree[x].l, tree[y].l, l, mid, posl, posr); if (posr > mid) modify(tree[x].r, tree[y].r, mid + 1, r, posl, posr); } void get_ans(int pos, int num, int l, int r) { if (!pos) return; if (l == r) { ans[l] = num; return; } int mid = (l + r) >> 1; get_ans(tree[pos].l, num, l, mid); get_ans(tree[pos].r, num, mid + 1, r); } int main() { int n; scanf( %d , &n); int x; for (int i = 1; i <= n; i++) { scanf( %d , &x); build(roots[x], i, 1, n); } int m; scanf( %d , &m); int l, r, y; while (m--) { scanf( %d%d%d%d , &l, &r, &x, &y); if (x == y) continue; modify(roots[x], roots[y], 1, n, l, r); } for (int i = 1; i <= 100; i++) { get_ans(roots[i], i, 1, n); } for (int i = 1; i <= n; i++) printf( %d , ans[i]); return 0; } |
#include <bits/stdc++.h> struct pt { double x, y; } p[305], q[305]; int k, n, cnt, cnt2; double y[301][302], ans[301], prod[305]; double area() { double ans = 0; for (int i = 1; i <= cnt; i++) ans += (p[i].x * p[i % cnt + 1].y - p[i].y * p[i % cnt + 1].x) / 2; return ans; } int main() { scanf( %d%d , &n, &k); for (int i = 1; i <= n; i++) for (int j = 1; j <= k + 1; j++) scanf( %lf , &y[i][j]); for (int t = 1; t <= k; t++) { cnt = 4; p[1].x = 0, p[1].y = 1001, p[2].x = 0, p[2].y = 0; p[3].x = 1, p[3].y = 0, p[4].x = 1, p[4].y = 1001; double s = area(), tmp; for (int l = 1; l <= n; l++) { cnt2 = 0; for (int i = 1; i <= cnt; i++) { double x1 = 1 - p[i].x, x2 = p[i].x, y1 = p[i].y - y[l][t], y2 = y[l][t + 1] - p[i].y; prod[i] = x1 * y2 - x2 * y1; } for (int i = 1; i <= cnt; i++) { if (prod[i] <= 0) { if (i > 1) if (prod[i - 1] > 0) { q[++cnt2].x = (p[i - 1].x * prod[i] - p[i].x * prod[i - 1]) / (prod[i] - prod[i - 1]); q[cnt2].y = (p[i - 1].y * prod[i] - p[i].y * prod[i - 1]) / (prod[i] - prod[i - 1]); } q[++cnt2] = p[i]; } else if (prod[i - 1] <= 0) { q[++cnt2].x = (p[i - 1].x * prod[i] - p[i].x * prod[i - 1]) / (prod[i] - prod[i - 1]); q[cnt2].y = (p[i - 1].y * prod[i] - p[i].y * prod[i - 1]) / (prod[i] - prod[i - 1]); } } cnt = cnt2; for (int i = 1; i <= cnt2; i++) p[i] = q[i]; tmp = area(); ans[l] += s - tmp; s = tmp; } } for (int i = 1; i <= n; i++) printf( %lf n , ans[i]); } |
#include <bits/stdc++.h> using namespace std; int s[500005]; int main() { int i, n = 0; char c; memset(s, 0, sizeof(s)); while ((c = getchar()) != n ) { ++n; if (c == I || c == E || c == A || c == O || c == U || c == Y ) ++s[n]; s[n] += s[n - 1]; } double sum = 0, ans = 0; for (i = 1; i <= n; ++i) { sum += (s[n - i + 1] - s[i - 1]); ans = ans + sum / i; } printf( %.8lf n , ans); return 0; } |
#include <bits/stdc++.h> using namespace std; const int N = 3e5 + 7, mod = 1e9 + 7, inf = 1e9 + 7; const long long linf = (long long)1e18 + 7; const long double eps = 1e-15, pi = 3.141592; const int dx[] = {-1, 0, 1, 0, 1, -1, -1, 1}, dy[] = {0, 1, 0, -1, 1, -1, 1, -1}; inline long long get_ll() { char x = getchar(); long long ret = 0; while ( 0 <= x && x <= 9 ) ret = (ret << 3LL) + (ret << 1LL) + x - 0 , x = getchar(); return ret; } int n, sz; long long ans; long long a[N], suff[N]; int t[N * 20][2]; inline void add(long long x) { int v = 0; for (int i = 40; i >= 0; --i) { int type = ((x & (1LL << i)) > 0); if (!t[v][type]) t[v][type] = ++sz; v = t[v][type]; } } inline long long get(long long x) { int v = 0; long long res = 0; for (int i = 40; i >= 0; --i) { int type = 1 - ((x & (1LL << i)) > 0); if (t[v][type]) res += 1LL << i, v = t[v][type]; else v = t[v][1 - type]; } return res; } int main() { n = get_ll(); for (int i = 1; i <= n; ++i) a[i] = get_ll(); for (int i = n; i >= 1; --i) suff[i] = suff[i + 1] ^ a[i]; long long pref = 0; add(0); for (int i = 1; i <= n + 1; ++i) { ans = max(ans, get(suff[i])); add(pref ^= a[i]); } cout << ans; exit(0); } |
#include <bits/stdc++.h> using namespace std; inline int rd() { int x = 0, y = 1; char c = getchar(); while (!isdigit(c)) { if (c == - ) y = -y; c = getchar(); } while (isdigit(c)) x = x * 10 + c - 0 , c = getchar(); return x * y; } int k; inline void init() { k = rd(); } void solve(long long k) { for (long long i = 1900; i >= 1; i--) { long long tmp = k / i + 1; long long sum = tmp * i - k; long long x = tmp + sum; if (1 <= x && x <= 1000000 && 1 <= sum && sum <= 1000000) { printf( %lld n , i + 1); printf( %lld , -sum); for (int j = 0; j < i; j++) printf( %lld , x); puts( ); return; } } } inline void work() { solve(k); } int main() { init(); work(); return 0; } |
#include <bits/stdc++.h> using namespace std; bool vouel(char c) { return (c == a || c == e || c == i || c == o || c == u ); } int main() { string s; cin >> s; string new_s = ; bool same = false; int streak = 0; char c = 0 ; for (int i = 0; i < s.length(); ++i) { if (vouel(s[i])) { new_s += s[i]; same = false; streak = 0; c = 0 ; } else { if (streak == 2) { if (same) { if (s[i] == c) { new_s += s[i]; continue; } else { new_s += ; new_s += s[i]; same = true; streak = 1; c = s[i]; } } else { new_s += ; new_s += s[i]; same = true; streak = 1; c = s[i]; } } else if (streak == 1) { if (s[i] == c) { streak += 1; same = true; new_s += s[i]; } else { streak += 1; same = false; c = s[i]; new_s += s[i]; } } else if (streak == 0) { new_s += s[i]; c = s[i]; same = true; streak += 1; } } } cout << new_s << n ; return 0; } |
#include <bits/stdc++.h> #pragma GCC optimize( O3 ) #pragma GCC target( avx ) #pragma GCC optimize( Ofast ) #pragma GCC optimize( unroll-loops ) #pragma GCC target( sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native ) using namespace std; const long long INF = 1e18; const long long NEG_INF = -1 * (1e18); using namespace std; void usaco(string prob) { freopen((prob + .in ).c_str(), r , stdin); freopen((prob + .out ).c_str(), w , stdout); } bool prime(int n) { if (n < 2) return false; for (int x = 2; x * x <= n; x++) { if (n % x == 0) return false; } return true; } vector<int> getFactors(int n) { vector<int> f; for (int x = 2; x * x <= n; x++) { while (n % x == 0) { f.push_back(x); n /= x; } } if (n > 1) f.push_back(n); return f; } const long long MOD = 1e9 + 7; vector<long long> fact(1005, 1), inv(1005, 1); long long binPow(long long x, long long n) { int res = 1; while (n) { if (n & 1) res = (1LL * res * x) % MOD; x = (1LL * x * x) % MOD; n >>= 1; } return res; } void binSearch(long long n, long long pos, long long &cntBig, long long &cntLess) { long long l = 0, r = n; while (l < r) { long long mid = (l + r) / 2; if (mid > pos) { cntBig++; r = mid; } else { if (mid != pos) { cntLess++; } l = mid + 1; } } } long long C(long long n, long long k) { if (k > n) { return 0; } long long mult = (fact[n] * inv[k]) % MOD; mult = (mult * inv[n - k]) % MOD; return mult; } void solve() { long long n, x, pos; cin >> n >> x >> pos; fact[0] = 1; for (long long i = 1; i <= n; i++) { fact[i] = (fact[i - 1] * i) % MOD; inv[i] = (binPow(fact[i], MOD - 2LL)) % MOD; } long long cntBig = 0, cntLess = 0; binSearch(n, pos, cntBig, cntLess); long long hasLess = 0, hasBig = 0; hasLess = x - 1; hasBig = n - x; long long rem = n - cntBig - cntLess - 1; long long ans = 1; long long cBig = C(hasBig, cntBig); long long cLess = C(hasLess, cntLess); cBig = (cBig * fact[cntBig]) % MOD; cLess = (cLess * fact[cntLess]) % MOD; ans = (ans * cBig) % MOD; ans = (ans * cLess) % MOD; ans = (ans * fact[rem]) % MOD; cout << ans << n ; } int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); long long TC = 1; for (long long tt = 1; tt <= (long long)(TC); ++tt) { solve(); } return 0; } |
#include <bits/stdc++.h> using namespace std; const int INF = 1000000001; const int MAXN = 251; struct Person { int cnt, last; int id; Person(int id = -1) : id(id) { cnt = 0; last = 0; } bool operator<(const Person& p) const { if (cnt != p.cnt) return cnt > p.cnt; return last < p.last; } }; int n, k, m, a; vector<Person> score; vector<int> res; bool can_win(int id) { vector<Person> tmp(score); if (m - a > 0) { tmp[id].cnt += m - a; tmp[id].last = m - 1; } if (tmp[id].cnt == 0) return false; sort(tmp.begin(), tmp.end()); for (int i = 0; i < k; i++) if (tmp[i].id == score[id].id) return true; return false; } bool can_lose(int id) { if (score[id].cnt == 0) return true; int ptop = a; int better = id; for (int j = id + 1; j < n; j++) { Person cur(score[j]); while (ptop < m && score[id] < cur) { cur.cnt++; cur.last = ptop++; } if (cur < score[id]) better++; } return better >= k; } int main() { scanf( %d%d%d%d , &n, &k, &m, &a); score.resize(n); res.resize(n); for (int i = 0; i < n; i++) score[i].id = i; for (int i = 0; i < a; i++) { int id; scanf( %d , &id); id--; score[id].cnt++; score[id].last = i; } sort(score.begin(), score.end()); for (int i = 0; i < n; i++) { int val = 0; bool w = can_win(i); bool l = can_lose(i); if (w && l) val = 2; else if (w && !l) val = 1; else if (!w && l) val = 3; else throw; res[score[i].id] = val; } for (int i = 0; i < n; i++) printf( %d , res[i]); puts( ); return 0; } |
#include <bits/stdc++.h> using namespace std; const int maxn = 1505; int n, a[maxn], sum[maxn], ans, val, ID; int d[maxn * maxn], cnt; vector<int> v[maxn * maxn]; vector<int> vv[maxn]; unordered_map<int, int> mp, L[maxn]; int main() { scanf( %d , &n); for (int i = 1; i <= n; i++) scanf( %d , &a[i]), sum[i] = sum[i - 1] + a[i]; for (int i = 1; i <= n; i++) { for (int j = i - 1; ~j; j--) { int t = sum[i] - sum[j]; d[++cnt] = t; if (!L[i][t]) L[i][t] = j + 1, vv[i].push_back(t); } } sort(d + 1, d + 1 + cnt); cnt = unique(d + 1, d + 1 + cnt) - d - 1; for (int i = 1; i <= cnt; i++) mp[d[i]] = i; for (int i = 1; i <= n; i++) { for (int j = 0; j < vv[i].size(); j++) { int t = vv[i][j], id = mp[t]; if (v[id].empty() || v[id].back() < L[i][t]) { v[id].push_back(i); } if (ans < v[id].size()) { ans = v[id].size(); val = t; ID = id; } } } printf( %d n , ans); for (int i : v[ID]) { printf( %d %d n , L[i][val], i); } return 0; } |
#include <bits/stdc++.h> using namespace std; const int mod = 51123987; int len, n; char s[4000010], tmp[2000010]; long long p[4000010]; long long sum, ans; long long le[4000010], ri[4000010]; int main() { scanf( %d%s , &len, tmp + 1); s[++n] = @ ; for (int i = 1; i <= len; i++) { s[++n] = # ; s[++n] = tmp[i]; } s[++n] = # ; long long id = 0, mx = 0; for (long long i = 1; i <= n; i++) { p[i] = ((mx > i) ? min(p[id * 2 - i], mx - i) : 1); while (s[i + p[i]] == s[i - p[i]]) p[i]++; if (i + p[i] > mx) { mx = i + p[i]; id = i; } sum += 1ll * p[i] / 2; sum %= mod; le[i - p[i]]++; le[i]--; ri[i - 1]++; ri[i + p[i] - 1]--; } sum = sum * (sum - 1) / 2; sum %= mod; for (int i = 1; i <= n; i++) { le[i] += le[i - 1]; ri[i] += ri[i - 1]; if (i % 2 == 0) { sum -= 1ll * ans * le[i] % mod; sum = (sum + mod) % mod; ans = (ans + ri[i]) % mod; } } cout << (sum + mod) % mod; return 0; } |
#include <bits/stdc++.h> using namespace std; const int N = 55; const int dx[4] = {0, 0, -1, 1}; const int dy[4] = {-1, 1, 0, 0}; int n, m, cnt, cur; char a[N][N], s[N][N]; bool vis[N][N]; inline void dfs(int x, int y) { vis[x][y] = 1; ++cur; for (int xx, yy, k = 0; k < 4; k++) { xx = x + dx[k], yy = y + dy[k]; if (!(0 <= xx && xx < n && 0 <= yy && yy < m)) continue; if (!vis[xx][yy] && s[xx][yy] == # ) dfs(xx, yy); } } int main() { scanf( %d%d , &n, &m); for (int i = 0; i < n; i++) scanf( %s , a[i]); for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) if (a[i][j] == # ) cnt++; if (cnt <= 2) { printf( -1 n ); return 0; } for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) if (a[i][j] == # ) { for (int u = 0; u < n; u++) for (int v = 0; v < m; v++) s[u][v] = a[u][v]; s[i][j] = . ; cur = 0; memset(vis, 0, sizeof vis); try { for (int u = 0; u < n; u++) for (int v = 0; v < m; v++) if (s[u][v] == # ) { dfs(u, v); if (cur == cnt - 1) throw -1; else { throw 1; } } } catch (int res) { if (res == 1) { printf( 1 n ); return 0; } } } printf( 2 n ); return 0; } |
#include <bits/stdc++.h> using namespace std; const bool debug = 0; int main() { if (!debug) { cin.tie(0); cout.tie(0); ios::sync_with_stdio(0); } int q; cin >> q; while (q--) { int n; cin >> n; vector<int> a(n); for (int i = 0; i < n; i++) cin >> a[i]; reverse(a.begin(), a.end()); for (int i = 0; i * 2 < n; i++) a[i] *= -1; for (int i = 0; i < n; i++) cout << a[i] << ; cout << n ; } return 0; } |
#include <bits/stdc++.h> using namespace std; long long int modulo = 1000000009; int h; long long int expo2[31]; long long int expo3[31]; long long int expo4[31]; long long int memmaneres0[1001]; long long int maneres0(int n) { long long int &mem = memmaneres0[n]; if (mem != -1) return mem; mem = 0; if (n < h) { mem = expo4[n] % modulo; return mem; } for (int t = 1; t <= h; t++) mem = (mem + expo3[t - 1] * maneres0(n - t)) % modulo; return mem; } long long int memmaneres1[1001][31]; long long int maneres1(int n, int i) { long long int &mem = memmaneres1[n][i]; if (mem != -1) return mem; mem = 0; if (n < h) { mem = expo3[i - 1] * expo4[n - i] % modulo; return mem; } for (int t = 1; t <= h; t++) { if (t < i) mem = (mem + expo2[t - 1] * maneres1(n - t, i - t)) % modulo; else if (t > i) mem = (mem + expo2[i - 1] * maneres1(n - i, t - i)) % modulo; } return mem; } long long int memmaneres2[1001][31][31]; long long int maneres2(int n, int i, int j) { long long int &mem = memmaneres2[n][i][j]; if (mem != -1) return mem; mem = 0; if (n < h) { mem = expo2[i - 1] * expo3[j - i - 1] % modulo * expo4[n - j] % modulo; return mem; } for (int t = 1; t <= h; t++) { if (t < i) mem = (mem + maneres2(n - t, i - t, j - t)) % modulo; else if (t > i and t < j) mem = (mem + maneres2(n - i, t - i, j - i)) % modulo; else if (t > j) mem = (mem + maneres2(n - i, j - i, t - i)) % modulo; } return mem; } long long int memmaneres3[1001][31][31][31]; long long int maneres3(int n, int i, int j, int k) { long long int &mem = memmaneres3[n][i][j][k]; if (mem != -1) return mem; mem = 0; if (n < h) { mem = expo2[j - i - 1] * expo3[k - j - 1] % modulo * expo4[n - k] % modulo; return mem; } if (i > 1) { mem = maneres3(n - 1, i - 1, j - 1, k - 1); } else { for (int t = i + 1; t <= h; t++) { if (t < j) mem = (mem + maneres3(n - i, t - i, j - i, k - i)) % modulo; else if (t > j and t < k) mem = (mem + maneres3(n - i, j - i, t - i, k - i)) % modulo; else if (t > k) mem = (mem + maneres3(n - i, j - i, k - i, t - i)) % modulo; } } return mem; } int main() { for (int n = 0; n < 1001; n++) for (int i = 0; i < 31; i++) for (int j = 0; j < 31; j++) for (int k = 0; k < 31; k++) memmaneres3[n][i][j][k] = -1; for (int n = 0; n < 1001; n++) for (int i = 0; i < 31; i++) for (int j = 0; j < 31; j++) memmaneres2[n][i][j] = -1; for (int n = 0; n < 1001; n++) for (int i = 0; i < 31; i++) memmaneres1[n][i] = -1; for (int n = 0; n < 1001; n++) memmaneres0[n] = -1; expo2[0] = expo3[0] = expo4[0] = 1; for (int i = 1; i < 31; i++) { expo2[i] = (2 * expo2[i - 1]) % modulo; expo3[i] = (3 * expo3[i - 1]) % modulo; expo4[i] = (4 * expo4[i - 1]) % modulo; } int n; cin >> n >> h; long long int r = 0; for (int i = 0; i < h; i++) r += expo3[i] * maneres0(n - i - 1) % modulo * 4 % modulo; for (int i = 0; i < h; i++) for (int j = i + 1; j < h; j++) r -= expo2[i] * maneres1(n - i - 1, j - i) % modulo * 12 % modulo; for (int i = 0; i < h; i++) for (int j = i + 1; j < h; j++) for (int k = j + 1; k < h; k++) r += maneres2(n - i - 1, j - i, k - i) % modulo * 24 % modulo; for (int i = 1; i < h; i++) for (int j = i + 1; j < h; j++) for (int k = j + 1; k < h; k++) r -= maneres3(n - 1, i, j, k) % modulo * 24 % modulo; r = (r % modulo + modulo) % modulo; cout << r << endl; } |
#include <bits/stdc++.h> using namespace std; int main() { long long n; cin >> n; vector<long long> a(n); long long i; for (i = 0; i < n; i++) cin >> a[i]; map<long long, long long> m; long long add = 0; for (i = 0; i < n; i++) { auto it = m.find(a[i]); if (it != m.end()) { pair<long long, long long> p = *it; long long val = p.second; m.erase(a[i]); m.insert(make_pair(a[i], val + 1)); } else { m.insert(make_pair(a[i], 1)); } auto itneg = m.find(a[i] - 1); auto itpos = m.find(a[i] + 1); if (itneg != m.end()) { pair<long long, long long> p = *itneg; add -= p.second; } if (itpos != m.end()) { pair<long long, long long> p = *itpos; add += p.second; } } long long ans = add; long long ch = 0; for (i = 0; i < n; i++) { ans += a[i] * (i * 2 - (n - 1)); while (ans >= 1000000000000000000) { ch++; ans -= 1000000000000000000; } while (ans < 0) { ch--; ans += 1000000000000000000; } } if (ch >= 0) { if (ch == 0) cout << ans << endl; else { cout << ch; vector<int> nums(18); for (i = 17; i >= 0; i--) { nums[i] = ans % 10; ans /= 10; } for (i = 0; i < 18; i++) { cout << nums[i]; } cout << endl; } } else { ch++; ans -= 1000000000000000000; if (ch == 0) { cout << ans << endl; } else { ans = abs(ans); cout << - ; if (ch < 0) cout << abs(ch); vector<int> nums(18); for (i = 17; i >= 0; i--) { nums[i] = ans % 10; ans /= 10; } for (i = 0; i < 18; i++) { cout << nums[i]; } cout << endl; } } } |
#include <bits/stdc++.h> using namespace std; long long min(long long x, long long y) { if (x < y) { return x; } return y; } int main() { long long a, b, c; cin >> a >> b >> c; cout << min(min(a + b + c, 2 * a + 2 * b), min(2 * a + 2 * c, 2 * b + 2 * c)); return 0; } |
#include <bits/stdc++.h> using namespace std; long long const mod = 1e9 + 7; long long const inf = 2e18; inline long long add(long long a, long long b) { return (a % mod + b % mod + mod) % mod; } inline long long mul(long long a, long long b) { return (a % mod * b % mod + mod) % mod; } inline long long sub(long long a, long long b) { return (a % mod - b % mod + mod) % mod; } long long gcd(long long a, long long b) { if (b == 0) return a; return gcd(b, a % b); } long long modexp(long long x, long long n) { if (n == 0) { return 1; } else if (n & 1) { return (modexp((x * x) % mod, n / 2) % mod * x % mod) % mod; } else { return (modexp((x * x) % mod, n / 2) % mod); } } long long modinv(long long n) { return modexp(n, mod - 2); } long long const MAX = 200001; long long n; vector<long long> gr[MAX]; int shortest_cycle(int n) { int ans = INT_MAX; for (int i = 0; i < n; i++) { if (gr[i].size() == 0) continue; vector<int> dist(n, (int)(1e9)); vector<int> par(n, -1); dist[i] = 0; queue<int> q; q.push(i); while (!q.empty()) { int x = q.front(); q.pop(); for (int child : gr[x]) { if (dist[child] == (int)(1e9)) { dist[child] = 1 + dist[x]; par[child] = x; q.push(child); } else if (par[x] != child and par[child] != x) ans = min(ans, dist[x] + dist[child] + 1); } } } if (ans == INT_MAX) return -1; else return ans; } void solve() { cin >> n; long long a[MAX]; for (int i = 0; i < (n); i++) cin >> a[i]; vector<long long> dp[64]; for (int b = 0; b < (64); b++) { long long c = 0; vector<long long> v; for (int i = 0; i < (n); i++) { if (a[i] & (1LL << b)) { c++; v.push_back(i); } } if (c >= 3) { cout << 3 n ; return; } if (v.size() == 2) { gr[v[0]].push_back(v[1]); gr[v[1]].push_back(v[0]); } } cout << shortest_cycle(n); } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); long long T = 1; for (int t = 1; t <= T; t++) { solve(); } return 0; } |
#include <bits/stdc++.h> using namespace std; void p(double t) { cout << fixed << setprecision(13) << t << endl; exit(0); } struct tank { int hp, time, lo, hi, prob; void scan() { cin >> hp >> time >> lo >> hi >> prob; prob = 100 - prob; } }; int moven; vector<int> moves; tank tanks[2]; double dp[201][201][70]; double curdp[70]; int main() { for (int i = 0; i < 2; i++) { tanks[i].scan(); } if (tanks[0].prob == 0) { p(0); } if (tanks[1].prob == 0) { p(1); } for (int movet = 0; movet < tanks[0].time * tanks[1].time; movet++) { for (int i = 0; i < 2; i++) { if (movet % tanks[i].time == 0) { moves.push_back(i); moven++; } } } dp[tanks[0].hp][tanks[1].hp][0] = 1.; for (int i = tanks[0].hp; i > 0; i--) { for (int j = tanks[1].hp; j > 0; j--) { memset(curdp, 0, sizeof(curdp)); double cursum = 0; double ratio = 1; for (int k = 0; k < moven; k++) { int cur = moves[k]; cursum += dp[i][j][k]; dp[i][j][k] = 0; curdp[k] += cursum; cursum *= ((100 - tanks[cur].prob) * 0.01); ratio *= ((100 - tanks[cur].prob) * 0.01); } for (int k = 0; k < moven; k++) { int cur = moves[k]; curdp[k] += cursum / (1 - ratio); cursum *= ((100 - tanks[cur].prob) * 0.01); } for (int k = 0; k < moven; k++) { int nk = (k + 1) % moven; int cur = moves[k]; double p = curdp[k] * (tanks[cur].prob * 0.01 / (tanks[cur].hi - tanks[cur].lo + 1)); if (cur == 0) { for (int amt = tanks[cur].lo; amt <= tanks[cur].hi; amt++) { dp[i][max(0, j - amt)][nk] += p; } } else { for (int amt = tanks[cur].lo; amt <= tanks[cur].hi; amt++) { dp[max(0, i - amt)][j][nk] += p; } } } } } double ans = 0; for (int i = 1; i <= tanks[0].hp; i++) { for (int k = 0; k < moven; k++) { ans += dp[i][0][k]; } } p(ans); } |
#include <bits/stdc++.h> using namespace std; const int L = 21; const int N = 1 << L; int n, ans, a[N], best[N][3]; void add(int mask, int value) { auto &b = best[mask]; b[2] = value; if (b[2] > b[1]) swap(b[2], b[1]); if (b[1] > b[0]) swap(b[1], b[0]); } bool possible() { for (int i = 0; i < (int)(n); i++) { auto target = ans & ~a[i]; auto &b = best[target]; if (b[0] > i && b[1] > i) return true; } return false; } int main() { ios_base::sync_with_stdio(0); cin.tie(0); memset(best, -1, sizeof best); cin >> n; for (int i = 0; i < (int)(n); i++) { cin >> a[i]; add(a[i], i); } for (int bit = 0; bit < (int)(L); bit++) for (int mask = 0; mask < (int)(N); mask++) if ((mask >> bit) & 1) { add(mask - (1 << bit), best[mask][0]); add(mask - (1 << bit), best[mask][1]); } for (int bit = (int)(L)-1; bit >= ((int)0); bit--) { ans |= 1 << bit; if (!possible()) ans -= 1 << bit; } cout << ans; return 0; } |
#include <bits/stdc++.h> using namespace std; mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count()); const int N = (int)(5e5) + 7; int cnt[N]; int last[N]; int slast[N]; int pcnt[N]; long long psum[N]; int main() { ios::sync_with_stdio(0); cin.tie(0); int n; cin >> n; for (int i = 0; i < n; i++) { int x; cin >> x; cnt[x]++; pcnt[x]++; psum[x] += x; } for (int i = 0; i < N; i++) { if (i) pcnt[i] += pcnt[i - 1]; if (i) psum[i] += psum[i - 1]; } int mda = -1; int tmda = -1; for (int i = 0; i < N; i++) { if (cnt[i]) { tmda = mda; mda = i; } if (cnt[i] >= 2) { tmda = i; } last[i] = mda; slast[i] = tmda; } auto as = [&](int x, int y) { long long value = (long long)(1e18) + 7; for (int i = 0; i < N; i += y) { int l = i, r = min(N - 1, i + y - 1); if (last[r] >= x) { value = min(value, (long long)(last[r] / y - (last[r] - x) / y)); } } return value; }; auto ans_two = [&](int x, int y) { long long best_a = (long long)(1e18) + 7; long long best_b = (long long)(1e18) + 7; for (int i = 0; i < N; i += y) { int l = i, r = min(N - 1, i + y - 1); if (last[r] >= l && last[r] >= x) { long long value = last[r] / y - (last[r] - x) / y; if (value < best_a) { swap(value, best_a); } if (value < best_b) { swap(value, best_b); } } if (slast[r] >= l && slast[r] >= x) { long long value = slast[r] / y - (slast[r] - x) / y; if (value < best_a) { swap(value, best_a); } if (value < best_b) { swap(value, best_b); } } } return best_a + best_b; }; auto check = [&](long long x, int y, long long s) { if (x >= N) { return false; } if (s - as(2 * x, y) >= x) { return true; } if (s - ans_two(x, y) >= x) { return true; } return false; }; long long ans = 4; vector<int> ord_y; for (int y = 2; y < N; y++) { ord_y.push_back(y); } shuffle(ord_y.begin(), ord_y.end(), rnd); auto seg_sum = [&](int l, int r) { return psum[r] - (l ? psum[l - 1] : 0); }; auto seg_cnt = [&](int l, int r) { return pcnt[r] - (l ? pcnt[l - 1] : 0); }; auto get_sum = [&](int y) { long long sum = 0; for (int i = 0; i < N; i += y) { int l = i, r = min(N - 1, i + y - 1); sum += seg_cnt(l, r) * (long long)(i / y); } return sum; }; for (int y : ord_y) { long long s = get_sum(y); long long vl = max(2ll, ans / y + 1); if (check(vl, y, s)) { int vr = N; while (vl < vr - 1) { int vm = (vl + vr) / 2; if (check(vm, y, s)) { vl = vm; } else { vr = vm; } } ans = vl * (long long)y; } } cout << ans << n ; } |
#include <bits/stdc++.h> using namespace std; int n, m, x, y, z, k, w, a, b, res, dist; vector<int> edge[200005], new_edge[200005]; int deg[200005], depth[200005], far[200005], far_dist[200005]; pair<int, int> dp[200005]; bool has_crit_point[200005]; void DFS(int x, int y, int pre) { if (y == 0) depth[x] = 0; else depth[x] = depth[y] + 1; int nxt_pre = pre; if (deg[x] >= 3) { has_crit_point[x] = 1; nxt_pre = x; if (pre != 0) { new_edge[pre].push_back(x); new_edge[x].push_back(pre); } } for (int i : edge[x]) if (i != y) DFS(i, x, nxt_pre), has_crit_point[x] |= has_crit_point[i]; if (!has_crit_point[x]) dp[x].first = x; for (int i : edge[x]) if (!has_crit_point[i]) { if (dp[x].first == 0 || depth[dp[i].first] >= depth[dp[x].first]) dp[x].second = dp[x].first, dp[x].first = dp[i].first; else if (dp[x].second == 0 || depth[dp[i].first] > depth[dp[x].second]) dp[x].second = dp[i].first; } } void solve(int x, int y) { for (int i : new_edge[x]) if (i != y) solve(i, x); int p = -1, q = -1, distp = 0, distq = 0; if (dp[x].second > 0) { far[x] = x; far_dist[x] = depth[dp[x].first] + depth[dp[x].second] - 2 * depth[x]; } for (int i : new_edge[x]) { int v = i; int distv = depth[dp[far[v]].first] + depth[dp[far[v]].second] - depth[far[v]] * 2; if (p == -1 || depth[far[v]] > depth[p]) q = p, distq = distp, p = far[v], distp = distv; else if (depth[far[v]] == depth[p] && distv > distp) q = p, distq = distp, p = far[v], distp = distv; else if (q == -1 || depth[far[v]] > depth[q]) distq = distv, q = far[v]; else if (depth[far[v]] == depth[q] && distv > distq) distq = distv, q = far[v]; if (depth[far[v]] > depth[far[x]]) far[x] = far[v], far_dist[x] = far_dist[v]; else if (depth[far[v]] == depth[far[x]] && far_dist[v] > far_dist[x]) far[x] = far[v], far_dist[x] = far_dist[v]; } if (dp[x].second > 0 && q == -1) q = x, distq = depth[dp[x].first] + depth[dp[x].second] - 2 * depth[x]; if (p == -1 || q == -1) return; if (depth[p] + depth[q] - 2 * depth[x] > res) { res = depth[p] + depth[q] - 2 * depth[x]; dist = distp + distq; a = p, b = q; } else if (depth[p] + depth[q] - 2 * depth[x] == res && distp + distq > dist) { dist = distp + distq; a = p, b = q; } } int main() { scanf( %d , &n); for (int i = (0); i < (n - 1); i++) scanf( %d %d , &x, &y), edge[x].push_back(y), edge[y].push_back(x), deg[x]++, deg[y]++; for (int i = (1); i <= (n); i++) if (deg[i] >= 3) x = i; DFS(x, 0, 0); a = b = -1; res = dist = 0; solve(x, 0); printf( %d %d n%d %d n , dp[a].first, dp[b].first, dp[a].second, dp[b].second); return 0; } |
#include <bits/stdc++.h> #pragma comment(linker, /STACK:36777216 ) using namespace std; const double pi = acos(-1.0); const double eps = 1e-11; const int oo = 0x3f3f3f3f; template <class T> inline void checkmin(T &a, T b) { if (b < a) a = b; } template <class T> inline void checkmax(T &a, T b) { if (b > a) a = b; } template <class T> inline T sqr(T x) { return x * x; } template <class T> inline T lowbit(T n) { return (n ^ (n - 1)) & n; } template <class T> inline int countbit(T n) { return (n == 0) ? 0 : (1 + countbit(n & (n - 1))); } template <class T> inline T gcd(T a, T b) { T c; while (a != 0) { c = a; a = b % a; b = c; } return b; } template <class T> inline T mabs(T a) { if (a < 0) return -a; else return a; } typedef vector<int> VI; typedef vector<VI> VII; typedef vector<string> VS; const int N = (int)21; const int MOD = (int)1e9 + 7; int g[N][N]; inline int solve(int testnum) { int n, k; cin >> n >> k; map<string, int> names; names.clear(); map<int, string> idx2name; idx2name.clear(); for (int i = (0); i < int(n); i++) { string s; cin >> s; names[s] = i; idx2name[i] = s; } for (int i = (0); i < int(n); i++) for (int j = (0); j < int(n); j++) g[i][j] = 1; for (int i = (0); i < int(k); i++) { string a, b; cin >> a >> b; int ia = names[a]; int ib = names[b]; g[ia][ib] = 0; } int best = 0; for (int mask = (0); mask < int((1 << (n))); mask++) { int f = 1; for (int i = (0); i < int(n); i++) { if ((mask & (1 << (i))) > 0) { for (int j = (0); j < int(n); j++) if ((mask & (1 << (j))) > 0) { if (g[i][j] == 0) { f = 0; } } } } if (!f || !mask) continue; if (countbit(mask) > countbit(best)) { best = mask; } } VS ret; ret.clear(); for (int b = (0); b < int(n); b++) if ((best & (1 << (b))) > 0) { ret.push_back(idx2name[b]); } sort((ret).begin(), (ret).end()); printf( %d n , ret.size()); for (auto &j : ret) printf( %s n , j.c_str()); return 0; } int main(int argc, char *argv[]) { ios::sync_with_stdio(false); int t = 1; if (argc > 1) t = atoi(argv[1]); for (int _t = (1); _t < int(t + 1); _t++) { int ret = ::solve(_t); if (ret == -1) { cerr << Failed test # << _t << endl; break; } cerr << Solved test # << _t << endl; } return 0; } |
#include <bits/stdc++.h> int main() { int sign = 1; int current = 0; int value = 0; for (char c; n != (c = getchar());) { if (c == + or c == - ) { value += sign * current; sign = (c == + ? 1 : -1); current = 0; } current *= 10; current += c - 0 ; } printf( %d , value + sign * current); return 0; } |
#include <bits/stdc++.h> using namespace std; inline int IN() { int x = 0, ch = getchar(), f = 1; while (!isdigit(ch) && (ch != - ) && (ch != EOF)) ch = getchar(); if (ch == - ) { f = -1; ch = getchar(); } while (isdigit(ch)) { x = (x << 1) + (x << 3) + ch - 0 ; ch = getchar(); } return x * f; } double nx, ny, T, nc, w, h, Dist[1005]; int n; struct Point { double x, y; } a[1005]; double dir[4][2] = {{-1, 0}, {0, -1}, {0, 1}, {1, 0}}; double sqr(double a) { return a * a; } double dist(double xa, double ya, double xb, double yb) { return sqrt(sqr(xb - xa) + sqr(yb - ya)); } double Calc(double x, double y) { for (int i = 0; i <= n - 1; i++) Dist[i] = dist(x, y, a[i].x, a[i].y); double Min1 = 1 << 30, pos1, Min2 = 1 << 30; for (int i = 0; i <= n - 1; i++) if (Dist[i] < Min1) Min1 = Dist[i], pos1 = i; for (int i = 0; i <= n - 1; i++) if (i != pos1 && Dist[i] < Min2) Min2 = Dist[i]; return Min2; } int main() { srand((unsigned)time(NULL)); double Max = 0; w = 1.0 * IN(), h = 1.0 * IN(), n = IN(); for (int i = 0; i <= n - 1; i++) a[i].x = IN(), a[i].y = IN(); for (int i = 1; i <= 60; i++) { double nx = rand() * rand() % (int)w, ny = rand() * rand() % (int)h; T = h, nc = Calc(nx, ny); while (T > 1e-12) { bool chg = 0; double X, Y; for (int j = 0; j <= 3; j++) { double x = nx + T * dir[j][0], y = ny + T * dir[j][1]; if (x < 0 || x > w || y < 0 || y > h) continue; double xc = Calc(x, y); if (xc > nc) { X = x, Y = y, nc = xc; chg = 1; } } if (chg) { nx = X, ny = Y; } else T *= 0.9; } Max = max(Max, Calc(nx, ny)); } printf( %.15lf n , Max); } |
#include <bits/stdc++.h> using namespace std; int arr[100001]; int tree[100001 * 3]; void init(int node, int b, int e) { if (b == e) { tree[node] = arr[b]; return; } int Left = node * 2; int Right = node * 2 + 1; int mid = (b + e) / 2; init(Left, b, mid); init(Right, mid + 1, e); tree[node] = tree[Left] + tree[Right]; } int query(int node, int b, int e, int i, int j) { if (i > e || j < b) return 0; if (b >= i && e <= j) return tree[node]; int Left = node * 2; int Right = node * 2 + 1; int mid = (b + e) / 2; int p1 = query(Left, b, mid, i, j); int p2 = query(Right, mid + 1, e, i, j); return p1 + p2; } void update(int node, int b, int e, int i, int newvalue) { if (i > e || i < b) return; if (b >= i && e <= i) { tree[node] = newvalue; return; } int Left = node * 2; int Right = node * 2 + 1; int mid = (b + e) / 2; update(Left, b, mid, i, newvalue); update(Right, mid + 1, e, i, newvalue); tree[node] = tree[Left] + tree[Right]; } int main() { int n, m; cin >> n >> m; for (int i = 1; i <= n; i++) { cin >> arr[i]; } init(1, 1, n); vector<int> v; while (m--) { int x, y; cin >> x >> y; int sum = query(1, 1, n, x, y); v.push_back(sum); } int ans = 0; for (int i = 0; i < v.size(); i++) { if (v[i] > 0) ans += v[i]; } cout << ans << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { long long n, m; cin >> n >> m; long long ans = n; for (__typeof(m) i = 0; i < m; i++) { long long a, b; cin >> a >> b; ans = min(ans, b - a + 1); } cout << ans << endl; for (__typeof(n) i = 0; i < n; i++) { cout << i % ans << ; } cout << endl; } |
#include <bits/stdc++.h> using namespace std; struct MaxFlow { int T; struct node { int to, nxt, cap; } ed[811 * 811 << 1]; int head[811], cur[811], cnt, ans; int h[811]; void addedge(int u, int v, int cap) { ed[cnt].to = v, ed[cnt].cap = cap, ed[cnt].nxt = head[u], head[u] = cnt++; ed[cnt].to = u, ed[cnt].cap = 0, ed[cnt].nxt = head[v], head[v] = cnt++; } bool bfs() { memset(h, -1, sizeof(h)); queue<int> q; h[1] = 0, q.push(1); while (!q.empty()) { int now = q.front(); q.pop(); for (int i = head[now]; ~i; i = ed[i].nxt) { if (ed[i].cap && h[ed[i].to] == -1) { h[ed[i].to] = h[now] + 1; q.push(ed[i].to); } } } return h[T] != -1; } int dfs(int x, int f) { if (x == T || f == 0) return f; int w, used = 0; for (int i = cur[x]; ~i; i = ed[i].nxt) { if (h[ed[i].to] == h[x] + 1) { w = f - used; w = dfs(ed[i].to, min(w, ed[i].cap)); ed[i].cap -= w; ed[i ^ 1].cap += w; if (ed[i].cap) cur[x] = i; used += w; if (used == f) return f; } } if (!used) h[x] = -1; return used; } void dinic() { while (bfs()) { for (int i = 1; i <= T; i++) { cur[i] = head[i]; } ans += dfs(1, 100000005); } } void init(int t) { memset(head, -1, sizeof(head)); ans = cnt = 0; T = t; } } flow; int dis[811][811], st[811]; int main() { int v, e, n, k; scanf( %d%d%d%d , &v, &e, &n, &k); for (int i = 1; i <= n; i++) scanf( %d , &st[i]); for (int i = 1; i <= v; i++) for (int j = i + 1; j <= v; j++) dis[i][j] = dis[j][i] = 100000005; for (int i = 1; i <= e; i++) { int a, b, c; scanf( %d%d%d , &a, &b, &c); dis[a][b] = min(dis[a][b], c); dis[b][a] = dis[a][b]; } for (int x = 1; x <= v; x++) { for (int i = 1; i <= v; i++) { for (int j = 1; j <= v; j++) { dis[i][j] = min(dis[i][x] + dis[x][j], dis[i][j]); } } } int l = 0, r = 1731311, ct = -1; while (l <= r) { int mid = l + r >> 1; flow.init(1 + n + v + 2); for (int i = 1; i <= n; i++) { flow.addedge(1, i + 1, 1); for (int j = 1; j <= v; j++) { if (dis[st[i]][j] <= mid) { flow.addedge(i + 1, 1 + j + n, 1); } } } for (int i = 1; i <= v; i++) flow.addedge(1 + i + n, 1 + v + n + 1, 1); flow.addedge(1 + v + n + 1, 1 + v + n + 2, k); flow.dinic(); if (flow.ans == k) { ct = mid; r = mid - 1; } else l = mid + 1; } printf( %d n , ct); return 0; } |
#include <bits/stdc++.h> using namespace std; int n, m; int a[205], b[205]; int main() { cin >> n >> m; for (int i = 0; i < n; i++) cin >> a[i]; for (int i = 0; i < m; i++) cin >> b[i]; for (int i = 0; i < 512; i++) { int cnt = 0; for (int j = 0; j < n; j++) { for (int k = 0; k < m; k++) { if (((a[j] & b[k]) | i) == i) { cnt++; break; } } } if (cnt == n) { cout << i << endl; break; } } } |
#include <bits/stdc++.h> using namespace std; int main() { string s; cin >> s; char cur = a ; vector<char> res(s.size()); for (int i = 0; i < s.size(); i++) { if (cur > z ) { res[i] = s[i]; } else if (s[i] <= cur) { res[i] = cur; cur++; } else { res[i] = s[i]; } } if (cur > z ) { for (auto elem : res) { cout << elem; } } else { cout << -1; } } |
#include <bits/stdc++.h> using namespace std; const int inf = 1e9; const int N = 1e6 + 10; signed main() { ios_base::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr); int n, m; cin >> n >> m; int g[n]; for (int i = 0; i < n; ++i) cin >> g[i]; sort(g, g + (sizeof(g) / sizeof(*g))); long long d[n]; fill(d, d + (sizeof(d) / sizeof(*d)), 0); for (int i = m; i < n; ++i) d[i] = g[i - m] + d[i - m]; long long sm = 0; for (int i = 0; i < n; ++i) { sm += g[i] + d[i]; cout << sm << ; } return 0; } |
#include <bits/stdc++.h> using namespace std; const int N = 5000010; vector<long long> v[N]; int a[N]; long long com2(long long n) { return n * (n - 1) / 2; } int main() { long long n, m; cin >> n >> m; for (int i = 1; i <= n; i++) { scanf( %d , &a[i]); if (a[i] >= m) { printf( 0 n ); return 0; } } for (int i = 1; i <= n; i++) if (a[i]) { for (int j = i; j <= n; j++) v[0].push_back(a[j]); break; } if (v[0].size() == 2) { long long lt = 1, rt = m / v[0][0] + 1, mid; long long ans = 0; while (lt <= rt) { mid = (lt + rt) >> 1; if (1LL * mid * v[0][0] + v[0][1] >= m) ans = mid, rt = mid - 1; else lt = mid + 1; } cout << ans << endl; } else if (v[0].size() == 3) { long long lt = 1, rt = 2000000000, mid; long long ans = 0; while (lt <= rt) { mid = (lt + rt) >> 1; long long p = com2(mid + 1); if (m / v[0][0] < p) { ans = mid, rt = mid - 1; continue; } p = p * v[0][0] + mid * v[0][1] + v[0][2]; if (p >= m) { ans = mid, rt = mid - 1; } else lt = mid + 1; } cout << ans << endl; } else { for (int i = 1; i < N; i++) { long long sum = 0; for (int j = 0; j < v[i - 1].size(); j++) { sum += v[i - 1][j]; v[i].push_back(sum); if (sum >= m) { printf( %d n , i); return 0; } } } } return 0; } |
#include <bits/stdc++.h> #pragma GCC optimize( O2 ) using namespace std; const int MAX = 2e5 + 5; const long long MAX2 = 11; const int MOD = 1000000000 + 7; const long long INF = 20000; const int dr[] = {1, 0, -1, 0, 1, 1, -1, -1}; const int dc[] = {0, 1, 0, -1, 1, -1, 1, -1}; const double pi = acos(-1); long long tc, a, b, c, d, x[3]; bool ans; inline bool cek() { sort(x, x + 3); if (x[0] < 0 || 2 * x[2] - x[0] - x[1] > a || (a - 2 * x[2] + x[0] + x[1]) % 3 || x[0] + x[1] + x[2] > b || (x[0] + x[1] + x[2]) % 3 != b % 3) return 0; return 1; } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); cin >> tc; while (tc--) { cin >> a >> b >> c >> d; if (c > d) c ^= d ^= c ^= d; a -= b; ans = 0; x[0] = 0, x[1] = c, x[2] = d; ans |= cek(); x[0] = 0, x[1] = c, x[2] = c + d; ans |= cek(); x[0] = 0, x[1] = d, x[2] = c + d; ans |= cek(); x[0] = 0, x[1] = c - d, x[2] = c; ans |= cek(); x[0] = 0, x[1] = d - c, x[2] = d; ans |= cek(); if (ans) cout << yes n ; else cout << no n ; } return 0; } |
#include <bits/stdc++.h> using namespace std; int n, k; int a[11]; int tmpa[11]; int sum; int main() { cin >> n; for (int i = 0; i < n; i++) { cin >> a[i]; tmpa[i] = a[i]; sum += a[i]; } sort(a, a + n); if (n == 1) { cout << -1 << endl; } else { if (n == 2 && a[0] == a[1]) { cout << -1 << endl; } else { cout << 1 << endl; for (int i = 0; i < n; i++) { if (tmpa[i] == a[0]) { cout << i + 1 << endl; break; } } } } return 0; } |
#include <bits/stdc++.h> using namespace std; int n, vis[5009], d[5009][5009]; vector<int> e; vector<vector<int> > g; char s[5009]; void dfs(int v, int pr = -1) { int i; vis[v] = 1; for (auto u : g[v]) { if (d[u][pr] == 1 && pr != -1) { cout << u << << pr << << v; exit(0); } if (!vis[u]) dfs(u, v); } } int main() { int i, j; scanf( %d , &n); g.resize(n + 1); ; for (i = (1); i <= (n); i++) { scanf( %s , s); ; for (j = (0); j <= (n - 1); j++) if (s[j] == 1 ) { g[i].push_back(j + 1); d[i][j + 1] = 1; } }; for (i = (1); i <= (n); i++) { if (!vis[i]) dfs(i); } cout << -1 ; } |
#include <bits/stdc++.h> using namespace std; int main(int argc, char const *argv[]) { int n, m; char c[2000][2000]; int rowcount[2000]; int colcount[2000], wallcount = 0; for (int i = 0; i < 2000; i++) { rowcount[i] = 0; colcount[i] = 0; } scanf( %d , &n); scanf( %d , &m); for (int i = 0; i < n; i++) scanf( %s , c[i]); for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if (c[i][j] == * ) { rowcount[i]++; colcount[j]++; wallcount++; } } } for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if (c[i][j] == * && rowcount[i] + colcount[j] - 1 == wallcount || c[i][j] == . && rowcount[i] + colcount[j] == wallcount) { printf( YES n ); printf( %d %d n , i + 1, j + 1); return 0; } } } printf( NO n ); return 0; } |
#include <bits/stdc++.h> using namespace std; const long long N = 30000; long long t, n, a[N], l, r; bool possible() { if (l > r) return 1; long long o = a[l - 1]; a[l - 1] = 0; for (long long i = l; i <= r; i++) { long long v = max(a[i - 1], a[i] - o); if (v > a[r + 1]) return 0; o = a[i] - v; a[i] = v; } return 1; } int main() { ios::sync_with_stdio(0); cin.tie(0); cin >> t; while (t--) { cin >> n; for (long long i = 0; i < n; i++) cin >> a[i]; l = 1; r = n - 2; for (; l < n && a[l - 1] >= a[l]; l++) ; for (; r >= 0 && a[r] <= a[r + 1]; r--) ; cout << (possible() ? YES n : NO n ); } } |
#include <bits/stdc++.h> using namespace std; const int MAXN = 200005; const int INFTY = 1 << 30; int D, N, M; pair<int, int> pos[MAXN]; vector<int> S; int nxt[MAXN]; int main() { scanf( %d %d %d , &D, &N, &M); for (int i = 0; i < M; i++) scanf( %d %d , &pos[i].first, &pos[i].second); sort(pos, pos + M); pos[M] = make_pair(D, 0); for (int i = M - 1; i >= 0; i--) { while (!S.empty() && pos[S.back()].second > pos[i].second) S.pop_back(); nxt[i] = S.empty() ? M : S.back(); S.push_back(i); } long long ans = 0; int cur = N - pos[0].first; for (int i = 0; i < M; i++) { if (cur < 0) { printf( -1 n ); return 0; } int need = min(N, pos[nxt[i]].first - pos[i].first); int add = max(0, need - cur); ans += (long long)pos[i].second * add; cur += add - (pos[i + 1].first - pos[i].first); } if (cur < 0) printf( -1 n ); else printf( %I64d n , ans); return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { ios::sync_with_stdio(0); cin.tie(0); int n, a, b; cin >> n >> a >> b; map<long long, int> M; map<pair<int, int>, int> M2; long long ans = 0; for (int i = 0; i < n; ++i) { int x, vx, vy; cin >> x >> vx >> vy; auto temp = (long long)a * vx - vy; ans += M[temp] - M2[{vx, vy}]; M[temp]++; M2[{vx, vy}]++; } cout << ans * 2 << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; long long a[200001], b[200001]; int n; int main(void) { int t; cin >> t; while (t--) { cin >> n; long long sum = 0LL; for (int i = 0; i < n; i++) { cin >> a[i]; } for (int i = 0; i < n; i++) { cin >> b[i]; sum += b[i]; } vector<pair<long long, long long> > c; for (int i = 0; i < n; i++) { c.push_back(make_pair(a[i], i)); } sort(c.begin(), c.end()); long long ans = sum; for (int i = 0; i < n; i++) { sum -= b[c[i].second]; ans = min(ans, max(sum, c[i].first)); } cout << ans << n ; } return 0; } |
#include <bits/stdc++.h> using namespace std; using ll = long long; using vi = vector<int>; using vvi = vector<vi>; using vll = vector<ll>; using vvll = vector<vll>; using vb = vector<bool>; using vd = vector<double>; using vs = vector<string>; using pii = pair<int, int>; using pll = pair<ll, ll>; using pdd = pair<double, double>; using vpii = vector<pii>; using vpll = vector<pll>; using vpdd = vector<pdd>; template <typename T> void ckmin(T& a, const T& b) { a = min(a, b); } template <typename T> void ckmax(T& a, const T& b) { a = max(a, b); } mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count()); namespace __input { template <class T1, class T2> void re(pair<T1, T2>& p); template <class T> void re(vector<T>& a); template <class T, size_t SZ> void re(array<T, SZ>& a); template <class T> void re(T& x) { cin >> x; } void re(double& x) { string t; re(t); x = stod(t); } template <class Arg, class... Args> void re(Arg& first, Args&... rest) { re(first); re(rest...); } template <class T1, class T2> void re(pair<T1, T2>& p) { re(p.first, p.second); } template <class T> void re(vector<T>& a) { for (int i = 0; i < (int((a).size())); i++) re(a[i]); } template <class T, size_t SZ> void re(array<T, SZ>& a) { for (int i = 0; i < (SZ); i++) re(a[i]); } } // namespace __input using namespace __input; namespace __output { template <class T1, class T2> void pr(const pair<T1, T2>& x); template <class T, size_t SZ> void pr(const array<T, SZ>& x); template <class T> void pr(const vector<T>& x); template <class T> void pr(const set<T>& x); template <class T1, class T2> void pr(const map<T1, T2>& x); template <class T> void pr(const T& x) { cout << x; } template <class Arg, class... Args> void pr(const Arg& first, const Args&... rest) { pr(first); pr(rest...); } template <class T1, class T2> void pr(const pair<T1, T2>& x) { pr( { , x.first, , , x.second, } ); } template <class T, bool pretty = true> void prContain(const T& x) { if (pretty) pr( { ); bool fst = 1; for (const auto& a : x) pr(!fst ? pretty ? , : : , a), fst = 0; if (pretty) pr( } ); } template <class T> void pc(const T& x) { prContain<T, false>(x); pr( n ); } template <class T, size_t SZ> void pr(const array<T, SZ>& x) { prContain(x); } template <class T> void pr(const vector<T>& x) { prContain(x); } template <class T> void pr(const set<T>& x) { prContain(x); } template <class T1, class T2> void pr(const map<T1, T2>& x) { prContain(x); } void ps() { pr( n ); } template <class Arg> void ps(const Arg& first) { pr(first); ps(); } template <class Arg, class... Args> void ps(const Arg& first, const Args&... rest) { pr(first, ); ps(rest...); } } // namespace __output using namespace __output; namespace __algorithm { template <typename T> void dedup(vector<T>& v) { sort((v).begin(), (v).end()); v.erase(unique((v).begin(), (v).end()), v.end()); } template <typename T> typename vector<T>::const_iterator find(const vector<T>& v, const T& x) { auto it = lower_bound((v).begin(), (v).end(), x); return it != v.end() && *it == x ? it : v.end(); } template <typename T> size_t index(const vector<T>& v, const T& x) { auto it = find(v, x); assert(it != v.end() && *it == x); return it - v.begin(); } template <typename T1, typename T2> typename vector<pair<T1, T2>>::iterator lower_bound( const vector<pair<T1, T2>>& v, const T1& x) { return lower_bound( (v).begin(), (v).end(), x, [](pair<T1, T2> a, pair<T1, T2> b) { return a.first < b.first; }); } template <typename T1, typename T2> typename vector<pair<T1, T2>>::iterator upper_bound( const vector<pair<T1, T2>>& v, const T1& x) { return upper_bound( (v).begin(), (v).end(), x, [](pair<T1, T2> a, pair<T1, T2> b) { return a.first < b.first; }); } } // namespace __algorithm using namespace __algorithm; struct __monostate { friend istream& operator>>(istream& is, const __attribute__((unused)) __monostate& ms) { return is; } friend ostream& operator<<(ostream& os, const __attribute__((unused)) __monostate& ms) { return os; } } ms; namespace __io { void setIn(string second) { freopen(second.c_str(), r , stdin); } void setOut(string second) { freopen(second.c_str(), w , stdout); } void setIO(string second = ) { ios_base::sync_with_stdio(0); cin.tie(0); cout << setprecision(15); if (int((second).size())) { setIn(second + .in ), setOut(second + .out ); } } } // namespace __io using namespace __io; int main() { setIO(); ll P; int K; re(P, K); vi poly; while (P) { int rem = P % K; if (int((poly).size()) & 1) { rem = rem ? K - rem : 0; poly.push_back(rem); P = (P + rem) / K; } else { poly.push_back(rem); P = (P - rem) / K; } } ps(int((poly).size())); pc(poly); return 0; } |
#include <bits/stdc++.h> using namespace std; int gcd(int a, int b) { return b ? gcd(b, a % b) : a; } void solve() { int m, d, w; long long int ans = 0, lim, g, x, y; scanf( %d%d%d , &m, &d, &w); lim = min(m, d); if (d == 1) ans = lim * lim; else { g = gcd(d - 1, w); w /= g; x = lim / w; y = lim % w; ans = y * (x + 1) * (x + 1) + (w - y) * x * x; } ans -= lim; ans >>= 1; printf( %lld n , ans); return; } int main() { int t; scanf( %d , &t); while (t--) solve(); } |
#include <bits/stdc++.h> using namespace std; signed main() { ios_base::sync_with_stdio(0); cin.tie(0); long long n; cin >> n; vector<long long> tpa[6], tpb[4]; long long amt[6]; fill(amt, amt + 6, 0); for (long long i = 0; i < n; ++i) { long long a, b, c; cin >> a >> b >> c; --a; --c; if (c < a) { swap(a, c); } if (a == 0 && c == 0) { tpb[0].push_back(b); } else if (a == 0 && c == 1) { tpa[0].push_back(b); ++amt[0]; } else if (a == 0 && c == 2) { tpa[1].push_back(b); ++amt[1]; } else if (a == 0 && c == 3) { tpa[2].push_back(b); ++amt[2]; } else if (a == 1 && c == 1) { tpb[1].push_back(b); } else if (a == 1 && c == 2) { tpa[3].push_back(b); ++amt[3]; } else if (a == 1 && c == 3) { tpa[4].push_back(b); ++amt[4]; } else if (a == 2 && c == 2) { tpb[2].push_back(b); } else if (a == 2 && c == 3) { tpa[5].push_back(b); ++amt[5]; } else { tpb[3].push_back(b); } } for (long long i = 0; i < 6; ++i) { if (i < 4) sort((tpb[i]).begin(), (tpb[i]).end(), greater<long long>()); sort((tpa[i]).begin(), (tpa[i]).end(), greater<long long>()); } long long ans = 0; for (long long i = 0; i < 4; ++i) { long long cr = 0; for (long long j : tpb[i]) { cr += j; } ans = max(ans, cr); } long long val[amt[0] + 1][amt[1] + 1][amt[2] + 1][amt[3] + 1][amt[4] + 1] [amt[5] + 1]; memset(val, 0, sizeof val); for (long long a = 0; a <= amt[0]; ++a) { for (long long b = 0; b <= amt[1]; ++b) { for (long long c = 0; c <= amt[2]; ++c) { for (long long d = 0; d <= amt[3]; ++d) { for (long long e = 0; e <= amt[4]; ++e) { for (long long f = 0; f <= amt[5]; ++f) { if (!a && !b && !c && !d && !e && !f) continue; if (a) { val[a][b][c][d][e][f] = max(val[a][b][c][d][e][f], val[a - 1][b][c][d][e][f] + tpa[0][a - 1]); } if (b) { val[a][b][c][d][e][f] = max(val[a][b][c][d][e][f], val[a][b - 1][c][d][e][f] + tpa[1][b - 1]); } if (c) { val[a][b][c][d][e][f] = max(val[a][b][c][d][e][f], val[a][b][c - 1][d][e][f] + tpa[2][c - 1]); } if (d) { val[a][b][c][d][e][f] = max(val[a][b][c][d][e][f], val[a][b][c][d - 1][e][f] + tpa[3][d - 1]); } if (e) { val[a][b][c][d][e][f] = max(val[a][b][c][d][e][f], val[a][b][c][d][e - 1][f] + tpa[4][e - 1]); } if (f) { val[a][b][c][d][e][f] = max(val[a][b][c][d][e][f], val[a][b][c][d][e][f - 1] + tpa[5][f - 1]); } } } } } } } for (long long i = 0; i < 16; ++i) { for (long long j = 0; j < 6; ++j) { amt[j] = tpa[j].size(); } long long cur = 0; bool adj[4]; fill(adj, adj + 4, false); for (long long j = 0; j < 4; ++j) { if (i & (1 << j)) { for (long long k : tpb[j]) { cur += k; } } else { adj[j] = 1; if (j == 0) { amt[0] = amt[1] = amt[2] = 0; } else if (j == 1) { amt[0] = amt[3] = amt[4] = 0; } else if (j == 2) { amt[1] = amt[3] = amt[5] = 0; } else if (j == 3) { amt[2] = amt[4] = amt[5] = 0; } } } if (!adj[0] && !amt[0] && !amt[1] && !amt[2]) continue; if (!adj[1] && !amt[0] && !amt[3] && !amt[4]) continue; if (!adj[2] && !amt[1] && !amt[3] && !amt[5]) continue; if (!adj[3] && !amt[2] && !amt[4] && !amt[5]) continue; bitset<4> dp[amt[0] + 1][amt[1] + 1][amt[2] + 1][amt[3] + 1][amt[4] + 1] [amt[5] + 1]; for (long long j = 0; j < 4; ++j) { dp[amt[0]][amt[1]][amt[2]][amt[3]][amt[4]][amt[5]][j] = 1; } for (long long a = amt[0]; a >= 0; --a) { for (long long b = amt[1]; b >= 0; --b) { for (long long c = amt[2]; c >= 0; --c) { for (long long d = amt[3]; d >= 0; --d) { for (long long e = amt[4]; e >= 0; --e) { for (long long f = amt[5]; f >= 0; --f) { if (a != amt[0]) { if (dp[a + 1][b][c][d][e][f][0]) { dp[a][b][c][d][e][f][1] = 1; } if (dp[a + 1][b][c][d][e][f][1]) { dp[a][b][c][d][e][f][0] = 1; } } if (b != amt[1]) { if (dp[a][b + 1][c][d][e][f][0]) { dp[a][b][c][d][e][f][2] = 1; } if (dp[a][b + 1][c][d][e][f][2]) { dp[a][b][c][d][e][f][0] = 1; } } if (c != amt[2]) { if (dp[a][b][c + 1][d][e][f][0]) { dp[a][b][c][d][e][f][3] = 1; } if (dp[a][b][c + 1][d][e][f][3]) { dp[a][b][c][d][e][f][0] = 1; } } if (d != amt[3]) { if (dp[a][b][c][d + 1][e][f][2]) { dp[a][b][c][d][e][f][1] = 1; } if (dp[a][b][c][d + 1][e][f][1]) { dp[a][b][c][d][e][f][2] = 1; } } if (e != amt[4]) { if (dp[a][b][c][d][e + 1][f][3]) { dp[a][b][c][d][e][f][1] = 1; } if (dp[a][b][c][d][e + 1][f][1]) { dp[a][b][c][d][e][f][3] = 1; } } if (f != amt[5]) { if (dp[a][b][c][d][e][f + 1][2]) { dp[a][b][c][d][e][f][3] = 1; } if (dp[a][b][c][d][e][f + 1][3]) { dp[a][b][c][d][e][f][2] = 1; } } } } } } } } long long cans = 0; for (long long a = max(0LL, amt[0]); a >= 0; --a) { for (long long b = max(0LL, amt[1]); b >= 0; --b) { for (long long c = max(0LL, amt[2]); c >= 0; --c) { for (long long d = max(0LL, amt[3]); d >= 0; --d) { for (long long e = max(0LL, amt[4]); e >= 0; --e) { for (long long f = max(0LL, amt[5]); f >= 0; --f) { bool usd[4]; fill(usd, usd + 4, 0); if (a < amt[0] || b < amt[1] || c < amt[2]) usd[0] = 1; if (a < amt[0] || d < amt[3] || e < amt[4]) usd[1] = 1; if (b < amt[1] || d < amt[3] || f < amt[5]) usd[2] = 1; if (c < amt[2] || e < amt[4] || f < amt[5]) usd[3] = 1; bool ok = 0; for (long long j = 0; j < 4; ++j) { if (dp[a][b][c][d][e][f][j]) ok = 1; if (i & (1 << j)) { if (!usd[j]) { ok = false; break; } } } if (!ok) continue; cans = max(cans, cur + val[amt[0] - a][amt[1] - b][amt[2] - c] [amt[3] - d][amt[4] - e][amt[5] - f]); } } } } } } for (long long j = 0; j < 6; ++j) { amt[j] = tpa[j].size(); } ans = max(ans, cans); } cout << ans << n ; } |
#include <bits/stdc++.h> using namespace std; int n; long double ans1[1000000]; long double ans2[1000000]; long double sa[1000000]; long double sb[1000000]; long double x1[1000000]; long double x[1000000]; long double sqr(long double x) { return x * x; } long double sqrtt(long double x) { if (x < 0) return 0; return sqrt(x); } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cin >> n; for (int i = 1; i <= n; i++) cin >> x[i]; for (int i = 1; i <= n; i++) cin >> x1[i]; for (int i = 1; i <= 1; i++) { long double D = sqrtt(-4 * x[i] + sqr(x1[i] + x[i])); ans1[i] = (x1[i] + x[i] + D) / 2.; ans2[i] = x[i] / ans1[i]; sa[i] = ans1[i]; sb[i] = ans2[i]; } for (int i = 2; i <= n; i++) { long double a = 1; long double b = sa[i - 1] - x[i] - sb[i - 1] - x1[i]; long double c = x[i] - sa[i - 1] * x[i] - x1[i] * sa[i - 1]; long double D = sqrtt(b * b - a * c * 4); ans1[i] = (-b + D) / 2.; ans2[i] = (x[i] - ans1[i] * sb[i - 1]) / (ans1[i] + sa[i - 1]); sa[i] = ans1[i] + sa[i - 1]; sb[i] = ans2[i] + sb[i - 1]; } cout.precision(9); for (int i = 1; i <= n; i++) cout << fixed << ans1[i] << ; cout << n ; for (int i = 1; i <= n; i++) cout << fixed << ans2[i] << ; cout << n ; } |
#include <bits/stdc++.h> using namespace std; const int N = 123, mod = 1e9 + 7; int n, b, p, x; int cnt[N]; vector<vector<int>> t, a, res; void add(int& a, int b) { a = (a + b); if (a >= mod) { a -= mod; } } int mult(int a, int b) { a = (a * 1ll * b) % mod; return a; } vector<vector<int>> mat_mult(const vector<vector<int>>& a, const vector<vector<int>>& b) { vector<vector<int>> c; c.resize(x, vector<int>(x)); for (int i = 0; i < x; i++) { for (int j = 0; j < x; j++) { for (int k = 0; k < x; k++) { add(c[i][k], mult(a[i][j], b[j][k])); } } } return c; } vector<vector<int>> binpow(int t) { if (t == 0) return res; vector<vector<int>> o = binpow(t / 2); o = mat_mult(o, o); if (t % 2 == 1) o = mat_mult(o, a); return o; } int main() { cin >> n >> b >> p >> x; a.resize(x, vector<int>(x)); res.resize(x, vector<int>(x)); for (int i = 1, val; i <= n; i++) { cin >> val; cnt[val]++; } for (int i = 0; i < x; i++) { res[i][i] = 1; } for (int i = 0; i < x; i++) { for (int j = 0; j < 10; j++) { a[i][(i * 10 + j) % x] += cnt[j]; } } res = binpow(b); cout << res[0][p]; } |
#include <bits/stdc++.h> using namespace std; int n, m, ans; int l[255 * 2], r[255 * 2], str[255 * 2], po[27]; char s[255][255]; int solve(int bas, int son) { int tot = 0; l[bas - 1] = bas; r[bas - 1] = bas - 1; for (int i = bas; i <= son; i++) { if (r[i - 1] < i) { l[i] = r[i] = i; } else { int sm = l[i - 1] + r[i - 1] - i; l[i] = i - min(sm - l[sm], sm - l[i - 1]); r[i] = 2 * i - l[i]; } while (r[i] + 1 <= son && l[i] - 1 >= bas && str[l[i] - 1] == str[r[i] + 1]) r[i]++, l[i]--; if (str[i] == 0) tot += (r[i] - l[i]) / 4; else tot += (r[i] - l[i] + 2) / 4; } return tot; } int main() { scanf( %d %d , &n, &m); for (int i = 1; i <= n; i++) scanf( %s , s[i] + 1); po[0] = 1; for (int i = 1; i < 26; i++) po[i] = 1ll * po[i - 1] * 701 % 1000000007; for (int i = 1; i <= m; i++) { int hash[255] = {0}, tot[255] = {0}; bitset<26> odd[255]; for (int j = i; j <= m; j++) { vector<pair<int, int> > v; for (int k = 1; k <= n; k++) { hash[k] = (hash[k] + po[s[k][j] - a ]) % 1000000007; tot[k] -= odd[k].test(s[k][j] - a ); odd[k][s[k][j] - a ] = !odd[k][s[k][j] - a ]; tot[k] += odd[k].test(s[k][j] - a ); v.push_back({hash[k], k}); } sort(v.begin(), v.end()); int cnt = 0; for (int k = 0; k < n; k++) { ++cnt; str[v[k].second * 2 - 1] = cnt; while (k + 1 < n && v[k].first == v[k + 1].first) { k++; str[v[k].second * 2 - 1] = cnt; } } for (int k = 1; k <= n; k++) { if (tot[k] > 1) continue; int bas = k; while (k + 1 <= n && tot[k + 1] < 2) k++; ans += solve((bas - 1) * 2, k * 2); } } } printf( %d , ans); } |
#include <bits/stdc++.h> using namespace std; const int N = 200005; vector<int> v[N]; int n, kk; int dis[N], ans[N]; void dfs1(int pos, int fa) { for (auto &i : v[pos]) if (i != fa) dfs1(i, pos), dis[pos] = max(dis[pos], dis[i]); ++dis[pos]; } bool dfs2(int pos, int fa, const multiset<int, greater<int>> &mt) { multiset<int, greater<int>> d; int mx = 0; for (auto &i : v[pos]) if (i != fa) d.insert(dis[i]); else mx = 1; bool fs = 1; for (auto &i : mt) { if (i == dis[pos] && fs) { fs = 0; continue; } mx = i + 1; break; } if (mx) d.insert(mx); while (d.size() > 3) d.erase(prev(d.end())); if (d.size() > 2 && *next(d.begin()) + *next(next(d.begin())) >= kk - 1) { cout << No << endl; return 0; } for (auto &i : v[pos]) if (i != fa && !dfs2(i, pos, d)) return 0; return 1; } int dep[N], f[N]; void dfs(int pos, int fa) { dep[pos] = dep[fa] + 1; f[pos] = fa; for (auto &i : v[pos]) if (i != fa) dfs(i, pos); } void dfs3(int pos, int fa, int cur, int dd) { ans[pos] = cur; for (auto &i : v[pos]) if (i != fa) dfs3(i, pos, (cur + dd + kk) % kk, dd); } int main() { ios::sync_with_stdio(false); cin >> n >> kk; int t1, t2; for (int i = 1; i < n; i++) { cin >> t1 >> t2; v[t1].push_back(t2); v[t2].push_back(t1); } dfs1(1, 0); if (kk != 2 && !dfs2(1, 0, {})) return 0; cout << Yes << endl; if (kk == 2) { dfs3(1, 0, 0, 1); for (int i = 1; i <= n; i++) cout << ans[i] + 1 << ; return 0; } dfs(1, 0); t1 = max_element(dep + 1, dep + n + 1) - dep; dfs(t1, 0); t2 = max_element(dep + 1, dep + n + 1) - dep; vector<int> d{t2}; while (f[t2]) d.push_back(t2 = f[t2]); int mid = (d.size() + 1) / 2 - 1; dfs3(d[mid], d[mid + 1], mid % kk, -1); dfs3(d[mid + 1], d[mid], (mid + 1) % kk, 1); for (int i = 1; i <= n; i++) cout << ans[i] + 1 << ; return 0; } |
#include <bits/stdc++.h> using namespace std; const int N = 1e5 + 5; string ans[N]; int len[N]; int dp[N]; string get_ans(const string &add) { if (add.size() <= 10) { auto res = add; reverse(res.begin(), res.end()); return res; } string res; int t = add.size(); for (int i = t - 1; i >= t - 5; i--) { res += add[i]; } res += ... ; res += add[1]; res += add[0]; return res; } bool check(const string &a) { int t = a.size(); if (a[t - 3] < a[t - 1]) return true; else if (a[t - 3] > a[t - 1]) return false; return dp[t - 1] < 0 || a[dp[t - 1]] < a[t - 1]; } int main() { string s; cin >> s; string a; bool pre = 0; memset(dp, -1, sizeof(dp)); for (int i = s.size() - 1; i >= 0; i--) { a += s[i]; int t = a.size(); if (t > 1) { if (a[t - 1] == a[t - 2]) { dp[t - 1] = dp[t - 2]; } else { dp[t - 1] = t - 2; } } if (!pre) { if (t >= 2) { if (a[t - 1] == a[t - 2] && (i + 1 == s.size() || s[i] == s[i + 1]) && (t == 2 || check(a))) { a.pop_back(); a.pop_back(); pre = 1; } } } else { pre = 0; } len[i] = a.size(); ans[i] = get_ans(a); } for (int i = 0; i < s.size(); i++) { cout << len[i] << << ans[i] << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; long long int n, h[100001], root[100001], par[100001][25], size[100001], dp_down_0[100001], dp_down_1[100001], dp_up_0[100001], dp_up_1[100001]; vector<pair<long long int, long long int> > v[100001]; long long int add(long long int x, long long int y) { return (x + y) % 1000000007; } long long int mul(long long int x, long long int y) { return (1LL * x * y) % 1000000007; } long long int sub(long long int x, long long int y) { return (x - y + 1000000007) % 1000000007; } long long int sq(long long int x) { return (1LL * x * x) % 1000000007; } void dfs_down(long long int cur, long long int p) { if (p != -1) h[cur] = h[p] + 1; par[cur][0] = p; for (long long int i = 1; i < 20; i++) { if (par[cur][i - 1] != -1) par[cur][i] = par[par[cur][i - 1]][i - 1]; } size[cur] = 1; for (long long int i = 0; i < v[cur].size(); i++) { long long int x = v[cur][i].first; if (x == p) continue; root[x] = add(root[cur], v[cur][i].second); dfs_down(x, cur); size[cur] += size[x]; dp_down_0[cur] = add(dp_down_0[cur], dp_down_0[x]); dp_down_0[cur] = add(dp_down_0[cur], mul(size[x], v[cur][i].second)); dp_down_1[cur] = add(dp_down_1[cur], mul(size[x], sq(v[cur][i].second))); dp_down_1[cur] = add(dp_down_1[cur], dp_down_1[x]); dp_down_1[cur] = add(dp_down_1[cur], mul(2, mul(v[cur][i].second, dp_down_0[x]))); } } void dfs_up(long long int cur, long long int p, long long int wt) { if (p != -1) { dp_up_0[cur] = add(dp_up_0[cur], dp_up_0[p]); dp_up_0[cur] = add(dp_up_0[cur], mul(n - size[p], wt)); long long int x = dp_down_0[p]; x = sub(x, dp_down_0[cur]); x = sub(x, mul(size[cur], wt)); dp_up_0[cur] = add(dp_up_0[cur], x); dp_up_0[cur] = add(dp_up_0[cur], mul(wt, size[p] - size[cur])); dp_up_1[cur] = add(dp_up_1[cur], dp_up_1[p]); dp_up_1[cur] = add(dp_up_1[cur], mul(n - size[p], sq(wt))); dp_up_1[cur] = add(dp_up_1[cur], mul(2, mul(wt, dp_up_0[p]))); x = dp_down_1[p]; x = sub(x, dp_down_1[cur]); x = sub(x, mul(2, mul(wt, dp_down_0[cur]))); x = sub(x, mul(size[cur], sq(wt))); long long int y = dp_down_0[p]; y = sub(y, dp_down_0[cur]); y = sub(y, mul(wt, size[cur])); dp_up_1[cur] = add(dp_up_1[cur], x); dp_up_1[cur] = add(dp_up_1[cur], mul(2, mul(wt, y))); dp_up_1[cur] = add(dp_up_1[cur], mul(sq(wt), size[p] - size[cur])); } for (long long int i = 0; i < v[cur].size(); i++) { long long int x = v[cur][i].first; if (x == p) continue; dfs_up(x, cur, v[cur][i].second); } } int lca(int v, int u) { if (h[v] < h[u]) swap(v, u); for (int i = 20 - 1; i >= 0; i--) { if (par[v][i] != -1 && h[par[v][i]] >= h[u]) { v = par[v][i]; } } if (v == u) return u; for (int i = 20 - 1; i >= 0; i--) { if (par[v][i] - par[u][i]) v = par[v][i], u = par[u][i]; } return par[v][0]; } long long int distance(long long int x, long long int y) { long long int ans = root[x]; ans = add(ans, root[y]); ans = sub(ans, mul(2, root[lca(x, y)])); return ans; } int main() { ios::sync_with_stdio(false); ; cin.tie(0); ; long long int i, j, q, x, y, ans, temp, z, lc, dist; memset(par, -1, sizeof par); cin >> n; for (i = 1; i <= n - 1; i++) { cin >> x >> y >> z; v[x].push_back(make_pair(y, z)); v[y].push_back(make_pair(x, z)); } dfs_down(1, -1); dfs_up(1, -1, 0); cin >> q; while (q--) { cin >> x >> y; dist = distance(x, y); lc = lca(x, y); if ((lc != x && lc != y) || lc == x) { ans = dp_down_1[y]; ans = add(ans, mul(sq(dist), size[y])); ans = add(ans, mul(2, mul(dist, dp_down_0[y]))); ans = mul(2, ans); ans = sub(ans, dp_down_1[x]); ans = sub(ans, dp_up_1[x]); cout << ans << n ; } else if (lc == y) { ans = dp_down_1[x]; temp = dp_up_1[x]; temp = sub(temp, dp_up_1[y]); temp = sub(temp, mul(2, mul(dist, dp_up_0[y]))); temp = sub(temp, mul(n - size[y], sq(dist))); ans = add(ans, temp); ans = mul(2, ans); ans = sub(ans, dp_down_1[x]); ans = sub(ans, dp_up_1[x]); cout << ans << n ; } else assert(false); } return 0; } |
#include <bits/stdc++.h> using namespace std; const int DIM = 55; char mat[2][DIM][DIM]; vector<pair<int, int>> lst1, lst2; void move(int k, int p, int q, vector<pair<int, int>> &lst) { lst.push_back(make_pair(p, q)); if (mat[k][p][q] == U ) { assert(mat[k][p + 0][q + 0] == U and mat[k][p + 0][q + 1] == U and mat[k][p + 1][q + 0] == D and mat[k][p + 1][q + 1] == D ); mat[k][p + 0][q + 0] = L ; mat[k][p + 0][q + 1] = R ; mat[k][p + 1][q + 0] = L ; mat[k][p + 1][q + 1] = R ; } else { assert(mat[k][p + 0][q + 0] == L and mat[k][p + 0][q + 1] == R and mat[k][p + 1][q + 0] == L and mat[k][p + 1][q + 1] == R ); mat[k][p + 0][q + 0] = U ; mat[k][p + 0][q + 1] = U ; mat[k][p + 1][q + 0] = D ; mat[k][p + 1][q + 1] = D ; } } void solve(int k, int p, int q, bool whSide, vector<pair<int, int>> &lst) { if (!whSide) { if (mat[k][p][q] != L ) { solve(k, p, q + 1, whSide ^ true, lst); move(k, p, q, lst); } } else { if (mat[k][p][q] != U ) { solve(k, p + 1, q, whSide ^ true, lst); move(k, p, q, lst); } } } int main(void) { int n, m; cin >> n >> m; for (int k = 0; k <= 1; ++k) for (int i = 1; i <= n; ++i) cin >> (mat[k][i] + 1); for (int i = 1; i <= n; i += (m % 2 == 0 ? 1 : 2)) { for (int j = 1; j <= m; j += (m % 2 == 0 ? 2 : 1)) { solve(0, i, j, (m % 2 == 0 ? false : true), lst1); solve(1, i, j, (m % 2 == 0 ? false : true), lst2); } } cout << lst1.size() + lst2.size() << n ; for (pair<int, int> pr : lst1) cout << pr.first << << pr.second << n ; reverse(lst2.begin(), lst2.end()); for (pair<int, int> pr : lst2) cout << pr.first << << pr.second << n ; for (int i = 1; i <= n; ++i) for (int j = 1; j <= m; ++j) assert(mat[0][i][j] == mat[1][i][j]); return 0; } |
#include <bits/stdc++.h> using namespace std; void bug() { cout << << endl; } template <class T> void bug(T a) { cout << a << ; } template <class T> void bug(T* a, int n) { for (int i = 0; i < (n); i++) bug(a[i]); } int n, m; vector<pair<pair<int, int>, bool> > e; int ans = 1000000000; vector<int> vs; int fa[111111], size[111111]; int find(int u) { if (fa[u] == u) return u; else return fa[u] = find(fa[u]); } void merge(int u, int v) { u = find(u); v = find(v); if (u == v) return; if (size[u] > size[v]) { size[u] += size[v]; fa[v] = u; } else { size[v] += size[u]; fa[u] = v; } } vector<int> g[111111]; int vis[111111]; void go(bool b) { for (int i = 0; i < (n); i++) g[i].clear(); memset(vis, -1, sizeof(vis)); for (int i = 0; i < (n); i++) { fa[i] = i; size[i] = 1; } for (int i = 0; i < (m); i++) { int u = e[i].first.first; int v = e[i].first.second; bool bb = e[i].second; if (bb == b) { merge(u, v); } } for (int i = 0; i < (m); i++) { int u = e[i].first.first; int v = e[i].first.second; bool bb = e[i].second; if (bb != b) { u = find(u); v = find(v); g[u].push_back(v); g[v].push_back(u); } } int ret = 0; vector<int> vv; for (int i = 0; i < (n); i++) if (find(i) == i && vis[i] == -1) { queue<int> q; q.push(i); vis[i] = 0; int zero = size[i], one = 0; vector<int> zs, os; zs.push_back(i); while (q.size() > 0) { int u = q.front(); q.pop(); for (int v : g[u]) { if (vis[v] != -1) { if (vis[v] != (1 - vis[u])) return; } else { vis[v] = (1 - vis[u]); if (vis[v] == 0) { zero += size[v]; zs.push_back(v); } else { one += size[v]; os.push_back(v); } q.push(v); } } } if (zero < one) { ret += zero; for (int i = 0; i < (zs.size()); i++) vv.push_back(zs[i]); } else { ret += one; for (int i = 0; i < (os.size()); i++) vv.push_back(os[i]); } } if (ans > ret) { ans = ret; set<int> s; for (int i = 0; i < (vv.size()); i++) s.insert(vv[i]); vs.clear(); for (int i = 0; i < (n); i++) if (s.find(find(i)) != s.end()) vs.push_back(i); } } int main() { ios::sync_with_stdio(false); cin >> n >> m; for (int i = 0; i < (m); i++) { int u, v; char c; cin >> u >> v >> c; u--; v--; bool b = (c == B ); e.push_back(make_pair(make_pair(u, v), b)); } go(0); go(1); if (ans == 1000000000) cout << -1 << endl; else { cout << ans << endl; for (int i = 0; i < (vs.size()); i++) { cout << vs[i] + 1 << ; } cout << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; bool Pfunc(string); int main() { string st; cin >> st; for (int i = st.size(); i > 0; i--) { bool b = false; for (int k = 0; k <= st.size() - i; k++) { if (Pfunc(st.substr(k, i)) == false) { cout << i; b = true; return 0; } else { } } if (b) { break; } } cout << 0; return 0; } bool Pfunc(string x) { for (int i = 0; i < x.size() / 2; i++) { if (x[i] != x[x.size() - i - 1]) { return false; } } return true; } |
#include <bits/stdc++.h> using namespace std; int c, bi, ba; int main() { int n; cin >> n; for (int i = 0; i < n; i++) { int x; cin >> x; if (i % 3 == 0) c += x; else if (i % 3 == 1) bi += x; else ba += x; } if (c > bi && c > ba) cout << chest ; else if (bi > c && bi > ba) cout << biceps ; else cout << back ; } |
#include <bits/stdc++.h> using namespace std; long long n, k, ans = 0, a, b; vector<long long> v, sum, sumk; vector<pair<long long, long long> > maxsumk, maxsum2k; int main() { cin >> n >> k; v.resize(n); for (int i = 0; i < n; i++) cin >> v[i]; sum.resize(n); sumk.resize(n); sum[0] = v[0]; for (int i = 1; i < n; i++) sum[i] = sum[i - 1] + v[i]; sumk[k - 1] = sum[k - 1]; for (int i = k; i < n; i++) sumk[i] = sum[i] - sum[i - k]; maxsumk.resize(n, {0, 0}); maxsumk[k - 1].first = sumk[k - 1]; maxsumk[k - 1].second = k - 1; for (int i = k; i < n; i++) { maxsumk[i].first = max(maxsumk[i - 1].first, sumk[i]); if (max(maxsumk[i - 1].first, sumk[i]) == maxsumk[i - 1].first) maxsumk[i].second = maxsumk[i - 1].second; else maxsumk[i].second = i; } maxsum2k.resize(n, {0, 0}); maxsum2k[2 * k - 1].first = sumk[2 * k - 1] + maxsumk[2 * k - 1 - k].first; maxsum2k[2 * k - 1].second = 2 * k - 1; for (int i = 2 * k; i < n; i++) { maxsum2k[i].first = max(sumk[i] + maxsumk[i - k].first, maxsum2k[i - 1].first); if (max(sumk[i] + maxsumk[i - k].first, maxsum2k[i - 1].first) == maxsum2k[i - 1].first) maxsum2k[i].second = maxsum2k[i - 1].second; else maxsum2k[i].second = i; } int v = maxsum2k[n - 1].second; b = v - k + 2; a = maxsumk[v - k].second - k + 2; cout << a << << b; } |
#include <bits/stdc++.h> using namespace std; long long x, off = 10; vector<long long> vec[15]; inline long long mul(long long a, long long b) { bool neg = false; long long res = 0; if (b < 0) { neg = true; b = -b; } while (b) { if (b & 1) res = (res + a) % off; a = (a + a) % off; b >>= 1; } return neg ? (off - res) % off : res; } inline pair<long long, long long> fib(long long n) { if (!n) return make_pair(0, 1); if (n & 1) { pair<long long, long long> res = fib(n - 1); return make_pair(res.second, (res.first + res.second) % off); } pair<long long, long long> res = fib(n >> 1); return make_pair( mul(res.first, 2 * res.second - res.first), (mul(res.first, res.first) + mul(res.second, res.second)) % off); } int main() { scanf( %lld , &x); for (int i = 0; i < 60; i++) { if (fib(i).first == x % off) vec[0].push_back(i); } long long step = 60; for (int i = 0; i < 12; i++) { off *= 10; for (long long y : vec[i]) { for (int j = 0; j < 10; j++) { if (fib(y + j * step).first == x % off) vec[i + 1].push_back(y + j * step); } } step *= 10; } if (!vec[12].size()) printf( -1 n ); else printf( %lld n , *min_element(vec[12].begin(), vec[12].end())); return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { string s, t; while (cin >> t) s += t; vector<string> str; int pos = 0; vector<int> a, ans; while (pos != ((int)(s).size())) { if (s.substr(pos, 7) == <table> ) { a.push_back(0); pos += 7; } else if (s.substr(pos, 4) == <tr> ) pos += 4; else if (s.substr(pos, 4) == <td> ) { ++a.back(); pos += 4; } else if (s.substr(pos, 5) == </td> ) pos += 5; else if (s.substr(pos, 5) == </tr> ) pos += 5; else if (s.substr(pos, 8) == </table> ) { ans.push_back(a.back()); a.pop_back(); pos += 8; } } sort((ans).begin(), (ans).end()); for (int(i) = 0; (i) < (((int)(ans).size())); ++(i)) cout << ans[i] << ; return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int n, t; cin >> n >> t; char pos[50]; cin >> pos; while (t--) { for (int i = 0; i < n; i++) { if (pos[i] == B ) { if ((i + 1) < n && pos[i + 1] == G ) { char temp = pos[i]; pos[i] = pos[i + 1]; pos[i + 1] = temp; i++; } } } } for (int i = 0; i < n; i++) { cout << pos[i]; } return 0; } |
#include <bits/stdc++.h> using namespace std; long long int mod = 1e9 + 7; long long int inf = 9 * 1e18; const long long maxn = 2e5 + 100; long long pow(long long a, long long b) { if (b < 0) return 0LL; long long ans = 1; while (b) { if (b & 1) ans = ans * a; a = a * a; b >>= 1; } return ans; } long long binpow(long long a, long long b, long long m) { if (b < 0) return 0LL; if (a <= 0) return 0LL; a %= m; long long ans = 1LL; while (b) { if (b & 1) ans = ans * a % m; a = a * a % m; b >>= 1; } return ans; } long long modinv(long long n) { return binpow(n, mod - 2, mod); } int gcdExtended(int a, int b, int *x, int *y) { if (a == 0) { *x = 0, *y = 1; return b; } int x1, y1; int gcd = gcdExtended(b % a, a, &x1, &y1); *x = y1 - (b / a) * x1; *y = x1; return gcd; } void modInverse(int a, int m) { int x, y; int g = gcdExtended(a, m, &x, &y); if (g != 1) cout << Inverse doesn t exist ; else { int res = (x % m + m) % m; cout << Modular multiplicative inverse is << res; } } bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) { return (a.second < b.second); } const long long N = 1e7 + 5; long long sp[N]; void sieve(long long N) { for (long long i = 1; i < N; i++) sp[i] = i; for (long long i = 2; i < N; i++) { if (sp[i] == i) { for (long long j = i * i; j < N; j += i) { if (sp[j] == j) sp[j] = i; } } } } void solve() { string s1; cin >> s1; long long k; cin >> k; long long n = s1.size(); map<char, char> ma; for (int i = 0; i < k; i++) { char u, x; cin >> u >> x; ma[u] = x; ma[x] = u; } long long c1 = 0, c2 = 0; long long ans = 0; long long j = 0; for (int i = 0; i < n; i++) { c1 = 1; c2 = 0; char a = s1[i]; char b = ma[a]; for (j = i + 1; j < n; j++) { if (s1[j] == a) c1++; else if (s1[j] == b) c2++; else break; } ans += min(c1, c2); i = j - 1; } cout << ans; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); ; int t; t = 1; while (t--) { solve(); } return 0; } |
#include <bits/stdc++.h> int start, n, m; bool edge[25][25]; long long memory[25][(1 << 19) + 5]; long long dfs(int u, int mask) { if (memory[u][mask] != -1) return memory[u][mask]; int visit = 0; for (int i = 0; i < n; i++) { if (mask & (1 << i)) visit++; } long long result = 0; if (visit >= 3 && edge[u][start]) result = 1; for (int v = 0; v <= start; v++) { if (!edge[u][v]) { continue; } if (mask & (1 << v)) { continue; } result += dfs(v, mask | (1 << v)); } memory[u][mask] = result; return result; } int main() { scanf( %d%d , &n, &m); for (int i = 0; i < m; i++) { int u, v; scanf( %d%d , &u, &v); u--; v--; edge[u][v] = edge[v][u] = true; } long long answer = 0; for (start = 0; start < n; start++) { for (int i = 0; i < n; i++) { for (int j = 0; j < 1 << n; j++) { memory[i][j] = -1; } } answer += dfs(start, 1 << start); } printf( %lld n , answer / 2); } |
#include <bits/stdc++.h> using namespace std; const double EPS = (double)1e-9; const double PI = (double)acos(-1.0); int irand(int lo, int hi) { return (((double)rand()) / (RAND_MAX + 1.0)) * (hi - lo + 1) + lo; } string toString(long long x) { stringstream ss; ss << x; return ss.str(); } long long toNumber(string S) { long long ret; sscanf(S.c_str(), %lld , &ret); return ret; } const int INF = (int)2e9; const long long MOD = (long long)1e9 + 7; int main() { long long n, res = 0, two = 1; scanf( %lld , &n); while (n > 1) { res += two * (n / 2); n = (n / 2) + (n % 2); two <<= 1; } printf( %lld n , res); return 0; } |
#include <bits/stdc++.h> using namespace std; vector<char> v; string s; int main() { cin >> s; for (int i = 0; i < s.size(); i++) { if (!v.empty() && v.back() == s[i]) v.pop_back(); else v.push_back(s[i]); } cout << (v.empty() ? Yes : No ); } |
#include <bits/stdc++.h> using namespace std; long long DP[20][4]; void init() { DP[0][3] = DP[0][2] = DP[0][1] = DP[0][0] = 1; for (int i = 1; i <= 18; i++) { DP[i][0] = 1; for (int j = 1; j <= 3; j++) { DP[i][j] = 9 * DP[i - 1][j - 1] + DP[i - 1][j]; } } } long long sol(int i, int j, string str) { if (i == 0) { if (j >= 0) return 1; else return 0; } int d = str[i - 1] - 0 ; if (d == 0) return sol(i - 1, j, str); else if (j == 0) return 1; return DP[i - 1][j] + (d - 1) * DP[i - 1][j - 1] + sol(i - 1, j - 1, str); } string tostr(long long x) { string rtn; while (x) { rtn += (x % 10 + 0 ); x /= 10; } return rtn; } string A, B; long long a, b; int cas; int main() { ios::sync_with_stdio(false); init(); cin >> cas; while (cas--) { cin >> a >> b; a--; A = tostr(a); B = tostr(b); cout << sol(B.length(), 3, B) - sol(A.length(), 3, A) << n ; } return 0; } |
#include <bits/stdc++.h> using namespace std; int N, K, ma; int A[1000005]; int dp[10000005]; bool ok(int val) { int nr = 0; for (int i = 1; i <= ma; i++) { dp[i] = 0; if (val <= i) dp[i] = 1; if (i % 2) dp[i] = max(dp[i], dp[i >> 1] + dp[(i + 1) >> 1]); else dp[i] = max(dp[i], 2 * dp[i >> 1]); } for (int i = 1; i <= N; i++) { nr += dp[A[i]]; if (nr >= K) return 1; } return 0; } int main() { bool notthesamecode = 1; cin.sync_with_stdio(false); cout.sync_with_stdio(false); cin >> N >> K; for (int i = 1; i <= N; i++) { cin >> A[i]; ma = max(ma, A[i]); } int st = 0, dr = (1e7 + 10), mid; while (st < dr) { mid = (st + dr + 1) / 2; if (ok(mid)) st = mid; else dr = mid - 1; } if (!st) cout << -1; else cout << st; return 0; } |
#include <bits/stdc++.h> namespace io { int F() { int F = 1, n = 0; char ch; while ((ch = getchar()) != - && (ch < 0 || ch > 9 )) ; ch == - ? F = 0 : n = ch - 0 ; while ((ch = getchar()) >= 0 && ch <= 9 ) n = n * 10 + ch - 0 ; return F ? n : -n; } long long G() { long long F = 1, n = 0; char ch; while ((ch = getchar()) != - && (ch < 0 || ch > 9 )) ; ch == - ? F = 0 : n = ch - 0 ; while ((ch = getchar()) >= 0 && ch <= 9 ) n = n * 10 + ch - 0 ; return F ? n : -n; } } // namespace io int R(int l, int r) { return (rand() << 15 | rand()) % (r - l + 1) + l; } int main() { long long n = io::G(), l = io::G() - 1, r = io::G() - 1, k = io::G(); long long B = l <= r ? r - l + 1 : n - (l - r - 1), S = n - B; long long ans = -1; int fl = 1; start:; if ((k - B) / n <= 22000000) { int u = (k - B) / n; for (register int x = 0; x <= u; ++x) { long long re = k - B - x * n; if (x == 0) { if (re <= B && re >= 0) if (fl || re) (ans < (S + re) ? ans = (S + re), 1 : 0); } else { long long B1 = re % x, S1 = re / x - B1; if (B1 > B || S1 < 0) continue; if (S1 <= S) { if (fl || B1) (ans < (B1 + S1) ? ans = (B1 + S1), 1 : 0); } else { long long T = S1 - S; long long ex = (T + x) / (x + 1); B1 += ex * x; S1 -= ex * (x + 1); if (S1 >= 0 && B1 <= B) if (fl || B1) (ans < (B1 + S1) ? ans = (B1 + S1), 1 : 0); } } } } else { for (register long long S1 = 0; S1 <= S; ++S1) for (register long long B1 = 0; B1 <= B; ++B1) { long long y = k - B1 - B; long long a = S1 + B1 + n; if (y == 0 && a == 0 || a && y % a == 0 && y / a >= 0) if (fl || B1) (ans < (S1 + B1) ? ans = (S1 + B1), 1 : 0); } } if (fl) { k = k + 1; fl = 0; goto start; } printf( %lld n , ans); return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int n, m, flag = 0; cin >> n >> m; char c; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { cin >> c; if (c == B || c == W || c == G ) continue; else flag = 1; } } if (flag == 0) cout << #Black&White << endl; else cout << #Color << endl; } |
#include <bits/stdc++.h> using namespace std; int main() { int n, m; cin >> n >> m; int a, b; double gia[n]; for (int i = 0; i < n; i++) { cin >> a >> b; gia[i] = (double)a / b; } double kq = gia[0]; for (int i = 1; i < n; i++) { if (kq > gia[i]) kq = gia[i]; } cout << setprecision(8) << kq * m; } |
#include <bits/stdc++.h> using namespace std; string s; string p; int a[2005]; int A[2005]; int ans[2005]; int dp[2005][2005]; int main() { cin >> s >> p; memset(a, -1, sizeof(a)); a[0] = 0; for (int i = 0; i < s.size(); i++) { for (int j = p.size() - 1; j >= 0; j--) { if (s[i] == p[j]) a[j + 1] = a[j]; } a[0] = i + 1; A[i + 1] = a[p.size()]; } for (int i = 1; i <= s.size(); i++) { for (int j = 0; j <= i; j++) { dp[i][j] = dp[i - 1][j]; if (A[i] >= 0 && j - (i - A[i] - p.size()) >= 0 && j - (i - A[i] - p.size()) <= A[i]) dp[i][j] = max(dp[A[i]][j - (i - A[i] - p.size())] + 1, dp[i][j]); } } for (int i = 0; i <= s.size(); i++) ans[i] = dp[s.size()][i]; for (int i = 0; i <= s.size(); i++) cout << ans[i] << ; return 0; } |
#include <bits/stdc++.h> using namespace std; const int INF = 2147483647; const int maxn = 21; const int dx[4] = {0, 0, 1, -1}; const int dy[4] = {1, -1, 0, 0}; int Map[maxn][maxn], Value[maxn], X[maxn], Y[maxn], XX[maxn], YY[maxn]; int vis[maxn][maxn][260][129], VV[maxn][maxn][260][129], inq[maxn][maxn][260][129]; int ans, num, N, M, D; const int Maxn = 3020120; char s[30]; struct Point { int x, y, z, value, num; } Q[Maxn]; void BFS(int sx, int sy) { int x, y, z, V, u, v, w, NOW, value, NNN, head, tail; Q[head = tail = 1] = (Point){sx, sy, 0, 0, 0}; memset(vis, 0, sizeof(vis)); vis[sx][sy][0][0] = 1; while (head <= tail) { x = Q[head].x; y = Q[head].y; z = Q[head].z; V = Q[head].value; NOW = Q[head].num; inq[x][y][z][V] = 0; ++head; V--; for (int i = 0; i < 4; i++) { u = x + dx[i], v = y + dy[i], w = z, value = V, NNN = NOW; if (!u || !v || u > N || v > M) continue; if (!Map[u][v]) continue; for (int k = 1; k <= D; k++) if (u == X[k] && v > Y[k] && x == X[k] + 1 || u == X[k] + 1 && v > Y[k] && x == X[k]) { w = w ^ (1 << k - 1); if (w & (1 << k - 1)) value += Value[k]; else value -= Value[k]; } for (int k = 1; k <= num; k++) { if (u == XX[k] && v > YY[k] && x == XX[k] + 1) NNN = NNN ^ (1 << k - 1); if (u == XX[k] + 1 && v > YY[k] && x == XX[k]) NNN = NNN ^ (1 << k - 1); } if (NNN == 1) NNN = 1; if (value > VV[u][v][w][NNN]) VV[u][v][w][NNN] = value; else continue; if (!vis[u][v][w][NNN]) Q[++tail] = (Point){u, v, w, value, NNN}; else continue; if (u == sx && v == sy && value > ans && NNN == 0) ans = max(ans, value); inq[u][v][w][NNN] = 1; } } } int main() { cin >> N >> M; memset(VV, 235, sizeof(VV)); for (int i = 1; i <= N; i++) { scanf( %s , s + 1); for (int j = 1; j <= M; j++) { if (s[j] > 0 && s[j] != # && s[j] != . && s[j] != S && s[j] != B ) X[s[j] - 48] = i, Y[s[j] - 48] = j, D = max(D, s[j] - 48); if (s[j] == . ) Map[i][j] = 1; if (s[j] == S ) Map[i][j] = 2; if (s[j] == B ) { XX[++num] = i; YY[num] = j; } } } for (int i = 1; i <= D; i++) scanf( %d , &Value[i]); for (int i = 1; i <= N; i++) for (int j = 1; j <= M; j++) if (Map[i][j] == 2) BFS(i, j); cout << ans; return 0; } |
#include <bits/stdc++.h> using namespace std; const int MOD = 1e9 + 7; int n, m, dp[250][1 << 15][2][2]; char g[250][251]; int calc(int r, int c, int left, int up, int emp) { if (r == n) { for (int i = 0; i < 15; i++) if (c + 1 < m && (left & (1 << i)) && g[i][c + 1] == x ) left &= ~(1 << i); return calc(0, c + 1, left, 0, emp); } if (c == m) return 1; int &ret = dp[r * m + c][left][up][emp]; if (ret != -1) return ret; ret = 0; if (g[r][c] == x ) { ret = calc(r + 1, c, left, 0, emp); } else { if (up || (left & (1 << r))) ret = (ret + calc(r + 1, c, left, up, emp)) % MOD; else if (!emp) ret = (ret + calc(r + 1, c, left, up, 1)) % MOD; ret = (ret + calc(r + 1, c, left | (1 << r), 1, emp)) % MOD; } return ret; } int main() { scanf( %d%d , &n, &m); for (int i = 0; i < n; i++) scanf( %s , g[i]); if (n > m) { char tmp[250][251]; for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) tmp[j][i] = g[i][j]; swap(n, m); for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) g[i][j] = tmp[i][j]; } memset(dp, -1, sizeof(dp)); printf( %d n , calc(0, 0, 0, 0, 0)); return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int A[5][5], x, y, p, q, sum; for (int i = 0; i < 5; i++) { for (int j = 0; j < 5; j++) { cin >> A[i][j]; if (A[i][j] == 1) { x = i; y = j; } } cout << endl; } if (x == 2 && y == 2) { p = 0; q = 0; } else if (x >= 2 && y >= 2) { p = x - 2; q = y - 2; } else if (x >= 2 && y <= 2) { p = x - 2; q = 2 - y; } else if (x <= 2 && y >= 2) { p = 2 - x; q = y - 2; } else if (x <= 2 && y <= 2) { p = 2 - x; q = 2 - y; } sum = p + q; cout << sum; return 0; } |
#include <bits/stdc++.h> using namespace std; int a[100005], b[100005], m[100005]; int main() { int n; scanf( %d , &n); for (int i = 1; i <= n; i++) scanf( %d , &a[i]); for (int i = 1; i <= n; i++) scanf( %d , &b[i]); m[1] = a[1] - b[1]; for (int i = 2; i <= n; i++) m[i] = m[i - 1] + a[i] - b[i]; int min = 1000000001; for (int i = 1; i <= n; i++) if (min > m[i]) min = m[i]; vector<int> d; for (int i = 1; i <= n; i++) { if (min >= 0) d.push_back(i); min -= a[i] - b[i]; } m[n + 1] = a[1] - b[n]; m[1] = a[1] - b[n]; for (int i = n; i >= 2; i--) m[i] = m[i + 1] + a[i] - b[i - 1]; min = 1000000001; for (int i = 1; i <= n; i++) if (min > m[i]) min = m[i]; if (min >= 0) d.push_back(1); min -= a[1] - b[n]; for (int i = n; i >= 2; i--) { if (min >= 0) d.push_back(i); min -= a[i] - b[i - 1]; } sort(d.begin(), d.end()); int i = 1; for (size_t j = 1; j < d.size(); j++) if (d[j] != d[j - 1]) d[i++] = d[j]; cout << i << endl; for (int j = 0; j < i; j++) if (j != i - 1) cout << d[j] << ; else cout << d[j] << endl; } |
#include <bits/stdc++.h> using namespace std; const int N = 2e5 + 5; const int inf = 1e9; int n, m; int mp[3][N]; char ch[N]; struct node { int d1, d2, d3, d4; }; struct tree { int l, r; node d; } t[N * 5]; node merge(node a, node b) { node tmp; tmp.d1 = min(inf, min(a.d1 + b.d1, a.d2 + b.d3) + 1); tmp.d2 = min(inf, min(a.d1 + b.d2, a.d2 + b.d4) + 1); tmp.d3 = min(inf, min(a.d3 + b.d1, a.d4 + b.d3) + 1); tmp.d4 = min(inf, min(a.d3 + b.d2, a.d4 + b.d4) + 1); return tmp; } inline void build(int x, int l, int r) { t[x].l = l, t[x].r = r; if (l == r) { t[x].d.d1 = t[x].d.d2 = t[x].d.d3 = t[x].d.d4 = inf; if (mp[1][l]) t[x].d.d1 = 0; if (mp[2][l]) t[x].d.d4 = 0; if (mp[1][l] && mp[2][l]) t[x].d.d2 = t[x].d.d3 = 1; return; } int mid = (l + r) >> 1; build(x << 1, l, mid); build(x << 1 | 1, mid + 1, r); t[x].d = merge(t[x << 1].d, t[x << 1 | 1].d); } inline node query(int x, int l, int r) { if (l == t[x].l && r == t[x].r) return t[x].d; int mid = (t[x].l + t[x].r) >> 1; if (r <= mid) return query(x << 1, l, r); else if (l > mid) return query(x << 1 | 1, l, r); else return merge(query(x << 1, l, mid), query(x << 1 | 1, mid + 1, r)); } inline int ask(int x, int y) { int a = (x - 1) % n + 1, b = (y - 1) % n + 1; if (a > b) { swap(x, y); swap(a, b); } node tmp = query(1, a, b); if (x <= n && y <= n) return tmp.d1; if (x <= n && y > n) return tmp.d2; if (x > n && y <= n) return tmp.d3; if (x > n && y > n) return tmp.d4; } int main() { scanf( %d%d , &n, &m); for (int i = 1; i <= 2; i++) { scanf( %s , ch); for (int j = 1; j <= n; j++) if (ch[j - 1] == . ) mp[i][j] = 1; } build(1, 1, n); for (int i = 1; i <= m; i++) { int x, y; scanf( %d%d , &x, &y); int ans = ask(x, y); if (ans < inf) printf( %d n , ans); else printf( -1 n ); } return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); int t = 0; cin >> t; for (int i = 0; i < t; i++) { long long m = 0; int n = 0; cin >> n; for (int j = n; j > 2; j -= 2) { m += (2 * pow((j - 1), 2)); } cout << m << endl; } } |
#include <bits/stdc++.h> using namespace std; int n, q, a[100010], l[100010], r[100010]; int st[100010], top; int main() { scanf( %d%d , &n, &q); for (int i = 1; i <= n; i++) scanf( %d , &a[i]); n--; for (int i = 1; i <= n; i++) a[i] = abs(a[i + 1] - a[i]); for (int i = 1; i <= n; i++) { while (top && a[st[top]] < a[i]) top--; l[i] = st[top]; st[++top] = i; } top = 0; st[top] = n + 1; for (int i = n; i >= 1; i--) { while (top && a[st[top]] <= a[i]) top--; r[i] = st[top]; st[++top] = i; } for (int i = 1; i <= q; i++) { int L, R; long long ans = 0; scanf( %d%d , &L, &R); if (L >= R) { puts( 0 ); continue; } R--; for (int j = L; j <= R; j++) { ans += (long long)(j - max(l[j], L - 1)) * (min(r[j], R + 1) - j) * a[j]; } printf( %lld n , ans); } return 0; } |
#include <bits/stdc++.h> using namespace std; long long pw(long long a, long long b) { long long t = 1; if (b == 0) return t; if (b % 2) { t = t * a; } t %= 1000000009; long long x = pw(a, b / 2); x = x * x; x %= 1000000009; t *= x; t %= 1000000009; return t; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); long long ti = 1; for (long long io = 0; io < ti; io++) { long long n, m, k; cin >> n >> m >> k; long long oc = 0, rm; oc = n / k; rm = n % k; long long ans = 0; if (m > (n - oc)) { long long x = m - n + oc; long long y; y = k; y = y * ((pw(2, x + 1) - 2) % 1000000009); y %= 1000000009; ans += y; y = k - 1; y *= (oc - x); y %= 1000000009; ans += y; ans += rm; } else { ans = m; } ans %= 1000000009; ans += 1000000009; ans %= 1000000009; cout << ans << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; int Solution() { int n; cin >> n; string s; cin >> s; int cnt = 0; for (int i = 0; i < n; ++i) cnt += (s[i] == H ); s += s; int ans = 0x7fffffff; for (int i = 0; i < n; ++i) { int dif = 0; for (int j = 0; j < cnt; ++j) if (s[i + j] != H ) ++dif; if (dif < ans) ans = dif; } cout << ans << endl; return 0; } int main() { Solution(); return 0; } |
#include <bits/stdc++.h> using namespace std; int gcd(int x, int y) { if (y == 0) return x; return gcd(y, x % y); } int lcm(int x, int y) { return x * y / gcd(x, y); } string in; int check(string s) { int ret = 0; while (true) { bool beforem = s[0] == M ; bool changed = false; for (int i = 1; i < s.size(); ++i) { if (s[i] == F ) { if (beforem) { s[i - 1] = F ; s[i] = M ; changed = true; } beforem = false; } else { beforem = true; } } if (!changed) break; ++ret; } return ret; } int main() { cin >> in; vector<int> times; int fcnt = 0; for (int i = 0; i < in.size(); ++i) { if (in[i] == F ) { if (times.size() == 0) { if (i == fcnt) { times.push_back(0); } else { times.push_back(i); } } else { if (i == fcnt) { times.push_back(0); } else { int move = i - fcnt; if (times[times.size() - 1] + 1 <= move) { times.push_back(move); } else { times.push_back(times[times.size() - 1] + 1); } } } ++fcnt; } } int ret = 0; for (int i = 0; i < times.size(); ++i) ret = max(ret, times[i]); printf( %d , ret); return 0; } |
#include <bits/stdc++.h> using namespace std; const long long INF = 1e18; template <typename T1, typename T2> istream& operator>>(istream& in, pair<T1, T2>& a) { in >> a.first >> a.second; return in; } template <typename T1, typename T2> ostream& operator<<(ostream& out, pair<T1, T2> a) { out << a.first << << a.second; return out; } template <typename T, typename T1> T amax(T& a, T1 b) { if (b > a) a = b; return a; } template <typename T, typename T1> T amin(T& a, T1 b) { if (b < a) a = b; return a; } template <typename Arg1> void __f(const char* name, Arg1&& arg1) { cerr << name << : << arg1 << n ; } template <typename Arg1, typename... Args> void __f(const char* names, Arg1&& arg1, Args&&... args) { const char* comma = strchr(names + 1, , ); cerr.write(names, comma - names) << : << arg1 << | ; __f(comma + 1, args...); } void solve() { long long n, k; cin >> n >> k; long long a[n], cnt = 0, l = 0, r = -1, l3, r3; for (long long i = 0; i < n; ++i) { cin >> a[i]; if (a[i] == 0) cnt++; if (cnt <= k) r++; } long long ans = r - l + 1; l3 = l; r3 = r; for (long long i = r + 1; i < n; ++i) { if (r == n - 1) break; if (a[i] == 0) { if (ans < r - l + 1) { ans = r - l + 1; l3 = l; r3 = r; } long long l1 = l; for (long long j = l1; j < n; ++j) { l++; if (a[j] == 0) break; } r++; } else r++; } if (ans < r - l + 1) { ans = r - l + 1; l3 = l; r3 = r; } cout << ans << n ; for (long long i = 0; i < n; ++i) { if (i >= l3 && i <= r3) cout << 1 << ; else cout << a[i] << ; } } signed main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); long long t = 1; while (t--) { solve(); } return 0; } |
#include <bits/stdc++.h> using namespace std; int xd[] = {0, 1, 0, -1}; int yd[] = {1, 0, -1, 0}; int xx[] = {0, 1, 0, -1, 1, -1, 1, -1}; int yy[] = {1, 0, -1, 0, 1, 1, -1, -1}; int kx[] = {-2, -1, -2, -1, 1, 2, 2, 1}; int ky[] = {1, 2, -1, -2, -2, -1, 1, 2}; bool islucky(int x) { int four = 0, seven = 0; while (x) { if (x % 10 != 7 && x % 10 != 4) return false; if (x % 10 == 7) seven++; else four++; x = x / 10; } return four == seven; } bool is_prime(long long x) { if (x == 1) return false; for (int i = 2; i * i <= x; i++) if (x % i == 0) return false; return true; } long long C(int k, int l) { if (l == k) return 1; if (l * 2 > k) l = k - l; long long res = 1, temp = l; for (int i = k - l + 1; i <= k; i++) { res *= i / temp; temp--; } return res; } long long sumOfDigit(int x) { int res = 0; while (x) { res += x % 10; x /= 10; } return res; } uint64_t bigPow(uint64_t base, uint64_t p) { uint64_t temp = 1; while (p--) { temp *= base; } return temp; } vector<int> soso; bool prime[10000001] = {0}; void SieveOfEratosthenes(int n) { soso.push_back(2); for (int p = 3; p * p <= n; p += 2) { if (prime[p] == false) { for (int i = p * 2; i <= n; i += p) prime[i] = true; } } for (int i = 3; i <= n; i += 2) if (!prime[i]) soso.push_back(i); } vector<vector<int> > AdjList; bool visited[100005]; void dfs(int s) { if (visited[s]) return; visited[s] = 1; for (int i = 0; i < AdjList[s].size(); i++) dfs(AdjList[s][i]); return; } long long gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); } unsigned long long fact(long long a) { unsigned long long ans = 1; for (int i = 1; i <= a; i++) ans *= i; return ans; } bool lucky(int x) { while (x) { if (x % 10 == 7) return true; x /= 10; } return false; } int main() { int t; cin >> t; while (t--) { vector<pair<pair<int, int>, int> > q; int n; cin >> n; for (int i = 0; i < n; i++) { int l, r; cin >> l >> r; q.push_back(make_pair(make_pair(l, i), r)); } sort(q.begin(), q.end()); int w = 0, last = 0; vector<pair<int, int> > turn; for (int i = 0; i < q.size(); i++) { if (q[i].second < max(q[i].first.first, last + 1)) { turn.push_back(make_pair(q[i].first.second, 0)); w++; } else { turn.push_back( make_pair(q[i].first.second, max(q[i].first.first, last + 1))); last = max(q[i].first.first, last + 1); } } sort(turn.begin(), turn.end()); for (int i = 0; i < turn.size(); i++) cout << turn[i].second << ; cout << endl; } } |
#include <bits/stdc++.h> using int_t = long long int; template <typename T, typename FirstOp = std::plus<T>, typename SecondOp = std::multiplies<T>, typename UpdateOp = std::plus<T>> class SegmentTree { public: explicit SegmentTree(std::size_t size, FirstOp first_operation = FirstOp(), SecondOp second_operation = SecondOp(), UpdateOp update_operation = UpdateOp(), T identity = T()) : m_size(size), m_tree(std::max(size * 4, std::size_t(4)), identity), m_lazy_tag(std::max(size * 4, std::size_t(4)), identity), m_first_operation(first_operation), m_second_operation(second_operation), m_update_operation(update_operation), m_identity(identity) {} void update(std::size_t pos, const T& value) { update(pos + 1, value, 1, 1, m_size); } void update(std::size_t start, std::size_t end, const T& value) { update(start + 1, end, value, 1, 1, m_size); } T query(std::size_t start, std::size_t end) { return query(start + 1, end, 1, 1, m_size); } private: std::size_t m_size; std::vector<T> m_tree; std::vector<T> m_lazy_tag; FirstOp m_first_operation; SecondOp m_second_operation; UpdateOp m_update_operation; const T m_identity; void push_up(std::size_t root) { m_tree[root] = m_first_operation(m_tree[left(root)], m_tree[right(root)]); } void push_down(std::size_t root, std::size_t length) { m_tree[left(root)] = m_update_operation( m_tree[left(root)], m_second_operation(m_lazy_tag[root], length - length / 2)); m_lazy_tag[left(root)] = m_update_operation(m_lazy_tag[left(root)], m_lazy_tag[root]); m_tree[right(root)] = m_update_operation( m_tree[right(root)], m_second_operation(m_lazy_tag[root], length / 2)); m_lazy_tag[right(root)] = m_update_operation(m_lazy_tag[right(root)], m_lazy_tag[root]); m_lazy_tag[root] = m_identity; } void update(std::size_t pos, const T& value, std::size_t root, std::size_t l, std::size_t r) { if (l == r) { m_tree[root] = m_update_operation(m_tree[root], value); return; } std::size_t m = (l + r) / 2; if (pos <= m) { update(pos, value, left(root), l, m); } else { update(pos, value, right(root), m + 1, r); } push_up(root); } void update(std::size_t start, std::size_t end, const T& value, std::size_t root, std::size_t l, std::size_t r) { if (start <= l && r <= end) { m_tree[root] = m_update_operation(m_tree[root], m_second_operation(value, r - l + 1)); m_lazy_tag[root] = m_update_operation(m_lazy_tag[root], value); return; } if (m_lazy_tag[root] != m_identity) { push_down(root, r - l + 1); } std::size_t m = (l + r) / 2; if (start <= m) { update(start, end, value, left(root), l, m); } if (m < end) { update(start, end, value, right(root), m + 1, r); } push_up(root); } T query(std::size_t start, std::size_t end, std::size_t root, std::size_t l, std::size_t r) { if (start <= l && r <= end) { return m_tree[root]; } if (m_lazy_tag[root] != m_identity) { push_down(root, r - l + 1); } std::size_t m = (l + r) / 2; if (start <= m && m < end) { return m_first_operation(query(start, end, left(root), l, m), query(start, end, right(root), m + 1, r)); } else if (end <= m) { return query(start, end, left(root), l, m); } else { return query(start, end, right(root), m + 1, r); } } static std::size_t left(std::size_t root) { return root * 2; } static std::size_t right(std::size_t root) { return root * 2 + 1; } }; int main() { std::ios::sync_with_stdio(false); std::cin.tie(nullptr); int_t m; std::cin >> m; std::vector<int_t> x(m); struct FirstOp { int_t operator()(int_t lhs, int_t rhs) const { return std::max(lhs, rhs); } }; struct SecondOp { int_t operator()(int_t x, std::size_t) const { return x; } }; SegmentTree<int_t, FirstOp, SecondOp> segment_tree(m); for (int_t i = 0; i < m; ++i) { int_t p; int_t t; std::cin >> p >> t; int_t index = m - p; if (t == 0) { segment_tree.update(index, m, -1); } else { std::cin >> x[index]; segment_tree.update(index, m, 1); } if (m == 1) { if (segment_tree.query(0, 1) > 0) { std::cout << x[0] << n ; } else { std::cout << -1 << n ; } continue; } int_t start = 0; int_t end = m; while (start < end - 1) { int_t mid = (start + end - 1) / 2; if (segment_tree.query(start, mid + 1) > 0) { end = mid + 1; } else if (segment_tree.query(mid, end) > 0) { start = mid + 1; } else { start = end = -1; } } if (start == -1) { std::cout << -1 << n ; } else { std::cout << x[start] << n ; } } return 0; } |
#include <bits/stdc++.h> using namespace std; int D[100010]; int TN[100010]; vector<int> G[100010]; vector<int> T[100010]; vector<long long int> TS[100010]; map<int, double> S[100010]; struct Furthest { int s, t, x, maxl, N; void DFS1(int u, int f, int l) { if (l > maxl) { x = u; maxl = l; } TN[u] = N; for (auto it = G[u].begin(); it != G[u].end(); ++it) { int v = *it; if (v != f) DFS1(v, u, l + 1); } } void DFS2(int u, int f, int l) { if (l > maxl) { x = u; maxl = l; } if (l > D[u]) D[u] = l; for (auto it = G[u].begin(); it != G[u].end(); ++it) { int v = *it; if (v != f) DFS2(v, u, l + 1); } } void DFS3(int u, int f, int l) { if (l > D[u]) D[u] = l; T[N].push_back(D[u]); for (auto it = G[u].begin(); it != G[u].end(); ++it) { int v = *it; if (v != f) DFS3(v, u, l + 1); } } void Find(int u, int n) { N = n; maxl = -1; DFS1(u, -1, 0); s = x; maxl = -1; DFS2(s, -1, 0); t = x; DFS3(t, -1, 0); sort(T[N].begin(), T[N].end()); TS[N].push_back(0); for (int i = 1; i <= T[N].size(); ++i) TS[N].push_back(T[N][i - 1] + TS[N][i - 1]); if (D[t] != D[s]) cout << Wrong! << endl; } }; Furthest fest; int main() { ios::sync_with_stdio(false); int n, m, q, i, j, k, x, y, cnt, u, v; cin >> n >> m >> q; for (i = 0; i < m; ++i) { cin >> u >> v; G[u].push_back(v); G[v].push_back(u); } cnt = 0; memset(D, 0xFF, sizeof(D)); for (i = 1; i <= n; ++i) if (D[i] < 0) fest.Find(i, cnt++); for (i = 0; i < q; ++i) { cin >> u >> v; x = TN[u]; y = TN[v]; if (x == y) cout << -1 << endl; else { if (T[x].size() > T[y].size()) swap(x, y); if (S[x].find(y) != S[x].end()) cout << S[x][y] << endl; else { int minv, maxl; double sum = 0; for (j = 0; j < T[x].size(); ++j) { u = T[x][j]; maxl = max(*T[x].rbegin(), *T[y].rbegin()); minv = maxl - u; k = lower_bound(T[y].begin(), T[y].end(), minv) - T[y].begin(); sum += (long long int)maxl * k + *TS[y].rbegin() - TS[y][k] + (T[y].size() - k) * (u + 1); } sum /= T[x].size() * T[y].size(); S[x][y] = sum; cout << fixed << setprecision(10) << sum << endl; } } } return 0; } |
#include <bits/stdc++.h> using namespace std; int n, cnt; char s[111]; void dfs(int id, int d) { if (id >= n) return; if (s[id] == * ) cnt++; else return; dfs(id + d, d); } int main() { scanf( %d n , &n); gets(s); bool fl = 0; for (int i = 0; i < n; ++i) { for (int d = 1; d <= n; ++d) { cnt = 0; dfs(i, d); if (cnt >= 5) fl = 1; } } if (fl) { puts( yes ); } else puts( no ); return 0; } |
#include <bits/stdc++.h> using namespace std; const int NR = 5005; void Min(int& x, int y) { x = min(x, y); } void Max(int& x, int y) { x = max(x, y); } int read() { int x = 0, f = 1; char ch = getchar(); while (ch < 0 || ch > 9 ) { if (ch == - ) f = -1; ch = getchar(); } while (ch >= 0 && ch <= 9 ) { x = (x << 3) + (x << 1) + (ch ^ 48); ch = getchar(); } return x * f; } int n, m; char s[NR << 1]; int sa[NR << 1], id[NR << 1]; int rk[NR << 1], lark[NR << 1]; int cnt[NR]; int h[NR << 1]; int dp[NR << 1]; int mn[NR][NR]; void work() { memset(s, 0, sizeof(s)); memset(sa, 0, sizeof(sa)); memset(rk, 0, sizeof(rk)); n = read(), scanf( %s , s + 1); m = max(n, 300); memset(cnt, 0, sizeof(cnt)); for (int i = 1; i <= n; i++) cnt[rk[i] = s[i]]++; for (int i = 1; i <= m; i++) cnt[i] += cnt[i - 1]; for (int i = n; i >= 1; i--) sa[cnt[rk[i]]--] = i; for (int w = 1; w < n; w <<= 1) { memset(cnt, 0, sizeof(cnt)); int p = 0; for (int i = n - w + 1; i <= n; i++) id[++p] = i; for (int i = 1; i <= n; i++) if (sa[i] > w) id[++p] = sa[i] - w; for (int i = 1; i <= n; i++) cnt[rk[id[i]]]++; for (int i = 1; i <= m; i++) cnt[i] += cnt[i - 1]; for (int i = n; i >= 1; i--) sa[cnt[rk[id[i]]]--] = id[i]; memcpy(lark, rk, sizeof(lark)); rk[sa[1]] = m = 1; for (int i = 2; i <= n; i++) { if (lark[sa[i]] == lark[sa[i - 1]] && lark[sa[i] + w] == lark[sa[i - 1] + w]) rk[sa[i]] = m; else rk[sa[i]] = ++m; } } memset(h, 0, sizeof(h)); int lcp = 0; for (int i = 1; i <= n; i++) { if (lcp) lcp--; while (s[i + lcp] == s[sa[rk[i] - 1] + lcp]) lcp++; h[rk[i]] = lcp; } for (int i = 1; i <= n; i++) { mn[i][i] = h[i]; for (int j = i + 1; j <= n; j++) mn[i][j] = min(mn[i][j - 1], h[j]); } int ans = 0; memset(dp, 0, sizeof(dp)); for (int i = 1; i <= n; i++) { int len = dp[i] = n - i + 1; for (int j = 1; j < i; j++) { if (rk[i] < rk[j]) continue; dp[i] = max(dp[i], dp[j] + len - mn[rk[j] + 1][rk[i]]); } ans = max(ans, dp[i]); } printf( %d n , ans); for (int i = 1; i <= n; i++) for (int j = 1; j <= n; j++) mn[i][j] = 0; } int main() { int T = read(); while (T--) work(); return 0; } |
#include <bits/stdc++.h> using namespace std; const long long MOD = 1e9 + 7; long long n, a[100010]; int main() { long long n, mx = 0, sum = 0; cin >> n; for (int i = 0; i < n; i++) { cin >> a[i]; if (a[i] > mx) mx = a[i]; sum += a[i]; } long long s = (sum + n - 2) / (n - 1); if (mx > s) s = mx; cout << s << n ; return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { long long n, m, tr; cin >> n >> m; vector<long long> a, b; for (int i = 1; i <= n; i++) { cin >> tr; a.push_back(tr); } for (int i = 1; i <= m; i++) { cin >> tr; b.push_back(tr); } long long max, ans = LONG_LONG_MAX; for (int i = 0; i < n; i++) { max = LONG_LONG_MIN; for (int j = 0; j < n; j++) { if (j == i) continue; for (int k = 0; k < m; k++) { if (a[j] * b[k] > max) max = a[j] * b[k]; } } if (max < ans) ans = max; } cout << ans; return 0; } |
#include <bits/stdc++.h> using namespace std; vector<string> m; int main() { int n, k; cin >> n >> k; int e = 0; for (int i = 1; i < k; i++) { string t = ; t += char( A + e / 26); t += char( a + e % 26); e++; m.push_back(t); } for (int i = k; i <= n; i++) { string s; cin >> s; if (s == YES ) { string t = ; t += char( A + e / 26); t += char( a + e % 26); e++; m.push_back(t); } else { m.push_back(m[i - k]); } } for (string &s : m) std::cout << s << ; } |
#include <bits/stdc++.h> using namespace std; vector<long long> v; vector<pair<long long, long long> > ans; long long sz, n, m, pos; long long p2(long long x) { long long y = sqrt(x); for (long long i = y - 1; i <= y + 1; i++) if (i * i == x) return y; return false; } bool fnd(long long x) { long long p = pos, i; for (i = pos; i <= sz; i++) { long long j = p2(i * i + x); if (j) { pos = j; ans.push_back({i, j}); return true; } } return false; } int32_t main() { cin >> n; for (long long i = 1; i <= n / 2; i++) { long long x; scanf( %lld , &x); v.push_back(x); } sz = 1e7; pos = 1; for (auto x : v) if (!fnd(x)) return cout << No << endl, 0; long long bef = 0; cout << Yes << endl; for (auto p : ans) { printf( %lld %lld , p.first * p.first - bef * bef, p.second * p.second - p.first * p.first); bef = p.second; } return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { long long n, m, h; cin >> n >> m >> h; long long r[n], c[m], a[n][m]; for (long long i = 0; i < m; i++) { cin >> c[i]; } for (int i = 0; i < n; i++) { cin >> r[i]; } for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { cin >> a[i][j]; } } for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if (r[i] == c[j] && a[i][j] == 1) { a[i][j] = r[i]; } } } for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if (a[i][j] == 1) { a[i][j] = min(r[i], c[j]); } } } for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { cout << a[i][j] << ; } cout << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; const int MAXN = -1; struct dot { long long x, y; dot(long long x = 0, long long y = 0) : x(x), y(y) {} }; bool operator<(dot a, dot b) { return ((a.x + a.y) == (b.x + b.y) ? a.x < b.x : (a.x + a.y) < (b.x + b.y)); } bool Amber(dot a, dot b) { return (a.x - a.y) < (b.x - b.y); } multiset<dot> L, R; long long getans(long long st, vector<dot> &V) { L.clear(); R.clear(); for (int i = (0); i < (int)(V.size()); i++) R.insert(V[i]); long long ans = 0; int p = 0; for (long long lim = -st; lim < st; lim += 2) { while (p < V.size() && (V[p].x - V[p].y < lim)) { L.insert(V[p]); R.erase(V[p]); p++; } if (L.empty() || R.empty()) { continue; } dot A = max(*L.begin(), *R.begin()); long long l = A.x + A.y; dot B = min(*L.rbegin(), *R.rbegin()); long long r = B.x + B.y; if (r < l) continue; ans += (r - l) / 2; } return ans; } int n; vector<dot> B, W; int main() { while (scanf( %d , &n) == 1) { B.clear(); W.clear(); for (int i = (0); i < (int)(n); i++) { dot T; scanf( %lld %lld , &T.x, &T.y); if ((T.x + T.y) % 2) B.push_back(T); else W.push_back(T); } sort(B.begin(), B.end(), Amber); sort(W.begin(), W.end(), Amber); long long ans = getans(200004, B) + getans(200005, W); printf( %lld n , ans); } return 0; } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.