Datasets:
malteklaes
/
cpp-code-code_search_net-style

Dataset card Data Studio Files
xet
Community
1
func_code_string
stringlengths
59
71.4k
#include <bits/stdc++.h> using namespace std; int n; int init[110]; string lst[110]; vector<int> fin; int main() { ios_base::sync_with_stdio(false); cin >> n; for (int i = (int)0; i < (int)n; ++i) cin >> lst[i]; for (int i = (int)0; i < (int)n; ++i) cin >> init[i]; bool flag = 1; while (flag) { flag = 0; for (int i = (int)0; i < (int)n; ++i) if (init[i] == 0) { flag = 1; fin.push_back(i + 1); for (int j = (int)0; j < (int)n; ++j) init[j] -= lst[i][j] - 0 ; } } cout << fin.size() << endl; for (int ele : fin) cout << ele << ; return 0; }
#include <bits/stdc++.h> using namespace std; int mm[110][110]; int tmp[110][110]; void draw(int a, int b, int v) { for (int lx = 0; lx < a; lx++) for (int ly = 0; ly < b; ly++) tmp[lx][ly] += v; return; } void prt(int a, int b) { for (int lx = 0; lx < a; lx++) { for (int ly = 0; ly < b; ly++) printf( %c , tmp[lx][ly] ? W : B ); puts( ); } return; } int main() { int n, m; scanf( %d %d , &n, &m); for (int lx = 0; lx < n; lx++) { char buf[200]; scanf( %s , buf); for (int ly = 0; ly < m; ly++) mm[lx][ly] = (buf[ly] == W ); } int cnt = 1; for (int lx = 0; lx < n; lx++) for (int ly = 0; ly < m; ly++) tmp[lx][ly] = mm[n - 1][m - 1]; for (int cc = n + m - 3; cc >= 0; cc--) { for (int x = 0; x <= cc; x++) { int y = cc - x; if (x >= n or y >= m) continue; if (tmp[x][y] != mm[x][y]) { draw(x + 1, y + 1, mm[x][y] - tmp[x][y]), cnt++; } } } printf( %d n , cnt); return 0; }
#include <bits/stdc++.h> using namespace std; long long int gcd(long long int a, long long int b) { return (!b) ? a : gcd(b, a % b); } int n, k; void solve() { cin >> n >> k; string s; cin >> s; vector<vector<int>> mvs; int mxs = 0; int cnt = 0; while (cnt <= n) { vector<int> cr; for (int i = 0; i <= (int)s.size() - 2; i++) { if (s[i] == R && s[i + 1] == L ) { cr.push_back(i); s[i] = L ; s[i + 1] = R ; i += 1; } } if ((int)cr.size() == 0) break; mvs.push_back(cr); mxs += (int)cr.size(); cnt += 1; } if (k >= (int)mvs.size() && k <= mxs) { int rem = (int)mvs.size(); for (auto fv : mvs) { vector<int> cv = fv; int i = 0; while (i < (int)cv.size()) { int ch = 1; if (rem == k) ch = (int)cv.size() - i; cout << ch << ; for (int j = 0; j < ch; j++) { cout << cv[i] + 1 << ; i += 1; } cout << n ; k -= 1; } rem -= 1; } } else { cout << -1; } } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); solve(); }
#include <bits/stdc++.h> using namespace std; long long gcd(long long a, long long b) { if (a == 0) return b; return gcd(b % a, a); } vector<string> results(100001); vector<pair<int, string> > wishes; vector<pair<int, string> > S_M, M_L, L_XL, XL_XXL, XXL_XXXL; bool compare(pair<int, string> a, pair<int, string> b) { if (a.second == S,M ) return false; if (a.second == M,L ) return b.second == S,M ; if (a.second == L,XL ) return b.second == S,M || b.second == M,L ; if (a.second == XL,XXL ) return b.second != XXL,XXXL ; return true; } int main() { int S = 0, M = 0, L = 0, XL = 0, XXL = 0, XXXL = 0; cin >> S >> M >> L >> XL >> XXL >> XXXL; map<string, int> sizes; sizes[ S ] = S; sizes[ M ] = M; sizes[ L ] = L; sizes[ XL ] = XL; sizes[ XXL ] = XXL; sizes[ XXXL ] = XXXL; int n; string s; cin >> n; unsigned long long xx = 0; for (int i = 0; i < n; i++) { cin >> s; int pos = s.find( , ); if (pos == string::npos) { results[i] = s; if (sizes[s] > 0) sizes[s]--; else { cout << NO ; return 0; } } else { if (s == S,M ) S_M.push_back(make_pair(i, s)); if (s == M,L ) M_L.push_back(make_pair(i, s)); if (s == L,XL ) L_XL.push_back(make_pair(i, s)); if (s == XL,XXL ) XL_XXL.push_back(make_pair(i, s)); if (s == XXL,XXXL ) { XXL_XXXL.push_back(make_pair(i, s)); xx++; } } } wishes.insert(wishes.end(), S_M.begin(), S_M.end()); wishes.insert(wishes.end(), M_L.begin(), M_L.end()); wishes.insert(wishes.end(), L_XL.begin(), L_XL.end()); wishes.insert(wishes.end(), XL_XXL.begin(), XL_XXL.end()); wishes.insert(wishes.end(), XXL_XXXL.begin(), XXL_XXXL.end()); for (int i = 0; i < wishes.size(); i++) { pair<int, string> wish = wishes[i]; string sz = wish.second; int ind = wish.first; int pos = sz.find( , ); string first = sz.substr(0, pos); string second = sz.substr(pos + 1); if (sizes[first] == 0 && sizes[second] == 0) { cout << NO ; return 0; } if (sizes[first] != 0) { results[ind] = first; sizes[first]--; } else { results[ind] = second; sizes[second]--; } } cout << YES << endl; for (int i = 0; i < n; i++) cout << results[i] << endl; return 0; }
#include <bits/stdc++.h> struct TSubStr { TSubStr(const std::string& text, size_t begin, size_t end) : Text(text), Begin(begin), End(end) {} const std::string& Text; size_t Begin; size_t End; static inline size_t getId(const std::string& text, size_t begin, size_t end) { size_t id = 0; size_t power = 1; for (size_t i = begin; i < end; ++i) { id += (text[i] - a + 1) * power; power *= 27; } return id; } static inline size_t getId(const std::string& str) { size_t id = 0; size_t power = 1; for (size_t i = 0; i < str.size(); ++i) { id += (str[i] - a + 1) * power; power *= 27; } return id; } inline size_t getId() const { size_t id = 0; size_t power = 1; for (size_t i = Begin; i < End; ++i) { id += (Text[i] - a + 1) * power; power *= 27; } return id; } }; void FillIndex(const std::string& text, std::vector<std::vector<size_t> >& index) { index.clear(); index.resize(27 * 27 * 27 * 27); for (size_t i = 0; i < text.size(); ++i) { index[TSubStr::getId(text, i, i + 1)].push_back(i); if (i + 1 < text.size()) index[TSubStr::getId(text, i, i + 2)].push_back(i); if (i + 2 < text.size()) index[TSubStr::getId(text, i, i + 3)].push_back(i); if (i + 3 < text.size()) index[TSubStr::getId(text, i, i + 4)].push_back(i); } } std::string ReverseStr(const std::string& str) { std::string res(str); std::reverse(res.begin(), res.end()); return res; } struct TProblemQuery { TProblemQuery(const std::string& firstStr, const std::string& secondStr) { if (firstStr < secondStr) { FirstStr = firstStr; SecondStr = secondStr; } else { FirstStr = secondStr; SecondStr = firstStr; } } TProblemQuery(const TProblemQuery& rhs) : FirstStr(rhs.FirstStr), SecondStr(rhs.SecondStr) {} TProblemQuery() {} bool operator==(const TProblemQuery& rhs) const { return FirstStr == rhs.FirstStr && SecondStr == rhs.SecondStr; } std::string FirstStr; std::string SecondStr; }; struct TProblemQueryHash { size_t operator()(const TProblemQuery& query) const { size_t x = HashFn(query.FirstStr); size_t y = HashFn(query.SecondStr); return (x * 1000000009) ^ y; } std::hash<std::string> HashFn; }; inline void TryImprove( const std::string& freqStr, const std::string& text, const std::vector<size_t>& freqStrOccurencies, std::unordered_map<TProblemQuery, size_t, TProblemQueryHash>& results, int freqStrI, int textI, int len) { if (textI + len > text.size()) { return; } TProblemQuery query(freqStr, text.substr(textI, len)); if (results.count(query)) { size_t& res = results[query]; size_t begI = std::min<size_t>(textI, freqStrOccurencies[freqStrI]); size_t endI = std::max<size_t>( textI + len, freqStrOccurencies[freqStrI] + freqStr.size()); size_t potentialRes = endI - begI; if (freqStrI > 0) { begI = std::min<size_t>(textI, freqStrOccurencies[freqStrI - 1]); endI = std::max<size_t>( textI + len, freqStrOccurencies[freqStrI - 1] + freqStr.size()); potentialRes = std::min<size_t>(potentialRes, endI - begI); } res = std::min<size_t>(res, potentialRes); } } void ProcessFreq( const std::string& freqStr, const std::string& text, const std::vector<std::vector<size_t> >& index, std::unordered_map<TProblemQuery, size_t, TProblemQueryHash>& results, std::vector<bool>& processedAsFreq) { const std::vector<size_t>& freqStrOccurencies = index[TSubStr::getId(freqStr)]; int freqStrI = 0; int textI = 0; while (textI < text.size()) { if (freqStrI < freqStrOccurencies.size() - 1 && textI > freqStrOccurencies[freqStrI]) { ++freqStrI; continue; } TryImprove(freqStr, text, freqStrOccurencies, results, freqStrI, textI, 1); TryImprove(freqStr, text, freqStrOccurencies, results, freqStrI, textI, 2); TryImprove(freqStr, text, freqStrOccurencies, results, freqStrI, textI, 3); TryImprove(freqStr, text, freqStrOccurencies, results, freqStrI, textI, 4); ++textI; } processedAsFreq[TSubStr::getId(freqStr)] = true; } void ProcessQuery( const TProblemQuery& query, const std::string& text, const std::vector<std::vector<size_t> >& index, std::unordered_map<TProblemQuery, size_t, TProblemQueryHash>& results, std::vector<bool>& processedAsFreq) { if (index[TSubStr::getId(query.FirstStr)].empty() || index[TSubStr::getId(query.SecondStr)].empty()) { return; } if (processedAsFreq[TSubStr::getId(query.FirstStr)] || processedAsFreq[TSubStr::getId(query.SecondStr)]) { return; } if (index[TSubStr::getId(query.FirstStr)].size() > 800) { ProcessFreq(query.FirstStr, text, index, results, processedAsFreq); return; } if (index[TSubStr::getId(query.SecondStr)].size() > 800) { ProcessFreq(query.SecondStr, text, index, results, processedAsFreq); return; } const std::vector<size_t>& firstStrOccurencies = index[TSubStr::getId(query.FirstStr)]; const std::vector<size_t>& secondStrOccurencies = index[TSubStr::getId(query.SecondStr)]; size_t& res = results[query]; int firstI = 0; int secondI = 0; int potentialSubstrBegin = std::min(firstStrOccurencies[firstI], secondStrOccurencies[secondI]); int potentialSubstrEnd = std::max(firstStrOccurencies[firstI] + query.FirstStr.size(), secondStrOccurencies[secondI] + query.SecondStr.size()); size_t potentialRes = potentialSubstrEnd - potentialSubstrBegin; res = std::min(res, potentialRes); while (secondI < secondStrOccurencies.size() && secondStrOccurencies[secondI] < firstStrOccurencies[firstI]) { potentialSubstrBegin = std::min(firstStrOccurencies[firstI], secondStrOccurencies[secondI]); potentialSubstrEnd = std::max(firstStrOccurencies[firstI] + query.FirstStr.size(), secondStrOccurencies[secondI] + query.SecondStr.size()); potentialRes = potentialSubstrEnd - potentialSubstrBegin; res = std::min(res, potentialRes); ++secondI; } while (secondI < secondStrOccurencies.size()) { if (firstI < firstStrOccurencies.size() - 1 && firstStrOccurencies[firstI + 1] < secondStrOccurencies[secondI]) { ++firstI; continue; } potentialSubstrBegin = std::min(firstStrOccurencies[firstI], secondStrOccurencies[secondI]); potentialSubstrEnd = std::max(firstStrOccurencies[firstI] + query.FirstStr.size(), secondStrOccurencies[secondI] + query.SecondStr.size()); potentialRes = potentialSubstrEnd - potentialSubstrBegin; res = std::min(res, potentialRes); if (firstI < firstStrOccurencies.size() - 1) { potentialSubstrBegin = std::min(firstStrOccurencies[firstI + 1], secondStrOccurencies[secondI]); potentialSubstrEnd = std::max(firstStrOccurencies[firstI + 1] + query.FirstStr.size(), secondStrOccurencies[secondI] + query.SecondStr.size()); potentialRes = potentialSubstrEnd - potentialSubstrBegin; res = std::min(res, potentialRes); } ++secondI; } } int main() { std::string text; std::cin >> text; std::vector<std::vector<size_t> > index; FillIndex(text, index); std::vector<bool> processedAsFreq(27 * 27 * 27 * 27, false); std::unordered_map<TProblemQuery, size_t, TProblemQueryHash> results; results.max_load_factor(3.0); results.reserve(300000); std::vector<TProblemQuery> queries; size_t m; std::cin >> m; size_t NO_ANSWER = 1000000009; for (size_t i = 0; i < m; ++i) { std::string strFirst; std::string strSecond; std::cin >> strFirst; std::cin >> strSecond; TProblemQuery query(strFirst, strSecond); queries.push_back(query); results[query] = NO_ANSWER; } for (size_t i = 0; i < m; ++i) { ProcessQuery(queries[i], text, index, results, processedAsFreq); size_t res = results[queries[i]]; std::cout << (res == NO_ANSWER ? -1 : (int)res) << n ; } return 0; }
#include <bits/stdc++.h> using namespace std; char s1[1000], s2[1000], v[1000], s[1000]; int d[200][200][200]; int p[200][200][200][3]; int pp[1000]; int main() { int i, j, k, l1, l2, l, tmp, ans, bk, ti, tj, tk, m; scanf( %s%s%s , s1, s2, v); l1 = strlen(s1); l2 = strlen(s2); l = strlen(v); pp[0] = 0; pp[1] = 0; i = 0; j = 1; while (1) { if (j == l) break; pp[j] = i; while ((i > 0) && (v[i] != v[j])) i = pp[i]; if (v[i] == v[j]) { i++; j++; } else j++; } memset(d, -1, sizeof(d)); d[0][0][0] = 0; for (i = 0; i <= l1; i++) for (j = 0; j <= l2; j++) for (k = 0; k < l; k++) if (d[i][j][k] != -1) { if (i < l1) if (d[i][j][k] > d[i + 1][j][k]) { d[i + 1][j][k] = d[i][j][k]; p[i + 1][j][k][0] = i; p[i + 1][j][k][1] = j; p[i + 1][j][k][2] = k; } if (j < l2) if (d[i][j][k] > d[i][j + 1][k]) { d[i][j + 1][k] = d[i][j][k]; p[i][j + 1][k][0] = i; p[i][j + 1][k][1] = j; p[i][j + 1][k][2] = k; } if ((i < l1) && (j < l2) && (s1[i] == s2[j])) { tmp = k; while ((tmp > 0) && (v[tmp] != s1[i])) tmp = pp[tmp]; if (v[tmp] == s1[i]) tmp++; if (tmp < l) { if (d[i][j][k] + 1 > d[i + 1][j + 1][tmp]) { d[i + 1][j + 1][tmp] = d[i][j][k] + 1; p[i + 1][j + 1][tmp][0] = i; p[i + 1][j + 1][tmp][1] = j; p[i + 1][j + 1][tmp][2] = k; } } } } ans = -1; for (k = 0; k < l; k++) if (d[l1][l2][k] > ans) { ans = d[l1][l2][k]; bk = k; } if (ans == 0) printf( 0 n ); else { m = 0; ti = l1; tj = l2; tk = bk; while ((ti != 0) || (tj != 0)) { i = p[ti][tj][tk][0]; j = p[ti][tj][tk][1]; k = p[ti][tj][tk][2]; if ((i < ti) && (j < tj)) { s[m] = s1[i]; m++; } ti = i; tj = j; tk = k; } s[m] = 0 ; reverse(s, s + m); printf( %s n , s); } }
#include <bits/stdc++.h> using namespace std; int main() { int n, m; cin >> n >> m; int mex = 1e9; for (int i = 0; i < m; i++) { int l, r; cin >> l >> r; mex = min(mex, r - l + 1); } cout << mex << n ; for (int i = 0; i < n; i++) { cout << i % mex << ; } return 0; }
#include <bits/stdc++.h> using namespace std; const int mod = 1e9 + 7; const int maxn = 1e4 + 5; class Matrix { public: long long a[3][3]; int n; void Init(int key) { memset(a, 0, sizeof a); if (key) for (int i = 0; i < n; i++) a[i][i] = 1; } Matrix operator*(const Matrix& b) { Matrix c; c.n = n; c.Init(0); for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) for (int k = 0; k < n; k++) c.a[i][j] = (c.a[i][j] + a[i][k] * b.a[k][j] % mod) % mod; return c; } Matrix Power(long long t) { Matrix ans, p = *this; ans.n = p.n; ans.Init(1); while (t) { if (t & 1) ans = ans * p; p = p * p; t >>= 1; } return ans; } void Print() { for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { if (j == 0) printf( %lld , a[i][j]); else printf( %lld , a[i][j]); } puts( ); } } }; struct node { int x, tag; long long y; friend bool operator<(const node& a, const node& b) { return a.y < b.y; } } a[maxn * 2]; long long sum[3], b[3]; void calc(long long n) { Matrix f, A; f.Init(0); A.Init(0); f.n = A.n = 3; for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { if (sum[j] == 0) f.a[i][j] = 1; else f.a[i][j] = 0; } } f.a[0][2] = f.a[2][0] = 0; A.a[0][0] = b[0], A.a[0][1] = b[1], A.a[0][2] = b[2]; A = A * f.Power(n); b[0] = A.a[0][0], b[1] = A.a[0][1], b[2] = A.a[0][2]; } int main() { int n; long long m; scanf( %d%lld , &n, &m); int cnt = 0; for (int i = 1; i <= n; i++) { int x; long long l, r; scanf( %d%lld%lld , &x, &l, &r); a[++cnt].x = x - 1, a[cnt].y = l - 1, a[cnt].tag = 1; a[++cnt].x = x - 1, a[cnt].y = r, a[cnt].tag = -1; } sort(a + 1, a + cnt + 1); b[0] = b[2] = 0, b[1] = 1; long long cur = 1; for (int i = 1; i <= cnt; i++) { calc(a[i].y - cur); cur = a[i].y; sum[a[i].x] += a[i].tag; } calc(m - cur); printf( %lld n , b[1]); return 0; }
#include <bits/stdc++.h> using namespace std; template <typename T> inline bool smin(T &a, const T &b) { return b < a ? a = b, 1 : 0; } template <typename T> inline bool smax(T &a, const T &b) { return a < b ? a = b, 1 : 0; } const long long N = 1e5 + 10, mod = (long long)1e9 + 7; long long n, k, ps[N], f[N], inv[N], pw10[N]; string s; long long pw(long long x, long long y) { x %= mod; long long ret = 1; for (; y; y >>= 1, (x *= x) %= mod) if (y & 1) (ret *= x) %= mod; return ret; } long long C(long long n, long long r) { if (r > n || r < 0 || n < 0) return 0; return ((f[n] * inv[r] % mod) * inv[n - r] % mod) % mod; } int32_t main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); cin >> n >> k >> s; ps[0] = s[0] - 0 ; for (long long i = 1; i < n; ++i) (ps[i] = ps[i - 1] + (s[i] - 0 )) %= mod; f[0] = inv[0] = 1; for (long long i = 1; i < N; ++i) { (f[i] = f[i - 1] * i) %= mod; inv[i] = pw(f[i], mod - 2); } pw10[0] = 1; for (long long i = 1; i < N; ++i) (pw10[i] = pw10[i - 1] * 10) %= mod; long long res = 0; for (long long sz = 0; sz <= n - 2; ++sz) { long long add = pw10[sz] * C(n - sz - 2, k - 1) % mod * ps[n - sz - 2] % mod; (res += add) %= mod; } for (long long i = 0; i < n; ++i) { long long add = (s[i] - 0 ) * pw10[n - i - 1] % mod * C(i, k); (res += add) %= mod; } cout << res << n ; }
#include <bits/stdc++.h> using namespace std; const int maxn = 2e5 + 10; const int inf = 0x3f3f3f3f; const double eps = 1e-8; map<int, int> ma; int n, x, num; int getId(int x) { if (ma.count(x) == 0) { ma[x] = num++; } return ma[x]; } int cnt[maxn]; vector<int> v; int main() { while (~scanf( %d , &n)) { memset(cnt, 0, sizeof(cnt)); num = 1; ma.clear(); v.clear(); for (int i = 1; i <= n; i++) { scanf( %d , &x); cnt[getId(x)]++; x = getId(x); } for (int i = 0; i <= n + 1; i++) { if (cnt[i] != 0) v.push_back(cnt[i]); } sort(v.begin(), v.end()); int now = 0, ans = 0; int len = v.size(); for (int i = 1; i <= v[len - 1]; i++) { int sum = 0; now = 0; for (int j = i;;) { int pos = lower_bound(v.begin() + now, v.end(), j) - v.begin(); if (pos == len) break; now = pos + 1; sum += j; j = j * 2; } ans = max(ans, sum); } printf( %d n , ans); } return 0; }
#include <bits/stdc++.h> #pragma GCC target( sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native ) #pragma GCC optimize( unroll-loops ) #pragma GCC optimize( fast-math ) using namespace std; mt19937 rnd(time(0) + 228 + k + e + k + e + r + o + f + e + y ); vector<int> genvec(int sz, int minelem, int maxelem) { ++maxelem; vector<int> ans(sz); for (int i = 0; i < sz; ++i) { ans[i] = minelem + rnd() % (maxelem - minelem); } return ans; } const long double EPS = 1e-14; bool checkprime(int x) { for (int i = 2; i * i <= x; ++i) if (x % i == 0) return 0; return 1; } const long double PI = acos(-1); const int MOD7 = 1000000007; const int MOD9 = 1000000009; const long long INF = 2e18; int mod = MOD7; const int inf = 1e9; signed main() { ios_base::sync_with_stdio(0); cout.tie(0); cin.tie(0); srand(time(NULL)); int t; cin >> t; while (t--) { int n; cin >> n; vector<int> p(2 * n); for (long long i = 0; i < p.size(); ++i) cin >> p[i]; ; int mx = 0; vector<int> luls; int cnt = 0; for (int i : p) { if (i > mx) { mx = i; if (cnt) luls.push_back(cnt); cnt = 1; } else { ++cnt; } } luls.push_back(cnt); vector<bool> dp(n + 1); dp[0] = 1; int ps = 0; for (int i : luls) { ps += i; for (int sum = n; sum >= 0; --sum) { if (!dp[sum]) continue; if (ps - sum - i > n) continue; if (sum + i <= n) { dp[sum + i] = 1; } } } cout << (dp[n] ? YES : NO ) << endl; } }
#include <bits/stdc++.h> const int N = 1e5 + 10; const int LOGN = 20; long long ans; int n; int pre[N << 1], to[N << 1], head[N], wcnt; long long dis[N]; int val[N], fa[N]; int dep[N]; int table[LOGN][N << 1]; int LOG2[N << 1]; int idcnt; int st[N]; inline int minp(int x, int y) { return (dep[x] < dep[y]) ? x : y; } inline void swap(int &x, int &y) { int t = x; x = y; y = t; } template <class T> inline T max(const T &x, const T &y) { return (x < y) ? y : x; } inline void addedge(int u, int v) { wcnt++; pre[wcnt] = head[u]; head[u] = wcnt; to[wcnt] = v; } inline void add2edge(int u, int v) { addedge(u, v); addedge(v, u); } void init() { int i, j, k; for (i = int(2); i <= int(idcnt); i++) LOG2[i] = LOG2[i >> 1] + 1; for (i = k = 1; k <= idcnt; i++, k <<= 1) for (j = 1; j <= int(idcnt - k); j++) table[i][j] = minp(table[i - 1][j], table[i - 1][j + k]); } inline long long getdis(int x, int y) { int l, r, k, z; l = st[x]; r = st[y]; if (l > r) swap(l, r); k = LOG2[r - l + 1]; z = minp(table[k][l], table[k][r - (1 << k) + 1]); return dis[x] + dis[y] - 2 * dis[z] + val[z]; } struct Node { int x, y; long long d; Node() { x = y = 0; d = -1; } Node(int x, int y) : x(x), y(y) { d = getdis(x, y); } bool operator<(const Node &b) const { return d < b.d; } Node operator+(const Node &b) const { if (d == -1) return b; else if (b.d == -1) return *this; Node res = max(*this, b); res = max(res, Node(x, b.x)); res = max(res, Node(x, b.y)); res = max(res, Node(y, b.x)); res = max(res, Node(y, b.y)); return res; } }; Node sum[N], g[N]; void predfs(int u) { int i; table[0][st[u] = ++idcnt] = u; dis[u] = dis[fa[u]] + val[u]; for (i = head[u]; i; i = pre[i]) if (fa[u] ^ to[i]) { fa[to[i]] = u; dep[to[i]] = dep[u] + 1; predfs(to[i]); table[0][++idcnt] = u; } } void dfs1(int u) { int i; sum[u] = Node(u, u); for (i = head[u]; i; i = pre[i]) if (fa[u] ^ to[i]) { dfs1(to[i]); sum[u] = sum[u] + sum[to[i]]; } } void dfs2(int u) { static Node pref[N], suff[N]; static int son[N]; int i, sn = 0; for (i = head[u]; i; i = pre[i]) if (fa[u] ^ to[i]) son[++sn] = to[i]; pref[0] = suff[sn + 1] = g[u] + Node(u, u); for (i = 1; i <= int(sn); i++) pref[i] = pref[i - 1] + sum[son[i]]; for (i = int(sn); i; i--) suff[i] = suff[i + 1] + sum[son[i]]; for (i = 1; i <= int(sn); i++) g[son[i]] = pref[i - 1] + suff[i + 1]; for (i = int(0); i <= int(sn + 1); i++) pref[i] = suff[i] = Node(); if (u > 1) ans = max(ans, sum[u].d + g[u].d); for (i = head[u]; i; i = pre[i]) if (fa[u] ^ to[i]) dfs2(to[i]); } int main() { int i; int u, v; scanf( %d , &n); for (i = 1; i <= int(n); i++) scanf( %d , &val[i]); for (i = 1; i <= int(n - 1); i++) { scanf( %d %d , &u, &v); add2edge(u, v); } predfs(1); init(); dfs1(1); ans = sum[1].d; dfs2(1); printf( %lld n , ans); return 0; }
#include <bits/stdc++.h> using namespace std; ifstream fin( input.txt ); ofstream fout( output.txt ); bool isPrime(int x) { if (x <= 4 || x % 2 == 0 || x % 3 == 0) return x == 2 || x == 3; for (int i = 5; i * i <= x; i += 6) if (x % i == 0 || x % (i + 2) == 0) return 0; return 1; } inline void boostIO() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); } int main() { boostIO(); int n, s; cin >> n >> s; int prev = 0; int h = 0; int m = 0; for (int i = 0; i < (n); ++i) { cin >> h >> m; m += h * 60; if (i == 0 && m - prev >= s + 1) { cout << 0 << << 0 << endl; return 0; } if (m - prev >= s * 2 + 2) { cout << (prev + s + 1) / 60 << << (prev + s + 1) % 60 << endl; return 0; } prev = m; } cout << (prev + s + 1) / 60 << << (prev + s + 1) % 60; return 0; }
#include <bits/stdc++.h> inline int read() { int data = 0, w = 1; char ch = getchar(); while (ch != - && (ch < 0 || ch > 9 )) ch = getchar(); if (ch == - ) w = -1, ch = getchar(); while (ch >= 0 && ch <= 9 ) data = data * 10 + (ch ^ 48), ch = getchar(); return data * w; } const int N(1e5 + 10), M(105), Mod(998244353); int n, K, L, f[N][M], s[N], len[N][M], a[N]; int main() { n = read(), K = read(), L = read(); for (int i = 1; i <= n; i++) a[i] = read(); for (int i = 1; i <= n; i++) for (int j = 1; j <= K; j++) if (a[i] == -1 || a[i] == j) len[i][j] = len[i - 1][j] + 1; s[0] = 1; for (int i = 1; i <= n; i++) for (int j = 1; j <= K; j++) if (a[i] == -1 || a[i] == j) { f[i][j] = s[i - 1]; if (i >= L && len[i][j] >= L) f[i][j] = (f[i][j] - s[i - L] + Mod) % Mod, f[i][j] = (f[i][j] + f[i - L][j]) % Mod; s[i] = (s[i] + f[i][j]) % Mod; } printf( %d n , s[n]); return 0; }
#include <bits/stdc++.h> using namespace std; const int maxn = 5006; const int mod = 1000000009; double x[maxn], y[maxn], z[maxn]; double d[maxn][maxn]; int n; double dis(double x1, double y1, double z1, double x2, double y2, double z2) { double dx = x1 - x2; double dy = y1 - y2; double dz = z1 - z2; return sqrt(dx * dx + dy * dy + dz * dz); } double getans() { double ret = 100000000000.0; for (int i = 1; i < n; ++i) for (int j = i + 1; j < n; ++j) { double dd = d[i][j] + d[0][i] + d[0][j]; ret = min(ret, dd); } return ret; } void init() { for (int i = 0; i < n; ++i) for (int j = 0; j < n; ++j) d[i][j] = dis(x[i], y[i], z[i], x[j], y[j], z[j]); } int main() { while (~scanf( %d , &n)) { for (int i = 0; i < n; ++i) { scanf( %lf%lf%lf , x + i, y + i, z + i); } init(); double ans = getans(); ans /= 2; printf( %.9lf n , ans); } return 0; }
#include <bits/stdc++.h> template <typename Y> inline bool updmin(Y &a, Y b) { if (a > b) { a = b; return 1; } return 0; } template <typename Y> inline bool updmax(Y &a, Y b) { if (a < b) { a = b; return 1; } return 0; } template <typename Y> inline Y abs(Y a) { if (a < 0) a = -a; return a; } template <typename Y> inline Y sqr(Y a) { return a * a; } int read() { int w = 1, q = 0, ch = ; for (; ch < 0 || ch > 9 ; ch = getchar()) if (ch == - ) w = -1; for (; ch >= 0 && ch <= 9 ; ch = getchar()) q = q * 10 + ch - 48; return q * w; } inline void FileIO() { freopen( .in , r , stdin); freopen( .out , w , stdout); } const int maxn = 800010; std::vector<std::pair<int, long long> > G[maxn]; int n, m, fa[maxn]; long long a[maxn], d[maxn], dk[maxn], df[maxn]; int dep[maxn], dfn[maxn], st[maxn][21], dfc = 0, lg[maxn]; int lca(int a, int b) { a = dfn[a]; b = dfn[b]; if (a > b) { std::swap(a, b); } int L = lg[b - a], u = st[a][L], v = st[b - (1 << L) + 1][L]; return dep[u] < dep[v] ? u : v; } void up(int p) { d[p] = a[p]; st[++dfc][0] = p; dfn[p] = dfc; dep[p] = dep[fa[p]] + 1; for (auto t : G[p]) { if (t.first == fa[p]) continue; fa[t.first] = p; up(t.first); dk[t.first] = std::max(0LL, d[t.first] - 2 * t.second); d[p] += dk[t.first]; st[++dfc][0] = p; } } void down(int p) { for (auto t : G[p]) { if (t.first == fa[p]) continue; df[t.first] = std::max(0LL, d[p] - dk[t.first] - 2 * t.second); d[t.first] += df[t.first]; down(t.first); } } long long ans[maxn]; std::vector<std::pair<int, int> > Q[maxn]; long long tr[maxn]; inline void add(int p, long long v) { if (!p) return; for (; p <= n; p += p & -p) { tr[p] += v; } } inline long long ask(int p) { long long r = 0; for (; p; p -= p & -p) { r += tr[p]; } return r; } inline long long ask(int l, int r) { return ask(r) - ask(l - 1); } void dfs(int p, long long ev) { add(dep[p] - 1, -ev - dk[p]); add(dep[p], d[p] - df[p]); for (auto q : Q[p]) { ans[q.second] += ask(dep[q.first], dep[p]); } for (auto t : G[p]) { if (t.first == fa[p]) continue; dfs(t.first, t.second); } add(dep[p] - 1, ev + dk[p]); add(dep[p], df[p] - d[p]); } int main() { n = read(); m = read(); for (int i = 1; i <= n; i++) { a[i] = read(); } for (int i = 1; i < n; i++) { int x = read(), y = read(); long long z = read(); G[x].push_back(std::make_pair(y, z)); G[y].push_back(std::make_pair(x, z)); } up(1); down(1); lg[1] = 0; for (int i = 2; i <= dfc; i++) { lg[i] = lg[i >> 1] + 1; } for (int k = 1; k <= 20; k++) { for (int i = 1; i + (1 << k) - 1 <= dfc; i++) { int u = st[i][k - 1], v = st[i + (1 << (k - 1))][k - 1]; st[i][k] = dep[u] < dep[v] ? u : v; } } for (int i = 1; i <= m; i++) { int u = read(), v = read(); if (u == v) { ans[i] = d[u]; continue; } int l = lca(u, v); if (l != u && l != v) { ans[i] += 2 * df[l] - d[l]; } else { ans[i] += df[l]; } if (l != u) { Q[u].push_back(std::make_pair(l, i)); } if (l != v) { Q[v].push_back(std::make_pair(l, i)); } } dfs(1, 0); for (int i = 1; i <= m; i++) { printf( %lld n , ans[i]); } return 0; }
#include <bits/stdc++.h> using namespace std; string s; int main() { long long k, d, t; scanf( %lld %lld %lld , &k, &d, &t); if (k % d == 0) { printf( %.10lf n , (double)t); return 0; } t *= 2; long long period = (k / d + 1) * d; long long periodPoints = 2 * k + period - k; long long nPeriods = t / periodPoints; long long timeSpent = nPeriods * periodPoints; long long rest = t - timeSpent; if (rest == 0) { printf( %.10lf n , (double)nPeriods * period); return 0; } if (2 * k >= rest) { printf( %.10lf n , (double)nPeriods * period + rest / 2.0); return 0; } printf( %.10lf n , (double)nPeriods * period + rest - k); }
#include <bits/stdc++.h> using namespace std; template <class T> inline void gn(T &first) { char c, sg = 0; while (c = getchar(), (c > 9 || c < 0 ) && c != - ) ; for ((c == - ? sg = 1, c = getchar() : 0), first = 0; c >= 0 && c <= 9 ; c = getchar()) first = (first << 1) + (first << 3) + c - 0 ; if (sg) first = -first; } template <class T1, class T2> inline void gn(T1 &x1, T2 &x2) { gn(x1), gn(x2); } char S1[1000100], S2[1000100]; char B[1000100 * 3]; int fail[1000100 * 3]; void build_fail_function(char B[], int len) { int j = fail[0] = -1; for (int i = 1; i < len; i++) { while (j != -1 and B[j + 1] != B[i]) j = fail[j]; if (B[j + 1] == B[i]) j++; fail[i] = j; } } int main() { int n; gn(n); n--; scanf( %s %s , S1, S2); for (int i = 0; i < n; i++) { if (S1[i] == N ) S1[i] = S ; else if (S1[i] == S ) S1[i] = N ; else if (S1[i] == W ) S1[i] = E ; else S1[i] = W ; } int nn = 0; for (int i = 0; i < n; i++) B[nn++] = S1[n - i - 1]; B[nn++] = * ; for (int i = 0; i < n; i++) B[nn++] = S2[i]; build_fail_function(B, nn); if (fail[nn - 1] == -1) return puts( YES ); puts( NO ); }
#include <bits/stdc++.h> using namespace std; const int MAXN = 2500 + 5; int cnt = 0; int rec[MAXN], mp[MAXN][MAXN], dp[MAXN][MAXN]; bool prime[MAXN]; void init(int n) { memset(prime, true, sizeof(prime)); prime[0] = prime[1] = false; for (int i = 2; i <= n; i++) { if (prime[i]) rec[cnt++] = i; for (int j = 0; j < cnt && rec[j] <= n / i; j++) { prime[i * rec[j]] = false; if (i % rec[j] == 0) break; } } } int main() { init(600); int n, m; scanf( %d%d , &n, &m); memset(mp, 0, sizeof(mp)); memset(dp, 0, sizeof(dp)); for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) { scanf( %1d , &mp[i][j]); dp[i][j] = dp[i][j - 1] + dp[i - 1][j] - dp[i - 1][j - 1] + mp[i][j]; } int ans = dp[n][m], up = max(n, m); for (int i = 0; rec[i] < up && i < cnt; i++) { int tmp = 0; for (int j = 0; j < n + rec[i]; j += rec[i]) for (int k = 0; k < m + rec[i]; k += rec[i]) { int sum = dp[min(n, j + rec[i])][min(m, k + rec[i])] - dp[min(n, j)][min(m, k + rec[i])] - dp[min(n, j + rec[i])][min(m, k)] + dp[min(n, j)][min(m, k)]; tmp += min(rec[i] * rec[i] - sum, sum); } ans = min(ans, tmp); } printf( %d n , ans); return 0; }
#include <bits/stdc++.h> using namespace std; vector<int> prefix_function(string t, string s, int k) { int m = (int)s.size(); s = t + ? + s; int n = (int)s.length(); vector<int> pi(n); for (int i = 1; i < n; ++i) { int j = pi[i - 1]; while (j > 0 && s[i] != s[j]) j = pi[j - 1]; if (s[i] == s[j]) ++j; pi[i] = j; } if (k >= (int)t.size()) { for (int i = t.size() + 1, ii = 1; i < n; i++, ii++) { if (pi[i] == t.size()) { if (m - ii >= k) { cout << Yes << endl; int x = ii - k + 1, y = ii + 1; if (x <= 0) y += 1 - x, x += 1 - x; cout << x << << y << endl; exit(0); } int jj = ii - (int)t.size(); if (jj >= k) { cout << Yes << endl; int x = jj - k + 1, y = jj + 1; if (y > m - k + 1) x += m - k + 1 - y, y += m - k + 1 - y; cout << x << << y << endl; exit(0); } } } } vector<int> occ(t.size() + 1, -1); for (int i = t.size() + k; i < n; i++) { int j = pi[i]; int idx = i - t.size() - 1; while (occ[j] == -1) { occ[j] = idx; if (j == 0) break; j = pi[j - 1]; } } return occ; } int main() { ios::sync_with_stdio(0); cin.tie(0); int n, m, k; cin >> n >> m >> k; string s, t; cin >> s >> t; vector<int> L = prefix_function(t, s, k); reverse(t.begin(), t.end()); reverse(s.begin(), s.end()); vector<int> R = prefix_function(t, s, k); for (int i = 0; i < R.size(); i++) { if (R[i] == -1) continue; R[i] = n - 1 - R[i]; } for (int l = 0; l <= m; l++) { int r = m - l; if (L[l] == -1 or R[r] == -1 or l > k or r > k) continue; if (L[l] < R[r]) { cout << Yes << endl; cout << L[l] - k + 1 + 1 << << R[r] + 1 << endl; exit(0); } } cout << No << endl; return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 1010; int n, m; int fw[N][N], fb[N][N]; int dx[8] = {-2, -2, 2, 2, 1, 1, -1, -1}; int dy[8] = {1, -1, 1, -1, 2, -2, 2, -2}; queue<pair<int, int> > q; void bfs(int x, int y, int f[][N]) { for (int i = 1; i <= n; ++i) for (int j = 1; j <= m; ++j) f[i][j] = -1; f[x][y] = 0; q.push(pair<int, int>(x, y)); while (!q.empty()) { pair<int, int> h = q.front(); q.pop(); int x = h.first, y = h.second; for (int i = 0; i < 8; ++i) { int xx = x + dx[i], yy = y + dy[i]; if (xx <= 0 || xx > n || yy <= 0 || yy > m) continue; if (f[xx][yy] == -1) { f[xx][yy] = f[x][y] + 1; q.push(pair<int, int>(xx, yy)); } } } } void go(int x, int y, int f[][N]) { while (f[x][y]) { for (int i = 0; i < 8; ++i) { int xx = x + dx[i], yy = y + dy[i]; if (xx <= 0 || xx > n || yy <= 0 || yy > m) continue; if (f[xx][yy] != -1 && f[xx][yy] < f[x][y]) { x = xx, y = yy; printf( %d %d n , x, y); fflush(stdout); break; } } } } int main() { int xw, yw, xb, yb, hn, hm; scanf( %d%d , &n, &m); scanf( %d%d%d%d , &xw, &yw, &xb, &yb); hn = n >> 1, hm = m >> 1; bfs(hn, hm, fw); bfs(hn + 1, hm, fb); double tw = fw[xw][yw]; double tb = fb[xb][yb] + 0.5; double twb = fb[xw][yw]; double tbb = fw[xb][yb] + 0.5; if (((xw + yw) & 1) ^ ((xb + yb) & 1)) { if (tw < tb) { puts( WHITE ); go(xw, yw, fw); } else if (twb < tb + 1) { puts( WHITE ); if (fb[xw][yw]) { go(xw, yw, fb); } else { printf( %d %d n , xw - 2, yw - 1); printf( %d %d n , xw, yw); } go(hn + 1, hm, fw); } else { puts( BLACK ); go(xb, yb, fb); } } else { if (tb < tw) { puts( BLACK ); go(xb, yb, fb); } else if (tbb < tw + 1) { puts( BLACK ); if (fw[xb][yb]) { go(xb, yb, fw); } else { printf( %d %d n , xb - 2, yb - 1); printf( %d %d n , xb, yb); } go(hn, hm, fb); } else { puts( WHITE ); go(xw, yw, fw); } } return 0; }
#include <bits/stdc++.h> int main() { int N; std::cin >> N; std::set<std::pair<int, int>> doubled; std::set<std::pair<int, int>> pend; int to_double = 0; int f_doubled = 0; int64_t total_damage = 0; int t; int d; for (int i = 0; i < N; i++) { std::cin >> t; std::cin >> d; total_damage += d; to_double += t * (d > 0 ? 1 : -1); if (d > 0) { pend.insert({d, t}); } else { auto search = doubled.find({-d, t}); if (search != doubled.end()) { doubled.erase(search); if (t == 0) f_doubled--; total_damage += d; } else { pend.erase(pend.find({-d, t})); } if (t == 1) { if (doubled.size() > 0) { auto it_doubled = doubled.begin(); std::pair<int, int> max = *it_doubled; doubled.erase(it_doubled); pend.insert(max); if (max.second == 0) f_doubled--; total_damage -= max.first; } } } if (to_double > doubled.size()) { if (pend.size() > 0) { auto it_pend = --pend.end(); std::pair<int, int> max = *it_pend; doubled.insert(max); pend.erase(it_pend); if (max.second == 0) f_doubled++; total_damage += max.first; } } else if (doubled.size() == to_double) { if (to_double > 0 && pend.size() > 0) { auto it_doubled = doubled.begin(); auto it_pend = --pend.end(); std::pair<int, int> min = *it_doubled; std::pair<int, int> max = *it_pend; if (max.first > min.first) { if (max.second == 0) f_doubled++; if (min.second == 0) f_doubled--; doubled.erase(it_doubled); pend.erase(it_pend); doubled.insert(max); pend.insert(min); total_damage += max.first - min.first; } } } if (doubled.size() > 0 && f_doubled == 0 && doubled.size() == to_double) { auto it_doubled = doubled.begin(); doubled.erase(it_doubled); std::pair<int, int> min = *it_doubled; total_damage -= min.first; if (pend.size() > 0) { auto it_pend = --pend.end(); std::pair<int, int> max = *it_pend; pend.erase(it_pend); doubled.insert(max); f_doubled++; total_damage += max.first; } pend.insert(min); } printf( %lld n , total_damage); } return 0; }
#include <bits/stdc++.h> using namespace std; const int MAXN = 5005, MAXC = 1000005; int a[MAXN], b[MAXC], c[MAXC]; int n, k, _max; int main() { if (0) { freopen( input.txt , r , stdin); freopen( output.txt , w , stdout); }; scanf( %d%d , &n, &k); for (int i = 1; i <= n; i++) scanf( %d , &a[i]), _max = max(_max, a[i]); for (int i = 1; i < n; i++) for (int j = i + 1; j <= n; j++) b[abs(a[i] - a[j])]++; for (int res = n - k; res <= 1000001; res++) { int cnt = 0; bool ok = true; for (int i = res; i <= _max; i += res) { cnt += b[i]; if (cnt > (k + 1) * k / 2) { ok = false; break; } } if (!ok) continue; int x = 0; for (int i = 1; i <= n; i++) { if (c[a[i] % res]) x++; c[a[i] % res]++; } if (x <= k) { cout << res << endl; return 0; } for (int i = 1; i <= n; i++) c[a[i] % res] = 0; } return 0; }
#include <bits/stdc++.h> using namespace std; const int maxnum = 2005; char str[maxnum][maxnum]; int state[maxnum]; int main() { int m, n; while (~scanf( %d%d , &n, &m)) { memset(state, 0, sizeof(state)); for (int i = 0; i < n; ++i) { scanf( %s , str[i]); for (int j = 0; j < m; ++j) { if (str[i][j] == 1 ) state[j] += 1 ; } } bool ans = false; for (int i = 0; i < n; ++i) { bool judge = true; for (int j = 0; j < m; ++j) { if (judge == false) break; if (str[i][j] == 1 ) { judge = state[j] - 1 ; } if (str[i][j] == 0 ) { judge = state[j]; } } if (judge) { ans = true; break; } } if (ans) printf( YES n ); else printf( NO n ); } return 0; }
#include <bits/stdc++.h> using namespace std; struct edge { int to, next, w; edge(int _to = 0, int _next = 0, int _w = 0) : to(_to), next(_next), w(_w) {} } e[300010 << 1]; int n, m; int g[300010], nume = 0; int d[300010]; int f[300010][2]; vector<int> ans; namespace LCT { int f[300010]; void init() { for (int i = 1; i <= n; i++) f[i] = i; } int getf(int x) { if (f[x] == x) return x; return f[x] = getf(f[x]); } int merge(int x, int y) { f[f[x]] = f[y]; } } // namespace LCT void addEdge(int u, int v, int w) { e[nume] = edge(v, g[u], w); g[u] = nume++; } void dfs(int x, int p) { for (int i = g[x]; ~i; i = e[i].next) if (e[i].to ^ p) dfs(e[i].to, x); int numch = 0; static int ch[300010][2]; int c0 = 0, c1 = 0; for (int i = g[x]; ~i; i = e[i].next) if (e[i].to ^ p) { ++numch; ch[numch][0] = f[e[i].to][0]; ch[numch][1] = f[e[i].to][1]; if (!ch[numch][0] && !ch[numch][1]) { f[x][0] = f[x][1] = 0; return; } if (ch[numch][0] && ch[numch][1]) { f[x][0] = f[x][1] = 1; return; } if (ch[numch][0]) c0++; if (ch[numch][1]) c1++; } if (d[x] == -1) { f[x][0] = f[x][1] = 1; return; } if (d[x] == 0) { if (c1 & 1) { f[x][1] = 1; f[x][0] = 0; } else { f[x][1] = 0; f[x][0] = 1; } } else { if (c1 & 1) { f[x][1] = 0; f[x][0] = 1; } else { f[x][1] = 1; f[x][0] = 0; } } } void dfs2(int x, int p, int fx) { if (f[x][0] != f[x][1]) { for (int i = g[x]; ~i; i = e[i].next) if (e[i].to ^ p) if (f[e[i].to][0]) { dfs2(e[i].to, x, 0); } else { ans.push_back(e[i].w); dfs2(e[i].to, x, 1); } } else { int temp = -1, c1 = 0; for (int i = g[x]; ~i; i = e[i].next) if (e[i].to ^ p) { if (f[e[i].to][0] == f[e[i].to][1] && temp == -1) { temp = i; } else { if (f[e[i].to][0]) dfs2(e[i].to, x, 0); else { dfs2(e[i].to, x, 1); ans.push_back(e[i].w); c1++; } } } if (temp == -1) return; if ((c1 & 1) == fx ^ d[x]) dfs2(e[temp].to, x, 0); else { dfs2(e[temp].to, x, 1); ans.push_back(e[temp].w); } } } int main() { memset(g, -1, sizeof g); scanf( %d%d , &n, &m); LCT::init(); for (int i = 1; i <= n; i++) scanf( %d , d + i); for (int i = 1; i <= m; i++) { int u, v; scanf( %d%d , &u, &v); if (LCT::getf(u) ^ LCT::getf(v)) { addEdge(u, v, i); addEdge(v, u, i); LCT::merge(u, v); } } dfs(1, 0); if (!f[1][0]) { puts( -1 ); return 0; } dfs2(1, 0, 0); int numans = ans.size(); printf( %d n , numans); for (int i = 0; i < numans; i++) printf( %d n , ans[i]); return 0; }
#include <bits/stdc++.h> using namespace std; long long int dp[360361]; long long int k; bool reach(long long int from, long long int to) { if (from <= to) return false; long long int d = from - to; if (d == 1) return true; for (long long int i = (long long int)(from - to + 1); i < ((long long int)(k + 1)); i++) if (to % i == 0 && to + i > from) return true; return false; } long long int calc(long long int from, long long int to) { for (long long int i = (long long int)(from); i < ((long long int)(to + 1)); i++) dp[i] = 999999; dp[from] = 0; for (long long int i = (long long int)(from + 1); i < ((long long int)(to + 1)); i++) { for (long long int j = i - 1; j >= max(from, i - k + 1); j--) { if (reach(i, j)) dp[i] = min(dp[i], dp[j] + 1); } } return dp[to]; } int main() { long long int a, b; cin >> a >> b >> k; a -= 360360 * (b / 360360); b = b % 360360; if (a < 360360) { cout << calc(b, a) << endl; } else { long long int res = 0; res += calc(b, 360360); long long int nums = (a - (a % 360360) - 360360) / 360360; res += calc(0, 360360) * nums; res += calc(0, a % 360360); cout << res << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; const long long INF = 10000000000; const int maxn = 5010; long long a[maxn]; long long last[maxn]; int dp[maxn]; long long s[maxn]; int n; int main(int argc, char *argv[]) { scanf( %d , &n); for (int i = 1; i <= n; i++) scanf( %I64d , &a[i]); fill(last, last + maxn, INF); fill(dp, dp + maxn, maxn); s[0] = 0; for (int i = 1; i <= n; i++) s[i] = s[i - 1] + a[i]; dp[0] = 0; last[0] = 0; for (int i = 1; i <= n; i++) { for (int j = 0; j < i; j++) { if (s[i] - s[j] >= last[j]) { if (dp[i] >= dp[j] + i - j - 1) { dp[i] = dp[j] + i - j - 1; last[i] = min(last[i], s[i] - s[j]); } } } } cout << dp[n] << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int abso(int a, int b) { if (a < b) return b - a; else return a - b; } long long power(long long x, long long e) { long long temp; if (e == 0) return 1; if (e % 2 == 0) { temp = power(x, e / 2); return temp * temp; } else { temp = power(x, e / 2); return temp * temp * x; } } bool cmp(pair<pair<int, int>, int> x, pair<pair<int, int>, int> y) { if (x.first.first == y.first.first) { if (x.first.second == y.first.second) return x.second < y.second; else return x.first.second > y.first.second; } return x.first.first > y.first.first; } bool cmp1(pair<int, int> x, pair<int, int> y) { if (x.second == y.second) return x.first < y.first; return x.second < y.second; } int main() { int n; cin >> n; string str; cin >> str; int arr[n + 1]; for (int i = 1; i <= n; i++) cin >> arr[i]; int cur = 1; int visit[n + 1]; memset(visit, 0, sizeof visit); int flag = 0, next; visit[cur] = 1; while (1) { if (str[cur - 1] == < ) { next = cur - arr[cur]; if (next < 1) { flag = 1; break; } else { if (visit[next] == 1) { flag = 2; break; } else { visit[next] = 1; cur = next; } } } else { next = cur + arr[cur]; if (next > n) { flag = 1; break; } else { if (visit[next] == 1) { flag = 2; break; } else { visit[next] = 1; cur = next; } } } } if (flag == 1) cout << FINITE << endl; else cout << INFINITE << endl; return 0; }
#include <bits/stdc++.h> int n, m, q; std::vector<int> dp; std::vector<std::pair<int, int> > edges; struct bip { std::vector<int> pers; std::stack<std::pair<int, int> > updates; std::stack<int> change; void update(int i, int j) { updates.push({i, pers[i]}); pers[i] = j; } int root(int u) { while (pers[(u + 1)] >= 0) u = pers[(u + 1)]; return u; } void merge(int u, int v) { if (!pers[(0)]) { change.push(0); return; } u = root(u); v = root(v); if (pers[(n + 1 + u)] == v) { change.push(0); return; } if (u == v) { update((0), 0); change.push(1); return; } int c = 0; int eu = pers[(n + 1 + u)]; int ev = pers[(n + 1 + v)]; if (ev != -1) { if (pers[(ev + 1)] < pers[(u + 1)]) u ^= ev ^= u ^= ev; update((u + 1), pers[(ev + 1)] + pers[(u + 1)]); c++; update((ev + 1), u); c++; } if (eu != -1) { if (pers[(eu + 1)] < pers[(v + 1)]) v ^= eu ^= v ^= eu; update((v + 1), pers[(eu + 1)] + pers[(v + 1)]); c++; update((eu + 1), v); c++; } update((n + 1 + u), v); c++; update((n + 1 + v), u); c++; change.push(c); } void undo() { int u = change.top(); change.pop(); while (u--) { std::pair<int, int> next = updates.top(); updates.pop(); pers[next.first] = next.second; } } } graph; void solve(int l, int r, int tl, int tr) { int mid = (l + r) / 2; for (int i = l; i < mid; i++) { graph.merge(edges[i].first, edges[i].second); } int opt = tr; for (int i = tr; i > std::max(tl, mid); i--) { graph.merge(edges[i].first, edges[i].second); if (graph.pers[(0)]) opt = i - 1; } dp[mid] = opt; for (int i = tr; i > std::max(tl, mid); i--) graph.undo(); dp[mid] = opt; if (l == r) { for (int i = l; i < mid; i++) graph.undo(); return; } graph.merge(edges[mid].first, edges[mid].second); solve(mid + 1, r, opt, tr); for (int i = mid; i >= l; i--) graph.undo(); if (l < mid) { for (int i = tr; i > opt; i--) graph.merge(edges[i].first, edges[i].second); solve(l, mid - 1, tl, opt); for (int i = opt + 1; i <= tr; i++) graph.undo(); } } signed main() { std::ios::sync_with_stdio(false); std::cin.tie(0); std::cin >> n >> m >> q; graph.pers = std::vector<int>(2 * n + 1, -1); graph.pers[(0)] = 1; edges.resize(m); int last = 0; for (int i = 0; i < m; i++) { std::cin >> edges[i].first >> edges[i].second; edges[i].first--; edges[i].second--; if (graph.pers[(0)]) last = i; graph.merge(edges[i].first, edges[i].second); } dp.resize(last + 1); for (int i = 0; i < m; i++) graph.undo(); solve(0, last, 0, m - 1); while (q--) { int l, r; std::cin >> l >> r; l--; r--; if (l > last || r < dp[l]) std::cout << YES << std::endl; else std::cout << NO << std::endl; } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int n, m, k, s = 0, k2 = 0, k1 = 0, z; cin >> n >> m >> k; z = k % 2; while (true) { if (s + 2 * m >= k) { goto v; } else { s = s + 2 * m; k2++; } } v:; cout << k2 + 1 << ; while (true) { if (s >= (k - 2)) goto z; else { s = s + 2; k1++; } } z:; cout << k1 + 1 << ; if (z == 0) cout << R ; else cout << L ; }
#include <bits/stdc++.h> using namespace std; int main() { int n, i, j, r; char str[] = { R , O , Y , B , G , I , V }; cin >> n; r = n % 7; n -= r; for (i = 0; i < n; i++) cout << str[i % 7]; for (i = 0; i < r; i++) cout << str[3 + i % 4]; }
#include <bits/stdc++.h> using namespace std; int dx[] = {0, 0, +1, -1}; int dy[] = {+1, -1, 0, 0}; int dxx[] = {+1, 0, -1, 0, +1, +1, -1, -1}; int dyy[] = {0, +1, 0, -1, +1, -1, +1, -1}; inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; } vector<pair<long long, long long> > ans; int main() { long long x, i, sz = 0, l, y; scanf( %lld , &x); l = min(x, 10000000LL); for (i = 1; i <= l; i++) { y = x * 6LL; if (y % i) continue; y /= i; if (y % (i + 1)) continue; y /= (i + 1); y += (i - 1); if (y % 3) continue; y /= 3; if (y < i) continue; ans.push_back(make_pair(i, y)); if (i == y) sz++; else sz += 2; } printf( %lld n , sz); for (i = 0; i < ans.size(); i++) printf( %lld %lld n , ans[i].first, ans[i].second); for (i = ans.size() - 1; ~i; i--) if (ans[i].first != ans[i].second) printf( %lld %lld n , ans[i].second, ans[i].first); return 0; }
#include <bits/stdc++.h> using namespace std; const long long MAX = 4e6; vector<long long> vec[1000000]; long long N, T, ok, cur = 2, arr[MAX], res[MAX], cnt[MAX], prime[MAX]; void cal() { prime[0] = 1; prime[1] = 1; for (long long A = 2; A < MAX; A++) if (!prime[A]) { if (A < 1000000) vec[A].push_back(A); for (long long B = A + A; B < MAX; B += A) { prime[B] = 1; if (B < 1000000) vec[B].push_back(A); } } return; } signed main() { ios_base::sync_with_stdio(false); cal(); cin >> N; for (long long A = 1; A <= N; A++) cin >> arr[A]; for (long long A = 1; A <= N; A++) { if (ok == 0) for (auto B : vec[arr[A]]) { cnt[B]++; if (cnt[B] > 1) ok = 1; } if (ok == 0) res[A] = arr[A]; else if (ok == 1) { for (auto B : vec[arr[A]]) cnt[B]--; cur = arr[A] + 1; while (true) { T = 0; for (auto B : vec[cur]) T += cnt[B]; if (T == 0) { res[A] = cur; for (auto B : vec[cur]) cnt[B]++; break; } cur++; } cur = 2; ok = 2; } else { while ((prime[cur]) or (cnt[cur])) cur++; res[A] = cur++; } } for (long long A = 1; A <= N; A++) cout << res[A] << ; return 0; }
#include <bits/stdc++.h> using namespace std; bool r[1010], c[1010]; int main() { int n, m; cin >> n >> m; for (int i = 0; i < m; i++) { int a, b; cin >> a >> b; a--; b--; r[a] = 1; c[b] = 1; } int ans = 0; for (int i = 1; i < n - 1; i++) { if (!c[i]) ans++; if (!r[i]) ans++; if (!c[i] && !r[i] && !c[n - i] && !r[n - i] && (n - 1 - i) == i) ans--; } cout << ans << endl; }
#include <bits/stdc++.h> using namespace std; long long int modinverse(long long int x, long long int y) { if (y == 0) { return 1; } long long int p = modinverse(x, y / 2) % 1000000007; p = (p * p) % 1000000007; return (y % 2 == 0) ? p : (x * p) % 1000000007; } long long int modexp(long long int a, long long int n) { long long int ans = 1; a = a % 1000000007; while (n > 0) { if (n % 2) { ans = (ans * a) % 1000000007; } n /= 2; a = (a * a) % 1000000007; } return ans; } long long int arr[300001], on[30], off[30]; void solve(vector<long long int> index, long long int k) { if (k == -1 or index.size() <= 1) { return; } vector<long long int> one, zero; long long int cnt1 = 0, cnt2 = 0, inversion1 = 0, inversion2 = 0; for (auto itr : index) { if ((arr[itr] >> k) % 2 == 1) { one.push_back(itr); cnt1++; inversion1 += cnt2; } else { zero.push_back(itr); cnt2++; inversion2 += cnt1; } } on[k] += inversion1; off[k] += inversion2; solve(zero, k - 1); solve(one, k - 1); } long long int countInversion(vector<long long int> index, long long int k) { if (k == -1 or index.size() <= 1) { return 0; } vector<long long int> zero, one; long long int cnt = 0, inversion = 0; for (auto itr : index) { if ((arr[itr] >> k) % 2 == 1) { one.push_back(itr); cnt++; } else { zero.push_back(itr); inversion += cnt; } } inversion += countInversion(zero, k - 1); inversion += countInversion(one, k - 1); return inversion; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); long long int tt = 1; for (long long int tc = 1; tc <= tt; tc++) { long long int n; cin >> n; for (long long int i = 0; i <= n - 1; i++) { cin >> arr[i]; } vector<long long int> v; for (long long int i = 0; i <= n - 1; i++) { v.push_back(i); } for (long long int i = 0; i <= 29; i++) { on[i] = off[i] = 0; } solve(v, 29); long long int x = 0; for (long long int i = 0; i <= 29; i++) { if (on[i] < off[i]) { x += pow(2, i); } } for (long long int i = 0; i <= n - 1; i++) { arr[i] = (arr[i] ^ x); } long long int b = countInversion(v, 29); cout << b << << x; cout << n ; } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int t; cin >> t; for (int tmp = 0; tmp < t; tmp++) { unsigned long long int n, k; cin >> n >> k; if (k >= n) { cout << 1 << n ; continue; } bool fl = false; for (int i = 2; i * i <= n; i++) { if (n % i == 0 && n / i <= k) { cout << i << n ; fl = true; break; } } if (!fl) { for (int i = int(sqrt(n)); i >= 2; i--) { if (n % i == 0 && i <= k) { cout << n / i << n ; fl = true; break; } } } if (!fl) { cout << n << n ; } } }
#include <bits/stdc++.h> using namespace std; const int maxn = 1e5 + 5; double prob[maxn]; int main() { ios::sync_with_stdio(false); int n, p; while (cin >> n >> p) { int l, r; for (int i = 0; i < n; ++i) { cin >> l >> r; prob[i] = (double)(r / p - (l - 1) / p) / (r + 1 - l); } double sum = 0; for (int i = 0; i < n; ++i) { int j = (i + 1) % n; sum += 1.0 - (1 - prob[i]) * (1 - prob[j]); } printf( %.8lf n , sum * 2000); } return 0; }
#include <bits/stdc++.h> using namespace std; const long long int MAX = -1000000000000000000; const long long int MIN = 1000000000000000000; const long long int inf = 1000000000000000000; const long long int KOK = 100000; const long long int LOG = 30; const long long int li = 105; const long long int mod = 1000000007; long long int n, m, cev, b, a[li], k, dp[105][100005], PS[li][li]; string s; vector<int> v; long long int f(long long int sira, long long int topl) { long long int mn = inf; if (topl <= 0) return 0; if (sira > n) { return inf; } if (~dp[sira][topl]) return dp[sira][topl]; for (int i = sira; i <= n; i++) { mn = min(mn, f(i + 1, topl - PS[sira][i] + PS[sira][sira - 1]) + 1); } return dp[sira][topl] = mn; } int main() { memset(dp, -1, sizeof(dp)); scanf( %lld %lld , &n, &m); for (long long int i = 1; i <= n; i++) { scanf( %lld , &a[i]); } sort(a + 1, a + n + 1); reverse(a + 1, a + n + 1); for (long long int i = 1; i <= n; i++) { long long int at = 0; for (long long int j = i; j <= n; j++) { PS[i][j] = PS[i][j - 1] + max(a[j] - at, 0ll); at++; } } long long int yess = f(1, m); if (yess >= inf) { printf( -1 n ); return 0; } printf( %lld n , yess); return 0; }
#include <bits/stdc++.h> using namespace std; string a; int main() { cin >> a; cout << a; for (int i = a.size() - 1; i >= 0; i--) cout << a[i]; }
#include <bits/stdc++.h> using namespace std; const int INF = 1061109567; const int MAXN = 510005; int dp[MAXN]; int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); cout.precision(20); int n, d; cin >> n >> d; memset(dp, 0, sizeof dp); dp[0] = 1; int items[n]; for (int i = 0; i < n; i++) cin >> items[i]; for (int j = 0; j < n; j++) { for (int i = MAXN - items[j]; i >= 0; i--) if (dp[i]) dp[i + items[j]] = 1; } int itCount = 0; int i = 0; while (i < 500000) { bool flag = false; for (int j = i + d; j >= i + 1; j--) { if (dp[j]) { itCount++; i = j; flag = true; break; } } if (!flag) break; } cout << i << << itCount << endl; }
#include <bits/stdc++.h> using namespace std; const int logN = 18; const int maxN = 200005; char pch[maxN]; int n, m, q, sz; vector<pair<int, char> > g[maxN]; pair<int, int> orange[maxN][logN]; pair<int, int> rrange[maxN][logN]; vector<array<int, 4> > queries[maxN]; int par[maxN][logN], pos[maxN], ord[maxN], ind[maxN], ans[maxN], dep[maxN], f[maxN]; inline void update(int i, int x) { while (i <= m) { f[i] += x; i += i & (-i); } } inline int query(int i) { int ret = 0; while (i) { ret += f[i]; i &= (i - 1); } return ret; } void dfs(int v, int p) { par[v][0] = p; for (auto x : g[v]) { if (x.first != p) { dep[x.first] = dep[v] + 1; pch[x.first] = x.second; dfs(x.first, v); } } } void buildSuffixArray(string s) { int m = (int)s.size(); { vector<pair<char, int> > vec; for (int i = 0; i < m; i++) { vec.emplace_back(s[i], i); } sort(vec.begin(), vec.end()); for (int i = 0; i < m; i++) { if (i == 0 || vec[i].first != vec[i - 1].first) pos[vec[i].second] = i; else pos[vec[i].second] = pos[vec[i - 1].second]; } } for (int k = 1; k < logN; k++) { vector<pair<pair<int, int>, int> > vec; for (int i = 0; i < m; i++) { int j = i + (1 << (k - 1)); if (j < m) { vec.push_back({{pos[i], pos[j]}, i}); } else { vec.push_back({{pos[i], -1}, i}); } } sort(vec.begin(), vec.end()); for (int i = 0; i < m; i++) { if (i == 0 || vec[i].first != vec[i - 1].first) pos[vec[i].second] = i; else pos[vec[i].second] = pos[vec[i - 1].second]; } if ((1 << k) >= m) break; } for (int i = 0; i < m; i++) { ord[pos[i]] = i; } } inline pair<int, int> compute(pair<int, int> range1, pair<int, int> range2, int len1, int len2) { if (range1.first == -1 || range2.first == -1) return {-1, -1}; if (len1 == 0) return range2; if (len2 == 0) return range1; pair<int, int> ret = {-1, -1}; { int low = range1.first, hig = range1.second; if (ord[hig] + len1 == sz || range2.first > pos[ord[hig] + len1]) return {-1, -1}; while (low < hig) { int mid = (low + hig) / 2; if (ord[mid] + len1 < sz && range2.first <= pos[ord[mid] + len1]) { hig = mid; } else { low = mid + 1; } } ret.first = low; } { int low = range1.first, hig = range1.second; if (ord[low] + len1 < sz && range2.second < pos[ord[low] + len1]) return {-1, -1}; while (low < hig) { int mid = (low + hig + 1) / 2; if (ord[mid] + len1 >= sz || pos[ord[mid] + len1] <= range2.second) { low = mid; } else { hig = mid - 1; } } ret.second = low; } if (ret.first > ret.second) { ret = {-1, -1}; } return ret; } inline int lca(int u, int v) { if (dep[u] < dep[v]) swap(u, v); int diff = dep[u] - dep[v]; for (int i = logN - 1; i >= 0; i--) { if ((diff >> i) & 1) u = par[u][i]; } if (u == v) return u; for (int i = logN - 1; i >= 0; i--) { if (par[u][i] != par[v][i]) { u = par[u][i]; v = par[v][i]; } } return par[u][0]; } pair<int, int> get(int u, int v) { int w = lca(u, v); pair<int, int> range1 = {0, sz - 1}; pair<int, int> range2 = {0, sz - 1}; int len1 = 0, len2 = 0; { int dist = dep[u] - dep[w]; for (int i = logN - 1; i >= 0; i--) { if ((dist >> i) & 1) { range1 = compute(range1, orange[u][i], len1, 1 << i); len1 += (1 << i); u = par[u][i]; } } } { int dist = dep[v] - dep[w]; for (int i = logN - 1; i >= 0; i--) { if ((dist >> i) & 1) { range2 = compute(rrange[v][i], range2, 1 << i, len2); len2 += (1 << i); v = par[v][i]; } } } return compute(range1, range2, len1, len2); } int main() { ios::sync_with_stdio(false); cin.tie(nullptr); cin >> n >> m >> q; for (int i = 1; i < n; i++) { int u, v; char ch; cin >> u >> v >> ch; g[u].emplace_back(v, ch); g[v].emplace_back(u, ch); } dep[1] = 0; dfs(1, 1); for (int k = 1; k < logN; k++) { par[1][k] = 1; for (int i = 2; i <= n; i++) { par[i][k] = par[par[i][k - 1]][k - 1]; } } string s = ; memset(ind, -1, sizeof(ind)); for (int i = 1; i <= m; i++) { string t; cin >> t; for (int j = 0; j < (int)t.size(); j++) { ind[j + (int)s.size()] = i; } s += t; s += # ; } sz = (int)s.size(); buildSuffixArray(s); memset(orange, -1, sizeof(orange)); memset(rrange, -1, sizeof(rrange)); { vector<int> lo(26, -1); vector<int> hi(26, -1); for (int i = 0; i < sz; i++) { if (s[ord[i]] == # ) continue; if (lo[s[ord[i]] - a ] == -1) { lo[s[ord[i]] - a ] = i; } hi[s[ord[i]] - a ] = i; } for (int i = 2; i <= n; i++) { orange[i][0] = {lo[pch[i] - a ], hi[pch[i] - a ]}; rrange[i][0] = {lo[pch[i] - a ], hi[pch[i] - a ]}; } } for (int k = 1; k < logN; k++) { for (int u = 1; u <= n; u++) { int v = par[u][k - 1]; orange[u][k] = compute(orange[u][k - 1], orange[v][k - 1], 1 << (k - 1), 1 << (k - 1)); } for (int u = 1; u <= n; u++) { int v = par[u][k - 1]; rrange[u][k] = compute(rrange[v][k - 1], rrange[u][k - 1], 1 << (k - 1), 1 << (k - 1)); } } memset(ans, 0, sizeof(ans)); for (int i = 1; i <= q; i++) { int u, v, l, r; cin >> u >> v >> l >> r; pair<int, int> range = get(u, v); if (range.first == -1) { continue; } queries[range.second].push_back({l, r, i, 1}); if (range.first > 0) { queries[range.first - 1].push_back({l, r, i, -1}); } } memset(f, 0, sizeof(f)); for (int i = 0; i < sz; i++) { if (ind[ord[i]] != -1) { update(ind[ord[i]], 1); } for (auto x : queries[i]) { ans[x[2]] += x[3] * (query(x[1]) - query(x[0] - 1)); } } for (int i = 1; i <= q; i++) { cout << ans[i] << n ; } return 0; }
#include <bits/stdc++.h> using namespace std; int a[1005][1005], i, m, ans, k, l, j, q, x, n, ma, mi; string s; int main() { cin >> n >> k; if (k >= (n + 1) / 2) { cout << -1; return 0; } cout << n * k << endl; for (int i = 1; i <= n; i++) { int w = k; for (int j = 1; j <= n; j++) { if (a[i][j] == 1 || i == j) continue; cout << i << << j << endl; a[i][j] = 1; a[j][i] = 1; w--; if (!w) break; } } }
#include <bits/stdc++.h> using namespace std; struct Node { string oper; bool val; int left = -1; int right = -1; bool will_left_change = false; bool will_right_change = false; }; vector<Node> tree; bool f(bool l_val, bool r_val, string oper) { if (oper == AND ) { return (l_val && r_val); } else if (oper == OR ) { return (l_val || r_val); } else if (oper == XOR ) { return (l_val ^ r_val); } } void calc(Node &v) { if (v.oper == IN ) return; calc(tree[v.left]); if (v.right != -1) { calc(tree[v.right]); } if (v.right == -1) v.val = !tree[v.left].val; else { v.val = f(tree[v.left].val, tree[v.right].val, v.oper); } if (v.right == -1) v.will_left_change = true; else { v.will_left_change = (f(tree[v.left].val, tree[v.right].val, v.oper) != f(!tree[v.left].val, tree[v.right].val, v.oper)); v.will_right_change = (f(tree[v.left].val, tree[v.right].val, v.oper) != f(tree[v.left].val, !tree[v.right].val, v.oper)); } } vector<int> ans; void calc_leaves(Node &v, int ones_cnt, int depth, int v_index) { if (v.oper == IN ) { if (ones_cnt == depth) { ans[v_index] = !tree[1].val; } else { ans[v_index] = tree[1].val; } return; } calc_leaves(tree[v.left], ones_cnt + (int)v.will_left_change, depth + 1, v.left); if (v.right != -1) { calc_leaves(tree[v.right], ones_cnt + (int)v.will_right_change, depth + 1, v.right); } } int main() { ios::sync_with_stdio(false); cin.tie(NULL); int n; cin >> n; tree.resize(n + 1); ans.resize(n + 1, -1); for (int i = 1; i <= n; i++) { string s; cin >> s; if (s == IN ) { int z; cin >> z; tree[i].oper = s; tree[i].val = z; } else if (s == NOT ) { int id; cin >> id; tree[i].oper = s; tree[i].left = id; } else { int left, right; cin >> left >> right; tree[i].oper = s; tree[i].left = left; tree[i].right = right; } } calc(tree[1]); calc_leaves(tree[1], 0, 0, -1); for (int i = 1; i <= n; i++) { if (ans[i] != -1) cout << ans[i]; } return 0; }
#include <bits/stdc++.h> using namespace std; priority_queue<long long> q; int n, k; int main() { scanf( %d%d , &n, &k); for (int i = 0; i < k; i++) q.push(0); for (int i = 0; i < n; i++) { long long s, m; scanf( %I64d%I64d , &s, &m); long long num = q.top(); q.pop(); num = max(-num, s); printf( %I64d n , m + num); q.push(-(m + num)); } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int t, a, b, c, r; cin >> t; while (t--) { cin >> a >> b >> c >> r; int min = a < b ? a : b; int max = min == a ? b : a; int res = max - min + 1; if (c - r >= min && c + r <= max) { res = res - 2 * r - 1; } else if (min > c - r && max < c + r) { res = 0; } else if (c - r >= min && c - r <= max && c + r >= max) { res = res - (max - c + r) - 1; } else if (c + r <= max && c + r >= min && min >= c - r) { res = res - (c + r - min) - 1; } res = res == max - min + 1 ? max - min : res; cout << res << endl; } }
#include <bits/stdc++.h> using namespace std; int n, a[2006]; int one, g, mn = 1e9; int gcd(int _a, int _b) { return _b == 0 ? _a : gcd(_b, _a % _b); } int main() { scanf( %d , &n); for (int i = 1; i <= n; i++) { scanf( %d , &a[i]); g = gcd(g, a[i]); if (a[i] == 1) one++; } if (one != 0) { printf( %d n , n - one); return 0; } if (g != 1) { puts( -1 ); return 0; } for (int i = 1; i <= n; i++) { int b = a[i]; for (int j = i + 1; j <= n; j++) { b = gcd(b, a[j]); if (b == 1) { mn = min(mn, j - i); break; } } } printf( %d n , mn + n - 1); return 0; }
#include <bits/stdc++.h> using namespace std; const int maxn = 405; const int maxm = 5005; const int INF = 1000000000; const int mod = 1000000; struct EDGE { int cap, cost, v, next; } edge[mod]; int head[maxn], E, q[mod]; bool used[maxn]; int pre[maxn], cur[maxn], dis[maxn]; void add_edge(int s, int t, int cap, int cost) { edge[E].cap = cap; edge[E].cost = cost; edge[E].next = head[s]; edge[E].v = t; head[s] = E++; edge[E].cap = 0; edge[E].cost = -cost; edge[E].next = head[t]; edge[E].v = s; head[t] = E++; } int min(int a, int b) { return (a == -1 || b < a) ? b : a; } int SPFA(int s, int t, int n) { int f = -1, r = 0; int i, v; q[r] = s; for (i = 0; i < n; i++) dis[i] = INF; dis[s] = 0; pre[s] = s; cur[s] = -1; memset(used, false, sizeof(bool) * n); used[s] = true; while (f != r) { f++; if (f >= mod) f -= mod; s = q[f]; used[s] = false; for (i = head[s]; i != -1; i = edge[i].next) { v = edge[i].v; if (edge[i].cap > 0 && dis[s] + edge[i].cost < dis[v]) { dis[v] = dis[s] + edge[i].cost; pre[v] = s; cur[v] = i; if (!used[v]) { used[v] = true; r++; if (r >= mod) r -= mod; q[r] = v; } } } } return dis[t]; } int MinCost(int s, int t, int n) { int ans = 0; int u, v, cap; int cost; while (1) { cost = SPFA(s, t, n); if (cost == INF) break; u = v = t; cap = -1; for (u = t; u != s; u = pre[u]) { cap = min(cap, edge[cur[u]].cap); } ans += cost * cap; u = v = t; for (u = t; u != s; u = pre[u]) { edge[cur[u]].cap -= cap; edge[cur[u] ^ 1].cap += cap; } } return ans; } int dx[maxn]; int dy[maxn]; int c[maxm]; int x[maxm]; int y[maxm]; int main() { int n, m, g, k, z; int i, j; int s, t; while (scanf( %d%d%d%d , &n, &m, &k, &g) != -1) { memset(dx, 0, sizeof(int) * n); memset(dy, 0, sizeof(int) * m); for (i = 0; i < k; i++) { scanf( %d%d , &x[i], &y[i]); dx[--x[i]]++; dy[--y[i]]++; } int ans = 0; for (i = 0; i < n; i++) ans += dx[i] % g != 0; for (i = 0; i < m; i++) ans += dy[i] % g != 0; printf( %d n , ans); memset(c, -1, sizeof(int) * k); s = n + m; t = s + 1; for (; g >= 1; g--) { E = 0; memset(head, -1, sizeof(int) * (t + 1)); for (i = 0; i < k; i++) if (c[i] == -1) add_edge(x[i], y[i] + n, 1, 0); for (i = 0; i < n; i++) { add_edge(s, i, dx[i] / g, 0); if (dx[i] % g) add_edge(s, i, 1, 1); } for (i = 0; i < m; i++) { add_edge(i + n, t, dy[i] / g, 0); if (dy[i] % g) add_edge(i + n, t, 1, 1); } MinCost(s, t, t + 1); for (i = 0, z = 0; i < k; i++) if (c[i] == -1) { if (edge[z].cap == 0) { c[i] = g; dx[x[i]]--; dy[y[i]]--; } z += 2; } } for (i = 0; i < k; i++) { if (i) printf( ); printf( %d , c[i]); } puts( ); } return 0; }
#include <bits/stdc++.h> using namespace std; const int maxk = 11; long long p[maxk]; void init() { p[0] = 1; for (int i = 1; i <= maxk; ++i) p[i] = p[i - 1] * 10; } long long f(long long x) { if (x == 0) return 0; long long ret = 0; int pc = maxk - 1; while (p[pc] > x) --pc; ret += (pc + 1) * (x - p[pc] + 1); while (pc > 0) { --pc; ret += (pc + 1) * (p[pc + 1] - p[pc]); } return ret; } typedef long long (*FUN)(long long); long long bis(long long pos, FUN fun) { long long ans = 0; long long l = 0, r = 1000000000; while (l < r) { long long mid = l + (r - l) / 2; if (fun(mid) < pos) ans = mid, l = mid + 1; else r = mid; } return ans; } long long g(long long x) { if (x == 0) return 0; int pc = maxk - 1; while (p[pc] > x) --pc; long long ret = 0; ret += (pc + 1) * (x - p[pc] + 1) * (1 + x - p[pc] + 1) / 2; while (pc > 0) { --pc; ret += (pc + 1) * 9 * p[pc] * (x + x - (p[pc] - 1) - (p[pc + 1] - 2)) / 2; } return ret; } char cc[100000]; int main() { init(); int q; long long k; scanf( %d , &q); long long temp = 0; while (q--) { scanf( %lld , &k); long long ans = bis(k, g); k -= g(ans); ans = bis(k, f); k -= f(ans); sprintf(cc, %lld , ans + 1); printf( %c n , cc[k - 1]); } getchar(); getchar(); return 0; }
#include <bits/stdc++.h> const long long inf = 1e16; using namespace std; long long read() { long long x = 0, f = 1; char ch = getchar(); while (!isdigit(ch)) { if (ch == - ) f = -1; ch = getchar(); } while (isdigit(ch)) x = x * 10 + ch - 0 , ch = getchar(); return f * x; } int n; long long ans, d[505][505]; struct tmp { long long a, b, k; bool operator<(const tmp &o) const { return b > o.b; } } a[505]; int main() { n = read(); for (int i = 1; i <= n; i++) a[i] = tmp{read(), read(), read()}; sort(a + 1, a + 1 + n); for (int i = 1; i <= n; i++) { for (int j = 0; j <= i; j++) { d[i][j] = d[i - 1][j]; if (j > 0) d[i][j] = max(d[i][j], d[i - 1][j - 1] + a[i].a - (j - 1) * a[i].b); d[i][j] = max(d[i][j], d[i - 1][j] + a[i].a - a[i].k * a[i].b); } } for (int i = 1; i <= n; i++) ans = max(ans, d[n][i]); return 0 * printf( %lld n , ans); }
#include <bits/stdc++.h> using namespace std; int main() { int t; cin >> t; while (t--) { int n; cin >> n; int c1, c2; int d1, d2; int diff1, diff2; for (int i = 0; i < 3; i++) { if ((n - i) % 3 == 0) { c2 = (n - i) / 3; c1 = n - 2 * c2; diff1 = i; break; } } for (int i = 0; i < 3; i++) { if ((n - i) % 3 == 0) { d2 = (n + i) / 3; d1 = n - 2 * d2; diff2 = i; break; } } if (diff1 < diff2) cout << c1 << << c2 << n ; else cout << d1 << << d2 << n ; } }
#include <bits/stdc++.h> using namespace std; long long int n = 0, m, l = 0, k, a, b, c, sum = 0, i, r = 0, j, second, h, first = 0, sc, ans = 0, x, t, y; double aa, pp; int main() { ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); cin >> k >> b >> n >> t; if (k == 1) { ans = (ceil((1 + n * b - t) * 1.0 / b)); if (ans <= 0) cout << 0; else cout << ans; return 0; } aa = (t * (k - 1)) + t * b; aa = aa / (t * (k - 1) + b); pp = n * (log(k)) - log(t) + log(aa); pp = pp / log(k); if (pp - floor(pp) < 1e-12) { cout << setprecision(10) << floor(pp); return 0; } ans = ceil(pp); if (ans <= 0) cout << 0; else cout << ans; }
#include <bits/stdc++.h> #pragma warning(disable : 4996) using namespace std; const long double pi = acos(-1.0); const long double eps = 1e-5; const int INF = 0x3f3f3f3f; const long long INFLL = 0x3f3f3f3f3f3f3f3f; struct poi { double x, y; } p[200010]; int main() { ios::sync_with_stdio(0), cin.tie(0), cout.tie(0); int n; cin >> n; for (int i = (1); i <= (n); i++) cin >> p[i].x >> p[i].y; if (n & 1) { cout << NO ; return 0; } poi c; c.x = (p[1].x + p[n / 2 + 1].x) / 2; c.y = (p[1].y + p[n / 2 + 1].y) / 2; for (int i = (2); i <= (n / 2); i++) { if (fabs((p[i].x + p[i + n / 2].x) / 2 - c.x) < eps && fabs((p[i].y + p[i + n / 2].y) / 2 - c.y) < eps) ; else { cout << NO ; return 0; } } cout << YES ; return 0; }
#include <bits/stdc++.h> using namespace std; template <class T> void debug(T a, T b) { for (; a != b; ++a) cerr << *a << ; cerr << endl; } template <class T> void chmin(T& a, const T& b) { if (a > b) a = b; } template <class T> void chmax(T& a, const T& b) { if (a < b) a = b; } namespace std { template <class S, class T> ostream& operator<<(ostream& out, const pair<S, T>& a) { out << ( << a.first << , << a.second << ) ; return out; } } // namespace std bool valid[200005]; struct DomTree { static const int MAX_V = 200000; int semi[MAX_V], U[MAX_V], idom[MAX_V]; int puf[MAX_V], par[MAX_V]; int mn[MAX_V]; void init() { memset(puf, -1, sizeof(puf)); for (int i = 0; i < (MAX_V); ++i) mn[i] = i; } int root(int a) { if (puf[a] == -1) return a; int r = root(puf[a]); if (semi[mn[puf[a]]] < semi[mn[a]]) mn[a] = mn[puf[a]]; return puf[a] = r; } void unite(int a, int b) { puf[b] = a; } int eval(int v) { root(v); return mn[v]; } int cnt; int vs[MAX_V]; vector<int> bucket[MAX_V]; vector<int> g[MAX_V], rg[MAX_V]; void dfs(int v) { semi[v] = cnt; vs[cnt++] = v; for (int u : g[v]) if (semi[u] < 0) { par[u] = v; dfs(u); } } vector<int> g3[200005]; int size[200005]; int dfs3(int v) { if (valid[v]) size[v] = 1; for (auto to : g3[v]) { size[v] += dfs3(to); } return size[v]; } int solve(int n, int r, vector<int>* g_) { init(); for (int i = 0; i < (n); ++i) { g[i] = g_[i]; rg[i].clear(); } for (int i = 0; i < (n); ++i) for (auto to : g[i]) { rg[to].push_back(i); } for (int i = 0; i < (n); ++i) semi[i] = -1; cnt = 0; dfs(r); for (int i = n - 1; i > 0; i--) { int w = vs[i]; for (int v : rg[w]) { int u = eval(v); chmin(semi[w], semi[u]); } bucket[vs[semi[w]]].push_back(w); for (int v : bucket[par[w]]) U[v] = eval(v); bucket[par[w]].clear(); unite(par[w], w); } for (int i = 1; i < n; i++) { int w = vs[i]; int u = U[w]; if (semi[w] == semi[u]) idom[w] = semi[w]; else idom[w] = idom[u]; } for (int i = 1; i < n; i++) { int w = vs[i]; idom[w] = vs[idom[w]]; } idom[r] = -1; for (int i = 0; i < (n); ++i) if (i != r) g3[idom[i]].push_back(i); dfs3(r); int res = 0; for (int i = 0; i < (n); ++i) if (i != r) chmax(res, size[i]); return res; } }; DomTree D; int n, m, s; vector<pair<int, int> > g[200005]; const long long int INF = 1e18; long long int cost[200005]; vector<int> g2[200005]; int main() { cin >> n >> m >> s; --s; for (int i = 0; i < (m); ++i) { int a, b, c; scanf( %d%d%d , &a, &b, &c); --a; --b; g[a].push_back({b, c}); g[b].push_back({a, c}); } for (int i = 0; i < (n); ++i) cost[i] = INF; priority_queue<pair<long long int, int>, vector<pair<long long int, int> >, greater<pair<long long int, int> > > pq; pq.push({0, s}); cost[s] = 0; while (!pq.empty()) { pair<long long int, int> cur = pq.top(); pq.pop(); if (cost[cur.second] < cur.first) continue; for (auto e : g[cur.second]) { if (cost[e.first] > cur.first + e.second) { cost[e.first] = cur.first + e.second; pq.push({cost[e.first], e.first}); } } } for (int i = 0; i < (n); ++i) if (cost[i] < INF) for (auto e : g[i]) { if (cost[e.first] == cost[i] + e.second) g2[i].push_back(e.first); } for (int i = 0; i < (n); ++i) if (cost[i] < INF) valid[i] = 1; for (int i = 0; i < (n); ++i) if (cost[i] == INF) g2[s].push_back(i); int res = D.solve(n, s, g2); cout << res << endl; return 0; }
#include <bits/stdc++.h> using namespace std; const int maxn = 100010; int n, m, h, t, maxv; int e[maxn][2]; set<int> mp[maxn]; vector<int> g[maxn]; vector<int> xv, yv; set<int> comm; bool check(int x, int y, vector<int> &xv, vector<int> &yv, set<int> &comm) { int lx = max(0, (int)(h - xv.size())); int ly = max(0, (int)(t - yv.size())); if (comm.size() >= lx + ly) { printf( YES n ); printf( %d %d n , x, y); set<int>::iterator it = comm.begin(); int mx = min((int)xv.size(), h); for (int i = 0; i < mx; i++) printf( %d , xv[i]); for (int i = 0; i < lx; i++) { printf( %d , *it); it++; } printf( n ); int my = min((int)yv.size(), t); for (int i = 0; i < my; i++) printf( %d , yv[i]); for (int i = 0; i < ly; i++) { printf( %d , *it); it++; } printf( n ); return true; } return false; } bool solve(int x, int y) { if (mp[x].size() <= h || mp[y].size() <= t) return false; int cnt = mp[x].size() - 1; for (int i = 0; i < g[y].size() && cnt < h + t; i++) { int tx = g[y][i]; if (tx == x) continue; if (mp[x].count(tx) == 0) cnt++; } if (cnt < h + t) return false; xv.clear(); yv.clear(); comm.clear(); for (set<int>::iterator it = mp[x].begin(); it != mp[x].end() && xv.size() <= h && comm.size() <= maxv; it++) { int ty = *it; if (ty == y) continue; if (mp[y].find(ty) != mp[y].end()) comm.insert(ty); else xv.push_back(ty); } for (set<int>::iterator it = mp[y].begin(); it != mp[y].end() && yv.size() <= t && comm.size() <= maxv; it++) { int tx = *it; if (tx == x) continue; if (mp[x].find(tx) != mp[x].end()) comm.insert(tx); else yv.push_back(tx); } if (check(x, y, xv, yv, comm)) return true; return false; } int main() { scanf( %d%d%d%d , &n, &m, &h, &t); maxv = h + t; for (int i = 1; i <= n; i++) mp[i].clear(); for (int i = 0; i < m; i++) { int tx, ty; scanf( %d%d , &tx, &ty); mp[tx].insert(ty); mp[ty].insert(tx); g[tx].push_back(ty); g[ty].push_back(tx); } int flags = false; for (int i = 1; i <= n; i++) if (flags == false) for (int j = 0; j < g[i].size(); j++) { if (solve(i, g[i][j])) { flags = true; break; } } if (!flags) printf( NO n ); return 0; }
#include <bits/stdc++.h> using namespace std; int n, m, G, R, d[100127], w[100127], rt, tot = 0, mi[100127 * 20], c[100127 * 20][2]; long long f[100127], s[100127], ans; void change(int &p, int l, int r, int x, int v) { if (!p) p = ++tot; mi[p] = v; if (l == r) return; int mid = (1ll * l + r) >> 1; (x <= mid) ? change(c[p][0], l, mid, x, v) : change(c[p][1], mid + 1, r, x, v); } int Ask(int p, int l, int r, int L, int R) { if (R < L) return n + 1; if ((!p) || (R < l) || (r < L)) return n + 1; if ((L <= l) && (r <= R)) return mi[p]; int mid = (1ll * l + r) >> 1; return min(Ask(c[p][0], l, mid, L, R), Ask(c[p][1], mid + 1, r, L, R)); } inline int Get(int v) { if (v >= R) return Ask(rt, 0, R + G - 1, (v + G) % (R + G), v - 1); return min(Ask(rt, 0, R + G - 1, v + G, R + G - 1), Ask(rt, 0, R + G - 1, 0, v - 1)); } inline long long calc(int x, int y, int v) { if (y == n + 1) return 0; v = (v + s[y] - s[x]) % (R + G); return R + G - v; } int main() { scanf( %d%d%d , &n, &G, &R); int i, p, x; for (i = 1; i <= n + 1; i++) scanf( %d , &d[i]); w[n + 1] = n + 1; f[n + 1] = 0; for (i = 2; i <= n + 1; i++) s[i] = s[i - 1] + d[i]; for (i = n; i >= 1; i--) { w[i] = Get(s[i] % (R + G)); change(rt, 0, R + G - 1, s[i] % (R + G), i); } for (i = n; i >= 1; i--) f[i] = f[w[i]] + s[w[i]] - s[i] + calc(i, w[i], 0); scanf( %d , &m); while (m--) { scanf( %d , &x); ans = d[1] + x; x = (x + d[1]) % (G + R); if (x >= G) { ans += R + G - x; x = 0; } p = Get((R + G - x) % (R + G)); ans += f[p] + s[p] + calc(1, p, x); printf( %lld n , ans); } return 0; }
#include <bits/stdc++.h> using namespace std; template <class T> T gcd(T a, T b) { while (b ^= a ^= b ^= a %= b) ; return a; } template <class T> T lcm(T a, T b) { return (a / gcd<T>(a, b) * b); } template <class T> inline int countbit(T n) { return (n == 0) ? 0 : (1 + countbit(n & (n - 1))); } template <class T> inline bool isPrimeNumber(T n) { if (n <= 1) return false; for (T i = 2; i * i <= n; i++) if (n % i == 0) return false; return true; } template <class T> inline T powerMod(T p, int e, T m) { if (e == 0) return 1 % m; else if (e % 2 == 0) { T t = powerMod(p, e / 2, m); return multiplyMod(t, t, m); } else return multiplyMod(powerMod(p, e - 1, m), p, m); } bool isUpperCase(char c) { return c >= A && c <= Z ; } bool isLowerCase(char c) { return c >= a && c <= z ; } char toLowerCase(char c) { return (isUpperCase(c)) ? (c + 32) : c; } char toUpperCase(char c) { return (isLowerCase(c)) ? (c - 32) : c; } template <class T> string toString(T n) { ostringstream ost; ost << n; ost.flush(); return ost.str(); } int toInt(string s) { int r = 0; istringstream sin(s); sin >> r; return r; } double toDouble(string s) { double r = 0; istringstream sin(s); sin >> r; return r; } const double pi = acos(-1.0); int main() { string s; cin >> s; int pos = -14; vector<string> v = { 01:10 , 02:20 , 03:30 , 04:40 , 05:50 , 10:01 , 11:11 , 12:21 , 13:31 , 14:41 , 15:51 , 20:02 , 21:12 , 22:22 , 23:32 }; for (int i = 0; i < v.size(); i++) { if (s < v[i]) { pos = i; break; } } if (pos == -14) cout << 00:00 ; else cout << v[pos]; return 0; }
#include <bits/stdc++.h> using namespace std; int n, m, t, tbl[510][510], star[510][510], sum[510]; int main() { scanf( %d%d%d , &n, &m, &t); if (t == 0) { long long ans = 0; for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) ans += i * j; cout << ans << endl; return 0; } for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) scanf( %1d , tbl[i] + j); for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) star[i][j] = (tbl[i][j] && tbl[i - 1][j] && tbl[i + 1][j] && tbl[i][j - 1] && tbl[i][j + 1]); long long ans = 0; for (int i = 2; i < n; i++) { memset(sum, 0, sizeof(sum)); for (int j = i; j < n; j++) { for (int k = 2; k < m; k++) sum[k] += star[j][k]; for (int k = 2, l = 2, now = 0; k < m; k++) { while (l < m && (l <= k || now < t)) now += sum[l++]; if (now >= t) ans += m - l + 1; now -= sum[k]; } } } cout << ans << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int k, d; cin >> k >> d; if (k > 1 && d == 0) cout << No solution ; else { cout << d; for (int i = 0; i < k - 1; i++) cout << 0 ; } return 0; }
#include <bits/stdc++.h> using namespace std; map<string, int> a; int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); int n; cin >> n; while (n--) { int temp_val; string temp_s; cin >> temp_val >> temp_s; sort(temp_s.begin(), temp_s.end()); if (a[temp_s] < 1) a[temp_s] = temp_val; else a[temp_s] = min(a[temp_s], temp_val); } int ans = INT_MAX; if (a[ A ] >= 1 && a[ B ] >= 1 && a[ C ] >= 1) ans = a[ A ] + a[ B ] + a[ C ]; if (a[ A ] >= 1 && a[ BC ] >= 1) ans = min(ans, a[ A ] + a[ BC ]); if (a[ C ] >= 1 && a[ AB ] >= 1) ans = min(ans, a[ C ] + a[ AB ]); if (a[ B ] >= 1 && a[ AC ] >= 1) ans = min(ans, a[ B ] + a[ AC ]); if (a[ AB ] >= 1 && a[ BC ] >= 1) ans = min(ans, a[ AB ] + a[ BC ]); if (a[ AC ] >= 1 && a[ AB ] >= 1) ans = min(ans, a[ AC ] + a[ AB ]); if (a[ BC ] >= 1 && a[ AC ] >= 1) ans = min(ans, a[ BC ] + a[ AC ]); if (a[ ABC ] >= 1) ans = min(ans, a[ ABC ]); if (ans == INT_MAX) cout << -1 << endl; else cout << ans << endl; return 0; }
#include <bits/stdc++.h> using namespace std; const int MAXN = 2020 + 1; int vis[MAXN], par[MAXN], orig[MAXN], match[MAXN], aux[MAXN], t, N; vector<int> conn[MAXN]; queue<int> Q; void addEdge(int u, int v) { conn[u].push_back(v); conn[v].push_back(u); } void init(int n) { N = n; t = 0; for (int i = 0; i <= n; ++i) { conn[i].clear(); match[i] = aux[i] = par[i] = 0; } } void augment(int u, int v) { int pv = v, nv; do { pv = par[v]; nv = match[pv]; match[v] = pv; match[pv] = v; v = nv; } while (u != pv); } int lca(int v, int w) { ++t; while (true) { if (v) { if (aux[v] == t) return v; else aux[v] = t; v = orig[par[match[v]]]; } swap(v, w); } } void blossom(int v, int w, int a) { while (orig[v] != a) { par[v] = w; w = match[v]; if (vis[w] == 1) Q.push(w), vis[w] = 0; orig[v] = orig[w] = a; v = par[w]; } } bool bfs(int u) { fill(vis + 1, vis + 1 + N, -1); iota(orig + 1, orig + N + 1, 1); Q = queue<int>(); Q.push(u); vis[u] = 0; while (!Q.empty()) { int v = Q.front(); Q.pop(); for (int x : conn[v]) { if (vis[x] == -1) { par[x] = v; vis[x] = 1; if (!match[x]) return augment(u, x), true; Q.push(match[x]); vis[match[x]] = 0; } else if (vis[x] == 0 && orig[v] != orig[x]) { int a = lca(orig[v], orig[x]); blossom(x, v, a); blossom(v, x, a); } } } return false; } int Match() { int ans = 0; vector<int> V(N - 1); iota(V.begin(), V.end(), 1); shuffle(V.begin(), V.end(), mt19937(0x94949)); for (auto x : V) if (!match[x]) { for (auto y : conn[x]) if (!match[y]) { match[x] = y, match[y] = x; ++ans; break; } } for (int i = 1; i <= N; ++i) if (!match[i] && bfs(i)) ++ans; return ans; } struct UFD { vector<int> ufd; UFD(int n) : ufd(n) { iota(ufd.begin(), ufd.end(), 0); } int Find(int x) { if (x == ufd[x]) return x; return ufd[x] = Find(ufd[x]); } void Union(int a, int b) { ufd[Find(a)] = Find(b); } }; int main() { int N; cin >> N; vector<int> V(N); for (int& x : V) cin >> x; vector<pair<int, int>> ft; int from = -1; for (int i = 0; i < N; ++i) { if (V[i] == 0) { if (from == -1) from = i; } else { if (from != -1) ft.emplace_back(from, i - 1); from = -1; } } if (from != -1) ft.emplace_back(from, N - 1); if (ft.size() == 1 && ft[0].first == 0 && ft[0].second == N - 1) { for (int i = 0; i < N; ++i) cout << (i / 2) + 1 << ; cout << endl; return 0; } vector<pair<int, int>> ov, av; for (auto [f, t] : ft) { if (f == 0) { for (int i = 0; i + 1 <= t; i += 2) V[i] = V[i + 1] = -1; if (t % 2 == 0) V[t] = V[t + 1]; } else if (t == N - 1) { for (int i = t; i - 1 >= f; i -= 2) V[i] = V[i - 1] = -1; if ((t - f) % 2 == 0) V[f] = V[f - 1]; } else { if ((t - f + 1) % 2 == 0) av.emplace_back(f, t); else ov.emplace_back(f, t); } } int K = 600; UFD ufd(K + 1); init(K); vector<bool> used(K + 1); vector<int> cooked(K + 1); for (int i = 0; i < N - 1; ++i) if (V[i] == V[i + 1] && V[i] > 0) used[V[i]] = 1; vector<pair<int, int>> raw; for (auto [f, t] : ov) { int s = V[f - 1], e = V[t + 1]; if (ufd.Find(s) == ufd.Find(e)) { cooked[s] = s; used[s] = 1; V[f] = V[f - 1]; for (int i = f + 1; i <= t; ++i) V[i] = -1; } else raw.emplace_back(f, t); ufd.Union(s, e); } for (int i = 1; i <= K; ++i) if (cooked[i]) cooked[ufd.Find(i)] = cooked[i]; for (int i = 1; i <= K; ++i) if (cooked[ufd.Find(i)]) used[i] = 1; vector<vector<int>> added(K + 1, vector<int>(K + 1, -1)); for (int i = 0; i < (int)av.size(); ++i) { auto [f, t] = av[i]; int s = ufd.Find(V[f - 1]), e = ufd.Find(V[t + 1]); if (used[s] || used[e]) continue; if (added[s][e] != -1) continue; if (s == e) continue; added[s][e] = added[e][s] = i; addEdge(s, e); } Match(); vector<int> root(K + 1); for (int i = 1; i <= K; ++i) if (match[i] && match[i] > i) { int s = i, e = match[i]; auto [f, t] = av[added[s][e]]; V[f] = V[f - 1]; V[t] = V[t + 1]; used[V[f - 1]] = used[V[t + 1]] = 1; for (int j = f + 1; j <= t - 1; ++j) V[j] = -1; } for (auto [f, t] : av) if (V[f] == 0) for (int j = f; j <= t; ++j) V[j] = -1; vector<vector<tuple<int, int, int>>> conn(K + 1); for (auto [f, t] : raw) { int s = V[f - 1], e = V[t + 1]; conn[s].emplace_back(e, f, t); conn[e].emplace_back(s, f, t); } function<void(int, int)> dfs = [&](int a, int p) { for (auto [b, f, t] : conn[a]) if (b != p) { if (V[f] == 0) { for (int i = f; i <= t; ++i) V[i] = -1; if (V[f - 1] == b) V[f] = b; else V[t] = b; } dfs(b, a); } }; for (int i = 1; i <= K; ++i) if (ufd.Find(i) == i) { int p = i; if (cooked[p]) p = cooked[p]; else for (int i = 1; i <= K; ++i) if (used[i] && ufd.Find(i) == p) p = i; dfs(p, -1); } for (int i = 0; i < N - 1; ++i) if (V[i] == V[i + 1] && V[i] > 0) used[V[i]] = 1; int tp = 1; for (int i = 0; i < N - 1; ++i) if (V[i] == -1) { while (tp <= K && used[tp]) ++tp; assert(V[i + 1] == -1); V[i] = V[i + 1] = tp; if (tp <= K) used[tp] = 1; ++tp; } for (auto x : V) cout << x << , assert(x > 0); cout << endl; }
#include <bits/stdc++.h> long long i, j, r, c, fre[1000], ans; char na, name1[1000][1000]; using namespace std; int main() { scanf( %lld %lld %c , &r, &c, &na); for (i = 0; i < r; i++) { for (j = 0; j < c; j++) { scanf( %c , &name1[i][j]); } } for (i = 0; i < r; i++) { for (j = 0; j < c; j++) { if (name1[i][j] == na) { if (i - 1 >= 0) { fre[(int)name1[i - 1][j]]++; } if (i + 1 < r) { fre[(int)name1[i + 1][j]]++; } if (j + 1 < c) { fre[(int)name1[i][j + 1]]++; } if (j - 1 >= 0) { fre[(int)name1[i][j - 1]]++; } } } } for (i = 65; i <= 90; i++) { if (fre[i] > 0) { ans++; } } if (fre[(int)na] > 0) { ans--; } printf( %lld n , ans); }
#include <iostream> #include <iomanip> #include<iterator> // for iterators #include<vector> // for vectors #include <utility> #include <algorithm> #include <set> #include <map> #include <stack> #include <unordered_map> using namespace std; int main() { int t, n, temp; scanf( %d , &t); vector<int> v; while (t --) { scanf( %d , &n); for (int i = 0; i < n; ++i) { scanf( %d , &temp); v.emplace_back(temp); } sort(v.begin() , v.end()); int counter = 0; for (int i = 1; i < v.size(); ++i) { if (v[i] > v[0]) counter ++; } printf( %d n , counter); v.clear(); } return 0; }
#include <bits/stdc++.h> using namespace std; long long power(long long a, long long b) { long long res = 1; a %= 998244353; assert(b >= 0); for (; b; b >>= 1) { if (b & 1) res = res * a % 998244353 % 998244353; a = a * a % 998244353; } return res; } long long gcd(long long a, long long b) { if (a < b) return gcd(b, a); if (b == 0) return a; return gcd(b, a % b); } long long n, m; long long flg = 0; vector<long long> ad[500005]; long long t[500005]; int main() { ios::sync_with_stdio(0); cin.tie(0); ; long long i, j, k, x; cin >> n >> m; for (i = 0; i < m; i++) { cin >> j >> k; ad[j].push_back(k); ad[k].push_back(j); } vector<pair<long long, long long> > ans; for (i = 1; i <= n; i++) { cin >> t[i]; ans.push_back(make_pair(t[i], i)); } sort(ans.begin(), ans.end()); for (i = 1; i <= n; i++) { set<long long> tp; for (auto x : ad[i]) { tp.insert(t[x]); } for (j = 1; j < t[i]; j++) { auto it = tp.find(j); if (it == tp.end()) { cout << -1 << n ; return 0; } else { tp.erase(j); } } auto it = tp.find(t[i]); if (it != tp.end()) { cout << -1 << n ; return 0; } } for (i = 0; i < ans.size(); i++) { cout << ans[i].second << ; } cout << n ; return 0; }
#include <bits/stdc++.h> #pragma GCC optimize( O3 ) using namespace std; const int MAX = 2e5 + 5; const long long MAX2 = 11; const long long MOD = 998244353; const long long MOD2 = 1000005329; const long long INF = 2e18; const int dr[] = {1, 0, -1, 0, 1, 1, -1, -1, 0}; const int dc[] = {0, 1, 0, -1, 1, -1, 1, -1, 0}; const double pi = acos(-1); const double EPS = 1e-9; const int block = 2000; int n, m, a, b, c, v[205][205], ans; pair<double, pair<int, int> > e[205 * 205]; double le, ri, m1, m2, n1, n2, a1, a2, u[205][205], nx; int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); cin >> n >> m; for (int i = 1; i <= n; ++i) for (int j = 1; j <= n; ++j) if (i != j) v[i][j] = MOD; for (int i = 1; i <= m; ++i) { cin >> a >> b >> c; e[i] = {c, {a, b}}; v[a][b] = v[b][a] = min(v[a][b], c); } for (int k = 1; k <= n; ++k) for (int i = 1; i <= n; ++i) for (int j = 1; j <= n; ++j) v[i][j] = min(v[i][j], v[i][k] + v[k][j]); for (int i = 1; i <= n; ++i) for (int j = 1; j <= n; ++j) u[i][j] = v[i][j]; ans = 1e9; for (int i = 1; i <= m; ++i) { a = e[i].second.first, b = e[i].second.second; le = 0.0, ri = e[i].first; for (int k = 1; k <= 40; ++k) { m1 = (le + le + ri) / 3.0, n1 = e[i].first - m1; m2 = (le + ri + ri) / 3.0, n2 = e[i].first - m2; a1 = a2 = 0.0; for (int j = 1; j <= n; ++j) { a1 = max(a1, min(u[a][j] + m1, u[b][j] + n1)); a2 = max(a2, min(u[a][j] + m2, u[b][j] + n2)); } if (a1 < a2) ri = m2; else le = m1; } ans = min(ans, (int)round(a1 * 2.0)); nx = m1; le = 0.0, ri = nx; for (int k = 1; k <= 40; ++k) { m1 = (le + le + ri) / 3.0, n1 = e[i].first - m1; m2 = (le + ri + ri) / 3.0, n2 = e[i].first - m2; a1 = a2 = 0.0; for (int j = 1; j <= n; ++j) { a1 = max(a1, min(u[a][j] + m1, u[b][j] + n1)); a2 = max(a2, min(u[a][j] + m2, u[b][j] + n2)); } if (a1 < a2) ri = m2; else le = m1; } ans = min(ans, (int)round(a1 * 2.0)); le = nx, ri = e[i].first; for (int k = 1; k <= 40; ++k) { m1 = (le + le + ri) / 3.0, n1 = e[i].first - m1; m2 = (le + ri + ri) / 3.0, n2 = e[i].first - m2; a1 = a2 = 0.0; for (int j = 1; j <= n; ++j) { a1 = max(a1, min(u[a][j] + m1, u[b][j] + n1)); a2 = max(a2, min(u[a][j] + m2, u[b][j] + n2)); } if (a1 < a2) ri = m2; else le = m1; } ans = min(ans, (int)round(a1 * 2.0)); } if (ans & 1) cout << ans / 2 << .5 n ; else cout << ans / 2 << .0 n ; return 0; }
#include <bits/stdc++.h> using namespace std; const int mod = 1e9 + 7; const double eps = 1e-10; const double pi = acos(-1.0); const int maxn = 1e6 + 10; const long long inf = 0x3f3f3f3f; const int dir[8][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}, {1, 1}, {1, -1}, {-1, 1}, {-1, -1}}; int n, m; int dis[1010][1010][4]; char g[1010][1010]; queue<pair<int, int> > q; void bfs(int x) { for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) if (g[i][j] == 0 + x) q.push(make_pair(i, j)), dis[i][j][x] = 0; while (!q.empty()) { pair<int, int> p = q.front(); q.pop(); for (int i = 0; i < 4; i++) { int dx = p.first + dir[i][0]; int dy = p.second + dir[i][1]; if (dx < 1 || dx > n || dy < 1 || dy > m || g[dx][dy] == # ) continue; int v = (g[dx][dy] == . ); if (dis[p.first][p.second][x] + v < dis[dx][dy][x]) { dis[dx][dy][x] = dis[p.first][p.second][x] + v; q.push(make_pair(dx, dy)); } } } } int main() { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); cin >> n >> m; for (int i = 1; i <= n; i++) cin >> g[i] + 1; memset(dis, inf, sizeof dis); bfs(1), bfs(2), bfs(3); long long ans = inf; for (int i = 1; i <= n; i++) for (int j = 1; j <= m; j++) { long long tmp = 0; for (int k = 1; k <= 3; k++) tmp += dis[i][j][k]; if (g[i][j] == . ) tmp -= 2; ans = min(ans, tmp); } if (ans == inf) cout << -1; else cout << ans; return 0; }
#include <bits/stdc++.h> using namespace std; int a[1000011]; int find(long long v) { int i, ret = -1; for (i = 1; i <= 2 * sqrt(v) + 1; ++i) { if (1ll * i * (i - 1) / 2 >= v) { ret = i; break; } } if (ret == -1 || 1ll * ret * (ret - 1) / 2 != v) return -1; return ret; } int main() { long long a00, a01, a10, a11; cin >> a00 >> a01 >> a10 >> a11; if (a00 + a01 + a10 + a11 == 0) { printf( 0 n ); return 0; } long long n = find(a00 + a01 + a10 + a11); long long n0 = find(a00), n1 = find(a11); if (a00 == 0 && a01 == 0 && a10 == 0) { n0 = 0; } if (a11 == 0 && a01 == 0 && a10 == 0) { n1 = 0; } if (n0 == -1 || n1 == -1 || n == -1 || n0 + n1 != n) { printf( Impossible n ); return 0; } int i = 1; while (n0 > 0 && n1 > 0) { if (a01 >= n1) { a[i++] = 0; a01 -= n1; n0++; } else { a[i++] = 1; n1--; } } if (a01 != 0) { printf( Impossible n ); return 0; } while (n0 > 0) { a[i++] = 0; n0--; } while (n1 > 0) { a[i++] = 1; n1--; } for (i = 1; i <= (int)n; ++i) { printf( %d , a[i]); } printf( n ); return 0; }
//Code By CXY07 #include<bits/stdc++.h> using namespace std; //#define FILE //#define int long long #define debug(x) cout << #x << = << x << endl #define file(FILENAME) freopen(FILENAME .in , r , stdin), freopen(FILENAME .out , w , stdout) #define LINE() cout << LINE = << __LINE__ << endl #define LL long long #define ull unsigned long long #define pii pair<int,int> #define mp make_pair #define pb push_back #define fst first #define scd second #define inv(x) qpow((x),mod - 2) #define lowbit(x) ((x) & (-(x))) #define abs(x) ((x) < 0 ? (-(x)) : (x)) #define randint(l, r) (rand() % ((r) - (l) + 1) + (l)) #define vec vector const int MAXN = 1e6 + 10; const int INF = 2e9; const double PI = acos(-1); const double eps = 1e-6; //const int mod = 1e9 + 7; //const int mod = 998244353; //const int G = 3; //const int base = 131; int T, n, m; int _L[MAXN], _R[MAXN]; int *L = _L + (int)5e5, *R = _R + (int)5e5; char s[MAXN]; template<typename T> inline bool read(T &a) { a = 0; char c = getchar(); int f = 1; while(c < 0 || c > 9 ) {if(c == - ) f = -1; c = getchar();} while(c >= 0 && c <= 9 ) {a = a * 10 + (c ^ 48); c = getchar();} a *= f; return 1; } template<typename A, typename ...B> inline bool read(A &x, B &...y) {return read(x) && read(y...);} void solve() { scanf( %s , s + 1); n = strlen(s + 1); for(int i = -n; i <= n; ++i) L[i] = R[i] = 0; int now = 0; for(int i = 1; i <= n; ++i) { if(s[i] == 1 ) R[now++]++; else L[now--]++; } now = 0; for(int i = 1; i <= n; ++i) { if(L[now] && (!R[now] || R[now - 1])) L[now--]--, putchar( 0 ); else R[now++]--, putchar( 1 ); } putchar( n ); } signed main () { #ifdef FILE freopen( .in , r ,stdin); freopen( .out , w ,stdout); #endif read(T); while(T--) solve(); return 0; }
#include <bits/stdc++.h> using namespace std; struct edge { int u, v; long long c; bool operator<(const edge& other) const { return c < other.c; } }; vector<int> parent; vector<int> size; int get(int v) { if (parent[v] == v) { return v; } return parent[v] = get(parent[v]); } void unite(int a, int b) { a = get(a), b = get(b); if (size[a] < size[b]) { swap(a, b); } parent[b] = a; size[a] += size[b]; } const int rmax = 18; vector<vector<int> > p; vector<vector<long long> > maxx; vector<vector<edge> > g; vector<int> tin, tout; int timer = 0; void dfs(int v, int par) { tin[v] = timer++; p[v][0] = par; for (edge& e : g[v]) { if (e.v != par) { maxx[e.v][0] = e.c; dfs(e.v, v); } } tout[v] = timer++; } bool ancestor(int u, int v) { return tin[u] <= tin[v] && tout[u] >= tout[v]; } int lca(int u, int v) { if (ancestor(u, v)) { return u; } for (int r = rmax - 1; r >= 0; --r) { if (!ancestor(p[u][r], v)) { u = p[u][r]; } } return p[u][0]; } long long getMax(int u, int v) { assert(u != v && ancestor(v, u)); long long ans = 0; for (int r = rmax - 1; r >= 0; --r) { if (!ancestor(p[u][r], v)) { ans = max(ans, maxx[u][r]); u = p[u][r]; } } return max(ans, maxx[u][0]); } int main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); int n, m; cin >> n >> m; vector<edge> edges(m); for (int i = 0; i < m; ++i) { int u, v; long long c; cin >> u >> v >> c; --u, --v; edges[i] = {u, v, c}; } sort((edges).begin(), (edges).end()); parent.resize(n); size.assign(n, 1); for (int i = 0; i < n; ++i) { parent[i] = i; } long long total = 0; vector<edge> useful; for (int i = 0; i < m; ++i) { int u = edges[i].u, v = edges[i].v; u = get(u), v = get(v); if (u == v) { continue; } unite(u, v); total += edges[i].c; useful.push_back(edges[i]); } set<int> s; for (int i = 0; i < n; ++i) { s.insert(get(i)); } if ((int)(s).size() == 1) { p = vector<vector<int> >(n, vector<int>(rmax)); maxx = vector<vector<long long> >(n, vector<long long>(rmax)); g.resize(n); for (edge& e : useful) { int u = e.u, v = e.v; long long c = e.c; g[u].push_back({u, v, c}); g[v].push_back({v, u, c}); } tin.resize(n); tout.resize(n); dfs(0, 0); for (int r = 0; r + 1 < rmax; ++r) { for (int v = 0; v < n; ++v) { int t = p[v][r]; p[v][r + 1] = p[t][r]; maxx[v][r + 1] = max(maxx[v][r], maxx[t][r]); } } } int q; cin >> q; while (q--) { int a, b; cin >> a >> b; --a, --b; if ((int)(s).size() > 2) { cout << -1 n ; continue; } if ((int)(s).size() == 2) { a = get(a), b = get(b); if (a == b) { cout << -1 n ; continue; } cout << total << n ; continue; } int w = lca(a, b); long long ans = 0; if (a != w) { ans = max(ans, getMax(a, w)); } if (b != w) { ans = max(ans, getMax(b, w)); } cout << total - ans << n ; } }
#include <bits/stdc++.h> using namespace std; const long long inf = (long long)1e18; const long long mod = (long long)1e9 + 7; const double eps = (double)1e-9; const double pi = acos(-1.0); const int dx[] = {0, 0, 1, 0, -1}; const int dy[] = {0, 1, 0, -1, 0}; const int N = 300500; int n, dp[N]; vector<int> g[N], l; vector<pair<int, int> > gr, G, ga[N]; void dfs(int v, int pr = -1) { dp[v] = 1; for (int to : g[v]) { if (to != pr) { dfs(to, v); dp[v] += dp[to]; } } } int dfs1(int v) { for (int to : g[v]) { if (dp[to] * 2 > n) { dp[v] -= dp[to]; dp[to] += dp[v]; return dfs1(to); } } return v; } void dfs2(int v, int pr, int gl = 0) { gr.push_back(make_pair(gl, v)); for (int to : g[v]) { if (to != pr) { dfs2(to, v, gl + 1); } } } void checkv(int st) { gr.clear(); dfs2(st, -1, 0); sort(gr.begin(), gr.end()); for (int i = 0; i + 1 < n; ++i) { if (gr[i].first == gr[i + 1].first && (int)g[gr[i].second].size() != (int)g[gr[i + 1].second].size()) return; } cout << st << endl; exit(0); } int main() { cin.tie(NULL); cout.tie(NULL); ios_base::sync_with_stdio(false); cin >> n; for (int i = 1; i < n; ++i) { int x, y; cin >> x >> y; g[x].push_back(y); g[y].push_back(x); } dfs(1); int centroid = dfs1(1); checkv(centroid); for (int i = 1; i <= n; ++i) if ((int)g[i].size() == 1) l.push_back(i); for (int x : l) { int last = x; int cur = g[x][0]; int dist = 1; while ((int)g[cur].size() == 2) { int nxt = g[cur][0]; if (nxt == last) nxt = g[cur][1]; dist++; last = cur; cur = nxt; } if (dist == n - 1) { checkv(x); cout << -1; return 0; } ga[cur].push_back(make_pair(x, dist)); G.push_back(make_pair(dist, x)); } for (int i = 1; i <= n; ++i) { if ((int)ga[i].size() == 1) { checkv(ga[i][0].first); cout << -1; return 0; } } for (int i = 0; i + 1 < (int)G.size(); ++i) if (G[i].first != G[i + 1].first) { checkv(G[i].second); checkv(G[i + 1].second); cout << -1; return 0; } cout << -1 << endl; return 0; return 0; }
#include <bits/stdc++.h> using namespace std; long long n, ns, a[1111]; void ok(long long x) { long long l = 0, r = min(2000000000ll, (1ll << 62) / (x + 1) + 1); while (l < r) { long long m = (l + r) / 2; if (m * (m - 1) / 2 + m * x >= n) r = m; else l = m + 1; if (m * (m - 1) / 2 + m * x == n && m % 2) a[++ns] = m + m * x; } } int main() { while (cin >> n) { ns = 0; for (int i = 0; i < 62; i++) ok((1ll << i) - 1); if (!ns) cout << -1 << endl; else { for (int i = 1; i <= ns; i++) cout << a[i] << endl; } } return 0; }
#include <bits/stdc++.h> using namespace std; char num[200001]; int numLen, m, temp, answer = 0; int stepArr = 1; int main() { cin >> num >> m; numLen = strlen(num); answer += (num[numLen - 1] - 48) % m; for (int i = numLen - 2; i >= 0; i--) { stepArr = (stepArr * 10) % m; answer += ((num[i] - 48) * stepArr) % m; answer %= m; } temp = answer; for (int i = 0; i < numLen - 1; i++) { temp = ((((temp - (num[i] - 48) * stepArr) % m + m) * 10) % m + (num[i] - 48) % m) % m; if (num[i + 1] ^ 48) { answer = min(answer, temp); } } cout << answer; return 0; }
#include <bits/stdc++.h> template <typename T> T mymax(T x, T y) { return (x > y ? x : y); } using namespace std; const int N = 100005; const long long inf = 1e18; vector<int> graph[N], cost[N]; int n, m; long long dis[N]; struct node { int nd, c; node(int _nd, int _c) { nd = _nd; c = _c; } bool operator<(const node& p) const { return c > p.c; } }; void dijkstra() { priority_queue<node> pq; pq.push(node(1, 0)); for (int i = 0; i < N; i++) dis[i] = inf; dis[1] = 0; while (!pq.empty()) { node top = pq.top(); pq.pop(); int u = top.nd; for (int i = 0; i < (int)graph[u].size(); i++) { int v = graph[u][i]; if (dis[v] > dis[u] + cost[u][i]) { dis[v] = dis[u] + cost[u][i]; pq.push(node(v, dis[v])); } } } queue<int> q; q.push(n); vector<int> ans; ans.push_back(n); while (!q.empty()) { int u = q.front(); q.pop(); for (int i = 0; i < graph[u].size(); i++) { int v = graph[u][i]; if (dis[u] - cost[u][i] == dis[v]) { ans.push_back(v); q.push(v); break; } } } if (ans.size() == 1) { printf( -1 n ); return; } reverse((ans).begin(), (ans).end()); for (int x : ans) { printf( %d , x); } printf( n ); } void solve() { cin >> n >> m; for (int i = 0; i < m; i++) { int u, v, w; cin >> u >> v >> w; graph[u].push_back(v); graph[v].push_back(u); if (cost[u].size() == 0) { cost[u].push_back(w); cost[v].push_back(w); } else { int mn = 1e9; for (int i = 0; i < graph[u].size() - 1; i++) { int adj = graph[u][i]; if (adj == v) { mn = min(mn, cost[u][i]); } } mn = min(mn, w); cost[u].push_back(mn); cost[v].push_back(mn); } } dijkstra(); return; } int main() { solve(); return 0; }
#include <bits/stdc++.h> const int N = 150; int n; double p[N]; void init() { std::cin >> n; for (int i = 1; i <= n; i++) { scanf( %lf , &p[i]); p[i] /= 100.0; } } void work() { static double f[N]; for (int i = 1; i <= n; i++) { f[i] = 1.0; } double answer = 1.0; double pr = 1.0; for (int t = 2; t <= 500000; t++) { int best = -1; for (int i = 1; i <= n; i++) { if (best == -1 || (1.0 - f[i] * (1.0 - p[i])) * (1.0 - f[best]) > (1.0 - f[best] * (1.0 - p[best])) * (1.0 - f[i])) { best = i; } } f[best] *= 1.0 - p[best]; pr = 1.0; for (int i = 1; i <= n; i++) { pr *= 1.0 - f[i]; } answer += 1.0 - pr; } printf( %.10f n , answer); } int main() { init(); work(); return 0; }
#include <bits/stdc++.h> using namespace std; int s[51]; int main() { int n, g, check = 0, t = 0, q = 0; cin >> n; g = (n * (n - 1)) / 2; pair<int, int> can[g - 1]; for (int i = 0; i < g - 1; i++) { cin >> can[i].first >> can[i].second; s[can[i].first]++; s[can[i].second]++; } for (int i = 1; i <= n; i++) { if (s[i] < n - 1) { if (t == 0) t = i; else q = i; } } for (int i = 0; i < g; i++) { if (can[i].first == t) { check = 1; for (int r = 0; r < g; r++) { if (can[r].first == can[i].second && can[r].second == q) { cout << t << << q; return 0; } } } } if (check == 0) { cout << q << << t; return 0; } for (int i = 0; i < g; i++) { if (can[i].first == q) { for (int r = 0; r < g; r++) { if (can[r].first == can[i].second && can[r].second == t) { cout << q << << t; return 0; } } } } cout << t << << q; }
#include <bits/stdc++.h> using namespace std; #pragma optimize( -O3 ) string to_string(string s) { return + s + ; } string to_string(const char* s) { return to_string((string)s); } string to_string(const bool& b) { return (b ? true : false ); } template <typename A, typename B> string to_string(pair<A, B> p) { return ( + to_string(p.first) + , + to_string(p.second) + ) ; } template <typename A> string to_string(const A& v) { bool first = true; string res = { ; for (const auto& x : v) { if (!first) res += , ; first = false; res += to_string(x); } res += } ; return res; } void debug_out() { cerr << endl; } template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) { cerr << << to_string(H); debug_out(T...); } template <typename T> inline void _read(T& x) { cin >> x; } template <typename A, typename B> inline void _read(pair<A, B>& x) { _read(x.first); _read(x.second); } template <typename T> inline void _read(vector<T>& x) { for (auto& v : x) _read(v); } void R() {} template <typename T, typename... U> void R(T& head, U&... tail) { _read(head); R(tail...); } template <typename T> inline void _write(const T& x) { cout << x << ; } template <typename A, typename B> inline void _write(const pair<A, B>& x) { _write(x.first); _write(x.second); } template <typename T> inline void _write(const vector<T>& in) { for (const auto& x : in) _write(x); } void W() { cout << n ; } template <typename T, typename... U> void W(const T& head, const U&... tail) { _write(head); W(tail...); } void go(); int main() { ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr); go(); return 0; } int solve(int a, int b) { if (a == 1 && b == 2) return 3; if (a == 1 && b == 3) return 4; if (a == 2 && b == 1) return 3; if (a == 2 && b == 3) { W( Infinite ); exit(0); } if (a == 3 && b == 1) return 4; if (a == 3 && b == 2) { W( Infinite ); exit(0); } } void go() { int n; R(n); vector<int> a(n); R(a); int ans = 0; for (int i = 1; i < n; i++) { ans += solve(a[i - 1], a[i]); } for (int i = 2; i < n; i++) if (a[i - 2] == 3 && a[i - 1] == 1 && a[i] == 2) ans--; W( Finite ); W(ans); }
#include <bits/stdc++.h> using namespace std; const double pi = acos(-1); int S, n, tot; int fa[2100], a[2100][2100], p[2100 * 2100 / 2]; vector<int> E[2100]; void EXT() { printf( NO n ); exit(0); } int get(int x) { if (fa[x] == x) return x; return fa[x] = get(fa[x]); } void dfs(int x, int ff, int dep) { if (a[S][x] != dep) EXT(); for (int i : E[x]) if (i != ff) dfs(i, x, dep + a[x][i]); } int main() { scanf( %d , &n); for (int i = 1; i <= n; ++i) for (int j = 1; j <= n; ++j) scanf( %d , &a[i][j]); for (int i = 1; i <= n; ++i) { if (a[i][i] != 0) EXT(); for (int j = i + 1; j <= n; ++j) { if (a[i][j] != a[j][i] || a[i][j] == 0) EXT(); p[++tot] = (i << 20) + j; } } sort(p + 1, p + tot + 1, [](int x, int y) { return a[x >> 20][x & 0xffff] < a[y >> 20][y & 0xffff]; }); for (int i = 1; i <= n; ++i) fa[i] = i; for (int i = 1; i <= tot; ++i) { int x = p[i] >> 20, y = p[i] & 0xffff; if (get(x) == get(y)) continue; E[x].push_back(y); E[y].push_back(x); fa[get(x)] = get(y); } for (int i = 1; i <= n; ++i) { S = i; dfs(i, 0, 0); } printf( YES n ); }
#include <bits/stdc++.h> using namespace std; int top; int t[10000]; long long sum[100000]; int ans[5002][5002]; const int MOD = 1e9 + 7; int main() { int n, a, b, k; scanf( %d%d%d%d , &n, &a, &b, &k); if (a < b) top = b - 1; else top = abs(n - b); for (int i = 1; i <= top; i++) { int far = i * 2 - 1; if (far <= top) ans[i][1] = 2 * (i - 1); else ans[i][1] = i - 1 + (top - i); } for (int i = 1; i <= top; i++) sum[i] = (sum[i - 1] + t[i]) % MOD; for (int j = 2; j <= k; j++) { for (int q = 1; q <= top; q++) sum[q] = (sum[q - 1] + ans[q][j - 1]) % MOD; for (int i = 1; i <= top; i++) { int far = i * 2 - 1; if (far <= top) ans[i][j] = (sum[i - 1] + sum[far]) % MOD - sum[i]; else ans[i][j] = (sum[i - 1] + sum[top]) % MOD - sum[i]; ans[i][j] = ans[i][j] % MOD; } } printf( %d n , (ans[abs(a - b)][k] + MOD) % MOD); }
#include <bits/stdc++.h> using namespace std; int level(int n, int sum[]) { int i; for (i = 1; i < 11; i++) { if (n > sum[i - 1] && n <= sum[i]) { return i; } } } int number(int n, int l, int sum[]) { int st = sum[l - 1] + 1; return n - st + 1; } int main() { int sum[11] = {0, 1, 3, 6, 10, 15, 21, 28, 36, 45, 55}; int n, t, i, j, k; cin >> n >> t; int ans = 0; vector<int> adj[60]; for (i = 1; i < 56; i++) { int l = level(i, sum); int num = number(i, l, sum); adj[i].push_back(sum[l] + num); adj[i].push_back(sum[l] + num + 1); } double w[100] = {0}; double one = 1.00; for (j = 1; j <= t; j++) { w[1] += one; for (i = 1; i < 56; i++) { if (w[i] >= one) { double rem = (w[i] - one) / 2.00; w[i] = one; for (k = 0; k < adj[i].size(); k++) { w[adj[i][k]] += rem; } } } } for (i = 1; i <= sum[n]; i++) { if (w[i] == one) ans++; } cout << ans << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int n; double p[110], S; int main() { scanf( %d , &n); for (int i = 0; i <= n; i++) scanf( %lf , p + i); for (int i = 0; i < n; i++) for (int j = i + 1; j <= n; j++) if (i * 2 <= n && n <= j * 2) S = max( S, (n * 0.5 - j) / (i - j) * p[i] + (n * 0.5 - i) / (j - i) * p[j]); printf( %.9lf n , S); return 0; }
#include <bits/stdc++.h> using namespace std; struct dn { int c, z; } a[500001], b[500001]; int s1[500001], s2[500001]; int aa, bb; int flag; struct da { int x, y; }; vector<da> ans; void jh(int u, int v) { if (!flag) ans.push_back((da){s1[u], s2[v]}); else ans.push_back((da){s2[v], s1[u]}); flag ^= 1; dn x[10], y[10]; int xx = 0, yy = 0; for (int i = u + 1; i <= aa; i++) x[++xx] = a[i]; for (int i = v + 1; i <= bb; i++) y[++yy] = b[i]; aa = u; bb = v; if (aa && yy && y[1].c == a[u].c) y[1].z += a[u].z, aa--; if (bb && xx && x[1].c == b[v].c) x[1].z += b[v].z, bb--; for (int i = 1; i <= yy; i++) a[aa + 1] = y[i], s1[aa + 1] = s1[aa] + y[i].z, aa++; for (int i = 1; i <= xx; i++) b[bb + 1] = x[i], s2[bb + 1] = s2[bb] + x[i].z, bb++; } void cl() { if (a[aa].c == b[bb].c) { if (aa == 2 && bb == 2) { jh(0, 1); jh(1, 1); } else if (aa == 1 && bb == 2) { jh(1, 1); } else if (aa == 1 && bb == 3) { jh(1, 2); jh(0, 1); } else if (aa == 2 && bb == 1) { jh(1, 1); } else if (aa == 3 && bb == 1) { jh(2, 1); jh(1, 0); } } else { if (aa == 2 && bb == 2) { jh(1, 1); } else if (aa == 1 && bb == 3) { jh(1, 1); jh(1, 1); } else if (aa == 1 && bb == 2) { jh(0, 1); } else if (aa == 3 && bb == 1) { jh(1, 1); jh(1, 1); } else if (aa == 2 && bb == 1) { jh(1, 0); } } } char aaa[1000010], bbb[1000010]; int main() { scanf( %s%s , aaa + 1, bbb + 1); for (int i = 1; aaa[i]; i++) { int j = i; while (aaa[j + 1] == aaa[i]) j++; a[++aa] = (dn){aaa[i] == b , j - i + 1}; i = j; } for (int i = 1; bbb[i]; i++) { int j = i; while (bbb[j + 1] == bbb[i]) j++; b[++bb] = (dn){bbb[i] == b , j - i + 1}; i = j; } for (int i = 1; i <= aa; i++) s1[i] = s1[i - 1] + a[i].z; for (int i = 1; i <= bb; i++) s2[i] = s2[i - 1] + b[i].z; if (aa == 1) { if (bb <= 3) cl(); else { int u = bb - 3; if (b[u].c == a[1].c) jh(0, u); else jh(1, u); } } else if (bb == 1) { if (aa <= 3) cl(); else { int u = aa - 3; if (a[u].c == b[1].c) jh(u, 0); else jh(u, 1); } } for (;;) { if (aa + bb <= 4) { cl(); break; } if (a[aa].c == b[bb].c) { if (aa > bb) jh(aa - 2, bb - 1); else jh(aa - 1, bb - 2); } else { if (abs(aa - bb) <= 1) jh(aa - 1, bb - 1); else if (aa > bb) jh(aa - 3, bb - 1); else jh(aa - 1, bb - 3); } } printf( %d n , ans.size()); for (int i = 0; i < ans.size(); i++) printf( %d %d n , ans[i].x, ans[i].y); }
#include <bits/stdc++.h> using namespace std; const int maxn = 51; const int tot = maxn * maxn; long long input[maxn]; long long dp[maxn][tot][maxn]; long long dp2[maxn][tot][maxn]; long long comb[maxn + 1][maxn + 1]; int N, M; void init() { cin >> N; for (int i = 0; i < N; i++) { cin >> input[i]; } cin >> M; comb[0][0] = 1; for (int i = 1; i <= maxn; i++) { comb[i][0] = 1; for (int j = 1; j <= i; j++) { comb[i][j] = comb[i - 1][j] + comb[i - 1][j - 1]; } } } long long factorial[maxn]; bool vst[maxn]; void run() { int total = 0; for (int i = 0; i < N; i++) { total += input[i]; } if (total <= M) { cout << N << endl; return; } for (int i = 0; i < N; i++) { memset(vst, 0, sizeof(vst)); vst[i] = 1; dp[i][0][0] = 1; int cnt = 0; for (int j = 0; j < N; j++) { if (vst[j] == 0) { cnt++; for (int k = 0; k < tot; k++) { for (int t = 0; t <= cnt; t++) { dp2[i][k][t] = dp[i][k][t]; } } for (int k = 0; k < tot; k++) { for (int t = 0; t <= cnt; t++) { if (dp[i][k][t] && (k + input[j] < tot)) { dp2[i][k + input[j]][t + 1] += dp[i][k][t]; } } } for (int k = 0; k < tot; k++) { for (int t = 0; t <= cnt; t++) { dp[i][k][t] = dp2[i][k][t]; } } } } } double ans = 0; for (int i = M; i >= 0; i--) { for (int j = 0; j < N; j++) { if (i + input[j] > M) { for (int k = 0; k < N; k++) { double tmp = dp[j][i][k] * 1.0 / comb[N][k]; tmp /= (N - k); tmp *= k; ans += tmp; } } } } printf( %.8lf n , ans); } void baoli() { const int n = 50; int tmp[n]; cout << n << ; for (int i = 0; i < n; i++) { tmp[i] = i + 1; cout << tmp[i] << ; } int m = 100; cout << m << endl; double ans = 0; for (int test = 0; test <= 10000; test++) { random_shuffle(tmp, tmp + n); int sum = 0; for (int i = 0; i < n; i++) { sum += tmp[i]; if (sum > m) { ans += i; break; } } } cout << ans / 10000 << endl; } int main() { init(); run(); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { long int a, b, c; cin >> a >> b >> c; a = abs(a) + abs(b); if (a > c) cout << NO << endl; else { if ((c - a) % 2 == 0) cout << YES << endl; else cout << NO << endl; } }
#include <bits/stdc++.h> using namespace std; int main() { string a; for (int i = 0; i <= 9; i++) { cout << i << endl; cout << flush; a = ; getline(cin, a); if (a == no ) { continue; } else { if (a == don t think so || a == great! || a == don t touch me! || a == not bad || a == cool ) { cout << normal ; } else { if (a == are you serious || a == worse || a == terrible || a == don t even || a == no way || a == go die in a hole ) { cout << grumpy ; } else { cout << normal ; } } return 0; } } }
#include <bits/stdc++.h> using namespace std; const int N = 1e5 + 10; vector<int> v[N]; int num[N]; int q[N]; int cnt; int check(int mid) { int t = num[0] + mid, res = 0, tot = 0; for (int i = 1; i <= 100000; i++) { for (int j = 0; j <= max(-1, num[i] - t); j++) tot++, res += v[i][j]; } if (tot > mid) return 1 << 30; cnt = 0; for (int i = 1; i <= 100000; i++) { for (int j = max(0, num[i] - t + 1); j <= num[i] - 1; j++) q[++cnt] = v[i][j]; } sort(q + 1, q + cnt + 1); for (int i = 1; i <= mid - tot; i++) res += q[i]; return res; } int main() { int x, y; int n; ios::sync_with_stdio(false), cin.tie(0), cout.tie(0); cin >> n; for (int i = 0; i < n; i++) { cin >> x >> y; if (x == 0 || y == 0) num[0]++; else v[x].push_back(y), num[x]++; } for (int i = 1; i <= 100000; i++) { sort(v[i].begin(), v[i].end()); } int f = 1; for (int i = 1; i <= n; i++) { if (num[i] >= num[0]) f = false; } if (f) { puts( 0 ); return 0; } int l = 1, r = n; int ans = 1 << 30; while (l <= r) { int mid1 = l + (r - l) / 3; int f1 = check(mid1); int mid2 = r - (r - l) / 3; int f2 = check(mid2); if (f1 <= f2) r = mid2 - 1, ans = min(ans, f1); else l = mid1 + 1, ans = min(ans, f2); } cout << ans << endl; return 0; }
#include <bits/stdc++.h> #pragma GCC optimize(2) using namespace std; const long long INF = 1e17 + 7; const int N = 1e4 + 7; const int M = 5e6 + 7; long long x[N], y[N]; long long ax, ay, bx, by, a, b, t; signed main() { ios::sync_with_stdio(false); cin >> x[0] >> y[0] >> ax >> ay >> bx >> by; int n = 0; for (; x[n] < INF && y[n] < INF; n++) { x[n + 1] = x[n] * ax + bx; y[n + 1] = y[n] * ay + by; if (x[n + 1] >= INF || y[n + 1] >= INF) break; } cin >> a >> b >> t; long long ans = 0; for (int l = 0; l <= n; l++) { for (int r = l; r <= n; r++) { unsigned long long to = min(abs(a - x[l]) + abs(b - y[l]), abs(a - x[r]) + abs(b - y[r])); to += abs(x[l] - x[r]) + abs(y[l] - y[r]); if (to <= t) ans = max(ans, r - l + 1ll); } } cout << ans << n ; return 0; }
#include <bits/stdc++.h> using namespace std; void fastio() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); } int main() { fastio(); long long int a, b; long long int mx = INT_MIN; long long int n, mn = INT_MAX; cin >> n; long long int ar[n]; for (int i = 0; i < n; i++) { cin >> ar[i]; mn = min(mn, ar[i]); mx = max(ar[i], mx); } long long int res = mx - mn + 1; cout << res - n; return 0; }
#include <bits/stdc++.h> using namespace std; mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count()); int len(pair<int, int> xy) { return xy.first + xy.second; } pair<int, int> jump(pair<int, int> xy, int len) { if (len == 0) return xy; auto [x, y] = xy; if (len > x + y) return {0, 0}; int bit = 31 - __builtin_clz(len); int cur = x ^ y; int take = cur & ((1 << bit) - 1); assert(take <= len); x &= ~take; y &= ~take; len -= take; while (len > 0) { int bit = __builtin_ctz(x ^ y); int take = min(1 << bit, len); if ((x >> bit) & 1) x -= take; else y -= take; len -= take; } return {x, y}; } pair<int, int> lca(pair<int, int> u, pair<int, int> v) { int lu = len(u), lv = len(v); if (lu > lv) { swap(lu, lv); swap(u, v); } v = jump(v, lv - lu); if (u == v) return u; for (int bit = 29; bit >= 0; bit--) { auto nu = jump(u, 1 << bit), nv = jump(v, 1 << bit); if (nu != nv) tie(u, v) = {nu, nv}; } return jump(u, 1); } bool cmp(pair<int, int> u, pair<int, int> v) { if (u == v) return false; bool swp = false; int lu = len(u), lv = len(v); if (lu > lv) { swap(lu, lv); swap(u, v); swp = true; } v = jump(v, lv - lu); if (u == v) return true ^ swp; return (u > v) ^ swp; } using event = pair<pair<int, int>, int>; vector<event> evt; struct node { int val, depth; node *left, *right; }; node *build(int from, int to) { if (from >= to) return nullptr; int val = 0; auto w = lca(evt[from].first, evt[to - 1].first); while (from < to && evt[from].first == w) { val += evt[from].second; ++from; } auto [wx, wy] = w; if ((wx + 1) & wy) return new node({val, len(w), nullptr, build(from, to)}); if (wx & (wy + 1)) return new node({val, len(w), build(from, to), nullptr}); pair<int, int> rchild(wx, wy + 1); int lo = from - 1, hi = to; while (lo + 1 < hi) { auto mi = (lo + hi) / 2; if (cmp(evt[mi].first, rchild)) lo = mi; else hi = mi; } return new node({val, len(w), build(from, hi), build(hi, to)}); } vector<int> change; void add(int l, int r) { change.push_back(l); change.push_back(r); } void simplify() { sort((change).begin(), (change).end()); vector<int> st; for (auto x : change) { if (!st.empty() && st.back() == x) st.pop_back(); else st.push_back(x); } change = st; } int dfs(node *u) { int ans = 0; if (u->left) { auto s = dfs(u->left); if (s > 0) add(u->depth + 1, u->left->depth); ans += s; } if (u->right) { auto s = dfs(u->right); if (s > 0) add(u->depth + 1, u->right->depth); ans += s; } ans += u->val; if (ans > 0) add(u->depth, u->depth + 1); return ans; } void print(node *u, string tab = ) { if (!u) { cerr << tab << X n ; return; } cerr << tab << u->val << << u->depth << endl; auto ntab = tab + ; print(u->left, ntab); print(u->right, ntab); } int main() { ios_base::sync_with_stdio(0); cin.tie(0); int m; cin >> m; while (m--) { int x1, y1, x2, y2; cin >> x1 >> y1 >> x2 >> y2; pair<int, int> u(x1, y1), v(x2, y2); pair<int, int> w = lca(u, v); evt.emplace_back(u, +1); evt.emplace_back(v, +1); evt.emplace_back(w, -1); if (len(w)) { w = jump(w, 1); evt.emplace_back(w, -1); } } sort((evt).begin(), (evt).end(), [](const event &a, const event &b) { return cmp(a.first, b.first); }); auto tree = build(0, ((int)(evt).size())); dfs(tree); simplify(); int ans = ((int)(change).size()); if (ans > 0 && change[0] == 0) --ans; cout << ans << endl; return 0; }
#include <bits/stdc++.h> using namespace std; const int mod = 1e9 + 7; vector<int> nums, fact; int a, b, n; void precomp() { fact.resize(n + 1); fact[0] = 1; for (int i = 1; i <= n; ++i) fact[i] = 1ll * fact[i - 1] * i % mod; } void gener() { int _max = log10(max(a, b) * n); queue<int> q; q.push(0); while (!q.empty()) { int top = q.front(); q.pop(); nums.push_back(top); if ((int)log10(top) == _max) continue; for (int i : {a, b}) q.push(10 * top + i); } } void egcd(int a, int b, int& x, int& y) { if (b == 0) { x = 1; y = 0; return; } int x1, y1; egcd(b, a % b, x1, y1); x = y1; y = x1 - (a / b) * y1; } int inv_mod(int a) { int x, y; egcd(a, mod, x, y); return (x + mod) % mod; } int binom(int n, int k) { int top = fact[n]; int bot = 1ll * fact[k] * fact[n - k] % mod; return 1ll * top * inv_mod(bot) % mod; } int main() { cin >> a >> b >> n; precomp(); gener(); int ans = 0; for (int c : nums) { int top = c - b * n; int bot = a - b; if (top % bot) continue; int res = top / bot; if (res >= 0 && res <= n) ans = (ans + binom(n, res)) % mod; } cout << ans << endl; }
#include <bits/stdc++.h> using namespace std; struct num { static const int MA = 1e9 + 7, MB = 1e9 + 9; int a, b; num() {} num(int x) : a(x), b(x) {} num(int a, int b) : a(a), b(b) {} num operator+(const num& x) const { return num((a + x.a) % MA, (b + x.b) % MB); } num operator-(const num& x) const { return num((a + MA - x.a) % MA, (b + MB - x.b) % MB); } num operator*(int x) const { return num(((long long)a * x) % MA, ((long long)b * x) % MB); } num operator*(const num& x) const { return num(((long long)a * x.a) % MA, ((long long)b * x.b) % MB); } bool operator==(const num& x) const { return a == x.a && b == x.b; } }; struct num2 { static const int MB = 1e9 + 9; int b; num2() {} num2(int x) : b(x) {} num2 operator+(const num2& x) const { return num2((b + x.b) % MB); } num2 operator-(const num2& x) const { return num2((b + MB - x.b) % MB); } num2 operator*(int x) const { return num2(((long long)b * x) % MB); } num2 operator*(const num2& x) const { return num2(((long long)b * x.b) % MB); } bool operator==(const num2& x) const { return b == x.b; } }; const int MODP = 701; template <class T> struct StringOps { StringOps() {} StringOps(const string& s) : s(s) { n = s.length(); deg.resize(n + 1); hashes.resize(n); deg[0] = T(1); for (int i = 1; i <= n; ++i) { deg[i] = deg[i - 1] * T(MODP); } T curhash = T(0); for (int i = 0; i < n; ++i) { curhash = curhash * T(MODP) + T(s[i]); hashes[i] = curhash; } } char get(int idx) { return s[idx]; } T get_hash(int l, int r) { T cur(0); if (l > 0) { cur = hashes[l - 1]; } return hashes[r] - cur * deg[r - l + 1]; } int string_lcp(int l, int r, int lim = 1e9) { int cleft = 1, cright = min(n - r, n - l); cright = min(lim, cright); int res = 0; while (cleft <= cright) { int key = (cleft + cright) / 2; if (s[l + key - 1] != s[r + key - 1]) { cright = key - 1; } else if (get_hash(l, l + key - 1) == get_hash(r, r + key - 1)) { res = key; cleft = key + 1; } else { cright = key - 1; } } return res; } bool substring_cmp(int l1, int r1, int l2, int r2) { int lcp = string_lcp(l1, l2); int len1 = r1 - l1 + 1, len2 = r2 - l2 + 1; if (lcp >= len1 && lcp >= len2) { return len1 < len2; } if (lcp >= len1) { return true; } if (lcp >= len2) { return false; } return s[l1 + lcp] < s[l2 + lcp]; } vector<T> hashes; vector<T> deg; string s; int n; }; const int maxN = 1000100; const int MOD = 1e9 + 7; int len1, len2; int u, v; StringOps<num2> sops; int get_nlength(const pair<int, int>& a) { if (a.first == u) { if (a.second != len1) { return len1 - 1; } else { return len1; } } if (a.second != len2) { return len2 - 1; } else { return len2; } } void fill_segs(int& l1, int& r1, int& l2, int& r2, const pair<int, int>& a) { if (a.first == u) { l2 = r2 = -1; if (a.second == 0) { l1 = 1, r1 = len1 - 1; } else if (a.second >= len1 - 1) { l1 = 0, r1 = a.second - 1; } else { l1 = 0, r1 = a.second - 1; l2 = a.second + 1, r2 = len1 - 1; } return; } l2 = r2 = -1; if (a.second == 0) { l1 = 1, r1 = len2 - 1; } else if (a.second >= len2 - 1) { l1 = 0, r1 = a.second - 1; } else { l1 = 0, r1 = a.second - 1; l2 = a.second + 1, r2 = len2 - 1; } l1 += len1, r1 += len1; if (l2 != -1) { l2 += len1, r2 += len1; } } int cmp2(vector<pair<int, int>>& a, vector<pair<int, int>>& b, int p1 = 0, int p2 = 0) { if (p1 == a.size() && p2 < b.size()) { return -1; } if (p1 == a.size() && p2 == b.size()) { return 0; } if (p2 == b.size() && p1 < a.size()) { return 1; } if (p1 + 1 == a.size() && p2 + 1 == b.size() && a[0] == b[0]) { return 0; } if (p1 + 2 == a.size() && p2 + 2 == b.size() && a[0] == b[0] && a[1] == b[1]) { return 0; } if (sops.get(a[p1].first) != sops.get(b[p2].first)) { char c1 = sops.get(a[p1].first); char c2 = sops.get(b[p2].first); if (c1 < c2) { return -1; } return 1; } int lcp = sops.string_lcp( a[p1].first, b[p2].first, min(a[p1].second - a[p1].first + 1, b[p2].second - b[p2].first + 1)); lcp = min( lcp, min(a[p1].second - a[p1].first + 1, b[p2].second - b[p2].first + 1)); int nx = a[p1].first + lcp - 1, ny = b[p2].first + lcp - 1; if (nx >= a[p1].second) { ++p1; } else { a[p1].first = nx + 1; } if (ny >= b[p2].second) { ++p2; } else { b[p2].first = ny + 1; } return cmp2(a, b, p1, p2); } bool cmp(const pair<int, int>& a, const pair<int, int>& b) { int nlen1 = get_nlength(a); int nlen2 = get_nlength(b); if (nlen1 == 0 && nlen2 == 0) { if (a.first == u & b.first == v) { return true; } return false; } if (nlen1 == 0) { return true; } if (nlen2 == 0) { return false; } int l1, r1, l2, r2; fill_segs(l1, r1, l2, r2, a); int p1, q1, p2, q2; fill_segs(p1, q1, p2, q2, b); vector<pair<int, int>> na; vector<pair<int, int>> nb; na.push_back(make_pair(l1, r1)); if (l2 != -1) { na.push_back(make_pair(l2, r2)); } nb.push_back(make_pair(p1, q1)); if (p2 != -1) { nb.push_back(make_pair(p2, q2)); } int val = cmp2(na, nb); if (val == 0) { if (a.first == u && b.first == v) { return true; } return false; } return val == -1; } struct Node { Node() { left = right = nullptr; } int idxleft, idxright; Node* left; Node* right; }; int curorder[maxN]; int lenorder; void dfs(Node* root) { if (!root) { return; } if (root->left) { dfs(root->left); } for (int i = root->idxleft; i <= root->idxright; ++i) { curorder[lenorder] = i; ++lenorder; } if (root->right) { dfs(root->right); } } pair<int, int> order[2][maxN]; int clen[2]; void get_order(const string& s, int p) { int n = s.length(); Node* root = new Node(); Node* curnode = root; for (int i = 0; i < n;) { int cur = i; while (cur < n && s[cur] == s[i]) { ++cur; } curnode->idxleft = i, curnode->idxright = cur - 1; if (cur == n) { break; } if (s[i] < s[cur]) { Node* left = new Node(); curnode->left = left; curnode = curnode->left; } else { Node* right = new Node(); curnode->right = right; curnode = curnode->right; } i = cur; } lenorder = 0; dfs(root); int ps = n; for (int i = 0; i < n; ++i) { if (curorder[i] == n - 1) { ps = i + 1; break; } } vector<pair<int, int>> result; clen[p] = 0; for (int i = 0; i < ps; ++i) { order[p][clen[p]] = make_pair(v, curorder[i]); ++clen[p]; } order[p][clen[p]] = make_pair(v, n); ++clen[p]; for (int i = ps; i < n; ++i) { order[p][clen[p]] = make_pair(v, curorder[i]); ++clen[p]; } } int dp[2][maxN]; int dp2[2][maxN]; void gen() { cout << 10 << endl; for (int i = 0; i < 10; ++i) { for (int j = 0; j < 100000; ++j) { cout << char(rand() % 26 + a ); } cout << endl; } } int main() { ios_base::sync_with_stdio(false); cin.tie(nullptr); int n; cin >> n; vector<string> s(n); for (int i = 0; i < n; ++i) { cin >> s[i]; } for (int i = 0; i <= s[0].length(); ++i) { dp[u][i] = 1; dp2[u][i] = 1; } sops = StringOps<num2>(s[0]); len1 = 0, len2 = s[0].length(); u = 1, v = 0; get_order(s[0], 0); swap(u, v); for (int i = 0; i + 1 < n; ++i) { string& s1 = s[i]; string& s2 = s[i + 1]; string nw = s1 + s2; len1 = s1.length(), len2 = s2.length(); sops = StringOps<num2>(nw); get_order(s[i + 1], v); int cadd = 0; int head1 = 0, head2 = 0; while (head1 < clen[u] || head2 < clen[v]) { if (head1 == clen[u]) { dp[v][order[v][head2].second] = cadd; ++head2; } else if (head2 == clen[v]) { break; } else { if (cmp(order[u][head1], order[v][head2])) { int nhead1 = head1; while (nhead1 < clen[u] && s1[order[u][nhead1].second] == s1[order[u][head1].second] && order[u][nhead1].second - order[u][head1].second == nhead1 - head1) { ++nhead1; } for (int j = head1; j < nhead1; ++j) { cadd += dp[u][order[u][j].second]; if (cadd >= MOD) { cadd -= MOD; } } head1 = nhead1; } else { int nhead2 = head2; while (nhead2 < clen[v] && s2[order[v][nhead2].second] == s2[order[v][head2].second] && order[v][nhead2].second - order[v][head2].second == nhead2 - head2) { ++nhead2; } for (int j = head2; j < nhead2; ++j) { dp[v][order[v][j].second] = cadd; } head2 = nhead2; } } } swap(u, v); } int res = 0; int res2 = 0; for (int i = 0; i <= s.back().length(); ++i) { res += dp[u][i]; if (res >= MOD) { res -= MOD; } res2 += dp2[u][i]; if (res2 >= MOD) { res2 -= MOD; } } cout << res << endl; cerr << (double)clock() / CLOCKS_PER_SEC << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int n, h, count = 0; cin >> n >> h; int a[n]; for (int i = 0; i < n; i++) cin >> a[i]; for (int i = 0; i < n; i++) { if (a[i] > h) count += 2; else count += 1; } cout << count; }
#include <bits/stdc++.h> using namespace std; int main() { int a; cin >> a; vector<int> s(6); for (int i = 0; i < 6; i++) { if ((1 << i) & a) s[i]++; } int res = 0; res += (16 * s[0]); res += (2 * s[1]); res += (8 * s[2]); res += (4 * s[3]); res += s[4]; res += (32 * s[5]); cout << res << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int l[6]; int main() { int n, m, a; cin >> m >> n; for (int i = 0; i < m; i++) { for (int i = 1; i <= n; i++) { cin >> a; l[i] = max(l[i - 1], l[i]) + a; } cout << l[n] << ; } return 0; }
#include <bits/stdc++.h> using namespace std; const int Inf = 0x3f3f3f3f; const long long INF = 0x3f3f3f3f3f3f3f3fll; const int qwq = 1 << 19; int N, Q; int a[qwq]; struct Query { int r1, c1, r2, c2, id; Query(int r1, int c1, int r2, int c2, int id) : r1(r1), c1(c1), r2(r2), c2(c2), id(id) {} bool inline operator<(const Query& a) const { return r2 < a.r2; } }; struct Segtree { int dt[qwq << 1]; void inline init() { memset(dt, Inf, sizeof(dt)); } void inline add(int a, int x) { a += qwq; dt[a] = x; while (a >>= 1) dt[a] = min(dt[a << 1], dt[a << 1 | 1]); } int inline get(int l, int r) { int res = Inf; for (l += qwq, r += qwq + 1; l < r; l >>= 1, r >>= 1) { if (l & 1) res = min(res, dt[l++]); if (r & 1) res = min(res, dt[--r]); } return res; } } sl, sr, qj; vector<Query> q1, q2; int ans[qwq]; vector<int> dd; int inline mianx(int a, int l, int r) { return max(min(a, r), l); } int inline Ubval(int val) { int l = -1, r = ((int)(dd).size()); while (r - l > 1) { int m = (l + r) >> 1; if (a[dd[m]] > val) r = m; else l = m; } return r; } int inline Lbpos(int val) { return lower_bound((dd).begin(), (dd).end(), val) - dd.begin(); } int inline FLbpos(int val) { return upper_bound((dd).begin(), (dd).end(), val, greater<int>()) - dd.begin(); } void inline solve() { int qid = 0; sl.init(); sr.init(); qj.init(); for (int i = 1; i <= (N); ++i) qj.add(i, a[i]); for (int i = 1; i <= (N); ++i) { while (((int)(dd).size()) && a[dd.back()] >= a[i]) dd.pop_back(); sl.add(((int)(dd).size()), a[i] - 2 * i); sr.add(((int)(dd).size()), -a[i] - 2 * i); int rp = ((int)(dd).size()); dd.push_back(i); while (qid < ((int)(q1).size()) && q1[qid].r2 == i) { int id = q1[qid].id; int r1 = q1[qid].r1, c1 = q1[qid].c1; int r2 = q1[qid].r2, c2 = q1[qid].c2; int lp = Lbpos(r1); ans[id] = min(ans[id], r2 - r1 + c2 + 1); ans[id] = min(ans[id], r2 - r1 + abs(min(c1, a[dd[lp]]) - c2)); int rpos = Ubval(c2), lpos = rpos - 1, pos; rpos = mianx(rpos, lp, rp); lpos = mianx(lpos, lp, rp); if (abs(a[dd[lpos]] - c2) < abs(a[dd[rpos]] - c2)) pos = lpos; else pos = rpos; ans[id] = min(ans[id], r2 - r1 + abs(a[dd[pos]] - c2) + 1); rpos = Ubval(c2), lpos = rpos - 1; rpos = mianx(rpos, 0, lp); lpos = mianx(lpos, -1, lp - 1); ans[id] = min(ans[id], r2 + r1 + sr.get(0, lpos) + c2 + 1); ans[id] = min(ans[id], r2 + r1 + sl.get(rpos, lp - 1) - c2 + 1); int sp = min(Ubval(min(c1, a[dd[lp]])), lp); rpos = Ubval(c2), lpos = rpos - 1; rpos = mianx(rpos, 0, sp); lpos = mianx(lpos, -1, sp - 1); ans[id] = min(ans[id], r2 + r1 + sr.get(0, lpos) + c2); ans[id] = min(ans[id], r2 + r1 + sl.get(rpos, sp - 1) - c2); ++qid; } } dd.clear(); sl.init(); sr.init(); --qid; for (int i = (N); ((-1) > 0 ? i <= (1) : i >= (1)); i += (-1)) { while (((int)(dd).size()) && a[dd.back()] >= a[i]) dd.pop_back(); sl.add(((int)(dd).size()), a[i] + 2 * i); sr.add(((int)(dd).size()), -a[i] + 2 * i); int rp = ((int)(dd).size()); dd.push_back(i); while (~qid && q1[qid].r2 == i) { int id = q1[qid].id; int r1 = q1[qid].r1, c1 = q1[qid].c1; int r2 = q1[qid].r2, c2 = q1[qid].c2; int rpos = Ubval(c2), lpos = rpos - 1; rpos = mianx(rpos, 0, rp + 1); lpos = mianx(lpos, -1, rp); ans[id] = min(ans[id], sr.get(0, lpos) + c2 - r2 - r1 + 1); ans[id] = min(ans[id], sl.get(rpos, rp) - c2 - r2 - r1 + 1); int sp = min(Ubval(min(qj.get(r1, r2), c1)), rp); rpos = Ubval(c2), lpos = rpos - 1; rpos = mianx(rpos, 0, sp); lpos = mianx(lpos, -1, sp - 1); ans[id] = min(ans[id], sr.get(0, lpos) + c2 - r2 - r1); ans[id] = min(ans[id], sl.get(rpos, sp - 1) - c2 - r2 - r1); --qid; } } } int main() { scanf( %d , &N); for (int i = 1; i <= (N); ++i) scanf( %d , a + i); scanf( %d , &Q); memset(ans, Inf, sizeof(ans)); for (int i = 1; i <= (Q); ++i) { int r1, c1, r2, c2; scanf( %d%d%d%d , &r1, &c1, &r2, &c2); if (r1 <= r2) q1.push_back(Query(r1, c1, r2, c2, i)); else q2.push_back(Query(N - r1 + 1, c1, N - r2 + 1, c2, i)); } sort((q1).begin(), (q1).end()); solve(); reverse(a + 1, a + N + 1); sort((q2).begin(), (q2).end()); q2.swap(q1); solve(); for (int i = 1; i <= (Q); ++i) printf( %d n , ans[i]); return 0; }
#include <bits/stdc++.h> int main() { float h, l; scanf( %f %f , &h, &l); float x = (l * l + h * h) / (2 * h) - h; printf( %f n , x); return 0; }
#include <bits/stdc++.h> int main() { std::ios_base::sync_with_stdio(false); int n; std::cin >> n; std::vector<std::vector<bool> > g(n, std::vector<bool>(n, 0)); for (int row = 0; row < n; row++) { std::string s; std::cin >> s; for (int col = 0; col < s.size(); col++) { g[row][col] = s[col] - 0 ; } } std::vector<int> a(n); for (int p = 0; p < n; p++) { std::cin >> a[p]; } bool done(false); std::vector<int> guests; while (!done) { done = true; for (int p = 0; p < n; p++) { if (a[p] != 0) { continue; } done = false; guests.push_back(p); for (int q = 0; q < n; q++) { a[q] -= g[p][q]; } break; } } std::cout << guests.size() << std::endl; for (int p = 0; p < guests.size(); p++) { std::cout << (1 + guests[p]) << std::endl; } return 0; }
#include <bits/stdc++.h> using namespace std; int n, m, k; int a[111][111][111]; int color[111][111][111], cc; char second[111]; void visit(queue<pair<pair<int, int>, int> >* q, int x, int y, int z) { if (a[x][y][z] == 1 && color[x][y][z] != cc) { color[x][y][z] = cc; q->push(make_pair(make_pair(x, y), z)); } } void go(int x, int y, int z, int mx, int my, int mz) { assert(a[x][y][z] == 1); if (mx > n) mx = n; if (my > m) my = m; if (mz > k) mz = k; ++cc; queue<pair<pair<int, int>, int> > q; color[x][y][z] = cc; q.push(make_pair(make_pair(x, y), z)); while (!q.empty()) { pair<pair<int, int>, int> fr = q.front(); q.pop(); int x = fr.first.first; int y = fr.first.second; int z = fr.second; if (x + 1 <= mx) visit(&q, x + 1, y, z); if (y + 1 <= my) visit(&q, x, y + 1, z); if (z + 1 <= mz) visit(&q, x, y, z + 1); } } bool reachable(int x, int y, int z) { if (x + 1 < n && a[x + 1][y][z] == 1 && color[x + 1][y][z] != cc) { return false; } if (y + 1 < m && a[x][y + 1][z] == 1 && color[x][y + 1][z] != cc) { return false; } if (z + 1 < k && a[x][y][z + 1] == 1 && color[x][y][z + 1] != cc) { return false; } return true; } bool critical(int x, int y, int z) { if (x > 0 && a[x - 1][y][z] == 1) { go(x - 1, y, z, x + 1, y + 1, z + 1); if (!reachable(x, y, z)) { return true; } } if (y > 0 && a[x][y - 1][z] == 1) { go(x, y - 1, z, x + 1, y + 1, z + 1); if (!reachable(x, y, z)) { return true; } } if (z > 0 && a[x][y][z - 1] == 1) { go(x, y, z - 1, x + 1, y + 1, z + 1); if (!reachable(x, y, z)) { return true; } } return false; } int main() { scanf( %d%d%d , &n, &m, &k); for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { scanf( %s , second); for (int t = 0; t < k; t++) { a[i][j][t] = (second[t] == 1 ); } } } int res = 0; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { for (int t = 0; t < k; t++) { if (a[i][j][t] == 1) { a[i][j][t] = 0; res += critical(i, j, t); a[i][j][t] = 1; } } } } printf( %d n , res); return 0; }
#include <bits/stdc++.h> using namespace std; const long long N = 1005; long long n, m, q, ans; bool vizitat[N][N]; long long dp[N][N][2]; bool verifica(long long i, long long j) { if (i < 1 || j < 1 || i > n || j > m) return false; return true; } long long cnt(long long i, long long j) { long long answer = 0; for (long long it = 0; it <= 1; it++) { long long up = 0; long long lin = i; long long col = j; while (verifica(lin, col) && vizitat[lin][col] == false) { if (up % 2 == it) { lin--; } else { col--; } up++; } long long down = 0; lin = i; col = j; while (verifica(lin, col) && vizitat[lin][col] == false) { if (down % 2 == it) { col++; } else { lin++; } down++; } answer += up * down; } answer--; return answer; } int32_t main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); cin >> n >> m >> q; for (long long i = 1; i <= n; i++) { for (long long j = 1; j <= m; j++) { dp[i][j][1] = dp[i][j - 1][0] + 1; dp[i][j][0] = dp[i - 1][j][1] + 1; ans += dp[i][j][1]; ans += dp[i][j][0]; } } ans -= n * m; while (q--) { long long lin, col; cin >> lin >> col; if (vizitat[lin][col] == true) { vizitat[lin][col] = false; ans += cnt(lin, col); } else { ans -= cnt(lin, col); vizitat[lin][col] = true; } cout << ans << n ; } return 0; }
#include <bits/stdc++.h> using namespace std; #define pb push_back #define ll long long #define ff first #define ss second void solve() { int n; cin>>n; int sum=0; int cnt=1; while(sum<n) { sum+=cnt; cnt+=1; } if(sum-1==n) cout<<cnt; else cout<<cnt-1; cout<< n ; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); #ifndef ONLINE_JUDGE freopen( input.txt , r ,stdin); freopen( output.txt , w ,stdout); #endif int q=1; cin>>q; while(q--) { solve(); } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int n, k; cin >> n >> k; int ar[n + 5]; int br[n + 5]; int mark[200005]; memset(mark, 0, sizeof mark); for (int i = 0; i < n; i++) { cin >> ar[i]; br[i] = ar[i]; } sort(br, br + n, greater<int>()); int sum = 0; int cr[n + 5]; int c = 0; for (int i = 0; i < k; i++) { sum += br[i]; for (int j = 0; j < n; j++) { if (br[i] == ar[j]) { ar[j] = 0; cr[c++] = j; } } } sort(cr, cr + k); cout << sum << endl; if (k == 1) cout << n << endl; else { for (int i = 0; i < k; i++) { if (i == 0) { cout << cr[i] + 1 << ; } else if (i == k - 1) { int p = cr[i] - cr[i - 1]; p += n - cr[i] - 1; cout << p << endl; } else { cout << cr[i] - cr[i - 1] << ; } } } return 0; }
#include <bits/stdc++.h> using namespace std; long long rdtsc() { long long tmp; asm( rdtsc : =A (tmp)); return tmp; } inline int myrand() { return abs((rand() << 15) ^ rand()); } inline int rnd(int x) { return myrand() % x; } void precalc() {} const int inf = (int)1.01e9; const int n = 4; int xs[n][2]; bool read() { for (int i = 0; i < 4; ++i) { if (scanf( %d%d , &xs[i][0], &xs[i][1]) < 2) { return false; } } return true; } int res; int axs[n][2]; int perm[4]; int calcans(int x[2], int y[2]) { for (int i = 0; i < n; ++i) { perm[i] = i; } int cres = inf; do { int cur = 0; for (int i = 0; i < n; ++i) { int cx = xs[perm[i]][0], cy = xs[perm[i]][1]; int nx = x[i / 2], ny = y[i % 2]; if (cx != nx && cy != ny) { cur = inf; break; } cur = max(cur, max(abs(cx - nx), abs(cy - ny))); } if (res > cur) { res = cur; for (int i = 0; i < n; ++i) { axs[perm[i]][0] = x[i / 2]; axs[perm[i]][1] = y[i % 2]; } } cres = min(cres, cur); } while (next_permutation(perm, perm + 4)); return cres; } int dir[n]; map<int, vector<int> *> o[2]; void updans() { o[0].clear(); o[1].clear(); for (int i = 0; i < n; ++i) { int x = xs[i][dir[i]]; auto it = o[dir[i]].find(x); vector<int> *v; if (it != o[dir[i]].end()) { v = it->second; } else { v = new vector<int>(); o[dir[i]][x] = v; } v->push_back(i); } int mx = max(((int)(o[0]).size()), ((int)(o[1]).size())); int mn = min(((int)(o[0]).size()), ((int)(o[1]).size())); if (mx != 2) { return; } int x[2], y[2]; int cntx = 0, cnty = 0; for (auto it : o[0]) { x[cntx++] = it.first; } for (auto it : o[1]) { y[cnty++] = it.first; } if (mn == 2) { if (abs(x[1] - x[0]) != abs(y[1] - y[0])) { return; } calcans(x, y); return; } if (mn == 1) { if (cntx == 1) { int dist = abs(y[1] - y[0]); for (int it = 0; it < 2; ++it) { x[1] = x[0] + (it ? (-dist) : dist); calcans(x, y); } } else { int dist = abs(x[1] - x[0]); for (int it = 0; it < 2; ++it) { y[1] = y[0] + (it ? (-dist) : dist); calcans(x, y); } } return; } if (mn == 0) { if (cntx == 0) { int dist = abs(y[1] - y[0]); int L = -inf, R = inf; while (R - L > 1) { int M = (L + R) / 2; x[0] = M, x[1] = M + dist; int curl = calcans(x, y); x[0] = M + 1, x[1] = M + 1 + dist; int curr = calcans(x, y); if (curl >= curr) { L = M; } else { R = M; } } x[0] = L, x[1] = L + dist; calcans(x, y); x[0] = R, x[1] = R + dist; calcans(x, y); } else { int dist = abs(x[1] - x[0]); int L = -inf, R = inf; while (R - L > 1) { int M = (L + R) / 2; y[0] = M, y[1] = M + dist; int curl = calcans(x, y); y[0] = M + 1, y[1] = M + 1 + dist; int curr = calcans(x, y); if (curl >= curr) { L = M; } else { R = M; } } y[0] = L, y[1] = L + dist; calcans(x, y); y[0] = R, y[1] = R + dist; calcans(x, y); } } } void gen(int i) { if (i == 4) { updans(); return; } dir[i] = 0; gen(i + 1); dir[i] = 1; gen(i + 1); } void solve() { res = inf; gen(0); if (res == inf) { printf( -1 n ); return; } printf( %d n , res); for (int i = 0; i < 4; ++i) { printf( %d %d n , axs[i][0], axs[i][1]); } } int main() { srand(rdtsc()); precalc(); int T = 0; scanf( %d , &T); for (int tn = 0; tn < T; ++tn) { assert(read()); solve(); } return 0; }