func_code_string
stringlengths 59
71.4k
|
|---|
#include <bits/stdc++.h> using namespace std; mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); const long long mod = 1000000007; const long long INF18 = 1000000000000000000; long long n; long long a[1010]; bool ok = false; void rec(long long depth, long long cnt, long long sum) { if (ok) return; if (depth >= n) { if (cnt < 1) return; if (sum == 0) ok = true; return; } rec(depth + 1, cnt, sum); rec(depth + 1, cnt + 1, sum + a[depth]); rec(depth + 1, cnt + 1, sum - a[depth]); } void solve() { cin >> n; for (long long i = 0; i < n; i++) cin >> a[i]; for (long long i = 0; i < n; i++) { if (a[i] == 0) { cout << YES n ; return; } for (long long j = 0; j < n; j++) { if (i == j) continue; if (a[i] == a[j]) { cout << YES n ; return; } } } ok = false; rec(0, 0, 0); if (ok) cout << YES n ; else cout << NO n ; } int32_t main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); long long t; cin >> t; while (t--) { solve(); } }
|
#include <bits/stdc++.h> using namespace std; int FuN(long long n) { string s; while (n != 0) { int ch = (n % 2); s += ch + 0 ; n /= 2; } int x = -1; for (int i = 0; i < s.size(); i++) { if (s[i] == 1 ) x = i + 1; } return x; } int main() { int t, n, i, j; t = 1; cin >> t; while (t--) { long long ans = 0, fg = 1, a[200005], cnt = 0, x; cin >> n; map<long long, long long> m; for (i = 1; i <= n; i++) { cin >> a[i]; x = FuN(a[i]); m[x]++; } for (auto it : m) { ans += (it.second * (it.second - 1)) / 2; } cout << ans << endl; } return 0; }
|
#include <bits/stdc++.h> using namespace std; template <class T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; } const double EPS = 1e-9; const double PI = acos(-1.); const int INF = 1e9; const int MAXN = 2e5 + 5; const long long MOD = 1e9 + 7; void output_path(int n, int a, int b, int c, int d) { cout << a << << c << ; for (int i = (1); i <= (int)(n); i++) { if (i != a && i != b && i != c && i != d) { cout << i << ; } } cout << d << << b << endl; } void solve() { int n, k, a, b, c, d; cin >> n >> k >> a >> b >> c >> d; if (n == 4 || k <= n) { cout << -1 << endl; return; } output_path(n, a, b, c, d); output_path(n, c, d, a, b); } int main() { int t = 1; while (t--) { solve(); } }
|
#include <bits/stdc++.h> using ll = long long; using namespace std; bool is_valid_streak(map<ll, ll>& unique_counts) { if (unique_counts.size() == 2 && unique_counts.begin()->first == 1 && unique_counts.begin()->second == 1) { return true; } else if (unique_counts.size() == 2 && unique_counts.begin()->first + 1 == unique_counts.rbegin()->first && unique_counts.rbegin()->second == 1) { return true; } return false; } int main() { ll n; cin >> n; vector<ll> a(n); map<ll, ll> counts; map<ll, ll> unique_counts; set<ll> unique_values; for (ll i = 0; i < n; i++) { cin >> a[i]; } ll ans = 0; for (ll i = 0; i < n; i++) { if (counts[a[i]] != 0) { unique_counts[counts[a[i]]]--; if (unique_counts[counts[a[i]]] == 0) { unique_counts.erase(counts[a[i]]); } } counts[a[i]]++; unique_counts[counts[a[i]]]++; unique_values.insert(a[i]); if (unique_values.size() == 1) { ans = i + 1; } else if (unique_values.size() == i + 1) { ans = i + 1; } else if (is_valid_streak(unique_counts)) { ans = i + 1; } } cout << ans << endl; }
|
#include <bits/stdc++.h> using namespace std; inline int read() { int num = 0, w = 0; char ch = 0; while (!isdigit(ch)) { w |= ch == - ; ch = getchar(); } while (isdigit(ch)) { num = (num << 3) + (num << 1) + (ch ^ 48); ch = getchar(); } return w ? -num : num; } int n, m; vector<int> c[1005], r[1005]; char ch[1005][1005]; bool vis[1005], vis2[1005]; int main() { n = read(), m = read(); int numj = 0, numi = 0; for (int i = 1; i <= n; i++) { for (int j = 1; j <= m; j++) { cin >> ch[i][j]; if (ch[i][j] == # ) { c[i].push_back(j); r[j].push_back(i); if (!vis[j]) { numj++; vis[j] = true; } if (!vis2[i]) { vis2[i] = true; numi++; } } } } int tag; for (int i = 1; i <= n; i++) { for (int j = 1; j <= m; j++) { if (ch[i][j] == . ) { if (c[i].size()) { int len = c[i].size(); if (j > c[i][len - 1] || j < c[i][0]) tag = 1; else { cout << -1; return 0; } } if (r[j].size()) { int len = r[j].size(); if (i > r[j][len - 1] || i < r[j][0]) tag = 1; else { cout << -1; return 0; } } } } } int pre, aft, minl = 1005, maxl = 0, ans = 0, rest = 0; for (int i = 1; i <= n; i++) { pre = 0; for (int j = 1; j <= m; j++) { if (ch[i][j] == # ) { if (!pre) pre = j; if (j == m || ch[i][j + 1] == . ) aft = j; } } if (!pre) { rest++; continue; } if (minl == 0) { minl = pre; maxl = aft; ans++; } else if (pre > maxl) { ans++; minl = pre; maxl = aft; } else if (aft < minl) { minl = pre; maxl = aft; ans++; } else { maxl = max(maxl, aft); minl = min(minl, pre); } } if (numj == m && rest) { cout << -1; return 0; } rest = 0; for (int i = 1; i <= m; i++) { int flag = 0; for (int j = 1; j <= n; j++) { if (ch[j][i] == # ) { flag = 1; break; } } if (!flag && numi == n) { cout << -1; return 0; } } cout << ans; 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; while (t--) { int n, max = 0, count1 = 0; cin >> n; vector<int> v; for (int i = 0; i < n; i++) { int x; cin >> x; v.push_back(x); if (max < x) { max = x; } } int c = v[0]; for (int i = 0; i < v.size(); i++) { if (v[i] == c) { count1++; } c = v[i]; } if (count1 == n) { cout << 0 << endl; } else { vector<int> v1(10000); map<int, int> mp; long long int sum; for (int i = 0; i < n; i++) { sum = v[i]; for (int j = i + 1; j < n; j++) { sum = sum + v[j]; if (sum <= 8000) { v1[sum] = 1; } } } int count = 0; for (int i = 0; i < n; i++) { if (v1[v[i]]) { count++; } } cout << count << endl; } } }
|
#include <bits/stdc++.h> using namespace std; namespace jumpmelon { long long divfloor(long long a, long long b) { long long k = a / b; if (k * b > a) k--; return k; } long long divceil(long long a, long long b) { long long k = a / b; if (k * b < a) k++; return k; } void work() { long long n, i_l, i_r, i_k; scanf( %lld%lld%lld%lld , &n, &i_l, &i_r, &i_k); long long d = i_l <= i_r ? i_r - i_l + 1 : i_r + n - i_l + 1; long long s = i_k - d, v = n - d + 1, ans = -1; if (n <= 1000000) { for (long long r = 0; r <= n; r++) { long long a = max(0LL, r - v), b = min(d, r); long long mink = max(0LL, divceil(s - b, n + r)); long long maxk = divfloor(s - a, n + r); if (mink <= maxk) ans = max(ans, r); } } else { for (long long k = 0; k * n <= s; k++) { long long t = s - k * n; long long minr = 0, maxr = n; if (k) maxr = min(maxr, divfloor(t, k)); maxr = min(maxr, divfloor(t + v, k + 1)); if (k) minr = max(minr, divceil(t - d, k)); else if (t > d) continue; minr = max(minr, divceil(t, k + 1)); if (minr <= maxr) ans = max(ans, maxr); } } printf( %lld n , ans); } } // namespace jumpmelon int main() { jumpmelon::work(); return 0; }
|
#include <bits/stdc++.h> #pragma GCC optimize( O3 ) using namespace std; const int N = 1e5 + 10; multiset<int> ms; int main() { ios_base::sync_with_stdio(0); cin.tie(0); int n; cin >> n; for (int i = 0; i < n; i++) { int x; cin >> x; ms.insert(x); } int cur = 1; while (!ms.empty()) { if (cur <= *ms.begin()) { ms.erase(ms.find(*ms.begin())); cur++; } else { ms.erase(ms.find(*ms.begin())); } } cout << cur << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; int dp[100][100]; struct point { public: int f, t; point() {} point(int a, int b) { f = a, t = b; } }; int main() { int X, k; cin >> X >> k; int val, sum = 0; vector<pair<int, int>> a, b; for (int i = 0; i < (X); i++) { cin >> val; sum += val; a.push_back(make_pair(val, i + 1)); } sort((a).begin(), (a).end()); int cnt = 0; while (k--) { int di = a[X - 1].first - a[0].first; if (di > 1) { a[X - 1].first--; a[0].first++; b.push_back(make_pair(a[X - 1].second, a[0].second)); sort((a).begin(), (a).end()); cnt++; } else break; } cout << a[X - 1].first - a[0].first << << cnt << endl; for (int j = 0; j < (cnt); j++) cout << b[j].first << << b[j].second << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; const int maxn = 300005; const int maxm = 5005; int gcd(int a, int b) { if (b == 0) return a; return gcd(b, a % b); } int main() { int n; scanf( %d , &n); int a[maxn]; bool exist[maxm]; for (int i = 0; i < maxm; ++i) exist[i] = true; int i = 2; while (i < maxm) { int j = i + i; if (exist[i]) { while (j < maxm) { exist[j] = false; j += i; } } i += 1; } vector<int> primes; for (int i = 2; i < maxm; ++i) if (exist[i]) { primes.push_back(i); } for (int i = 0; i < n; ++i) scanf( %d , a + i); int cur_gcd = gcd(a[0], a[1]); for (int i = 2; i < n; ++i) if (cur_gcd != 1) cur_gcd = gcd(cur_gcd, a[i]); for (int i = 0; i < n; ++i) a[i] = a[i] / cur_gcd; vector<int> nums; for (int i = 0; i < n; ++i) { int cur = a[i]; for (int j = 0; j < primes.size(); ++j) if (primes[j] > cur) break; else if (cur % primes[j] == 0) { nums.push_back(primes[j]); while (cur % primes[j] == 0) { cur = cur / primes[j]; } } if (cur > 1) nums.push_back(cur); } sort(nums.begin(), nums.end()); int ans = 0; int left = 0, right = 0; while (right < nums.size()) { while (right < nums.size() && nums[right] == nums[left]) right++; if (right - left > ans) { ans = right - left; } left = right; } if (ans == 0 || ans == n) cout << -1 << endl; else cout << n - ans << endl; }
|
#include <bits/stdc++.h> using namespace std; int a[300010]; int main() { int t, n; cin >> t; while (t--) { cin >> n; int prvi = -1, br_jednakih = 1, maxi = -1; for (int i = 0; i < n; i++) { cin >> a[i]; maxi = max(maxi, a[i]); if (i == 0) { prvi = a[i]; continue; } if (a[i] == prvi) { br_jednakih++; } } if (br_jednakih == n) { cout << -1 << endl; continue; } if (a[0] == maxi && a[1] != a[0]) { cout << 1 << endl; continue; } bool da = false; for (int i = 1; i < n - 1; i++) { if (a[i] == maxi && (a[i + 1] != maxi || a[i - 1] != maxi) && !da) { cout << i + 1 << endl; da = true; break; } } if (da) continue; if (a[n - 1] == maxi && a[n - 2] != maxi) { cout << n << endl; } } return 0; }
|
#include <bits/stdc++.h> void parse(int size, std::string& input, int& pos, int depth, int& max_depth, std::vector<std::vector<std::string> >& comments) { if (size <= pos) { return; } if (depth > max_depth) { max_depth = depth; comments.push_back(std::vector<std::string>()); } int end = pos; while (input[end++] != , ) { } comments[depth].push_back(input.substr(pos, end - pos - 1)); pos = end; while (end < size && input[end++] != , ) { } if (end == size) { ++end; } int children = std::stoi(input.substr(pos, end - pos - 1)); pos = end; for (int i = 0; i < children; ++i) { parse(size, input, pos, depth + 1, max_depth, comments); } } int main() { std::string input; std::cin >> input; std::vector<std::vector<std::string> > comments; int max_depth = -1, pos = 0, size = input.size(); while (pos < size) { parse(size, input, pos, 0, max_depth, comments); } std::cout << max_depth + 1 << std::endl; bool not_first; for (std::vector<std::string>& level : comments) { not_first = false; for (std::string& comment : level) { if (not_first) { std::cout << ; } else { not_first = true; } std::cout << comment; } std::cout << std::endl; } return 0; }
|
#include <bits/stdc++.h> using namespace std; int n, CA, CB; struct point { int x, y; bool operator<(const point &p) const { return x != p.x ? x < p.x : y < p.y; } } st[201000]; int BX[201000], EX[201000], BY[201000], EY[201000]; long long res; void Pro(vector<point> &w, int *B, int *E) { int i; int top = 0; for (auto &tp : w) { while (top && st[top].x + st[top].y >= tp.x + tp.y) top--; if (top && st[top].y - st[top].x <= tp.y - tp.x) continue; st[++top] = tp; } int pv = 1; for (i = 1; i <= 200020; i++) { while (pv < top && st[pv].y + abs(i - st[pv].x) >= st[pv + 1].y + abs(i - st[pv + 1].x)) pv++; B[i] = st[pv].y + abs(i - st[pv].x); } top = 0; for (auto &tp : w) { while (top && st[top].y - st[top].x <= tp.y - tp.x) top--; if (top && st[top].y + st[top].x >= tp.y + tp.x) continue; st[++top] = tp; } pv = 1; for (i = 1; i <= 200020; i++) { while (pv < top && st[pv].y - abs(i - st[pv].x) <= st[pv + 1].y - abs(i - st[pv + 1].x)) pv++; E[i] = st[pv].y - abs(i - st[pv].x); if (B[i] > E[i]) B[i] = 1, E[i] = 0; } } struct AA { int t, y, ck; bool operator<(const AA &p) const { return t < p.t; } } T[401000]; int BIT[201000][2]; void Add(int a, int ck, int b) { while (a <= 200020) { BIT[a][ck] += b; a += (a & -a); } } int Sum(int a, int ck) { if (a < 0) return 0; int r = 0; while (a) { r += BIT[a][ck]; a -= (a & -a); } return r; } void Do(vector<point> w, int ck) { if (w.empty()) return; int i; sort(w.begin(), w.end()); Pro(w, BX, EX); for (i = 0; i < w.size(); i++) swap(w[i].x, w[i].y); sort(w.begin(), w.end()); Pro(w, BY, EY); int cnt = 0; for (i = 1; i <= 200020; i++) { BIT[i][0] = BIT[i][1] = 0; T[cnt++] = {BY[i], i, 1}; T[cnt++] = {EY[i] + 1, i, -1}; } sort(T, T + cnt); int pv = 0; for (i = 1; i <= 200020; i++) { while (pv < cnt && T[pv].t <= i) { Add(T[pv].y, T[pv].y % 2, T[pv].ck); pv++; } if (BX[i] > EX[i]) continue; res += Sum(EX[i], (ck + i) % 2) - Sum(BX[i] - 1, (ck + i) % 2); } } int main() { int i, x, y; scanf( %d , &n); vector<point> A, B; for (i = 1; i <= n; i++) { scanf( %d%d , &x, &y); x += 1e5 + 10; y += 1e5 + 10; if ((x + y) % 2) { A.push_back({x, y}); } else { B.push_back({x, y}); } } Do(A, 0); Do(B, 1); printf( %lld n , res); }
|
#include <bits/stdc++.h> using namespace std; long long n, h; long long r(long long l, long long s, long long e, long long d) { if (s + 1 == e) return 0; long long m = 1 + (s + e) >> 1; long long k = (n < m ? (d ? (1ll << (h - l)) : 1) : (d ? 1 : (1ll << (h - l)))); if (n < m) return r(l + 1, s, m, 1) + k; return r(l + 1, m, e, 0) + k; } int main() { cin >> h >> n; --n; cout << r(0, 0, 1ll << h, 0); }
|
#include <bits/stdc++.h> using namespace std; int ar[200010]; vector<int> ans; void solve() { int n, a, b, k, cnt = 0; cin >> n >> a >> b >> k; string s; cin >> s; int nxt = n + 1; for (int i = n; i > 0; i--) { if (s[i - 1] == 1 ) { cnt += (nxt - i - 1) / b; nxt = i; } ar[i] = nxt; } cnt += (nxt - 1) / b; int last = 0; if (cnt < a) { printf( 0 n ); return; } for (int i = 1; i <= n; i++) { if (s[i - 1] == 1 ) { last = i; continue; } if (i - last == b) { cnt--; ans.push_back(i); last = i; if (cnt < a) break; } } printf( %d n , ans.size()); for (int i = 0; i < ans.size(); i++) { printf( %d , ans[i]); } printf( n ); } int main() { int t = 1; for (int i = 1; i <= t; i++) { solve(); } }
|
#include <bits/stdc++.h> using namespace std; int main() { std::ios::sync_with_stdio(false); int n, d, h; cin >> n >> d >> h; if (d > 2 * h || (d == 1 && (n - 1 > d))) { cout << -1 << endl; } else { for (int i = 1; i <= h; i++) { cout << i << << i + 1 << endl; } if (d > h) { cout << 1 << << h + 2 << endl; for (int i = h + 2; i <= d; i++) { cout << i << << i + 1 << endl; } } if (n - 1 > d) { if (h > 1) { for (int i = d + 2; i <= n; i++) { cout << 2 << << i << endl; } } else { for (int i = d + 2; i <= n; i++) { cout << 1 << << i << endl; } } } } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n; int a[105]; cin >> n; for (int i = 0; i < n; i++) cin >> a[i]; int c = 0; for (int i = 0; i < n;) { if (a[i] == 1) { while (a[i] == 1 || a[i + 1] == 1) { c++; i++; if (i == n) break; } } i++; } cout << c << endl; return 0; }
|
#include <bits/stdc++.h> int diru[] = {-1, -1, -1, 0, 0, 1, 1, 1}; int dirv[] = {-1, 0, 1, -1, 1, -1, 0, 1}; using namespace std; template <class T> T sq(T n) { return n * n; } template <class T> T gcd(T a, T b) { return (b != 0 ? gcd<T>(b, a % b) : a); } template <class T> T lcm(T a, T b) { return (a / gcd<T>(a, b) * b); } template <class T> bool inside(T a, T b, T c) { return a <= b && b <= c; } template <class T> void setmax(T &a, T b) { if (a < b) a = b; } template <class T> void setmin(T &a, T b) { if (b < a) a = b; } template <class T> T power(T N, T P) { return (P == 0) ? 1 : N * power(N, P - 1); } pair<int, int> in[110]; int main() { int n, T, t = 1, m, i, j, k; while (scanf( %d , &n) == 1) { scanf( %d , &k); double ans = 0; for (i = 0; i < n; i++) { scanf( %d , &in[i].first); scanf( %d , &in[i].second); } for (i = 1; i < n; i++) { ans += sqrt((double)(( ((in[i].first - in[i - 1].first) * (in[i].first - in[i - 1].first)) + ((in[i].second - in[i - 1].second) * (in[i].second - in[i - 1].second))))); } ans /= (double)50.0; printf( %.15lf n , ans * (double)k); } return 0; }
|
#include <bits/stdc++.h> using namespace std; double m1 = 200.0, m2 = 0.0, DV; int card, n, k, Q, getcard; int a[110], vs[110], b[110], len = 0; int sum = 0, tmp; int main() { memset(vs, 0, sizeof(vs)); scanf( %d%d , &n, &k); card = (int)(n / k); for (int i = 1; i <= n; ++i) scanf( %d , &a[i]); scanf( %d , &Q); for (int i = 1; i <= Q; ++i) { sum = 0; for (int j = 1; j <= card; ++j) { scanf( %d , &tmp); sum += a[tmp]; vs[tmp] = 1; } DV = double(sum) / double(card); if (DV < m1) m1 = DV; if (DV > m2) m2 = DV; } for (int i = 1; i <= n; ++i) if (!vs[i]) b[++len] = a[i]; getcard = (n - len) / card; if (len >= card && getcard < k) { sort(b + 1, b + len + 1); sum = 0; for (int i = 1; i <= card; ++i) sum += b[i]; DV = double(sum) / double(card); if (DV < m1) m1 = DV; if (DV > m2) m2 = DV; sum = 0; for (int i = len - card + 1; i <= len; ++i) sum += b[i]; DV = double(sum) / double(card); if (DV < m1) m1 = DV; if (DV > m2) m2 = DV; } printf( %.10lf %.10lf n , m1, m2); return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int a; cin >> a; if (a == 1) { cout << 1 << << 1 << endl << 1 << endl; } else { cout << 2 * (a - 1) << << 2 << endl << 1 << << 2 << endl; } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); int n; cin >> n; int a = 0, b = 0, r = 0; while (true) { a = (int)n / 36; r = n % 36; b = (int)r / 3; if (r % 3 == 2) b += 1; if (b >= 12) n = b * 3 + a * 36; else break; } cout << a << << b << endl; ; return 0; }
|
#include <bits/stdc++.h> using namespace std; enum Type { Normal, HBox, VBox }; struct Widget { char name[11]; long long width, height; int border, spacing; vector<int> sons; Type type; }; int wCnt; Widget widgets[101]; map<string, int> name2id; int str2int(char* start, char* end) { int res = 0; for (char* p = start; p != end; ++p) { res = res * 10 + (*p - 0 ); } return res; } void addWidget(char name[11], int width, int height, Type type) { strcpy(widgets[wCnt].name, name); widgets[wCnt].width = width; widgets[wCnt].height = height; widgets[wCnt].border = 0; widgets[wCnt].spacing = 0; widgets[wCnt].type = type; name2id[name] = wCnt; wCnt++; } bool isWidget(char buf[50]) { if (strncmp(buf, Widget , 6) == 0) { char name[11]; int width, height; int p1, p2, p3; for (int i = 7; buf[i] != 0 ; ++i) { if (buf[i] == ( ) { p1 = i; } else if (buf[i] == , ) { p2 = i; } else if (buf[i] == ) ) { p3 = i; } } strncpy(name, buf + 7, p1 - 7); name[p1 - 7] = 0 ; width = str2int(buf + p1 + 1, buf + p2); height = str2int(buf + p2 + 1, buf + p3); addWidget(name, width, height, Normal); return true; } else { return false; } } bool isBox(char buf[50]) { char name[11]; if (strncmp(buf, HBox , 4) == 0) { strcpy(name, buf + 5); addWidget(name, 0, 0, HBox); return true; } else if (strncmp(buf, VBox , 4) == 0) { strcpy(name, buf + 5); addWidget(name, 0, 0, VBox); return true; } else { return false; } } void operate(char buf[50]) { char name[11]; int p1, p2, p3; for (int i = 0; buf[i] != 0 ; ++i) { if (buf[i] == . ) { p1 = i; } else if (buf[i] == ( ) { p2 = i; } else if (buf[i] == ) ) { p3 = i; } } strncpy(name, buf, p1); name[p1] = 0 ; int idx = name2id[name]; if (strncmp(buf + p1 + 1, pack , p2 - p1 - 1) == 0) { char packName[11]; strncpy(packName, buf + p2 + 1, p3 - p2 - 1); packName[p3 - p2 - 1] = 0 ; int packIdx = name2id[packName]; widgets[idx].sons.push_back(packIdx); } else if (strncmp(buf + p1 + 1, set_border , p2 - p1 - 1) == 0) { int border = str2int(buf + p2 + 1, buf + p3); widgets[idx].border = border; } else if (strncmp(buf + p1 + 1, set_spacing , p2 - p1 - 1) == 0) { int spacing = str2int(buf + p2 + 1, buf + p3); widgets[idx].spacing = spacing; } } void compBox(int idx) { if (widgets[idx].sons.size() == 0 || widgets[idx].width != 0) { return; } int sonSize = widgets[idx].sons.size(); for (int i = 0; i < sonSize; ++i) { int sonIdx = widgets[idx].sons[i]; compBox(sonIdx); if (widgets[idx].type == HBox) { widgets[idx].width += widgets[sonIdx].width; widgets[idx].height = max(widgets[idx].height, widgets[sonIdx].height); } else if (widgets[idx].type == VBox) { widgets[idx].width = max(widgets[idx].width, widgets[sonIdx].width); widgets[idx].height += widgets[sonIdx].height; } } widgets[idx].width += 2 * widgets[idx].border; widgets[idx].height += 2 * widgets[idx].border; if (widgets[idx].type == HBox) { widgets[idx].width += (sonSize - 1) * widgets[idx].spacing; } else if (widgets[idx].type == VBox) { widgets[idx].height += (sonSize - 1) * widgets[idx].spacing; } } void compSize() { for (int i = 0; i < wCnt; ++i) { if (widgets[i].type != Normal && widgets[i].width == 0 && widgets[i].sons.size() != 0) { compBox(i); } } } bool cmp(Widget a, Widget b) { return (strcmp(a.name, b.name) <= 0) ? true : false; } void clear() { name2id.clear(); for (int i = 0; i < wCnt; ++i) { widgets[i].sons.clear(); } } int main() { int n; while (scanf( %d , &n) != EOF) { getchar(); wCnt = 0; while (n--) { char buf[50]; fgets(buf, 50, stdin); int bufLen = strlen(buf); buf[bufLen - 1] = 0 ; if (isWidget(buf)) { continue; } if (isBox(buf)) { continue; } operate(buf); } compSize(); sort(widgets, widgets + wCnt, cmp); for (int i = 0; i < wCnt; ++i) { printf( %s %I64d %I64d n , widgets[i].name, widgets[i].width, widgets[i].height); } clear(); } return 0; }
|
#include <bits/stdc++.h> using namespace std; const double pi = acos(-1.0); const int inf = (int)1e9; const double inf1 = 1e-9; const int ss = (int)1e6 + 3; int main() { string s; getline(cin, s); int sz = s.find( . ); int z1 = 0; if (sz == -1) { sz = s.size(); z1 = -1; } string res; int z = 0; if (s[0] == - ) { res = ( ; z = 1; } res += $ ; for (int i = z; i < (sz - z) % 3 + z; ++i) res += s[i]; if ((sz - z) % 3 != 0) res += , ; string tmp; for (int i = (sz - z) % 3 + z; i < sz; i += 3) { res += s[i]; res += s[i + 1]; res += s[i + 2]; res += , ; } res.erase(res.size() - 1, 1); res += . ; s += 00 ; res += s[sz + 1 + z1]; res += s[sz + 2 + z1]; if (s[0] == - ) { res += ) ; } cout << res; return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int t; cin >> t; while (t--) { long long ans1, ans2; long long n, m; cin >> n >> m; ans1 = n * m / 2; ans2 = ans1; if (n * m % 2) ans1++; long long x1, y1, x2, y2; cin >> x1 >> y1 >> x2 >> y2; long long white1 = (x2 - x1 + 1) * (y2 - y1 + 1) / 2; long long black1 = white1; if ((x2 - x1 + 1) * (y2 - y1 + 1) % 2) { if (abs(x2 - y2) % 2) black1++; else white1++; } long long x3, y3, x4, y4; cin >> x3 >> y3 >> x4 >> y4; long long white2 = (x4 - x3 + 1) * (y4 - y3 + 1) / 2; long long black2 = white2; if ((x4 - x3 + 1) * (y4 - y3 + 1) % 2) { if (abs(x4 - y3) % 2) black2++; else white2++; } long long x5 = max(x1, x3), y5 = max(y1, y3), x6 = min(x2, x4), y6 = min(y2, y4); long long white = 0, black = 0; if (x5 <= x6 && y5 <= y6) { long long gapx = x6 - x5 + 1; long long gapy = y6 - y5 + 1; white = gapx * gapy / 2; black = white; if (gapx * gapy % 2) { if (abs(x5 - y5) % 2) black++; else white++; } } ans1 -= white; ans2 -= black; white1 -= white; black1 -= black; white2 -= white; black2 -= black; ans1 += black1; ans2 -= black1; ans2 += white2; ans1 -= white2; ans2 += white + black; cout << ans1 << << ans2 << n ; } return 0; }
|
#include <bits/stdc++.h> using namespace std; constexpr int inf = numeric_limits<int>::max() >> 1; constexpr int N = 100001; constexpr int mod = 1000000007; int h[N], tin[N], tout[N], ap[N], n, root, a[N], T; int mx[N * 4], mn[N * 4], ml[N * 4]; vector<int> g[N]; void dfs(int u, int p) { tin[u] = ++T; ap[T] = u; h[u] = h[p] + 1; for (int v : g[u]) if (v != p) dfs(v, u); tout[u] = T; } void build(int id, int l, int r) { if (l == r) { mx[id] = h[ap[l]]; mn[id] = a[ap[l]]; ml[id] = h[ap[l]]; return; } build((id << 1), l, (l + r) / 2); build(((id << 1) + 1), (l + r) / 2 + 1, r); mx[id] = max(mx[(id << 1)], mx[((id << 1) + 1)]); mn[id] = min(mn[(id << 1)], mn[((id << 1) + 1)]); ml[id] = min(ml[(id << 1)], ml[((id << 1) + 1)]); return; } int query(int id, int l, int r, int L, int R, int dep) { if (R < l || r < L) return inf; if (ml[id] > dep) return inf; if (L <= l && r <= R && mx[id] <= dep) return mn[id]; return min(query((id << 1), l, (l + r) / 2, L, R, dep), query(((id << 1) + 1), (l + r) / 2 + 1, r, L, R, dep)); } void solution() { cin >> n >> root; for (int i = 1; i <= n; i++) cin >> a[i]; for (int i = 1; i < n; i++) { int u, v; cin >> u >> v; g[u].push_back(v); g[v].push_back(u); } dfs(root, 0); build(1, 1, n); int m; cin >> m; int last = 0; while (m--) { int p, q; cin >> p >> q; p = 1 + ((p + last) % n); q = (q + last) % n; last = query(1, 1, n, tin[p], tout[p], h[p] + q); cout << last << n ; } } signed main() { ios_base::sync_with_stdio(0); cin.tie(0); int tc = 1; while (tc--) { solution(); cout << n ; } }
|
#include <bits/stdc++.h> using namespace std; const int M = 2e5 + 1; int vis[M], vis2[M]; int main() { string t, s; cin >> s >> t; int a = 0, b = 0; for (char c : t) vis[c]++; int i = 0; for (char c : s) { if (vis[c]) { vis[c]--; a++; vis2[i] = 1; } i++; } for (i = 0; i < s.size(); i++) { if (vis2[i]) continue; char c = s[i]; if (islower(c)) c = toupper(c); else c = tolower(c); if (vis[c]) b++, vis[c]--; } cout << a << << b; }
|
#include <bits/stdc++.h> using namespace std; const int P = 1e9 + 7; int add(int a, int b) { if ((a += b) >= P) a -= P; return a; } int sub(int a, int b) { if ((a -= b) < 0) a += P; return a; } int mul(int a, int b) { return 1ll * a * b % P; } int kpow(int a, int b) { int r = 1; for (; b; b >>= 1, a = mul(a, a)) { if (b & 1) r = mul(r, a); } return r; } const int N = 205; int a, b, c, w, n, m, p1, p2; char ans[N][N]; bool vis[200]; bool solve(int n, int m) { if (n * m % 2 == 1) return 0; if (n % 2 == 1) { if (m / 2 > a) return 0; a -= m / 2; for (int i = 1; i <= m; i += 2) ans[n][i] = ans[n][i + 1] = (i / 2 % 2 == 0 ? a : b ); n--; } if (m % 2 == 1) { if (n / 2 > b) return 0; b -= n / 2; for (int i = 1; i <= n; i += 2) ans[i][m] = ans[i + 1][m] = (i / 2 % 2 == 0 ? a : b ); m--; } if (a & 1) a--; if (b & 1) b--; if (n * m > a * 2 + b * 2 + c * 4) return 0; for (int i = 1; i <= n; i += 2) for (int j = 1; j <= m; j += 2) { for (int k = ( a ); k < ( z + 1); k++) vis[k] = 0; vis[ans[i - 1][j]] = 1; vis[ans[i - 1][j + 1]] = 1; vis[ans[i][j - 1]] = 1; vis[ans[i + 1][j - 1]] = 1; for (int k = ( c ); k < ( z + 1); k++) if (!vis[k]) { p1 = k; vis[p1] = 1; break; } for (int k = ( c ); k < ( z + 1); k++) if (!vis[k]) { p2 = k; vis[p2] = 1; break; } if (a > 0) { a -= 2; ans[i][j] = ans[i][j + 1] = p1; ans[i + 1][j] = ans[i + 1][j + 1] = p2; } else if (b > 0) { b -= 2; ans[i][j] = ans[i + 1][j] = p1; ans[i][j + 1] = ans[i + 1][j + 1] = p2; } else { c--; ans[i][j] = ans[i][j + 1] = ans[i + 1][j] = ans[i + 1][j + 1] = p1; } } return 1; } int main() { std::ios::sync_with_stdio(false); std::cin.tie(0); cin >> n >> m >> a >> b >> c; bool ok = solve(n, m); if (!ok) cout << IMPOSSIBLE << n ; else { for (int i = (1); i < (n + 1); i++) { for (int j = (1); j < (m + 1); j++) cout << ans[i][j]; cout << n ; } } return 0; }
|
#include <bits/stdc++.h> using namespace std; const long long INF = 1e9 + 7; const long long MOD = 998244353; vector<vector<pair<long long, long long> > > adj; int c[2]; int colour[700005]; bool ok; int n; void dfs(int idx) { c[colour[idx]] += (idx <= n); for (auto x : adj[idx]) { if (colour[x.first] == -1) { colour[x.first] = colour[idx] ^ x.second; dfs(x.first); } else if (colour[x.first] != (colour[idx] ^ x.second)) { ok = false; } } } int main(void) { ios_base::sync_with_stdio(0); cin.tie(0); int t; cin >> t; while (t--) { int m; cin >> n >> m; adj.assign(n + m + 5, vector<pair<long long, long long> >()); for (int i = 0; i < n + m + 5; i++) { colour[i] = -1; } int fake = n + 1; for (int i = 0; i < m; i++) { int a, b; string c; cin >> a >> b >> c; if (c == crewmate ) { adj[a].push_back(pair<long long, long long>(fake, 1)); adj[fake].push_back(pair<long long, long long>(a, 1)); adj[fake].push_back(pair<long long, long long>(b, 1)); adj[b].push_back(pair<long long, long long>(fake, 1)); fake++; } else { adj[a].push_back(pair<long long, long long>(b, 1)); adj[b].push_back(pair<long long, long long>(a, 1)); } } int ans = 0; ok = true; for (int i = 1; i < n + 1; i++) { if (colour[i] == -1) { colour[i] = 0; c[0] = c[1] = 0; dfs(i); ans += max(c[0], c[1]); } } if (!ok) { ans = -1; } cout << ans << n ; } }
|
#include <bits/stdc++.h> int a[1005]; void Init() { int i; a[0] = 1; a[1] = 1; for (i = 2; i <= 1000; i++) { a[i] = a[i - 1] * 3 % 1000003; } } int main() { int i, n; Init(); scanf( %d , &n); printf( %d n , a[n]); return 0; }
|
#include <bits/stdc++.h> int m, n, a[10][10] = {{0, 1, 2}, {1, 0, 2}, {1, 2, 0}, {2, 1, 0}, {2, 0, 1}, {0, 2, 1}, {0, 1, 2}}; int main() { scanf( %d %d , &n, &m); n %= 6; printf( %d , a[n][m]); return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int a, b[100], c, xd = 0, lol; cin >> a; for (int i = 0; i < a; i++) { cin >> b[i]; } sort(b, b + a); for (int i = 0; i < a; i++) { if (i == a - 1) { c = b[i]; } } for (int i = 0; i < a; i++) { if (b[i] <= c) { xd = xd + (c - b[i]); } } cout << xd; }
|
#include <bits/stdc++.h> using namespace std; template <class T> T inline sqr(T x) { return x * x; } const long double pi = 3.1415926535897932384626433832795; const long double eps = 1e-8; const int MAXN = 1000500; string s; int n; int fin[3]; struct node { int l, r, par, link; map<char, int> next; node(int l = 0, int r = 0, int par = -1) : l(l), r(r), par(par), link(-1) {} int len() { return r - l; } int &get(char c) { if (!next.count(c)) next[c] = -1; return next[c]; } }; node t[MAXN]; int sz; struct state { int v, pos; state(int v, int pos) : v(v), pos(pos) {} }; state ptr(0, 0); state go(state st, int l, int r) { while (l < r) if (st.pos == t[st.v].len()) { st = state(t[st.v].get(s[l]), 0); if (st.v == -1) return st; } else { if (s[t[st.v].l + st.pos] != s[l]) return state(-1, -1); if (r - l < t[st.v].len() - st.pos) return state(st.v, st.pos + r - l); l += t[st.v].len() - st.pos; st.pos = t[st.v].len(); } return st; } int split(state st) { if (st.pos == t[st.v].len()) return st.v; if (st.pos == 0) return t[st.v].par; node v = t[st.v]; int id = sz++; t[id] = node(v.l, v.l + st.pos, v.par); t[v.par].get(s[v.l]) = id; t[id].get(s[v.l + st.pos]) = st.v; t[st.v].par = id; t[st.v].l += st.pos; return id; } int get_link(int v) { if (t[v].link != -1) return t[v].link; if (t[v].par == -1) return 0; int to = get_link(t[v].par); return t[v].link = split( go(state(to, t[to].len()), t[v].l + (t[v].par == 0), t[v].r)); } void tree_extend(int pos) { for (;;) { state nptr = go(ptr, pos, pos + 1); if (nptr.v != -1) { ptr = nptr; return; } int mid = split(ptr); int leaf = sz++; t[leaf] = node(pos, n, mid); t[mid].get(s[pos]) = leaf; ptr.v = get_link(mid); ptr.pos = t[ptr.v].len(); if (!mid) break; } } void build_tree() { sz = 1; for (int i = 0; i < n; ++i) tree_extend(i); } long long d[MAXN][3]; long long ans[MAXN]; const int MOD = 1e9 + 7; long long bal[MAXN]; void add(int l, int r, int val) { bal[l] += val; bal[r + 1] -= val; } void dfs(int v, int len) { for (auto w : ::t[v].next) { int nlen = len + ::t[w.second].len(); dfs(w.second, nlen); } int tt = -1; for (int i = 0; i < (int)(3); ++i) if (fin[i] >= t[v].l && fin[i] < t[v].r) { tt = i; break; } if (tt != -1) d[v][tt] = 1; else { for (auto w : ::t[v].next) { for (int i = 0; i < (int)(3); ++i) d[v][i] += d[w.second][i]; } long long c = 1; for (int i = 0; i < (int)(3); ++i) c = (c * d[v][i]) % MOD; add(len - t[v].len() + 1, len, c); } } int main() { vector<string> in(3); for (int i = 0; i < (int)(3); ++i) { cin >> in[i]; s += in[i]; fin[i] = s.length(); s += char( 0 + i); } n = s.length(); build_tree(); dfs(0, 0); int l = 1e9; for (int i = 0; i < (int)(3); ++i) l = min(l, (int)in[i].length()); long long z = 0; for (int i = 0; i < (int)(MAXN); ++i) { z += bal[i]; z %= MOD; z = (z + MOD) % MOD; ans[i] = z; } for (int i = 1; i <= (int)(l); ++i) printf( %d , (int)ans[i]); return 0; }
|
#include <bits/stdc++.h> using namespace std; using UL = unsigned long int; using UI = unsigned int; using ULL = unsigned long long int; using LI = long int; using LL = long long; using LF = double; using LLF = long double; const int mod1 = 1000000007; const int mod2 = 998244353; const double PI = acos(-1); int main() { ios_base::sync_with_stdio(0); cin.tie(NULL); cout.tie(NULL); int ntc = 1, tc, i, j; int n, k; for (tc = 1; tc <= ntc; tc++) { cin >> n >> k; string s; cin >> s; int cnt1[26] = {0}, cnt2[26] = {0}; string ans = ; for (auto ch : s) { cnt1[ch - a ]++; } for (i = 0; i < 26 && k > 0; i++) { cnt2[i] += min(k, cnt1[i]); k -= min(k, cnt1[i]); } for (auto ch : s) { if (cnt2[ch - a ] > 0) { cnt2[ch - a ]--; continue; } cout << ch; } } return 0; }
|
#include <bits/stdc++.h> using namespace std; const int N = 1004; int n, p, q, f[N][54][54], vc = 1000000000, ns[N][30], nt[N][30]; char c[N], s[N], t[N]; bool check1(int i, char x, int j) { if (i + 1 < j) return false; for (int k = 1; k < j; k++) { if (s[i + k - j + 1] != s[k]) return false; } if (x != s[j]) return false; return true; } bool check2(int i, char x, int j) { if (i + 1 < j) return false; for (int k = 1; k < j; k++) { if (t[i + k - j + 1] != t[k]) return false; } if (x != t[j]) return false; return true; } void build() { for (int i = 0; i <= p; i++) { for (char x = a ; x <= z ; x++) { for (int j = p; j >= 1; j--) { if (check1(i, x, j)) { ns[i][x - a + 1] = j; break; } } } } for (int i = 0; i <= q; i++) { for (char x = a ; x <= z ; x++) { for (int j = q; j >= 1; j--) { if (check2(i, x, j)) { nt[i][x - a + 1] = j; break; } } } } } int cal(int i, int x, int y) { if (i == n) return 0; if (f[i][x][y] != -vc) return f[i][x][y]; f[i][x][y] = -vc + 1; if (c[i + 1] == * ) { for (char b = a ; b <= z ; b++) { int cost = 0; int nx1 = ns[x][b - a + 1]; if (nx1 == p) cost++; int nx2 = nt[y][b - a + 1]; if (nx2 == q) cost--; f[i][x][y] = max(f[i][x][y], cal(i + 1, nx1, nx2) + cost); } } else { int cost = 0; char b = c[i + 1]; int nx1 = ns[x][b - a + 1]; if (nx1 == p) cost++; int nx2 = nt[y][b - a + 1]; if (nx2 == q) cost--; f[i][x][y] = max(f[i][x][y], cal(i + 1, nx1, nx2) + cost); } return f[i][x][y]; } int main() { scanf( %s%s%s , c + 1, s + 1, t + 1); p = strlen(s + 1); q = strlen(t + 1); n = strlen(c + 1); build(); for (int i = 0; i <= n; i++) { for (int j = 0; j <= p; j++) { for (int z = 0; z <= q; z++) f[i][j][z] = -vc; } } cout << cal(0, 0, 0); }
|
#include <bits/stdc++.h> using namespace std; string S; set<string> answer; void izomorphism1(string &s) { swap(s[0], s[3]); swap(s[1], s[3]); swap(s[2], s[3]); } void izomorphism2(string &s) { swap(s[1], s[4]); swap(s[3], s[5]); swap(s[4], s[5]); } void izomorphism3(string &s) { swap(s[4], s[2]); swap(s[0], s[5]); swap(s[4], s[5]); } int main() { cin >> S; sort(S.begin(), S.end()); do { string cur_S, min_string; cur_S = S; min_string = S; for (int i = 1; i <= 4; i++, izomorphism1(cur_S)) for (int j = 1; j <= 4; j++, izomorphism2(cur_S)) for (int z = 1; z <= 4; z++, izomorphism3(cur_S)) { min_string = min(min_string, cur_S); } answer.insert(min_string); } while (next_permutation(S.begin(), S.end())); cout << answer.size() << endl; return 0; }
|
#include <bits/stdc++.h> const unsigned long long maxn = 70; unsigned long long n, flg, KKK, ans; unsigned long long f[maxn], mul10[maxn], cycle[maxn], a[maxn]; struct matrix { unsigned long long len, wid; unsigned long long mt[3][3]; } pre[14][45]; inline unsigned long long min(unsigned long long a, unsigned long long b) { return a < b ? a : b; } unsigned long long modmul(unsigned long long a, unsigned long long b, unsigned long long mod) { unsigned long long res = 0; while (b) { if (b & 1) { res += a; if (res > mod) res -= mod; } a += a; if (a > mod) a -= mod; b >>= 1; } return res; } matrix mul(matrix a, matrix b, unsigned long long mod) { matrix res; res.len = a.len, res.wid = b.wid; for (unsigned long long u = 1; u <= a.len; u++) for (unsigned long long v = 1; v <= b.wid; v++) res.mt[u][v] = 0; for (unsigned long long u = 1; u <= a.len; u++) for (unsigned long long v = 1; v <= b.wid; v++) for (unsigned long long w = 1; w <= a.wid; w++) res.mt[u][v] = (res.mt[u][v] + modmul(a.mt[u][w], b.mt[w][v], mod)) % mod; return res; } unsigned long long calc(unsigned long long b, unsigned long long kk, unsigned long long mod) { matrix a, res; res.len = 1, res.wid = 2, res.mt[1][1] = 0, res.mt[1][2] = 1; for (unsigned long long i = 0; i <= 44; i++) if ((b >> i) & 1) res = mul(res, pre[kk][i], mod); return res.mt[1][1]; } void dfs(unsigned long long len, unsigned long long now) { if (now > ans) return; if (len == n + 1) { flg = 1, ans = min(ans, now); return; } for (unsigned long long i = 0; i < 10; i++) { unsigned long long k = (modmul(i, cycle[len], cycle[len + 1]) + now) % cycle[len + 1]; if (calc(k, len, mul10[len]) == a[len]) dfs(len + 1, k); } } signed main() { f[0] = 0, f[1] = 1; for (unsigned long long i = 2; i <= 60; i++) f[i] = f[i - 1] + f[i - 2]; cycle[0] = 6, mul10[0] = 1; for (unsigned long long i = 1; i <= 19; i++) cycle[i] = 10ll * cycle[i - 1], mul10[i] = 10ll * mul10[i - 1]; for (unsigned long long i = 1; i <= 13; i++) { pre[i][0].len = pre[i][0].wid = 2, pre[i][0].mt[1][1] = 0, pre[i][0].mt[1][2] = pre[i][0].mt[2][1] = pre[i][0].mt[2][2] = 1; for (unsigned long long j = 1; j <= 44; j++) pre[i][j] = mul(pre[i][j - 1], pre[i][j - 1], mul10[i]); } scanf( %llu , &KKK); n = 13, ans = 10000000000000000; for (unsigned long long i = 1; i <= n; i++) a[i] = a[i - 1] + KKK % 10 * mul10[i - 1], KKK /= 10; for (unsigned long long i = 0; i < 60; i++) if (f[i] % 10 == a[1]) dfs(1, i); if (flg == 0) puts( -1 ); else printf( %llu n , ans); return 0; }
|
#include <bits/stdc++.h> using namespace std; map<int, int> mp; int main() { int n, m; cin >> n >> m; int now1 = 0; for (int i = 0; i < n; i++) { int c, t; cin >> c >> t; now1 += c * t; mp[now1] = 1; } map<int, int>::iterator it = mp.begin(); int now = 0; for (int i = 0; i < m; i++) { int v; cin >> v; while (v > it->first) { it++; now++; } cout << now + 1 << endl; } }
|
#include <bits/stdc++.h> using namespace std; template <typename T, typename U> inline void smin(T &a, U b) { if (a > b) a = b; } template <typename T, typename U> inline void smax(T &a, U b) { if (a < b) a = b; } template <class T> inline void gn(T &first) { char c, sg = 0; while (c = getchar(), (c > 9 || c < 0 ) && c != - ) ; for ((c == - ? sg = 1, c = getchar() : 0), first = 0; c >= 0 && c <= 9 ; c = getchar()) first = (first << 1) + (first << 3) + c - 0 ; if (sg) first = -first; } template <class T, class T1> inline void gn(T &first, T1 &second) { gn(first); gn(second); } template <class T, class T1, class T2> inline void gn(T &first, T1 &second, T2 &z) { gn(first); gn(second); gn(z); } template <class T> inline void print(T first) { if (first < 0) { putchar( - ); return print(-first); } if (first < 10) { putchar( 0 + first); return; } print(first / 10); putchar(first % 10 + 0 ); } template <class T> inline void printsp(T first) { print(first); putchar( ); } template <class T> inline void println(T first) { print(first); putchar( n ); } template <class T, class U> inline void print(T first, U second) { printsp(first); println(second); } template <class T, class U, class V> inline void print(T first, U second, V z) { printsp(first); printsp(second); println(z); } int power(int a, int b, int m, int ans = 1) { for (; b; b >>= 1, a = 1LL * a * a % m) if (b & 1) ans = 1LL * ans * a % m; return ans; } int ch[300010], re[300010], a[300010]; int C(int n, int m) { return ((long long)ch[n] * re[m] % 1000000007) * (long long)re[n - m] % 1000000007; } void pre() { ch[0] = 1; for (int i = 1; i < 300010; i++) ch[i] = (long long)ch[i - 1] * i % 1000000007; re[300010 - 1] = power(ch[300010 - 1], 1000000007 - 2, 1000000007); for (int i = 300010 - 1; i > 0; i--) re[i - 1] = (long long)re[i] * i % 1000000007; return; } int main() { pre(); int n; gn(n); for (int i = 1; i <= n; i++) gn(a[i]); if (n == 1) { printf( %d n , a[1]); return 0; } if (n == 2) { printf( %d n , ((a[1] + a[2]) % 1000000007 + 1000000007) % 1000000007); return 0; } if (n & 1) { for (int i = 1; i < n; i++) { if (i & 1) a[i] = ((a[i] + a[i + 1]) % 1000000007 + 1000000007) % 1000000007; else a[i] = ((a[i] - a[i + 1]) % 1000000007 + 1000000007) % 1000000007; } n--; } if (n == 2) { printf( %d n , (a[1] + a[2]) % 1000000007); return 0; } long long ans1 = 0, ans2 = 0; int m = n / 2; for (int i = 1; i <= n; i++) { if (i & 1) { ans1 = (ans1 + (long long)C(m - 1, i / 2) * a[i] % 1000000007) % 1000000007; } else { ans2 = (ans2 + (long long)C(m - 1, i / 2 - 1) * a[i] % 1000000007) % 1000000007; } } if (m & 1 == 1) printf( %I64d n , (ans1 + ans2) % 1000000007); else printf( %I64d n , ((ans1 - ans2) % 1000000007 + 1000000007) % 1000000007); return 0; }
|
#include <bits/stdc++.h> struct node { int x, y; int dir, len; } arr[1100 * 1100], st[1100]; int n, m, tot, vis[1100][1100], cnt; int srow[1100][1100], scol[1100][1100]; int dir[4] = {1, -1, -1, 1}; char mmap[1100][1100]; void Initial() { int i, j, k; for (i = 1; i <= n; ++i) for (j = 1; j <= m; ++j) srow[i][j] = srow[i][j - 1] + vis[i][j]; for (j = 1; j <= m; ++j) for (i = 1; i <= n; ++i) scol[i][j] = scol[i - 1][j] + vis[i][j]; } int GetDir(char c) { if (c == N ) return 0; if (c == S ) return 1; if (c == W ) return 2; if (c == E ) return 3; } int Isok(int in) { int i, j, k, x, y; x = st[in].x, y = st[in].y; for (i = 1; i <= tot; ++i) { int td = arr[i].dir, tl = arr[i].len; if (td == 0) { if (x - tl <= 0) return 0; if (scol[x][y] - scol[x - tl - 1][y] > 0) return 0; x -= tl; } else if (td == 1) { if (x + tl >= n + 1) return 0; if (scol[x + tl][y] - scol[x - 1][y] > 0) return 0; x += tl; } else if (td == 2) { if (y - tl <= 0) return 0; if (srow[x][y] - srow[x][y - tl - 1] > 0) return 0; y -= tl; } else { if (y + tl >= m + 1) return 0; if (srow[x][y + tl] - srow[x][y - 1] > 0) return 0; y += tl; } } cnt++; return 1; } int main() { int i, j, k; while (scanf( %d%d , &n, &m) != EOF) { for (i = 0; i < 26; ++i) st[i].x = -1; for (i = 1; i <= n; ++i) { scanf( %s , mmap[i] + 1); for (j = 1; j <= m; ++j) { if (mmap[i][j] >= A && mmap[i][j] <= Z ) st[mmap[i][j] - A ].x = i, st[mmap[i][j] - A ].y = j; vis[i][j] = mmap[i][j] == # ? 1 : 0; } } Initial(); scanf( %d , &tot); for (i = 1; i <= tot; ++i) { char str[20]; scanf( %s %d , str, &arr[i].len); arr[i].dir = GetDir(str[0]); } cnt = 0; for (i = 0; i < 26; ++i) if (st[i].x != -1 && Isok(i)) printf( %c , i + A ); if (cnt == 0) printf( no solution n ); printf( n ); } }
|
#include <bits/stdc++.h> using namespace std; const int N = 2000 + 5; int a[N], b[N]; bool mark[N]; vector<int> ch; int main() { int n, m, mn, ans = 0; cin >> n >> m; mn = n / m; for (int i = 0; i < n; i++) { cin >> a[i]; if (a[i] <= m && !mark[a[i]]) { b[a[i]]++; if (b[a[i]] == mn) mark[a[i]] = true; } else ch.push_back(i); } for (int i = 1; i <= m; i++) while (!mark[i]) { ans++; a[ch.back()] = i; ch.pop_back(); b[i]++; if (b[i] == mn) mark[i] = true; } cout << mn << << ans << n ; for (int i = 0; i < n; i++) cout << a[i] << ; cout << n ; return 0; }
|
#include <bits/stdc++.h> const unsigned long long inf = 1LL << 61; const double eps = 1e-5; using namespace std; bool cmp(int a, int b) { return a > b; } string itoa(long long a) { string t = ; while (a > 0) { t += (char)(a % 10 + 0 ); a /= 10; } string s = ; for (int i = t.size() - 1; i >= 0; i--) s += t[i]; return s; } long long atoi(string s) { long long t = 1; long long ans = 0; for (int i = s.size() - 1; i >= 0; i--) { long long b = (long long)(s[i] - 0 ); ans += b * t; t *= 10; } return ans; } int main() { int n, m; while (cin >> n >> m) { long long c = m + n; string c1 = itoa(c); string c2 = ; for (int i = 0; i < c1.size(); i++) { if (c1[i] != 0 ) c2 += c1[i]; } long long cc = atoi(c2); string a = itoa(n); string b = itoa(m); string a1 = ; string b1 = ; for (int i = 0; i < a.size(); i++) { if (a[i] != 0 ) a1 += a[i]; } for (int j = 0; j < b.size(); j++) { if (b[j] != 0 ) b1 += b[j]; } long long aa = atoi(a1); long long bb = atoi(b1); if (aa + bb == cc) puts( YES ); else puts( NO ); } return 0; }
|
#include <bits/stdc++.h> using namespace std; int a[100005]; int ans[100005]; string s[100005]; map<string, int> h; vector<pair<int, int> > v; string res[6] = { S , M , L , XL , XXL , XXXL }; int main() { memset(ans, -1, sizeof(ans)); ios_base::sync_with_stdio(false); cin.tie(NULL); h[ S ] = 0; h[ M ] = 1; h[ L ] = 2; h[ XL ] = 3; h[ XXL ] = 4; h[ XXXL ] = 5; for (int i = 0; i < 6; i++) cin >> a[i]; int n; cin >> n; bool ok = 1; for (int i = 1; i <= n; i++) { cin >> s[i]; string t[2]; t[0] = ; t[1] = ; int k = 0; int m = s[i].length(); for (int j = 0; j < m; j++) { if (s[i][j] == , ) k++; else t[k] += s[i][j]; } if (t[1] == ) { ans[i] = h[t[0]]; a[h[t[0]]]--; if (a[h[t[0]]] < 0) ok = 0; } else v.push_back(pair<int, int>(h[t[0]], i)); } sort(v.begin(), v.end()); for (int i = 0; i < v.size(); i++) { int j = v[i].second, x = v[i].first; if (a[x] > 0) ans[j] = x, a[x]--; else ans[j] = x + 1, a[x + 1]--; } for (int i = 0; i < 6; i++) if (a[i] < 0) ok = 0; if (!ok) printf( NO n ); else { cout << YES << n ; for (int i = 1; i <= n; i++) cout << res[ans[i]] << n ; } }
|
#include <bits/stdc++.h> using namespace std; int a[103], n, x, y, m, ans; int main() { cin >> x >> y >> n; m = x * y; for (int i = 0; i < n; i++) cin >> a[i]; for (int i = 0; i < m; i++) { int x, j; cin >> x; for (j = 0; j < n; j++) { if (a[j] == x) break; } ans = ans + j + 1; for (int k = j - 1; k >= 0; k--) a[k + 1] = a[k]; a[0] = x; } cout << ans; }
|
#include <bits/stdc++.h> using namespace std; void runcase() { int n, k; cin >> n >> k; vector<int> a(n); for (int i = 0; i < n; i++) cin >> a[i]; int changes = 0; k--; for (int i = 1; i < n; i++) if (a[i] != a[i - 1]) changes++; int ans = 0; if (k == 0) { if (changes == 0) ans = 1; else ans = -1; } else { ans = max(1, (changes + k - 1) / k); } cout << ans << endl; } int main() { int t; cin >> t; while (t--) runcase(); return 0; }
|
#include <bits/stdc++.h> using namespace std; long long f[10]; void ge() { f[0] = 1; for (int i = 1; i <= 9; i++) { f[i] = f[i - 1] * 10; } } long long a[100005], b[100005]; int main() { ge(); int n, k; long long ans = 1; int i, j; scanf( %d%d , &n, &k); for (i = 0; i < n / k; i++) { scanf( %I64d , &a[i]); } for (i = 0; i < n / k; i++) { scanf( %I64d , &b[i]); } for (i = 0; i < n / k; i++) { long long n1 = (f[k] - 1) / a[i] + 1; long long n2 = (f[k - 1] - 1) / a[i] + 1; long long n3 = (f[k - 1] * (b[i] + 1) - 1) / a[i] + 1 - (f[k - 1] * b[i] - 1) / a[i] - 1; if (b[i] == 0) ans *= n1 - n2; else ans *= n1 - n3; ans %= 1000000007; } printf( %I64d , ans); return 0; }
|
#include <bits/stdc++.h> using namespace std; void solve() { int n; cin >> n; vector<long long int> a(n); vector<long long int> mp(n + 1, 0); for (int i = 0; i < n; i++) { cin >> a[i]; mp[a[i]]++; } vector<long long int> ans(n + 1); priority_queue<pair<long long, long long>> pq; long long cost = 0; for (int i = 0; i < n + 1; i++) { ans[i] = mp[i] + cost; if (mp[i] == 0) { if (pq.empty()) { for (int j = i + 1; j < n + 1; j++) ans[j] = -1; break; } auto tp = pq.top(); pq.pop(); cost += (long long)(i - tp.first); tp.second--; if (tp.second > 1) pq.push({tp.first, tp.second}); } if (mp[i] > 1) pq.push({i, mp[i]}); } for (int i = 0; i < n + 1; i++) cout << ans[i] << ; cout << endl; } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); int t; cin >> t; while (t--) { solve(); } }
|
#include <bits/stdc++.h> using namespace std; vector<int> in[101000]; int n, m, k, curt; int up[101000], t[101000], tout[101000], ans[101000]; int jmp[101000][20]; char used[101000]; void dfs(int v, int p) { if (used[v]) return; used[v] = 1; t[v] = curt++; up[v] = t[v]; for (unsigned int i = 0; i < in[v].size(); i++) if (used[in[v][i]]) { if (p != in[v][i]) up[v] = min(up[v], t[in[v][i]]); } else { dfs(in[v][i], v); up[v] = min(up[v], up[in[v][i]]); } } void dfs2(int v, int cur) { if (used[v]) return; used[v] = 1; ans[v] = cur; for (unsigned int i = 0; i < in[v].size(); i++) if (!used[in[v][i]] && !((t[v] < t[in[v][i]] && up[in[v][i]] > t[v]) || (t[v] > t[in[v][i]] && up[v] > t[in[v][i]]))) dfs2(in[v][i], cur); for (unsigned int i = 0; i < in[v].size(); i++) if (!used[in[v][i]] && ((t[v] < t[in[v][i]] && up[in[v][i]] > t[v]) || (t[v] > t[in[v][i]] && up[v] > t[in[v][i]]))) dfs2(in[v][i], cur + 1); } void getLCA(int v, int p) { if (used[v]) return; used[v] = 1; t[v] = curt++; jmp[v][0] = p; for (int i = 1; i <= 18; ++i) jmp[v][i] = jmp[jmp[v][i - 1]][i - 1]; for (unsigned int i = 0; i < in[v].size(); i++) if (in[v][i] != p) getLCA(in[v][i], v); tout[v] = curt++; } char upp(int a, int b) { return t[a] <= t[b] && tout[a] >= tout[b]; } int lca(int a, int b) { if (upp(a, b)) return a; if (upp(b, a)) return b; for (int i = 18; i >= 0; --i) if (!upp(jmp[a][i], b)) a = jmp[a][i]; return jmp[a][0]; } int main(void) { cin >> n >> m; for (int i = 0; i < m; i++) { int q, w; cin >> q >> w; in[q].push_back(w); in[w].push_back(q); } dfs(1, -1); memset(used, 0, sizeof(used)); curt = 0; dfs2(1, 0); curt = 0; memset(used, 0, sizeof(used)); getLCA(1, 1); cin >> k; for (int i = 0; i < k; i++) { int q, w; cin >> q >> w; int l = lca(q, w); cout << ans[q] + ans[w] - 2 * ans[l] << endl; } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { double x, y, r, x1, y1; cin >> r >> x >> y >> x1 >> y1; double diam = 2 * r; double dist = sqrt((x1 - x) * (x1 - x) + (y1 - y) * (y1 - y)); int q = 0; if (dist == 0) { cout << 0 << endl; } else { while (dist >= diam) { dist -= diam; q++; } if (dist == 0) { cout << q << endl; } else { cout << q + 1 << endl; } } return 0; }
|
#include <bits/stdc++.h> const int mod = 1e9 + 7; const int MAX = 1e5 + 7; using namespace std; string st = fedabc ; void solve(unsigned long long n, char c) { n--; unsigned long long res = 16LL * (n / 4LL); if (n % 2) res += 7; res += st.find(c) + 1; cout << res; } void mysolve(unsigned long long n, char c) { unsigned long long l = 0, r = n / 2; unsigned long long res = 0; while (l <= r) { unsigned long long mid = (l + r) / 2; if ((1 + (mid + (mid * 3LL))) <= n) { res = mid; l = mid + 1; } else { r = mid - 1; } } unsigned long long currF = (1 + (res + (res * 3))); unsigned long long served = 2LL * res; unsigned long long sec = 6; if ((currF == n) || (currF + 2 == n)) { sec += ((served - 1) * 6) + (currF - 1); } else if (currF + 1 == n || currF + 3 == n) { sec += (served * 6) + (currF); } else if (currF + 4 == n || currF + 6 == n) { sec += ((served + 1) * 6) + (currF + 1); } for (auto i : st) { sec++; if (i == c) break; } cout << sec; } int main() { ios::sync_with_stdio(false); cin.tie(0); string s; cin >> s; unsigned long long n = stoll(s.substr(0, s.size() - 1)); char seat = s[s.size() - 1]; solve(n, seat); }
|
#include <bits/stdc++.h> using namespace std; int ar[1002][1002]; char buf[20]; int main() { int n, m, k, w; int res = 0; vector<pair<int, int> > r; scanf( %d %d %d %d n , &n, &m, &k, &w); vector<vector<string> > f(k); for (int i = 0; i < k; i++) { for (int j = 0; j < n; j++) { fgets(buf, 20, stdin); string s = buf; s = s.substr(0, s.size() - 1); f[i].push_back(s); } } for (int i = 0; i < f.size(); i++) { for (int j = i + 1; j < f.size(); j++) { int d = 0; for (int e = 0; e < n; e++) { for (int l = 0; l < m; l++) { if (f[i][e][l] != f[j][e][l]) d++; } } if (d * w < n * m) { ar[i + 1][j + 1] = d * w; ar[j + 1][i + 1] = d * w; } else { ar[i + 1][j + 1] = 1000; ar[j + 1][i + 1] = 1000; } } } for (int i = 0; i < k + 1; i++) { ar[0][i] = n * m; ar[i][0] = n * m; } vector<char> used(k + 1, false); vector<int> min_edge(k + 1, 1000), end_edge(k + 1, -1); min_edge[0] = 0; for (int i = 0; i < k + 1; i++) { int v = -1; for (int j = 0; j < k + 1; j++) { if (!used[j] && (v == -1 || min_edge[j] < min_edge[v])) v = j; } used[v] = true; if (end_edge[v] != -1) { res += ar[v][end_edge[v]]; r.push_back(pair<int, int>(v, end_edge[v])); } for (int j = 0; j < k + 1; j++) { if (ar[v][j] < min_edge[j]) { min_edge[j] = ar[v][j]; end_edge[j] = v; } } } printf( %d n , res); for (int i = 0; i < r.size(); i++) { printf( %d %d n , r[i].first, r[i].second); } return 0; }
|
#include <bits/stdc++.h> using namespace std; size_t ham_dist(const string &a, const string &b) { size_t ct = 0; for (size_t i = 0; i < a.size(); ++i) if (a[i] != b[i]) ++ct; return ct; } string opp(const string &a) { string r = ; for (size_t i = 0; i < a.size(); ++i) r += (a[i] == 0 ? 1 : 0 ); return r; } string read_line(size_t m) { string r; for (size_t j = 0; j < m; ++j) { char c[2]; cin >> c; r += string(c); } return r; } string string_from_int(size_t len, size_t z) { string o; for (size_t i = 0; i < len; ++i) { if (z & (1 << i)) o += 1 ; else o += 0 ; } return o; } int main() { size_t n, m, k; cin >> n >> m >> k; map<string, size_t> counts; vector<string> mat; mat.reserve(n); for (size_t i = 0; i < n; ++i) { string l = read_line(m); mat.push_back(l); } if (n < m) { vector<string> newmat = mat; swap(n, m); mat.clear(); mat.reserve(n); for (size_t i = 0; i < n; ++i) { string p; for (size_t j = 0; j < m; ++j) { p += newmat[j][i]; } mat.push_back(p); } } for (size_t i = 0; i < n; ++i) { string &l = mat[i]; if (counts.find(l) == counts.end()) counts[l] = 0; ++counts[l]; } bool feasible = false; if (counts.size() <= k + 2) { if (n <= k) { for (size_t z = 0; z < ((size_t)1 << m); ++z) { string l = string_from_int(m, z); if (counts.find(l) == counts.end()) counts[l] = 0; } } for (map<string, size_t>::iterator it = counts.begin(); it != counts.end(); ++it) { size_t cost = 0; for (map<string, size_t>::iterator jt = counts.begin(); jt != counts.end(); ++jt) { if (jt->second == 0) continue; size_t cost_per = ham_dist(it->first, jt->first); cost_per = min(cost_per, ham_dist(opp(it->first), jt->first)); cost += cost_per * jt->second; } if (cost <= k) { feasible = true; k = cost; } } } if (!feasible) { cout << -1 << endl; } else { cout << k << endl; } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n, num; cin >> n; if (n % 2 == 0) { num = n / 2; cout << num << endl; for (int i = 0; i < num; i++) { cout << 2 ; } } else { num = ((n - 3) / 2) + 1; cout << num << endl; for (int i = 0; i < num - 1; i++) { cout << 2 ; } cout << 3 ; } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { cin.sync_with_stdio(0); cin.tie(0); int n; cin >> n; vector<int> data(n + 1); for (int i = 1; i <= n; i++) cin >> data[i]; int i = 1, j = n; while (j > i && data[j] == data[1]) j--; while (i < j && data[i + 1] == data[1]) i++; cout << max(j - 1, max(j - i, n - i - 1)) << endl; }
|
#include <bits/stdc++.h> #pragma GCC optimize( Ofast ) #pragma GCC target( avx,avx2,fma ) #pragma GCC optimization( unroll-loops ) using namespace std; mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); int n = 0, k = 0, s = 0; cin >> n >> k >> s; int sz = min(n * (n - 1), k * (k - 1) / 2 + s); vector<vector<int> > dp(k + 1, vector<int>(sz + 1, 1e9 + 42)); dp[0][0] = 0; for (int pos = 0; pos < n; pos++) { int q; cin >> q; for (int i = k - 1; i >= 0; i--) for (int j = sz - pos; j >= 0; j--) dp[i + 1][j + pos] = min(dp[i + 1][j + pos], dp[i][j] + q); } int ans = 1e9 + 42; for (int i = k * (k - 1) / 2; i <= sz; i++) ans = min(ans, dp[k][i]); cout << ans; return 0; }
|
// “Alhamdulillah for Everything” #include<bits/stdc++.h> using namespace std; #define pai acos(-1) #define ff first #define ss second #define ll long long #define pb push_back #define mp make_pair #define pll pair<ll,ll> #define sz(a) (ll)a.size() #define endl n #define gcd(a, b) __gcd(a, b) #define lcm(a, b) ((a*b)/gcd(a,b)) #define all(vec) vec.begin(),vec.end() #define ms(a, b) memset(a,b,sizeof(a)) #define rep(i,n) for(int i= 0; i < int(n); i++) #define rep1(i,n) for(int i= 1; i <= n; i++) #define TEST_CASE(t) for(int zz=1;zz<=t;zz++) #define PRINT_CASE printf( Case %d: ,zz) #define fii freopen( input.txt , r ,stdin); #define foo freopen( output.txt , w ,stdout); #define boom ios_base::sync_with_stdio(0);cin.tie(NULL);cout.tie(NULL); const ll M = 1e9+7; const ll mxn = 1e5+7; const ll inf = 1e18; int main() { //boom; ll i,j,k,a,b,c,d,n,m,t,x,y,z,u,v; cin>>t; TEST_CASE(t) { cin>>n>>k; vector<ll>vec(n); for(i=0;i<n;i++) { cin>>vec[i]; } ll ans=0,sum=vec[0]; for(i=1;i<n;i++) { a=vec[i]*100; b=sum*k; if(a<b) { sum+=vec[i]; } else { ll tem=a-b+k-1; tem/=k; sum+=(vec[i]+tem); ans+=tem; } //cout<<i<< === <<sum<< ==== <<ans<<endl; } cout<<ans<<endl; } return 0; }
|
#include <bits/stdc++.h> using namespace std; template <typename T> inline T POW(T B, T P) { if (P == 0) return 1; if (P & 1) return B * POW(B, P - 1); else return SQR(POW(B, P / 2)); } template <typename T> inline T ModInv(T b, T m) { return BigMod(b, m - 2, m); } template <typename T> inline T ABS(T a) { if (a < 0) return -a; else return a; } template <typename T> inline T gcd(T a, T b) { if (a < 0) return gcd(-a, b); if (b < 0) return gcd(a, -b); return (b == 0) ? a : gcd(b, a % b); } template <typename T> inline T lcm(T a, T b) { if (a < 0) return lcm(-a, b); if (b < 0) return lcm(a, -b); return a * (b / gcd(a, b)); } template <class T> inline T BMOD(T p, T e, T m) { T ret = 1; while (e) { if (e & 1) ret = (ret * p) % m; p = (p * p) % m; e >>= 1; } return (T)ret; } int n, T; int wt[200005], bit[200005]; set<pair<int, int> > st; void update(int pos) { while (pos < 200001) { bit[pos] += 1; pos += (pos & -pos); } return; } int query(int pos) { int sum = 0; while (pos > 0) { sum += bit[pos]; pos -= (pos & -pos); } return sum; } int main() { scanf( %d%d , &n, &T); for (int i = 1; i <= n; i++) { scanf( %d , &wt[i]); st.insert(make_pair(wt[i] - i, i)); } int ans = 0; for (auto &i : st) { int xx = i.first; int yy = i.second; update(yy); int rng = T - 1 - xx; rng = min(n, rng); rng = min(rng, T - 1); if (rng <= 0) continue; int id = query(rng); ans = max(ans, id); } printf( %d , ans), puts( ); return 0; }
|
#include <bits/stdc++.h> const int maxn = 1025; const int maxm = 10; using namespace std; int main() { int n; string s; cin >> n; cin >> s; int ans1 = 0, ans2 = 0; int cnt1 = 0; int f = 0; for (int i = 0; i < s.length(); i++) { if (s[i] == ( ) { f = 1; ans1 = max(ans1, cnt1); cnt1 = 0; continue; } if (s[i] == ) ) { f = 0; continue; } if (!f) { if (s[i] != _ ) { cnt1++; } else { ans1 = max(ans1, cnt1); cnt1 = 0; } } if (f) { if ((s[i - 1] == ( || s[i - 1] == _ ) && s[i] != _ ) { ans2++; } } } ans1 = max(ans1, cnt1); cnt1 = 0; cout << ans1 << << ans2 << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n, k; cin >> n >> k; if (abs(n - k) == 1 || ((n - k) == 0 && n > 0 && k > 0)) { cout << YES ; } else cout << NO ; }
|
#include <bits/stdc++.h> int main() { long long n, k; std::cin >> n >> k; long long c = std::max(n - 2 * k, 0LL); std::cout << n * (n - 1) / 2 - c * (c - 1) / 2 << n ; return 0; }
|
#include <bits/stdc++.h> using namespace std; int n, m, q; int arr[110][110], r[10010], c[10010], v[10010], t[10010]; int main() { scanf( %d , &n), scanf( %d , &m), scanf( %d , &q); for (int z = 0; z < q; ++z) { scanf( %d , &t[z]); if (t[z] == 1) scanf( %d , &r[z]); if (t[z] == 2) scanf( %d , &c[z]); if (t[z] == 3) scanf( %d , &r[z]), scanf( %d , &c[z]), scanf( %d , &v[z]); } reverse(t, t + q); reverse(c, c + q); reverse(r, r + q); reverse(v, v + q); for (int z = 0; z < q; ++z) { if (t[z] == 1) { --r[z]; v[z] = arr[r[z]][m - 1]; for (int j = m - 1; j > 0; --j) arr[r[z]][j] = arr[r[z]][j - 1]; arr[r[z]][0] = v[z]; } else if (t[z] == 2) { --c[z]; v[z] = arr[n - 1][c[z]]; for (int i = n - 1; i > 0; --i) arr[i][c[z]] = arr[i - 1][c[z]]; arr[0][c[z]] = v[z]; } else { arr[r[z] - 1][c[z] - 1] = v[z]; } } for (int i = 0; i < n; ++i) for (int j = 0; j < m; ++j) printf( %d%c , arr[i][j], n [j == m - 1]); }
|
#include <bits/stdc++.h> using namespace std; const int p = 1000000007; int K; struct Ma { int g[31][31]; Ma() { memset(g, 0, sizeof(g)); } int* operator[](int x) { return g[x]; } Ma operator*(const Ma& b) const { Ma res; for (int i = 0; i <= K; i++) for (int k = 0; k <= K; k++) if (g[i][k]) for (int j = 0; j <= K; j++) res.g[i][j] = (res.g[i][j] + (long long)g[i][k] * b.g[k][j]) % p; return res; } void w() { for (int i = 0; i <= K; i++) g[i][i] = 1; } } A[105][30], res, pre[105][30], sub[105][30]; int num[105], tot; int main() { ios::sync_with_stdio(0); long long n; cin >> n >> K; while (n) num[tot++] = n % K, n /= K; for (int i = 0; i < K; i++) { for (int j = 0; j <= K; j++) A[0][i][j][j] = 1; for (int j = 0; j <= K; j++) A[0][i][j][i] = 1; } for (int i = 1; i <= tot; i++) { pre[i - 1][0] = A[i - 1][0]; for (int j = 1; j < K; j++) pre[i - 1][j] = pre[i - 1][j - 1] * A[i - 1][j]; sub[i - 1][K - 1] = A[i - 1][K - 1]; for (int j = K - 2; ~j; j--) sub[i - 1][j] = A[i - 1][j] * sub[i - 1][j + 1]; for (int j = 0; j < K; j++) { A[i][j].w(); A[i][j] = sub[i - 1][j]; if (j) A[i][j] = A[i][j] * pre[i - 1][j - 1]; } } res.g[K][K] = 1; for (int i = tot - 1, j = 0; ~i; i--) while (num[i]--) res = res * A[i][j], j = (j + 1) % K; int ans = 0; for (int i = 0; i <= K; i++) ans = (ans + res[K][i]) % p; cout << ans << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; int n; int l[6][6], h[6][6], a[6][6]; int in[6]; int cost; int rec(int inNode, int outNode) { if (inNode == n - 1) return 0; int bestCost = -1; for (int f = l[inNode][outNode]; f <= h[inNode][outNode]; f++) { if (in[inNode] >= f && (outNode != n - 1 || in[inNode] == f)) { int nextIn = inNode, nextOut = outNode + 1; if (outNode == n) { nextIn = inNode + 1; nextOut = 0; }; if (nextIn == nextOut) nextOut++; in[inNode] -= f; in[outNode] += f; int val = rec(nextIn, nextOut); if (val != -1) { val += f * f; if (f > 0) val += a[inNode][outNode]; bestCost = max(bestCost, val); } in[inNode] += f; in[outNode] -= f; } } return bestCost; } int s, f; int main() { cin >> n; for (int i = 0; i < n * (n - 1) / 2; i++) { cin >> s >> f; s--, f--; cin >> l[s][f] >> h[s][f] >> a[s][f]; } int maxCost = -1; int f; for (f = 0; f <= 25; f++) { memset(in, 0, sizeof in); in[0] = f; maxCost = rec(0, 1); if (maxCost != -1) break; } if (maxCost != -1) cout << f << << maxCost << endl; else cout << -1 << << -1 << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; long long n, m; long long side[300001]; vector<long long> edges[300001]; bool vis[300001]; bool res = 1; map<long long, long long> mp; long long dfs(long long u, long long s) { vis[u] = 1; side[u] = s; ++mp[s]; long long ret = 1; for (long long i = 0; i < edges[u].size(); ++i) { long long nxt = edges[u][i]; if (vis[nxt] && side[u] == side[nxt]) { res = 0; } else if (!vis[nxt]) { ret += dfs(nxt, -s); } } return ret; } int32_t main() { cin >> n >> m; for (long long i = 0; i < m; ++i) { long long a, b; cin >> a >> b; edges[a].emplace_back(b); edges[b].emplace_back(a); } long long big = 0; long long cnt = 0; for (long long i = 1; i <= n; ++i) { if (vis[i]) continue; long long x = dfs(i, i); if (x == 2) ++cnt; big = max(big, x); } if (big == 1) { cout << 3 << n * (n - 1) * (n - 2) / 6 << n ; } else if (big == 2) { cout << 2 << cnt * (n - 2) << n ; } else if (res == 1) { long long ans = 0; for (auto it = mp.begin(); it != mp.end(); ++it) { long long x = (*it).second; ans += x * (x - 1) / 2; } cout << 1 << ans << n ; } else { cout << 0 1 n ; } return 0; }
|
#include <bits/stdc++.h> using namespace std; const int MAXN = 112345; long long l[MAXN], r[MAXN]; int main() { int n; cin >> n; for (int i = 0; i < n; ++i) scanf( %lld %lld , l + i, r + i); sort(l, l + n); sort(r, r + n); long long ans = n; for (int i = 0; i < n; ++i) ans += max(l[i], r[i]); cout << ans << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; const int NMax = 5e3 + 5; const int MMax = 1e3 + 5; int N, M; char input[NMax][MMax + 101]; short bit[NMax][MMax][2]; char solMin[MMax], solMax[MMax]; map<string, int> ID; struct elem { bool known; int op1, op2; char tor; } v[NMax]; int compute(int, int, int); int main() { cin.sync_with_stdio(false); cin.tie(0); cin >> N >> M; cin.getline(input[0], MMax + 100); for (int i = 1; i <= N; ++i) { cin.getline(input[i] + 1, MMax + 100); string name = ; int j = 1; while ( a <= input[i][j] && input[i][j] <= z ) { name += input[i][j++]; } ID[name] = i; } for (int i = 1; i <= N; ++i) { int j = 1; while (input[i][j] != = ) { ++j; } j += 2; if (input[i][j] == 0 || input[i][j] == 1 ) { v[i].known = true; for (int k = 1; k <= M; ++k) { bit[i][k][0] = bit[i][k][1] = input[i][j] - 0 + 1; ++j; } } else { string str; if (input[i][j] == ? ) { v[i].op1 = -1; ++j; } else { str = ; while ( a <= input[i][j] && input[i][j] <= z ) { str += input[i][j]; ++j; } v[i].op1 = ID[str]; } ++j; if (input[i][j] == A ) { v[i].tor = & ; j += 3; } else if (input[i][j] == O ) { v[i].tor = | ; j += 2; } else { v[i].tor = ^ ; j += 3; } ++j; if (input[i][j] == ? ) { v[i].op2 = -1; } else { str = ; while ( a <= input[i][j] && input[i][j] <= z ) { str += input[i][j]; ++j; } v[i].op2 = ID[str]; } } } for (int b = 1; b <= M; ++b) { int nr1By1 = 0, nr1By0 = 0; for (int i = 1; i <= N; ++i) { nr1By1 += compute(i, b, 1); nr1By0 += compute(i, b, 0); } if (nr1By1 > nr1By0) { solMax[b] = 1 ; } else { solMax[b] = 0 ; } if (nr1By1 < nr1By0) { solMin[b] = 1 ; } else { solMin[b] = 0 ; } } cout << (solMin + 1) << n << (solMax + 1); return 0; } int compute(int id, int b, int val) { if (bit[id][b][val] != 0) { return bit[id][b][val] - 1; } int f1, f2; if (v[id].op1 == -1) { f1 = val; } else { f1 = compute(v[id].op1, b, val); } if (v[id].op2 == -1) { f2 = val; } else { f2 = compute(v[id].op2, b, val); } int res; if (v[id].tor == & ) { res = f1 & f2; } else if (v[id].tor == | ) { res = f1 | f2; } else { res = f1 ^ f2; } bit[id][b][val] = res + 1; return res; }
|
#include <iostream> #include <bits/stdc++.h> #include<algorithm> #define fastio ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL) #define ll long long #define MOD 1000000007 #define f first #define s second #define pb push_back #define nl n #define mem(arr, value) memset(arr, value, sizeof(arr)) #define vll vector<ll> #define vb vector<bool> #define vpll vector<pair<ll, ll>> #define vvll vector<vector<ll>> using namespace std; // DEBUG void __print(int x) { cerr << x; } void __print(ll x) { cerr << x; } void __print(double x) { cerr << x; } void __print(char x) { cerr << << x << ; } void __print(const char* x) { cerr << << x << ; } void __print(const string& x) { cerr << << x << ; } void __print(bool x) { cerr << (x ? true : false ); } template<typename T, typename V> void __print(const pair<T, V>& x) { cerr << { ; __print(x.first); cerr << , ; __print(x.second); cerr << } ; } template<typename T> void __print(const T& x) { int _ = 0; cerr << { ; for (auto& i : x) cerr << (_++ ? , : ), __print(i); cerr << } ; } void _print() { cerr << ] n ; } template <typename T, typename... V> void _print(T t, V... v) { __print(t); if (sizeof...(v)) cerr << , ; _print(v...); } #ifndef ONLINE_JUDGE #define dbg(x...) cerr << [ << #x << ] = [ ; _print(x) #else #define dbg(x...) #endif bool flag = false; bool comp1(pair<pair<ll, ll>, pair<ll,ll> > a, pair<pair<ll, ll>, pair<ll, ll>> b) { return a.s.s < b.s.s; } bool comp(pair<ll,ll> a, pair<ll, ll> b) { return a.s < b.s; } struct myComp { constexpr bool operator()( pair< pair<ll,ll>, pair<ll,ll> > const& a, pair< pair<ll,ll>, pair<ll,ll> > const& b) const noexcept { return a.s.s < b.s.s; } }; ll digitSum(ll n){ll sum=0; while(n>0){sum += n%10;n=n/10;}return sum;} void dfs(vvll &adj, vb &visited, ll v, ll e) { // visited[v] = true; for (ll i=0; i<adj[v].size(); i++) { ll n = adj[v][i]; if (n==e) { flag = true; return; } dfs(adj, visited, n, e); } // return false; } bool isSubsetSum(int set[], int n, int sum) { bool subset[n + 1][sum + 1]; for (int i = 0; i <= n; i++) subset[i][0] = true; for (int i = 1; i <= sum; i++) subset[0][i] = false; for (int i = 1; i <= n; i++) { for (int j = 1; j <= sum; j++) { if (j < set[i - 1]) subset[i][j] = subset[i - 1][j]; if (j >= set[i - 1]) subset[i][j] = subset[i - 1][j] || subset[i - 1][j - set[i - 1]]; } } return subset[n][sum]; } void solve() { ll n; cin>>n; ll b[n+2]; ll sum = 0; for (ll i=0; i<n+2; i++) { cin>>b[i]; sum+=b[i]; } sort(b, b+n+2); ll aa = b[n+1]; ll bb = b[n]; ll x=-1; ll temp1 = sum - b[n+1]; for (ll i=0; i<n+1; i++) { temp1 = temp1 - b[i]; if (temp1 == aa) { x = i; break; } temp1 += b[i]; } if (x == -1) { ll temp2 = sum - b[n] - b[n+1]; if (temp2 == b[n]) { x = n; } } if (x==-1) cout<<-1<<endl; else { for (ll i=0; i<n+1; i++) { if (i==x) continue; else cout<<b[i]<< ; } cout<<endl; } } int main() { fastio; ll t=1; cin>>t; while (t-->0) { solve(); } return 0; }
|
#include <bits/stdc++.h> using namespace std; int n, a[100005] = {0}, b[100005] = {0}, t, j, i, rn = 0, r[100005] = {0}, dis[100005] = {0}; vector<int> v; vector<int> ht; int main() { scanf( %d , &n); for (i = 1; i <= n; i++) { scanf( %d , &a[i]); if (a[i] == 1) ht.push_back(i); } for (i = 1; i <= n; i++) { scanf( %d , &b[i]); dis[b[i]]++; } for (i = 0; i < ht.size(); i++) { v.clear(); v.push_back(ht[i]); while (1) { t = v.size(); if (b[v[t - 1]] == 0) { break; } if (dis[b[v[t - 1]]] == 1) v.push_back(b[v[t - 1]]); else break; } if (rn < v.size()) { rn = v.size(); for (j = 0; j < rn; j++) r[j] = v[j]; } } printf( %d n , rn); for (i = rn - 1; i >= 0; i--) printf( %d%c , r[i], i ? : n ); return 0; }
|
#include <bits/stdc++.h> int main() { int n; scanf( %d , &n); int *mas = new int[n], m = 0; for (int i = 0; i < n; i++) { scanf( %d , &mas[m++]); while (m > 1 && mas[m - 1] == mas[m - 2]) { mas[m - 2]++; m--; } } printf( %d n , m); for (int i = 0; i < m; i++) printf( %d , mas[i]); return 0; }
|
#include <bits/stdc++.h> using namespace std; const int N = 101000; const double eps = 1e-9, g = 9.8; double V, angle, ca, sa, Y, K, x, y; int i, j, k, l, m, n, o, p; inline int sn(double x) { return x < -eps ? -1 : x > eps ? 1 : 0; } inline double Sqr(double x) { return x * x; } struct Point { double x, y; inline void read() { scanf( %lf%lf , &x, &y); } bool operator<(const Point &t) const { return x < t.x; } } wall[N], ans[N]; struct fire { double a, b; int i; fire() {} fire(double x, double y, int id) { a = x; b = y; i = id; } inline void read(int id) { scanf( %lf , &angle); ca = cos(angle); sa = sin(angle); a = g / (2 * Sqr(V * ca)); b = sa / ca; i = id; ans[i].x = (b / a); ans[i].y = 0; } bool operator<(const fire &t) const { double b1 = b - K * a, b2 = t.b - K * t.a; return (b1 < b2) || (!sn(b1 - b2) && (i < t.i)); } } Tfire, P; set<fire> F; set<fire>::iterator pos; int main() { scanf( %d%lf , &n, &V); K = (double)0.455555; for (i = 1; i <= n; i++) { Tfire.read(i); F.insert(Tfire); } scanf( %d , &m); for (i = 1; i <= m; i++) wall[i].read(); sort(wall + 1, wall + m + 1); for (i = 1; i <= m; i++) { K = wall[i].x; Y = wall[i].y / wall[i].x; while (1) { pos = F.lower_bound(fire(0, Y + eps, N)); if (pos == F.begin()) break; pos--; P = (*pos); j = P.i; if (ans[j].x > wall[i].x) { ans[j].x = wall[i].x; ans[j].y = (-P.a) * Sqr(wall[i].x) + wall[i].x * P.b; } F.erase(pos); } } for (i = 1; i <= n; i++) printf( %.9lf %.9lf n , ans[i].x, ans[i].y); return 0; }
|
#include <bits/stdc++.h> using namespace std; int n; string s[500001]; char line[10]; int dp[30][30]; int main() { scanf( %d , &n); for (int i = 0; i < n; ++i) { memset(line, 0, sizeof(line)); scanf( %s , line); s[i] = line; } memset(dp, 0, sizeof(dp)); for (int k = 0; k < n; ++k) { int len = (int)s[k].size(); int start = s[k][0] - a , end = s[k][len - 1] - a ; for (int i = 0; i < 26; ++i) if (dp[i][start]) { dp[i][end] = max(dp[i][end], dp[i][start] + len); } dp[start][end] = max(dp[start][end], len); } int ret = 0; for (int i = 0; i < 26; ++i) ret = max(ret, dp[i][i]); cout << ret << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); int t; cin >> t; while (t--) { int n; cin >> n; long long int a[n], b[n]; long long int sum = 0, suma = 0; for (int i = 0; i < n; i++) { cin >> a[i]; sum += a[i]; } for (int i = 0; i < n; i++) { cin >> b[i]; suma += b[i]; } long long int mina = *min_element(a, a + n); long long int mine = *min_element(b, b + n); long long int ans = 0; for (int i = 0; i < n; i++) { ans += min(abs(a[i] - mina), abs(b[i] - mine)); int aoeu = a[i]; a[i] -= min(abs(a[i] - mina), abs(b[i] - mine)); b[i] -= min(abs(aoeu - mina), abs(b[i] - mine)); ans += abs(a[i] - mina); ans += abs(b[i] - mine); } cout << ans << n ; } }
|
#include <bits/stdc++.h> using namespace std; int q[200010]; int main() { std::ios::sync_with_stdio(false); std::cin.tie(0); int t; cin >> t; while (t--) { string s; cin >> s; int l = s.length(); if (l == 1) { if (s[0] == L ) { cout << 2 << endl; } else { cout << 1 << endl; } continue; } int flag = 0; for (int i = 0; i < l; i++) { if (s[i] == R ) { flag = 1; break; } } if (flag == 0) { cout << l + 1 << endl; continue; } int k = 1; q[0] = 0; for (int i = 0; i < l; i++) { if (s[i] == R ) { q[k++] = i + 1; } } q[k] = l + 1; int maxn = 0; for (int i = 1; i <= k; i++) { int x = q[i] - q[i - 1]; maxn = max(maxn, x); } cout << maxn << endl; } return 0; }
|
#include <bits/stdc++.h> using namespace std; long long n, j, i, l, t, k, x, y; string s, a[10000001]; int main() { cin >> n >> s; for (i = 1; i < n; i++) for (j = 0; j < n - i; j++) { t++; for (l = 0; l <= i; l++) { a[t] += s[j + l]; } } for (i = 1; i <= t; i++) { x = 0; y = 0; for (j = 0; j < a[i].size(); j++) if (a[i][j] == U ) y++; else if (a[i][j] == D ) y--; else if (a[i][j] == L ) x--; else if (a[i][j] == R ) x++; if (x == 0 && y == 0) k++; } cout << k; return 0; }
|
#include <bits/stdc++.h> using namespace std; const int N = 5005; int gcd[N]; int GCD(int a, int b) { return b ? GCD(b, a % b) : a; } vector<int> primes; void Calc() { for (int i = 2; i * i <= 1000000000; i++) { bool is_prime = true; for (int p : primes) { if (p * p > i) { break; } is_prime &= i % p != 0; } if (is_prime) { primes.push_back(i); } } } vector<int> Factorize(int a) { vector<int> res; for (int p : primes) { if (p * p > a) { break; } while (a % p == 0) { res.push_back(p); a /= p; } } if (a != 1) { res.push_back(a); } return res; } int main() { ios_base::sync_with_stdio(false); Calc(); int n; int m; cin >> n >> m; vector<int> a(n); for (int i = 0; i < n; i++) { cin >> a[i]; } set<int> b; for (int i = 0; i < m; i++) { int p; cin >> p; b.insert(p); } gcd[0] = a[0]; for (int i = 1; i < n; i++) { gcd[i] = GCD(gcd[i - 1], a[i]); } int res = 0; int t = 1; for (int i = n - 1; i >= 0; i--) { auto factors = Factorize(gcd[i] / t); int d = 0; for (auto p : factors) { d += b.count(p) ? 1 : -1; } if (d > 0) { t = gcd[i]; res += d * (i + 1); } } for (auto num : a) { auto factors = Factorize(num); int d = 0; for (auto p : factors) { d += b.count(p) ? -1 : 1; } res += d; } cout << res << n ; }
|
#include <bits/stdc++.h> using namespace std; void expand(int); int main() { int num; cin >> num; expand(num); cout << n ; } void expand(int value) { const char* const ones[20] = { zero , one , two , three , four , five , six , seven , eight , nine , ten , eleven , twelve , thirteen , fourteen , fifteen , sixteen , seventeen , eighteen , nineteen }; const char* const tens[10] = { , ten , twenty , thirty , forty , fifty , sixty , seventy , eighty , ninety }; if (value < 0) { cout << minus ; expand(-value); } else if (value >= 20) { cout << tens[value / 10]; if (value % 10) { cout << - ; expand(value % 10); } } else { cout << ones[value]; } return; }
|
#include <bits/stdc++.h> #ifdef LOCAL #include debuger.hpp #else #define DUMP(...) 1145141919810 #define CHECK(...) (__VA_ARGS__) #endif const int kN = 200000 + 5; const int INF = 0x3f3f3f3f; std::vector<int> edges[kN]; int n, q; int header[kN],dfn[kN],tim,parent[kN],sz[kN]; int depth[kN]; int last[kN]; void get_sz(int u, int fa) { sz[u] = 1; for (int v : edges[u]) { if (v == fa) continue; depth[v] = depth[u] + 1; get_sz(v, u); sz[u] += sz[v]; } } void rebuild(int u, int fa, int color) { dfn[u] = tim ++; parent[u] = fa; header[u] = color; last[color] = u; int p = -1; for (int v : edges[u]) { if (v == fa) continue; if (p == -1 || sz[v] > sz[p]) { p = v; } } if (p != -1) { rebuild(p, u, color); } for (int v : edges[u]) { if (v == fa || v == p) continue; rebuild(v, u, v); } } int get_lca(int a, int b) { while (header[a] != header[b]) { if (dfn[header[a]] < dfn[header[b]]) { std::swap(a,b); } a = parent[header[a]]; } return dfn[a] < dfn[b] ? a : b; } struct SegmentTree { int mx[kN << 1]; int get_id(int l, int r) const { return l + r | l != r; } void up(int l, int r) { if (l != r) { int mid = l + r >> 1; mx[get_id(l, r)] = std::max(mx[get_id(l, mid)], mx[get_id(mid + 1, r)]); } } void build(int l, int r) { mx[get_id(l, r)] = -INF; if (l != r) { int mid = l + r >> 1; build(l, mid); build(mid + 1, r); } } int query(int L, int R, int l, int r) const { if (r < L || R < l) return -INF; if (L <= l && r <= R) return mx[get_id(l, r)]; int mid = l + r >> 1; return std::max(query(L, R, l, mid), query(L, R, mid + 1, r)); } void modify(int p, int v, int l, int r) { if (l == r) { mx[get_id(l, r)] = v; } else { int mid = l + r >> 1; if (p <= mid) modify(p, v, l, mid); else modify(p, v, mid + 1, r); up(l, r); } } } tree[2]; // 0: val-dfn[v], 1: val+dfn[v] struct Fenwick { int arr[kN]; void update(int p, int dt) { for (int i = p; i >= 0; i -= ~i & i + 1) arr[i] += dt; } int query(int p) const { int ret = 0; for (int i = p; i < kN; i += ~i & i + 1) ret += arr[i]; return ret; } void hld_update(int u, int dt) { while (u != -1) { update(dfn[u], dt); if (dfn[header[u]] > 0) { update(dfn[header[u]] - 1, -dt); } u = parent[header[u]]; } } } bit; const int kLog = 19; int pjump[kLog][kN]; void init_jump() { for (int i = 0; i < n; ++i) { pjump[0][i] = parent[i]; } for (int i = 0; i + 1 < kLog; ++i) { for (int u = 0; u < n; ++u) { pjump[i + 1][u] = pjump[i][u] == -1 ? -1 : pjump[i][pjump[i][u]]; } } } int jump(int u, int d) { for (int i = 0; i < kLog; ++i) { if (d >> i & 1) { u = pjump[i][u]; if (u == -1) return 0; } } return u; } std::multiset<std::pair<int, int>> multiset; std::multiset<int> virtual_sets[kN]; int hld_query(int u, int guard) { int ret = 0; int v = u; int prev_head = -1; while (v != -1 && dfn[v] >= dfn[guard]) { int w = header[v]; if (dfn[w] < dfn[guard]) w = guard; int e = last[header[v]]; if (!virtual_sets[v].empty()) { int homologous_val = -INF; if (prev_head != -1) { int val = tree[1].query(dfn[prev_head], dfn[last[prev_head]], 0, n - 1); if (val != -INF) { homologous_val = val - dfn[prev_head] + 1; } } if (homologous_val != *virtual_sets[v].rbegin()) { ret = std::max(ret, depth[u] - depth[v] + *virtual_sets[v].rbegin()); } else if (virtual_sets[v].size() >= 2) { ret = std::max(ret, depth[u] - depth[v] + *std::prev(std::prev(virtual_sets[v].end()))); } } if (dfn[v] < dfn[e]) { int val = tree[1].query(dfn[v] + 1, dfn[e], 0, n - 1); if (val != -INF) { ret = std::max(ret, val - dfn[v] + depth[u] - depth[v]); } } if (dfn[w] < dfn[v]) { int val = tree[0].query(dfn[w], dfn[v] - 1, 0, n - 1); if (val != -INF) { ret = std::max(ret, val + dfn[v] + depth[u] - depth[v]); } } DUMP(v, ret); prev_head = header[v]; v = parent[header[v]]; } return ret; } #define ERASE_ONE(set, elem) (set).erase((set).find(elem)) void hld_insert(int u) { std::vector<int> stack; for (int v = u; v != -1; v = parent[header[v]]) { stack.emplace_back(v); } for (int i = (int)stack.size() - 1; i >= 0; --i) { int x = stack[i]; int h = header[x]; if (parent[h] != -1) { int val = tree[1].query(dfn[h], dfn[last[h]], 0, n - 1); if (val != -INF) { ERASE_ONE(virtual_sets[parent[h]], val - dfn[h] + 1); } } } virtual_sets[u].emplace(0); for (int x : stack) { int val = *virtual_sets[x].rbegin(); tree[0].modify(dfn[x], val - dfn[x], 0, n - 1); tree[1].modify(dfn[x], val + dfn[x], 0, n - 1); int h = header[x]; if (parent[h] != -1) { int val = tree[1].query(dfn[h], dfn[last[h]], 0, n - 1); if (val != -INF) { virtual_sets[parent[h]].emplace(val - dfn[h] + 1); } } } } void hld_remove(int u) { std::vector<int> stack; for (int v = u; v != -1; v = parent[header[v]]) { stack.emplace_back(v); } for (int i = (int)stack.size() - 1; i >= 0; --i) { int x = stack[i]; int h = header[x]; if (parent[h] != -1) { int val = tree[1].query(dfn[h], dfn[last[h]], 0, n - 1); if (val != -INF) { ERASE_ONE(virtual_sets[parent[h]], val - dfn[h] + 1); } } } ERASE_ONE(virtual_sets[u], 0); for (int x : stack) { if (!virtual_sets[x].empty()) { int val = *virtual_sets[x].rbegin(); tree[0].modify(dfn[x], val - dfn[x], 0, n - 1); tree[1].modify(dfn[x], val + dfn[x], 0, n - 1); } else { tree[0].modify(dfn[x], -INF, 0, n - 1); tree[1].modify(dfn[x], -INF, 0, n - 1); } int h = header[x]; if (parent[h] != -1) { int val = tree[1].query(dfn[h], dfn[last[h]], 0, n - 1); if (val != -INF) { virtual_sets[parent[h]].emplace(val - dfn[h] + 1); } } } } int main() { scanf( %d%d , &n, &q); for (int i = 0; i < n - 1; ++i) { int a, b; scanf( %d%d , &a, &b); --a; --b; edges[a].emplace_back(b); edges[b].emplace_back(a); } get_sz(0, -1); rebuild(0, -1, 0); tree[0].build(0, n - 1); tree[1].build(0, n - 1); init_jump(); while (q--) { int op; scanf( %d , &op); if (op == 1) { int u, v; scanf( %d%d , &u, &v); --u; --v; int lca = get_lca(u, v); bit.hld_update(u, 1); bit.hld_update(v, 1); bit.hld_update(lca, -1); multiset.emplace(depth[lca], lca); hld_insert(lca); } else if (op == 2) { int u, v; scanf( %d%d , &u, &v); --u; --v; int lca = get_lca(u, v); bit.hld_update(u, -1); bit.hld_update(v, -1); bit.hld_update(lca, 1); ERASE_ONE(multiset, std::make_pair(depth[lca], lca)); hld_remove(lca); } else { int d; scanf( %d , &d); CHECK(!multiset.empty()); int v = multiset.rbegin()->second; int guard = jump(v, d + d); if (bit.query(dfn[guard]) != bit.query(dfn[0])) { puts( No ); continue; } puts(hld_query(v, guard) <= d + d ? Yes : No ); } } }
|
#include <bits/stdc++.h> using namespace std; const int N = 200005; int n, a[N], ans[N], cnt, x, y; bool Ok = 0; int main() { cin >> n; for (int i = 0; i <= n; i++) { cin >> a[i]; if (i) Ok |= (a[i] > 1 && a[i - 1] > 1); } if (!Ok) { cout << perfect ; } else { cout << ambiguous << endl; cnt = 1; for (int i = 1; i <= n; i++) { for (int j = 1; j <= a[i]; j++) { ans[cnt + j] = cnt; } if (a[i] > 1 && a[i - 1] > 1) { x = cnt + a[i]; y = cnt - 1; } cnt += a[i]; } for (int i = 1; i <= cnt; i++) { cout << ans[i] << ; } cout << endl; ans[x] = y; for (int j = 1; j <= cnt; j++) { cout << ans[j] << ; } } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; string s; cin >> s; int counter = 0; for (int i = 0; i < n; i++) { int j = 0; for (j = i + 1; j < n; j++) { if (s[j] == s[i]) counter++; else { break; } } i = j - 1; } cout << counter; return 0; }
|
#include <bits/stdc++.h> using namespace std; int a[250]; int main() { int n; scanf( %d , &n); for (int i = 0; i < n; i++) { int N = 250; for (int j = 0; j < N; j++) scanf( %d , a + j); double M = 0; for (int j = 0; j < N; j++) M += a[j]; M /= N; double v = 0; for (int j = 0; j < N; j++) v += (a[j] - M) * (a[j] - M); v /= N; if (v < 3 * M) puts( poisson ); else puts( uniform ); } }
|
#include <bits/stdc++.h> using namespace std; int bv[7][9] = {{}, {4}, {2, 6}, {2, 4, 6}, {0, 2, 6, 8}, {0, 2, 4, 6, 8}, {0, 2, 3, 5, 6, 8}}; int bh[7][9] = {{}, {4}, {0, 8}, {0, 4, 8}, {0, 2, 6, 8}, {0, 2, 4, 6, 8}, {0, 1, 2, 6, 7, 8}}; int cv[7] = {0}; int ch[7] = {0}; char s[2036][2036]; bool h[2036][2036]; bool v[2036][2036]; int MOD = 1000000007; int f(int first, int second) { int res = 0; int sx = first * 4 + 1, sy = second * 4 + 1; int pos = 0; for (int i = (0); i < (int)(3); i++) for (int j = (0); j < (int)(3); j++) { if (s[sx + i][sy + j] == O ) { res |= 1 << pos; } ++pos; } return res; } long long doub[536]; long long sing[536]; long long tmp[536]; int main() { for (int k = (0); k < (int)(7); k++) { for (int i = (0); i < (int)(k); i++) { cv[k] |= 1 << bv[k][i]; ch[k] |= 1 << bh[k][i]; } } int n, m; scanf( %d%d , &n, &m); for (int i = (0); i < (int)(n * 4); i++) scanf( %s , s[i]); memset(h, 0, sizeof(h)); memset(v, 0, sizeof(v)); for (int i = (0); i < (int)(n); i++) for (int j = (0); j < (int)(m); j++) { int cod = f(i, j); for (int k = (0); k < (int)(7); k++) { h[i][j] |= ch[k] == cod; v[i][j] |= cv[k] == cod; } } for (int j = (0); j < (int)(m); j++) { sing[j] = n % 2 == 0; for (int i = (0); i < (int)(n); i++) sing[j] &= v[i][j]; } for (int j = (1); j < (int)(m); j++) { memset(tmp, 0, sizeof(tmp)); for (int i = (0); i < (int)(n); i++) { if (i >= 1) { if (v[i][j - 1] && v[i][j] && v[i - 1][j - 1] && v[i - 1][j]) { tmp[i] += (i - 2 == -1 ? 1 : tmp[i - 2]); } } if (h[i][j - 1] && h[i][j]) { tmp[i] += (i - 1 == -1 ? 1 : tmp[i - 1]); } tmp[i] %= MOD; } doub[j] = tmp[n - 1]; if (sing[j] && sing[j - 1]) { doub[j] = (doub[j] + MOD - 1) % MOD; } } memset(tmp, 0, sizeof(tmp)); for (int j = (0); j < (int)(m); j++) { if (j >= 1) { if (doub[j]) { tmp[j] += doub[j] * (j == 1 ? 1 : tmp[j - 2]) % MOD; tmp[j] %= MOD; } } if (sing[j]) { tmp[j] += sing[j] * (j == 0 ? 1 : tmp[j - 1]) % MOD; tmp[j] %= MOD; } } printf( %d n , (int)tmp[m - 1]); return 0; }
|
#include <bits/stdc++.h> #define lo long long #define KKH 1546C #define fi first #define se second #define BIT(x,k) (((x)>>(k-1))&1) #define rs(x,a) memset(x,(a),sizeof x) #define off(x,k) ((x)^(1<<(k-1))) using namespace std; void START() { #ifdef toilagun2004 freopen(KKH .inp , r ,stdin); freopen(KKH .out , w ,stdout); #endif // toilagun2004 ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); } const int gh=1e5+6; int n,a[gh],g[gh],d[gh]; int main() { START(); int T; cin>>T; while(T--){ cin>>n; rs(d,0); rs(g,0); for (int i=1;i<=n;i++) { cin>>a[i]; if (i&1) d[a[i]]++; else g[a[i]]++; } sort(a+1,a+n+1); for (int i=1;i<=n;i++) { if (i&1) d[a[i]]--; else g[a[i]]--; } bool hung=true; for(int e=1;e<=100000 && hung;e++) if (d[e] || g[e]) hung=false; if (hung) cout<< YES n ; else cout<< NO n ; } }
|
#include <bits/stdc++.h> using namespace std; const long long INF = 1000000000000000000LL; long long ff(long long a, long long b, long long c) { if ((a + b) % 2 != 0) return INF; long long x = (a + b) / 2; if (a < b) swap(a, b); long long y = 0, z = (a - b) / 2; return x + y + z; } int main() { long long a, b, c; scanf( %I64d%I64d%I64d , &a, &b, &c); printf( %I64d n , min(min(ff(a, b, c), ff(b, c, a)), ff(c, a, b))); return 0; }
|
#include<bits/stdc++.h> using namespace std; typedef long long int ll; void solve() { ll n; cin>>n; vector<ll> v; for(int i=0;i<n;i++) { ll x; cin>>x; v.push_back(x); } sort(v.begin(),v.end()); ll cost=0; for(ll i=2; i<n; ++i) { ll j=lower_bound(v.begin(),v.end(),v[i]-2)-v.begin(); ll x=(i-j); cost+=(x*(x-1))/2; }cout<<cost<< n ; } int main() { int t; cin>>t; while(t--) { solve(); } }
|
#include <bits/stdc++.h> using namespace std; long long mod = 1000000007; long long poww(long long num, long long p) { long long ret = 1; while (p != 0) { if (p & 1) { ret = (ret * num) % mod; } num = (num * num) % mod; p = p >> 1; } return ret; } int main() { ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); int t; cin >> t; while (t--) { long long n, p; cin >> n >> p; long long a[n]; for (int i = 0; i < n; i++) cin >> a[i]; if (p == 1) { if (n % 2 == 1) cout << 1 n ; else cout << 0 n ; continue; } sort(a, a + n); stack<pair<long long, long long> > st; for (int i = n - 1; i >= 0; i--) { if (st.size() == 0) { st.push(make_pair(a[i], 1)); } else { long long t1 = a[i]; long long cnt = 1; while (true) { pair<long long, long long> t2 = st.top(); if (t2.first > t1) { st.push(make_pair(t1, cnt)); break; } else if (t2.first == t1) { st.pop(); if (st.size() == 0) break; else { cnt = t2.second + 1; if (cnt == p) { cnt = 1; t1++; } else { st.push(make_pair(t1, cnt)); break; } } } } } } if (st.size() == 0) { cout << 0 << n ; } else { long long ans = 0; while (st.size() != 1) { pair<long long, long long> temp = st.top(); st.pop(); ans = (ans + (temp.second * poww(p, temp.first)) % mod) % mod; } pair<long long, long long> temp = st.top(); st.pop(); long long res = poww(p, temp.first); res = (res - ans + mod) % mod; cout << res << n ; } } }
|
#include <bits/stdc++.h> using namespace std; void solve() { int n; cin >> n; long long a[1010000]; long long s[1010000]; memset(a, 0, sizeof(a)); for (int i = 0; i < n; i++) { scanf( %lld , a + i); } vector<pair<long long, long long>> pll; for (int i = 0; i < n; i++) { long long sum = a[i]; long long sz = 1; while (!pll.empty() && pll.back().first * 1.0 / pll.back().second > sum * 1.0 / sz) { sum += pll.back().first; sz += pll.back().second; pll.pop_back(); } pll.push_back(make_pair(sum, sz)); } for (int i = 0; i < pll.size(); i++) { for (int j = 0; j < pll[i].second; j++) { if (!i && !j) printf( %.9lf , pll[i].first * 1.0 / pll[i].second); else printf( %.9lf , pll[i].first * 1.0 / pll[i].second); } } return; } int main() { solve(); return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n, a1, t1, a2, t2, n1 = 0, n2 = 0; cin >> n >> a1 >> a2 >> t1 >> t2; n1 += t1 * 2; n2 += t2 * 2; n1 += a1 * n; n2 += a2 * n; if (n1 > n2) cout << Second ; if (n2 > n1) cout << First ; if (n1 == n2) cout << Friendship ; }
|
#include <bits/stdc++.h> using namespace std; const int N = 1e5 + 5; long long DP[N]; int n; int a[N]; int freq[N]; long long solve(int num) { if (num < 1) return 0; if (DP[num] != -1) return DP[num]; return DP[num] = max((long long)num * freq[num] + solve(num - 2), solve(num - 1)); } int main() { memset(DP, -1, sizeof DP); scanf( %d , &n); int mx = 0; for (int i = 0; i < n; ++i) { scanf( %d , a + i); ++freq[a[i]]; if (a[i] > mx) mx = a[i]; } printf( %lld n , solve(mx)); }
|
#include <bits/stdc++.h> using namespace std; int n, m; bool reachable(vector<set<int>> g, int u, int v) { if (g[u].find(v) == g[u].end()) { for (auto x : g[u]) { if (g[x].find(v) != g[x].end()) return true; } } else { return true; } return false; } int main() { ios_base::sync_with_stdio(0); cin.tie(0); cin >> n >> m; set<pair<int, int>> edges; set<int> badnodes; while (m--) { int x, y; cin >> x >> y; --x; --y; edges.insert({x, y}); edges.insert({y, x}); badnodes.insert(x); badnodes.insert(y); } int c = 0; for (int u = 0; u < n; ++u) { if (badnodes.find(u) == badnodes.end()) c = u; } cout << n - 1 << endl; vector<set<int>> g(n); for (int u = 0; u < n; ++u) { if (u == c) continue; if (reachable(g, u, c)) continue; if (edges.find({u, c}) == edges.end()) { g[c].insert(u); g[u].insert(c); cout << c + 1 << << u + 1 << endl; } else { for (int v = 0; v < n; ++v) { if (edges.find({u, v}) == edges.end()) { g[u].insert(v); g[v].insert(u); cout << u + 1 << << v + 1 << endl; } } } } return 0; }
|
#include <bits/stdc++.h> using namespace std; long long parent[200001], Size[200001]; long long find_set(long long x) { if (x == parent[x]) return parent[x]; return parent[x] = find_set(parent[x]); } void Union(long long x, long long y) { x = find_set(x); y = find_set(y); if (Size[x] > Size[y]) { parent[y] = parent[x]; Size[x] += Size[y]; } else { parent[x] = parent[y]; Size[y] += Size[x]; } } signed main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); ; long long t; cin >> t; while (t--) { long long n, k; cin >> n >> k; string s; cin >> s; for (long long i = 0; i <= n; i++) { parent[i] = i; Size[i] = 1; } for (long long i = 0; i < n - k; i++) { Union(i, i + k); if (i < n / 2) Union(i, n - i - 1); } vector<long long> v[n + 1]; for (long long i = 0; i < n; i++) { long long p = find_set(i); v[p].push_back(s[i] - a ); } long long ans = 0; for (long long i = 0; i < n; i++) { if (v[i].size() == 0) continue; map<long long, long long> mm; for (auto j : v[i]) { mm[j]++; } long long Max = INT_MIN; for (auto i : mm) Max = max(Max, i.second); ans += v[i].size() - Max; } cout << ans << n ; } }
|
#include <bits/stdc++.h> const int MNN = 2e3 + 1; using namespace std; int n, b[MNN][MNN], mx; bool used[MNN]; int main() { cin >> n; for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { cin >> b[i][j]; } } for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { mx = max(mx, b[i][j]); } if (used[mx] == 1) { cout << mx + 1 << ; used[mx + 1] = 1; } else { cout << mx << ; used[mx] = 1; } mx = 0; } return 0; }
|
#include <bits/stdc++.h> using namespace std; template <typename G> struct triple { G first, second, T; }; struct BIT { vector<int> v; BIT(int n) : v(n + 10) {} void upd(int p) { for (; p < v.size(); p += (p & (-p))) ++v[p]; } int query(int p) { int x = 0; for (; p > 0; p -= (p & (-p))) x += v[p]; return x; } }; struct fraction { long long x, y; bool operator<(fraction o) { return x * o.y < y * o.x; } bool operator>(fraction o) { return x * o.y > y * o.x; } bool operator!=(fraction o) { return x * o.y != y * o.x; } }; struct info { fraction f1, f2; int ind; info(long long x, long long v, long long _ind, long long w) : ind(_ind) { f1 = {abs(x), abs(v - w)}; f2 = {abs(x), abs(v + w)}; } }; bool cmp1(info x, info y) { if (x.f1 != y.f1) return x.f1 < y.f1; if (x.f2 != y.f2) return x.f2 > y.f2; return x.ind < y.ind; } bool cmp2(info x, info y) { if (x.f2 != y.f2) return x.f2 < y.f2; if (x.f1 != y.f1) return x.f1 > y.f1; return x.ind > y.ind; } int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); int n, w; cin >> n >> w; vector<info> a; for (int i = 0; i < n; i++) { int x, v; cin >> x >> v; a.push_back({x, v, i, w}); } vector<int> t1(n), t2(n); sort(a.begin(), a.end(), cmp1); for (int i = 0; i < n; i++) t1[i] = a[i].ind; sort(a.begin(), a.end(), cmp2); for (int i = 0; i < n; i++) t2[i] = a[i].ind; vector<int> p(n); for (int i = 0; i < n; i++) p[t1[i]] = i + 1; long long ans = 0; BIT abi(n); for (int i = 0; i < n; i++) { ans += i - abi.query(p[t2[i]]); abi.upd(p[t2[i]]); } cout << ans << n ; return 0; }
|
#include <bits/stdc++.h> using namespace std; const int N = 200010; vector<int> t[N], f[2], f0[2]; int n, c0[N * 2], lim[N]; void add(int x) { for (; x <= n * 2; x += (x & (-x))) c0[x]++; } int query(int x) { int ret = 0; for (; x; x -= (x & (-x))) ret += c0[x]; return ret; } void up(int &a, int b) { if (a == -1 || a > b) a = b; } int main() { int k; scanf( %d%d , &n, &k); for (int i = 1; i <= k; i++) { int r, c, x, y; scanf( %d%d , &r, &c); t[c].push_back(n - r + 1); } for (int i = n; i; i--) if (t[i].size()) { sort(t[i].begin(), t[i].end()); for (int j = 0; j <= t[i].size() - 1; j++) add(i + t[i][j]); for (int j = t[i].size() - 1; j >= 0; j--) if (t[i][j] * (t[i][j] + 1) / 2 + 2 <= query(i + t[i][j]) * 3) { lim[i] = t[i][j]; break; } if (lim[i + 1] + 1 > lim[i] && (lim[i + 1] + 1) * (lim[i + 1] + 2) / 2 + 2 <= query(i + lim[i + 1] + 1) * 3) lim[i] = lim[i + 1] + 1; } for (int i = 1; i <= n; i++) { lim[i] = max(lim[i], lim[i - 1] - 1); lim[i] = min(800, n - i + 1); } f[0].resize(800 + 1, 1e9); f0[0].resize(800 + 1, 1e9); f[1].resize(800 + 1, 1e9); f0[1].resize(800 + 1, 1e9); f0[0][0] = 0; for (int i = 0; i <= n; i++) { int cnt = t[i].size(), ll = 0; int i0 = i & 1, i1 = (i + 1) & 1; for (int j = 0; j <= lim[i]; j++) { if (ll <= (int)t[i].size() - 1 && j == t[i][ll]) cnt--, ll++; if (j < lim[i]) { up(f[i0][j + 1], f[i0][j] + j + 1); up(f[i0][j + 1], f0[i0][j] + (j + 1) * (j + 2) / 2 + 2); } if (j) { up(f0[i1][j - 1], f0[i0][j] + cnt * 3); up(f0[i1][j - 1], f[i0][j] + cnt * 3); } else { up(f0[i1][j], f0[i0][j] + cnt * 3); up(f0[i1][j], f[i0][j] + cnt * 3); } f[i0][j] = f0[i0][j] = 1e9; } } printf( %d n , f0[(n + 1) & 1][0]); return 0; }
|
#include <bits/stdc++.h> using namespace std; const int N = 100005; bool prime[N + 5]; int vis[11111]; int main() { int tc = 1; cin >> tc; while (tc--) { int n; int m; cin >> n >> m; int ara[n + 1]; for (int i = 0; i < n; i++) { cin >> ara[i]; } if (m < n || n == 2) { cout << -1 << endl; continue; } else { int sum = 0; for (int i = 0; i < n - 1; i++) { sum += ara[i]; sum += ara[i + 1]; } sum += ara[n - 1]; sum += ara[0]; cout << sum << endl; for (int i = 1; i < n; i++) { cout << i << << i + 1 << endl; } cout << 1 << << n << endl; } } }
|
#include <bits/stdc++.h> using namespace std; template <typename flow_t = int, typename cost_t = int> struct mcSFlow { struct Edge { cost_t c; flow_t f; int to, rev; Edge(int _to, cost_t _c, flow_t _f, int _rev) : c(_c), f(_f), to(_to), rev(_rev) {} }; const cost_t INFCOST = numeric_limits<cost_t>::max() / 2; const cost_t INFFLOW = numeric_limits<flow_t>::max() / 2; cost_t epsilon; int N, S, T; vector<vector<Edge> > G; vector<unsigned int> isEnqueued, state; mcSFlow(int _N, int _S, int _T) : epsilon(0), N(_N), S(_S), T(_T), G(_N) {} void add_edge(int a, int b, cost_t cost, flow_t cap) { if (a == b) { assert(cost >= 0); return; } cost *= N; epsilon = max(epsilon, abs(cost)); assert(a >= 0 && a < N && b >= 0 && b < N); G[a].emplace_back(b, cost, cap, G[b].size()); G[b].emplace_back(a, -cost, 0, G[a].size() - 1); } flow_t calc_max_flow() { vector<flow_t> dist(N), state(N); vector<Edge *> path(N); auto cmp = [](Edge *a, Edge *b) { return a->f < b->f; }; flow_t addFlow, retflow = 0; ; do { fill(dist.begin(), dist.end(), -1); dist[S] = 0; auto head = state.begin(), tail = state.begin(); for (*tail++ = S; head != tail; ++head) { for (Edge const &e : G[*head]) { if (e.f && dist[e.to] == -1) { dist[e.to] = dist[*head] + 1; *tail++ = e.to; } } } addFlow = 0; fill(state.begin(), state.end(), 0); auto top = path.begin(); Edge dummy(S, 0, INFFLOW, -1); *top++ = &dummy; while (top != path.begin()) { int n = (*prev(top))->to; if (n == T) { auto next_top = min_element(path.begin(), top, cmp); flow_t flow = (*next_top)->f; while (--top != path.begin()) { Edge &e = **top, &f = G[e.to][e.rev]; e.f -= flow; f.f += flow; } addFlow = 1; retflow += flow; top = next_top; continue; } for (flow_t &i = state[n], i_max = G[n].size(), need = dist[n] + 1;; ++i) { if (i == i_max) { dist[n] = -1; --top; break; } if (dist[G[n][i].to] == need && G[n][i].f) { *top++ = &G[n][i]; break; } } } } while (addFlow); return retflow; } vector<flow_t> excess; vector<cost_t> h; void push(Edge &e, flow_t amt) { if (e.f < amt) amt = e.f; e.f -= amt; excess[e.to] += amt; G[e.to][e.rev].f += amt; excess[G[e.to][e.rev].to] -= amt; } void relabel(int vertex) { cost_t newHeight = -INFCOST; for (unsigned int i = 0; i < G[vertex].size(); ++i) { Edge const &e = G[vertex][i]; if (e.f && newHeight < h[e.to] - e.c) { newHeight = h[e.to] - e.c; state[vertex] = i; } } h[vertex] = newHeight - epsilon; } const int scale = 2; pair<flow_t, cost_t> minCostFlow() { cost_t retCost = 0; for (int i = 0; i < N; ++i) { for (Edge &e : G[i]) { retCost += e.c * (e.f); } } flow_t retFlow = calc_max_flow(); excess.resize(N); h.resize(N); queue<int> q; isEnqueued.assign(N, 0); state.assign(N, 0); for (; epsilon; epsilon >>= scale) { fill(state.begin(), state.end(), 0); for (int i = 0; i < N; ++i) for (auto &e : G[i]) if (h[i] + e.c - h[e.to] < 0 && e.f) push(e, e.f); for (int i = 0; i < N; ++i) { if (excess[i] > 0) { q.push(i); isEnqueued[i] = 1; } } while (!q.empty()) { int cur = q.front(); q.pop(); isEnqueued[cur] = 0; while (excess[cur] > 0) { if (state[cur] == G[cur].size()) { relabel(cur); } for (unsigned int &i = state[cur], max_i = G[cur].size(); i < max_i; ++i) { Edge &e = G[cur][i]; if (h[cur] + e.c - h[e.to] < 0) { push(e, excess[cur]); if (excess[e.to] > 0 && isEnqueued[e.to] == 0) { q.push(e.to); isEnqueued[e.to] = 1; } if (excess[cur] == 0) break; } } } } if (epsilon > 1 && epsilon >> scale == 0) { epsilon = 1 << scale; } } for (int i = 0; i < N; ++i) { for (Edge &e : G[i]) { retCost -= e.c * (e.f); } } return make_pair(retFlow, retCost / 2 / N); } flow_t getFlow(Edge const &e) { return G[e.to][e.rev].f; } }; const int N = 260, M = 30, inf = 1e5 + 42; int a[N]; char var[N]; int val[M]; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); int n, m; cin >> n >> m; int act_source = 0, source = 1, sink = 2 * n + 2; mcSFlow<long long, long long> mf(sink + 1, act_source, sink); mf.add_edge(act_source, source, 0, m); mf.add_edge(source, sink, 0, inf); for (int i = 1; i <= n; ++i) { cin >> a[i]; mf.add_edge(source, 2 * i, __builtin_popcount(a[i]), inf); mf.add_edge(2 * i, 2 * i + 1, -inf, 1); mf.add_edge(2 * i + 1, sink, 0, inf); } for (int i = 1; i <= n; ++i) { for (int j = i + 1; j <= n; ++j) { mf.add_edge(2 * i + 1, 2 * j, (a[i] == a[j]) ? 0 : __builtin_popcount(a[j]), inf); } } auto ans = mf.minCostFlow(); assert(ans.first == m); ans.second += n * inf; char nxt_var = a ; for (int i = 1; i <= n; ++i) { if (!var[i]) { var[i] = nxt_var++; } for (auto &e : mf.G[2 * i + 1]) { if (mf.getFlow(e) == 1 and e.to != sink) { var[e.to / 2] = var[i]; break; } } } vector<string> events; for (int i = 1; i <= n; ++i) { if (val[var[i] - a ] != a[i]) { val[var[i] - a ] = a[i]; events.push_back(var[i] + string( = ) + to_string(a[i])); } events.push_back(string( print( ) + var[i] + string( ) )); } cout << events.size() << << ans.second << n ; for (auto &s : events) { cout << s << n ; } }
|
#include <bits/stdc++.h> using namespace std; const int maxn = 1000010; int n, a, b, cur, h[maxn], nxt[maxn * 2], p[maxn * 2]; void add_edge(int x, int y) { cur++; nxt[cur] = h[x]; h[x] = cur; p[cur] = y; } int tid, dfn[maxn], dep[maxn], lg[maxn], fa[maxn][25]; void dfs(int x, int f) { dfn[x] = ++tid; for (int j = h[x]; j; j = nxt[j]) if (p[j] != f) fa[p[j]][0] = x, dep[p[j]] = dep[x] + 1, dfs(p[j], x); } int LCA(int x, int y) { if (dep[x] < dep[y]) swap(x, y); int k = dep[x] - dep[y]; for (int i = lg[k]; i >= 0; i--) if (k & (1 << i)) x = fa[x][i]; if (x == y) return x; for (int i = lg[dep[x]]; i >= 0; i--) if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i]; return fa[x][0]; } int q, k, s[maxn], st[maxn], top, f[maxn], gg[maxn]; bool tf[maxn], jud; bool cmp(int x, int y) { return dfn[x] < dfn[y]; } int lst[maxn]; vector<pair<int, int> > g[maxn]; void DP(int x) { f[x] = 0; gg[x] = 0; for (vector<pair<int, int> >::iterator it = g[x].begin(); it != g[x].end(); it++) { DP(it->first); f[x] += f[it->first]; if (tf[x] && tf[it->first] && it->second == 1) jud = false; } if (tf[x]) { gg[x] = 1; for (vector<pair<int, int> >::iterator it = g[x].begin(); it != g[x].end(); it++) f[x] += gg[it->first]; return; } else { int cnt = 0; for (vector<pair<int, int> >::iterator it = g[x].begin(); it != g[x].end(); it++) if (gg[it->first]) cnt++; if (cnt == 0) gg[x] = 0; else if (cnt == 1) gg[x] = 1; else f[x]++; } } int main() { scanf( %d , &n); for (int i = 2; i <= n; i++) lg[i] = lg[i / 2] + 1; for (int i = 1; i < n; i++) scanf( %d%d , &a, &b), add_edge(a, b), add_edge(b, a); dep[1] = 1; dfs(1, 0); for (int i = 1; i <= lg[n]; i++) for (int j = 1; j <= n; j++) fa[j][i] = fa[fa[j][i - 1]][i - 1]; scanf( %d , &q); for (int T = 1; T <= q; T++) { scanf( %d , &k); for (int i = 1; i <= k; i++) scanf( %d , s + i), tf[s[i]] = true; sort(s + 1, s + k + 1, cmp); top = 0; st[++top] = 0; for (int i = 1; i <= k; i++) { int t = LCA(s[i], st[top]); if (t != st[top]) { while (dfn[t] <= dfn[st[top - 1]]) { if (lst[st[top - 1]] < T) g[st[top - 1]].clear(), lst[st[top - 1]] = T; g[st[top - 1]].push_back({st[top], dep[st[top]] - dep[st[top - 1]]}); top--; } if (t != st[top]) { if (lst[t] < T) g[t].clear(), lst[t] = T; g[t].push_back({st[top], dep[st[top]] - dep[t]}); st[top] = t; } } st[++top] = s[i]; } while (top > 1) { if (lst[st[top - 1]] < T) g[st[top - 1]].clear(), lst[st[top - 1]] = T; g[st[top - 1]].push_back({st[top], dep[st[top]] - dep[st[top - 1]]}); top--; } jud = true; DP(st[1]); if (!jud) printf( -1 n ); else printf( %d n , f[st[1]]); for (int i = 1; i <= k; i++) tf[s[i]] = false; } return 0; }
|
#include <bits/stdc++.h> using namespace std; long long int N, M, Max = 0, Maxj = 0, A[1000][1000], arr[1000][1] = {}; int main() { cin >> N >> M; for (int i = 0; i < M; i++) { Max = -1; for (int j = 0; j < N; j++) { cin >> A[i][j]; if (Max < A[i][j]) { Max = A[i][j]; Maxj = j; } } arr[Maxj][0]++; } long long int max = 0, ind = 1; for (int i = 0; i < N; i++) { if (max < arr[i][0]) { max = arr[i][0]; ind = i + 1; } } cout << ind; return 0; }
|
#include <bits/stdc++.h> using namespace std; const long long N = 2 * 1e5 + 100; long long n, k, s, t, c[N], v[N], g[N], d[N], sum[N]; inline long long read() { long long f = 1, x = 0; char s = getchar(); while (s < 0 || s > 9 ) { if (s == - ) f = -1; s = getchar(); } while (s >= 0 && s <= 9 ) { x = x * 10 + s - 0 ; s = getchar(); } return x * f; } signed main() { n = read(); k = read(); s = read(); t = read(); for (long long i = 1; i <= n; i++) c[i] = read(), v[i] = read(); for (long long i = 1; i <= k; i++) g[i] = read(); sort(g + 1, g + 1 + k); for (long long i = 1; i <= k; i++) d[i] = g[i] - g[i - 1]; d[k + 1] = s - g[k]; k++; sort(d + 1, d + 1 + k); for (long long i = 1; i <= k; i++) sum[i] = sum[i - 1] + d[i]; if (t < s) { printf( -1 n ); return 0; } long long MIN = 0x3f3f3f3f; for (long long i = 1; i <= n; i++) { if (v[i] < d[k]) continue; long long pos = upper_bound(d + 1, d + 1 + k, v[i] / 2) - d - 1; long long all = sum[pos] + (sum[k] - sum[pos]) * 3 - (k - pos) * v[i]; if (all <= t) MIN = min(MIN, c[i]); } if (MIN == 0x3f3f3f3f) printf( -1 n ); else printf( %lld n , MIN); }
|
#include bits/stdc++.h using namespace std; int main() { ios::sync_with_stdio (0) ; cin.tie (0) ; int T ; cin >> T ; while ( T-- ) { long x, y; cin >> x >> y ; cout << x - 1 << << y << endl ; } }
|
#include <bits/stdc++.h> #pragma comment(linker, /STACK:256000000 ) using namespace std; int main() { ios::sync_with_stdio(false); cin.tie(0); long long n, m; cin >> n >> m; long long vmax = n - (m - 1); long long kmax = vmax * (vmax - 1) / 2; long long vmin = n / m; long long vmin_add = n - vmin * m; long long kmin = (m - vmin_add) * vmin * (vmin - 1) / 2 + vmin_add * (vmin + 1) * vmin / 2; cout << kmin << << kmax; return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { long long a, b, c, d, maxi1, maxi2; cin >> a >> b >> c >> d; maxi1 = max(((3 * a) / 10), (a - ((a / 250) * c))); maxi2 = max(((3 * b) / 10), (b - ((b / 250) * d))); if (maxi1 == maxi2) { cout << Tie n ; } else if (maxi2 > maxi1) { cout << Vasya n ; } else { cout << Misha n ; } return 0; }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.