func_code_string
stringlengths 59
71.4k
|
|---|
#include <bits/stdc++.h> using namespace std; const int N = (int)(1e2 + 5); int n, m, k; int grid[N][N]; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cin >> n >> m >> k; for (int(i) = (1); (i) <= (n); (i)++) for (int(j) = (1); (j) <= (m); (j)++) cin >> grid[i][j]; int score = 0, updates = 0; for (int(j) = (1); (j) <= (m); (j)++) { int col_score = 0; int col_update = 0; int update = 0; for (int(i) = (1); (i) <= (n); (i)++) { if (i - 1 >= 1) update += grid[i - 1][j]; if (grid[i][j] == 1) { int temp_score = 0; for (int q = i; q < i + k && q <= n; q++) temp_score += grid[q][j]; if (temp_score > col_score) { col_score = temp_score; col_update = update; } } } score += col_score; updates += col_update; } cout << score << << updates; return 0; } |
#include <bits/stdc++.h> #pragma GCC optimize( O3 ) using namespace std; template <class c> struct rge { c b, e; }; template <class c> rge<c> range(c i, c j) { return rge<c>{i, j}; } template <class c> auto dud(c* x) -> decltype(cerr << *x, 0); template <class c> char dud(...); struct debug { template <class c> debug& operator<<(const c&) { return *this; } }; const long long MOD = 1e9 + 7; const long long N = 1e6 + 10; const long long INF = 1e18 + 10; bool isPrime(long long x) { if (x <= 1) return false; for (long long i = 2; i * i <= x; i++) { if (x % i == 0) return false; } return true; } vector<bool> prime(N, true); vector<long long> primes; void seive() { prime[0] = prime[1] = false; for (long long i = 2; i * i <= N; i++) { if (prime[i]) { for (long long j = i + i; j < N; j += i) prime[j] = false; } } for (long long i = 0; i < N; i++) { if (prime[i]) { primes.emplace_back(i); } } } int main() { ios_base::sync_with_stdio(false); cin.tie(0); seive(); long long n; cin >> n; if (isPrime(n)) { cout << 1 << endl; cout << n << endl; return 0; } long long cur = n; while (cur--) { if (isPrime(cur)) { debug() << [ << cur : << (cur) << ] ; if (cur + 2 == n) { cout << 2 << endl; cout << 2 << << cur << endl; return 0; } int target = n - cur; debug() << [ << target : << (target) << ] ; int L = 0, R = (int)primes.size() - 1; while (L <= R) { if (primes[L] + primes[R] == target) { cout << 3 << endl; cout << primes[L] << << primes[R] << << cur << endl; return 0; } else if (primes[L] + primes[R] > target) R--; else { debug() << [ << L : << (L) << ] [ << R : << (R) << ] ; debug() << [ << primes[L] : << (primes[L]) << ] [ << primes[R] : << (primes[R]) << ] ; L++; } } } } return 0; } |
#include <bits/stdc++.h> using namespace std; signed main() { long long n; cin >> n; char s; long long cnt = 0; while (cin >> s) { cnt += s == 8 ; } long long ans = 0; for (long long i = 0; i <= cnt; ++i) { if (min(i, (n - i) / 10) > ans) ans = min(i, (n - i) / 10); } cout << ans; } |
#include <bits/stdc++.h> using namespace std; const int INF = (int)1e9; const int EPS = 1e-8; const int MOD = 1000000007; const long double PI = 3.14159265359; const int dx4[4] = {0, 1, 0, -1}; const int dy4[4] = {-1, 0, 1, 0}; const int dx8[8] = {-1, -1, -1, 0, 1, 1, 1, 0}; const int dy8[8] = {-1, 0, 1, 1, 1, 0, -1, -1}; inline bool grid_inside(int x, int y, int n, int m) { return x >= 1 && x <= n && y >= 1 && y <= m; } bool inrange(int a, int b, int a1, int b1) { if (a >= a1 && a <= b1) return true; if (b >= a1 && b <= b1) return true; if (a1 >= a && a1 <= b) return true; if (b1 >= a && b1 <= b) return true; return false; } template <typename T> T lcm(T a, T b) { return (a * b) / __gcd(a, b); } template <typename ForwardIterator, typename T> T first_val(ForwardIterator first, ForwardIterator last, T value) { auto it = std::lower_bound(first, last, value); return (it != last) ? (it - first) : -1; } template <typename ForwardIterator, typename T> T last_val(ForwardIterator first, ForwardIterator last, T value) { auto it = std::upper_bound(first, last, value); return ((it != last) ? ((it - first) - 1) : -1); } template <typename T> T Dis(T x1, T y1, T x2, T y2) { return sqrt(((x1 - x2) * (x1 - x2)) + ((y1 - y2) * (y1 - y2))); } template <typename T> T Angle(T x1, T y1, T x2, T y2) { return atan((double)(y1 - y2) / (double)(x1 - x2)); } int Set(int N, int pos) { return N = N | (1 << pos); } int Reset(int N, int pos) { return N = N & ~(1 << pos); } bool Check(int N, int pos) { return (bool)(N & (1 << pos)); } template <class T, class X> inline T togglebit(T a, X i) { T t = 1; return (a ^ (t << i)); } bool compare(const pair<int, int> &i, const pair<int, int> &j) { return i.first < j.first; } int doubleCompare(double x, double y) { if (fabs(x - y) <= EPS) return 0; if (x < y) return -1; return 1; } int LSOne(long long int n) { return log2(n & -n) + 1; } int rangeClear(int n, int i, int j) { int ones = ~0; int a = ones << (j + 1); int b = (i << 2) - 1; int mask = a | b; int ans = n & mask; return ans; } int countSetBits(int n) { int count = 0; while (n > 0) { count += (n & 1); n = n >> 1; } return count; } int getPosBit(int n, int k) { return (n & (1 << k)) != 0 ? 1 : 0; } void setPosBit(int &n, int k) { n = n | (1 << k); } long long int fast_power(long long int a, long long int x) { if (x == 0) return 1; else if (x == 1) return a; else { long long int R = fast_power(a, x >> 1); if (!(x & 1)) return R * R; else return R * a * R; } } long long int fast_power_unlocked(long long int a, long long int n, long long int mod) { long long int res = 1; while (n > 0) { if (n & 1) { res = (res * a) % mod; } a = (a * a) % mod; n = n >> 1; } return res; } long long int modInverse(long long int A, long long int M) { return fast_power_unlocked(A, M - 2, M); } bool checkPrime(long long int n) { int cnt = 0; for (long long int i = 2; i * i <= n; i++) { if (n % i == 0) { if (n / i == i) cnt++; else cnt += 2; } } if (cnt == 2) return true; else return false; } const int MAX_N = 1001; void solve() { int n, x, m; cin >> n >> x >> m; pair<int, int> v; v = make_pair(x, x); int k = 1; while (m--) { int a, b; cin >> a >> b; if (inrange(a, b, v.first, v.second)) { if (a < v.first) v.first = a; if (b > v.second) v.second = b; } } cout << v.second - v.first + 1; } int main() { ios::sync_with_stdio(false); cin.tie(nullptr); ; for (auto blockTime = make_pair(chrono::high_resolution_clock::now(), true); blockTime.second; fprintf(stderr, %s: %ld ms n , Time Taken , chrono::duration_cast<chrono::milliseconds>( chrono::high_resolution_clock::now() - blockTime.first) .count()), fflush(stderr), blockTime.second = false) { int t; cin >> t; for (int i = 0; i < t; ++i) { solve(); cout << n ; } } } |
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(0); cin.tie(0), cout.tie(0); long long n, m, l; cin >> n >> m >> l; vector<long long> a(n); vector<pair<long long, long long>> lr(n); long long ans = 0, old = -1000; long long flag = 0; for (long long i = 0; i < n; i++) { cin >> a[i]; if (a[i] > l) { if (flag == 0) ans++; flag = 1; } if (a[i] <= l && flag == 1) { flag = 0; } } while (m--) { long long tp; cin >> tp; if (tp == 0) { cout << ans << endl; } else { long long p, d; cin >> p >> d; if (n > 1) { if (a[p - 1] <= l && a[p - 1] + d > l) { if (p - 1 > 0 && p - 1 < n - 1) { if (a[p - 2] > l && a[p] > l) ans--; else if (a[p - 2] <= l && a[p] > l) ans += 0; else if (a[p - 2] > l && a[p] <= l) ans += 0; else ans++; } else if (p - 1 == 0) { if (a[p] > l) ans += 0; else if (a[p] <= l) ans++; } else { if (a[p - 2] > l) ans += 0; else if (a[p - 2] <= l) ans++; } } } else { if (a[p - 1] <= l && a[p - 1] + d > l) ans++; } a[p - 1] += d; } } return 0; } |
#include <bits/stdc++.h> #pragma comment(linker, /STACK:200000000 ) using namespace std; char a[105][105]; int n, m; bool u[105][105]; int main() { memset(u, false, sizeof(u)); scanf( %d %d n , &n, &m); for (int i = 0; i < n; i++, scanf( n )) for (int j = 0; j < m; j++) scanf( %c , &a[i][j]); for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) { for (int ix = 0; ix < m; ix++) if (ix != j && a[i][ix] == a[i][j]) u[i][ix] = u[i][j] = true; for (int ix = 0; ix < n; ix++) if (ix != i && a[ix][j] == a[i][j]) u[ix][j] = u[i][j] = true; } for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) { if (!u[i][j]) putchar(a[i][j]); } return 0; } |
#include <bits/stdc++.h> using namespace std; int v[1005][1005]; long long c[1005][1005], sum[1005][1005], t[1005][1005]; int main() { int n = 0, m = 0, a = 0, b = 0; scanf( %d%d%d%d , &n, &m, &a, &b); for (int i = 1; i <= n; ++i) { for (int j = 1; j <= m; ++j) { scanf( %d , &v[i][j]); sum[i][j] = sum[i][j - 1] + sum[i - 1][j] - sum[i - 1][j - 1] + (long long)v[i][j]; } } vector<pair<long long, pair<int, int>>> res; set<pair<long long, pair<int, int>>> cost; for (int i = 1; i <= n; ++i) { deque<long long> q; for (int j = m; j >= 1; --j) { while (!q.empty() && v[i][q.back()] > v[i][j]) { q.pop_back(); } q.push_back(j); while (q.front() >= j + b) { q.pop_front(); } t[i][j] = v[i][q.front()]; } } for (int i = 1; i <= m; ++i) { deque<long long> q; for (int j = n; j >= 1; --j) { while (!q.empty() && t[q.back()][i] > t[j][i]) { q.pop_back(); } q.push_back(j); while (q.front() >= j + a) { q.pop_front(); } c[j][i] = t[q.front()][i]; } } for (int i = 1; i + a - 1 <= n; ++i) { for (int j = 1; j + b - 1 <= m; ++j) { long long tmp = sum[i + a - 1][j + b - 1] - sum[i + a - 1][j - 1] - sum[i - 1][j + b - 1] + sum[i - 1][j - 1] - (long long)a * b * c[i][j]; cost.insert(make_pair(tmp, make_pair(i, j))); } } auto it = cost.begin(); while (it != cost.end()) { while (it != cost.end() && c[it->second.first][it->second.second] == -1) { ++it; } if (it == cost.end()) { break; } res.push_back(*it); int row = it->second.first, col = it->second.second; int rMin = max(row - a + 1, 0), cMin = max(col - b + 1, 0), rMax = min(row + a - 1, n - (a - 1)), cMax = min(col + b - 1, m - (b - 1)); for (int i = rMin; i <= rMax; ++i) { for (int j = cMin; j <= cMax; ++j) { c[i][j] = -1; } } } printf( %d n , res.size()); for (int i = 0; i < res.size(); ++i) { printf( %d %d %I64d n , res[i].second.first, res[i].second.second, res[i].first); } return 0; } |
#include <bits/stdc++.h> using namespace std; string a, p, s; bool suff[2002][2002]; bool pref[2002][2002]; long long int hash1[2002][2002]; long long int hash2[2002][2002]; set<pair<int, int> > ans; int main() { cin >> a >> p >> s; long long int mod1 = 1000000007; long long int mod2 = 1000003; for (int i = 0; i < a.size(); i++) { pref[i][p.size() - 1] = (a[i] == p[p.size() - 1]); suff[i][s.size() - 1] = (a[i] == s[s.size() - 1]); } for (int i = p.size() - 2; i >= 0; i--) for (int j = 0; j < a.size() - 1; j++) pref[j][i] = pref[j + 1][i + 1] && (a[j] == p[i]); for (int i = s.size() - 2; i >= 0; i--) for (int j = 0; j < a.size() - 1; j++) suff[j][i] = suff[j + 1][i + 1] && (a[j] == s[i]); int l = max(p.size(), s.size()); for (int i = 0; i < a.size(); i++) { hash1[i][i] = a[i] - a ; hash2[i][i] = 0; for (int j = i + 1; j < a.size(); j++) { hash1[i][j] = (hash1[i][j - 1] * 26 + a[j] - a ) % mod1; hash2[i][j] = j - i; } } for (int i = 0; i < a.size(); i++) for (int j = i + l - 1; j < a.size(); j++) if (pref[i][0] && suff[j - s.size() + 1][0]) ans.insert(make_pair(hash1[i][j], hash2[i][j])); cout << ans.size() << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; char str[100003]; struct Node { int val; int val2; Node* pt[26]; } node[100003]; int cnt; int mex(Node* node) { if (node->val != -1) return node->val; int f[30] = {}; for (int i = 0; i < 26; ++i) if (node->pt[i]) f[mex(node->pt[i])] = 1; for (int i = 0; i < 30; ++i) if (f[i] == 0) return node->val = i; } int mex2(Node* node) { if (node->val2 != -1) return node->val2; int f[30] = {}; int flag = 0; for (int i = 0; i < 26; ++i) if (node->pt[i]) { f[mex2(node->pt[i])] = 1; flag = 1; } if (!flag) return node->val2 = 1; for (int i = 0; i < 30; ++i) if (f[i] == 0) return node->val2 = i; } int main() { cnt = 27; int N, K; cin >> N >> K; for (int i = 0; i < 100003; ++i) node[i].val = node[i].val2 = -1; for (int i = 0; i < N; ++i) { cin >> str; Node* now = node; now->pt[str[0] - a ] = node + str[0] - a + 1; for (int j = 0; str[j]; ++j) if (now->pt[str[j] - a ]) now = now->pt[str[j] - a ]; else now = now->pt[str[j] - a ] = node + cnt++; } if (mex(node) == 0) cout << Second << endl; else if (K % 2 == 1 || mex2(node)) cout << First << endl; else cout << Second << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; struct pairvar { int a; int b; int c; int max; }; bool isPrime(long long x) { if (x == 1) { return false; } long long a = (long long)x; for (int i = 2; i <= (long long)sqrt((double)a); i++) { if (a % i == 0) { return false; } } return true; } int gcd(int a, int b) { if (b == 0) { return a; } return gcd(b, a % b); } long long factorial(long long x) { long long sum = 1; for (long long i = 1; i <= x; i++) { sum *= i; } return sum; } string tostr(int x) { string s = ; while (x != 0) { s += (x % 10) + 0 ; x /= 10; } string t = ; for (int i = s.length() - 1; i >= 0; i--) { t += s[i]; } return t; } bool cmp(const pairvar &a, const pairvar &b) { if (a.a == b.a) return a.b < b.b; return a.a < b.a; } int calc(int a, int b) { return (a * b) / gcd(a, b); } int main() { string s; cin >> s; int ans = 1; int k = s.size() - 1; int j = 1; for (int i = s.size() - 1; i >= 0; i--) { if (s[i] == 0 ) { k--; j++; } else { if (k > j) { ans++; k--; j = 1; } else if (k == j) { if (s[0] >= s[i]) { j = 1; k--; ans++; } else { j++; k--; } } } } cout << ans; } |
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); long long n, sum = 0; cin >> n; vector<long long> arr(n + 1); for (long long i = 1; i <= n; i++) cin >> arr[i], sum += arr[i]; map<pair<long long, long long>, long long> ma; long long m, a, b, c; cin >> m; while (m--) { cin >> a >> b >> c; if (!ma.count({a, b})) { if (c > 0) { arr[c]--; if (arr[c] >= 0) sum--; } } else { long long temp = ma[{a, b}]; arr[temp]++; if (arr[temp] > 0) sum++; if (c > 0) { arr[c]--; if (arr[c] >= 0) sum--; } else { ma.erase(ma.find({a, b})); } } if (c != 0) ma[{a, b}] = c; cout << sum << endl; } return 0; } |
#include <bits/stdc++.h> inline int read() { register int x = 0; register char f = 1, ch = getchar(); for (; !isdigit(ch); ch = getchar()) if (ch == - ) f = !f; for (; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + (ch ^ 0 ); return f ? x : -x; } int n, d[250005], X, vis[250005]; long long sum; std ::vector<std ::pair<int, int> > E[250005]; std ::pair<int, int> D[250005]; void addedge(int u, int v, int w) { E[u].push_back(std ::make_pair(v, w)), ++d[u]; } bool cmp(std ::pair<int, int> x, std ::pair<int, int> y) { return d[x.first] > d[y.first]; } struct Normal_Heap { std ::vector<long long> a; void push(long long x) { a.push_back(x), std ::push_heap(a.begin(), a.end()); } long long top() { return a[0]; } void pop() { std ::pop_heap(a.begin(), a.end()), a.pop_back(); } long long popn() { long long x; return std ::pop_heap(a.begin(), a.end()), x = a[a.size() - 1], a.pop_back(), x; } int size() { return a.size(); } }; struct Erase_Heap { Normal_Heap a, b; int sz; long long sum; void push(long long x) { a.push(x), ++sz, sum += x; } void erase(long long x) { b.push(x), --sz, sum -= x; } void pre() { while (a.size() && b.size() && a.top() == b.top()) a.pop(), b.pop(); } long long top() { return pre(), a.top(); } void pop() { pre(), --sz, sum -= a.top(), a.pop(); } int size() { return sz; } } H[250005]; void die(int u) { for (auto to : E[u]) { register int v = to.first, w = to.second; if (d[v] <= X) break; H[v].push(w); } } long long dp[250005][2]; std ::vector<long long> tmp, del; void dfs(int u, int fa = 0) { vis[u] = X; int num = d[u] - X; long long res = 0; for (; H[u].size() > num; H[u].pop()) ; for (auto to : E[u]) { register int v = to.first, w = to.second; if (v == fa) continue; if (d[v] <= X) break; dfs(v, u); } tmp.clear(), del.clear(); for (auto to : E[u]) { register int v = to.first, w = to.second; if (v == fa) continue; if (d[v] <= X) break; long long x = dp[v][1] + w - dp[v][0]; if (x <= 0) { --num, res += dp[v][1] + w; continue; } res += dp[v][0], H[u].push(x), del.push_back(x); } for (; H[u].size() && H[u].size() > num; H[u].pop()) tmp.push_back(H[u].top()); dp[u][0] = res + H[u].sum; for (; H[u].size() && H[u].size() > num - 1; H[u].pop()) tmp.push_back(H[u].top()); dp[u][1] = res + H[u].sum; for (auto i : tmp) H[u].push(i); for (auto i : del) H[u].erase(i); } int main() { n = read(); for (register int i = 1, u, v, w; i < n; ++i) u = read(), v = read(), w = read(), addedge(u, v, w), addedge(v, u, w), sum += w; printf( %lld , sum); for (register int i = 1; i <= n; ++i) D[i] = std ::make_pair(d[i], i), std ::sort(E[i].begin(), E[i].end(), cmp); std ::sort(D + 1, D + 1 + n); register int i = 1; for (X = 1; X < n; ++X) { while (i <= n && D[i].first == X) die(D[i].second), ++i; long long ans = 0; for (register int j = i; j <= n; ++j) { register int v = D[j].second; if (vis[v] == X) continue; dfs(v), ans += dp[v][0]; } printf( %lld , ans); } putchar( n ); } |
#include <bits/stdc++.h> using namespace std; const bool testing = false; pair<long long, long long> d[100000]; int nf[100000], nb[100000]; pair<long long, long long> getmid(int a, int b) { long long y = d[b].second - d[a].second; long long x = d[b].first - d[a].first; pair<long long, long long> res = make_pair(-y + x * x + 2 * x * d[a].first, 2 * x); return res; } void program() { int n; cin >> n; for (int i = 0; i < n; i++) { long long t1, t2; cin >> t1 >> t2; d[i] = make_pair(t1, t2); } std::sort(d, d + n); int start = 0; while (start + 1 < n && d[start + 1].first == d[start].first) start++; { nb[start] = -1; int prev = start; while (prev < n) { int t = prev + 1; while (t + 1 < n && d[t + 1].first == d[t].first) t++; if (t < n) nb[t] = prev; nf[prev] = t; prev = t; } } { int t1 = start; while (true) { int t2 = nf[t1]; if (t2 == n) break; int t3 = nf[t2]; if (t3 == n) break; pair<long long, long long> A1 = getmid(t1, t2); pair<long long, long long> A2 = getmid(t1, t3); if (A2.first * A1.second <= A1.first * A2.second) { nf[t1] = t3; nb[t3] = t1; if (nb[t1] != -1) t1 = nb[t1]; } else t1 = nf[t1]; } } long long res = 0; { int t = start; while (nf[t] != n) { res++; t = nf[t]; } } cout << res; } int main() { if (!testing) { program(); return 0; } FILE* fin = NULL; fin = fopen( in.txt , w+ ); fprintf(fin, n3 n-1 0 n0 2 n1 0 n ); fclose(fin); freopen( in.txt , r , stdin); printf( test case(1) => expected : n ); printf( 2 ); printf( test case(1) => found : n ); program(); fin = fopen( in.txt , w+ ); fprintf(fin, n5 n1 0 n1 -1 n0 -1 n-1 0 n-1 -1 n ); fclose(fin); freopen( in.txt , r , stdin); printf( test case(2) => expected : n ); printf( 1 ); printf( test case(2) => found : n ); program(); return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; int arr[n]; long long sum = 0; for (int i = 0; i < n; i++) { cin >> arr[i]; sum += arr[i]; } if (sum % 2 != 0) { sum++; } long long sum1 = 0; for (int i = 0; i < n; i++) { sum1 += arr[i]; if (sum1 >= (sum / 2)) { cout << i + 1 << endl; return 0; } } } |
#include <bits/stdc++.h> using namespace std; template <class T> T abs(T x) { if (x < 0) return -x; return x; } template <class T> T sqr(T a) { return a * a; } const double pi = acos(-1.0); const double eps = 1e-8; int a[100010]; int a1[100010]; int a2[100010]; int b; int ar[100010]; int flag[100010]; int main() { int i, n, m, k; while (2 == scanf( %d%d , &n, &m)) { int cnt = 0; for (i = 1; i <= n + m; i++) { if (i <= n) scanf( %d , &a1[i]); else scanf( %d , &a2[i - n]); } k = 0; for (i = 1; i <= n + m; i++) { scanf( %d , &b); if (b == 1) { cnt++; if (i <= n) ar[cnt] = a1[i]; else ar[cnt] = a2[i - n]; } else { ++k; if (i <= n) a[k] = a1[i]; else a[k] = a2[i - n]; } } k = 1; for (i = 1; i <= n; i++) { if (k + 1 <= cnt) { if (abs(a[i] - ar[k]) <= abs(a[i] - ar[k + 1])) flag[k]++; else { k++; i--; } } else flag[k]++; } for (i = 1; i <= cnt; i++) printf( %d , flag[i]); } return 0; } |
#include <bits/stdc++.h> using namespace std; ifstream in; ofstream out; const long long kk = 1000; const long long MOD = 10e9 + 7; long long a, b, x, y; long long GCD(long long n, unsigned long long m) { while (n != 0 && m != 0) { if (n > m) { n %= m; } else { m %= n; } } return (n + m); } int main() { ios_base::sync_with_stdio(0); cin >> a >> b >> x >> y; long long x1, y1; long long k = GCD(x, y); x /= k; y /= k; cout << min(a / x, b / y); return 0; } |
#include <bits/stdc++.h> using namespace std; const int MAXN = 200000 + 5; int n, ex, ey; char s[MAXN]; struct node { int x, y; node() {} node(int _x, int _y) : x(_x), y(_y) {} } p[MAXN]; bool OK(int t) { for (int i = 0; i + t <= n; i++) { int px = p[i].x - p[0].x + p[n].x - p[i + t].x; int py = p[i].y - p[0].y + p[n].y - p[i + t].y; int tx = ex - px; int ty = ey - py; if (abs(tx) + abs(ty) <= t) { return true; } } return false; } int main() { while (~scanf( %d , &n)) { scanf( %s , s + 1); scanf( %d%d , &ex, &ey); if ((n - abs(ex) - abs(ey)) < 0) { printf( -1 n ); continue; } if ((n - abs(ex) - abs(ey)) & 1) { printf( -1 n ); continue; } p[0] = node(0, 0); for (int i = 1; i <= n; i++) { if (s[i] == U ) { p[i] = node(p[i - 1].x, p[i - 1].y + 1); } else if (s[i] == D ) { p[i] = node(p[i - 1].x, p[i - 1].y - 1); } else if (s[i] == L ) { p[i] = node(p[i - 1].x - 1, p[i - 1].y); } else if (s[i] == R ) { p[i] = node(p[i - 1].x + 1, p[i - 1].y); } } int l = 0, r = n; while (l <= r) { int mid = (l + r) >> 1; if (OK(mid)) { r = mid - 1; } else { l = mid + 1; } } printf( %d n , r + 1); } return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { string s; int mod = 1e9 + 7; cin >> s; for (int i = 0; i < s.size(); i++) { if (s[i] == w || s[i] == m ) { cout << 0; return 0; } } int a, b = 1, c = 0; for (int i = 0; i < s.length(); i++) { if (s[i] == s[i - 1] && (s[i] == n || s[i] == u )) { a = (b + c) % mod; } else a = b; c = b; b = a; } cout << a; } |
#include <bits/stdc++.h> using namespace std; long long mulMod(long long a, long long b, long long m = 1000000007) { long long x = 0, y = a % m; while (b > 0) { if (b % 2 == 1) x = (x + y) % m; y = (y * 2) % m; b /= 2; } return x % m; } long long expMod(long long b, long long e, long long m = 1000000007) { if (!e) return 1; long long q = expMod(b, e / 2, m); q = mulMod(q, q, m); return e % 2 ? mulMod(b, q, m) : q; } long long invFact[20], fact[20]; long long inverso(long long x) { return expMod(x, 1000000007 - 2); } void pre() { fact[0] = 1; for (int i = (1); i < (20 - 2); i++) fact[i] = (fact[i - 1] * i) % 1000000007; invFact[20 - 3] = inverso(fact[20 - 3]); for (int i = 20 - 3 - 1; i >= 0; i--) invFact[i] = (invFact[i + 1] * (i + 1)) % 1000000007; return; } long long comb(long long nn, long long k) { if (k < 0 || nn < k) return 0; return (fact[nn] * invFact[k] % 1000000007) * invFact[nn - k] % 1000000007; } int n; long long win[15][15]; long long get(int mask1, int mask2) { long long ret = 1; for (int i = (0); i < (n); i++) { if ((mask1 >> i) & 1) { for (int j = (0); j < (n); j++) { if ((mask2 >> j) & 1) { ret = ((ret * win[i][j] % 1000000007) + 1000000007) % 1000000007; assert(ret >= 0); } } } } return ret; } int main() { ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); cin >> n; vector<long long> a(n); for (int i = (0); i < (n); i++) cin >> a[i]; for (int i = (0); i < (n); i++) for (int j = (0); j < (n); j++) win[i][j] = (((a[i] * inverso(a[i] + a[j])) % 1000000007) + 1000000007) % 1000000007; vector<long long> proba(1 << n, 1); long long rta = 0; for (int mask = 1; mask < (1 << n); mask++) { for (int submask = mask & (mask - 1); submask; submask = (submask - 1) & mask) { proba[mask] -= proba[submask] * get(submask, mask ^ submask); proba[mask] = ((proba[mask] % 1000000007) + 1000000007) % 1000000007; assert(proba[mask] >= 0); } rta += ((__builtin_popcount(mask) * proba[mask]) % 1000000007 * get(mask, ((1 << n) - 1) ^ mask)) % 1000000007; rta = ((rta % 1000000007) + 1000000007) % 1000000007; } cout << rta << n ; return 0; } |
#include <bits/stdc++.h> using namespace std; const int Maxn = int(1e5); inline int read() { int x = 0, f = 1; char ch = getchar(); while (ch < 0 || ch > 9 ) { if (ch == - ) f = -1; ch = getchar(); } while (ch >= 0 && ch <= 9 ) { x = x * 10 + ch - 0 ; ch = getchar(); } return x * f; } struct Node { int to, nxt, w; } Edge[Maxn * 2 + 5]; int tot, Head[Maxn + 5]; inline void Addedge(int x, int y, int z) { Edge[++tot] = (Node){y, Head[x], z}; Head[x] = tot; } long long ans; int n, l, w, rt, sum; int siz[Maxn + 5], maxs[Maxn + 5], vis[Maxn + 5]; int dis1[Maxn + 5], dis2[Maxn + 5], cur, allcur; struct Point { int a, b, c; } tmp[Maxn + 5], all[Maxn + 5]; inline int cmp1(Point x, Point y) { return x.a < y.a; } inline int cmp2(Point x, Point y) { return x.a > y.a; } int t[Maxn + 5], top; inline void Add(int x, int y) { while (x <= l) t[x] += y, x += (x & -x); } inline int Query(int x) { int res = 0; while (x > 0) res += t[x], x -= (x & -x); return res; } inline void dfs1(int x, int f) { siz[x] = 1, maxs[x] = 0; for (register int i = Head[x]; i; i = Edge[i].nxt) { int y = Edge[i].to; if (y == f || vis[y]) continue; dfs1(y, x); siz[x] += siz[y]; maxs[x] = max(maxs[x], siz[y]); } maxs[x] = max(maxs[x], sum - siz[x]); rt = maxs[x] < maxs[rt] ? x : rt; } inline void dfs2(int x, int f, int grand) { tmp[++cur] = (Point){dis1[x], dis2[x], grand}; for (register int i = Head[x]; i; i = Edge[i].nxt) { int y = Edge[i].to; if (y == f || vis[y]) continue; dis1[y] = dis1[x] + Edge[i].w; dis2[y] = dis2[x] + 1; dfs2(y, x, grand); } } inline void Count(int x) { int it = 1; allcur = 0; for (register int i = Head[x]; i; i = Edge[i].nxt) { int y = Edge[i].to; if (vis[y]) continue; dis1[y] = Edge[i].w, dis2[y] = 1; cur = 0, dfs2(y, x, y); for (register int j = 1; j <= cur; ++j) if (tmp[j].a <= w) all[++allcur] = tmp[j]; } sort(all + 1, all + allcur + 1, cmp1); for (register int i = Head[x]; i; i = Edge[i].nxt) { int y = Edge[i].to; if (vis[y]) continue; dis1[y] = Edge[i].w, dis2[y] = 1; it = 1, cur = 0, dfs2(y, x, y); sort(tmp + 1, tmp + cur + 1, cmp2); for (register int j = 1; j <= cur; ++j) { while (it <= allcur && tmp[j].a + all[it].a <= w) { if (all[it].c < y) Add(all[it].b, 1); it++; } if (tmp[j].a <= w && tmp[j].b <= l) ans++; if (tmp[j].b < l) ans += Query(l - tmp[j].b); } for (register int j = 1; j < it; ++j) if (all[j].c < y) Add(all[j].b, -1); } } inline void Divide(int x) { vis[x] = 1; Count(x); for (register int i = Head[x]; i; i = Edge[i].nxt) { int y = Edge[i].to; if (vis[y]) continue; rt = 0, maxs[0] = sum = siz[y]; dfs1(y, 0), dfs1(rt, 0); Divide(rt); } } int main() { n = read(), l = read(), w = read(); for (register int i = 1; i < n; ++i) { int a = read(), b = read(); Addedge(i + 1, a, b), Addedge(a, i + 1, b); } maxs[0] = sum = n; dfs1(1, 0), dfs1(rt, 0); Divide(rt); printf( %I64d , ans); return 0; } |
#include <bits/stdc++.h> using namespace std; template <class T> void splitstr(const string &s, vector<T> &out) { istringstream in(s); out.clear(); copy(istream_iterator<T>(in), istream_iterator<T>(), back_inserter(out)); } template <class T> T read_value(string s) { T result; istringstream sin(s); sin >> result; return result; } string read_line() { string ret_val; getline(std::cin, ret_val); return ret_val; } template <class T> void init_array(T *arr, int size, T value) { for (int i = 0; i < size; i++) arr[i] = value; } template <class T> inline T gcd(T a, T b) { return (!a) ? b : gcd(b % a, a); } template <class T> inline T mod(T a, T p) { a %= p; return (a < 0) ? a + p : a; } template <class T> inline int num_bits(T n) { return (!n) ? 0 : 1 + numbits(n & (n - 1)); } template <class T> inline T inverse(T a, T m) { a = mod<T>(a, m); return (a == 1) ? 1 : mod((1 - m * inverse(m % a, a)) / a, m); } template <class T> inline bool is_prime(T a) { T lim = (T)sqrt((double)a); for (T i = 2; i <= T(lim + 1E-9); i++) if (a % i == 0) return false; return true; } template <class T> inline T power(T a, T p, T mod) { if (!p) return 1; T temp = power(a, p >> 1, mod); temp = (temp * temp) % mod; if (p & 1) temp = (temp * a) % mod; return temp; } void get_primes(int start, int end, vector<int> &vi) { int *p = new int[end + 1]; init_array<int>(p, end + 1, 0); p[1] = 1; for (int i = 2; i <= end; i++) { if (!p[i]) { if (i >= start) vi.push_back(i); for (int j = 2 * i; j <= end; j += i) p[j] = 1; } } delete[] p; } bool dfs(int current, int final, int total, int *visited, int **edges, bool flow) { if (current == final) return true; if (visited[current]) return false; visited[current] = true; for (int i = 0; i < total; i++) if (edges[current][i] && dfs(i, final, total, visited, edges, flow)) { if (flow) { edges[current][i]--; edges[i][current]++; } return true; } return false; } int flow(int in, int out, int total, int **edges) { int result = 0; int *visited = new int[total]; while (init_array<int>(visited, total, 0), dfs(in, out, total, visited, edges, true)) result++; delete[] visited; return result; } void create_set(int x, int *P, int *rank) { P[x] = x; rank[x] = 0; } int find_set(int x, int *P) { if (x != P[x]) P[x] = find_set(P[x], P); return P[x]; } bool merge_sets(int x, int y, int *P, int *rank) { int Px = find_set(x, P); int Py = find_set(y, P); if (Px == Py) return false; if (rank[Px] > rank[Py]) P[Py] = Px; else P[Px] = Py; if (rank[Px] == rank[Py]) rank[Py]++; return true; } template <typename T> int read_cum_freq(int index, T *tree) { int sum = 0; while (index) { sum += tree[index]; index -= (index & -index); } return sum; } template <typename T> void upd_freq(int index, int mxIndex, int value, T *tree) { while (index <= mxIndex) { tree[index] += value; index += (index & -index); } } template <typename T> int read_freq(int index, T *tree) { return read_cum_freq(index, tree) - read_cum_freq(index - 1, tree); } void build_failure_function(const string &str, int *temp_arr) { temp_arr[0] = temp_arr[1] = 0; for (int i = 2; i <= ((int)(str).size()); i++) { temp_arr[i] = -1; for (int ind = temp_arr[i - 1]; temp_arr[i] == -1; ind = temp_arr[ind]) { if (str[ind] == str[i - 1]) { temp_arr[i] = ind + 1; } else if (ind == 0) { temp_arr[i] = 0; } } } } void KMP(const string &text, const string &pattern, int *res) { int *temp_arr = new int[((int)(pattern).size()) + 1]; build_failure_function(pattern, temp_arr); int i = 0; int ind = 0; while (i < ((int)(text).size())) { if (text[i] == pattern[ind]) { res[i] = ++ind; if (res[i] == ((int)(pattern).size())) { ind = temp_arr[ind]; } i++; } else if (ind == 0) { res[i++] = 0; } else { ind = temp_arr[ind]; } } delete[] temp_arr; } void setup(int value, string name) { string name_in = name + .in ; string name_out = name + .out ; freopen(name_in.c_str(), r , stdin); if (value) { freopen(name_out.c_str(), w , stdout); } } int main() { int n, m; std::cin >> n >> m; vector<string> vs(n); for (int i = 0; i < n; i++) std::cin >> vs[i]; for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) { bool flag = true; for (int k = 0; k < m; k++) if (k != j && vs[i][j] == vs[i][k]) flag = false; for (int k = 0; k < n; k++) if (k != i && vs[i][j] == vs[k][j]) flag = false; if (flag) std::cout << vs[i][j]; } return 0; } |
#include <bits/stdc++.h> using namespace std; char first[100001], second[100001], zero[100001]; int number1[10], number2[10]; int just_zero() { char *p1 = first, *p2 = second; while (number1[0]--) *p1++ = *p2++ = 0 ; return p1 - first; } int summary_ten(int count) { int min_rez = -1; int t = 0; for (int i = 1; i < 6; i++) { if (number1[i] && number2[10 - i]) { int now_rez = min(number1[i], number2[9 - i]) + min(number2[10 - i], number1[i - 1]) - min(number1[i] - 1, number2[9 - i]) - min(number2[10 - i] - 1, number1[i - 1]); if (now_rez < min_rez || min_rez == -1) { t = i; min_rez = now_rez; } } } if (t) { number1[t]--; number2[10 - t]--; first[count] = t + 0 ; second[count] = (10 - t) + 0 ; return count + 1; } return count; } int summary_nine(int count) { char *p1 = &first[count], *p2 = &second[count]; for (int i = 0; i < 10; i++) { int t1 = number1[9 - i]; int t2 = number2[i]; while (t1 * t2) { *p1++ = (9 - i) + 0 ; *p2++ = i + 0 ; t1--; t2--; number1[9 - i]--; number2[i]--; } } return p1 - first; } int what_else(int count) { char *zero_p = zero; while (number1[0] * number2[0]) { *zero_p++ = 0 ; number1[0]--; number2[0]--; } char *p1 = &first[count], *p2 = &second[count]; for (int i = 0; i < 10; i++) { while (number1[i]) { *p1++ = i + 0 ; number1[i]--; } while (number2[i]) { *p2++ = i + 0 ; number2[i]--; } } return p1 - first; } void print_screen(int count) { char *p1 = first + count, *p2 = second + count; while (true) { printf( %c , *p1); if (p1 == first) break; *p1--; } printf( %s n , zero); while (true) { printf( %c , *p2); if (p2 == second) break; *p2--; } printf( %s , zero); return; } void maximum_sum() { int count1 = summary_ten(0); int count2 = count1; if (count1) count2 = summary_nine(count1); int count3 = what_else(count2); print_screen(count3 - 1); return; } int main() { char str[100001]; scanf( %s , &str); char *p = &str[0]; while (*p) { number2[*p - 0 ]++; number1[(*p++) - 0 ]++; } maximum_sum(); scanf( %s , &str); return 0; } |
#include <bits/stdc++.h> using namespace std; const long long N = 2000; long long calcula(long long l, long long r, long long k) { long long d1 = -r; long long d2 = l - r; long long aum = d2 - d1; long long lim1 = d1; long long lim2 = d1 + (r * 1000000 - 1) * aum; if (lim1 <= k && k <= lim2 && (k - d1) % aum == 0) { long long num = (k - d1) / aum + 1; return num; } return -1; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.precision(10); cout << fixed; long long k; cin >> k; for (long long i = 1; i <= N; i++) { for (long long j = 1; j <= N; j++) { if (i + j > N) break; long long aux = calcula(i, j, k); if (aux != -1) { cout << i + j << endl; for (long long a = 0; a < i - 1; a++) { cout << 0 << ; } cout << -1 << ; for (long long a = 0; a < j; a++) { cout << min(aux, 1000000ll) << ; aux -= min(aux, 1000000ll); } cout << endl; return 0; } } } cout << -1 << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int cakesneeded, timek, k, timeforoven; cin >> cakesneeded >> timek >> k >> timeforoven; int cyclesneeded = cakesneeded / k; if (cakesneeded % k != 0) { cyclesneeded++; } int totaltime = cyclesneeded * timek; int partialtime = totaltime - timek; if (partialtime > timeforoven) { cout << YES ; } else { cout << NO ; } } |
#include <bits/stdc++.h> using namespace std; int main() { long long a, b, c, d; cin >> a >> b >> c >> d; long long w, x, y, z; bool f = 1; if (a == c && f) { w = a + abs(d - b); x = b; y = a + abs(d - b); z = d; f = 0; } if (b == d && f) { w = a; x = b + abs(a - c); y = c; z = b + abs(a - c); f = 0; } else if (f) { if (abs(a - c) == abs(b - d)) { w = a; x = d; y = c; z = b; f = 0; } else { cout << -1 << endl; ; } } if (!f) cout << w << << x << << y << << z << endl; ; } |
#include <bits/stdc++.h> using namespace std; long long gcd(long long a, long long b) { while (b) { swap(a %= b, b); } return a; } long long n, m, x, y, a, b, g; double dist1(long long curstep) { long long l1 = a / g * curstep; long long l2 = b / g * curstep; long long x1 = max(1ll, (x - (l1 - l1 / 2))); if (x1 + l1 > n) { x1 = n - l1; } long long x2 = x1 + l1; long long y1 = max(1ll, (y - (l2 - l2 / 2))); if (y1 + l2 > m) { y1 = m - l2; } long long y2 = y1 + l2; double c1 = (x1 + x2 + .0) / 2; double c2 = (y1 + y2 + .0) / 2; double tempdst = sqrt((c1 - x) * (c1 - x) + (c2 - y) * (c2 - y)); return tempdst; } int main() { cin >> n >> m >> x >> y >> a >> b; g = gcd(a, b); a /= g; b /= g; long long step = min(n / a, m / b); a *= step; b *= step; long long l1 = a; long long l2 = b; long long x1 = max(0ll, (x - (l1 - l1 / 2))); if (x1 + l1 > n) { x1 = n - l1; } long long x2 = x1 + l1; long long y1 = max(0ll, (y - (l2 - l2 / 2))); if (y1 + l2 > m) { y1 = m - l2; } long long y2 = y1 + l2; cout << x1 << ; cout << y1 << ; cout << x2 << ; cout << y2; return 0; } |
#include <bits/stdc++.h> using namespace std; const int maxn = 1e5 + 100; long long n_r, n_g, n_b, r[maxn], g[maxn], b[maxn], ans; void cal(long long n_r, long long n_g, long long n_b, long long r[], long long g[], long long b[]) { long long x, y, z, i, j = 1, k = 1; for (i = 1; i <= n_g; ++i) { y = g[i]; while (r[j] <= y && j <= n_r) ++j; if (j == 1) continue; --j; x = r[j]; while (b[k] < y) ++k; if (k > n_b) break; z = b[k]; ans = min(ans, (x - y) * (x - y) + (y - z) * (y - z) + (z - x) * (z - x)); } } void solve() { ans = 0x7fffffffffffffff; cal(n_r, n_g, n_b, r, g, b); cal(n_r, n_b, n_g, r, b, g); cal(n_g, n_r, n_b, g, r, b); cal(n_g, n_b, n_r, g, b, r); cal(n_b, n_g, n_r, b, g, r); cal(n_b, n_r, n_g, b, r, g); cout << ans << n ; } int main() { int t, i, j; ios::sync_with_stdio(false); cin >> t; while (t--) { cin >> n_r >> n_g >> n_b; for (i = 1; i <= n_r; ++i) cin >> r[i]; for (i = 1; i <= n_g; ++i) cin >> g[i]; for (i = 1; i <= n_b; ++i) cin >> b[i]; sort(r + 1, r + 1 + n_r); sort(g + 1, g + 1 + n_g); sort(b + 1, b + 1 + n_b); solve(); } return 0; } |
#include <bits/stdc++.h> using namespace std; vector<int> e[111]; int used[111], cnt, cnt2; void dfs(int x) { used[x] = 1; cnt += e[x].size(); cnt2++; for (int i = 0; i < e[x].size(); i++) if (used[e[x][i]] == 0) dfs(e[x][i]); } int main() { int i, j, k, n, m, stop = 0; scanf( %d%d , &n, &m); for (i = 0; i < m; i++) { int x, y; scanf( %d%d , &x, &y); e[x].push_back(y); e[y].push_back(x); } for (i = 1; i <= n; i++) { if (!used[i]) { cnt = 0; cnt2 = 0; dfs(i); if (cnt2 % 2 == 1 && cnt2 * 2 == cnt) { stop++; } } } printf( %d n , stop + (n - stop) % 2); return 0; } |
#include <bits/stdc++.h> using namespace std; queue<int> qx, qy; int d[2][110000]; char s[2][110000]; int n, k; int main() { gets(s[0]); sscanf(s[0], %d %d , &n, &k); gets(s[0]); gets(s[1]); memset(d, 63, sizeof(d)); d[0][0] = 0; qx.push(0); qy.push(0); for (; qx.size();) { int x = qx.front(); int y = qy.front(); qx.pop(); qy.pop(); if (d[y][x] > x) continue; if (x + k >= n) { printf( YES n ); return 0; } if (s[y][x + 1] == - ) { if (d[y][x + 1] > d[y][x] + 1) { d[y][x + 1] = d[y][x] + 1; qx.push(x + 1); qy.push(y); } } if (x > 0 && s[y][x - 1] == - ) { if (d[y][x - 1] > d[y][x] + 1) { d[y][x - 1] = d[y][x] + 1; qx.push(x - 1); qy.push(y); } } if (s[y ^ 1][x + k] == - ) { if (d[y ^ 1][x + k] > d[y][x] + 1) { d[y ^ 1][x + k] = d[y][x] + 1; qx.push(x + k); qy.push(y ^ 1); } } } printf( NO n ); return 0; } |
#include <bits/stdc++.h> using namespace std; int t, n; int a[200001]; int main() { scanf( %d , &t); while (t--) { scanf( %d , &n); for (int i = 1; i <= n; i++) scanf( %d , &a[i]); bool flag = false; for (int i = 2; i <= n; i++) if (abs(a[i] - a[i - 1]) > 1) { flag = true; printf( YES n ); printf( %d %d n , i - 1, i); break; } if (!flag) printf( NO n ); } return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int n; scanf( %d n , &n); set<int> in, x; long totalCost(0), cost(0); while (n--) { int a, b, c; scanf( %d %d %d n , &a, &b, &c); totalCost += c; if (in.count(a) || x.count(b)) { cost += c; x.insert(a); in.insert(b); } else { in.insert(a); x.insert(b); } } if (totalCost - cost < cost) { cost = totalCost - cost; } printf( %ld n , cost); return 0; } |
#include <bits/stdc++.h> using namespace std; int n; vector<int> a; void printall(int x, int y, bool paren = false) { if (paren) printf( ( ); for (int i = x; i < y; i++) printf( %d-> , a[i]); printf( %d , a[y]); if (paren) printf( ) ); } int main() { scanf( %d , &n); a.resize(n); for (int i = 0; i < n; i++) scanf( %d , &a[i]); if (a.back() != 0) { puts( NO ); } else { if (n == 1 or a[n - 2] == 1) { puts( YES ); printall(0, n - 1); } else { int i; for (i = n - 3; i >= 0; i--) if (a[i] == 0) break; if (i < 0) { puts( NO ); } else { puts( YES ); if (i - 1 >= 0) { printall(0, i - 1); printf( -> ); } printf( (0-> ); printall(i + 1, n - 2, true); printf( )->0 ); } } } } |
#include <bits/stdc++.h> using namespace std; const long long mod = 1e9 + 7; long double PI = acosl(-1); const long long infl = 1e18; const int nmax = 1e6 + 5; const int MAXLG = log2(nmax) + 1; const int N = 2e4 + 5; struct Hopcroft_Karp { int NIL = 0, INF = (1 << 28), match[N], dist[N], n, m; vector<int> G[N]; void init(int lft, int rgt) { n = lft, rgt = m; for (int i = 0; i <= n + m + 1; i++) G[i].clear(); } void addEdge(int u, int v) { G[u].push_back(v + n); } bool bfs() { queue<int> Q; for (int i = 1; i <= n; i++) { if (match[i] == NIL) dist[i] = 0, Q.push(i); else dist[i] = INF; } dist[NIL] = INF; while (!Q.empty()) { int u = Q.front(); Q.pop(); if (u != NIL) { for (int i = 0; i < G[u].size(); i++) { int v = G[u][i]; if (dist[match[v]] == INF) { dist[match[v]] = dist[u] + 1; Q.push(match[v]); } } } } return (dist[NIL] != INF); } bool dfs(int u) { if (u != NIL) { for (int i = 0; i < G[u].size(); i++) { int v = G[u][i]; if (dist[match[v]] == dist[u] + 1) { if (dfs(match[v])) { match[v] = u; match[u] = v; return true; } } } dist[u] = INF; return false; } return true; } int hopcroft_karp() { memset(dist, 0, sizeof dist); memset(match, 0, sizeof match); int matching = 0; while (bfs()) { for (int i = 1; i <= n; i++) { if (match[i] == NIL && dfs(i)) { matching++; } } } return matching; } }; int main() { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); Hopcroft_Karp carp; int n, m; cin >> n >> m; vector<pair<int, pair<int, int> > > ejes; for (int i = 0; i < m; i++) { int u, v, d; cin >> u >> v >> d; ejes.push_back({d, {u, v}}); } carp.init(n, n); for (pair<int, pair<int, int> > pp : ejes) { carp.addEdge(pp.second.first, pp.second.second); } int z = carp.hopcroft_karp(); if (z != n) cout << -1 n , exit(0); sort(ejes.begin(), ejes.end()); int lo = 1, hi = 1000000000; while (hi > lo) { int mid = (hi + lo) / 2; carp.init(n, n); for (auto pp : ejes) { if (pp.first > mid) break; carp.addEdge(pp.second.first, pp.second.second); } if (carp.hopcroft_karp() == n) hi = mid; else lo = mid + 1; } cout << lo << endl; } |
#include <bits/stdc++.h> using namespace std; double max(double a, double b) { return (a > b ? a : b); } int main() { std::ios::sync_with_stdio(false); cin.tie(0); int n; cin >> n; double A[n][n]; for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) { cin >> A[i][j]; } } vector<vector<double> > DP(n, vector<double>(1 << n, 0)); DP[0][0] = 1; for (int i = 1; i < n; ++i) { DP[i][1 << (n - 1)] = A[0][i]; } double mom = 0; for (int k = 1; k < n; ++k) { for (int i = 0; i < (1 << n); ++i) { if (__builtin_popcount(i) != k) { continue; } for (int player = 0; player < n; ++player) { if (i & (1 << player)) { continue; } double mx = 0; DP[player][i] = 0; for (int enemy = 0; enemy < n; ++enemy) { mx = 0; if (i & (1 << enemy)) { mx += A[player][enemy] * DP[player][i - (1 << enemy)]; mx += A[enemy][player] * DP[enemy][i - (1 << enemy)]; } DP[player][i] = max(mx, DP[player][i]); } if (k == n - 1) { mom = max(DP[player][i], mom); } } } } cout << (n == 1 ? 1 : mom) << n ; } |
#include <bits/stdc++.h> int MakeTB(unsigned int *A, unsigned int *B, unsigned int *T, unsigned int N, unsigned int StartBit) { for (unsigned int i = 0; i < N - 1; i++) if (A[i] == 0) if (B[i] == 0) { if (i > 0 && T[i] != 0) return 0; T[i] = 0; T[i + 1] = 0; } else return 0; else if (B[i] == 0) { if (i == 0) T[i] = StartBit; T[i + 1] = !T[i]; } else { if (i > 0 && T[i] != 1) return 0; T[i] = 1; T[i + 1] = 1; } return 1; } int MakeTWB(unsigned int *A, unsigned int *B, unsigned int *T, unsigned int N) { unsigned int *a, *b, *t1, *t2; a = new unsigned int[N - 1]; b = new unsigned int[N - 1]; t1 = new unsigned int[N]; t2 = new unsigned int[N]; for (unsigned int i = 0; i < N - 1; i++) { a[i] = A[i] & 1; b[i] = B[i] & 1; } if (!(MakeTB(a, b, t1, N, 0) || MakeTB(a, b, t1, N, 1))) return 0; for (unsigned int i = 0; i < N - 1; i++) { a[i] = A[i] >> 1; b[i] = B[i] >> 1; } if (!(MakeTB(a, b, t2, N, 0) || MakeTB(a, b, t2, N, 1))) return 0; for (unsigned int i = 0; i < N; i++) T[i] = t1[i] | (t2[i] << 1); return 1; } int main(void) { unsigned int N; unsigned int *a, *b, *t; scanf( %d , &N); a = new unsigned int[N - 1]; b = new unsigned int[N - 1]; t = new unsigned int[N]; for (unsigned int i = 0; i < N - 1; i++) scanf( %d , &a[i]); for (unsigned int i = 0; i < N - 1; i++) scanf( %d , &b[i]); if (MakeTWB(a, b, t, N)) { printf( YES n ); for (unsigned int i = 0; i < N; i++) printf( %i , t[i]); } else printf( NO ); return 0; } |
#include <bits/stdc++.h> using namespace std; map<int, int> mp, x[1000005]; int main() { int t1; cin >> t1; while (t1--) { string s, t; cin >> s >> t; mp.clear(); for (int i = 0; i < s.size(); i++) mp[s[i]]++; bool q = true; for (int i = 0; i < t.size(); i++) { if (mp[t[i]] == 0) { q = false; break; } } if (q == false) { cout << -1 << endl; continue; } for (int j = 100005; j >= 1; j--) x[j].clear(); for (int i = s.size() - 1; i >= 0; i--) { for (int j = 1; j <= 26; j++) x[i + 1][j] = x[i + 2][j]; x[i + 1][s[i] - a + 1] = i + 1; } int in = 0, ans = 0; while (in < t.size()) { ans++; int ind = 0; while (true) { if (x[ind + 1][t[in] - a + 1] == 0) break; ind = x[ind + 1][t[in] - a + 1]; in++; if (in >= t.size()) break; } if (in >= t.size()) break; } cout << ans << endl; } } |
#include <bits/stdc++.h> using namespace std; int a[10001]; int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); int n, m, k; cin >> n >> m >> k; long long int x1 = 1, x2 = 1; int p = k; if (k % 2 == 0) { k -= 1; } int x = 1, y = 1, res = 0; for (int j = 1; j <= m; j++) { for (int i = 1; i <= n; i++) { a[i] = x; if (a[i] == k) { cout << i << << j << ; p % 2 == 0 ? cout << R : cout << L ; return 0; } x += m * 2; } x = y + 2 * j; } return 0; } |
#include <bits/stdc++.h> using namespace std; const int MAXN = 1e6 + 10; int n, a[MAXN], d[MAXN]; bool pic[MAXN]; int main() { scanf( %d , &n); for (int i = 0; i < n; i++) { int temp; scanf( %d , &temp); pic[temp] = 1; } fill(d, d + MAXN, 1); int ans = 0; for (int i = 1; i < MAXN; i++) { if (pic[i]) ans = max(ans, d[i]); if (pic[i]) for (int j = i + i; j < MAXN; j += i) d[j] = max(d[j], d[i] + 1); } printf( %d n , ans); return 0; } |
#include <bits/stdc++.h> using namespace std; const int N = 2e5 + 5; struct BIT { int n; vector<int> bit; BIT(int _n = 0) { n = _n; bit.assign(n + 5, 0); } void update(int pos, int val) { for (; pos <= n; pos += pos & -pos) bit[pos] += val; } int getsum(int pos) { int res = 0; for (; pos; pos -= pos & -pos) res += bit[pos]; return res; } }; BIT bit[3]; set<int> pos[3]; int a[N]; int n, q; int fix(char c) { if (c == R ) return 0; if (c == S ) return 1; return 2; } int getans() { int res = 0; for (int x = 0; x < 3; x++) if (pos[x].size()) { int y = (x + 1) % 3; int z = (x + 2) % 3; if (!pos[y].size()) res += n * (!pos[z].size()); else { res += pos[x].size(); if (pos[z].size()) { int l = *pos[y].begin(); int r = *prev(pos[y].end()); int u = *pos[z].begin(); int v = *prev(pos[z].end()); if (r < v) res -= bit[x].getsum(v) - bit[x].getsum(r - 1); if (u < l) res -= bit[x].getsum(l) - bit[x].getsum(u - 1); } } } return res; } int main() { ios_base::sync_with_stdio(0); cin.tie(0); cin >> n >> q; for (int i = 0; i < 3; i++) bit[i] = BIT(n); for (int i = 1; i <= n; i++) { char c; cin >> c; a[i] = fix(c); pos[a[i]].insert(i); bit[a[i]].update(i, 1); } cout << getans() << n ; while (q--) { int i; char c; cin >> i >> c; pos[a[i]].erase(i); bit[a[i]].update(i, -1); a[i] = fix(c); pos[a[i]].insert(i); bit[a[i]].update(i, 1); cout << getans() << n ; } return 0; } |
#include <bits/stdc++.h> using namespace std; struct ss { long long sur, x, y, z; ss() {} ss(long long a, long long b, long long c, long long d) { sur = a; x = b; y = c; z = d; } } ans; int n, tot, a[100], b[100]; long long x, uu, p[100], u[200000]; long long calc(long long a, long long b, long long c) { return a * b + a * c + b * c; } long long getsqr(long long a) { long long b = (long long)sqrt(a) + 1; while (b * b > a) --b; return b; } long long gettri(long long a) { long long b = (long long)pow(a, 1.0 / 3) + 1; while (b * b * b > a) --b; return b; } void dfs(int now, long long lim, long long xx) { if (!now) { u[++tot] = xx; return; } dfs(now - 1, lim, xx); for (int i = 1; i <= a[now]; ++i) { xx *= p[now]; if (xx > lim) break; dfs(now - 1, lim, xx); } } void dfs2(int now, long long lim, long long xx) { if (!now) { if (calc(uu, xx, x / xx / uu) < ans.sur) ans = ss(calc(uu, xx, x / xx / uu), uu, xx, x / xx / uu); return; } dfs2(now - 1, lim, xx); for (int i = 1; i <= a[now]; ++i) { xx *= p[now]; if (xx > lim) break; dfs2(now - 1, lim, xx); } } bool cmp(long long a, long long b) { return a > b; } int main() { int T; cin >> T; for (int test = 1; test <= T; ++test) { cin >> n; x = 1; for (int i = 1; i <= n; ++i) { cin >> p[i] >> a[i]; for (int j = 1; j <= a[i]; ++j) x *= p[i]; } memcpy(b, a, sizeof(a)); tot = 0; dfs(n, gettri(x), 1LL); sort(u + 1, u + tot + 1, cmp); ans = ss(calc(x, 1, 1), x, 1, 1); for (int i = 1; i <= tot; ++i) { long long vw = x / u[i], v = getsqr(vw), w = u[i]; uu = u[i]; if (calc(u[i], v, v) > ans.sur) continue; for (int j = 1; j <= n; ++j) while (w % p[j] == 0) { w /= p[j]; --a[j]; } dfs2(n, getsqr(vw), 1LL); memcpy(a, b, sizeof(b)); } cout << ans.sur * 2 << << ans.x << << ans.y << << ans.z << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; int depth[200005], dad[200005]; int dep = 0; void node_depth(vector<int> vec[], int i) { dep = depth[i] + 1; for (auto j : vec[i - 1]) { if (j != dad[i]) { depth[j] = dep; } } for (auto j : vec[i - 1]) { if (j != dad[i]) { node_depth(vec, j); } } } int entry[200005], exiit[200005]; int timer = 0; void ancestor(vector<int> vec[], int i) { entry[i] = timer; timer++; for (auto j : vec[i - 1]) { if (j != dad[i]) { dad[j] = i; ancestor(vec, j); } } exiit[i] = timer; timer++; } bool isParent(int a, int b) { return (entry[a] <= entry[b] && exiit[a] >= exiit[b]); } signed idiot() { depth[1] = 0; int n, m; cin >> n >> m; vector<int> edge[n]; dad[1] = 1; for (int i = 0; i < n - 1; i++) { int u, v; cin >> u >> v; edge[u - 1].push_back(v); edge[v - 1].push_back(u); } ancestor(edge, 1); node_depth(edge, 1); while (m--) { int k; cin >> k; int temp = 1; vector<int> ve; while (k--) { int vi; cin >> vi; if (depth[vi] > depth[temp]) { temp = vi; } ve.push_back(vi); } bool path = true; for (auto i : ve) { if (!isParent(dad[i], temp)) { path = false; break; } } cout << (path ? YES : NO ) << n ; } return 0; } signed main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); int test_case = 1; while (test_case--) idiot(); return 0; } |
#include <bits/stdc++.h> using namespace std; const int maxn = 2e5 + 7, maxm = 35 * maxn; int nxt[maxm][2], tot, a[maxn]; long long ans = 0; void ins(int x) { int now = 0; for (int i = 29; i >= 0; i--) { int go = (x >> i) & 1; if (nxt[now][go] == 0) nxt[now][go] = ++tot; now = nxt[now][go]; } } long long query(int x) { long long ret = 0; int now = 0; for (int i = 29; i >= 0; i--) { int go = (x >> i) & 1; if (nxt[now][go]) now = nxt[now][go]; else now = nxt[now][go ^ 1], ret |= (1 << i); } return ret; } void dfs(int l, int r, int dep) { if (dep == -1 || l >= r) return; int mid = l - 1; while (mid < r && (a[mid + 1] >> dep & 1) == 0) mid++; dfs(l, mid, dep - 1); dfs(mid + 1, r, dep - 1); if (mid == l - 1 || mid == r) return; for (int i = l; i <= mid; i++) ins(a[i]); long long ret = 1e18; for (int i = mid + 1; i <= r; i++) ret = min(ret, query(a[i])); ans += ret; for (int i = 0; i <= tot; i++) nxt[i][0] = nxt[i][1] = 0; tot = 0; } int n; int main() { scanf( %d , &n); for (int i = 1; i <= n; i++) scanf( %d , &a[i]); sort(a + 1, a + n + 1); dfs(1, n, 29); return 0 * printf( %lld n , ans); } |
#include <bits/stdc++.h> using namespace std; int main() { int a, b = 0; cin >> a; if (a % 2 == 1) { b += 16; } if ((a >> 1) % 2 == 1) { b += 2; } if ((a >> 2) % 2 == 1) { b += 8; } if ((a >> 3) % 2 == 1) { b += 4; } if ((a >> 4) % 2 == 1) { b += 1; } if ((a >> 5) % 2 == 1) { b += 32; } cout << b << endl; } |
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); long long n; cin >> n; vector<long long int> v(n); for (long long int i = 0; i < n; i++) { cin >> v[i]; } sort((v).begin(), (v).end()); set<long long> s; if (n == 1) { cout << -1; } else if (n == 2) { s.insert(v[1] + (v[1] - v[0])); s.insert(v[0] - (v[1] - v[0])); if ((v[1] - v[0]) % 2 == 0) { s.insert(v[0] + (v[1] - v[0]) / 2); } cout << s.size() << n ; for (auto i : s) { cout << i << ; } } else { long long d = INT_MAX; for (long long i = 0; i < n - 1; i++) { d = min(d, v[i + 1] - v[i]); } bool missed = false; bool noap = false; for (long long i = 0; i < n - 1; i++) { if (v[i + 1] == v[i] + d) continue; else { if (v[i + 1] == v[i] + (d * 2)) { if (missed == false) { missed = true; s.insert(v[i] + d); } else { noap = true; break; } } else { noap = true; break; } } } if (noap) { cout << 0; } else if (missed) { cout << 1 << n ; cout << (*s.begin()); } else { s.insert(v[0] - d); s.insert(v[n - 1] + d); cout << s.size() << n ; for (auto i : s) { cout << i << ; } } } } |
#include <bits/stdc++.h> #pragma comment(linker, /STACK:1024000000,1024000000 ) template <class T> bool scanff(T &ret) { char c; int sgn; T bit = 0.1; if (c = getchar(), c == EOF) return 0; while (c != - && c != . && (c < 0 || c > 9 )) c = getchar(); sgn = (c == - ) ? -1 : 1; ret = (c == - ) ? 0 : (c - 0 ); while (c = getchar(), c >= 0 && c <= 9 ) ret = ret * 10 + (c - 0 ); if (c == || c == n ) { ret *= sgn; return 1; } while (c = getchar(), c >= 0 && c <= 9 ) ret += (c - 0 ) * bit, bit /= 10; ret *= sgn; return 1; } using namespace std; long long dp[55][55][55]; int a[55]; int n, sum; double ans; int main() { ans = 0.0; scanff(n); int tot = 0; for (int i = int(1); i <= int(n); i++) scanff(a[i]), tot += a[i]; scanff(sum); if (tot <= sum) { printf( %.10f n , n * 1.0); return 0; } for (int c = int(1); c <= int(n); c++) { memset(dp, 0, sizeof(dp)); dp[0][0][0] = 1; for (int i = int(1); i <= int(n); i++) { for (int j = int(0); j <= int(i - 1); j++) for (int k = int(0); k <= int(sum); k++) { if (dp[i - 1][j][k]) { dp[i][j][k] += dp[i - 1][j][k]; if (i != c && k + a[i] <= sum) dp[i][j + 1][k + a[i]] += dp[i - 1][j][k]; } } } for (int j = int(1); j <= int(n); j++) { for (int k = int(max(0, sum - a[c] + 1)); k <= int(50); k++) { if (dp[n][j][k]) { double temp = dp[n][j][k] * j; int num = n - j; int n1 = n - j, n2 = n; for (int l = int(1); l <= int(num); l++) { temp *= double(n1); temp /= double(n2); n1--; n2--; } temp /= double(n - j); ans += temp; } } } } printf( %.10f n , ans); return 0; } |
#include <bits/stdc++.h> using namespace std; const int M = 200010; int par[M]; int sz[M]; struct edge { int u, v, w; bool operator<(const edge &e) const { return w < e.w; } }; edge E[M]; pair<int, int> q[M]; long long out[M]; int f(int u) { return par[u] = par[u] == u ? u : f(par[u]); } int add(int u, int v) { u = f(u); v = f(v); if (u == v) return 0; par[v] = u; sz[u] += sz[v]; return sz[u]; } long long get(int n) { if (n <= 0) return 0; return ((long long)n * (long long)(n - 1)) / 2; } int main() { ios_base::sync_with_stdio(false); int n, m; cin >> n >> m; for (int i = 0; i < n - 1; i++) { cin >> E[i].u >> E[i].v >> E[i].w; } for (int i = 0; i < m; i++) { cin >> q[i].first; q[i].second = i; } sort(E, E + n - 1); sort(q, q + m); for (int i = 1; i <= n; i++) par[i] = i, sz[i] = 1; long long ans = 0; int j = 0; for (int i = 0; i < m; i++) { while (j < n - 1) { if (E[j].w > q[i].first) break; int u = f(E[j].u), v = f(E[j].v); ans -= (get(sz[u]) + get(sz[v])); ans += get(add(u, v)); j++; } out[q[i].second] = ans; } for (int i = 0; i < m; i++) cout << out[i] << ; cout << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int n; scanf( %d , &n); for (int i = 1, j = n; i <= n / 2; ++i, --j) printf( %d %d , i, j); if (n % 2 == 1) printf( %d , n / 2 + 1); return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int a, b; cin >> a >> b; if (a == b) cout << a << 0 << << b << 1 << endl; else if (a + 1 == b) { cout << a << 9 << << b << 0 << endl; } else if (a == 9 && b == 1) { cout << 9 10 << endl; } else { cout << -1; } return 0; } |
#include <bits/stdc++.h> using namespace std; const int maxn = 100123; const int lgn = 20; long long a[maxn], f[maxn][lgn], ans; vector<int> G[maxn]; void dfs(int u, int p, int x) { int w = a[u] >> x & 1; f[u][w] = 1, f[u][w ^ 1] = 0; for (auto& v : G[u]) { if (v != p) { dfs(v, u, x); ans += (1 << x) * (f[u][1] * f[v][0] + f[u][0] * f[v][1]); f[u][w] += f[v][0]; f[u][w ^ 1] += f[v][1]; } } } int main() { cin.sync_with_stdio(0); cin.tie(0); int n; cin >> n; for (int i = 0; i < (n); ++i) cin >> a[i], ans += a[i]; for (int i = 0; i < (n - 1); ++i) { int u, v; cin >> u >> v; --u, --v; G[u].push_back(v); G[v].push_back(u); } for (int i = 0; i < (lgn); ++i) dfs(0, -1, i); cout << ans << n ; } |
#include <bits/stdc++.h> using namespace std; int ans; char s[100]; int main() { cin >> s; for (int i = 0; i < strlen(s); i++) if (s[i] == a || s[i] == e || s[i] == i || s[i] == o || s[i] == u || s[i] == 1 || s[i] == 3 || s[i] == 5 || s[i] == 7 || s[i] == 9 ) ans++; cout << ans << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { int test, i, k, j, sum1, sum, n, p; cin >> test; for (i = 0; i < test; i++) { cin >> n >> k; sum = 0; sum1 = 0; vector<int> v1, v2; for (j = 0; j < n; j++) { cin >> p; v1.push_back(p); } for (j = 0; j < n; j++) { cin >> p; v2.push_back(p); } sort(v1.begin(), v1.end()); sort(v2.begin(), v2.end()); for (j = 0; j < k; j++) { if (v2[n - j - 1] > v1[j]) sum1 = sum1 + v2[n - j - 1]; else sum1 = sum1 + v1[j]; } for (j = k; j < n; j++) sum = sum + v1[j]; cout << sum + sum1 << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; int n, k; int query(int l, int r) { if (l < 1 || r > n) return false; string re; cout << 1 << << l << << r << endl; cin >> re; return re == TAK ; } int get(int l, int r) { if (l > r) return false; while (l < r) { int mid = (l + r) >> 1; if (query(mid, mid + 1)) r = mid; else l = mid + 1; } return l; } int main() { cin >> n >> k; int x, y; x = get(1, n); y = get(1, x - 1); if (!query(y, x)) y = get(x + 1, n); cout << 2 << << x << << y << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; const double pi = acos(-1.0), eps = 1e-4; double fgcd(double a, double b) { return fabs(a) < eps ? b : (fabs(b) < eps ? a : fgcd(b, fmod(a, b))); } int main() { double a, b, c, d, e, f; cin >> a >> b >> c >> d >> e >> f; c -= a; e -= a; d -= b; f -= b; a = (c * c + d * d) / 2; b = (e * e + f * f) / 2; double ov = 1.0 / (d * e - c * f); double A = (d * b - f * a) * ov, B = (e * a - c * b) * ov; double R = sqrt(A * A + B * B), G1 = asin(sqrt(a * 2) / (R * 2)), G2 = asin(sqrt(b * 2) / (R * 2)), G = asin(hypot(c - e, d - f) / (R * 2)); G = fgcd(G1, fgcd(G2, pi)); G = pi / round(pi / G); A = round(pi / G) * R * R * sin(G * 2) / 2; printf( %.8lf n , A); } |
#include <bits/stdc++.h> using namespace std; struct Q { int l; int r; int num; Q(int _l, int _r, int _num) : l(_l), r(_r), num(_num) {} }; int cnt[100100]; int res[100100]; int main() { ios_base::sync_with_stdio(0); cin.tie(0); int n, m; cin >> n >> m; vector<int> a(n); for (int i = 0; i < n; i++) { cin >> a[i]; } vector<int> comp = a; sort(comp.begin(), comp.end()); comp.resize(unique(comp.begin(), comp.end()) - comp.begin()); for (int i = 0; i < n; i++) { a[i] = lower_bound(comp.begin(), comp.end(), a[i]) - comp.begin(); } int K = sqrt(n); int B = n / K + 1; vector<vector<Q>> blocks(B); for (int i = 0; i < m; i++) { int l, r; cin >> l >> r; l--; r--; blocks[l / K].emplace_back(l, r, i); } for (int b = 0; b < B; b++) { sort(blocks[b].begin(), blocks[b].end(), [&](Q x, Q y) { return x.r < y.r; }); } for (int b = 0; b < B; b++) { if (blocks[b].empty()) continue; memset(cnt, 0, sizeof(cnt)); int ans = 0; for (int i = blocks[b][0].l; i <= blocks[b][0].r; i++) { if (cnt[a[i]] == comp[a[i]]) { ans--; } cnt[a[i]]++; if (cnt[a[i]] == comp[a[i]]) { ans++; } } int pl = blocks[b][0].l; int pr = blocks[b][0].r; res[blocks[b][0].num] = ans; for (int q = 1; q < (int)blocks[b].size(); q++) { for (int i = pr + 1; i <= blocks[b][q].r; i++) { if (cnt[a[i]] == comp[a[i]]) { ans--; } cnt[a[i]]++; if (cnt[a[i]] == comp[a[i]]) { ans++; } } pr = blocks[b][q].r; for (int i = blocks[b][q].l; i < pl; i++) { if (cnt[a[i]] == comp[a[i]]) { ans--; } cnt[a[i]]++; if (cnt[a[i]] == comp[a[i]]) { ans++; } } for (int i = pl; i < blocks[b][q].l; i++) { if (cnt[a[i]] == comp[a[i]]) { ans--; } cnt[a[i]]--; if (cnt[a[i]] == comp[a[i]]) { ans++; } } pl = blocks[b][q].l; res[blocks[b][q].num] = ans; } } for (int i = 0; i < m; i++) { cout << res[i] << n ; } return 0; } |
#include <bits/stdc++.h> using namespace std; const int MAXN = 105000; const int INF = 2100000000; struct target { int mi_n[2], ma_x[2], z, n; }; struct point { int min, n, dot, d[2], fa, l, r; }; int n, m, root, now, txl, txr, tyl, tyr, ans[MAXN] = {0}; target rec[MAXN]; point t[MAXN]; void input_data() { scanf( %d , &n); for (int i = 1; i <= n; i++) { scanf( %d%d%d%d%d , &rec[i].mi_n[0], &rec[i].ma_x[0], &rec[i].mi_n[1], &rec[i].ma_x[1], &rec[i].z); rec[i].n = i; } scanf( %d , &m); for (int i = 1; i <= m; i++) { scanf( %d%d , &t[i].d[0], &t[i].d[1]); t[i].n = i; } } bool cmp_1(point a, point b) { return a.d[now] < b.d[now]; } void gengxin(int father, int son) { if (t[father].min > t[son].min) { t[father].min = t[son].min; t[father].dot = t[son].dot; } } void up_data(int rt) { t[rt].min = t[rt].n; t[rt].dot = rt; if (t[rt].n == 0) { t[rt].min = INF; t[rt].dot = 0; } int l = t[rt].l, r = t[rt].r; if (l) gengxin(rt, l); if (r) gengxin(rt, r); } int build(int begin, int end, int fa, int fx) { int m = (begin + end) >> 1; now = fx; nth_element(t + begin, t + m, t + end + 1, cmp_1); t[m].fa = fa; if (begin < m) t[m].l = build(begin, m - 1, m, 1 - fx); if (m < end) t[m].r = build(m + 1, end, m, 1 - fx); up_data(m); return m; } bool inrange(int x, target b, int fx) { return ((b.mi_n[fx] <= x) && (x <= b.ma_x[fx])); } int query(int rt, int fx, int r, int xl, int xr, int yl, int yr) { if (!rt) return 0; if (!t[rt].dot) return 0; if (txl <= xl && xr <= txr && tyl <= yl && yr <= tyr) return t[rt].dot; int t1 = 0, t2 = 0; if (inrange(t[rt].d[fx], rec[r], fx)) { if (fx == 0) { t1 = query(t[rt].l, 1 - fx, r, xl, t[rt].d[0], yl, yr); t2 = query(t[rt].r, 1 - fx, r, t[rt].d[0], xr, yl, yr); } else { t1 = query(t[rt].l, 1 - fx, r, xl, xr, yl, t[rt].d[1]); t2 = query(t[rt].r, 1 - fx, r, xl, xr, t[rt].d[1], yr); } } else { if (t[rt].d[fx] < rec[r].mi_n[fx]) { if (fx == 0) return query(t[rt].r, 1 - fx, r, t[rt].d[0], xr, yl, yr); else return query(t[rt].r, 1 - fx, r, xl, xr, t[rt].d[1], yr); } if (rec[r].ma_x[fx] < t[rt].d[fx]) { if (fx == 0) return query(t[rt].l, 1 - fx, r, xl, t[rt].d[0], yl, yr); else return query(t[rt].l, 1 - fx, r, xl, xr, yl, t[rt].d[1]); } } int fi = 0; int temp = INF; if (t1 != 0) if (t[t1].n < temp) { temp = t[t1].n; fi = t1; } if (t2 != 0) if (t[t2].n < temp) { temp = t[t2].n; fi = t2; } if (t[rt].n != 0 && t[rt].n < temp) if (inrange(t[rt].d[0], rec[r], 0) && inrange(t[rt].d[1], rec[r], 1)) { temp = t[rt].n; fi = rt; } return fi; } void adjust(int rt) { up_data(rt); if (rt != root) adjust(t[rt].fa); } bool cmp_2(target a, target b) { return a.z < b.z; } void get_ans() { root = build(1, m, 0, 0); sort(rec + 1, rec + 1 + n, cmp_2); for (int i = 1; i <= n; i++) { txl = rec[i].mi_n[0], txr = rec[i].ma_x[0], tyl = rec[i].mi_n[1], tyr = rec[i].ma_x[1]; int hit = query(root, 0, i, 0, INF, 0, INF); if (hit != 0) { ans[t[hit].n] = rec[i].n; t[hit].n = 0; adjust(hit); } } } void output_ans() { for (int i = 1; i <= m; i++) printf( %d n , ans[i]); } int main() { input_data(); get_ans(); output_ans(); return 0; } |
#include <bits/stdc++.h> using namespace std; int n, m, q, ans; map<int, int> boss[100010]; map<pair<int, int>, int> mp; vector<pair<int, int> > vt[100010]; int findf(int x, int col) { if (!boss[col].count(x) || x == boss[col][x]) { boss[col][x] = x; return x; } return boss[col][x] = findf(boss[col][x], col); } void dsu(int x, int y, int col) { x = findf(x, col); y = findf(y, col); if (x != y) { boss[col][y] = x; } return; } int main() { int i, j, a, b, c; cin >> n >> m; for (i = 0; i < m; i++) { cin >> a >> b >> c; a--, b--, c--; dsu(a, b, c); } for (i = 0; i < m; i++) { for (map<int, int>::iterator it = boss[i].begin(); it != boss[i].end(); it++) { a = it->first; b = it->second; vt[a].push_back(make_pair(i, b)); } } for (i = 0; i < n; i++) { for (j = 0; j < vt[i].size(); j++) { vt[i][j].second = findf(i, vt[i][j].first); } } cin >> q; for (i = 0; i < q; i++) { cin >> a >> b; a--, b--; if (vt[a].size() >= vt[b].size()) { swap(a, b); } if (mp.count(make_pair(a, b))) { cout << mp[make_pair(a, b)] << endl; continue; } ans = 0; for (j = 0; j < vt[a].size(); j++) { if (binary_search(vt[b].begin(), vt[b].end(), vt[a][j])) { ans++; } } mp[make_pair(a, b)] = ans; cout << ans << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; using ll = long long; template <typename T> using PQ = priority_queue<T>; template <typename T> using GPQ = priority_queue<T, vector<T>, greater<T>>; template <class L, class R> ostream& operator<<(ostream& os, pair<L, R> p); template <class T> ostream& operator<<(ostream& os, vector<T> v) { os << [ ; for (auto vv : v) os << vv << , ; return os << ] ; } template <class T> ostream& operator<<(ostream& os, set<T> v) { os << [ ; for (auto vv : v) os << vv << , ; return os << ] ; } template <class L, class R> ostream& operator<<(ostream& os, pair<L, R> p) { return os << ( << p.first << , << p.second << ) ; } template <typename T> inline T sq(T a) { return a * a; } template <typename T> T gcd(T a, T b) { if (a > b) return gcd(b, a); return a == 0 ? b : gcd(b % a, a); } template <typename T, typename U> T mypow(T b, U n) { if (n == 0) return 1; if (n == 1) return b; if (n % 2 == 0) { return mypow(b * b, n / 2); } else { return mypow(b, n - 1) * b; } } ll pcnt(ll b) { return __builtin_popcountll(b); } template <typename T> T iceil(T n, T d) { return (n + d - 1) / d; } map<char, int> hand = {{ R , 0}, { S , 1}, { P , 2}}; class BIT { public: explicit BIT(int N, int v) : V_NUM(N) { data.resize(N); fill(data.begin(), data.end(), v); } ll query(int i) { ll ret = 0; while (i > 0) { ret += data[i]; i -= (i & -i); } return ret; } void update(int i, int v) { while (i < V_NUM) { data[i] += v; i += (i & -i); } } int_fast32_t V_NUM; vector<int> data; }; int main() { int N, Q; string S; cin >> N >> Q >> S; S = $ + S; vector<BIT> bit(3, BIT(N + 1, 0)); vector<set<int>> pos(3); for (int i = 1; i <= N; ++i) { bit[hand[S[i]]].update(i, 1); pos[hand[S[i]]].insert(i); } for (int q = 0; q <= Q; ++q) { int lose = 0; int emp = 0; for (int h = 0; h < 3; ++h) { if (pos[h].empty()) ++emp; } if (emp == 1) { for (int h = 0; h < 3; ++h) { if (pos[h].empty() || pos[(h + 1) % 3].empty()) continue; lose = pos[(h + 1) % 3].size(); } } else if (emp == 0) { for (int h = 0; h < 3; ++h) { int w = (h + 1) % 3, l = (h + 2) % 3; int wpos = *(pos[w].begin()), lpos = *(pos[l].begin()); lose += max(0LL, bit[h].query(wpos) - bit[h].query(lpos)); wpos = *(--pos[w].end()), lpos = *(--pos[l].end()); lose += max(0LL, bit[h].query(lpos) - bit[h].query(wpos)); } } cout << N - lose << n ; if (q == Q) break; int p; char c; cin >> p >> c; bit[hand[S[p]]].update(p, -1); pos[hand[S[p]]].erase(p); bit[hand[c]].update(p, 1); pos[hand[c]].insert(p); S[p] = c; } return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { string s; cin >> s; int n = s.length(); vector<vector<int> > pos( z - a + 1); for (int i = 0; i < n; i++) pos[s[i] - a ].push_back(i); int good = 0; for (int c = 0; c <= z - a ; c++) { if (pos[c].empty()) continue; int c_good = 0; for (int k = 0; k < n; k++) { int cnt[ z - a + 1] = {}; for (int i : pos[c]) cnt[s[(i + k) % n] - a ]++; int cur_c_good = 0; for (int d = 0; d <= z - a ; d++) cur_c_good += (cnt[d] == 1); c_good = max(c_good, cur_c_good); } good += c_good; } cout.precision(10); cout << fixed; cout << (double)good / n; return 0; } |
#include <bits/stdc++.h> using namespace std; const int mod = 1e9 + 7; const double PI = acos(-1.0); const int MAXN = 2e5 + 5; long long int freq[MAXN]; long long int pref_sum(int l, int r) { return (l ? freq[r] - freq[l - 1] : freq[r]); } void cp() { int n; long long int k; cin >> n >> k; vector<long long int> arr(n); memset(freq, 0, sizeof(freq)); for (int i = 0; i < n; i++) cin >> arr[i], freq[arr[i]]++; for (int i = 1; i < MAXN; i++) freq[i] += freq[i - 1]; sort(arr.begin(), arr.end()); int need = arr[0]; int ans = 0; long long int cost = 0; for (int i = 2e5; i >= need; i--) { long long int cnt = pref_sum(i + 1, MAXN - 1); long long int total = cost + cnt; if (total > k) { ans++; cost = cnt; } else cost += cnt; } if (cost) { ans++; } cout << ans << n ; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); ; int t; t = 1; while (t--) { cp(); } return 0; } |
#include <bits/stdc++.h> using namespace std; const int MAX = 35005; struct segtree { segtree *left, *right; int start, end, v, m; int lazy; segtree(int start, int end) : start(start), end(end), v(0), lazy(0) { if (start == end) { left = right = NULL; } else { m = (start + end) / 2; left = new segtree(start, m); right = new segtree(m + 1, end); } } void propagate() { if (lazy) { v += lazy; if (left != NULL) left->lazy += lazy; if (right != NULL) right->lazy += lazy; lazy = 0; } } void update(int a, int b, int val) { if (b < a) return; propagate(); if (a == start && b == end) { lazy += val; propagate(); } else { if (b <= m) left->update(a, b, val); else if (a > m) right->update(a, b, val); else left->update(a, m, val), right->update(m + 1, b, val); left->propagate(); right->propagate(); v = max(left->v, right->v); } } int query(int a, int b) { if (b < a) return 1; propagate(); if (a == start && b == end) return v; if (b <= m) return left->query(a, b); if (a > m) return right->query(a, b); return max(left->query(a, m), right->query(m + 1, b)); } }; int dp[MAX][51]; int main() { ios_base::sync_with_stdio(false); cin.tie(0); int n, k; cin >> n >> k; vector<int> v(n + 1); for (int i = 1; i <= n; i++) { cin >> v[i]; } set<int> diff; for (int i = 1; i <= n; i++) { diff.insert(v[i]); dp[i][1] = diff.size(); } for (int i = 2; i <= k; i++) { segtree cur(1, n); for (int j = 1; j <= n; j++) { cur.update(j, j, dp[j][i - 1]); } vector<int> last(n + 1, 1); for (int j = 1; j <= n; j++) { cur.update(last[v[j]], j - 1, 1); dp[j][i] = cur.query(1, j - 1); last[v[j]] = j; } } cout << dp[n][k] << n ; } |
#include <cstdio> #include <cstring> #include <algorithm> #define rep(a,b,c) for(int a=b;a<=c;a++) #define per(a,b,c) for(int a=b;a>=c;a--) #define int long long const int inf=0x3f3f3f3f; template<class T>inline void read(T &x) { T 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();} x*=f; } const int N=1e6+1; struct Node { int i,j,val; }a[N]; int n,du[N],idx; char s[10]; inline bool cmp(Node a,Node b) { return a.val==b.val?a.j<b.j:a.val>b.val; } inline void solve() { read(n); rep(i,1,n) read(du[i]); rep(i,1,n-1) rep(j,i+1,n) { if(du[i]>du[j]) a[++idx].i=i,a[idx].j=j,a[idx].val=du[i]-du[j]; else a[++idx].i=j,a[idx].j=i,a[idx].val=du[j]-du[i]; } std::sort(a+1,a+idx+1,cmp); rep(i,1,idx) { printf( ? %lld %lld n ,a[i].i,a[i].j); fflush(stdout); scanf( %s ,s+1); if(s[1]== Y ) { printf( ! %lld %lld n ,a[i].i,a[i].j); fflush(stdout); return; } } puts( ! 0 0 ); fflush(stdout); } signed main() { //int TEST; read(TEST); while(TEST--) solve(); } |
#include <bits/stdc++.h> using namespace std; int32_t main() { ios_base::sync_with_stdio(false); cin.tie(NULL); long long int t, a, b, diff, n; cin >> t; while (t--) { cin >> a >> b; diff = abs(a - b); n = ceil((-1 + sqrt(1 + 8 * diff)) / 2); if (((n + 1) / 2) % 2 != diff % 2) { if (n % 2) n += 2; else n++; } if (n == -0) n = 0; cout << n << n ; } } |
#include <bits/stdc++.h> using namespace std; int n, Q; string s[100005]; int L[100005], R[100005], K[100005]; long long ans[100005]; vector<int> in[100005], ot[100005], G[100005 << 1]; long long sm[100005]; int last, fa[100005 << 1], tr[100005 << 1][26], len[100005 << 1], tot, f[100005 << 1], sa[100005 << 1], c[100005 << 1], pos[100005]; void ins(int c) { if (tr[last][c]) { int p = last, q; if (len[q = tr[p][c]] != len[p] + 1) { int v = ++tot; memcpy(tr[v], tr[q], sizeof tr[q]), fa[v] = fa[q], len[v] = len[p] + 1; for (; p != -1 && tr[p][c] == q; p = fa[p]) tr[p][c] = v; fa[q] = v; } last = tr[last][c]; return; } int u = ++tot, p = last, q; len[last = u] = len[p] + 1; for (; p != -1 && tr[p][c] == 0; p = fa[p]) tr[p][c] = u; if (p == -1) fa[u] = 0; else if (len[q = tr[p][c]] == len[p] + 1) fa[u] = q; else { int v = ++tot; memcpy(tr[v], tr[q], sizeof tr[q]), fa[v] = fa[q], len[v] = len[p] + 1; for (; p != -1 && tr[p][c] == q; p = fa[p]) tr[p][c] = v; fa[q] = fa[u] = v; } } int st[100005 << 1], ed[100005 << 1], tim, ST[100005 << 1], ED[100005 << 1]; void dfs0(int u) { st[u] = ++tim; for (int v : G[u]) dfs0(v); ed[u] = tim; } int bl[100005], sb[100005 << 1], id[100005 << 1]; int main() { ios::sync_with_stdio(false); cin >> n >> Q; for (int i = (1), LIM = (n); i <= LIM; i++) cin >> s[i]; for (int i = (1), LIM = (Q); i <= LIM; i++) { cin >> L[i] >> R[i] >> K[i]; if (s[K[i]].length() <= 305) ot[R[i]].push_back(i), in[L[i] - 1].push_back(i); else G[K[i]].push_back(i); } for (int i = (1), LIM = (n); i <= LIM; i++) if (!G[i].empty()) { last = 0, fa[0] = -1; for (int j = (0), LIM = (s[i].length() - 1); j <= LIM; j++) ins(s[i][j] - a ), f[last]++; for (int j = (0), LIM = (tot); j <= LIM; j++) c[j] = 0; for (int j = (0), LIM = (tot); j <= LIM; j++) c[len[j]]++; for (int j = (1), LIM = (tot); j <= LIM; j++) c[j] += c[j - 1]; for (int j = (0), LIM = (tot); j <= LIM; j++) sa[--c[len[j]]] = j; for (int j = (tot), LIM = (1); j >= LIM; j--) { int u = sa[j]; f[fa[u]] += f[u]; } for (int j = (1), LIM = (n); j <= LIM; j++) { int u = 0, L = 0; for (int k = (0), LIM = (s[j].length() - 1); k <= LIM; k++) { int v = s[j][k] - a ; for (; u != -1 && !tr[u][v]; u = fa[u]) ; if (u == -1) u = 0, L = 0; else L = min(L + 1, len[u] + 1), u = tr[u][v]; } sm[j] = sm[j - 1] + (L == s[j].length()) * (f[u]); } for (int v : G[i]) ans[v] = sm[R[v]] - sm[L[v] - 1]; G[i].clear(); memset(tr, 0, sizeof(tr[0]) * (tot + 1)); for (int j = (0), LIM = (tot); j <= LIM; j++) f[j] = 0; tot = 0; } last = 0; fa[0] = -1; for (int i = (1), LIM = (n); i <= LIM; i++) { last = 0; for (int j = (0), LIM = (s[i].length() - 1); j <= LIM; j++) ins(s[i][j] - a ); pos[i] = last; } for (int i = (1), LIM = (tot); i <= LIM; i++) G[fa[i]].push_back(i); dfs0(0); for (int i = (1), LIM = (tim); i <= LIM; i++) id[i] = i / 305, ST[id[i]] = ST[id[i]] ? ST[id[i]] : i, ED[id[i]] = i; ; for (int i = (1), LIM = (n); i <= LIM; i++) { int u = st[pos[i]], v = ed[pos[i]]; for (int j = (id[u] + 1), LIM = (id[v] - 1); j <= LIM; j++) bl[j]++; if (id[u] == id[v]) { for (int j = (u), LIM = (v); j <= LIM; j++) sb[j]++; } else { for (int j = (u), LIM = (ED[id[u]]); j <= LIM; j++) sb[j]++; for (int j = (ST[id[v]]), LIM = (v); j <= LIM; j++) sb[j]++; } for (int p : in[i]) { int u = 0, t = K[p]; for (int j = (0), LIM = (s[t].length() - 1); j <= LIM; j++) { v = s[t][j] - a ; for (; u != -1 && !tr[u][v]; u = fa[u]) ; if (u == -1) u = 0; else u = tr[u][v]; ans[p] -= sb[st[u]] + bl[id[st[u]]]; } } for (int p : ot[i]) { int u = 0, t = K[p]; for (int j = (0), LIM = (s[t].length() - 1); j <= LIM; j++) { v = s[t][j] - a ; for (; u != -1 && !tr[u][v]; u = fa[u]) ; if (u == -1) u = 0; else u = tr[u][v]; ans[p] += sb[st[u]] + bl[id[st[u]]]; } } } for (int i = (1), LIM = (Q); i <= LIM; i++) printf( %lld n , ans[i]); } |
#include <bits/stdc++.h> template <typename T, typename U> static inline void amin(T &x, U y) { if (y < x) x = y; } template <typename T, typename U> static inline void amax(T &x, U y) { if (x < y) x = y; } using namespace std; const int N = 2e5 + 5; int par[N], r[N]; int find(int a) { if (par[a] < 0) return a; else return (par[a] = find(par[a])); } void merge(int a, int b) { a = find(a); b = find(b); if (a == b) return; if (r[a] > r[b]) { par[b] = a; r[a] += r[b]; } else { par[a] = b; r[b] += r[a]; } } void solve() { int n, m, i, j; cin >> n >> m; for (i = 1; i < n + 1; i++) par[i] = -1, r[i] = 1; for (i = 0; i < m; i++) { int a, b; cin >> a >> b; merge(a, b); } long long int ans = 1; for (i = 1; i < n + 1; i++) { if (r[i] > 1 && par[i] < 0) ans = ans * pow(2, r[i] - 1); } cout << ans; } int main() { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); int t = 1; while (t--) { solve(); } return 0; } |
#include <bits/stdc++.h> struct Solution { int n, k; std::vector<std::vector<int>> as; std::vector<int> pows; int64_t calcPair(int ind1, int ind2) { std::vector<int> left; left.reserve(as[ind1].size()); for (int v : as[ind1]) { left.push_back((int64_t(k - v) * pows[ind2 + 1]) % k); } std::sort(left.begin(), left.end()); int64_t result = 0; size_t i1 = 0; size_t j1 = 0; std::vector<int>& right = as[ind2]; while (i1 < left.size() && j1 < right.size()) { if (left[i1] < right[j1]) { i1++; continue; } if (left[i1] > right[j1]) { j1++; continue; } size_t i2 = i1; while (i2 < left.size() && left[i2] == left[i1]) i2++; size_t j2 = j1; while (j2 < right.size() && right[j2] == right[j1]) j2++; result += (i2 - i1) * int64_t(j2 - j1); i1 = i2; j1 = j2; } if (ind1 == ind2) { for (int v : right) { if ((v + int64_t(v) * pows[ind2 + 1]) % k == 0) { result--; } } } return result; } void run(std::istream& in, std::ostream& out) { in >> n >> k; as.assign(10, std::vector<int>()); pows.resize(11); pows[0] = 1; for (int i = 1; i <= 10; i++) { pows[i] = (pows[i - 1] * int64_t(10)) % k; } for (int i = 0; i < n; i++) { int a; in >> a; int aa = a % k; int len = 1; while (a >= 10) { a /= 10; len++; } as[len - 1].push_back(aa); } for (size_t i = 0; i < as.size(); i++) { std::sort(as[i].begin(), as[i].end()); } int64_t ans = 0; for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { ans += calcPair(i, j); } } out << ans << n ; } }; int main() { std::cin.sync_with_stdio(false); std::cin.tie(nullptr); Solution().run(std::cin, std::cout); return 0; } |
#include <bits/stdc++.h> using namespace std; int pai[1000010]; int find(int x) { if (pai[x] == x) return x; return pai[x] = find(pai[x]); } void join(int a, int b) { pai[find(a)] = find(b); } int main() { int n, m, q; cin >> n >> m >> q; for (int i = 1; i <= n + m; i++) pai[i] = i; for (int i = 0; i < q; i++) { int a, b; cin >> a >> b; b += n; join(a, b); } int comps = 0; for (int i = 1; i <= n + m; i++) comps += pai[i] == i; cout << comps - 1 << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; void solve() { long long n; long long k; cin >> n; cin >> k; vector<long long> d(n); vector<long long> afterd(n); for (long long i = 0; i < n; i++) cin >> d[i]; for (long long i = 0; i < n; i++) cin >> afterd[i]; vector<pair<long long, long long> > utility(n); for (long long i = 0; i < n; i++) { utility[i].first = d[i] - afterd[i]; utility[i].second = i; } sort(utility.begin(), utility.end()); set<long long> u2; long long p = 0; while (k > 0 || utility[p].first < 0) { u2.insert(utility[p].second); p += 1; k -= 1; } long long cost = 0; for (long long i = 0; i < n; i++) { if (u2.find(i) != u2.end()) cost += d[i]; else cost += afterd[i]; } cout << cost; } int32_t main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); solve(); return 0; } |
#include <bits/stdc++.h> using namespace std; const int N = 10005; const int P = 998244353; struct edge { int u, v, len; inline edge() {} inline edge(int _u, int _v, int _len) { u = _u; v = _v; len = _len; } } a[N], Q[N], res[N]; struct node { int l, r; vector<int> E; node *lson, *rson; } pool[3 * N], *root; int n, m; int OscarDaGumert; int top = -1; int Index, cnt; bitset<N> cur; bitset<N> ans; void B_T(node *now, int l, int r) { now->l = l; now->r = r; if (l == r) return; int lr = (l + r) >> 1, rl = lr + 1; now->lson = &pool[++top]; B_T(now->lson, l, lr); now->rson = &pool[++top]; B_T(now->rson, rl, r); } void change(node *now, int l, int r, int id) { if (now->l == l && now->r == r) { now->E.push_back(a[id].len); return; } int lr = (now->l + now->r) >> 1, rl = lr + 1; if (r < rl) change(now->lson, l, r, id); else if (l > lr) change(now->rson, l, r, id); else { change(now->lson, l, lr, id); change(now->rson, rl, r, id); } } inline void query(node *now) { bitset<N> tmp = cur; int len = now->E.size(); for (int i = 0; i < len; i++) { cur |= (cur << now->E[i]); } ans |= cur; if (now->l != now->r) { query(now->lson); query(now->rson); } cur = tmp; } void init() { int x1, x2, x3; scanf( %d%d , &n, &m); for (int i = 1; i <= m; i++) { scanf( %d%d%d , &x1, &x2, &x3); a[i] = edge(x1, x2, x3); } root = &pool[++top]; B_T(root, 1, n); for (int i = 1; i <= m; i++) change(root, a[i].u, a[i].v, i); cur[0] = 1; query(root); int cnt = 0; for (int i = 1; i <= n; i++) { if (ans[i] == 1) { cnt++; } } printf( %d n , cnt); for (int i = 1; i <= n; i++) { if (ans[i] == 1) { printf( %d , i); } } } int main(int argc, char **argv) { init(); return 0; } |
#include <bits/stdc++.h> using namespace std; const long long MOD = 1e9 + 9; const long long INF = 1e18; const int MAXN = 1e6 + 10; const int MAXM = 1e4 + 500; const int N = 2000 + 15; const double EPS = 1e-9; int dx[] = {1, 0, 0, -1}; int dy[] = {0, 1, -1, 0}; double len(complex<long long> a) { return sqrt(a.real() * a.real() + a.imag() * a.imag()); } long long sq(complex<long long> a) { return a.real() * a.real() + a.imag() * a.imag(); } complex<long long> perp(complex<long long> p) { return {-p.imag(), p.real()}; } long long dotProduct(complex<long long> a, complex<long long> b) { return (conj(a) * b).real(); } long long crossProduct(complex<long long> a, complex<long long> b) { return (conj(a) * b).imag(); } long long orient(complex<long long> a, complex<long long> b, complex<long long> c) { return crossProduct(b - a, c - a); } bool inDisk(complex<long long> a, complex<long long> b, complex<long long> p) { return dotProduct(a - p, b - p) <= 0; } bool onSegment(complex<long long> a, complex<long long> b, complex<long long> p) { return orient(a, b, p) == 0 && inDisk(a, b, p); }; struct cmpX { bool operator()(complex<long long> a, complex<long long> b) { return make_pair(a.real(), a.imag()) < make_pair(b.real(), b.imag()); } }; struct line { complex<long long> v; long long c; line(complex<long long> v, long long c) : v(v), c(c) {} line(long long a, long long b, long long c) : v({b, -a}), c(c) {} line(complex<long long> p, complex<long long> q) : v(q - p), c(crossProduct(v, p)) {} long long side(complex<long long> p) { return crossProduct(v, p) - c; } double dist(complex<long long> p) { return abs(side(p)) / len(v); } line perpThrough(complex<long long> p) { return {p, p + perp(v)}; } bool cmpProj(complex<long long> p, complex<long long> q) { return dotProduct(v, p) < dotProduct(v, q); } line translate(complex<long long> t) { return {v, c + crossProduct(v, t)}; } complex<long long> proj(complex<long long> p) { return p - perp(v) * side(p) / sq(v); } }; double segPoint(complex<long long> a, complex<long long> b, complex<long long> p) { if (a != b) { line l(a, b); if (l.cmpProj(a, p) && l.cmpProj(p, b)) return l.dist(p); } return min(abs(p - a), abs(p - b)); } bool inAngle(complex<long long> a, complex<long long> b, complex<long long> c, complex<long long> p) { if (orient(a, b, c) < 0) swap(b, c); return orient(a, b, p) >= 0 && orient(a, c, p) <= 0; } bool isInsidePol(vector<complex<long long> > &a, complex<long long> b) { int n = a.size(); int pos = 0, neg = 0; for (int i = 0; i < n - 1; i++) { if (onSegment(a[i], a[(i + 1) % n], b)) return false; line l(a[i], a[i + 1]); if (l.side(b) > 0) pos++; else neg++; } line l(a[n - 1], a[0]); if (l.side(b) > 0) pos++; else neg++; return ((!pos && neg == n) || (!neg && pos == n)); } long long i, j, k; long long n, m, t; int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); string w; cin >> w; stack<int> kek; kek.push(0); for (auto e : w) { e == kek.top() ? kek.pop() : kek.push(e); } cout << (kek.top() ? No : Yes ); return 0; } |
#include <bits/stdc++.h> using namespace std; int n, k; int p[55]; string t; void getp() { int j = 0; p[0] = p[1] = 0; for (int i = 1; i < t.length(); ++i) { while (j && t[j] != t[i]) j = p[j]; if (t[j] == t[i]) j++; p[i + 1] = j; } } void build() { getp(); string ans = t; int cnt = 1; while (cnt < k) { for (int i = p[t.length()]; i < t.length(); ++i) ans.append(1, t[i]); cnt++; } cout << ans; } int main() { cin >> n >> k >> t; build(); return 0; } |
#include <bits/stdc++.h> using namespace std; int n, u, r; vector<long long> k; vector<int> a, b, p, tmp; vector<vector<int> > v; vector<int> w; void read(); int main() { ios_base::sync_with_stdio(false); read(); v.push_back(a); w.push_back(1); long long s = 0; if (u & 1) s = -1e15; else { for (int i = 0; i < n; ++i) s += (a[i] * k[i]); } int uu = (u < 29 ? u : u - 2); for (int i = 0; i < uu; ++i) { int lim = v.size(); for (int j = 0; j < lim; ++j) { if (w[j]) { v.push_back(v[j]); w.push_back(0); for (int h = 0; h < n; ++h) v.back()[h] ^= b[h]; for (int h = 0; h < n; ++h) tmp[h] = v[j][p[h]] + r; swap(v[j], tmp); } else { w[j] = 1; for (int h = 0; h < n; ++h) tmp[h] = v[j][p[h]] + r; swap(v[j], tmp); } } if ((u - i) & 1) { for (int i = 0; i < v.size(); ++i) { long long ss = 0; for (int j = 0; j < n; ++j) ss += (v[i][j] * k[j]); s = max(s, ss); } } } if (uu < u) { for (int i = 0; i < v.size(); ++i) { long long ss = 0; for (int j = 0; j < n; ++j) tmp[j] = (v[i][p[j]] ^ b[p[j]]) + r; for (int j = 0; j < n; ++j) ss += (tmp[j] * k[j]); s = max(s, ss); ss = 0; for (int j = 0; j < n; ++j) tmp[j] = ((v[i][p[j]] + r) ^ b[j]); for (int j = 0; j < n; ++j) ss += (tmp[j] * k[j]); s = max(s, ss); ss = 0; for (int j = 0; j < n; ++j) tmp[j] = v[i][p[p[j]]] + r + r; for (int j = 0; j < n; ++j) ss += (tmp[j] * k[j]); s = max(s, ss); } } cout << s << endl; return 0; } void read() { cin >> n >> u >> r; a.resize(n); b.resize(n); k.resize(n); p.resize(n); tmp.resize(n); for (int i = 0; i < n; ++i) cin >> a[i]; for (int i = 0; i < n; ++i) cin >> b[i]; for (int i = 0; i < n; ++i) cin >> k[i]; for (int i = 0; i < n; ++i) cin >> p[i], --p[i]; } |
#include <bits/stdc++.h> using namespace std; const int maxN = 2005; int d[maxN][maxN], c[maxN][maxN], D[maxN], C[maxN], dx[maxN][maxN], cx[maxN][maxN]; int main() { ios::sync_with_stdio(0); cin.tie(0); int n, k; cin >> n >> k; char cur; for (int i = 1; i <= n; ++i) for (int j = 1; j <= n; ++j) { cin >> cur; d[i][j] = d[i][j - 1] + (cur == W ); c[i][j] = c[i - 1][j] + (cur == W ); } for (int i = 1; i <= n; ++i) { D[i] = D[i - 1] + (d[i][n] == n); C[i] = C[i - 1] + (c[n][i] == n); } for (int i = 1; i <= n; ++i) for (int j = k; j <= n; ++j) dx[i][j] = dx[i - 1][j] + (d[i][n] - d[i][j] + d[i][j - k] == n - k); for (int i = k; i <= n; ++i) for (int j = 1; j <= n; ++j) cx[i][j] = cx[i][j - 1] + (c[n][j] - c[i][j] + c[i - k][j] == n - k); int ans = 0; for (int i = k; i <= n; ++i) for (int j = k; j <= n; ++j) ans = max(ans, D[n] - D[i] + D[i - k] + dx[i][j] - dx[i - k][j] + C[n] - C[j] + C[j - k] + cx[i][j] - cx[i][j - k]); cout << ans; return 0; } |
#include <bits/stdc++.h> using namespace std; int n, a[500010], x, sz; long long ans; int main() { scanf( %d , &n); for (int step = 1; step <= n; step++) { scanf( %d , &x); while (a[sz - 1] > a[sz] && a[sz] <= x && sz >= 2) { ans += min(a[sz - 1], x); sz--; } a[++sz] = x; } sort(a + 1, a + sz + 1); for (int i = 1; i <= sz - 2; i++) ans += a[i]; printf( %I64d , ans); } |
#include <bits/stdc++.h> using namespace std; int n; vector<int> v; vector<int> ans_lis; int main() { ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr); cin >> n; for (int i = 1; i <= n; i++) { int x; cin >> x; v.emplace_back(x); } sort(v.begin(), v.end()); for (int i = (int)v.size() - 1; i >= 0; i--) { if (i % 2 == 0) { ans_lis.insert(ans_lis.begin(), v[i]); } else ans_lis.emplace_back(v[i]); } bool flag = true; if (ans_lis[0] >= ans_lis.back() + ans_lis[1]) flag = false; if (ans_lis.back() >= ans_lis[0] + ans_lis[(int)ans_lis.size() - 2]) flag = false; for (int i = 1; i + 1 < (int)ans_lis.size() && flag; i++) { if (ans_lis[i] >= ans_lis[i + 1] + ans_lis[i - 1]) flag = false; } if (!flag) cout << NO << endl; else { cout << YES << endl; for (int i = 0; i < (int)ans_lis.size(); i++) cout << ans_lis[i] << ; cout << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; const int N = 100010; const int M = 4; int now[2], dila[2]; int vis[N][4], n, m, cnt, ans_cnt; char s[4]; long long ans; int main() { int i, j, k, *p; bool lose = false; scanf( %d%d%d%d%s , &n, &m, &now[0], &now[1], s); if (s[0] == U ) dila[0] = -1; else dila[0] = 1; if (s[1] == L ) dila[1] = -1; else dila[1] = 1; if (now[0] == 1) vis[now[1]][0]++, cnt++; if (now[0] == n) vis[now[1]][2]++, cnt++; if (now[1] == 1) vis[now[0]][1]++, cnt++; if (now[1] == m) vis[now[0]][3]++, cnt++; ans_cnt += (m - (((now[1] - now[0] + 1) % 2 - 2) % 2 + 2)) / 2 + 1; ans_cnt += (n - (((now[0] - now[1] + 1) % 2 - 2) % 2 + 2)) / 2 + 1; ans_cnt += (m - (((now[1] + (n - now[0])) % 2 - 2) % 2 + 2)) / 2 + 1; ans_cnt += (n - (((now[0] + (m - now[1])) % 2 - 2) % 2 + 2)) / 2 + 1; ans++; while (cnt < ans_cnt && !lose) { k = 0x7fffffff; if (dila[0] == 1) k = min(k, n - now[0]); else k = min(k, now[0] - 1); if (dila[1] == 1) k = min(k, m - now[1]); else k = min(k, now[1] - 1); ans += k; now[0] += dila[0] * k; now[1] += dila[1] * k; if (now[0] == 1) { p = &vis[now[1]][0]; (*p)++; if (*p == 1) cnt++; if (*p > M) lose = true; if (dila[0] == -1) dila[0] = -dila[0]; } if (now[0] == n) { p = &vis[now[1]][2]; (*p)++; if (*p == 1) cnt++; if (*p > M) lose = true; if (dila[0] == 1) dila[0] = -dila[0]; } if (now[1] == 1) { p = &vis[now[0]][1]; (*p)++; if (*p == 1) cnt++; if (*p > M) lose = true; if (dila[1] == -1) dila[1] = -dila[1]; } if (now[1] == m) { p = &vis[now[0]][3]; (*p)++; if (*p == 1) cnt++; if (*p > M) lose = true; if (dila[1] == 1) dila[1] = -dila[1]; } } if (lose) puts( -1 ); else cout << ans << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; const int N = 2e5 + 5; long long mx, mi; int t, head[N], len, k, vis[N]; struct edge { int v, w, next; } e[N * 2]; void add(int u, int v, int w) { e[len].v = v; e[len].w = w; e[len].next = head[u]; head[u] = len++; } void dfs(int u, int fa) { vis[u] = 1; for (int j = head[u]; j; j = e[j].next) { int v = e[j].v; int w = e[j].w; if (v == fa) continue; dfs(v, u); if (vis[v] & 1) { mi += w; } mx += (long long)min(k - vis[v], vis[v]) * w; vis[u] += vis[v]; } } int main() { scanf( %d , &t); while (t--) { scanf( %d , &k); int u, v, w; k <<= 1; len = 1; memset(head, 0, sizeof(head)); memset(vis, 0, sizeof(vis)); for (int i = 1; i < k; i++) { scanf( %d%d%d , &u, &v, &w); add(u, v, w); add(v, u, w); } mi = 0, mx = 0; dfs(1, 0); printf( %lld %lld n , mi, mx); } return 0; } |
#include <bits/stdc++.h> using namespace std; int n, cnt = 0; long long sum = 0; bool flag = false; struct Node { int num; int pos; } a[200005]; bool cmp(const Node &a, const Node &b) { return a.num < b.num; } vector<int> v; int main() { cin >> n; for (int i = 1; i <= n; i++) { cin >> a[i].num; a[i].pos = i; sum += a[i].num; } sort(a + 1, a + n + 1, cmp); for (int i = 1; i <= n - 1; i++) { if (sum - a[i].num == 2 * a[n].num) { cnt++; v.push_back(a[i].pos); } } if (sum - a[n].num == 2 * a[n - 1].num) { v.push_back(a[n].pos); cnt++; } if (cnt == 0) { cout << 0 << endl; return 0; } cout << cnt << endl; for (int i = 0; i < v.size(); i++) { cout << v[i] << ; } return 0; } |
#include <bits/stdc++.h> using namespace std; string itosm(long long x) { if (x == 0) return 0 ; string ans = ; while (x > 0) { ans += ((x % 10) + 0 ); x /= 10; } reverse(ans.begin(), ans.end()); return ans; } long long stoim(string str) { long long ans = 0; long long k = 1; for (int i = str.length() - 1; i >= 0; i--) { ans += (str[i] - 0 ) * k; k *= 10; } return ans; } const long long infll = 1e18 + 3; const int inf = 1009000999; const double eps = 1e-6; const int maxn = 1e6 + 77; const int baseint = 1000200013; const long long basell = 1e18 + 3; const long double PI = acos(-1.0); int main() { srand(228228); ios_base::sync_with_stdio(0); ; string t, s, p = ; cin >> t >> s; int n = s.length(); while (p.length() != n) p += 0 ; int cnt = 0; for (int i = (0); i < (n); i++) { if (s[i] == t[i]) p[i] = s[i]; else cnt++; } if (cnt % 2) { cout << impossible ; return 0; } cnt = 0; for (int i = (0); i < (n); i++) { if (s[i] != t[i]) { if (cnt <= 0) { p[i] = s[i]; cnt++; } else { p[i] = t[i]; cnt--; } } } cout << p; return 0; } |
#include <bits/stdc++.h> using namespace std; string s; string name, host, sour; int main() { ios::sync_with_stdio(false); cin >> s; int i = 0; while (i < s.size() && s[i] != @ ) { name.push_back(s[i]); i++; } i++; while (i < s.size() && s[i] != / ) { host.push_back(s[i]); i++; } bool exist = 0; if (s[i] == / ) exist = 1; i++; if (i != s.size() + 1) while (i < s.size()) { sour.push_back(s[i]); i++; } if (sour.size() > 16 || name.size() == 0 || name.size() > 16 || host.size() > 32 || host.size() == 0) { cout << NO n ; return 0; } if (exist && sour.size() == 0) { cout << NO n ; return 0; } for (int j = 0; j < name.size(); j++) { char c = name[j]; if (!isdigit(c) && !isalpha(c) && (c != < && c != > && c != _ )) { cout << NO n ; return 0; } } int cnt = 0; for (int j = 0; j < host.size(); j++) { char c = host[j]; if (!isdigit(c) && !isalpha(c) && (c != < && c != > && c != . && c != _ )) { cout << NO n ; return 0; } if (c == . ) { if (cnt == 0) { cout << NO n ; return 0; } cnt = -1; } cnt++; if (cnt > 16) { cout << NO n ; return 0; } } if (cnt == 0) { cout << NO n ; return 0; } for (int j = 0; j < sour.size(); j++) { char c = sour[j]; if (!isalpha(c) && !isdigit(c) && (c != < && c != > && c != _ )) { cout << NO n ; return 0; } } cout << YES n ; return 0; } |
#include <bits/stdc++.h> using namespace std; int min(int a, int b) { if (a < b) return a; else return b; } int main() { int n, len, a[100010], f[100010], dai, max = 0, vitri = 0; char s[100010]; char si[13][13]; bool kt; scanf( %s , s); len = strlen(s); for (int i = 0; i < len; i++) f[i] = 0; scanf( %d , &n); for (int i = 1; i <= n; i++) scanf( %s , si[i]); for (int i = 0; i < len; i++) { dai = 100; for (int j = 1; j <= n; j++) { kt = true; for (int k = 0; k < strlen(si[j]); k++) if (si[j][k] != s[i + k]) { kt = false; break; } if (kt && strlen(si[j]) < dai) dai = strlen(si[j]); } a[i] = dai; } f[len] = 0; for (int i = len - 1; i >= 0; i--) { if (a[i] != 100) f[i] = min(f[i + 1] + 1, a[i] - 1); else f[i] = f[i + 1] + 1; if (f[i] > max) { max = f[i]; vitri = i; } } printf( %d %d , max, vitri); } |
#include <bits/stdc++.h> using namespace std; template <class T> void chmax(T &x, T y) { x = x > y ? x : y; } template <class T> void chmin(T &x, T y) { x = x < y ? x : y; } const int maxn = 205; int n, k; int d[maxn], ans[maxn], choice[maxn]; int dp[maxn][maxn]; int dist[maxn][maxn]; vector<int> v[maxn]; void predfs(int pos, int fa, int *dis) { for (int i = 0; i < (int)(v[pos]).size(); i++) { int to = v[pos][i]; if (to == fa) continue; dis[to] = dis[pos] + 1; predfs(to, pos, dis); } } void dfs(int pos, int fa) { for (int i = 1; i <= n; i++) dp[pos][i] = d[dist[pos][i]] + k; for (int i = 0; i < (int)(v[pos]).size(); i++) { int to = v[pos][i]; if (to == fa) continue; dfs(to, pos); for (int j = 1; j <= n; j++) dp[pos][j] += min(dp[to][choice[to]], dp[to][j] - k); } choice[pos] = min_element(dp[pos] + 1, dp[pos] + n + 1) - dp[pos]; return; } void print(int pos, int fa, int j) { for (int i = 0, _j; i < (int)(v[pos]).size(); i++) { int to = v[pos][i]; if (to == fa) continue; if (dp[to][choice[to]] < dp[to][j] - k) { _j = choice[to]; } else { _j = j; } ans[to] = _j; print(to, pos, _j); } } int main() { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); cin >> n >> k; for (int i = 1; i <= n - 1; i++) cin >> d[i]; for (int i = 1; i <= n - 1; i++) { int x, y; cin >> x >> y; v[x].push_back(y); v[y].push_back(x); } for (int i = 1; i <= n; i++) predfs(i, 0, dist[i]); dfs(1, 0); cout << dp[1][choice[1]] << endl; print(1, 0, choice[1]); ans[1] = choice[1]; for (int i = 1; i <= n; i++) cout << ans[i] << ; cout << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; int n, x, y; int a, b; int diff; void ask(int mask) { int sz = 0; for (int i = 0; i < n; ++i) { if ((i & mask) > 0) { ++sz; } } if (sz == 0) { return; } printf( ? %d , sz); for (int i = 0; i < n; ++i) { if ((i & mask) > 0) { printf( %d , i + 1); } } printf( n ); fflush(stdout); int ans = 0; scanf( %d , &ans); if (ans != 0 && ans != x) { diff += mask; } } vector<int> v; bool f(int sr) { printf( ? %d , sr + 1); for (int i = 0; i <= sr; ++i) { printf( %d , v[i] + 1); } printf( n ); fflush(stdout); int ans; scanf( %d , &ans); if (ans != 0 && ans != x) { return true; } return false; } void input() { scanf( %d%d%d , &n, &x, &y); } void solve() { for (int i = 0; i < 10; ++i) { ask((1 << i)); } for (int i = 0; i < n; ++i) { if ((i ^ diff) < i) { v.push_back(i); } } int l, r, mid; l = 0; r = v.size() - 1; while (l != r) { int mid = (l + r) / 2; if (f(mid) == true) { r = mid; } else { l = mid + 1; } } printf( ! %d %d n , (v[l] ^ diff) + 1, v[l] + 1); fflush(stdout); } int main() { ios_base ::sync_with_stdio(false); cin.tie(NULL); input(); solve(); return 0; } |
#include <bits/stdc++.h> using namespace std; const int inf = ~0U >> 1; const long long INF = (long long)1e18; const double pi = acos(-1.0); template <class T> inline T sqr(T a) { return a * a; } template <class T> inline T min(T a, T b, T c) { return min(min(a, b), c); } template <class T> inline T max(T a, T b, T c) { return max(max(a, b), c); } template <class T> inline void read(T &n) { char c; for (c = getchar(); !(c >= 0 && c <= 9 ); c = getchar()) ; n = c - 0 ; for (c = getchar(); c >= 0 && c <= 9 ; c = getchar()) n = n * 10 + c - 0 ; } int pw(int base, int n, int mo) { if (n == 0) return 1; if (n == 1) return base; int tmp = pw(base, n >> 1, mo); tmp = (long long)tmp * tmp % mo; if (n & 1) tmp = (long long)tmp * base % mo; return tmp; } const int maxn = 200000; int N, M, x, y, p[maxn], c[maxn], f[maxn], s[maxn]; long long ans; bool cmp(const int &a, const int &b) { return c[a] > c[b]; } vector<int> E[maxn]; int find(int x) { if (f[x] == x) return x; int t = find(f[x]); s[x] += s[f[x]]; return f[x] = t; } int main() { scanf( %d%d , &N, &M); for (int i = (1); i <= (N); ++i) scanf( %d , &c[i]); for (int i = (1); i <= (M); ++i) { scanf( %d%d , &x, &y); if (c[x] < c[y]) E[x].push_back(y); else E[y].push_back(x); } for (int i = (1); i <= (N); ++i) p[i] = i; sort(p + 1, p + N + 1, cmp); for (int i = (1); i <= (N); ++i) f[i] = i, s[i] = 1; for (int i = (1); i <= (N); ++i) { int S = p[i]; for (int j = 0; j < E[S].size(); ++j) { int x = find(S), y = find(E[S][j]); if (x != y) { ans += (long long)c[S] * s[x] * s[y]; f[x] = y; s[y] += s[x]; } } } double ret = ans * 2. / N / (N - 1); printf( %.10lf n , ret); return 0; } |
#include <bits/stdc++.h> using namespace std; int x, y; long long s; int main() { cin >> x >> y >> s; if (abs(x) + abs(y) <= s && (s - (abs(x) + abs(y))) % 2 == 0) cout << Yes ; else cout << No ; return 0; } |
#include <bits/stdc++.h> using namespace std; int t, n; string str; int main() { cin >> t; while (t--) { cin >> n >> str; int x = n, res = n; for (int i = 0; i < n; i++) if (str[i] == 1 ) { res = max(res, max(n + 1, 2 * max(i + 1, n - i))); } cout << res << endl; } return 0; } |
#include <bits/stdc++.h> using namespace std; int n, m; string grid[105]; int check_bomb(int i, int j) { if ((i > 0 && grid[i - 1][j] == * ) || (i < n - 1 && grid[i + 1][j] == * ) || (j > 0 && grid[i][j - 1] == * ) || (j < m - 1 && grid[i][j + 1] == * ) || (i > 0 && j > 0 && grid[i - 1][j - 1] == * ) || (i > 0 && j < m - 1 && grid[i - 1][j + 1] == * ) || (i < n - 1 && j > 0 && grid[i + 1][j - 1] == * ) || (i < n - 1 && j < m - 1 && grid[i + 1][j + 1] == * )) { printf( NO ); return 1; } return 0; } int count_bomb(int i, int j) { int k = grid[i][j] - 48; int cnt = 0; if (i > 0 && grid[i - 1][j] == * ) cnt++; if (i < n - 1 && grid[i + 1][j] == * ) cnt++; if (j > 0 && grid[i][j - 1] == * ) cnt++; if (j < m - 1 && grid[i][j + 1] == * ) cnt++; if (i > 0 && j > 0 && grid[i - 1][j - 1] == * ) cnt++; if (i > 0 && j < m - 1 && grid[i - 1][j + 1] == * ) cnt++; if (i < n - 1 && j > 0 && grid[i + 1][j - 1] == * ) cnt++; if (i < n - 1 && j < m - 1 && grid[i + 1][j + 1] == * ) cnt++; if (cnt != k) { printf( NO ); return 1; } return 0; } int main() { scanf( %d %d , &n, &m); for (int i = 0; i < n; i++) { cin >> grid[i]; } for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if (grid[i][j] == . ) { int check = check_bomb(i, j); if (check == 1) return 0; } else if (grid[i][j] >= 1 && grid[i][j] <= 9 ) { int bomb = count_bomb(i, j); if (bomb == 1) return 0; } } } printf( YES ); return 0; } |
#include <bits/stdc++.h> using namespace std; int n; long long a, b, T; char s[500010]; long long pref[500010]; long long suff[500010]; int main() { cin >> n >> a >> b >> T; for (int i = 1; i <= n; ++i) { cin >> s[i]; } pref[1] = 0; for (int i = 2; i <= n; ++i) { pref[i] = a + pref[i - 1] + 1; if (s[i] == w ) { pref[i] += b; } } suff[n + 1] = 0; for (int i = n; i >= 2; --i) { suff[i] = a + 1 + suff[i + 1]; if (s[i] == w ) { suff[i] += b; } } int ans = 0; long long t = 1; if (s[1] == w ) { t += b; } if (T < t) { cout << 0; return 0; } T -= t; ++ans; for (int i = 2; i <= n; ++i) { if (pref[i] > T) { break; } ans = max(ans, i); long long t = T - pref[i] - (i - 1) * a; if (t < 0) { continue; } int l = i; int r = n + 1; while (l + 1 < r) { int m = (l + r) / 2; if (suff[m] <= t) { r = m; } else { l = m; } } ans = max(ans, i + n + 1 - r); } for (int i = n; i >= 2; --i) { if (suff[i] > T) { break; } ans = max(n - i + 2, ans); long long t = T - suff[i] - (n + 1 - i) * a; if (t < 0) { continue; } int l = 1, r = i; while (l + 1 < r) { int m = (l + r) / 2; if (pref[m] <= t) { l = m; } else { r = m; } } ans = max(ans, n - i + 1 + l); } cout << ans; return 0; } |
#include <bits/stdc++.h> using namespace std; const int N = 60; const int M = 40010; const int OFF = 20005; int n, m; int lt[N], rt[N]; set<int> cnt; bitset<N> ll[M], rr[M]; int main() { cin >> n >> m; for (int i = 0; i < n; i++) { cin >> lt[i]; } for (int i = 0; i < m; i++) { cin >> rt[i]; for (int j = 0; j < n; j++) { cnt.insert(lt[j] + rt[i] + OFF); ll[lt[j] + rt[i] + OFF].set(j); rr[lt[j] + rt[i] + OFF].set(i); } } int m1 = 0; for (auto cc1 : cnt) { for (auto cc2 : cnt) { bitset<N> unl = ll[cc1] | ll[cc2]; bitset<N> unr = rr[cc1] | rr[cc2]; m1 = max(m1, int(unl.count() + unr.count())); } } printf( %d n , m1); return 0; } |
#include <bits/stdc++.h> using namespace std; const int inf = 1e9 + 5; const long long linf = 1e18 + 5; class point { public: int x, y; double m; point() {} point(int x, int y) { this->x = x; this->y = y; this->m = atan2(y, x); } bool operator<(point other) const { return m < other.m; } bool operator==(point other) const { return x == other.x and y == other.y and m == other.m; } }; int n, c, x, y, sumx, sumy; pair<int, int> a[5]; set<point> s; long long ccw(point a, point c, point b) { pair<int, int> v1 = make_pair(c.x - a.x, c.y - a.y); pair<int, int> v2 = make_pair(b.x - a.x, b.y - a.y); return (long long)v1.first * v2.second - (long long)v1.second * v2.first; } set<point>::iterator something_stupid_(point x) { set<point>::iterator it = s.lower_bound(x); if (it == s.end()) it = s.begin(); return it; } set<point>::iterator something_stupid_(set<point>::iterator it) { it++; if (it == s.end()) it = s.begin(); return it; } set<point>::iterator _something_stupid(set<point>::iterator it) { if (it == s.begin()) { it = s.end(); it--; } else it--; return it; } int main() { ios ::sync_with_stdio(0); cin >> n; for (int i = 1; i <= 3; i++) { cin >> c >> a[i].first >> a[i].second; sumx += a[i].first; sumy += a[i].second; } pair<int, int> cent = make_pair(sumx, sumy); for (int i = 1; i <= 3; i++) { a[i].first *= 3; a[i].second *= 3; a[i].first -= cent.first; a[i].second -= cent.second; point t(a[i].first, a[i].second); s.insert(t); } for (int i = 4; i <= n; i++) { cin >> c >> x >> y; x *= 3; y *= 3; x -= cent.first; y -= cent.second; point t(x, y); if (c == 1) { set<point>::iterator left = something_stupid_(t); set<point>::iterator right = _something_stupid(left); if (ccw(*left, *right, t) <= 0) continue; while (s.size() >= 2 and ccw(t, *left, *something_stupid_(left)) <= 0) { set<point>::iterator it = left; left = something_stupid_(left); s.erase(it); } right = _something_stupid(left); while (s.size() >= 2 and ccw(t, *right, *_something_stupid(right)) >= 0) { set<point>::iterator it = right; right = _something_stupid(right); s.erase(it); } s.insert(t); } else { set<point>::iterator left = something_stupid_(t); set<point>::iterator right = _something_stupid(left); if (ccw(*left, *right, t) <= 0) cout << YES << n ; else cout << NO << n ; } } return 0; } |
#include <bits/stdc++.h> using namespace std; int a[2010]; long long C[2010][2010]; long long A[2010]; bool use[2010]; int n, m, N; void init() { memset(use, 0, sizeof(use)); C[0][0] = 1; for (int i = 1; i <= 2000; ++i) C[i][0] = 1; for (int i = 1; i <= 2000; ++i) for (int j = 1; j <= i; ++j) C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % 1000000007; A[0] = 1; A[1] = 1; for (int i = 2; i <= 2000; ++i) A[i] = (A[i - 1] * i) % 1000000007; n = 0; } void solve() { long long Ans = 1; Ans = A[n]; for (int i = 1; i <= N; ++i) if (a[i] == -1 && !use[i]) m++; long long tmp = 0; for (int i = 1; i <= m; ++i) { if (i & 1) tmp = (tmp + (C[m][i] * A[n - i]) % 1000000007) % 1000000007; else tmp = (1000000007 + tmp - (C[m][i] * A[n - i]) % 1000000007) % 1000000007; } cout << (Ans + 1000000007 - tmp) % 1000000007; } int main() { scanf( %d , &N); init(); for (int i = 1; i <= N; ++i) { scanf( %d , &a[i]); if (a[i] != -1) use[a[i]] = 1; else n++; } solve(); return 0; } |
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(0); cin.tie(0); long long n, m, ta, tb, k, res = 0; cin >> n >> m >> ta >> tb >> k; if (k >= n || k >= m) { cout << -1; return 0; } vector<long long> a(n), b(m); for (int i = 0; i < n; i++) cin >> a[i]; for (int i = 0; i < m; i++) cin >> b[i]; for (int i = 0; i < n && i <= k; i++) { long long search = a[i] + ta; long long l = -1; long long r = m; long long mid; while (l != r - 1) { mid = (l + r) / 2; if (b[mid] >= search) r = mid; else l = mid; } if (r + max(0LL, k - i) >= m) { cout << -1; return 0; } res = max(res, b[r + max(0LL, k - i)] + tb); } cout << res; } |
#include <bits/stdc++.h> using namespace std; long long n, k; int arr[400009]; map<int, int> mp; vector<int> v; int sum[400009]; int main() { cin >> n >> k; for (int i = 0; i < n; i++) { scanf( %d , &arr[i]); if (mp[arr[i]] == 0) { v.push_back(arr[i]); } mp[arr[i]]++; } sort(v.begin(), v.end()); k *= 8; int ans = 1000000009; int j = 0; int num = 0; int curr = 0; for (int i = 0; i < v.size(); i++) { curr += mp[v[i]]; } for (int i = 0; i < v.size(); i++) { while (j < v.size() && ceil(log2(j - i + 1)) * n <= k) { curr -= mp[v[j]]; j++; } ans = min(ans, curr); j = max(i, j); curr += mp[v[i]]; } cout << ans << endl; } |
#include <bits/stdc++.h> using namespace std; int main() { int tt = 120; int test[6] = {0, 1, 3, 5, 2, 4}; int n = 5; int p[2001], s[2001]; int p_l[2001], s_l[2001]; int ans = 0; vector<pair<int, int> > v_ans; scanf( %d , &n); for (int i = 1; i <= n; i++) { scanf( %d , &p[i]); p_l[p[i]] = i; } for (int i = 1; i <= n; i++) s[i] = i; for (int i = 1; i <= n; i++) { scanf( %d , &s[i]); s_l[s[i]] = i; } for (int i = 1; i <= n; i++) { if (p[i] != s[i]) { int r = p_l[s[i]]; for (int j = i; j <= r; j++) { int pos_j = s_l[p[j]]; int pos_r = s_l[p[r]]; if ((pos_j >= r && pos_r <= j && pos_j != pos_r)) { ans += abs(j - r); v_ans.push_back(make_pair(j, r)); swap(p[j], p[r]); swap(p_l[p[j]], p_l[p[r]]); r = j; j = i - 1; } } } } printf( %d n%d n , ans, v_ans.size()); for (int i = 0; i < v_ans.size(); i++) printf( %d %d n , v_ans[i].first, v_ans[i].second); return 0; } |
#include <bits/stdc++.h> using namespace std; int H, M, K; int NonZeroDigit(int x) { int res = 0; while (x) { if (x % 10) res++; x /= 10; } return res; } int Get(int x, int p) { for (int i = 1; i < p; ++i) x /= 10; return x; } long long Solve(int h, int m) { int d = NonZeroDigit(M - 1); long long res = Get(h, K - d); res += (long long)Get(m, K) + (long long)h * Get(M - 1, K); return res; } int main() { cin >> H >> M >> K; int h1, m1, h2, m2; cin >> h1 >> m1 >> h2 >> m2; if (pair<int, int>(h1, m1) <= pair<int, int>(h2, m2)) cout << Solve(h2, m2) - Solve(h1, m1) << endl; else cout << Solve(H - 1, M - 1) - Solve(h1, m1) + (NonZeroDigit(H - 1) + NonZeroDigit(M - 1) >= K) + Solve(h2, m2) << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; int a1, a2, a3, a4; int head; int b, c; int nott(int x) { if (x == 4) return 7; return 4; } int main() { cin >> a1 >> a2 >> a3 >> a4; if (abs(a3 - a4) > 1) { cout << -1 << endl; return 0; } if (a3 > a4) head = 4; if (a4 > a3) head = 7; c = a3; b = a4; if (!head) { if (b != a1) head = 4; else head = 7; } if (head) { if (head == 7) c++; else b++; } if (b > a1 || c > a2) { cout << -1 << endl; return 0; } if (head == 7) { cout << 7; a2--; a4--; c--; } for (int i = 0; i < a1 - (b - 1); ++i) cout << 4; for (int i = 0; i < b - 1 - (b == c + 1); ++i) cout << 74; for (int i = 0; i < a2 - (b - 1) + (b == c + 1); ++i) cout << 7; if (b == c + 1) cout << 4; cout << endl; return 0; } |
#include <bits/stdc++.h> using namespace std; string st, t; vector<string> a; int p; int main() { ios_base ::sync_with_stdio(false); cin >> st; for (auto i : st) { t += i; if (i == > ) { a.push_back(t); t = ; } } for (auto i : a) { if (i[1] == / ) { --p; } for (int j = 0; j < p; ++j) { cout << ; } cout << i << endl; if (i[1] != / ) { ++p; } } } |
#include <bits/stdc++.h> using namespace std; int a[110][110], row[110], col[110], ansrow[110], anscol[110], n, m, tans, ans; bool flag; int main() { scanf( %d%d , &n, &m); for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) scanf( %d , &a[i][j]); ans = 10000000; for (int i = 0; i <= 500; i++) { row[1] = i; flag = 1; for (int j = 1; j <= m; j++) if (a[1][j] < i) { flag = 0; break; } else col[j] = a[1][j] - i; if (!flag) break; for (int j = 2; j <= n; j++) { if (a[j][1] - col[1] < 0) { flag = 0; break; } row[j] = a[j][1] - col[1]; for (int k = 2; k <= m; k++) if (a[j][k] - col[k] != row[j]) { flag = 0; break; } if (!flag) break; } if (!flag) continue; tans = 0; for (int j = 1; j <= n; j++) tans += row[j]; for (int j = 1; j <= m; j++) tans += col[j]; if (tans < ans) { ans = tans; for (int j = 1; j <= n; j++) ansrow[j] = row[j]; for (int j = 1; j <= m; j++) anscol[j] = col[j]; } } if (ans == 10000000) { printf( -1 ); return 0; } printf( %d n , ans); for (int i = 1; i <= n; i++) for (int j = 1; j <= ansrow[i]; j++) printf( row %d n , i); for (int i = 1; i <= m; i++) for (int j = 1; j <= anscol[i]; j++) printf( col %d n , i); return 0; } |
#include <bits/stdc++.h> using namespace std; int a[1000050]; vector<int> vec[1000050]; int pos[1000050]; int main() { int n, x; scanf( %d%d , &n, &x); for (int i = 0; i < n; i++) { scanf( %d , a + i); vec[a[i]].push_back(i); } pos[x + 1] = n; int st = 1; for (int i = x; i; i--) { pos[i] = pos[i + 1]; if (vec[i].size()) { if (vec[i].back() < pos[i]) { pos[i] = vec[i][0]; } else { st = i + 1; break; } } } int cur = -1; long long res = 0; for (int i = 1; i <= x; i++) { int p = lower_bound(pos + st, pos + x + 1, cur) - pos; p = max(p, i + 1); res += (x - p + 2); if (p == i) res--; if (vec[i].size()) { if (cur < vec[i][0]) cur = vec[i].back(); else break; } } printf( %lld n , res); return 0; } |
#include <bits/stdc++.h> using namespace std; void solve() { int n, k; cin >> n >> k; priority_queue<pair<int, int> > p; set<int> s; for (int i = 1; i <= n; i++) { int in; cin >> in; p.push({in, i}); s.insert(i + k); } long long ans = 0; vector<int> v(n); while (p.size()) { int c = p.top().first, d = p.top().second; p.pop(); auto it = s.lower_bound(d); ans += 1LL * (*it - d) * c; v[d - 1] = *it; s.erase(it); } cout << ans << n ; for (auto i : v) cout << i << ; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); ; solve(); return 0; } |
#include <bits/stdc++.h> using namespace std; string arf[1005], ars[1005]; string ans[1005]; void solve() { int n; cin >> n; map<string, vector<int> > f, s; int done[n]; memset(done, 0, sizeof(done)); ; for (int i = 0; i < (int)(n); i++) { string s1, s2; cin >> s1 >> s2; arf[i] = s1.substr(0, 3); ars[i] = s1.substr(0, 2) + s2.substr(0, 1); f[arf[i]].push_back(i); s[ars[i]].push_back(i); } map<string, int> final; for (auto i = f.begin(); i != f.end(); i++) { if (i->second.size() > 1) { for (int k = 0; k < i->second.size(); k++) { final[ars[i->second[k]]]++; ans[i->second[k]] = ars[i->second[k]]; done[i->second[k]] = 1; } } } for (int i = 0; i < n; i++) { if (done[i] == 0) { if (final[ars[i]] == 0) { final[ars[i]] = 1; ans[i] = ars[i]; } else if (final[arf[i]] == 0) { final[arf[i]] = 1; ans[i] = arf[i]; } else { cout << NO ; return; } } } for (auto i = final.begin(); i != final.end(); i++) { if (i->second > 1) { cout << NO ; return; } } cout << YES n ; for (int i = 0; i < (int)(n); i++) { cout << ans[i] << n ; } } int main() { cin.tie(0); cout.tie(0); cin.sync_with_stdio(0); cout.sync_with_stdio(0); int TC = 1; for (int ZZ = 1; ZZ <= TC; ZZ++) { clock_t start = clock(); solve(); clock_t end = clock(); cerr << Time: << (double)(end - start) / CLOCKS_PER_SEC << seconds << n ; } return 0; } |
Subsets and Splits