func_code_string stringlengths 59 71.4k |
|---|
#include <bits/stdc++.h> using namespace std; pair<int, int> volc[100000]; int main() { int n, m; scanf( %d , &n); scanf( %d , &m); for (int i = 0; i < m; i++) { scanf( %d , &volc[i].first); scanf( %d , &volc[i].second); } sort(volc, volc + m); int x = 0; vector<pair<int, int> > ints; ints.push_back(make_pair(1, 1)); int i = 0; while (i != m) { if (ints.empty()) break; if (volc[i].first > x + 1) { int f = ints[0].first; ints.clear(); ints.push_back(make_pair(f, n)); } x = volc[i].first; vector<pair<int, int> > ys; int last = 0; while (x == volc[i].first) { if ((volc[i].second - last - 1) > 0) ys.push_back(make_pair(last + 1, volc[i].second - 1)); last = volc[i].second; i++; } if ((n + 1 - last - 1) > 0) ys.push_back(make_pair(last + 1, n)); vector<pair<int, int> > nints; int k = 0; for (int j = 0; j < (int)(ints.size()); j++) { while (k < (int)(ys.size()) && ys[k].second < ints[j].first) k++; while (k < (int)(ys.size()) && ys[k].first <= ints[j].second) { nints.push_back( make_pair(max(ys[k].first, ints[j].first), ys[k].second)); k++; } } ints = nints; } if (ints.empty()) { cout << -1 << endl; return 0; } if (x != n || ints[(int)(ints.size()) - 1].second == n) cout << 2 * (n - 1) << endl; else cout << -1 << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; struct Polynom { long long x, y; } a[6001], b[6001]; int main() { string s; cin >> s; if (s.length() == 1) { cout << s << endl; return 0; } for (int i = s.length(); i > 0; i--) s[i] = s[i - 1]; int n = s.length(); long long x = 0, y = s[0] - 48; for (int i = 1; i <= n; i++) { if (s[i] == + || s[i] == * ) { a[i].x = x; a[i].y = y; } if (s[i] == + ) { x += y; y = s[i + 1] - 48; } if (s[i] == * ) { y *= (s[i + 1] - 48); } } a[n].x = x; a[n].y = y; x = 0; y = s[n] - 48; for (int i = n; i >= 1; i--) { if (s[i] == + || s[i] == * ) { b[i].x = x; b[i].y = y; } if (s[i] == + ) { x += y; y = s[i - 1] - 48; } if (s[i] == * ) { y *= (s[i - 1] - 48); } } b[0].x = x; b[0].y = y; long long ans = 0; s[0] = + ; s[n + 1] = + ; s[n + 2] = 0 ; for (int i = 0; i <= n + 1; i++) { if (s[i] == + || s[i] == * ) { x = 0; y = s[i + 1] - 48; for (int j = i + 2; j <= n + 1; j++) { if (s[j] == + || s[j] == * ) { long long res = x + y; if (s[i] == * ) res *= a[i].y; if (s[j] == * ) res *= b[j].y; if (s[i] == + ) res += a[i].y; if (s[j] == + ) res += b[j].y; res += a[i].x + b[j].x; if (res > ans) { ans = res; } } if (s[j] == + ) { x += y; y = s[j + 1] - 48; } if (s[j] == * ) { y *= (s[j + 1] - 48); } } } } cout << ans << endl; } |
#include <bits/stdc++.h> using namespace std; const long long int mod = 1000000007; int main() { ios::sync_with_stdio(0); int n; cin >> n; long long int a[10000], sum[10000], all[10000], m[10000]; memset(all, 0, sizeof(all)); for (int i = 2; i < pow(2, n + 1); i++) { cin >> a[i]; } m[1] = sum[1] = 0; for (int i = 2; i < pow(2, n + 1); i++) { m[i] = sum[i] = sum[i / 2] + a[i]; } long long int fin[10000]; fin[1] = sum[(int)pow(2, n)]; for (int i = pow(2, n); i < pow(2, n + 1); i++) { fin[1] = max(fin[1], sum[i]); } for (int i = pow(2, n) - 1; i >= 1; i--) { m[i] = max(m[2 * i], m[2 * i + 1]); } long long int ans = 0; for (int i = 1; i < pow(2, n); i++) { all[2 * i] = all[2 * i + 1] = all[i]; if (m[2 * i] + all[i] < fin[1]) { ans += (fin[1] - all[i] - m[2 * i]); all[2 * i] = all[i] + fin[1] - all[i] - m[2 * i]; } if (m[2 * i + 1] + all[i] < fin[1]) { ans += (fin[1] - all[i] - m[2 * i + 1]); all[2 * i + 1] = all[i] + fin[1] - all[i] - m[2 * i + 1]; } cerr << i << : << i << | << ans << : << ans << endl; ; } cout << ans << endl; } |
#include <bits/stdc++.h> using namespace std; const long double PI = acos(-1); vector<complex<double> > fft(const vector<complex<double> >& as) { int n = (int)as.size(); int k = 0; while ((1 << k) < n) k++; vector<int> r(n); r[0] = 0; int h = -1; for (int i = 1; i < n; i++) { if ((i & (i - 1)) == 0) h++; r[i] = r[i ^ (1 << h)]; r[i] |= (1 << (k - h - 1)); } vector<complex<double> > root(n); for (int i = 0; i < n; i++) { double ang = 2.0 * PI * i / n; root[i] = complex<double>(cos(ang), sin(ang)); } vector<complex<double> > cur(n); for (int i = 0; i < n; i++) cur[i] = as[r[i]]; for (int len = 1; len < n; len <<= 1) { vector<complex<double> > ncur(n); int step = n / (len << 1); for (int pdest = 0; pdest < n;) { for (int i = 0; i < len; i++) { complex<double> val = root[i * step] * cur[pdest + len]; ncur[pdest] = cur[pdest] + val; ncur[pdest + len] = cur[pdest] - val; pdest++; } pdest += len; } cur.swap(ncur); } return cur; } vector<complex<double> > inv_fft(const vector<complex<double> >& fa) { vector<complex<double> > res = fft(fa); int nn = res.size(); for (int i = 0; i < nn; i++) { res[i] /= nn; } reverse(res.begin() + 1, res.end()); return res; } vector<complex<double> > multiply(vector<complex<double> >& a, vector<complex<double> >& b) { int len = a.size() + b.size(); while (len & (len - 1)) ++len; a.resize(len); b.resize(len); a = fft(a); b = fft(b); for (int i = 0; i < len; ++i) a[i] *= b[i]; a = inv_fft(a); return a; } void create(string& s, int size, char x, int k, vector<complex<double> >& v) { complex<double> zero(0, 0); for (int i = 0, b = 1; i < size; i += b, b = 1) { if (s[i] == x) { b = 0; v[i] = 1; for (int j = i - 1; j >= 0 && s[j] != x && v[j] == zero && j >= i - k; j--) v[j] = 1; int tmp = i; for (++i; i < size && s[i] != x && i <= tmp + k && v[i] == zero; i++) v[i] = 1; } } } int main() { ios::sync_with_stdio(false), cin.tie(nullptr); int k, a = 0, g = 0, c = 0, t = 0, n, m; string s, s2; cin >> n >> m >> k >> s >> s2; for (int i = 0; i < m / 2; i++) { swap(s2[i], s2[m - 1 - i]); } int size = 1; while (size < m + n - 1) size *= 2; vector<complex<double> > av(n), av2(m); create(s, n, A , k, av); create(s2, m, A , 0, av2); av = multiply(av, av2); vector<complex<double> > tv(n), tv2(m); create(s, n, T , k, tv); create(s2, m, T , 0, tv2); tv = multiply(tv, tv2); vector<complex<double> > gv(n), gv2(m); create(s, n, G , k, gv); create(s2, m, G , 0, gv2); gv = multiply(gv, gv2); vector<complex<double> > cv(n), cv2(m); create(s, n, C , k, cv); create(s2, m, C , 0, cv2); cv = multiply(cv, cv2); int sum = 0; for (int i = 0; i < cv.size(); i++) sum += ((int)(cv[i].real() + gv[i].real() + av[i].real() + tv[i].real() + 0.3) == m); cout << sum; return 0; } |
#include <bits/stdc++.h> using namespace std; char grid[512][512]; bool used[512][512]; int n, m; struct op { char type; int x, y; op() {} op(char c, int a, int b) { type = c; x = a; y = b; } }; vector<op> res; int dx[4] = {0, -1, 0, 1}; int dy[4] = {1, 0, -1, 0}; void go(int x, int y, int level) { if (x < 1 || x > n || y > m || y < 1) return; if (used[x][y]) return; used[x][y] = 1; for (int i = 0; i < 4; i++) { go(x + dx[i], y + dy[i], level + 1); } if (level) { res.push_back(op( D , x, y)); res.push_back(op( R , x, y)); } } int main() { cin >> n >> m; for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) cin >> grid[i][j]; for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) { if (grid[i][j] == . ) res.push_back(op( B , i, j)); else used[i][j] = 1; } for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) { if (!used[i][j]) { go(i, j, 0); } } int k = res.size(); cout << k << endl; for (int i = 0; i < k; i++) { cout << res[i].type << << res[i].x << << res[i].y << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; long long n, a[1005]; int main() { scanf( %I64d , &n); for (int i = 1; i <= n; i++) scanf( %I64d , &a[i]); sort(a + 1, a + n + 1); long long ans = 0; for (int i = 2; i <= n; i++) ans += a[i] - a[i - 1] - 1; printf( %I64d n , ans); return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; int a[n]; bool f = false; for (int x = 0; x < n; x++) { cin >> a[x]; if (a[x] == 1) f = true; } if (f) { cout << -1; } else cout << 1; return 0; } |
#include <bits/stdc++.h> using namespace std; const int maxN = 50 + 10; long long dp[maxN]; int used[maxN]; int main() { int n; long long l; cin >> n >> l; dp[0] = 1; dp[1] = 1; for (int i = 2; i < maxN; i++) dp[i] = dp[i - 1] + dp[i - 2]; l--; for (int i = 0; i < n; i++) { int k = n - i; if (dp[k - 1] > l) cout << i + 1 << ; else { l -= dp[k - 1]; cout << i + 2 << << i + 1 << ; i++; } } } |
#include <bits/stdc++.h> using namespace std; void Emsawy() { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); } const double PI = acos(-1.0); const double eps = 1e-10; const long long mod = 1e9 + 7, oo = 1e9; int dx[]{1, -1, 0, 0, 1, -1, 1, -1}; int dy[]{0, 0, 1, -1, 1, -1, -1, 1}; vector<vector<pair<int, int> > > adj; int n, m, k, t; const int N = 4001; int L[N], R[N]; long dp[89][2002][89 * 2 + 10]; long go(int l, int r, int k) { long &ret = dp[k][l][n - r - l + 89]; if (ret != -oo) return ret; if (l <= (n - r)) { ret = -oo; if (r - l > k) ret = max(ret, go(l + k, r, k) - L[l] + L[l + k]); if (r - l > k + 1) ret = max(ret, go(l + k + 1, r, k + 1) - L[l] + L[l + k + 1]); return (ret == -oo ? ret = 0 : ret); } ret = oo; if (r - l > k) ret = min(ret, go(l, r - k, k) - (-R[r] + R[r - k])); if (r - l > k + 1) ret = min(ret, go(l, r - k - 1, k + 1) - (-R[r] + R[r - k - 1])); return (ret == oo ? ret = 0 : ret); } int main() { Emsawy(); while (cin >> n) { for (int i = 1; i <= n; i++) { cin >> L[i]; R[i] = L[i]; L[i] += L[i - 1]; } for (int i = n - 1; i >= 1; i--) R[i] += R[i + 1]; for (int i = 0; i < 89; i++) { for (int j = 0; j < 2002; j++) { for (int g = 0; g < 89 * 2 + 10; g++) { dp[i][j][g] = -oo; } } } n += 1; cout << go(0, n, 1) << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; int nod, edge; int a[401][401]; int dist[401]; int vis[401]; int bfs(int node) { queue<int> q; q.push(node); vis[node] = 1; while (q.size()) { int cur = q.front(); q.pop(); if (cur == nod) return dist[cur]; for (int i = nod; i >= 1; i--) { if (!vis[i] and (a[cur][i] + a[i][cur])) { dist[i] += dist[cur] + 1, q.push(i); vis[i] = 1; } } } return 0; } int bfs1(int node) { memset(dist, 0, sizeof dist); memset(vis, 0, sizeof vis); queue<int> q; q.push(node); vis[node] = 1; while (q.size()) { int cur = q.front(); q.pop(); if (cur == nod) return dist[cur]; for (int i = nod; i >= 1; i--) { if (!vis[i] and !(a[cur][i] + a[i][cur])) { dist[i] += dist[cur] + 1, q.push(i); vis[i] = 1; } } } return 0; } int main() { cin >> nod >> edge; int x, y; while (edge--) { cin >> x >> y; a[x][y] = 1; a[y][x] = 1; } int ans = bfs(1); int ans2 = bfs1(1); if (ans != 0 and ans2 != 0) cout << max(ans, ans2); else cout << -1; } |
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; int f = 0; int a[502] = {0, 1, 3, 6, 10, 15, 21, 28, 36, 45, 55, 66, 78, 91, 105, 120, 136, 153, 171, 190, 210, 231, 253, 276, 300, 325, 351, 378, 406, 435, 465, 496}; for (int i = 0; i < 32; i++) { if (a[i] == n) { cout << YES ; f = 1; } } if (f == 0) cout << NO ; } |
#include <bits/stdc++.h> using namespace std; struct point { int x, y; int det(point p) { return x * p.y - y * p.x; } }; point a[10], b[10]; int GetCross(point p1, point p2, point p) { return (p2.x - p1.x) * (p.y - p1.y) - (p.x - p1.x) * (p2.y - p1.y); } bool check(point p) { return GetCross(b[1], b[2], p) * GetCross(b[3], b[4], p) >= 0 && GetCross(b[2], b[3], p) * GetCross(b[4], b[1], p) >= 0; } int main() { for (int i = 1; i <= 4; i++) { scanf( %d%d , &a[i].x, &a[i].y); } for (int i = 1; i <= 4; i++) { scanf( %d%d , &b[i].x, &b[i].y); } int mix = min(min(min(a[1].x, a[2].x), a[3].x), a[4].x); int mxx = max(max(max(a[1].x, a[2].x), a[3].x), a[4].x); int miy = min(min(min(a[1].y, a[2].y), a[3].y), a[4].y); int mxy = max(max(max(a[1].y, a[2].y), a[3].y), a[4].y); for (int i = mix; i <= mxx; i++) { for (int j = miy; j <= mxy; j++) { point pi; pi.x = i; pi.y = j; if (check(pi)) { printf( YES n ); return 0; } } } printf( NO n ); return 0; } |
#include <bits/stdc++.h> using namespace std; const int maxn = 100005; const int sqrtn = 505; int l = 1, r, sum, cant; int n, m, p, s[maxn], w[maxn], cnt[maxn], last[maxn], pre[maxn], nxt[maxn], qwq[maxn][sqrtn], num[maxn]; vector<int> v; struct node { int l, r, id; } a[maxn]; inline bool cmp(node a, node b) { return a.l / p == b.l / p ? ((a.l / p) & 1 ? a.r < b.r : a.r > b.r) : a.l < b.l; } inline void add(int x) { cnt[w[x]]++; sum += cnt[w[x]] == 1; } inline void add_right(int x) { add(x); if (cnt[w[x]] != 1 && pre[x]) { qwq[w[x]][pre[x]]++; if (qwq[w[x]][pre[x]] == 1) { num[w[x]]++; if (num[w[x]] == 2) { cant++; } } } } void add_left(int x) { add(x); if (cnt[w[x]] != 1 && nxt[x]) { qwq[w[x]][nxt[x]]++; if (qwq[w[x]][nxt[x]] == 1) { num[w[x]]++; if (num[w[x]] == 2) { cant++; } } } } inline void del(int x) { cnt[w[x]]--; sum -= cnt[w[x]] == 0; } inline void del_right(int x) { del(x); if (qwq[w[x]][pre[x]] && pre[x]) { qwq[w[x]][pre[x]]--; if (qwq[w[x]][pre[x]] == 0) { num[w[x]]--; if (num[w[x]] == 1) { cant--; } } } } inline void del_left(int x) { del(x); if (qwq[w[x]][nxt[x]] && nxt[x]) { qwq[w[x]][nxt[x]]--; if (qwq[w[x]][nxt[x]] == 0) { num[w[x]]--; if (num[w[x]] == 1) { cant--; } } } } signed main() { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); cin >> n; for (int i = 1; i <= n; i++) { cin >> w[i]; if (last[w[i]]) { pre[i] = i - last[w[i]]; nxt[last[w[i]]] = i - last[w[i]]; v.push_back(pre[i]); v.push_back(nxt[last[w[i]]]); } last[w[i]] = i; } sort(v.begin(), v.end()); v.erase(unique(v.begin(), v.end()), v.end()); for (int i = 1; i <= n; i++) { } p = sqrt(n); cin >> m; for (int i = 1; i <= m; i++) { cin >> a[i].l >> a[i].r; a[i].id = i; } sort(a + 1, a + m + 1, cmp); for (int i = 1; i <= m; i++) { while (l > a[i].l) { add_left(--l); } while (r < a[i].r) { add_right(++r); } while (l < a[i].l) { del_left(l++); } while (r > a[i].r) { del_right(r--); } s[a[i].id] = sum + (cant == sum); } for (int i = 1; i <= m; i++) { cout << s[i] << n ; } } |
#include <bits/stdc++.h> using namespace std; int a[123][123], b[123][123], f1[54][54][54][54], f2[54][54][54][54]; int n; void getans(int i1, int j1, int i2, int j2) { int i, j, t; printf( ? %d %d %d %d n , i1, j1, i2, j2); fflush(stdout); scanf( %d , &t); if (t == f1[i1][j1][i2][j2]) { printf( ! n ), fflush(stdout); for (i = 1; i <= n; i++) { for (j = 1; j <= n; j++) printf( %d , (1 + a[i][j]) / 2); printf( n ); } } else { printf( ! n ), fflush(stdout); for (i = 1; i <= n; i++) { for (j = 1; j <= n; j++) printf( %d , (1 + b[i][j]) / 2); printf( n ); } } exit(0); } int main() { int i, j, i1, i2, j1, j2, t, j3, i3; scanf( %d , &n); a[1][1] = 1, a[n][n] = -1; for (i = 1; i <= n; i++) for (j = 2 - (i % 2); j <= n; j += 2) { if (!a[i][j]) { if (a[i - 1][j - 1]) { printf( ? %d %d %d %d n , i - 1, j - 1, i, j); fflush(stdout); scanf( %d , &t); if (!t) a[i][j] = -a[i - 1][j - 1]; else a[i][j] = a[i - 1][j - 1]; continue; } if (i > j) { printf( ? %d %d %d %d n , i - 2, j, i, j); fflush(stdout); scanf( %d , &t); if (!t) a[i][j] = -a[i - 2][j]; else a[i][j] = a[i - 2][j]; continue; } else { printf( ? %d %d %d %d n , i, j - 2, i, j); fflush(stdout); scanf( %d , &t); if (!t) a[i][j] = -a[i][j - 2]; else a[i][j] = a[i][j - 2]; continue; } } } a[1][2] = 1; for (i = 1; i <= n; i++) for (j = 3 - (i % 2); j <= n; j += 2) { if (!a[i][j]) { if (a[i - 1][j - 1]) { printf( ? %d %d %d %d n , i - 1, j - 1, i, j); fflush(stdout); scanf( %d , &t); if (!t) a[i][j] = -a[i - 1][j - 1]; else a[i][j] = a[i - 1][j - 1]; continue; } if (i > j - 1) { printf( ? %d %d %d %d n , i - 2, j, i, j); fflush(stdout); scanf( %d , &t); if (!t) a[i][j] = -a[i - 2][j]; else a[i][j] = a[i - 2][j]; continue; } else { printf( ? %d %d %d %d n , i, j - 2, i, j); fflush(stdout); scanf( %d , &t); if (!t) a[i][j] = -a[i][j - 2]; else a[i][j] = a[i][j - 2]; continue; } } } printf( ? %d %d %d %d n , 2, 1, 3, 2); fflush(stdout); scanf( %d , &t); if (!t) a[2][1] = -a[3][2]; else a[2][1] = a[3][2]; j = 1; for (i = 4; i <= n; i += 2) { printf( ? %d %d %d %d n , i - 2, j, i, j); fflush(stdout); scanf( %d , &t); if (!t) a[i][j] = -a[i - 2][j]; else a[i][j] = a[i - 2][j]; continue; } for (i = 1; i <= n; i++) for (j = 1; j <= n; j++) b[i][j] = (((i + j) & 1) ? -a[i][j] : a[i][j]); for (i3 = 0; i3 < n; i3++) for (j3 = 0; j3 < n; j3++) { for (i2 = i3 + 1; i2 <= n; i2++) for (j2 = j3 + 1; j2 <= n; j2++) { i1 = i2 - i3, j1 = j2 - j3; if (i1 == i2 && j1 == j2) f1[i1][j1][i2][j2] = 1, f2[i1][j1][i2][j2] = 1; else if (i2 + j2 - i1 - j1 == 1) { f1[i1][j1][i2][j2] = (a[i1][j1] == a[i2][j2]); f2[i1][j1][i2][j2] = (b[i1][j1] == b[i2][j2]); } else { if (a[i1][j1] == a[i2][j2] && (f1[i1 + 1][j1][i2 - 1][j2] || f1[i1][j1 + 1][i2][j2 - 1] || f1[i1 + 1][j1][i2][j2 - 1] || f1[i1][j1 + 1][i2 - 1][j2])) f1[i1][j1][i2][j2] = 1; else f1[i1][j1][i2][j2] = 0; if (b[i1][j1] == b[i2][j2] && (f2[i1 + 1][j1][i2 - 1][j2] || f2[i1][j1 + 1][i2][j2 - 1] || f2[i1 + 1][j1][i2][j2 - 1] || f2[i1][j1 + 1][i2 - 1][j2])) f2[i1][j1][i2][j2] = 1; else f2[i1][j1][i2][j2] = 0; if (f1[i1][j1][i2][j2] != f2[i1][j1][i2][j2]) getans(i1, j1, i2, j2); } } } } |
#include <bits/stdc++.h> using namespace std; bool isprime(int n) { for (int i = 2; i < n; i++) { if (n % i == 0) { return false; } } return true; } int main() { int n; cin >> n; string s; cin >> s; int diff = 1; int i = 0; while (i < n) { cout << s[i]; i = i + diff; diff++; } } |
#include <bits/stdc++.h> using namespace std; vector<pair<char, pair<int, int> > > closest(10, make_pair( * , make_pair(0, 0))); int n, X, Y; int check_dir(int x, int y) { if (x == X && y > Y) return 1; if (x == X && y < Y) return 5; if (Y == y && x > X) return 3; if (Y == y && x < X) return 7; if (X < x && (x - X) == (y - Y)) return 2; if (X > x && (x - X) == (y - Y)) return 6; if (y > Y && (X - x) == (y - Y)) return 4; if (y < Y && (X - x) == (y - Y)) return 8; return 0; } int dist(int x, int y, int xx, int yy) { return max(abs(xx - x), abs(yy - y)); } void get_closest(char z, int x, int y, int dir) { if (closest[dir].first == * || dist(X, Y, x, y) < dist(X, Y, closest[dir].second.first, closest[dir].second.second)) { closest[dir].first = z; closest[dir].second = make_pair(x, y); } } int main() { scanf( %d%d%d , &n, &X, &Y); for (int i = 0; i < n; ++i) { char z; int x, y; cin >> z >> x >> y; int dir = check_dir(x, y); if (dir) { get_closest(z, x, y, dir); } } bool flag = false; for (int i = 1; i <= 7; i += 2) { if (closest[i].first == R || closest[i].first == Q ) flag = true; } for (int i = 2; i <= 8; i += 2) { if (closest[i].first == B || closest[i].first == Q ) flag = true; } if (flag) printf( YES ); else printf( NO ); return 0; } |
#include <bits/stdc++.h> using namespace std; void c_p_c() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); } bool isPrime(long long n) { if (n <= 1) return false; if (n <= 3) return true; if (n % 2 == 0 || n % 3 == 0) return false; for (long long i = 5; i * i <= n; i += 6) { if (n % i == 0 || n % (i + 2) == 0) return false; } return true; } vector<long long> Sieve(long long n) { bool prime[n + 1]; memset(prime, true, sizeof(prime)); for (long long i = 2; i * i <= n; i++) { if (prime[i]) { for (long long j = i * i; j <= n; j += i) { prime[j] = false; } } } vector<long long> primes; for (long long i = 2; i <= n; i++) { if (prime[i]) primes.push_back(i); } return primes; } map<long long, long long> primeFactors(long long n) { map<long long, long long> factors; while (n % 2 == 0) { n /= 2; factors[2]++; } for (long long i = 3; i <= sqrt(n); i += 2) { while (n % i == 0) { factors[i]++; n /= i; } } if (n > 2) factors[n]++; return factors; } int32_t main() { c_p_c(); long long t; cin >> t; while (t--) { long long n; cin >> n; vector<long long> arr(n + 1, 0); long long num; for (long long i = 0; i < n; i++) { cin >> num; arr[num]++; } sort(arr.begin(), arr.end(), greater<long long>()); long long ans = arr[0], prev = arr[0]; for (long long i = 1; i <= n; i++) { if (prev == 0) break; if (arr[i] >= prev) { ans += prev - 1; prev--; } else { ans += arr[i]; prev = arr[i]; } } cout << ans << n ; } } |
#include <bits/stdc++.h> using namespace std; const int N = 1e4 + 5; int n, a[N], m, k; long long ans; int main() { scanf( %d%d%d , &n, &m, &k); for (int i = 1; i <= n; i++) scanf( %d , &a[i]); if (n % 2 == 0) { puts( 0 ); return 0; } int mn = N * 100; for (int i = 1; i <= n; i += 2) mn = min(mn, a[i]); long long ans = min((long long)mn, 1ll * (m / ((n + 1) / 2)) * k); cout << ans; return 0; } |
#include <bits/stdc++.h> using namespace std; string ITS(long long x) { string s = ; while (x > 0) { s += (char)(x % 10 + 0 ); x /= 10; } string t = ; for (int i = s.size() - 1; i > -1; i--) t += s[i]; return t; } long long inf = 1e9; long long mod = 1e9 + 7; const long long M = 2e3; int main() { std::ios::sync_with_stdio(false); long long n, m; cin >> n >> m; double a = n * pow(1.000000011, m); cout << fixed << setprecision(15) << a; } |
#include <bits/stdc++.h> using namespace std; long long n = 0, m = 0, q = 0; long long ans = 0; vector<vector<int>> G = vector<std::vector<int>>(100001); vector<long long> f(112345), fa(100001), dep(100001), val(100001), sz(100001), s(100001); long long F(long long x) { return x == f[x] ? x : (f[x] = F(f[x])); } void dfs(long long u, long long ff) { sz[u] = 1; dep[u] = dep[ff] + 1; fa[u] = ff; for (int i = 0; i < G[u].size(); ++i) { long long v = G[u][i]; if (v == ff) { continue; } dfs(v, u); sz[u] += sz[v]; val[u] += sz[v] * sz[v]; } val[u] += (n - sz[u]) * (n - sz[u]); ans -= val[u]; } void merge(int x, int y) { ans -= s[x] * (s[x] - 1) * (s[x] - 2); ans -= s[y] * (s[y] - 1) * (s[y] - 2); ans -= s[x] * (s[x] - 1) * (n - s[x]) * 2; ans -= s[y] * (s[y] - 1) * (n - s[y]) * 2; ans -= (n - s[x]) * (n - s[x]) * s[x]; ans -= (n - s[y]) * (n - s[y]) * s[y]; ans += val[x] * s[x]; ans += val[y] * s[y]; val[x] += val[y] - sz[y] * sz[y] - (n - sz[y]) * (n - sz[y]); s[x] += s[y]; f[y] = x; ans += s[x] * (s[x] - 1) * (s[x] - 2); ans += s[x] * (s[x] - 1) * (n - s[x]) * 2; ans += (n - s[x]) * (n - s[x]) * s[x]; ans -= val[x] * s[x]; } int main() { cin >> n; for (int i = 1; i <= n; ++i) { G[i] = std::vector<int>(); s[i] = 1; f[i] = i; } for (int i = 0; i < n - 1; ++i) { int u, v; cin >> u >> v; G[u].push_back(v); G[v].push_back(u); } ans = 1LL * n * (n - 1) * (n - 1); dfs(1, 0); cout << ans << endl; cin >> q; while (q-- > 0) { int u, v; cin >> u >> v; u = F(u); v = F(v); while (u != v) { if (dep[u] < dep[v]) { int o = v; v = u; u = o; } merge(F(fa[u]), u); u = F(u); } cout << ans << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; template <class T> bool uin(T &a, T b) { return a > b ? (a = b, true) : false; } template <class T> bool uax(T &a, T b) { return a < b ? (a = b, true) : false; } const long long maxn = 1000001, mod = 1e9 + 7; int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); int n; cin >> n; long double a[n], b[n]; for (long long i = 0; i < (long long)(n); ++i) cin >> a[i]; for (long long i = 0; i < (long long)(n); ++i) cin >> b[i]; int ex = 0; map<long double, int> freq; for (long long i = 0; i < (long long)(n); ++i) { if (a[i] == 0 && b[i] == 0) ex++; if (a[i] == 0) continue; freq[b[i] / a[i]]++; } int ans = 0; for (auto it : freq) { ans = max(ans, it.second); } cout << ans + ex << n ; return 0; } |
#include <bits/stdc++.h> #pragma GCC optimize( O3 ) using namespace std; const int N = 3e5 + 5, M = 1e8 + 5, OO = 1000000; int T, n, m; int u, v; int deg[N]; int main() { scanf( %d , &n); for (int i = 1; i < n; ++i) { scanf( %d %d , &u, &v); ++deg[u], ++deg[v]; } for (int i = 1; i <= n; ++i) { if (deg[i] == 2) { printf( NO n ); return 0; } } printf( YES n ); } |
#include <bits/stdc++.h> #pragma GCC target( sse ) const int maxn = 2e5 + 5; struct IO { char c; inline char gc() { static char buf[maxn], *p1 = buf, *p2 = buf; return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, maxn, stdin), p1 == p2) ? EOF : *p1++; } template <typename T> inline IO &operator>>(T &_) { _ = 0; bool f = 1; c = gc(); while (c < 0 || c > 9 ) { if (c == - ) f = 0; c = gc(); } while (c >= 0 && c <= 9 ) { _ = _ * 10 + c - 48; c = gc(); } if (!f) _ = -_; return *this; } char buf[maxn]; int p = 0; ~IO() { fwrite(buf, 1, p, stdout); } inline void pc(const char &c) { buf[p++] = c; if (p == maxn) fwrite(buf, 1, maxn, stdout), p = 0; } template <typename T> inline IO &operator<<(T x) { if (!x) { pc(48); pc( n ); return *this; } static int wt[41], len; len = 0; if (x < 0) { pc( - ); x = -x; } for (; x; x /= 10) { wt[++len] = x % 10; } while (len) { pc(wt[len--] + 48); } pc( n ); return *this; } inline IO &operator>>(char s[]) { c = gc(); int len = -1; while (c == || c == n || c == r ) c = gc(); while (c != && c != n && c != r && c != 0 && c != EOF) { s[++len] = c; c = gc(); } s[++len] = 0 ; return *this; } } io; int n, m, q; char s1[maxn], s2[maxn]; unsigned long long b1[64][(maxn >> 6) + 64], b2[64][(maxn >> 6) + 64]; void build() { for (int i = 0; i < 64; i++) { for (int j = i; j < n; j += 64) { for (int k = 0; k < 64; k++) b1[i][j >> 6] += (1ll << k) * (s1[j + k] - 48); } } for (int i = 0; i < 64; i++) { for (int j = i; j < m; j += 64) { for (int k = 0; k < 64; k++) b2[i][j >> 6] += (1ll << k) * (s2[j + k] - 48); } } } int main() { io >> s1 >> s2; n = strlen(s1), m = strlen(s2); build(); io >> q; while (q--) { int p1, p2, len; io >> p1 >> p2 >> len; int now = 0, a1 = 0, a2 = 0, a3 = 0, a4 = 0, a5 = 0, a6 = 0, a7 = 0, a8 = 0; unsigned long long *f1 = b1[p1 & 63] + (p1 >> 6), *f2 = b2[p2 & 63] + (p2 >> 6); for (; now + 511 < len; now += 512, f1 += 8, f2 += 8) { a1 += __builtin_popcountll(f1[0] ^ f2[0]); a2 += __builtin_popcountll(f1[1] ^ f2[1]); a3 += __builtin_popcountll(f1[2] ^ f2[2]); a4 += __builtin_popcountll(f1[3] ^ f2[3]); a5 += __builtin_popcountll(f1[4] ^ f2[4]); a6 += __builtin_popcountll(f1[5] ^ f2[5]); a7 += __builtin_popcountll(f1[6] ^ f2[6]); a8 += __builtin_popcountll(f1[7] ^ f2[7]); } for (; now < len; now++) a1 += (s1[p1 + now] - 48) ^ (s2[p2 + now] - 48); io << a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8; } return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); long long int t; cin >> t; while (t--) { long long int n, i, j, k, sum = 0, ev = 0, ze = 0; string s; cin >> s; n = s.length(); for (i = 0; i < n; i++) { sum = sum + s[i] - 0 ; if ((s[i] - 0 ) % 2 == 0) ev++; if (s[i] - 0 == 0) ze++; } if (ze == 0) cout << cyan << endl; else { if (ev < 2) cout << cyan << endl; else { if (sum % 3 == 0) cout << red << endl; else cout << cyan << endl; } } } } |
#include <bits/stdc++.h> using namespace std; int main() { int n, ans; cin >> n; long long a[n]; for (int i = 0; i < n; i++) { cin >> a[i]; } ans = a[0]; for (int i = 1; i < n; i++) { a[i] += ans; if (a[i] - ans > 0) { ans = a[i]; } } for (int i = 0; i < n; i++) { cout << a[i] << ; } } |
#include <bits/stdc++.h> using namespace std; int MOD = 1000000007; int tree[20000][2]; int main() { ios::sync_with_stdio(0); int n, a, b, k; cin >> n >> a >> b >> k; for (int i = 1; i <= n; i++) { if (i != b) tree[i][0]++; } int h = 1; for (int j = 1; j <= k; j++) { for (int i = 2; i <= n; i++) { tree[i][1 - h] += tree[i - 1][1 - h]; tree[i][1 - h] %= MOD; } for (int i = 1; i <= n; i++) { if (i == b) continue; int lim = abs(i - b); lim--; tree[i][h] = tree[min(n, i + lim)][1 - h] - tree[max(1, i - lim) - 1][1 - h]; tree[i][h] += MOD; tree[i][h] %= MOD; tree[i][h] -= (tree[i][1 - h] - tree[i - 1][1 - h] + MOD) % MOD; tree[i][h] += MOD; tree[i][h] %= MOD; } h ^= 1; } for (int i = 2; i <= n; i++) { tree[i][1 - h] += tree[i - 1][1 - h]; tree[i][1 - h] %= MOD; } cout << (tree[a][1 - h] - tree[a - 1][1 - h] + MOD) % MOD << endl; return 0; } |
#include <bits/stdc++.h> template <typename T> bool Chkmax(T &x, T y) { return x < y ? x = y, true : false; } template <typename T> bool Chkmin(T &x, T y) { return y < x ? x = y, true : false; } const int MAXN = 1e5 + 1e4, MAXK = 5 + 5; const double eps = 1e-4; int n; int k; std::pair<int, int> ans[MAXK]; inline int Dcmp(const double &x) { if (fabs(x) < eps) return 0; return x > 0 ? 1 : -1; } struct Point { double x, y; Point() {} Point(double x, double y) : x(x), y(y) {} }; struct Line { int A, B, C, id; Line() {} Line(int A, int B, int C, int id) : A(A), B(B), C(C), id(id) {} inline bool OnLine(const Point &p) { return Dcmp(A * p.x + B * p.y + C) == 0; } } s[MAXN]; Point GetInter(Line l1, Line l2) { if (l2.A == 0) std::swap(l1, l2); double x, y; x = (double)(-l2.C + (double)l2.B * l1.C / l1.B) / (l2.A - (double)l1.A * l2.B / l1.B); y = (double)(-l1.C - l1.A * x) / l1.B; return Point(x, y); } bool Work(int N, int K) { if (N <= K) { printf( YES n%d n , k - K + N); for (int i = 1, _ = N; i <= _; i++) printf( %d %d n , s[i].id, -1); return true; } if (K == 0) return false; Point p[MAXK * MAXK]; std::pair<int, int> fr[MAXK * MAXK]; int tot = 0; for (int i = 1, _ = K + 1; i <= _; i++) for (int j = i + 1, _ = K + 1; j <= _; j++) { ++tot; p[tot] = GetInter(s[i], s[j]); fr[tot] = std::make_pair(s[i].id, s[j].id); } for (int i = 1, _ = tot; i <= _; i++) { int newN = N; for (int j = 1; j <= newN; j++) { if (s[j].OnLine(p[i])) { std::swap(s[j], s[newN--]); j--; } } if (Work(newN, K - 1)) { printf( %d %d n , fr[i].first, fr[i].second); return true; } } return false; } void Init() { int A, B, C; scanf( %d%d , &n, &k); for (int i = 1, _ = n; i <= _; i++) { scanf( %d%d%d , &A, &B, &C); s[i] = Line(A, B, C, i); } } int main() { if (fopen( D.in , r ) != NULL) { freopen( D.in , r , stdin); freopen( D.out , w , stdout); } Init(); if (!Work(n, k)) printf( NO n ); return 0; } |
#include <bits/stdc++.h> int mod = 1000000007; using namespace std; using namespace std; int n, k; int a[400005]; int pos[400005]; map<int, int> m; int main() { ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0); ; cin >> n >> k; for (int i = 1; i <= n; i++) pos[i] = 1e7; m[a[1]] = 1e7; for (int i = 1; i <= n; i++) { cin >> a[i]; } for (int i = 1; i <= n; i++) { pos[m[a[i]]] = i; m[a[i]] = i; } int ans = 0; set<int> s; set<pair<int, int> > ss; for (int i = 1; i <= n; i++) { if (!s.count(a[i])) { if (s.size() < k) { ans++; s.insert(a[i]); ss.insert(make_pair(pos[i], a[i])); } else { ans++; set<pair<int, int> >::iterator it = ss.end(); it--; int val = (*it).second; ss.erase(it); s.erase((val)); s.insert(a[i]); ss.insert(make_pair(pos[i], a[i])); } } else { ss.erase(ss.begin()); ss.insert(make_pair(pos[i], a[i])); } } cout << ans; } |
#include <bits/stdc++.h> using namespace std; int main() { int n = ({ int x; scanf( %d , &x); x; }); string s; cin >> s; string ans = no ; for (int d = (1); d < (30); d += (1)) { for (int i = (0); i < (n); i += (1)) { int g = 1; for (int j = (0); j < (5); j += (1)) { if (i + j * d >= n || s[i + j * d] == . ) { g = 0; } } if (g) { ans = yes ; break; } } } cout << ans << endl; } |
#include <bits/stdc++.h> using namespace std; using ll = long long; using ld = long double; using ull = unsigned long long; using pii = pair<int, int>; using C = complex<double>; const double PI = 3.14159265; const double eps = 1e-8; const int N = 1 << 17; const int M = 1e9 + 7; const int inf = 1e9 + 7; const ll INF = 1e18; ll pw(ll a, ll b) { ll t = 1; a %= M; for (; b; b >>= 1) { if (b & 1) { t = t * a % M; } a = a * a % M; } return t; } ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; } int n; int num[N]; int mx[N << 1]; int seg[N << 1]; int find() { int u = 1, w = 0; while (u < N) { if (mx[u << 1 | 1] + w > 0) { u = u << 1 | 1; } else { w += seg[u << 1 | 1]; u <<= 1; } } return u - N; } void add(int p, int v) { p += N; seg[p] += v; mx[p] = seg[p] == 1; for (p >>= 1; p; p >>= 1) { seg[p] = seg[p << 1] + seg[p << 1 | 1]; mx[p] = max(mx[p << 1 | 1], mx[p << 1] + seg[p << 1 | 1]); } } int main() { ios::sync_with_stdio(0), cin.tie(0), cout.tie(0); cin >> n; int p, t, x; for (int i = 0; i < n; i++) { cin >> p >> t; if (t == 1) { cin >> num[p]; add(p, 1); } else { add(p, -1); } int ps = find(); if (mx[1] <= 0) { puts( -1 ); } else { printf( %d n , num[ps]); } } } |
#include <bits/stdc++.h> using namespace std; int main() { int t; cin >> t; while (t--) { long long x, y; cin >> x >> y; long long l = x - y; l = l < 0 ? -l : l; int r = l % 10; long long a = l / 10.0; if (r) a++; cout << a; cout << n ; } } |
#include <bits/stdc++.h> using namespace std; const long double INF = 1e9; const long double EPS = 1e-9; long double dist(long double x1, long double y1, long double x2, long double y2) { return sqrt(pow(x1 - x2, 2) + pow(y1 - y2, 2)); } long double func(long double X, long double Y, long double L, long double R) { return min(dist(L, 0, X, Y), dist(R, 0, X, Y)) + R - L; } int main() { cout.setf(ios::fixed); cout.precision(15); int n, k; cin >> n >> k; k--; vector<int> x(n); for (int i = 0; i < n; i++) cin >> x[i]; int X, Y; cin >> X >> Y; int xStart; if (k < n) xStart = x[k]; sort(x.begin(), x.end()); if (k == n) { cout << func(X, Y, x[0], x[n - 1]); return 0; } k = lower_bound(x.begin(), x.end(), xStart) - x.begin(); long double ans = INF; for (int i = 0; i < n; i++) { long double cur1 = min(x[k] - x[0] + x[i] - x[0] + dist(x[i], 0, X, Y), abs(x[i] - x[k]) + x[i] - x[0] + dist(x[0], 0, X, Y)); if (i + 1 < n) cur1 += func(X, Y, x[i + 1], x[n - 1]); long double cur2 = min(x[n - 1] - x[k] + x[n - 1] - x[i] + dist(x[i], 0, X, Y), abs(x[k] - x[i]) + x[n - 1] - x[i] + dist(x[n - 1], 0, X, Y)); if (i - 1 >= 0) cur2 += func(X, Y, x[0], x[i - 1]); ans = min(ans, min(cur1, cur2)); } cout << ans << n ; return 0; } |
#include <bits/stdc++.h> using namespace std; int v, e; vector<int> out[30005]; vector<int> ans; bool vis[30005]; void dfstree(int n) { for (auto x : out[n]) { if (!vis[x]) { vis[x] = true; dfstree(x); } } ans.push_back(n); } int main() { cin >> v >> e; for (int i = 0; i < e; i++) { int x, y; cin >> x >> y; out[x].push_back(y); } for (int i = 1; i < v + 1; i++) { if (!vis[i]) { vis[i] = true; dfstree(i); } } for (auto x : ans) cout << x << ; cout << n ; ; } |
#include <bits/stdc++.h> using namespace std; long long n, a[300005], ans; int main() { cin >> n; for (int i = 1; i <= n; i++) { cin >> a[i]; } sort(a + 1, a + n + 1); for (int i = 1; i <= n / 2; i++) { ans += (a[i] + a[n - i + 1]) * (a[i] + a[n - i + 1]); } cout << ans; return 0; } |
#include <bits/stdc++.h> using namespace std; const int maxn = 100; int n, m, ans; int num[maxn]; set<int> st[2]; set<int>::iterator it, itt; void get_st(int begin, int end, set<int> &st) { st.clear(); st.insert(0); for (int i = 0; i < (1 << (end - begin)); ++i) { int tmp = 0; for (int j = 0; j < end - begin; ++j) { if (((i >> j) & 1) == 1) { tmp = (tmp + num[j + begin]) % m; } } st.insert(tmp); } } int main() { ios::sync_with_stdio(false); while (scanf( %d%d , &n, &m) != EOF) { ans = 0; for (int i = 0; i < n; ++i) { scanf( %d , &num[i]); } get_st(0, (n + 1) / 2, st[0]); get_st((n + 1) / 2, n, st[1]); for (it = st[0].begin(); it != st[0].end(); ++it) { for (int i = 1; i <= 2; ++i) { itt = st[1].lower_bound(m * i - *it); if (itt != st[1].begin()) { --itt; ans = max(ans, (*it + *itt) % m); } } } printf( %d n , ans); } return 0; } |
#include <bits/stdc++.h> using namespace std; int n, m, a[200005], head[200005]; struct edge { int to, nxt; edge(int _t = -1, int _n = -1) { to = _t; nxt = _n; } } e[400005]; void addedge(int u, int v) { e[m] = edge(v, head[u]); head[u] = m++; e[m] = edge(u, head[v]); head[v] = m++; } vector<int> g; int dp[200005], s; void dfs1(int fa, int u) { if (a[u] == -1) dp[u] = 1; else dp[u] = 0; for (int p = head[u]; p != -1; p = e[p].nxt) { int v = e[p].to; if (v == fa) continue; dfs1(u, v); dp[u] += dp[v]; } } void dfs2(int fa, int u) { if (s == 0 || dp[u] == 0) return; int x; for (int p = head[u]; p != -1; p = e[p].nxt) { int v = e[p].to; x = v; if (v == fa || dp[v] == 0) continue; g.push_back(v + 1); if (a[v] == -1) { s--; dp[v]--; } else { s++; dp[v]++; } a[v] = -a[v]; dfs2(u, v); if (s == 0) return; g.push_back(u + 1); if (a[u] == -1) { s--; dp[u]--; } else { s++; dp[u]++; } a[u] = -a[u]; } if (a[u] == -1) { a[u] = 1; if (fa == -1) { g.push_back(x + 1); g.push_back(1); g.push_back(x + 1); return; } else { g.push_back(fa + 1); g.push_back(u + 1); s--; dp[u]--; if (a[fa] == -1) { s--; dp[fa]--; } else { s++; dp[fa]++; } a[fa] = -a[fa]; } } } int main() { scanf( %d , &n); for (int i = 0; i < n; ++i) { scanf( %d , &a[i]); if (a[i] == -1) s++; } memset(head, -1, sizeof(head)); m = 0; for (int i = 1; i < n; ++i) { int u, v; scanf( %d%d , &u, &v); addedge(u - 1, v - 1); } if (s == 0) { printf( 1 n ); return 0; } g.clear(); dfs1(-1, 0); dfs2(-1, 0); printf( 1 ); for (int i = 0; i < g.size(); ++i) printf( %d , g[i]); printf( n ); return 0; } |
#include <bits/stdc++.h> using namespace std; const int N = int(3e5), mod = int(1e9) + 7, block = 316; int n, m, q; vector<int> g[N], comp[N], heavy, di[N]; int root[N], cur, sz[N], d[N], dr[N], d1[N], d2[N]; bool used[N]; bool h[N]; long double ans[N], fans[N]; vector<pair<int, int> > qu[N]; void dfs(int v) { used[v] = 1; comp[cur].push_back(v); sz[cur]++; root[v] = cur; for (int i = 0; i < g[v].size(); i++) { int to = g[v][i]; if (!used[to]) dfs(to); } } void dfs1(int v, int p = -1) { used[v] = 1; for (int i = 0; i < g[v].size(); i++) { int to = g[v][i]; if (to == p) continue; dfs1(to, v); d1[v] = max(d1[v], d1[to] + 1); } } void dfs2(int v, int p = -1) { int mx1 = d2[v], mx2 = 0; for (int i = 0; i < g[v].size(); i++) { int to = g[v][i]; if (to == p) continue; if (d1[to] + 1 > mx1) { mx2 = mx1; mx1 = d1[to] + 1; } else if (d1[to] + 1 > mx2) { mx2 = d1[to] + 1; } } for (int i = 0; i < g[v].size(); i++) { int to = g[v][i]; if (to == p) continue; if (mx1 == d1[to] + 1) { d2[to] = mx2 + 1; } else d2[to] = mx1 + 1; dfs2(to, v); } } int a[N], b[N], an, bn; long long pref[N]; void cons(int v) { an = 0; for (int i = 0; i < di[v].size(); i++) { a[++an] = di[v][i]; } for (int i = 1; i <= an; i++) { pref[i] = pref[i - 1] + a[i]; } } long double get(int v, int curd) { bn = 0; long long sum = 0; for (int i = 0; i < di[v].size(); i++) { b[++bn] = di[v][i]; } int j = an; for (int i = 1; i <= bn; i++) { while (j > 0 && b[i] + a[j] + 1 > curd) j--; sum += 1ll * j * curd + 1ll * (an - j) * b[i] + pref[an] - pref[j] + an - j; } return (sum + 0.0) / (1ll * an * bn); } int main() { scanf( %d%d%d , &n, &m, &q); for (int i = 1, u, v; i <= m; i++) { scanf( %d%d , &u, &v); g[u].push_back(v); g[v].push_back(u); } for (int i = 1; i <= n; i++) { if (!used[i]) { cur = i; dfs(i); } } for (int i = 1; i <= n; i++) { if (root[i] == i) { if (sz[i] > block) { heavy.push_back(i); h[i] = 1; } } } memset(used, 0, sizeof(used)); for (int i = 1; i <= n; i++) { if (!used[i]) { dfs1(i); dfs2(i); int v = root[i]; for (int j = 0; j < comp[v].size(); j++) { int u = comp[v][j]; dr[u] = max(d1[u], d2[u]); di[v].push_back(dr[u]); d[v] = max(d[v], dr[u]); } sort(di[v].begin(), di[v].end()); } } for (int i = 1, u, v; i <= q; i++) { scanf( %d%d , &u, &v); u = root[u]; v = root[v]; if (u == v) { ans[i] = -1; } else { if (h[u]) { qu[u].push_back(make_pair(v, i)); } else if (h[v]) { qu[v].push_back(make_pair(u, i)); } else { int curd = max(d[u], d[v]); cons(u); ans[i] = get(v, curd); } } } for (int i = 1; i <= n; i++) { if (int(qu[i].size()) > 0) { cons(i); for (int j = 1; j <= n; j++) if (root[j] == j) { fans[j] = get(j, max(d[i], d[j])); } for (int j = 0; j < qu[i].size(); j++) { ans[qu[i][j].second] = fans[qu[i][j].first]; } } } for (int i = 1; i <= q; i++) { printf( %.12lf n , double(ans[i])); } return 0; } |
#include <bits/stdc++.h> using namespace std; int a, b, c, d, p; int main() { cin >> a >> b >> c >> d; d -= c - 1; a -= c; b -= c; if (d == 2) { a--; b--; p = 3; } if (d == 1) { if (a) { a--; p = 1; } else { b--; p = 2; } } if (a < 0 || b < 0 || d > 2 || d < 0) cout << -1 ; else { if (p & 2) cout << 7 ; for (; a > 0; a--) cout << 4 ; for (; c > 0; c--) cout << 47 ; for (; b > 0; b--) cout << 7 ; if (p & 1) cout << 4 ; } return 0; } |
#include <bits/stdc++.h> using namespace std; const int maxn = 1e6 + 10; int n, k; int ver[maxn], t[maxn], dp[maxn], tin[maxn], cnt = 0, tout[maxn], h[maxn], p[maxn][30], important[maxn], ans = 0; vector<int> e[maxn]; void dfs(int u, int par = 0) { cnt++; tin[u] = cnt; h[u] = h[par] + 1; for (int i = 0; i < e[u].size(); i++) { int v = e[u][i]; if (v == par) continue; p[v][0] = u; for (int j = 1; j < 22; j++) p[v][j] = p[p[v][j - 1]][j - 1]; dfs(v, u); } tout[u] = cnt; return; } int get(int u, int len) { for (int i = 22; i >= 0; i--) if (len & (1 << i)) u = p[u][i]; return u; } int lca(int u, int v) { if (h[u] > h[v]) swap(u, v); int len = h[v] - h[u]; v = get(v, len); if (u == v) return u; for (int i = 22; i >= 0; i--) if (p[u][i] != p[v][i]) { u = p[u][i]; v = p[v][i]; } return p[u][0]; } bool cmp(int u, int v) { return tin[u] < tin[v]; } bool compare(int u, int v) { return tin[u] < tin[v] && tout[u] >= tout[v]; } bool buildGraph() { for (int i = 1; i < k; i++) ver[i + k] = lca(ver[i], ver[i + 1]); sort(ver + 1, ver + 2 * k, cmp); int cnter = unique(ver + 1, ver + 2 * k) - ver - 1; for (int i = 1; i <= cnter; i++) e[ver[i]].clear(); stack<int> s; s.push(ver[1]); for (int i = 2; i <= cnter; i++) { int v = ver[i]; while (!compare(s.top(), v)) s.pop(); int u = s.top(); if (important[u] && important[v] && u == p[v][0]) return 0; s.push(v); e[u].push_back(v); } return 1; } void dfsSolve(int u) { int cnter = 0; for (int i = 0; i < e[u].size(); i++) { int v = e[u][i]; dfsSolve(v); cnter += dp[v]; } if (important[u]) { ans += cnter; dp[u] = 1; } else { if (cnter >= 2) ans++, dp[u] = 0; else if (cnter == 1) dp[u] = 1; else dp[u] = 0; } } int main() { memset(h, 0, sizeof(h)); memset(tin, 0, sizeof(tin)); memset(tout, 0, sizeof(tout)); memset(dp, 0, sizeof(dp)); memset(p, 0, sizeof(p)); memset(important, 0, sizeof(important)); ios_base::sync_with_stdio(false); cin >> n; for (int i = 1; i < n; i++) { int u, v; cin >> u >> v; e[u].push_back(v); e[v].push_back(u); } dfs(1); int q; cin >> q; while (q--) { cin >> k; for (int i = 1; i <= k; i++) { cin >> ver[i]; important[ver[i]] = 1; t[i] = ver[i]; } sort(ver + 1, ver + k + 1, cmp); if (!buildGraph()) { cout << -1 << endl; } else { ans = 0; dfsSolve(ver[1]); cout << ans << endl; } for (int i = 1; i <= k; i++) important[t[i]] = 0; } return 0; } |
#include <bits/stdc++.h> using namespace std; string ar; string br; int n = 0, lst = 0, lstmin = 0, lp = 0, lpc = 0; int gzg = 0, rzg = 0, gzy2 = 0, rzy2 = 0; int gzf = 0, gzc = 0, rzf = 0, rzc = 0; int gzcc = 0, rzff = 0; int main() { int f = 0; cin >> n; ar.reserve(n + 1); br.reserve(n + 1); cin >> ar; for (f = 0; f < n; f++) { if (lst == lstmin) lpc++; if (ar[f] == ( ) lst++; else lst--; if (lst < lstmin) { lstmin = lst; lp = f + 1; lpc = 0; } } if (lst != 0) { cout << 0 n1 1 n ; return 0; } rzg = lpc; gzcc = lp; rzff = lp; for (f = lp; f < lp + n * 2 + 2; f++) { if (ar[f % n] == ( ) lst++; else lst--; switch (lst) { case 0: if (gzy2 <= gzg) { gzy2 = gzg; gzc = (gzcc + 1) % n + 1; gzf = f % n + 1; } gzg = 0; gzcc = f % n; break; case 1: gzg++; if (rzy2 <= rzg) { rzy2 = rzg; rzf = rzff % n + 1; rzc = f % n + 1; } rzff = f % n + 1; rzg = lpc; break; case 2: rzg++; break; } } if (rzy2 >= gzy2 && rzy2 > lpc) { cout << rzy2 << n << rzf << << rzc << n ; } else if (gzy2 > rzy2 && gzy2 > lpc) { cout << gzy2 << n << gzf << << gzc << n ; } else { cout << lpc << n1 1 n ; } return 0; } |
#include <bits/stdc++.h> using namespace std; int ToInt(string& s, int len) { int r = 0; for (int i = 0, max_ = (len); i < max_; ++i) { r *= 10; r += s[i] - 0 ; } return r; } int GCD(int a, int b) { return b != 0 ? GCD(b, a % b) : a; } int LCM(int a, int b) { return a * (b / GCD(a, b)); } long long Pow(long long n, long long e) { if (e == 0) return 1; if (e == 1) return n; else if (e & 1) { long long t = Pow(n, e / 2); return n * t * t; } else { long long t = Pow(n, e / 2); return t * t; } } int main() { string s; int N; scanf( %d , &N); getline(cin, s); getline(cin, s); int h = 0; for (int i = 0, max_ = ((int)(s).size()); i < max_; ++i) if (s[i] == H ) ++h; int min = 10000; for (int start = 0, max_ = ((int)(s).size()); start < max_; ++start) { int swaps = 0; for (int i = 0, max_ = (h); i < max_; ++i) if (s[(start + i) % (int)(s).size()] == T ) ++swaps; min = std::min(min, swaps); } printf( %d n , min); return 0; } |
#include <bits/stdc++.h> using namespace std; int cnt[(100000 + 10)]; int f[(100000 + 10)]; int main() { int n; cin >> n; int ans = 0; int mx = 0; for (int i = 1; i <= n; i++) { int v; cin >> v; cnt[f[v]]--; f[v]++; cnt[f[v]]++; int ok = 0; mx = max(mx, f[v]); if (cnt[1] == i) { ok = 1; } else if (cnt[mx] == i) { ok = 1; } else if (cnt[mx] * mx == i - 1 && cnt[1] == 1) { ok = 1; } else if (cnt[mx - 1] * (mx - 1) == i - mx && cnt[mx] == 1) { ok = 1; } if (ok) { ans = i; } } cout << ans << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; template <class T> inline void amin(T &x, const T &y) { if (y < x) x = y; } template <class T> inline void amax(T &x, const T &y) { if (x < y) x = y; } template <class Iter> void rprintf(const char *fmt, Iter begin, Iter end) { for (bool sp = 0; begin != end; ++begin) { if (sp) putchar( ); else sp = true; printf(fmt, *begin); } putchar( n ); } int A, B, C; int N; void MAIN() { scanf( %d%d%d%d , &A, &B, &C, &N); int ans = 0; for (int i = 0, i_len = (N); i < i_len; ++i) { int x; scanf( %d , &x); if (B < x && x < C) ans++; } printf( %d n , ans); } int main() { int TC = 1; for (int tc = 0, tc_len = (TC); tc < tc_len; ++tc) MAIN(); return 0; } |
#include <bits/stdc++.h> using namespace std; struct art { int t, d, p, id; } a[101]; pair<int, int> go[101][2001]; bool cmp(art xx, art yy) { return xx.d < yy.d; } int f[101][2001], num[101][2001], ans[1000], tt; int main() { int n; cin >> n; for (register int i = 1; i <= n; i++) cin >> a[i].t >> a[i].d >> a[i].p, a[i].id = i; sort(a + 1, a + n + 1, cmp); for (register int i = 1; i <= n; i++) for (register int k = 1; k <= 2000; k++) { if (k <= a[i].d && k - a[i].t > 0) { f[i][k] = f[i - 1][k - a[i].t] + a[i].p, go[i][k] = make_pair(i - 1, k - a[i].t), num[i][k] = i; } if (f[i][k - 1] > f[i][k]) { f[i][k] = f[i][k - 1]; go[i][k] = make_pair(i, k - 1), num[i][k] = -1; } if (f[i - 1][k] > f[i][k]) { f[i][k] = f[i - 1][k]; go[i][k] = make_pair(i - 1, k), num[i][k] = -1; ; } } cout << f[n][2000] << endl; int n1 = n, n2 = 2000; while (go[n1][n2].first) { if (num[n1][n2] != -1) ans[++tt] = a[num[n1][n2]].id; pair<int, int> cur = go[n1][n2]; n1 = cur.first; n2 = cur.second; } if (num[n1][n2] != -1 && num[n1][n2] != 0) ans[++tt] = a[num[n1][n2]].id; cout << tt << endl; for (register int i = tt; i; i--) cout << ans[i] << ; cout << endl; return 0; } |
#include <bits/stdc++.h> int main() { int i = 0, z, flag = 0, even = 0; char str[100002], temp; scanf( %s , str); int size = strlen(str); char x = str[size - 1]; for (i = 0; i < size; i++) { if (str[i] % 2 == 0) { even = 1; if (str[i] < x) { flag = 1; str[size - 1] = str[i]; str[i] = x; break; } else { z = i; } } } if (i >= size && even == 1) { flag = 1; str[size - 1] = str[z]; str[z] = x; } if (flag == 1) { printf( %s , str); } else printf( -1 ); return 0; } |
#include <bits/stdc++.h> #pragma GCC optimize( O3 ) using namespace std; long long n; bool valid(long long x) { long long a = 0, b = 0; long long r = n; while (r) { a += min(r, x); r -= min(r, x); b += r / 10; r -= r / 10; } return a >= b; } signed main() { ios_base::sync_with_stdio(false); cin.tie(NULL); long long seed; asm( rdtsc : =A (seed)); srand(seed); cin >> n; long long lo = 0, hi = n; while (lo + 1 < hi) { long long mid = (lo + hi) / 2; if (valid(mid)) hi = mid; else lo = mid; } cout << lo + 1 << n ; } |
#include <bits/stdc++.h> using namespace std; template <typename A, typename B> string to_string(pair<A, B> p); template <typename A, typename B, typename C> string to_string(tuple<A, B, C> p); template <typename A, typename B, typename C, typename D> string to_string(tuple<A, B, C, D> p); string to_string(const string& s) { return + s + ; } string to_string(const char* s) { return to_string((string)s); } string to_string(bool b) { return (b ? true : false ); } string to_string(vector<bool> v) { bool first = true; string res = { ; for (int i = 0; i < static_cast<int>(v.size()); i++) { if (!first) { res += , ; } first = false; res += to_string(v[i]); } res += } ; return res; } template <size_t N> string to_string(bitset<N> v) { string res = ; for (size_t i = 0; i < N; i++) { res += static_cast<char>( 0 + v[i]); } return res; } template <typename A> string to_string(A v) { bool first = true; string res = { ; for (const auto& x : v) { if (!first) { res += , ; } first = false; res += to_string(x); } res += } ; return res; } template <typename A, typename B> string to_string(pair<A, B> p) { return ( + to_string(p.first) + , + to_string(p.second) + ) ; } template <typename A, typename B, typename C> string to_string(tuple<A, B, C> p) { return ( + to_string(get<0>(p)) + , + to_string(get<1>(p)) + , + to_string(get<2>(p)) + ) ; } template <typename A, typename B, typename C, typename D> string to_string(tuple<A, B, C, D> p) { return ( + to_string(get<0>(p)) + , + to_string(get<1>(p)) + , + to_string(get<2>(p)) + , + to_string(get<3>(p)) + ) ; } void debug_out() { cerr << endl; } template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) { cerr << << to_string(H); debug_out(T...); } template <typename T> T inverse(T a, T m) { T u = 0, v = 1; while (a != 0) { T t = m / a; m -= t * a; swap(a, m); u -= t * v; swap(u, v); } assert(m == 1); return u; } template <typename T> class Modular { public: using Type = typename decay<decltype(T::value)>::type; constexpr Modular() : value() {} template <typename U> Modular(const U& x) { value = normalize(x); } template <typename U> static Type normalize(const U& x) { Type v; if (-mod() <= x && x < mod()) v = static_cast<Type>(x); else v = static_cast<Type>(x % mod()); if (v < 0) v += mod(); return v; } const Type& operator()() const { return value; } template <typename U> explicit operator U() const { return static_cast<U>(value); } constexpr static Type mod() { return T::value; } Modular& operator+=(const Modular& other) { if ((value += other.value) >= mod()) value -= mod(); return *this; } Modular& operator-=(const Modular& other) { if ((value -= other.value) < 0) value += mod(); return *this; } template <typename U> Modular& operator+=(const U& other) { return *this += Modular(other); } template <typename U> Modular& operator-=(const U& other) { return *this -= Modular(other); } Modular& operator++() { return *this += 1; } Modular& operator--() { return *this -= 1; } Modular operator++(int) { Modular result(*this); *this += 1; return result; } Modular operator--(int) { Modular result(*this); *this -= 1; return result; } Modular operator-() const { return Modular(-value); } template <typename U = T> typename enable_if<is_same<typename Modular<U>::Type, int>::value, Modular>::type& operator*=(const Modular& rhs) { value = normalize(static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value)); return *this; } template <typename U = T> typename enable_if<is_same<typename Modular<U>::Type, int64_t>::value, Modular>::type& operator*=(const Modular& rhs) { int64_t q = static_cast<int64_t>(static_cast<long double>(value) * rhs.value / mod()); value = normalize(value * rhs.value - q * mod()); return *this; } template <typename U = T> typename enable_if<!is_integral<typename Modular<U>::Type>::value, Modular>::type& operator*=(const Modular& rhs) { value = normalize(value * rhs.value); return *this; } Modular& operator/=(const Modular& other) { return *this *= Modular(inverse(other.value, mod())); } template <typename U> friend const Modular<U>& abs(const Modular<U>& v) { return v; } template <typename U> friend bool operator==(const Modular<U>& lhs, const Modular<U>& rhs); template <typename U> friend bool operator<(const Modular<U>& lhs, const Modular<U>& rhs); template <typename U> friend std::istream& operator>>(std::istream& stream, Modular<U>& number); private: Type value; }; template <typename T> bool operator==(const Modular<T>& lhs, const Modular<T>& rhs) { return lhs.value == rhs.value; } template <typename T, typename U> bool operator==(const Modular<T>& lhs, U rhs) { return lhs == Modular<T>(rhs); } template <typename T, typename U> bool operator==(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) == rhs; } template <typename T> bool operator!=(const Modular<T>& lhs, const Modular<T>& rhs) { return !(lhs == rhs); } template <typename T, typename U> bool operator!=(const Modular<T>& lhs, U rhs) { return !(lhs == rhs); } template <typename T, typename U> bool operator!=(U lhs, const Modular<T>& rhs) { return !(lhs == rhs); } template <typename T> bool operator<(const Modular<T>& lhs, const Modular<T>& rhs) { return lhs.value < rhs.value; } template <typename T> Modular<T> operator+(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) += rhs; } template <typename T, typename U> Modular<T> operator+(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) += rhs; } template <typename T, typename U> Modular<T> operator+(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) += rhs; } template <typename T> Modular<T> operator-(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) -= rhs; } template <typename T, typename U> Modular<T> operator-(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) -= rhs; } template <typename T, typename U> Modular<T> operator-(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) -= rhs; } template <typename T> Modular<T> operator*(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) *= rhs; } template <typename T, typename U> Modular<T> operator*(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) *= rhs; } template <typename T, typename U> Modular<T> operator*(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) *= rhs; } template <typename T> Modular<T> operator/(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) /= rhs; } template <typename T, typename U> Modular<T> operator/(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) /= rhs; } template <typename T, typename U> Modular<T> operator/(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) /= rhs; } template <typename T, typename U> Modular<T> power(const Modular<T>& a, const U& b) { assert(b >= 0); Modular<T> x = a, res = 1; U p = b; while (p > 0) { if (p & 1) res *= x; x *= x; p >>= 1; } return res; } template <typename T> bool IsZero(const Modular<T>& number) { return number() == 0; } template <typename T> string to_string(const Modular<T>& number) { return to_string(number()); } template <typename T> std::ostream& operator<<(std::ostream& stream, const Modular<T>& number) { return stream << number(); } template <typename T> std::istream& operator>>(std::istream& stream, Modular<T>& number) { typename common_type<typename Modular<T>::Type, int64_t>::type x; stream >> x; number.value = Modular<T>::normalize(x); return stream; } constexpr int md = 998244353; using Mint = Modular<std::integral_constant<decay<decltype(md)>::type, md>>; vector<Mint> fact(1, 1); vector<Mint> inv_fact(1, 1); Mint C(int n, int k) { if (k < 0 || k > n) { return 0; } while ((int)fact.size() < n + 1) { fact.push_back(fact.back() * (int)fact.size()); inv_fact.push_back(1 / fact.back()); } return fact[n] * inv_fact[k] * inv_fact[n - k]; } int main() { ios::sync_with_stdio(false); cin.tie(0); int n, m; cin >> n >> m; C(n + m, 0); auto Prob = [&](int i, int p) { Mint ret = fact[i] * inv_fact[p] * m * inv_fact[i + m] * fact[m - 1 + p]; return ret; }; vector<Mint> dp(n + 1); dp[0] = 0; Mint c1 = 0; Mint ci = 0; for (int i = 0; i <= n; i++) { Mint q = Mint(1) / (i + m + 1); if (i > 0) { dp[i] = c1 + ci * i; dp[i] *= m * fact[i] * inv_fact[i + m] * q; Mint rest = Prob(i, i); dp[i] = (dp[i] + rest * (1 + q * (n - i))) / (1 - rest); } int p = i; c1 += (dp[p] * (m + 1) + Mint(1 - p) * (n + m + 1)) * inv_fact[p] * fact[m - 1 + p]; ci += (dp[p] + (n + m + 1)) * inv_fact[p] * fact[m - 1 + p]; } cout << dp[n] << n ; return 0; } |
#include <bits/stdc++.h> using namespace std; const long long N = 1e5 + 7; int T, n, t, a[N]; map<long long, long long> mp; int main() { scanf( %d , &T); while (T--) { mp.clear(); scanf( %d%d , &n, &t); for (int i = 1; i <= n; ++i) { scanf( %d , &a[i]); } if (t % 2 == 1) { for (int i = 1; i <= n; ++i) { mp[a[i]] = 1; mp[t - a[i]] = 0; } for (int i = 1; i <= n; ++i) { printf( %d , mp[a[i]]); } printf( n ); } else { for (int i = 1; i <= n; ++i) { mp[a[i]] = 1; mp[t - a[i]] = 0; } int flag = 0; for (int i = 1; i <= n; ++i) { if (a[i] * 2 == t) { printf( %d , flag); flag = 1 - flag; } else { printf( %d , mp[a[i]]); } } printf( n ); } } return 0; } |
#include <bits/stdc++.h> using namespace std; const int maxn = 1000010; int dp[maxn][2]; int n, cnt = 1, head[maxn], to[maxn], nxt[maxn], val[maxn]; inline void add(int x, int y, int z) { nxt[++cnt] = head[x]; head[x] = cnt; to[cnt] = y; val[cnt] = z; } void dfs(int x, int fa) { for (int i = head[x]; i; i = nxt[i]) { if (to[i] == fa) continue; dfs(to[i], x); dp[x][0] += dp[to[i]][0] + val[i]; } } void dfs1(int x, int fa) { for (int i = head[x]; i; i = nxt[i]) { if (to[i] == fa) continue; dp[to[i]][1] = dp[x][0] - dp[to[i]][0] - val[i] + dp[x][1] + val[i ^ 1]; dfs1(to[i], x); } } int st[maxn], top; int main() { cin >> n; for (int i = 1, x, y; i < n; ++i) { cin >> x >> y; add(x, y, 0); add(y, x, 1); } dfs(1, 1); dfs1(1, 1); int tot = 1e9; for (int i = 1; i <= n; ++i) { tot = min(tot, dp[i][0] + dp[i][1]); } for (int i = 1; i <= n; ++i) { if (dp[i][0] + dp[i][1] == tot) { st[++top] = i; } } cout << tot << endl; for (int i = 1; i <= top; ++i) { cout << st[i] << ; } return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int T; cin >> T; while (T--) { int a, b, c; scanf( %d%d%d , &a, &b, &c); int temp = 0; if (a == b && b == c) { printf( 0 n ); } else { if (b > a) { temp = b; b = a; a = temp; } if (c > a) { temp = c; c = a; a = temp; } if (b >= c) { printf( %d n , max(2 * (a - c) - 4, 0)); } else { printf( %d n , max(2 * (a - b) - 4, 0)); } } } } |
#include <bits/stdc++.h> using namespace std; int fireball1, fireball2, health[100], attack[100], attack1[100]; int n, sum = 2e+8; void dfs(int x, int y) { if (y >= sum) return; if (x == n) { sum = y; for (int i = 1; i <= n; i++) attack[i] = attack1[i]; return; } for (int i = 0; i <= 100; i++) { if (y + i > sum) break; if (health[x - 1] - fireball2 * i >= 0) continue; if (x == n - 1) if (health[n] - fireball2 * i >= 0) continue; attack1[x] = i; health[x - 1] -= fireball2 * i; health[x] -= fireball1 * i; health[x + 1] -= fireball2 * i; dfs(x + 1, y + i); health[x - 1] += fireball2 * i; health[x] += fireball1 * i; health[x + 1] += fireball2 * i; if (health[x] - fireball1 * i < 0 && health[x + 1] - fireball2 * i < 0) break; } } int main() { scanf( %d%d%d , &n, &fireball1, &fireball2); for (int i = 1; i <= n; i++) scanf( %d , &health[i]); dfs(2, 0); printf( %d n , sum); for (int i = 2; i < n; i++) for (int j = 1; j <= attack[i]; j++) printf( %d , i); } |
#include <bits/stdc++.h> using namespace std; const int maxn = 300000 + 3000; int n, m; int a[maxn], l[maxn], r[maxn], pos[maxn]; struct Segtree { int l, r; int val; } node[maxn << 3]; inline int read() { int x; scanf( %d , &x); return x; } inline void build(int p, int l, int r) { node[p].l = l, node[p].r = r; node[p].val = 0; if (l == r) return; int mid = (l + r) >> 1; build(p << 1, l, mid); build(p << 1 | 1, mid + 1, r); } inline void update(int p) { node[p].val = node[p << 1].val + node[p << 1 | 1].val; } inline void change(int p, int vl, int vr, int c) { if (node[p].l == vl && node[p].r == vr) { node[p].val += c; return; } int mid = (node[p].l + node[p].r) >> 1; if (vr <= mid) change(p << 1, vl, vr, c); else change(p << 1 | 1, vl, vr, c); update(p); } inline int query(int p, int vl, int vr) { if (node[p].l == vl && node[p].r == vr) return node[p].val; int mid = (node[p].l + node[p].r) >> 1; if (vr <= mid) return query(p << 1, vl, vr); else if (vl > mid) return query(p << 1 | 1, vl, vr); else return query(p << 1, vl, mid) + query(p << 1 | 1, mid + 1, vr); } int main() { n = read(), m = read(); build(1, 1, n + m); for (int i = 1; i <= n; ++i) change(1, m + i, m + i, 1), pos[i] = m + i, l[i] = r[i] = i; for (int i = 1; i <= m; ++i) { scanf( %d , &a[i]); l[a[i]] = min(1, l[a[i]]); r[a[i]] = max(r[a[i]], query(1, 1, pos[a[i]])); change(1, pos[a[i]], pos[a[i]], -1); pos[a[i]] = m - i + 1; change(1, pos[a[i]], pos[a[i]], 1); } for (int i = 1; i <= n; ++i) { r[i] = max(r[i], query(1, 1, pos[i])); printf( %d %d n , l[i], r[i]); } return 0; } |
#include <bits/stdc++.h> using namespace std; inline int read() { char c = getchar(); int x = 0; bool f = 0; for (; !isdigit(c); c = getchar()) f ^= !(c ^ 45); for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48); if (f) x = -x; return x; } int n, m, k, s; vector<int> e[200005]; vector<int> dfn, res[200005]; bool vis[200005]; void dfs(int u) { vis[u] = 1; dfn.push_back(u); for (auto v : e[u]) if (!vis[v]) dfs(v), dfn.push_back(u); } signed main() { n = read(), m = read(), k = read(), s = ceil(2.0 * n / k); for (register int i = (1); i <= (m); ++i) { int u = read(), v = read(); e[u].push_back(v), e[v].push_back(u); } dfs(1); for (register int i = (0); i <= ((int)dfn.size() - 1); ++i) res[i / s + 1].push_back(dfn[i]); for (register int i = (1); i <= (k); ++i) { if (!res[i].size()) res[i].push_back(1); cout << res[i].size() << ; for (auto x : res[i]) cout << x << ; puts( ); } return 0; } |
#include <bits/stdc++.h> using namespace std; struct sb { long long x; long long y; bool operator<(const sb &wakaka) const { return x < wakaka.x; } } test; set<sb> node; int main() { long long x; cin >> x; long long len = 2 * pow((double)x, (double)1 / (double)3); long long cnt = 0; long long n = 0; while (1) { n++; if (n > len) break; long long en = x * 6; long long i2 = (n - 1) * n * (2 * n - 1); en = en - i2; long long he = (n - 1) * n * 3; en = en + he * n; long long la = 6 * n * n - he; if (en % la == 0) { long long ans = en / la; test.x = n; test.y = ans; if (ans < n) break; node.insert(test); test.y = n; test.x = ans; node.insert(test); cnt = cnt + 2; } } cout << node.size() << endl; for (set<sb>::iterator it = node.begin(); it != node.end(); it++) { test = *it; cout << test.x << << test.y << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; using namespace std; int n, a, b, ans; int main() { cin >> n; while (n--) { cin >> a >> b; a++, b--; while (b /= 4) a++; ans = max(ans, a); } cout << ans; } |
#include <bits/stdc++.h> #pragma GCC optimize( Ofast ) #pragma GCC target( avx2 ) #pragma GCC optimization( O3 ) #pragma GCC optimization( unroll-loops ) using namespace std; const int N = 30 + 7; const int mod = 1e9 + 7; const int B = 317; int n; int u, r; int a[N][N]; int b[N]; int c[N]; int p[N]; long long foo(int x, bool f) { long long s = -1e18; if (x % 2 == 0) { s = 0; for (int i = 1; i <= n; i++) s += a[x][i] * 1LL * c[i]; } if (x == 0) return s; if (f) { for (int i = 1; i <= n; i++) { a[x - 1][i] = a[x][i] ^ b[i]; } s = max(s, foo(x - 1, false)); } for (int i = 1; i <= n; i++) { a[x - 1][i] = a[x][p[i]] + r; } s = max(s, foo(x - 1, true)); return s; } int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); cin >> n >> u >> r; for (int i = 1; i <= n; i++) cin >> a[u][i]; for (int i = 1; i <= n; i++) cin >> b[i]; for (int i = 1; i <= n; i++) cin >> c[i]; for (int i = 1; i <= n; i++) cin >> p[i]; cout << foo(u, true); } |
#include <bits/stdc++.h> using namespace std; long long ans; int n, l, w, x, pn; vector<int> pos, neg; int cal(long long a, int b) { if (b == 0) return (a > 0 ? INT_MAX : -INT_MAX); if (a < 0) { if (a % b != 0) return (a / b - 1); } return a / b; } int main() { ios::sync_with_stdio(false); scanf( %d%d%d , &n, &l, &w); for (int i = 1; i <= n; i++) { scanf( %d%d , &x, &pn); if (pn == -1) neg.push_back(x); else pos.push_back(x); } sort(neg.begin(), neg.end()); sort(pos.begin(), pos.end()); for (int i = 0; i < neg.size(); i++) { int v = neg[i]; auto now = lower_bound(pos.begin(), pos.end(), -v - l); int max1 = cal((long long)(v + l) * (w + 1) - 1, w - 1); int max2 = cal((long long)(v + l) * (w - 1) - 1, w + 1); ans += (upper_bound(pos.begin(), now, max1) - pos.begin()) + (upper_bound(now, pos.end(), min(max2, v)) - now); } cout << ans << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; map<pair<int, int>, int> mp; set<int> s; int m; pair<int, int> p[100001]; long long ans; const long long md = 1e9 + 9; int up[3][2] = {-1, 1, 0, 1, 1, 1}; int dwn[3][2] = {-1, -1, 0, -1, 1, -1}; int cnt(int ind) { int res = 0; int x = p[ind].first, y = p[ind].second; for (int i = 0; i < 3; i++) { int xx = x + dwn[i][0], yy = y + dwn[i][1]; if (mp.find(make_pair(xx, yy)) != mp.end()) res++; } return res; } bool chk(int ind) { int x = p[ind].first, y = p[ind].second; for (int i = 0; i < 3; i++) { int xx = x + up[i][0], yy = y + up[i][1]; if (mp.find(make_pair(xx, yy)) != mp.end()) { int d = mp[make_pair(xx, yy)]; if (cnt(d) <= 1) { return false; } } } return true; } void work(int ind) { ans = (ans * (long long)m % md + ind) % md; int x = p[ind].first, y = p[ind].second; mp.erase(make_pair(x, y)); for (int i = 0; i < 3; i++) { int xx = x + dwn[i][0], yy = y + dwn[i][1]; if (mp.find(make_pair(xx, yy)) != mp.end()) { int d = mp[make_pair(xx, yy)]; if (chk(d)) { s.insert(d); } } } } void mx() { set<int>::iterator it; int x; while (!s.empty()) { it = s.end(); it--; if (chk(*it)) { x = *it; s.erase(it); break; } s.erase(it); } work(x); } void mn() { set<int>::iterator it; int x; while (!s.empty()) { it = s.begin(); if (chk(*it)) { x = *it; s.erase(it); break; } s.erase(it); } work(x); } int main() { scanf( %d , &m); for (int i = 0; i < m; i++) { scanf( %d%d , &p[i].first, &p[i].second); mp[make_pair(p[i].first, p[i].second)] = i; s.insert(i); } for (int i = 0; i < m; i++) { if (i & 1) mn(); else mx(); } printf( %lld , ans); return 0; } |
#include <bits/stdc++.h> using namespace std; const long long maxn = 50050; const long long bign = 55000; long long n, m; long long tmp[bign], judge[bign]; long long ans, head[maxn], sz[maxn], maxp[maxn]; long long dis[bign], size; long long q[bign], targetnum; long long rt, tot, vis[maxn]; struct edge { long long next, to, dis; } e[maxn * 2]; inline void addedge(long long next, long long to, long long dis) { e[++size].to = to; e[size].dis = dis; e[size].next = head[next]; head[next] = size; } void getzx(long long t, long long fat) { long long i, j; maxp[t] = sz[t] = 1; for (i = head[t]; i; i = e[i].next) { j = e[i].to; if (j == fat || vis[j]) continue; getzx(j, t); sz[t] += sz[j]; maxp[t] = max(maxp[t], sz[j]); } maxp[t] = max(maxp[t], tot - sz[t]); if (maxp[t] < maxp[rt]) rt = t; } inline void getdis(long long t, long long fat) { long long i, j, k; tmp[++tmp[0]] = dis[t]; for (i = head[t]; i; i = e[i].next) { j = e[i].to; k = e[i].dis; if (j == fat || vis[j]) continue; dis[j] = dis[t] + k; getdis(j, t); } } inline void calc(long long t) { long long i, j, k, l, p = 0; for (i = head[t]; i; i = e[i].next) { j = e[i].to; k = e[i].dis; if (vis[j]) continue; dis[j] = k; tmp[0] = 0; getdis(j, t); for (k = tmp[0]; k; k--) if (targetnum >= tmp[k]) ans += judge[targetnum - tmp[k]]; for (k = tmp[0]; k; k--) { q[++p] = tmp[k]; judge[tmp[k]]++; } } for (k = p; k; k--) judge[k] = 0; } inline void solve(long long t) { long long i, j; vis[t] = judge[0] = 1; calc(t); for (i = head[t]; i; i = e[i].next) { j = e[i].to; if (vis[j]) continue; tot = sz[j]; maxp[rt = 0] = 0x3f3f3f3f; getzx(j, 0); solve(rt); } } signed main() { ios::sync_with_stdio(false); register long long i, j; cin >> n >> targetnum; long long t1, t2; for (i = 1; i < n; i++) { cin >> t1 >> t2; addedge(t1, t2, 1); addedge(t2, t1, 1); } maxp[rt = 0] = 0x3f3f3f3f; tot = n; getzx(1, 0); solve(rt); cout << ans << endl; } |
#include <bits/stdc++.h> using namespace std; const int maxn = 12, mod = 1e9 + 7; long long dp[maxn][2][maxn]; int num[maxn]; long long dfs(int pos, bool bnd, int ned) { if (ned < 0) return 0; if (pos < 0) return ned == 0; long long& ndp = dp[pos][bnd][ned]; if (~ndp) return ndp; ndp = 0; int bound = bnd ? num[pos] : 9; for (int i = 0; i <= bound; i++) ndp += dfs(pos - 1, bnd && i == bound, ned - (i == 4 || i == 7)); return ndp; } long long cnt[maxn]; int init(long long x) { int len = 0; while (x) { num[len++] = x % 10; x /= 10; } memset(dp, -1, sizeof(dp)); for (int i = len; i >= 0; i--) { cnt[i] = dfs(len - 1, true, i); } cnt[0]--; return len; } long long ans; void dfs(int st, long long v, int len, int adder) { if (st == 7) { for (int i = adder + 1; i <= len; i++) { (ans += v * cnt[i] % mod) %= mod; } return; } if (adder >= len) return; for (int i = 0; i <= len; i++) { if (cnt[i] == 0) continue; long long mid = v * cnt[i] % mod; cnt[i]--; dfs(st + 1, mid, len, adder + i); cnt[i]++; } } int main() { long long n; scanf( %I64d , &n); int len = init(n); ans = 0; dfs(1, 1, len, 0); printf( %I64d n , ans); return 0; } |
#include <bits/stdc++.h> using namespace std; int arr[100][100]; bool dp[100][100][1000]; bool W[100][100][1000]; int main() { int N; int M; int K; scanf( %d %d %d , &N, &M, &K); K++; char ch[101]; for (int n = 0; n < N; n++) { scanf( %s , ch); for (int m = 0; m < M; m++) { arr[n][m] = ch[m] - 0 ; } } memset(dp, false, sizeof(dp)); for (int m = 0; m < M; m++) { dp[N - 1][m][arr[N - 1][m]] = true; } for (int n = N - 2; n >= 0; n--) { for (int m = 0; m < M; m++) { int y[] = {n + 1, n + 1}; int x[] = {m - 1, m + 1}; for (int pos = 0; pos < 2; pos++) { int Y = y[pos]; int X = x[pos]; if (Y >= 0 && Y < N && X >= 0 && X < M) { for (int k = 0; k < 1000; k++) { if (dp[Y][X][k]) { dp[n][m][k + arr[n][m]] = true; W[n][m][k + arr[n][m]] = pos; } } } } } } int sol = -1; int pos = -1; for (int k = 0; k < 1000; k += K) { for (int m = 0; m < M; m++) { if (dp[0][m][k]) { sol = k; pos = m; } } } printf( %d n , sol); if (sol != -1) { int help = sol; stack<int> st; for (int n = 0; n < N - 1; n++) { st.push(W[n][pos][help]); if (W[n][pos][help] == 0) { help -= arr[n][pos]; pos--; } else { help -= arr[n][pos]; pos++; } } printf( %d n , pos + 1); while (!st.empty()) { if (st.top() == 0) { printf( R ); } else { printf( L ); } st.pop(); } printf( n ); } return 0; } |
#include <bits/stdc++.h> using namespace std; long len; string a, b; const long long mo = 1000000007; long long good[200001], bad[200001]; int x, y, n; int main() { cin >> a >> b >> n; if (a.length() != b.length()) { cout << 0; return 0; } len = a.length(); bool f; for (int i = 0; i < len; i++) { f = false; for (int j = 0; j < len; j++) { if (b[j] != b[(j + i) % len]) { f = true; break; } } if (f == false) { x++; } else { y++; } } if (a == b) { good[0] = 1; bad[0] = 0; } else { good[0] = 0; bad[0] = 1; } f = false; b = b + b; bool p; for (int i = 0; i < len; i++) { p = false; for (int j = 0; j < len; j++) { if (b[j + i] != a[j]) { p = true; break; } } if (p == false) { f = true; break; } } if (f == false) { cout << 0; return 0; } for (int i = 1; i <= n; i++) { good[i] = ((good[i - 1] % mo) * ((x - 1) % mo) + (bad[i - 1] * x) % mo) % mo; bad[i] = ((good[i - 1] % mo) * (y % mo) + (bad[i - 1] % mo) * ((y - 1) % mo)) % mo; } for (int i = 1; i <= n; i++) { } cout << good[n] % mo; return 0; } |
#include <bits/stdc++.h> using namespace std; const int maxn = 1e3 + 5; unordered_map<bitset<maxn>, int> ma, flag; bitset<maxn> s[35]; int t1, t2; void dfs1(bitset<maxn> z, int cost, int pos) { if (pos > t1 + t2) { if (flag[z] == 0) ma[z] = cost; else ma[z] = min(ma[z], cost); flag[z] = 1; return; } dfs1(z ^ s[pos], cost + 1, pos + 1); dfs1(z, cost, pos + 1); } int dfs2(bitset<maxn> z, int cost, int pos) { int res = 1e9; if (flag[z] != 0) res = cost + ma[z]; if (pos <= t1) { res = min(res, dfs2(z ^ s[pos], cost + 1, pos + 1)); res = min(res, dfs2(z, cost, pos + 1)); } return res; } int main() { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); int n, m, d; cin >> n >> m >> d; t1 = m / 3; t2 = m - t1; for (int i = 1; i <= m; i++) { int cnt; cin >> cnt; for (int j = 1; j <= cnt; j++) { int x; cin >> x; s[i][x] = 1; } } bitset<maxn> tmp; dfs1(tmp, 0, t1 + 1); while (d--) { int cnt; cin >> cnt; bitset<maxn> q; for (int i = 1; i <= cnt; i++) { int x; cin >> x; q[x] = 1; } int ans = dfs2(q, 0, 1); if (ans == 1e9) cout << -1 << n ; else cout << ans << n ; } return 0; } |
#include <bits/stdc++.h> using namespace std; constexpr int maxn = 3e3 + 4; struct Node { int la, nx; } nodes[maxn]; int X[maxn], Y[maxn]; std::vector<int> yp[maxn]; int R, C, N, K; int ordX[maxn], ord[maxn]; int ans[maxn], xans = 0; inline void update(int x) { int c = x; for (int k = 1; k < K && c; ++k) c = nodes[c].nx; xans -= ans[x]; if (!nodes[x].la) ans[x] = X[c] * (R + 1 - X[x]); else ans[x] = X[c] * (X[nodes[x].la] - X[x]); xans += ans[x]; } int main() { cin >> R >> C >> N >> K; for (int i = 1; i <= N; ++i) { cin >> X[i] >> Y[i]; yp[Y[i]].push_back(i); } iota(ordX + 1, ordX + N + 1, 1); sort(ordX + 1, ordX + N + 1, [&](int a, int b) { return X[a] > X[b]; }); long long rans = 0; for (int ups = 1; ups <= C; ++ups) { xans = 0; memset(ans, 0, sizeof(ans)); int cn = 0; for (int i = 1; i <= N; ++i) { if (Y[ordX[i]] >= ups) ord[++cn] = ordX[i]; } memset(nodes, 0, sizeof(nodes)); for (int i = 1; i <= cn; ++i) { nodes[ord[i]].la = ord[i - 1]; nodes[ord[i - 1]].nx = ord[i]; } for (int i = 1; i <= cn; ++i) update(ord[i]); rans += xans; for (int i = C; i > ups; --i) { for (int j : yp[i]) { nodes[nodes[j].la].nx = nodes[j].nx; nodes[nodes[j].nx].la = nodes[j].la; } for (int j : yp[i]) { for (int k = 1, c = nodes[j].la; k < K && c; ++k, c = nodes[c].la) update(c); if (nodes[j].nx) update(nodes[j].nx); xans -= ans[j]; } rans += xans; } } cout << rans << endl; return 0; } |
#include <bits/stdc++.h> #pragma comment(linker, /stack:247474112 ) #pragma GCC optimize( Ofast ) using namespace std; string ans[2] = { Bob , Alice }; void solve() { long long n, k; cin >> n >> k; if (k % 3 != 0) { if (n % 3) cout << ans[1]; else cout << ans[0]; return; } long long per_cycle = (k / 3 - 1) * 3 + 4; n %= per_cycle; if (n == 0) n = per_cycle; if (n <= (k / 3 - 1) * 3) { if (n % 3) cout << ans[1]; else cout << ans[0]; } else { n -= (k / 3 - 1) * 3; if (n != 4) cout << ans[1]; else cout << ans[0]; } } int32_t main() { ios::sync_with_stdio(0), cin.tie(0), cout.tie(0); long long t; cin >> t; while (t--) { solve(); cout << n ; } return 0; } |
#include <bits/stdc++.h> using namespace std; const int maxn = 3000 + 50; const int maxm = 3000 + 50; const int maxt = 3000000 + 100; const int maxk = 10 + 3; const long long unit = 1LL; const int INF = 0x3f3f3f3f; const long long Inf = 0x3f3f3f3f3f3f3f3fLL; const double eps = 1e-3; const double inf = 1e15; const double pi = acos(-1.0); const long long mod = 1000000007LL; inline long long read() { long long x = 0; bool t = false; char ch = getchar(); while ((ch < 0 || ch > 9 ) && ch != - ) ch = getchar(); if (ch == - ) t = true, ch = getchar(); while (ch <= 9 && ch >= 0 ) x = x * 10 + ch - 48, ch = getchar(); return t ? -x : x; } inline long long add(long long x, long long y) { return x + y >= mod ? x + y - mod : x + y; } inline long long sub(long long x, long long y) { return x < y ? x - y + mod : x - y; } inline long long mul(long long x, long long y) { return x * y - x * y / mod * mod; } struct EasyMath { inline long long Quick_Pow(long long a, long long b) { long long sum = 1; for (; b; b >>= 1, a = (long long)a * a % mod) if (b & 1) sum = sum * a % mod; return sum; } inline long long inv(long long x) { return Quick_Pow(x, mod - 2); } } em; long long n, d; long long f[maxn][maxn], g[maxn], s[maxn][maxn], C[maxn][maxn]; long long inv[maxn], fac[maxn], ifac[maxn]; void GetInv(int n) { inv[1] = fac[0] = fac[1] = ifac[0] = ifac[1] = 1; for (register int i = (2); i <= (n); ++i) { inv[i] = ((mod - mod / i)) * inv[mod % i] % mod; fac[i] = fac[i - 1] * i % mod; ifac[i] = ifac[i - 1] * inv[i] % mod; } } struct Edge { int to, next; } edge[maxm]; int tot, head[maxn]; void init() { tot = 1; memset(head, 0, sizeof(head)); } void AddEdge(int u, int v) { edge[tot] = (Edge){v, head[u]}; head[u] = tot++; } void dfs(int u) { for (int i = head[u]; i; i = edge[i].next) { int v = edge[i].to; dfs(v); for (int j = 1; j <= n; ++j) (f[u][j] *= s[v][j]) %= mod; } for (int j = 1; j <= n; ++j) s[u][j] = (s[u][j - 1] + f[u][j]) % mod; } inline long long CC(long long n, long long m) { long long ans = 1; for (long long i = 0; i < m; ++i) (ans *= ((n - i) * inv[i + 1]) % mod) %= mod; return ans; } int main() { init(); n = read(), d = read(); GetInv(n + 10); C[0][0] = 1; for (register int i = (1); i <= (n); ++i) { C[i][0] = C[i][i] = 1; for (register int j = (1); j <= (n); ++j) { f[i][j] = 1; } for (register int j = (1); j <= (i - 1); ++j) { C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod; } } int x; for (register int i = (2); i <= (n); ++i) { x = read(); AddEdge(x, i); } dfs(1); for (register int j = (1); j <= (n); ++j) { g[j] = f[1][j]; for (register int i = (1); i <= (j - 1); ++i) { g[j] = ((g[j] - C[j - 1][j - i] * g[i] % mod) % mod + mod) % mod; } } long long ans = 0; for (register int i = (1); i <= (min(n, d)); ++i) { (ans += CC(d, i) * g[i] % mod) %= mod; } printf( %lld n , ans); return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; int a[n]; for (int i = 0; i < n; i++) { cin >> a[i]; } sort(a, a + n); for (int i = 0; i < n - 2; i++) { if (a[i] == a[i + 1] && a[i] == a[i + 2]) { cout << NO ; return 0; } } cout << YES << endl; vector<int> v1, v2; v1.push_back(a[0]); for (int i = 1; i < n; i++) { if (a[i] != a[i - 1]) v1.push_back(a[i]); else v2.push_back(a[i]); } int p = v1.size(); int r = v2.size(); cout << p << endl; for (int i = 0; i < p; i++) { cout << v1[i] << ; } cout << endl; cout << r << endl; for (int i = r - 1; i >= 0; i--) { cout << v2[i] << ; } } |
#include <bits/stdc++.h> using namespace std; int n; int maxt[5210][5210]; int a[5210][5210]; char str[5210]; int getn(char ch) { if (ch >= 0 && ch <= 9 ) { return ch - 0 ; } else { return 10 + ch - A ; } } int main() { scanf( %d , &n); memset(maxt, 0, sizeof(maxt)); for (int i = 1; i <= n; i++) { scanf( %s , str + 1); int In = 0, len = strlen(str + 1); for (int j = len; j >= 1; j--) { int N = getn(str[j]); int Jn = 0; while (N) { a[i][n - In - Jn] = N % 2; N /= 2; Jn++; } for (; Jn < 4; Jn++) { if (n - In - Jn == 0) { break; } a[i][n - In - Jn] = 0; } In += Jn; } for (int j = n - In; j >= 1; j--) { a[i][j] = 0; } } for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { maxt[i][j] = a[i][j] + maxt[i - 1][j] + maxt[i][j - 1] - maxt[i - 1][j - 1]; } } for (int I = n; I >= 1; I--) { if (n % I == 0) { int flag = 1; for (int i = 1; i <= (n / I); i++) { for (int j = 1; j <= (n / I); j++) { int cnt = maxt[i * I][j * I] - maxt[(i - 1) * I][j * I] - maxt[i * I][(j - 1) * I] + maxt[(i - 1) * I][(j - 1) * I]; if (cnt != I * I * a[i * I][j * I]) { flag = 0; break; } } if (!flag) { break; } } if (flag) { printf( %d n , I); break; } } } return 0; } |
#include <bits/stdc++.h> using namespace std; using namespace std; const long long MOD = 1e9 + 7; const int INF = 1e9; int n, k, mn, mx, ans = INF; int a[8] = {0, 1, 2, 3, 4, 5, 6, 7}; char s[8][10]; int main() { ios::sync_with_stdio(0); cin.tie(0); cin >> n >> k; for (int i = 0; i < n; i++) cin >> s[i]; int num; do { mn = 1e9; mx = 0; for (int i = 0; i < n; i++) { num = 0; for (int j = 0; j < k; j++) num = num * 10 + (s[i][a[j]] - 0 ); if (mn > num) mn = num; if (mx < num) mx = num; } if (mx - mn < ans) ans = mx - mn; } while (next_permutation(a, a + k)); cout << ans << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; const int N = 1e4 + 4; long long int a[N][20], pre[N][20], ans; struct node { node *left, *right; long long int cnt; node() { left = NULL; right = NULL; cnt = 0; } }; struct trie { node *x; }; void insert(node *t, long long int x) { for (long long int i = 31; i >= 0; i--) { if (x & (1 << i)) { if (t->right == NULL) t->right = new node(); t = t->right; t->cnt++; } else { if (t->left == NULL) t->left = new node(); t = t->left; t->cnt++; } } } void del(node *t, long long int x) { for (long long int i = 31; i >= 0; i--) { if (x & (1 << i)) { t = t->right; t->cnt--; } else { t = t->left; t->cnt--; } } } long long int query(node *t, long long int x) { long long int ret = 0; for (long long int i = 31; i >= 0; i--) { if (x & (1 << i)) { if (t->left && t->left->cnt != 0) { ret |= (1 << i); t = t->left; } else t = t->right; } else { if (t->right && t->right->cnt != 0) { ret |= (1 << i); t = t->right; } else t = t->left; } } return ret; } int main() { ios_base::sync_with_stdio(false); cin.tie(0); trie t; t.x = new node(); long long int n; cin >> n; insert(t.x, 0); for (long long int i = 1; i <= n; i++) { char ch; cin >> ch; long long int x; cin >> x; if (ch == + ) insert(t.x, x); if (ch == - ) del(t.x, x); if (ch == ? ) cout << query(t.x, x) << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; const int N = 100004; long long a[N], b[N]; int n, p = 0; long long fun(int n) { long long ans = 0, sum = 0; for (int i = 1; i <= n; i++) { sum += b[i]; if (sum < 0) sum = 0; ans = max(ans, sum); } return ans; } int main() { long long ans = 0; scanf( %d , &n); for (int i = 1; i <= n; i++) scanf( %lld , &a[i]); for (int i = 1; i < n; i++) a[i] = ((a[i + 1] - a[i]) > 0 ? (a[i + 1] - a[i]) : -(a[i + 1] - a[i])); --n; for (int i = 1; i <= n; i++) b[i] = i & 1 ? a[i] : -a[i]; ans = fun(n); for (int i = 2; i <= n; i++) b[++p] = i & 1 ? -a[i] : a[i]; ans = max(ans, fun(p)); printf( %lld n , ans); } |
#include <bits/stdc++.h> using namespace std; int A[55]; int main() { int n; long long int m; cin >> n >> m; if (n == 1) { printf( %d n , 1); return 0; } long long int tot = 1LL << (n - 1); int l = 1; int r = n; for (int i = 1; i < n + 1; i++) { if (m > tot / 2) { A[r] = i; m -= tot / 2; r--; } else { A[l] = i; l++; } tot /= 2; } for (int i = 1; i < n + 1; i++) { printf( %d , A[i]); } return 0; } |
#include <bits/stdc++.h> using namespace std; long long n, m, k, sum, num, ans; long long a[200005]; int main() { cin >> n >> m >> k; for (int i = 1; i <= m; i++) cin >> a[i]; sort(a + 1, a + m + 1); sum = 0, num = 1, ans = 1; for (int i = 2; i <= m; i++) { if ((a[i] - 1 - sum) / k != (a[i - 1] - 1 - sum) / k) { ans++; sum += num; num = 1; } else num++; } cout << ans; return 0; } |
#include <bits/stdc++.h> using namespace std; long long dx[8] = {0, 1, 0, -1, 1, 1, -1, -1}; long long dy[8] = {1, 0, -1, 0, -1, 1, 1, -1}; class pa3 { public: long long x; long long y, z; pa3(long long x = 0, long long y = 0, long long z = 0) : x(x), y(y), z(z) {} bool operator<(const pa3& p) const { if (x != p.x) return x < p.x; if (y != p.y) return y < p.y; return z < p.z; } bool operator>(const pa3& p) const { if (x != p.x) return x > p.x; if (y != p.y) return y > p.y; return z > p.z; } bool operator==(const pa3& p) const { return x == p.x && y == p.y && z == p.z; } bool operator!=(const pa3& p) const { return !(x == p.x && y == p.y && z == p.z); } }; class pa4 { public: long long x; long long y, z, w; pa4(long long x = 0, long long y = 0, long long z = 0, long long w = 0) : x(x), y(y), z(z), w(w) {} bool operator<(const pa4& p) const { if (x != p.x) return x < p.x; if (y != p.y) return y < p.y; if (z != p.z) return z < p.z; return w < p.w; } bool operator>(const pa4& p) const { if (x != p.x) return x > p.x; if (y != p.y) return y > p.y; if (z != p.z) return z > p.z; return w > p.w; } bool operator==(const pa4& p) const { return x == p.x && y == p.y && z == p.z && w == p.w; } }; class pa2 { public: long long x, y; pa2(long long x = 0, long long y = 0) : x(x), y(y) {} pa2 operator+(pa2 p) { return pa2(x + p.x, y + p.y); } pa2 operator-(pa2 p) { return pa2(x - p.x, y - p.y); } bool operator<(const pa2& p) const { return y != p.y ? y < p.y : x < p.x; } bool operator>(const pa2& p) const { return x != p.x ? x < p.x : y < p.y; } bool operator==(const pa2& p) const { return abs(x - p.x) == 0 && abs(y - p.y) == 0; } bool operator!=(const pa2& p) const { return !(abs(x - p.x) == 0 && abs(y - p.y) == 0); } }; string itos(long long i) { ostringstream s; s << i; return s.str(); } long long Gcd(long long v, long long b) { if (v == 0) return b; if (b == 0) return v; if (v > b) return Gcd(b, v); if (v == b) return b; if (b % v == 0) return v; return Gcd(v, b % v); } long long extgcd(long long a, long long b, long long& x, long long& y) { if (b == 0) { x = 1; y = 0; return a; } long long d = extgcd(b, a % b, y, x); y -= a / b * x; return d; } pair<long long, long long> operator+(const pair<long long, long long>& l, const pair<long long, long long>& r) { return {l.first + r.first, l.second + r.second}; } pair<long long, long long> operator-(const pair<long long, long long>& l, const pair<long long, long long>& r) { return {l.first - r.first, l.second - r.second}; } ostream& operator<<(ostream& os, const vector<long long>& VEC) { for (auto v : VEC) os << v << ; return os; } ostream& operator<<(ostream& os, const pair<long long, long long>& PAI) { os << PAI.first << : << PAI.second; return os; } ostream& operator<<(ostream& os, const pa3& PAI) { os << PAI.x << : << PAI.y << : << PAI.z; return os; } ostream& operator<<(ostream& os, const pa4& PAI) { os << PAI.x << : << PAI.y << : << PAI.z << : << PAI.w; return os; } ostream& operator<<(ostream& os, const vector<pair<long long, long long> >& VEC) { for (auto v : VEC) os << v << ; return os; } ostream& operator<<(ostream& os, const vector<pa3>& VEC) { for (auto v : VEC) { os << v << ; os << endl; } return os; } long long beki(long long wa, long long rr, long long warukazu) { if (rr == 0) return 1 % warukazu; if (rr == 1) return wa % warukazu; wa %= warukazu; if (rr % 2 == 1) return ((long long)beki(wa, rr - 1, warukazu) * (long long)wa) % warukazu; long long zx = beki(wa, rr / 2, warukazu); return (zx * zx) % warukazu; } long long pr[2521000]; long long inv[2521000]; const long long mod = 998244353; long long comb(long long nn, long long rr) { if (nn == -1 && rr == -1) return 1; if (rr < 0 || rr > nn || nn < 0) return 0; long long r = pr[nn] * inv[rr]; r %= mod; r *= inv[nn - rr]; r %= mod; return r; } void gya(long long ert) { pr[0] = 1; for (long long i = 1; i <= ert; i++) { pr[i] = ((long long)pr[i - 1] * i) % mod; } inv[ert] = beki(pr[ert], mod - 2, mod); for (long long i = ert - 1; i >= 0; i--) { inv[i] = (long long)inv[i + 1] * (i + 1) % mod; } } long long beki(long long a, long long b) { long long ANS = 1; long long be = a % mod; while (b) { if (b & 1) { ANS *= be; ANS %= mod; } be *= be; be %= mod; b /= 2; } return ANS; } struct segsum { private: public: long long cor = (1 << 20); vector<long long> vec; void shoki1() { vec.resize(2 * cor + 3, 0); } void shoki2() { for (long long i = cor - 1; i > 0; i--) vec[i] = vec[2 * i] + vec[2 * i + 1]; } void clear() { for (long long i = 0; i < (long long)vec.size(); i++) vec[i] = 0; } void updadd(long long x, long long w) { x += cor; vec[x] += w; x /= 2; while (x) { vec[x] = vec[2 * x] + vec[2 * x + 1]; x /= 2; } } void updchan(long long x, long long w) { x += cor; vec[x] = w; while (x) { x /= 2; vec[x] = vec[2 * x] + vec[2 * x + 1]; } } long long sum(long long a, long long b) { long long hi = 0, mi = 0; a += cor, b += cor; while (a < b) { if (a & 1) { hi = hi + vec[a]; a++; } if (b & 1) { b--; mi = vec[b] + mi; } a /= 2, b /= 2; } return hi + mi; } long long lower_bound(long long p, long long x) { p += cor; long long ima = 0; while (1) { while (!(p & 1)) p /= 2; if (ima + vec[p] >= x) break; ima = ima + vec[p]; p++; if (p == (p & (-p))) return cor; } while (1) { if (p >= cor) return p - cor; p *= 2; if (ima + vec[p] < x) { ima += vec[p]; p++; } } } long long upper_bound(long long p, long long x) { p += cor; long long ima = 0; while (1) { while (!(p & 1)) p /= 2; if (ima + vec[p] > x) break; ima = ima + vec[p]; p++; if (p == (p & (-p))) return cor; } while (1) { if (p >= cor) return p - cor; p *= 2; if (ima + vec[p] <= x) { ima += vec[p]; p++; } } } }; segsum ss; vector<long long> G[1000020]; vector<long long> ve[1000020]; long long hin[1000020]; long long iti[1000020]; vector<pa3> que[1000020]; long long a[1000020]; long long ans[1000002]; void ato(long long n) { for (long long i = 0; i <= n; i++) { G[i].clear(); } ve[0].clear(); } void tasu(long long r, long long d = 1) { long long h = hin[r]; long long k = ve[h].size(); long long s = ve[h].back(); if (r != s) { swap(ve[h][iti[r]], ve[h][k - 1]); swap(iti[r], iti[s]); } ve[h].pop_back(); ve[h + d].push_back(r); hin[r] = h + d; iti[r] = (long long)ve[h + d].size() - 1; ss.updadd(h, -1); ss.updadd(h + d, 1); } void dfs(long long r) { while (que[r].size()) { pa3 z = que[r].back(); que[r].pop_back(); long long l = z.x; long long k = z.y; long long e = ss.lower_bound(l, k); if (e == ss.cor) { ans[z.z] = -1; } else { ans[z.z] = ve[e][0]; } } for (auto v : G[r]) { tasu(a[v]); dfs(v); tasu(a[v], -1); } } void solve() { long long n; cin >> n; long long q; cin >> q; for (long long i = 1; i <= n; i++) cin >> a[i]; for (long long i = 2; i <= n; i++) { long long y; cin >> y; G[y].push_back(i); } for (long long i = 0; i < q; i++) { long long y, yy, yyy; cin >> y >> yy >> yyy; que[y].push_back(pa3(yy, yyy, i)); } for (long long i = 1; i <= n; i++) { ve[0].push_back(i); hin[i] = 0; iti[i] = i - 1; } tasu(a[1]); dfs(1); tasu(a[1], -1); for (long long i = 0; i < q; i++) cout << ans[i] << ; cout << endl; ato(n); } signed main() { cin.tie(0); ios::sync_with_stdio(false); ss.shoki1(); ss.shoki2(); long long n = 1; cin >> n; for (long long i = 0; i < n; i++) solve(); return 0; } |
#include<bits/stdc++.h> using namespace std; #define ff first #define ss second #define ll long long int #define ld long double #define pii pair<ll,ll> #define pb push_back #define rep(i,a,b) for(int i=a;i<b;i++) #define t(x) int t; cin>>t; while(t--) #define vi vector<int> #define mii map<int,int> #define min3(a, b, c) min(min(a, b), c) #define min4(a, b, c, d) min(min(a, b), min(c, d)) #define max3(a, b, c) max(max(a, b), c) #define max4(a, b, c, d) max(max(a, b), max(c, d)) #define ps(x,y) fixed<<setprecision(y)<<x #define setbits(x) __builtin_popcountll(x) #define zrobits(x) __builtin_ctzll(x) #define all(x) x.begin(),x.end() // #define M 1000000007 #define FIO ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0) mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); bool isPerfectSquare(ll x) { // Find floating point value of // square root of x. if (x >= 0) { long long sr = sqrt(x); // if product of square root //is equal, then // return T/F return (sr * sr == x); } // else return false if n<0 return false; } int main() { FIO; #ifndef ONLINE_JUDGE freopen( input.txt , r , stdin); freopen( output.txt , w , stdout); #endif t(x) { ll n; cin >> n; ll a[n]; ll check = 0; rep(i, 0, n) { cin >> a[i]; if (!isPerfectSquare(a[i])) check = 1; } if (check) cout << YES << endl; else cout << NO << endl; } } |
#include <bits/stdc++.h> using namespace std; long long int mod = 1000000007; long long int numOfPoints(long long int &x, long long int &y, long long int &n, long long int t) { long long int region1 = 2 * t * (t + 1) + 1; long long int region2; if (y - t >= 1) region2 = 0; else region2 = abs(y - t - 1) * abs(y - t - 1); long long int region3; if (y + t <= n) region3 = 0; else region3 = abs(n - y - t) * abs(n - y - t); long long int region4; if (x - t >= 1) region4 = 0; else region4 = abs(x - t - 1) * abs(x - t - 1); long long int region5; if (x + t <= n) region5 = 0; else region5 = abs(n - x - t) * abs(n - x - t); long long int region6; if (t >= (n + 1 - y) + (n + 1 - x)) region6 = (t - (n + 1 - y) - (n + 1 - x) + 1) * (t - (n + 1 - y) - (n + 1 - x) + 2) / 2; else region6 = 0; long long int region7; if (t >= (n + 1 - y) + (x - 0)) region7 = (t - (n + 1 - y) - (x - 0) + 1) * (t - (n + 1 - y) - (x - 0) + 2) / 2; else region7 = 0; long long int region8; if (t >= (y - 0) + (n + 1 - x)) region8 = (t - (y - 0) - (n + 1 - x) + 1) * (t - (y - 0) - (n + 1 - x) + 2) / 2; else region8 = 0; long long int region9; if (t >= (y - 0) + (x - 0)) region9 = (t - (y - 0) - (x - 0) + 1) * (t - (y - 0) - (x - 0) + 2) / 2; else region9 = 0; return region1 - region2 - region3 - region4 - region5 + region6 + region7 + region8 + region9; } int main() { long long int i, j, k, l, m, n, p, q, x, y, z, a, b, c, r, fs, ls, md; scanf( %lld , &n); scanf( %lld , &x); scanf( %lld , &y); scanf( %lld , &c); if (c == 1) { printf( 0 n ); return 0; } fs = 0, ls = 2000000007LL; while (fs + 1 < ls) { md = (fs + ls) / 2; if (c <= numOfPoints(x, y, n, md)) ls = md; else fs = md; } printf( %lld n , ls); return 0; } |
#include <bits/stdc++.h> using namespace std; ifstream in; ofstream out; const long long kk = 1000; const long long ml = kk * kk; const long long mod = ml * kk + 7; const long long inf = ml * ml * ml + 7; long long n, i, j; vector<long long> m; vector<long long> bef[10 * kk]; bool viv = false; int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); cin >> n; for (i = 0; i < n - 1; i++) { long long a, b; cin >> a >> b; a--; b--; if (a != n - 1 && b != n - 1 || (a == b)) { cout << NO ; return 0; } if (a > b) swap(a, b); m.push_back(a); } sort(m.begin(), m.end()); vector<long long> kol(n, 0); for (auto i : m) kol[i]++; for (i = 0; i < n; i++) if (kol[i] > i + 1) { cout << NO ; return 0; } vector<long long> st; vector<pair<long long, long long> > re; for (i = 0; i < n - 1; i++) { if (kol[i] == 0) st.push_back(i); if (kol[i] - 1 > st.size()) { cout << NO ; return 0; } if (kol[i] > 0) { long long j = kol[i] - 1; bef[i].push_back(n - 1); while (j) { bef[i].push_back(st.back()); st.pop_back(); j--; } } } for (i = 0; i < n; i++) if (!bef[i].empty()) { for (j = 1; j < bef[i].size(); j++) re.push_back({bef[i][j - 1], bef[i][j]}); re.push_back({i, bef[i].back()}); } cout << YES << endl; for (auto i : re) cout << i.second + 1 << << i.first + 1 << n ; return 0; } |
#include <bits/stdc++.h> using namespace std; const int N = 330000; int a[N], m; long long dp[5500][5500]; int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); int n, k; cin >> n >> k; for (int i = 1; i <= n; i++) cin >> a[i]; sort(a + 1, a + n + 1); m = n / k; int b = k - n % k, c = n % k; for (int i = 0; i < 66; i++) for (int j = 0; j < 66; j++) dp[i][j] = LLONG_MIN; long long tot = 0; for (int i = 1; i < n; i++) tot += abs(a[i + 1] - a[i]); for (int i = 0; i <= b; i++) { for (int j = 0; j <= c; j++) { if (i == 0 && j == 0) { dp[i][j] = 0; continue; } if (i == 1 && j == 0) { dp[i][j] = 0; continue; } if (i == 0 && j == 1) { dp[i][j] = 0; continue; } if (i) dp[i][j] = max(dp[i][j], dp[i - 1][j] + abs(a[m * (i - 1) + (m + 1) * j] - a[m * (i - 1) + (m + 1) * j + 1])); if (j) dp[i][j] = max(dp[i][j], dp[i][j - 1] + abs(a[m * i + (m + 1) * (j - 1)] - a[m * i + (m + 1) * (j - 1) + 1])); } } cout << tot - dp[b][c] << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; template <class T> void chmin(T &a, const T &b) { if (a > b) a = b; } template <class T> void chmax(T &a, const T &b) { if (a < b) a = b; } template <class T> using MaxHeap = priority_queue<T>; template <class T> using MinHeap = priority_queue<T, vector<T>, greater<T>>; template <class T> vector<T> vect(int len, T elem) { return vector<T>(len, elem); } template <class T, class U> ostream &operator<<(ostream &os, const pair<T, U> &p) { os << p.first << , << p.second; return os; } template <class T, class U> istream &operator>>(istream &is, pair<T, U> &p) { is >> p.first >> p.second; return is; } template <class T> ostream &operator<<(ostream &os, const vector<T> &vec) { for (int i = 0; i < vec.size(); i++) { os << vec[i]; if (i + 1 < vec.size()) os << ; } return os; } template <class T> istream &operator>>(istream &is, vector<T> &vec) { for (int i = 0; i < vec.size(); i++) is >> vec[i]; return is; } void fastio() { cin.tie(0); ios::sync_with_stdio(0); cout << fixed << setprecision(20); } template <int MOD> struct ModInt { long long val; ModInt() : val(0ll) {} ModInt(const long long &v) : val(((v % MOD) + MOD) % MOD) {} bool operator==(const ModInt &x) const { return val == x.val; } bool operator!=(const ModInt &x) const { return !(*this == x); } bool operator<(const ModInt &x) const { return val < x.val; } bool operator>(const ModInt &x) const { return val > x.val; } bool operator>=(const ModInt &x) const { return !(*this < x); } bool operator<=(const ModInt &x) const { return !(*this > x); } ModInt operator-() const { return ModInt(MOD - val); } ModInt inv() const { return this->pow(MOD - 2); } ModInt &operator+=(const ModInt &x) { if ((val += x.val) >= MOD) val -= MOD; return *this; } ModInt &operator-=(const ModInt &x) { if ((val += MOD - x.val) >= MOD) val -= MOD; return *this; } ModInt &operator*=(const ModInt &x) { (val *= x.val) %= MOD; return *this; } ModInt &operator/=(const ModInt &x) { return *this *= x.inv(); }; ModInt operator+(const ModInt &x) const { return ModInt(*this) += x; } ModInt operator-(const ModInt &x) const { return ModInt(*this) -= x; } ModInt operator*(const ModInt &x) const { return ModInt(*this) *= x; } ModInt operator/(const ModInt &x) const { return ModInt(*this) /= x; } friend istream &operator>>(istream &i, ModInt &x) { long long v; i >> v; x = v; return i; } friend ostream &operator<<(ostream &o, const ModInt &x) { o << x.val; return o; } ModInt pow(long long x) const { auto res = ModInt(1ll); auto b = *this; while (x) { if (x & 1) res *= b; x >>= 1; b *= b; } return res; } }; template <int MOD> ModInt<MOD> pow(ModInt<MOD> a, long long x) { ModInt<MOD> res = ModInt<MOD>(1ll); while (x) { if (x & 1) res *= a; x >>= 1; a *= a; } return res; } constexpr int MOD = 998244353; using mint = ModInt<MOD>; vector<mint> inv, fac, facinv; mint nCr(int n, int r) { assert(!(n < r)); assert(!(n < 0 || r < 0)); return fac[n] * facinv[r] * facinv[n - r]; } void init(int SIZE) { fac.resize(SIZE + 1); inv.resize(SIZE + 1); facinv.resize(SIZE + 1); fac[0] = inv[1] = facinv[0] = mint(1ll); for (int i = 1; i <= SIZE; i++) fac[i] = fac[i - 1] * mint(i); for (int i = 2; i <= SIZE; i++) inv[i] = mint(0ll) - mint(MOD / i) * inv[MOD % i]; for (int i = 1; i <= SIZE; i++) facinv[i] = facinv[i - 1] * inv[i]; return; } void solve() { int n; cin >> n; string s; cin >> s; long long l = 0; while (s[l] == s[0]) l++; long long r = 0; while (s[n - 1 - r] == s[n - 1]) r++; if (s[0] != s[n - 1]) { cout << (l + r + 1) % MOD << n ; } else { cout << ((l + 1) * (r + 1)) % MOD << n ; } return; } signed main() { fastio(); solve(); return 0; } |
#include <bits/stdc++.h> using ll = long long; using ull = unsigned long long; using std::cin; using std::cout; void print() {} template <typename T, typename... Args> void print(T t, Args... args) { cout << t << , print(args...); } template <typename... Args> void println(Args... args) { print(args...), cout << n ; } void printF(const char *format) { cout << format; } template <typename T, typename... Args> void printF(const char *format, T t, Args... args) { while (*format != % && *format) cout.put(*format++); if (*format++ == 0 ) return; cout << t; printF(format, args...); } ll getTotalBright(const std::vector<ll> &v, ll time, ll C) { ll ret = 0; for (ll i = 0; i < C + 1; ++i) { ret += v[i] * ((time + i) % (C + 1)); } return ret; } int main() { std::ios_base::sync_with_stdio(false); std::cin.tie(NULL); int N, Q, C, x1, y1, x2, y2, s; int time; cin >> N >> Q >> C; std::array<std::array<std::vector<ll>, 101>, 101> grid; for (auto &row : grid) for (auto &col : row) col.resize(C + 1, 0); for (int i = 0; i < N; ++i) { cin >> x1 >> y1 >> s; grid[x1][y1][s]++; } for (int i = 1; i < 101; ++i) { for (int h = 0; h <= C; ++h) { grid[i][0][h] += grid[i - 1][0][h]; grid[0][i][h] += grid[0][i - 1][h]; } } for (int i = 1; i < 101; ++i) { for (int j = 1; j < 101; ++j) { for (int h = 0; h <= C; ++h) { grid[i][j][h] += grid[i - 1][j][h] + grid[i][j - 1][h] - grid[i - 1][j - 1][h]; } } } for (int q = 0; q < Q; ++q) { cin >> time >> x1 >> y1 >> x2 >> y2; ll bright = 0; bright += getTotalBright(grid[x2][y2], time, C); bright -= getTotalBright(grid[x1 - 1][y2], time, C); bright -= getTotalBright(grid[x2][y1 - 1], time, C); bright += getTotalBright(grid[x1 - 1][y1 - 1], time, C); println(bright); } return 0; } |
#include <bits/stdc++.h> using namespace std; const long long int MOD = 1e9 + 7; const long long int MAXN = 100010; long long int par[MAXN], nxt[MAXN]; int find_root(int a) { if (par[a] == a) { return a; } int f = par[a]; par[a] = find_root(par[a]); nxt[a] = (nxt[a] + nxt[f]) % MOD; if (nxt[a] < 0) nxt[a] += MOD; return par[a]; } int main() { long long int n; cin >> n; for (int i = 1; i <= n; i++) { par[i] = i; } long long int answer = 0; for (int i = 1; i <= n; i++) { long long int k; cin >> k; for (int j = 0; j < k; j++) { long long int v, x; cin >> v >> x; long long int root = find_root(v); par[root] = i; answer = (answer + ((nxt[v] + x) % MOD)) % MOD; while (answer < 0) answer += MOD; if (x < 0) x += MOD; nxt[root] = ((nxt[v] + x) % MOD); if (nxt[root] < 0) { nxt[root] += MOD; } } } cout << answer % MOD << endl; } |
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; vector<long int> arr; arr.push_back(0); arr.push_back(1); if (n == 1) { cout << 1 << << 0 << << 0 << endl; return 0; } else if (n == 2) { cout << 1 << << 1 << << 0 << endl; return 0; } else if (n == 3) { cout << 1 << << 1 << << 1 << endl; return 0; } else if (n == 0) { cout << 0 << << 0 << << 0; return 0; } for (long int i = 2; i <= n; i++) { arr.push_back(arr[i - 1] + arr[i - 2]); if (arr[i] == n) break; } vector<long int>::iterator l = lower_bound(arr.begin(), arr.end(), n); cout << arr[l - 1 - arr.begin()] << << arr[l - arr.begin() - 3] << << arr[l - arr.begin() - 4] << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; int uf[310100]; int get_fa(int x) { return uf[x] == x ? x : uf[x] = get_fa(uf[x]); } struct Edge { Edge *next; int np; int id; } E[310100 * 2], *V[310100]; int tope = -1; void add_edge(int x, int y, int id) { E[++tope].np = y; E[tope].id = id; E[tope].next = V[x]; V[x] = &E[tope]; } int qq[310100]; int pnt[310100]; int pid[310100]; void dfs(int now) { for (Edge *ne = V[now]; ne; ne = ne->next) { if (ne->np == pnt[now]) continue; pnt[ne->np] = now; pid[ne->np] = ne->id; dfs(ne->np); } } int times[310100]; void dfs2(int now) { for (Edge *ne = V[now]; ne; ne = ne->next) { if (ne->np == pnt[now]) continue; dfs2(ne->np); times[now] = (times[now] + times[ne->np]) % 2; } } int main() { int n, m; scanf( %d%d , &n, &m); for (int i = 0; i < n; i++) scanf( %d , qq + i); for (int i = 0; i < n; i++) uf[i] = i; for (int i = 0; i < m; i++) { int x, y; scanf( %d%d , &x, &y); x--, y--; if (get_fa(x) != get_fa(y)) { uf[get_fa(x)] = get_fa(y); add_edge(x, y, i + 1); add_edge(y, x, i + 1); } } dfs(0); vector<int> A, B; for (int i = 0; i < n; i++) { int x; x = qq[i]; if (x == 1) A.push_back(i); if (x == -1) B.push_back(i); } if (A.size() % 2 == 1) { if (B.size() == 0) { printf( -1 n ); return 0; } else { A.push_back(B.back()); B.pop_back(); } } for (int i = 0; i < A.size(); i++) times[A[i]]++; dfs2(0); int ans = 0; for (int i = 1; i < n; i++) if (times[i] == 1) ans++; printf( %d n , ans); for (int i = 1; i < n; i++) if (times[i]) printf( %d n , pid[i]); } |
#include <bits/stdc++.h> using namespace std; long long n; string s; long long cnt[10]; int main(void) { ios::sync_with_stdio(0); cin.tie(0); cin >> n; cin >> s; for (long long(i) = (0); (i) <= (n - 1); (i)++) cnt[s[i] - 0 ]++; cout << min(n / 11, cnt[8]) << endl; return 0; } |
#include <bits/stdc++.h> int main() { long n(0); scanf( %ld , &n); const long maxSquare = n * n; int total(0); for (long a = 1; a < n; a++) { for (long b = a; b < n; b++) { long sumOfSquares = a * a + b * b; if (sumOfSquares > maxSquare) { break; } int temp = sqrt(sumOfSquares); if (temp * temp == sumOfSquares) { ++total; } } } printf( %d n , total); return 0; } |
#include <bits/stdc++.h> using namespace std; vector<int> mil, omil; int main() { int n, t; string a, b; char c[100010]; cin >> n >> t; cin >> a; cin >> b; t = n - t; for (int i = 0; i < a.size(); i++) { if (a[i] == b[i]) mil.push_back(i); else omil.push_back(i); } if (mil.size() < t) { t -= mil.size(); if (omil.size() < (2 * t)) { puts( -1 ); return 0; } for (int i = 0; i < mil.size(); i++) c[mil[i]] = a[mil[i]]; for (int i = 0; i < t; i++) c[omil[i]] = a[omil[i]]; for (int i = t; i < 2 * t; i++) c[omil[i]] = b[omil[i]]; for (int i = 2 * t; i < omil.size(); i++) { for (char ch = a ; ch <= z ; ch++) { if (ch != a[omil[i]] && ch != b[omil[i]]) { c[omil[i]] = ch; break; } } } puts(c); return 0; } for (int i = 0; i < t; i++) c[mil[i]] = a[mil[i]]; for (int i = t; i < mil.size(); i++) { for (char ch = a ; ch <= z ; ch++) { if (ch != a[mil[i]] && ch != b[mil[i]]) { c[mil[i]] = ch; break; } } } for (int i = 0; i < omil.size(); i++) { for (char ch = a ; ch <= z ; ch++) { if (ch != a[omil[i]] && ch != b[omil[i]]) { c[omil[i]] = ch; break; } } } puts(c); } |
#include <bits/stdc++.h> using namespace std; void solve() { int n, m, k, fri = 0; cin >> n >> m >> k; vector<int> v; for (int i = 0; i < m + 1; i++) { int t; cin >> t; v.push_back(t); } int la = v[m]; vector<int> labit; for (int i = 0; i < 32; i++) { if ((1 << i) & la) labit.push_back(1); else labit.push_back(0); } for (int i = 0; i < m; i++) { int cnt = 0; for (int j = 0; j < 32; j++) { int tembit; if ((1 << j) & v[i]) tembit = 1; else tembit = 0; if (tembit != labit[j]) cnt++; } if (cnt <= k) fri++; } cout << fri; } int main() { int t = 1; for (int i = 0; i < t; i++) solve(); return 0; } |
#include <bits/stdc++.h> using namespace std; const long long maxn = 1000100; long long n, k, a[maxn]; string s; struct t { long long open = 0, close = 0, ans = 0; } tree[4 * maxn], ft; t merge(t x, t y) { t temp; temp.ans = x.ans + y.ans + min(x.open, y.close); temp.open = x.open + y.open - min(x.open, y.close); temp.close = x.close + y.close - min(x.open, y.close); return temp; } void build(long long node, long long start, long long end) { if (start > end) return; if (start == end) { if (s[start] == ( ) tree[node].open++; else tree[node].close++; return; } long long mid = (start + end) / 2; build(2 * node, start, mid); build(2 * node + 1, mid + 1, end); tree[node] = merge(tree[2 * node], tree[2 * node + 1]); } t query(long long node, long long start, long long end, long long l, long long r) { if (start > end || start > r || l > end) return ft; if (l <= start && end <= r) return tree[node]; long long mid = (start + end) / 2; t p1 = query(2 * node, start, mid, l, r); t p2 = query(2 * node + 1, mid + 1, end, l, r); return merge(p1, p2); } void solve() { cin >> s; n = s.length(); build(1, 0, n - 1); cin >> k; while (k--) { long long x, y; cin >> x >> y; x--; y--; cout << 2 * query(1, 0, n - 1, x, y).ans << n ; } } signed main() { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); long long t = 1; for (long long i = 1; i <= t; i++) { solve(); } return 0; } |
#include <bits/stdc++.h> using namespace std; bool compare(pair<double, int> p1, pair<double, int> p2) { return p1.first > p2.first; } int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); int n, t1, t2, k; cin >> n >> t1 >> t2 >> k; vector<pair<double, int>> participants(n); int a, b; for (size_t i = 0; i < n; i++) { cin >> a >> b; participants[i] = make_pair(max(a * t1 * (100 - k) / 100.0 + b * t2, b * t1 * (100 - k) / 100.0 + a * t2), i + 1); } stable_sort(participants.begin(), participants.end(), compare); for (size_t i = 0; i < n; i++) cout << participants[i].second << << fixed << setprecision(2) << participants[i].first << endl; } |
#include <bits/stdc++.h> using namespace std; long long mod = 1000000007; long long fact[100001]; vector<long long> vec[100001]; long long vis[100001], win[100001], flag[100001]; long long power(long long x, long long y) { long long res = 1; while (y) { if (y & 1) res = (res * x) % mod; x = (x * x) % mod; y >>= 1; } return res; } long long nCr(long long n, long long r) { if (r > n) return 0; else if (r < 0) return 0; else if (r == 0 || r == n) return 1; long long ans = fact[n]; ans = (ans * power(fact[n - r], mod - 2)) % mod; ans = (ans * power(fact[r], mod - 2)) % mod; return ans; } void dfs(long long x) { vis[x] = 1; for (long long i = 0; i < vec[x].size(); i++) { long long node = vec[x][i]; if (vis[node] == -1) dfs(node); if (win[node] == 0) flag[x] = 1; } if (flag[x] == 1) win[x] = 1; } int main() { ios_base::sync_with_stdio(false); cin.tie(0); long long n; cin >> n; long long a[n + 1]; for (long long i = 1; i <= n; i++) cin >> a[i]; for (long long i = 1; i <= n; i++) { for (long long j = i; j > 0; j -= a[i]) { if (a[j] > a[i]) vec[a[i]].push_back(a[j]); } for (long long j = i; j <= n; j += a[i]) { if (a[j] > a[i]) vec[a[i]].push_back(a[j]); } } for (long long i = 1; i <= n; i++) { vis[i] = -1; win[i] = 0; flag[i] = 0; } dfs(1); string s; for (long long i = 1; i <= n; i++) { if (win[a[i]] == 1) s += A ; else s += B ; } cout << s << endl; for (long long i = 1; i <= n; i++) vec[i].clear(); return 0; } |
#include <bits/stdc++.h> using namespace std; struct node { int v, r, siz; node* ch[2]; long long sum[5]; void maintain() { int pre = 0; int s = 1; if (ch[0] != NULL) s += ch[0]->siz; pre = s; if (ch[1] != NULL) s += ch[1]->siz; siz = s; memset(sum, 0, sizeof(sum)); sum[(pre % 5)] = v; for (int i = 0; i < 5; i++) { if (ch[0] != NULL) sum[i] += ch[0]->sum[i]; if (ch[1] != NULL) sum[(pre + i) % 5] += ch[1]->sum[i]; } } node(int x) { this->v = x; this->r = rand(); this->siz = 1; this->ch[0] = this->ch[1] = NULL; memset(sum, 0, sizeof(sum)); this->sum[1] = x; } int cmp(int x) { if (x == v) return -1; return x < v ? 0 : 1; } }; node* rt; void rotate(node*& o, int d) { node* k = o->ch[d ^ 1]; o->ch[d ^ 1] = k->ch[d]; k->ch[d] = o; o->maintain(); k->maintain(); o = k; } void Insert(node*& o, int v) { if (o == NULL) { o = new node(v); return; } else { int d = v < o->v ? 0 : 1; Insert(o->ch[d], v); if (o->ch[d]->r > o->r) rotate(o, d ^ 1); if (o != NULL) o->maintain(); } } void Remove(node*& o, int v) { int d = o->cmp(v); if (d == -1) { if (o->ch[0] != NULL && o->ch[1] != NULL) { int d2 = o->ch[0]->r > o->ch[1]->r ? 1 : 0; rotate(o, d2); Remove(o->ch[d2], v); if (o != NULL) o->maintain(); } else if (o->ch[0] != NULL) o = o->ch[0]; else o = o->ch[1]; } else { Remove(o->ch[d], v); if (o != NULL) o->maintain(); } } int kth(node*& o, int k) { if (k == 0 || o == NULL || o->siz < k) return -1; else { int s = o->ch[0] == NULL ? 0 : o->ch[0]->siz; if (k == s + 1) return o->v; else if (k <= s) return kth(o->ch[0], k); else return kth(o->ch[1], k - s - 1); } } void print(node*& o) { if (o == NULL) return; if (o->ch[0] != NULL) print(o->ch[0]); printf( v=%d r=%d siz=%d || , o->v, o->r, o->siz); if (o->ch[1] != NULL) print(o->ch[1]); } string Coms[] = { add , del , sum }; int n; int main() { scanf( %d , &n); string com; int x; for (int i = 0; i < n; i++) { cin >> com; if (com == Coms[0]) { scanf( %d , &x); Insert(rt, x); } else if (com == Coms[1]) { scanf( %d , &x); Remove(rt, x); } else { if (rt == NULL) printf( 0 n ); else { printf( %lld n , rt->sum[3]); } } } return 0; } |
#include <bits/stdc++.h> using namespace std; int n; vector<int> f, s; int main() { long long buf, sumf = 0, sums = 0; int last = 0; cin >> n; for (int i = 0; i < n; i++) { cin >> buf; if (buf > 0) { f.push_back(buf); sumf += buf; last = 1; } else { s.push_back(-buf); sums -= buf; last = 2; } } if (sumf > sums) cout << first << endl; else if (sumf < sums) cout << second << endl; else { for (int i = 0; i < min(f.size(), s.size()); i++) { if (f[i] > s[i]) { cout << first << endl; return 0; } else if (f[i] < s[i]) { cout << second << endl; return 0; } } if (f.size() > s.size()) { cout << first << endl; } else if (f.size() < s.size()) { cout << second << endl; } else { if (last == 1) cout << first << endl; else cout << second << endl; } } return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int color[3], time = 30; for (int i = 0; i < 3; i++) cin >> color[i]; int maxi = *max_element(color, color + 3); int index; if (maxi == color[0]) index = 0; if (maxi == color[1]) index = 1; if (maxi == color[2]) index = 2; int loop = ceil(maxi / 2.0); for (int i = 0; i < loop - 1; i++) time += 2; time += loop - 1; if (index == 2) time += 2; else if (index == 1) time++; int tmp = index; if ((maxi - 1) % 2 != 0) { if (maxi - 1 == color[0]) tmp = 0; if (maxi - 1 == color[1]) tmp = 1; if (maxi - 1 == color[2]) tmp = 2; if (tmp - index > 0) time += tmp - index; } cout << time; return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.precision(10); cout << fixed; int base; cin >> base; string s; cin >> s; vector<long long> dp(s.size() + 1); dp[0] = 0; long long MAX = 1e18; for (int i = 0; i < s.size(); i++) { dp[i + 1] = MAX; for (int j = 0; j <= i; j++) { long long number = 0; bool b = true; for (int k = j; k <= i; k++) { if (k == j && k != i && s[k] == 0 ) { b = false; break; } if (number > (MAX + 0 - s[k] + 9) / 10) { b = false; break; } number = 10 * number + s[k] - 0 ; } if (b && number < base) { if (dp[j] <= (dp[i + 1] - number + base - 1) / base) { dp[i + 1] = min(dp[i + 1], dp[j] * base + number); } } } } cout << dp.back() << endl; return 0; } |
#include <bits/stdc++.h> using std::abs; using std::bitset; using std::cerr; using std::cin; using std::copy; using std::cout; using std::endl; using std::fill; using std::fixed; using std::greater; using std::lower_bound; using std::map; using std::max; using std::min; using std::next_permutation; using std::pair; using std::priority_queue; using std::queue; using std::reverse; using std::rotate; using std::set; using std::sort; using std::string; using std::swap; using std::tie; using std::tuple; using std::unique; using std::unordered_map; using std::unordered_set; using std::upper_bound; using std::vector; int const INF = (int)1e9; long long const INFL = (long long)1e18; long double const PI = 3.1415926535897932384626433832795028; int const N = 100100; int a[N], c[N]; struct Node { int ind; int sz; int prior; int ma; Node *l, *r; Node* pr; Node() {} Node(int ind) : ind(ind), sz(1), prior(rand() | (rand() << 16)), ma(a[ind]), l(0), r(0), pr(0) {} }; int size(Node* v) { return v ? v->sz : 0; } int maxa(Node* v) { return v ? v->ma : -INF; } void update(Node* v) { if (v) { v->sz = 1 + size(v->l) + size(v->r); v->ma = max({a[v->ind], maxa(v->l), maxa(v->r)}); if (v->l) v->l->pr = v; if (v->r) v->r->pr = v; } } Node* merge(Node* a, Node* b) { if (!a) return b; if (!b) return a; if (a->prior > b->prior) { a->r = merge(a->r, b); update(a); return a; } else { b->l = merge(a, b->l); update(b); return b; } } void split(Node* v, int cnt, Node*& l, Node*& r) { if (!v) { l = r = NULL; return; } if (size(v->l) >= cnt) { split(v->l, cnt, l, v->l); update(v); r = v; } else { split(v->r, cnt - 1 - size(v->l), v->r, r); update(v); l = v; } } Node* firstGreater(Node* v, int val) { while (true) { if (maxa(v->l) > val) { v = v->l; } else if (a[v->ind] < val) { v = v->r; } else { break; } } return v; } int getIndex(Node* v) { int ret = size(v->l); while (v->pr) { if (v->pr->r == v) { ret += 1 + size(v->pr->l); } v = v->pr; } return ret; } void solve() { int n; scanf( %d , &n); for (int i = 0; i < n; ++i) { scanf( %d%d , a + i, c + i); } Node* H = NULL; for (int i = 0; i < n; ++i) { Node* cur = new Node(i); Node *L, *M, *R; split(H, c[i], L, R); if (maxa(L) < a[i]) { H = merge(L, merge(cur, R)); } else { Node* big = firstGreater(L, a[i]); int cnt = getIndex(big); split(L, cnt, L, M); H = merge(L, merge(cur, merge(M, R))); } } for (int i = 0; i < n; ++i) { Node* cur; split(H, size(H) - 1, H, cur); printf( %d , cur->ind + 1); } puts( ); } int main() { solve(); } |
#include <bits/stdc++.h> using namespace std; bool exitInput = false; int ntest = 1, itest = 1; const char* directions[4] = { NE , SE , SW , NW }; const long long Mod = 1000000000LL + 7; const int maxn = 100 + 2; const int maxv = 1000000 + 5; const int maxe = 600000 + 5; const int root = 1; int a, n, b; int isprime[1250002]; int base_prime[10000000 + 1], ans[10000000 + 1]; long long res; void sieve(int gh) { int i, j, k, x; int nBytes = gh / 8 + 1; isprime[0] = 0xFC; for (i = 1; i <= nBytes; ++i) { isprime[i] = 0xFF; } for (i = 2; i <= gh; ++i) { j = i >> 3; k = i - (j << 3); if (isprime[j] & (1 << k)) { for (x = i + i; x <= gh; x += i) { j = x >> 3; k = x - (j << 3); isprime[j] &= ~(1 << k); base_prime[x] = i; } base_prime[i] = i; } } } int main() { int i, j, k, t; scanf( %d %d , &a, &n); b = a + n - 1; sieve(b); res = 0; ans[1] = 1; for (i = 2; i <= b; ++i) { if (base_prime[i] == i) { ans[i] = i; } else { t = j = i / base_prime[i]; k = 0; while (j % base_prime[i] == 0) { j /= base_prime[i]; ++k; } j = t; if (k & 1) ans[i] = ans[j] / base_prime[i]; else ans[i] = ans[j] * base_prime[i]; } } for (i = a; i <= b; ++i) { res += ans[i]; } printf( %lld n , res); return 0; } |
#include <bits/stdc++.h> using namespace std; long long gcd(long long a, long long b) { if (a % b == 0) return b; return gcd(b, a % b); } void solve() { int n; int ans = 0; cin >> n; int a[8008]; int b[8008] = {0}; for (int i = 1; i <= n; i++) { cin >> a[i]; b[i] = b[i - 1] + a[i]; } if (n < 3) { cout << 0 << endl; return; } for (int i = 1; i <= n; i++) { int l = 1, r = 2; for (; r <= n;) { if (r > n) { break; } if (r >= i && l <= i) { l = i + 1; r = i + 2; continue; } if (b[r] - b[l - 1] < a[i]) { r++; continue; } else if (b[r] - b[l - 1] > a[i]) { if (r - 1 <= l) { l++; r++; } else { l++; } } else { ans++; break; } } } cout << ans << endl; } int main() { ios::sync_with_stdio(false); int t; cin >> t; while (t--) { solve(); } return 0; } |
#include <bits/stdc++.h> using namespace std; int main(void) { int i, n; long long int s; s = 0; set<int> x, k; map<int, int> m, mu; cin >> n; int a[n]; for (i = 0; i < n; i++) { cin >> a[i]; m[a[i]]++; x.insert(a[i]); } for (i = 0; i < n; i++) { if (k.find(a[i]) == k.end()) { s += x.size() - 1; if (m[a[i]] > 1) s++; k.insert(a[i]); } mu[a[i]]++; if (m[a[i]] == mu[a[i]]) x.erase(a[i]); } cout << s; return 0; } |
#include <bits/stdc++.h> const int N = 110; using namespace std; inline int read() { int x = 0, f = 1; char ch = getchar(); while (ch < 0 || ch > 9 ) { if (ch == - ) { f = -1; } ch = getchar(); } while (ch <= 9 && ch >= 0 ) { x = (x << 1) + (x << 3) + ch - 0 ; ch = getchar(); } return x * f; } int n, a[N], cnt; int minn[N]; bool in_q(int x) { for (int i = 1; i <= cnt; i++) { if (x % minn[i] == 0) { return 1; } if (minn[i] % x == 0) { minn[i] = x; return 1; } } return 0; } int main() { cin >> n; for (int i = 1; i <= n; i++) { cin >> a[i]; } sort(a + 1, a + 1 + n); for (int i = 1; i <= n; i++) { if (!in_q(a[i])) { minn[++cnt] = a[i]; } } cout << cnt << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; int read(); const int N = 1.5e5 + 5; int n, p, k, m, a[N]; vector<pair<int, int> > seg[N << 2], res; int eq[N << 2]; void puteq(int k, int l, int r, int v) { eq[k] = v; seg[k].clear(); seg[k].push_back(make_pair(v, r - l + 1)); } bool cmp(const pair<int, int> &a, const pair<int, int> &b) { return a.second > b.second; } void pushup(vector<pair<int, int> > &a, vector<pair<int, int> > &b) { for (int i = (0); i < (b.size()); ++i) a.push_back(b[i]); sort(a.begin(), a.end()); for (int i = (0); i < (int(a.size()) - 1); ++i) if (a[i].first == a[i + 1].first) a[i + 1].second += a[i].second, a[i].second = 0; sort(a.begin(), a.end(), cmp); while (a.size() && a.back().second == 0) a.pop_back(); while (a.size() > k) { for (int i = (k + 1); i >= (1); --i) a[a.size() - i].second -= a.back().second; while (a.size() && a.back().second == 0) a.pop_back(); } } void pushdown(int k, int l, int r, int mid) { if (eq[k]) { puteq((k << 1), l, mid, eq[k]); puteq(((k << 1) | 1), mid + 1, r, eq[k]); eq[k] = 0; } } void change(int k, int l, int r, int x, int y, int v) { if (x <= l && r <= y) return puteq(k, l, r, v); int mid = l + r >> 1; pushdown(k, l, r, mid); if (x <= mid) change((k << 1), l, mid, x, y, v); if (y > mid) change(((k << 1) | 1), mid + 1, r, x, y, v); seg[k] = seg[(k << 1)]; pushup(seg[k], seg[((k << 1) | 1)]); } vector<pair<int, int> > ans; void query(int k, int l, int r, int x, int y) { if (x <= l && r <= y) return pushup(ans, seg[k]); int mid = l + r >> 1; pushdown(k, l, r, mid); if (x <= mid) query((k << 1), l, mid, x, y); if (y > mid) query(((k << 1) | 1), mid + 1, r, x, y); } void build(int k, int l, int r) { if (l == r) { seg[k].push_back(make_pair(a[l], 1)); return; } int mid = l + r >> 1; build((k << 1), l, mid), build(((k << 1) | 1), mid + 1, r); seg[k] = seg[(k << 1)], pushup(seg[k], seg[((k << 1) | 1)]); } int main() { scanf( %d%d%d , &n, &m, &p); k = 100 / p; for (int i = (1); i <= (n); ++i) scanf( %d , a + i); build(1, 1, n); while (m--) { static int op, l, r, v; scanf( %d%d%d , &op, &l, &r); if (op == 1) scanf( %d , &v), change(1, 1, n, l, r, v); else { ans.clear(); query(1, 1, n, l, r); printf( %d , int(ans.size())); for (int i = (0); i < (ans.size()); ++i) printf( %d , ans[i].first); puts( ); } } return 0; } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.