func_code_string
stringlengths 59
71.4k
|
|---|
/*ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ βββββββββββββββββββββββββββββββββββββ¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬ββββ¬β¬β¬β¬β¬β¬ββββββββββββββββββββββββ ββββββββββββββββββββββββββββββββββββββ¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬βββββββββββ¬β¬β¬ββββββββββββββββββββββββ ββββββββββββββββββββββββββββββββββββββββ¬β¬β¬β¬β¬β¬β¬β¬ββββββ¬β¬β¬β¬β¬β¬β¬ββ¬β¬ββββββββββββββββββββββββ βββββββββββββββββββββββββββββββββ¬β¬βββββββ¬β¬β¬β¬β¬β¬βββββ¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬βββββββββββββββββββββββ ββββββββββββββββββββββββββββββββ¬β¬β¬β¬β¬β¬ββββ¬β¬β¬β¬β¬β¬βββ¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬ββββββββββββββββββββββββ ββββββββββββββββββββββββββββββββ¬β¬β¬β¬β¬β¬β¬ββββ¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬ββββββββββββββββββββββββ ββββββββββββββββββββββββββββββββββββββββββββ¬β¬β¬β¬β¬β¬ββββββββββ¬β¬β¬β¬ββββββββββββββββββββββββ ββββββββββββββββββββββββββββββββββββββββββββ¬β¬β¬β¬β¬βββββββββ¬β¬β¬β¬β¬β¬β¬βββββββββββββββββββββββ βββββββββββββββββββββββββββββββββββ¬β¬ββββββββ¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬ββββββββββββββββββββββββ ββββββββββββββββββββββββββββββββ¬β¬β¬β¬βββββββββ¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬ββββββββββββββββββββββββ ββββββββββββββββββββββββββββββββββββββββββββ¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬ββββββββββββββββββββββββ ββββββββββββββββββββββββββββββββββββββββββββ¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬ββββββββββββββββββββββββ ββββββββββββββββββββββββββββββββββββββββββββ¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬ββββββββββββββββββββββββ ββββββββββββββββββββββββββββββββββββββββββββ¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬ββββββββββββββββββββββββ βββββββββββββββββββββββββββββββββββββββββββ¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬ββββββββββββββββββββββββ ββββββββββββββββββββββββββββββββββββββββββββ¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬βββ¬ββ¬β¬βββββββββββββββββββββββββ ββββββββββββββββββββββββββββββββββββββββββββββββ¬β¬β¬β¬β¬β¬β¬βββ¬β¬β¬β¬β¬βββββββββββββββββββββββββ ββββββββββββββββββββββββββββββββββββββββββββ¬βββββ¬β¬β¬βββββ¬β¬β¬β¬β¬β¬βββββββββββββββββββββββββ βββββββββββββββββββββββββββββββββββββββββββ¬β¬β¬βββ¬ββββββ¬β¬β¬β¬β¬β¬β¬ββββββββββββββββββββββββββ ββββββββββββββββββββββββββββββββββββββββββββββββββ¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬ββββββββββββββββββββββββββ βββββββββββββββββββββββββββββββββββββββββ¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬βββββββββββββββββββββββββββ βββββββββββββββββββββββββββββββββββββββββββ¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬ββββββββββββββββββββββββββββ βββββββββββββββββββββββββββββββββββββββββββββββ¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬βββββββββββββββββββββββββββββ ββββββββββββββββββββββββββββββββββββββββββ¬ββββ¬β¬β¬β¬β¬β¬β¬β¬β¬β¬β¬ββββββββββββββββββββββββββββββ βββββββββββββββββββββββββββββββββββββββββββββββ¬β¬β¬β¬β¬β¬β¬β¬β¬βββββββββββββββββββββββββββββββ βββββββββββββββββββββββββββββββββββββββββββββββ¬β¬β¬β¬β¬β¬β¬β¬ββββββββββββββββββββββββββββββββ βββββββββββββββββββββββββββββββββββββββββββββββ¬β¬β¬β¬β¬β¬ββββββββββββββββββββββββββββββββββ ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ */ /* ______ __ __ __ __ ________ _______ __ __ ______ ______ ______ ______ __ __ / | | / | | / / / / | | | ββββββ ββ | ββ ββ / ββ ββββββββ βββββββ | ββ | ββ ββββββ ββββββ ββββββ ββββββ ββ | ββ | ββ__| ββ ββ__| ββ βββ / βββ ββ__ | ββ | ββ | ββ__| ββ ββ__| ββ ββ___ ββ ββ___ ββ ββ__| ββ βββ | ββ | ββ ββ ββ ββ ββββ ββββ ββ | ββ | ββ | ββ ββ ββ ββ ββ ββ | ββ ββ ββββ ββ | ββββββββ ββββββββ ββ ββ ββ ββ βββββ | ββ | ββ | ββββββββ ββββββββ_ ββββββ _ ββββββ ββββββββ ββ ββ ββ | ββ | ββ ββ | ββ ββ βββ| ββ ββ_____| ββ__/ ββ | ββ | ββ ββ | ββ __| ββ __| ββ ββ | ββ ββ ββββ | ββ | ββ ββ | ββ ββ β | ββ ββ ββ ββ | ββ | ββ ββ | ββ ββ ββ ββ ββ ββ | ββ ββ βββ ββ ββ ββ ββ ββ ββ ββββββββ βββββββ ββ ββ ββ ββ ββββββ ββββββ ββ ββ ββ ββ */ /* __ __ __ __ __ ______ ______ _______ ______ __ | | | | / / | / | | ββ | ββ ______ ______ ____| ββ ββ_______ ______ _| ββ_ ______ | ββββββ ββββββ βββββββ ββββββ ββ _______ ______ | ββ__| ββ/ | / ββ / | ββ / | ββ__| ββ ββ ββ ββ__/ ββ ββ ββ | / | | ββ ββ ββββββ ββββββ βββββββ ββ βββββββ ββββββ ββββββ | ββββββ | ββ ββ ββ | ββ ββ ββ | ββ βββββββ ββββββ | ββββββββ ββ ββ/ ββ ββ | ββ ββ ββ | ββ ββ | ββ | ββ __| ββ | ββ | ββββββββ ββ __| βββββββ| ββ __ | ββ ββ / ββ | ββ | ββ ββββββββ βββββββ ββ__| ββ ββ ββ | ββ ββ__| ββ | ββ| ββ__/ ββ | ββ | ββ ββ__/ ββ | ββ__/ | ββ_ ββββββ βββββββ | ββ | ββ ββ ββ ββ ββ ββ ββ ββ | ββ ββ ββ ββ ββ ββ ββ | ββ | ββ ββ ββ ββ ββ ββ | ββ ββ ββ ββ ββ ββ βββββββ βββββββ βββββββ ββ ββ ββ_ βββββββ ββββ ββββββ ββ ββ ββββββ ββ ββββββ ββ βββββββ βββββββ | __| ββ ββ ββ ββββββ */ #include<bits/stdc++.h> #define ll long long #define ld long double #define f(i,n) for(ll i=0;i<(n);i++) #define f1(i,n) for(ll i=1;i<=n;i++) #define el n #define sq(a) (a)*(a) #define pb push_back #define asort(a,n) sort(a,a+n) #define dsort(a,n) sort(a,a+n,greater<>()) #define vasort(v) sort(v.begin(), v.end()); #define vdsort(v) sort(v.begin(), v.end(),greater<>()); #define cina(arr) f(i,n) cin >> arr[i]; #define YES cout << YES n #define Yes cout << Yes <<el #define yes cout << yes <<el #define NO cout << NO n #define No cout << No <<el #define no cout << no <<el #define covid19 ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0); #define TC int t; cin >> t; while(t--) const double pi=acos(-1); using namespace std; int main() { #ifndef ONLINE_JUDGE clock_t start = clock(); #endif covid19; TC { ll n; cin >> n; for (ll i = 0; i < 32; i++) { ll x = pow(2, i); if (x > n) { cout << x / 2 - 1; break; } } cout << el; } #ifndef ONLINE_JUDGE clock_t end = clock(); double time_taken = double(end - start) / double(CLOCKS_PER_SEC); cout << Time taken: << time_taken; cout << sec n ; #endif } /* NOTESSS decimal digit root :: d(n)=1+((nβ1)mod9) */ |
#include <bits/stdc++.h> using namespace std; const double EPS = 1e-9; const int MOD = 1e9 + 7; int dx[8] = {0, 0, 1, -1, -1, 1, -1, 1}, dy[8] = {1, -1, 0, 0, -1, -1, 1, 1}; void INPUT() {} void OUTPUT() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); } int main() { INPUT(); OUTPUT(); string s; cin >> s; string ans = , s1 = , s0 = ; for (int i = ((int)((s).size())) - 1; i >= 0; i--) { if (s[i] == 0 ) { ans += 0 ; s0 += 0 ; } else if (s[i] == 2 ) { ans += 2 ; s0 = ; } else { s1 += 1 ; } } cout << s0 + s1; int i = ((int)((ans).size())) - 1; while (ans[i] == 0 ) { i--; } while (i > -1) { cout << ans[i]; i--; } return 0; } |
#include <bits/stdc++.h> using namespace std; void solve(); int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); solve(); return 0; } void solve() { long long a, b; cin >> a >> b; long long ct = 0; while (a > 0 && b > 0) { if (a > b) { ct += a / b; a = a % b; } else { ct += b / a; b = b % a; } } cout << ct; } |
#include <bits/stdc++.h> using namespace std; struct query { long long l, r, x; }; int n, a[109]; long long m; int main() { cin >> n >> m; vector<query> v; vector<long long> cp = {1LL << 60}; for (int i = 0; i < n; i++) { cin >> a[i]; int pr = sqrt(a[i]); for (int j = 1; j < pr; j++) { v.push_back(query{j, j + 1, (a[i] + j - 1) / j}); cp.push_back(j); } cp.push_back(pr); int r = (a[i] + pr - 1) / pr, ptr = pr; for (int j = r; j > 1; j--) { v.push_back(query{ptr, (a[i] + j - 2) / (j - 1), j}); ptr = v.back().r; cp.push_back(ptr); } v.push_back(query{ptr, 1LL << (59 + 1), 1}); } sort(cp.begin(), cp.end()); cp.erase(unique(cp.begin(), cp.end()), cp.end()); vector<long long> sum(cp.size()); for (query i : v) { int pl = lower_bound(cp.begin(), cp.end(), i.l) - cp.begin(); int pr = lower_bound(cp.begin(), cp.end(), i.r) - cp.begin(); sum[pl] += i.x; sum[pr] -= i.x; } for (int i = 1; i < cp.size(); i++) sum[i] += sum[i - 1]; long long ret = 0; for (int i = 0; i < cp.size() - 1; i++) { long long r = min(cp[i + 1] - 1, (m + sum[0]) / sum[i]); if (cp[i] <= r) ret = max(ret, r); } cout << ret << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; const long long int mod = 1000000007; const long long int inf = 0x3f3f3f3f3f3f3f3fLL; const double eps = 1e-9; const double PI = acos(-1); long long int i, j, k; void solve(void); inline bool equal(double a, double b) { return fabs(a - b) < eps; } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout << fixed << setprecision(10); int t = 1; while (t--) solve(); return 0; } void solve() { int n, a, b, T; cin >> n >> a >> b >> T; char c[n]; for (i = (0); i <= (n - 1); ++i) cin >> c[i]; int lo = 1, hi = n, mid, ans = 0, left[n], right[n]; left[0] = right[0] = 1 + (c[0] == w ? b : 0); for (i = (1); i <= (n - 1); ++i) left[i] = left[i - 1] + a + (c[n - i] == w ? b : 0) + 1; for (i = (1); i <= (n - 1); ++i) right[i] = right[i - 1] + a + (c[i] == w ? b : 0) + 1; while (lo <= hi) { mid = (lo + hi) >> 1; bool pos = 0; for (i = (mid - 1); i >= (0); --i) { long long int time1 = right[i] + left[mid - i - 1] - left[0] + i * a; if (time1 <= T) pos = 1; long long int time2 = left[i] + right[mid - i - 1] - right[0] + i * a; if (time2 <= T) pos = 1; } if (pos) { ans = ((ans) > (mid) ? (ans) : (mid)); lo = mid + 1; } else hi = mid - 1; } cout << ans << n ; } |
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); int t = 1; cin >> t; while (t-- > 0) { int n; cin >> n; string srr[n]; for (int i = 0; i < n; i++) { cin >> srr[i]; } vector<pair<int, int>> afirst(n); vector<pair<int, int>> bfirst(n); vector<pair<int, int>> cfirst(n); vector<pair<int, int>> dfirst(n); vector<pair<int, int>> efirst(n); for (int i = 0; i < n; i++) { int countabc[5] = {0}; for (int j = 0; j < srr[i].size(); j++) { countabc[srr[i][j] - a ]++; } afirst[i].first = 2 * countabc[0] - srr[i].size(); bfirst[i].first = 2 * countabc[1] - srr[i].size(); cfirst[i].first = 2 * countabc[2] - srr[i].size(); dfirst[i].first = 2 * countabc[3] - srr[i].size(); efirst[i].first = 2 * countabc[4] - srr[i].size(); afirst[i].second = i; bfirst[i].second = i; cfirst[i].second = i; dfirst[i].second = i; efirst[i].second = i; } sort(afirst.begin(), afirst.end()); sort(bfirst.begin(), bfirst.end()); sort(cfirst.begin(), cfirst.end()); sort(dfirst.begin(), dfirst.end()); sort(efirst.begin(), efirst.end()); int maxi = 0; int curr = 0; int total = 0; for (int i = n - 1; i >= 0; i--) { curr += afirst[i].first; if (curr >= 1) { total++; } else { break; } } maxi = max(maxi, total); curr = 0; total = 0; for (int i = n - 1; i >= 0; i--) { curr += bfirst[i].first; if (curr >= 1) { total++; } else { break; } } maxi = max(maxi, total); curr = 0; total = 0; for (int i = n - 1; i >= 0; i--) { curr += cfirst[i].first; if (curr >= 1) { total++; } else { break; } } maxi = max(maxi, total); curr = 0; total = 0; for (int i = n - 1; i >= 0; i--) { curr += dfirst[i].first; if (curr >= 1) { total++; } else { break; } } maxi = max(maxi, total); curr = 0; total = 0; for (int i = n - 1; i >= 0; i--) { curr += efirst[i].first; if (curr >= 1) { total++; } else { break; } } maxi = max(maxi, total); cout << maxi << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; inline long long rd() { long long x = 0; char o, f = 1; while (o = getchar(), o < 48) if (o == 45) f = -f; do x = (x << 3) + (x << 1) + (o ^ 48); while (o = getchar(), o > 47); return x * f; } const int maxn = 1e2 + 5; const long long mod = 998244353; int _; int n, m, a[maxn][maxn]; long long ans; void solve(int x, int y) { vector<int> v; v.push_back(a[x][y]); if (n - x + 1 != x) v.push_back(a[n - x + 1][y]); if (m - y + 1 != y) v.push_back(a[x][m - y + 1]); if (n - x + 1 != x && m - y + 1 != y) v.push_back(a[n - x + 1][m - y + 1]); sort(v.begin(), v.end()); int len = v.size(); len /= 2; for (auto u : v) { ans += abs(v[len] - u); } } int main() { for (_ = rd(); _; _--) { ans = 0; n = rd(); m = rd(); for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) a[i][j] = rd(); for (int i = 1; i <= (n + 1) / 2; i++) { for (int j = 1; j <= (m + 1) / 2; j++) solve(i, j); } printf( %lld n , ans); } return 0; } |
#include <bits/stdc++.h> using namespace std; int m, n, a[7][7] = {{0, 1, 2}, {1, 0, 2}, {1, 2, 0}, {2, 1, 0}, {2, 0, 1}, {0, 2, 1}, {0, 1, 2}}; int main() { cin >> n >> m; n %= 6; cout << a[n][m]; return 0; } |
#include <bits/stdc++.h> using namespace std; template <typename T1, typename T2> inline void chkmin(T1& a, T2 b) { if (a > b) a = b; } template <typename T1, typename T2> inline void chkmax(T1& a, T2 b) { if (a < b) a = b; } using ll = long long; using ld = long double; const string FILENAME = input ; using ll = long long; using ld = long double; struct Point { ld x, y; Point() {} Point(ld _x, ld _y) : x(_x), y(_y) {} ld len() { return sqrt(x * x + y * y); } }; Point operator+(const Point& a, const Point& b) { return Point(a.x + b.x, a.y + b.y); } Point operator-(const Point& a, const Point& b) { return Point(a.x - b.x, a.y - b.y); } ld operator*(const Point& a, const Point& b) { return a.x * b.y - a.y * b.x; } ld operator^(const Point& a, const Point& b) { return a.x * b.x + a.y * b.y; } const double Pi = acos(-1); const int MAXN = 100228; int n, k; Point p[MAXN]; bool ok(double r) { vector<pair<double, int> > st; int add = 0; for (int i = 0; i < n; i++) { double f = p[i].len(); if (f > 2 * r + 1e-9) { continue; } if (abs(p[i].x) < 1e-9 && abs(p[i].y) < 1e-9) { add++; continue; } Point q = p[i]; swap(q.x, q.y); q.x *= -1; double fm = sqrt(q.x * q.x + q.y * q.y); q.x /= fm; q.y /= fm; double h = sqrt(r * r - (f / 2) * (f / 2)); q.x *= h; q.y *= h; Point s = p[i]; s.x /= 2; s.y /= 2; Point e = s + q; Point e1 = s - q; double l = atan2(e.y, e.x) + 2 * Pi; double rr = atan2(e1.y, e1.x) + 2 * Pi; while (l < 0) { l += 2 * Pi; } while (rr < 0) { rr += 2 * Pi; } while (l >= 2 * Pi) { l -= 2 * Pi; } while (rr >= 2 * Pi) { rr -= 2 * Pi; } if (l > rr) { swap(l, rr); } if (rr - l <= Pi + 1e-9) { st.push_back(make_pair(l, 1)); st.push_back(make_pair(rr, -1)); } else { st.push_back(make_pair(0, 1)); st.push_back(make_pair(l, -1)); st.push_back(make_pair(rr, 1)); st.push_back(make_pair(2 * Pi, -1)); } } sort((st).begin(), (st).end()); int cur = 0; int tm = 0; for (auto x : st) { cur += x.second; chkmax(tm, cur); } return tm + add >= k; } void solve() { cin >> n >> k; for (int i = 0; i < n; i++) { int x, y; cin >> x >> y; p[i].x = x; p[i].y = y; } double l = 0.0; double r = 200228; for (int it = 0; it < 36; it++) { double mid = (l + r) / 2.0; if (ok(mid)) { r = mid; } else { l = mid; } } cout << fixed << l << n ; } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); int t = 1; while (t--) { solve(); } return 0; } |
#include <bits/stdc++.h> using namespace std; const int N = 1005; long long sum[N][N]; int spt[11][N][N], mn[N][N], arr[N][N]; bool visit[N][N]; int n, m, a, b, x; void buildSparse() { int LN = log2(n) + 1, LM = log2(m) + 1; for (int lg = 1; lg <= LM; lg++) for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) spt[lg][i][j] = min(spt[lg - 1][i][j], spt[lg - 1][i][j + (1 << (lg - 1))]); for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) { sum[i][j] += sum[i - 1][j]; if (j >= b) { int lg = log2(b), l = j - b + 1, r = j - (1 << lg) + 1; mn[i][j] = min(spt[lg][i][l], spt[lg][i][r]); } } for (int i = 1; i <= n; i++) for (int j = b; j <= m; j++) spt[0][i][j] = mn[i][j]; for (int lg = 1; lg <= LN; lg++) for (int i = 1; i <= n; i++) for (int j = b; j <= m; j++) spt[lg][i][j] = min(spt[lg - 1][i][j], spt[lg - 1][i + (1 << (lg - 1))][j]); } long long getRemoved(int i, int j) { int lg = log2(a), l = i - a + 1; int r = i - (1 << lg) + 1; int minn = min(spt[lg][l][j], spt[lg][r][j]); long long res = sum[i][j] - sum[i - a][j] - sum[i][j - b] + sum[i - a][j - b] - 1LL * a * b * minn; return res; } int main() { ios_base::sync_with_stdio(0); cin.tie(0); cin >> n >> m >> a >> b; for (int i = 1; i <= n; i++) { for (int j = 1; j <= m; j++) { cin >> arr[i][j]; spt[0][i][j] = arr[i][j]; sum[i][j] += sum[i][j - 1] + arr[i][j]; } } buildSparse(); vector<pair<long long, pair<int, int>>> v, ans; for (int i = a; i <= n; i++) for (int j = b; j <= m; j++) v.push_back({getRemoved(i, j), {i, j}}); sort(v.begin(), v.end()); for (int i = 0; i < v.size(); i++) { int x = v[i].second.first - a + 1, y = v[i].second.second - b + 1; if (!visit[x][y] && !visit[x + a - 1][y] && !visit[x][y + b - 1] && !visit[x + a - 1][y + b - 1]) { ans.push_back({v[i].first, {x, y}}); for (int j = 0; j < a; j++) for (int k = 0; k < b; k++) visit[x + j][y + k] = true; } } cout << ans.size() << endl; for (int i = 0; i < ans.size(); i++) cout << ans[i].second.first << << ans[i].second.second << << ans[i].first << n ; return 0; } |
#include <bits/stdc++.h> using namespace std; const int maxn = 100000 + 10; struct Edge { int from, to, w; } edges[maxn]; int val[maxn]; long long ans; int size[maxn], fa[maxn]; bool cmp(Edge a, Edge b) { return a.w > b.w; } int Getfa(int x) { if (fa[x] == x) return x; else return fa[x] = Getfa(fa[x]); } int main() { int n, m; cin >> n >> m; for (int i = 1; i <= n; ++i) scanf( %d , &val[i]); for (int i = 1; i <= m; ++i) { int u, v; scanf( %d %d , &u, &v); edges[i].from = u, edges[i].to = v; edges[i].w = min(val[u], val[v]); } sort(edges + 1, edges + 1 + m, cmp); for (int i = 1; i <= n; ++i) size[i] = 1, fa[i] = i; ans = 0; for (int i = 1; i <= m; ++i) { int u = edges[i].from, v = edges[i].to; int fx = Getfa(u), fy = Getfa(v); if (fx == fy) continue; ans += (long long)size[fx] * size[fy] * edges[i].w; fa[fx] = fy; size[fy] += size[fx]; } printf( %.6lf n , (double)2.0 * ans / n / (n - 1)); return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int N, M; char eat; cin >> N >> M; scanf( %c , &eat); char temp[5000]; vector<vector<bool>> grid(N, vector<bool>(M)); for (int r = 0; r < N; r++) { scanf( %s , temp); for (int c = 0; c < M; c++) grid[r][c] = (temp[c] == 1 ? 1 : 0); } int result = 0; vector<vector<int>> memo(N, vector<int>(M)); for (int r = 0; r < N; r++) { for (int c = M - 1; c >= 0; c--) { if (grid[r][c] == 1) memo[r][c] = 1 + (c != M - 1 ? memo[r][c + 1] : 0); } } for (int c = 0; c < M; c++) { vector<int> width; for (int r = 0; r < N; r++) { if (memo[r][c] != 0) width.push_back(memo[r][c]); } sort(width.rbegin(), width.rend()); for (int i = 0; i < width.size(); i++) { int area = (i + 1) * width[i]; result = max(result, area); } } cout << result << endl; } |
#include <bits/stdc++.h> using namespace std; #define pb push_back #define MP make_pair #define ll long long #define lb lower_bound #define ub upper_bound #define bs binary_search #define fo(i,a,b) for(int i=a;i<b;i++) #define rfo(i,b,a) for(int i=b;i>=a;i--) typedef vector<ll> vi; typedef vector<vi> vvi; string solve(){ ll n; cin>>n; vi a(n); map<int,int> m; fo(i,0,n){ cin>>a[i]; m[a[i]] = m[a[i]] + (i%2); } sort(a.begin(), a.end()); fo(i,0,n){ m[a[i]] = m[a[i]]-(i%2); } map<int,int> :: iterator itr; for(itr = m.begin() ; itr!= m.end() ; itr++){ if(itr->second != 0) return NO ; } return YES ; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); int t; cin>>t; while(t--) { cout<<solve()<<endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; struct t { char c; int a, b; t(char c, int a, int b) : c(c), a(a), b(b) {} t() {} }; int n; vector<t> e; double temp; double t0 = 1000; double gen_rand() { int x = rand() + 1, y = rand() + 1; x %= y; return x / (double)y; } int get_ans() { int r = 0, b = 0; int R = 0, B = 0; int ans = 0; for (int i = 0; i < n; i++) { int need = max(max(0, max(0, e[i].a - R) - r), max(0, max(0, e[i].b - B) - b)); ans += need; r -= max(0, max(0, e[i].a - R)); b -= max(0, max(0, e[i].b - B)); r += need; b += need; ans++; if (e[i].c == R ) { R++; } else { B++; } } return ans; } int main() { srand(time(NULL)); cin >> n; for (int i = 0; i < n; i++) { char c; int r, b; cin >> c >> r >> b; e.push_back({c, r, b}); } random_shuffle(e.begin(), e.end()); temp = t0; int ans = INT_MAX; for (int qwe = 0; qwe < 70000; ++qwe) { int cur = get_ans(); ans = min(ans, cur); vector<t> was = e; for (int i = 0; i < n * temp / t0; i++) { swap(e[rand() % n], e[rand() % n]); } int now = get_ans(); ans = min(ans, now); if (now < cur) { cur = now; } else { double go = exp(-(now - cur) / temp); if (gen_rand() <= go) { cur = now; } else { e = was; } } temp *= 0.999; } cout << ans << endl; } |
#include <bits/stdc++.h> using namespace std; template <typename T> T gcd(T a, T b) { return (b ? __gcd(a, b) : a); } template <typename T> T lcm(T a, T b) { return (a * (b / gcd(a, b))); } template <class T> ostream &operator<<(ostream &os, vector<T> V) { os << [ ; for (auto v : V) os << v << ; return os << ] ; } template <class T> ostream &operator<<(ostream &os, set<T> S) { os << { ; for (auto s : S) os << s << ; return os << } ; } template <class L, class R> ostream &operator<<(ostream &os, pair<L, R> P) { return os << ( << P.first << , << P.second << ) ; } template <class L, class R> ostream &operator<<(ostream &os, map<L, R> M) { os << { ; for (auto m : M) os << ( << m.first << : << m.second << ) ; return os << } ; } const int N = 5e5 + 5; long long ar[N]; long long l[N], r[N], ans[N]; int main() { cin.sync_with_stdio(0); cin.tie(0); cin.exceptions(cin.failbit); int n; cin >> n; for (int i = 1; i <= n; ++i) cin >> ar[i]; vector<long long> lft(1, 0), rt(1, n + 1); for (int i = 1; i <= n; ++i) { while (ar[lft.back()] > ar[i]) { lft.pop_back(); } l[i] = l[lft.back()] + ar[i] * (i - lft.back()); lft.push_back(i); } for (int i = n; i; --i) { while (ar[rt.back()] > ar[i]) rt.pop_back(); r[i] = r[rt.back()] + ar[i] * (rt.back() - i); rt.push_back(i); } for (int i = 1; i <= n; ++i) { ans[i] = l[i] + r[i] - ar[i]; } long long maxa = max_element(ans + 1, ans + n + 1) - ans; for (int i = maxa - 1; i; --i) { if (ar[i] > ar[i + 1]) ar[i] = ar[i + 1]; } for (int i = maxa + 1; i <= n; ++i) if (ar[i - 1] < ar[i]) ar[i] = ar[i - 1]; for (int i = 1; i <= n; ++i) cout << ar[i] << ; cout << n ; return 0; } |
#include <bits/stdc++.h> using namespace std; string getbiner(long long n) { string ret = ; while (n) { if (n % 2) ret += 1 ; else ret += 0 ; n /= 2; } return ret; } long long getnum(string s) { long long ret = 0; long long now = 1; cout << t << ( s ) << = << (s) << n ; for (long long(i) = (0); (i) < (s.length()); (i)++) { ret += ((s[i] - 0 ) * now); now *= 2; } return ret; } int main() { ios::sync_with_stdio(NULL); cin.tie(NULL); cout.tie(NULL); long long n, m; cin >> n >> m; if (n < m) { cout << 0 << n ; return 0; } if ((n - m) % 2) { cout << 0 << n ; return 0; } long long k = (n - m) / 2; string a = getbiner(m); string b = getbiner(k); long long mx = max(a.length(), b.length()); long long diffa = mx - a.length(); long long diffb = mx - b.length(); for (long long(i) = (0); (i) < (diffa); (i)++) a += 0 ; for (long long(i) = (0); (i) < (diffb); (i)++) b += 0 ; reverse(a.begin(), a.end()); reverse(b.begin(), b.end()); long long counter = 0; int flag = 0; for (long long(i) = (0); (i) < (a.length()); (i)++) { if (a[i] == 1 && b[i] == 0 ) { counter++; } else if (a[i] == 1 && b[i] == 1 ) { flag = 1; } } if (flag) { cout << 0 << n ; return 0; } long long ans = pow(2, counter); if (n == m) ans -= 2; cout << ans << n ; } |
#include <bits/stdc++.h> #pragma GCC optimize( Ofast ) #pragma GCC target( avx,avx2,fma ) using namespace std; int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); int n; cin >> n; int arr[n + 1]; int dp[n + 1][3]; for (int i = 1; i <= n; i++) cin >> arr[i]; dp[0][0] = dp[0][1] = dp[0][2] = 0; for (int i = 1; i <= n; i++) { dp[i][0] = max(max(dp[i - 1][1], dp[i - 1][2]), dp[i - 1][0]); if (arr[i] == 0) { dp[i][1] = dp[i - 1][1]; dp[i][2] = dp[i - 1][2]; } if (arr[i] == 1) { dp[i][1] = max(dp[i - 1][0] + 1, dp[i - 1][2] + 1); dp[i][2] = max(dp[i - 1][2], dp[i - 1][0]); } if (arr[i] == 2) { dp[i][2] = max(dp[i - 1][0] + 1, dp[i - 1][1] + 1); dp[i][1] = max(dp[i - 1][1], dp[i - 1][0]); } if (arr[i] == 3) { dp[i][1] = max(dp[i - 1][0] + 1, dp[i - 1][2] + 1); dp[i][2] = max(dp[i - 1][0] + 1, dp[i - 1][1] + 1); } } cout << n - max(dp[n][0], max(dp[n][1], dp[n][2])); return 0; } |
#include <bits/stdc++.h> using namespace std; const int maxn = 2 * 100 * 1000 + 10; bool f1[maxn], f2[maxn]; int n, dis[maxn], dis2[maxn], barg[maxn], mxdis, mxdis2, jj1, j2, h1, h2; vector<int> e[maxn], e2[maxn]; vector<pair<int, int> > v1, v2; void barg2(int v, int p, int t) { f2[v] = true; dis2[v] = t; for (int i = 0; i < e[v].size(); i++) { int u = e[v][i]; if (u != p && u != h2) barg2(u, v, t + 1); } } void barg1(int v, int p, int t) { f1[v] = true; dis[v] = t; for (int i = 0; i < e[v].size(); i++) { int u = e[v][i]; if (u != p && u != h1) barg1(u, v, t + 1); } } int hazf2(int v, int p) { if (v == jj1) return jj1; for (int i = 0; i < e2[v].size(); i++) { int u = e2[v][i]; if (u != p) { int x = hazf2(u, v); if (x != -1) return u; } } return -1; } int hazf1(int v, int p) { if (v == j2) return j2; for (int i = 0; i < e2[v].size(); i++) { int u = e2[v][i]; if (u != p) { int x = hazf1(u, v); if (x != -1) return u; } } return -1; } int dfs4(int v, int p) { int mx1 = 0, mx2 = 0; for (int i = 0; i < e[v].size(); i++) { int u = e[v][i]; if (u != p) { int mx3 = dfs4(u, v); if (mx3 > mx2) mx2 = mx3; if (mx2 > mx1) swap(mx2, mx1); } } barg[v] = mx2 + mx1; return barg[v] + 1; } void dfs3(int v, int p, int t) { dis2[v] = t; for (int i = 0; i < e2[v].size(); i++) { int u = e2[v][i]; if (u != p) dfs3(u, v, t + 1); } return; } void dfs2(int v, int p, int t) { dis[v] = t; for (int i = 0; i < e2[v].size(); i++) { int u = e2[v][i]; if (u != p) dfs2(u, v, t + 1); } return; } bool dfs(int v, int p) { bool f = true; if (e[v].size() > 2) f = false; for (int i = 0; i < e[v].size(); i++) { int u = e[v][i]; if (u != p) if (dfs(u, v) == false) { f = false; e2[v].push_back(u); e2[u].push_back(v); } } return f; } int main() { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); cin >> n; for (int i = 0; i < n; i++) f1[i] = false, f2[i] = false; for (int i = 0; i < n - 1; i++) { int v, u; cin >> v >> u; v--, u--; e[v].push_back(u); e[u].push_back(v); } int v; for (int i = 0; i < n; i++) if (e[i].size() > 2) { v = i; break; } dfs(v, -1); for (int i = 0; i < n; i++) if (e2[i].size() > 0) { v = i; break; } dfs2(v, -1, 0); dfs4(v, -1); mxdis = dis[v]; for (int i = 0; i < n; i++) if (e2[i].size() > 0 && dis[i] > mxdis) { mxdis = dis[i]; v = i; } for (int i = 0; i < n; i++) if (e2[i].size() > 0 && dis[i] == mxdis) v1.push_back({barg[i], i}); dfs3(v, -1, 0); mxdis2 = dis2[v]; for (int i = 0; i < n; i++) if (e2[i].size() > 0 && dis2[i] > mxdis2) mxdis2 = dis2[i]; for (int i = 0; i < n; i++) if (e2[i].size() > 0 && dis2[i] == mxdis2) v2.push_back({barg[i], i}); sort(&v1[0], &v1[v1.size()]); sort(&v2[0], &v2[v2.size()]); reverse(&v1[0], &v1[v1.size()]); reverse(&v2[0], &v2[v2.size()]); if (v1[0].second == v2[0].second) if (v2.size() == 1 || v1[1].first > v2[1].first) jj1 = v1[1].second, j2 = v2[0].second; else jj1 = v1[0].second, j2 = v2[1].second; else jj1 = v1[0].second, j2 = v2[0].second; h1 = hazf1(jj1, -1); h2 = hazf2(j2, -1); barg1(jj1, -1, 0); barg2(j2, -1, 0); mxdis = -1; for (int i = 0; i < n; i++) if (f1[i] == true && dis[i] > mxdis) { mxdis = dis[i]; v = i; } f1[v] = false; cout << v + 1 << ; mxdis = -1; for (int i = 0; i < n; i++) if (f2[i] == true && dis2[i] > mxdis) { mxdis = dis2[i]; v = i; } f2[v] = false; cout << v + 1 << n ; mxdis = -1; for (int i = 0; i < n; i++) if (f1[i] == true && e[i].size() == 1 && dis[i] > mxdis) { mxdis = dis[i]; v = i; } cout << v + 1 << ; mxdis = -1; for (int i = 0; i < n; i++) if (f2[i] == true && e[i].size() == 1 && dis2[i] > mxdis) { mxdis = dis2[i]; v = i; } cout << v + 1 << n ; return 0; } |
#include <bits/stdc++.h> using namespace std; int n; int a[200005]; string ans = ; int main() { ios_base::sync_with_stdio(0); ; cin >> n; for (int i = 0; i < n; i++) { cin >> a[i]; } int l = 0, r = n - 1; int mini = 0; while (l <= r) { if (l == r) { if (a[l] > mini) { ans += L ; } break; } if (a[l] > mini || a[r] > mini) { if (a[l] > mini && a[r] > mini) { if (a[l] < a[r]) { ans += L ; mini = a[l]; l++; } else { ans += R ; mini = a[r]; r--; } } else if (a[l] > mini) { ans += L ; mini = a[l]; l++; } else { ans += R ; mini = a[r]; r--; } } else { break; } } cout << ans.size() << endl; cout << ans << endl; return 0; } |
#include <bits/stdc++.h> #pragma GCC optimize( O3 ) using namespace std; int n, a[100100], m, x, rs = 1e9; int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); cin >> n >> m; for (int i = 1; i <= m; i++) cin >> x, a[x]++; for (int i = 1; i <= n; i++) rs = min(rs, a[i]); cout << rs; return 0; } |
#include <bits/stdc++.h> using namespace std; vector<int> a, b; int x[50]; int main() { int n, l; scanf( %d%d , &n, &l); for (int i = 0; i < (int)n; ++i) scanf( %d , x + i); for (int i = 1; i < (int)n; ++i) a.push_back(x[i] - x[i - 1]); a.push_back(x[0] + l - x[n - 1]); for (int i = 0; i < (int)n; ++i) scanf( %d , x + i); for (int i = 1; i < (int)n; ++i) b.push_back(x[i] - x[i - 1]); b.push_back(x[0] + l - x[n - 1]); for (int i = 0; i < (int)n; ++i) if (a == b) printf( YES n ), exit(0); else { int t = a[0]; for (int j = 1; j < (int)n; ++j) a[j - 1] = a[j]; a[n - 1] = t; } printf( NO n ); } |
#include <bits/stdc++.h> using namespace std; complex<double> r() { double a, b; cin >> a >> b; return {a, b}; } double cross(complex<double> a, complex<double> b) { return (conj(a) * b).imag(); } double orient(complex<double> a, complex<double> b, complex<double> c) { return cross(b - a, c - a); } void up(vector<complex<double> > &st, complex<double> p) { while ((long long)(st).size() >= 2 && orient(st.end()[-2], st.back(), p) >= 0) st.pop_back(); st.push_back(p); } struct line { complex<double> d; double c; line(complex<double> a, complex<double> b) : d(b - a), c(cross(d, a)) {} }; complex<double> inter(line l1, line l2) { return (l1.c * l2.d - l2.c * l1.d) / cross(l1.d, l2.d); } signed main() { ios::sync_with_stdio(false); cin.tie(NULL); long long n; complex<double> obj; cin >> n; obj = r(); vector<complex<double> > ps(n); double mx = 0, my = 0; for (long long i = 0; i < (n); i++) { ps[i] = r(); mx = max(mx, (ps[i].real())); my = max(my, (ps[i].imag())); } ps.push_back({0.0, my}); sort(ps.begin(), ps.end(), [](complex<double> a, complex<double> b) { return make_tuple(a.real(), -a.imag()) < make_tuple(b.real(), -b.imag()); }); vector<complex<double> > hull; for (complex<double> p : ps) up(hull, p); hull.push_back({mx, 0.0}); long long i = upper_bound(hull.begin(), hull.end(), obj, [](complex<double> a, complex<double> b) { return cross(a, b) < 0; }) - hull.begin() - 1; complex<double> a = inter(line(0, obj), line(hull[i], hull[i + 1])); cout << fixed << setprecision(8) << obj.real() / a.real() << n ; } |
#include <bits/stdc++.h> using namespace std; void USACO(string s) { ios_base::sync_with_stdio(0); cin.tie(0); freopen((s + .in ).c_str(), r , stdin); freopen((s + .out ).c_str(), w , stdout); } const long long MAXN = 5010; void solve() { long long n; string s; cin >> n; cin >> s; long long a[n]; for (long long i = 0; i < n; i++) cin >> a[i]; long long dp[n][4]; memset(dp, 0, sizeof(dp)); dp[0][0] = (s[0] != h ? 0 : a[0]); dp[0][1] = (s[0] == h ? 0 : 1e15); dp[0][2] = dp[0][3] = 1e15; for (long long i = 1; i < n; i++) { dp[i][0] = dp[i][1] = dp[i][2] = dp[i][3] = 1e15; dp[i][0] = dp[i - 1][0] + (s[i] == h ? a[i] : 0); if (s[i] == h ) dp[i][1] = dp[i - 1][0]; dp[i][1] = min(dp[i][1], dp[i - 1][1] + (s[i] == a ? a[i] : 0)); if (s[i] == a ) dp[i][2] = dp[i - 1][1]; dp[i][2] = min(dp[i][2], dp[i - 1][2] + (s[i] == r ? a[i] : 0)); if (s[i] == r ) dp[i][3] = dp[i - 1][2]; dp[i][3] = min(dp[i][3], dp[i - 1][3] + (s[i] == d ? a[i] : 0)); } cout << min(min(dp[n - 1][0], dp[n - 1][1]), min(dp[n - 1][2], dp[n - 1][3])) << n ; } int main() { solve(); } |
#include <bits/stdc++.h> using namespace std; const int maxn = 110; const int dx[4] = {0, 0, 1, -1}; const int dy[4] = {1, -1, 0, 0}; int n, m, ret; char G[maxn][maxn]; bool ok(int x, int y) { return x >= 0 && y >= 0 && x < n && y < m; } void dfs(int x, int y) { if (G[x][y] == . ) return; G[x][y] = . ; for (int i = 0; i < (4); i++) { int tx = x + dx[i]; int ty = y + dy[i]; if (ok(tx, ty) && G[tx][ty] == B ) { dfs(tx, ty); } } } signed main() { while (~scanf( %d , &n) && ~scanf( %d , &m)) { memset((G), 0, sizeof(G)); ret = 0; for (int i = 0; i < (n); i++) scanf( %s , G[i]); for (int i = 0; i < (n); i++) { for (int j = 0; j < (m); j++) { if (G[i][j] == B ) { dfs(i, j); ret++; } } } printf( %d n , ret); } return 0; } |
#include <bits/stdc++.h> const int MOD = int(1E9) + 7; const int MAXN = 100000; int pw[MAXN + 5], cnt[MAXN + 5]; void init() { pw[0] = 1; for (int i = 1; i <= MAXN; i++) pw[i] = 2LL * pw[i - 1] % MOD; } int main() { init(); int n, x; scanf( %d , &n); for (int i = 1; i <= n; i++) { scanf( %d , &x); if (x != -1) cnt[x]++; } int ans = pw[n - 1] - 1; for (int i = 1; i <= n; i++) ans = (ans - 1LL * (pw[cnt[i]] - 1) % MOD) % MOD; printf( %d n , (ans + MOD) % MOD); } |
#include <bits/stdc++.h> using namespace std; void fre() { freopen( c://test//input.in , r , stdin); freopen( c://test//output.out , w , stdout); } template <class T1, class T2> inline void gmax(T1 &a, T2 b) { if (b > a) a = b; } template <class T1, class T2> inline void gmin(T1 &a, T2 b) { if (b < a) a = b; } const int N = 5005, M = 0, Z = 1e9 + 7; const int inf = 0x3f3f3f3f; template <class T1, class T2> inline void gadd(T1 &a, T2 b) { a = (a + b) % Z; } int casenum, casei; int n, m; int f[N][N]; int d[N][N]; int v[N]; int c[N]; vector<int> a[N]; int sz[N]; void dfs(int x) { f[x][0] = d[x][0] = sz[x] = 0; for (auto y : a[x]) { dfs(y); for (int i = sz[x]; ~i; --i) { for (int j = 1; j <= sz[y]; ++j) { gmin(f[x][i + j], f[x][i] + f[y][j]); gmin(f[x][i + j], f[x][i] + d[y][j]); gmin(d[x][i + j], d[x][i] + d[y][j]); } } sz[x] += sz[y]; } ++sz[x]; for (int i = sz[x]; i; --i) { f[x][i] = min(f[x][i - 1] + v[x] - c[x], inf); gmin(d[x][i], d[x][i - 1] + v[x]); } } int main() { while (~scanf( %d%d , &n, &m)) { memset(f, 63, sizeof(f)); memset(d, 63, sizeof(d)); for (int i = 1; i <= n; ++i) { a[i].clear(); scanf( %d%d , &v[i], &c[i]); if (i > 1) { int fa; scanf( %d , &fa); a[fa].push_back(i); } } dfs(1); int ans = 0; for (int i = 1; i <= n; ++i) { if (f[1][i] <= m || d[1][i] <= m) { gmax(ans, i); } } printf( %d n , ans); } return 0; } |
#include <bits/stdc++.h> using namespace std; const int mod = 1000003; const int maxn = 500010; int n, m; char str[maxn]; struct node { int lr, ud; } ma[maxn]; inline char s(int i, int j) { return str[(i - 1) * m + (j - 1)]; } int tran(int i, int j) { return (i - 1) * m + (j - 1); } int solve() { int ret = 1; for (int i = 1; i <= n; ++i) { for (int j = 1; j <= m; ++j) { int ind = tran(i, j); char cha = s(i, j); if (cha >= 1 && cha <= 4 ) { if (cha == 1 ) { if (ma[ind].lr != 0 && ma[ind].lr != 1) return -1; if (ma[ind].ud != 0 && ma[ind].ud != 1) return -1; ma[ind].lr = 1; ma[ind].ud = 1; for (int k = i - 1; k >= 1; --k) { int tp = tran(k, j); if (ma[tp].ud == 0) ma[tp].ud = ((i - k) % 2 ? 2 : 1); else { if (ma[tp].ud != ((i - k) % 2 ? 2 : 1)) return -1; else break; } } for (int k = i + 1; k <= n; ++k) { int tp = tran(k, j); if (ma[tp].ud == 0) ma[tp].ud = ((k - i) % 2 ? 2 : 1); else { if (ma[tp].ud != ((k - i) % 2 ? 2 : 1)) return -1; else break; } } for (int k = j - 1; k >= 1; --k) { int tp = tran(i, k); if (ma[tp].lr == 0) ma[tp].lr = ((j - k) % 2 ? 2 : 1); else { if (ma[tp].lr != ((j - k) % 2 ? 2 : 1)) return -1; else break; } } for (int k = j + 1; k <= m; ++k) { int tp = tran(i, k); if (ma[tp].lr == 0) ma[tp].lr = ((k - j) % 2 ? 2 : 1); else { if (ma[tp].lr != ((k - j) % 2 ? 2 : 1)) return -1; else break; } } } else if (cha == 2 ) { if (ma[ind].lr != 0 && ma[ind].lr != 1) return -1; if (ma[ind].ud != 0 && ma[ind].ud != 2) return -1; ma[ind].lr = 1; ma[ind].ud = 2; for (int k = i - 1; k >= 1; --k) { int tp = tran(k, j); if (ma[tp].ud == 0) ma[tp].ud = ((i - k) % 2 ? 1 : 2); else { if (ma[tp].ud != ((i - k) % 2 ? 1 : 2)) return -1; else break; } } for (int k = i + 1; k <= n; ++k) { int tp = tran(k, j); if (ma[tp].ud == 0) ma[tp].ud = ((k - i) % 2 ? 1 : 2); else { if (ma[tp].ud != ((k - i) % 2 ? 1 : 2)) return -1; else break; } } for (int k = j - 1; k >= 1; --k) { int tp = tran(i, k); if (ma[tp].lr == 0) ma[tp].lr = ((j - k) % 2 ? 2 : 1); else { if (ma[tp].lr != ((j - k) % 2 ? 2 : 1)) return -1; else break; } } for (int k = j + 1; k <= m; ++k) { int tp = tran(i, k); if (ma[tp].lr == 0) ma[tp].lr = ((k - j) % 2 ? 2 : 1); else { if (ma[tp].lr != ((k - j) % 2 ? 2 : 1)) return -1; else break; } } } else if (cha == 3 ) { if (ma[ind].lr != 0 && ma[ind].lr != 2) return -1; if (ma[ind].ud != 0 && ma[ind].ud != 2) return -1; ma[ind].lr = 2; ma[ind].ud = 2; for (int k = i - 1; k >= 1; --k) { int tp = tran(k, j); if (ma[tp].ud == 0) ma[tp].ud = ((i - k) % 2 ? 1 : 2); else { if (ma[tp].ud != ((i - k) % 2 ? 1 : 2)) return -1; else break; } } for (int k = i + 1; k <= n; ++k) { int tp = tran(k, j); if (ma[tp].ud == 0) ma[tp].ud = ((k - i) % 2 ? 1 : 2); else { if (ma[tp].ud != ((k - i) % 2 ? 1 : 2)) return -1; else break; } } for (int k = j - 1; k >= 1; --k) { int tp = tran(i, k); if (ma[tp].lr == 0) ma[tp].lr = ((j - k) % 2 ? 1 : 2); else { if (ma[tp].lr != ((j - k) % 2 ? 1 : 2)) return -1; else break; } } for (int k = j + 1; k <= m; ++k) { int tp = tran(i, k); if (ma[tp].lr == 0) ma[tp].lr = ((k - j) % 2 ? 1 : 2); else { if (ma[tp].lr != ((k - j) % 2 ? 1 : 2)) return -1; else break; } } } else { if (ma[ind].lr != 0 && ma[ind].lr != 2) return -1; if (ma[ind].ud != 0 && ma[ind].ud != 1) return -1; ma[ind].lr = 2; ma[ind].ud = 1; for (int k = i - 1; k >= 1; --k) { int tp = tran(k, j); if (ma[tp].ud == 0) ma[tp].ud = ((i - k) % 2 ? 2 : 1); else { if (ma[tp].ud != ((i - k) % 2 ? 2 : 1)) return -1; else break; } } for (int k = i + 1; k <= n; ++k) { int tp = tran(k, j); if (ma[tp].ud == 0) ma[tp].ud = ((k - i) % 2 ? 2 : 1); else { if (ma[tp].ud != ((k - i) % 2 ? 2 : 1)) return -1; else break; } } for (int k = j - 1; k >= 1; --k) { int tp = tran(i, k); if (ma[tp].lr == 0) ma[tp].lr = ((j - k) % 2 ? 1 : 2); else { if (ma[tp].lr != ((j - k) % 2 ? 1 : 2)) return -1; else break; } } for (int k = j + 1; k <= m; ++k) { int tp = tran(i, k); if (ma[tp].lr == 0) ma[tp].lr = ((k - j) % 2 ? 1 : 2); else { if (ma[tp].lr != ((k - j) % 2 ? 1 : 2)) return -1; else break; } } } } } } map<int, bool> row, col; map<int, bool>::iterator it; for (int i = 1; i <= n; ++i) { for (int j = 1; j <= m; ++j) { int ind = tran(i, j); if (!ma[ind].lr) row[i] = 1; if (!ma[ind].ud) col[j] = 1; } } for (int i = 1; i <= row.size(); ++i) ret = ret * 2 % mod; for (int i = 1; i <= col.size(); ++i) ret = ret * 2 % mod; return ret; } int main() { while (~scanf( %d%d , &n, &m)) { int ans = 0; memset(ma, 0, sizeof(ma)); for (int i = 1; i <= n; ++i) scanf( %s , str + (i - 1) * m); int ret = solve(); if (ret == -1) puts( 0 ); else printf( %d n , ret); } return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int t; long long k, x; cin >> t; while (t--) { cin >> k >> x; cout << x + ((k - 1) * 9) << endl; } } |
#include <bits/stdc++.h> using namespace std; long long n, t, i, j, a[300006], q; int main() { scanf( %lld , &t); while (t--) { long long ans = 0; memset(a, 0, sizeof a); scanf( %lld%lld , &n, &q); for (i = 1; i <= n; i++) { scanf( %lld , &a[i]); } long long flag = 0; for (i = 1; i <= n; i++) { if (a[i] > a[i - 1] && a[i] > a[i + 1] && flag == 0) { ans += a[i]; flag = 1; } else if (a[i] < a[i - 1] && a[i] < a[i + 1] && flag == 1) { ans -= a[i]; flag = 0; } } printf( %lld n , ans); } } |
#include <bits/stdc++.h> using namespace std; int main() { int t; cin >> t; while (t--) { int n, k1, k2; cin >> n >> k1 >> k2; bool ya = 0; while (k1--) { int a; cin >> a; if (a == n) { ya = 1; } } while (k2--) { int a; cin >> a; } if (ya) { cout << YES << endl; } else { cout << NO << endl; } } } |
#include <bits/stdc++.h> using namespace std; const int MAXN = 2010; vector<int> edges[MAXN]; queue<int> q; int visited[MAXN]; int main() { int n, m, a, b; char x; cin >> n >> m; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { cin >> x; if (x == # ) { edges[i].push_back(n + j); edges[n + j].push_back(i); } } } q.push(n - 1); q.push(0); while (!q.empty()) { a = q.front(); q.pop(); b = q.front(); q.pop(); if (a == 0) { cout << b; return 0; } for (int i : edges[a]) { if (!visited[i]) { q.push(i); q.push(b + 1); visited[i] = true; } } } cout << -1; return 0; } |
#include <bits/stdc++.h> using namespace std; const int maxn = 1e6 + 5; int n, q; int a[maxn], b[maxn], f[maxn], g[maxn][30]; int c(int l, int r) { int k = (int)log2(r - l + 1); return max(g[l][k], g[r - (1 << k) + 1][k]); } void solve() { cin >> n; for (int i = 1; i <= n; ++i) cin >> a[i]; cin >> q; for (int i = 1; i <= q; ++i) { int id, p, first; cin >> id; if (id == 1) { cin >> p >> first; a[p] = first; b[p] = i; } else cin >> f[i]; } for (int i = 1; i <= q; ++i) g[i][0] = f[i]; int m = (int)log2(q) + 1; for (int j = 1; j <= m; ++j) for (int i = 1; i + (1 << (j - 1)) - 1 <= q; ++i) g[i][j] = max(g[i][j - 1], g[i + (1 << (j - 1))][j - 1]); for (int i = 1; i <= n; ++i) cout << max(a[i], c(max(1, b[i]), q)) << ; } int main() { solve(); } |
#include <bits/stdc++.h> using namespace std; string itos(int a) { if (!a) return 0 ; string res; while (a) { res += (char)( 0 + (a % 10)); a /= 10; } reverse((res).begin(), (res).end()); return res; } int main() { int n; int a[10], can = 0; ; cin >> n; for (int i = 0; i < n; i++) { cin >> a[i]; can |= 1 << a[i]; } if (n > 6) { cout << 0 << endl; return 0; } vector<string> v; vector<int> mask; for (int i = 0; i < 256; i++) { string s = itos(i); int tmp = 0; for (int j = 0; j < s.size(); j++) { tmp |= 1 << (int)(s[j] - 0 ); } if ((tmp & can) == tmp) { v.push_back(s); mask.push_back(tmp); } } vector<string> ans; for (int i = 0; i < (int)(v.size()); i++) for (int j = 0; j < (int)(v.size()); j++) { int size = min(v[i].size(), v[j].size()); bool f = true; for (int k = 0; k < size; k++) { if (v[i][k] != v[j][v[j].size() - 1 - k]) { f = false; break; } } if (!f) continue; for (int k = 0; k < (int)(v.size()); k++) for (int l = 0; l < (int)(v.size()); l++) { if ((mask[i] | mask[j] | mask[k] | mask[l]) != can) continue; string s = v[i] + v[k] + v[l] + v[j]; bool f = true; for (int x = 0; 2 * x < s.size(); x++) { if (s[x] != s[s.size() - 1 - x]) { f = false; break; } } if (f) ans.push_back(v[i] + . + v[k] + . + v[l] + . + v[j]); } } cout << ans.size() << endl; for (int i = 0; i < ans.size(); i++) cout << ans[i] << endl; } |
#include <bits/stdc++.h> #pragma GCC target( avx2 ) #pragma GCC optimization( O3 ) #pragma GCC optimization( unroll-loops ) using namespace std; long long fn(long long x, long long rn[]) { if (x == rn[x]) return x; else return rn[x] = fn(rn[x], rn); } bool un(long long x, long long y, long long rn[], long long sz[]) { x = fn(x, rn); y = fn(y, rn); if (x == y) return false; if (sz[x] < sz[y]) swap(x, y); sz[x] += sz[y]; rn[y] = x; return true; } long long gcd(long long a, long long b) { if (!b) return a; return gcd(b, a % b); } long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); } long long MOD = 998244353; long long mod = 1000000007; long long power(long long x, long long y, long long p) { long long res = 1; x %= p; while (y > 0) { if (y & 1) res = (res * x) % p; y = y >> 1; x = (x * x) % p; } return res; } long long inv(long long val, long long MODx = MOD) { return power(val, MODx - 2, MODx); } vector<long long> fac, ifac; void preFac(long long sz) { fac.resize(sz + 1), ifac.resize(sz + 1); fac[0] = 1; for (int i = 1; i <= sz; i++) { fac[i] = (i * fac[i - 1]) % MOD; } ifac[sz] = inv(fac[sz]); for (int i = sz - 1; i >= 0; i--) { ifac[i] = ((i + 1) * ifac[i + 1]) % MOD; } } long long nCr(long long N, long long R) { if (R <= N and R >= 0) { return ((fac[N] * ifac[R]) % MOD * ifac[N - R]) % MOD; } return 0; } int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); long long n, k; cin >> n >> k; map<long long, long long> pos; long long p[n + 1], q[n + 1]; for (long long i = 1; i <= n; i++) { cin >> p[i]; } for (long long i = 1; i <= n; i++) { cin >> q[i]; pos[q[i]] = i; } long long pt = 1; long long pt_cons = 1; vector<vector<long long>> comp; vector<long long> vec; while (pt <= n) { vec.push_back(p[pt]); pt_cons = max(pt_cons, pos[p[pt]]); if (pt == pt_cons) { comp.push_back(vec); vec.clear(); pt_cons = 1; } pt++; } if (!vec.empty()) { comp.push_back(vec); } if (comp.size() < k) { cout << NO ; return 0; } string ans(n + 1, * ); char x = a ; for (auto u : comp) { for (auto v : u) { ans[v] = x; } x++; if (x == ( z + 1)) { x = z ; } } cout << YES n ; for (long long i = 1; i <= n; i++) { cout << ans[i]; } } |
#include <bits/stdc++.h> using namespace std; int n, s; int c[3]; void init() { int score; scanf( %d%d , &n, &s); for (int i = 0; i < n; i++) { scanf( %d , &score); c[score - 3]++; } } int gcd(int a, int b) { return b ? gcd(b, a % b) : a; } void extended_gcd(int a, int b, int c, int &x, int &y) { if (!b) { x = c / a, y = 0; return; } extended_gcd(b, a % b, c, y, x); y -= (a / b) * x; } void solve() { int k[3], ret = 0x7FFFFFFF; int d = gcd(c[1], c[2]); for (int i = 0; i <= s; i++) { int A = c[1], B = c[2], C = s - i * c[0], x, y; if (C < 0) break; if (C % d != 0) continue; extended_gcd(A, B, C, x, y); int delta1 = B / d, delta2 = A / d; if (y > x && delta2 != 0) { int delta = (y - x) / delta2; y -= delta2 * delta; x += delta1 * delta; } for (int step = 17; step >= 0; step--) { if (y >= x) break; if (y + delta2 * (1 << step) <= x - delta1 * (1 << step)) { y += delta2 * (1 << step); x -= delta1 * (1 << step); } } if (c[1] * x > c[2] * y) { for (int step = 17; step >= 0; step--) if (x - delta1 * (1 << step) >= i) { if (c[1] * (x - delta1 * (1 << step)) >= c[2] * (y + delta2 * (1 << step))) { x -= delta1 * (1 << step); y += delta2 * (1 << step); } } } if (y < i && delta2 != 0) { int delta = (i - y - 1) / delta2 + 1; y += delta2 * delta; x -= delta1 * delta; } for (int j = 0;; j++) { if (x >= i && y >= x && abs(c[0] * i - c[1] * x) + abs(c[1] * x - c[2] * y) < ret) { ret = abs(c[0] * i - c[1] * x) + abs(c[1] * x - c[2] * y); k[0] = i, k[1] = x, k[2] = y; } if (y >= x && c[2] * y > c[1] * x) { break; } y += delta2; x -= delta1; if (x < i) break; } } if (ret == 0x7FFFFFFF) { printf( %d n , -1); } else printf( %d %d %d n , k[0], k[1], k[2]); } int main() { init(); solve(); return 0; } |
#include <bits/stdc++.h> using namespace std; const int N = 1e5 + 5; const int M = 1e9 + 7; long long a[N]; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); long long a, b, x, y, z; cin >> a >> b >> x >> y >> z; cout << max(0ll, y - (a - 2 * x)) + max(0ll, y - (b - 3 * z)); } |
#include <bits/stdc++.h> using namespace std; template <typename Arg1> void __f(const char* name, Arg1&& arg1) { std::cerr << name << : << arg1 << endl; } template <typename Arg1, typename... Args> void __f(const char* names, Arg1&& arg1, Args&&... args) { const char* comma = strchr(names + 1, , ); std::cerr.write(names, comma - names) << : << arg1 << | ; __f(comma + 1, args...); } const long long MOD = 998244353; const long long INFLL = 0x3f3f3f3f3f3f3f3f; const int INF = 0x3f3f3f3f; const long long MAXN = 1e+5 + 7; const int m = 998244353; const int nax = 1e6; long long fatorial[nax + 1]; long long binary_pow(long long a, long long b) { a = a % m; long long ans = 1; while (b > 0) { if (b & 1) { ans = (ans * a) % m; } a = (a * a) % m; b = b >> 1; } return ans; } long long modular_inverse(long long a) { return binary_pow(a, m - 2); } void calcula_fatorial() { fatorial[0] = 1; for (int i = 1; i <= nax; i++) { fatorial[i] = (fatorial[i - 1] * i) % m; } } long long binomial_coefficient(int n, int k) { return fatorial[n] * modular_inverse(fatorial[k]) % m * modular_inverse(fatorial[n - k]) % m; } void solve() { long long n, k; cin >> n >> k; set<long long> evento; map<long long, long long> entrada, saida; for (int i = 0; i < n; ++i) { long long a, b; cin >> a >> b; evento.insert(a); evento.insert(b); entrada[a]++; saida[b]++; } long long ans = 0, sz = 0; for (auto e : evento) { sz += entrada[e]; for (int i = 0; i < saida[e]; ++i) { if (sz - 1 < k - 1) { sz--; continue; } ans += binomial_coefficient(sz - 1, k - 1); ans %= m; sz--; } } cout << ans << n ; } int main() { calcula_fatorial(); ios_base::sync_with_stdio(0); cin.tie(0); long long i, j, n; int t = 1; while (t--) solve(); return 0; } |
#include<bits/stdc++.h> using namespace std; #define INF 1234567890 #define ll long long int T; int N, M, P; vector<int> g[400401], h[400401]; bool vis[400401], reach[400401], loop[400401]; vector<int> st; int myscc[400401], sz[400401], dp[400401]; void DFS(int n) { vis[n] = true; for(int next : g[n]) { if (vis[next]) continue; DFS(next); } st.push_back(n); } void DFS2(int n) { vis[n] = true; for(int next : h[n]) { if (vis[next]) continue; DFS2(next); } myscc[n] = P; sz[P]++; } void DFS3(int n) { vis[n] = true; for(int next : g[n]) { if (vis[next]) continue; DFS3(next); } } bool isScc(int i) { return (sz[myscc[i]] >= 2 || loop[i]); } int main() { ios::sync_with_stdio(0); cin.tie(0); cin.exceptions(ios::badbit | ios::failbit); cin >> T; while(T--) { cin >> N >> M; // clear P = 0; for(int i=1; i<=N; i++) { g[i].clear(); h[i].clear(); } memset(vis, 0, sizeof(bool)*(N+1)); memset(reach, 0, sizeof(bool)*(N+1)); memset(loop, 0, sizeof(bool)*(N+1)); st.clear(); for(int i=0; i<M; i++) { int a, b; cin >> a >> b; if (a == b) { loop[a] = true; continue; } g[a].push_back(b); h[b].push_back(a); } DFS(1); for(int i=1; i<=N; i++) if (vis[i]) reach[i] = true; for(int i=1; i<=N; i++) if (!vis[i]) DFS(i); memset(vis, 0, sizeof(bool)*(N+1)); reverse(st.begin(), st.end()); // DFS μ’
λ£ μμ = μμμ λ ¬μ for(int n : st) { if (vis[n]) continue; sz[P] = 0; DFS2(n); P++; } memset(vis, 0, sizeof(bool)*(N+1)); for(int i=1; i<=N; i++) if (reach[i] && isScc(i) && !vis[i]) DFS3(i); // 1 -> scc -> xκ° κ°λ₯νκ°? memset(dp, 0, sizeof(int)*(N+1)); // 0,1,2+ dp[1] = 1; for(int n : st) { if (dp[n] > 2) dp[n] = 2; for(int next : g[n]) dp[next] += dp[n]; } for(int i=1; i<=N; i++) { if (reach[i] == false) cout << 0 ; else if (vis[i]) cout << -1 ; else if (dp[i] >= 2) cout << 2 ; else cout << 1 ; } cout << n ; } return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); ; int t; cin >> t; vector<int> a(7); while (t--) { long long k; cin >> k; int sum = 0; for (int i = 0; i < 7; i++) { cin >> a[i]; sum += a[i]; } long long ans = (k / sum) * 7; long long rem = k % sum; if (rem == 0) { ans -= 7; rem = sum; } int min = 7; int count = 0, count_sum = 0; for (int i = 0; i < 7; i++) { count = 0; count_sum = 0; for (int j = 0; j < 7; j++) { count++; if (a[(i + j) % 7]) { count_sum++; } if (count_sum == rem) { if (count < min) { min = count; break; } } } } cout << ans + min << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; struct node { int go[2], sum; node(int x0, int x1, int _sum) { go[0] = x0, go[1] = x1, sum = _sum; } }; node root(-1, -1, 0); vector<node> t = {root}; int get_sum(int v) { return v == -1 ? 0 : t[v].sum; } int go(int v, int id) { if (t[v].go[id] == -1) { t[v].go[id] = t.size(); t.push_back(node(-1, -1, 0)); } return t[v].go[id]; } void add(int a) { int v = 0; for (int bit = 29; bit >= 0; bit--) { int x = (a >> bit) & 1; v = go(v, x); t[v].sum++; } } int get(int a, int k) { int v = 0, ans = 0, bit = 29; while (bit >= 0) { int x = (a >> bit) & 1, y = (k >> bit) & 1; if (x > y) ans += get_sum(t[v].go[0]); if ((x ^ 1) > y) ans += get_sum(t[v].go[1]); if (t[v].go[x ^ y] == -1) break; v = go(v, x ^ y); bit--; } if (bit == -1) ans += t[v].sum; return ans; } void solve() { int n, k; cin >> n >> k; add(0); long long pref = 0, ans = 0; for (int i = 1; i <= n; i++) { int v; cin >> v; pref = pref ^ v; ans += get(pref, k); add(pref); } cout << ans << n ; } int main() { ios::sync_with_stdio(NULL), cin.tie(0), cout.tie(0); cout.setf(ios::fixed), cout.precision(20); solve(); } |
#include <bits/stdc++.h> using namespace std; long long mod = 1000000009; long long A[200000]; long long root(long long a) { long long i = a; if (A[i] != i) { A[i] = root(A[i]); } return A[a]; } void unio(long long a, long long b) { long long ra = root(a); long long rb = root(b); if (ra != rb) { A[ra] = rb; } } signed main() { long long n, m; cin >> n >> m; long long val = 1; for (long long i = 1; i <= n; i++) { A[i] = i; } for (long long i = 1; i <= m; i++) { long long a, b; cin >> a >> b; if (root(a) == root(b)) { val = (val * 2LL) % mod; } else { unio(a, b); } val--; val = (val + mod) % mod; cout << val << endl; val++; } } |
#include <bits/stdc++.h> const int maxn = 200005, K = 37, mod = 1e9 + 7; int add(int a, int b) { return a + b >= mod ? a + b - mod : a + b; } int dec(int a, int b) { return a - b < 0 ? a - b + mod : a - b; } int mul(int a, int b) { return 1ll * a * b % mod; } int ksm(int a, int b = mod - 2) { int ret = 1; for (; b; b >>= 1, a = mul(a, a)) if (b & 1) ret = mul(ret, a); return ret; } int n, a[maxn]; std::tuple<int, int, int> p[maxn]; int f[maxn], c[maxn], mx, ans; void ins(int x, int v) { for (; x <= mx; x += x & -x) c[x] = std::max(c[x], v); } int ask(int x) { int res = 0xcfcfcfcf; for (; x; x -= x & -x) res = std::max(res, c[x]); return res; } int main() { memset(c, 0xcf, sizeof(c)); memset(f, 0xcf, sizeof(f)); scanf( %d , &n); for (int i = 1; i <= n; i++) scanf( %d , a + i), p[i] = std::make_tuple(i - a[i], a[i], i), mx = std::max(mx, a[i]); mx++; std::sort(p + 1, p + 1 + n); ins(1, 0); for (int i = 1; i <= n; i++) { if (std::get<2>(p[i]) >= std::get<1>(p[i])) f[i] = ask(std::get<1>(p[i])) + 1; ins(std::get<1>(p[i]) + 1, f[i]); ans = std::max(ans, f[i]); } printf( %d n , ans); return 0; } |
#include <bits/stdc++.h> using namespace std; const int INF = (1 << 30) - 1; const long long lINF = (1LL << 62) - 1; const double dINF = 1e40; const int MAXT = 1 << 22, MAXN = 1001000; struct seg_tree { int sum[MAXT], len; void build(int n) { for (len = 1; len < n; len <<= 1) ; } template <int val> void update(int pos) { for (int x = pos + len; x > 0; x >>= 1) sum[x] += val; } int find(int k) { int x; for (x = 1; x < len;) { x <<= 1; if (sum[x] < k) { k -= sum[x]; x ^= 1; } } return x - len; } } ds; int pos[MAXT], val[MAXN]; bool app[MAXN]; int main() { int n, m; scanf( %d%d , &n, &m); ds.build(n + m); for (int i = 0; i < n; i++) { pos[m + i] = i; ds.update<1>(m + i); } memset(val, -1, sizeof(val)); bool flag = true; for (int i = m - 1; i >= 0; i--) { int k, mark; scanf( %d%d , &mark, &k); int p = ds.find(k), op = pos[p]; ds.update<-1>(p); pos[i] = op; ds.update<1>(i); if (val[op] == -1) val[op] = mark; else if (val[op] != mark) { flag = false; break; } } memset(app, false, sizeof(app)); for (int i = 0; i < n; i++) if (val[i] != -1) { if (app[val[i]]) { flag = false; break; } app[val[i]] = true; } if (flag) { for (int i = 0, v = 1; i < n; i++) { if (val[i] == -1) { for (; app[v]; ++v) ; app[v] = true; val[i] = v; } if (i == n - 1) printf( %d n , val[i]); else printf( %d , val[i]); } } else puts( -1 ); return 0; } |
#include <bits/stdc++.h> using namespace std; const long long INF = (long long)-1e18; const int N = 200 * 1000 + 100; vector<int> g[N]; vector<int> w[N]; vector<pair<long long, long long> > cur; long long add[N]; long long ans[N]; int a[N]; long long dfs2(int v) { ans[v] = add[v]; for (int i = 0; i < g[v].size(); i++) ans[v] += dfs2(g[v][i]); return ans[v]; } void dfs(int v, int par, long long h) { if (v != par) { long long dist = h - a[v]; vector<pair<long long, long long> >::iterator it = lower_bound( cur.begin(), cur.end(), pair<long long, long long>(dist, INF)); add[par]++; if (it != cur.begin()) { it--; add[it->second]--; } } cur.push_back(pair<long long, long long>(h, v)); for (int i = 0; i < g[v].size(); i++) dfs(g[v][i], v, h + w[v][i]); cur.pop_back(); } int main() { int n; cin >> n; for (int i = 0; i < n; i++) { cin >> a[i]; } for (int i = 1; i < n; i++) { int p, l; cin >> p >> l; p--; g[p].push_back(i); w[p].push_back(l); } dfs(0, 0, 0); dfs2(0); for (long long i = 0; i < n; i++) cout << ans[i] << ; cout << endl; } |
#include <bits/stdc++.h> using namespace std; std::mt19937 rnd( (int)std::chrono::steady_clock::now().time_since_epoch().count()); long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); } const int NDIG = 6; const int MAXQ = 100000; const int MAXSUM = 999999; int nvals; int gain[NDIG]; int nq; int q[MAXQ]; long long qans[MAXQ]; long long dp[NDIG + 1][MAXSUM + 1]; long long tmp[MAXSUM + 1]; pair<long long, int> qq[MAXSUM + 1]; int qhead, qtail; void solve() { for (int ndig = (0); ndig <= (NDIG); ++ndig) for (int sum = (0); sum <= (MAXSUM); ++sum) dp[ndig][sum] = ndig == 0 && sum == 0 ? 0 : LLONG_MIN; for (int ndig = (1); ndig <= (NDIG); ++ndig) { int curgain = gain[NDIG - ndig]; long long vargain = (long long)10 * curgain; for (int sum = (0); sum <= (MAXSUM); ++sum) tmp[sum] = dp[ndig - 1][sum] == LLONG_MIN ? LLONG_MIN : dp[ndig - 1][sum] - (sum / 3) * vargain; for (int mod = (0); mod < (30); ++mod) if (mod <= 9 * nvals) { long long fixedgain = (long long)(mod / 3) * curgain; qhead = qtail = 0; for (int sum = mod; sum <= MAXSUM; sum += 10) { int fst = (sum - mod) / 10; int qmx = min((sum - mod) / 30, (9 * nvals - mod) / 30); long long now = tmp[fst]; while (qtail < qhead && now >= qq[qhead - 1].first) --qhead; qq[qhead++] = make_pair(now, fst); while (qtail < qhead && qq[qtail].second < fst - (qmx - 10)) ++qtail; long long best = qtail < qhead ? qq[qtail].first : LLONG_MIN; if (best != LLONG_MIN) { dp[ndig][sum] = max(dp[ndig][sum], best + fixedgain + (fst / 3) * vargain); } for (int q = (max(0, qmx - 10)); q <= (qmx); ++q) { long long opt = dp[ndig - 1][fst - 3 * q]; if (opt == LLONG_MIN) continue; int nthree = mod / 3 + 10 * q; opt += fixedgain + q * vargain; if (nthree >= 3 * (nvals - 1) && mod % 3 != 0) opt -= (long long)(nthree - 3 * (nvals - 1)) * curgain; dp[ndig][sum] = max(dp[ndig][sum], opt); } } } } for (int i = (0); i < (nq); ++i) qans[i] = dp[NDIG][q[i]]; } void run() { scanf( %d , &nvals); for (int i = (0); i < (NDIG); ++i) scanf( %d , &gain[i]); scanf( %d , &nq); for (int i = (0); i < (nq); ++i) scanf( %d , &q[i]); solve(); for (int i = (0); i < (nq); ++i) printf( %lld n , qans[i]); } long long qansstupid[MAXQ]; void solvestupid() { auto calc = [&](int x) { long long ret = 0; for (int i = 0; x > 0; ++i, x /= 10) if (x % 10 % 3 == 0) ret += (long long)(x % 10 / 3) * gain[i]; return ret; }; for (int i = (0); i < (nq); ++i) { int sum = q[i]; qansstupid[i] = LLONG_MIN; if (nvals == 4) { for (int a = (0); a <= (sum); ++a) for (int b = (0); b <= (sum - a); ++b) for (int c = (0); c <= (sum - a - b); ++c) { int d = sum - a - b - c; long long cur = calc(a) + calc(b) + calc(c) + calc(d); qansstupid[i] = max(qansstupid[i], cur); } } else if (nvals == 3) { for (int a = (0); a <= (sum); ++a) for (int b = (0); b <= (sum - a); ++b) { int c = sum - a - b; long long cur = calc(a) + calc(b) + calc(c); qansstupid[i] = max(qansstupid[i], cur); } } else if (nvals == 2) { for (int a = (0); a <= (sum); ++a) { int b = sum - a; long long cur = calc(a) + calc(b); qansstupid[i] = max(qansstupid[i], cur); } } else if (nvals == 1) { int a = sum; long long cur = calc(a); qansstupid[i] = max(qansstupid[i], cur); } else { assert(false); } } } void stress() { for (int rep = (0); rep < (1000); ++rep) { nvals = rnd() % 4 + 1; int sum = rnd() % (nvals == 4 ? 100 : 10000) + 1; for (int i = (0); i < (NDIG); ++i) gain[i] = rnd() % 1000 + 1; nq = 1, q[0] = sum; solve(); solvestupid(); bool ok = true; for (int i = (0); i < (nq); ++i) if (qans[i] != qansstupid[i]) ok = false; if (ok) { printf( . ); continue; } printf( err have=%lld want=%lld n , qans[0], qansstupid[0]); printf( %d n , nvals); for (int i = (0); i < (NDIG); ++i) { if (i != 0) printf( ); printf( %d , gain[i]); } puts( ); printf( %d n , nq); for (int i = (0); i < (nq); ++i) printf( %d n , q[i]); } } int main() { run(); return 0; } |
#include <bits/stdc++.h> using namespace std; bool isprime(int a) { for (int i = 2; i * i <= a; i++) { if (a % i == 0) return false; } return true; } bool v[10010]; int gcd(int a, int b) { if (a % b == 0) return b; return gcd(b, a % b); } int main() { int T; cin >> T; for (int i = 2; i < 10010; i++) { v[i] = isprime(i); } while (T--) { int a; int b; cin >> a >> b; if (a == 1 || b == 1) { cout << Finite << endl; continue; } if (gcd(a, b) == 1) { cout << Finite << endl; continue; } else { cout << Infinite << endl; continue; } } return 0; } |
#include <bits/stdc++.h> const long long mod = 1000000007; const long long Inf = 2 * 1e9; using namespace std; long long toint(string s) { long long anss = 0; for (int(i) = 0; (i) < s.length(); (i)++) anss = anss * 10 + (s[i] - 0 ); return anss; } long long gcd(long long a, long long b) { if (b == 0) return a; else return gcd(b, a % b); } long long lcm(long long a, long long b) { return a / gcd(a, b) * b; } vector<bool> used(200001, false); vector<int> g(200001); void dfs(int v) { used[v] = true; if (!used[g[v]]) dfs(g[v]); } int main() { int n; cin >> n; vector<int> t(n + 1), ch(n + 1); for (int(i) = 1; (i) < n + 1; (i)++) { scanf( %d , &t[i]); if (i > 1) t[i] -= t[1]; } t[1] = 0; ch[0] = 0; for (int(i) = 1; (i) < n + 1; (i)++) { int ans = 20; ch[i] = ch[i - 1]; int pos = lower_bound((t).begin(), (t).end(), max(0, t[i] - 89)) - t.begin(); int sum = ch[i] - ch[max(0, pos - 1)]; ans = min({ans, 50 - sum}); pos = lower_bound((t).begin(), (t).end(), max(0, t[i] - 1439)) - t.begin(); sum = ch[i] - ch[max(0, pos - 1)]; ans = min({ans, 120 - sum}); ch[i] += ans; printf( %d n , ans); } return 0; } |
#include <bits/stdc++.h> using namespace std; void input() {} int main() { input(); ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); int n; cin >> n; if (n % 2 == 0) cout << -1 << n ; else { for (int i = 0; i < n; i++) cout << i << ; cout << n ; for (int i = 0; i < n; i++) cout << i << ; cout << n ; for (int i = 0; i < n; i++) cout << (2 * i) % n << ; } } |
#include <bits/stdc++.h> using namespace std; int i, j, k, n, m, l; const int N = 1e5 + 8; int vis[N]; vector<int> adj[N]; int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); ; cin >> n; for (i = 1; i < n; i++) { int u, v; cin >> u >> v; adj[u].push_back(v); adj[v].push_back(u); } queue<int> q; q.push(1); memset(vis, 0, sizeof(vis)); vis[1] = 1; l = 0; long long ev = 0, od = 0; while (1) { int c = q.size(); if (!c) break; while (c) { int s = q.front(); q.pop(); c--; if (l & 1) ev++; else od++; for (auto u : adj[s]) { if (!vis[u]) { vis[u] = 1; q.push(u); } } } l++; } cout << (ev * od - (n - 1)) << n ; return 0; } |
#include <bits/stdc++.h> using namespace std; double r[1000]; double p = atan(1.) * 4.; int main() { double rez = 0; int n; cin >> n; for (int i = 0; i < n; i++) cin >> r[i]; sort(r, r + n); bool t = true; for (int i = n - 1; i >= 0; i--) { if (t) rez += r[i] * r[i] * p; else rez -= r[i] * r[i] * p; t = !t; } printf( %.6f , rez); cin >> n; return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { string s; getline(cin, s); int i = s.size() - 1; while (s[i] == ? ) { i--; } while (s[i] == 32) { i--; } if (s[i] == y || s[i] == u || s[i] == o || s[i] == i || s[i] == e || s[i] == a ) { cout << YES ; return 0; } if (s[i] == Y || s[i] == U || s[i] == O || s[i] == I || s[i] == E || s[i] == A ) { cout << YES ; return 0; } cout << NO ; return 0; } |
#include <bits/stdc++.h> using namespace std; const double PI = acos(-1.0); const double eps = 1e-6; const int INF = 0x3f3f3f3f; const int MAXN = 1e5 + 10; int cnt, head[MAXN], tot; int n, tim, a[MAXN], root[MAXN]; struct Poi { int w, dfn, dep, col; } poi[MAXN]; bool cmp(int a, int b) { return poi[a].dep < poi[b].dep; } struct Edge { int v, nex; } edge[MAXN * 2]; struct Node { int l, r, m; } node[MAXN * 20]; void add(int u, int v) { edge[cnt] = {v, head[u]}; head[u] = cnt++; } void dfs(int u, int fa) { poi[u].dep = poi[fa].dep + 1; poi[u].dfn = ++tim; for (int i = head[u]; ~i; i = edge[i].nex) { int v = edge[i].v; if (v == fa) continue; dfs(v, u); } poi[u].col = tim; } void up(int rt) { node[rt].m = min(node[node[rt].l].m, node[node[rt].r].m); } void update(int &rt, int l, int r, int k, int x) { node[++tot] = node[rt]; rt = tot; if (l == r) { node[rt].m = x; return; } int mid = ((l + r) >> 1); if (k <= mid) update(node[rt].l, l, mid, k, x); else update(node[rt].r, mid + 1, r, k, x); up(rt); } int bin(int x) { int l = 1, r = n; while (l <= r) { int mid = ((l + r) >> 1); if (poi[a[mid]].dep <= x) l = mid + 1; else r = mid - 1; } return r; } int query(int rt, int l, int r, int L, int R) { if (l == L && r == R) return node[rt].m; int mid = ((l + r) >> 1); if (R <= mid) return query(node[rt].l, l, mid, L, R); else if (L > mid) return query(node[rt].r, mid + 1, r, L, R); else { int a = query(node[rt].l, l, mid, L, mid); int b = query(node[rt].r, mid + 1, r, mid + 1, R); return min(a, b); } } inline int read() { int k = 0; char f = 1; char c = getchar(); for (; !isdigit(c); c = getchar()) if (c == - ) f = -1; for (; isdigit(c); c = getchar()) k = k * 10 + c - 0 ; return k * f; } int main() { int s; memset(head, -1, sizeof head); cin >> n >> s; for (int i = 1; i <= n; i++) poi[i].w = read(), a[i] = i; for (int i = 1; i < n; i++) { int u, v; u = read(), v = read(); add(u, v); add(v, u); } dfs(s, 0); sort(a + 1, a + 1 + n, cmp); node[0].m = INF; for (int i = 1; i <= n; i++) { root[i] = root[i - 1]; int idx = a[i]; int p = poi[idx].dfn; int w = poi[idx].w; update(root[i], 1, n, p, w); } int m; cin >> m; int ans = 0; while (m--) { int x, k; x = read(), k = read(); x = (x + ans) % n + 1; k = (k + ans) % n; int dep = poi[x].dep + k; int l = poi[x].dfn, r = poi[x].col; int p = bin(dep); ans = query(root[p], 1, n, l, r); printf( %d n , ans); } return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; for (int row = -n; row <= n; row++) { int top = n - abs(row); for (int i = 0; i < abs(row); i++) { cout << ; } for (int i = 0; i < top; ++i) { cout << i << ; } for (int i = top; i > 0; --i) { cout << i << ; } cout << 0 << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { string s; cin >> s; int n, d = 0; n = s.size(); for (int i = 0; i < n; i++) { if (s[i] == o ) d++; } if (d == 0) { cout << YES ; return 0; } if ((n - d) % d == 0) { cout << YES ; return 0; } cout << NO ; } |
#include <bits/stdc++.h> using namespace std; const int maxn = 10002; const int maxm = 15000002; int f[maxm], p[maxn]; bool v[maxn]; int a[maxn]; int n, m, s; int main() { int i, j; for (i = 2; i < 12; i++) { if (!v[i]) p[s++] = i; for (j = 0; j < s && i * p[j] < 12; j++) { v[i * p[j]] = 1; if (i % p[j] == 0) break; } } for (i = 2; i < maxm; i++) if (!f[i]) for (j = i; j < maxm; j += i) f[j] = i; scanf( %d , &n); m = 1; for (j = 0; j < s; ++j) { m *= p[j]; if (m > n) break; } --j; m = 0; for (i = 2; i <= 2 * n * n && i < maxm; ++i) if (f[i] <= p[j]) { a[m++] = i; } sort(a, a + m); reverse(a, a + m); for (i = 0; i < n; ++i) printf( %d , a[i]); puts( ); return 0; } |
#include <bits/stdc++.h> int minx, miny, minz, maxx, maxy, maxz, n, m, Q, x, y, z, mx1, mn1, mx2, mn2, mx3, mn3, D, cnt; using namespace std; struct node { int l, r, maxx, maxy, maxz, minx, miny, minz, d[3]; } t[2000005]; inline bool cmp(node aa, node bb) { if (aa.d[D] == bb.d[D]) { if (aa.d[(D + 1) % 3] == bb.d[(D + 1) % 3]) return aa.d[(D + 2) % 3] < bb.d[(D + 2) % 3]; return aa.d[(D + 1) % 3] < bb.d[(D + 1) % 3]; } return aa.d[D] < bb.d[D]; } inline void update(int x, int y) { t[x].maxx = max(t[x].maxx, t[y].maxx); t[x].minx = min(t[x].minx, t[y].minx); t[x].maxy = max(t[x].maxy, t[y].maxy); t[x].miny = min(t[x].miny, t[y].miny); t[x].maxz = max(t[x].maxz, t[y].maxz); t[x].minz = min(t[x].minz, t[y].minz); } int build(int l, int r, int d) { int mid = (l + r) >> 1; D = d; nth_element(t + l, t + mid, t + r + 1, cmp); t[mid].minx = t[mid].maxx = t[mid].d[0]; t[mid].miny = t[mid].maxy = t[mid].d[1]; t[mid].minz = t[mid].maxz = t[mid].d[2]; if (l < mid) t[mid].l = build(l, mid - 1, (d + 1) % 3), update(mid, t[mid].l); ; if (r > mid) t[mid].r = build(mid + 1, r, (d + 1) % 3), update(mid, t[mid].r); ; return mid; } bool inc(int l1, int r1, int l2, int r2) { if (l1 > r2 || l2 > r1) return 0; else return 1; } bool in(int d) { if (!inc(t[d].minx, t[d].maxx, mn1, mx1)) return 0; if (!inc(t[d].miny, t[d].maxy, mn2, mx2)) return 0; if (!inc(t[d].minz, t[d].maxz, mn3, mx3)) return 0; return 0 ^ 1; } bool check(int l1, int r1, int l2, int r2) { return l2 <= l1 && r2 >= r1; } bool check(int d) { if (!check(t[d].minx, t[d].maxx, mn1, mx1)) return 0; if (!check(t[d].miny, t[d].maxy, mn2, mx2)) return 0; if (!check(t[d].minz, t[d].maxz, mn3, mx3)) return 0; return 1; } int query(int k) { if (!k) return 0; if (!in(k)) return 0; if (check(k)) return 0 ^ 1; if (t[k].d[0] >= mn1 && t[k].d[0] <= mx1 && t[k].d[1] >= mn2 && t[k].d[1] <= mx2 && t[k].d[2] >= mn3 && t[k].d[2] <= mx3) return 0 ^ 1; if (query(t[k].l)) return 1; if (query(t[k].r)) return 1; return 0; } inline int read() { char ch = getchar(); int f = 1, w = 0; for (; ch < 0 || ch > 9 ; ch = getchar()) if (ch == - ) f = -1; for (; ch >= 0 && ch <= 9 ; ch = getchar()) w = w * 10 + ch - 0 ; return w * f; } int main() { minx = read(); miny = read(); minz = read(); n = read(); m = read(); Q = read(); maxx = maxy = maxz = 1; for (int i = 1; i <= n; i++) { x = read(); y = read(); z = read(); minx = min(minx, x); maxx = max(maxx, x); miny = min(miny, y); maxy = max(maxy, y); minz = min(minz, z); maxz = max(maxz, z); } for (int i = 1; i <= m; i++) { x = read(); y = read(); z = read(); if (x >= minx && x <= maxx && y >= miny && y <= maxy && z <= maxz && z >= minz) return puts( INCORRECT ), 0; t[++cnt].d[0] = x; t[cnt].d[1] = y; t[cnt].d[2] = z; } puts( CORRECT ); int rt = build(1, cnt, 1); while (Q--) { x = read(); y = read(); z = read(); if (minx <= x && x <= maxx && miny <= y && y <= maxy && minz <= z && z <= maxz) { puts( OPEN ); continue; } mx1 = max(x, maxx); mn1 = min(x, minx); mx2 = max(y, maxy); mn2 = min(y, miny); mx3 = max(z, maxz); mn3 = min(z, minz); if (query(rt)) puts( CLOSED ); else puts( UNKNOWN ); } return 0; } |
#include <bits/stdc++.h> using namespace std; bool debug = false; int n, m, k; int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0}; long long ln, lk, lm; int gg(int x, int y) { int z = y; while (x % y != 0) { z = x % y; x = y; y = z; } return z; } map<int, vector<int>> X[2]; map<pair<pair<int, int>, pair<int, int>>, vector<int>> mp[2]; int cx[20005], cy[20005], cr[20005], ans; int dis(int i, int j) { return (cx[i] - cx[j]) * (cx[i] - cx[j]) + (cy[i] - cy[j]) * (cy[i] - cy[j]); } pair<int, int> gett(int x, int y) { if (y == 0) return {0, 1}; int tmp = gg(abs(x), abs(y)); pair<int, int> tt = {abs(y / tmp), abs(x / tmp)}; if ((y < 0 && x > 0) || (y > 0 && x < 0)) tt.second *= -1; return tt; } void cal(int i, int j) { if (cy[i] == cy[j]) { int x = cx[i] + cx[j]; if (x % 2 != 0) return; x /= 2; auto p = X[0][x]; int sz = p.size(); if (sz == 0) return; int tar = cy[i]; int c = p.end() - upper_bound(p.begin(), p.end(), tar); p = X[1][x]; c += sz - (p.end() - lower_bound(p.begin(), p.end(), tar)); ans += sz - c; return; } int x = cx[i] - cx[j], y = cy[i] - cy[j]; int zx = (cx[i] + cx[j]), zy = (cy[i] + cy[j]); pair<int, int> kk = gett(y * -1, x); pair<int, int> bb = gett(kk.second * 2, kk.second * zy - kk.first * zx); if (mp[0].find({kk, bb}) == mp[0].end()) return; auto p = mp[0][{kk, bb}]; int sz = p.size(); int tar = zx / 2; int c = p.end() - upper_bound(p.begin(), p.end(), tar); p = mp[1][{kk, bb}]; c += sz - (p.end() - lower_bound(p.begin(), p.end(), tar)); ans += sz - c; } int main() { scanf( %d%d , &n, &m); int a, b, c, d; for (int(i) = 0; (i) < (int)(n); (i)++) { scanf( %d%d%d%d , &a, &b, &c, &d); if (a == c) { X[0][a].push_back({min(b, d)}); X[1][a].push_back({max(b, d)}); } else { int x = a - c, y = b - d; pair<int, int> tt = gett(x, y); y = d * a - c * b; pair<int, int> bb = gett(x, y); mp[0][{tt, bb}].push_back(min(a, c)); mp[1][{tt, bb}].push_back(max(a, c)); } } for (int(i) = 0; (i) < (int)(2); (i)++) { for (auto &p : X[i]) sort(p.second.begin(), p.second.end()); for (auto &p : mp[i]) sort(p.second.begin(), p.second.end()); } for (int(i) = 0; (i) < (int)(m); (i)++) scanf( %d%d%d , cx + i, cy + i, cr + i); for (int(i) = 0; (i) < (int)(m); (i)++) for (int j = i + 1; j < m; j++) if (cr[i] == cr[j]) { int D = cr[i] + cr[j]; D *= D; if (dis(i, j) > D) { cal(i, j); } } printf( %d n , ans); return 0; } |
#include <bits/stdc++.h> using namespace std; const int MN = 200010; int a[MN], b[MN], p[MN], q[MN]; char ans[MN]; int main() { int t, m, k; for (scanf( %d , &t); t--;) { scanf( %d%d , &m, &k); int pos = 0, pos1; for (int i = 1; i <= k; i++) { scanf( %d , &a[i]); } bool flag = false; for (int i = 1; i < m; i++) { scanf( %d%d , &p[i], &q[i]); if (q[i] == 1 && !flag) { flag = true; for (int j = 1; j <= k; j++) { b[j] = a[j]; } pos1 = pos; } if (p[i] != 0) { a[p[i]]--; } else { pos++; } } int minA = MN; if (flag) { for (int i = 1; i <= k; i++) { if (a[i] == b[i]) { minA = min(minA, a[i]); } } pos -= minA; } for (int i = 1; i <= k; i++) { if (flag && a[i] == b[i] && a[i] <= pos1) { printf( Y ); } else { printf( %c , (a[i] > pos ? N : Y )); } } printf( n ); } return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { char a[10][10]; char b[10][10]; vector<char> v, l; long long int i, count = 0, j; for (i = 0; i < 2; i++) { for (j = 0; j < 2; j++) { cin >> a[i][j]; } } v.push_back(a[0][0]); v.push_back(a[0][1]); v.push_back(a[1][1]); v.push_back(a[1][0]); for (i = 0; i < 2; i++) { for (j = 0; j < 2; j++) { cin >> b[i][j]; } } l.push_back(b[0][0]); l.push_back(b[0][1]); l.push_back(b[1][1]); l.push_back(b[1][0]); int flag = 0; v.erase(remove(v.begin(), v.end(), X ), v.end()); l.erase(remove(l.begin(), l.end(), X ), l.end()); for (i = 0; i < 3; i++) { if (equal(v.begin(), v.end(), l.begin())) { flag = 1; break; } else { vector<char>::iterator k = v.begin() + 2; char la = *k; v.insert(v.begin(), *k); v.erase(v.begin() + 3); } } if (flag) cout << YES n ; else cout << NO n ; return 0; } |
#include <bits/stdc++.h> using namespace std; void solve() { int n; cin >> n; vector<int> a(n); int sum = 0, maxi = -1; for (int i = 0; i < n; i++) { cin >> a[i]; sum += a[i]; maxi = max(a[i], maxi); } if (maxi > (sum / 2)) cout << T << n ; else { if (sum % 2 == 0) cout << HL << n ; else cout << T << n ; } } int main() { int t; cin >> t; while (t--) solve(); return 0; } |
#include <bits/stdc++.h> int main() { int k, d, i, n, x; scanf( %d%d , &k, &d); n = k; x = d; if ((k > 1) && (d == 0)) { printf( No solution ); } else { for (i = 1; ((i < n) && (x > 0)); i++) { printf( 1 ); x--; } while (i < n) { printf( 0 ); i++; } if (x == 0) { printf( 0 ); } else { printf( %d , (d - i + 1)); } } } |
#include <bits/stdc++.h> int main() { int n, o, i, k, m; scanf( %d%d , &n, &o); scanf( %d%d , &k, &m); int a[n], b[o]; for (i = 0; i < n; i++) scanf( %d , &a[i]); for (i = 0; i < o; i++) scanf( %d , &b[i]); if (a[k - 1] < b[o - m]) printf( YES ); else printf( NO ); return 0; } |
#include <bits/stdc++.h> using namespace std; const long long N = 5e5 + 9; vector<long long> adj[N], vec[N]; long long h[N], up[N], ans[N]; pair<long long, long long> edge[N]; vector<pair<long long, long long> > a[N]; void DFS1(long long u, long long par) { h[u] = 1; for (long long v : adj[u]) if (v != par) { DFS1(v, u); h[u] = max(h[u], h[v] + 1); vec[u].push_back(h[v]); } } void DFS2(long long u, long long par) { multiset<long long> s; for (long long v : adj[u]) if (v != par) s.insert(-h[v]); for (long long v : adj[u]) if (v != par) { s.erase(s.find(-h[v])); up[v] = up[u] + 1; if (!s.empty()) up[v] = max(up[v], -(*s.begin()) + 1); vec[v].push_back(up[v]); s.insert(-h[v]); } for (long long v : adj[u]) if (v != par) DFS2(v, u); } void DFS3(long long u, long long par) { for (long long v : adj[u]) if (v != par) { vector<pair<long long, long long> > b; long long iu = 0, iv = 0; while (iu < a[u].size() && iv < a[v].size()) { if (a[u][iu].first < a[v][iv].first) b.push_back(a[u][iu++]); else if (a[u][iu].first > a[v][iv].first) b.push_back(a[v][iv++]); else if (a[u][iu].first == a[v][iv].first) b.push_back({a[v][iv].first, a[v][iv++].second + a[u][iu++].second}); } while (iv < a[v].size()) b.push_back(a[v][iv++]); while (iu < a[u].size()) b.push_back(a[u][iu++]); for (long long i = 0; i < b.size(); i++) { if (b[i].first == up[v]) b[i].second--; if (b[i].first == h[v]) b[i].second--; } long long num = 0; while (b.size()) { ans[b.back().first * 2] = max(ans[b.back().first * 2], (num += b.back().second)); b.pop_back(); } DFS3(v, u); } } int32_t main() { ios::sync_with_stdio(0); cin.tie(0); long long n; cin >> n; for (long long i = 1; i < n; i++) { long long u, v; cin >> u >> v; adj[u].push_back(v); adj[v].push_back(u); } fill(ans, ans + N, 1); DFS1(1, 0); DFS2(1, 0); for (long long i = 1; i <= n; i++) { sort(vec[i].begin(), vec[i].end()); for (long long j = 0; j < vec[i].size() - 1; j++) if (vec[i][j] != vec[i][j + 1]) ans[vec[i][j] * 2 + 1] = max(ans[vec[i][j] * 2 + 1], (long long)vec[i].size() - j); for (long long j = 0; j < vec[i].size(); j++) ans[vec[i][j] * 2 - 1] = max(ans[vec[i][j] * 2 - 1], (long long)vec[i].size() - j), ans[vec[i][j] * 2] = max( ans[vec[i][j] * 2], (long long)vec[i].size() - j); for (long long j = 0, k = 0; max(j, k) < vec[i].size(); j = k) { while (k < vec[i].size() && vec[i][j] == vec[i][k]) k++; a[i].push_back({vec[i][j], k - j}); } } DFS3(1, 0); for (long long i = n; i > 0; i--) ans[i] = max(ans[i], ans[i + 2]); for (long long i = 1; i <= n; i++) ans[1] = max(ans[1], (long long)adj[i].size() + 1); for (long long i = 1; i <= n; i++) cout << ans[i] << ; return 0; } |
#include <bits/stdc++.h> using namespace std; bool dp[10005][3]; int main() { int n, i; string s; set<string> ans; cin >> s; n = s.length(); for (i = n - 1; i >= 5; i--) { if (i + 2 <= n) { if (i + 2 == n || dp[i + 2][1] || (dp[i + 2][0] && s.substr(i + 2, 2) != s.substr(i, 2))) { dp[i][0] = true; ans.insert(s.substr(i, 2)); } } if (i + 3 <= n) { if (i + 3 == n || dp[i + 3][0] || (dp[i + 3][1] && s.substr(i + 3, 3) != s.substr(i, 3))) { dp[i][1] = true; ans.insert(s.substr(i, 3)); } } } cout << ans.size() << endl; while (!ans.empty()) { cout << *ans.begin() << endl; ans.erase(ans.begin()); } } |
#include <bits/stdc++.h> using namespace std; const int maxn = 345; int ai[maxn]; int bi[maxn]; bool used[maxn]; int m, r, t; void init() { for (int i = 1; i <= m; i++) { scanf( %d , &ai[i]); ai[i]++; } } vector<int> V; void play() { memset(bi, 0, sizeof(bi)); memset(used, 0, sizeof(used)); V.clear(); if (t < r) { printf( -1 n ); return; } long long sum = 0; for (int i = 1; i <= m; i++) { int st = 0; while (bi[ai[i]] < r) { for (int j = ai[i] - st; j <= ai[i] - st + t - 1; j++) { if (j <= 0 || j > 320) continue; bi[j]++; } sum++; st++; } } printf( %I64d n , sum); } int main() { while (scanf( %d%d%d , &m, &t, &r) != EOF) { init(); play(); } return 0; } |
#include <bits/stdc++.h> using namespace std; const long long mod = 1e9 + 7, N = 1e5 + 5; int main() { std::ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); int n; cin >> n; long long a[n + 5], ans = 0, maxx = 0, sum = 0; vector<long long> e, o; for (int i = 0; i < n; i++) { cin >> a[i]; if (a[i] & 1) e.push_back(a[i]); else o.push_back(a[i]); maxx = max(a[i], maxx); sum += a[i]; } sort(e.begin(), e.end()), sort(o.begin(), o.end()); long long es = (long long)e.size(), os = (long long)o.size(); if (abs(es - os) <= 1) { cout << 0; return 0; } if (es == 0 || os == 0) { cout << sum - maxx; return 0; } if (es > os) { for (int i = 0; i < (es - os - 1); i++) { ans += e[i]; } } else { for (int i = 0; i < (os - es - 1); i++) { ans += o[i]; } } cout << ans; return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int n, m, k, x, y; scanf( %d%d%d , &n, &m, &k); bool f = false; while (k--) { scanf( %d%d , &x, &y); int mn = (1 << 20); for (int i = 1; i <= n; ++i) for (int j = 1; j <= m; ++j) if (i == 1 || j == 1 || i == n || j == m) mn = min(mn, abs(i - x) + abs(j - y)); if (mn <= 4) f = true; } if (f) cout << YES << endl; else cout << NO << endl; } |
#include<bits/stdc++.h> using namespace std; #define IOS ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0); #define int long long #define rep(i,a,b) for(int i=a;i<b;i++) #define repn(i,a,b) for(int i=a;i>=b;i--) #define ff first #define ss second #define lb lower_bound #define ub upper_bound #define pii pair<int,int> #define vi vector<int> #define vs vector<string> #define vii vector<pii> #define vvi vector<vector<int>> #define vvii vector<vector<pii>> #define pb push_back #define ppb pop_back #define pf push_front #define ppf pop_front #define sz(x) (int)x.size() #define all(v) (v).begin(), (v).end() #define ret(x) return cout<<x,0; #define rety return cout<< YES ,0; #define retn return cout<< NO ,0; #define fl fflush(stdout) #define hell 1000000007 #define hell2 998244353 #define pi 3.14159265358979323846 int solve(){ int n,m; cin >> n >> m; string s,a; cin >> s; a = s; for(int i = 0; i < min(m,n); i++){ int x{}; for(int j = 0; j < n; j++){ if(j == 0){ if(s[1] == 1 && s[0] == 0 ) a[0] = 1 ; x++; } else if(j == n-1){ if(s[n-1] == 0 && s[n-2] == 1 ) a[n-1] = 1 ; x++; } else{ if((s[j-1] == 1 && s[j+1] == 0 && s[j] == 0 ) || (s[j-1] == 0 && s[j+1] == 1 && s[j] == 0 )) a[j] = 1 ; x++; } } s = a; if(x == 0) break; } cout << s << endl; return 0; } signed main(){ IOS; int tp=1; cin>>tp; while(tp--){ solve(); } return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int n, k; cin >> n >> k; int ans = 0; int inp; for (int i = 0; i < n; i++) { cin >> inp; int temp = (inp + k - 1) / k; ans += temp; } cout << (ans + 1) / 2 << endl; } |
#include <bits/stdc++.h> using namespace std; map<char, int> m; char letters[30]; int numbers[30]; int mystring[30]; int ceiling(int top, int bottom) { return (top + bottom - 1) / bottom; } int main() { string s; int n; cin >> s >> n; for (int i = 0; i < (int)s.length(); i++) m[s[i]]++; int numChar = 0; for (map<char, int>::iterator it = m.begin(); it != m.end(); ++it) { letters[numChar] = it->first; numbers[numChar] = it->second; numChar++; } if (numChar > n) { cout << -1 << endl; return 0; } for (int i = 0; i < numChar; i++) mystring[i] = 1; for (int i = numChar; i < n; i++) { int needMost = -1, needMostIndex = -1; for (int j = 0; j < numChar; j++) { if (ceiling(numbers[j], mystring[j]) > needMost) { needMost = ceiling(numbers[j], mystring[j]); needMostIndex = j; } } mystring[needMostIndex]++; } int needMost = -1; for (int j = 0; j < numChar; j++) { if (ceiling(numbers[j], mystring[j]) > needMost) { needMost = ceiling(numbers[j], mystring[j]); } } cout << needMost << endl; for (int i = 0; i < numChar; i++) for (int j = 0; j < mystring[i]; j++) cout << letters[i]; cout << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; const long long Size = 501; const long long mod = 1e9 + 7; long long a[Size], num[Size]; bool vis[Size]; long long f[Size], d[Size]; long long dp[Size][Size]; inline long long min(long long a, long long b) { return a < b ? a : b; } inline long long max(long long a, long long b) { return a > b ? a : b; } long long fastpow(long long b, long long p, long long k) { long long ans = 1; while (p) { if (p & 1) ans = ans * b % k; b = b * b % k; p >>= 1; } return ans; } void init() { f[0] = 1; for (long long i = 1; i <= 300; i++) f[i] = f[i - 1] * i % mod; d[300] = fastpow(f[300], mod - 2, mod); for (long long i = 299; i >= 0; i--) d[i] = d[i + 1] * (i + 1) % mod; } long long read() { long long x = 0, f = 1; char ch = getchar(); while (ch < 0 || ch > 9 ) { if (ch == - ) f = -1; ch = getchar(); } while (ch >= 0 && ch <= 9 ) { x = 10 * x + ch - 0 ; ch = getchar(); } return x * f; } long long C(long long a, long long b) { if (a < 0 || b < 0 || a < b) return 0; if (!b || a == b) return 1; return (f[a] * d[b] % mod) * d[a - b] % mod; } int main() { init(); C(2, 1); long long n = read(), size = 0; for (long long i = 1; i <= n; i++) a[i] = read(); for (long long i = 1; i <= n; i++) { if (!vis[i]) { size++; for (long long j = i; j <= n; j++) { if (sqrt(a[i] * a[j]) == (long long)sqrt(a[i] * a[j])) { vis[j] = true; num[size]++; } } } } long long sum = num[1] - 1; dp[1][sum] = 1; for (long long i = 2; i <= size; sum += num[i++]) { for (long long j = 0; j <= sum; j++) { if (!dp[i - 1][j]) continue; for (long long k = 0; k <= num[i]; k++) { long long tmp = min(j, k + 1), temp; for (long long l = 0; l <= tmp; l++) { temp = dp[i - 1][j] * C(num[i] - 1, k) % mod * C(j, l) % mod * C(sum + 2 - j, k - l + 1) % mod; dp[i][j + num[i] - 1 - k - l] += temp; dp[i][j + num[i] - 1 - k - l] %= mod; } } } } long long ans = dp[size][0]; for (long long i = 1; i <= size; i++) ans = ans * f[num[i]] % mod; printf( %I64d , ans); return 0; } |
#include <bits/stdc++.h> using namespace std; const int MAXN = 500010; const int MAXM = 500010; const int INF = 1e9 + 7; const double pi = acos(0.0) * 2.0; const double eps = 1e-12; inline int read(int &x) { scanf( %d , &x); return x; } inline long long read(long long &x) { scanf( %I64d , &x); return x; } inline char read(char c) { c = getchar(); return c; } inline char *read(char *&x) { scanf( %s , x); return x; } inline char *readln(char *&x) { gets(x); return x; } inline string read(string &x) { cin >> x; return x; } inline string readln(string &x) { getline(cin, x); return x; } inline float read(float &x) { scanf( %f , &x); return x; } inline double read(double &x) { scanf( %lf , &x); return x; } inline void ToString(char *x, string &y) { y = x; } template <typename T> inline void read(vector<T> &a, int n) { a.clear(); T x; for (int i = 0; i < n; i++) a.push_back(read(x)); } template <typename T> inline void read(T a[], int n) { for (int i = 0; i < n; i++) read(a[i]); } inline int write(int x) { printf( %d , x); return x; } inline int writeln(int x) { printf( %d n , x); return x; } inline long long write(long long x) { printf( %I64d , x); return x; } inline long long writeln(long long x) { printf( %I64d n , x); return x; } inline char write(char c) { putchar(c); return c; } inline char writeln(char c) { putchar(c); putchar( n ); return c; } inline char *write(char *x) { printf( %s , x); return x; } inline char *writeln(char *x) { puts(x); return x; } inline string write(string x) { cout << x; return x; } inline string writeln(string x) { cout << x << n ; return x; } inline float write(float x) { printf( %f , x); return x; } inline float writeln(float x) { printf( %f n , x); return x; } inline double write(double x) { printf( %lf , x); return x; } inline double writeln(double x) { printf( %lf n , x); return x; } template <typename T> inline void write(vector<T> &a, int n) { for (int i = 0; i < n - 1; i++) { write(a[i]); putchar( ); } writeln(a[n - 1]); } template <typename T> inline void writeln(vector<T> &a, int n) { for (int i = 0; i < n; i++) writeln(a[i]); } template <typename T> inline void write(T a[], int n) { for (int i = 0; i < n - 1; i++) { write(a[i]); putchar( ); } writeln(a[n - 1]); } template <typename T> inline void writeln(T a[], int n) { for (int i = 0; i < n; i++) writeln(a[i]); } template <class T> inline T abs1(T a) { return a < 0 ? -a : a; } template <class T> inline T max1(T a, T b) { return a > b ? a : b; } template <class T> inline T max1(T a, T b, T c) { return max1(max1(a, b), c); } template <class T> inline T max1(T a, T b, T c, T d) { return max1(max1(a, b, c), d); } template <class T> inline T max1(T a, T b, T c, T d, T e) { return max1(max1(a, b, c, d), e); } template <class T> inline T min1(T a, T b) { return a < b ? a : b; } template <class T> inline T min1(T a, T b, T c) { return min1(min1(a, b), c); } template <class T> inline T min1(T a, T b, T c, T d) { return min1(min1(a, b, c), d); } template <class T> inline T min1(T a, T b, T c, T d, T e) { return min1(min1(a, b, c, d), e); } inline int jud(double a, double b) { if (abs(a) < eps && abs(b) < eps) return 0; else if (abs1(a - b) / abs1(a) < eps) return 0; if (a < b) return -1; return 1; } template <typename t> inline int jud(t a, t b) { if (a < b) return -1; if (a == b) return 0; return 1; } int N, M, T = INF, Cases = 0; double l, r; double ans[MAXN]; string s; int main() { std::ios::sync_with_stdio(false); cin >> s; N = s.length(); double sum = 0; for (int i = 1; i <= N; i++) sum += 1 / double(i); ans[0] = ans[N - 1] = sum; l = 1; r = N; for (int i = 1; i < (N + 1) / 2; i++) { sum -= 1.0 / l + 1.0 / r; ans[i] = ans[N - i - 1] = ans[i - 1] + sum; l += 1; r -= 1; } double res = 0; for (int i = 0; i < N; i++) { if (s[i] == A || s[i] == E || s[i] == O || s[i] == I || s[i] == U || s[i] == Y ) res += ans[i]; } cout.setf(ios::fixed); cout << setprecision(9) << res << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; template <class T> using v2d = vector<vector<T> >; 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; } mt19937 rng(chrono::system_clock::now().time_since_epoch().count()); const int maxN = 2e5 + 10; const int maxM = 5e5 + 10; int n, m, a, b; vector<int> adj[maxN]; int fa[maxN], fb[maxN]; long long ca = 0, cb = 0; void DFSa(int u) { if (u == b) { return; } fa[u] = 1; for (auto &v : adj[u]) { if (!fa[v]) { DFSa(v); } } } void DFSb(int u) { if (u == a) { return; } fb[u] = 1; for (auto &v : adj[u]) { if (!fb[v]) { DFSb(v); } } } int main() { ios_base::sync_with_stdio(false); cin.tie(nullptr); int T; cin >> T; while (T--) { cin >> n >> m >> a >> b; for (int i = 1; i <= (int)(n); ++i) { adj[i].clear(); fa[i] = fb[i] = 0; } while (m--) { int u, v; cin >> u >> v; adj[u].emplace_back(v); adj[v].emplace_back(u); } DFSa(a); DFSb(b); ca = cb = 0; for (int i = 1; i <= (int)(n); ++i) { if (fa[i]) { ca += !fb[i]; } if (fb[i]) { cb += !fa[i]; } } cout << (ca - 1) * (cb - 1) << n ; } return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); int t; cin >> t; while (t--) { unsigned int n; cin >> n; unsigned long k; cin >> k; if (n & 1) { for (int i = 2; i <= (n); i++) { if (n % i == 0) { n += i; break; } } n += 2 * (k - 1); } else n += 2 * k; cout << n << n ; } return 0; } |
#include <bits/stdc++.h> using namespace std; void solve(priority_queue<pair<long long, int>, vector<pair<long long, int> >, greater<pair<long long, int> > > &P, priority_queue<pair<long long, int> > &N, vector<long long> &ans, int k, int x) { while (k > 0) { int ps = P.size(), pn = N.size(); if (ps && pn) { pair<long long, int> pt = P.top(); P.pop(); pair<long long, int> nt = N.top(); N.pop(); int sign = (pn & 1) ? -1 : 1; if (nt.first * -1 <= pt.first) { nt.first += sign * x; if (nt.first >= 0) { P.push(nt); P.push(pt); } else { N.push(nt); P.push(pt); } } else { pt.first -= sign * x; if (pt.first < 0) { N.push(nt); N.push(pt); } else { N.push(nt); P.push(pt); } } } else if (ps) { pair<long long, int> pt = P.top(); P.pop(); pt.first -= x; if (pt.first < 0) { N.push(pt); } else { P.push(pt); } } else { pair<long long, int> nt = N.top(); N.pop(); int sign = (pn & 1) ? -1 : 1; nt.first += sign * x; if (nt.first >= 0) { P.push(nt); } else { N.push(nt); } } k--; } while (!P.empty()) { pair<long long, int> it = P.top(); P.pop(); ans[it.second] = it.first; } while (!N.empty()) { pair<long long, int> it = N.top(); N.pop(); ans[it.second] = it.first; } } int main() { int n, k, x, t; while (cin >> n >> k >> x) { priority_queue<pair<long long, int>, vector<pair<long long, int> >, greater<pair<long long, int> > > Qp; priority_queue<pair<long long, int> > Qn; for (int i = 0; i < n; i++) { cin >> t; if (t >= 0) Qp.push(make_pair(t, i)); else Qn.push(make_pair(t, i)); } vector<long long> ans(n); solve(Qp, Qn, ans, k, x); for (int i = 0; i < n; i++) cout << ans[i] << ; cout << endl; } } |
#include <bits/stdc++.h> using namespace std; char ch[200000]; int main() { scanf( %s , ch + 1); int n = strlen(ch + 1); int flag = 0; for (int i = 1; i <= n; i++) { if (ch[i] != ch[n - i + 1]) flag++; } if (flag == 2 || n % 2 == 1 && flag == 0) printf( YES ); else printf( NO ); return 0; } |
#include <bits/stdc++.h> using namespace std; map<string, int> globmap; int optwin[32000]; int optptsc[32000]; int optptso[32000]; int pts[32000]; map<string, int> hashid; string hashinv[32000]; void findit(int s) { if (optwin[s] != -1) { return; } string S = hashinv[s]; string append = z ; optwin[s] = 0; optptsc[s] = 0; optptso[s] = 1000000000; bool can = 0; for (int c = a ; c <= z ; c++) { append[0] = c; string Snext; for (int b = 0; b < 2; b++) { if (b) Snext = S + append; else Snext = append + S; if (hashid.find(Snext) == hashid.end()) continue; can = 1; int snext = hashid[Snext]; findit(snext); int candwin = !optwin[snext]; int candptsc = pts[snext] + optptso[snext]; int candptso = optptsc[snext]; if (candwin < optwin[s]) continue; if (candwin > optwin[s]) { optwin[s] = candwin; optptsc[s] = candptsc; optptso[s] = candptso; continue; } if (candptsc < optptsc[s]) continue; if (candptsc > optptsc[s]) { optwin[s] = candwin; optptsc[s] = candptsc; optptso[s] = candptso; continue; } if (candptso > optptso[s]) continue; if (candptso < optptso[s]) { optwin[s] = candwin; optptsc[s] = candptsc; optptso[s] = candptso; continue; } } } if (!can) { optwin[s] = 0; optptsc[s] = 0; optptso[s] = 0; } } int main() { int n; scanf( %d , &n); map<string, int> globmap; for (int i = 0; i < n; i++) { string word; cin >> word; map<string, bool> allsubs; int L = word.size(); for (int i = 0; i < L; i++) for (int j = i; j < L; j++) allsubs[word.substr(i, j - i + 1)] = 1; for (map<string, bool>::iterator it = allsubs.begin(); it != allsubs.end(); it++) { string S = (*it).first; if (globmap.find(S) == globmap.end()) globmap[S] = 1; else globmap[S]++; } } int ct = 0; for (map<string, int>::iterator it = globmap.begin(); it != globmap.end(); it++) { string S = (*it).first; int L = S.size(); int maxx = 0; int summ = 0; for (int i = 0; i < L; i++) { summ += S[i] - a + 1; if (S[i] - a + 1 > maxx) maxx = S[i] - a + 1; } (*it).second += summ * maxx; hashid[S] = ct + 1; hashinv[ct + 1] = S; pts[ct + 1] = (*it).second; ct++; } hashid[ ] = 0; hashinv[0] = ; pts[0] = 0; ct++; for (int i = 0; i < ct; i++) { optwin[i] = -1; optptsc[i] = -1; optptso[i] = -1; } findit(0); if (optwin[0]) printf( First n ); else printf( Second n ); printf( %d %d n , optptsc[0], optptso[0]); } |
#include <bits/stdc++.h> using namespace std; int longestIncreasingSubsequenceDP(int a[], int n) { int dp[n], ans = 0; for (int k = 0; k < n; k++) { dp[k] = 1; for (int i = 0; i < k; i++) { if (a[i] <= a[k]) { dp[k] = max(dp[k], dp[i] + 1); ans = max(dp[k], ans); } } } return ans; } int gcd(int a, int b) { if (a == 0) return b; if (b == 0) return a; if (a == b) return a; if (a > b) return gcd(a - b, b); return gcd(a, b - a); } void scanArray(int arr[], int n) { for (int i = 0; i < n; i++) { cin >> arr[i]; } } int highestFromThree(int n1, int n2, int n3) { return max(max(n1, n2), n3); } int highestFromFour(int n1, int n2, int n3, int n4) { return max(max(n1, n2), max(n3, n4)); } int result[1000] = {0}; int factDP(int n) { if (n >= 0) { result[0] = 1; for (int i = 1; i <= n; ++i) { result[i] = i * result[i - 1]; } return result[n]; } } int main() { int n, m; cin >> n >> m; int l[n], r[n]; vector<pair<int, int>> v; int points[m]; for (int i = 0; i < m; i++) { points[i] = i + 1; } for (int i = 0; i < n; i++) { cin >> l[i] >> r[i]; v.push_back(make_pair(l[i], r[i])); } int count = m; for (int i = 0; i < m; i++) { for (int j = 0; j < v.size(); j++) { if (points[i] >= v[j].first && points[i] <= v[j].second) { count--; points[i] = 0; break; } } } cout << count << n ; for (int i = 0; i < m; i++) { if (points[i] != 0) { cout << points[i] << ; } } return 0; } |
#include <bits/stdc++.h> using namespace std; const int N = 100005; int n, a[4]; char s[N]; int main() { cin >> n >> s; for (int i = 0; i < n; ++i) { if (s[i] == A ) a[0]++; else if (s[i] == C ) a[1]++; else if (s[i] == G ) a[2]++; else if (s[i] == T ) a[3]++; } sort(a, a + 4); int mx = a[3]; long long m = 0; for (int i = 0; i < 4; ++i) if (a[i] == mx) m++; long long ans = 1; for (int i = 0; i < n; ++i) ans = (ans * m) % (1000000007); cout << ans << endl; } |
#include <bits/stdc++.h> using std::abs; using std::bitset; using std::cerr; using std::cin; using std::copy; using std::cout; using std::deque; using std::endl; using std::fill; using std::fixed; using std::greater; using std::iota; using std::istream; using std::lower_bound; using std::make_pair; using std::make_tuple; using std::map; using std::max; using std::max_element; using std::min; using std::min_element; using std::multiset; using std::next_permutation; using std::nth_element; using std::ostream; 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; long long rnd(long long x, long long y) { static auto gen = std::bind(std::uniform_int_distribution<long long>(), std::mt19937(960172)); return gen() % (y - x + 1) + x; } long long gcd(long long a, long long b) { while (b > 0) { long long t = a % b; a = b; b = t; } return a; } template <typename T> T sqr(T const& a) { return a * a; } int const INF = 100 + (int)1e9; long long const INFL = 100 + (long long)1e18; long double const PI = 3.1415926535897932384626433832795028; void solve() { vector<string> const hs = { Anka , Chapay , Cleo , Troll , Dracul , Snowy , Hexadecimal }; int qq; cin >> qq; int n = hs.size(); vector<vector<int>> z(n, vector<int>(n)); while (qq--) { string a, b, c; cin >> a >> b >> c; int i = 0; while (hs[i] != a) ++i; int j = 0; while (hs[j] != c) ++j; ++z[i][j]; } int A, B, C; cin >> A >> B >> C; int three = 1; for (int i = 0; i < n; ++i) three *= 3; int diff = 2 * INF; int sym = 0; for (int mask = 0; mask < three; ++mask) { int val = mask; vector<int> who(n), cnt(3); for (int i = 0; i < n; ++i) { int x = val % 3; val /= 3; who[i] = x; ++cnt[x]; } if (!cnt[0] || !cnt[1] || !cnt[2]) continue; int a = A / cnt[0], b = B / cnt[1], c = C / cnt[2]; int cdiff = max({a, b, c}) - min({a, b, c}); int csym = 0; for (int x = 0; x < n; ++x) for (int y = 0; y < n; ++y) csym += z[x][y] * (who[x] == who[y]); if (cdiff < diff || (cdiff == diff && csym > sym)) { diff = cdiff; sym = csym; } } cout << diff << << sym << endl; } int main() { cout.precision(15); cout << fixed; cerr.precision(6); cerr << fixed; solve(); } |
#include <bits/stdc++.h> using namespace std; const int N = 100 * 1000 + 5; int xs, ys, xt, yt, n, a[N], b[N], r[N]; map<pair<int, int>, int> mark; map<pair<int, int>, int> dist; int dx[] = {1, -1, 0, 0, 1, 1, -1, -1}; int dy[] = {0, 0, 1, -1, 1, -1, 1, -1}; void bfs(int x, int y) { queue<pair<int, int> > q; dist[{x, y}] = 0; q.push({x, y}); while (!q.empty()) { pair<int, int> p = q.front(); q.pop(); x = p.first, y = p.second; for (int i = 0; i < 8; i++) { int nx = x + dx[i], ny = y + dy[i]; if (!mark[{nx, ny}]) continue; else if (dist[{nx, ny}] > dist[{x, y}] + 1) { dist[{nx, ny}] = dist[{x, y}] + 1; q.push({nx, ny}); } } } } void input() { cin >> xs >> ys >> xt >> yt >> n; for (int i = 0; i < n; i++) cin >> r[i] >> a[i] >> b[i]; } void solve() { for (int i = 0; i < n; i++) { for (int j = a[i]; j <= b[i]; j++) { mark[{r[i], j}] = true; dist[{r[i], j}] = 1e9; } } bfs(xs, ys); } void output() { int ans = dist[{xt, yt}]; if (ans == 1e9) cout << -1 << n ; else cout << ans << n ; } int main() { ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0); input(); solve(); output(); } |
#include<bits/stdc++.h> #define ll long long using namespace std; ll T,n,k; void work(){ scanf( %lld%lld ,&n,&k); if(n<=k){printf( %lld n ,(long long)ceil((double)k*1.0/(double)n));return;} else{ if(n%k==0){ printf( %lld n ,1LL); return; } else printf( %lld n ,2LL); } return; } int main(){ scanf( %d ,&T); while(T--)work(); return 0; } |
#include <bits/stdc++.h> using namespace std; const double PI = acos(-1.0); const int INF = 1000 * 1000 * 1000 + 7; const long long LINF = INF * (long long)INF; const int MAX = 3000 + 47; vector<int> g[MAX]; vector<int> S; int L[MAX]; int U[MAX]; queue<int> q; int D[MAX]; int n; void dfs(int v, int p) { if (U[v] == 1) { int sz = (int)S.size() - 1; L[v] = 1; while (S[sz] != v) { L[S[sz]] = 1; sz--; } return; } U[v] = 1; S.push_back(v); for (int i = (0); i < ((int)g[v].size()); i++) { int to = g[v][i]; if (to == p) continue; dfs(to, v); } S.pop_back(); U[v] = 2; } void bfs() { for (int i = (0); i < (n); i++) D[i] = INF; for (int i = (0); i < (n); i++) { if (!L[i]) continue; q.push(i); D[i] = 0; } while (!q.empty()) { int v = q.front(); q.pop(); for (int i = (0); i < ((int)g[v].size()); i++) { int to = g[v][i]; if (D[to] != INF) continue; D[to] = D[v] + 1; q.push(to); } } } int main() { ios::sync_with_stdio(false); cin.tie(0); cin >> n; for (int i = (0); i < (n); i++) { int x, y; cin >> x >> y; x--; y--; g[x].push_back(y); g[y].push_back(x); } dfs(0, 0); bfs(); for (int i = (0); i < (n); i++) { cout << D[i] << ; } cout << endl; } |
#include <bits/stdc++.h> using namespace std; int n, m, l, r, cnt; int a[105]; int main() { cin >> n >> m; for (int i = 0; i < n; ++i) { cin >> l >> r; for (int i = l; i <= r; ++i) { a[i] = 1; } } for (int i = 1; i <= m; ++i) { if (!a[i]) cnt++; } cout << cnt << endl; for (int i = 1; i <= m; ++i) { if (!a[i]) cout << i << ; } cout << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int n, x, ser = 0, dim = 0; vector<int> v; cin >> n; for (int i = 0; i < n; i++) { cin >> x; v.push_back(x); } for (int i = 0; i < n; i++) { if (i % 2 == 0) { ser += max(v.front(), v.back()); if (v.front() > v.back()) v.erase(v.begin()); else v.pop_back(); } else { dim += max(v.front(), v.back()); if (v.front() > v.back()) v.erase(v.begin()); else v.pop_back(); } } cout << ser << << dim << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; int n, b, t[32], c[32], s[1 << 11], cnt[1 << 11]; bool dp[12][25][1 << 11]; int main() { scanf( %d , &n); for (int i = 1; i <= n; ++i) { scanf( %d , t + i); if (t[i] > 1) c[++b] = t[i]; } if (n == 1) { puts( YES ); return 0; } if (b * 2 > n - 1) { puts( NO ); return 0; } sort(c + 1, c + b + 1); if (c[b] < n) { puts( NO ); return 0; } dp[0][n - b][0] = 1; for (int S = 1; S < (1 << b); S++) { s[S] = s[S & (S - 1)] + c[__builtin_ctz(S) + 1]; cnt[S] = cnt[S & (S - 1)] + 1; } for (int i = 1; i <= b; ++i) for (int j = 0; j <= n - b; ++j) { for (int S = 0; S < (1 << (i - 1)); S++) { bool z = 0; int cS = ((1 << (i - 1)) - 1) ^ S; for (int T = cS; !z; T = (T - 1) & cS) { for (int k = j; k <= n - b; ++k) { if (dp[i - 1][k][S ^ T] && s[T] + k - j == c[i] - 1 && k - j + cnt[T] >= 2) { z = 1; break; } } if (!T) break; } if (z) dp[i][j][S ^ (1 << (i - 1))] = 1; } } puts(dp[b][0][1 << (b - 1)] ? YES : NO ); return 0; } |
#include <bits/stdc++.h> #pragma GCC optimize( Ofast ) #pragma GCC target( sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native ) using namespace std; long long MOD = 1e9 + 7; long long dp[4000][4000]; long long mn[4000][4000]; int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); long long n; cin >> n; set<long long> uss; long long a[n]; long long b[n]; long long sm = 0; for (int i = 0; i < n; i++) { cin >> a[i]; a[i] = a[i] - i; uss.insert(a[i]); } vector<long long> us; for (auto i : uss) { us.push_back(i); } for (int i = 0; i < n; i++) { for (int j = 0; j < us.size(); j++) { dp[i + 1][j] = mn[i][j] + abs(us[j] - a[i]); mn[i + 1][j] = dp[i + 1][j]; if (j) mn[i + 1][j] = min(mn[i + 1][j], mn[i + 1][j - 1]); } } cout << mn[n][us.size() - 1]; } |
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(); int n; cin >> n; int t; int speed = 0; int ans = 0; int c = 0; int bs; stack<int> s; cin >> t >> speed; for (int i = 1; i < n; i++) { cin >> t; if (t == 1) { cin >> speed; while (!s.empty() && speed > s.top()) { s.pop(); ans++; } } else if (t == 2) { ans += c; c = 0; } else if (t == 3) { cin >> bs; s.push(bs); if (bs < speed) { s.pop(); ans++; } } else if (t == 4) { c = 0; } else if (t == 5) { while (!s.empty()) s.pop(); } else { c++; } } cout << ans; return 0; } |
#include <bits/stdc++.h> using namespace std; const double eps(1e-8); const long long inf = -99999999999999999; long long row, col, k, p; long long sumr[1001]; long long sumc[1001]; long long answerR[1000001]; long long answerC[1000001]; priority_queue<long long> Rtmp, Ctmp; int main() { scanf( %I64d %I64d %I64d %I64d , &row, &col, &k, &p); memset(sumr, 0, sizeof(sumr)); memset(sumc, 0, sizeof(sumc)); long long tmp; for (int i = 1; i <= row; i++) { for (int j = 1; j <= col; j++) { scanf( %I64d , &tmp); sumr[i] += tmp; sumc[j] += tmp; } } for (int i = 1; i <= row; i++) { Rtmp.push(sumr[i]); } for (int i = 1; i <= col; i++) { Ctmp.push(sumc[i]); } memset(answerR, 0, sizeof(answerR)); memset(answerC, 0, sizeof(answerC)); long long ans = 0; for (int j = 1; j <= k; j++) { ans += Rtmp.top(); tmp = Rtmp.top(); tmp -= col * p; Rtmp.pop(); Rtmp.push(tmp); answerR[j] = ans; } ans = 0; for (int j = 1; j <= k; j++) { ans += Ctmp.top(); tmp = Ctmp.top(); tmp -= row * p; Ctmp.pop(); Ctmp.push(tmp); answerC[j] = ans; } long long answer = inf; for (int i = 0; i <= k; i++) { answer = max(answer, answerR[i] + answerC[k - i] - i * (k - i) * p); } printf( %I64d n , answer); return 0; } |
#include <bits/stdc++.h> using namespace std; const long long int mod = 1000000000 + 7; const long long int N = 10000000 + 6; int main() { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); int n, k; cin >> n >> k; char matrix[4][n]; for (int i = 0; i < 4; i++) for (int j = 0; j < n; j++) matrix[i][j] = . ; bool bo = true; if (k & 1) { if (k > n - 2) { int g = n - 2; for (int i = 1; i <= g; i++) matrix[1][i] = # ; int l = k - n; matrix[2][1] = # ; matrix[2][n - 2] = # ; for (int i = 2; i <= l + 1; i++) matrix[2][i] = # ; } else { int i = n / 2 - k / 2; int c = 1; for (int j = i; c <= k; c++, j++) matrix[1][j] = # ; } } else { int g = k / 2; for (int i = 1; i <= g; i++) matrix[1][i] = # ; for (int i = 1; i <= g; i++) matrix[2][i] = # ; } if (bo) { cout << YES n ; for (int i = 0; i < 4; i++) { for (int j = 0; j < n; j++) cout << matrix[i][j]; cout << n ; } } else cout << NO n ; return 0; } |
#include <bits/stdc++.h> template <typename T> void read(T& val) { std::string tmp = typeid(val).name(); if (strcmp(tmp.c_str(), i ) == 0) scanf( %d , &val); else if (strcmp(tmp.c_str(), x ) == 0) scanf( %I64d , &val); else if (strcmp(tmp.c_str(), d ) == 0) scanf( %lf , &val); else if (tmp.length() > 2 && tmp.back() == c ) scanf( %s , val); else if (strcmp(tmp.c_str(), c ) == 0) scanf( %c , &val); } template <typename T, typename... Targs> void read(T& val, Targs&... Fargs) { read(val); read(Fargs...); } template <typename T> void print(T val) { std::string tmp = typeid(val).name(); if (strcmp(tmp.c_str(), i ) == 0) printf( %d , val); else if (strcmp(tmp.c_str(), x ) == 0) printf( %I64d , val); else if (strcmp(tmp.c_str(), d ) == 0) printf( %.15f , val); else if (strcmp(tmp.c_str(), c ) == 0) printf( %c , val); else if (tmp.length() > 2 && tmp.back() == c ) printf( %s , val); } template <typename T, typename... Targs> void print(T val, Targs... Fargs) { print(val); print(Fargs...); } const double pi = acos(-1); const int MOD = 1e9 + 7; const int INF = 1e9 + 7; const int MAXN = 1e6 + 5; const double eps = 1e-9; using namespace std; int a = 1, b, c, n, x, y, z; int main() { read(n, x, y, c); while (a < c) { b++; z = min(x - 1, b); a += max(z - max((y + b - n), 0) + 1, 0) + max(z - max((b - y + 1), 0) + 1, 0) - (z == b); z = min(n - x, b); a += max(z - max((y + b - n), 1) + 1, 0) + max(z - max((b - y + 1), 1) + 1, 0) - (z == b); } print(b); return 0; } |
#include <bits/stdc++.h> #pragma GCC optimize( Ofast ) using namespace std; const long long Mod = 1000000007LL, INF = 1e9, LINF = 1e18; const long double Pi = 3.141592653589793116, EPS = 1e-9, Gold = ((1 + sqrt(5)) / 2); long long keymod[] = {1000000007LL, 1000000009LL, 1000000021LL, 1000000033LL}; long long keyCount = sizeof(keymod) / sizeof(long long); mt19937 rng32(chrono::steady_clock::now().time_since_epoch().count()); mt19937_64 rng64(chrono::steady_clock::now().time_since_epoch().count()); template <class T> int getbit(T s, int i) { return (s >> i) & 1; } template <class T> T onbit(T s, int i) { return s | (T(1) << i); } template <class T> T offbit(T s, int i) { return s & (~(T(1) << i)); } template <class T> int cntbit(T s) { return __builtin_popcountll(s); } auto TimeStart = chrono::steady_clock::now(); auto TimeEnd = chrono::steady_clock::now(); void ControlIO(int argc, char* argv[]); void TimerStart(); void TimerStop(); void Exit(); string cppstr_infile = FILE.IN ; string cppstr_outfile = FILE.OUT ; int n; vector<int> c; vector<long long> dp; vector<vector<int>> adj; vector<vector<int>> DependencyList; set<int> FinalList; void DFS_GetList(int z, int last, vector<int>& MaxLeaf, vector<int>& MaxID, vector<int>& MaxCnt) { dp[z] = 0; bool isLeaf = true; for (auto t : adj[z]) { if (t == last) continue; isLeaf = false; DFS_GetList(t, z, MaxLeaf, MaxID, MaxCnt); dp[z] += dp[t]; if (MaxLeaf[t] >= MaxLeaf[z]) MaxID[z] = MaxID[t]; if (MaxLeaf[t] > MaxLeaf[z]) MaxCnt[z] = MaxCnt[t]; else if (MaxLeaf[t] == MaxLeaf[z]) MaxCnt[z] += MaxCnt[t]; MaxLeaf[z] = max(MaxLeaf[z], MaxLeaf[t]); } if (isLeaf) { MaxLeaf[z] = dp[z] = c[z]; MaxID[z] = z; MaxCnt[z] = 1; DependencyList[z].push_back(z); return; } int MaxRemovable = -MaxLeaf[z]; if (MaxRemovable + c[z] > 0) return; if (MaxRemovable + c[z] < 0 && MaxCnt[z] == 1) { DependencyList[MaxID[z]].clear(); } if (MaxCnt[z] == 1) DependencyList[MaxID[z]].push_back(z); else { DependencyList[z].push_back(z); MaxID[z] = z; } dp[z] += (MaxRemovable + c[z]); MaxLeaf[z] = c[z]; MaxCnt[z] = 1; } void Input() { cin >> n; c.resize(n); dp.resize(n); adj.resize(n); DependencyList.resize(n); for (auto& z : c) cin >> z; for (int i = 1; i < n; i++) { int a, b; cin >> a >> b; a--; b--; adj[a].push_back(b); adj[b].push_back(a); } } void Solve() { vector<int> MaxLeaf(n, -1), MaxID(n, -1), MaxCnt(n, 0); DFS_GetList(0, -1, MaxLeaf, MaxID, MaxCnt); for (int id = 0; id < n; id++) { for (auto z : DependencyList[id]) FinalList.insert(z + 1); } cout << dp[0] << << FinalList.size() << n ; for (auto it = FinalList.begin(); it != FinalList.end(); it++) cout << (*it) << ; cout << n ; } int main(int argc, char* argv[]) { ControlIO(argc, argv); ios_base::sync_with_stdio(0); cin.tie(NULL); Input(); TimerStart(); Solve(); TimerStop(); return 0; } void ControlIO(int argc, char* argv[]) { char* infile = new char[cppstr_infile.size() + 1]; char* outfile = new char[cppstr_outfile.size() + 1]; strcpy(infile, cppstr_infile.c_str()); strcpy(outfile, cppstr_outfile.c_str()); } void TimerStart() {} void TimerStop() {} void Exit() { TimerStop(); exit(0); } |
#include <bits/stdc++.h> using namespace std; using ll = long long; using pll = pair<ll, ll>; using pii = pair<int, int>; struct Node { vector<ll> con; ll h1, h2; } g[100010]; ll dfs(ll n, ll p) { g[n].h1 = g[n].h2 = 0; for (auto &i : g[n].con) { if (i == p) continue; ll k = dfs(i, n) + 1; if (k >= g[n].h1) { g[n].h2 = g[n].h1; g[n].h1 = k; } else if (k >= g[n].h2) { g[n].h2 = k; } } return g[n].h1; } ll dist(ll n, ll p, ll t) { if (n == t) return 0; ll ans = (ll)(1e17); for (auto &i : g[n].con) { if (i == p) continue; ans = min(ans, dist(i, n, t) + 1); } return ans; } int32_t main() { ios::sync_with_stdio(false); cin.tie(0); ll N; cin >> N; while (N--) { ll n, a, b, da, db; cin >> n >> a >> b >> da >> db; for (ll i = 0; i <= n - 1; i++) g[i].con.clear(); a--; b--; ll s, t; for (ll i = 0; i <= n - 2; i++) { cin >> s >> t; s--; t--; g[s].con.emplace_back(t); g[t].con.emplace_back(s); } dfs(0, 0); ll height = 0; for (ll i = 0; i <= n - 1; i++) height = max(height, g[i].h1 + g[i].h2); ll dis = dist(a, a, b); if (da * 2 < db && da * 2 < height && dis > da) cout << Bob n ; else cout << Alice n ; } return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int t; cin >> t; for (int i = 0; i < t; i++) { int n, m; cin >> n; vector<int> v(2 * n), v2; for (int i = 0; i < 2 * n; i++) { cin >> v[i]; } for (int i = 0; i < 2 * n; i++) { int d = 1; for (int j = 0; j < i; j++) { if (v[j] == v[i]) { d = 0; break; } } if (d) { v2.push_back(v[i]); } } for (int i = 0; i < v2.size(); i++) { cout << v2[i] << ; } cout << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; int c[1100000], v[1100000], w[1100000], n, K, s1[1100000], s2[1100000], len1, len2, pre1, pre2; void insert(int k) { while (len1 >= pre1 && v[s1[len1]] <= v[k]) len1--; s1[++len1] = k; while (len2 >= pre2 && c[s2[len2]] >= c[k]) len2--; s2[++len2] = k; } int main() { scanf( %d%d , &n, &K); for (int i = 1; i <= n; i++) scanf( %d , &v[i]); for (int i = 1; i <= n; i++) scanf( %d , &c[i]); pre1 = 1; pre2 = 1; len1 = 1; len2 = 1; int now = 1; s1[1] = 1; s2[1] = 1; for (int i = 1; i <= n; i++) { if (now < i) insert(i), now++; while (s1[pre1] < i) pre1++; while (s2[pre2] < i) pre2++; while (now < n) { int k1 = v[s1[pre1]], k2 = c[s2[pre2]]; if (k1 * 100 >= k2) break; k1 = max(k1, v[now + 1]); k2 = min(k2, c[now + 1]); if (k1 * 100 < k2) { insert(now + 1); now++; } else break; } int k1 = v[s1[pre1]], k2 = c[s2[pre2]]; w[i] = min(k1 * 100, k2); if (now != n) { k1 = max(k1, v[now + 1]); k2 = min(k2, c[now + 1]); w[i] = max(w[i], min(k1 * 100, k2)); } } sort(w + 1, w + n + 1); double ans = 0, noww = (double)K / (double)n; for (int i = 1; i <= n - K + 1; i++) { ans = ans + w[i] * noww; int k1 = n - K + 1 - i, k2 = n - i; noww = noww * k1 / k2; } printf( %.11lf n , ans); return 0; } |
#include <bits/stdc++.h> using namespace std; string s; int a[305], ans[305], b[305][305], n, mx = 0; bool visit[305]; int main() { cin >> n; for (int i = 1; i <= n; i++) { cin >> a[i]; } for (int i = 1; i <= n; i++) { cin >> s; for (int j = 0; j < n; j++) { b[i][j + 1] = s[j] - 48; } } for (int k = 1; k <= n; k++) { for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { if (b[i][k] && b[k][j]) b[i][j] = 1; } } } for (int i = 1; i <= n; i++) { mx = a[i]; for (int j = 1; j <= n; j++) { if (b[i][j]) { if (a[j] < mx && !visit[a[j]]) { mx = a[j]; swap(a[i], a[j]); } } } visit[mx] = 1; ans[i] = mx; } for (int i = 0; i < n; i++) { if (i) cout << << ans[i + 1]; else cout << ans[i + 1]; } return 0; } |
#include <bits/stdc++.h> using namespace std; long long int isp[100005]; void pp() { for (long long int i = 2; i <= 100000; i++) { if (!isp[i]) { for (long long int j = i * i; j <= 100000; j += i) { isp[j] = 1; } } } } int32_t main() { ios_base::sync_with_stdio(false); cin.tie(NULL); long long int t; cin >> t; pp(); while (t--) { long long int n, i, j, x, y; cin >> n; if (!isp[n]) { for (long long int i = 1; i <= n; i++) { for (long long int j = 1; j <= n; j++) { cout << 1 << ; } cout << n ; } continue; } x = -1; for (long long int i = n + 1; i <= 100000; i++) { if (!isp[i] && isp[i - n + 1]) { x = i - n + 1; break; } } for (long long int i = 1; i < n; i++) { for (long long int j = 1; j < n; j++) { cout << 1 << ; } cout << x << n ; } y = 0; for (long long int i = 1; i < n; i++) { y += x; cout << x << ; } for (long long int i = y; i <= 100000; i++) { if (!isp[i] && isp[i - y]) { x = i - y; break; } } cout << x << n ; } return 0; } |
#include <bits/stdc++.h> using namespace std; pair<long long, long long> p; vector<pair<long long, long long>> adj[101]; long long visited[101]; long long parent[101]; long long maxi = 0; set<long long, greater<long long>> set1; vector<long long> arr; long long ans[101]; void dfs(long long v, long long p) { for (auto q : adj[v]) { long long u = q.first; if (u == p) continue; dfs(u, v); ans[v] = max(ans[v], ans[u] + q.second); } } signed main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); long long n, a, b, c; cin >> n; long long z = n - 1; while (z--) { cin >> a >> b >> c; adj[a].push_back(make_pair(b, c)); adj[b].push_back(make_pair(a, c)); } memset(visited, 0, sizeof(visited)); dfs(0, -1); cout << ans[0] << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; using namespace std; vector<int> x[1003]; int a[1003], v[1003]; int n; void pp() { for (int i = 1; i <= n; i++) { for (int j = 0; j < x[i].size(); j++) cout << i << << x[i][j] << n ; } } int main() { int m, k; cin >> n >> m >> k; for (int i = 1; i <= k; i++) { cin >> a[i]; v[a[i]] = 1; } if (k == n) { cout << -1 << n ; return 0; } int l; for (int i = 1; i <= n; i++) { if (v[i] == 0) l = i; } for (int i = 1; i <= n; i++) { if (i != l) x[l].push_back(i); } int w = n - 1; if (w == m) { pp(); return 0; } for (int i = 1; i <= n; i++) { for (int j = i + 1; j <= n; j++) { if (i != l && i != a[1] && i != a[2] && j != l && j != a[1] && j != a[2]) { x[i].push_back(j); w++; if (w == m) { pp(); return 0; } } } } for (int i = 1; i <= n; i++) { if (i != l && i != a[1] && i != a[2]) { if (v[i] == 1) { x[a[1]].push_back(i); w++; if (w == m) { pp(); return 0; } } else { x[a[1]].push_back(i); w++; if (w == m) { pp(); return 0; } x[a[2]].push_back(i); w++; if (w == m) { pp(); return 0; } } } } cout << -1 << n ; } |
#include <bits/stdc++.h> using namespace std; const int N = 1e5 + 5; const int INF = 0x3f3f3f3f; long long n, l, r; pair<long long, long long> dfs(long long x) { if (x == 0) return make_pair(1, 0); else if (x == 1) return make_pair(1, 1); long long tmp = x & 1; pair<long long, long long> t = dfs(x / 2); t.first = t.first * 2 + 1; t.second = t.second * 2 + tmp; return t; } long long get(long long x, long long k) { if (x == 0) return 0; else if (x == 1) return 1; pair<long long, long long> t = dfs(x / 2); if (k <= t.first) return get(x / 2, k); else if (k == t.first + 1) return t.second + (x & 1); else { return t.second + (x & 1) + get(x / 2, k - t.first - 1); } } int main() { scanf( %I64d%I64d%I64d , &n, &l, &r); printf( %I64d n , get(n, r) - (l - 1 == 0 ? 0 : get(n, l - 1))); return 0; } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.