func_code_string
stringlengths 59
71.4k
|
|---|
#include <algorithm> #include <bitset> #include <cmath> #include <complex> #include <cstdio> #include <iostream> #include <map> #include <numeric> #include <queue> #include <random> #include <set> #include <stack> #include <string> #include <sys/types.h> #include <unistd.h> #include <unordered_map> #include <unordered_set> #include <vector> #pragma region macros #define _overload(_1, _2, _3, name, ...) name #define _rep(i, n) _range(i, 0, n) #define _range(i, a, b) for (int i = int(a); i < int(b); ++i) #define rep(...) _overload(__VA_ARGS__, _range, _rep, )(__VA_ARGS__) #define _rrep(i, n) _rrange(i, n, 0) #define _rrange(i, a, b) for (int i = int(a) - 1; i >= int(b); --i) #define rrep(...) _overload(__VA_ARGS__, _rrange, _rrep, )(__VA_ARGS__) #pragma endregion macros using namespace std; template <class T> bool chmax(T &a, const T &b) { return (a < b) ? (a = b, 1) : 0; } template <class T> bool chmin(T &a, const T &b) { return (b < a) ? (a = b, 1) : 0; } using ll = long long; using R = long double; const R EPS = 1e-9L; // [-1000,1000]->EPS=1e-8 [-10000,10000]->EPS=1e-7 inline int sgn(const R &r) { return (r > EPS) - (r < -EPS); } inline R sq(R x) { return sqrt(max(x, 0.0L)); } const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1}; const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1}; const pid_t pid = getpid(); // Problem Specific Parameter: ll p[1010][1010]; ll psum[1010]; ll p2sum[1010]; int main(void) { std::cin.tie(0); std::ios::sync_with_stdio(false); int m, k; cin >> m >> k; rep(i, k) { rep(j, m) { cin >> p[i][j]; psum[i] += p[i][j]; p2sum[i] += 1LL * p[i][j] * p[i][j]; } } const ll vsum = (psum[k - 1] - psum[0]) / (k - 1); ll y = -1; rep(i, 1, k - 1) { const ll v = (psum[i] - psum[i - 1]); if (v != vsum) { y = i; break; } } ll x; rep(j, m) { const ll v = (psum[y] - psum[y - 1]); const ll modify = vsum - v; p2sum[y] -= p[y][j] * p[y][j]; p[y][j] += modify; p2sum[y] += p[y][j] * p[y][j]; set<ll> s; rep(i, 1, k - 1) { const ll d2 = (p2sum[i - 1] + p2sum[i + 1]) - 2LL * p2sum[i]; s.insert(d2); } if (s.size() == 1) { x = p[y][j]; break; } p2sum[y] -= p[y][j] * p[y][j]; p[y][j] -= modify; p2sum[y] += p[y][j] * p[y][j]; } cout << y << << x << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; long long poww(long long a, long long b, long long md) { return (!b ? 1 : (b & 1 ? a * poww(a * a % md, b / 2, md) % md : poww(a * a % md, b / 2, md) % md)); } const long long MAXN = 1e6 + 10; const long long INF = 8e18; const long long MOD = 1e9 + 7; pair<long long, long long> A[MAXN]; long long n; set<pair<long long, long long> > st; int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); ; cin >> n; for (int i = 0; i < n; i++) { cin >> A[i].first; A[i].second = i; st.insert({i, A[i].first}); } sort(A, A + n); long long ans = 0, val = 0; long long rem = n; for (int i = 0; i < n - 2; i++) { auto it = st.find({A[i].second, A[i].first}); auto ite = st.end(); ite--; if (it == st.begin() || it == ite) { ans += (A[i].first - val) * (rem - 2); val += (A[i].first - val); st.erase(it); rem--; } else { auto nxt = it, prv = it; nxt++; prv--; ans += min(nxt->second, prv->second) - val; st.erase(it); rem--; } } cout << ans << n ; return 0; }
|
#include <bits/stdc++.h> using namespace std; struct comp { bool operator()(const vector<long long>& lhs, const vector<long long>& rhs) const { return lhs[0] > rhs[0] || (lhs[0] == rhs[0] && lhs[2] > rhs[2]) || (lhs[0] == rhs[0] && lhs[2] == rhs[2] && lhs[1] > rhs[1]); } }; vector<long long> t; vector<long long> ans; priority_queue<vector<long long>, vector<vector<long long> >, comp> events; queue<long long> q; set<long long> inq; priority_queue<long long, vector<long long>, greater<long long> > ready; bool clear(long long index) { auto it = inq.lower_bound(index); if (it == inq.end()) return inq.empty(); return it == inq.begin(); } int32_t main() { ios::sync_with_stdio(false); long long n, p; cin >> n >> p; t.resize(n); ans.resize(n); for (long long i = 0; i < n; i++) cin >> t[i]; for (long long i = 0; i < n; i++) events.push({t[i], i, 1}); while (!events.empty()) { vector<long long> a = events.top(); events.pop(); long long status = a[2], index = a[1], time = a[0]; if (status == 1) { if (clear(index)) { if (q.empty()) events.push({time + p, index, 2}); q.push(index); inq.insert(index); } else ready.push(index); } else { ans[index] = time; q.pop(); inq.erase(index); if (!ready.empty() && clear(ready.top())) { long long nextIndex = ready.top(); ready.pop(); q.push(nextIndex); inq.insert(nextIndex); } if (!q.empty()) { long long nextIndex = q.front(); events.push({time + p, nextIndex, 2}); } } } for (long long i = 0; i < n; i++) cout << ans[i] << ; }
|
#include <bits/stdc++.h> using namespace std; int a[1000000], g[1000000], h[1000000]; int d[1000000]; int dp[1000000]; int up[1000000]; int h1[1000000]; int h2[1000000]; int t1[1000000]; int t2[1000000]; vector<int> v[1000000]; int x, y, n, m; int maxy, one_kek, two_kek; void dfs(int x, int pr = -1) { h[x] = 1; d[x] = g[x]; h1[x] = 0; h2[x] = 0; t1[x] = 0; t2[x] = 0; for (int i = 0; i < v[x].size(); i++) { int to = v[x][i]; if (to == pr) continue; dfs(to, x); if (d[to] == 0) continue; d[x] += d[to]; h[x] += h[to]; if (1 + h1[to] > h2[x]) { h2[x] = 1 + h1[to]; t2[x] = to; if (h2[x] > h1[x]) { swap(h1[x], h2[x]); swap(t1[x], t2[x]); } } } if (d[x] == 0) return; } void dfs1(int x, int pr = -1) { if (d[x] == 0) return; if (pr == -1) dp[x] = h1[x]; else { if (t1[pr] == x) up[x] = 1 + max(up[pr], h2[pr]); else up[x] = 1 + max(up[pr], h1[pr]); dp[x] = max(h1[x], up[x]); } for (int i = 0; i < v[x].size(); i++) { int to = v[x][i]; if (to == pr) continue; dfs1(to, x); } } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cin >> n >> m; for (int i = 1; i < n; i++) { cin >> x >> y; v[x].push_back(y); v[y].push_back(x); } for (int i = 1; i <= m; i++) { cin >> a[i]; g[a[i]]++; } if (m == 1) { cout << a[1] << n << 0; return 0; } dfs(a[1]); dfs1(a[1]); for (int i = 1; i <= m; i++) { if (dp[a[i]] > maxy) { maxy = dp[a[i]]; one_kek = a[i]; } else if (dp[a[i]] == maxy) one_kek = min(one_kek, a[i]); } cout << one_kek << n << h[a[1]] * 2 - 2 - maxy << n ; }
|
#include <bits/stdc++.h> using namespace std; int a[1003][1003]; int r[1003]; int c[1003]; char ch[5]; int main() { int n, m, k; scanf( %d %d %d , &n, &m, &k); for (int i = 1; i <= n; i++) { for (int j = 1; j <= m; j++) { scanf( %d , &a[i][j]); } } for (int i = 1; i <= n; i++) { r[i] = i; } for (int i = 1; i <= m; i++) { c[i] = i; } for (int i = 1; i <= k; i++) { scanf( %s , ch); int x, y; scanf( %d %d , &x, &y); if (ch[0] == r ) { swap(r[x], r[y]); } else if (ch[0] == c ) { swap(c[x], c[y]); } else { printf( %d n , a[r[x]][c[y]]); } } return 0; }
|
#include <bits/stdc++.h> using namespace std; const long long MOD = 1000 * 1000 * 1000 + 7; const double PI = acos(-1.0); long long gcd(long long a, long long b) { long long m; while (b) { m = a % b; a = b; b = m; } return a; } int solve() { string s; cin >> s; long long total = 0; int n = s.size(); for (int i = 0; i < n; ++i) { if (s[i] >= 0 && s[i] <= 9 ) { int j = i; long long u = 0; int dot = -1; while (s[j] >= 0 && s[j] <= 9 || s[j] == . ) { if (s[j] == . ) dot = j; else u = u * 10 + (s[j] - 0 ); ++j; } if (dot == -1 || j - dot != 3) u = u * 100; total += u; i = j - 1; } } s.clear(); if (total % 100 != 0) { s += total % 10 + 0 ; total /= 10; s += total % 10 + 0 ; total /= 10; s += . ; } else { total /= 100; } int j = 0; do { ++j; s += total % 10 + 0 ; if (j == 3) s += . , j = 0; } while (total /= 10); if (s.back() == . ) s.pop_back(); reverse(s.begin(), s.end()); cout << s << endl; return 0; } int main() { solve(); }
|
#include <bits/stdc++.h> using namespace std; int main() { ios::sync_with_stdio(false); string s; cin >> s; int x = 0, y = 0; for (int i = 0; i < s.size(); i++) s[i] == x ? x++ : y++; if (x > y) for (int i = 0; i < x - y; i++) cout << x ; else for (int i = 0; i < y - x; i++) cout << y ; return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n, req = 1; scanf( %d , &n); map<int, int> index; for (int i = 0; i < n; i++) { int x; scanf( %d , &x); if (x == req) { index[x] = i + 1 + 2000; req++; } } int cnt = 0; for (int i = 1; index[i] != 0; i++) { cnt++; } printf( %d n , cnt); if (cnt) printf( %d , index[1]); for (int i = 2; index[i] != 0; i++) { printf( %d , index[i]); } if (cnt) printf( n ); return 0; }
|
#include <bits/stdc++.h> #pragma warning(disable : 4996) using namespace std; int n, m; char a[2000000], b[2000000]; int main() { int i, j, k; scanf( %s%s , a, b); n = strlen(a), m = strlen(b); int now = 0; for (i = 0; i < m; i++) { if (b[i] == a[now]) { now++; if (now == n) break; } } int c1, c2; c1 = i; now = n - 1; for (i = m - 1; i >= 0; i--) { if (b[i] == a[now]) { now--; if (now == -1) break; } } c2 = i; printf( %d , max(0, c2 - c1)); return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; int u[n + 1]; int a[n + 1][n + 1]; int maxx[n + 1]; int dom[n + 1]; for (int i = 1; i <= n; i++) { cin >> u[i]; for (int j = 1; j <= n; j++) { a[i][j] = 0; } maxx[i] = u[i]; dom[i] = 0; } for (int i = 1; i <= n; i++) { for (int j = 1; j <= i; j++) { a[u[i]][j]++; if (maxx[j] != u[i]) { if (a[u[i]][j] > a[maxx[j]][j]) { maxx[j] = u[i]; dom[u[i]]++; } else if (a[u[i]][j] == a[maxx[j]][j]) { if (u[i] < maxx[j]) { maxx[j] = u[i]; dom[u[i]]++; } else { dom[maxx[j]]++; } } else if (a[u[i]][j] < a[maxx[j]][j]) { dom[maxx[j]]++; } } else { dom[u[i]]++; } } } for (int i = 1; i <= n; i++) { cout << dom[i] << ; } return 0; }
|
#include <bits/stdc++.h> #pragma GCC optimize( Ofast ) #pragma GCC target( sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma ) #pragma GCC optimize( unroll-loops ) using namespace std; long long MOD = 998244353; double eps = 1e-12; void solve() { long long n; cin >> n; for (long long i = 0; i <= n; i++) { for (long long j = 0; j <= n; j++) { for (long long k = 0; k <= n; k++) { if ((i * 3 + j * 5 + k * 7) == n) { cout << i << << j << << k << n ; return; } } } } cout << -1 << n ; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); long long t; cin >> t; for (int it = 1; it <= t; it++) { solve(); } return 0; }
|
#include <bits/stdc++.h> #pragma GCC optimize( O3 ) using namespace std; int main() { int T; cin >> T; while (T--) { long long n, m; cin >> n >> m; long long d = n / m; long long w = m % 10; long long sm = 0; for (int i = 0; i < 10; i++) { sm += (i * w) % 10; } long long fsm = 0; for (int i = 1; i <= d % 10; i++) { fsm += (i * w) % 10; } cout << sm * (d / 10) + fsm << n ; } }
|
#include <bits/stdc++.h> using namespace std; const int MAXN = 5000 + 10; int n, T; double p[MAXN]; int t[MAXN]; double dp[MAXN][MAXN]; int main() { scanf( %d%d , &n, &T); for (int i = 1; i <= n; ++i) { scanf( %lf%d , &p[i], &t[i]); p[i] *= 0.01; } double ans = 0.0; dp[0][0] = 1.0; for (int i = 1; i <= n; ++i) { double sum = 0.0; double npn = pow(1.0 - p[i], t[i]); for (int j = 1; j <= T; ++j) { sum += dp[i - 1][j - 1]; if (j > t[i]) { sum -= dp[i - 1][j - t[i] - 1] * npn; } dp[i][j] += sum * p[i]; if (j >= t[i]) { dp[i][j] += dp[i - 1][j - t[i]] * npn; } sum *= 1.0 - p[i]; ans += dp[i][j]; } } printf( %.8f n , ans); return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { long long int n, max = -1; cin >> n; long long int a[n], b[n]; for (int i = 0; i < n; i++) { cin >> a[i]; } for (int i = n - 1; i >= 0; i--) { if (max < a[i]) { max = a[i]; b[n - i] = 0; } else { b[n - i] = max + 1 - a[i]; } } for (int i = n; i > 0; i--) { cout << b[i] << ; } return 0; }
|
#include <bits/stdc++.h> using namespace std; const int MAXBUF = 10000; char buf[MAXBUF], *ps = buf, *pe = buf + 1; inline bool isdigit(const char& n) { return (n >= 0 && n <= 9 ); } inline void rnext() { if (++ps == pe) pe = (ps = buf) + fread(buf, sizeof(char), sizeof(buf) / sizeof(char), stdin); } template <class T> inline bool in(T& ans) { ans = 0; T f = 1; if (ps == pe) return false; do { rnext(); if ( - == *ps) f = -1; } while (!isdigit(*ps) && ps != pe); if (ps == pe) return false; do { ans = (ans << 1) + (ans << 3) + *ps - 48; rnext(); } while (isdigit(*ps) && ps != pe); ans *= f; return true; } const int MAXOUT = 10000; char bufout[MAXOUT], outtmp[50], *pout = bufout, *pend = bufout + MAXOUT; inline void write() { fwrite(bufout, sizeof(char), pout - bufout, stdout); pout = bufout; } inline void out_char(char c) { *(pout++) = c; if (pout == pend) write(); } inline void out_str(char* s) { while (*s) { *(pout++) = *(s++); if (pout == pend) write(); } } template <class T> inline void out_int(T x) { if (!x) { out_char( 0 ); return; } if (x < 0) x = -x, out_char( - ); int len = 0; while (x) { outtmp[len++] = x % 10 + 48; x /= 10; } outtmp[len] = 0; for (int i = 0, j = len - 1; i < j; i++, j--) swap(outtmp[i], outtmp[j]); out_str(outtmp); } template <typename T, typename... T2> inline int in(T& value, T2&... value2) { in(value); return in(value2...); } const double eps = 1e-9; const int maxn = 5e5 + 10; const int INF = 0x3f3f3f3f; const int mod = 1e9 + 7; int N, M, tmp, K, Q; struct Edge { int u, v, w, id; } edge[maxn]; struct node { int w, id, pointer; friend bool operator<(node a, node b) { return a.w > b.w; } }; vector<int> query[maxn]; priority_queue<node> P; int Back[maxn][2]; int cnt; int tree[maxn]; int Size[maxn]; int ans[maxn], ID[maxn]; void init() { for (register int i = 1; i <= N; i++) tree[i] = i, Size[i] = 1; } int find(int p) { if (p == tree[p]) return p; return find(tree[p]); } bool Union(int u, int v) { u = find(u); v = find(v); if (u == v) return false; if (Size[u] > Size[v]) swap(u, v); tree[u] = v; Size[v] += Size[u]; Back[++cnt][0] = u; Back[cnt][1] = v; return true; } void Cancel() { while (cnt) { int u = Back[cnt][0]; int v = Back[cnt--][1]; tree[u] = u; Size[v] -= Size[u]; } } bool cmp(Edge a, Edge b) { return a.w < b.w; } int main() { in(N, M); init(); for (register int i = 1; i <= M; i++) in(edge[i].u, edge[i].v, edge[i].w), edge[i].id = i; sort(edge + 1, edge + M + 1, cmp); for (register int i = 1; i <= M; i++) ID[edge[i].id] = i; in(Q); for (register int i = 1; i <= Q; i++) { in(tmp); while (tmp--) { int t; in(t); t = ID[t]; query[i].push_back(t); } sort(query[i].begin(), query[i].end()); node h; h.id = i; h.pointer = 0; h.w = query[i][0]; P.push(h); } for (int i = 1; i <= M;) { int W = edge[i].w; int j = i + 1; for (; j <= M && edge[j].w == edge[i].w; j++) ; j--; while (!P.empty()) { node x = P.top(); if (x.w > j) break; P.pop(); int v = x.id; while (x.pointer < query[v].size() && query[v][x.pointer] <= j) { if (!Union(edge[query[v][x.pointer]].u, edge[query[v][x.pointer]].v)) break; x.pointer++; } Cancel(); if (x.pointer == query[v].size()) { ans[x.id] = 1; continue; } x.w = query[v][x.pointer]; if (x.w > j) P.push(x); } for (; i <= j; i++) Union(edge[i].u, edge[i].v); cnt = 0; } for (register int i = 1; i <= Q; i++) { if (ans[i] == 1) puts( YES ); else puts( NO ); } return 0; }
|
#include <bits/stdc++.h> using namespace std; const int N = 100005; inline int in() { int x; scanf( %d , &x); return x; } inline long long lin() { long long x; scanf( %I64d , &x); return x; } vector<int> G[N + N]; pair<int, int> edg[N + N]; int n, k, start; int inp[N + N]; int st[N + N], T = 1; long long res, f[N + N]; void dfs(int u, int par) { st[u] = T++; if (inp[u] == 1) f[u]++; for (int i = 0; i < (int)G[u].size(); i++) { int v = G[u][i]; if (v != par) { dfs(v, u); f[u] += f[v]; res += min(f[v], 2LL * k - f[v]); } } } int main() { n = in(); k = in(); for (int i = 1; i <= k + k; i++) { int x = in(); inp[x] = 1; } for (int i = 1; i <= n - 1; i++) { int u = in(), v = in(); G[u].push_back(v); G[v].push_back(u); edg[i] = make_pair(u, v); } res = 0; dfs(1, -1); printf( %I64d n , res); }
|
#include <bits/stdc++.h> using namespace std; bool test(long long, long long, long long); int main(void) { long long n, m; cin >> n >> m; long long first, last; first = 0; last = sqrt(2 * n) + 1; if (m >= n) { cout << n; return 0; } while (test(first, n, m) == 0) { long long med; med = (first + last) / 2; if (test(med, n, m) == 1) last = med; else first = med; if (last - first == 1 && test(first, n, m) == 0) first = last; } cout << first + m; return 0; } bool test(long long day, long long n, long long m) { if (day % 2 == 0) { if ((day / 2) * (day + 1) >= (n - m)) return 1; } else { if (day * ((day + 1) / 2) >= (n - m)) return 1; } return 0; }
|
#include <bits/stdc++.h> using namespace std; char s[50005]; map<string, int> st; int sq = 300; vector<int> p[500100]; vector<int> h; string s1[500100]; int res[1010][1010]; void pro(int x1, int y1) { int x = h[x1]; int y = h[y1]; int pri = -1, prj = -1; int mn = 1e9; int r; for (int i = 0, j = 0; i < p[x].size() || j < p[y].size();) { if (i < p[x].size() && j < p[y].size()) { r = max(p[x][i] + s1[x].size(), p[y][j] + s1[y].size()) - min(p[x][i], p[y][j]); mn = min(mn, r); } if (i >= p[x].size()) prj = p[y][j], j++; else if (j >= p[y].size()) pri = p[x][i], i++; else if (p[x][i] < p[y][j]) pri = p[x][i], i++; else prj = p[x][j], j++; } res[x1][y1] = mn; res[y1][x1] = mn; } int main() { scanf( %s , s); int n = strlen(s); int k = 0; for (int i = 0; i < n; i++) { string t = ; for (int j = 0; j < 4 && j + i < n; j++) { t.push_back(s[j + i]); if (st.count(t) == 0) { s1[k] = t; st[t] = k++; } p[st[t]].push_back(i); } } for (int i = 0; i < k; i++) { if (p[i].size() > sq) { h.push_back(i); } } for (int i = 0; i < h.size(); i++) { res[i][i] = s1[h[i]].size(); for (int j = i + 1; j < h.size(); j++) { pro(i, j); } } int q; cin >> q; char s2[10]; char s3[10]; vector<int>::iterator it, it1; while (q--) { scanf( %s , s2); scanf( %s , s3); if (st.count(s2) == 0 || st.count(s3) == 0) { printf( -1 n ); continue; } int x = st[s2]; int y = st[s3]; it = lower_bound(h.begin(), h.end(), x); it1 = lower_bound(h.begin(), h.end(), y); int mn = 1e9, r; if (it != h.end() && *it == x && it1 != h.end() && *it1 == y) { printf( %d n , res[it - h.begin()][it1 - h.begin()]); continue; } else if (it == h.end() || *it != x) { for (int i = 0; i < p[x].size(); i++) { it = lower_bound(p[y].begin(), p[y].end(), p[x][i]); if (it != p[y].end()) { r = max(p[x][i] + s1[x].size(), *it + s1[y].size()); r -= min(p[x][i], *it); mn = min(mn, r); } if (it != p[y].begin()) { it--; r = max(p[x][i] + s1[x].size(), *it + s1[y].size()); r -= min(p[x][i], *it); mn = min(mn, r); } } } else { for (int i = 0; i < p[y].size(); i++) { it = lower_bound(p[x].begin(), p[x].end(), p[y][i]); if (it != p[x].end()) { r = max(p[y][i] + s1[y].size(), *it + s1[x].size()); r -= min(p[y][i], *it); mn = min(mn, r); } if (it != p[x].begin()) { it--; r = max(p[y][i] + s1[y].size(), *it + s1[x].size()); r -= min(p[y][i], *it); mn = min(mn, r); } } } printf( %d n , mn); } return 0; }
|
#include <bits/stdc++.h> using namespace std; long long n, m, a[1000500]; map<pair<int, long long>, bool> dp; bool found = false; void solve(int idx, long long sum, bool take) { if (found) return; if (take && sum % m == 0) { found = true; return; } if (idx >= n) return; bool &ret = dp[{idx, sum}]; if (ret) return; ret = true; solve(idx + 1, sum + a[idx], take + 1); if (found) return; solve(idx + 1, sum, take); if (found) return; } int main() { scanf( %lld%lld , &n, &m); bool z = false; for (int i = 0; i < n; ++i) scanf( %lld , &a[i]), z |= (a[i] == 0); solve(0, 0, 0); if (z || found) return puts( YES ); puts( NO ); return 0; }
|
#include <bits/stdc++.h> using namespace std; inline int read() { char c = getchar(); int x = 0, f = 1; for (; !isdigit(c); c = getchar()) if (c == - ) f = -1; for (; isdigit(c); c = getchar()) x = x * 10 + c - 0 ; return x * f; } const int MAXN = 8e3 + 5; int nxt[MAXN], p[MAXN][MAXN], dp[MAXN]; int N, len; char s[MAXN], S[MAXN]; inline int calc(int x) { int ret = 0; while (x) x /= 10, ret++; return ret; } inline void KMP(int st) { len = N - st + 1; for (int i = 1; i <= len; i++) s[i] = S[st + i - 1]; int j = 0; for (int i = 2; i <= len; i++) { while (j && s[i] != s[j + 1]) j = nxt[j]; if (s[i] == s[j + 1]) j++; nxt[i] = j; } for (int i = 1; i <= len; i++) { int tmp = i - nxt[i]; if (i % tmp) tmp = i; p[st][st + i - 1] = tmp + calc(i / tmp); } } int main() { scanf( %s , S + 1); N = strlen(S + 1); for (int i = 1; i <= N; i++) KMP(i); memset(dp, 0x3f, sizeof(dp)); dp[0] = 0; for (int i = 1; i <= N; i++) for (int j = 0; j < i; j++) dp[i] = min(dp[i], dp[j] + p[j + 1][i]); printf( %d n , dp[N]); return 0; }
|
#include <bits/stdc++.h> using namespace std; template <typename T> void maxtt(T& t1, T t2) { t1 = max(t1, t2); } template <typename T> void mintt(T& t1, T t2) { t1 = min(t1, t2); } bool debug = 0; int n, m, k; string direc = URDL ; const long long MOD2 = (long long)1000000007 * (long long)1000000007; long long ln, lk, lm; void etp(bool f = 0) { puts(f ? YES : NO ); exit(0); } void addmod(int& x, int y, int mod = 1000000007) { x += y; if (x >= mod) x -= mod; if (x < 0) x += mod; assert(x >= 0 && x < mod); } void et(int x = -1) { printf( %d n , x); exit(0); } long long fastPow(long long x, long long y, int mod = 1000000007) { long long ans = 1; while (y > 0) { if (y & 1) ans = (x * ans) % mod; x = x * x % mod; y >>= 1; } return ans; } long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; } int p[1000035], q[1000035]; void fmain(int tid) { scanf( %d%lld , &n, &lk); for (int(i) = 1; (i) <= (int)(n); (i)++) { p[i] = q[i] = i; } long long mi = (long long)(n + 1) * n / 2; int hf = n / 2; long long mx = (long long)(n - hf + 1 + n) * hf; if (n & 1) mx += n / 2 + 1; if (lk < mi) et(); mintt(lk, mx); long long tar = lk - mi; for (int(i) = 1; (i) <= (int)(hf); (i)++) { int bg = n + 1 - i; if (bg - i <= tar) { swap(q[i], q[bg]); tar -= bg - i; } else { swap(q[i], q[i + tar]); break; } } printf( %lld n , lk); for (int(i) = 1; (i) <= (int)(n); (i)++) printf( %d , p[i]); puts( ); for (int(i) = 1; (i) <= (int)(n); (i)++) printf( %d , q[i]); puts( ); } int main() { int t = 1; for (int(i) = 1; (i) <= (int)(t); (i)++) { fmain(i); } return 0; }
|
#include <bits/stdc++.h> using namespace std; struct abc { int p, q, idx; }; bool compareTwoStudents(abc a, abc b) { if (a.p != b.p) return a.p < b.p; return (a.q < b.q); } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); int i, j, k, m, n, t, u, v, w, p = 0, q, flag = 0; long long int x, y, z; string s, s1, s2; vector<int> abc; vector<int>::iterator it; priority_queue<int> pq; map<int, int> make_pair; cin >> t; while (t--) { std::cin >> n; std::cout << n << n ; } return 0; }
|
#include <bits/stdc++.h> using namespace std; template <typename T> void out(T x) { cout << x << endl; exit(0); } const int maxn = 2000 + 7; int n; long double p; int t; long double dp[maxn][maxn]; int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); cin >> n >> p >> t; dp[0][0] = 1.0; for (int i = 0; i < t; i++) { for (int j = 0; j < n; j++) { dp[i + 1][j] += (1.0 - p) * dp[i][j]; dp[i + 1][j + 1] += p * dp[i][j]; } dp[i + 1][n] += dp[i][n]; } long double ans = 0.0; for (int i = 1; i <= n; i++) { ans += 1.0 * i * dp[t][i]; } cout << fixed << setprecision(12) << ans << n ; return 0; }
|
#include <bits/stdc++.h> #pragma GCC optimize(3, Ofast , inline ) #pragma GCC target( avx ) using namespace std; template <class t> inline t read(t &x) { char c = getchar(); bool f = 0; x = 0; while (!isdigit(c)) f |= c == - , c = getchar(); while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = getchar(); if (f) x = -x; return x; } template <class t> inline void write(t x) { if (x < 0) putchar( - ), write(-x); else { if (x > 9) write(x / 10); putchar( 0 + x % 10); } } const int mod = 1e9 + 7, N = 705; int ans, n, dig[N], f[N][N][10][2]; char s[N]; signed main() { scanf( %s , s + 1); n = strlen(s + 1); for (int i = 1; i <= n; i++) dig[i] = s[i] ^ 48; for (int i = 0; i <= 9; i++) f[0][0][i][0] = 1; for (int i = 0; i < n; i++) for (int j = 0; j <= i; j++) for (int k = 1; k <= 9; k++) for (int lim = 0; lim <= 1; lim++) for (int x = 0; x <= (lim ? 9 : dig[i + 1]); x++) (f[i + 1][j + (x >= k)][k][lim | (x < dig[i + 1])] += f[i][j][k][lim]) %= mod; for (int k = 1; k <= 9; k++) for (int i = 1, mul = 1; i <= n; i++) ans = (ans + 1ll * mul * (f[n][i][k][0] + f[n][i][k][1]) % mod) % mod, mul = (1ll * mul * 10 + 1) % mod; write(ans); }
|
#include <bits/stdc++.h> using namespace std; const int N = 2e5 + 100; int a[N]; int per[N]; int main() { int n; cin >> n; for (int i = 0; i < n - 1; i++) { scanf( %d , &a[i]); } int ls = a[0]; set<int> st; for (int i = 1; i <= n; i++) { st.insert(i); } for (int i = 0; i < n - 1; i++) { if (per[a[i]]) { ls = *(--st.end()); st.erase(--st.end()); per[ls] = a[i]; } else { st.erase(a[i]); per[a[i]] = per[ls]; per[ls] = a[i]; if (i == 0) i--; } } printf( %d n , a[0]); for (int i = 1; i <= n; i++) { if (per[i] == i) continue; printf( %d %d n , i, per[i]); } return 0; }
|
#include <bits/stdc++.h> int a, b, c; long long int MOD; long long int Comb[110][110]; long long int comb(int a, int b) { if (a == b) return 1; if (b == 0) return 1; if (Comb[a][b] != -1) return Comb[a][b]; return Comb[a][b] = (comb(a - 1, b - 1) + comb(a - 1, b)) % MOD; } int check[110][110]; std::vector<long long int> ans[110][110]; void func(int k, int h) { if (check[k][h]) return; if (k == 0) { ans[k][h].push_back(1 % MOD); check[k][h] = 1; return; } int start = 0; if (h == b) start++; for (int i = 0; i <= k - 1; i++) { func(i, h + 1); func(k - i - 1, h + 1); while (ans[k][h].size() <= start + ans[i][h + 1].size() + ans[k - i - 1][h + 1].size() - 2) ans[k][h].push_back(0); for (int j1 = 0; j1 < ans[i][h + 1].size(); j1++) { for (int j2 = 0; j2 < ans[k - i - 1][h + 1].size(); j2++) { long long int t = ans[i][h + 1][j1] * ans[k - i - 1][h + 1][j2]; t %= MOD; t *= comb(k - 1, i), t %= MOD; ans[k][h][start + j1 + j2] += t, ans[k][h][start + j1 + j2] %= MOD; } } } check[k][h] = 1; } int main() { scanf( %d%d%d%lld , &a, &b, &c, &MOD); for (int i = 0; i <= a; i++) for (int j = 0; j <= a; j++) Comb[i][j] = -1; func(a, 1); if (ans[a][1].size() >= c + 1) printf( %lld , ans[a][1][c] % MOD); else printf( 0 ); }
|
#include <bits/stdc++.h> const long long INF = 2 * 1e9; const long long MOD = 1000000007; using namespace std; void solve() { long long n, k, m; cin >> n >> k >> m; vector<long long> a(n); vector<pair<long long, long long> > c; long long x; cin >> x; c.push_back({x, 1}); long long cnt = 0; for (long long i = 1; i < n; i++) { long long x; cin >> x; if (c.size() == 0) { c.push_back({x, 1}); continue; } if (x == c.back().first) { c[(long long)(c).size() - 1].second++; cnt += c[(long long)(c).size() - 1].second / k * k; c[(long long)(c).size() - 1].second %= k; if (c[(long long)(c).size() - 1].second == 0) c.pop_back(); } else { c.push_back({x, 1}); } } if ((long long)(c).size() == 0) { cout << 0 << n ; return; } long long i = 0, j = (long long)(c).size() - 1; auto tmp = c; long long cnt1 = 0; while (1) { if (tmp[i].first == tmp[j].first) { if (i == j) break; cnt1 += (tmp[i].second + tmp[j].second) / k * k; if ((tmp[i].second + tmp[j].second) % k == 0) { i++; j--; } else break; } else { break; } } long long ans = 0; if (i == j && tmp[i].first == tmp[j].first) { long long cur = tmp[i].second * m; long long cnt2 = (cur / k) * k; cur %= k; ans += cnt * m + cnt1 * (m - 1) + cnt2; if (cur == 0) { i--; j++; while (i >= 0 && j < tmp.size()) { if (tmp[i].first == tmp[j].first) { ans += (tmp[i].second + tmp[j].second) / k * k; if ((tmp[i].second + tmp[j].second) % k == 0) { i--; j++; } else break; } else break; } } } else { ans += cnt * m + (cnt1) * (m - 1); } cout << n * m - ans << n ; } signed main() { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); cout.fixed; cout.precision(12); solve(); return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { long long int n; cin >> n; long long int ans = 0; if (n == 1 || n == 2) { cout << n << endl; return 0; } for (long long int i = 1; i <= (sqrt(n)); i++) { if (n % i == 0) ans += 2; if (i * i == n) ans = ans - 1; } cout << ans << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; template <typename _T> inline void read(_T &f) { f = 0; _T fu = 1; char c = getchar(); while (c < 0 || c > 9 ) { if (c == - ) { fu = -1; } c = getchar(); } while (c >= 0 && c <= 9 ) { f = (f << 3) + (f << 1) + (c & 15); c = getchar(); } f *= fu; } template <typename T> void print(T x) { if (x < 0) putchar( - ), x = -x; if (x < 10) putchar(x + 48); else print(x / 10), putchar(x % 10 + 48); } template <typename T> void print(T x, char t) { print(x); putchar(t); } const int md = 998244353; inline int add(int x, int y) { x += y; if (x >= md) x -= md; return x; } inline int sub(int x, int y) { x -= y; if (x < 0) x += md; return x; } inline int mul(int x, int y) { return 1ll * x * y % md; } inline int fpow(int x, int y) { int ans = 1; while (y) { if (y & 1) ans = mul(ans, x); y >>= 1; x = mul(x, x); } return ans; } namespace Poly { vector<int> rev, roots, one(1, 1); vector<int> operator+(vector<int> a, vector<int> b) { int n = max((int)a.size(), (int)b.size()); a.resize(n); b.resize(n); for (int i = 0; i < n; i++) { a[i] = add(a[i], b[i]); } return a; } vector<int> operator-(vector<int> a, vector<int> b) { int n = max((int)a.size(), (int)b.size()); a.resize(n); b.resize(n); for (int i = 0; i < n; i++) { a[i] = sub(a[i], b[i]); } return a; } void getRevRoot(int base) { int n = 1 << base; rev.resize(n); roots.resize(n); for (int i = 1; i < n; i++) rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (base - 1)); for (int mid = 1; mid < n; mid <<= 1) { int wn = fpow(3, (md - 1) / (mid << 1)); roots[mid] = 1; for (int i = 1; i < mid; i++) roots[mid + i] = mul(roots[mid + i - 1], wn); } } void ntt(vector<int> &a, int base) { int n = 1 << base; for (int i = 0; i < n; i++) if (i < rev[i]) swap(a[i], a[rev[i]]); for (int mid = 1; mid < n; mid <<= 1) { for (int i = 0; i < n; i += (mid << 1)) { for (int j = 0; j < mid; j++) { int x = a[i + j], y = mul(a[i + j + mid], roots[mid + j]); a[i + j] = add(x, y); a[i + j + mid] = sub(x, y); } } } } vector<int> operator*(vector<int> a, vector<int> b) { int base = 0, n = (int)a.size() + (int)b.size() - 1; while ((1 << base) < n) ++base; a.resize(1 << base); b.resize(1 << base); getRevRoot(base); ntt(a, base); ntt(b, base); for (int i = 0; i < (1 << base); i++) a[i] = mul(a[i], b[i]); reverse(a.begin() + 1, a.end()); ntt(a, base); a.resize(n); int inv = fpow(1 << base, md - 2); for (int i = 0; i < n; i++) { a[i] = mul(a[i], inv); } return a; } } // namespace Poly using Poly::operator*; const int N = 1e5 + 5; vector<int> f, g, tmp; int fac[N], inv[N]; int n; long long m; int main() { read(n); read(m); f.resize(n + 1); tmp.resize(n + 1); fac[0] = 1; for (int i = 1; i <= n; i++) fac[i] = mul(fac[i - 1], i); inv[n] = fpow(fac[n], md - 2); for (int i = n; i >= 1; i--) inv[i - 1] = mul(inv[i], i); for (int i = 0; i <= n; i++) read(f[i]), tmp[i] = inv[i]; for (int i = 0; i <= n; i++) f[i] = mul(f[i], fac[i]); reverse(f.begin(), f.end()); g = f * tmp; g.resize(n + 1); reverse(g.begin(), g.end()); for (int i = 0; i <= n; i++) g[i] = mul(mul(g[i], inv[i]), fpow(fpow(i + 1, m % (md - 1)), md - 2)); for (int i = 1; i <= n; i += 2) tmp[i] = md - tmp[i]; for (int i = 0; i <= n; i++) g[i] = mul(g[i], fac[i]); reverse(g.begin(), g.end()); f = g * tmp; f.resize(n + 1); reverse(f.begin(), f.end()); for (int i = 0; i <= n; i++) f[i] = mul(f[i], inv[i]), print(f[i], i == n ? n : ); return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n; map<int, int> m; cin >> n; int a[n]; for (int i = 0; i < n; i++) { cin >> a[i]; m[a[i]]++; } int chek[32]; chek[0] = 2; for (int i = 1; i < 32; i++) { chek[i] = chek[i - 1] * 2; } int sm = 0, coun = 0; for (int i = 0; i < n; i++) { for (int j = 0; j < 32; j++) { int h = chek[j] - a[i]; if (m.find(h) != m.end()) { if (h == a[i] && m[a[i]] > 1) { coun++; break; } if (h != a[i]) { coun++; break; } } } } cout << n - coun << endl; return 0; }
|
#include <bits/stdc++.h> #define testCase int T; cin>>T; while(T--) #define int long long #define Endl endl using namespace std; /* */ const int N = 1e5+13, LMAX = 3e18 + 13, IMAX = 1e9 + 5, mod = 1e9 + 7; //998244353; int32_t main() { ios_base::sync_with_stdio(false); cin.tie(nullptr); testCase { int mn = 101; int n, x; cin >> n; for (int i = 0; i < n; ++i) { cin >> x; mn = min(mn, x); } if (mn < 0) cout << NO n ; else { cout << YES n ; cout << 101 n ; for (int i = 0; i <=100; ++i) { cout << i << ; }cout << n ; } } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { long long n, k, a[300001], seti = 0, l, r, z = 0, maxi = 0, fz, lt = -1, rt = -1; cin >> n >> k; for (long long i = 0; i < n; i++) cin >> a[i]; l = 0; for (long long i = 0; i < n; i++) { if (a[i] == 0) { z++; if (z == k + 1) { r = i - 1; if (r - l + 1 > maxi) { maxi = r - l + 1; lt = l; rt = r; } z--; if (a[l] == 0) { l++; } else { for (long long j = l + 1; j < n; j++) { if (a[j] == 0) { l = j + 1; break; } } } } } } if (n - l > maxi) { lt = l; rt = n - 1; maxi = n - l; } cout << maxi << endl; if (lt != -1) for (long long i = lt; i <= rt; i++) a[i] = 1; for (long long i = 0; i < n; i++) cout << a[i] << ; }
|
#include <bits/stdc++.h> using namespace std; template <typename Arg1> void __f(const char* name, Arg1&& arg1) { cout << name << : << arg1 << n ; } template <typename Arg1, typename... Args> void __f(const char* names, Arg1&& arg1, Args&&... args) { const char* comma = strchr(names + 1, , ); cout.write(names, comma - names) << : << arg1 << | ; __f(comma + 1, args...); } inline int sbt(int x) { return __builtin_popcount(x); } inline long long gl(long long a, long long b) { return (b - a + 1); } inline long long mul(long long a, long long b, long long m = (long long)(1e9 + 7)) { return ((a % m) * (b % m)) % m; } inline long long add(long long a, long long b, long long m = (long long)(1e9 + 7)) { return (a + b) % m; } inline long long sub(long long a, long long b, long long m = (long long)(1e9 + 7)) { return (a - b + m) % m; } long long fastpow(long long a, long long b) { long long res = 1; while (b > 0) { if (b & 1) res = mul(res, a); a = mul(a, a); b >>= 1; } return res; } long long modinv(long long a) { return fastpow(a, (long long)(1e9 + 7) - 2); } void get_ac() { long long n, k; cin >> n >> k; string s; cin >> s; vector<vector<long long>> v; bool f; long long mink = 0, maxk = 0; while (1) { f = 0; vector<long long> va; for (int i = 0; i < n - 1; i++) { if (s[i] == R && s[i + 1] == L ) { swap(s[i], s[i + 1]); f = 1; va.push_back(i); i++; } } if (!f) break; v.push_back(va); maxk += (long long)(va.size()); mink++; } if (k < mink || k > maxk) { cout << -1; return; } long long i = 0, j = 0; while (k > mink - i) { cout << 1 << << v[i][j] + 1; cout << n ; j++; if (j == (long long)(v[i].size())) { i++; j = 0; } k--; } for (int l = i; l < mink; l++) { cout << ((long long)(v[l].size()) - j) << ; for (int m = j; m < (long long)(v[l].size()); m++) { cout << v[l][m] + 1 << ; } j = 0; cout << n ; } } int main() { cin.sync_with_stdio(false); cout.sync_with_stdio(false); cin.tie(NULL); { get_ac(); } return 0; }
|
#include <bits/stdc++.h> #pragma GCC optimize( O3 ) using namespace std; struct Point { int x; int y; }; int direction(Point a, Point b, Point c) { return (c.x - a.x) * (b.y - a.y) - (c.y - a.y) * (b.x - a.x); } bool onsegment(Point a, Point b, Point c) { return (min(a.x, b.x) <= c.x && max(a.x, b.x) >= c.x && min(a.y, b.y) <= c.y && max(a.y, b.y) >= c.y); } bool intersects(Point a, Point b, Point c, Point d) { int d1 = direction(c, d, a), d2 = direction(c, d, b), d3 = direction(a, b, c), d4 = direction(a, b, d); if (d1 * d2 < 0 && d3 * d4 < 0) { return true; } else if (d1 == 0 && onsegment(c, d, a)) { return true; } else if (d2 == 0 && onsegment(c, d, b)) { return true; } else if (d3 == 0 && onsegment(a, b, c)) { return true; } else if (d4 == 0 && onsegment(a, b, d)) { return true; } else { return false; } } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); Point a[5], b[5]; for (int i = 0; i < 4; i++) { int x, y; cin >> x >> y; a[i] = {x, y}; } a[4] = a[0]; for (int i = 0; i < 4; i++) { int x, y; cin >> x >> y; b[i] = {x, y}; } b[4] = b[0]; for (int i = 0; i < 4; i++) { if (intersects(b[i], b[i + 1], a[0], a[2]) || intersects(b[i], b[i + 1], a[1], a[3])) { return cout << YES n , 0; } } for (int i = 0; i < 4; i++) { if (b[i].x >= min(min(a[0].x, a[1].x), min(a[2].x, a[3].x)) && b[i].x <= max(max(a[0].x, a[1].x), max(a[2].x, a[3].x)) && b[i].y >= min(min(a[0].y, a[1].y), min(a[2].y, a[3].y)) && b[i].y <= max(max(a[0].y, a[1].y), max(a[2].y, a[3].y))) { return cout << YES n , 0; } } for (int i = 0; i < 5; i++) { a[i] = {a[i].x - a[i].y, a[i].x + a[i].y}; b[i] = {b[i].x - b[i].y, b[i].x + b[i].y}; } for (int i = 0; i < 4; i++) { if (a[i].x >= min(min(b[0].x, b[1].x), min(b[2].x, b[3].x)) && a[i].x <= max(max(b[0].x, b[1].x), max(b[2].x, b[3].x)) && a[i].y >= min(min(b[0].y, b[1].y), min(b[2].y, b[3].y)) && a[i].y <= max(max(b[0].y, b[1].y), max(b[2].y, b[3].y))) { return cout << YES n , 0; } } return cout << NO n , 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; vector<int> a; while (n) { int x = n, p = 1, m = 0; while (x) { if (x % 10) m += p; x /= 10; p *= 10; } n -= m; a.push_back(m); } cout << a.size() << endl; for (int &i : a) cout << i << ; }
|
#include <bits/stdc++.h> int main() { long long n; scanf( %lld , &n); long long a[1000005] = {0}; for (int i = 1; i <= n; i++) { scanf( %lld , &a[i]); } long long ans = 0; for (int i = 1; i <= n; i++) { ans = ans + a[i] * i - (i - 1); } printf( %lld , ans); return 0; }
|
#include <bits/stdc++.h> using lint = long long; using ld = long double; template <class T> using numr = std::numeric_limits<T>; struct input_t { template <class T> operator T() { T t; std::cin >> t; return t; } } input; namespace ns { using namespace std; template <int mod> struct NumberTheoreticTransform { vector<int> rev, rts; int base, max_base, root; NumberTheoreticTransform() : base(1), rev{0, 1}, rts{0, 1} { assert(mod >= 3 && mod % 2 == 1); auto tmp = mod - 1; max_base = 0; while (tmp % 2 == 0) tmp >>= 1, max_base++; root = 2; while (mod_pow(root, (mod - 1) >> 1) == 1) ++root; assert(mod_pow(root, mod - 1) == 1); root = mod_pow(root, (mod - 1) >> max_base); } inline int mod_pow(int x, int n) { int ret = 1; while (n > 0) { if (n & 1) ret = mul(ret, x); x = mul(x, x); n >>= 1; } return ret; } inline int inverse(int x) { return mod_pow(x, mod - 2); } inline unsigned add(unsigned x, unsigned y) { x += y; if (x >= mod) x -= mod; return x; } inline unsigned mul(unsigned a, unsigned b) { return 1ull * a * b % (unsigned long long)mod; } void ensure_base(int nbase) { if (nbase <= base) return; rev.resize(1 << nbase); rts.resize(1 << nbase); for (int i = 0; i < (1 << nbase); i++) { rev[i] = (rev[i >> 1] >> 1) + ((i & 1) << (nbase - 1)); } assert(nbase <= max_base); while (base < nbase) { int z = mod_pow(root, 1 << (max_base - 1 - base)); for (int i = 1 << (base - 1); i < (1 << base); i++) { rts[i << 1] = rts[i]; rts[(i << 1) + 1] = mul(rts[i], z); } ++base; } } void ntt(vector<int> &a) { const int n = (int)a.size(); assert((n & (n - 1)) == 0); int zeros = __builtin_ctz(n); ensure_base(zeros); int shift = base - zeros; for (int i = 0; i < n; i++) { if (i < (rev[i] >> shift)) { swap(a[i], a[rev[i] >> shift]); } } for (int k = 1; k < n; k <<= 1) { for (int i = 0; i < n; i += 2 * k) { for (int j = 0; j < k; j++) { int z = mul(a[i + j + k], rts[j + k]); a[i + j + k] = add(a[i + j], mod - z); a[i + j] = add(a[i + j], z); } } } } vector<int> multiply(vector<int> a, vector<int> b) { int need = a.size() + b.size() - 1; int nbase = 1; while ((1 << nbase) < need) nbase++; ensure_base(nbase); int sz = 1 << nbase; a.resize(sz, 0); b.resize(sz, 0); ntt(a); ntt(b); int inv_sz = inverse(sz); for (int i = 0; i < sz; i++) { a[i] = mul(a[i], mul(b[i], inv_sz)); } reverse(a.begin() + 1, a.end()); ntt(a); a.resize(need); return a; } }; } // namespace ns constexpr int mod = 998244353; lint inverse(lint x) { assert(x % mod); lint y = 1, u = mod, v = 0; while (x) { lint q = u / x; u -= q * x; std::swap(u, x); v -= q * y; std::swap(v, y); } assert(x == 0 && std::abs(u) == 1 && std::abs(y) == mod && std::abs(v) < mod); return v < 0 ? v + mod : v; } lint normalized(lint x) { if (x <= -mod || mod <= x) x %= mod; if (x < 0) x += mod; return x; } struct mint { lint value; mint() = default; mint(lint x) : value(normalized(x)) {} }; std::ostream &operator<<(std::ostream &os, mint x) { return os << x.value; } mint operator+(mint x, mint y) { lint z = x.value + y.value; if (mod <= z) z -= mod; return mint{z}; } mint operator-(mint x, mint y) { lint z = x.value - y.value; if (z < 0) z += mod; return mint{z}; } mint operator*(mint x, mint y) { return mint{x.value * y.value % mod}; } mint operator/(mint x, mint y) { return mint{x.value * inverse(y.value) % mod}; } mint &operator+=(mint &x, mint y) { return x = x + y; } mint &operator-=(mint &x, mint y) { return x = x - y; } mint &operator*=(mint &x, mint y) { return x = x * y; } mint &operator/=(mint &x, mint y) { return x = x / y; } bool operator==(mint x, mint y) { return x.value == y.value; } bool operator!=(mint x, mint y) { return x.value != y.value; } mint power(mint x, lint y) { mint z = 1; for (; y; y >>= 1) { if (y & 1) z *= x; x *= x; } return z; } int main() { std::cin.tie(nullptr); std::ios_base::sync_with_stdio(false); std::cout.setf(std::ios_base::fixed); std::cout.precision(15); lint n = (lint)input / 2, k = input; std::vector<int> a(10); while (k--) { int x = input; a.at(x) = 1; } while (!a.back()) a.pop_back(); ns::NumberTheoreticTransform<mod> ntt; std::vector<int> b = {1}; for (; n; n >>= 1) { if (n & 1ll) b = ntt.multiply(a, b); a = ntt.multiply(a, a); } std::vector<mint> c(b.size()); std::transform(std::begin(b), std::end(b), c.begin(), [](int x) { return x; }); std::cout << std::accumulate(std::begin(c), std::end(c), mint{0}, [](mint acc, mint x) { return acc + x * x; }) << n ; }
|
#include <bits/stdc++.h> using namespace std; const int N = 1e5 + 500; const int inf = 1e9 + 5; struct node { int l, r; } b[N]; bool cmp(node a, node b) { return a.l < b.l; } bool rcmp(node a, node b) { return a.r > b.r; } int n, m, a[N], cnt, rt, ls[N * 32], rs[N * 32], sz[N * 32], vl[N * 32], Big[N], Small[N], flag, b1[N], b2[N]; bool tag[N * 32]; void add(int &x, int l, int r, int pos) { if (!x) x = ++cnt; sz[x]++; vl[x]++; if (l == r) return; int mi = (l + r) >> 1; if (pos <= mi) add(ls[x], l, mi, pos); else add(rs[x], mi + 1, r, pos); } void Pd(int x) { if (x) tag[x] ^= 1, vl[x] = sz[x] - vl[x]; } void pd(int x) { if (tag[x]) Pd(ls[x]), Pd(rs[x]), tag[x] = 0; } void modify(int x, int l, int r, int pos) { if (!x) return; if (r <= pos) { Pd(x); return; } int mi = (l + r) >> 1; pd(x); modify(ls[x], l, mi, pos); if (mi < pos) modify(rs[x], mi + 1, r, pos); vl[x] = vl[ls[x]] + vl[rs[x]]; } int ask(int x, int l, int r, int pos) { if (!x) return 0; if (l >= pos) return vl[x]; int mi = (l + r) >> 1, ans = 0; pd(x); if (pos <= mi) ans += ask(ls[x], l, mi, pos); ans += ask(rs[x], mi + 1, r, pos); return ans; } void modifyy(int x, int l, int r, int pos) { if (!x) return; if (l >= pos) { Pd(x); return; } int mi = (l + r) >> 1; pd(x); if (pos <= mi) modifyy(ls[x], l, mi, pos); modifyy(rs[x], mi + 1, r, pos); vl[x] = vl[ls[x]] + vl[rs[x]]; } int askk(int x, int l, int r, int pos) { if (!x) return 0; if (r <= pos) return vl[x]; int mi = (l + r) >> 1, ans = 0; pd(x); ans += askk(ls[x], l, mi, pos); if (mi < pos) ans += askk(rs[x], mi + 1, r, pos); return ans; } int main() { scanf( %d%d , &n, &m); long long ans = 1ll * n * (n - 1) / 2 * (n - 2) / 3; long long spc = 0; for (int i = 1; i <= n; i++) scanf( %d , a + i); for (int i = 1; i <= m; i++) scanf( %d%d , &b[i].l, &b[i].r); sort(b + 1, b + m + 1, cmp); sort(a + 1, a + n + 1); for (int i = 1, j = 1; i <= n; i = j) { while (j <= n && a[i] == a[j]) ++j; for (int k = i; k <= j - 1; k++) b1[k] = j - k - 1, b2[k] = k - i; ans -= 1ll * (j - i) * (j - i - 1) / 2 * (j - i - 2) / 3; spc += 1ll * (j - i) * (j - i - 1) / 2 * (n - j + i); } cnt = rt = 0; for (int i = 1; i <= n; i++) add(rt, 0, inf, a[i]); int j = 1; for (int i = 1; i <= n; i++) { while (j <= m && b[j].l <= a[i]) { modify(rt, 0, inf, b[j].r), ++j; } int t = ask(rt, 0, inf, a[i] + 1); Big[i] += t; Small[i] += n - i - b1[i] - t; } cnt = rt = 0; memset(sz, 0, sizeof(sz)); memset(vl, 0, sizeof(vl)); memset(ls, 0, sizeof(ls)); memset(rs, 0, sizeof(rs)); memset(tag, 0, sizeof(tag)); for (int i = 1; i <= n; i++) add(rt, 0, inf, a[i]); sort(b + 1, b + m + 1, rcmp); j = 1; for (int i = n; i >= 1; i--) { while (j <= m && b[j].r >= a[i]) modifyy(rt, 0, inf, b[j].l), ++j; int t = askk(rt, 0, inf, a[i] - 1); Small[i] += t; Big[i] += i - 1 - b2[i] - t; } long long tmp = 0; for (int i = 1; i <= n; i++) { tmp += 1ll * Big[i] * (Big[i] - 1) / 2; tmp += 1ll * Small[i] * (Small[i] - 1) / 2; } tmp = (tmp + spc) / 2; printf( %I64d n , ans - tmp); return 0; }
|
#include <bits/stdc++.h> using namespace std; typedef long long LL; typedef pair<int, int> PII; typedef pair<LL,LL> PLL; const int INF = 0x3f3f3f3f, N = 1e5 + 10; inline int lc(int u) {return u << 1;} inline int rc(int u) {return u << 1 | 1;} inline int lowbit(int x) {return x & (-x);} int y[27] = {10010,11020,20011,21012,11011,21021,22022,12021,11011,12012,10120,11130,20121,21122,11121,21131,22132,12131,11121,12122,10221,11231,12113,20222,21223,11222}; char x[30000]; inline void solve() { for (int i = 0; i < 26; i ++ ) { if (x[y[i]] == 0) x[y[i]] = i + a ; } int n; cin >> n; for (int i = 1; i <= n; i ++ ) { int res = 0; for (int j = 0; j < 5; j ++ ) { int tmp; cin >> tmp; res = res * 10 + tmp; } cout << x[res]; } } int main() { // ios::sync_with_stdio(false), cin.tie(nullptr); // int t; cin >> t; // while (t -- ) solve(); return 0; }
|
#include <bits/stdc++.h> using namespace std; const int N = 1e6 + 10; int n, k, root, ans; vector<int> g[N]; int dfs(int u, int f) { if (g[u].size() == 1) return 0; vector<int> d; for (int v : g[u]) if (v != f) d.push_back(dfs(v, u) + 1); sort(d.begin(), d.end()); int sz = d.size(); while (sz >= 2) { if (d[sz - 1] + d[sz - 2] <= k) break; ans++, sz--; d.pop_back(); } int ret = d.back(); d.clear(); return ret; } int main() { scanf( %d %d , &n, &k); for (int i = 1; i < n; i++) { int u, v; scanf( %d %d , &u, &v); g[u].push_back(v); g[v].push_back(u); } for (int i = 1; i <= n; i++) if (g[i].size() > 1) { root = i; break; } dfs(root, -1); printf( %d , ans + 1); return 0; }
|
#include <bits/stdc++.h> #pragma GCC optimize( Ofast,no-stack-protector,unroll-loops ) #pragma GCC optimize( no-stack-protector,fast-math ) using namespace std; const long long N = 1e6 + 100, OO = 724249387, T = (1 << 20) + 10, M = 998244353, P = 6151, SQ = 280, lg = 64; long long n, m, k, num, ed, t; vector<long long> v[N]; bool mark[N]; void dfs(long long x) { mark[x] = 1; num++; for (auto u : v[x]) if (!mark[u]) dfs(u); } int32_t main() { ios::sync_with_stdio(false), cin.tie(0), cout.tie(0); cin >> n >> m >> k; for (long long i = 0; i < m; i++) { long long x, y; cin >> x >> y; v[x].push_back(y); v[y].push_back(x); } for (long long i = 1; i <= n; i++) { if (!mark[i]) { num = 0; dfs(i); ed += min(num, k); t++; } } ed /= 2; if (k == 1) return cout << max((long long)0, t - 2), 0; cout << max((long long)0, t - 1 - ed); return 0; }
|
#include <bits/stdc++.h> using namespace std; inline int read() { char ch = getchar(); int res = 0, flag = 1; while (ch < 0 || ch > 9 ) { if (ch == - ) flag = -1; ch = getchar(); } while (ch >= 0 && ch <= 9 ) { res = res * 10 + ch - 0 ; ch = getchar(); } return res * flag; } int r, c, n, k, p[3005][3005], x, y, cnt[3005], nxt[3005], lst[3005], tmp[3005]; long long ans; int main() { r = read(); c = read(); n = read(); k = read(); for (register int i = 1; i <= n; ++i) { x = read(); y = read(); p[x][++p[x][0]] = y; } for (register int i = 1; i <= r; ++i) sort(p[i] + 1, p[i] + p[i][0] + 1); for (register int i = r; i; --i) { int h = 1, t = 0, s = 0; long long now = 0; for (register int j = 1; j <= p[i][0]; ++j) ++cnt[p[i][j]]; while (1) { while (t < c && s < k) { ++t; s += cnt[t]; } if (s < k) break; while (h <= t && s >= k) { s -= cnt[h]; ++h; now += c - t + 1; } } nxt[0] = 1; lst[c + 1] = c; for (register int j = 1; j <= c; ++j) { nxt[j] = j + 1; lst[j] = j - 1; } for (register int j = 1; j <= c; ++j) if (!cnt[j]) { nxt[lst[j]] = nxt[j]; lst[nxt[j]] = lst[j]; } memcpy(tmp, cnt, sizeof(cnt)); for (register int j = r; j >= i; --j) { ans += now; for (register int u = 1; u <= p[j][0]; ++u) { h = t = p[j][u]; int s1 = tmp[h], s2 = 0; while (nxt[t] <= c && s1 + s2 + tmp[nxt[t]] <= k) { t = nxt[t]; s2 += tmp[t]; } while (1) { if (s1 + s2 == k) now -= (h - lst[h]) * (nxt[t] - t); h = lst[h]; s1 += tmp[h]; if (!h || s1 > k) break; while (s1 + s2 > k) { s2 -= tmp[t]; t = lst[t]; } } --tmp[p[j][u]]; if (!tmp[p[j][u]]) { nxt[lst[p[j][u]]] = nxt[p[j][u]]; lst[nxt[p[j][u]]] = lst[p[j][u]]; } } } } printf( %lld n , ans); return 0; }
|
#include <bits/stdc++.h> using namespace std; const int MAX = int(1e9 + 5); const long long MAXL = long long(1e18 + 5); const long long MOD = long long(1e9 + 7); const long long MOD2 = long long(998244353); void fastio() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); return; } void precision(int x) { cout.setf(ios::fixed | ios::showpoint); cout.precision(x); return; } long long gcd(long long a, long long b) { if (a > b) { swap(a, b); } if (a == 0) { return b; } if (a == b) { return a; } return gcd(b % a, a); } long long lcm(long long a, long long b) { return a / gcd(a, b) * b; } bool is_prime(long long a) { if (a == 1) { return false; } long long i; for (i = 2; i * i <= a; i++) { if (a % i == 0) { return false; } } return true; } bool is_square(long long a) { long long b = long long(sqrt(a)); return (b * b == a); } bool is_cube(long long a) { long long b = long long(cbrt(a)); return (b * b * b == a); } int digit_sum(long long a) { int sum = 0; while (a) { sum += int(a % 10); a /= 10; } return sum; } long long binpow(long long a, int b) { long long ans = 1; while (b) { if ((b & 1) == 1) { ans *= a; } b >>= 1; a *= a; } return ans; } long long binpow_by_mod(long long a, long long b, long long mod) { long long ans = 1; while (b) { if ((b & 1) == 1) { ans *= a; ans %= mod; } b >>= 1; a *= a; a %= mod; } return ans; } long long factorial(int a) { int i; long long ans = 1; for (i = 2; i <= a; i++) { ans *= long long(i); } return ans; } long long factorial_by_mod(int a, long long mod) { int i; long long ans = 1; for (i = 2; i <= a; i++) { ans *= long long(i); ans %= mod; } return ans; } const int N = 200005; int a[N]; int n; void solve() { int i, j; cin >> n; for (i = 1; i <= n; i++) { cin >> a[i]; } sort(a + 1, a + n + 1); for (i = 2; i <= (n / 2) + 1; i++) { cout << a[i] << << a[1] << endl; } return; } void precalc() { return; } int main() { fastio(); precalc(); int tests = 1, tc; cin >> tests; for (tc = 1; tc <= tests; tc++) { solve(); } return 0; }
|
#include <bits/stdc++.h> using namespace std; const long long N = 1e3 + 10; long long n, m, ans, h[N][N]; char ar[N][N]; bool get(long long i, long long j) { long long x = h[i][j]; i -= x; if (i < 0) return 0; if (h[i][j] != x) return 0; i -= x; if (i < 0) return 0; return h[i][j] >= x; } bool ok(long long row, long long l, long long r) { long long x = h[row][l]; if (ar[row][l] != ar[row][r]) return 0; row -= x; if (ar[row][l] != ar[row][r]) return 0; row -= x; return ar[row][l] == ar[row][r]; } long long choose2(long long x) { return (x * (x - 1)) / 2; } long long solve(vector<bool> &vec, long long row) { assert(vec.size() == m); long long res = 0; for (long long i = 0; i < vec.size(); i++) { if (!vec[i]) continue; long long r = i + 1; while (r < vec.size() && vec[r] && h[row][i] == h[row][r] && ok(row, i, r)) r++; res += choose2(r - i + 1); i = r - 1; } return res; } int32_t main() { ios::sync_with_stdio(0); cin.tie(0); cin >> n >> m; for (long long i = 0; i < n; i++) for (long long j = 0; j < m; j++) cin >> ar[i][j]; for (long long j = 0; j < m; j++) h[0][j] = 1; for (long long i = 1; i < n; i++) for (long long j = 0; j < m; j++) { if (ar[i][j] == ar[i - 1][j]) h[i][j] = h[i - 1][j] + 1; else h[i][j] = 1; } for (long long i = 0; i < n; i++) { vector<bool> vec; for (long long j = 0; j < m; j++) vec.push_back(get(i, j)); ans += solve(vec, i); } cout << ans << endl; }
|
#include <bits/stdc++.h> using namespace std; void solve(int test_case) { int a, b; cin >> a >> b; cout << b % max(b / 2 + 1, a) << n ; } int main() { ios::sync_with_stdio(false); cin.tie(nullptr); int t; cin >> t; for (int test_case = 1; test_case <= t; ++test_case) { solve(test_case); } }
|
#include <bits/stdc++.h> using namespace std; int a[1000001]; int mod = 1000000007; int f(int x, int y) { int res = 1; long long xx = x; while (y > 0) { if (y % 2) res = (res * xx) % mod; xx = (xx * xx) % mod; y = y / 2; } return res; } int main() { int t, p; int n, ba; int i, j; scanf( %d , &t); for (p = 1; p <= t; p++) { scanf( %d%d , &n, &ba); for (i = 1; i <= n; i++) scanf( %d , &a[i]); if (ba == 1) { printf( %d n , n % 2); continue; } sort(a + 1, a + n + 1); long long cur = 1; for (i = n - 1; i >= 1; i--) { if (a[i] == a[i + 1]) { if (cur == 0) cur++; else cur--; } else { if (cur == 0) cur++; else { while (a[i + 1] > a[i] && cur < i) { a[i + 1]--; cur = cur * ba; } if (cur < i) cur--; else break; } } } if (i == 0) printf( %d n , (cur * f(ba, a[1])) % mod); else { int res = (cur * f(ba, a[i + 1])) % mod; for (; i >= 1; i--) res = ((res - f(ba, a[i])) % mod + mod) % mod; printf( %d n , res); } } return 0; }
|
#include <bits/stdc++.h> using namespace std; int n; char grid[101][101]; bool rw[101], cl[101]; int main() { bool f, r = 0, c = 0; int cnt; scanf( %d , &n); for (int i = 0; i < n; ++i) { scanf( %s , grid[i]); f = 1; for (int j = 0; j < n; ++j) { f &= (grid[i][j] == E ); if (grid[i][j] == . ) rw[i] = cl[j] = 1; } c |= f; } for (int j = 0; j < n; ++j) { f = 1; for (int i = 0; i < n; ++i) { f &= (grid[i][j] == E ); } r |= f; } if (r && c) { printf( -1 n ); } else { cnt = 0; for (int i = 0; i < n; ++i) cnt += rw[i]; if (cnt == n) { for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) { if (grid[i][j] == . ) { printf( %d %d n , i + 1, j + 1); break; } } } } else { for (int j = 0; j < n; ++j) { for (int i = 0; i < n; ++i) { if (grid[i][j] == . ) { printf( %d %d n , i + 1, j + 1); break; } } } } } return 0; }
|
#include <bits/stdc++.h> int main() { int n, k, a[4] = {2, 3, 4, 5}, x, min = 250; scanf( %d %d , &n, &k); if (n * 5 == k || n * 3 == k || n * 4 == k) { printf( 0 ); return 0; } for (int i = n; i >= 0; i--) { x = i * 5; if (x > k) continue; for (int j = n; j >= 0; j--) { x = i * 5 + j * 4; if (x > k) continue; for (int z = n; z >= 0; z--) { x = i * 5 + j * 4 + z * 3; if (x > k) continue; for (int l = 0; l <= n; l++) { x = i * 5 + j * 4 + z * 3 + l * 2; if (x > k) break; if (x == k && l < min && (i + j + z + l == n)) min = l; } } } } printf( %d , min); return 0; }
|
#include <bits/stdc++.h> using namespace std; bool check(vector<vector<int>> &a, int n, int x) { deque<pair<int, int>> q; map<pair<int, int>, bool> was; q.push_back({1, 1}); was[{1, 1}] = true; int dx[] = {1, 0, -1, 0}; int dy[] = {0, 1, 0, -1}; while (!q.empty()) { auto u = q.front(); q.pop_front(); for (int i = 0; i < 4; i++) { int xx = u.first + dx[i]; int yy = u.second + dy[i]; if (xx == n && yy == n) return false; if (a[xx][yy] == x && !was[{xx, yy}]) { q.push_back({xx, yy}); was[{xx, yy}] = true; } } } return true; } void v(vector<vector<int>> &a, int n) { for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { cout << a[i][j]; } cout << endl; } } void solve() { vector<vector<int>> a; int n; cin >> n; a = vector<vector<int>>(n + 2, vector<int>(n + 2, 2)); for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { char x; cin >> x; if (x != S && x != F ) { a[i][j] = x - 0 ; } } } vector<pair<int, int>> c = { {n - 1, n - 1}, {n - 1, n}, {n, n - 1}, {n - 2, n}, {n, n - 2}}; if (check(a, n, 1) && check(a, n, 0)) { cout << 0 << endl; return; } for (int i = 0; i < c.size(); i++) { a[c[i].first][c[i].second] = 1 - a[c[i].first][c[i].second]; if (check(a, n, 1) && check(a, n, 0)) { cout << 1 << n ; cout << c[i].first << << c[i].second << endl; return; } a[c[i].first][c[i].second] = 1 - a[c[i].first][c[i].second]; } for (int i = 0; i < c.size(); i++) { for (int j = i + 1; j < c.size(); j++) { a[c[i].first][c[i].second] = 1 - a[c[i].first][c[i].second]; a[c[j].first][c[j].second] = 1 - a[c[j].first][c[j].second]; if (check(a, n, 1) && check(a, n, 0)) { cout << 2 << n ; cout << c[i].first << << c[i].second << endl; cout << c[j].first << << c[j].second << endl; return; } a[c[i].first][c[i].second] = 1 - a[c[i].first][c[i].second]; a[c[j].first][c[j].second] = 1 - a[c[j].first][c[j].second]; } } } int main() { ios::sync_with_stdio(false); cin.tie(0); int t = 1; cin >> t; for (int i = 1; i <= t; i++) { solve(); } }
|
#include <bits/stdc++.h> using namespace std; long long t[5005], c[5005], ans[5005], n, i, l, b, v; int main() { cin >> n; for (i = 1; i <= n; i++) cin >> t[i]; for (l = 1; l <= n; l++) { for (i = 1; i <= n; i++) c[i] = 0; b = 0; for (i = l; i <= n; i++) { v = t[i]; c[v]++; if (c[v] > c[b] || (c[v] == c[b] && v < b)) b = v; ans[b]++; } } for (i = 1; i <= n - 1; i++) cout << ans[i] << ; cout << ans[n] << endl; return 0; }
|
#include <bits/stdc++.h> int main() { int l, r, a, n; scanf( %d %d %d , &l, &r, &a); if (l > r) { if (r + a < l) { printf( %d n , 2 * (r + a)); } else { n = r + a - l; printf( %d n , 2 * (l + n / 2)); } } else { if (l + a < r) { printf( %d n , 2 * (l + a)); } else { n = l + a - r; printf( %d n , 2 * (r + n / 2)); } } return 0; }
|
#include <bits/stdc++.h> using namespace std; const int N = 200010; pair<int, int> bug[N]; pair<int, pair<int, int> > stud[N]; set<pair<int, int> > smart; int ans[N]; int studs, bugs, exams; long long solve(int days) { long long sum = 0; smart.clear(); int last = 0; for (int i = 0; i < bugs; i += days) { while (last < studs && stud[last].first >= bug[i].first) { smart.insert(stud[last].second); last++; } if (smart.empty()) { return (long long)1e18; } pair<int, int> t = *(smart.begin()); smart.erase(smart.begin()); sum += t.first; for (int j = i; j < bugs && j < i + days; j++) { ans[bug[j].second] = t.second; } } return sum; } int main() { scanf( %d%d%d , &studs, &bugs, &exams); for (int i = 0; i < bugs; i++) { scanf( %d , &(bug[i].first)); bug[i].second = i; } for (int i = 0; i < studs; i++) { scanf( %d , &(stud[i].first)); } for (int i = 0; i < studs; i++) { scanf( %d , &(stud[i].second.first)); stud[i].second.second = i; } sort(bug, bug + bugs); reverse(bug, bug + bugs); sort(stud, stud + studs); reverse(stud, stud + studs); int ll = 1, rr = bugs + 1; while (ll < rr) { int mid = (ll + rr) >> 1; if (solve(mid) <= exams) rr = mid; else ll = mid + 1; } if (ll > bugs) { cout << NO n ; return 0; } solve(ll); printf( YES n ); for (int i = 0; i < bugs; i++) { printf( %d , ans[i] + 1); } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { double a, b, mn = 1e12; cin >> a >> b; int n; cin >> n; while (n--) { double x, y, v, dis; cin >> x >> y >> v; dis = sqrt((a - x) * (a - x) + (b - y) * (b - y)); dis /= v; mn = min(mn, dis); } cout << fixed << setprecision(7) << mn << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; struct node { int to, id; }; vector<node> E[10005]; vector<int> Ans; int dep[10005], fa[10005][15], Id[10005], S1[10005], S0[10005], Stk[10005], cnt, n1, n, m; bool mk[10005], Mk[10005]; void dfs(int x, int f) { mk[x] = 1; dep[x] = dep[f] + 1, fa[x][0] = f; for (int i = (0), i_ = (E[x].size() - 1); i <= i_; i++) { int y = E[x][i].to; if (!mk[y]) { Stk[++cnt] = y; Id[y] = E[x][i].id; dfs(y, x); } } } int LCA(int x, int y) { if (dep[x] > dep[y]) swap(x, y); int d = dep[y] - dep[x]; for (int i = (0), i_ = (13); i <= i_; i++) if (d & (1 << i)) y = fa[y][i]; for (int i = (13), i_ = (0); i >= i_; i--) if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i]; return x == y ? x : fa[x][0]; } void Init() { for (int j = (1), j_ = (13); j <= j_; j++) for (int i = (1), i_ = (cnt); i <= i_; i++) fa[Stk[i]][j] = fa[fa[Stk[i]][j - 1]][j - 1]; } void Dfs(int x) { for (int i = (0), i_ = (E[x].size() - 1); i <= i_; i++) { int y = E[x][i].to; if (Id[y] == E[x][i].id) Dfs(y); else if (dep[y] < dep[x] && y != fa[x][0]) { if ((dep[x] & 1) == (dep[y] & 1)) { n1++; S1[x]++, S1[y]++, S1[LCA(x, y)] -= 2; Mk[E[x][i].id] = 1; } else S0[x]++, S0[y]++, S0[LCA(x, y)] -= 2; } } } void DFS(int x) { for (int i = (0), i_ = (E[x].size() - 1); i <= i_; i++) { int y = E[x][i].to; if (Id[y] == E[x][i].id) { DFS(y); S0[x] += S0[y], S1[x] += S1[y]; } } } void Deal() { if (!n1) { for (int i = (1), i_ = (m); i <= i_; i++) Ans.push_back(i); return; } for (int i = (1), i_ = (n); i <= i_; i++) if (S1[i] == n1 && !S0[i]) Ans.push_back(Id[i]); if (n1 == 1) for (int i = (1), i_ = (m); i <= i_; i++) if (Mk[i]) Ans.push_back(i); } int main() { int a, b; scanf( %d%d , &n, &m); for (int i = (1), i_ = (m); i <= i_; i++) { scanf( %d%d , &a, &b); E[a].push_back((node){b, i}); E[b].push_back((node){a, i}); } for (int i = (1), i_ = (n); i <= i_; i++) if (!mk[i]) cnt = 0, dfs(i, 0), Init(), Dfs(i), DFS(i); Deal(); printf( %d n , Ans.size()); sort(Ans.begin(), Ans.end()); for (int i = (0), i_ = (Ans.size() - 1); i <= i_; i++) printf( %d , Ans[i]); puts( ); return 0; }
|
#include <bits/stdc++.h> using namespace std; const double PI = acos(-1.0); const int N = 1e6 + 5; int f[N]; int a[] = {1, 2}; int na = 2; int main() { int cnt; cin >> cnt; if (cnt == 1) { cout << 1 1 n1 ; return 0; } int x = 1; for (int i = 2; i < N; i++) { if (i % 2 == 0) x++; if (x == cnt) { cout << i << 2 n1 2 ; return 0; } } return 0; }
|
#include <cstdio> #include <cmath> long long T, n; bool flag; int main() { scanf( %d , &T); for(int t = 1; t <= T; t ++) { scanf( %lld , &n); flag = false; for(long long i = 2; i <= n; i *= 2) { if(n == i) { printf( NO n ); flag = true; break; } } if(!flag) printf( YES n ); } return 0; }
|
#include <bits/stdc++.h> using namespace std; const int maxn = 3020; long long a[maxn], b[maxn]; long long dp1[maxn][maxn]; int n; bool cmp(int x, int y) { return x > y; } int main() { while (cin >> n) { for (int i = 0; i < n; i++) cin >> a[i]; for (int i = 0; i < n; i++) { a[i] -= i; b[i] = a[i]; } sort(b, b + n); memset(dp1, 0, sizeof(dp1)); for (int i = 0; i < n; i++) { long long minx = dp1[i][0]; for (int j = 0; j < n; j++) { minx = min(minx, dp1[i][j]); dp1[i + 1][j] = minx + abs(a[i] - b[j]); } } long long min_up = dp1[n][0]; for (int i = 1; i < n; i++) { min_up = min(min_up, dp1[n][i]); } cout << min_up << endl; } return 0; }
|
#include <bits/stdc++.h> #pragma GCC optimize( O2,unroll-loops ) using namespace std; const int inf = 1000000010; const long long INF = 1000000000000001000LL; const int mod = 1000000007; const int MAXN = 100200, SQ = 320, NSQ = MAXN / SQ + 1; int n, m, w, u, v, x, y, t, a, b, maxb; int A[MAXN], B[MAXN], ans[MAXN], lazy[NSQ]; pair<long long, long long> X[MAXN]; vector<int> vec[MAXN]; struct CHT { pair<long long, int> cht[SQ]; int L, R; inline long long Inter(pair<long long, long long> x, pair<long long, long long> y) { if (x.first == y.first) return (x <= y ? -INF : INF); return (x.second - y.second) / (y.first - x.first) + ((x.second - y.second) % (y.first - x.first) > 0); } inline void Add(int a) { while (R && Inter(X[cht[R - 1].second], X[a]) <= cht[R - 1].first) R--; if (!R) cht[R++] = {-INF, a}; else cht[R] = {Inter(X[cht[R - 1].second], X[a]), a}, R++; } inline pair<long long, long long> Get(long long x) { while (L + 1 < R && cht[L + 1].first <= x) L++; int i = cht[L].second; return {X[i].first * x + X[i].second, i}; } } cht[NSQ]; void Build(int id) { int tl = id * SQ, tr = min(MAXN, tl + SQ); cht[id].L = cht[id].R = 0; for (int i = tl; i < tr; i++) { X[i].second += lazy[id] * X[i].first; cht[id].Add(i); } lazy[id] = 0; } void Add(int l, int r, int val) { int idl = -1, idr = -1; while (l < r && l % SQ) idl = l / SQ, X[l].second += val * l, l++; while (l < r && r % SQ) idr = r / SQ, r--, X[r].second += val * r; while (l < r) lazy[l / SQ] += val, l += SQ; if (idl != -1) Build(idl); if (idr != -1) Build(idr); } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); cin >> n >> w; for (int i = 1; i <= n; i++) { cin >> A[i] >> B[i]; vec[B[i]].push_back(i); maxb = max(maxb, B[i]); } for (int i = 0; i < MAXN; i++) X[i].first = i; for (int i = 0; i * SQ < MAXN; i++) Build(i); int ted = n; for (int i = 0; i <= maxb + 1; i++) { pair<long long, long long> p = {-inf, -1}; for (int j = 0; j * SQ + SQ <= MAXN; j++) p = max(p, cht[j].Get(lazy[j])); cout << p.first + 1ll * ted * i * w << << p.second << n ; for (int j : vec[i]) Add(0, A[j] + 1, +1), ted--; } return 0; }
|
#include <bits/stdc++.h> using namespace std; using namespace std::chrono; long long mod = 1000000007; void __print(int x) { cerr << x; } void __print(long x) { cerr << x; } void __print(long long x) { cerr << x; } void __print(unsigned x) { cerr << x; } void __print(unsigned long x) { cerr << x; } void __print(unsigned long long x) { cerr << x; } void __print(float x) { cerr << x; } void __print(double x) { cerr << x; } void __print(long double x) { cerr << x; } void __print(char x) { cerr << << x << ; } void __print(const char *x) { cerr << << x << ; } void __print(const string &x) { cerr << << x << ; } void __print(bool x) { cerr << (x ? true : false ); } template <typename T, typename V> void __print(const pair<T, V> &x) { cerr << { ; __print(x.first); cerr << , ; __print(x.second); cerr << } ; } template <typename T> void __print(const T &x) { int f = 0; cerr << { ; for (auto &i : x) cerr << (f++ ? , : ), __print(i); cerr << } ; } void _print() { cerr << ] n ; } template <typename T, typename... V> void _print(T t, V... v) { __print(t); if (sizeof...(v)) cerr << , ; _print(v...); } void init() {} void solve() { long long x, y, n, i, j; cin >> n; vector<pair<long long, long long> > adj(n - 1); vector<long long> deg(n + 1, 0); for (i = 0; i < n - 1; i++) { cin >> x >> y; deg[x]++; deg[y]++; adj[i] = {x, y}; } vector<long long> edge; for (i = 0; i < n + 1; i++) { if (deg[i] == 1) { edge.push_back(i); } } if ((int)edge.size() == 2) { for (i = 0; i < n - 1; i++) { cout << i << endl; } } else { long long ep = 0, elp = 3; for (i = 0; i < n - 1; i++) { bool flag = false; for (j = 0; j < 3; j++) { if (edge[j] == adj[i].first or edge[j] == adj[i].second) { flag = true; } } if (flag) { cout << ep << endl; ep++; } else { cout << elp << endl; elp++; } } } } int main() { init(); auto start = high_resolution_clock::now(); int T = 1; while (T--) { solve(); } auto stop = high_resolution_clock::now(); auto duration = duration_cast<milliseconds>(stop - start); }
|
#include <bits/stdc++.h> #define int long long #define f(i,a,n) for (int i = a; i < n; ++i) #define f1(i,a,n) for(int i=n-1;i>=a;i--) #define ff first #define ss second #define pb push_back #define mp make_pair #define all(x) x.begin(), x.end() #define sortall(x) sort(all(x)) #define fastio ios_base::sync_with_stdio(false), cin.tie(NULL); #define w1 solve(); #define mod (int)(1e9 + 7) #define prq priority_queue #define gcd __gcd #define sz(x) (int)x.size() #define w(t) int t; cin>>t; while (t--) { solve(); } #define N 1000001 using namespace std; void __print(int x) {cerr << x;} void __print(float x) {cerr << x;} void __print(double x) {cerr << x;} void __print(long double x) {cerr << x;} void __print(char x) {cerr << << x << ;} void __print(const char *x) {cerr << << x << ;} void __print(const string &x) {cerr << << x << ;} void __print(bool x) {cerr << (x ? true : false );} template<typename T, typename V> void __print(const pair<T, V> &x) {cerr << { ; __print(x.first); cerr << , ; __print(x.second); cerr << } ;} template<typename T> void __print(const T &x) {int f = 0; cerr << { ; for (auto &i : x) cerr << (f++ ? , : ), __print(i); cerr << } ;} void _print() {cerr << ] n ;} template <typename T, typename... V> void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << , ; _print(v...);} #ifdef Avash_Local_Machine #define debug(x...) cerr << [ << #x << ] = [ ; _print(x) #else #define debug(x...) #endif typedef vector<int> vi; typedef pair<int, int> pii; typedef vector<pii> vpi; typedef vector<string> vs; typedef vector<char> vc; const int INF = (int)(1e17); const double PI = 3.141592653589793; int dx[4] = { -1, 0, 1, 0}; int dy[4] = {0, 1, 0, -1}; string path = URDL ; void solve() { int q; cin >> q; char c; int n , id = 1; set<pii> set1, set2; //set1 for price,id //set2 for id,price while (q--) { cin >> c; if (c == 1 ) { cin >> n; set1.insert(mp(n, id)); set2.insert(mp(id, n)); ++id; } if (c == 2 ) { auto it = *set2.begin(); cout << it.ff << n ; auto ind = set1.lower_bound(mp(it.ss, it.ff)); set1.erase(ind); set2.erase(set2.begin()); } if (c == 3 ) { auto it = *set1.rbegin(); // debug(it); auto ind = set1.lower_bound(mp(it.ff, -INF)); // debug(ind); cout << (*ind).ss << n ; auto ind1 = set2.lower_bound(mp((*ind).ss, (*ind).ff)); // debug(*ind1); set2.erase(ind1); set1.erase(ind); // debug(set2); } } } int32_t main() { fastio w1 // w(t) return 0; }
|
#include <bits/stdc++.h> using namespace std; int tt; int n, m; int main() { scanf( %d , &tt); while (tt--) { scanf( %d %d , &n, &m); long long z = (n - m), g = m + 1; long long k = z / g; long long ans = (n * 1ll * (n + 1) / 2) - (k * (k + 1) / 2) * g - (k + 1) * (z % g); printf( %lld n , ans); } return 0; }
|
#include <bits/stdc++.h> using namespace std; int n, F[500007], wartosc[500007], Fat[500007]; bool valid_number[500007], valid_edges[300007], query_node[500007]; int Find(int a) { return (a == Fat[a] ? a : Fat[a] = Find(Fat[a])); } inline void Union(int a, int b) { a = Find(a); b = Find(b); F[a] = F[b] = ++n; Fat[a] = Fat[b] = F[n] = Fat[n] = n; } vector<int> G[500007]; int pre[500007], pos[500007], order[500007], nr; bool visited[500007]; void DFS(int v) { visited[v] = 1; pre[v] = ++nr; order[nr] = v; for (auto i : G[v]) if (!visited[i]) DFS(i); pos[v] = nr; } int tree[1 << 20], M = 1; inline void zrob_drzewa() { for (int i = 1; i <= n; i++) if (F[i] != i) { G[i].push_back(F[i]); G[F[i]].push_back(i); } for (int i = 1; i <= n; i++) if (F[i] == i) DFS(i); while (M < n) M *= 2; for (int i = 1; i <= n; i++) tree[i + M - 1] = wartosc[order[i]]; for (int i = M - 1; i > 0; i--) tree[i] = max(tree[i * 2], tree[i * 2 + 1]); } void remove_invalid(int v) { if (valid_number[tree[v]]) return; tree[v] = 0; if (v >= M) return; remove_invalid(v * 2); remove_invalid(v * 2 + 1); tree[v] = max(tree[v * 2], tree[v * 2 + 1]); } int maks(int a, int b, int v = 1, int p = 1, int k = M) { if (p > b || k < a) return 0; if (p >= a && k <= b) { remove_invalid(v); return tree[v]; } return max(maks(a, b, v * 2, p, (p + k) / 2), maks(a, b, v * 2 + 1, (p + k) / 2 + 1, k)); } int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); int m, q; cin >> n >> m >> q; n = n; for (int i = 1, a; i <= n; i++) { cin >> wartosc[i]; valid_number[wartosc[i]] = true; F[i] = i; Fat[i] = i; } vector<pair<int, int>> edges(m + 1); for (int i = 1; i <= m; i++) { cin >> edges[i].first >> edges[i].second; valid_edges[i] = true; } vector<pair<int, int>> queries(q); for (int i = 0; i < q; i++) { cin >> queries[i].first >> queries[i].second; if (queries[i].first == 2) valid_edges[queries[i].second] = false; } for (int i = 1; i <= m; i++) if (valid_edges[i]) Union(edges[i].first, edges[i].second); int Res[q]; for (int i = q - 1; i >= 0; i--) { if (queries[i].first == 1) { int v = queries[i].second; v = Find(v); Res[i] = v; } else { int j = queries[i].second; int a = edges[j].first, b = edges[j].second; Union(a, b); } } zrob_drzewa(); for (int i = 0; i < q; i++) { if (queries[i].first == 2) continue; int v = Res[i]; int res = maks(pre[v], pos[v]); cout << res << n ; valid_number[res] = false; valid_number[0] = true; } }
|
#include <bits/stdc++.h> using namespace std; int a[200005]; int main() { int t, k, i, j, n, m, x, y, q, c; cin >> n >> k; if ((n - 1) % k >= 2) { printf( %d n , 2 * ((n - 1) / k) + 2); } else if ((n - 1) % k == 1) { printf( %d n , 2 * ((n - 1) / k) + 1); } else { printf( %d n , 2 * ((n - 1) / k)); } for (i = 0; i < k; i++) a[i] = 1; for (i = 2; i <= n; i++) { j = (i - 2) % k; printf( %d %d n , i, a[j]); a[j] = i; } return 0; }
|
#include <bits/stdc++.h> using namespace std; int N, Y[50001]; set<int> pos[50001]; set<int> used; priority_queue<int> q; int next(int x) { int temp = x; while (x != 0) { if (used.count(x) == 0) return x; x /= 2; } return temp; } int main() { cin >> N; for (int i = 0; i < N; i++) { cin >> Y[i]; used.insert(Y[i]); q.push(Y[i]); } for (;;) { int num = next(q.top()); if (q.top() == num) break; used.erase(num); used.insert(num); q.pop(); q.push(num); } while (!q.empty()) { cout << q.top() << ; q.pop(); } cout << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; const int maxn = 1e5 + 3; int a[maxn], b[maxn], c[maxn], sum; int main() { int n; cin >> n; for (int i = 1; i <= n; i++) { cin >> a[i]; sum += a[i]; } int ans = 0, cnt = 0; for (int i = 1; i <= n; i++) { ans += a[i]; cnt -= a[i]; b[i] = max(max(cnt, ans), b[i - 1] + a[i]); } ans = 0, cnt = 0; for (int i = n; i > 0; i--) { ans += a[i]; cnt -= a[i]; c[i] = max(max(cnt, ans), c[i + 1] + a[i]); } int mx = 0; for (int i = 0; i <= n; i++) mx = max(c[i + 1] + b[i], mx); cout << mx; }
|
#include <bits/stdc++.h> using namespace std; int main() { int a, b, l, r, c, pl, pr, cl, cr; cin >> a >> b >> l >> r; c = a + b; cl = --l / c; cr = --r / c; pl = l % c; pr = r % c; if (cl == cr) { if (pl < a && pr < a) { cout << pr - pl + 1 << endl; } else if (pl < a && pr >= a) { cout << a - pl << endl; } else { cout << 1 << endl; } } else if (a <= b) { if (cl < cr - 1) { cout << a + 1 << endl; } else { if (pr >= a) { cout << a + 1 << endl; } else { if (pl >= a) { cout << pr + 1 + 1 << endl; } else { int left = a - pl; int right = pr + 1; if (left + right > a) { cout << a + (right == a) << endl; } else { cout << left + right + (right == a) << endl; } } } } } else { int d = a - b; if (cl == cr - 1) { if (pr >= a && pl >= a) { cout << a + 1 << endl; } else if (pr < a && pl >= a) { cout << pr + 1 + 1 << endl; } else if (pr >= a && pl < a) { cout << min((a + a - pl), a + a - b) << endl; } else if (pr < a && pl < a) { if (pl > b) { cout << pr + 1 + a - pl << endl; } else { cout << pr + 1 + a - b << endl; } } } else if (cl == cr - 2) { if (pr >= a && pl >= a) { cout << a + a - b << endl; } else if (pr >= a && pl < a) { cout << a + a - b << endl; } else if (pr < a && pl < a) { cout << min((a + pr + 1 + a - pl + 1), a + a - b) << endl; } else { cout << a + max(1, d + min(0, pr - a + 1 + max(0, a - pl))); } } else { cout << a + d << endl; } } }
|
#include <bits/stdc++.h> using namespace std; int gcd(int x, int y) { return (!y ? x : gcd(y, x % y)); } const int maxn = 2e5; vector<int> g[maxn], tree[maxn]; map<pair<int, int>, int> we; int par[maxn]; int gpar(int v) { return (par[v] == v ? v : par[v] = gpar(par[v])); } bool mrg(int u, int v) { u = gpar(u); v = gpar(v); if (u == v) return false; par[v] = u; return true; } int h[maxn]; void dfs(int v, int p) { for (auto u : tree[v]) { if (u == p) continue; par[u] = v; h[u] = h[v] + 1; dfs(u, v); } } vector<int> get_path(int u, int v) { if (h[u] < h[v]) swap(u, v); vector<int> p, rig; while (h[u] > h[v]) { p.push_back(u); u = par[u]; } while (u != v) { p.push_back(u); rig.push_back(v); u = par[u], v = par[v]; } p.push_back(u); reverse(rig.begin(), rig.end()); for (auto i : rig) p.push_back(i); return p; } const int maxb = 18; int mods[2] = {int(1e9 + 7), int(1e9 + 9)}; int mod; const int N = (1 << maxb); int bpw(int a, int b) { int ans = 1; while (b) { if (b & 1) ans = 1LL * ans * a % mod; a = 1LL * a * a % mod; b >>= 1; } return ans; } void fwht(int* a, int val) { for (int len = 2; len <= N; len *= 2) for (int i = 0; i < N; i += len) { int nxt = len / 2; for (int j = 0; j < nxt; j++) { int x = a[i + j], y = a[i + j + nxt]; a[i + j] = (x + y) % mod; a[i + j + nxt] = (x - y + mod) % mod; } } if (val == -1) { int inv = bpw(N, mod - 2); for (int i = 0; i < N; i++) a[i] = 1LL * a[i] * inv % mod; } } int ans[2][N], cnt[N]; int32_t main() { ios::sync_with_stdio(0), cin.tie(0); int n, m; cin >> n >> m; int tot = 0; for (int i = 0; i < m; i++) { int u, v, w; cin >> u >> v >> w; u--, v--; g[u].push_back(v); g[v].push_back(u); we[{u, v}] = we[{v, u}] = w; tot ^= w; } for (int i = 0; i < n; i++) par[i] = i; vector<pair<int, int> > bads; for (int i = 0; i < n; i++) { for (auto j : g[i]) { if (mrg(i, j)) { tree[i].push_back(j); tree[j].push_back(i); } else if (i < j) bads.push_back({i, j}); } } if (bads.size() == 0) { cout << tot << << 1 << n ; return 0; } dfs(0, 0); for (int it = 0; it < 2; it++) { mod = mods[it]; for (int i = 0; i < N; i++) ans[it][i] = 1; for (auto t : bads) { vector<int> p = get_path(t.first, t.second); p.push_back(p[0]); memset(cnt, 0, sizeof cnt); for (int i = 0; i + 1 < p.size(); i++) { int w = we[{p[i], p[i + 1]}]; cnt[w]++; } fwht(cnt, 1); for (int i = 0; i < N; i++) ans[it][i] = 1LL * ans[it][i] * cnt[i] % mod; } fwht(ans[it], -1); } int jav = 1e9, who = -1; for (int i = 0; i < N; i++) if (ans[0][i] || ans[1][i]) { if ((i ^ tot) < jav) { jav = i ^ tot; who = i; } } assert(who != -1); cout << jav << << ans[0][who] << n ; }
|
#include <bits/stdc++.h> using namespace std; long long bbuy(long long* c, long long l, int n); int main() { long long n, l; cin >> n >> l; long long c[n]; for (int i = 0; i < n; ++i) { cin >> c[i]; } long long bp = c[0]; for (int i = 0; i < n; ++i) { bp *= 2; bp = min(bp, c[i]); if (bp != c[i]) c[i] = -1; } long long bcost = 0; bcost += bbuy(c, l, n); cout << bcost; return 0; } long long bbuy(long long* c, long long l, int n) { int i = int(log2(l)); long long gcost = 0; long long cost = 0, buy; long long prev = l; while (i >= n || c[i] == -1) i--; buy = l / pow(2, i); l -= buy * pow(2, i); cost = buy * c[i]; if (l > 0) cost += bbuy(c, l, n); for (int j = i + 1; j < n; ++j) { l = prev; if (c[j] == -1) continue; buy = (l / pow(2, j)) + 1; if (cost > buy * c[j]) { cost = buy * c[j]; l -= buy * pow(2, j); } } gcost += cost; return gcost; }
|
#include <bits/stdc++.h> using namespace std; namespace std { template <> struct hash<pair<int, int>> { size_t operator()(const pair<int, int> &x) const { long long P = 38923, Q = 109797901; return (size_t)((x.first * P + x.second) % Q); } }; }; // namespace std template <class T> using pqg = priority_queue<T, vector<T>, greater<T>>; template <typename T> void print(T t) { cout << t << endl; } template <typename T, typename... Args> void print(T t, Args... args) { cout << t << ; print(args...); } int main() { ios::sync_with_stdio(false); cin.tie(0); long long x, y, z; cin >> x >> y >> z; if (x > y + z) print( + ); else if (y > x + z) print( - ); else if (x == y && z == 0) print( 0 ); else print( ? ); return 0; }
|
#include <bits/stdc++.h> using namespace std; template <typename T> inline T qmin(const T a, const T b) { return a < b ? a : b; } template <typename T> inline T qmax(const T a, const T b) { return a > b ? a : b; } template <typename T> inline void getmin(T &a, const T b) { if (a > b) a = b; } template <typename T> inline void getmax(T &a, const T b) { if (a < b) a = b; } inline void fileio(string s) { freopen((s + .in ).c_str(), r , stdin); freopen((s + .out ).c_str(), w , stdout); } const int inf = 1e9; const long long linf = 1e17 + 7; const int N = 2e5 + 7; struct seg { int h, l, r; seg() {} seg(int _h, int _l, int _r) : h(_h), l(_l), r(_r) {} bool operator<(const seg &b) const { return h < b.h; } } a[N]; struct node { int l, r, v; seg s; node() {} node(int _l, int _r, int _v, seg _s) : l(_l), r(_r), v(_v), s(_s) {} bool operator<(const node &b) const { return l < b.l; } }; inline int overlap(int l1, int r1, int l2, int r2) { return qmax(0, qmin(r1, r2) - qmax(l1, l2)); } inline bool canget(const seg &a, set<node>::iterator it) { set<node>::iterator ul = it, ur = it; --ul; ++ur; seg pre = ul->s, nxt = ur->s, cur = it->s; if (pre.h < a.h && pre.h > cur.h && overlap(a.l, a.r, pre.l, pre.r) && overlap(pre.l, pre.r, cur.l, cur.r)) return false; if (nxt.h < a.h && nxt.h > cur.h && overlap(a.l, a.r, nxt.l, nxt.r) && overlap(nxt.l, nxt.r, cur.l, cur.r)) return false; return true; } set<node> s; int n, t; int main() { scanf( %d%d , &n, &t); for (int i = 1; i <= n; ++i) scanf( %d%d%d , &a[i].h, &a[i].l, &a[i].r); a[++n] = seg(t, -inf, inf); sort(a + 1, a + n + 1); node bot(-inf, inf, inf << 1, seg(0, -inf, inf)); node left(-inf - 1, -inf, 0, seg()); node right(inf, inf + 1, 0, seg()); s.insert(bot); s.insert(left); s.insert(right); for (int i = 1; i <= n; ++i) { set<node>::iterator ul = s.upper_bound(node(a[i].l, a[i].r, 0, seg())), ur; int ans = 0; for (--ul; ul->r <= a[i].l; ++ul) ; for (ur = ul; ur->l < a[i].r; ++ur) { if (!canget(a[i], ur)) continue; getmax(ans, qmin(overlap(a[i].l, a[i].r, ur->l, ur->r), ur->v)); } --ur; int l = ul->l, r = ur->r, v1 = ul->v, v2 = ur->v; seg s1 = ul->s, s2 = ur->s; ++ur; s.erase(ul, ur); s.insert(node(a[i].l, a[i].r, ans, a[i])); if (l < a[i].l) s.insert(node(l, a[i].l, v1, s1)); if (r > a[i].r) s.insert(node(a[i].r, r, v2, s2)); } set<node>::iterator ite = s.begin(); ++ite; printf( %d n , ite->v); return 0; }
|
#include <bits/stdc++.h> #pragma comment(linker, /STACK:100000000000000 ) using namespace std; const long long int INF = 2e9; void init(vector<int> &dsu) { for (int i = 0; i < ((int)(dsu).size()); i++) { dsu[i] = i; } } int find_p(vector<int> &dsu, int id) { if (dsu[id] == id) return id; return dsu[id] = find_p(dsu, dsu[id]); } bool unite(vector<int> &dsu, int f, int s) { f = find_p(dsu, f); s = find_p(dsu, s); if (f == s) return true; dsu[f] = s; return false; } inline bool in(long double f, long double s, long double d) { return s >= f && s <= d; } bool intr(pair<long double, long double> f, pair<long double, long double> s, long double time) { if (time == INF) return true; long double a1 = -1, b1 = -1, c1 = -(a1 * f.first + b1 * f.second); long double a2 = 1, b2 = -1, c2 = -(a2 * s.first + b2 * s.second); long double x = (b1 * c2 - b2 * c1) / (a1 * b2 - b1 * a2), y = (c1 * a2 - a1 * c2) / (a1 * b2 - b1 * a2); return in(f.first - time, x, f.first + time) && in(f.second - time, y, f.second + time) && in(s.first - time, x, s.first + time) && in(s.second - time, y, s.second + time); } bool ini(long double f, long double s, long double time) { return (f - s) <= time * 2; } bool intr2(pair<long double, long double> f, pair<long double, long double> s, int q, long double time) { if (!q && !(f.first + f.second == s.first + s.second)) return false; if (q && !(f.first - f.second == s.first - s.second)) return false; if (time == INF) return true; long double x = min(f.first, s.first), x2 = max(f.first, s.first); long double y = min(f.second, s.second), y2 = max(f.second, s.second); return ini(x, x2, time) && ini(y, y2, time); } bool can(vector<pair<long double, long double> > p1, vector<pair<long double, long double> > p2, long long int time) { int n = (int)(p1).size(), m = (int)(p2).size(); for (int q = 0; q < (2); q++) { vector<int> with(n, -1); vector<int> dsu(m); init(dsu); for (int i = 0; i < (n); i++) { for (int j = 0; j < (m); j++) { if (intr(!q ? p1[i] : p2[j], !q ? p2[j] : p1[i], time)) { if (with[i] == -1) with[i] = j; else { if (unite(dsu, j, with[i])) { return true; } } } } for (int j = 0; j < (i); j++) { if (i == j) continue; if (with[j] == -1 || with[i] == -1) continue; if (intr2(p1[i], p1[j], q, time)) { if (unite(dsu, with[i], with[j])) { return true; } } } } swap(n, m); swap(p1, p2); } return false; } int main() { int n, m; cin >> n >> m; vector<pair<long double, long double> > p1(n), p2(m); bool yes = false; for (int i = 0; i < (n); i++) { int a, b; scanf( %d%d , &a, &b); p1[i] = make_pair(a, b); if (i && a + b != p1[i - 1].first + p1[i - 1].second) yes = true; } bool yes2 = false; for (int i = 0; i < (m); i++) { int a, b; scanf( %d%d , &a, &b); p2[i] = make_pair(a, b); if (i && a - b != p2[i - 1].first - p2[i - 1].second) yes2 = true; } if ((!yes || !yes2) || !can(p1, p2, INF)) { cout << Poor Sereja! ; return 0; } long long int l = 0, r = INF; while (l != r) { long long int m = (l + r) / 2; if (can(p1, p2, m)) { r = m; } else l = m + 1; } cout << l; }
|
#include <bits/stdc++.h> using namespace std; template <class A, class B> inline bool mina(A &first, B second) { return (first > second) ? (first = second, 1) : 0; } template <class A, class B> inline bool maxa(A &first, B second) { return (first < second) ? (first = second, 1) : 0; } const int MAXN = 150005; int N; int in[MAXN]; bool good(int a, int b) { swap(in[a], in[b]); bool bad = false; for (int(i) = 0; (i) < (N - 1); ++(i)) { if (i % 2 == 0) { if (in[i] >= in[i + 1]) { bad = true; break; } } else { if (in[i] <= in[i + 1]) { bad = true; break; } } } swap(in[a], in[b]); return !bad; } bool check2(int p) { if (p < 0 || p >= N) return true; if (p % 2 == 0) { if (p + 1 < N && in[p] >= in[p + 1]) return false; if (p - 1 >= 0 && in[p] >= in[p - 1]) return false; } else { if (p + 1 < N && in[p] <= in[p + 1]) return false; if (p - 1 >= 0 && in[p] <= in[p - 1]) return false; } return true; } bool check_local(int a, int b) { swap(in[a], in[b]); bool g1 = true; for (int i = -1; i <= 1; i++) { g1 &= check2(a + i); g1 &= check2(b + i); } swap(in[a], in[b]); return g1; } int main() { scanf( %d , &N); for (int(i) = 0; (i) < (N); ++(i)) { scanf( %d , &in[i]); } set<int> bad; int num_bad_local = 0; int xx = -1; for (int(i) = 0; (i) < (N - 1); ++(i)) { if (i % 2 == 0) { if (in[i] >= in[i + 1]) { bad.insert(i); bad.insert(i + 1); num_bad_local++; xx = i; i++; } } else { if (in[i] <= in[i + 1]) { bad.insert(i); bad.insert(i + 1); num_bad_local++; xx = i; i++; } } } if (((int)(bad).size()) > 10) { printf( 0 n ); return 0; } set<pair<int, int> > ans; for (int first : bad) { for (int second : bad) { if (first < second) { if (good(first, second)) { ans.insert(pair<int, int>(first, second)); } } } } if (num_bad_local == 1) { for (int(g) = 0; (g) < (N); ++(g)) { if (g != xx && g != xx + 1) { if (check_local(g, xx)) { int a = g; int b = xx; if (a > b) swap(a, b); ans.insert(pair<int, int>(a, b)); } if (check_local(g, xx + 1)) { int a = g; int b = xx + 1; if (a > b) swap(a, b); ans.insert(pair<int, int>(a, b)); } } } } cout << ((int)(ans).size()) << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; const int inf = (int)1e9 + 7; const double pi = 3.14159265358979323846; template <class T> T sqr(T x) { return x * x; } double len(const pair<int, int> &p1, const pair<int, int> &p2) { return sqrt(sqr((long long)p1.first - p2.first) + sqr((long long)p1.second - p2.second)); } double foo(const vector<pair<int, int>> &pol, int l, int r, bool side) { static vector<vector<vector<double>>> dp( 2, vector<vector<double>>(2500, vector<double>(2501, -1))); if (r <= l + 1) return 0; if (l > (int)pol.size() / 2) return foo(pol, l - (pol.size() + 1) / 2, r - (pol.size() + 1) / 2, side); if (dp[side][l][r - l] == -1) if (side) dp[side][l][r - l] = max(len(pol[r - 1], pol[l]) + foo(pol, l, r - 1, 0), len(pol[r - 1], pol[r - 2]) + foo(pol, l, r - 1, 1)); else dp[side][l][r - l] = max(len(pol[l], pol[l + 1]) + foo(pol, l + 1, r, 0), len(pol[l], pol[r - 1]) + foo(pol, l + 1, r, 1)); return dp[side][l][r - l]; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); int n; cin >> n; vector<pair<int, int>> pol(n); for (auto &it : pol) cin >> it.first >> it.second; for (int i = 0; i < n - 1; i++) pol.push_back(pol[i]); double best = numeric_limits<double>::lowest(); for (int i = 0; i < n - 1; i++) best = max(best, max(foo(pol, i, i + n, 0), foo(pol, i, i + n, 1))); cout.precision(20); cout << fixed << best << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; const int MAX = 2e5 + 4; string s; int main() { ios_base::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr); ; cin >> s; long long n = s.size(); long long sub = 0; for (int k = 1; k <= 8; k++) { for (int i = 0; i + k <= n; i++) { bool flag = false; for (int j = 1; 2 * j < k; j++) { for (int st = i; st + 2 * j < i + k; st++) { if (s[st] == s[st + j] && s[st] == s[st + 2 * j]) { flag = true; } } } if (!flag) sub++; } } cout << n * (n + 1) / 2 - sub << n ; }
|
#include <bits/stdc++.h> using namespace std; const int N = 3E4 + 7; int x[N], y[N]; void solve() { int n; cin >> n; int a[n]; for (int i = 0; i < n; i++) cin >> a[i]; x[0] = a[0], y[0] = 0; for (int i = 1; i < n; i++) { x[i] = min(x[i - 1], a[i]), y[i] = a[i] - x[i]; if (y[i] >= y[i - 1]) continue; y[i] = y[i - 1], x[i] = a[i] - y[i]; if (x[i] < 0) { cout << NO n ; return; } } cout << YES n ; } int main() { ios_base::sync_with_stdio(0); cin.tie(0); int t; cin >> t; while (t--) solve(); return 0; }
|
#include <bits/stdc++.h> using namespace std; const int maxn = 200000 + 10; struct Tree { int tl, tr; int mx; } tree[maxn << 2]; set<int> st[maxn]; int ve[maxn], n, m; void build(int id, int l, int r) { tree[id].tl = l; tree[id].tr = r; tree[id].mx = -1; if (l == r) return; int mid = (l + r) >> 1; build(id << 1, l, mid); build(id << 1 | 1, mid + 1, r); } void update(int id, int pos, int val, int y) { int l = tree[id].tl, r = tree[id].tr; if (l == r) { if (st[pos].size()) tree[id].mx = *(--st[pos].end()); else tree[id].mx = -1; return; } int mid = (l + r) >> 1; if (pos <= mid) update(id << 1, pos, val, y); else update(id << 1 | 1, pos, val, y); tree[id].mx = max(tree[id << 1].mx, tree[id << 1 | 1].mx); } int query(int id, int ql, int qr, int y) { int l = tree[id].tl, r = tree[id].tr; if (tree[id].mx <= y || ql > qr) { return -1; } int mid = (l + r) >> 1; if (l == r) return l; if (qr <= mid) return query(id << 1, ql, qr, y); else if (ql > mid) return query(id << 1 | 1, ql, qr, y); else { int tmp = query(id << 1, ql, mid, y); if (tmp != -1) return tmp; return query(id << 1 | 1, mid + 1, qr, y); } } struct Point { int x, y; char op[5]; void init() { scanf( %s%d%d , op, &x, &y); } } q[maxn]; int main() { int n; scanf( %d , &n); for (int i = 1; i <= n; i++) { q[i].init(); ve[i] = q[i].x; } sort(ve + 1, ve + 1 + n); int m = unique(ve + 1, ve + 1 + n) - (ve + 1); build(1, 1, m); for (int i = 1; i <= n; i++) { int pos = lower_bound(ve + 1, ve + 1 + m, q[i].x) - ve; if (q[i].op[0] == a ) { st[pos].insert(q[i].y); update(1, pos, 1, q[i].y); } else if (q[i].op[0] == r ) { st[pos].erase(q[i].y); update(1, pos, 1, q[i].y); } else { int ans = query(1, pos + 1, m, q[i].y); if (ans == -1) printf( -1 n ); else printf( %d %d n , ve[ans], *st[ans].upper_bound(q[i].y)); } } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); long long int n, k; cin >> n >> k; string s[n + 1]; set<string> ar; for (int x = 0; x < n; x++) { cin >> s[x]; ar.insert(s[x]); } char a[3] = { S , E , T }; long long int ans = 0; for (int x = 0; x < n; x++) { for (int y = x + 1; y < n; y++) { string d; for (int z = 0; z < k; z++) { if (s[x][z] == s[y][z]) { d += s[x][z]; } else { for (int i = 0; i < 3; i++) { if (a[i] != s[x][z] && a[i] != s[y][z]) { d += a[i]; break; } } } } if (d.length() != 0) if (ar.count(d)) ++ans; } } cout << ans / 3 << n ; }
|
#include <bits/stdc++.h> using namespace std; long long gcd(long long a, long long b) { return (a ? gcd(b % a, a) : b); } long long power(long long a, long long n) { long long p = 1; while (n > 0) { if (n & 1) { p = p * a; } n >>= 1; a *= a; } return p; } long long power(long long a, long long n, long long mod) { long long p = 1; while (n > 0) { if (n & 1) { p = p * a; p %= mod; } n >>= 1; a *= a; a %= mod; } return p % mod; } const int N = 300005; long long x[N]; long long d[N], a[N]; long long find(int i, int j) { if (i == 0) return x[j]; return (x[j] - x[i - 1] + 1000000007) % 1000000007; } int main() { int i, j; int n; scanf( %d , &n); for (i = 0; i < n; i++) scanf( %lld , &a[i]); sort(a, a + n); x[0] = 1; for (i = 1; i < n; i++) { d[i] = a[i] - a[i - 1]; x[i] = (power(2ll, i, 1000000007) + x[i - 1]) % 1000000007; } long long ans = 0; for (i = 1; i < n; i++) { ans += (d[i] * find(i - 1, n - 2)) % 1000000007; } long long z = ans; for (i = 2; i < n; i++) { z = (z - (d[i - 1] * x[n - i]) % 1000000007 + 1000000007) % 1000000007; z = (z * power(2, 1000000007 - 2, 1000000007)) % 1000000007; ans = (ans + z) % 1000000007; } printf( %lld n , ans); return 0; }
|
#include <bits/stdc++.h> using namespace std; int x, y; int n, m, k; int main() { cin >> n >> m >> k; for (int i = 0; i < k; i++) { cin >> x >> y; if (x <= 5 || y <= 5 || n - x <= 4 || m - y <= 4) { cout << YES << endl; return 0; } } cout << NO << endl; return 0; }
|
#include <bits/stdc++.h> #pragma comment(linker, /stack:100000000 ) using namespace std; const int N = 155; const int INF = 1000000000; struct Edge { int to, flow, cap, cost; Edge() {} Edge(int to, int flow, int cap, int cost) : to(to), flow(flow), cap(cap), cost(cost) {} }; vector<Edge> g[N]; void add_edge(int from, int to, int cap, int cost) { g[from].push_back(Edge(to, 0, cap, cost)); g[to].push_back(Edge(from, cap, cap, -cost)); } int* count_letters(string s) { int* a = new int[26]; memset(a, 0, 26 * sizeof(int)); for (int(i) = 0; (i) < ((int)(s).size()); (i)++) a[s[i] - a ]++; return a; } int d[N], p[N], id[N]; void find_flow(int src, int goal, int need) { int flow = 0, n = goal + 1, cost = 0; while (flow < need) { for (int(i) = 0; (i) < (n); (i)++) d[i] = INF, p[i] = id[i] = -1; d[src] = 0; for (int(i) = 0; (i) < (n - 1); (i)++) { for (int(a) = 0; (a) < (n); (a)++) { for (int(j) = 0; (j) < ((int)(g[a]).size()); (j)++) { int b = g[a][j].to; if (g[a][j].flow < g[a][j].cap && d[b] > d[a] + g[a][j].cost) { d[b] = d[a] + g[a][j].cost; p[b] = a; id[b] = j; } } } } if (d[goal] == INF) { puts( -1 ); return; } int push = INF, cur = goal; while (cur != src) { push = min(push, g[p[cur]][id[cur]].cap - g[p[cur]][id[cur]].flow); cur = p[cur]; } cur = goal; flow += push; while (cur != src) { g[p[cur]][id[cur]].flow += push; cost += push * g[p[cur]][id[cur]].cost; for (int(i) = 0; (i) < ((int)(g[cur]).size()); (i)++) { if (g[cur][i].to == p[cur]) { g[cur][i].flow -= push; break; } } cur = p[cur]; } } printf( %d n , cost); } int main() { string t; cin >> t; int* a = count_letters(t); int n; cin >> n; for (int(i) = 0; (i) < (26); (i)++) add_edge(n + 1 + i, n + 27, a[i], 0); for (int(i) = 0; (i) < (n); (i)++) { string s; int cap; cin >> s >> cap; int* b = count_letters(s); add_edge(0, i + 1, cap, i + 1); for (int(j) = 0; (j) < (26); (j)++) add_edge(i + 1, n + 1 + j, b[j], 0); } find_flow(0, n + 27, (int)(t).size()); return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { long long int i, t, c, sum = 0; cin >> t; long long int a[t]; for (i = 0; i < t; i++) { cin >> a[i]; } for (i = 0; i < t; i++) { sum += a[i]; } if (sum % 2 == 0) { cout << sum << endl; } else { long long int min = 1000000001; for (i = 0; i < t; i++) { if (a[i] <= min && a[i] % 2 != 0) { min = a[i]; } } sum = sum - min; cout << sum << endl; } return 0; }
|
#include <bits/stdc++.h> int main() { int n, s[10001], ss[10001]; scanf( %d , &n); for (int i = 1; i <= n; i++) scanf( %d , &s[i]); for (int i = 1; i < n; i++) { ss[i] = abs(s[i] - s[i + 1]); } ss[n] = abs(s[n] - s[1]); int t, min = 999999; for (int i = 1; i <= n; i++) { if (min > ss[i]) { min = ss[i]; t = i; } } if (t != n) printf( %d %d n , t, t + 1); else printf( %d %d n , t, 1); return 0; }
|
#include <bits/stdc++.h> using namespace std; const int N = 132700; int n; tuple<int, int, int, int> esq[N], dir[N]; vector<tuple<int, int, int, int>> v; int main(void) { ios_base::sync_with_stdio(false); cin >> n; for (int i = 0; i < n; i++) { int a, b, c, d; cin >> a >> b >> c >> d; v.emplace_back(a, b, c, d); } esq[0] = make_tuple(-0x3f3f3f3f, -0x3f3f3f3f, +0x3f3f3f3f, +0x3f3f3f3f); for (int i = 1; i <= n; i++) { int xb, yb, xu, yu; tie(xb, yb, xu, yu) = v[i - 1]; get<0>(esq[i]) = max(get<0>(esq[i - 1]), xb); get<1>(esq[i]) = max(get<1>(esq[i - 1]), yb); get<2>(esq[i]) = min(get<2>(esq[i - 1]), xu); get<3>(esq[i]) = min(get<3>(esq[i - 1]), yu); } dir[n + 1] = make_tuple(-0x3f3f3f3f, -0x3f3f3f3f, +0x3f3f3f3f, +0x3f3f3f3f); for (int i = n; i >= 1; i--) { int xb, yb, xu, yu; tie(xb, yb, xu, yu) = v[i - 1]; get<0>(dir[i]) = max(get<0>(dir[i + 1]), xb); get<1>(dir[i]) = max(get<1>(dir[i + 1]), yb); get<2>(dir[i]) = min(get<2>(dir[i + 1]), xu); get<3>(dir[i]) = min(get<3>(dir[i + 1]), yu); } for (int i = 1; i <= n; i++) { int xb, yb, xu, yu; xb = max(get<0>(esq[i - 1]), get<0>(dir[i + 1])); yb = max(get<1>(esq[i - 1]), get<1>(dir[i + 1])); xu = min(get<2>(esq[i - 1]), get<2>(dir[i + 1])); yu = min(get<3>(esq[i - 1]), get<3>(dir[i + 1])); if (xb <= xu and yb <= yu) { cout << xb << << yb << endl; return 0; } } assert(0); return 0; }
|
#include <bits/stdc++.h> using namespace std; long long dp[2010][2010]; int a[2010]; int p[2010]; bool used[2010]; bool ok[2010]; int main() { int n; cin >> n; dp[0][0] = 1; int rem = 0; for (int i = 0; i < n; i++) { cin >> a[i]; if (a[i] != -1) { used[a[i] - 1] = true; rem++; } else p[i] = i - rem + 1; } int cnt = 0; for (int i = 0; i < n; i++) if (used[i]) ok[p[i]] = true; for (int i = 1; i <= n; i++) { dp[i][0] = dp[i - 1][1] + dp[i - 1][0] * (i - 1); if (ok[i]) dp[i][0] += dp[i - 1][0]; dp[i][0] %= 1000000007; for (int j = 1; j <= i; j++) { dp[i][j] = dp[i - 1][j + 1] * (j + 1) + dp[i - 1][j] * (i - 1 - j); if (ok[i]) dp[i][j] += dp[i - 1][j]; else dp[i][j] += dp[i - 1][j - 1]; dp[i][j] %= 1000000007; } } long long ans = 0; for (int j = 0; j <= cnt; j++) ans = (dp[n - rem][j] + ans) % 1000000007; cout << ans << endl; }
|
#include <bits/stdc++.h> using namespace std; int a, b; int main() { cin >> a >> b; if (abs(a - b) <= 1 && (a || b)) { cout << YES << endl; } else { cout << NO << endl; } return 0; }
|
#include <bits/stdc++.h> using namespace std; void Q_Q() { ios::sync_with_stdio(0); ios_base::sync_with_stdio(0); cin.tie(0), cout.tie(0); } map<int, bool> mp; int main() { Q_Q(); int n, k; double t; cin >> n >> k >> t; int arr[n]; long long int sum = 0; for (int i = 0; i < n; i++) { arr[i] = k; sum += k; } int j = n - 1; while ((sum * 1.0 / ((n * k) * 1.0)) > t / 100) { arr[j]--; if (arr[j] == 0) j--; sum--; } for (int i = 0; i < n; i++) cout << arr[i] << ; return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { unsigned int n, m, l; cin >> n >> m >> l; int s = 0; while (l--) { s += 2 * (n + m - 2); n -= 4; m -= 4; } cout << s; }
|
#include <bits/stdc++.h> using namespace std; const int N = 1e5 + 2; long long d, k, a, b, t; int main() { cin >> d >> k >> a >> b >> t; if (d <= k) { cout << d * a; } else if (t + k * a > k * b) { cout << k * a + (d - k) * b; } else { long long cnt = d / k; long long ans = k * a * cnt + (cnt - 1) * t + min(t + (d % k) * a, (d % k) * b); cout << ans; } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { long long n, i; scanf( %I64d , &n); if (n <= 3) { printf( 1 ); return 0; } if (n == 4) { printf( 2 ); return 0; } if (n % 2 == 0) printf( 2 ); else { bool u = 1; for (i = 2; i * i <= n; i++) if (n % i == 0) { u = 0; break; } if (u) printf( 1 ); else { n = n - 2; bool v = 1; for (i = 2; i * i <= n; i++) if (n % i == 0) { v = 0; break; } if (v) printf( 2 ); else printf( 3 ); } } }
|
#include <bits/stdc++.h> using namespace std; long long mod = 1e9 + 7; long long inf = 4e18; const long long N = 2e5 + 5; long long ans[N]; signed main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); long long tt = 1; while (tt--) { long long n; cin >> n; long long l, r; map<long long, long long> mp; for (long long i = 0; i < n; ++i) { cin >> l >> r; ++mp[l]; --mp[r + 1]; } long long cnt = 0; l = -1; for (auto it : mp) { if (l == -1) { l = it.first; cnt += it.second; } else { ans[cnt] += (it.first - l); l = it.first; cnt += it.second; } } for (long long i = 1; i <= n; ++i) cout << ans[i] << ; } return 0; }
|
#include <bits/stdc++.h> using namespace std; const int a[6] = {3, 3, 3, 2, 2, 1}; const int b[6] = {2, 1, 0, 1, 0, 0}; const int inf = 1000000000; const double eps = 1e-6; int Dist[6]; double X[7]; int Round(double X) { int T = (int)X; if (T + 1 - X < eps) T++; return T; } bool Check(int Len) { static double G[7][7], A[7]; memset(G, 0, sizeof(G)); for (int i = 0; i < 6; i++) for (int j = 0; j < 7; j++) { bool F0 = (j + 1) & (1 << a[i]); bool F1 = (j + 1) & (1 << b[i]); G[i][j] = F0 ^ F1; } for (int i = 0; i < 7; i++) G[6][i] = 1; for (int i = 0; i < 6; i++) A[i] = Dist[i]; A[6] = Len; for (int i = 0; i < 7; i++) { if (!G[i][i]) { int P = i + 1; while (!G[P][i]) P++; for (int j = i; j < 7; j++) swap(G[i][j], G[P][j]); swap(A[i], A[P]); } for (int j = i + 1; j < 7; j++) if (G[j][i]) { double T = G[j][i] / G[i][i]; for (int k = i; k < 7; k++) G[j][k] -= G[i][k] * T; A[j] -= A[i] * T; } } for (int i = 6; i >= 0; i--) { X[i] = A[i] / G[i][i]; for (int j = 0; j < i; j++) A[j] -= X[i] * G[j][i]; } for (int i = 0; i < 7; i++) if (fabs(X[i] - Round(X[i])) > eps || X[i] < -eps) return false; return true; } int main() { for (int i = 0; i < 6; i++) scanf( %d , &Dist[i]); int Ans = -1, Sum = 0; for (int i = 0; i < 6; i++) Sum += Dist[i]; for (int i = Sum / 4; Ans == -1 && i <= Sum / 3; i++) if (Check(i)) Ans = i; printf( %d n , Ans); if (Ans == -1) return 0; string S[4]; for (int i = 0; i < 7; i++) { int M = Round(X[i]); for (int j = 0; j < M; j++) { S[0] += a ; for (int k = 1; k < 4; k++) S[k] += ((i + 1) & (1 << (3 - k))) ? b : a ; } } for (int i = 0; i < 4; i++) cout << S[i] << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; const int MO = 1e9 + 7; int n, K; long long dp[105][44], tt[44]; vector<int> e[105]; void add(long long &x, long long y) { x = (x + y) % MO; } void mul(long long &x, long long y) { x = x * y % MO; } void dfs(int u, int f) { dp[u][K + 1] = 1; dp[u][0] = 1; for (auto v : e[u]) if (v != f) { dfs(v, u); for (int i = 0; i <= 2 * K; ++i) for (int j = 0; j <= 2 * K; ++j) add(tt[i + j <= 2 * K ? min(i, j + 1) : max(i, j + 1)], dp[u][i] * dp[v][j]); memcpy(dp[u], tt, sizeof tt); memset(tt, 0, sizeof tt); } } int main() { cin >> n >> K; for (int i = 1, x, y; i < n; ++i) { cin >> x >> y; e[x].push_back(y); e[y].push_back(x); } dfs(1, 0); long long ans = 0; for (int i = 0; i <= K; ++i) add(ans, dp[1][i]); cout << ans << endl; }
|
#include <bits/stdc++.h> using namespace std; long long n, m, val[105], c[105][105], pref[105][105], calc[105][105], dp[105][10005]; int main() { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); cin >> n >> m; for (long long i = 1; i <= n; ++i) { cin >> val[i]; for (long long j = 1; j <= val[i]; ++j) cin >> c[i][j], pref[i][j] = pref[i][j - 1] + c[i][j]; } for (long long i = 1; i <= n; ++i) for (long long j = 1; j <= min(m, val[i]); ++j) for (long long k = 0; k <= j; ++k) calc[i][j] = max(calc[i][j], pref[i][k] + pref[i][val[i]] - pref[i][val[i] - (j - k)]); long long tot = 0; for (long long i = 1; i <= n; ++i) { tot += val[i]; for (long long j = 1; j <= min(tot, m); ++j) { for (long long k = 0; k <= min(j, val[i]); ++k) { dp[i][j] = max(dp[i][j], dp[i - 1][j - k] + calc[i][k]); } } } cout << dp[n][m] << endl; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n, t[90]; bool ans = false; cin >> n; for (int i = 0; i < n; i++) { cin >> t[i]; } if (t[0] > 15) { cout << 15; ans = true; } for (int i = 0; i < n - 1 && ans == false; i++) { t[i] += 15; if (t[i] < t[i + 1]) { cout << t[i]; ans = true; } } t[n - 1] += 15; if (t[n - 1] >= 90 && ans == false) { cout << 90; } if (t[n - 1] < 90 && ans == false) { cout << t[n - 1]; } }
|
#include <bits/stdc++.h> using namespace std; template <typename Abel> struct BIT2D { vector<vector<Abel>> dat[4]; BIT2D(int h, int w) { for (int which = 0; which < 4; which++) dat[which].assign(h + 1, vector<Abel>(w + 1)); } inline void sub_add(int which, int a, int b, Abel x) { int h = dat[which].size(), w = dat[which][0].size(); for (int i = a; i < h; i += i & -i) for (int j = b; j < w; j += j & -j) dat[which][i][j] += x; } inline void add(int si, int sj, Abel x) { sub_add(0b00, si, sj, x * (si - 1) * (sj - 1)); sub_add(0b10, si, sj, -x * (si - 1)); sub_add(0b01, si, sj, -x * (sj - 1)); sub_add(0b11, si, sj, x); } inline void add(int si, int ti, int sj, int tj, Abel x) { add(si, sj, x), add(si, tj, -x), add(ti, sj, -x), add(ti, tj, x); } inline Abel sub_sum(int which, int a, int b) { Abel res = Abel(0); for (int i = a; i > 0; i -= i & -i) for (int j = b; j > 0; j -= j & -j) res += dat[which][i][j]; return res; } inline Abel sum(int si, int sj) { Abel res = Abel(0); res += sub_sum(0b00, si - 1, sj - 1); res += sub_sum(0b10, si - 1, sj - 1) * (sj - 1); res += sub_sum(0b01, si - 1, sj - 1) * (si - 1); res += sub_sum(0b11, si - 1, sj - 1) * (si - 1) * (sj - 1); return res; } inline Abel sum(int si, int ti, int sj, int tj) { return sum(ti, tj) - sum(si, tj) - sum(ti, sj) + sum(si, sj); } }; struct Xor { long long val; Xor(long long val_ = 0) : val(val_) {} Xor operator=(long long val_) { this->val = val_; return *this; } Xor operator-() { return val; } const Xor &operator+=(const Xor &x); const Xor &operator-=(const Xor &x); friend ostream &operator<<(ostream &os, const Xor &a) { return os << a.val; } }; Xor operator+(Xor x, Xor y) { return x.val ^ y.val; } Xor operator-(Xor x, Xor y) { return x.val ^ y.val; } Xor operator*(Xor x, int p) { return p & 1 ? x : 0; } const Xor &Xor::operator+=(const Xor &x) { return *this = *this + x; } const Xor &Xor::operator-=(const Xor &x) { return *this = *this - x; } int main() { cin.tie(nullptr); ios::sync_with_stdio(false); int n, m; cin >> n >> m; BIT2D<Xor> bit(n, n); while (m--) { int op; cin >> op; int si, sj, ti, tj; cin >> si >> sj >> ti >> tj; if (op == 1) { cout << bit.sum(si, ti + 1, sj, tj + 1) << endl; } if (op == 2) { long long v; cin >> v; bit.add(si, ti + 1, sj, tj + 1, v); } } return 0; }
|
#include <bits/stdc++.h> using namespace std; void solve() { long long n; cin >> n; long long x = n * (n * n + 1) / 2; vector<long long> a[101]; for (long long j = 0; j < n / 2; j++) for (long long i = 1; i < n + 1; i++) { long long x = n * j + i; a[i].push_back(x); a[i].push_back(n * n - x + 1); } for (long long i = 1; i < n + 1; i++) { for (auto x : a[i]) cout << x << ; cout << n ; } } signed main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); long long TESTS = 1; while (TESTS--) { solve(); } return 0; }
|
#include <bits/stdc++.h> using namespace std; template <class T> T power(T a, T b) { T x; if (b == 0) x = 1; else x = a; for (size_t i = 1; i < b; i++) x *= a; return x; } long long int gcd(long long int a, long long int b) { return b == 0 ? a : gcd(b, a % b); } long long int n, m, a, b, c, ab, ba, x, y, z, avg, total, ans, sum; long long int arr2[300001], arr3[100001], arr4[100001], arr5[100001]; char c1, c2; vector<pair<string, long long int> > vec; vector<long long int> v; bool f, f1, f2, found; string str, s1, s2, s3, s4; map<long long int, long long int> mp, mp1; set<int> seto; double d, d1; long long int x1, x2, y11, y2; long long int mini = 10000000000, maxi = 0; set<string> sets; void rec(int n, string s) { if (n == 11) return; sets.insert(s); rec(n + 1, s + 4 ); rec(n + 1, s + 7 ); } int main() { rec(0, ); for (set<string>::iterator i = sets.begin(); i != sets.end(); i++) { string s = *i; if (!s.empty()) arr2[x++] = stoll(s); } sort(arr2, arr2 + x); cin >> n >> m; y = n; for (long long int i = 0; i < x; i++) { if (y <= arr2[i]) { sum += (min(arr2[i] - y, m - y) + 1) * arr2[i]; y = arr2[i] + 1; } if (y > m) break; } cout << sum; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n, k; scanf( %i%i , &n, &k); if (k * 2 >= n) printf( -1 n ); else { printf( %i n , n * k); for (int i = 0; i < n; i++) for (int j = 0; j < k; j++) printf( %i %i n , i + 1, (i + j + 1) % n + 1); } return 0; }
|
#include <bits/stdc++.h> using namespace std; vector<long long> lucky; void backtrack(long long num) { if (num > 10000000000) return; lucky.push_back(num); backtrack(num * 10 + 4); backtrack(num * 10 + 7); } int main() { backtrack(0); sort(lucky.begin(), lucky.end()); pair<long long, long long> P, V; int k; cin >> P.first >> P.second; cin >> V.first >> V.second; cin >> k; long long denominator = 1LL * (P.second - P.first + 1) * (V.second - V.first + 1); long long numerator = 0; for (int i = k; i + 1 < (int)lucky.size(); i++) { long long pLo = max(lucky[i - k] + 1, P.first); long long pHi = min(lucky[i - k + 1], P.second); long long vLo = max(lucky[i], V.first); long long vHi = min(lucky[i + 1] - 1, V.second); vLo = max(vLo, max(pLo, pHi)); long long yo = 1LL * max(0LL, pHi - pLo + 1) * max(0LL, vHi - vLo + 1); numerator += yo; pLo = max(lucky[i], P.first); pHi = min(lucky[i + 1] - 1, P.second); vLo = max(lucky[i - k] + 1, V.first); vHi = min(lucky[i - k + 1], V.second); pLo = max(pLo, max(vLo, vHi)); yo = 1LL * max(0LL, pHi - pLo + 1) * max(0LL, vHi - vLo + 1); numerator += yo; } if (k == 1) for (int i = 0; i < (int)lucky.size(); i++) if (lucky[i] >= max(P.first, V.first) && lucky[i] <= min(P.second, V.second)) numerator -= 1; printf( %.9lf n , (1.0 * numerator) / denominator); return 0; }
|
#include <bits/stdc++.h> using namespace std; vector<int> Neighbors[2000000]; bool Visited[2000000]; bool Leaf[2000000]; char Color[500001]; queue<int> Queue; void bfs(int i) { Visited[i] = true; Queue.push(i); while (Queue.empty() == false) { int u = Queue.front(); Queue.pop(); Leaf[u] = true; for (int v = 0; v < Neighbors[u].size(); v++) if (Visited[Neighbors[u][v]] == false) { Visited[Neighbors[u][v]] = true; Queue.push(Neighbors[u][v]); Leaf[u] = false; } } } int main() { int T; scanf( %d , &T); for (int t = 1; t <= T; t++) { int n; scanf( %d , &n); for (int i = 1; i <= n; i++) Neighbors[i].clear(); int u, v; for (int i = 0; i + 1 < n; i++) { scanf( %d %d , &u, &v); Neighbors[u].push_back(v); Neighbors[v].push_back(u); } scanf( %s , Color); if (n < 3) { printf( Draw n ); continue; } int n_ = n; for (int i = 1; i <= n; i++) if (Color[i - 1] == W ) { Neighbors[n_ + 1].clear(); Neighbors[n_ + 2].clear(); Neighbors[n_ + 3].clear(); Neighbors[i].push_back(n_ + 1); Neighbors[n_ + 1].push_back(i); Neighbors[n_ + 1].push_back(n_ + 2); Neighbors[n_ + 1].push_back(n_ + 3); Neighbors[n_ + 2].push_back(n_ + 1); Neighbors[n_ + 3].push_back(n_ + 1); n_ += 3; } n = n_; int won = 0; for (int i = 1; i <= n; i++) if (Neighbors[i].size() >= 4) { printf( White n ); won = 1; break; } if (won) continue; for (int i = 1; i <= n; i++) Visited[i] = 0; bfs(1); if (Neighbors[1].size() == 1) Leaf[1] = true; for (int i = 1; i <= n; i++) if (Neighbors[i].size() >= 3) { int leaves = 0; for (int j = 0; j < Neighbors[i].size(); j++) if (Leaf[Neighbors[i][j]]) leaves++; if (Neighbors[i].size() - leaves >= 2) { printf( White n ); won = 1; break; } } if (won) continue; int left = 1; while (left <= n && Neighbors[left].size() < 3) left++; int right = n; while (right > 0 && Neighbors[right].size() < 3) right--; if (left <= n && right > 0 && left < right) { int curr, prev = left; int len = 2; for (int i = 0; i < Neighbors[prev].size(); i++) if (Leaf[Neighbors[prev][i]] == 0) curr = Neighbors[prev][i]; while (curr != right) { if (Neighbors[curr][0] != prev) { prev = curr; curr = Neighbors[curr][0]; } else { prev = curr; curr = Neighbors[curr][1]; } len++; } if (len % 2 == 1) { printf( White n ); continue; } } printf( Draw n ); } return 0; }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.