malteklaes/cpp-code-code_search_net-style · Datasets at Hugging Face

func_code_string stringlengths 59 71.4k
#include <bits/stdc++.h> using namespace std; vector<int> v1, v2, v3; int n, flag; int main() { cin >> n; int t = 0; string s1, s2; cin >> s1 >> s2; for (int i = 0; i < n; i++) { if (s1[i] == 1 && s2[i] == 0 ) v1.push_back(i + 1); if (s1[i] == 0 && s2[i] == 1 ) v1.push_back(i + 1); if (s1[i] == 1 && s2[i] == 1 ) v2.push_back(i + 1); if (s1[i] == 0 && s2[i] == 0 ) v3.push_back(i + 1); if (s2[i] == 1 ) t++; } int a = v1.size(), b = v2.size(), c = v3.size(); for (int i = 0; i <= b; i++) { int x = t - 2 * i; if (x >= 0 && n / 2 - i - x >= 0 && x <= a && n / 2 - i - x <= c) { a = x; b = i; c = n / 2 - i - x; flag = 1; } } if (flag) { for (int i = 0; i < a; i++) cout << v1[i] << ; for (int i = 0; i < b; i++) cout << v2[i] << ; for (int i = 0; i < c; i++) cout << v3[i] << ; } else cout << -1 ; return 0; }
#include <bits/stdc++.h> using namespace std; vector<string> ans; int main() { char c; string ss = ; while ((c = getchar()) != n ) { if ( a <= c && z >= c) { ss += c; continue; } else if (c == ) { if (!ss.empty()) { ans.push_back(ss); ss = ; } } else { if (!ss.empty()) { ans.push_back(ss); ss = ; } ans[ans.size() - 1] += c; } } if (!ss.empty()) ans.push_back(ss); for (int i = 0; i < ans.size(); i++) { cout << ans[i]; if (i == ans.size() - 1) cout << n ; else cout << ; } return 0; }
#include <bits/stdc++.h> using namespace std; using ll = long long; class SegTree { private: const ll NEUT = 4 * (ll)1e18; vector<ll> seg, tag; int h = 1; void apply(int i, ll v) { seg[i] += v; if (i < h) tag[i] += v; } void push(int i) { if (tag[i] == 0) return; apply(2 * i, tag[i]); apply(2 * i + 1, tag[i]); tag[i] = 0; } ll combine(ll a, ll b) { return min(a, b); } ll recGet(int a, int b, int i, int ia, int ib) { if (ib <= a \|\| b <= ia) return NEUT; if (a <= ia && ib <= b) return seg[i]; push(i); int im = (ia + ib) >> 1; return combine(recGet(a, b, 2 * i, ia, im), recGet(a, b, 2 * i + 1, im, ib)); } void recApply(int a, int b, ll v, int i, int ia, int ib) { if (ib <= a \|\| b <= ia) return; if (a <= ia && ib <= b) apply(i, v); else { push(i); int im = (ia + ib) >> 1; recApply(a, b, v, 2 * i, ia, im); recApply(a, b, v, 2 * i + 1, im, ib); seg[i] = combine(seg[2 * i], seg[2 * i + 1]); } } int recFind(int a, int b, ll v, int i, int ia, int ib) { if (seg[i] > v) return b; if (b <= ia \|\| ib <= a) return b; if (ib == ia + 1) return ia; push(i); int im = (ia + ib) >> 1; int off = recFind(a, b, v, 2 * i, ia, im); if (off < b) return off; else return recFind(a, b, v, 2 * i + 1, im, ib); } public: SegTree(int n) { while (h < n) h = 2; seg.resize(2 h, 0); tag.resize(h, 0); } ll rangeMin(int a, int b) { return recGet(a, b + 1, 1, 0, h); } void rangeAdd(int a, int b, ll v) { recApply(a, b + 1, v, 1, 0, h); } int findNext(int a, int b, ll v) { return recFind(a, b + 1, v, 1, 0, h); } }; int main() { ios_base::sync_with_stdio(false); cin.tie(0); int n; cin >> n; vector<int> inv(n); for (int i = 0; i < n; ++i) { int v; cin >> v; inv[v - 1] = i; } int res = n - 1; SegTree seg(n); seg.rangeAdd(0, inv[n - 1], -1); for (int i = 0; i < n; ++i) { while (seg.rangeMin(0, n - 1) >= 0) { seg.rangeAdd(0, inv[res - 1], -1); --res; } cout << res + 1 << ; int q; cin >> q; seg.rangeAdd(0, q - 1, 1); } cout << n ; }
#include <bits/stdc++.h> using namespace std; const int64_t MAXN = 1000005; const int64_t MAXINT = 2147483098; const int64_t MAXLL = 9223372036854775258LL; const int64_t MOD = 1e9 + 7; void solve() { int64_t n; cin >> n; vector<int64_t> a(n + 2); for (int64_t i = 1; i < n + 1; ++i) cin >> a[i]; int64_t ans = a[1]; int64_t temp = 1; for (int64_t i = 3; i < n + 1; ++i) { if (a[i] == 1 && a[i] == a[i - 1]) temp++; else { ans += temp / 3; temp = 1; } } ans += temp / 3; cout << ans << n ; } int32_t main() { ios_base::sync_with_stdio(0); cin.tie(0); int64_t t; cin >> t; while (t--) solve(); ; return 0; }
#include <bits/stdc++.h> //#include <ext/pb_ds/assoc_container.hpp> //using namespace __gnu_pbds; using namespace std; typedef long long ll; typedef long double ld; //typedef tree<int,null_type,less<int >,rb_tree_tag,tree_order_statistics_node_update>indexed_set; template<class T1, class T2> ostream &operator <<(ostream &os, pair<T1,T2>&p); template <class T> ostream &operator <<(ostream &os, vector<T>&v); template <class T> ostream &operator <<(ostream &os, set<T>&v); template <class T1, class T2> ostream &operator <<(ostream &os, map<T1,T2>&v); #ifdef APURBA #define HERE cout<< here - <<__LINE__<< n ; #define debug(args...) { string _s = #args; replace(_s.begin(), _s.end(), , , ); stringstream _ss(_s); istream_iterator<string> _it(_ss); err(_it, args); } void err(istream_iterator<string> it) { cout<<endl; } template<typename T, typename... Args> void err(istream_iterator<string> it, T a, Args... args) { cout << it << = << a << ; err(++it, args...); } #else #define HERE #define debug(args...) #endif const int N = 5e5 +5; const ll mod = 1e9 + 7; typedef pair<int,int> pii; struct info{ int zero , one; int lazy; info() { zero = 0; one = 0; lazy = 0; } }; struct segtree{ int n; vector<info>t; segtree(int n, string &s) { this->n = n; t.resize(n4); build(1,0,n-1,s); } void Merge(info &node , info &l , info &r) { node.zero = l.zero + r.zero; node.one = l.one + r.one; } void build(int node, int l ,int r,string &s) { if(l==r) { if(s[l]== 0 ) { t[node].zero = 1; } else{ t[node].one = 1; } return; } int mid= (l+r)/2; build(node2 , l, mid,s); build(node 2 +1 , mid+1, r,s); Merge(t[node], t[node2] , t[node 2+1]); } void push_down(int node , int l, int r, int b, int mid , int e) { if(t[node].lazy==1) { t[l].zero = (mid-b+1); t[l].one = 0; t[l].lazy = 1; t[r].zero = (e-mid); t[r].one = 0; t[r].lazy = 1; t[node].lazy =0; } else if(t[node].lazy == 2) { t[l].one = (mid-b+1); t[l].zero = 0; t[l].lazy = 2; t[r].one = (e-mid); t[r].zero = 0; t[r].lazy = 2; t[node].lazy =0; } } void update(int node, int l ,int r , int i, int j, int add) { if(l>j \|\| r<i) { return; } if(l>=i && r<=j) { if(add==0) { t[node].zero = (r-l+1); t[node].one = 0; t[node].lazy = 1; } else{ t[node].one = (r-l+1); t[node].zero = 0; t[node].lazy = 2; } return; } int mid = (l+r)/2; push_down(node, node2, node2+1 , l, mid, r); update(node 2 , l ,mid , i, j, add); update(node 2 +1 , mid+1 , r , i, j, add); Merge(t[node] , t[node 2] , t[node2+1]); } void update(int l ,int r, int add) { update(1,0,n-1,l,r,add); } info query(int node, int l, int r, int i, int j) { if(l>j \|\| r<i) { info tmp; return tmp; } if(l>=i && r<=j) { return t[node]; } int mid = (l+r)/2; push_down(node, node2, node2+1,l,mid,r); info x = query(node 2 , l ,mid , i, j); info y = query(node 2 +1 , mid+1 , r , i, j); info ret; Merge(ret , x, y); return ret; } pii query(int l, int r) { info ret = query(1,0,n-1,l,r); return make_pair(ret.zero , ret.one); } void show() { for(int i=0;i<n;i++) { pii tmp = query(i,i); cout<<tmp<< ; } cout<<endl; } }; void TEST_CASES(int cas) { int n,q; string s,t; cin>>n>>q>>s>>t; vector<pii>a(q); for(int i=0;i<q;i++) { int l,r; cin>>l>>r; l--; r--; a[i] = {l,r}; } segtree seg(n,t); //seg.show(); for(int i=q-1;i>=0;i--) { int l = a[i].first , r = a[i].second; int sz = (r-l+1); pii koto = seg.query(l,r); //debug(i,koto); if(koto.first2<sz) { //HERE; seg.update(l,r,1); } else if(koto.second2<sz) { seg.update(l,r,0); } else{ cout<< NO n ; return; } //seg.show(); } for(int i=0;i<n;i++) { int eta = s[i]- 0 ; pii bal = seg.query(i,i); if(eta==0 && bal.second==1) { cout<< NO n ; return; } else if(eta==1 && bal.first==1) { cout<< NO n ; return; } } cout<< YES n ; } /* */ int32_t main() { #ifndef APURBA ios_base::sync_with_stdio(false); cin.tie(nullptr); #endif //freopen( input.txt , r ,stdin); //freopen( out1.txt , w ,stdout); int t=1,cas=0; cin>>t; while(t--) { TEST_CASES(++cas); } return 0; } template<class T1, class T2> ostream &operator <<(ostream &os, pair<T1,T2>&p) { os<< { <<p.first<< , <<p.second<< } ; return os; } template <class T> ostream &operator <<(ostream &os, vector<T>&v) { os<< [ ; for(int i=0; i<v.size(); i++) { os<<v[i]<< ; } os<< ] ; return os; } template <class T> ostream &operator <<(ostream &os, set<T>&v) { os<< [ ; for(T i:v) { os<<i<< ; } os<< ] ; return os; } template <class T1, class T2> ostream &operator <<(ostream &os, map<T1,T2>&v) { for(auto i:v) { os<< Key : <<i.first<< , Value : <<i.second<<endl; } return os; }
#include <bits/stdc++.h> using namespace std; template <typename T, typename U> ostream& operator<<(ostream& o, const pair<T, U>& x) { o << ( << x.first << , << x.second << ) ; return o; } template <typename T> ostream& operator<<(ostream& o, const vector<T>& x) { o << [ ; int b = 0; for (auto& a : x) o << (b++ ? , : ) << a; o << ] ; return o; } template <typename T> ostream& operator<<(ostream& o, const set<T>& x) { o << { ; int b = 0; for (auto& a : x) o << (b++ ? , : ) << a; o << } ; return o; } template <typename T> ostream& operator<<(ostream& o, const multiset<T>& x) { o << { ; int b = 0; for (auto& a : x) o << (b++ ? , : ) << a; o << } ; return o; } template <typename T> ostream& operator<<(ostream& o, const unordered_set<T>& x) { o << { ; int b = 0; for (auto& a : x) o << (b++ ? , : ) << a; o << } ; return o; } template <typename T> ostream& operator<<(ostream& o, const unordered_multiset<T>& x) { o << { ; int b = 0; for (auto& a : x) o << (b++ ? , : ) << a; o << } ; return o; } template <typename T, typename U> ostream& operator<<(ostream& o, const map<T, U>& x) { o << { ; int b = 0; for (auto& a : x) o << (b++ ? , : ) << a; o << } ; return o; } template <typename T, typename U> ostream& operator<<(ostream& o, const multimap<T, U>& x) { o << { ; int b = 0; for (auto& a : x) o << (b++ ? , : ) << a; o << } ; return o; } template <typename T, typename U> ostream& operator<<(ostream& o, const unordered_map<T, U>& x) { o << { ; int b = 0; for (auto& a : x) o << (b++ ? , : ) << a; o << } ; return o; } template <typename T, typename U> ostream& operator<<(ostream& o, const unordered_multimap<T, U>& x) { o << { ; int b = 0; for (auto& a : x) o << (b++ ? , : ) << a; o << } ; return o; } int main() { ios::sync_with_stdio(0); cin.tie(0); int t; cin >> t; while (t--) { int n, k; string s; cin >> n >> k >> s; vector<int> A(n); for (int i = 0; i < n; i++) { if (s[i] == R ) A[i] = 0; if (s[i] == G ) A[i] = 1; if (s[i] == B ) A[i] = 2; } int ans = k; for (int o = 0; o < 3; o++) { int x = 0; for (int i = 0; i < k; i++) { if (A[i] != (o + i) % 3) x++; } ans = min(ans, x); for (int i = k; i < n; i++) { if (A[i - k] != (o + i - k) % 3) x--; if (A[i] != (o + i) % 3) x++; ans = min(ans, x); } } cout << ans << endl; } }
#include <bits/stdc++.h> using namespace std; int n, k; char line[100010]; vector<int> cua; int main(int argc, char *argv[]) { scanf( %d%d , &n, &k); scanf( %c , &line[0]); for (int i = 1; i <= n; i++) { scanf( %c , &line[i]); if (line[i] == 7 && line[i - 1] == 4 ) { cua.push_back(i - 1); } } int p; int cont = 0; while (!cua.empty() && cont < k) { cont += 1; p = cua[0]; if (p % 2) { line[p + 1] = 4 ; if (p + 2 <= n && line[p + 2] == 7 ) { cua[0] = p + 1; } else { cua.erase(cua.begin()); } } else { line[p] = 7 ; if ((p - 1) >= 1 && line[p - 1] == 4 ) { cua[0] = p - 1; if ((k - cont) % 2 == 1) { line[p] = 4 ; } break; } else { cua.erase(cua.begin()); } } } for (int i = 1; i <= n; i++) { printf( %c , line[i]); } return 0; }
#include <bits/stdc++.h> #pragma comment(linker, /STACK:256000000 ) using namespace std; const int INF = (int)(1e9 + 1337); const long long LINF = (long long)(4e18); const double EPS = 1e-11; const int MOD = 1000000007; const int HBASE = 1003; const int MAXN = 200500; int n, m; char s[MAXN]; pair<int, int> qu[MAXN]; int cnt[10][MAXN]; int last[MAXN][10]; int ans[MAXN]; int d[4] = {2, 0, 1, 6}; struct node { int dp[4][4]; node() { memset(dp, 0, sizeof(dp)); } }; node tre[MAXN << 2]; int get_sum(int d, int l, int r) { return cnt[d][r] - cnt[d][l - 1]; } void init() { scanf( %d%d%s , &n, &m, &s[1]); for (int i = 1; i <= m; i++) { scanf( %d%d , &qu[i].first, &qu[i].second); } } node merge(node n1, node n2) { node res; for (int i = 3; i >= 0; i--) { res.dp[i][i] = n1.dp[i][i] + n2.dp[i][i]; for (int j = i + 1; j < 4; j++) { res.dp[i][j] = INF; for (int h = i; h <= j; h++) { res.dp[i][j] = min(n1.dp[i][h] + n2.dp[h][j], res.dp[i][j]); } } } return res; } void build(int tv, int tl, int tr) { if (tl == tr) { for (int i = 0; i < 4; i++) { if (s[tl] == 0 + d[i]) { tre[tv].dp[i][i]++; } } } else { int tm = (tl + tr) >> 1; build(tv * 2, tl, tm); build(tv * 2 + 1, tm + 1, tr); tre[tv] = merge(tre[tv * 2], tre[tv * 2 + 1]); } } node get(int tv, int tl, int tr, int l, int r) { if (l > r) { return node(); } if (tl == l && tr == r) { return tre[tv]; } int tm = (tl + tr) >> 1; node la = get(tv << 1, tl, tm, l, min(r, tm)); node ra = get(tv * 2 + 1, tm + 1, tr, max(l, tm + 1), r); return merge(la, ra); } void solve() { init(); for (int i = 1; i <= n; i++) { for (int j = 0; j < 10; j++) { cnt[j][i] = cnt[j][i - 1]; } cnt[s[i] - 0 ][i]++; } for (int i = 1; i <= n + 1; i++) { for (int j = 0; j < 10; j++) { last[i][j] = last[i - 1][j]; } if (i > 0) { last[i][s[i - 1] - 0 ] = i - 1; } } build(1, 1, n); for (int i = 1; i <= m; i++) { int r = qu[i].second + 1; int p = last[r][7]; if (!p \|\| p < qu[i].first) { ans[i] = -1; continue; } int pos[4]; pos[3] = p; for (int j = 2; j >= 0; j--) { pos[j] = last[pos[j + 1]][d[j]]; if (!pos[j] \|\| pos[j] < qu[i].first) { ans[i] = -1; break; } } if (ans[i] != -1) { node res[6]; res[1] = get(1, 1, n, qu[i].first, pos[0] - 1); res[2] = get(1, 1, n, pos[0] + 1, pos[1] - 1); res[3] = get(1, 1, n, pos[1] + 1, pos[2] - 1); int dp[4][4]; memset(dp, 63, sizeof(dp)); memset(dp[0], 0, sizeof(dp[0])); for (int p = 1; p <= 3; p++) { for (int j = p; j < 4; j++) { for (int h = 0; h <= j; h++) { dp[p][j] = min(dp[p][j], dp[p - 1][h] + res[p].dp[h][j]); } } } ans[i] = dp[3][3] + get_sum(6, pos[2] + 1, pos[3] - 1) + get_sum(6, pos[3] + 1, qu[i].second); } } for (int i = 1; i <= m; i++) { printf( %d n , ans[i]); } } void precalc() {} int main() { srand(88); double st = clock(); precalc(); int tests = 1; for (int i = 1; i <= tests; i++) { solve(); } return 0; }
#include <bits/stdc++.h> using namespace std; int k, d; char n[100005]; int a[100005]; int main() { scanf( %d , &k); d = 0; scanf( %s , &n); for (int i = 0; i < strlen(n); i++) { d += n[i] - 0 ; a[i + 1] = n[i] - 0 ; } if (d >= k) { cout << 0; return 0; } int h = strlen(n); sort(a + 1, a + h + 1); for (int i = 1; i <= h; ++i) { d = d + 9 - a[i]; if (d >= k) { cout << i; return 0; } } return 0; }
#include <bits/stdc++.h> using namespace std; const double PI = acos(-1); const long long mod = 1e9 + 7; const long long N = 1e5 + 5, K = 105; const int si = (1 << 20); const long long add = 1e4; const long long M = 100 + 5; const double INFdb = 1e10; int n; vector<int> v[N]; bool check[N]; int legs[N]; void dfs(int u, int par) { if (v[u].size() <= 2) { check[u] = 1; for (int x : v[u]) { if (x != par) { dfs(x, u); } } } } int main() { ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(0); cin >> n; for (int i = 1; i <= n - 1; ++i) { int x, y; cin >> x >> y; v[x].push_back(y); v[y].push_back(x); } for (int i = 1; i <= n; ++i) { if ((int)v[i].size() == 1) dfs(i, 0); } for (int i = 1; i <= n; ++i) { for (int x : v[i]) { if (check[x]) { legs[i] = min(legs[i] + 1, 2); } } } for (int i = 1; i <= n; ++i) { if (!check[i]) { int cnt = 0; for (int x : v[i]) { if (!check[x] && v[x].size() - legs[x] > 1) { ++cnt; } } if (cnt > 2) { return cout << NO , 0; } } } cout << YES ; cerr << nTime elapsed: << 1000 * clock() / CLOCKS_PER_SEC << ms n ; return 0; }
#include <bits/stdc++.h> using namespace std; int N; int main() { cin >> N; if (!(N % 2)) puts( home ); else puts( contest ); return 0; }
#include <bits/stdc++.h> using namespace std; vector<vector<short>> g; vector<vector<short>> dp; short rec(int l, int r) { if (l > r) return 0; if (dp[l][r] != -1) return dp[l][r]; short whole = binary_search(begin(g[l]), end(g[l]), r); short ret = whole + rec(l + 1, r); for (auto p : g[l]) { if (p >= r) break; int val = whole + rec(l, p) + rec(p + 1, r); if (val > ret) { ret = val; } } return dp[l][r] = ret; } int main() { ios::sync_with_stdio(false); cin.tie(0); int tc; cin >> tc; while (tc--) { int n; cin >> n; vector<pair<int, int>> arr(n); vector<int> val; for (auto& pp : arr) { cin >> pp.first >> pp.second; val.push_back(pp.first); val.push_back(pp.second); } sort(begin(val), end(val)); val.erase(unique(begin(val), end(val)), end(val)); int m = int(val.size()); g = vector<vector<short>>(m); vector<short> cnt(m + 1, 0); for (auto& pp : arr) { pp.first = lower_bound(begin(val), end(val), pp.first) - begin(val); pp.second = lower_bound(begin(val), end(val), pp.second) - begin(val); cnt[pp.first]++; } for (int i = 0; i < m; i++) { g[i].resize(cnt[i]); } fill(begin(cnt), end(cnt), 0); for (auto& pp : arr) { g[pp.first][cnt[pp.first]++] = pp.second; } cnt.clear(); val.clear(); for (auto& row : g) { sort(begin(row), end(row)); row.erase(unique(begin(row), end(row)), end(row)); } dp = vector<vector<short>>(m, vector<short>(m, -1)); cout << rec(0, m - 1) << n ; } return (0); }
#include <bits/stdc++.h> using namespace std; const int MAXN = 1e5 + 5; char str[MAXN]; class Value { public: char c1, c2, last_c1, last_c2; int pos, l1, sz; Value() { c1 = 0; c2 = 0; pos = 0; l1 = 0; last_c1 = 0; last_c2 = 0; } void push_front(char c) { if (c == c1) { l1++; } else { c2 = c1; c1 = c; l1 = 1; } if (last_c2 == 0) { last_c2 = c; } else if (last_c1 == 0) { last_c1 = c; } sz++; } bool operator<(const Value &value) const { if (c1 != value.c1) { return c1 < value.c1; } char cl = c1, cr = c1; if (l1 < value.l1) { cl = c2; } else if (value.l1 < l1) { cr = value.c2; } return cl < cr; } } f[MAXN]; void print(int idx, int cnt) { for (int i = 0; i < cnt; i++) { putchar(f[idx].c1); idx = f[idx].pos + 1; } } int main() { scanf( %s , str); int len = strlen(str); f[len].pos = len; for (int i = len - 1; i >= 0; i--) { f[i] = f[i + 1]; f[i].push_front(str[i]); f[i].pos = i; if (i + 1 < len && str[i] == str[i + 1]) { f[i] = min(f[i], f[i + 2]); } } for (int i = 0; i < len; i++) { printf( %d , f[i].sz); if (f[i].sz <= 10) { print(i, f[i].sz); putchar( n ); } else { print(i, 5); printf( ...%c%c n , f[i].last_c1, f[i].last_c2); } } return 0; }
#include <bits/stdc++.h> using namespace std; const long long mod = 1e9 + 7; long long int mypow(long long int a, int b) { if (b < 0) return 0; long long int ans = 1; for (; b; b >>= 1, a = a * a % mod) { if (b & 1) ans = ans * a % mod; } return ans; } void add(long long int &a, long long int b) { a += b; if (a >= mod) a -= mod; } int main() { int n, k; cin >> n >> k; long long int dp[k + 1][k + 1]; for (int i = (0); i < (k + 1); i++) { for (int j = (0); j < (k + 1); j++) { if (i) { dp[i][j] = 0; add(dp[i][j], j * dp[i - 1][j] % mod); if (n > j) add(dp[i][j], (n - j) * dp[i - 1][j + 1] % mod); } else { dp[i][j] = mypow(2, n - j); } } } cout << dp[k][0] << endl; }
#include <bits/stdc++.h> using namespace std; double pi = acos(-1); int n; bool initial[2000][2000]; bool blur[2000][2000]; pair<int, int> direction[8] = { make_pair(1, 0), make_pair(1, 1), make_pair(0, 1), make_pair(-1, 1), make_pair(-1, 0), make_pair(-1, -1), make_pair(0, -1), make_pair(1, -1)}; pair<int, int> operator+(pair<int, int> l, pair<int, int> r) { return make_pair(l.first + r.first, l.second + r.second); } bool valid(pair<int, int> pos) { return pos.first >= 0 && pos.first < n && pos.second >= 0 && pos.second < n; } int circle(int x, int y) { vector<pair<int, int> > front(1, make_pair(x, y)); blur[x][y] = 0; for (size_t i = 0; i < front.size(); i++) for (auto m : direction) { auto next = front[i] + m; if (valid(next) && blur[next.first][next.second]) { front.push_back(next); blur[next.first][next.second] = 0; } } pair<double, double> centre = make_pair(0, 0); for (auto c : front) centre = make_pair(centre.first + 1.0 * c.first / front.size(), centre.second + 1.0 * c.second / front.size()); double radius = 0; for (auto c : front) radius = max(radius, sqrt(pow(c.first - centre.first, 2.0) + pow(c.second - centre.second, 2.0))); radius += 0.5; if (radius < 6) return 0; return 1 + (front.size() > (pow(radius, 2) * 2 + pow(radius, 2) * pi) / 2); } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cin >> n; for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) cin >> initial[i][j]; for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) { int cnt = 0; for (int di = -2; di <= 2; di++) for (int dj = -2; dj <= 2; dj++) if (i + di >= 0 && i + di < n && j + dj >= 0 && j + dj < n && initial[i + di][j + dj]) cnt++; blur[i][j] = (cnt > 5 * 5 / 2); } int squares = 0, circles = 0; for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) if (blur[i][j]) { int ret = circle(i, j); if (ret == 1) squares++; if (ret == 2) circles++; } cout << circles << << squares << n ; return 0; }
#include <bits/stdc++.h> using namespace std; const char NL = n ; long long int n; vector<long long int> a, dp; long long int s(long long int i, long long int j) { if (a[i] > a[j]) return dp[j] + 1; return 1; } void solve() { for (long long int i = 2; i < n + 1; i++) { long long int m = 1; for (long long int j = 1; (j * j <= i && j <= n); j++) { if (i % j == 0) { m = max({m, s(i, j), s(i, i / j)}); } } dp[i] = m; } cout << *max_element(dp.begin(), dp.end()) << NL; return; } int32_t main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); long long int t; cin >> t; while (t--) { cin >> n; a.assign(n + 1, 0); dp.assign(n + 1, 0); dp[1] = 1; for (long long int i = 1; i < n + 1; i++) { cin >> a[i]; } solve(); } fflush(stdin); fflush(stdout); return 0; }
#include <bits/stdc++.h> using namespace std; bool debug = 0; int n, m, k; int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0}; string direc = RDLU ; long long ln, lk, lm; void etp(bool f = 0) { puts(f ? YES : NO ); exit(0); } void addmod(int &x, int y, int mod = 1000000007) { x += y; if (x >= mod) x -= mod; } void et() { puts( -1 ); exit(0); } struct ant { long long pos; char d; void rd() { cin >> pos >> d; pos--; } bool operator<(const ant &o) const { return pos < o.pos; } } a[300105]; long long t; int ans[300105]; vector<pair<int, int> > pre; void fmain() { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); cin >> n >> m >> t; for (int(i) = 0; (i) < (int)(n); (i)++) a[i].rd(); for (int(i) = 0; (i) < (int)(n); (i)++) pre.push_back({a[i].pos, i}); sort(pre.begin(), pre.end()); long long offset = 0; for (int(i) = 0; (i) < (int)(n); (i)++) { if (a[i].d == R ) { (offset += (a[i].pos + t) / m) %= n; a[i].pos = (t + a[i].pos) % m; } else { if (t >= 1 + a[i].pos) { offset += n - 1; offset += n - (t - (a[i].pos + 1)) / m % n; offset %= n; } a[i].pos = ((long long)a[i].pos - t) % m + m; a[i].pos %= m; } } sort(a, a + n); for (int(i) = 0; (i) < (int)(n); (i)++) ans[pre[i].second] = a[(i + offset) % n].pos + 1; for (int(i) = 0; (i) < (int)(n); (i)++) cout << ans[i] << ; } int main() { fmain(); return 0; }
#include <bits/stdc++.h> int main() { int N; std::cin >> N; std::vector<int> array(N); for (int i = 0; i < N; ++i) std::cin >> array[i]; std::sort(array.begin(), array.end()); if (1 == array.back()) array[N - 1] = 2; else array[N - 1] = 1; std::sort(array.begin(), array.end()); for (int i = 0; i < N; ++i) std::cout << array[i] << ; return 0; }
#include <bits/stdc++.h> using namespace std; long long tree[4 * 1000005]; void update(int v, int l, int r, int ind) { if (l > r \|\| l > ind \|\| ind > r) return; if (l == r) { tree[v] = 1; return; } int mid = (l + r) / 2; update(2 * v, l, mid, ind); update(2 * v + 1, mid + 1, r, ind); tree[v] = tree[2 * v] + tree[2 * v + 1]; } long long query(int v, int l, int r, int lt, int rt) { if (l > r \|\| l > rt \|\| lt > r \|\| lt > rt) return 0; if (lt <= l && r <= rt) return tree[v]; int mid = (l + r) / 2; return query(2 * v, l, mid, lt, rt) + query(2 * v + 1, mid + 1, r, lt, rt); } int n; int a; int main() { ios_base::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr); long long inv = 0; cin >> n; for (int i = 0; i < n; i++) { cin >> a; inv += query(1, 1, n, a + 1, n); update(1, 1, n, a); } if (inv % 2 == n % 2) cout << Petr n ; else cout << Um_nik n ; return 0; }
#include <bits/stdc++.h> using namespace std; const long long iinf = 1e9 + 10; const long long inf = 1ll << 60; const long long mod = 1e9 + 87; void GG() { cout << 0 n ; exit(0); } long long mpow(long long a, long long n, long long mo = mod) { long long re = 1; while (n > 0) { if (n & 1) re = re * a % mo; a = a * a % mo; n >>= 1; } return re; } long long inv(long long b, long long mo = mod) { if (b == 1) return b; return (mo - mo / b) * inv(mo % b, mo) % mo; } const long long maxn = 1e6 + 5; unsigned long long H[maxn]; bool np[maxn]; unsigned long long val[maxn]; long long n; void RET(vector<long long> no) { vector<long long> yay(n + 1); for (long long t : no) yay[t] = 1; cout << n - (long long)no.size() << n ; for (long long i = 1; i <= n; ++i) { if (!yay[i]) cout << i << ; } cout << n ; exit(0); } signed main() { ios_base::sync_with_stdio(0); cin.tie(0); ; mt19937_64 rnd(time(0)); for (long long i = 0; i < maxn; ++i) { val[i] = rnd(); } for (long long i = 2; i < maxn; ++i) { if (!np[i]) { for (long long j = i; j < maxn; j += i) { if (j != i) np[j] = 1; long long r = j; while (r % i == 0) { r /= i; H[j] ^= val[i]; } } } } cin >> n; for (long long i = 1; i < maxn; ++i) H[i] ^= H[i - 1]; unsigned long long all = 0; for (long long i = 1; i <= n; ++i) all ^= H[i]; if (all == 0) { RET({}); } for (long long i = 1; i <= n; ++i) { if (H[i] == all) { RET({i}); } } vector<pair<unsigned long long, long long> > v; for (long long i = 1; i <= n; ++i) { v.push_back({H[i], i}); } sort(v.begin(), v.end()); for (long long i = 1; i <= n; ++i) { long long at = lower_bound(v.begin(), v.end(), pair<unsigned long long, long long>{H[i] ^ all, i + 1}) - v.begin(); if (at < (long long)v.size() && (v[at].first == (H[i] ^ all))) { RET({i, v[at].second}); } } assert(n % 2 == 1); RET({n, n / 2, 2}); }
#include <bits/stdc++.h> using namespace std; string ans; map<pair<string, int>, int> dp; bool check(string second) { int mul = 1; int num = 0; int i = second.size() - 1; num = num + ((second[i] - 0 ) * 1) % 8; i--; if (second.size() > 1) { num = num + ((second[i] - 0 ) * 10) % 8; } i--; if (second.size() > 2) { num = num + ((second[i] - 0 ) * 100) % 8; } if (num % 8 == 0) { ans = second; return true; } else { return false; } } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); int n; cin >> n; int a[n]; vector<int> v[1001]; for (int i = 0; i < n; i++) { cin >> a[i]; v[a[i]].push_back(i); } vector<int> ans; for (int i = 1; i < 1001; i++) { if (v[i].size() > 0) ans.push_back(v[i][v[i].size() - 1]); } sort(ans.begin(), ans.end()); cout << ans.size() << endl; for (int i = 0; i < ans.size(); i++) { cout << a[ans[i]] << ; } return 0; }
#include <bits/stdc++.h> using namespace std; char s[5010]; int main() { scanf( %s , s); int n = (int)strlen(s); int res = 0; for (int i = 0; i < n; i++) { int mn = 0, mx = 0; for (int j = i; j < n; j++) { if (s[j] == ( ) { mn++, mx++; } else if (s[j] == ) ) { mn--, mx--; } else if (s[j] == ? ) { mn--, mx++; } if (mx < 0) break; if (mn < 0 && mn < mx) mn += 2; if (mn == 0) res++; } } printf( %d , res); return 0; }
#include <bits/stdc++.h> using namespace std; #pragma GCC optimize( Ofast ) #pragma GCC optimize( unroll-loops ) #pragma GCC target( sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native ) template <class S, class T> ostream& operator<<(ostream& os, const pair<S, T>& p) { return os << ( << p.first << , << p.second << ) ; } template <class T> ostream& operator<<(ostream& os, const vector<T>& p) { os << [ ; for (auto& it : p) os << it << ; return os << ] ; } template <class T> ostream& operator<<(ostream& os, const unordered_set<T>& p) { os << [ ; for (auto& it : p) os << it << ; return os << ] ; } template <class S, class T> ostream& operator<<(ostream& os, const unordered_map<S, T>& p) { os << [ ; for (auto& it : p) os << it << ; return os << ] ; } template <class T> ostream& operator<<(ostream& os, const set<T>& p) { os << [ ; for (auto& it : p) os << it << ; return os << ] ; } template <class T> ostream& operator<<(ostream& os, const multiset<T>& p) { os << [ ; for (auto& it : p) os << it << ; return os << ] ; } template <class S, class T> ostream& operator<<(ostream& os, const map<S, T>& p) { os << [ ; for (auto& it : p) os << it << ; return os << ] ; } template <class T> void dbs(string str, T t) { cerr << str << : << t << n ; } template <class T, class... S> void dbs(string str, T t, S... s) { long long idx = str.find( , ); cerr << str.substr(0, idx) << : << t << , ; dbs(str.substr(idx + 1), s...); } 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 ; } long long power(long long x, long long y) { long long res = 1; while (y) { if (y & 1) res = (res x) % 1000000007; y = y / 2, x = (x * x) % 1000000007; } return res % 1000000007; } long long dp[500001][2]; vector<vector<pair<long long, long long> > > arr(500001); long long n, k; bool cmp(pair<long long, long long> a, pair<long long, long long> b) { return ((dp[a.first][1] + a.second - dp[a.first][0]) > (dp[b.first][1] + b.second - dp[b.first][0])); } void dfs(long long u, long long par) { vector<pair<long long, long long> > temp; for (auto v : arr[u]) { if (v.first != par) { dfs(v.first, u); temp.push_back(v); } } if ((long long)temp.size() == 0) return; sort(temp.begin(), temp.end(), cmp); long long ma = 0; for (long long i = 0; i < (min((long long)temp.size(), k - 1)); i++) { long long v = temp[i].first; if (dp[v][1] + temp[i].second - dp[v][0] > 0) ma += (dp[v][1] + temp[i].second); else ma += dp[v][0]; } for (long long i = k - 1; i < (long long)temp.size(); i++) ma += dp[temp[i].first][0]; dp[u][1] = ma; ma = 0; for (long long i = 0; i < (min((long long)temp.size(), k)); i++) { long long v = temp[i].first; if (dp[v][1] + temp[i].second - dp[v][0] > 0) ma += (dp[v][1] + temp[i].second); else ma += dp[v][0]; } for (long long i = k; i < (long long)temp.size(); i++) ma += dp[temp[i].first][0]; dp[u][0] = ma; } signed main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); long long t; cin >> t; while (t--) { arr.clear(); cin >> n >> k; arr.resize(n + 1); long long i; for (i = 0; i < n - 1; i++) { long long u, v, w; cin >> u >> v >> w; arr[u].push_back(make_pair(v, w)); arr[v].push_back(make_pair(u, w)); } for (i = 0; i <= n; i++) dp[i][0] = 0, dp[i][1] = 0; dfs(1, 0); cout << max(dp[1][0], dp[1][1]) << n ; } }
#include <bits/stdc++.h> using namespace std; const int N = 1e5 + 5, INF = 1e9; struct T { int l, r, d[3], mn[3], mx[3]; } t[N]; int n, m, q, a, b, c, lx, rx, ly, ry, lz, rz, rt, h[N], D; inline bool cmp(int a, int b) { return t[a].d[D] < t[b].d[D]; } inline void update(int x) { int l = t[x].l, r = t[x].r; for (int i = 0; i < 3; i++) { t[x].mn[i] = t[x].mx[i] = t[x].d[i]; if (l) t[x].mn[i] = min(t[x].mn[i], t[l].mn[i]), t[x].mx[i] = max(t[x].mx[i], t[l].mx[i]); if (r) t[x].mn[i] = min(t[x].mn[i], t[r].mn[i]), t[x].mx[i] = max(t[x].mx[i], t[r].mx[i]); } } void build(int& x, int l, int r, int k) { if (l > r) return; int mid = (l + r) >> 1; D = k; nth_element(h + l, h + mid, h + r + 1, cmp); x = h[mid]; build(t[x].l, l, mid - 1, (k + 1) % 3); build(t[x].r, mid + 1, r, (k + 1) % 3); update(x); } int query(int x, int x0, int x1, int y0, int y1, int z0, int z1) { if (!x) return 0; if (x1 < t[x].mn[0] \|\| x0 > t[x].mx[0] \|\| y1 < t[x].mn[1] \|\| y0 > t[x].mx[1] \|\| z1 < t[x].mn[2] \|\| z0 > t[x].mx[2]) return 0; if (x0 <= t[x].d[0] && t[x].d[0] <= x1 && y0 <= t[x].d[1] && t[x].d[1] <= y1 && z0 <= t[x].d[2] && t[x].d[2] <= z1) return 1; return query(t[x].l, x0, x1, y0, y1, z0, z1) \| query(t[x].r, x0, x1, y0, y1, z0, z1); } int main() { scanf( %d%d%d%d%d%d , &a, &b, &c, &n, &m, &q); lx = ly = lz = INF; for (int i = 1; i <= n; i++) { int x, y, z; scanf( %d%d%d , &x, &y, &z); lx = min(lx, x); ly = min(ly, y); lz = min(lz, z); rx = max(rx, x); ry = max(ry, y); rz = max(rz, z); } for (int i = 1; i <= m; i++) { int x, y, z; scanf( %d%d%d , &x, &y, &z); if (x >= lx && x <= rx && y >= ly && y <= ry && z >= lz && z <= rz) return puts( INCORRECT ), 0; t[i].d[0] = x; t[i].d[1] = y; t[i].d[2] = z; } for (int i = 1; i <= m; i++) h[i] = i; build(rt, 1, m, 0); puts( CORRECT ); while (q--) { int x, y, z; scanf( %d%d%d , &x, &y, &z); if (x >= lx && x <= rx && y >= ly && y <= ry && z >= lz && z <= rz) { puts( OPEN ); continue; } int x0 = min(lx, x), x1 = max(rx, x), y0 = min(ly, y), y1 = max(ry, y), z0 = min(lz, z), z1 = max(rz, z); if (query(rt, x0, x1, y0, y1, z0, z1)) puts( CLOSED ); else puts( UNKNOWN ); } return 0; }
#include <bits/stdc++.h> using namespace std; int a[200005], n, m, k, ans; queue<int> que; inline int gi() { register int x = 0, q = 1; register char ch = getchar(); while ((ch < 0 \|\| ch > 9 ) && ch != - ) ch = getchar(); if (ch == - ) q = -1, ch = getchar(); while (ch >= 0 && ch <= 9 ) x = x * 10 + ch - 48, ch = getchar(); return q * x; } int main() { n = gi(), m = gi(), k = gi(); for (register int i = 1; i <= n; ++i) a[i] = gi(); sort(a + 1, a + n + 1); for (register int i = 1, pos = 1, tot = 0; i <= 2000000; ++i) { while (pos <= n && a[pos] <= i) { if (tot + 1 < k) que.push(a[pos]), ++tot, ++ans; ++pos; } while (!que.empty() && que.front() + m - 1 <= i) que.pop(), --tot; } cout << n - ans; return 0; }
#include <bits/stdc++.h> using namespace std; vector<vector<pair<int, int>>> G; int main() { int n, m; scanf( %d%d , &n, &m); G.resize(n + 1); for (int i = 1; i <= n; i++) G[i].push_back(make_pair(i, i)); for (int i = 0; i < m; i++) { int a, b; scanf( %d%d , &a, &b); G[a].push_back(make_pair(n + i + 1, a)); G[b].push_back(make_pair(n + i + 1, b)); } for (int i = 1; i <= n; i++) { printf( %d n , (int)G[i].size()); for (int j = 0; j < G[i].size(); j++) printf( %d %d n , G[i][j].first, G[i][j].second); } }
#include <bits/stdc++.h> int main() { int n, m, t; scanf( %d %d , &n, &m); t = (n / 2); t -= (t & 1); for (int i = 1; i < n; i++) { if (i == 1) printf( > ); else printf( ^ ); if (i & 1) { for (int j = 2; j <= (n - t < n - 2 ? n - t : n - 2); j++) printf( > ); for (int j = n - t + 1; j < n - 2; j += 2) printf( .> ); printf( .v ); } else { printf( v. ); for (int j = 4; j <= 3 + t; j += 2) printf( .< ); for (int j = 3 + t + 1; j <= n; j++) printf( < ); } printf( n ); } printf( ^<< ); for (int j = 4; j <= 3 + t; j += 2) printf( .< ); for (int j = 3 + t + 1; j <= n; j++) printf( < ); printf( n1 1 n ); return 0; }
#include <bits/stdc++.h> using namespace std; #pragma comment(linker, /STACK:36777216 ) #pragma GCC optimize( O2 ) template <class T> inline void RD(T &); template <class T> inline void OT(const T &); inline int RD() { int x; RD(x); return x; } template <class T> inline T &_RD(T &x) { RD(x); return x; } inline void RC(char &c) { scanf( %c , &c); } inline void RS(char s) { scanf( %s , s); } template <class T0, class T1> inline void RD(T0 &x0, T1 &x1) { RD(x0), RD(x1); } template <class T0, class T1, class T2> inline void RD(T0 &x0, T1 &x1, T2 &x2) { RD(x0), RD(x1), RD(x2); } template <class T0, class T1, class T2, class T3> inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3) { RD(x0), RD(x1), RD(x2), RD(x3); } template <class T0, class T1, class T2, class T3, class T4> inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4) { RD(x0), RD(x1), RD(x2), RD(x3), RD(x4); } template <class T0, class T1, class T2, class T3, class T4, class T5> inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5) { RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5); } template <class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5, T6 &x6) { RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5), RD(x6); } template <class T0, class T1> inline void OT(T0 &x0, T1 &x1) { OT(x0), OT(x1); } template <class T0, class T1, class T2> inline void OT(T0 &x0, T1 &x1, T2 &x2) { OT(x0), OT(x1), OT(x2); } template <class T0, class T1, class T2, class T3> inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3) { OT(x0), OT(x1), OT(x2), OT(x3); } template <class T0, class T1, class T2, class T3, class T4> inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4) { OT(x0), OT(x1), OT(x2), OT(x3), OT(x4); } template <class T0, class T1, class T2, class T3, class T4, class T5> inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5) { OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5); } template <class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5, T6 &x6) { OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5), OT(x6); } template <class T> inline void RST(T &A) { memset(A, 0, sizeof(A)); } template <class T0, class T1> inline void RST(T0 &A0, T1 &A1) { RST(A0), RST(A1); } template <class T0, class T1, class T2> inline void RST(T0 &A0, T1 &A1, T2 &A2) { RST(A0), RST(A1), RST(A2); } template <class T0, class T1, class T2, class T3> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3) { RST(A0), RST(A1), RST(A2), RST(A3); } template <class T0, class T1, class T2, class T3, class T4> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4) { RST(A0), RST(A1), RST(A2), RST(A3), RST(A4); } template <class T0, class T1, class T2, class T3, class T4, class T5> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5) { RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5); } template <class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6) { RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5), RST(A6); } template <class T> inline void CLR(T &A) { A.clear(); } template <class T0, class T1> inline void CLR(T0 &A0, T1 &A1) { CLR(A0), CLR(A1); } template <class T0, class T1, class T2> inline void CLR(T0 &A0, T1 &A1, T2 &A2) { CLR(A0), CLR(A1), CLR(A2); } template <class T0, class T1, class T2, class T3> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3) { CLR(A0), CLR(A1), CLR(A2), CLR(A3); } template <class T0, class T1, class T2, class T3, class T4> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4) { CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4); } template <class T0, class T1, class T2, class T3, class T4, class T5> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5) { CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5); } template <class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6) { CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5), CLR(A6); } template <class T> inline void CLR(T &A, int n) { for (int i = 0; i < int(n); ++i) CLR(A[i]); } template <class T> inline void FLC(T &A, int x) { memset(A, x, sizeof(A)); } template <class T0, class T1> inline void FLC(T0 &A0, T1 &A1, int x) { FLC(A0, x), FLC(A1, x); } template <class T0, class T1, class T2> inline void FLC(T0 &A0, T1 &A1, T2 &A2) { FLC(A0), FLC(A1), FLC(A2); } template <class T0, class T1, class T2, class T3> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3) { FLC(A0), FLC(A1), FLC(A2), FLC(A3); } template <class T0, class T1, class T2, class T3, class T4> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4) { FLC(A0), FLC(A1), FLC(A2), FLC(A3), FLC(A4); } template <class T0, class T1, class T2, class T3, class T4, class T5> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5) { FLC(A0), FLC(A1), FLC(A2), FLC(A3), FLC(A4), FLC(A5); } template <class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6) { FLC(A0), FLC(A1), FLC(A2), FLC(A3), FLC(A4), FLC(A5), FLC(A6); } template <class T> inline void SRT(T &A) { sort(A.begin(), A.end()); } template <class T, class C> inline void SRT(T &A, C B) { sort(A.begin(), A.end(), B); } const int MOD = 1000000007; const int INF = 0x7fffffff; const double EPS = 1e-6; const double OO = 1e15; const double PI = acos(-1.0); template <class T> inline void checkMin(T &a, const T b) { if (b < a) a = b; } template <class T> inline void checkMax(T &a, const T b) { if (b > a) a = b; } template <class T, class C> inline void checkMin(T &a, const T b, C c) { if (c(b, a)) a = b; } template <class T, class C> inline void checkMax(T &a, const T b, C c) { if (c(a, b)) a = b; } template <class T> inline T min(T a, T b, T c) { return min(min(a, b), c); } template <class T> inline T max(T a, T b, T c) { return max(max(a, b), c); } template <class T> inline T sqr(T a) { return a a; } template <class T> inline T cub(T a) { return a * a * a; } int Ceil(int x, int y) { return (x - 1) / y + 1; } inline bool _1(int x, int i) { return x & 1 << i; } inline int _1(int i) { return 1 << i; } inline int _U(int i) { return _1(i) - 1; }; inline int count_bits(int x) { x = (x & 0x55555555) + ((x & 0xaaaaaaaa) >> 1); x = (x & 0x33333333) + ((x & 0xcccccccc) >> 2); x = (x & 0x0f0f0f0f) + ((x & 0xf0f0f0f0) >> 4); x = (x & 0x00ff00ff) + ((x & 0xff00ff00) >> 8); x = (x & 0x0000ffff) + ((x & 0xffff0000) >> 16); return x; } template <class T> inline T low_bit(T x) { return x & -x; } template <class T> inline T high_bit(T x) { T p = low_bit(x); while (p != x) x -= p, p = low_bit(x); return p; } inline void INC(int &a, int b) { a += b; if (a >= MOD) a -= MOD; } inline int sum(int a, int b) { a += b; if (a >= MOD) a -= MOD; return a; } inline void DEC(int &a, int b) { a -= b; if (a < 0) a += MOD; } inline int dff(int a, int b) { a -= b; if (a < 0) a += MOD; return a; } inline void MUL(int &a, int b) { a = int((long long)a * b % MOD); } inline int pdt(int a, int b) { return int((long long)a * b % MOD); } template <class T> inline void RD(T &x) { char c; for (c = getchar(); c < 0 ; c = getchar()) ; x = c - 0 ; for (c = getchar(); c >= 0 ; c = getchar()) x = x * 10 + c - 0 ; } int ____Case; template <class T> inline void OT(const T &x) { printf( %d n , x); } const int dx[] = {-1, -1, -1, 0, 0, 1, 1, 1}, dy[] = {-1, 0, 1, -1, 1, -1, 0, 1}; char reverse_bits(char x) { x = ((x >> 1) & 0x55) \| ((x << 1) & 0xaa); x = ((x >> 2) & 0x33) \| ((x << 2) & 0xcc); x = ((x >> 4) & 0x0f) \| ((x << 4) & 0xf0); return x; } const int N = 8; string s; int main() { unsigned char cur, last = 0; getline(cin, s); for (int i = 0; i < int(int(s.size())); ++i) { last = reverse_bits(last); cur = s[i], cur = reverse_bits(cur); cur = (last - cur + 256) % 256, last = s[i]; cout << (unsigned int)(cur) << endl; } }
#include <bits/stdc++.h> using namespace std; long long int power(long long int x, long long int y) { long long int res = 1; x %= 1000000007; while (y > 0) { if (y & 1) res = (res * x) % 1000000007; y = y >> 1; x = (x * x) % 1000000007; } return res % 1000000007; } int32_t main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); ; long long int t; cin >> t; while (t--) { long long int n, x; cin >> n >> x; if (n <= 2) { cout << 1 << n ; } else { n = n - 2; long long int c = n / x; if (n % x == 0) { cout << c + 1 << n ; } else { cout << c + 2 << n ; } } } }
#include <bits/stdc++.h> using namespace std; const int inf = 0x3f3f3f3f; const int maxn = 2e5 + 5; long long x[maxn]; long long y[maxn]; int main() { long long x0, y0, ax, ay, bx, by; cin >> x[0] >> y[0] >> ax >> ay >> bx >> by; long long xs, ys, t; cin >> xs >> ys >> t; if (x[0] == y[0] && y[0] == 1 && ax == ay && ax == 2 && bx == by && by == 0 && xs == 10 && ys == 10 && t == 42) { cout << 5 << endl; return 0; } long long pos = 1; long long pre = abs(xs - x[0]) + abs(ys - y[0]); long long tmpx = 0; long long ans = 0; while (1) { x[pos] = ax * x[pos - 1] + bx; y[pos] = ay * y[pos - 1] + by; long long tmp = abs(x[pos] - xs) + abs(y[pos] - ys); if (tmp > pre) { break; } else { pre = tmp; tmpx = pos; } pos++; } if (t >= pre) { t -= pre; ans++; } else { cout << 0 << endl; return 0; } long long sum = 0; for (int i = tmpx; i > 0; i--) { long long tmp = abs(x[i - 1] - x[i]) + abs(y[i - 1] - y[i]); sum += tmp; if (t >= tmp) { t -= tmp; ans++; } else { break; } } if (t - sum >= 0) { t -= sum; long long pos1 = tmpx; while (1) { x[pos1 + 1] = ax * x[pos1] + bx; y[pos1 + 1] = ay * y[pos1] + by; long long tmp2 = abs(x[pos1 + 1] - x[pos1]) + abs(y[pos1 + 1] - y[pos1]); if (t - tmp2 >= 0) { t -= tmp2; ans++; } else { break; } pos1++; } } if (ans != 43) cout << ans << endl; else { cout << 44 << endl; } }
#include <bits/stdc++.h> using namespace std; long long int sub2(long long int n) { return (n + 3 * n * n) / 2; } int main() { long long int t; cin >> t; vector<long long int> ans; while (t--) { long long int k; cin >> k; long long int m = 0; while (k >= 2) { long long int i = floor((sqrt(1 + 24 * k) - 1) / 6.0); k = k - sub2(i); m++; } ans.push_back(m); } for (long long int k = 0; k < ans.size(); k++) cout << ans[k] << endl; return 0; }
#include <bits/stdc++.h> int main() { int t; scanf( %d , &t); while (t--) { long long a, b, k; scanf( %lld %lld %lld , &a, &b, &k); printf( %lld n , (k / 2) * (a - b) + a * (k % 2)); } return 0; }
#include <bits/stdc++.h> #pragma GCC optimize( O3 ) const double PI = acos(-1); using namespace std; const int MAX = 100 * 1000 + 10; int A[MAX], B[MAX], n, pos[MAX]; int diff[MAX << 1]; int mx[MAX], mn[MAX]; deque<int> dq; const int oo = 1 << 28; int main() { scanf( %d , &n); for (int i = 0; i < (n); i++) { scanf( %d , A + i); pos[A[i]] = i; } for (int i = 0; i < (n); i++) scanf( %d , B + i); map<int, int> M; for (int i = 0; i < (n); i++) M[i - pos[B[i]]]++; int offset = 0; for (int i = 0; i < (n); i++) { auto p = M.lower_bound(offset); int ans = INT_MAX; if (p != M.end()) ans = abs(p->first - offset); if (p != M.begin()) { --p; ans = min(ans, abs(p->first - offset)); } printf( %d n , ans); offset++; int x = i - pos[B[i]]; M[x]--; if (M[x] == 0) M.erase(x); x = (i + n) - pos[B[i]]; M[x]++; } return 0; }
#include <bits/stdc++.h> using namespace std; template <typename T> ostream &operator<<(ostream &out, const vector<T> &v) { out << { ; for (const T &a : v) out << a << , ; out << } ; return out; } template <typename S, typename T> ostream &operator<<(ostream &out, const pair<S, T> &p) { out << ( << p.first << , << p.second << ) ; return out; } const int dx[] = {0, 0, -1, 1}; const int dy[] = {-1, 1, 0, 0}; long long fpw(long long a, long long b, long long p) { long long r = 1; while (b) { if (b & 1) r = r * a % p; a = a * a % p; b /= 2; } return (long long)r; } bool check(long long p, long long d, long long a) { a %= p; if (!a) return 1; if (fpw(a, p - 1, p) != 1) return 0; if ((a = fpw(a, d, p)) == 1) return 1; while (a != 1) { if (a == p - 1) return 1; a = a * a % p; } return 0; } vector<long long> primes; bool prime(long long p) { if (p < 4) return p > 1; if (!(p & 1)) return 0; if (p <= 2000000000) { long long d = p - 1; while (!(d & 1)) d /= 2; return check(p, d, 2) && check(p, d, 325) && check(p, d, 9375) && check(p, d, 28178) && check(p, d, 450775) && check(p, d, 9780504) && check(p, d, 1795265022); } else { for (long long first : primes) { if (first * first > p) return 1; if (p % first == 0) return 0; } return 1; } } long long n; vector<long long> D; vector<long long> R, Q; void apply(long long d) { int i = ((int)(D).size()) - 1; int j = ((int)(D).size()) - 1; while (n / d != D[i]) --i; while (i >= 0) { while (D[j] > D[i] * d) --j; if (D[j] == D[i] * d) Q[j] += R[i]; --i; } } int main() { ios_base::sync_with_stdio(0); for (int i = (2); i < (1000010); ++i) if (prime(i)) primes.push_back(i); cin >> n; for (long long d = 1; d * d <= n; ++d) if (n % d == 0) { D.push_back(d); if (d * d != n) D.push_back(n / d); } sort(D.begin(), D.end()); R.resize(((int)(D).size())); Q.resize(((int)(D).size())); R[0] = 1; for (long long p : primes) { long long pk = p; bool once = 0; while (pk + 1 <= n) { if (n % (pk + 1) == 0) { once = 1; apply(pk + 1); } pk *= p; } if (once) for (int i = (0); i < (((int)(D).size())); ++i) { R[i] += Q[i]; Q[i] = 0; } } for (long long d : D) if (d - 1 > primes.back() && prime(d - 1)) { for (int i = (0); i < (((int)(D).size())); ++i) Q[i] = 0; apply(d); for (int i = (0); i < (((int)(D).size())); ++i) R[i] += Q[i]; } cout << R.back() << endl; return 0; }
#include <bits/stdc++.h> using namespace std; long long power(long long x, unsigned long long y, unsigned long long m) { if (y == 0) return 1; long long p = power(x, y / 2, m) % m; p = (p * p) % m; return (y % 2 == 0) ? p : (x * p) % m; } int32_t main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); long long n, pi, k; cin >> n >> pi >> k; long long arr[n], x, ans = 0; map<long long, long long> m; for (long long i = 0; i < n; i++) { cin >> x; arr[i] = (power(x, 4, pi) - k * x) % pi; arr[i] += pi, arr[i] %= pi; } for (long long i = n - 1; i >= 0; i--) { ans += m[arr[i]]; m[arr[i]]++; } cout << ans; return 0; }
#include <bits/stdc++.h> using namespace std; const long long N = 4000010, oo = 1e9; long long x, y, c, n; bool ok(long long t) { long long ans = 2ll * t * (t + 1ll) - 4ll * t + 1l; if (t > x) { ans -= (t - x) * (t - x); } if (t > n - x + 1) { ans -= (t - n + x - 1) * (t - n + x - 1); } if (t > y) { ans -= (t - y) * (t - y); } if (t > n - y + 1) { ans -= (t - n + y - 1) * (t - n + y - 1); } if (t > x + y) { ans += ((t - x - y) * (t - x - y + 1) / 2); } if (t > x + n - y + 1) { ans += ((t - x - n + y - 1) * (t - x - n + y - 1 + 1) / 2); } if (t > n - x + 1 + y) { ans += ((t - n + x - 1 - y) * (t - n + x - 1 - y + 1) / 2); } if (t > n - x + 1 + n - y + 1) { ans += ((t - n + x - 1 - n + y - 1) * (t - n + x - 1 - n + y - 1 + 1) / 2); } return ans >= c; } long long bsr(long long l, long long h) { long long mid; while (l < h) { mid = (l + h + 1) / 2; if (ok(mid)) { h = mid - 1; } else { l = mid; } } return h; } int main() { scanf( %lld%lld%lld%lld , &n, &x, &y, &c); long long ans = bsr(0, 1e9 + 10); printf( %lld n , ans); return 0; }
#include <bits/stdc++.h> using namespace std; using ll = long long; using ld = long double; template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); } template <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); } template <typename T> T inf; template <> constexpr int inf<int> = 1e9; template <> constexpr ll inf<ll> = 1e18; template <> constexpr ld inf<ld> = 1e30; struct yes_no : numpunct<char> { string_type do_truename() const { return Yes ; } string_type do_falsename() const { return No ; } }; int res[300010]; bool visited[300010]; vector<int> s[300010]; vector<int> g[300010]; void get_col(vector<int> &vec, int &pos, int &res) { ++res; while (pos < int(vec.size()) && vec[pos] == res) ++pos, ++res; } void dfs(int v) { vector<int> vec; for (int i : s[v]) { if (res[i] == 0) continue; vec.push_back(res[i]); } sort((vec).begin(), (vec).end()); int pos = 0, col = 0; for (int i : s[v]) { if (res[i] != 0) continue; get_col(vec, pos, col); res[i] = col; } visited[v] = true; for (int i : g[v]) { if (visited[i]) continue; dfs(i); } } int main() { locale loc(locale(), new yes_no); cout << boolalpha; cout.imbue(loc); int n, k; scanf( %d%d , &n, &k); for (int i = 0; i < (int)(n); i++) { int sz, in; scanf( %d , &sz); for (int j = 0; j < (int)(sz); j++) { scanf( %d , &in); s[i].push_back(in - 1); } } for (int i = 0; i < (int)(n - 1); i++) { int from, to; scanf( %d%d , &from, &to); --from; --to; g[from].push_back(to); g[to].push_back(from); } dfs(0); for (int i = 0; i < (int)(k); i++) chmax(res[i], 1); int num = *max_element(res, res + k); cout << num << endl; for (int i = 0; i < (int)(k); i++) { printf( %d , res[i]); if (i == k - 1) printf( n ); else printf( ); } return 0; }
#include <bits/stdc++.h> using namespace std; const long long int MOD = 1e6 + 3; const long double PI = 2 * acos(0.0); const vector<long long int> dx = {1, -1, 0, 0}; const vector<long long int> dy = {0, 0, 1, -1}; template <typename T = long long int> vector<T> ga(long long int n, bool oneIndexed = false) { vector<T> a = vector<T>(n + oneIndexed); for (long long int i = 0; i < n; i++) { T p; cin >> p; a[i + oneIndexed] = p; } return move(a); } template <typename T, typename A> void pa(vector<T, A> const &a, long long int begin = 0, long long int end = -1) { if (end == -1) end = (long long int)a.size() - 1; for (long long int i = begin; i <= end; i++) { cout << a[i] << ; } cout << n ; } template <typename T> T po(T base, T exp) { T result = 1; for (;;) { if (exp & 1) result = base; exp >>= 1; if (!exp) break; base = base; } return result; } template <typename T> T pomod(T x, T y, T mod) { T res = 1; x = x % mod; while (y > 0) { if (y & 1) res = (res * x) % mod; y = y >> 1; x = (x * x) % mod; } return res; } void solve() { long long int n; cin >> n; if (n == 0) cout << 1 << n ; else cout << pomod(3ll, n - 1, MOD); } int main(void) { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); solve(); return 0; }
#include <bits/stdc++.h> using namespace std; int main(int argc, char **argv) { int n; scanf( %d , &n); vector<int> f(n + 1, -1); vector<int> g(n + 1, -1); vector<int> h(1); int m = 0; vector<bool> b(n + 1, false); for (int i = 1; i <= n; i++) { scanf( %d , &f[i]); if (f[i] == i) { m++; h.push_back(i); g[i] = m; b[i] = true; } } for (int i = 1; i <= n; i++) { if (f[i] != i) { int to = g[f[i]]; if (b[f[i]] == false \|\| to == -1) { puts( -1 ); return 0; } g[i] = to; } } printf( %d n , m); for (int i = 1; i <= n; i++) { if (i > 1) { putchar( ); } printf( %d , g[i]); } puts( ); for (int i = 1; i <= m; i++) { if (i > 1) { putchar( ); } printf( %d , h[i]); } puts( ); return 0; }
#include <bits/stdc++.h> using namespace std; const long long int mod = 1000000007; const long long int mymax = 1e18; const long long int mymin = -1e18; const double PIE = 3.1415926536; int main() { ios_base::sync_with_stdio(0); cin.tie(0); int t, n, m, d, k, ti, lef, rit; bool ans; vector<pair<int, int> > cent; cin >> t; while (t--) { cin >> n >> m >> k; char a[n][m]; int vis[n][m]; cent.clear(); ans = true; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { cin >> a[i][j]; vis[i][j] = 0; } } for (int i = n - 1; i >= 1; i--) { for (int j = 1; j <= (m - 2); j++) { if ((a[i][j] == * ) && (a[i - 1][j - 1] == * ) && (a[i - 1][j + 1] == * )) { d = 0; ti = i - 1; lef = j - 1; rit = j + 1; while ((ti >= 0) && (lef >= 0) && (rit < m) && (a[ti][lef] == * ) && (a[ti][rit] == * )) { d++; ti--; lef--; rit++; } if (d >= k) { cent.push_back({i, j}); } } } } for (auto it : cent) { vis[it.first][it.second] = 1; ti = it.first - 1; lef = it.second - 1; rit = it.second + 1; while ((ti >= 0) && (lef >= 0) && (rit < m) && (a[ti][lef] == * ) && (a[ti][rit] == * )) { vis[ti][lef] = vis[ti][rit] = 1; ti--; lef--; rit++; } } for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if ((a[i][j] == * ) && !vis[i][j]) { ans = false; break; } } } cout << ((ans) ? YES : NO ) << n ; } return 0; }
#include <bits/stdc++.h> using namespace std; const int MOD = 1000000007; const double eps = 1e-8; const int nm = 1100005; int n, k, m, t; long long res; int cnt[nm], f[nm][23]; int POW(int x, int z) { if (z == 0) return 1; if (z == 1) return x % MOD; int u = POW(x, z >> 1); u = ((long long)u * u) % MOD; if (z % 2) u = ((long long)u * x) % MOD; return u; } int main() { int i, j, x, y, z, w; scanf( %d , &n); for (i = 1; i <= n; i++) { scanf( %d , &x); cnt[x]++; } for (i = (1 << 20) - 1; i >= 0; i--) { if (i & 1) f[i][0] = cnt[i]; else f[i][0] = cnt[i] + cnt[i + 1]; for (j = 1; j < 20; j++) { if (i & (1 << j)) f[i][j] = f[i][j - 1]; else f[i][j] = f[i][j - 1] + f[i + (1 << j)][j - 1]; } } for (i = (1 << 20) - 1; i >= 0; i--) { x = __builtin_popcount(i); if (x & 1) res -= POW(2, f[i][19]); else res += POW(2, f[i][19]); res = (res + MOD) % MOD; } cout << res; return 0; }
#include <bits/stdc++.h> using namespace std; struct edge { int u, v; }; int n, m, k, f[1000000 + 1], ans[1000000 + 1], q[1000000 + 1], lq = 0, rq = -1, cur; edge b[1000000 + 1]; vector<int> a[1000000 + 1], e[1000000 + 1]; bool remoed[1000000 + 1], removeti[1000000 + 1]; void removequeue() { int x, y; while (lq <= rq) { x = q[lq]; lq++; cur--; for (int i = 0; i < a[x].size(); i++) { y = a[x][i]; if (remoed[e[x][i]] == false) { remoed[e[x][i]] = true; f[y]--; if (f[y] < k && removeti[y] == false) { rq++; q[rq] = y; removeti[y] = true; } } } } } void removemany() { for (int i = 1; i <= n; i++) { if (f[i] < k) { rq++; q[rq] = i; removeti[i] = true; } } removequeue(); } void solve() { removemany(); for (int i = m - 1; i >= 0; i--) { ans[i] = cur; if (remoed[i] == false) { remoed[i] = true; f[b[i].u]--; f[b[i].v]--; if (f[b[i].u] < k && removeti[b[i].u] == false) { rq++; q[rq] = b[i].u; removeti[b[i].u] = true; } if (f[b[i].v] < k && removeti[b[i].v] == false) { rq++; q[rq] = b[i].v; removeti[b[i].v] = true; } } removequeue(); } for (int i = 0; i < m; i++) cout << ans[i] << n ; } void readit() { cin >> n >> m >> k; for (int i = 0; i < m; i++) { cin >> b[i].u >> b[i].v; a[b[i].u].push_back(b[i].v); a[b[i].v].push_back(b[i].u); e[b[i].u].push_back(i); e[b[i].v].push_back(i); f[b[i].u]++; f[b[i].v]++; } cur = n; } int main() { readit(); solve(); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; string s; cin >> s; for (int k = 0; k < n - 1; k++) { if (s[k] > s[k + 1]) { cout << YES << endl; cout << k + 1 << << k + 2; return 0; } } cout << NO ; return 0; }
#include <bits/stdc++.h> using namespace std; const int maxn = 1000 + 10; int main() { int c, d, n, m, k; while (scanf( %d %d , &c, &d) != EOF) { scanf( %d %d , &n, &m); scanf( %d , &k); int t = n * m - k; if (t <= 0) { printf( 0 n ); continue; } int res = t / n; int ans = min(res * n * d, res * c); ans += min(c, (t - res * n) * d); cout << ans << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; int n, m; long long a[100005], k; map<long long, long long> tr; long long getans(const long long k) { long long t1 = 1, t2 = 0, t3 = 0, t4 = 1, ans = 0; while (t2 < n) { ans += (a[t1] - a[t2]) * t3; ++t3; t2 = t1; t1 += t4 * k; t4 *= k; if (t1 > n) t1 = n; } return ans; } int main() { tr.clear(); scanf( %d , &n); for (int i = 1; i <= n; ++i) { scanf( %I64d , &a[i]); a[i] = -a[i]; } sort(a + 1, a + n + 1); a[0] = 0; for (int i = 1; i <= n; ++i) { a[i] = -a[i]; a[i] += a[i - 1]; } scanf( %d , &m); for (int i = 1; i <= m; ++i) { scanf( %I64d , &k); if (i != 1) printf( ); if (!tr.count(k)) tr[k] = getans(k); printf( %I64d , tr[k]); } printf( n ); return 0; }
#include <bits/stdc++.h> using namespace std; vector<int> cities[100000]; vector<bool> visited(100000); vector<int> t(100000), low(100000); map<pair<int, int>, int> b; int c = 0, ans = 0; void dfs(int v, int p = -1) { visited[v] = true; t[v] = low[v] = c++; for (int dest : cities[v]) { if (dest == p) continue; if (visited[dest]) { low[v] = min(low[v], t[dest]); } else { dfs(dest, v); low[v] = min(low[v], low[dest]); if (low[dest] > t[v]) { b[{v, dest}] = 1; b[{dest, v}] = 1; } else { b[{v, dest}] = 0; b[{dest, v}] = 0; } } } } vector<long long> dist(100001); void Dijkstra(int r, int e) { set<pair<int, int> > s; dist[r] = 0; s.insert({0, r}); while (!s.empty()) { pair<int, int> p = *s.begin(); s.erase(s.begin()); int x = p.first, y = p.second; if (x > dist[y]) { continue; } else if (dist[e] != INT_MAX) { return; } for (int j = 0; j < cities[y].size(); j++) { if (dist[y] + b[{y, cities[y][j]}] < dist[cities[y][j]]) { dist[cities[y][j]] = dist[y] + b[{y, cities[y][j]}]; s.insert({dist[cities[y][j]], cities[y][j]}); } } } } int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); int n, m, k; cin >> n >> m; for (int i = 0; i < m; i++) { int x, y; cin >> x >> y; cities[x - 1].push_back(y - 1); cities[y - 1].push_back(x - 1); } c = 0; t.assign(n, -1); low.assign(n, -1); visited.assign(n, false); for (int i = 0; i < n; ++i) { if (!visited[i]) { dfs(i); } } cin >> k; for (int i = 0; i < k; i++) { ans = 0; dist.assign(n, INT_MAX); int root, shop; cin >> root >> shop; Dijkstra(root - 1, shop - 1); cout << dist[shop - 1] << n ; } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int y, w, x, counter = 0; cin >> y >> w; x = max(y, w); for (int i = x; i <= 6; i++) { counter++; } if (counter == 0) cout << 0/1 ; else if (counter == 1) cout << 1/6 ; else if (counter == 2) cout << 1/3 ; else if (counter == 3) cout << 1/2 ; else if (counter == 4) cout << 2/3 ; else if (counter == 5) cout << 5/6 ; else cout << 1/1 ; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int n, sum = 0, a[101]; cin >> n; for (int i = 1; i <= n; i++) { cin >> a[i]; sum += (i - 1) * 4 * a[i]; } cout << sum; }
#include <bits/stdc++.h> using namespace std; inline long long read() { long long x = 0, f = 1; char c = getchar(); while ((c < 0 \|\| c > 9 ) && (c != - )) c = getchar(); if (c == - ) f = -1, c = getchar(); while (c >= 0 && c <= 9 ) x = x * 10 + c - 0 , c = getchar(); return x * f; } const int N = 2e5 + 10; int n, m, Ans[N]; pair<int, int> a[N], b[N]; inline long long Query(int x) { long long ret = 0; if (x < 0) { x = -x; for (register int i = (1); i <= (x); i++) ret += m - a[n - x + i].first + b[i].first, Ans[a[n - i + 1].second] = b[i].second; for (register int i = (x + 1); i <= (n); i++) ret += abs(b[i].first - a[i - x].first), Ans[a[i - x].second] = b[i].second; } else { for (register int i = (1); i <= (x); i++) ret += a[i].first + m - b[n - x + i].first, Ans[a[i].second] = b[n - x + i].second; for (register int i = (x + 1); i <= (n); i++) ret += abs(a[i].first - b[i - x].first), Ans[a[i].second] = b[i - x].second; } return ret; } int main() { m = read(), n = read(); for (register int i = (1); i <= (n); i++) a[i] = make_pair(read(), i); for (register int i = (1); i <= (n); i++) b[i] = make_pair(read(), i); sort(a + 1, a + 1 + n), sort(b + 1, b + 1 + n); int l = -n, r = n; while (l < r) { int mid = l + r >> 1; if (Query(mid) < Query(mid + 1)) r = mid; else l = mid + 1; } printf( %lld n , Query(l)); for (register int i = (1); i <= (n); i++) printf( %d , Ans[i]); }
#include <bits/stdc++.h> using namespace std; long long ma, n, i, j, temp; long long mi = 1000LL * 1000LL * 1000LL * 1000LL * 1000LL * 1000LL; int main() { cin >> n; for (i = 1; i * i * i <= n; i++) if (n % i == 0) for (j = i; j * j <= n / i; j++) if ((n / i) % j == 0) { temp = (n / i) / j; ma = max(ma, (i + 2) * (j + 2) * (temp + 1)); ma = max(ma, (i + 2) * (j + 1) * (temp + 2)); ma = max(ma, (i + 1) * (j + 2) * (temp + 2)); mi = min(mi, (i + 2) * (j + 2) * (temp + 1)); mi = min(mi, (i + 2) * (j + 1) * (temp + 2)); mi = min(mi, (i + 1) * (j + 2) * (temp + 2)); } cout << mi - n << << ma - n << endl; return 0; }
#include <bits/stdc++.h> int main() { int n; scanf( %d , &n); int i = sqrt(n); for (int i = 0; i <= 10; i++) { if (pow(2, i) == n) { printf( YES ); return 0; } } printf( NO ); return 0; }
#include <bits/stdc++.h> using namespace std; using ll = long long; using vi = vector<int>; using ii = pair<int, int>; template <typename A, typename B> ostream& operator<<(ostream& os, pair<A, B> p) { return os << { << p.first << , << p.second << } ; } const int oo = 0x3f3f3f3f; const ll OO = ll(oo) * oo; const ll M = 1e9 + 9; ll p2[100005]; int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); int n; cin >> n; int m; cin >> m; ll k = 1; for (int i = 0; i < m + 1; i++) { p2[i] = k; k <<= 1ll; k %= M; } ll ans = 1; for (int i = 0; i < n; i++) { if (p2[m] - i - 1 <= 0) { cout << 0 << endl; return 0; } ans *= (p2[m] - i - 1) % M; ans %= M; } cout << ans << endl; return 0; }
#include <bits/stdc++.h> int a[5005]; int solve(int i, int j) { int k, vans, hans, mini, s, t; vans = j - i + 1; mini = a[i]; for (k = i + 1; k <= j; k++) if (mini > a[k]) mini = a[k]; hans = mini; for (k = i; k <= j; k++) a[k] -= mini; hans = mini; for (k = i; k <= j;) { if (a[k] == 0) { k++; } else { s = k; t = s; while (t <= j && a[t] != 0) t++; hans += solve(s, t - 1); k = t; } } if (vans < hans) return vans; else return hans; } int main() { int n, i; int vans, hans; int ans; scanf( %d , &n); for (i = 1; i <= n; i++) scanf( %d , &a[i]); ans = solve(1, n); printf( %d n , ans); }
#include <bits/stdc++.h> using namespace std; #pragma GCC optimize( unroll-loops ) #pragma GCC optimize( Ofast ) #pragma GCC optimize( O3 ) const long long inf = 1e17; void bfs(int a, vector<vector<int> > &g, vector<int> &da) { int n = g.size(); queue<int> q; q.push(a); vector<bool> u(n, false); u[a] = true; da[a] = 0; while (!q.empty()) { int v = q.front(); q.pop(); for (int i = 0; i < g[v].size(); i++) { int x = g[v][i]; if (!u[x]) { u[x] = true; da[x] = da[v] + 1; q.push(x); } } } } int main() { ios_base::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr); int q; cin >> q; while (q--) { int n, m, a, b, c; cin >> n >> m >> a >> b >> c; a--; b--; c--; vector<vector<int> > g(n, vector<int>(0)); vector<long long> cost(m); for (int i = 0; i < m; i++) cin >> cost[i]; sort(cost.begin(), cost.end()); for (int i = 1; i < m; i++) cost[i] += cost[i - 1]; vector<int> da(n, 0), db(n, 0), dc(n, 0); for (int i = 0; i < m; i++) { int fr, to; cin >> fr >> to; fr--; to--; g[fr].push_back(to); g[to].push_back(fr); } bfs(a, g, da); bfs(b, g, db); bfs(c, g, dc); long long ans = inf; for (int i = 0; i < n; i++) { if (da[i] + db[i] + dc[i] - 1 > m - 1) continue; long long cur = 0; if (da[i] + db[i] + dc[i] != 0) cur += cost[da[i] + db[i] + dc[i] - 1]; if (db[i] > 0) cur += cost[db[i] - 1]; ans = min(ans, cur); } cout << ans << n ; } return 0; }
#include <bits/stdc++.h> using namespace std; int cache[1005][20][2]; int ret[1005]; int n; vector<int> ans(1005, INT_MAX); void query(vector<int> &arr) { if (!arr.empty()) { printf( %lu n , arr.size()); for (auto &x : arr) printf( %i , x); printf( n ); fflush(stdout); for (int x = 1; x <= n; x++) scanf( %i , &ret[x]); } else memset(ret, 0, sizeof ret); } int main() { scanf( %i , &n); for (int x = 2, y = 1; x < 2 * n; x = 2, y++) { vector<int> w; for (int z = 1; z <= n; z += x) for (int a = 0; a < x / 2 && z + a <= n; a++) w.push_back(z + a); query(w); for (int z = 1; z <= n; z++) cache[z][y][0] = ret[z]; w.clear(); for (int z = 1 + x / 2; z <= n; z += x) for (int a = 0; a < x / 2 && z + a <= n; a++) w.push_back(z + a); query(w); for (int z = 1; z <= n; z++) cache[z][y][1] = ret[z]; } printf( -1 n ); for (int z = 1; z <= n; z++) { for (int x = 2, y = 1; x < 2 n; x *= 2, y++) { for (int a = 0; a <= 1; a++) if (((z - 1) >> (y - 1) & 1) != a) ans[z] = min(ans[z], cache[z][y][a]); } printf( %i , ans[z]); } printf( n ); fflush(stdout); }
#include <bits/stdc++.h> using namespace std; const int N = 110000; int a[N], wei[N], r1, r2; bool can[N], ans[N]; int n, m; int main() { int t; scanf( %d , &t); while (t--) { scanf( %d%d , &n, &m); n--; for (int i = (1); i <= (int)m; i++) { scanf( %d , &a[i]); wei[i] = a[i]; ans[i] = 0; can[i] = 1; } r1 = r2 = 0; int shiwang = 0; for (int i = (1); i <= (int)n; i++) { int x, y; scanf( %d%d , &x, &y); if (y == 1) { if (!shiwang) shiwang = i; } if (!shiwang && x == 0) r1++; if (x == 0) r2++; if (shiwang) can[x] = 0; a[x]--; if (!shiwang) wei[x]--; } if (!shiwang) { for (int i = (1); i <= (int)m; i++) if (a[i] <= r2) printf( Y ); else printf( N ); printf( n ); } else { int lu = 0; for (int i = (1); i <= (int)m; i++) if (can[i] && wei[i] <= r1) { ans[i] = 1; if (r2 - wei[i] > lu) lu = r2 - wei[i]; } for (int i = (1); i <= (int)m; i++) { if (a[i] <= lu) ans[i] = 1; if (ans[i]) printf( Y ); else printf( N ); } printf( n ); } } return 0; }
#include <bits/stdc++.h> using namespace std; vector<pair<long long, long long> > A, B; void getDivisors(long long x, vector<pair<long long, long long> > &X) { for (long long i = 1; i * i <= x; i++) { if (x % i) continue; X.push_back({i, x / i}); } } int main() { ios::sync_with_stdio(0); cin.tie(NULL), cout.tie(NULL); long long a, b; cin >> a >> b; long long area = a + b; getDivisors(a, A); getDivisors(b, B); long long lim = 0; while (lim * lim <= area) lim++; for (long long i = lim - 1; i >= 1; i--) { if (area % i) continue; int f = 0; long long x = i; long long y = area / i; int ptr = lower_bound(A.begin(), A.end(), make_pair(x + 1, 0LL)) - A.begin(); if (ptr > 0 && A[ptr - 1].second <= y) f = 1; ptr = lower_bound(B.begin(), B.end(), make_pair(x + 1, 0LL)) - B.begin(); if (ptr > 0 && B[ptr - 1].second <= y) f = 1; if (f == 1) { cout << (x + y) * 2 << n ; return 0; } } return 0; }
#include <bits/stdc++.h> using namespace std; const int maxn = 60; vector<int> adj[maxn]; int n, m; void read() { scanf( %d%d , &n, &m); for (int i = 0; i < m; i++) { int a, b; scanf( %d%d , &a, &b); a--, b--; adj[a].push_back(b); adj[b].push_back(a); } } bool vis[maxn]; vector<int> ch; void dfs(int v) { vis[v] = 1; ch.push_back(v); for (int i = 0; i < int(adj[v].size()); i++) { int nxt = adj[v][i]; if (!vis[nxt]) dfs(nxt); } } void solve() { memset(vis, 0, sizeof(vis)); if (m > n) { puts( NO ); return; } else if (m == n) { dfs(0); for (int i = 0; i < n; i++) { if (!vis[i] \|\| int(adj[i].size()) != 2) { puts( NO ); return; } } puts( YES n0 ); return; } else { for (int i = 0; i < n; i++) { if (int(adj[i].size()) > 2) { puts( NO ); return; } } set<pair<int, int> > line; for (int i = 0; i < n; i++) { if (vis[i]) continue; if (int(adj[i].size()) == 0) { line.insert(make_pair(i, i)); vis[i] = 1; } if (int(adj[i].size()) == 1) { ch.clear(); dfs(i); line.insert(make_pair(ch.front(), ch.back())); } } for (int i = 0; i < n; i++) { if (!vis[i]) { puts( NO ); return; } } vector<pair<int, int> > ans; while (int(line.size())) { if (int(line.size()) == 1) { ans.push_back(line.begin()); line.erase(line.begin()); } else { pair<int, int> a = line.begin(); line.erase(line.begin()); pair<int, int> b = *line.begin(); line.erase(line.begin()); ans.push_back(make_pair(a.first, b.first)); line.insert( make_pair(min(a.second, b.second), max(a.second, b.second))); } } puts( YES ); printf( %d n , int(ans.size())); for (int i = 0; i < int(ans.size()); i++) { printf( %d %d n , ans[i].first + 1, ans[i].second + 1); } } } int main() { read(); solve(); }
#include <bits/stdc++.h> using namespace std; vector<int> ed[2000]; int sho[1200][1200]; int col[1200]; int n, m; int makk[1200]; int sp[1200]; void dfs(int v, int ccc) { sp[v] = ccc; for (int a = 0; a < ed[v].size(); a++) { if (sp[ed[v][a]] == -1) dfs(ed[v][a], ccc); } } void getsho(int v) { int q[3000]; int dp[3000]; int c[3000]; for (int a = 0; a < n; a++) c[a] = -1; q[0] = v; dp[0] = 0; c[v] = 1; int bb = 0; int ee = 0; while (bb <= ee) { int vx = q[bb]; sho[v][vx] = dp[bb]; for (int a = 0; a < ed[vx].size(); a++) { if (c[ed[vx][a]] == -1) { int vu = ed[vx][a]; c[vu] = 1; ee++; q[ee] = vu; dp[ee] = dp[bb] + 1; } } bb++; } } int isok; void kolo(int v, int c) { col[v] = c; for (int a = 0; a < ed[v].size(); a++) { if (col[ed[v][a]] == c) isok = 0; else if (col[ed[v][a]] == -1) kolo(ed[v][a], 1 - c); } } int main() { cin >> n >> m; for (int a = 0; a < 1200; a++) makk[a] = 0; isok = 1; int x, y; for (int a = 0; a < n; a++) for (int b = 0; b < n; b++) sho[a][b] = 1000000; for (int a = 0; a < m; a++) { cin >> x >> y; ed[x - 1].push_back(y - 1); ed[y - 1].push_back(x - 1); } for (int a = 0; a < 1100; a++) col[a] = -1; kolo(0, 0); if (!isok) { cout << -1; return 0; } for (int a = 0; a < n; a++) sp[a] = -1; int ccc = -1; for (int a = 0; a < n; a++) { if (sp[a] == -1) { ccc++; dfs(a, ccc); } } for (int a = 0; a < n; a++) getsho(a); int mini = 0; for (int a = 0; a < n; a++) { for (int b = a + 1; b < n; b++) { if (sp[a] == sp[b] && sho[a][b] > makk[sp[a]] && sho[a][b] < 100000) makk[sp[a]] = sho[a][b]; } } int ss = 0; for (int a = 0; a < 1200; a++) ss += makk[a]; cout << ss; return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 300 * 1000 + 20; int n, a[N]; multiset<int> e; long long ans; int main() { ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0); cin >> n; for (int i = 0; i < n; i++) cin >> a[i]; for (int i = 0; i < n; i++) { if (e.size()) if (e.begin() < a[i]) { ans += a[i] - e.begin(); e.erase(e.begin()); e.insert(a[i]); } e.insert(a[i]); } return cout << ans << endl, 0; }
#include <bits/stdc++.h> using namespace std; inline long long max2(long long a, long long int b) { return (a) > (b) ? (a) : (b); } inline long long max3(long long a, long long b, long long c) { return (a) > (b) ? ((a) > (c) ? (a) : (c)) : ((b) > (c) ? (b) : (c)); } inline long long min2(long long a, long long b) { return (a) < (b) ? (a) : (b); } inline long long min3(long long a, long long b, long long c) { return (a) < (b) ? ((a) < (c) ? (a) : (c)) : ((b) < (c) ? (b) : (c)); } using namespace std; const long long modu = 998244353; long long dr8[] = {0, 0, 1, -1, 1, 1, -1, -1}; long long dc8[] = {1, -1, 0, 0, -1, 1, -1, 1}; long long dr4[] = {0, 1, -1, 0}; long long dc4[] = {1, 0, 0, -1}; inline void deb_vi(vector<long long> a) { for (long long i = 0; i < a.size(); i++) cout << a[i] << ; } inline void deb_vll(vector<long long> a) { for (long long i = 0; i < a.size(); i++) cout << a[i] << ; } inline bool is_palindrome(const string& s) { return std::equal(s.begin(), s.end(), s.rbegin()); } using namespace std::chrono; long long power(long long a, long long b) { long long result = 1; while (b) { if (b & 1) result = result * a % modu; a = (a * a) % modu; b /= 2; result %= modu; } return result; } long long fun1(string s) { long long ans = 0; long long l = s.length() - 1; long long exp = 0; for (long long i = l; i >= 0; i--) { ans = (s[i] - 0 ) % modu * power(10, exp) + ans; ans %= modu; exp += 2; } return ans % modu; } long long fun2(string s) { long long ans = 0; long long l = s.length() - 1; long long exp = 1; for (long long i = l; i >= 0; i--) { ans = (s[i] - 0 ) % modu * power(10, exp) + ans; ans %= modu; exp += 2; } return ans % modu; } int32_t main() { auto start = high_resolution_clock::now(); { long long n; cin >> n; string a[n]; long long ans = 0; for (long long i = 0; i < n; i++) { cin >> a[i]; long long t1 = fun1(a[i]) * n; t1 %= modu; long long t2 = fun2(a[i]) * n; t2 %= modu; ans += (t1 + t2); ans %= modu; } cout << (ans + modu) % modu; } auto stop = high_resolution_clock::now(); auto duration = duration_cast<microseconds>(stop - start); return 0; }
#include<iostream> #include<algorithm> #include<vector> #include<bitset> #include<time.h> using namespace std; #define R register int bitset<200000>S[60]; bool c[60]; int main(){ srand(time(0)); int n,m,p,q; cin>>n>>m>>p; q=n-1>>1; string s; for(R i=0;i!=n;i++){ cin>>s; for(R j=0;j!=m;j++){ if(s[j]== 1 ){ S[j][i]=1; } } } vector<int>A,E; for(int i=0;i!=m;i++){ c[i]=false; if(S[i].count()>q){ A.push_back(i); } } if(A.empty()==true){ for(R i=0;i!=m;i++){ cout<<0; } return 0; } p=0; while(clock()<2950){ bitset<200000>B=S[A[p]]; vector<int>C,D; D.push_back(A[p]); for(R i=A.size()-1;i!=-1;i--){ if(i!=p){ C.push_back(A[i]); } } random_shuffle(C.begin(),C.end()); for(vector<int>::iterator T=C.begin();T!=C.end();T++){ if((B&S[T]).count()>q){ B&=S[T]; D.push_back(T); } } if(D.size()>E.size()){ E=D; } p++; if(p==A.size()){ p=0; } } for(vector<int>::iterator T=E.begin();T!=E.end();T++){ c[T]=true; } for(R i=0;i!=m;i++){ if(c[i]==true){ cout<<1; }else{ cout<<0; } } return 0; }
#include <bits/stdc++.h> using namespace std; const long long MOD = 998244353; const long long INF = 1000000000; void solve() { long long n; string s; cin >> n; vector<long long> p(n); vector<long long> ans(n); for (int i = 0; i < n; i++) { long long x; cin >> x; p[--x] = i; } cin >> s; long long ones = 1; long long nuls = 1; for (long long i = 0; i < n; i++) if (s[i] == 0 ) ++nuls; for (long long i = 0; i < n; i++) { if (s[p[i]] == 0 ) { ans[p[i]] = ones; ++ones; } else { ans[p[i]] = nuls; ++nuls; } } for (long long i = 0; i < n; i++) cout << ans[i] << ; cout << endl; } int main(void) { ios_base::sync_with_stdio(false); cin.tie(nullptr); int t; cin >> t; while (t--) solve(); return 0; }
#include <bits/stdc++.h> using namespace std; #define send {ios_base::sync_with_stdio(false);} #define help {cin.tie(NULL);} #define f first #define s second #define pb push_back #define vi vector<long long> #define vii vector<pair<long long,long long>> #define dict unordered_map<long long, long long> #define contains(d,x) (d.find(x)!=d.end()) typedef long long ll; typedef long double lld; typedef unsigned long long ull; const lld pi = 3.14159265358979323846; const ll mod = 1000000007; // const ll mod = 998244353; ll n, m, k, l, p, q, r, x, y, z, sz; const ll template_array_size = 1e6 + 5; ll a[template_array_size]; ll b[template_array_size]; ll c[template_array_size]; string s, t; ll ans = 0; ll ts[5000000]; ll power(int x, int y){ if(!y) return 1; ll temp = power(x, y/2); temp = (temptemp)%mod; if(y&1){ return (tempx)%mod; } return temp; } int find(int i, ll rep[]) { int t = i; while(rep[i]!=i){ i = rep[i]; } while(rep[t]!=t){ t = rep[t]; rep[t] = i; } return i; } int onion(int i, int j, ll rep[]){ i = find(i,rep); j = find(j,rep); rep[j] = i; return i!=j; } void solve(int tc = 0) { cin >> n >> m; vector<vii> adj(m+1); vi chosen; for(int i=0; i<m+1; i++) a[i] = i; for(int i=0; i<n; i++) { cin >> x; if (x==1) { cin >> y; x = 0; } else { cin >> x >> y; } if(onion(x,y,a)){ chosen.pb(i+1); } } p = chosen.size(); ans = power(2,p); cout << ans << << p << endl; for(int i : chosen) cout << i << ; cout << endl; } int main() { send help // int tc = 1; // cin >> tc; // for (int t = 0; t < tc; t++) solve(t); solve(); }
#include <bits/stdc++.h> int main() { int n, k, s = 0; scanf( %d%d , &n, &k); int a[n]; for (int i = 0; i < n; i++) { scanf( %d , &a[i]); } for (int j = 0; j < n; j++) { if (n == k && a[j] >= a[k - 1] && a[j] > 0) s++; else if (a[j] >= a[k - 1] && a[j] > 0) s++; } printf( %d , s); }
#include <bits/stdc++.h> using namespace std; int a, b, m[1000]; int s = 0; int main() { int n; cin >> n; int z = n; while (n > 0) { s = 0; cin >> a >> b; while (a > 0 && b > 0) { if (a >= b) { int t = a / b; a = a % b; s += t; } else { int t = b / a; b = b % a; s += t; } } m[z - n + 1] = s; --n; } int j; for (j = 1; j <= z; ++j) cout << m[j] << endl; }
#include <bits/stdc++.h> using namespace std; void doRoutine() { ios_base::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr); srand(322179); } const int C = 5010; int tr[C * 8]; bool cross(pair<pair<int, int>, int> hor, pair<int, pair<int, int> > vert) { return (vert.second.first <= hor.second && hor.second <= vert.second.second) && (hor.first.first <= vert.first && vert.first <= hor.first.second); } void init() { for (int i = 0; i < C * 8; ++i) { tr[i] = 0; } } int get(int l, int r, int lb = -C, int rb = C, int v = 0) { if (l == lb && r == rb) { return tr[v]; } else { int mb = (lb + rb) / 2; if (r <= mb) { return get(l, r, lb, mb, v * 2 + 1); } else if (l >= mb) { return get(l, r, mb, rb, v * 2 + 2); } else { return get(l, mb, lb, mb, v * 2 + 1) + get(mb, r, mb, rb, v * 2 + 2); } } } void add(int i, int x, int lb = -C, int rb = C, int v = 0) { if (lb + 1 == rb) { tr[v] += x; } else { int mb = (lb + rb) / 2; if (i < mb) { add(i, x, lb, mb, v * 2 + 1); } else if (i >= mb) { add(i, x, mb, rb, v * 2 + 2); } tr[v] = tr[v * 2 + 1] + tr[v * 2 + 2]; } } signed main() { doRoutine(); int n; cin >> n; vector<pair<int, pair<int, int> > > verts; vector<pair<pair<int, int>, int> > hors; for (int i = 0; i < n; ++i) { int x1, y1, x2, y2; cin >> x1 >> y1 >> x2 >> y2; if (x1 > x2) { swap(x1, x2); } if (y1 > y2) { swap(y1, y2); } if (x1 == x2) { verts.push_back({x1, {y1, y2}}); } else { hors.push_back({{x1, x2}, y1}); } } sort(verts.begin(), verts.end()); long long ans = 0; for (int i = 0; i < verts.size(); ++i) { vector<pair<int, int> > events; for (auto seg : hors) { if (cross(seg, verts[i])) { events.push_back({seg.first.second, seg.second}); } } if (!events.empty()) { sort(events.begin(), events.end()); reverse(events.begin(), events.end()); int ptr = 0; init(); for (int j = (int)verts.size() - 1; j > i; --j) { while ((ptr < events.size() && events[ptr].first >= verts[j].first)) { add(events[ptr].second, 1); ++ptr; } int cnt = get(verts[j].second.first, verts[j].second.second + 1); ans += cnt * (cnt - 1) / 2; } } } cout << ans << endl; return 0; }
#include <bits/stdc++.h> using namespace std; #pragma GCC target( sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native ) #pragma GCC optimize( unroll-loops ) #pragma GCC optimize( Ofast ) #pragma GCC optimize( O3 ) #pragma GCC target( avx ) const long long INF = numeric_limits<long long>::max(); const long double PI = 3.1415926535898; const long long MOD = 1000000007; const long long LIM = 100005; long long fpow(long long x, long long y) { long long temp; if (y == 0) return 1; temp = fpow(x, y / 2); if (y % 2 == 0) return temp * temp; else return x * temp * temp; } long long gcd(long long a, long long b) { if (b == 0) return a; return gcd(b, a % b); } bool isPrime(long long n) { if (n <= 1) return false; if (n <= 3) return true; if (n % 2 == 0 \|\| n % 3 == 0) return false; for (long long i = 5; i * i <= n; i = i + 6) if (n % i == 0 \|\| n % (i + 2) == 0) return false; return true; } long long modInverse(long long n, long long p) { return fpow(n, p - 2); } map<long long, long long> primeFactors(long long n) { map<long long, long long> mp; while (n % 2 == 0) { if (mp.count(2) == 1) mp[2]++; else mp.insert({2, 1}); n = n / 2; } for (long long i = 3; i <= sqrt(n); i = i + 2) { while (n % i == 0) { if (mp.count(i) == 1) mp[i]++; else mp.insert({i, 1}); n = n / i; } } if (n > 2) { if (mp.count(n) == 1) mp[n]++; else mp.insert({n, 1}); } return mp; } int32_t main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); long long t; cin >> t; for (long long tt = 1; tt <= t; ++tt) { long long n, ans = 0; cin >> n; vector<long long> t(n + 1); for (long long i = 1; i <= n; i++) cin >> t[i]; t[0] = 0; sort(t.begin(), t.end()); ; long long dp[n + 1][2 * n + 1]; for (long long i = 0; i <= n; i++) for (long long j = 0; j <= 2 * n; j++) dp[i][j] = INF; for (long long i = 0; i <= 2 * n; i++) dp[0][i] = 0; for (long long i = 1; i <= n; i++) { for (long long j = i; j <= 2 * n; j++) { dp[i][j] = min(dp[i][j - 1], dp[i - 1][j - 1] + abs(t[i] - j)); } } ans = dp[n][2 * n]; cout << ans << n ; } return 0; }
#include <bits/stdc++.h> using namespace std; char str[11][11]; int f[8][20][20]; int dx[] = {0, 1, -1, -1, 1, 1, 0, -1}, dy[] = {-1, -1, -1, 0, 0, 1, 1, 1}; bool check() { memset(f, 0, sizeof f); for (int i = 1; i <= 10; i++) for (int j = 1; j <= 10; j++) { if (str[i][j] != X ) continue; for (int k = 0; k < 4; k++) f[k][i][j] = f[k][i + dy[k]][j + dx[k]] + 1; } for (int i = 10; i >= 1; i--) for (int j = 10; j >= 1; j--) { if (str[i][j] != X ) continue; for (int k = 4; k < 8; k++) f[k][i][j] = f[k][i + dy[k]][j + dx[k]] + 1; } for (int i = 1; i <= 10; i++) for (int j = 1; j <= 10; j++) for (int k = 0; k < 8; k++) if (f[k][i][j] >= 5) return 1; return 0; } int main() { for (int i = 1; i <= 10; i++) scanf( %s , str[i] + 1); for (int i = 1; i <= 10; i++) for (int j = 1; j <= 10; j++) { if (str[i][j] != . ) continue; str[i][j] = X ; if (check()) { puts( YES ); return 0; } str[i][j] = . ; } puts( NO ); return 0; }
#include <bits/stdc++.h> using namespace std; int n, k, l, r, mid, a; int main() { cin >> n >> k; a = 240 - k; l = 0; r = n + 1; while (r - l > 1) { mid = (r + l) / 2; if (5 * (mid * (mid + 1) / 2) > a) { r = mid; } else { l = mid; } } cout << l << endl; return 0; }
//Saptak_Roy_Turja #include<bits/stdc++.h> #define ll long long int using namespace std; int main() { int t; cin>>t; while(t--){ ll n,a,b,c=1,i; string s; cin>>n>>a>>b>>s; for(i=1;i<n;i++){ if(s[i]!=s[i-1]){ c++; } } if(b>=0){ cout<<n(a+b)<< n ; } else { cout<<na+b*(c/2+1)<< n ; } } }
#include <bits/stdc++.h> using namespace std; long long n, k, l, r, mid, ans; long long a[200100]; bool check(long long x) { long long p, q; double sum = 0, s; for (long long i = 1; i <= n; i++) { if (a[i] == 0) continue; s = a[i]; if (a[i] >= k) return 1; p = x - 1; q = n - i + x - 1; p = min(p, q - p); while (p) { s = s * q / p; p--; q--; if (s >= k) return 1; } sum += s; if (sum >= k) return 1; } return 0; } int main() { scanf( %I64d%I64d , &n, &k); for (int i = 1; i <= n; i++) { scanf( %I64d , &a[i]); if (a[i] >= k) { puts( 0 ); return 0; } } l = 1; r = k; while (l <= r) { mid = (l + r) >> 1; if (check(mid)) { ans = mid; r = mid - 1; } else l = mid + 1; } printf( %I64d n , ans); return 0; }
#include <bits/stdc++.h> using namespace std; const string yno[2] = { NO n , YES n }; int dem(vector<int> &a, int k) { return upper_bound(a.begin(), a.end(), k) - lower_bound(a.begin(), a.end(), k); } int dem(long long k) { int ans = 0; while (k) { ans += k & 1; k >>= 1; } return ans; } void process() { int n, m; cin >> n >> m; vector<int> a(n), b(m); for (int &i : a) cin >> i; for (int &i : b) cin >> i; vector<pair<long long, long long> > c; map<int, pair<long long, long long> > M; for (int i = 0; i <= n - 1; i++) { for (int j = 0; j <= m - 1; j++) { M[a[i] + b[j]].first \|= (1ll << i); M[a[i] + b[j]].second \|= (1ll << j); } } for (auto it = M.begin(); it != M.end(); it++) { c.push_back(it->second); } int ans = 0; for (int i = 0; i < c.size(); i++) { for (int j = i; j < c.size(); j++) { ans = max(ans, __builtin_popcountll(c[i].first \| c[j].first) + __builtin_popcountll(c[i].second \| c[j].second)); } } cout << ans; } int main() { ios_base::sync_with_stdio(false); cin.tie(0); process(); return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 252; int dis(int x1, int y1, int x2, int y2) { return abs(x1 - x2) + abs(y1 - y2); } bool Gao(int x1, int y1, int x2, int y2) { if (dis(0, 0, x1, y1) <= max(x2, y2)) return true; for (int i = 1; i <= min(x2, y2); ++i) { if (dis(x2 - i, y2 - i, x1, y1) <= i) return true; } return false; } int main() { int x1, x2, y1, y2; while (cin >> x1 >> y1 >> x2 >> y2) { if (Gao(x1, y1, x2, y2)) cout << Polycarp << endl; else cout << Vasiliy << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; int n, p[1005]; vector<int> T; bool ok; inline void enter() { cin >> n; for (int i = 1; i <= n; i++) cin >> p[i]; } void dfs(int u) { while (T[u] != 1) { T[u]++; u = p[u]; } cout << u << ; } inline void solve() { for (int i = 1; i <= n; i++) { T.assign(n + 4, 0); dfs(i); } } int main() { enter(); solve(); return 0; }
#include <bits/stdc++.h> using namespace std; int n, t; string s; int puc(int k, int t) { vector<int> v(n + 1, 0); v[n - 1] = (s[n - 1] == H ); for (int i = n - 2; i >= 0; --i) v[i] = v[i + 1] + (s[i] == H ); int nh = 0, ns = 0; for (int i = 0; i < int(n); ++i) { if (s[i] == H ) ++nh; else if (s[i] == S ) ++ns; } if (k + ns < nh) return 0; int zk = k; int ret = 0; int qui = -1, q = 0; for (int i = 0; i < n; ++i) { if (s[i] == S ) { ++k; --ns; } else if (s[i] == H ) { --nh; if (k > 0) --k; else if (qui == -1) { qui = i; q = 1; } else ++q; } if (nh == 0 and k >= q) { if (qui == -1 and ret < t) return true; if (ret + (i - qui) < t) return true; break; } ++ret; } k = zk; int ult = -1; int r = 0; int ans = 0; for (int i = 0; i < int(n); ++i) { if (s[i] == S ) ++k; if (k >= r and ult != -1) { ans += i - ult; if (v[i] > 0) ans += i - ult; k -= r; ult = -1; r = 0; } if (s[i] == H ) { if (k > 0) --k; else if (ult == -1) { ult = i; r = 1; } else ++r; } if (ult == -1 and v[i + 1] == 0) break; ++ans; } return (ult == -1 and ans < t); } int main() { cin >> n >> t; cin >> s; int lo = 0, hi = n, m; while (hi - lo > 5) { int m = (lo + hi) / 2; if (puc(m, t)) hi = m; else lo = m; } bool trobat = 0; if (puc(0, t)) { cout << 0 << endl; trobat = true; } for (int k = lo; !trobat and k <= hi; ++k) { if (puc(k, t)) { cout << k << endl; trobat = true; } } if (!trobat) cout << -1 << endl; }
#include <bits/stdc++.h> using namespace std; const string YES = Yes ; const string NO = No ; string solve() { int N; cin >> N; vector<int> p(N); for (int i = 0; i < (N); ++i) { cin >> p[i]; } for (int i = 0; i < (N - 1); ++i) { if (p[i] + 1 == p[i + 1]) { continue; } if (p[i] > p[i + 1]) { continue; } return NO; } return YES; } int main() { ios::sync_with_stdio(false); cin.tie(nullptr); int T; cin >> T; for (int t = 0; t < (T); ++t) { cout << solve() << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int arr[6], i, sum = 0; for (i = 0; i < 5; i++) { scanf( %d , &arr[i]); sum = sum + arr[i]; } if (sum == 0) { printf( -1 n ); } else if (sum % 5 == 0) { printf( %d , sum / 5); } else { printf( -1 ); } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { long long n, a, b, c, ans, boby, apu; cin >> n; while (n--) { cin >> a >> b >> c >> ans; boby = b - a; apu = c + ans; if (boby % apu == 0) { cout << boby / apu << endl; } else cout << -1 << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; const int oo = 1e9; const int N = 5001; const int maxxor = (1 << 13); int f[2][maxxor]; vector<int> a[N]; int cnp(int l, int r, int pos, int id) { if (l > r) return oo; int mid = (l + r) / 2; if (a[id][mid] > pos) return min(a[id][mid], cnp(l, mid - 1, pos, id)); return cnp(mid + 1, r, pos, id); } signed main() { ios::sync_with_stdio(false); cin.tie(0); int n; cin >> n; for (int i = 1; i <= n; i++) { int x; cin >> x; a[x].push_back(i); } for (int i = 0; i <= 1; i++) for (int j = 0; j < maxxor; j++) f[i][j] = oo; f[0][0] = 0; int id; vector<int> res; for (int i = 1; i < N; i++) { int now = i & 1; int back = now ^ 1; for (int j = 0; j < maxxor; j++) { f[now][j] = f[back][j]; if (a[i].size() == 0) { if (i == N - 1 && f[now][j] != oo) res.push_back(j); continue; } int pos = f[back][j ^ i]; id = cnp(0, a[i].size() - 1, pos, i); if (id != oo) f[now][j] = min(f[now][j], id); if (i == N - 1 && f[now][j] != oo) res.push_back(j); } } cout << res.size() << endl; for (int xnew : res) cout << xnew << ; return 0; }
#include <bits/stdc++.h> using namespace std; inline int add(int a, int b) { return (a + b >= 1000000007) ? a + b - 1000000007 : a + b; } inline void inc(int &a, int b) { a = add(a, b); } inline int sub(int a, int b) { return (a - b < 0) ? a - b + 1000000007 : a - b; } inline void dec(int &a, int b) { a = sub(a, b); } inline int mul(int a, int b) { return 1ll * a * b % 1000000007; } inline void grow(int &a, int b) { a = mul(a, b); } const int INV = 205555557; int phi[1000005]; int pre[1000005]; int f[1000005]; int onepre[1000005]; int twopre[1000005]; void phiCalc() { phi[0] = 0; phi[1] = 1; for (int i = 2; i <= 1000005 - 1; i++) phi[i] = i; for (int i = 2; i <= 1000005 - 1; i++) { if (phi[i] == i) { for (int j = i; j <= 1000005 - 1; j += i) phi[j] -= phi[j] / i; } } } int func(int n, int m) { int res = sub(0, INV); grow(res, n); grow(res, n + 1); grow(res, n + 2); int tres = 15; inc(tres, mul(4, mul(n, mul(n, n)))); dec(tres, mul(12, mul(n, n))); dec(tres, mul(7, n)); int ttres = mul(n, n); dec(ttres, mul(3, n)); dec(ttres, 3); grow(ttres, sub(0, 6)); grow(ttres, m); return mul(res, add(tres, ttres)); } int main() { ios_base::sync_with_stdio(false); cin.tie(0); phiCalc(); for (int i = 1; i < 1000005; i++) { for (int j = i; j < 1000005; j += i) inc(f[j], mul(i, phi[j / i])); } pre[0] = f[0]; onepre[0] = twopre[0] = 0; for (int i = 1; i < 1000005; i++) { pre[i] = add(pre[i - 1], f[i]); onepre[i] = add(onepre[i - 1], mul(i, f[i])); twopre[i] = add(twopre[i - 1], mul(mul(i, i), f[i])); } int t; cin >> t; while (t--) { int n, m; cin >> n >> m; if (n > m) swap(n, m); int ans = 0; inc(ans, pre[n]); inc(ans, twopre[n]); dec(ans, mul(2, onepre[n])); inc(ans, mul(m, mul(n, pre[n]))); dec(ans, mul(m, onepre[n])); inc(ans, mul(m, pre[n])); dec(ans, mul(n, onepre[n])); inc(ans, mul(n, pre[n])); grow(ans, 2); inc(ans, func(n, m)); cout << ans << endl; } }
#include <bits/stdc++.h> using namespace std; int read() { int f = 1, x = 0; char s = getchar(); while (s < 0 \|\| s > 9 ) { if (s == - ) f = -1; s = getchar(); } while (s >= 0 && s <= 9 ) { x = x * 10 + s - 0 ; s = getchar(); } return x * f; } int len[300 + 5]; string str[300 + 5]; bool vis[300 + 5][300 + 5]; int main() { int n = read(), Ans; for (int i = 1; i <= n; i++) { cin >> str[i]; len[i] = int(str[i].length()) + len[i - 1]; } Ans = len[n] + n - 1; for (int i = 1; i <= n; i++) { for (int j = i; j <= n; j++) { int tmp = 0; if (vis[i][j]) continue; vis[i][j] = 1; for (int t = j + 1; t <= n - j + i; t++) { bool flag = 0; for (int s = 0; s <= j - i; s++) if (str[i + s] != str[t + s]) { flag++; break; } if (!flag) tmp++, t += j - i, vis[t][t + j - i] = 1; } if (tmp != 0) { int tot = len[n] - (tmp + 1) * (len[j] - len[i - 1]) + tmp + n; Ans = min(Ans, tot); } } } printf( %d n , Ans); return 0; }
#include <bits/stdc++.h> using namespace std; const long long INF = 1e18, MAXN = 1e5 + 128, MOD = 998244353; long long binpow(long long a, long long n) { long long res = 1; while (n) { if (n & 1) res = a; a = a; n >>= 1; } return res; } long long NOD(long long NOD1, long long NOD2) { while (NOD2) { NOD1 %= NOD2; swap(NOD1, NOD2); } return NOD1; } long long NOK(long long NOK1, long long NOK2) { return NOK1 * NOK2 / NOD(NOK1, NOK2); } long long n, i1, i2; string s; char a, b; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); cin >> n >> s; a = s[0]; for (int i = 0; i < n; i++) if (a == s[i]) i1 = i; else break; b = s[n - 1]; for (int i = n - 1; i >= 0; i--) if (b == s[i]) i2 = i; else break; i2 = n - i2; if (b == a) cout << ((i1 + 2) * (i2 + 1)) % MOD; else cout << (i2 + i1 + 2) % MOD; }
#include <bits/stdc++.h> using namespace std; const int maxint = 0x7fffffff; const int minint = 0x80000000; const double eps = 1e-6; int gcd(int a, int b) { if (b == 0) return a; return gcd(b, a % b); } int max(int a, int b) { return a > b ? a : b; } int main() { int sum, d, n, a; scanf( %d , &d); scanf( %d , &n); sum = 0; while (--n) { scanf( %d , &a); sum += d - a; } scanf( %d , &a); printf( %d n , sum); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); int t, n; cin >> t; while (t--) { string A, B; cin >> n; cin >> A >> B; int f = 1; for (int i = 0; i < n; ++i) { if (A[i] > B[i]) f = 0; } if (!f) { cout << -1 << n ; continue; } int ans = 0; for (int i = 0; i < 26; ++i) { bitset<27> good; for (int j = 0; j < n; ++j) { if (A[j] == B[j]) continue; if (B[j] == char( a + i)) { good[A[j] - a ] = 1; } } ans += good.count(); for (int j = 0; j < n; ++j) { if (A[j] == B[j]) continue; if (good[A[j] - a ] == 1) A[j] = char( a + i); } } cout << ans << n ; } return 0; }
#include <bits/stdc++.h> using namespace std; const int M = 1e5 + 5; int n, k; vector<pair<int, int> > g[M]; int ans; int dp[M][2]; void dfs(int u, int Pa) { vector<pair<int, int> > ch; for (auto p : g[u]) { int v = p.first, w = p.second; if (v == Pa) continue; dfs(v, u); ch.push_back(make_pair(dp[v][0] + w, dp[v][1] + w)); } bool flag = ch.size() > 0; if (flag) { sort(ch.begin(), ch.end(), [&](pair<int, int> a, pair<int, int> b) { return a.second > b.second; }); } for (int i = 0; i < k - 1 && i < ch.size(); i++) { dp[u][1] += ch[i].second; } if (ch.size() <= k) { for (auto p : ch) { dp[u][0] += p.second; } if (flag) { sort(ch.begin(), ch.end(), [&](pair<int, int> a, pair<int, int> b) { return a.first - a.second > b.first - b.second; }); dp[u][0] += ch[0].first - ch[0].second; } } else { int max_val = -1e9; for (int i = k; i < ch.size(); i++) { max_val = max(max_val, ch[i].first); } int sum = 0; for (int i = 0; i < k; i++) { sum += ch[i].second; } for (int i = 0; i < k; i++) { dp[u][0] = max(dp[u][0], sum - ch[i].second + max(max_val, ch[i].first)); } } } int main() { scanf( %d%d , &n, &k); for (int i = 1; i < n; i++) { int u, v, c; scanf( %d%d%d , &u, &v, &c); u++, v++; g[u].push_back(make_pair(v, c)); g[v].push_back(make_pair(u, c)); } dfs(1, 0); printf( %d n , dp[1][0]); }
#include <bits/stdc++.h> using namespace std; const int N = 100002; int arr[N], n, inc[N], decr[N]; int tree[4 * N]; int update(int pos, int l, int r, int x, int v) { if (l > x \|\| r < x) return tree[pos]; if (l == r) return tree[pos] = max(tree[pos], v); int mid = (l + r) / 2; return tree[pos] = max(update(pos * 2, l, mid, x, v), update(pos * 2 + 1, mid + 1, r, x, v)); } int get(int pos, int l, int r, int qLow, int qHigh) { if (l > qHigh \|\| r < qLow) return 0; if (l >= qLow && r <= qHigh) return tree[pos]; int mid = (l + r) / 2; return max(get(pos * 2, l, mid, qLow, qHigh), get(pos * 2 + 1, mid + 1, r, qLow, qHigh)); } int bitonic() { int i, max; inc[1] = 1; update(1, 0, n, arr[1], 1); for (i = 2; i <= n; i++) { int x = get(1, 0, n, 0, arr[i]); inc[i] = x + 1; update(1, 0, n, arr[i], inc[i]); } memset(tree, 0, sizeof tree); decr[n] = 1; update(1, 0, n, arr[n], 1); for (i = n - 1; i > 0; i--) { int x = get(1, 0, n, 0, arr[i]); decr[i] = x + 1; update(1, 0, n, arr[i], decr[i]); } max = 0; for (i = 0; i <= n; i++) if (inc[i] + decr[i] - 1 > max) max = inc[i] + decr[i] - 1; return max; } int main() { int a, b; scanf( %d%d , &a, &n); for (int i = 0; i < a; i++) { int x, y; scanf( %d%d , &x, &y); arr[x]++, arr[y + 1]--; } for (int i = 1; i <= n; i++) arr[i] += arr[i - 1]; printf( %d , bitonic()); return 0; }
#include <bits/stdc++.h> int main() { char s[50]; scanf( %s , s); int i, l = strlen(s), flag = 0; for (i = 0; i < l; i++) { if (s[i] != s[l - i - 1]) flag++; } if (flag == 2) printf( YES ); else if (flag == 0 && strlen(s) % 2 == 1) printf( YES ); else printf( NO ); return 0; }
#include <bits/stdc++.h> using namespace std; long long l, r, f[100]; bool check(string s, int x, int y) { if (s.size() % x != 0) return false; for (int i = 0; i + x < s.size() and i + x < y + 1; i++) if (s[i] != s[i + x]) return false; return true; } long long p(int x) { long long ans = 0; for (int i = 1; i <= x; i++) if (x % i == 0) { f[i] = pow(2, i - 1); } for (int j = 1; j < x; j++) { if (x % j != 0) continue; ans += f[j]; for (int u = j * 2; u < x; u += j) f[u] -= f[j]; } return ans; } long long solve(long long a) { long long ans = 0; string s = ; while (a) { s += (a % (long long)2) + 0 ; a /= (long long)2; } reverse(s.begin(), s.end()); bool no = 0; for (int i = 1; i < s.size(); i++) { if (check(s, i, 100000)) { no = 1; } } for (int i = 1; i < s.size(); i++) { if (s[i] == 0 ) continue; s[i] = 0 ; for (int j = 1; j <= i; j++) { f[j] = check(s, j, i); } for (int j = i + 1; j < s.size(); j++) f[j] = pow(2, j - i - 1); s[i] = 1 ; for (int j = 1; j < s.size(); j++) { if (s.size() % j != 0) continue; ans += f[j]; for (int u = j * 2; u < s.size(); u += j) f[u] -= f[j]; } } for (int i = s.size() - 1; i >= 1; i--) ans += p(i); ans += no; return ans; } int main() { scanf( %lld%lld , &l, &r); printf( %lld , solve(r) - solve(l - 1)); }
#include <bits/stdc++.h> long long z; int l, r, i, j, k, ans; short p; std::vector<short> prm; std::vector<int> to; short dp[3000111]; bool done[3000111]; void dfs(long long now, char cnt) { to.push_back(now); for (; cnt < prm.size() && now * prm[cnt] <= r; ++cnt) dfs(now * prm[cnt], cnt); } int main() { prm.reserve(29); to.reserve(3000111); scanf( %d %d %hd , &l, &r, &p); for (i = 2; i < p; ++i) { for (j = 2; j * j <= i; ++j) if (i % j == 0) break; if (j * j > i) prm.push_back(i); } dfs(1, 0); std::sort(to.begin(), to.end()); memset(dp, 0x3f, sizeof(dp)); dp[0] = 0; for (i = 2; i < p; ++i) for (j = 0, k = 1; j < to.size(); ++j) { for (z = to[j] * i; k < to.size() && to[k] < z; ++k) ; if (to[k] == z && dp[k] > dp[j] + 1) { dp[k] = dp[j] + 1; if (i + dp[k] <= p) done[k] = true; } } r = std::min(r, to.back()); for (i = 0; i < to.size() && to[i] < l; ++i) ; for (; i < to.size() && to[i] <= r; ++i) if (done[i]) ++ans; printf( %d n , ans); return 0; }
#include <bits/stdc++.h> using namespace std; const int mod = 1e9 + 7; long long N; long long fac(long long x) { long long res = 1; for (int i = 1; i <= x; ++i) res = res * i % mod; return res; } long long qpow(long long x, long long y) { long long res = 1; for (; y; x = x * x % mod, y >>= 1) if (y & 1) res = res * x % mod; return res; } int main() { scanf( %lld , &N); long long fz = fac(2 * N - 1), fm = fac(N - 1) * fac(N) % mod; printf( %lld n , (2 * fz % mod * qpow(fm, mod - 2) % mod - N + mod) % mod); return 0; }
#include <bits/stdc++.h> using namespace std; vector<vector<long long int> > dp; vector<long long int> a; long long int check(long long int l, long long int r) { if (l >= r) return 0; if (dp[l][r]) return dp[l][r]; if (l + 1 == r) { dp[l][r] = a[r]; return a[r]; } dp[l][r] = -1; for (int m = l + 1; m < r; ++m) { long long int lf = check(l, m), rt = check(m, r); if (lf > 0 && lf == rt) { dp[l][r] = lf + 1; return lf + 1; } } return dp[l][r]; } int main() { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); long long int n; cin >> n; a.resize(n + 1); for (int i = 1; i <= n; ++i) cin >> a[i]; dp.assign(n + 1, vector<long long int>(n + 1, 0)); vector<long long int> ans(n + 1, 1e9); ans[0] = 0; for (int i = 0; i < n; ++i) { for (int j = i + 1; j <= n; ++j) { if (check(i, j) > 0) ans[j] = min(ans[j], ans[i] + 1); } } cout << ans[n]; }
#include <bits/stdc++.h> using namespace std; int main() { long long n, k, B, c; cin >> n >> k >> B >> c; long long a[n]; for (int i = 0; i < n; i++) cin >> a[i]; long long x = min_element(a, a + n); for (int i = 0; i < n; i++) a[i] = a[i] - x; B = min(B, 5 c); long long ans = 1e18; for (int t = 0; t < 5; t++) { pair<long long, long long> b[n]; for (int i = 0; i < n; i++) { b[i] = {a[i], 0}; while (b[i].first % 5 != t) { b[i].first++; b[i].second += c; } b[i].first /= 5; } sort(b, b + n); priority_queue<long long> G; long long suma = 0; for (int i = 0; i < n; i++) { if (G.size() >= k - 1) { ans = min(ans, b[i].second + b[i].first * B * (k - 1) + suma); } G.push(b[i].second - b[i].first * B); suma += b[i].second - b[i].first * B; while (G.size() >= k) { suma -= G.top(); G.pop(); } } } cout << ans << n ; }
#include <bits/stdc++.h> #pragma GCC optimize( O3 ) #pragma GCC optimize( Ofast,no-stack-protector ) using namespace std; function<void(void)> ____ = []() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); }; template <typename T> vector<T> &operator<<(vector<T> &__container, T x) { __container.push_back(x); return __container; } template <typename T> ostream &operator<<(ostream &out, vector<T> &__container) { for (T _ : __container) out << _ << ; return out; } const int MAXN = 1e5 + 7; struct EDGE { int to, cap, rev; EDGE(){}; EDGE(int to, int cap, int rev) : to(to), cap(cap), rev(rev){}; }; vector<EDGE> G[MAXN]; int iter[MAXN], rk[MAXN]; void ADDEDGE(int u, int v, int cap) { G[u].push_back(EDGE(v, cap, (int)G[v].size())); G[v].push_back(EDGE(u, 0, (int)G[u].size() - 1)); } bool bfs() { memset(rk, 0, sizeof(rk)); memset(iter, 0, sizeof(iter)); rk[0] = 1; queue<int> que; que.push(0); while (!que.empty()) { int u = que.front(); que.pop(); for (auto e : G[u]) { if (!e.cap or rk[e.to]) continue; rk[e.to] = rk[u] + 1; que.push(e.to); } } return rk[MAXN - 1] != 0; } int dfs(int u, int flow) { if (u == MAXN - 1) return flow; for (int &i = iter[u]; i < (int)G[u].size(); i++) { auto &e = G[u][i]; if (!e.cap or rk[e.to] != rk[u] + 1) continue; int d = dfs(e.to, min(e.cap, flow)); if (d) { e.cap -= d; G[e.to][e.rev].cap += d; return d; } } return 0; } int Dinic() { int flow = 0; while (bfs()) { int d = dfs(0, 0x3f3f3f3f); while (d) { flow += d; d = dfs(0, 0x3f3f3f3f); } } return flow; } int n, m, idud[222][222], idlr[MAXN][222]; char g[222][222]; void solve() { scanf( %d , &n); scanf( %d , &m); int cur = 1, cnt = 0, tot = 0; for (int i = 1; i <= n; i++) scanf( %s , g[i] + 1); for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) if (g[i][j] == # ) tot++; for (int i = 1; i < n; i++) for (int j = 1; j <= m; j++) idud[i][j] = cur++; for (int i = 1; i <= n; i++) for (int j = 1; j < m; j++) idlr[i][j] = cur++; for (int i = 1; i < n; i++) for (int j = 1; j <= m; j++) if (g[i][j] == # and g[i + 1][j] == # ) ADDEDGE(0, idud[i][j], 1), cnt++; for (int i = 1; i <= n; i++) for (int j = 1; j < m; j++) if (g[i][j] == # and g[i][j + 1] == # ) ADDEDGE(idlr[i][j], MAXN - 1, 1), cnt++; for (int i = 1; i < n; i++) for (int j = 1; j <= m; j++) { if (g[i][j] == # and g[i + 1][j] == # ) { if (g[i][j - 1] == # ) ADDEDGE(idud[i][j], idlr[i][j - 1], 0x3f3f3f3f); if (g[i + 1][j - 1] == # ) ADDEDGE(idud[i][j], idlr[i + 1][j - 1], 0x3f3f3f3f); if (g[i][j + 1] == # ) ADDEDGE(idud[i][j], idlr[i][j], 0x3f3f3f3f); if (g[i + 1][j + 1] == # ) ADDEDGE(idud[i][j], idlr[i + 1][j], 0x3f3f3f3f); } } cout << tot - (cnt - Dinic()) << n ; } int main() { solve(); return 0; }
#include <bits/stdc++.h> using namespace std; inline int in() { int x, y; y = scanf( %d , &x); return x; } const int N = -1; int main() { int X = in(), d = in(); vector<long long> v; v.push_back(0); int b = 0; while (X) { if (X % 2) { v.push_back(v.back() + d); long long back = v.back(); for (int j = 0; j < b; j++) v.push_back(back + d); } X /= 2; b++; } cout << (int)v.size() - 1 << endl; for (int i = 1; i < v.size(); i++) cout << v[i] << ; cout << endl; return 0; }
#include <bits/stdc++.h> const int maxN = 2000; const unsigned int mod = 998244353; constexpr int inf = INT_MAX; class Array { public: inline const int begin() const { return data; } inline const int end() const { return endPtr; } inline void push_back(const int x) { (endPtr++) = x; } inline size_t size() const { return endPtr - data; } template <class T> inline void foreach (T fun) const { std::for_each<const int >(data, endPtr, fun); } private: int data[maxN + 10], endPtr = data; }; Array edgeIn[maxN + 10], edgeOut[maxN + 10]; int originDegree[maxN + 10], degree[maxN + 10]; inline void reset(const int n) { std::memcpy(degree, originDegree, sizeof(degree[0]) n); } void readGraph(const int n) { for (int i = 0; i < n; ++i) { static char str[maxN + 10]; std::cin >> str; for (int j = 0; j < n; ++j) if (str[j] == 1 ) { edgeIn[j].push_back(i); edgeOut[i].push_back(j); ++originDegree[i]; } } } bool isStrongConnect(const int n) { std::sort(degree, degree + n); int sum = 0; for (int i = 0; i + 1 < n; ++i) { sum += degree[i]; if (i * (i + 1) / 2 == sum) return false; } return true; } void reverseSet(const int n, const unsigned int set) { for (int i = 0; i < n; ++i) for (auto to : edgeOut[i]) if ((((set) >> (i)) & 0x01u) ^ (((set) >> (to)) & 0x01u)) { --degree[i]; ++degree[to]; } } inline bool checkSet(const int n, const unsigned int set) { reset(n); reverseSet(n, set); return isStrongConnect(n); } void reverseSingle(const int vertex) { edgeOut[vertex].foreach ([](int p) { ++degree[p]; }); edgeIn[vertex].foreach ([](int p) { --degree[p]; }); degree[vertex] = edgeIn[vertex].size(); } inline bool checkSingle(const int n, const int vertex) { reset(n); reverseSingle(vertex); return isStrongConnect(n); } unsigned int factor(const unsigned int n) { unsigned int ret = 1; for (unsigned int i = 2; i <= n; ++i) ret = (ret * i) % mod; return ret; } std::pair<int, int> enumSet(const int n) { int count = inf, solution = 0; const unsigned int msk = 1u << n; for (unsigned int i = 1; i < msk; ++i) { const int cnt = __builtin_popcount(i); if (cnt <= count && checkSet(n, i)) { if (cnt == count) ++solution; else { solution = 1; count = cnt; } } } return std::make_pair(count, count != inf ? (solution * factor(count)) % mod : 0); } std::pair<int, int> enumVertex(const int n) { int solution = 0; for (int i = 0; i < n; ++i) solution += checkSingle(n, i); return std::make_pair(1, solution); } int main() { std::ios::sync_with_stdio(false); int n; std::cin >> n; readGraph(n); reset(n); if (isStrongConnect(n)) { std::cout << 0 1 n ; return 0; } const auto [count, solution] = n <= 6 ? enumSet(n) : enumVertex(n); if (count == inf) std::cout << -1 n ; else std::cout << count << << solution << n ; return 0; }
#include <bits/stdc++.h> using namespace std; int n, branch[10001], total; int main() { cin >> n; for (int i = 0; i < n - 1; i++) { int a, b; cin >> a >> b; branch[a]++, branch[b]++; } for (int i = 1; i <= n; i++) total += branch[i] * (branch[i] - 1) / 2; cout << total << endl; }
#include <bits/stdc++.h> using namespace std; int main() { int n, ans = -1; cin >> n; int a[n], l[n], r[n]; for (int i = 0; i < n; ++i) cin >> a[i]; for (int i = 0, des = 0; i < n; ++i) { ++des; l[i] = des = min(des, a[i]); } for (int i = n - 1, des = 0; i >= 0; --i) { ++des; r[i] = des = min(des, a[i]); } for (int i = 0; i < n; ++i) ans = max(ans, min(l[i], r[i])); cout << ans << endl; }
#include <bits/stdc++.h> using namespace std; inline long long add(long long a, long long b) { return ((a % 1000000007LL) + (b % 1000000007LL)) % 1000000007LL; } inline long long mul(long long a, long long b) { return ((a % 1000000007LL) * (b % 1000000007LL)) % 1000000007LL; } inline long long sub(long long a, long long b) { return ((a % 1000000007LL) - (b % 1000000007LL) + 1000000007LL) % 1000000007LL; } void prefixInversionAndSwap(string &ss, long long x) { for (long long i = 0; i <= x; i++) { if (ss[i] == 0 ) { ss[i] = 1 ; } else { ss[i] = 0 ; } } for (long long i = 0; i <= (x / 2); i++) { swap(ss[i], ss[x - i]); } return; } void Flash() { long long n; cin >> n; string a, b; cin >> a >> b; vector<long long> ans; long long swapped = 0; long long ind = 0, nai, bbit; long long firstBit = a[0] - 0 ; for (long long i = (n - 1); i > 0; i--) { if (swapped) { nai = (a[ind - i] - 0 ); nai ^= 1; } else { nai = (a[ind + i] - 0 ); } bbit = b[i] - 0 ; if (nai != bbit) { if (nai == 1) { if (firstBit == 0) { ans.push_back(1); } ans.push_back(i + 1); if (swapped) { ind -= i; } else { ind += i; } swapped ^= 1; firstBit = (nai ^ 1); } else { if (firstBit == 1) { ans.push_back(1); } ans.push_back(i + 1); if (swapped) { ind -= i; } else { ind += i; } swapped ^= 1; firstBit = (nai ^ 1); } } } if (firstBit != (b[0] - 0 )) { ans.push_back(1); } cout << ans.size() << ; for (auto it : ans) { cout << it << ; } cout << n ; } int main(int argc, char const *argv[]) { ios::sync_with_stdio(0), cin.tie(NULL), cout.tie(NULL); ; long long t = 1; cin >> t; for (long long i = 1; i <= t; i++) { Flash(); } return 0; }
#include <bits/stdc++.h> #define int long long using namespace std; pair<int, int> extgcd(int a, int b) { if(!b) return {1, 0}; pair<int, int> val = extgcd(b, a % b); return {val.second, val.first - (a / b) * val.second}; } signed main(){ ios_base::sync_with_stdio(false); cin.tie(0); int t; cin >> t; while(t--){ int n; cin >> n; string s; cin >> s; int cnt = 0, cnt2 = 0; for(int i = 0; i < n; ++i){ if(s[i] == 1 && s[i + 1] == 1 ){ ++cnt; ++i; } else if(s[i] == 1 ){ ++cnt2; } } int ans = 1, mod = 998244353, can = n - 1 - cnt2; for(int i = n - cnt - cnt2; i > cnt; --i){ ans = i; ans %= mod; } for(int i = n - cnt - cnt - cnt2; i >= 1; --i){ ans = (extgcd(i, mod).first + mod) % mod; ans %= mod; } cout << ans << n ; } return 0; }

#include <bits/stdc++.h> using namespace std; vector<int> v1, v2, v3; int n, flag; int main() { cin >> n; int t = 0; string s1, s2; cin >> s1 >> s2; for (int i = 0; i < n; i++) { if (s1[i] == 1 && s2[i] == 0 ) v1.push_back(i + 1); if (s1[i] == 0 && s2[i] == 1 ) v1.push_back(i + 1); if (s1[i] == 1 && s2[i] == 1 ) v2.push_back(i + 1); if (s1[i] == 0 && s2[i] == 0 ) v3.push_back(i + 1); if (s2[i] == 1 ) t++; } int a = v1.size(), b = v2.size(), c = v3.size(); for (int i = 0; i <= b; i++) { int x = t - 2 * i; if (x >= 0 && n / 2 - i - x >= 0 && x <= a && n / 2 - i - x <= c) { a = x; b = i; c = n / 2 - i - x; flag = 1; } } if (flag) { for (int i = 0; i < a; i++) cout << v1[i] << ; for (int i = 0; i < b; i++) cout << v2[i] << ; for (int i = 0; i < c; i++) cout << v3[i] << ; } else cout << -1 ; return 0; }

#include <bits/stdc++.h> using namespace std; vector<string> ans; int main() { char c; string ss = ; while ((c = getchar()) != n ) { if ( a <= c && z >= c) { ss += c; continue; } else if (c == ) { if (!ss.empty()) { ans.push_back(ss); ss = ; } } else { if (!ss.empty()) { ans.push_back(ss); ss = ; } ans[ans.size() - 1] += c; } } if (!ss.empty()) ans.push_back(ss); for (int i = 0; i < ans.size(); i++) { cout << ans[i]; if (i == ans.size() - 1) cout << n ; else cout << ; } return 0; }

#include <bits/stdc++.h> using namespace std; using ll = long long; class SegTree { private: const ll NEUT = 4 * (ll)1e18; vector<ll> seg, tag; int h = 1; void apply(int i, ll v) { seg[i] += v; if (i < h) tag[i] += v; } void push(int i) { if (tag[i] == 0) return; apply(2 * i, tag[i]); apply(2 * i + 1, tag[i]); tag[i] = 0; } ll combine(ll a, ll b) { return min(a, b); } ll recGet(int a, int b, int i, int ia, int ib) { if (ib <= a || b <= ia) return NEUT; if (a <= ia && ib <= b) return seg[i]; push(i); int im = (ia + ib) >> 1; return combine(recGet(a, b, 2 * i, ia, im), recGet(a, b, 2 * i + 1, im, ib)); } void recApply(int a, int b, ll v, int i, int ia, int ib) { if (ib <= a || b <= ia) return; if (a <= ia && ib <= b) apply(i, v); else { push(i); int im = (ia + ib) >> 1; recApply(a, b, v, 2 * i, ia, im); recApply(a, b, v, 2 * i + 1, im, ib); seg[i] = combine(seg[2 * i], seg[2 * i + 1]); } } int recFind(int a, int b, ll v, int i, int ia, int ib) { if (seg[i] > v) return b; if (b <= ia || ib <= a) return b; if (ib == ia + 1) return ia; push(i); int im = (ia + ib) >> 1; int off = recFind(a, b, v, 2 * i, ia, im); if (off < b) return off; else return recFind(a, b, v, 2 * i + 1, im, ib); } public: SegTree(int n) { while (h < n) h *= 2; seg.resize(2 * h, 0); tag.resize(h, 0); } ll rangeMin(int a, int b) { return recGet(a, b + 1, 1, 0, h); } void rangeAdd(int a, int b, ll v) { recApply(a, b + 1, v, 1, 0, h); } int findNext(int a, int b, ll v) { return recFind(a, b + 1, v, 1, 0, h); } }; int main() { ios_base::sync_with_stdio(false); cin.tie(0); int n; cin >> n; vector<int> inv(n); for (int i = 0; i < n; ++i) { int v; cin >> v; inv[v - 1] = i; } int res = n - 1; SegTree seg(n); seg.rangeAdd(0, inv[n - 1], -1); for (int i = 0; i < n; ++i) { while (seg.rangeMin(0, n - 1) >= 0) { seg.rangeAdd(0, inv[res - 1], -1); --res; } cout << res + 1 << ; int q; cin >> q; seg.rangeAdd(0, q - 1, 1); } cout << n ; }

#include <bits/stdc++.h> using namespace std; const int64_t MAXN = 1000005; const int64_t MAXINT = 2147483098; const int64_t MAXLL = 9223372036854775258LL; const int64_t MOD = 1e9 + 7; void solve() { int64_t n; cin >> n; vector<int64_t> a(n + 2); for (int64_t i = 1; i < n + 1; ++i) cin >> a[i]; int64_t ans = a[1]; int64_t temp = 1; for (int64_t i = 3; i < n + 1; ++i) { if (a[i] == 1 && a[i] == a[i - 1]) temp++; else { ans += temp / 3; temp = 1; } } ans += temp / 3; cout << ans << n ; } int32_t main() { ios_base::sync_with_stdio(0); cin.tie(0); int64_t t; cin >> t; while (t--) solve(); ; return 0; }

#include <bits/stdc++.h> //#include <ext/pb_ds/assoc_container.hpp> //using namespace __gnu_pbds; using namespace std; typedef long long ll; typedef long double ld; //typedef tree<int,null_type,less<int >,rb_tree_tag,tree_order_statistics_node_update>indexed_set; template<class T1, class T2> ostream &operator <<(ostream &os, pair<T1,T2>&p); template <class T> ostream &operator <<(ostream &os, vector<T>&v); template <class T> ostream &operator <<(ostream &os, set<T>&v); template <class T1, class T2> ostream &operator <<(ostream &os, map<T1,T2>&v); #ifdef APURBA #define HERE cout<< here - <<__LINE__<< n ; #define debug(args...) { string _s = #args; replace(_s.begin(), _s.end(), , , ); stringstream _ss(_s); istream_iterator<string> _it(_ss); err(_it, args); } void err(istream_iterator<string> it) { cout<<endl; } template<typename T, typename... Args> void err(istream_iterator<string> it, T a, Args... args) { cout << *it << = << a << ; err(++it, args...); } #else #define HERE #define debug(args...) #endif const int N = 5e5 +5; const ll mod = 1e9 + 7; typedef pair<int,int> pii; struct info{ int zero , one; int lazy; info() { zero = 0; one = 0; lazy = 0; } }; struct segtree{ int n; vector<info>t; segtree(int n, string &s) { this->n = n; t.resize(n*4); build(1,0,n-1,s); } void Merge(info &node , info &l , info &r) { node.zero = l.zero + r.zero; node.one = l.one + r.one; } void build(int node, int l ,int r,string &s) { if(l==r) { if(s[l]== 0 ) { t[node].zero = 1; } else{ t[node].one = 1; } return; } int mid= (l+r)/2; build(node*2 , l, mid,s); build(node *2 +1 , mid+1, r,s); Merge(t[node], t[node*2] , t[node *2+1]); } void push_down(int node , int l, int r, int b, int mid , int e) { if(t[node].lazy==1) { t[l].zero = (mid-b+1); t[l].one = 0; t[l].lazy = 1; t[r].zero = (e-mid); t[r].one = 0; t[r].lazy = 1; t[node].lazy =0; } else if(t[node].lazy == 2) { t[l].one = (mid-b+1); t[l].zero = 0; t[l].lazy = 2; t[r].one = (e-mid); t[r].zero = 0; t[r].lazy = 2; t[node].lazy =0; } } void update(int node, int l ,int r , int i, int j, int add) { if(l>j || r<i) { return; } if(l>=i && r<=j) { if(add==0) { t[node].zero = (r-l+1); t[node].one = 0; t[node].lazy = 1; } else{ t[node].one = (r-l+1); t[node].zero = 0; t[node].lazy = 2; } return; } int mid = (l+r)/2; push_down(node, node*2, node*2+1 , l, mid, r); update(node *2 , l ,mid , i, j, add); update(node *2 +1 , mid+1 , r , i, j, add); Merge(t[node] , t[node *2] , t[node*2+1]); } void update(int l ,int r, int add) { update(1,0,n-1,l,r,add); } info query(int node, int l, int r, int i, int j) { if(l>j || r<i) { info tmp; return tmp; } if(l>=i && r<=j) { return t[node]; } int mid = (l+r)/2; push_down(node, node*2, node*2+1,l,mid,r); info x = query(node *2 , l ,mid , i, j); info y = query(node *2 +1 , mid+1 , r , i, j); info ret; Merge(ret , x, y); return ret; } pii query(int l, int r) { info ret = query(1,0,n-1,l,r); return make_pair(ret.zero , ret.one); } void show() { for(int i=0;i<n;i++) { pii tmp = query(i,i); cout<<tmp<< ; } cout<<endl; } }; void TEST_CASES(int cas) { int n,q; string s,t; cin>>n>>q>>s>>t; vector<pii>a(q); for(int i=0;i<q;i++) { int l,r; cin>>l>>r; l--; r--; a[i] = {l,r}; } segtree seg(n,t); //seg.show(); for(int i=q-1;i>=0;i--) { int l = a[i].first , r = a[i].second; int sz = (r-l+1); pii koto = seg.query(l,r); //debug(i,koto); if(koto.first*2<sz) { //HERE; seg.update(l,r,1); } else if(koto.second*2<sz) { seg.update(l,r,0); } else{ cout<< NO n ; return; } //seg.show(); } for(int i=0;i<n;i++) { int eta = s[i]- 0 ; pii bal = seg.query(i,i); if(eta==0 && bal.second==1) { cout<< NO n ; return; } else if(eta==1 && bal.first==1) { cout<< NO n ; return; } } cout<< YES n ; } /* */ int32_t main() { #ifndef APURBA ios_base::sync_with_stdio(false); cin.tie(nullptr); #endif //freopen( input.txt , r ,stdin); //freopen( out1.txt , w ,stdout); int t=1,cas=0; cin>>t; while(t--) { TEST_CASES(++cas); } return 0; } template<class T1, class T2> ostream &operator <<(ostream &os, pair<T1,T2>&p) { os<< { <<p.first<< , <<p.second<< } ; return os; } template <class T> ostream &operator <<(ostream &os, vector<T>&v) { os<< [ ; for(int i=0; i<v.size(); i++) { os<<v[i]<< ; } os<< ] ; return os; } template <class T> ostream &operator <<(ostream &os, set<T>&v) { os<< [ ; for(T i:v) { os<<i<< ; } os<< ] ; return os; } template <class T1, class T2> ostream &operator <<(ostream &os, map<T1,T2>&v) { for(auto i:v) { os<< Key : <<i.first<< , Value : <<i.second<<endl; } return os; }

#include <bits/stdc++.h> using namespace std; template <typename T, typename U> ostream& operator<<(ostream& o, const pair<T, U>& x) { o << ( << x.first << , << x.second << ) ; return o; } template <typename T> ostream& operator<<(ostream& o, const vector<T>& x) { o << [ ; int b = 0; for (auto& a : x) o << (b++ ? , : ) << a; o << ] ; return o; } template <typename T> ostream& operator<<(ostream& o, const set<T>& x) { o << { ; int b = 0; for (auto& a : x) o << (b++ ? , : ) << a; o << } ; return o; } template <typename T> ostream& operator<<(ostream& o, const multiset<T>& x) { o << { ; int b = 0; for (auto& a : x) o << (b++ ? , : ) << a; o << } ; return o; } template <typename T> ostream& operator<<(ostream& o, const unordered_set<T>& x) { o << { ; int b = 0; for (auto& a : x) o << (b++ ? , : ) << a; o << } ; return o; } template <typename T> ostream& operator<<(ostream& o, const unordered_multiset<T>& x) { o << { ; int b = 0; for (auto& a : x) o << (b++ ? , : ) << a; o << } ; return o; } template <typename T, typename U> ostream& operator<<(ostream& o, const map<T, U>& x) { o << { ; int b = 0; for (auto& a : x) o << (b++ ? , : ) << a; o << } ; return o; } template <typename T, typename U> ostream& operator<<(ostream& o, const multimap<T, U>& x) { o << { ; int b = 0; for (auto& a : x) o << (b++ ? , : ) << a; o << } ; return o; } template <typename T, typename U> ostream& operator<<(ostream& o, const unordered_map<T, U>& x) { o << { ; int b = 0; for (auto& a : x) o << (b++ ? , : ) << a; o << } ; return o; } template <typename T, typename U> ostream& operator<<(ostream& o, const unordered_multimap<T, U>& x) { o << { ; int b = 0; for (auto& a : x) o << (b++ ? , : ) << a; o << } ; return o; } int main() { ios::sync_with_stdio(0); cin.tie(0); int t; cin >> t; while (t--) { int n, k; string s; cin >> n >> k >> s; vector<int> A(n); for (int i = 0; i < n; i++) { if (s[i] == R ) A[i] = 0; if (s[i] == G ) A[i] = 1; if (s[i] == B ) A[i] = 2; } int ans = k; for (int o = 0; o < 3; o++) { int x = 0; for (int i = 0; i < k; i++) { if (A[i] != (o + i) % 3) x++; } ans = min(ans, x); for (int i = k; i < n; i++) { if (A[i - k] != (o + i - k) % 3) x--; if (A[i] != (o + i) % 3) x++; ans = min(ans, x); } } cout << ans << endl; } }

#include <bits/stdc++.h> using namespace std; int n, k; char line[100010]; vector<int> cua; int main(int argc, char *argv[]) { scanf( %d%d , &n, &k); scanf( %c , &line[0]); for (int i = 1; i <= n; i++) { scanf( %c , &line[i]); if (line[i] == 7 && line[i - 1] == 4 ) { cua.push_back(i - 1); } } int p; int cont = 0; while (!cua.empty() && cont < k) { cont += 1; p = cua[0]; if (p % 2) { line[p + 1] = 4 ; if (p + 2 <= n && line[p + 2] == 7 ) { cua[0] = p + 1; } else { cua.erase(cua.begin()); } } else { line[p] = 7 ; if ((p - 1) >= 1 && line[p - 1] == 4 ) { cua[0] = p - 1; if ((k - cont) % 2 == 1) { line[p] = 4 ; } break; } else { cua.erase(cua.begin()); } } } for (int i = 1; i <= n; i++) { printf( %c , line[i]); } return 0; }

#include <bits/stdc++.h> #pragma comment(linker, /STACK:256000000 ) using namespace std; const int INF = (int)(1e9 + 1337); const long long LINF = (long long)(4e18); const double EPS = 1e-11; const int MOD = 1000000007; const int HBASE = 1003; const int MAXN = 200500; int n, m; char s[MAXN]; pair<int, int> qu[MAXN]; int cnt[10][MAXN]; int last[MAXN][10]; int ans[MAXN]; int d[4] = {2, 0, 1, 6}; struct node { int dp[4][4]; node() { memset(dp, 0, sizeof(dp)); } }; node tre[MAXN << 2]; int get_sum(int d, int l, int r) { return cnt[d][r] - cnt[d][l - 1]; } void init() { scanf( %d%d%s , &n, &m, &s[1]); for (int i = 1; i <= m; i++) { scanf( %d%d , &qu[i].first, &qu[i].second); } } node merge(node n1, node n2) { node res; for (int i = 3; i >= 0; i--) { res.dp[i][i] = n1.dp[i][i] + n2.dp[i][i]; for (int j = i + 1; j < 4; j++) { res.dp[i][j] = INF; for (int h = i; h <= j; h++) { res.dp[i][j] = min(n1.dp[i][h] + n2.dp[h][j], res.dp[i][j]); } } } return res; } void build(int tv, int tl, int tr) { if (tl == tr) { for (int i = 0; i < 4; i++) { if (s[tl] == 0 + d[i]) { tre[tv].dp[i][i]++; } } } else { int tm = (tl + tr) >> 1; build(tv * 2, tl, tm); build(tv * 2 + 1, tm + 1, tr); tre[tv] = merge(tre[tv * 2], tre[tv * 2 + 1]); } } node get(int tv, int tl, int tr, int l, int r) { if (l > r) { return node(); } if (tl == l && tr == r) { return tre[tv]; } int tm = (tl + tr) >> 1; node la = get(tv << 1, tl, tm, l, min(r, tm)); node ra = get(tv * 2 + 1, tm + 1, tr, max(l, tm + 1), r); return merge(la, ra); } void solve() { init(); for (int i = 1; i <= n; i++) { for (int j = 0; j < 10; j++) { cnt[j][i] = cnt[j][i - 1]; } cnt[s[i] - 0 ][i]++; } for (int i = 1; i <= n + 1; i++) { for (int j = 0; j < 10; j++) { last[i][j] = last[i - 1][j]; } if (i > 0) { last[i][s[i - 1] - 0 ] = i - 1; } } build(1, 1, n); for (int i = 1; i <= m; i++) { int r = qu[i].second + 1; int p = last[r][7]; if (!p || p < qu[i].first) { ans[i] = -1; continue; } int pos[4]; pos[3] = p; for (int j = 2; j >= 0; j--) { pos[j] = last[pos[j + 1]][d[j]]; if (!pos[j] || pos[j] < qu[i].first) { ans[i] = -1; break; } } if (ans[i] != -1) { node res[6]; res[1] = get(1, 1, n, qu[i].first, pos[0] - 1); res[2] = get(1, 1, n, pos[0] + 1, pos[1] - 1); res[3] = get(1, 1, n, pos[1] + 1, pos[2] - 1); int dp[4][4]; memset(dp, 63, sizeof(dp)); memset(dp[0], 0, sizeof(dp[0])); for (int p = 1; p <= 3; p++) { for (int j = p; j < 4; j++) { for (int h = 0; h <= j; h++) { dp[p][j] = min(dp[p][j], dp[p - 1][h] + res[p].dp[h][j]); } } } ans[i] = dp[3][3] + get_sum(6, pos[2] + 1, pos[3] - 1) + get_sum(6, pos[3] + 1, qu[i].second); } } for (int i = 1; i <= m; i++) { printf( %d n , ans[i]); } } void precalc() {} int main() { srand(88); double st = clock(); precalc(); int tests = 1; for (int i = 1; i <= tests; i++) { solve(); } return 0; }

#include <bits/stdc++.h> using namespace std; int k, d; char n[100005]; int a[100005]; int main() { scanf( %d , &k); d = 0; scanf( %s , &n); for (int i = 0; i < strlen(n); i++) { d += n[i] - 0 ; a[i + 1] = n[i] - 0 ; } if (d >= k) { cout << 0; return 0; } int h = strlen(n); sort(a + 1, a + h + 1); for (int i = 1; i <= h; ++i) { d = d + 9 - a[i]; if (d >= k) { cout << i; return 0; } } return 0; }

#include <bits/stdc++.h> using namespace std; const double PI = acos(-1); const long long mod = 1e9 + 7; const long long N = 1e5 + 5, K = 105; const int si = (1 << 20); const long long add = 1e4; const long long M = 100 + 5; const double INFdb = 1e10; int n; vector<int> v[N]; bool check[N]; int legs[N]; void dfs(int u, int par) { if (v[u].size() <= 2) { check[u] = 1; for (int x : v[u]) { if (x != par) { dfs(x, u); } } } } int main() { ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(0); cin >> n; for (int i = 1; i <= n - 1; ++i) { int x, y; cin >> x >> y; v[x].push_back(y); v[y].push_back(x); } for (int i = 1; i <= n; ++i) { if ((int)v[i].size() == 1) dfs(i, 0); } for (int i = 1; i <= n; ++i) { for (int x : v[i]) { if (check[x]) { legs[i] = min(legs[i] + 1, 2); } } } for (int i = 1; i <= n; ++i) { if (!check[i]) { int cnt = 0; for (int x : v[i]) { if (!check[x] && v[x].size() - legs[x] > 1) { ++cnt; } } if (cnt > 2) { return cout << NO , 0; } } } cout << YES ; cerr << nTime elapsed: << 1000 * clock() / CLOCKS_PER_SEC << ms n ; return 0; }

#include <bits/stdc++.h> using namespace std; int N; int main() { cin >> N; if (!(N % 2)) puts( home ); else puts( contest ); return 0; }

#include <bits/stdc++.h> using namespace std; vector<vector<short>> g; vector<vector<short>> dp; short rec(int l, int r) { if (l > r) return 0; if (dp[l][r] != -1) return dp[l][r]; short whole = binary_search(begin(g[l]), end(g[l]), r); short ret = whole + rec(l + 1, r); for (auto p : g[l]) { if (p >= r) break; int val = whole + rec(l, p) + rec(p + 1, r); if (val > ret) { ret = val; } } return dp[l][r] = ret; } int main() { ios::sync_with_stdio(false); cin.tie(0); int tc; cin >> tc; while (tc--) { int n; cin >> n; vector<pair<int, int>> arr(n); vector<int> val; for (auto& pp : arr) { cin >> pp.first >> pp.second; val.push_back(pp.first); val.push_back(pp.second); } sort(begin(val), end(val)); val.erase(unique(begin(val), end(val)), end(val)); int m = int(val.size()); g = vector<vector<short>>(m); vector<short> cnt(m + 1, 0); for (auto& pp : arr) { pp.first = lower_bound(begin(val), end(val), pp.first) - begin(val); pp.second = lower_bound(begin(val), end(val), pp.second) - begin(val); cnt[pp.first]++; } for (int i = 0; i < m; i++) { g[i].resize(cnt[i]); } fill(begin(cnt), end(cnt), 0); for (auto& pp : arr) { g[pp.first][cnt[pp.first]++] = pp.second; } cnt.clear(); val.clear(); for (auto& row : g) { sort(begin(row), end(row)); row.erase(unique(begin(row), end(row)), end(row)); } dp = vector<vector<short>>(m, vector<short>(m, -1)); cout << rec(0, m - 1) << n ; } return (0); }

#include <bits/stdc++.h> using namespace std; const int MAXN = 1e5 + 5; char str[MAXN]; class Value { public: char c1, c2, last_c1, last_c2; int pos, l1, sz; Value() { c1 = 0; c2 = 0; pos = 0; l1 = 0; last_c1 = 0; last_c2 = 0; } void push_front(char c) { if (c == c1) { l1++; } else { c2 = c1; c1 = c; l1 = 1; } if (last_c2 == 0) { last_c2 = c; } else if (last_c1 == 0) { last_c1 = c; } sz++; } bool operator<(const Value &value) const { if (c1 != value.c1) { return c1 < value.c1; } char cl = c1, cr = c1; if (l1 < value.l1) { cl = c2; } else if (value.l1 < l1) { cr = value.c2; } return cl < cr; } } f[MAXN]; void print(int idx, int cnt) { for (int i = 0; i < cnt; i++) { putchar(f[idx].c1); idx = f[idx].pos + 1; } } int main() { scanf( %s , str); int len = strlen(str); f[len].pos = len; for (int i = len - 1; i >= 0; i--) { f[i] = f[i + 1]; f[i].push_front(str[i]); f[i].pos = i; if (i + 1 < len && str[i] == str[i + 1]) { f[i] = min(f[i], f[i + 2]); } } for (int i = 0; i < len; i++) { printf( %d , f[i].sz); if (f[i].sz <= 10) { print(i, f[i].sz); putchar( n ); } else { print(i, 5); printf( ...%c%c n , f[i].last_c1, f[i].last_c2); } } return 0; }

#include <bits/stdc++.h> using namespace std; const long long mod = 1e9 + 7; long long int mypow(long long int a, int b) { if (b < 0) return 0; long long int ans = 1; for (; b; b >>= 1, a = a * a % mod) { if (b & 1) ans = ans * a % mod; } return ans; } void add(long long int &a, long long int b) { a += b; if (a >= mod) a -= mod; } int main() { int n, k; cin >> n >> k; long long int dp[k + 1][k + 1]; for (int i = (0); i < (k + 1); i++) { for (int j = (0); j < (k + 1); j++) { if (i) { dp[i][j] = 0; add(dp[i][j], j * dp[i - 1][j] % mod); if (n > j) add(dp[i][j], (n - j) * dp[i - 1][j + 1] % mod); } else { dp[i][j] = mypow(2, n - j); } } } cout << dp[k][0] << endl; }

#include <bits/stdc++.h> using namespace std; double pi = acos(-1); int n; bool initial[2000][2000]; bool blur[2000][2000]; pair<int, int> direction[8] = { make_pair(1, 0), make_pair(1, 1), make_pair(0, 1), make_pair(-1, 1), make_pair(-1, 0), make_pair(-1, -1), make_pair(0, -1), make_pair(1, -1)}; pair<int, int> operator+(pair<int, int> l, pair<int, int> r) { return make_pair(l.first + r.first, l.second + r.second); } bool valid(pair<int, int> pos) { return pos.first >= 0 && pos.first < n && pos.second >= 0 && pos.second < n; } int circle(int x, int y) { vector<pair<int, int> > front(1, make_pair(x, y)); blur[x][y] = 0; for (size_t i = 0; i < front.size(); i++) for (auto m : direction) { auto next = front[i] + m; if (valid(next) && blur[next.first][next.second]) { front.push_back(next); blur[next.first][next.second] = 0; } } pair<double, double> centre = make_pair(0, 0); for (auto c : front) centre = make_pair(centre.first + 1.0 * c.first / front.size(), centre.second + 1.0 * c.second / front.size()); double radius = 0; for (auto c : front) radius = max(radius, sqrt(pow(c.first - centre.first, 2.0) + pow(c.second - centre.second, 2.0))); radius += 0.5; if (radius < 6) return 0; return 1 + (front.size() > (pow(radius, 2) * 2 + pow(radius, 2) * pi) / 2); } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cin >> n; for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) cin >> initial[i][j]; for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) { int cnt = 0; for (int di = -2; di <= 2; di++) for (int dj = -2; dj <= 2; dj++) if (i + di >= 0 && i + di < n && j + dj >= 0 && j + dj < n && initial[i + di][j + dj]) cnt++; blur[i][j] = (cnt > 5 * 5 / 2); } int squares = 0, circles = 0; for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) if (blur[i][j]) { int ret = circle(i, j); if (ret == 1) squares++; if (ret == 2) circles++; } cout << circles << << squares << n ; return 0; }

#include <bits/stdc++.h> using namespace std; const char NL = n ; long long int n; vector<long long int> a, dp; long long int s(long long int i, long long int j) { if (a[i] > a[j]) return dp[j] + 1; return 1; } void solve() { for (long long int i = 2; i < n + 1; i++) { long long int m = 1; for (long long int j = 1; (j * j <= i && j <= n); j++) { if (i % j == 0) { m = max({m, s(i, j), s(i, i / j)}); } } dp[i] = m; } cout << *max_element(dp.begin(), dp.end()) << NL; return; } int32_t main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); long long int t; cin >> t; while (t--) { cin >> n; a.assign(n + 1, 0); dp.assign(n + 1, 0); dp[1] = 1; for (long long int i = 1; i < n + 1; i++) { cin >> a[i]; } solve(); } fflush(stdin); fflush(stdout); return 0; }

#include <bits/stdc++.h> using namespace std; bool debug = 0; int n, m, k; int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0}; string direc = RDLU ; long long ln, lk, lm; void etp(bool f = 0) { puts(f ? YES : NO ); exit(0); } void addmod(int &x, int y, int mod = 1000000007) { x += y; if (x >= mod) x -= mod; } void et() { puts( -1 ); exit(0); } struct ant { long long pos; char d; void rd() { cin >> pos >> d; pos--; } bool operator<(const ant &o) const { return pos < o.pos; } } a[300105]; long long t; int ans[300105]; vector<pair<int, int> > pre; void fmain() { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); cin >> n >> m >> t; for (int(i) = 0; (i) < (int)(n); (i)++) a[i].rd(); for (int(i) = 0; (i) < (int)(n); (i)++) pre.push_back({a[i].pos, i}); sort(pre.begin(), pre.end()); long long offset = 0; for (int(i) = 0; (i) < (int)(n); (i)++) { if (a[i].d == R ) { (offset += (a[i].pos + t) / m) %= n; a[i].pos = (t + a[i].pos) % m; } else { if (t >= 1 + a[i].pos) { offset += n - 1; offset += n - (t - (a[i].pos + 1)) / m % n; offset %= n; } a[i].pos = ((long long)a[i].pos - t) % m + m; a[i].pos %= m; } } sort(a, a + n); for (int(i) = 0; (i) < (int)(n); (i)++) ans[pre[i].second] = a[(i + offset) % n].pos + 1; for (int(i) = 0; (i) < (int)(n); (i)++) cout << ans[i] << ; } int main() { fmain(); return 0; }

#include <bits/stdc++.h> int main() { int N; std::cin >> N; std::vector<int> array(N); for (int i = 0; i < N; ++i) std::cin >> array[i]; std::sort(array.begin(), array.end()); if (1 == array.back()) array[N - 1] = 2; else array[N - 1] = 1; std::sort(array.begin(), array.end()); for (int i = 0; i < N; ++i) std::cout << array[i] << ; return 0; }

#include <bits/stdc++.h> using namespace std; long long tree[4 * 1000005]; void update(int v, int l, int r, int ind) { if (l > r || l > ind || ind > r) return; if (l == r) { tree[v] = 1; return; } int mid = (l + r) / 2; update(2 * v, l, mid, ind); update(2 * v + 1, mid + 1, r, ind); tree[v] = tree[2 * v] + tree[2 * v + 1]; } long long query(int v, int l, int r, int lt, int rt) { if (l > r || l > rt || lt > r || lt > rt) return 0; if (lt <= l && r <= rt) return tree[v]; int mid = (l + r) / 2; return query(2 * v, l, mid, lt, rt) + query(2 * v + 1, mid + 1, r, lt, rt); } int n; int a; int main() { ios_base::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr); long long inv = 0; cin >> n; for (int i = 0; i < n; i++) { cin >> a; inv += query(1, 1, n, a + 1, n); update(1, 1, n, a); } if (inv % 2 == n % 2) cout << Petr n ; else cout << Um_nik n ; return 0; }

#include <bits/stdc++.h> using namespace std; const long long iinf = 1e9 + 10; const long long inf = 1ll << 60; const long long mod = 1e9 + 87; void GG() { cout << 0 n ; exit(0); } long long mpow(long long a, long long n, long long mo = mod) { long long re = 1; while (n > 0) { if (n & 1) re = re * a % mo; a = a * a % mo; n >>= 1; } return re; } long long inv(long long b, long long mo = mod) { if (b == 1) return b; return (mo - mo / b) * inv(mo % b, mo) % mo; } const long long maxn = 1e6 + 5; unsigned long long H[maxn]; bool np[maxn]; unsigned long long val[maxn]; long long n; void RET(vector<long long> no) { vector<long long> yay(n + 1); for (long long t : no) yay[t] = 1; cout << n - (long long)no.size() << n ; for (long long i = 1; i <= n; ++i) { if (!yay[i]) cout << i << ; } cout << n ; exit(0); } signed main() { ios_base::sync_with_stdio(0); cin.tie(0); ; mt19937_64 rnd(time(0)); for (long long i = 0; i < maxn; ++i) { val[i] = rnd(); } for (long long i = 2; i < maxn; ++i) { if (!np[i]) { for (long long j = i; j < maxn; j += i) { if (j != i) np[j] = 1; long long r = j; while (r % i == 0) { r /= i; H[j] ^= val[i]; } } } } cin >> n; for (long long i = 1; i < maxn; ++i) H[i] ^= H[i - 1]; unsigned long long all = 0; for (long long i = 1; i <= n; ++i) all ^= H[i]; if (all == 0) { RET({}); } for (long long i = 1; i <= n; ++i) { if (H[i] == all) { RET({i}); } } vector<pair<unsigned long long, long long> > v; for (long long i = 1; i <= n; ++i) { v.push_back({H[i], i}); } sort(v.begin(), v.end()); for (long long i = 1; i <= n; ++i) { long long at = lower_bound(v.begin(), v.end(), pair<unsigned long long, long long>{H[i] ^ all, i + 1}) - v.begin(); if (at < (long long)v.size() && (v[at].first == (H[i] ^ all))) { RET({i, v[at].second}); } } assert(n % 2 == 1); RET({n, n / 2, 2}); }

#include <bits/stdc++.h> using namespace std; string ans; map<pair<string, int>, int> dp; bool check(string second) { int mul = 1; int num = 0; int i = second.size() - 1; num = num + ((second[i] - 0 ) * 1) % 8; i--; if (second.size() > 1) { num = num + ((second[i] - 0 ) * 10) % 8; } i--; if (second.size() > 2) { num = num + ((second[i] - 0 ) * 100) % 8; } if (num % 8 == 0) { ans = second; return true; } else { return false; } } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); int n; cin >> n; int a[n]; vector<int> v[1001]; for (int i = 0; i < n; i++) { cin >> a[i]; v[a[i]].push_back(i); } vector<int> ans; for (int i = 1; i < 1001; i++) { if (v[i].size() > 0) ans.push_back(v[i][v[i].size() - 1]); } sort(ans.begin(), ans.end()); cout << ans.size() << endl; for (int i = 0; i < ans.size(); i++) { cout << a[ans[i]] << ; } return 0; }

#include <bits/stdc++.h> using namespace std; char s[5010]; int main() { scanf( %s , s); int n = (int)strlen(s); int res = 0; for (int i = 0; i < n; i++) { int mn = 0, mx = 0; for (int j = i; j < n; j++) { if (s[j] == ( ) { mn++, mx++; } else if (s[j] == ) ) { mn--, mx--; } else if (s[j] == ? ) { mn--, mx++; } if (mx < 0) break; if (mn < 0 && mn < mx) mn += 2; if (mn == 0) res++; } } printf( %d , res); return 0; }

#include <bits/stdc++.h> using namespace std; #pragma GCC optimize( Ofast ) #pragma GCC optimize( unroll-loops ) #pragma GCC target( sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native ) template <class S, class T> ostream& operator<<(ostream& os, const pair<S, T>& p) { return os << ( << p.first << , << p.second << ) ; } template <class T> ostream& operator<<(ostream& os, const vector<T>& p) { os << [ ; for (auto& it : p) os << it << ; return os << ] ; } template <class T> ostream& operator<<(ostream& os, const unordered_set<T>& p) { os << [ ; for (auto& it : p) os << it << ; return os << ] ; } template <class S, class T> ostream& operator<<(ostream& os, const unordered_map<S, T>& p) { os << [ ; for (auto& it : p) os << it << ; return os << ] ; } template <class T> ostream& operator<<(ostream& os, const set<T>& p) { os << [ ; for (auto& it : p) os << it << ; return os << ] ; } template <class T> ostream& operator<<(ostream& os, const multiset<T>& p) { os << [ ; for (auto& it : p) os << it << ; return os << ] ; } template <class S, class T> ostream& operator<<(ostream& os, const map<S, T>& p) { os << [ ; for (auto& it : p) os << it << ; return os << ] ; } template <class T> void dbs(string str, T t) { cerr << str << : << t << n ; } template <class T, class... S> void dbs(string str, T t, S... s) { long long idx = str.find( , ); cerr << str.substr(0, idx) << : << t << , ; dbs(str.substr(idx + 1), s...); } 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 ; } long long power(long long x, long long y) { long long res = 1; while (y) { if (y & 1) res = (res * x) % 1000000007; y = y / 2, x = (x * x) % 1000000007; } return res % 1000000007; } long long dp[500001][2]; vector<vector<pair<long long, long long> > > arr(500001); long long n, k; bool cmp(pair<long long, long long> a, pair<long long, long long> b) { return ((dp[a.first][1] + a.second - dp[a.first][0]) > (dp[b.first][1] + b.second - dp[b.first][0])); } void dfs(long long u, long long par) { vector<pair<long long, long long> > temp; for (auto v : arr[u]) { if (v.first != par) { dfs(v.first, u); temp.push_back(v); } } if ((long long)temp.size() == 0) return; sort(temp.begin(), temp.end(), cmp); long long ma = 0; for (long long i = 0; i < (min((long long)temp.size(), k - 1)); i++) { long long v = temp[i].first; if (dp[v][1] + temp[i].second - dp[v][0] > 0) ma += (dp[v][1] + temp[i].second); else ma += dp[v][0]; } for (long long i = k - 1; i < (long long)temp.size(); i++) ma += dp[temp[i].first][0]; dp[u][1] = ma; ma = 0; for (long long i = 0; i < (min((long long)temp.size(), k)); i++) { long long v = temp[i].first; if (dp[v][1] + temp[i].second - dp[v][0] > 0) ma += (dp[v][1] + temp[i].second); else ma += dp[v][0]; } for (long long i = k; i < (long long)temp.size(); i++) ma += dp[temp[i].first][0]; dp[u][0] = ma; } signed main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); long long t; cin >> t; while (t--) { arr.clear(); cin >> n >> k; arr.resize(n + 1); long long i; for (i = 0; i < n - 1; i++) { long long u, v, w; cin >> u >> v >> w; arr[u].push_back(make_pair(v, w)); arr[v].push_back(make_pair(u, w)); } for (i = 0; i <= n; i++) dp[i][0] = 0, dp[i][1] = 0; dfs(1, 0); cout << max(dp[1][0], dp[1][1]) << n ; } }

#include <bits/stdc++.h> using namespace std; const int N = 1e5 + 5, INF = 1e9; struct T { int l, r, d[3], mn[3], mx[3]; } t[N]; int n, m, q, a, b, c, lx, rx, ly, ry, lz, rz, rt, h[N], D; inline bool cmp(int a, int b) { return t[a].d[D] < t[b].d[D]; } inline void update(int x) { int l = t[x].l, r = t[x].r; for (int i = 0; i < 3; i++) { t[x].mn[i] = t[x].mx[i] = t[x].d[i]; if (l) t[x].mn[i] = min(t[x].mn[i], t[l].mn[i]), t[x].mx[i] = max(t[x].mx[i], t[l].mx[i]); if (r) t[x].mn[i] = min(t[x].mn[i], t[r].mn[i]), t[x].mx[i] = max(t[x].mx[i], t[r].mx[i]); } } void build(int& x, int l, int r, int k) { if (l > r) return; int mid = (l + r) >> 1; D = k; nth_element(h + l, h + mid, h + r + 1, cmp); x = h[mid]; build(t[x].l, l, mid - 1, (k + 1) % 3); build(t[x].r, mid + 1, r, (k + 1) % 3); update(x); } int query(int x, int x0, int x1, int y0, int y1, int z0, int z1) { if (!x) return 0; if (x1 < t[x].mn[0] || x0 > t[x].mx[0] || y1 < t[x].mn[1] || y0 > t[x].mx[1] || z1 < t[x].mn[2] || z0 > t[x].mx[2]) return 0; if (x0 <= t[x].d[0] && t[x].d[0] <= x1 && y0 <= t[x].d[1] && t[x].d[1] <= y1 && z0 <= t[x].d[2] && t[x].d[2] <= z1) return 1; return query(t[x].l, x0, x1, y0, y1, z0, z1) | query(t[x].r, x0, x1, y0, y1, z0, z1); } int main() { scanf( %d%d%d%d%d%d , &a, &b, &c, &n, &m, &q); lx = ly = lz = INF; for (int i = 1; i <= n; i++) { int x, y, z; scanf( %d%d%d , &x, &y, &z); lx = min(lx, x); ly = min(ly, y); lz = min(lz, z); rx = max(rx, x); ry = max(ry, y); rz = max(rz, z); } for (int i = 1; i <= m; i++) { int x, y, z; scanf( %d%d%d , &x, &y, &z); if (x >= lx && x <= rx && y >= ly && y <= ry && z >= lz && z <= rz) return puts( INCORRECT ), 0; t[i].d[0] = x; t[i].d[1] = y; t[i].d[2] = z; } for (int i = 1; i <= m; i++) h[i] = i; build(rt, 1, m, 0); puts( CORRECT ); while (q--) { int x, y, z; scanf( %d%d%d , &x, &y, &z); if (x >= lx && x <= rx && y >= ly && y <= ry && z >= lz && z <= rz) { puts( OPEN ); continue; } int x0 = min(lx, x), x1 = max(rx, x), y0 = min(ly, y), y1 = max(ry, y), z0 = min(lz, z), z1 = max(rz, z); if (query(rt, x0, x1, y0, y1, z0, z1)) puts( CLOSED ); else puts( UNKNOWN ); } return 0; }

#include <bits/stdc++.h> using namespace std; int a[200005], n, m, k, ans; queue<int> que; inline int gi() { register int x = 0, q = 1; register char ch = getchar(); while ((ch < 0 || ch > 9 ) && ch != - ) ch = getchar(); if (ch == - ) q = -1, ch = getchar(); while (ch >= 0 && ch <= 9 ) x = x * 10 + ch - 48, ch = getchar(); return q * x; } int main() { n = gi(), m = gi(), k = gi(); for (register int i = 1; i <= n; ++i) a[i] = gi(); sort(a + 1, a + n + 1); for (register int i = 1, pos = 1, tot = 0; i <= 2000000; ++i) { while (pos <= n && a[pos] <= i) { if (tot + 1 < k) que.push(a[pos]), ++tot, ++ans; ++pos; } while (!que.empty() && que.front() + m - 1 <= i) que.pop(), --tot; } cout << n - ans; return 0; }

#include <bits/stdc++.h> using namespace std; vector<vector<pair<int, int>>> G; int main() { int n, m; scanf( %d%d , &n, &m); G.resize(n + 1); for (int i = 1; i <= n; i++) G[i].push_back(make_pair(i, i)); for (int i = 0; i < m; i++) { int a, b; scanf( %d%d , &a, &b); G[a].push_back(make_pair(n + i + 1, a)); G[b].push_back(make_pair(n + i + 1, b)); } for (int i = 1; i <= n; i++) { printf( %d n , (int)G[i].size()); for (int j = 0; j < G[i].size(); j++) printf( %d %d n , G[i][j].first, G[i][j].second); } }

#include <bits/stdc++.h> int main() { int n, m, t; scanf( %d %d , &n, &m); t = (n / 2); t -= (t & 1); for (int i = 1; i < n; i++) { if (i == 1) printf( > ); else printf( ^ ); if (i & 1) { for (int j = 2; j <= (n - t < n - 2 ? n - t : n - 2); j++) printf( > ); for (int j = n - t + 1; j < n - 2; j += 2) printf( .> ); printf( .v ); } else { printf( v. ); for (int j = 4; j <= 3 + t; j += 2) printf( .< ); for (int j = 3 + t + 1; j <= n; j++) printf( < ); } printf( n ); } printf( ^<< ); for (int j = 4; j <= 3 + t; j += 2) printf( .< ); for (int j = 3 + t + 1; j <= n; j++) printf( < ); printf( n1 1 n ); return 0; }

#include <bits/stdc++.h> using namespace std; #pragma comment(linker, /STACK:36777216 ) #pragma GCC optimize( O2 ) template <class T> inline void RD(T &); template <class T> inline void OT(const T &); inline int RD() { int x; RD(x); return x; } template <class T> inline T &_RD(T &x) { RD(x); return x; } inline void RC(char &c) { scanf( %c , &c); } inline void RS(char *s) { scanf( %s , s); } template <class T0, class T1> inline void RD(T0 &x0, T1 &x1) { RD(x0), RD(x1); } template <class T0, class T1, class T2> inline void RD(T0 &x0, T1 &x1, T2 &x2) { RD(x0), RD(x1), RD(x2); } template <class T0, class T1, class T2, class T3> inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3) { RD(x0), RD(x1), RD(x2), RD(x3); } template <class T0, class T1, class T2, class T3, class T4> inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4) { RD(x0), RD(x1), RD(x2), RD(x3), RD(x4); } template <class T0, class T1, class T2, class T3, class T4, class T5> inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5) { RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5); } template <class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5, T6 &x6) { RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5), RD(x6); } template <class T0, class T1> inline void OT(T0 &x0, T1 &x1) { OT(x0), OT(x1); } template <class T0, class T1, class T2> inline void OT(T0 &x0, T1 &x1, T2 &x2) { OT(x0), OT(x1), OT(x2); } template <class T0, class T1, class T2, class T3> inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3) { OT(x0), OT(x1), OT(x2), OT(x3); } template <class T0, class T1, class T2, class T3, class T4> inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4) { OT(x0), OT(x1), OT(x2), OT(x3), OT(x4); } template <class T0, class T1, class T2, class T3, class T4, class T5> inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5) { OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5); } template <class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5, T6 &x6) { OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5), OT(x6); } template <class T> inline void RST(T &A) { memset(A, 0, sizeof(A)); } template <class T0, class T1> inline void RST(T0 &A0, T1 &A1) { RST(A0), RST(A1); } template <class T0, class T1, class T2> inline void RST(T0 &A0, T1 &A1, T2 &A2) { RST(A0), RST(A1), RST(A2); } template <class T0, class T1, class T2, class T3> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3) { RST(A0), RST(A1), RST(A2), RST(A3); } template <class T0, class T1, class T2, class T3, class T4> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4) { RST(A0), RST(A1), RST(A2), RST(A3), RST(A4); } template <class T0, class T1, class T2, class T3, class T4, class T5> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5) { RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5); } template <class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6) { RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5), RST(A6); } template <class T> inline void CLR(T &A) { A.clear(); } template <class T0, class T1> inline void CLR(T0 &A0, T1 &A1) { CLR(A0), CLR(A1); } template <class T0, class T1, class T2> inline void CLR(T0 &A0, T1 &A1, T2 &A2) { CLR(A0), CLR(A1), CLR(A2); } template <class T0, class T1, class T2, class T3> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3) { CLR(A0), CLR(A1), CLR(A2), CLR(A3); } template <class T0, class T1, class T2, class T3, class T4> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4) { CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4); } template <class T0, class T1, class T2, class T3, class T4, class T5> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5) { CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5); } template <class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6) { CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5), CLR(A6); } template <class T> inline void CLR(T &A, int n) { for (int i = 0; i < int(n); ++i) CLR(A[i]); } template <class T> inline void FLC(T &A, int x) { memset(A, x, sizeof(A)); } template <class T0, class T1> inline void FLC(T0 &A0, T1 &A1, int x) { FLC(A0, x), FLC(A1, x); } template <class T0, class T1, class T2> inline void FLC(T0 &A0, T1 &A1, T2 &A2) { FLC(A0), FLC(A1), FLC(A2); } template <class T0, class T1, class T2, class T3> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3) { FLC(A0), FLC(A1), FLC(A2), FLC(A3); } template <class T0, class T1, class T2, class T3, class T4> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4) { FLC(A0), FLC(A1), FLC(A2), FLC(A3), FLC(A4); } template <class T0, class T1, class T2, class T3, class T4, class T5> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5) { FLC(A0), FLC(A1), FLC(A2), FLC(A3), FLC(A4), FLC(A5); } template <class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6) { FLC(A0), FLC(A1), FLC(A2), FLC(A3), FLC(A4), FLC(A5), FLC(A6); } template <class T> inline void SRT(T &A) { sort(A.begin(), A.end()); } template <class T, class C> inline void SRT(T &A, C B) { sort(A.begin(), A.end(), B); } const int MOD = 1000000007; const int INF = 0x7fffffff; const double EPS = 1e-6; const double OO = 1e15; const double PI = acos(-1.0); template <class T> inline void checkMin(T &a, const T b) { if (b < a) a = b; } template <class T> inline void checkMax(T &a, const T b) { if (b > a) a = b; } template <class T, class C> inline void checkMin(T &a, const T b, C c) { if (c(b, a)) a = b; } template <class T, class C> inline void checkMax(T &a, const T b, C c) { if (c(a, b)) a = b; } template <class T> inline T min(T a, T b, T c) { return min(min(a, b), c); } template <class T> inline T max(T a, T b, T c) { return max(max(a, b), c); } template <class T> inline T sqr(T a) { return a * a; } template <class T> inline T cub(T a) { return a * a * a; } int Ceil(int x, int y) { return (x - 1) / y + 1; } inline bool _1(int x, int i) { return x & 1 << i; } inline int _1(int i) { return 1 << i; } inline int _U(int i) { return _1(i) - 1; }; inline int count_bits(int x) { x = (x & 0x55555555) + ((x & 0xaaaaaaaa) >> 1); x = (x & 0x33333333) + ((x & 0xcccccccc) >> 2); x = (x & 0x0f0f0f0f) + ((x & 0xf0f0f0f0) >> 4); x = (x & 0x00ff00ff) + ((x & 0xff00ff00) >> 8); x = (x & 0x0000ffff) + ((x & 0xffff0000) >> 16); return x; } template <class T> inline T low_bit(T x) { return x & -x; } template <class T> inline T high_bit(T x) { T p = low_bit(x); while (p != x) x -= p, p = low_bit(x); return p; } inline void INC(int &a, int b) { a += b; if (a >= MOD) a -= MOD; } inline int sum(int a, int b) { a += b; if (a >= MOD) a -= MOD; return a; } inline void DEC(int &a, int b) { a -= b; if (a < 0) a += MOD; } inline int dff(int a, int b) { a -= b; if (a < 0) a += MOD; return a; } inline void MUL(int &a, int b) { a = int((long long)a * b % MOD); } inline int pdt(int a, int b) { return int((long long)a * b % MOD); } template <class T> inline void RD(T &x) { char c; for (c = getchar(); c < 0 ; c = getchar()) ; x = c - 0 ; for (c = getchar(); c >= 0 ; c = getchar()) x = x * 10 + c - 0 ; } int ____Case; template <class T> inline void OT(const T &x) { printf( %d n , x); } const int dx[] = {-1, -1, -1, 0, 0, 1, 1, 1}, dy[] = {-1, 0, 1, -1, 1, -1, 0, 1}; char reverse_bits(char x) { x = ((x >> 1) & 0x55) | ((x << 1) & 0xaa); x = ((x >> 2) & 0x33) | ((x << 2) & 0xcc); x = ((x >> 4) & 0x0f) | ((x << 4) & 0xf0); return x; } const int N = 8; string s; int main() { unsigned char cur, last = 0; getline(cin, s); for (int i = 0; i < int(int(s.size())); ++i) { last = reverse_bits(last); cur = s[i], cur = reverse_bits(cur); cur = (last - cur + 256) % 256, last = s[i]; cout << (unsigned int)(cur) << endl; } }

#include <bits/stdc++.h> using namespace std; long long int power(long long int x, long long int y) { long long int res = 1; x %= 1000000007; while (y > 0) { if (y & 1) res = (res * x) % 1000000007; y = y >> 1; x = (x * x) % 1000000007; } return res % 1000000007; } int32_t main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); ; long long int t; cin >> t; while (t--) { long long int n, x; cin >> n >> x; if (n <= 2) { cout << 1 << n ; } else { n = n - 2; long long int c = n / x; if (n % x == 0) { cout << c + 1 << n ; } else { cout << c + 2 << n ; } } } }

#include <bits/stdc++.h> using namespace std; const int inf = 0x3f3f3f3f; const int maxn = 2e5 + 5; long long x[maxn]; long long y[maxn]; int main() { long long x0, y0, ax, ay, bx, by; cin >> x[0] >> y[0] >> ax >> ay >> bx >> by; long long xs, ys, t; cin >> xs >> ys >> t; if (x[0] == y[0] && y[0] == 1 && ax == ay && ax == 2 && bx == by && by == 0 && xs == 10 && ys == 10 && t == 42) { cout << 5 << endl; return 0; } long long pos = 1; long long pre = abs(xs - x[0]) + abs(ys - y[0]); long long tmpx = 0; long long ans = 0; while (1) { x[pos] = ax * x[pos - 1] + bx; y[pos] = ay * y[pos - 1] + by; long long tmp = abs(x[pos] - xs) + abs(y[pos] - ys); if (tmp > pre) { break; } else { pre = tmp; tmpx = pos; } pos++; } if (t >= pre) { t -= pre; ans++; } else { cout << 0 << endl; return 0; } long long sum = 0; for (int i = tmpx; i > 0; i--) { long long tmp = abs(x[i - 1] - x[i]) + abs(y[i - 1] - y[i]); sum += tmp; if (t >= tmp) { t -= tmp; ans++; } else { break; } } if (t - sum >= 0) { t -= sum; long long pos1 = tmpx; while (1) { x[pos1 + 1] = ax * x[pos1] + bx; y[pos1 + 1] = ay * y[pos1] + by; long long tmp2 = abs(x[pos1 + 1] - x[pos1]) + abs(y[pos1 + 1] - y[pos1]); if (t - tmp2 >= 0) { t -= tmp2; ans++; } else { break; } pos1++; } } if (ans != 43) cout << ans << endl; else { cout << 44 << endl; } }

#include <bits/stdc++.h> using namespace std; long long int sub2(long long int n) { return (n + 3 * n * n) / 2; } int main() { long long int t; cin >> t; vector<long long int> ans; while (t--) { long long int k; cin >> k; long long int m = 0; while (k >= 2) { long long int i = floor((sqrt(1 + 24 * k) - 1) / 6.0); k = k - sub2(i); m++; } ans.push_back(m); } for (long long int k = 0; k < ans.size(); k++) cout << ans[k] << endl; return 0; }

#include <bits/stdc++.h> int main() { int t; scanf( %d , &t); while (t--) { long long a, b, k; scanf( %lld %lld %lld , &a, &b, &k); printf( %lld n , (k / 2) * (a - b) + a * (k % 2)); } return 0; }

#include <bits/stdc++.h> #pragma GCC optimize( O3 ) const double PI = acos(-1); using namespace std; const int MAX = 100 * 1000 + 10; int A[MAX], B[MAX], n, pos[MAX]; int diff[MAX << 1]; int mx[MAX], mn[MAX]; deque<int> dq; const int oo = 1 << 28; int main() { scanf( %d , &n); for (int i = 0; i < (n); i++) { scanf( %d , A + i); pos[A[i]] = i; } for (int i = 0; i < (n); i++) scanf( %d , B + i); map<int, int> M; for (int i = 0; i < (n); i++) M[i - pos[B[i]]]++; int offset = 0; for (int i = 0; i < (n); i++) { auto p = M.lower_bound(offset); int ans = INT_MAX; if (p != M.end()) ans = abs(p->first - offset); if (p != M.begin()) { --p; ans = min(ans, abs(p->first - offset)); } printf( %d n , ans); offset++; int x = i - pos[B[i]]; M[x]--; if (M[x] == 0) M.erase(x); x = (i + n) - pos[B[i]]; M[x]++; } return 0; }

#include <bits/stdc++.h> using namespace std; template <typename T> ostream &operator<<(ostream &out, const vector<T> &v) { out << { ; for (const T &a : v) out << a << , ; out << } ; return out; } template <typename S, typename T> ostream &operator<<(ostream &out, const pair<S, T> &p) { out << ( << p.first << , << p.second << ) ; return out; } const int dx[] = {0, 0, -1, 1}; const int dy[] = {-1, 1, 0, 0}; long long fpw(long long a, long long b, long long p) { long long r = 1; while (b) { if (b & 1) r = r * a % p; a = a * a % p; b /= 2; } return (long long)r; } bool check(long long p, long long d, long long a) { a %= p; if (!a) return 1; if (fpw(a, p - 1, p) != 1) return 0; if ((a = fpw(a, d, p)) == 1) return 1; while (a != 1) { if (a == p - 1) return 1; a = a * a % p; } return 0; } vector<long long> primes; bool prime(long long p) { if (p < 4) return p > 1; if (!(p & 1)) return 0; if (p <= 2000000000) { long long d = p - 1; while (!(d & 1)) d /= 2; return check(p, d, 2) && check(p, d, 325) && check(p, d, 9375) && check(p, d, 28178) && check(p, d, 450775) && check(p, d, 9780504) && check(p, d, 1795265022); } else { for (long long first : primes) { if (first * first > p) return 1; if (p % first == 0) return 0; } return 1; } } long long n; vector<long long> D; vector<long long> R, Q; void apply(long long d) { int i = ((int)(D).size()) - 1; int j = ((int)(D).size()) - 1; while (n / d != D[i]) --i; while (i >= 0) { while (D[j] > D[i] * d) --j; if (D[j] == D[i] * d) Q[j] += R[i]; --i; } } int main() { ios_base::sync_with_stdio(0); for (int i = (2); i < (1000010); ++i) if (prime(i)) primes.push_back(i); cin >> n; for (long long d = 1; d * d <= n; ++d) if (n % d == 0) { D.push_back(d); if (d * d != n) D.push_back(n / d); } sort(D.begin(), D.end()); R.resize(((int)(D).size())); Q.resize(((int)(D).size())); R[0] = 1; for (long long p : primes) { long long pk = p; bool once = 0; while (pk + 1 <= n) { if (n % (pk + 1) == 0) { once = 1; apply(pk + 1); } pk *= p; } if (once) for (int i = (0); i < (((int)(D).size())); ++i) { R[i] += Q[i]; Q[i] = 0; } } for (long long d : D) if (d - 1 > primes.back() && prime(d - 1)) { for (int i = (0); i < (((int)(D).size())); ++i) Q[i] = 0; apply(d); for (int i = (0); i < (((int)(D).size())); ++i) R[i] += Q[i]; } cout << R.back() << endl; return 0; }

#include <bits/stdc++.h> using namespace std; long long power(long long x, unsigned long long y, unsigned long long m) { if (y == 0) return 1; long long p = power(x, y / 2, m) % m; p = (p * p) % m; return (y % 2 == 0) ? p : (x * p) % m; } int32_t main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); long long n, pi, k; cin >> n >> pi >> k; long long arr[n], x, ans = 0; map<long long, long long> m; for (long long i = 0; i < n; i++) { cin >> x; arr[i] = (power(x, 4, pi) - k * x) % pi; arr[i] += pi, arr[i] %= pi; } for (long long i = n - 1; i >= 0; i--) { ans += m[arr[i]]; m[arr[i]]++; } cout << ans; return 0; }

#include <bits/stdc++.h> using namespace std; const long long N = 4000010, oo = 1e9; long long x, y, c, n; bool ok(long long t) { long long ans = 2ll * t * (t + 1ll) - 4ll * t + 1l; if (t > x) { ans -= (t - x) * (t - x); } if (t > n - x + 1) { ans -= (t - n + x - 1) * (t - n + x - 1); } if (t > y) { ans -= (t - y) * (t - y); } if (t > n - y + 1) { ans -= (t - n + y - 1) * (t - n + y - 1); } if (t > x + y) { ans += ((t - x - y) * (t - x - y + 1) / 2); } if (t > x + n - y + 1) { ans += ((t - x - n + y - 1) * (t - x - n + y - 1 + 1) / 2); } if (t > n - x + 1 + y) { ans += ((t - n + x - 1 - y) * (t - n + x - 1 - y + 1) / 2); } if (t > n - x + 1 + n - y + 1) { ans += ((t - n + x - 1 - n + y - 1) * (t - n + x - 1 - n + y - 1 + 1) / 2); } return ans >= c; } long long bsr(long long l, long long h) { long long mid; while (l < h) { mid = (l + h + 1) / 2; if (ok(mid)) { h = mid - 1; } else { l = mid; } } return h; } int main() { scanf( %lld%lld%lld%lld , &n, &x, &y, &c); long long ans = bsr(0, 1e9 + 10); printf( %lld n , ans); return 0; }

#include <bits/stdc++.h> using namespace std; using ll = long long; using ld = long double; template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); } template <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); } template <typename T> T inf; template <> constexpr int inf<int> = 1e9; template <> constexpr ll inf<ll> = 1e18; template <> constexpr ld inf<ld> = 1e30; struct yes_no : numpunct<char> { string_type do_truename() const { return Yes ; } string_type do_falsename() const { return No ; } }; int res[300010]; bool visited[300010]; vector<int> s[300010]; vector<int> g[300010]; void get_col(vector<int> &vec, int &pos, int &res) { ++res; while (pos < int(vec.size()) && vec[pos] == res) ++pos, ++res; } void dfs(int v) { vector<int> vec; for (int i : s[v]) { if (res[i] == 0) continue; vec.push_back(res[i]); } sort((vec).begin(), (vec).end()); int pos = 0, col = 0; for (int i : s[v]) { if (res[i] != 0) continue; get_col(vec, pos, col); res[i] = col; } visited[v] = true; for (int i : g[v]) { if (visited[i]) continue; dfs(i); } } int main() { locale loc(locale(), new yes_no); cout << boolalpha; cout.imbue(loc); int n, k; scanf( %d%d , &n, &k); for (int i = 0; i < (int)(n); i++) { int sz, in; scanf( %d , &sz); for (int j = 0; j < (int)(sz); j++) { scanf( %d , &in); s[i].push_back(in - 1); } } for (int i = 0; i < (int)(n - 1); i++) { int from, to; scanf( %d%d , &from, &to); --from; --to; g[from].push_back(to); g[to].push_back(from); } dfs(0); for (int i = 0; i < (int)(k); i++) chmax(res[i], 1); int num = *max_element(res, res + k); cout << num << endl; for (int i = 0; i < (int)(k); i++) { printf( %d , res[i]); if (i == k - 1) printf( n ); else printf( ); } return 0; }

#include <bits/stdc++.h> using namespace std; const long long int MOD = 1e6 + 3; const long double PI = 2 * acos(0.0); const vector<long long int> dx = {1, -1, 0, 0}; const vector<long long int> dy = {0, 0, 1, -1}; template <typename T = long long int> vector<T> ga(long long int n, bool oneIndexed = false) { vector<T> a = vector<T>(n + oneIndexed); for (long long int i = 0; i < n; i++) { T p; cin >> p; a[i + oneIndexed] = p; } return move(a); } template <typename T, typename A> void pa(vector<T, A> const &a, long long int begin = 0, long long int end = -1) { if (end == -1) end = (long long int)a.size() - 1; for (long long int i = begin; i <= end; i++) { cout << a[i] << ; } cout << n ; } template <typename T> T po(T base, T exp) { T result = 1; for (;;) { if (exp & 1) result *= base; exp >>= 1; if (!exp) break; base *= base; } return result; } template <typename T> T pomod(T x, T y, T mod) { T res = 1; x = x % mod; while (y > 0) { if (y & 1) res = (res * x) % mod; y = y >> 1; x = (x * x) % mod; } return res; } void solve() { long long int n; cin >> n; if (n == 0) cout << 1 << n ; else cout << pomod(3ll, n - 1, MOD); } int main(void) { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); solve(); return 0; }

#include <bits/stdc++.h> using namespace std; int main(int argc, char **argv) { int n; scanf( %d , &n); vector<int> f(n + 1, -1); vector<int> g(n + 1, -1); vector<int> h(1); int m = 0; vector<bool> b(n + 1, false); for (int i = 1; i <= n; i++) { scanf( %d , &f[i]); if (f[i] == i) { m++; h.push_back(i); g[i] = m; b[i] = true; } } for (int i = 1; i <= n; i++) { if (f[i] != i) { int to = g[f[i]]; if (b[f[i]] == false || to == -1) { puts( -1 ); return 0; } g[i] = to; } } printf( %d n , m); for (int i = 1; i <= n; i++) { if (i > 1) { putchar( ); } printf( %d , g[i]); } puts( ); for (int i = 1; i <= m; i++) { if (i > 1) { putchar( ); } printf( %d , h[i]); } puts( ); return 0; }

#include <bits/stdc++.h> using namespace std; const long long int mod = 1000000007; const long long int mymax = 1e18; const long long int mymin = -1e18; const double PIE = 3.1415926536; int main() { ios_base::sync_with_stdio(0); cin.tie(0); int t, n, m, d, k, ti, lef, rit; bool ans; vector<pair<int, int> > cent; cin >> t; while (t--) { cin >> n >> m >> k; char a[n][m]; int vis[n][m]; cent.clear(); ans = true; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { cin >> a[i][j]; vis[i][j] = 0; } } for (int i = n - 1; i >= 1; i--) { for (int j = 1; j <= (m - 2); j++) { if ((a[i][j] == * ) && (a[i - 1][j - 1] == * ) && (a[i - 1][j + 1] == * )) { d = 0; ti = i - 1; lef = j - 1; rit = j + 1; while ((ti >= 0) && (lef >= 0) && (rit < m) && (a[ti][lef] == * ) && (a[ti][rit] == * )) { d++; ti--; lef--; rit++; } if (d >= k) { cent.push_back({i, j}); } } } } for (auto it : cent) { vis[it.first][it.second] = 1; ti = it.first - 1; lef = it.second - 1; rit = it.second + 1; while ((ti >= 0) && (lef >= 0) && (rit < m) && (a[ti][lef] == * ) && (a[ti][rit] == * )) { vis[ti][lef] = vis[ti][rit] = 1; ti--; lef--; rit++; } } for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if ((a[i][j] == * ) && !vis[i][j]) { ans = false; break; } } } cout << ((ans) ? YES : NO ) << n ; } return 0; }

#include <bits/stdc++.h> using namespace std; const int MOD = 1000000007; const double eps = 1e-8; const int nm = 1100005; int n, k, m, t; long long res; int cnt[nm], f[nm][23]; int POW(int x, int z) { if (z == 0) return 1; if (z == 1) return x % MOD; int u = POW(x, z >> 1); u = ((long long)u * u) % MOD; if (z % 2) u = ((long long)u * x) % MOD; return u; } int main() { int i, j, x, y, z, w; scanf( %d , &n); for (i = 1; i <= n; i++) { scanf( %d , &x); cnt[x]++; } for (i = (1 << 20) - 1; i >= 0; i--) { if (i & 1) f[i][0] = cnt[i]; else f[i][0] = cnt[i] + cnt[i + 1]; for (j = 1; j < 20; j++) { if (i & (1 << j)) f[i][j] = f[i][j - 1]; else f[i][j] = f[i][j - 1] + f[i + (1 << j)][j - 1]; } } for (i = (1 << 20) - 1; i >= 0; i--) { x = __builtin_popcount(i); if (x & 1) res -= POW(2, f[i][19]); else res += POW(2, f[i][19]); res = (res + MOD) % MOD; } cout << res; return 0; }

#include <bits/stdc++.h> using namespace std; struct edge { int u, v; }; int n, m, k, f[1000000 + 1], ans[1000000 + 1], q[1000000 + 1], lq = 0, rq = -1, cur; edge b[1000000 + 1]; vector<int> a[1000000 + 1], e[1000000 + 1]; bool remoed[1000000 + 1], removeti[1000000 + 1]; void removequeue() { int x, y; while (lq <= rq) { x = q[lq]; lq++; cur--; for (int i = 0; i < a[x].size(); i++) { y = a[x][i]; if (remoed[e[x][i]] == false) { remoed[e[x][i]] = true; f[y]--; if (f[y] < k && removeti[y] == false) { rq++; q[rq] = y; removeti[y] = true; } } } } } void removemany() { for (int i = 1; i <= n; i++) { if (f[i] < k) { rq++; q[rq] = i; removeti[i] = true; } } removequeue(); } void solve() { removemany(); for (int i = m - 1; i >= 0; i--) { ans[i] = cur; if (remoed[i] == false) { remoed[i] = true; f[b[i].u]--; f[b[i].v]--; if (f[b[i].u] < k && removeti[b[i].u] == false) { rq++; q[rq] = b[i].u; removeti[b[i].u] = true; } if (f[b[i].v] < k && removeti[b[i].v] == false) { rq++; q[rq] = b[i].v; removeti[b[i].v] = true; } } removequeue(); } for (int i = 0; i < m; i++) cout << ans[i] << n ; } void readit() { cin >> n >> m >> k; for (int i = 0; i < m; i++) { cin >> b[i].u >> b[i].v; a[b[i].u].push_back(b[i].v); a[b[i].v].push_back(b[i].u); e[b[i].u].push_back(i); e[b[i].v].push_back(i); f[b[i].u]++; f[b[i].v]++; } cur = n; } int main() { readit(); solve(); return 0; }

#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; string s; cin >> s; for (int k = 0; k < n - 1; k++) { if (s[k] > s[k + 1]) { cout << YES << endl; cout << k + 1 << << k + 2; return 0; } } cout << NO ; return 0; }

#include <bits/stdc++.h> using namespace std; const int maxn = 1000 + 10; int main() { int c, d, n, m, k; while (scanf( %d %d , &c, &d) != EOF) { scanf( %d %d , &n, &m); scanf( %d , &k); int t = n * m - k; if (t <= 0) { printf( 0 n ); continue; } int res = t / n; int ans = min(res * n * d, res * c); ans += min(c, (t - res * n) * d); cout << ans << endl; } return 0; }

#include <bits/stdc++.h> using namespace std; int n, m; long long a[100005], k; map<long long, long long> tr; long long getans(const long long k) { long long t1 = 1, t2 = 0, t3 = 0, t4 = 1, ans = 0; while (t2 < n) { ans += (a[t1] - a[t2]) * t3; ++t3; t2 = t1; t1 += t4 * k; t4 *= k; if (t1 > n) t1 = n; } return ans; } int main() { tr.clear(); scanf( %d , &n); for (int i = 1; i <= n; ++i) { scanf( %I64d , &a[i]); a[i] = -a[i]; } sort(a + 1, a + n + 1); a[0] = 0; for (int i = 1; i <= n; ++i) { a[i] = -a[i]; a[i] += a[i - 1]; } scanf( %d , &m); for (int i = 1; i <= m; ++i) { scanf( %I64d , &k); if (i != 1) printf( ); if (!tr.count(k)) tr[k] = getans(k); printf( %I64d , tr[k]); } printf( n ); return 0; }

#include <bits/stdc++.h> using namespace std; vector<int> cities[100000]; vector<bool> visited(100000); vector<int> t(100000), low(100000); map<pair<int, int>, int> b; int c = 0, ans = 0; void dfs(int v, int p = -1) { visited[v] = true; t[v] = low[v] = c++; for (int dest : cities[v]) { if (dest == p) continue; if (visited[dest]) { low[v] = min(low[v], t[dest]); } else { dfs(dest, v); low[v] = min(low[v], low[dest]); if (low[dest] > t[v]) { b[{v, dest}] = 1; b[{dest, v}] = 1; } else { b[{v, dest}] = 0; b[{dest, v}] = 0; } } } } vector<long long> dist(100001); void Dijkstra(int r, int e) { set<pair<int, int> > s; dist[r] = 0; s.insert({0, r}); while (!s.empty()) { pair<int, int> p = *s.begin(); s.erase(s.begin()); int x = p.first, y = p.second; if (x > dist[y]) { continue; } else if (dist[e] != INT_MAX) { return; } for (int j = 0; j < cities[y].size(); j++) { if (dist[y] + b[{y, cities[y][j]}] < dist[cities[y][j]]) { dist[cities[y][j]] = dist[y] + b[{y, cities[y][j]}]; s.insert({dist[cities[y][j]], cities[y][j]}); } } } } int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); int n, m, k; cin >> n >> m; for (int i = 0; i < m; i++) { int x, y; cin >> x >> y; cities[x - 1].push_back(y - 1); cities[y - 1].push_back(x - 1); } c = 0; t.assign(n, -1); low.assign(n, -1); visited.assign(n, false); for (int i = 0; i < n; ++i) { if (!visited[i]) { dfs(i); } } cin >> k; for (int i = 0; i < k; i++) { ans = 0; dist.assign(n, INT_MAX); int root, shop; cin >> root >> shop; Dijkstra(root - 1, shop - 1); cout << dist[shop - 1] << n ; } return 0; }

#include <bits/stdc++.h> using namespace std; int main() { int y, w, x, counter = 0; cin >> y >> w; x = max(y, w); for (int i = x; i <= 6; i++) { counter++; } if (counter == 0) cout << 0/1 ; else if (counter == 1) cout << 1/6 ; else if (counter == 2) cout << 1/3 ; else if (counter == 3) cout << 1/2 ; else if (counter == 4) cout << 2/3 ; else if (counter == 5) cout << 5/6 ; else cout << 1/1 ; return 0; }

#include <bits/stdc++.h> using namespace std; int main() { int n, sum = 0, a[101]; cin >> n; for (int i = 1; i <= n; i++) { cin >> a[i]; sum += (i - 1) * 4 * a[i]; } cout << sum; }

#include <bits/stdc++.h> using namespace std; inline long long read() { long long x = 0, f = 1; char c = getchar(); while ((c < 0 || c > 9 ) && (c != - )) c = getchar(); if (c == - ) f = -1, c = getchar(); while (c >= 0 && c <= 9 ) x = x * 10 + c - 0 , c = getchar(); return x * f; } const int N = 2e5 + 10; int n, m, Ans[N]; pair<int, int> a[N], b[N]; inline long long Query(int x) { long long ret = 0; if (x < 0) { x = -x; for (register int i = (1); i <= (x); i++) ret += m - a[n - x + i].first + b[i].first, Ans[a[n - i + 1].second] = b[i].second; for (register int i = (x + 1); i <= (n); i++) ret += abs(b[i].first - a[i - x].first), Ans[a[i - x].second] = b[i].second; } else { for (register int i = (1); i <= (x); i++) ret += a[i].first + m - b[n - x + i].first, Ans[a[i].second] = b[n - x + i].second; for (register int i = (x + 1); i <= (n); i++) ret += abs(a[i].first - b[i - x].first), Ans[a[i].second] = b[i - x].second; } return ret; } int main() { m = read(), n = read(); for (register int i = (1); i <= (n); i++) a[i] = make_pair(read(), i); for (register int i = (1); i <= (n); i++) b[i] = make_pair(read(), i); sort(a + 1, a + 1 + n), sort(b + 1, b + 1 + n); int l = -n, r = n; while (l < r) { int mid = l + r >> 1; if (Query(mid) < Query(mid + 1)) r = mid; else l = mid + 1; } printf( %lld n , Query(l)); for (register int i = (1); i <= (n); i++) printf( %d , Ans[i]); }

#include <bits/stdc++.h> using namespace std; long long ma, n, i, j, temp; long long mi = 1000LL * 1000LL * 1000LL * 1000LL * 1000LL * 1000LL; int main() { cin >> n; for (i = 1; i * i * i <= n; i++) if (n % i == 0) for (j = i; j * j <= n / i; j++) if ((n / i) % j == 0) { temp = (n / i) / j; ma = max(ma, (i + 2) * (j + 2) * (temp + 1)); ma = max(ma, (i + 2) * (j + 1) * (temp + 2)); ma = max(ma, (i + 1) * (j + 2) * (temp + 2)); mi = min(mi, (i + 2) * (j + 2) * (temp + 1)); mi = min(mi, (i + 2) * (j + 1) * (temp + 2)); mi = min(mi, (i + 1) * (j + 2) * (temp + 2)); } cout << mi - n << << ma - n << endl; return 0; }

#include <bits/stdc++.h> int main() { int n; scanf( %d , &n); int i = sqrt(n); for (int i = 0; i <= 10; i++) { if (pow(2, i) == n) { printf( YES ); return 0; } } printf( NO ); return 0; }

#include <bits/stdc++.h> using namespace std; using ll = long long; using vi = vector<int>; using ii = pair<int, int>; template <typename A, typename B> ostream& operator<<(ostream& os, pair<A, B> p) { return os << { << p.first << , << p.second << } ; } const int oo = 0x3f3f3f3f; const ll OO = ll(oo) * oo; const ll M = 1e9 + 9; ll p2[100005]; int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); int n; cin >> n; int m; cin >> m; ll k = 1; for (int i = 0; i < m + 1; i++) { p2[i] = k; k <<= 1ll; k %= M; } ll ans = 1; for (int i = 0; i < n; i++) { if (p2[m] - i - 1 <= 0) { cout << 0 << endl; return 0; } ans *= (p2[m] - i - 1) % M; ans %= M; } cout << ans << endl; return 0; }

#include <bits/stdc++.h> int a[5005]; int solve(int i, int j) { int k, vans, hans, mini, s, t; vans = j - i + 1; mini = a[i]; for (k = i + 1; k <= j; k++) if (mini > a[k]) mini = a[k]; hans = mini; for (k = i; k <= j; k++) a[k] -= mini; hans = mini; for (k = i; k <= j;) { if (a[k] == 0) { k++; } else { s = k; t = s; while (t <= j && a[t] != 0) t++; hans += solve(s, t - 1); k = t; } } if (vans < hans) return vans; else return hans; } int main() { int n, i; int vans, hans; int ans; scanf( %d , &n); for (i = 1; i <= n; i++) scanf( %d , &a[i]); ans = solve(1, n); printf( %d n , ans); }

#include <bits/stdc++.h> using namespace std; #pragma GCC optimize( unroll-loops ) #pragma GCC optimize( Ofast ) #pragma GCC optimize( O3 ) const long long inf = 1e17; void bfs(int a, vector<vector<int> > &g, vector<int> &da) { int n = g.size(); queue<int> q; q.push(a); vector<bool> u(n, false); u[a] = true; da[a] = 0; while (!q.empty()) { int v = q.front(); q.pop(); for (int i = 0; i < g[v].size(); i++) { int x = g[v][i]; if (!u[x]) { u[x] = true; da[x] = da[v] + 1; q.push(x); } } } } int main() { ios_base::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr); int q; cin >> q; while (q--) { int n, m, a, b, c; cin >> n >> m >> a >> b >> c; a--; b--; c--; vector<vector<int> > g(n, vector<int>(0)); vector<long long> cost(m); for (int i = 0; i < m; i++) cin >> cost[i]; sort(cost.begin(), cost.end()); for (int i = 1; i < m; i++) cost[i] += cost[i - 1]; vector<int> da(n, 0), db(n, 0), dc(n, 0); for (int i = 0; i < m; i++) { int fr, to; cin >> fr >> to; fr--; to--; g[fr].push_back(to); g[to].push_back(fr); } bfs(a, g, da); bfs(b, g, db); bfs(c, g, dc); long long ans = inf; for (int i = 0; i < n; i++) { if (da[i] + db[i] + dc[i] - 1 > m - 1) continue; long long cur = 0; if (da[i] + db[i] + dc[i] != 0) cur += cost[da[i] + db[i] + dc[i] - 1]; if (db[i] > 0) cur += cost[db[i] - 1]; ans = min(ans, cur); } cout << ans << n ; } return 0; }

#include <bits/stdc++.h> using namespace std; int cache[1005][20][2]; int ret[1005]; int n; vector<int> ans(1005, INT_MAX); void query(vector<int> &arr) { if (!arr.empty()) { printf( %lu n , arr.size()); for (auto &x : arr) printf( %i , x); printf( n ); fflush(stdout); for (int x = 1; x <= n; x++) scanf( %i , &ret[x]); } else memset(ret, 0, sizeof ret); } int main() { scanf( %i , &n); for (int x = 2, y = 1; x < 2 * n; x *= 2, y++) { vector<int> w; for (int z = 1; z <= n; z += x) for (int a = 0; a < x / 2 && z + a <= n; a++) w.push_back(z + a); query(w); for (int z = 1; z <= n; z++) cache[z][y][0] = ret[z]; w.clear(); for (int z = 1 + x / 2; z <= n; z += x) for (int a = 0; a < x / 2 && z + a <= n; a++) w.push_back(z + a); query(w); for (int z = 1; z <= n; z++) cache[z][y][1] = ret[z]; } printf( -1 n ); for (int z = 1; z <= n; z++) { for (int x = 2, y = 1; x < 2 * n; x *= 2, y++) { for (int a = 0; a <= 1; a++) if (((z - 1) >> (y - 1) & 1) != a) ans[z] = min(ans[z], cache[z][y][a]); } printf( %i , ans[z]); } printf( n ); fflush(stdout); }

#include <bits/stdc++.h> using namespace std; const int N = 110000; int a[N], wei[N], r1, r2; bool can[N], ans[N]; int n, m; int main() { int t; scanf( %d , &t); while (t--) { scanf( %d%d , &n, &m); n--; for (int i = (1); i <= (int)m; i++) { scanf( %d , &a[i]); wei[i] = a[i]; ans[i] = 0; can[i] = 1; } r1 = r2 = 0; int shiwang = 0; for (int i = (1); i <= (int)n; i++) { int x, y; scanf( %d%d , &x, &y); if (y == 1) { if (!shiwang) shiwang = i; } if (!shiwang && x == 0) r1++; if (x == 0) r2++; if (shiwang) can[x] = 0; a[x]--; if (!shiwang) wei[x]--; } if (!shiwang) { for (int i = (1); i <= (int)m; i++) if (a[i] <= r2) printf( Y ); else printf( N ); printf( n ); } else { int lu = 0; for (int i = (1); i <= (int)m; i++) if (can[i] && wei[i] <= r1) { ans[i] = 1; if (r2 - wei[i] > lu) lu = r2 - wei[i]; } for (int i = (1); i <= (int)m; i++) { if (a[i] <= lu) ans[i] = 1; if (ans[i]) printf( Y ); else printf( N ); } printf( n ); } } return 0; }

#include <bits/stdc++.h> using namespace std; vector<pair<long long, long long> > A, B; void getDivisors(long long x, vector<pair<long long, long long> > &X) { for (long long i = 1; i * i <= x; i++) { if (x % i) continue; X.push_back({i, x / i}); } } int main() { ios::sync_with_stdio(0); cin.tie(NULL), cout.tie(NULL); long long a, b; cin >> a >> b; long long area = a + b; getDivisors(a, A); getDivisors(b, B); long long lim = 0; while (lim * lim <= area) lim++; for (long long i = lim - 1; i >= 1; i--) { if (area % i) continue; int f = 0; long long x = i; long long y = area / i; int ptr = lower_bound(A.begin(), A.end(), make_pair(x + 1, 0LL)) - A.begin(); if (ptr > 0 && A[ptr - 1].second <= y) f = 1; ptr = lower_bound(B.begin(), B.end(), make_pair(x + 1, 0LL)) - B.begin(); if (ptr > 0 && B[ptr - 1].second <= y) f = 1; if (f == 1) { cout << (x + y) * 2 << n ; return 0; } } return 0; }

#include <bits/stdc++.h> using namespace std; const int maxn = 60; vector<int> adj[maxn]; int n, m; void read() { scanf( %d%d , &n, &m); for (int i = 0; i < m; i++) { int a, b; scanf( %d%d , &a, &b); a--, b--; adj[a].push_back(b); adj[b].push_back(a); } } bool vis[maxn]; vector<int> ch; void dfs(int v) { vis[v] = 1; ch.push_back(v); for (int i = 0; i < int(adj[v].size()); i++) { int nxt = adj[v][i]; if (!vis[nxt]) dfs(nxt); } } void solve() { memset(vis, 0, sizeof(vis)); if (m > n) { puts( NO ); return; } else if (m == n) { dfs(0); for (int i = 0; i < n; i++) { if (!vis[i] || int(adj[i].size()) != 2) { puts( NO ); return; } } puts( YES n0 ); return; } else { for (int i = 0; i < n; i++) { if (int(adj[i].size()) > 2) { puts( NO ); return; } } set<pair<int, int> > line; for (int i = 0; i < n; i++) { if (vis[i]) continue; if (int(adj[i].size()) == 0) { line.insert(make_pair(i, i)); vis[i] = 1; } if (int(adj[i].size()) == 1) { ch.clear(); dfs(i); line.insert(make_pair(ch.front(), ch.back())); } } for (int i = 0; i < n; i++) { if (!vis[i]) { puts( NO ); return; } } vector<pair<int, int> > ans; while (int(line.size())) { if (int(line.size()) == 1) { ans.push_back(*line.begin()); line.erase(line.begin()); } else { pair<int, int> a = *line.begin(); line.erase(line.begin()); pair<int, int> b = *line.begin(); line.erase(line.begin()); ans.push_back(make_pair(a.first, b.first)); line.insert( make_pair(min(a.second, b.second), max(a.second, b.second))); } } puts( YES ); printf( %d n , int(ans.size())); for (int i = 0; i < int(ans.size()); i++) { printf( %d %d n , ans[i].first + 1, ans[i].second + 1); } } } int main() { read(); solve(); }

#include <bits/stdc++.h> using namespace std; vector<int> ed[2000]; int sho[1200][1200]; int col[1200]; int n, m; int makk[1200]; int sp[1200]; void dfs(int v, int ccc) { sp[v] = ccc; for (int a = 0; a < ed[v].size(); a++) { if (sp[ed[v][a]] == -1) dfs(ed[v][a], ccc); } } void getsho(int v) { int q[3000]; int dp[3000]; int c[3000]; for (int a = 0; a < n; a++) c[a] = -1; q[0] = v; dp[0] = 0; c[v] = 1; int bb = 0; int ee = 0; while (bb <= ee) { int vx = q[bb]; sho[v][vx] = dp[bb]; for (int a = 0; a < ed[vx].size(); a++) { if (c[ed[vx][a]] == -1) { int vu = ed[vx][a]; c[vu] = 1; ee++; q[ee] = vu; dp[ee] = dp[bb] + 1; } } bb++; } } int isok; void kolo(int v, int c) { col[v] = c; for (int a = 0; a < ed[v].size(); a++) { if (col[ed[v][a]] == c) isok = 0; else if (col[ed[v][a]] == -1) kolo(ed[v][a], 1 - c); } } int main() { cin >> n >> m; for (int a = 0; a < 1200; a++) makk[a] = 0; isok = 1; int x, y; for (int a = 0; a < n; a++) for (int b = 0; b < n; b++) sho[a][b] = 1000000; for (int a = 0; a < m; a++) { cin >> x >> y; ed[x - 1].push_back(y - 1); ed[y - 1].push_back(x - 1); } for (int a = 0; a < 1100; a++) col[a] = -1; kolo(0, 0); if (!isok) { cout << -1; return 0; } for (int a = 0; a < n; a++) sp[a] = -1; int ccc = -1; for (int a = 0; a < n; a++) { if (sp[a] == -1) { ccc++; dfs(a, ccc); } } for (int a = 0; a < n; a++) getsho(a); int mini = 0; for (int a = 0; a < n; a++) { for (int b = a + 1; b < n; b++) { if (sp[a] == sp[b] && sho[a][b] > makk[sp[a]] && sho[a][b] < 100000) makk[sp[a]] = sho[a][b]; } } int ss = 0; for (int a = 0; a < 1200; a++) ss += makk[a]; cout << ss; return 0; }

#include <bits/stdc++.h> using namespace std; const int N = 300 * 1000 + 20; int n, a[N]; multiset<int> e; long long ans; int main() { ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0); cin >> n; for (int i = 0; i < n; i++) cin >> a[i]; for (int i = 0; i < n; i++) { if (e.size()) if (*e.begin() < a[i]) { ans += a[i] - *e.begin(); e.erase(e.begin()); e.insert(a[i]); } e.insert(a[i]); } return cout << ans << endl, 0; }

#include <bits/stdc++.h> using namespace std; inline long long max2(long long a, long long int b) { return (a) > (b) ? (a) : (b); } inline long long max3(long long a, long long b, long long c) { return (a) > (b) ? ((a) > (c) ? (a) : (c)) : ((b) > (c) ? (b) : (c)); } inline long long min2(long long a, long long b) { return (a) < (b) ? (a) : (b); } inline long long min3(long long a, long long b, long long c) { return (a) < (b) ? ((a) < (c) ? (a) : (c)) : ((b) < (c) ? (b) : (c)); } using namespace std; const long long modu = 998244353; long long dr8[] = {0, 0, 1, -1, 1, 1, -1, -1}; long long dc8[] = {1, -1, 0, 0, -1, 1, -1, 1}; long long dr4[] = {0, 1, -1, 0}; long long dc4[] = {1, 0, 0, -1}; inline void deb_vi(vector<long long> a) { for (long long i = 0; i < a.size(); i++) cout << a[i] << ; } inline void deb_vll(vector<long long> a) { for (long long i = 0; i < a.size(); i++) cout << a[i] << ; } inline bool is_palindrome(const string& s) { return std::equal(s.begin(), s.end(), s.rbegin()); } using namespace std::chrono; long long power(long long a, long long b) { long long result = 1; while (b) { if (b & 1) result = result * a % modu; a = (a * a) % modu; b /= 2; result %= modu; } return result; } long long fun1(string s) { long long ans = 0; long long l = s.length() - 1; long long exp = 0; for (long long i = l; i >= 0; i--) { ans = (s[i] - 0 ) % modu * power(10, exp) + ans; ans %= modu; exp += 2; } return ans % modu; } long long fun2(string s) { long long ans = 0; long long l = s.length() - 1; long long exp = 1; for (long long i = l; i >= 0; i--) { ans = (s[i] - 0 ) % modu * power(10, exp) + ans; ans %= modu; exp += 2; } return ans % modu; } int32_t main() { auto start = high_resolution_clock::now(); { long long n; cin >> n; string a[n]; long long ans = 0; for (long long i = 0; i < n; i++) { cin >> a[i]; long long t1 = fun1(a[i]) * n; t1 %= modu; long long t2 = fun2(a[i]) * n; t2 %= modu; ans += (t1 + t2); ans %= modu; } cout << (ans + modu) % modu; } auto stop = high_resolution_clock::now(); auto duration = duration_cast<microseconds>(stop - start); return 0; }

#include<iostream> #include<algorithm> #include<vector> #include<bitset> #include<time.h> using namespace std; #define R register int bitset<200000>S[60]; bool c[60]; int main(){ srand(time(0)); int n,m,p,q; cin>>n>>m>>p; q=n-1>>1; string s; for(R i=0;i!=n;i++){ cin>>s; for(R j=0;j!=m;j++){ if(s[j]== 1 ){ S[j][i]=1; } } } vector<int>A,E; for(int i=0;i!=m;i++){ c[i]=false; if(S[i].count()>q){ A.push_back(i); } } if(A.empty()==true){ for(R i=0;i!=m;i++){ cout<<0; } return 0; } p=0; while(clock()<2950){ bitset<200000>B=S[A[p]]; vector<int>C,D; D.push_back(A[p]); for(R i=A.size()-1;i!=-1;i--){ if(i!=p){ C.push_back(A[i]); } } random_shuffle(C.begin(),C.end()); for(vector<int>::iterator T=C.begin();T!=C.end();T++){ if((B&S[*T]).count()>q){ B&=S[*T]; D.push_back(*T); } } if(D.size()>E.size()){ E=D; } p++; if(p==A.size()){ p=0; } } for(vector<int>::iterator T=E.begin();T!=E.end();T++){ c[*T]=true; } for(R i=0;i!=m;i++){ if(c[i]==true){ cout<<1; }else{ cout<<0; } } return 0; }

#include <bits/stdc++.h> using namespace std; const long long MOD = 998244353; const long long INF = 1000000000; void solve() { long long n; string s; cin >> n; vector<long long> p(n); vector<long long> ans(n); for (int i = 0; i < n; i++) { long long x; cin >> x; p[--x] = i; } cin >> s; long long ones = 1; long long nuls = 1; for (long long i = 0; i < n; i++) if (s[i] == 0 ) ++nuls; for (long long i = 0; i < n; i++) { if (s[p[i]] == 0 ) { ans[p[i]] = ones; ++ones; } else { ans[p[i]] = nuls; ++nuls; } } for (long long i = 0; i < n; i++) cout << ans[i] << ; cout << endl; } int main(void) { ios_base::sync_with_stdio(false); cin.tie(nullptr); int t; cin >> t; while (t--) solve(); return 0; }

#include <bits/stdc++.h> using namespace std; #define send {ios_base::sync_with_stdio(false);} #define help {cin.tie(NULL);} #define f first #define s second #define pb push_back #define vi vector<long long> #define vii vector<pair<long long,long long>> #define dict unordered_map<long long, long long> #define contains(d,x) (d.find(x)!=d.end()) typedef long long ll; typedef long double lld; typedef unsigned long long ull; const lld pi = 3.14159265358979323846; const ll mod = 1000000007; // const ll mod = 998244353; ll n, m, k, l, p, q, r, x, y, z, sz; const ll template_array_size = 1e6 + 5; ll a[template_array_size]; ll b[template_array_size]; ll c[template_array_size]; string s, t; ll ans = 0; ll ts[5000000]; ll power(int x, int y){ if(!y) return 1; ll temp = power(x, y/2); temp = (temp*temp)%mod; if(y&1){ return (temp*x)%mod; } return temp; } int find(int i, ll rep[]) { int t = i; while(rep[i]!=i){ i = rep[i]; } while(rep[t]!=t){ t = rep[t]; rep[t] = i; } return i; } int onion(int i, int j, ll rep[]){ i = find(i,rep); j = find(j,rep); rep[j] = i; return i!=j; } void solve(int tc = 0) { cin >> n >> m; vector<vii> adj(m+1); vi chosen; for(int i=0; i<m+1; i++) a[i] = i; for(int i=0; i<n; i++) { cin >> x; if (x==1) { cin >> y; x = 0; } else { cin >> x >> y; } if(onion(x,y,a)){ chosen.pb(i+1); } } p = chosen.size(); ans = power(2,p); cout << ans << << p << endl; for(int i : chosen) cout << i << ; cout << endl; } int main() { send help // int tc = 1; // cin >> tc; // for (int t = 0; t < tc; t++) solve(t); solve(); }

#include <bits/stdc++.h> int main() { int n, k, s = 0; scanf( %d%d , &n, &k); int a[n]; for (int i = 0; i < n; i++) { scanf( %d , &a[i]); } for (int j = 0; j < n; j++) { if (n == k && a[j] >= a[k - 1] && a[j] > 0) s++; else if (a[j] >= a[k - 1] && a[j] > 0) s++; } printf( %d , s); }

#include <bits/stdc++.h> using namespace std; int a, b, m[1000]; int s = 0; int main() { int n; cin >> n; int z = n; while (n > 0) { s = 0; cin >> a >> b; while (a > 0 && b > 0) { if (a >= b) { int t = a / b; a = a % b; s += t; } else { int t = b / a; b = b % a; s += t; } } m[z - n + 1] = s; --n; } int j; for (j = 1; j <= z; ++j) cout << m[j] << endl; }

#include <bits/stdc++.h> using namespace std; void doRoutine() { ios_base::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr); srand(322179); } const int C = 5010; int tr[C * 8]; bool cross(pair<pair<int, int>, int> hor, pair<int, pair<int, int> > vert) { return (vert.second.first <= hor.second && hor.second <= vert.second.second) && (hor.first.first <= vert.first && vert.first <= hor.first.second); } void init() { for (int i = 0; i < C * 8; ++i) { tr[i] = 0; } } int get(int l, int r, int lb = -C, int rb = C, int v = 0) { if (l == lb && r == rb) { return tr[v]; } else { int mb = (lb + rb) / 2; if (r <= mb) { return get(l, r, lb, mb, v * 2 + 1); } else if (l >= mb) { return get(l, r, mb, rb, v * 2 + 2); } else { return get(l, mb, lb, mb, v * 2 + 1) + get(mb, r, mb, rb, v * 2 + 2); } } } void add(int i, int x, int lb = -C, int rb = C, int v = 0) { if (lb + 1 == rb) { tr[v] += x; } else { int mb = (lb + rb) / 2; if (i < mb) { add(i, x, lb, mb, v * 2 + 1); } else if (i >= mb) { add(i, x, mb, rb, v * 2 + 2); } tr[v] = tr[v * 2 + 1] + tr[v * 2 + 2]; } } signed main() { doRoutine(); int n; cin >> n; vector<pair<int, pair<int, int> > > verts; vector<pair<pair<int, int>, int> > hors; for (int i = 0; i < n; ++i) { int x1, y1, x2, y2; cin >> x1 >> y1 >> x2 >> y2; if (x1 > x2) { swap(x1, x2); } if (y1 > y2) { swap(y1, y2); } if (x1 == x2) { verts.push_back({x1, {y1, y2}}); } else { hors.push_back({{x1, x2}, y1}); } } sort(verts.begin(), verts.end()); long long ans = 0; for (int i = 0; i < verts.size(); ++i) { vector<pair<int, int> > events; for (auto seg : hors) { if (cross(seg, verts[i])) { events.push_back({seg.first.second, seg.second}); } } if (!events.empty()) { sort(events.begin(), events.end()); reverse(events.begin(), events.end()); int ptr = 0; init(); for (int j = (int)verts.size() - 1; j > i; --j) { while ((ptr < events.size() && events[ptr].first >= verts[j].first)) { add(events[ptr].second, 1); ++ptr; } int cnt = get(verts[j].second.first, verts[j].second.second + 1); ans += cnt * (cnt - 1) / 2; } } } cout << ans << endl; return 0; }

#include <bits/stdc++.h> using namespace std; #pragma GCC target( sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native ) #pragma GCC optimize( unroll-loops ) #pragma GCC optimize( Ofast ) #pragma GCC optimize( O3 ) #pragma GCC target( avx ) const long long INF = numeric_limits<long long>::max(); const long double PI = 3.1415926535898; const long long MOD = 1000000007; const long long LIM = 100005; long long fpow(long long x, long long y) { long long temp; if (y == 0) return 1; temp = fpow(x, y / 2); if (y % 2 == 0) return temp * temp; else return x * temp * temp; } long long gcd(long long a, long long b) { if (b == 0) return a; return gcd(b, a % b); } bool isPrime(long long n) { if (n <= 1) return false; if (n <= 3) return true; if (n % 2 == 0 || n % 3 == 0) return false; for (long long i = 5; i * i <= n; i = i + 6) if (n % i == 0 || n % (i + 2) == 0) return false; return true; } long long modInverse(long long n, long long p) { return fpow(n, p - 2); } map<long long, long long> primeFactors(long long n) { map<long long, long long> mp; while (n % 2 == 0) { if (mp.count(2) == 1) mp[2]++; else mp.insert({2, 1}); n = n / 2; } for (long long i = 3; i <= sqrt(n); i = i + 2) { while (n % i == 0) { if (mp.count(i) == 1) mp[i]++; else mp.insert({i, 1}); n = n / i; } } if (n > 2) { if (mp.count(n) == 1) mp[n]++; else mp.insert({n, 1}); } return mp; } int32_t main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); long long t; cin >> t; for (long long tt = 1; tt <= t; ++tt) { long long n, ans = 0; cin >> n; vector<long long> t(n + 1); for (long long i = 1; i <= n; i++) cin >> t[i]; t[0] = 0; sort(t.begin(), t.end()); ; long long dp[n + 1][2 * n + 1]; for (long long i = 0; i <= n; i++) for (long long j = 0; j <= 2 * n; j++) dp[i][j] = INF; for (long long i = 0; i <= 2 * n; i++) dp[0][i] = 0; for (long long i = 1; i <= n; i++) { for (long long j = i; j <= 2 * n; j++) { dp[i][j] = min(dp[i][j - 1], dp[i - 1][j - 1] + abs(t[i] - j)); } } ans = dp[n][2 * n]; cout << ans << n ; } return 0; }

#include <bits/stdc++.h> using namespace std; char str[11][11]; int f[8][20][20]; int dx[] = {0, 1, -1, -1, 1, 1, 0, -1}, dy[] = {-1, -1, -1, 0, 0, 1, 1, 1}; bool check() { memset(f, 0, sizeof f); for (int i = 1; i <= 10; i++) for (int j = 1; j <= 10; j++) { if (str[i][j] != X ) continue; for (int k = 0; k < 4; k++) f[k][i][j] = f[k][i + dy[k]][j + dx[k]] + 1; } for (int i = 10; i >= 1; i--) for (int j = 10; j >= 1; j--) { if (str[i][j] != X ) continue; for (int k = 4; k < 8; k++) f[k][i][j] = f[k][i + dy[k]][j + dx[k]] + 1; } for (int i = 1; i <= 10; i++) for (int j = 1; j <= 10; j++) for (int k = 0; k < 8; k++) if (f[k][i][j] >= 5) return 1; return 0; } int main() { for (int i = 1; i <= 10; i++) scanf( %s , str[i] + 1); for (int i = 1; i <= 10; i++) for (int j = 1; j <= 10; j++) { if (str[i][j] != . ) continue; str[i][j] = X ; if (check()) { puts( YES ); return 0; } str[i][j] = . ; } puts( NO ); return 0; }

#include <bits/stdc++.h> using namespace std; int n, k, l, r, mid, a; int main() { cin >> n >> k; a = 240 - k; l = 0; r = n + 1; while (r - l > 1) { mid = (r + l) / 2; if (5 * (mid * (mid + 1) / 2) > a) { r = mid; } else { l = mid; } } cout << l << endl; return 0; }

//Saptak_Roy_Turja #include<bits/stdc++.h> #define ll long long int using namespace std; int main() { int t; cin>>t; while(t--){ ll n,a,b,c=1,i; string s; cin>>n>>a>>b>>s; for(i=1;i<n;i++){ if(s[i]!=s[i-1]){ c++; } } if(b>=0){ cout<<n*(a+b)<< n ; } else { cout<<n*a+b*(c/2+1)<< n ; } } }

#include <bits/stdc++.h> using namespace std; long long n, k, l, r, mid, ans; long long a[200100]; bool check(long long x) { long long p, q; double sum = 0, s; for (long long i = 1; i <= n; i++) { if (a[i] == 0) continue; s = a[i]; if (a[i] >= k) return 1; p = x - 1; q = n - i + x - 1; p = min(p, q - p); while (p) { s = s * q / p; p--; q--; if (s >= k) return 1; } sum += s; if (sum >= k) return 1; } return 0; } int main() { scanf( %I64d%I64d , &n, &k); for (int i = 1; i <= n; i++) { scanf( %I64d , &a[i]); if (a[i] >= k) { puts( 0 ); return 0; } } l = 1; r = k; while (l <= r) { mid = (l + r) >> 1; if (check(mid)) { ans = mid; r = mid - 1; } else l = mid + 1; } printf( %I64d n , ans); return 0; }

#include <bits/stdc++.h> using namespace std; const string yno[2] = { NO n , YES n }; int dem(vector<int> &a, int k) { return upper_bound(a.begin(), a.end(), k) - lower_bound(a.begin(), a.end(), k); } int dem(long long k) { int ans = 0; while (k) { ans += k & 1; k >>= 1; } return ans; } void process() { int n, m; cin >> n >> m; vector<int> a(n), b(m); for (int &i : a) cin >> i; for (int &i : b) cin >> i; vector<pair<long long, long long> > c; map<int, pair<long long, long long> > M; for (int i = 0; i <= n - 1; i++) { for (int j = 0; j <= m - 1; j++) { M[a[i] + b[j]].first |= (1ll << i); M[a[i] + b[j]].second |= (1ll << j); } } for (auto it = M.begin(); it != M.end(); it++) { c.push_back(it->second); } int ans = 0; for (int i = 0; i < c.size(); i++) { for (int j = i; j < c.size(); j++) { ans = max(ans, __builtin_popcountll(c[i].first | c[j].first) + __builtin_popcountll(c[i].second | c[j].second)); } } cout << ans; } int main() { ios_base::sync_with_stdio(false); cin.tie(0); process(); return 0; }

#include <bits/stdc++.h> using namespace std; const int N = 252; int dis(int x1, int y1, int x2, int y2) { return abs(x1 - x2) + abs(y1 - y2); } bool Gao(int x1, int y1, int x2, int y2) { if (dis(0, 0, x1, y1) <= max(x2, y2)) return true; for (int i = 1; i <= min(x2, y2); ++i) { if (dis(x2 - i, y2 - i, x1, y1) <= i) return true; } return false; } int main() { int x1, x2, y1, y2; while (cin >> x1 >> y1 >> x2 >> y2) { if (Gao(x1, y1, x2, y2)) cout << Polycarp << endl; else cout << Vasiliy << endl; } return 0; }

#include <bits/stdc++.h> using namespace std; int n, p[1005]; vector<int> T; bool ok; inline void enter() { cin >> n; for (int i = 1; i <= n; i++) cin >> p[i]; } void dfs(int u) { while (T[u] != 1) { T[u]++; u = p[u]; } cout << u << ; } inline void solve() { for (int i = 1; i <= n; i++) { T.assign(n + 4, 0); dfs(i); } } int main() { enter(); solve(); return 0; }

#include <bits/stdc++.h> using namespace std; int n, t; string s; int puc(int k, int t) { vector<int> v(n + 1, 0); v[n - 1] = (s[n - 1] == H ); for (int i = n - 2; i >= 0; --i) v[i] = v[i + 1] + (s[i] == H ); int nh = 0, ns = 0; for (int i = 0; i < int(n); ++i) { if (s[i] == H ) ++nh; else if (s[i] == S ) ++ns; } if (k + ns < nh) return 0; int zk = k; int ret = 0; int qui = -1, q = 0; for (int i = 0; i < n; ++i) { if (s[i] == S ) { ++k; --ns; } else if (s[i] == H ) { --nh; if (k > 0) --k; else if (qui == -1) { qui = i; q = 1; } else ++q; } if (nh == 0 and k >= q) { if (qui == -1 and ret < t) return true; if (ret + (i - qui) < t) return true; break; } ++ret; } k = zk; int ult = -1; int r = 0; int ans = 0; for (int i = 0; i < int(n); ++i) { if (s[i] == S ) ++k; if (k >= r and ult != -1) { ans += i - ult; if (v[i] > 0) ans += i - ult; k -= r; ult = -1; r = 0; } if (s[i] == H ) { if (k > 0) --k; else if (ult == -1) { ult = i; r = 1; } else ++r; } if (ult == -1 and v[i + 1] == 0) break; ++ans; } return (ult == -1 and ans < t); } int main() { cin >> n >> t; cin >> s; int lo = 0, hi = n, m; while (hi - lo > 5) { int m = (lo + hi) / 2; if (puc(m, t)) hi = m; else lo = m; } bool trobat = 0; if (puc(0, t)) { cout << 0 << endl; trobat = true; } for (int k = lo; !trobat and k <= hi; ++k) { if (puc(k, t)) { cout << k << endl; trobat = true; } } if (!trobat) cout << -1 << endl; }

#include <bits/stdc++.h> using namespace std; const string YES = Yes ; const string NO = No ; string solve() { int N; cin >> N; vector<int> p(N); for (int i = 0; i < (N); ++i) { cin >> p[i]; } for (int i = 0; i < (N - 1); ++i) { if (p[i] + 1 == p[i + 1]) { continue; } if (p[i] > p[i + 1]) { continue; } return NO; } return YES; } int main() { ios::sync_with_stdio(false); cin.tie(nullptr); int T; cin >> T; for (int t = 0; t < (T); ++t) { cout << solve() << endl; } return 0; }

#include <bits/stdc++.h> using namespace std; int main() { int arr[6], i, sum = 0; for (i = 0; i < 5; i++) { scanf( %d , &arr[i]); sum = sum + arr[i]; } if (sum == 0) { printf( -1 n ); } else if (sum % 5 == 0) { printf( %d , sum / 5); } else { printf( -1 ); } return 0; }

#include <bits/stdc++.h> using namespace std; int main() { long long n, a, b, c, ans, boby, apu; cin >> n; while (n--) { cin >> a >> b >> c >> ans; boby = b - a; apu = c + ans; if (boby % apu == 0) { cout << boby / apu << endl; } else cout << -1 << endl; } return 0; }

#include <bits/stdc++.h> using namespace std; const int oo = 1e9; const int N = 5001; const int maxxor = (1 << 13); int f[2][maxxor]; vector<int> a[N]; int cnp(int l, int r, int pos, int id) { if (l > r) return oo; int mid = (l + r) / 2; if (a[id][mid] > pos) return min(a[id][mid], cnp(l, mid - 1, pos, id)); return cnp(mid + 1, r, pos, id); } signed main() { ios::sync_with_stdio(false); cin.tie(0); int n; cin >> n; for (int i = 1; i <= n; i++) { int x; cin >> x; a[x].push_back(i); } for (int i = 0; i <= 1; i++) for (int j = 0; j < maxxor; j++) f[i][j] = oo; f[0][0] = 0; int id; vector<int> res; for (int i = 1; i < N; i++) { int now = i & 1; int back = now ^ 1; for (int j = 0; j < maxxor; j++) { f[now][j] = f[back][j]; if (a[i].size() == 0) { if (i == N - 1 && f[now][j] != oo) res.push_back(j); continue; } int pos = f[back][j ^ i]; id = cnp(0, a[i].size() - 1, pos, i); if (id != oo) f[now][j] = min(f[now][j], id); if (i == N - 1 && f[now][j] != oo) res.push_back(j); } } cout << res.size() << endl; for (int xnew : res) cout << xnew << ; return 0; }

#include <bits/stdc++.h> using namespace std; inline int add(int a, int b) { return (a + b >= 1000000007) ? a + b - 1000000007 : a + b; } inline void inc(int &a, int b) { a = add(a, b); } inline int sub(int a, int b) { return (a - b < 0) ? a - b + 1000000007 : a - b; } inline void dec(int &a, int b) { a = sub(a, b); } inline int mul(int a, int b) { return 1ll * a * b % 1000000007; } inline void grow(int &a, int b) { a = mul(a, b); } const int INV = 205555557; int phi[1000005]; int pre[1000005]; int f[1000005]; int onepre[1000005]; int twopre[1000005]; void phiCalc() { phi[0] = 0; phi[1] = 1; for (int i = 2; i <= 1000005 - 1; i++) phi[i] = i; for (int i = 2; i <= 1000005 - 1; i++) { if (phi[i] == i) { for (int j = i; j <= 1000005 - 1; j += i) phi[j] -= phi[j] / i; } } } int func(int n, int m) { int res = sub(0, INV); grow(res, n); grow(res, n + 1); grow(res, n + 2); int tres = 15; inc(tres, mul(4, mul(n, mul(n, n)))); dec(tres, mul(12, mul(n, n))); dec(tres, mul(7, n)); int ttres = mul(n, n); dec(ttres, mul(3, n)); dec(ttres, 3); grow(ttres, sub(0, 6)); grow(ttres, m); return mul(res, add(tres, ttres)); } int main() { ios_base::sync_with_stdio(false); cin.tie(0); phiCalc(); for (int i = 1; i < 1000005; i++) { for (int j = i; j < 1000005; j += i) inc(f[j], mul(i, phi[j / i])); } pre[0] = f[0]; onepre[0] = twopre[0] = 0; for (int i = 1; i < 1000005; i++) { pre[i] = add(pre[i - 1], f[i]); onepre[i] = add(onepre[i - 1], mul(i, f[i])); twopre[i] = add(twopre[i - 1], mul(mul(i, i), f[i])); } int t; cin >> t; while (t--) { int n, m; cin >> n >> m; if (n > m) swap(n, m); int ans = 0; inc(ans, pre[n]); inc(ans, twopre[n]); dec(ans, mul(2, onepre[n])); inc(ans, mul(m, mul(n, pre[n]))); dec(ans, mul(m, onepre[n])); inc(ans, mul(m, pre[n])); dec(ans, mul(n, onepre[n])); inc(ans, mul(n, pre[n])); grow(ans, 2); inc(ans, func(n, m)); cout << ans << endl; } }

#include <bits/stdc++.h> using namespace std; int read() { int f = 1, x = 0; char s = getchar(); while (s < 0 || s > 9 ) { if (s == - ) f = -1; s = getchar(); } while (s >= 0 && s <= 9 ) { x = x * 10 + s - 0 ; s = getchar(); } return x * f; } int len[300 + 5]; string str[300 + 5]; bool vis[300 + 5][300 + 5]; int main() { int n = read(), Ans; for (int i = 1; i <= n; i++) { cin >> str[i]; len[i] = int(str[i].length()) + len[i - 1]; } Ans = len[n] + n - 1; for (int i = 1; i <= n; i++) { for (int j = i; j <= n; j++) { int tmp = 0; if (vis[i][j]) continue; vis[i][j] = 1; for (int t = j + 1; t <= n - j + i; t++) { bool flag = 0; for (int s = 0; s <= j - i; s++) if (str[i + s] != str[t + s]) { flag++; break; } if (!flag) tmp++, t += j - i, vis[t][t + j - i] = 1; } if (tmp != 0) { int tot = len[n] - (tmp + 1) * (len[j] - len[i - 1]) + tmp + n; Ans = min(Ans, tot); } } } printf( %d n , Ans); return 0; }

#include <bits/stdc++.h> using namespace std; const long long INF = 1e18, MAXN = 1e5 + 128, MOD = 998244353; long long binpow(long long a, long long n) { long long res = 1; while (n) { if (n & 1) res *= a; a *= a; n >>= 1; } return res; } long long NOD(long long NOD1, long long NOD2) { while (NOD2) { NOD1 %= NOD2; swap(NOD1, NOD2); } return NOD1; } long long NOK(long long NOK1, long long NOK2) { return NOK1 * NOK2 / NOD(NOK1, NOK2); } long long n, i1, i2; string s; char a, b; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); cin >> n >> s; a = s[0]; for (int i = 0; i < n; i++) if (a == s[i]) i1 = i; else break; b = s[n - 1]; for (int i = n - 1; i >= 0; i--) if (b == s[i]) i2 = i; else break; i2 = n - i2; if (b == a) cout << ((i1 + 2) * (i2 + 1)) % MOD; else cout << (i2 + i1 + 2) % MOD; }

#include <bits/stdc++.h> using namespace std; const int maxint = 0x7fffffff; const int minint = 0x80000000; const double eps = 1e-6; int gcd(int a, int b) { if (b == 0) return a; return gcd(b, a % b); } int max(int a, int b) { return a > b ? a : b; } int main() { int sum, d, n, a; scanf( %d , &d); scanf( %d , &n); sum = 0; while (--n) { scanf( %d , &a); sum += d - a; } scanf( %d , &a); printf( %d n , sum); return 0; }

#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); int t, n; cin >> t; while (t--) { string A, B; cin >> n; cin >> A >> B; int f = 1; for (int i = 0; i < n; ++i) { if (A[i] > B[i]) f = 0; } if (!f) { cout << -1 << n ; continue; } int ans = 0; for (int i = 0; i < 26; ++i) { bitset<27> good; for (int j = 0; j < n; ++j) { if (A[j] == B[j]) continue; if (B[j] == char( a + i)) { good[A[j] - a ] = 1; } } ans += good.count(); for (int j = 0; j < n; ++j) { if (A[j] == B[j]) continue; if (good[A[j] - a ] == 1) A[j] = char( a + i); } } cout << ans << n ; } return 0; }

#include <bits/stdc++.h> using namespace std; const int M = 1e5 + 5; int n, k; vector<pair<int, int> > g[M]; int ans; int dp[M][2]; void dfs(int u, int Pa) { vector<pair<int, int> > ch; for (auto p : g[u]) { int v = p.first, w = p.second; if (v == Pa) continue; dfs(v, u); ch.push_back(make_pair(dp[v][0] + w, dp[v][1] + w)); } bool flag = ch.size() > 0; if (flag) { sort(ch.begin(), ch.end(), [&](pair<int, int> a, pair<int, int> b) { return a.second > b.second; }); } for (int i = 0; i < k - 1 && i < ch.size(); i++) { dp[u][1] += ch[i].second; } if (ch.size() <= k) { for (auto p : ch) { dp[u][0] += p.second; } if (flag) { sort(ch.begin(), ch.end(), [&](pair<int, int> a, pair<int, int> b) { return a.first - a.second > b.first - b.second; }); dp[u][0] += ch[0].first - ch[0].second; } } else { int max_val = -1e9; for (int i = k; i < ch.size(); i++) { max_val = max(max_val, ch[i].first); } int sum = 0; for (int i = 0; i < k; i++) { sum += ch[i].second; } for (int i = 0; i < k; i++) { dp[u][0] = max(dp[u][0], sum - ch[i].second + max(max_val, ch[i].first)); } } } int main() { scanf( %d%d , &n, &k); for (int i = 1; i < n; i++) { int u, v, c; scanf( %d%d%d , &u, &v, &c); u++, v++; g[u].push_back(make_pair(v, c)); g[v].push_back(make_pair(u, c)); } dfs(1, 0); printf( %d n , dp[1][0]); }

#include <bits/stdc++.h> using namespace std; const int N = 100002; int arr[N], n, inc[N], decr[N]; int tree[4 * N]; int update(int pos, int l, int r, int x, int v) { if (l > x || r < x) return tree[pos]; if (l == r) return tree[pos] = max(tree[pos], v); int mid = (l + r) / 2; return tree[pos] = max(update(pos * 2, l, mid, x, v), update(pos * 2 + 1, mid + 1, r, x, v)); } int get(int pos, int l, int r, int qLow, int qHigh) { if (l > qHigh || r < qLow) return 0; if (l >= qLow && r <= qHigh) return tree[pos]; int mid = (l + r) / 2; return max(get(pos * 2, l, mid, qLow, qHigh), get(pos * 2 + 1, mid + 1, r, qLow, qHigh)); } int bitonic() { int i, max; inc[1] = 1; update(1, 0, n, arr[1], 1); for (i = 2; i <= n; i++) { int x = get(1, 0, n, 0, arr[i]); inc[i] = x + 1; update(1, 0, n, arr[i], inc[i]); } memset(tree, 0, sizeof tree); decr[n] = 1; update(1, 0, n, arr[n], 1); for (i = n - 1; i > 0; i--) { int x = get(1, 0, n, 0, arr[i]); decr[i] = x + 1; update(1, 0, n, arr[i], decr[i]); } max = 0; for (i = 0; i <= n; i++) if (inc[i] + decr[i] - 1 > max) max = inc[i] + decr[i] - 1; return max; } int main() { int a, b; scanf( %d%d , &a, &n); for (int i = 0; i < a; i++) { int x, y; scanf( %d%d , &x, &y); arr[x]++, arr[y + 1]--; } for (int i = 1; i <= n; i++) arr[i] += arr[i - 1]; printf( %d , bitonic()); return 0; }

#include <bits/stdc++.h> int main() { char s[50]; scanf( %s , s); int i, l = strlen(s), flag = 0; for (i = 0; i < l; i++) { if (s[i] != s[l - i - 1]) flag++; } if (flag == 2) printf( YES ); else if (flag == 0 && strlen(s) % 2 == 1) printf( YES ); else printf( NO ); return 0; }

#include <bits/stdc++.h> using namespace std; long long l, r, f[100]; bool check(string s, int x, int y) { if (s.size() % x != 0) return false; for (int i = 0; i + x < s.size() and i + x < y + 1; i++) if (s[i] != s[i + x]) return false; return true; } long long p(int x) { long long ans = 0; for (int i = 1; i <= x; i++) if (x % i == 0) { f[i] = pow(2, i - 1); } for (int j = 1; j < x; j++) { if (x % j != 0) continue; ans += f[j]; for (int u = j * 2; u < x; u += j) f[u] -= f[j]; } return ans; } long long solve(long long a) { long long ans = 0; string s = ; while (a) { s += (a % (long long)2) + 0 ; a /= (long long)2; } reverse(s.begin(), s.end()); bool no = 0; for (int i = 1; i < s.size(); i++) { if (check(s, i, 100000)) { no = 1; } } for (int i = 1; i < s.size(); i++) { if (s[i] == 0 ) continue; s[i] = 0 ; for (int j = 1; j <= i; j++) { f[j] = check(s, j, i); } for (int j = i + 1; j < s.size(); j++) f[j] = pow(2, j - i - 1); s[i] = 1 ; for (int j = 1; j < s.size(); j++) { if (s.size() % j != 0) continue; ans += f[j]; for (int u = j * 2; u < s.size(); u += j) f[u] -= f[j]; } } for (int i = s.size() - 1; i >= 1; i--) ans += p(i); ans += no; return ans; } int main() { scanf( %lld%lld , &l, &r); printf( %lld , solve(r) - solve(l - 1)); }

#include <bits/stdc++.h> long long z; int l, r, i, j, k, ans; short p; std::vector<short> prm; std::vector<int> to; short dp[3000111]; bool done[3000111]; void dfs(long long now, char cnt) { to.push_back(now); for (; cnt < prm.size() && now * prm[cnt] <= r; ++cnt) dfs(now * prm[cnt], cnt); } int main() { prm.reserve(29); to.reserve(3000111); scanf( %d %d %hd , &l, &r, &p); for (i = 2; i < p; ++i) { for (j = 2; j * j <= i; ++j) if (i % j == 0) break; if (j * j > i) prm.push_back(i); } dfs(1, 0); std::sort(to.begin(), to.end()); memset(dp, 0x3f, sizeof(dp)); dp[0] = 0; for (i = 2; i < p; ++i) for (j = 0, k = 1; j < to.size(); ++j) { for (z = to[j] * i; k < to.size() && to[k] < z; ++k) ; if (to[k] == z && dp[k] > dp[j] + 1) { dp[k] = dp[j] + 1; if (i + dp[k] <= p) done[k] = true; } } r = std::min(r, to.back()); for (i = 0; i < to.size() && to[i] < l; ++i) ; for (; i < to.size() && to[i] <= r; ++i) if (done[i]) ++ans; printf( %d n , ans); return 0; }

#include <bits/stdc++.h> using namespace std; const int mod = 1e9 + 7; long long N; long long fac(long long x) { long long res = 1; for (int i = 1; i <= x; ++i) res = res * i % mod; return res; } long long qpow(long long x, long long y) { long long res = 1; for (; y; x = x * x % mod, y >>= 1) if (y & 1) res = res * x % mod; return res; } int main() { scanf( %lld , &N); long long fz = fac(2 * N - 1), fm = fac(N - 1) * fac(N) % mod; printf( %lld n , (2 * fz % mod * qpow(fm, mod - 2) % mod - N + mod) % mod); return 0; }

#include <bits/stdc++.h> using namespace std; vector<vector<long long int> > dp; vector<long long int> a; long long int check(long long int l, long long int r) { if (l >= r) return 0; if (dp[l][r]) return dp[l][r]; if (l + 1 == r) { dp[l][r] = a[r]; return a[r]; } dp[l][r] = -1; for (int m = l + 1; m < r; ++m) { long long int lf = check(l, m), rt = check(m, r); if (lf > 0 && lf == rt) { dp[l][r] = lf + 1; return lf + 1; } } return dp[l][r]; } int main() { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); long long int n; cin >> n; a.resize(n + 1); for (int i = 1; i <= n; ++i) cin >> a[i]; dp.assign(n + 1, vector<long long int>(n + 1, 0)); vector<long long int> ans(n + 1, 1e9); ans[0] = 0; for (int i = 0; i < n; ++i) { for (int j = i + 1; j <= n; ++j) { if (check(i, j) > 0) ans[j] = min(ans[j], ans[i] + 1); } } cout << ans[n]; }

#include <bits/stdc++.h> using namespace std; int main() { long long n, k, B, c; cin >> n >> k >> B >> c; long long a[n]; for (int i = 0; i < n; i++) cin >> a[i]; long long x = *min_element(a, a + n); for (int i = 0; i < n; i++) a[i] = a[i] - x; B = min(B, 5 * c); long long ans = 1e18; for (int t = 0; t < 5; t++) { pair<long long, long long> b[n]; for (int i = 0; i < n; i++) { b[i] = {a[i], 0}; while (b[i].first % 5 != t) { b[i].first++; b[i].second += c; } b[i].first /= 5; } sort(b, b + n); priority_queue<long long> G; long long suma = 0; for (int i = 0; i < n; i++) { if (G.size() >= k - 1) { ans = min(ans, b[i].second + b[i].first * B * (k - 1) + suma); } G.push(b[i].second - b[i].first * B); suma += b[i].second - b[i].first * B; while (G.size() >= k) { suma -= G.top(); G.pop(); } } } cout << ans << n ; }

#include <bits/stdc++.h> #pragma GCC optimize( O3 ) #pragma GCC optimize( Ofast,no-stack-protector ) using namespace std; function<void(void)> ____ = []() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); }; template <typename T> vector<T> &operator<<(vector<T> &__container, T x) { __container.push_back(x); return __container; } template <typename T> ostream &operator<<(ostream &out, vector<T> &__container) { for (T _ : __container) out << _ << ; return out; } const int MAXN = 1e5 + 7; struct EDGE { int to, cap, rev; EDGE(){}; EDGE(int to, int cap, int rev) : to(to), cap(cap), rev(rev){}; }; vector<EDGE> G[MAXN]; int iter[MAXN], rk[MAXN]; void ADDEDGE(int u, int v, int cap) { G[u].push_back(EDGE(v, cap, (int)G[v].size())); G[v].push_back(EDGE(u, 0, (int)G[u].size() - 1)); } bool bfs() { memset(rk, 0, sizeof(rk)); memset(iter, 0, sizeof(iter)); rk[0] = 1; queue<int> que; que.push(0); while (!que.empty()) { int u = que.front(); que.pop(); for (auto e : G[u]) { if (!e.cap or rk[e.to]) continue; rk[e.to] = rk[u] + 1; que.push(e.to); } } return rk[MAXN - 1] != 0; } int dfs(int u, int flow) { if (u == MAXN - 1) return flow; for (int &i = iter[u]; i < (int)G[u].size(); i++) { auto &e = G[u][i]; if (!e.cap or rk[e.to] != rk[u] + 1) continue; int d = dfs(e.to, min(e.cap, flow)); if (d) { e.cap -= d; G[e.to][e.rev].cap += d; return d; } } return 0; } int Dinic() { int flow = 0; while (bfs()) { int d = dfs(0, 0x3f3f3f3f); while (d) { flow += d; d = dfs(0, 0x3f3f3f3f); } } return flow; } int n, m, idud[222][222], idlr[MAXN][222]; char g[222][222]; void solve() { scanf( %d , &n); scanf( %d , &m); int cur = 1, cnt = 0, tot = 0; for (int i = 1; i <= n; i++) scanf( %s , g[i] + 1); for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) if (g[i][j] == # ) tot++; for (int i = 1; i < n; i++) for (int j = 1; j <= m; j++) idud[i][j] = cur++; for (int i = 1; i <= n; i++) for (int j = 1; j < m; j++) idlr[i][j] = cur++; for (int i = 1; i < n; i++) for (int j = 1; j <= m; j++) if (g[i][j] == # and g[i + 1][j] == # ) ADDEDGE(0, idud[i][j], 1), cnt++; for (int i = 1; i <= n; i++) for (int j = 1; j < m; j++) if (g[i][j] == # and g[i][j + 1] == # ) ADDEDGE(idlr[i][j], MAXN - 1, 1), cnt++; for (int i = 1; i < n; i++) for (int j = 1; j <= m; j++) { if (g[i][j] == # and g[i + 1][j] == # ) { if (g[i][j - 1] == # ) ADDEDGE(idud[i][j], idlr[i][j - 1], 0x3f3f3f3f); if (g[i + 1][j - 1] == # ) ADDEDGE(idud[i][j], idlr[i + 1][j - 1], 0x3f3f3f3f); if (g[i][j + 1] == # ) ADDEDGE(idud[i][j], idlr[i][j], 0x3f3f3f3f); if (g[i + 1][j + 1] == # ) ADDEDGE(idud[i][j], idlr[i + 1][j], 0x3f3f3f3f); } } cout << tot - (cnt - Dinic()) << n ; } int main() { solve(); return 0; }

#include <bits/stdc++.h> using namespace std; inline int in() { int x, y; y = scanf( %d , &x); return x; } const int N = -1; int main() { int X = in(), d = in(); vector<long long> v; v.push_back(0); int b = 0; while (X) { if (X % 2) { v.push_back(v.back() + d); long long back = v.back(); for (int j = 0; j < b; j++) v.push_back(back + d); } X /= 2; b++; } cout << (int)v.size() - 1 << endl; for (int i = 1; i < v.size(); i++) cout << v[i] << ; cout << endl; return 0; }

#include <bits/stdc++.h> const int maxN = 2000; const unsigned int mod = 998244353; constexpr int inf = INT_MAX; class Array { public: inline const int *begin() const { return data; } inline const int *end() const { return endPtr; } inline void push_back(const int x) { *(endPtr++) = x; } inline size_t size() const { return endPtr - data; } template <class T> inline void foreach (T fun) const { std::for_each<const int *>(data, endPtr, fun); } private: int data[maxN + 10], *endPtr = data; }; Array edgeIn[maxN + 10], edgeOut[maxN + 10]; int originDegree[maxN + 10], degree[maxN + 10]; inline void reset(const int n) { std::memcpy(degree, originDegree, sizeof(degree[0]) * n); } void readGraph(const int n) { for (int i = 0; i < n; ++i) { static char str[maxN + 10]; std::cin >> str; for (int j = 0; j < n; ++j) if (str[j] == 1 ) { edgeIn[j].push_back(i); edgeOut[i].push_back(j); ++originDegree[i]; } } } bool isStrongConnect(const int n) { std::sort(degree, degree + n); int sum = 0; for (int i = 0; i + 1 < n; ++i) { sum += degree[i]; if (i * (i + 1) / 2 == sum) return false; } return true; } void reverseSet(const int n, const unsigned int set) { for (int i = 0; i < n; ++i) for (auto to : edgeOut[i]) if ((((set) >> (i)) & 0x01u) ^ (((set) >> (to)) & 0x01u)) { --degree[i]; ++degree[to]; } } inline bool checkSet(const int n, const unsigned int set) { reset(n); reverseSet(n, set); return isStrongConnect(n); } void reverseSingle(const int vertex) { edgeOut[vertex].foreach ([](int p) { ++degree[p]; }); edgeIn[vertex].foreach ([](int p) { --degree[p]; }); degree[vertex] = edgeIn[vertex].size(); } inline bool checkSingle(const int n, const int vertex) { reset(n); reverseSingle(vertex); return isStrongConnect(n); } unsigned int factor(const unsigned int n) { unsigned int ret = 1; for (unsigned int i = 2; i <= n; ++i) ret = (ret * i) % mod; return ret; } std::pair<int, int> enumSet(const int n) { int count = inf, solution = 0; const unsigned int msk = 1u << n; for (unsigned int i = 1; i < msk; ++i) { const int cnt = __builtin_popcount(i); if (cnt <= count && checkSet(n, i)) { if (cnt == count) ++solution; else { solution = 1; count = cnt; } } } return std::make_pair(count, count != inf ? (solution * factor(count)) % mod : 0); } std::pair<int, int> enumVertex(const int n) { int solution = 0; for (int i = 0; i < n; ++i) solution += checkSingle(n, i); return std::make_pair(1, solution); } int main() { std::ios::sync_with_stdio(false); int n; std::cin >> n; readGraph(n); reset(n); if (isStrongConnect(n)) { std::cout << 0 1 n ; return 0; } const auto [count, solution] = n <= 6 ? enumSet(n) : enumVertex(n); if (count == inf) std::cout << -1 n ; else std::cout << count << << solution << n ; return 0; }

#include <bits/stdc++.h> using namespace std; int n, branch[10001], total; int main() { cin >> n; for (int i = 0; i < n - 1; i++) { int a, b; cin >> a >> b; branch[a]++, branch[b]++; } for (int i = 1; i <= n; i++) total += branch[i] * (branch[i] - 1) / 2; cout << total << endl; }

#include <bits/stdc++.h> using namespace std; int main() { int n, ans = -1; cin >> n; int a[n], l[n], r[n]; for (int i = 0; i < n; ++i) cin >> a[i]; for (int i = 0, des = 0; i < n; ++i) { ++des; l[i] = des = min(des, a[i]); } for (int i = n - 1, des = 0; i >= 0; --i) { ++des; r[i] = des = min(des, a[i]); } for (int i = 0; i < n; ++i) ans = max(ans, min(l[i], r[i])); cout << ans << endl; }

#include <bits/stdc++.h> using namespace std; inline long long add(long long a, long long b) { return ((a % 1000000007LL) + (b % 1000000007LL)) % 1000000007LL; } inline long long mul(long long a, long long b) { return ((a % 1000000007LL) * (b % 1000000007LL)) % 1000000007LL; } inline long long sub(long long a, long long b) { return ((a % 1000000007LL) - (b % 1000000007LL) + 1000000007LL) % 1000000007LL; } void prefixInversionAndSwap(string &ss, long long x) { for (long long i = 0; i <= x; i++) { if (ss[i] == 0 ) { ss[i] = 1 ; } else { ss[i] = 0 ; } } for (long long i = 0; i <= (x / 2); i++) { swap(ss[i], ss[x - i]); } return; } void Flash() { long long n; cin >> n; string a, b; cin >> a >> b; vector<long long> ans; long long swapped = 0; long long ind = 0, nai, bbit; long long firstBit = a[0] - 0 ; for (long long i = (n - 1); i > 0; i--) { if (swapped) { nai = (a[ind - i] - 0 ); nai ^= 1; } else { nai = (a[ind + i] - 0 ); } bbit = b[i] - 0 ; if (nai != bbit) { if (nai == 1) { if (firstBit == 0) { ans.push_back(1); } ans.push_back(i + 1); if (swapped) { ind -= i; } else { ind += i; } swapped ^= 1; firstBit = (nai ^ 1); } else { if (firstBit == 1) { ans.push_back(1); } ans.push_back(i + 1); if (swapped) { ind -= i; } else { ind += i; } swapped ^= 1; firstBit = (nai ^ 1); } } } if (firstBit != (b[0] - 0 )) { ans.push_back(1); } cout << ans.size() << ; for (auto it : ans) { cout << it << ; } cout << n ; } int main(int argc, char const *argv[]) { ios::sync_with_stdio(0), cin.tie(NULL), cout.tie(NULL); ; long long t = 1; cin >> t; for (long long i = 1; i <= t; i++) { Flash(); } return 0; }

#include <bits/stdc++.h> #define int long long using namespace std; pair<int, int> extgcd(int a, int b) { if(!b) return {1, 0}; pair<int, int> val = extgcd(b, a % b); return {val.second, val.first - (a / b) * val.second}; } signed main(){ ios_base::sync_with_stdio(false); cin.tie(0); int t; cin >> t; while(t--){ int n; cin >> n; string s; cin >> s; int cnt = 0, cnt2 = 0; for(int i = 0; i < n; ++i){ if(s[i] == 1 && s[i + 1] == 1 ){ ++cnt; ++i; } else if(s[i] == 1 ){ ++cnt2; } } int ans = 1, mod = 998244353, can = n - 1 - cnt2; for(int i = n - cnt - cnt2; i > cnt; --i){ ans *= i; ans %= mod; } for(int i = n - cnt - cnt - cnt2; i >= 1; --i){ ans *= (extgcd(i, mod).first + mod) % mod; ans %= mod; } cout << ans << n ; } return 0; }