func_code_string
stringlengths 59
71.4k
|
|---|
#include<bits/stdc++.h> using namespace std; 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...);} #ifndef ONLINE_JUDGE #define debug(x...) cerr << [ << #x << ] = [ ; _print(x) #else #define debug(x...) #endif #define ll long long #define f first #define s second #define Fast ios_base::sync_with_stdio(false);cin.tie(NULL); typedef pair<ll , pair<ll, ll> > pi; int pow(int x,int y){ int res=1; while(y){ if(y&1) res*=x; y>>=1; x*=x; } return res; } struct Compare { constexpr bool operator()(pi const & a, pi const & b) const noexcept { return a.first < b.first || (a.first == b.first && a.second.first > b.second.first); } }; void prefix_function( string s,ll arr[] ) { long long border=0; arr[0]=0; for(long long i=1;i<s.size();i++) { while(border>0 && s[i]!=s[border]) border=arr[border-1]; if(s[i]==s[border]) border++; else border=0; arr[i]=border; } }//send mod-2 for a^-1 if mod is a prime number ll mod=998244353; ll add( ll a , ll b) { return (((a%mod)+(b%mod))%mod); } ll mul(ll a,ll b) { return (((a%mod)*(b%mod))%mod); } ll binpow(ll a, ll b) { ll res = 1; while (b) { if (b & 1) res = mul(res, a); a = mul(a, a); b >>= 1; } return res; } ll subs(ll a,ll b) { return (((a%mod)-(b%mod)+mod)%mod); } ll dv(ll a,ll b) { ll inv=binpow(b,mod-2); return mul(a,inv); } ll dsu_arr[100000]; ll dsu_sz[100000]; void dsu(ll n) { for(ll i=0;i<=n;i++) { dsu_arr[i]=i; dsu_sz[i]=1; } } ll find(ll x) { ll root=x; while (root!=dsu_arr[root]) { root=dsu_arr[root]; } while(x!=dsu_arr[x]) { dsu_arr[x]=root; x=dsu_arr[x]; } return root; } ll merge(ll x,ll y) { ll root1=find(x); ll root2=find(y); if(root1==root2) return 0ll; if(dsu_sz[x]>dsu_sz[y]){ dsu_arr[root2]=root1; dsu_sz[root1]+=dsu_sz[root2]; } else { dsu_sz[root2]+=dsu_sz[root1]; dsu_arr[root1]=root2; } return 1ll; } /* vector<ll>adj[100005]; bool vis[100005]; ll dist[100005]; void bfs(ll c) { vis[c]=true; dist[c]=0; queue<ll>q; q.push(c); while(!q.empty()) { ll x=q.front(); q.pop(); for(ll i=0;i<adj[x].size();i++) { ll y=adj[x][i]; if(!vis[y]) { vis[y]=true; dist[y]=dist[x]+1; q.push(y); } } } } */ int main() { Fast ll test; cin>>test; while(test--) { string s; cin>>s; map<char,ll>cnt; for(char a= a ;a<= z ;a++) { cnt[a]=-1; } for(ll i=0;i<s.size();i++) { cnt[s[i]]=max(cnt[s[i]],i+1); } for(char a= a ;a<= z ;a++) { if(cnt[a]==-1) { cnt[a]=1000000000; } } stack<char>ans; map<char,bool>taken; for(ll i=0;i<s.size();i++) { char x=s[i]; ll r=i+1; if(taken[s[i]]) continue; bool hbe=true; while(!ans.empty()) { ll u=ans.top(); if(u<x && cnt[u]>r){ taken[u]=false; ans.pop(); } else break; } ans.push(x); taken[x]=true; // cout<<ans.size()<< <<ans.top()<<endl; } string sura; while (!ans.empty()) { sura+=ans.top(); ans.pop(); } for(ll i=sura.size()-1;i>=0;i--) { cout<<sura[i]; } cout<< n ; } }
|
#include <bits/stdc++.h> struct Mat { double a[253][253]; } A[53]; int Sta[25][25], d[25], n, m, a, b, tot; double p[25], tp[253][253]; std::vector<int> v[25]; void sq(int x, int y) { register int i, ii, iii; for (i = 0; i < tot; i++) for (ii = 0; ii < tot; ii++) for (iii = 0; iii < tot; iii++) tp[i][iii] += A[y].a[i][ii] * A[y].a[ii][iii]; for (i = 0; i < tot; i++) for (ii = 0; ii < tot; ii++) A[x].a[i][ii] = tp[i][ii], tp[i][ii] = 0; } int main() { scanf( %d%d%d%d , &n, &m, &a, &b); register int i, ii; for (i = 1; i <= n; i++) for (ii = i; ii <= n; ii++) Sta[i][ii] = Sta[ii][i] = tot++; for (i = 1; i <= m; i++) { int x, y; scanf( %d%d , &x, &y), d[x]++, d[y]++; v[x].push_back(y), v[y].push_back(x); } for (i = 1; i <= n; i++) scanf( %lf , p + i), A[0].a[Sta[i][i]][Sta[i][i]] = 1; for (i = 1; i <= n; i++) for (ii = i + 1; ii <= n; ii++) { int Id1 = Sta[i][ii], Id2 = Id1; double P = p[i], Q = p[ii] * P; A[0].a[Id1][Id2] += Q; for (int u : v[ii]) { Q = (1 - p[ii]) / d[ii] * P, Id2 = Sta[i][u], A[0].a[Id1][Id2] += Q; } for (int t : v[i]) { P = (1 - p[i]) / d[i], Q = p[ii] * P, Id2 = Sta[t][ii], A[0].a[Id1][Id2] += Q; for (int u : v[ii]) { Q = (1 - p[ii]) / d[ii] * P, Id2 = Sta[t][u], A[0].a[Id1][Id2] += Q; } } } for (i = 1; i <= 50; i++) sq(i, i - 1); for (i = 1; i <= n; i++) printf( %.12lf , A[50].a[Sta[a][b]][Sta[i][i]]); puts( ); }
|
#include <bits/stdc++.h> using namespace std; int main() { int m, n, k, i, j, t, x; int c[200]; cin >> n; int a[n]; for (i = 0; i < n; i++) { cin >> a[i]; c[i] = a[i]; } cin >> m; int b[m]; for (j = 0; j < m; j++) { cin >> b[j]; c[i + j] = b[j]; } x = m + n; for (i = 0; i < n; i++) { for (j = 0; j < m; j++) { t = 0; for (k = 0; k < x; k++) { if (a[i] + b[j] == c[k]) { t = 1; break; } } if (t == 0) { cout << a[i] << << b[j] << endl; goto here; } } } here: return 0; }
|
#include <bits/stdc++.h> using namespace std; struct point { double x, y; point(double x, double y) : x(x), y(y) {} point() {} inline void read() { scanf( %lf%lf , &x, &y); } inline double len() const { return sqrt(x * x + y * y); } inline double len2() const { return x * x + y * y; } inline point rot() { return point(-y, x); } }; inline int sgn(double a) { if (a > 1e-7) return 1; else if (a < -1e-7) return -1; return 0; } inline point operator-(const point &a, const point &b) { return point(a.x - b.x, a.y - b.y); } inline point operator+(const point &a, const point &b) { return point(a.x + b.x, a.y + b.y); } inline point operator*(const point &a, double b) { return point(b * a.x, b * a.y); } inline point operator*(double b, const point &a) { return point(b * a.x, b * a.y); } inline double operator*(const point &a, const point &b) { return a.x * b.x + a.y * b.y; } inline double operator%(const point &a, const point &b) { return a.x * b.y - a.y * b.x; } inline bool operator==(const point &a, const point &b) { return sgn(a.x - b.x) == 0 && sgn(a.y - b.y) == 0; } inline bool operator!=(const point &a, const point &b) { return !(a == b); } inline double dist(const point &a, const point &b) { return (a - b).len(); } struct line { point a, b, v; line() {} line(const point &a, const point &b) : a(a), b(b), v(b - a) {} }; double sqr(double a) { return a * a; } inline double dist(const point &a, const line &b) { return abs((a - b.a) % b.v) / b.v.len(); } point operator*(const line &a, const line &b) { return b.a + (((a.a - b.a) % a.v) / (b.v % a.v)) * b.v; } bool operator*(const point &a, const line &b) { return ((a - b.a) * b.v) * ((a - b.b) * b.v) < -1e-7; } bool Solve(point a, point b, point c) { if (a == b || b == c || c == a) return false; if (sgn((a - b) % (c - b)) == 0) return false; line l0((a + b) * 0.5, (a + b) * 0.5 + (b - a).rot()), l1(1.5 * b - 0.5 * c, 1.5 * b - 0.5 * c + (c - b).rot()); point p[4]; p[0] = l0 * l1; p[1] = 2 * b - p[0]; p[3] = 2 * a - p[0]; p[2] = 2 * c - p[1]; if (sgn((p[1] - p[0]) % (p[2] - p[1])) == 1) reverse(p, p + 4); for (int i = 0; i < 4; i++) { if (sgn((p[(i + 1) % 4] - p[i]) % (p[(i + 2) % 4] - p[(i + 1) % 4])) >= 0) return false; } printf( YES n ); for (int i = 0; i < 4; i++) printf( %.9lf %.9lf , p[i].x, p[i].y); printf( n ); return true; } int main() { int T; scanf( %d , &T); while (T--) { point a, b, c; a.read(), b.read(), c.read(); if (Solve(a, b, c)) continue; if (Solve(a, c, b)) continue; if (Solve(b, a, c)) continue; if (Solve(b, c, a)) continue; if (Solve(c, a, b)) continue; if (Solve(c, b, a)) continue; printf( NO n n ); } return 0; }
|
#include <bits/stdc++.h> using namespace std; const int MAXN = 1e5 + 5; int n, m, h, t, u, v, src[MAXN], dst[MAXN], num[MAXN], used[MAXN]; vector<int> g[MAXN]; void out(vector<int> &v) { for (int i = 0; i < v.size(); ++i) { cout << v[i] << n [i == v.size() - 1]; } } bool check(int u, int v, int ver) { int cnt = 0; num[u] = num[v] = -1; for (int i = 0; i < g[u].size() && i < h + t; ++i) { int w = g[u][i]; if (w == v) continue; used[w] = ver; num[w] = 1; ++cnt; } for (int i = 0; i < g[v].size() && i < h + t; ++i) { int w = g[v][i]; if (w == u) continue; if (used[w] == ver) { num[w] = 2; continue; } used[w] = ver; num[w] = 1; ++cnt; } int degu = g[u].size() - 1, degv = g[v].size() - 1; if (h >= t != degu >= degv) swap(degu, degv); return degu >= h && degv >= t && cnt >= h + t; } void solve() { for (int mm = 0; mm < m; ++mm) { if (check(src[mm], dst[mm], mm + 1)) { cout << YES n ; u = src[mm], v = dst[mm]; if (h >= t != g[u].size() >= g[v].size()) swap(u, v); cout << u << << v << endl; vector<int> ans; for (int i = 0; i < g[u].size() && ans.size() < h; ++i) { int v = g[u][i]; if (num[v] == 1) { num[v] == -1; ans.push_back(v); } } for (int i = 0; i < g[u].size() && ans.size() < h; ++i) { int v = g[u][i]; if (num[v] > 1) { ans.push_back(v); num[v] = -1; } } out(ans); ans.clear(); swap(u, v); for (int i = 0; i < g[u].size() && ans.size() < t; ++i) { int v = g[u][i]; if (num[v] != -1) ans.push_back(v); } out(ans); return; } } cout << NO n ; } int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout << setprecision(6) << fixed; clog.copyfmt(cout); cin >> n >> m >> h >> t; for (int i = 0; i < m; ++i) { cin >> u >> v; src[i] = u, dst[i] = v; g[u].push_back(v); g[v].push_back(u); } solve(); return 0; }
|
#include <bits/stdc++.h> using namespace std; const long double eps = 1e-13; const long double PI = acos(-1); const int INF = (int)1e9; const long long INFF = (long long)1e18; const int mod = (int)1e9 + 7; const int MXN = (int)2e5 + 7; char s[MXN]; int cnt[MXN]; int num[MXN], num2[MXN], a[MXN]; bool check() { for (int i = 0; i < 1 << 6; i++) num2[i] = num[i]; for (int i = 0; i < 6; i++) { for (int j = 0; j < 1 << 6; j++) { if (j & (1 << i)) num2[j] += num2[j ^ (1 << i)]; } } for (int i = 0; i < 1 << 6; i++) { int sum = 0; for (int j = 0; j < 6; j++) if (i & (1 << j)) sum += cnt[j]; if (sum < num2[i]) return false; } return true; } char ans[MXN]; int main() { scanf( %s , s + 1); int l = strlen(s + 1); for (int i = 1; s[i]; i++) { cnt[s[i] - a ]++; a[i] = (1 << 6) - 1; } int m; scanf( %d , &m); while (m--) { int p; scanf( %d %s , &p, s + 1); a[p] = 0; for (int i = 1; s[i]; i++) a[p] ^= (1 << (s[i] - a )); } for (int i = 1; i <= l; i++) { num[a[i]]++; } for (int i = 1; i <= l; i++) { num[a[i]]--; for (int j = 0; j < 6; j++) { if (!cnt[j] || !(a[i] & (1 << j))) continue; cnt[j]--; if (check()) { ans[i] = j + a ; break; } else { cnt[j]++; } } if (!ans[i]) { puts( Impossible ); return 0; } } printf( %s n , ans + 1); return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n, t = 1, i; cin >> n; int a[n]; for (i = 0; i < n; i++) { cin >> a[i]; } sort(a, a + n); for (i = 0; i < n - 1; i++) { if (a[i + 1] == a[i]) { t++; } else if (t > (n + 1) / 2) { cout << NO ; return 0; } else t = 1; } if (t > ((n + 1) / 2)) cout << NO ; else cout << YES ; return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int t; cin >> t; while (t--) { int n; cin >> n; int arr[n]; for (int i = 0; i < n; i++) { cin >> arr[i]; } int res[101] = {0}; for (int i = 0; i < n; i++) { res[arr[i]]++; } int cnt[101] = {0}; for (int i = 0; i < 101; i++) { if (res[i] >= 1) { res[i]--; cnt[i]++; } } int f, s; for (int i = 0; i < 101; i++) { if (res[i] == 0) { f = i; break; } } for (int i = 0; i < 101; i++) { if (cnt[i] == 0) { s = i; break; } } cout << f + s << n ; } }
|
#include <bits/stdc++.h> using namespace std; int K, P, cd; int cal(int ct, vector<pair<int, int> > vt) { int t = vt.size(), res = 0; for (int st = 1; st < (1 << t); st++) { int val = 1, sl = 0; for (int j = 0; j < t; j++) { if ((st >> j) % 2 == 1) val *= vt[j].first, sl++; } if (sl % 2 == 0) res -= ct / val; else res += ct / val; } return ct - res; } void solve() { vector<pair<int, int> > vt; int x = P; for (int i = 2; i * i <= P; i++) { if (x % i == 0) { int t = 0; while (x % i == 0) t++, x /= i; vt.push_back(pair<int, int>(i, t)); } } if (x > 1) vt.push_back(pair<int, int>(x, 1)); int t = vt.size(); int res0 = cal(cd, vt), r = 10000000, l = cd; int ans; while (1) { int mid = (l + r) / 2; int v = cal(mid, vt) - res0; if (v == K) { ans = mid; break; } if (v > K) { r = mid - 1; } else l = mid + 1; } while (1) { int ok = 1; for (int j = 0; j < vt.size(); j++) { if (ans % vt[j].first == 0) { ok = 0; break; } } if (ok) break; else ans--; } cout << ans << endl; } int main() { int T; cin >> T; for (int i = 0; i < T; i++) { cin >> cd >> P >> K; solve(); } return 0; }
|
#include <bits/stdc++.h> using namespace std; const int maxn = (int)1e5 * 2 + 7; int a[maxn], b[maxn], t[4 * maxn], n, W, H; void build(int v, int l, int r) { if (r - l == 1) { t[v] = a[l]; return; } build(2 * v + 1, l, (l + r) / 2); build(2 * v + 2, (l + r) / 2, r); t[v] = max(t[2 * v + 1], t[2 * v + 2]); } int get(int v, int l, int r, int ql, int qr) { if (ql <= l && qr >= r) return t[v]; if (ql >= r || qr <= l) return 0; return max(get(2 * v + 1, l, (l + r) / 2, ql, qr), get(2 * v + 2, (l + r) / 2, r, ql, qr)); } void upd(int v, int l, int r, int pos, int x) { if (r - l == 1) { t[v] = x; return; } if (pos < (l + r) / 2) { upd(2 * v + 1, l, (l + r) / 2, pos, x); } else { upd(2 * v + 2, (l + r) / 2, r, pos, x); } t[v] = max(t[2 * v + 1], t[2 * v + 2]); } int main() { scanf( %d , &n); for (int i = 0; i < n; i++) { int ww, hh; scanf( %d %d , &ww, &hh); a[i] = hh; b[i] = ww; W += ww; } build(0, 0, n); for (int i = 0; i < n; i++) { W -= b[i]; upd(0, 0, n, i, -10000); H = get(0, 0, n, 0, n); printf( %d , H * W); W += b[i]; upd(0, 0, n, i, a[i]); } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { long long left; long long right; scanf( %lld%lld , &left, &right); long long ans = 0LL; for (int i = (62); i >= (0); --i) { long long bitLeft = left & (1LL << i); long long bitRight = right & (1LL << i); if (bitRight && !bitLeft) { ans = (1LL << (i + 1)) - 1LL; printf( %lld n , ans); return 0; } } printf( %lld n , ans); return 0; }
|
#include <bits/stdc++.h> long long k, pa, pb, dp[1107][1107]; int main() { scanf( %lld%lld%lld , &k, &pa, &pb); long long invb = 1, base = pb; for (int t = 1000000007 - 2; t; t >>= 1, (base *= base) %= 1000000007) if (t & 1) (invb *= base) %= 1000000007; long long inva_b = 1; base = pa + pb; for (int t = 1000000007 - 2; t; t >>= 1, (base *= base) %= 1000000007) if (t & 1) (inva_b *= base) %= 1000000007; long long invab = pa * invb % 1000000007; pa *= inva_b; pa %= 1000000007; pb *= inva_b; pb %= 1000000007; for (int i = k; ~i; --i) for (int j = k; ~j; --j) if (i + j >= k) dp[i][j] = (i + j + invab) % 1000000007; else dp[i][j] = pa * dp[i + 1][j] % 1000000007 + pb * dp[i][i + j] % 1000000007, dp[i][j] %= 1000000007; printf( %lld n , dp[1][0]); return 0; }
|
#include <bits/stdc++.h> using namespace std; template <class Ta, class Tb> inline Tb cast(Ta a) { stringstream ss; ss << a; Tb b; ss >> b; return b; }; const double EPS = 1e-9; const int INF = 1000000000; const int MOD = 1000000007; const int diri[8] = {-1, 0, 1, 0, -1, 1, 1, -1}; const int dirj[8] = {0, 1, 0, -1, 1, 1, -1, -1}; vector<int> tree; int root(int n) { if (tree[n] == -1) return n; return tree[n] = root(tree[n]); } int main() { int n, m; cin >> n >> m; vector<int> deg(n, 0); tree = vector<int>(n, -1); for (int i = 0; i < m; ++i) { int x, y; cin >> x >> y; --x; --y; ++deg[x]; ++deg[y]; int a = root(x), b = root(y); if (a != b) { tree[b] = a; } } int c = 0; for (int i = 0; i < n; ++i) if (deg[i] != 0 and tree[i] == -1) ++c; if (deg[0] == 0 and c > 0) ++c; int s = 0; for (int i = 0; i < n; ++i) if (deg[i] % 2 == 1) ++s; if (c == 1) cout << s / 2 << endl; else { vector<int> v(n, 0); for (int i = 0; i < n; ++i) if (deg[i] % 2 == 1) v[root(i)] = 1; int t = 0; for (int i = 0; i < n; ++i) t += v[i]; cout << c + s / 2 - t << endl; } }
|
#include <bits/stdc++.h> using namespace std; int main() { int n, m, h; string s; cin >> n >> s; m = (s[3] - 0 ) * 10 + s[4] - 0 ; if (m > 59) { s[3] = 0 ; } if (n == 24) { h = (s[0] - 0 ) * 10 + s[1] - 0 ; if (h > 23) { if (s[0] - 0 > 2) s[0] = 0 ; else if (s[1] - 0 > 3) s[1] = 0 ; } } else { h = (s[0] - 0 ) * 10 + s[1] - 0 ; if (h == 0) s[1] = 1 ; if (h > 12) { if (s[0] - 0 > 1) s[0] = 0 ; else if (s[1] - 0 > 2) s[1] = 2 ; if (s[0] == 0 && s[1] == 0 ) s[0] = 1 ; } } cout << s << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(0); cin.tie(0); priority_queue<int, vector<int>, greater<int>> pq; int n, k; cin >> n >> k; for (int i = 0; i < n; i++) { int x; cin >> x; pq.push(x); } int ans = 0; for (int i = 0; i < k; i++) { ans += pq.top(); pq.pop(); } cout << ans << n ; return 0; }
|
#include <bits/stdc++.h> using namespace std; const int N = 1e5 + 5; map<int, int> v[N]; int rec(int node, int w) { auto it = v[node].lower_bound(w); if (it == v[node].begin()) { return 1; } it--; return (*it).second + 1; } int32_t main() { ios::sync_with_stdio(0); cin.tie(0); int n, m; cin >> n >> m; int ans = 0; while (m--) { int a, b, w; cin >> a >> b >> w; int val = rec(a, w); if (rec(b, w + 1) > val) { continue; } v[b][w] = val; auto it = v[b].upper_bound(w); while (it != v[b].end() && (*it).second <= val) { it = v[b].erase(it); } ans = max(ans, val); } cout << ans; }
|
#include <bits/stdc++.h> using namespace std; int main() { long long int a, b; scanf( %lld%lld , &a, &b); long long int c = a, d = b; long long int cnt = 0, rem; while (c >= 1 && d >= 1) { if (d == 1) { printf( %lld , cnt + c); return 0; } if (c >= d) { cnt += c / d; c = c % d; } else { cnt += d / c; d = d % c; } } printf( %lld n , cnt); return 0; }
|
#include <bits/stdc++.h> using namespace std; const int N = (int)5e5 + 9; vector<int> T[N]; bool use[2 * N]; int p; int l[N], r[N]; void dfs(int u, int par) { if (par == -1) { l[u] = 1; r[u] = T[u].size() + 2; use[1] = true; use[T[u].size() + 2] = true; p = T[u].size() + 3; vector<pair<int, int> > srt; int fl = 2; for (auto x : T[u]) { if (x == par) continue; dfs(x, u); srt.push_back(make_pair(r[x], x)); } sort(srt.begin(), srt.end()); reverse(srt.begin(), srt.end()); for (int i = 0; i < srt.size(); i++) { l[srt[i].second] = fl++; } return; } vector<int> rr; for (auto x : T[u]) { if (x == par) { continue; } while (use[p]) p++; use[p] = true; rr.push_back(p); } while (use[p]) p++; r[u] = p; use[p] = true; vector<pair<int, int> > srt; for (int i = 0; i < T[u].size(); i++) { if (T[u][i] == par) continue; dfs(T[u][i], u); srt.push_back(make_pair(r[T[u][i]], T[u][i])); } sort(srt.begin(), srt.end()); reverse(srt.begin(), srt.end()); for (int i = 0; i < srt.size(); i++) { l[srt[i].second] = rr[i]; } } int main() { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); ; int n; cin >> n; int x, y; for (int i = 1; i < n; i++) { cin >> x >> y; T[x].push_back(y); T[y].push_back(x); } dfs(1, -1); for (int i = 1; i <= n; i++) cout << l[i] << << r[i] << n ; return 0; }
|
#include <bits/stdc++.h> #pragma GCC optimize( O3 ) #pragma GCC target( avx2 ) using namespace std; const long double two = 2; const long double INF = 2e18 + 100; const long long MOD = 998244353; const long long N = 1e5 + 10; const long long nul = 0; const long long SIZE = 1e6 * 3; struct exam { long long s, d, c, ind; exam(long long s1, long long d1, long long c1, long long ind1) { s = s1; d = d1; c = c1; ind = ind1; } }; vector<long long> ans; vector<exam> smth; bool lol(long long st, long long len, long long fin, long long ind) { long long i = st; while (len--) { while (ans[i] != 0 && i < fin) i++; if (i == fin) return 0; ans[i] = ind + 1; } return 1; } bool comp(exam a, exam b) { if (a.d < b.d) return 1; else return 0; } signed main() { long long n, m; cin >> n >> m; ans.resize(n, 0); smth; for (long long i = 0; i < m; i++) { long long s, d, c; cin >> s >> d >> c; s--; d--; ans[d] = m + 1; smth.push_back(exam(s, d, c, i)); } sort((smth).begin(), (smth).end(), comp); bool flag = 0; for (long long i = 0; i < m; i++) { if (lol(smth[i].s, smth[i].c, smth[i].d, smth[i].ind) == 0) flag = 1; } if (flag) cout << -1 << endl; else { for (long long i : ans) cout << i << ; cout << endl; } }
|
#include <bits/stdc++.h> using namespace std; bool sol(long long n, long long m, long long a, long long l, long long r, long long& b, long long& c) { if (abs(n * a - m) <= r - l) { long long diff = m - n * a; b = diff > 0 ? r : l; c = b - diff; return true; } return false; } int main() { int T; cin >> T; while (T--) { long long l, r, m; cin >> l >> r >> m; for (long long a = l; a <= r; a++) { long long n0 = m / a, n1 = m / a + 1; long long b, c; if (n0 > 0 && sol(n0, m, a, l, r, b, c)) { printf( %lld %lld %lld n , a, b, c); break; } if (n1 > 0 && sol(n1, m, a, l, r, b, c)) { printf( %lld %lld %lld n , a, b, c); break; } } } }
|
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false), cin.tie(nullptr); string a, b, c = ; cin >> a >> b; for (int i = 0; i < a.length(); i++) { if (a[i] + 1 < b[i]) { c += a[i] + 1; for (int j = i + 1; j < a.length(); j++) c += z ; break; } else if (a[i] + 1 == b[i]) { bool big = 0; for (int j = i + 1; j < a.length(); j++) { if (a[j] != z ) big = 1; } if (big) { c += a[i]; for (int j = i + 1; j < a.length(); j++) c += z ; break; } else { c += a[i] + 1; for (int j = i + 1; j < a.length(); j++) c += a ; break; } } else c += a[i]; } if (c != a && c != b) cout << c; else cout << No such string ; return 0; }
|
#include <bits/stdc++.h> using namespace std; int arr[5] = {10, 15, 60, 4, 19}; int result = 0; int getMin(int r, int g, int b) { if (r < g) { if (r < b) { return r; } else { return b; } } else { if (g < b) { return g; } else { return b; } } } int getMax(int r, int g, int b) { if (r > g) { if (r > b) { return r; } else { return b; } } else { if (g > b) { return g; } else { return b; } } } int getMin(int a, int b) { if (a < b) { return a; } else { return b; } } void solve(int r, int g, int b) { int count = 0; int sum = r + g + b; int min = getMin(r, g, b); int max = getMax(r, g, b); int mid = sum - (min + max); result = getMin(sum / 2, min + mid); } void print(int arr[], int n) { for (int i = 0; i < n; i++) { printf( %d , arr[i]); } } void merge(int a[], int l, int m, int r) { int n1 = m - l + 1; int n2 = r - m; int *L = new int[n1]; int *R = new int[n2]; for (int i = 0; i < n1; i++) { L[i] = arr[l + i]; } for (int i = 0; i < n2; i++) { R[i] = arr[m + 1 + i]; } int i = 0, j = 0, k = l; while (i < n1 && j < n2) { if (L[i] < R[j]) { arr[k] = L[i]; k++; i++; } else { arr[k] = R[j]; j++; k++; } } while (i < n1) { arr[k] = L[i]; k++; i++; } while (j < n2) { arr[k] = R[j]; k++; j++; } } void merge(int a[], int l, int r) { if (l < r) { int m = l + (r - l) / 2; merge(arr, l, m); merge(arr, m + 1, r); merge(arr, l, m, r); } } int main() { int n; int r, g, b; char ch; int min = 9999999, max = -9999999; scanf( %d , &n); for (int i = 0; i < n; i++) { scanf( %d , &r); if (r > max) { max = r; } scanf( %d , &g); if (g > max) { max = g; } scanf( %d , &b); if (b > max) { max = b; } solve(r, g, b); printf( %d n , result); } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); string s; cin >> s; long long a = -1, b = -1; int flag = 0; for (int i = 0; i < s.length(); i++) { if (s[i] == [ ) { a = i; flag = 1; break; } } if (flag == 0) { cout << -1 ; return 0; } flag = 0; for (int i = a; i < s.length(); i++) { if (s[i] == : ) { a = i; flag = 1; break; } } if (flag == 0) { cout << -1 ; return 0; } flag = 0; for (int i = s.length() - 1; i >= 0; i--) { if (s[i] == ] ) { b = i; flag = 1; break; } } if (flag == 0) { cout << -1 ; return 0; } flag = 0; for (int i = b; i >= 0; i--) { if (s[i] == : ) { b = i; flag = 1; break; } } if (flag == 0) { cout << -1 ; return 0; } if (a >= b) { cout << -1 ; return 0; } long long ans = 4; for (int i = a + 1; i <= b - 1; i++) { if (s[i] == | ) ans++; } cout << ans << endl; }
|
#include <bits/stdc++.h> using namespace std; long long int a[500005]; int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); long long int t, n, m, q, i, j, k, x, y = 2, z; cin >> n >> k; set<long long int> s; for (i = 0; i < n; i++) cin >> a[i]; sort(a, a + n); for (i = 0; i < n - 1; i++) { x = a[i] + k; if (x + k <= a[i + 1]) s.insert(x); x = a[i + 1] - k; if (a[i] + k <= x) s.insert(x); } cout << s.size() + 2; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n, x, y; cin >> n >> x >> y; int z = n / 2; if (x >= z && x <= z + 1 && y >= z && y <= z + 1) cout << NO ; else cout << YES ; return 0; }
|
#include <bits/stdc++.h> using namespace std; const int MAXN = 405; char G[405][405], P[405][405]; bitset<MAXN> nolet[405][27]; int main() { int N, M; scanf( %d%d , &N, &M); for (int i = 0; i < N; ++i) { scanf( %s , G[i]); for (int c = 0; c < 26; ++c) for (int j = 0; j < M; ++j) if (G[i][j] - a != c) nolet[i][c].set(j); } int R, C; scanf( %d%d , &R, &C); for (int i = 0; i < R; ++i) { scanf( %s , P[i]); } for (int i = 0; i < N; ++i) { bitset<MAXN> no; for (int r = 0; r < R; ++r) for (int c = 0; c < C; ++c) { if (P[r][c] == ? ) continue; int ii = (i + r) % N; auto b = nolet[ii][P[r][c] - a ]; no |= (b >> c) | (b << (M - c)); } for (int j = 0; j < M; ++j) printf( %d , !no[j]); printf( n ); } }
|
#include <bits/stdc++.h> int a[100000]; int main() { int y, k, n, i; while (scanf( %d %d %d , &y, &k, &n) != EOF) { int flag = 0; int l = n / k; for (i = 1; i <= l; i++) { a[i] = i * k; if (a[i] > y) { printf( %d , a[i] - y); flag = 1; } } if (flag == 0) printf( -1 ); printf( n ); } }
|
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; char a[n][5]; for (int i = 1; i <= n; i++) { for (int j = 1; j <= 5; j++) { cin >> a[i][j]; } } int flag = 0; for (int i = 1; i <= n; i++) { for (int j = 1; j <= 4; j++) { if ((a[i][j] == O ) && (a[i][j + 1] == O )) { a[i][j] = + ; a[i][j + 1] = + ; flag = 1; break; } } if (flag) break; } if (flag) { cout << YES << endl; for (int i = 1; i <= n; i++) { for (int j = 1; j <= 5; j++) { cout << a[i][j]; } cout << endl; } } else cout << NO << endl; return 0; }
|
#include <bits/stdc++.h> const int inf = (1ll << 30) - 1; const int maxn = (int)1e5 + 10; using namespace std; pair<long long, long long> e[100100]; int en; vector<int> g[100100]; long long dp[100100], d[100100]; int pr[100100]; int used[100100]; long long mi[100100]; int n, m, L, second, t; void solve() { scanf( %d%d%d%d%d , &n, &m, &L, &second, &t); long long cons = (long long)1e9 + 1; for (int i = 0, a, b, w; i < m; i++) { scanf( %d%d%d , &a, &b, &w); if (w == 0) { g[a].push_back(en); g[b].push_back(en); e[en++] = make_pair(a ^ b, cons); } else { g[a].push_back(en); g[b].push_back(en); e[en++] = make_pair(a ^ b, w); } } for (int i = 0; i < n; i++) { dp[i] = 2ll * cons * n; } dp[t] = 0; for (int i = 0; i < n; i++) { int v = -1; for (int j = 0; j < n; j++) { if (used[j]) continue; if (v == -1 || dp[v] > dp[j]) v = j; } used[v] = 1; for (int j = 0; j < g[v].size(); j++) { int ind = g[v][j]; int to = e[ind].first ^ v; if (used[to]) continue; if (e[ind].second < cons) { dp[to] = min(dp[v] + e[ind].second, dp[to]); } } } for (int i = 0; i < n; i++) { d[i] = 2ll * cons * n; used[i] = 0; } d[second] = 0; for (int i = 0; i < n; i++) { int v = -1; for (int j = 0; j < n; j++) { if (used[j]) continue; if (v == -1 || d[v] > d[j]) v = j; } used[v] = 1; for (int j = 0; j < g[v].size(); j++) { int ind = g[v][j]; int to = e[ind].first ^ v; if (used[to]) continue; if (e[ind].second < cons) { d[to] = min(d[v] + e[ind].second, d[to]); } } } for (int i = 0; i < n; i++) { used[i] = 0; } for (int i = 0; i < n; i++) { int v = -1; for (int j = 0; j < n; j++) { if (used[j]) continue; if (v == -1 || d[v] > d[j]) v = j; } used[v] = 1; for (int j = 0; j < g[v].size(); j++) { int ind = g[v][j]; int to = e[ind].first ^ v; if (e[ind].second < cons) { d[to] = min(d[v] + e[ind].second, d[to]); } else { if (mi[ind] == 0) { mi[ind] = max(L - d[v] - dp[to], 1ll); } else { mi[ind] = max(L - d[v] - dp[to], mi[ind]); } d[to] = min(d[v] + mi[ind], d[to]); } } } for (int i = 0; i < n; i++) { d[i] = 2ll * cons * n; used[i] = 0; } for (int i = 0; i < en; i++) { if (e[i].second == cons) e[i].second = mi[i]; } d[second] = 0; for (int i = 0; i < n; i++) { int v = -1; for (int j = 0; j < n; j++) { if (used[j]) continue; if (v == -1 || d[v] > d[j]) v = j; } used[v] = 1; for (int j = 0; j < g[v].size(); j++) { int ind = g[v][j]; int to = e[ind].first ^ v; d[to] = min(d[v] + e[ind].second, d[to]); } } if (d[t] != L) { printf( NO n ); return; } printf( YES n ); for (int i = 0; i < n; i++) { for (int j = 0; j < g[i].size(); j++) { int ind = g[i][j]; int to = e[ind].first ^ i; if (to > i) { printf( %d %d %I64d n , to, i, e[ind].second); } } } } int main() { int t = 1; for (int i = 1; i <= t; i++) { solve(); } return 0; }
|
#include <bits/stdc++.h> using namespace std; int n, m; int sz = 1; string data[109]; struct node { int x, y; int pos; }; bool operator<(const node& a, const node& b) { if (a.x == b.x) { if (a.y == b.y) { return a.pos < b.pos; } return a.y < b.y; } return a.x < b.x; } map<node, int> mem; int conv(vector<int> v) { int ret = 0; for (typeof(v.begin()) it = (v.begin()); it != v.end(); it++) { ret = ret * 4 + (*it); } return ret; } vector<int> conv2(int pos) { vector<int> ret; for (long long i = 0; i < (long long)sz - 1; i++) { ret.push_back(pos % 4); pos /= 4; } reverse(ret.begin(), ret.end()); return ret; } int main() { scanf( %d , &n); scanf( %d , &m); for (long long i = 0; i < (long long)n; i++) cin >> data[i]; queue<node> q; vector<int> p; int x = -1, y; node top; for (long long i = 0; i < (long long)n; i++) { for (long long j = 0; j < (long long)m; j++) { if (data[i][j] == 1 ) { x = i; y = j; } if (data[i][j] > 1 && data[i][j] <= 9 ) { sz = max(sz, (int)(data[i][j] - 0 )); } } } top.x = x; top.y = y; int xx, yy, px = x, py = y; for (long long i = 0; i < (long long)sz - 1; i++) { if (px - 1 >= 0) { if ((data[px - 1][py] - 1 ) == i + 1) { px--; p.push_back(0); } } if (px + 1 < n) { if ((data[px + 1][py] - 1 ) == i + 1) { px++; p.push_back(1); } } if (py - 1 >= 0) { if ((data[px][py - 1] - 1 ) == i + 1) { py--; p.push_back(2); } } if (py + 1 < m) { if ((data[px][py + 1] - 1 ) == i + 1) { py++; p.push_back(3); } } } top.pos = conv(p); q.push(top); mem[top] = 1; while (!q.empty()) { top = q.front(); x = top.x; y = top.y; int pos = top.pos; int cost = mem[top]; q.pop(); p = conv2(pos); if (data[x][y] == @ ) { cout << cost - 1 << endl; return 0; } px = x; py = y; if (px - 1 >= 0 && ((data[px - 1][py]) != # )) { vector<int> nw; nw.push_back(1); nw.insert(nw.end(), p.begin(), p.end() - 1); int xx, yy; xx = px - 1; yy = py; node temp; temp.x = xx; temp.y = yy; xx = x; yy = y; int flag = 0; for (int i = 1; i < sz - 1; i++) { if (nw[i] == 0) { xx--; } else if (nw[i] == 1) xx++; else if (nw[i] == 2) yy--; else yy++; if (xx == temp.x && yy == temp.y) { flag = 1; break; } } if (flag == 0) { temp.pos = conv(nw); if (mem.find(temp) == mem.end()) { mem[temp] = cost + 1; q.push(temp); } } } if (px + 1 < n && ((data[px + 1][py]) != # )) { vector<int> nw; nw.push_back(0); nw.insert(nw.end(), p.begin(), p.end() - 1); int xx, yy; xx = px + 1; yy = py; node temp; temp.x = xx; temp.y = yy; xx = x; yy = y; int flag = 0; for (int i = 1; i < sz - 1; i++) { if (nw[i] == 0) { xx--; } else if (nw[i] == 1) xx++; else if (nw[i] == 2) yy--; else yy++; if (xx == temp.x && yy == temp.y) { flag = 1; break; } } if (flag == 0) { temp.pos = conv(nw); if (mem.find(temp) == mem.end()) { mem[temp] = cost + 1; q.push(temp); } } } if (py - 1 >= 0 && ((data[px][py - 1]) != # )) { vector<int> nw; nw.push_back(3); nw.insert(nw.end(), p.begin(), p.end() - 1); int xx, yy; xx = px; yy = py - 1; node temp; temp.x = xx; temp.y = yy; xx = x; yy = y; int flag = 0; for (int i = 1; i < sz - 1; i++) { if (nw[i] == 0) { xx--; } else if (nw[i] == 1) xx++; else if (nw[i] == 2) yy--; else yy++; if (xx == temp.x && yy == temp.y) { flag = 1; break; } } if (flag == 0) { temp.pos = conv(nw); if (mem.find(temp) == mem.end()) { mem[temp] = cost + 1; q.push(temp); } } } if (py + 1 < m && ((data[px][py + 1]) != # )) { vector<int> nw; nw.push_back(2); nw.insert(nw.end(), p.begin(), p.end() - 1); int xx, yy; xx = px; yy = py + 1; node temp; temp.x = xx; temp.y = yy; xx = x; yy = y; int flag = 0; for (int i = 1; i < sz - 1; i++) { if (nw[i] == 0) { xx--; } else if (nw[i] == 1) xx++; else if (nw[i] == 2) yy--; else yy++; if (xx == temp.x && yy == temp.y) { flag = 1; break; } } if (flag == 0) { temp.pos = conv(nw); if (mem.find(temp) == mem.end()) { mem[temp] = cost + 1; q.push(temp); } } } } cout << -1 << endl; }
|
#include <bits/stdc++.h> using namespace std; int n; int p; int a[300010]; int ans; int main() { int i, j, k; scanf( %d , &n); ans = 1; a[n + 1] = -1; printf( 1 ); for (k = 1; k <= n; ++k) { scanf( %d , &p); if (a[p + 1] == -1) { i = p - 1; a[p] = -1; while ((i > 0) && (a[i] == 1)) { a[i] = -1; --ans; --i; } } else { if (!a[p]) { a[p] = 1; ++ans; } } printf( %d , ans); } }
|
#include <bits/stdc++.h> using namespace std; int main() { long long sum = 0; int d[1000000 + 1] = {0}; for (int i = 1; i <= 1000000; i++) { for (int j = i; j <= 1000000; j += i) { d[j]++; } } int a, b, c; cin >> a >> b >> c; for (auto(i) = (1); (i) < (a + 1); ++(i)) for (auto(j) = (1); (j) < (b + 1); ++(j)) for (auto(k) = (1); (k) < (c + 1); ++(k)) sum = (sum + d[i * j * k]) % 1073741824; cout << sum % 1073741824; return 0; }
|
#include <bits/stdc++.h> struct Seg { int l; int r; int y; }; struct Event { int x; enum { BEG, END } type; Seg seg; static Event beginOf(Seg seg) { return Event{seg.l, BEG, seg}; } static Event endOf(Seg seg) { return Event{seg.r, END, seg}; } friend bool operator<(const Event& a, const Event& b) { return std::tie(a.x, a.type, a.seg.y) < std::tie(b.x, b.type, b.seg.y); } }; int main() { int sx, sy; std::cin >> sy >> sx; std::vector<Event> events; events.reserve(sy * sx); for (int y = 0; y < sy; y++) { int intervals; std::cin >> intervals; for (int i = 0; i < intervals; i++) { int l, r; std::cin >> l >> r; Seg seg{l - 1, r, y}; events.push_back(Event::beginOf(seg)); events.push_back(Event::endOf(seg)); } } std::sort(events.begin(), events.end()); std::vector<std::vector<int>> dp(sx + 1, std::vector<int>(sx + 1, 0)); for (int len = 1; len <= sx; len++) { for (int l = 0, r = len; r <= sx; l++, r++) { int currHeight = 0; auto currEv = events.begin(); for (int x = l; x < r; x++) { for (; currEv != events.end() && currEv->x <= x; ++currEv) { if (l <= currEv->seg.l && currEv->seg.r <= r) { if (currEv->type == Event::BEG) currHeight++; else currHeight--; } } dp[l][r] = std::max(dp[l][r], dp[l][x] + dp[x + 1][r] + currHeight * currHeight); } } } std::cout << dp[0][sx] << std::endl; }
|
#include <bits/stdc++.h> using namespace std; inline int read() { int x = 0, f = 1; char c = getchar(); while (c < 0 || c > 9 ) { if (c == - ) f = -1; c = getchar(); } while (c >= 0 && c <= 9 ) { x = (x << 3) + (x << 1) + (c ^ 48); c = getchar(); } return f == 1 ? x : ~x + 1; } inline void print(int x) { if (x < 0) putchar( - ), x = ~x + 1; if (x >= 10) print(x / 10); putchar((x % 10) | 48); } int typ; int n; int h[500010]; int ans[500010]; set<int> st; int Id[500010]; bool cmp(int x, int y) { return h[x] > h[y]; } bool b[500010]; int Ans; struct node { int vl, vr, l, r, ans; bool full; node() { vl = vr = l = r = full = 0; } void init(int x) { vl = vr = x; l = r = ans = full = 1; } } tre[2000010]; node pushup(node ls, node rs) { node u; u.vl = ls.vl, u.vr = rs.vr; u.ans = max(ls.ans, rs.ans); u.l = ls.l, u.r = rs.r; u.full = 0; if (ls.vr ^ rs.vl) { u.ans = max(u.ans, ls.r + rs.l); u.full = (ls.full & rs.full); if (ls.full) u.l = ls.l + rs.l; if (rs.full) u.r = rs.r + ls.r; } return u; } void build(int p, int l, int r) { if (l == r) { tre[p].init(0); return; } int mid = l + r >> 1; build(p << 1, l, mid); build(p << 1 | 1, mid + 1, r); tre[p] = pushup(tre[p << 1], tre[p << 1 | 1]); } void modify(int p, int l, int r, int pos) { if (l == r) { tre[p].init(1); return; } int mid = l + r >> 1; if (pos <= mid) modify(p << 1, l, mid, pos); else modify(p << 1 | 1, mid + 1, r, pos); tre[p] = pushup(tre[p << 1], tre[p << 1 | 1]); return; } node queryl(int p, int l, int r, int pos) { if (l == r) return tre[p]; int mid = l + r >> 1; if (pos <= mid) return queryl(p << 1, l, mid, pos); node u = queryl(p << 1 | 1, mid + 1, r, pos); return pushup(tre[p << 1], u); } node queryr(int p, int l, int r, int pos) { if (l == r) return tre[p]; int mid = l + r >> 1; if (pos > mid) return queryr(p << 1 | 1, mid + 1, r, pos); node u = queryr(p << 1, l, mid, pos); return pushup(u, tre[p << 1 | 1]); } void firm(int l, int r, int x) { auto itl = st.lower_bound(l); if (itl == st.end()) return; vector<set<int>::iterator> vit; while (itl != st.end() && (*itl) <= r) { vit.push_back(itl); ans[*itl] = x; ++itl; } for (auto i : vit) st.erase(i); } int main() { n = read(); for (int i = 1; i <= n; ++i) { h[i] = read(); st.insert(i); Id[i] = i; } sort(Id + 1, Id + n + 1, cmp); build(1, 1, n); for (int i = 1; i <= n; ++i) { modify(1, 1, n, Id[i]); b[Id[i]] = 1; if (h[Id[i]] != h[Id[i + 1]]) Ans = max(Ans, tre[1].ans - 1 >> 1); node tl = queryl(1, 1, n, Id[i]); node tr = queryr(1, 1, n, Id[i]); int sl = Id[i] - tl.r + 1, sr = Id[i] + tr.l - 1; if (b[sl] == 0) { if (b[sr] == 1) { int len = (sr - sl + 1); firm(sr - (len >> 1) + 1, sr, h[Id[i]]); } } else { if (b[sr] == 0) { int len = sr - sl + 1; firm(sl, sl + (len >> 1) - 1, h[Id[i]]); } else firm(sl, sr, h[Id[i]]); } if (sl == Id[i] && Id[i] != 1) { node tmp = queryl(1, 1, n, Id[i] - 1); int len = tmp.r; firm(Id[i] - (len >> 1), Id[i], h[Id[i]]); } if (sr == Id[i] && Id[i] != n) { node tmp = queryr(1, 1, n, Id[i] + 1); int len = tmp.l; firm(Id[i], Id[i] + (len >> 1), h[Id[i]]); } } printf( %d n , Ans); for (int i = 1; i <= n; ++i) printf( %d , ans[i]); }
|
#include <bits/stdc++.h> using namespace std; int main() { vector<string> v; int i, j, k, l, l1, l2; string a, b, s1, s2, s; cin >> a >> b; l1 = a.size(); l2 = b.size(); for (i = 1; i <= l1; i++) { for (j = 1; j <= l2; j++) { for (k = 0, s1 = ; k < i; k++) { s1 += a[k]; } for (l = 0, s2 = ; l < j; l++) { s2 += b[l]; } s = s1 + s2; v.push_back(s); } } sort(v.begin(), v.end()); cout << v[0] << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; int n; int m; struct st { int dp; int maxt; int cnt; bool use; st() { dp = maxt = cnt = 0; use = false; } }; vector<st> dp[123457]; vector<int> v[123457]; vector<int> nex[123457]; bool oc[123457]; bool visited[123457]; pair<int, int> max1[123457]; pair<int, int> max2[123457]; int sum_cnt[123457]; int not_contain[123457]; int dpp[123457]; inline void dfs(int a, int b) { if (dp[a][b].use) { return; } dp[a][b].use = true; if (visited[a]) { dp[a][b].cnt = sum_cnt[a]; dp[a][b].dp = dpp[a]; dp[a][b].maxt = max1[a].first; if (max1[a].second == b) { dp[a][b].maxt = max2[a].first; } dp[a][b].use = true; if (dp[v[a][b]][nex[a][b]].cnt) { dp[a][b].dp -= dp[v[a][b]][nex[a][b]].dp + 2; dp[a][b].cnt -= dp[v[a][b]][nex[a][b]].cnt; } dfs(v[a][not_contain[a]], nex[a][not_contain[a]]); if (dp[v[a][not_contain[a]]][nex[a][not_contain[a]]].cnt) { dp[a][b].dp += dp[v[a][not_contain[a]]][nex[a][not_contain[a]]].dp + 2; dp[a][b].cnt += dp[v[a][not_contain[a]]][nex[a][not_contain[a]]].cnt; dp[a][b].maxt = max(dp[a][b].maxt, dp[v[a][not_contain[a]]][nex[a][not_contain[a]]].maxt + 1); } return; } visited[a] = true; if (oc[a]) { dp[a][b].cnt++; } int siz = v[a].size(); pair<int, int> MA1 = make_pair(0, -1); pair<int, int> MA2 = make_pair(0, -1); for (int i = 0; i < siz; i++) { if (i == b) { continue; } int l = v[a][i]; int r = nex[a][i]; if (!dp[l][r].use) { dfs(l, r); } if (dp[l][r].cnt) { dp[a][b].cnt += dp[l][r].cnt; if (dp[l][r].maxt + 1 > dp[a][b].maxt) { dp[a][b].maxt = dp[l][r].maxt + 1; } pair<int, int> ne = make_pair(dp[l][r].maxt + 1, i); if (ne > MA1) { MA2 = MA1; MA1 = ne; } else { if (ne > MA2) { MA2 = ne; } } dp[a][b].dp += dp[l][r].dp + 2; } } sum_cnt[a] = dp[a][b].cnt; not_contain[a] = b; max1[a] = MA1; max2[a] = MA2; dpp[a] = dp[a][b].dp; } int main() { scanf( %d%d , &n, &m); for (int i = 1; i < n; i++) { int a, b; scanf( %d%d , &a, &b); a--; b--; nex[a].push_back(v[b].size()); nex[b].push_back(v[a].size()); v[a].push_back(b); v[b].push_back(a); } for (int i = 0; i < n; i++) { dp[i].assign(v[i].size(), st()); } for (int i = 0; i < m; i++) { int a; scanf( %d , &a); a--; oc[a] = true; } int ans = INT_MAX; int ans_index = 0; for (int i = 0; i < n; i++) { int maxx = 0; int sum = 0; int siz = v[i].size(); for (int j = 0; j < siz; j++) { int l = v[i][j]; int r = nex[i][j]; dfs(l, r); if (dp[l][r].cnt) { if (dp[l][r].maxt + 1 > maxx) { maxx = dp[l][r].maxt + 1; } sum += dp[l][r].dp + 2; } } sum -= maxx; if (ans > sum) { ans = sum; ans_index = i; } } printf( %d n , ans_index + 1); printf( %d n , ans); return 0; }
|
#include <bits/stdc++.h> using namespace std; void ok(int x) { cout << x << n ; exit(0); } int main() { int n, p; cin >> n >> p; for (int k = 0; k < int(1e8); k++) { long long n1 = n - 1LL * p * k; if (n1 < 0) continue; if (n1 >= k && k >= __builtin_popcountll(n1)) ok(k); } ok(-1); }
|
#include <bits/stdc++.h> using namespace std; vector<pair<int, int> > ans; vector<int> e[100010]; void dfs(int x, int p, int entry) { ans.emplace_back(x, entry); if (x == 1) { for (int it : e[x]) if (it != p) dfs(it, x, ++entry), ans.emplace_back(1, entry); } else { int cur = entry; int sz = e[x].size() - 1; if (entry - 1 >= sz) { cur = entry - 1 - sz; ans.emplace_back(x, cur); for (int it : e[x]) if (it != p) { cur++; dfs(it, x, cur), ans.emplace_back(x, cur); } } else { for (int it : e[x]) if (it != p) { ++cur; dfs(it, x, cur), ans.emplace_back(x, cur); if (cur == sz + 1) { cur = 0; ans.emplace_back(x, 0); } } } } } int main() { ios_base::sync_with_stdio(0); cin.tie(0); int n; cin >> n; for (int i = 1, u, v; i < n; i++) { cin >> u >> v; e[u].emplace_back(v); e[v].emplace_back(u); } dfs(1, 0, 0); cout << ans.size() << n ; for (auto &[u, v] : ans) cout << u << << v << n ; }
|
#include <bits/stdc++.h> using namespace std; int main() { string s; int n, sumA = 0, sumG = 0; cin >> n; vector<pair<int, int>> vec(n); for (int i = 0; i < n; i++) cin >> vec[i].first >> vec[i].second; if (vec[0].first > vec[0].second) { sumG = vec[0].second; s.push_back( G ); } else { sumA = vec[0].first; s.push_back( A ); } for (int i = 1; i < n; i++) { if (sumA + vec[i].first - sumG <= 500) { sumA += vec[i].first; s.push_back( A ); } else { sumG += vec[i].second; s.push_back( G ); } } if (abs(sumA - sumG) <= 500) cout << s; else cout << -1; return 0; }
|
#include <bits/stdc++.h> using namespace std; vector<int> spl; int p[2000006]; void prime() { p[0] = p[1] = 0; for (int i = 2; i < 1420; i++) { if (!p[i]) { spl.push_back(i); for (int j = i * i; j < 2000006; j += i) p[j] = i; } } } int n, q; int a[100005]; vector<int> edge[100005]; int par[100005]; int siz[100005]; int dep[100005]; int dfs1(int u, int p, int d) { par[u] = p; siz[u] = 1; dep[u] = d; for (auto v : edge[u]) if (v != p) siz[u] += dfs1(v, u, d + 1); return siz[u]; } int cnt; int reid[100005]; int reidm1[100005]; int head[100005]; void dfs2(int u, int h) { reid[u] = cnt; reidm1[cnt++] = u; head[reid[u]] = reid[h]; int ch = 0, s = 0; for (auto v : edge[u]) if (v != par[u] && s < siz[v]) s = siz[v], ch = v; if (!ch) return; dfs2(ch, h); for (auto v : edge[u]) if (v != par[u] && v != ch) dfs2(v, v); } vector<int> prv[2000006]; void scan() { for (int id = 1; id <= n; id++) { int val = a[reidm1[id]]; while (p[val] > 0) { prv[p[val]].push_back(id); int k = p[val]; while (val % k == 0) val /= k; } if (val > 1) prv[val].push_back(id); } } void build(int md) { if (md) dfs1(1, 0, 1); if (md) { cnt = 1; dfs2(1, 1); } scan(); } int find(int id, int p) { if (id < 1) return -1; auto it = upper_bound(prv[p].begin(), prv[p].end(), id); it--; if (head[id] <= *it && *it <= id) return *it; else return find(reid[par[reidm1[head[id]]]], p); } void sol() { while (q--) { int op, x, y; scanf( %d , &op); if (op == 1) { scanf( %d , &x); int val = a[x], ans = -1; while (p[val]) { ans = max(ans, find(reid[par[x]], p[val])); int k = p[val]; while (val % k == 0) val /= k; } if (val > 1) ans = max(ans, find(reid[par[x]], val)); printf( %d n , ans == -1 ? -1 : reidm1[ans]); } else { scanf( %d%d , &x, &y); int id = reid[x]; int val = a[x]; while (p[val] > 0) { int idx = lower_bound(prv[p[val]].begin(), prv[p[val]].end(), id) - prv[p[val]].begin(); prv[p[val]].erase(prv[p[val]].begin() + idx); int k = p[val]; while (val % k == 0) val /= k; } if (val > 1) { int idx = lower_bound(prv[val].begin(), prv[val].end(), id) - prv[val].begin(); prv[val].erase(prv[val].begin() + idx); } val = a[x] = y; while (p[val] > 0) { prv[p[val]].push_back(id); sort(prv[p[val]].begin(), prv[p[val]].end()); int k = p[val]; while (val % k == 0) val /= k; } if (val > 1) { prv[val].push_back(id); sort(prv[val].begin(), prv[val].end()); } } } } int main() { prime(); scanf( %d%d , &n, &q); for (int i = 1; i <= n; i++) scanf( %d , &a[i]); for (int i = 1; i < n; i++) { int x, y; scanf( %d%d , &x, &y); edge[x].push_back(y); edge[y].push_back(x); } build(1); sol(); return 0; }
|
#include <bits/stdc++.h> using namespace std; template <typename T> T gcd(T a, T b) { if (a == 0) return b; return gcd(b % a, a); } template <typename T> T pow(T a, T b, long long m) { T ans = 1; while (b > 0) { if (b % 2 == 1) ans = ((ans % m) * (a % m)) % m; b /= 2; a = ((a % m) * (a % m)) % m; } return ans % m; } int n; int a[1005]; int dp[1005][1005]; int solve(int f, int s) { if (f > n) return 0; if (s == n) { return max(a[f], a[s]); } if (s > n) { return a[f]; } if (dp[f][s] != -1) return dp[f][s]; int ans = (long long)1e9 + 2; ans = min(ans, max(a[f], a[s]) + solve(s + 1, s + 2)); ans = min(ans, max(a[f], a[s + 1]) + solve(s, s + 2)); ans = min(ans, max(a[s], a[s + 1]) + solve(f, s + 2)); return dp[f][s] = ans; } void print(int f, int s) { if (f > n) return; if (s == n) { cout << f << << s << n ; return; } if (s > n) { cout << f; return; } if (dp[f][s] == max(a[f], a[s]) + solve(s + 1, s + 2)) { cout << f << << s << n ; print(s + 1, s + 2); } else if (dp[f][s] == max(a[f], a[s + 1]) + solve(s, s + 2)) { cout << f << << s + 1 << n ; print(s, s + 2); } else if (dp[f][s] == max(a[s], a[s + 1]) + solve(f, s + 2)) { cout << s << << s + 1 << n ; print(f, s + 2); } } int main() { cin >> n; for (int i = 1; i <= n; i++) cin >> a[i]; memset(dp, -1, sizeof dp); cout << solve(1, 2) << n ; print(1, 2); }
|
#include <bits/stdc++.h> using namespace std; const int MAXH = 200000 + 10, MAXN = 2000 + 10; const long long MOD = 1000000007; struct Point { int x, y; bool operator<(const Point &p1) const { return x + y < p1.x + p1.y; } } p[MAXN]; long long fac[MAXH], inv[MAXH]; long long f[MAXN]; inline long long Fastpow(long long a, long long b) { long long res = 1; while (b) { if (b & 1) (res *= a) %= MOD; (a *= a) %= MOD; b >>= 1; } return res; } long long Calc(int a, int b) { return ((((fac[a + b - 2] * inv[a - 1]) % MOD) * inv[b - 1]) % MOD); } int main() { int h, w, n, mx; scanf( %d%d%d , &h, &w, &n); mx = h + w; for (int i = 1; i <= n; ++i) scanf( %d%d , &p[i].x, &p[i].y); p[++n] = (Point){h, w}; sort(p + 1, p + 1 + n); fac[0] = inv[0] = 1; for (int i = 1; i <= mx; ++i) fac[i] = fac[i - 1] * (long long)i % MOD; for (int i = 1; i <= mx; ++i) inv[i] = Fastpow(fac[i], MOD - 2); for (int i = 1; i <= n; ++i) { f[i] = Calc(p[i].x, p[i].y); for (int j = 1; j < i; ++j) if (p[j].x <= p[i].x && p[j].y <= p[i].y) { f[i] -= f[j] * Calc(p[i].x - p[j].x + 1, p[i].y - p[j].y + 1) % MOD; ((f[i] %= MOD) += MOD) %= MOD; } } cout << f[n] << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n, x = 0, y = 0; cin >> n; int *C = new int[n]; for (int i = 0; i < n; i++) { cin >> C[i]; } for (int j = 0; j < n; j++) { if (j == 0) { y = abs(C[j] - C[j + 1]); x = abs(C[j] - C[n - 1]); } else if (j == n - 1) { x = max(abs(C[j] - C[n - 1]), abs(C[j] - C[0])); y = abs(C[j] - C[j - 1]); } else { x = max(abs(C[j] - C[n - 1]), abs(C[j] - C[0])); y = min(abs(C[j] - C[j + 1]), abs(C[j] - C[j - 1])); } cout << y << << x << endl; } }
|
#include <bits/stdc++.h> using namespace std; int modul(int a, int b) { if (a - b < 0) return b - a; return a - b; } int main() { int n, k, st, et, s, e, d, v[103], j, m, stm, etm; cin >> n >> k; st = et = 0; d = 0; for (int i = 1; i <= n; i++) { cin >> v[i]; if (v[i] == 1) et++; else st++; } stm = etm = 0; for (int i = 1; i <= k; i++) { s = st; e = et; j = i; while (j <= n) { if (v[j] == 1) e--; else s--; j += k; } m = modul(s, e); if (m > d) { stm = s; etm = e; d = m; } } cout << d; return 0; }
|
#include <bits/stdc++.h> using namespace std; const int N = 1010, L = 33, B = 7340033, root = 3; int dp[L][N << 2]; int mypw(int x, int k) { int ret = 1; while (k) { if (k & 1) ret = 1ll * ret * x % B; k >>= 1; x = 1ll * x * x % B; } return ret; } void change(int y[], int l) { for (int i = 1, j = l / 2; i < l - 1; ++i) { if (i < j) swap(y[i], y[j]); int k = l / 2; while (j >= k) { j -= k; k >>= 1; } if (j < k) j += k; } } void fft(int y[], int l, int on) { change(y, l); for (int h = 2; h <= l; h <<= 1) { int wn = mypw(root, (B - 1) / h); if (on == -1) wn = mypw(wn, B - 2); for (int j = 0; j < l; j += h) { int w = 1; for (int k = j; k < j + h / 2; ++k) { int u = y[k]; int t = 1ll * y[k + h / 2] * w % B; y[k] = u + t; if (y[k] >= B) y[k] -= B; y[k + h / 2] = u + B - t; if (y[k + h / 2] >= B) y[k + h / 2] -= B; w = 1ll * w * wn % B; } } } if (on == -1) { int inv = mypw(l, B - 2); for (int i = 0; i < l; ++i) { y[i] = 1ll * y[i] * inv % B; } } } void calc(int a[], int b[], int l) { l *= 2; for (int i = 0; i < l; ++i) { if (i < l / 2) a[i] = b[i]; else a[i] = 0; } fft(a, l, 1); for (int i = 0; i < l; ++i) a[i] = 1ll * a[i] * a[i] % B; fft(a, l, -1); } void init() { dp[0][0] = 1; for (int i = 1; i < L; ++i) { calc(dp[i], dp[i - 1], 1 << 10); calc(dp[i], dp[i], 1 << 10); for (int j = (1 << 10) - 1; j > 0; --j) { dp[i][j] = dp[i][j - 1]; } dp[i][0] = 1; } } int main() { int q; init(); scanf( %d , &q); while (q--) { int n, k; scanf( %d%d , &n, &k); int cnt = 0; while (n > 1 && (n & 1)) { ++cnt; n >>= 1; } printf( %d n , dp[cnt][k]); } return 0; }
|
#include <bits/stdc++.h> const int BUFFSIZE = 10240; char BUFF[BUFFSIZE + 1], *p = BUFF; int CHAR, SIGN, BYTES = 0; using namespace std; vector<long long> V; void dfs(long long N) { if (N > 5000000000LL) return; V.push_back(N); dfs(N * 10 + 4); dfs(N * 10 + 7); } int main() { dfs(0); sort(V.begin(), V.end()); long long pl, pr, vl, vr, k; cin >> pl >> pr >> vl >> vr >> k; double den = (pr - pl + 1) * (vr - vl + 1); double num = 0; for (int i = 1; i + k - 1 < V.size(); i++) { long long x = V[i]; long long y = V[i + k - 1]; long long lftp = V[i - 1] + 1; long long rgtp = x; long long lftv = y; long long rgtv = V[i + k] - 1; lftp = max(lftp, pl); rgtp = min(rgtp, pr); lftv = max(lftv, vl); rgtv = min(rgtv, vr); if (lftp <= rgtp && lftv <= rgtv) { double prob = (rgtp - lftp + 1.0) * (rgtv - lftv + 1.0); num += prob; } lftv = V[i - 1] + 1; rgtv = x; lftp = y; rgtp = V[i + k] - 1; lftp = max(lftp, pl); rgtp = min(rgtp, pr); lftv = max(lftv, vl); rgtv = min(rgtv, vr); if (lftp <= rgtp && lftv <= rgtv) { double prob = (rgtp - lftp + 1.0) * (rgtv - lftv + 1.0); num += prob; } } if (k == 1) { for (int i = 1; i < V.size(); i++) if (V[i] >= pl && V[i] <= pr && V[i] >= vl && V[i] <= vr) num -= 1; } double res = 1.0 * num / den; printf( %.20lf n , res); return 0; }
|
#include <bits/stdc++.h> using namespace std; using ll = long long; bitset<10000> B; int BIT[100010]; int n; void update(int pos, int x) { for (; pos < n; pos |= pos + 1) BIT[pos] += x; } int qu(int pos) { int ret = 0; for (; pos; pos &= pos - 1) ret += BIT[pos - 1]; return ret; } int main() { ios::sync_with_stdio(0); cin.tie(0); for (int len = 1; len <= 4; ++len) { for (int mask = 0; mask < 1 << len; ++mask) { int num = 0; for (int bit = 0; bit < len; ++bit) if (mask & (1 << bit)) num = num * 10 + 4; else num = num * 10 + 7; B[num] = 1; } } int m; cin >> n >> m; int a[n]; for (int i = 0; i < n; ++i) { cin >> a[i]; if (B[a[i]]) update(i, 1); } while (m--) { string type; int l, r; cin >> type >> l >> r; if (type == count ) { cout << qu(r) - qu(l - 1) << n ; } else { int d; cin >> d; for (int i = l - 1; i <= r - 1; ++i) { if (B[a[i]]) update(i, -1); a[i] += d; if (B[a[i]]) update(i, 1); } } } }
|
#include <bits/stdc++.h> using namespace std; const long long mod = 1e9 + 7; const int maxn = 1e5 + 5; long long dp[205][15005]; long long p2[205], p5[205]; long long a[205]; int n, k; int main() { cin >> n >> k; for (int i = 1; i <= n; i++) { cin >> a[i]; while (a[i] % 2 == 0) a[i] /= 2, p2[i]++; while (a[i] % 5 == 0) a[i] /= 5, p5[i]++; } memset(dp, -0x3f3f3f3f, sizeof(dp)); dp[0][0] = 0; for (int i = 1; i <= n; i++) { for (int j = k; j >= 1; j--) { for (int k = 12005; k >= p2[i]; k--) { dp[j][k] = max(dp[j][k], dp[j - 1][k - p2[i]] + p5[i]); } } } long long mx = 0; for (long long i = 0; i <= 12005; i++) { mx = max(mx, min(i, dp[k][i])); } printf( %lld n , mx); return 0; }
|
#include <bits/stdc++.h> using namespace std; map<string, int> types; int count(const string &data) { int amps = 0, stars = 0, i, j; for (i = 0; i < (int)data.size() && data[i] == & ; i++, amps++) ; for (j = data.size() - 1; j >= 0 && data[j] == * ; j--, stars++) ; string t = data.substr(i, j - i + 1); if (!types.count(t) || types[t] == -1) return -1; int answer = types[t]; answer += stars - amps, answer = max(-1, answer); return answer; } int n; string command, a, b; int main() { cin >> n; types[ void ] = 0, types[ errtype ] = -1; for (int i = 0; i < n; i++) { cin >> command >> a; if (command == typedef ) cin >> b, types[b] = count(a); else { int p = count(a); if (p == -1) cout << errtype << endl; else { cout << void ; for (int i = 0; i < p; i++) cout << * ; cout << endl; } } } return 0; }
|
#include <bits/stdc++.h> using namespace std; int Case, n, sz, ans, A[300000 + 5], Min[300000 + 5], Max[300000 + 5], Id[300000 + 5]; int main() { for (scanf( %d , &Case); Case; Case--) { scanf( %d , &n); for (int i = 1; i <= n; i++) Id[i] = 0, Min[i] = n + 1, Max[i] = 0; for (int i = 1; i <= n; i++) { scanf( %d , A + i); Id[A[i]] = 1; } for (int i = 1; i <= n; i++) Id[i] += Id[i - 1]; sz = Id[n]; for (int i = 1; i <= n; i++) { A[i] = Id[A[i]]; Min[A[i]] = min(Min[A[i]], i); Max[A[i]] = max(Max[A[i]], i); } ans = sz; for (int l = 1, r = 0, mx; l <= sz; l++) { if (r < l) r = l, mx = Max[l]; for (; r < sz && Min[r + 1] > mx; r++) mx = Max[r + 1]; ans = min(ans, sz - (r - l + 1)); } printf( %d n , ans); } return 0; }
|
#include <bits/stdc++.h> using namespace std; int k; long long int m, lim = 2e18; long long int dp[70][70][2]; long long int solve(string s, int pos, int k, bool f) { if (k < 0) return 0; if (pos == (int)s.size()) { return (k == 0); } if (dp[pos][k][f] != -1) return dp[pos][k][f]; long long int ret = 0; for (char c = 0 ; c <= 1 ; ++c) { if (!f and s[pos] < c) continue; ret += solve(s, pos + 1, k - (c == 1 ), f | (s[pos] > c)); } return dp[pos][k][f] = ret; } long long int get(string s) { if (s == 1 ) { if (k == 1) return 1; else return 0; } memset(dp, -1, sizeof dp); return solve(s, 0, k, 0); } string binary(long long int num) { string ret = ; while (num) { if (num & 1) ret += 1 ; else ret += 0 ; num >>= 1LL; } reverse((ret).begin(), (ret).end()); return ret; } long long int search(long long int l, long long int r) { long long int mid = (l + r) / 2LL; long long int tot = get(binary(2 * mid)) - get(binary(mid)); if (tot == m) return mid; else if (tot < m) return search(mid + 1, r); return search(l, mid - 1); } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); while (cin >> m >> k) { long long int ans = search(1LL, lim); cout << ans << n ; } }
|
#include <bits/stdc++.h> int arr[1005]; int n; using namespace std; int main() { int n; scanf( %d , &n); int sum = 0; for (int i = 0; i < 505; i++) { sum += i; arr[i + 1] = sum; } if (n == 0) { printf( a n ); return 0; } for (int i = 0; i < 26; i++) { if (n == 0) { return 0; } int howmany = lower_bound(arr, arr + 500, n) - arr; if (arr[howmany] == n) { for (int j = 0; j < howmany; j++) { printf( %c , a + i); } printf( n ); return 0; } if (arr[howmany] > n) { n -= arr[howmany - 1]; for (int j = 0; j < howmany - 1; j++) { printf( %c , a + i); } continue; } } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { long long n; cin >> n; vector<long long> p(n); for (auto& i : p) cin >> i; vector<long long> dp(n, 1); vector<int> exist(n, false); for (long long i = 0; i < (n); ++i) { exist[p[i] - 1] = true; if (p[i] != 1) if (exist[p[i] - 2]) { dp[p[i] - 1] = 1 + dp[p[i] - 2]; } } long long max_c = 0; for (long long i = 0; i < (n); ++i) max_c = max(max_c, dp[i]); cout << n - max_c << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; const long long N = 5 * 1e5 + 1; int main() { long long q; cin >> q; vector<long long> v(N); for (int i = 0; i <= N; i++) { v[i] = i; } deque<long long> dq; vector<pair<long long, long long>> pq(q); long long idx = 0; while (q--) { long long a; cin >> a; if (a == 1) { long long b; cin >> b; pq[idx].first = b; pq[idx].second = 0; idx++; } else { long long b, c; cin >> b >> c; pq[idx].first = b; pq[idx].second = c; idx++; } } for (int i = idx - 1; i >= 0; i--) { if (pq[i].first != 0 && pq[i].second != 0) { v[pq[i].first] = v[pq[i].second]; } else { dq.push_front(v[pq[i].first]); } } for (auto it : dq) { cout << it << ; } cout << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; const int cap = 1e3; int n, m; char grid[cap][cap]; int vis[4][cap][cap] = {}; vector<pair<int, int>> dirs = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}}; bool dfs(int i, int j, int d, int t) { if (i < 0 || i == n || j < 0 || j == m || grid[i][j] == * || (vis[d][i][j] != -1 && t >= vis[d][i][j])) return false; if (grid[i][j] == T ) return true; vis[d][i][j] = t; int x, y; x = i + dirs[d].first; y = j + dirs[d].second; if (dfs(x, y, d, t)) return true; if (t < 2) for (int k = 0; k < 4; ++k) if (k != d) { x = i + dirs[k].first; y = j + dirs[k].second; if (dfs(x, y, k, t + 1)) return true; } return false; } int main() { memset(vis, -1, sizeof vis); scanf( %d %d , &n, &m); int i_s = -1, j_s = -1; for (int i = 0; i < n; ++i) for (int j = 0; j < m; ++j) { scanf( %c , &grid[i][j]); if (grid[i][j] == S ) { i_s = i; j_s = j; } } for (int d = 0; d < 4; ++d) if (dfs(i_s, j_s, d, 0)) { printf( YES ); return 0; } printf( NO ); return 0; }
|
#include <bits/stdc++.h> using namespace std; long long n, pos, ans = 10000000000000000; long long a[3000 + 5], b[3000 + 5], f[3000 + 5][3000 + 5], Min[3000 + 5]; long long read() { char c; long long x = 0, f = 1; c = getchar(); while (c > 9 || c < 0 ) { if (c == - ) f = -1; c = getchar(); } while (c >= 0 && c <= 9 ) { x = (x << 3) + (x << 1) + c - 0 ; c = getchar(); } return x * f; } signed main() { n = read(); for (register long long i = 1; i <= n; ++i) a[i] = read() - i, b[i] = a[i]; sort(b + 1, b + n + 1); pos = unique(b + 1, b + n + 1) - b - 1; for (register long long i = 1; i <= n; ++i) { for (register long long j = 1; j <= pos; ++j) f[i][j] = Min[j] + abs(a[i] - b[j]); Min[0] = 10000000000000000; for (register long long j = 1; j <= pos; ++j) Min[j] = min(Min[j - 1], f[i][j]); } for (register long long i = 1; i <= pos; ++i) ans = min(ans, f[n][i]); printf( %lld , ans); return 0; }
|
#include <bits/stdc++.h> #define int long long int #define us unsigned int #define null 0 #define m_p make_pair #define f_i first #define s_e second #define p_b push_back using namespace std; void IOS() { ios_base::sync_with_stdio(false); cin.tie(NULL); } int32_t main() { IOS(); int test; cin>>test; while(test--) { int n; cin>>n; string s; cin>>s; map<char,int> mp; bool flag=true; for(int i=0;i<n;i++) { if(mp.find(s[i])==mp.end()) { mp[s[i]]=i; } else if(i-mp[s[i]]>1) { flag=false; break; } mp[s[i]]=i; } if(flag) { cout<< YES <<endl; } else { cout<< NO <<endl; } } }
|
#include <bits/stdc++.h> using namespace std; const int Y = 10; int n; string fcol = ; bool place(int y, int x) { cout << x << << y << endl; string ret; cin >> ret; return (ret == fcol); } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cin >> n; cout << 0 << Y << endl; cin >> fcol; bool lastbl = true; int cx = 0; int jmp = (1 << 28); for (int i = 0; i < n - 1; ++i) { if (lastbl) { lastbl = place(Y, cx + jmp); cx += jmp; } else { lastbl = place(Y, cx - jmp); cx -= jmp; } jmp /= 2; } if (lastbl) { cout << cx << << Y + 1 << << cx + 1 << << Y - 1 << endl; } else { cout << cx << << Y + 1 << << cx - 1 << << Y - 1 << endl; } return 0; }
|
#include <bits/stdc++.h> using namespace std; struct FlowEdge { int to, cap, rev; FlowEdge(int to_, int cap_, int rev_) : to(to_), cap(cap_), rev(rev_) {} }; class FordFulkerson { public: FordFulkerson() {} FordFulkerson(int n) : G(n), used(n) {} void add(int from, int to, int cap) { G[from].emplace_back(to, cap, (int)G[to].size()); G[to].emplace_back(from, 0, (int)G[from].size() - 1); } int get(int s, int t) { int f = 1, res = 0; while (f) { fill(begin(used), end(used), false); f = dfs(s, t, INT_MAX); res += f; } return res; } private: vector<vector<FlowEdge>> G; vector<bool> used; int dfs(int v, int t, int f) { if (v == t) return f; used[v] = 1; for (auto &e : G[v]) { if (!used[e.to] && e.cap > 0) { int d = dfs(e.to, t, min(e.cap, f)); if (d > 0) { e.cap -= d; G[e.to][e.rev].cap += d; return d; } } } return 0; } }; const string T = fair n , F = unfair n ; const int MAXV = 20099, SRC = 0, QUERY = 10001, SINK = 20010, MOD5 = 20001; int N, B, Q, upTo[10099], quantity[10099]; pair<int, int> query[10099]; int main() { ios::sync_with_stdio(0); cin.tie(0); cin >> N >> B >> Q; for (int i = 0; i < (int)Q; ++i) cin >> upTo[i] >> quantity[i]; for (int i = 0; i < (int)Q; ++i) query[i] = make_pair(upTo[i], quantity[i]); query[Q] = make_pair(0, 0); query[Q] = make_pair(B, N); Q += 2; sort(query, query + Q); FordFulkerson flowG(MAXV); for (int i = 0; i < (int)5; ++i) flowG.add(SRC, MOD5 + i, N / 5); for (int num = 1; num < (int)B + 1; ++num) { int mod5 = num % 5; flowG.add(MOD5 + mod5, num, 1); } for (int i = 0; i < (int)Q - 1; ++i) { int lef = query[i].first, rig = query[i + 1].first; int cnt = query[i + 1].second - query[i].second; if (cnt < 0) { cout << F; return 0; } for (int num = lef + 1; num <= rig; ++num) { flowG.add(num, QUERY + i, 1); } flowG.add(QUERY + i, SINK, cnt); } int maxFlow = flowG.get(SRC, SINK); cout << (maxFlow == N ? T : F); }
|
#include <bits/stdc++.h> using namespace std; int main() { int t, x = 0, k = 0; cin >> t; while (t--) { int m, n, x, y = 0; cin >> m; cin >> n; x = m * n; int a[x]; for (int i = 0; i < x; i++) { cin >> a[i]; if (a[i] < 0) { a[i] = 0 - a[i]; k++; } y = y + a[i]; } sort(a, a + x); if (k % 2 == 0) cout << y << endl; else cout << y - 2 * a[0] << endl; k = 0; } return 0; }
|
#include <bits/stdc++.h> using namespace std; long long MOD = 1000000007; void runCase(int caseNum) { string s; cin >> s; int res = true; if (s.size()) { stack<char> st; st.push(s[0]); for (int i = 1; i < s.size(); ++i) { if (!st.empty() && st.top() == s[i]) st.pop(); else st.push(s[i]); } res = st.empty(); } cout << (res ? Yes : No ) << endl; } int main(int argc, char* argv[]) { runCase(0); return 0; }
|
#include <bits/stdc++.h> using namespace std; inline int read(int f = 1, int x = 0, char ch = ) { while (!isdigit(ch = getchar())) if (ch == - ) f = -1; while (isdigit(ch)) x = x * 10 + ch - 0 , ch = getchar(); return f * x; } const int N = 1e2 + 5; int n, c[2], p[N], q[N], f[2][N][N][N]; int main() { n = read(); for (int i = 1; i <= n; ++i) p[i] = q[i] = read(), p[i] &= 1, c[p[i]] += q[i] != 0; c[0] = n / 2 - c[0], c[1] = n - n / 2 - c[1]; memset(f, 0x3f, sizeof(f)), f[0][0][0][0] = f[1][0][0][0] = 0; for (int i = 1; i <= n; ++i) for (int j = 0; j <= c[0]; ++j) for (int k = 0; k <= c[1]; ++k) if (q[i]) f[p[i]][i][j][k] = min(f[0][i - 1][j][k] + (0 ^ p[i]), f[1][i - 1][j][k] + (1 ^ p[i])); else { if (j) f[0][i][j][k] = min(f[0][i][j][k], f[0][i - 1][j - 1][k]), f[0][i][j][k] = min(f[0][i][j][k], f[1][i - 1][j - 1][k] + 1); if (k) f[1][i][j][k] = min(f[1][i][j][k], f[1][i - 1][j][k - 1]), f[1][i][j][k] = min(f[1][i][j][k], f[0][i - 1][j][k - 1] + 1); } printf( %d n , min(f[0][n][c[0]][c[1]], f[1][n][c[0]][c[1]])); return 0; }
|
#include <bits/stdc++.h> using namespace std; const long long MAGIC = 400; const long long N = 1e5 + 2; const long long inf = 1e14 + 2; long long lzval[MAGIC], lzmul[MAGIC], ar[N], add[N]; bool used[N]; vector<long long> idx[MAGIC]; struct hull { long long ptr; struct line { long long a, b, idx; long long y(long long x) { return a * x + b; } }; vector<line> hull; bool bad(line x, line y, line z) { assert(y.a != x.a); if (z.a == y.a) { return z.b > y.b; } return (1.0 * (x.b - z.b)) / (z.a - x.a) < (1.0 * (y.b - z.b)) / (z.a - y.a); } void insert(line a) { while (hull.size() > 1) { if (bad(hull[hull.size() - 2], hull[hull.size() - 1], a)) { hull.pop_back(); } else { break; } } if (hull.size() && hull.back().a == a.a) { if (hull.back().b > a.b) { return; } else { hull.pop_back(); } } hull.push_back(a); } void build(vector<long long> &wow) { hull.clear(); ptr = 0; for (long long i = 0; i < wow.size(); i++) { long long idx = wow[i]; if (used[idx]) { continue; } line tmp; tmp.a = ar[idx]; tmp.b = add[idx]; tmp.idx = idx; insert(tmp); } } pair<long long, long long> get(long long idx) { while (ptr + 1 < hull.size() && hull[ptr].y(lzmul[idx]) < hull[ptr + 1].y(lzmul[idx])) { ptr++; } return pair<long long, long long>(hull[ptr].y(lzmul[idx]) + lzval[idx], -hull[ptr].idx); } } lis[MAGIC]; long long grp(long long x) { return (x + MAGIC - 1) / MAGIC; } bool cmp(long long x, long long y) { if (ar[x] != ar[y]) { return ar[x] > ar[y]; } return add[x] > add[y]; } signed main() { ios::sync_with_stdio(0); cin.tie(0); long long n, i, j, k, l, mx, ans = 0, mxans = 0, z, q; cin >> n; for (i = 1; i <= n; i++) { cin >> ar[i]; add[i] = ar[i]; idx[grp(i)].push_back(i); } mx = grp(n); for (i = 1; i <= mx; i++) { sort(idx[i].begin(), idx[i].end(), cmp); lis[i].build(idx[i]); } for (i = 1; i <= n; i++) { pair<long long, long long> res = {-inf, -1}; for (j = 1; j <= mx; j++) { if (lis[j].hull.size()) { res = max(res, lis[j].get(j)); pair<long long, long long> kek = lis[j].get(j); } } ans += res.first; mxans = max(mxans, ans); q = j = -res.second; used[j] = true; j = grp(j); for (k = j + 1; k <= mx; k++) { lzmul[k]++; } for (k = 1; k < j; k++) { lzval[k] += ar[q]; } k = (j - 1) * MAGIC + 1, l = min(j * MAGIC, n); for (z = k; z <= l; z++) { add[z] += lzval[j] + lzmul[j] * ar[z]; if (z >= q) { add[z] += ar[z]; } else { add[z] += ar[q]; } } lzval[j] = lzmul[j] = 0; lis[j].build(idx[j]); } cout << mxans; }
|
#include <bits/stdc++.h> using namespace std; long long m[1000001], cd, kq[100000]; map<long long, long long> ruler; int main() { cin >> cd; for (long long i = 1; i <= cd; i++) { cin >> m[i]; ruler[m[i]] = 1; } for (long long i = 1; i <= cd; i++) { long long e = 1; kq[e] = m[i]; long long t = m[i]; while (e <= cd) { if (ruler[t * 2] == 1) { kq[e + 1] = t * 2; t = t * 2; } else if (t % 3 == 0 && ruler[t / 3] == 1) { kq[e + 1] = t / 3; t = t / 3; } else break; e++; if (e == cd) { for (long long k = 1; k <= cd; k++) cout << kq[k] << ; exit(0); } } } }
|
#include <bits/stdc++.h> using namespace std; map<string, int> A; string s; int main() { A[ void ] = 100; A[ errtype ] = 0; int n; cin >> n; for (int i = 0; i < n; ++i) { cin >> s; if (s[4] == d ) { string a, b; cin >> a >> b; int l = a.length(); int p = 0, q = 0; for (int j = 0; j < l; ++j) if (a[j] == & ) ++p; else if (a[j] == * ) ++q; a = a.substr(p, l - p - q); q -= p; if (A[a] + q < 100) A[b] = 0; else A[b] = A[a] + q; } else { string a; cin >> a; int p = 0, q = 0; int l = a.length(); for (int j = 0; j < l; ++j) if (a[j] == & ) ++p; else if (a[j] == * ) ++q; a = a.substr(p, l - p - q); q -= p; if (A[a] + q < 100) puts( errtype ); else { printf( void ); int t = A[a] + q; for (int j = 100; j < t; ++j) printf( * ); puts( ); } } } return 0; }
|
#include <bits/stdc++.h> using std::map; const int MAXN = 1000 + 3; int table[MAXN][MAXN]; int n, m, k; map<int, int> r, c; int main(int argc, char *argv[]) { scanf( %d%d%d , &n, &m, &k); for (int i = 1; i <= n; ++i) { r[i] = i; for (int j = 1; j <= m; ++j) { if (i == 1) c[j] = j; scanf( %d , &table[i][j]); } } char cmd; int tmp, x, y; while (k--) { scanf( %s%d%d , &cmd, &x, &y); if (cmd == r ) { tmp = r[x]; r[x] = r[y]; r[y] = tmp; } else if (cmd == c ) { tmp = c[x]; c[x] = c[y]; c[y] = tmp; } else printf( %d n , table[r[x]][c[y]]); } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { long long i, j, d = 0, e = 0, f = 0, sum = 0, c = 0, n; cin >> n; char a[4][4]; map<int, int> m; for (i = 0; i < 4; i++) { for (j = 0; j < 4; j++) { cin >> a[i][j]; } } for (i = 0; i < 4; i++) { for (j = 0; j < 4; j++) { if (a[i][j] >= 49 && a[i][j] <= 57) { m[a[i][j]]++; } } } for (auto x : m) { if (x.second > (2 * n)) { c++; } } if (c == 0) { cout << YES ; } else cout << NO ; }
|
#include <bits/stdc++.h> using namespace std; using ll = long long; const int MOD = (int)998244353; const int MAXN = (int)1e6 + 5; template <typename T> class BIT { public: BIT(T* _a, int _n) { a = _a; n = _n; bit = new T[n + 1]; for (int i = 1; i <= n; ++i) bit[i] = 0; for (int i = 1; i <= n; ++i) upd_(i, a[i]); } void upd(int i, T val) { T diff = val - a[i]; a[i] = val; while (i <= n) { bit[i] = bit[i] + diff; i += i & (-i); } } T get(int i) { T ret = 0; while (i > 0) { ret = ret + bit[i]; i -= i & (-i); } return ret; } private: void upd_(int i, T val) { while (i <= n) { bit[i] = bit[i] + val; i += i & (-i); } } T *bit, *a; int n; }; ll n, k, m, a1[MAXN], a2[MAXN], a3[MAXN]; struct Segment { Segment(int _l, int _r, int _c, int _p) : l(_l), r(_r), c(_c), p(_p) { end = 0; }; int l, r, c, p; bool end; int pos; int get_coord() { if (end) return r; return l; } }; bool cmp1(Segment& lhs, Segment& rhs) { return lhs.p < rhs.p; } bool cmp2(Segment& lhs, Segment& rhs) { int lhsx = (lhs.end == 1) ? lhs.r : lhs.l; int rhsx = (rhs.end == 1) ? rhs.r : rhs.l; if (lhsx == rhsx) return lhs.end < rhs.end; return lhsx < rhsx; } vector<Segment> segs; bool can(BIT<ll>& bit1, BIT<ll>& bit2, int pos) { return (bit1.get(pos) >= k); } int main() { cin >> n >> k >> m; for (int i = 0; i < m; ++i) { int l, r, c, p; scanf( %d%d%d%d , &l, &r, &c, &p); Segment seg(l, r, c, p); segs.push_back(seg); } sort(segs.begin(), segs.end(), cmp1); int sz = segs.size(); for (int i = 1; i <= sz; ++i) { segs[i - 1].pos = i; a3[i] = segs[i - 1].p; Segment seg = segs[i - 1]; seg.end = 1; segs.push_back(seg); } sort(segs.begin(), segs.end(), cmp2); ll sol = 0; BIT<ll> bit1(a1, m), bit2(a2, m); int segpos = 0; for (int i = 1; i <= n; ++i) { while (segpos < 2 * m && (segs[segpos].get_coord() < i || (segs[segpos].get_coord() == i && segs[segpos].end == 0))) { int pos = segs[segpos].pos; if (segs[segpos].end == 0) { bit1.upd(pos, segs[segpos].c); bit2.upd(pos, 1LL * segs[segpos].c * segs[segpos].p); } else { bit1.upd(pos, 0); bit2.upd(pos, 0); } segpos++; } ll solc = m; int l = 1, r = m; while (l <= r) { int mid = (l + r) / 2; if (can(bit1, bit2, mid)) { solc = min(solc, (ll)mid); r = mid - 1; } else l = mid + 1; } if (bit1.get(m) < k) sol += bit2.get(m); else { ll diff = bit1.get(solc) - k; sol += bit2.get(solc) - diff * a3[solc]; } } cout << sol; return 0; }
|
#include <bits/stdc++.h> struct node { int mx, se, cmx; int cnt; long long sum; node() : mx(0), se(-1), cmx(0), cnt(0), sum(0) {} node(int v) : mx(v), se(-1), cmx(1), cnt(1), sum(v) {} }; node operator+(const node &a, const node &b) { node res; if (a.mx == b.mx) { res.mx = a.mx; res.se = std::max(a.se, b.se); res.cmx = a.cmx + b.cmx; } else if (a.mx > b.mx) { res.mx = a.mx; res.se = std::max(a.se, b.mx); res.cmx = a.cmx; } else { res.mx = b.mx; res.se = std::max(a.mx, b.se); res.cmx = b.cmx; } res.cnt = a.cnt + b.cnt; res.sum = a.sum + b.sum; return res; } int enlarge(int n) { int res = 1; while (res < n) { res <<= 1; } return res; } class segment_tree { int n; std::vector<node> a; std::vector<int> tag, mxtag; void node_add(int u, int v) { a[u].mx += v; a[u].se += v; a[u].sum += 1ll * v * a[u].cnt; tag[u] += v; } void node_add_mx(int u, int v) { a[u].mx += v; a[u].sum += 1ll * v * a[u].cmx; mxtag[u] += v; } void down(int u) { if (tag[u]) { node_add(u << 1, tag[u]); node_add(u << 1 | 1, tag[u]); tag[u] = 0; } if (mxtag[u]) { int lmx = a[u << 1].mx, rmx = a[u << 1 | 1].mx; if (lmx >= rmx) { node_add_mx(u << 1, mxtag[u]); } if (rmx >= lmx) { node_add_mx(u << 1 | 1, mxtag[u]); } mxtag[u] = 0; } } void modify(int u, int l, int r, int x, int v) { if (l + 1 == r) { a[u] = node(v); return; } int mid = (l + r + 1) >> 1; down(u); if (x < mid) { modify(u << 1, l, mid, x, v); } else { modify(u << 1 | 1, mid, r, x, v); } a[u] = a[u << 1] + a[u << 1 | 1]; } void add(int u, int l, int r, int L, int R, int v) { if (L <= l && r <= R) { node_add(u, v); return; } int mid = (l + r + 1) >> 1; down(u); if (L < mid) { add(u << 1, l, mid, L, R, v); } if (mid < R) { add(u << 1 | 1, mid, r, L, R, v); } a[u] = a[u << 1] + a[u << 1 | 1]; } void chmin(int u, int l, int r, int L, int R, int v) { if (a[u].mx <= v) { return; } if (L <= l && r <= R && a[u].se < v) { node_add_mx(u, v - a[u].mx); return; } int mid = (l + r + 1) >> 1; down(u); if (L < mid) { chmin(u << 1, l, mid, L, R, v); } if (mid < R) { chmin(u << 1 | 1, mid, r, L, R, v); } a[u] = a[u << 1] + a[u << 1 | 1]; } int get_cnt(int u, int l, int r, int L, int R) { if (L <= l && r <= R) { return a[u].cnt; } int mid = (l + r + 1) >> 1; down(u); if (R <= mid) { return get_cnt(u << 1, l, mid, L, R); } else if (L >= mid) { return get_cnt(u << 1 | 1, mid, r, L, R); } else { return get_cnt(u << 1, l, mid, L, R) + get_cnt(u << 1 | 1, mid, r, L, R); } } public: segment_tree(int _n) : n(_n), a(enlarge(n) << 1), tag(enlarge(n) << 1), mxtag(enlarge(n) << 1) {} void modify(int x, int v) { modify(1, 0, n, x, v); } void add(int l, int r, int v) { if (l >= r) { return; } add(1, 0, n, l, r, v); } void chmin(int l, int r, int v) { if (l >= r) { return; } chmin(1, 0, n, l, r, v); } int get_cnt(int l, int r) { if (l >= r) { return 0; } return get_cnt(1, 0, n, l, r); } long long get_sum() { return a[1].sum; } }; int main() { std::ios_base::sync_with_stdio(false); std::cin.tie(0); int n; std::cin >> n; std::vector<int> p(n); for (int i = 0; i < n; ++i) { int v; std::cin >> v; --v; p[v] = i; } std::vector<long long> ans(n); for (int _ = 0; _ < 2; ++_) { segment_tree T(n); for (int i = 0; i < n; ++i) { T.modify(p[i], i + 1); T.chmin(0, p[i], T.get_cnt(0, p[i])); T.add(p[i] + 1, n, 1); ans[i] += T.get_sum() - 1ll * i * (i + 1) / 2; } for (int i = 0; i < n; ++i) { p[i] = n - 1 - p[i]; } } for (int i = 0; i < n; ++i) { std::cout << ans[i] - i - 1 << n ; } }
|
#include <bits/stdc++.h> const int INF = 1e9 + 7; struct Node { int min, max; int low, high; int lcnt, rcnt, cnt; } st[2000000]; int as[500005]; int query(int w, int L, int R, int& low, int& high) { if (R - L == 1) { return as[L] >= low && as[L] <= high; } int M = (L + R) / 2; if (low > st[w].max) return 0; if (high < st[w].min) return 0; if (low <= st[w].min && high >= st[w].max) return st[w].cnt; if (low > st[w].high) { return query(w * 2 + 1, L, M, low, high); } else if (high < st[w].low) { return query(w * 2 + 2, M, R, low, high); } else { high = std::max(high, st[w].high); low = std::min(low, st[w].low); int res = 0; int ign1, ign2; if (high > st[w].high) res += query(w * 2 + 1, L, M, ign1 = st[w].high + 1, high); if (low < st[w].low) res += query(w * 2 + 2, M, R, low, ign2 = st[w].low - 1); if (low <= st[w].low && high >= st[w].high && st[w].low <= st[w].high) res++; return res; } } void pull(int w, int L, int R) { int ign1, ign2; assert(R - L > 1); int M = (L + R) / 2; st[w].min = std::min(st[w * 2 + 1].min, st[w * 2 + 2].min); st[w].max = std::max(st[w * 2 + 1].max, st[w * 2 + 2].max); st[w].high = st[w * 2 + 2].max; st[w].low = st[w * 2 + 1].min; query(w * 2 + 1, L, M, st[w].low, st[w].high); query(w * 2 + 2, M, R, st[w].low, st[w].high); if (st[w].low <= st[w].high) { st[w].lcnt = query(w * 2 + 1, L, M, ign1 = st[w].high + 1, ign2 = INF); st[w].rcnt = query(w * 2 + 2, M, R, ign1 = -INF, ign2 = st[w].low - 1); st[w].cnt = st[w].lcnt + st[w].rcnt + 1; } else { st[w].lcnt = st[w * 2 + 1].cnt; st[w].rcnt = st[w * 2 + 2].cnt; st[w].cnt = st[w].lcnt + st[w].rcnt; } } void build(int w, int L, int R, int a, int b) { if (a >= R || b <= L) return; if (R - L == 1) { st[w].min = st[w].max = as[L]; st[w].cnt = 1; } else { int M = (L + R) / 2; build(w * 2 + 1, L, M, a, b); build(w * 2 + 2, M, R, a, b); pull(w, L, R); } } void dump(int w, int L, int R) { int M = (L + R) / 2; if (R - L > 1) { printf( [%d,%d): min=%d max=%d low=%d high=%d lcnt=%d rcnt=%d cnt=%d n , L, R, st[w].min, st[w].max, st[w].low, st[w].high, st[w].lcnt, st[w].rcnt, st[w].cnt); dump(w * 2 + 1, L, M); dump(w * 2 + 2, M, R); } } int main() { int N, Q; scanf( %d %d , &N, &Q); for (int i = 0; i < N; i++) { scanf( %d , &as[i]); } build(0, 0, N, 0, N); for (int i = 0; i < Q; i++) { int I, X; scanf( %d %d , &I, &X); I--; as[I] = X; build(0, 0, N, I, I + 1); printf( %d n , st[0].cnt); } }
|
#include <bits/stdc++.h> using namespace std; const string nameFiles = ; void error(vector<string>::iterator) {} template <typename T, typename... Args> void error(vector<string>::iterator cur_var, T a, Args... args) { cerr << cur_var->substr((*cur_var)[0] == ) << = << a << endl; error(++cur_var, args...); } vector<string> split(string const& str, char c) { vector<string> res; stringstream ss(str); string x; while (getline(ss, x, c)) res.emplace_back(x); return move(res); } int main() { if (!nameFiles.empty()) { freopen((nameFiles + .in ).c_str(), r , stdin); freopen((nameFiles + .out ).c_str(), w , stdout); } int n, m; cin >> n >> m; vector<int> a(n); unordered_set<int> mod; for (int i = 0; i < n; ++i) { cin >> a[i]; a[i] %= m; if (a[i] == 0) { cout << YES << endl; return 0; } } for (int i = 0; i < n; ++i) { vector<int> ttt; for (int x : mod) { int temp = (x + a[i]) % m; if (temp == 0) { cout << YES << endl; return 0; } ttt.push_back(temp); } mod.insert(ttt.begin(), ttt.end()); mod.insert(a[i]); } cout << NO << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; const int INF = 0x7f7f7f7f; const int MOD = 1e9 + 7; const double eps = 1e-6; int main() { int n, r, v; scanf( %d%d%d , &n, &r, &v); double s = acos(-1.0) * r * 2; while (n--) { int a, b; scanf( %d%d , &a, &b); double d = b - a; int c = (d / s); double len = d - c * s; double L = 0, R = len; double mid = (L + R) / 2; while (R - L >= eps) { if (mid + 2 * r * sin(mid / 2 / r) >= len) R = mid; else L = mid; mid = (L + R) / 2; } printf( %.12lf n , (c * s + mid) / v); } return 0; }
|
#include <bits/stdc++.h> using namespace std; template <typename T> T gcd(T a, T b) { return !b ? a : gcd(b, a % b); } template <typename T> T lcm(T a, T b) { return a * (b / gcd(a, b)); } template <typename T> T sqr(T a) { return a * a; } template <typename T> T cube(T a) { return a * a * a; } template <typename T> inline void smin(T &a, T b) { a = a < b ? a : b; } template <typename T> inline void smax(T &a, T b) { a = a > b ? a : b; } int in() { int n; scanf( %d , &n); return n; } long long Lin() { long long n; scanf( %lld , &n); return n; } double Din() { double n; scanf( %lf , &n); return n; } const long long inf = (long long)1e17; const long long mod = (long long)1e9 + 7; const int N = 1e5 + 5; struct CHT_DEC_MIN { vector<long long> m, b; bool bad(int f1, int f2, int f3) { return 1.0 * (b[f2] - b[f1]) * (m[f1] - m[f3]) >= 1.0 * (b[f3] - b[f1]) * (m[f1] - m[f2]); } void add(long long M, long long B) { m.push_back(M), b.push_back(B); int sz = (int)m.size(); while (sz >= 3 && bad(sz - 3, sz - 2, sz - 1)) { m.erase(m.end() - 2); b.erase(b.end() - 2); sz--; } } long long f(int idx, long long X) { return m[idx] * X + b[idx]; } long long query(long long X) { int low = 0, high = (int)m.size() - 1; while (high - low > 5) { int mid1 = (low + low + high) / 3; int mid2 = (low + high + high) / 3; if (f(mid1, X) >= f(mid2, X)) { low = mid1 + 1; } else { high = mid2 - 1; } } long long res = f(low, X); for (int i = low + 1; i <= high; i++) { res = min(res, f(i, X)); } return res; } }; long long a[N], s[N]; CHT_DEC_MIN tree[4 * N]; void update(int pos, int left, int right, int x, long long M, long long B) { tree[pos].add(M, B); if (left == right) return; int mid = (left + right) >> 1; if (x <= mid) update(pos * 2, left, mid, x, M, B); else update(pos * 2 + 1, mid + 1, right, x, M, B); } long long query(int pos, int left, int right, int x, int y, long long X) { if (left > y || right < x) return (long long)1e17; if (left >= x && right <= y) { return tree[pos].query(X); } int mid = (left + right) >> 1; long long m = query(pos * 2, left, mid, x, y, X); long long n = query(pos * 2 + 1, mid + 1, right, x, y, X); return min(m, n); } int solve() { int n = in(); vector<pair<long long, int> > tem; for (int i = 1; i <= n; i++) { a[i] = Lin(); s[i] += s[i - 1] + a[i]; tem.push_back({a[i], i}); } sort(tem.begin(), tem.end()); for (int i = 0; i < n; i++) { int idx = tem[i].second; long long M = -a[idx], B = a[idx] * idx - s[idx]; update(1, 1, n, idx, M, B); } int q = in(); while (q--) { int x = in(), y = in(); x = y - x + 1; printf( %lld n , s[y] + query(1, 1, n, x, y, (long long)x - 1)); } return 0; } int main() { int test = 1, tc = 0; while (test--) { solve(); } return 0; }
|
#include <bits/stdc++.h> using namespace std; template <typename T> void write(ostream& out, T t) { out << t << n ; } template <typename T, typename... Args> void write(ostream& out, T t, Args... args) { out << t << ; write(out, args...); } template <typename... Args> void debug(Args... args) {} template <typename T> inline T abs(T t) { return t < 0 ? -t : t; } const long long modn = 1000000007; const long long modn2 = 10000019; inline long long mod(long long x) { return x % modn; } const int MAXK = 1003, MAXQ = 2 * 30004 + 10010; const int MAXN = MAXQ; const long long INF = 9000000000LL; int n, m, k; vector<pair<long long, int> > s; long long dp[15009][MAXK]; void prep_cin() { ios::sync_with_stdio(false); cin.tie(0); } struct qry { int t, id; }; vector<qry> q; int L[MAXN], R[MAXN]; int acu[MAXN]; long long pot[MAXK]; int h; inline long long f(int h) { long long res = 0; long long mx = 0; for (int a = 1; a <= k; a++) { mx = mod(max(mx, dp[h][a])); res = mod(res + mod(mx * pot[a - 1])); } return res; } inline bool sup(int i, int j, int l, int r) { return (i < l && j > r); } inline void add(int id) { h++; int pes = s[id].second; long long val = s[id].first; for (int a = 0; a <= k; a++) { dp[h][a] = dp[h - 1][a]; if (a >= pes && dp[h - 1][a - pes] != -INF) dp[h][a] = max(dp[h][a], dp[h - 1][a - pes] + val); } } void go(int i, int j) { if (i == j) { if (q[i].t == 3) printf( %lld n , f(h)); return; } int m = (i + j) / 2; if (acu[m] - (i == 0 ? 0 : acu[i - 1]) != 0) { int old = h; for (int a = m + 1; a <= j; a++) { if (q[a].t == 1 || q[a].t == 3) continue; int id = q[a].id; if (sup(L[id], R[id], i, m)) add(id); } go(i, m); h = old; } if (acu[j] - acu[m] != 0) { int old = h; for (int a = i; a <= m; a++) { if (q[a].t == 2 || q[a].t == 3) continue; int id = q[a].id; if (sup(L[id], R[id], m + 1, j)) add(id); } go(m + 1, j); h = old; } } int main() { scanf( %d%d , &n, &k); pot[0] = 1; for (int a = 1; a < k; a++) pot[a] = mod(pot[a - 1] * modn2); const int inf = 1e7; for (int a = 0; a < n; a++) { pair<long long, int> x; scanf( %lld %d , &x.first, &x.second); s.push_back(x); q.push_back({1, a}); L[a] = a; R[a] = inf; } scanf( %d , &m); for (int a = 0; a < m; a++) { qry p; scanf( %d , &p.t); if (q.size() > 0) acu[q.size()] = acu[q.size() - 1]; if (p.t == 1) { pair<long long, int> x; scanf( %lld %d , &x.first, &x.second); s.push_back(x); p.id = (int)s.size() - 1; L[p.id] = q.size(); R[p.id] = inf; } else if (p.t == 2) { scanf( %d , &p.id); p.id--; R[p.id] = q.size(); } else acu[q.size()]++; q.push_back(p); } n = s.size(); m = q.size(); for (int a = 0; a <= k; a++) dp[0][a] = -INF; dp[0][0] = 0; go(0, m - 1); }
|
#include <bits/stdc++.h> using namespace std; int main() { int t; scanf( %d , &t); for (int tt = 0; tt < t; tt++) { vector<vector<int> > A(9, vector<int>(9)); for (int i = 0; i < 9; i++) { int q; scanf( %d , &q); for (int j = 0; j < 9; j++) { A[i][8 - j] = q % 10; q /= 10; } } A[0][0] = A[0][1]; A[1][3] = A[0][3]; A[2][6] = A[0][6]; A[3][1] = A[3][0]; A[4][4] = A[3][4]; A[5][7] = A[4][7]; A[6][2] = A[6][1]; A[7][5] = A[8][5]; A[8][8] = A[7][7]; for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) printf( %d , A[i][j]); printf( n ); } } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); long long t, n, k, p; long long a[50]; cin >> t; while (t--) { cin >> n >> k; for (int i = 0; i < n; i++) cin >> a[i]; long long limit = 10e16; p = 1; while (p < limit) { p *= k; } if (p > limit) { p /= k; } while (p != 0) { for (int i = 0; i < n; i++) { if (a[i] >= p) { a[i] -= p; break; } } p /= k; } bool checker = true; for (int i = 0; i < n; i++) { if (a[i] != 0) { checker = false; break; } } if (checker) { cout << YES n ; } else { cout << NO n ; } } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n, a, b, ans = 0; cin >> n >> a >> b; vector<int> vec(n); for (int i = 0; i < n; i++) cin >> vec[i]; for (int i = 0; i < n / 2 + (n % 2); i++) { if (vec[i] != vec[n - i - 1] && vec[i] != 2 && vec[n - i - 1] != 2) { cout << -1; return 0; } if (vec[i] == vec[n - i - 1] && vec[i] == 2 && i != n - i - 1) { ans += 2 * (min(a, b)); } else if (vec[i] == vec[n - i - 1] && vec[i] == 2 && i == n - i - 1) { ans += min(a, b); } if (vec[i] == 1 && vec[n - i - 1] == 2 || vec[n - i - 1] == 1 && vec[i] == 2) { ans += b; } if (vec[i] == 0 && vec[n - i - 1] == 2 || vec[n - i - 1] == 0 && vec[i] == 2) { ans += a; } } cout << ans; }
|
#include <bits/stdc++.h> using namespace std; const int MAX_N = 100005, MAX_K = 105; int N, M, K, S; int good_type[MAX_N]; int distances[MAX_N][MAX_K]; vector<int> adj[MAX_N]; int dist[MAX_N]; void RunBFS(int type) { queue<int> q; for (int i = 0; i < N; ++i) { if (good_type[i] == type) { distances[i][type] = 0; q.push(i); } } while (!q.empty()) { int u = q.front(); q.pop(); for (const int& v : adj[u]) { if (distances[v][type] == -1) { distances[v][type] = distances[u][type] + 1; q.push(v); } } } } int main() { scanf( %d %d %d %d , &N, &M, &K, &S); for (int i = 0; i < N; ++i) { scanf( %d , &good_type[i]); --good_type[i]; } for (int i = 0; i < M; ++i) { int u, v; scanf( %d %d , &u, &v); --u; --v; adj[u].push_back(v); adj[v].push_back(u); } memset(distances, -1, sizeof distances); for (int i = 0; i < K; ++i) { RunBFS(i); } for (int i = 0; i < N; ++i) { sort(distances[i], distances[i] + K); long long sum = 0; for (int j = 0; j < S; ++j) sum += distances[i][j]; printf( %lld , sum); } return 0; }
|
#include <bits/stdc++.h> using namespace std; const long long N = 1e6 + 7; const long long mod = 1e9 + 7; long long gcd(long long a, long long b) { if (b == 0) return a; return gcd(b, a % b); } map<long long, long long> mp; int32_t main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); long long i = 1; vector<long long> v; long long n, a, b, m; cin >> m >> a >> b; long long k = gcd(a, b); long long z = m / k; long long val1 = m * z - (k * z * (z + 1) / 2) + z + m + 1; long long val2 = 0; long long start = 0; long long cnt = 0; long long ans = 0; long long currmx = 0; while (start <= (a + b)) { if (mp[start]) break; mp[start] = 1; currmx = max(currmx, start); if (start <= m) { ans += min(currmx - start, m - start + 1); } if (start >= b) start -= b; else start += a; } cout << val1 - ans << n ; return 0; }
|
#include <bits/stdc++.h> using namespace std; const long long linf = 1LL << 62; const int iinf = 1000000009; const double dinf = 1e17; const int Mod = 1e9 + 9; const int maxn = 1000005; int n; long long a, b[maxn]; long long dp[3][maxn]; void solve() { ios::sync_with_stdio(false); cin >> n; for (int i = 1; i <= n; i++) cin >> a, b[i] = __builtin_popcountll(a); long long suf = 0; dp[0][n + 1] = 1; long long res = 0; for (int i = n; i >= 1; i--) { long long sum = 0, mx = 0, ret = 0; for (int j = i; j <= min(n, i + 64); j++) { sum += b[j]; mx = max(b[j], mx); if (mx > sum - mx && sum % 2 == 0) ret--; } suf += b[i]; if (suf & 1) ret += dp[1][i + 1]; else ret += dp[0][i + 1]; res += ret; dp[0][i] = dp[0][i + 1]; dp[1][i] = dp[1][i + 1]; if (suf & 1) dp[1][i]++; else dp[0][i]++; } cout << res << endl; } int main() { int t = 1; for (int i = 1; i <= t; i++) solve(); return 0; }
|
#include <bits/stdc++.h> using namespace std; int n, m, q; int x[1000][1000]; int r[1000][1000][4]; void upd1(int j) { int i = 0; for (int k = 0; k < n; ++k) { if (x[k][j] == 0) { i = k + 1; r[k][j][0] = -1; } else r[k][j][0] = i; } i = n - 1; for (int k = n - 1; k > -1; --k) { if (x[k][j] == 0) { i = k - 1; r[k][j][1] = -1; } else r[k][j][1] = i; } } void upd2(int i) { int j = 0; for (int k = 0; k < m; ++k) { if (x[i][k] == 0) { j = k + 1; r[i][k][2] = -1; } else r[i][k][2] = j; } j = m - 1; for (int k = m - 1; k > -1; --k) { if (x[i][k] == 0) { j = k - 1; r[i][k][3] = -1; } else r[i][k][3] = j; } } int main() { cin.sync_with_stdio(false); cin >> n >> m >> q; for (int i = 0; i < n; ++i) for (int j = 0; j < m; ++j) cin >> x[i][j]; for (int j = 0; j < m; ++j) upd1(j); for (int i = 0; i < n; ++i) upd2(i); for (int k = 0; k < q; ++k) { int op; int i, j; cin >> op; cin >> i >> j; i--; j--; if (op == 1) { x[i][j] = 1 - x[i][j]; upd1(j); upd2(i); } else { int res = 0; if (x[i][j] != 0) { int up = 0; int down = n - 1; for (int k = j; k <= r[i][j][3]; ++k) { up = max(up, r[i][k][0]); down = min(down, r[i][k][1]); res = max(res, (down - up + 1) * (k - j + 1)); } up = 0; down = n - 1; for (int k = j; k >= r[i][j][2]; --k) { up = max(up, r[i][k][0]); down = min(down, r[i][k][1]); res = max(res, (down - up + 1) * (j - k + 1)); } int left = 0; int right = m - 1; for (int k = i; k <= r[i][j][1]; ++k) { left = max(left, r[k][j][2]); right = min(right, r[k][j][3]); res = max(res, (right - left + 1) * (k - i + 1)); } left = 0; right = m - 1; for (int k = i; k >= r[i][j][0]; --k) { left = max(left, r[k][j][2]); right = min(right, r[k][j][3]); res = max(res, (right - left + 1) * (i - k + 1)); } } cout << res << endl; } } return 0; }
|
#include <bits/stdc++.h> using namespace std; const int max_n = 511, inf = 1e9 + 100; bool m[max_n][max_n]; bool vis[max_n][max_n]; int mini[max_n], maxi[max_n]; int minj[max_n], maxj[max_n]; int si, sj; int n; int di[] = {0, 0, 1, -1}; int dj[] = {-1, 1, 0, 0}; char dir[] = LRDU ; string result; bool on_field(int i, int j) { return i >= 0 && j >= 0 && i < n && j < n; } void upd_mx(int i, int j) { mini[j] = min(mini[j], i); maxi[j] = max(maxi[j], i); minj[i] = min(minj[i], j); maxj[i] = max(maxj[i], j); } void dfs(int i, int j) { if (vis[i][j]) { return; } vis[i][j] = 1; if (m[i][j] == 0) { result += 1 ; m[i][j] = 1; upd_mx(i, j); } if (on_field(i - 1, j) && !vis[i - 1][j] && mini[j] < i) { result += U ; dfs(i - 1, j); result += D ; } if (on_field(i + 1, j) && !vis[i + 1][j] && maxi[j] > i) { result += D ; dfs(i + 1, j); result += U ; } if (on_field(i, j - 1) && !vis[i][j - 1] && minj[i] < j) { result += L ; dfs(i, j - 1); result += R ; } if (on_field(i, j + 1) && !vis[i][j + 1] && maxj[i] > j) { result += R ; dfs(i, j + 1); result += L ; } } int main() { for (int i = 0; i < max_n; ++i) { minj[i] = mini[i] = max_n; maxj[i] = maxi[i] = -1; } cin >> n >> si >> sj; --si, --sj; for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) { cin >> m[i][j]; if (m[i][j] == 1) { mini[j] = min(mini[j], i); maxi[j] = max(maxi[j], i); minj[i] = min(minj[i], j); maxj[i] = max(maxj[i], j); } } } dfs(si, sj); for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) { if (m[i][j] && !vis[i][j]) { cout << NO << endl; return 0; } } } int fi = si, fj = sj; while (si > 0) { int upj = -1; for (int j = 0; j < n; ++j) { if (m[si][j] && m[si - 1][j]) { upj = j; break; } } if (upj == -1) { break; } while (sj < upj) { result += R ; ++sj; } while (sj > upj) { result += L ; --sj; } result += U ; --si; } while (si < fi) { int dj = -1; for (int j = 0; j < n; ++j) { if (m[si][j] && m[si + 1][j]) { dj = j; break; } } if (dj == -1) { break; } while (sj < dj) { result += R ; ++sj; } while (sj > dj) { result += L ; --sj; } while (sj > 0 && m[si][sj - 1]) { result += L ; --sj; } while (sj < dj) { result += 2 ; result += R ; ++sj; } while (sj + 1 < n && m[si][sj + 1]) { result += R ; ++sj; } while (sj > dj) { result += 2 ; result += L ; --sj; } result += 2 ; result += D ; ++si; } while (si + 1 < n) { int dj = -1; for (int j = 0; j < n; ++j) { if (m[si][j] && m[si + 1][j]) { dj = j; break; } } if (dj == -1) { break; } while (sj < dj) { result += R ; ++sj; } while (sj > dj) { result += L ; --sj; } result += D ; ++si; } while (si > fi) { int upj = -1; for (int j = 0; j < n; ++j) { if (m[si][j] && m[si - 1][j]) { upj = j; break; } } if (upj == -1) { break; } while (sj < upj) { result += R ; ++sj; } while (sj > upj) { result += L ; --sj; } while (sj > 0 && m[si][sj - 1]) { result += L ; --sj; } while (sj < upj) { result += 2 ; result += R ; ++sj; } while (sj + 1 < n && m[si][sj + 1]) { result += R ; ++sj; } while (sj > upj) { result += 2 ; result += L ; --sj; } result += 2 ; result += U ; --si; } while (sj < fj) { result += R ; ++sj; } while (sj > fj) { result += L ; --sj; } while (sj > 0 && m[si][sj - 1]) { result += L ; --sj; } while (sj < fj) { result += 2 ; result += R ; ++sj; } while (sj + 1 < n && m[si][sj + 1]) { result += R ; ++sj; } while (sj > fj) { result += 2 ; result += L ; --sj; } result += 2 ; if (result.size() > 2e6) { exit(228); } cout << YES << endl; cout << result << endl; return 0; }
|
#include <bits/stdc++.h> #pragma GCC optimize( O3 ) #pragma GCC optimize( unroll-loops ) #pragma comment(linker, /STACK:2000000 ) using namespace std; template <int D, typename T> struct Vec : public vector<Vec<D - 1, T>> { static_assert(D >= 1, Vector dimension must be greater than zero! ); template <typename... Args> Vec(int n = 0, Args... args) : vector<Vec<D - 1, T>>(n, Vec<D - 1, T>(args...)) {} }; template <typename T> struct Vec<1, T> : public vector<T> { Vec(int n = 0, T val = T()) : vector<T>(n, val) {} }; using ll = long long; using db = long double; using ii = pair<int, int>; const int N = 2e5 + 5, LG = 19, MOD = 998244353; const int SQ = 320; const long double EPS = 1e-7; void printCase(int cs) { cout << Case # << cs << : ; } int p[N], n, q; int fast(int b, int e) { int res = 1; for (; e; e >>= 1, b = 1ll * b * b % MOD) if (e & 1) { res = 1ll * res * b % MOD; } return res; } int t[N << 2], lz[N << 2], cur = 1; void build(int node, int s, int e) { lz[node] = 1; if (s == e) { t[node] = cur; cur = 1ll * cur * p[s] % MOD; return; } int md = (s + e) >> 1; build(node << 1, s, md); build(node << 1 | 1, md + 1, e); t[node] = t[node << 1] + t[node << 1 | 1]; if (t[node] >= MOD) t[node] -= MOD; } void push(int node, int s, int e) { if (lz[node] == 1) return; t[node] = 1ll * t[node] * lz[node] % MOD; if (s != e) { lz[node << 1] = 1ll * lz[node] * lz[node << 1] % MOD; lz[node << 1 | 1] = 1ll * lz[node] * lz[node << 1 | 1] % MOD; } lz[node] = 1; } int qry(int node, int s, int e, int l, int r) { push(node, s, e); if (r < s || e < l) return 0; if (l <= s && e <= r) return t[node]; int md = (s + e) >> 1; int ret = qry(node << 1, s, md, l, r) + qry(node << 1 | 1, md + 1, e, l, r); if (ret >= MOD) ret -= MOD; return ret; } void upd(int node, int s, int e, int l, int r, int v) { push(node, s, e); if (r < s || e < l) return; if (l <= s && e <= r) { lz[node] = 1ll * lz[node] * v % MOD; push(node, s, e); return; } int md = (s + e) >> 1; upd(node << 1, s, md, l, r, v); upd(node << 1 | 1, md + 1, e, l, r, v); t[node] = t[node << 1] + t[node << 1 | 1]; if (t[node] >= MOD) t[node] -= MOD; } int sum[N]; int qry(int l, int r) { return 1ll * sum[r] * fast(sum[l - 1], MOD - 2) % MOD; } int get(int l, int r) { return 1ll * qry(1, 1, n, l, r) * fast(qry(l, r), MOD - 2) % MOD; } int32_t main() { ios_base::sync_with_stdio(0); cin.tie(0); cin >> n >> q; const int INV100 = fast(100, MOD - 2); sum[0] = 1; for (int i = 1; i < n + 1; i++) { cin >> p[i]; p[i] = 1ll * p[i] * INV100 % MOD; sum[i] = 1ll * sum[i - 1] * p[i] % MOD; } build(1, 1, n); set<int> checkPoints({1, n + 1}); int ans = get(1, n); while (q--) { int x; cin >> x; if (checkPoints.count(x)) { int l = *(--checkPoints.find(x)); int r = *(checkPoints.upper_bound(x)); ans -= get(l, x - 1); if (ans < 0) ans += MOD; ans -= get(x, r - 1); if (ans < 0) ans += MOD; int toMul = 1ll * qry(1, 1, n, x - 1, x - 1) * p[x - 1] % MOD; upd(1, 1, n, x, r - 1, toMul); ans += get(l, r - 1); if (ans >= MOD) ans -= MOD; checkPoints.erase(x); } else { int l = *(--checkPoints.upper_bound(x)); int r = *(checkPoints.upper_bound(x)); ans = (ans - get(l, r - 1)); if (ans < 0) ans += MOD; ans += get(l, x - 1); if (ans >= MOD) ans -= MOD; int toDivide = 1ll * qry(1, 1, n, x - 1, x - 1) * p[x - 1] % MOD; toDivide = fast(toDivide, MOD - 2); upd(1, 1, n, x, r - 1, toDivide); ans += get(x, r - 1); if (ans >= MOD) ans -= MOD; checkPoints.insert(x); } cout << ans << n ; } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { long b, c, m, n, k, l; cin >> m >> k; l = k; for (int i = 0; i < k; i++) { if (m % 10 == 0) m /= 10; else m--; } cout << m; }
|
#include <bits/stdc++.h> int main() { int t; scanf( %d , &t); while (t--) { int n; scanf( %d , &n); int a[n]; for (int i = 0; i < n; i++) { scanf( %d , &a[i]); } for (int i = 0; i < n; i++) { for (int j = 0; j < n - i - 1; j++) { if (a[j + 1] < a[j]) { int t = a[j]; a[j] = a[j + 1]; a[j + 1] = t; } } } int ans = INT_MAX; for (int i = 0; i < n - 1; i++) { if (a[i + 1] - a[i] < ans) { ans = a[i + 1] - a[i]; if (ans == 0) break; } } printf( %d n , ans); } return 0; }
|
#include <bits/stdc++.h> using namespace std; const int MAXD = 500; const int MAXS = 5000; bool vis[MAXD][MAXS + 1]; int dig[MAXD][MAXS + 1], from[MAXD][MAXS + 1]; struct Data { int last, c, prev_r; int r, sum; bool operator<(const Data &other) const { return last < other.last; } }; queue<Data> mst; int main() { int d, s; ios::sync_with_stdio(false); cin >> d >> s; mst.push({0, 0, 0, 0, 0}); int last = 0; while (!mst.empty()) { auto it = mst.front(); int r = it.r, sum = it.sum; int prev_r = it.prev_r, c = it.c; mst.pop(); if (vis[r][sum]) { continue; } vis[r][sum] = 1; dig[r][sum] = c; from[r][sum] = prev_r; for (c = 0; c < 10; c++) { int cur = (r * 10 + c) % d; if (sum + c <= s && vis[cur][sum + c] == 0) { mst.push({++last, c, r, cur, sum + c}); } } } if (vis[0][s]) { vector<int> sol; int r = 0; while (s > 0) { int cur = dig[r][s]; sol.push_back(cur); r = from[r][s]; s -= cur; } reverse(sol.begin(), sol.end()); for (auto it : sol) { cout << it; } return 0; } cout << -1; return 0; }
|
#include <bits/stdc++.h> using namespace std; signed main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); long long n; cin >> n; if (n == 2) { cout << 2; } else { cout << 1; } return 0; }
|
#include <bits/stdc++.h> using namespace std; int mod = 998244353; const int M = 2e5 + 10; const int N = 5e2 + 10; inline long long read() { long long b = 1, sum = 0; char c = getchar(); while (!isdigit(c)) { if (c == - ) b = -1; c = getchar(); } while (isdigit(c)) { sum = sum * 10 + c - 0 ; c = getchar(); } return b * sum; } int hs, gs; int n, m, k, T; int h, g, a[1 << 22]; long long sum; vector<int> ans; void change(int x) { int l = 2 * x, r = 2 * x + 1; if (a[l] == 0 && a[r] == 0) { a[x] = 0; } else { if (a[l] > a[r]) { a[x] = a[l]; change(l); } else { a[x] = a[r]; change(r); } } } int pull(int x) { int l = 2 * x, r = 2 * x + 1; if (a[l] == 0 && a[r] == 0) { return x; } else { if (a[l] > a[r]) { return pull(l); } else { return pull(r); } } } void solv(int x) { if (a[x] == 0) return; int l = 2 * x, r = 2 * x + 1; while (pull(x) >= gs) { ans.push_back(x); sum -= a[x]; change(x); } solv(l); solv(r); } int main() { int i, j; T = read(); while (T--) { sum = 0; h = read(), g = read(); hs = (1 << h); gs = (1 << g); n = hs - gs; for (i = 1; i <= hs - 1; i++) { a[i] = read(); a[i + n] = a[i + 2 * n] = 0; sum += a[i]; } ans.clear(); solv(1); printf( %lld n , sum); for (i = 0; i < ans.size(); i++) { printf( %d , ans[i]); } printf( n ); } return 0; }
|
#include <bits/stdc++.h> using namespace std; int n; int v[1100]; int pd[1100][1 << 8]; int qtd1, qtd2; int vis[1100][1 << 8]; int inv[1100]; vector<int> pos[10]; bool check(int mask) { for (int i = 0; i < 8; ++i) { if (mask & (1 << i)) continue; if (qtd1) return false; } return true; } int f(int x, int mask) { if (x >= n) { if (check(mask)) return 0; else return -0x3F3F3F3F; } int &p = pd[x][mask]; if (vis[x][mask] < qtd2) { vis[x][mask] = qtd2; p = f(x + 1, mask); if (!(mask & (1 << v[x]))) { int fim, qtd; qtd = pos[v[x]].size() - inv[x]; if (qtd1 && qtd >= qtd1) { fim = pos[v[x]][inv[x] + qtd1 - 1] + 1; p = max(p, f(fim, mask | (1 << v[x])) + qtd1); } qtd = pos[v[x]].size() - inv[x]; if (qtd >= qtd2) { fim = pos[v[x]][inv[x] + qtd2 - 1] + 1; p = max(p, f(fim, mask | (1 << v[x])) + qtd2); } } } return p; } int main() { int ans = 1; scanf( %d , &n); for (int i = 0; i < n; ++i) { scanf( %d , &v[i]); v[i]--; inv[i] = (int)pos[v[i]].size(); pos[v[i]].push_back(i); } for (int i = 0; i < n; ++i) { qtd1 = i, qtd2 = i + 1; ans = max(ans, f(0, 0)); } printf( %d n , ans); return 0; }
|
#include <bits/stdc++.h> bool a[100000 << 1]; int b[100000 << 1], c[100000 << 1], h[100000], n, m, i, x, y; int go(int k) { int i, t, x = -1; for (i = h[k]; ~i; i = b[i]) if (!a[i]) { a[i] = 1, a[i >= m ? i - m : i + m] = 1; t = go(c[i]); if (~t) printf( %d %d %d n , k + 1, c[i] + 1, t + 1); else if (~x) printf( %d %d %d n , x + 1, k + 1, c[i] + 1), x = -1; else x = c[i]; } return ~x ? x : -1; } int main() { scanf( %d%d , &n, &m); if (m & 1) { puts( No solution ); return 0; } for (i = 0; i < m * 2; i++) c[i] = -1; for (i = 0; i < n; i++) h[i] = -1; for (i = 0; i < m; ++i) { scanf( %d%d , &x, &y); --x, --y; b[i] = h[x]; c[i] = y; h[x] = i; b[i + m] = h[y]; c[i + m] = x; h[y] = i + m; } go(0); return 0; }
|
#include <bits/stdc++.h> using namespace std; const double pi = acos(-1.0); const double eps = 1e-11; const int inf = 0x7FFFFFFF; template <class T> inline void checkmin(T &a, T b) { if (b < a) a = b; } template <class T> inline void checkmax(T &a, T b) { if (b > a) a = b; } template <class T> inline T sqr(T x) { return x * x; } template <class T> void show(T a, int n) { for (int i = 0; i < n; ++i) cout << a[i] << ; cout << endl; } template <class T> void show(T a, int r, int l) { for (int i = 0; i < r; ++i) show(a[i], l); cout << endl; } struct S { long long w, h; long long bord, space; string tp; vector<int> son; int vis; void init(int x, int y, string t) { w = x, h = y; bord = space = 0; tp = t; son.clear(); vis = false; } void dfs(); } s[100000]; char buf[10000]; void S::dfs() { vis = true; if (son.size() > 0) { for (int i = 0; i < son.size(); i++) if (!s[son[i]].vis) { s[son[i]].dfs(); } if (tp == VBox ) { for (int i = 0; i < son.size(); i++) { int v = son[i]; w = max(s[v].w, w); if (i > 0) h += space; h += s[v].h; } w += 2 * bord; h += 2 * bord; } else if (tp == HBox ) { for (int i = 0; i < son.size(); i++) { int v = son[i]; h = max(s[v].h, h); if (i > 0) w += space; w += s[v].w; } w += 2 * bord; h += bord * 2; } } } string nn[10000]; struct SS { string s; long long x, y; const bool operator<(const SS &b) const { return s < b.s; } } ss[10000]; int main() { int n; while (cin >> n) { map<string, int> mp; int cnt = 0; for (int i = 0; i < n; i++) { scanf( %[^ n] , buf); bool newtp = true; for (int i = 0; buf[i]; i++) if (buf[i] == ( || buf[i] == ) || buf[i] == . || buf[i] == , ) { if (buf[i] == . ) newtp = false; buf[i] = ; } istringstream sin(buf); string t, nm, nm2; sin >> t; if (t == Widget || t == VBox || t == HBox ) { int x = 0, y = 0; sin >> nm; mp[nm] = cnt; nn[cnt] = nm; if (t == Widget ) { sin >> x >> y; } s[cnt].init(x, y, t); cnt++; } else { nm = t; int x; sin >> t; if (t == set_border ) { sin >> x; s[mp[nm]].bord = x; } else if (t == set_spacing ) { sin >> x; s[mp[nm]].space = x; } else if (t == pack ) { sin >> nm2; s[mp[nm]].son.push_back(mp[nm2]); } else puts( fuck ); } } for (int i = 0; i < cnt; i++) { if (!s[i].vis) s[i].dfs(); } for (int i = 0; i < cnt; i++) { ss[i].s = nn[i]; ss[i].x = s[i].w; ss[i].y = s[i].h; } sort(ss, ss + cnt); for (int i = 0; i < cnt; i++) { cout << ss[i].s << << ss[i].x << << ss[i].y << endl; } } return 0; }
|
#include <bits/stdc++.h> using namespace std; const int inf = 1e9 + 7; template <class T> void dbs(string str, T t) { cerr << str << : << t << n ; } template <class T, class... second> void dbs(string str, T t, second... s) { int idx = str.find( , ); cerr << str.substr(0, idx) << : << t << , ; dbs(str.substr(idx + 1), s...); } template <class second, class T> ostream& operator<<(ostream& os, const pair<second, T>& p) { return os << ( << p.first << , << p.second << ) ; } template <class T> void prc(T a, T b) { cerr << [ ; for (T i = a; i != b; ++i) { if (i != a) cerr << , ; cerr << *i; } cerr << ] n ; } const int N = 2020; long long first[N][N]; long long G[N][N]; string s; long long g(int n, int k); long long f(int n, int k) { if (k < 0) return 0; if (n == 0) return k == 0; long long& ans = first[n][k]; if (ans != -1) return ans; ans = 0; int ch = s[int(s.size()) - n] - a ; ans = ch * f(n - 1, k) + (25 - ch) * f(n - 1, k - n) + g(n - 1, k) + (k == 0); int nk = k; for (int i = 1; i <= n - 1; ++i) { int ch = s[int(s.size()) - n + i] - a ; nk = k - (i + 1) * (n - i); if (nk < 0) { for (int i = n - 1; i >= 1; --i) { int ch = s[int(s.size()) - n + i] - a ; nk = k - (i + 1) * (n - i); if (nk < 0) break; ans += (25 - ch) * f(n - i - 1, nk); ans %= inf; } break; } ans += (25 - ch) * f(n - i - 1, nk); ans %= inf; } ans %= inf; return ans; } long long g(int n, int k) { if (k < 0) return 0; if (n == 0) return 0; long long& ans = G[n][k]; if (ans != -1) return ans; int ch = s[int(s.size()) - n] - a ; ans = ch * f(n - 1, k) + g(n - 1, k); ans %= inf; return ans; } int main() { ios::sync_with_stdio(0); cin.tie(0); int n, k; cin >> n >> k; memset(first, -1, sizeof first); memset(G, -1, sizeof G); cin >> s; cout << f(n, k) << n ; return 0; }
|
#include <bits/stdc++.h> using namespace std; int n, m, g[505][505], f[505][505], tot[505], ans[505][505]; int main() { scanf( %d%d , &n, &m); memset(g, 0x3f, sizeof(g)); memset(f, 0x3f, sizeof(f)); for (int i = 1; i <= n; i++) f[i][i] = 0; for (int i = 1; i <= m; i++) { int u, v, w; scanf( %d%d%d , &u, &v, &w); g[u][v] = g[v][u] = f[u][v] = f[v][u] = min(g[u][v], w); } for (int k = 1; k <= n; k++) for (int i = 1; i <= n; i++) for (int j = 1; j <= n; j++) f[i][j] = f[j][i] = min(f[i][j], f[i][k] + f[k][j]); for (int i = 1; i <= n; i++) { memset(tot, 0, sizeof(tot)); for (int j = 1; j <= n; j++) for (int k = 1; k <= n; k++) if (f[i][k] + g[k][j] == f[i][j]) tot[j]++; for (int j = 1; j <= n; j++) for (int k = 1; k <= n; k++) if (f[i][k] + f[k][j] == f[i][j]) ans[i][j] += tot[k]; } for (int i = 1; i <= n; i++) for (int j = i + 1; j <= n; j++) { if (i == j) continue; if (f[i][j] >= 0x3f3f3f3f - 100) ans[i][j] = 0; printf( %d , ans[i][j]); } printf( n ); }
|
#include <bits/stdc++.h> using namespace std; inline void read(int &a) { a = 0; int c = getchar(), b = 1; while (c > 9 || c < 0 ) { if (c == - ) b = -1; c = getchar(); } while (c >= 0 && c <= 9 ) a = (a << 3) + (a << 1) + c - 48, c = getchar(); a *= b; } inline int Rem() { int a = 0, c = getchar(), b = 1; while (c > 9 || c < 0 ) { if (c == - ) b = -1; c = getchar(); } while (c >= 0 && c <= 9 ) a = (a << 3) + (a << 1) + c - 48, c = getchar(); return a *= b; } inline void write(long long x) { if (x > 9) write(x / 10); putchar( 0 + x % 10); } inline void W(long long x) { if (x < 0) { putchar( - ), x = -x; } write(x); } const int N = 2e5 + 5, M = 1e6 + 5; int n, m, a[N], pos[N], block; long long ans, rec[N], cnt[M]; struct node { int l, r, id; } q[N]; inline bool cmp(node a, node b) { return (pos[a.l] == pos[b.l]) ? (pos[a.l] & 1 ? a.r < b.r : a.r > b.r) : a.l < b.l; } inline void add(int x) { cnt[x]++; ans += ((cnt[x] * cnt[x]) - ((cnt[x] - 1) * (cnt[x] - 1))) * x; } inline void del(int x) { ans -= ((cnt[x] * cnt[x]) - ((cnt[x] - 1) * (cnt[x] - 1))) * x; cnt[x]--; } int main() { read(n); read(m); block = sqrt(n); for (register int i = 1; i <= n; i++) read(a[i]), pos[i] = i / block; for (register int i = 1; i <= m; i++) { read(q[i].l); read(q[i].r); q[i].id = i; } sort(q + 1, q + 1 + m, cmp); for (register int i = 1, ql, qr, l = 1, r = 0; i <= m; i++) { ql = q[i].l, qr = q[i].r; while (ql < l) add(a[--l]); while (ql > l) del(a[l++]); while (qr < r) del(a[r--]); while (qr > r) add(a[++r]); rec[q[i].id] = ans; } for (register int i = 1; i <= m; i++) W(rec[i]), putchar( n ); return 0; }
|
#include <bits/stdc++.h> using namespace std; const double eps = 1e-10, pi = 3.1415926535898; const int mod = 998244353, maxn = 2e5 + 10; int T, n, m, k, x, y, a[maxn], p, b; long long fac[maxn] = {1, 1}, inv[maxn] = {1, 1}, inv_fac[maxn] = {1, 1}; char st[maxn]; void init() { for (int i = 2; i < maxn; ++i) { fac[i] = fac[i - 1] * i % mod; inv[i] = (mod - mod / i) * inv[mod % i] % mod; inv_fac[i] = inv_fac[i - 1] * inv[i] % mod; } } long long C(long long n, long long m) { if (m < 0 || n < 0 || n < m) return 0; return fac[n] * inv_fac[n - m] % mod * inv_fac[m] % mod; } int main(int argc, char const *argv[]) { init(); scanf( %d %d , &n, &m); if (n == 2) { printf( 0 n ); return 0; } long long ans = 0, cnt = 0; for (int i = n - 2; i <= m - 1; ++i) { cnt += C(i, n - 2); } cnt %= mod; for (int i = 2; i <= n - 1; ++i) { long long cc = cnt; cc = cc * C(n - 3, i - 2) % mod * (n - 2) % mod; ans += cc; } cout << ans % mod << endl; ; return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { string a, b, str; int n, cont = 0, ca = 0, cb = 0; cin >> a >> b; n = a.size(); for (int i = 0; i < n; i++) { if (a[i] != b[i]) cont++; } if (cont % 2 == 0) { for (int i = 0; i < n; i++) { if (a[i] != b[i]) { if (ca > cb) cb++, str += b[i]; else ca++, str += a[i]; } else str += a[i]; } cout << str << endl; } else printf( impossible n ); }
|
#include <bits/stdc++.h> using namespace std; inline void input(long long &x) { long long y = 1; char c = getchar(); while (c < 0 || c > 9 ) { if (c == - ) y = -1; c = getchar(); } x = 0; while (c >= 0 && c <= 9 ) { x = x * 10 + (c - 0 ); c = getchar(); } x = x * y; } const long long inf = 1e18; long long f, t, temp, a1, cnt, p1, a2, now, p2, resf, rest; long long ans = inf; signed main() { input(f); input(t); input(temp); input(a1); input(cnt); input(p1); input(a2); input(now); input(p2); if (cnt > now) { swap(a1, a2); swap(p1, p2); swap(cnt, now); } for (register long long i = 0; (i - 1) * a1 <= f; ++i) { resf = f - min(i * a1, f); rest = t - min(i * a1, f) * cnt; if (!resf) { if (rest < 0) break; ans = min(ans, i * p1); break; } if (temp * resf > rest && now * resf > rest) continue; if (temp * resf <= rest) ans = min(ans, i * p1); else { long long x, pk; if ((rest - temp * resf) % (now - temp) == 0) x = (rest - temp * resf) / (now - temp) + 0; else x = (rest - temp * resf) / (now - temp) + 1; if (x % a2 == 0) pk = (x / a2) + 0; else pk = (x / a2) + 1; ans = min(ans, pk * p2 + i * p1); } } ans = max(ans, 0ll); if (ans < inf) printf( %lld n , ans); else puts( -1 ); return 0; }
|
#include <bits/stdc++.h> using namespace std; const int MAXN = (int)1e5 + 10; int n, cnt = 0; string a, b; void check(string a, string b) { int p = 0; for (; p < ((int)(a).size()) && a[p] == b[p]; ++p) ; if (a.substr(0, p) == b.substr(0, p) && a.substr(p) == b.substr(p + 1)) ++cnt; } int main() { cin >> n >> a >> b; int p = 0; for (; a[p] == b[p]; ++p) ; if (a.substr(0, p) == b.substr(0, p) && a.substr(p + 1) == b.substr(p + 1)) puts( 2 ), exit(0); check(b.substr(p + 1), a.substr(p)); check(a.substr(p + 1), b.substr(p)); cout << cnt << endl; fclose(stdin); fclose(stdout); return 0; }
|
#include <bits/stdc++.h> using namespace std; typedef long long ll; ll a[200009],n,p; bool vis[200009][2]; pair <ll,ll> g[200009]; int main() { ios::sync_with_stdio(0); int t; cin>>t; while(t--) { cin>>n>>p; ll ans=0; for(int i=1;i<=n;i++) { cin>>a[i]; vis[i][0]=vis[i][1]=0; g[i]=make_pair(a[i],i); } vis[1][0]=vis[n][1]=1; sort(g+1,g+n+1); for(int i=1;i<=n;i++) { int w=g[i].second; if(a[w]>p)break; int l,r; l=r=w; while(!vis[l][0]&&(a[l-1]%a[w]==0))l--; while(!vis[r][1]&&(a[r+1]%a[w]==0))r++; ans+=(r-l)*a[w]; if(l!=r){vis[l][1]=vis[r][0]=1;} for(int h=l+1;h<r;h++)vis[h][0]=vis[h][1]=1; } for(int i=1;i<=n;i++)if(!vis[i][1])ans+=p; cout<<ans<<endl; } return 0; }
|
#include <bits/stdc++.h> using namespace std; template <class T1, class T2> inline istream& operator>>(istream& fin, pair<T1, T2>& pr) { fin >> pr.first >> pr.second; return fin; } template <class T0, class T1, class T2> inline istream& operator>>(istream& fin, tuple<T0, T1, T2>& t) { fin >> get<0>(t) >> get<1>(t) >> get<2>(t); return fin; } template <class T> inline istream& operator>>(istream& fin, vector<T>& a) { for (auto& u : a) fin >> u; return fin; } template <class T, size_t n> inline istream& operator>>(istream& fin, array<T, n>& a) { for (auto& u : a) fin >> u; return fin; } int f542() { size_t n, time; cin >> n >> time; typedef struct { size_t buf, val; } value_t; const auto comp = [](const value_t& a, const value_t& b) { return a.buf < b.buf || (a.buf == b.buf && a.val < b.val); }; priority_queue<value_t, vector<value_t>, decltype(comp)> heap(comp); for (size_t i = 0; i < n; ++i) { size_t val, lag; cin >> lag >> val; if (lag < time + 1) heap.push({time - lag, val}); } size_t val = 0; while (!heap.empty()) { const auto top = heap.top(); heap.pop(); if (top.buf == 0 || heap.empty()) val = max(val, top.val); else { const auto next = heap.top(); if (top.buf != next.buf) heap.push({next.buf, top.val}); else { heap.pop(); heap.push({top.buf - 1, top.val + next.val}); } } } return val; } int main(const int argc, char* argv[]) { cout << f542(); return EXIT_SUCCESS; }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.