Datasets:
malteklaes
/
cpp-code-code_search_net-style

Dataset card Data Studio Files Community
1
func_code_string
stringlengths
59
71.4k
#include <bits/stdc++.h> template <class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; } template <class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; } constexpr long long MAX = 5100000; constexpr long long INF = 1LL << 60; constexpr int inf = 1000000007; constexpr long long mod = 1000000007LL; const long double PI = acos((long double)(-1)); using namespace std; int f(int a, int b) { return max(a, b); } int g(int a, int b) { return a + b; } int h(int a, int b) { return a + b; } template <typename Monoid, typename OperatorMonoid = Monoid> struct LazySegmentTree { int sz, height; vector<Monoid> data; vector<OperatorMonoid> lazy; const Monoid M1; const OperatorMonoid OM0; LazySegmentTree(int n, const Monoid& M1, const OperatorMonoid OM0) : M1(M1), OM0(OM0) { sz = 1; height = 0; while (sz < n) sz <<= 1, height++; data.assign(2 * sz, M1); lazy.assign(2 * sz, OM0); } void set(int k, const Monoid& x) { data[k + sz] = x; } void build() { for (int k = sz - 1; k > 0; k--) { data[k] = f(data[2 * k + 0], data[2 * k + 1]); } } inline void propagate(int k) { if (lazy[k] != OM0) { lazy[2 * k + 0] = h(lazy[2 * k + 0], lazy[k]); lazy[2 * k + 1] = h(lazy[2 * k + 1], lazy[k]); data[k] = reflect(k); lazy[k] = OM0; } } inline Monoid reflect(int k) { return lazy[k] == OM0 ? data[k] : g(data[k], lazy[k]); } inline void recalc(int k) { while (k >>= 1) data[k] = f(reflect(2 * k + 0), reflect(2 * k + 1)); } inline void thrust(int k) { for (int i = height; i > 0; i--) propagate(k >> i); } void update(int a, int b, const OperatorMonoid& x) { if (a >= b) return; thrust(a += sz); thrust(b += sz - 1); for (int l = a, r = b + 1; l < r; l >>= 1, r >>= 1) { if (l & 1) lazy[l] = h(lazy[l], x), ++l; if (r & 1) --r, lazy[r] = h(lazy[r], x); } recalc(a); recalc(b); } Monoid query(int a, int b) { if (a >= b) return M1; thrust(a += sz); thrust(b += sz - 1); Monoid L = M1, R = M1; for (int l = a, r = b + 1; l < r; l >>= 1, r >>= 1) { if (l & 1) L = f(L, reflect(l++)); if (r & 1) R = f(reflect(--r), R); } return f(L, R); } Monoid operator[](const int& k) { return query(k, k + 1); } }; int main() { constexpr int lm = 450000; int n, k, kkt; scanf( %d %d %d , &n, &k, &kkt); LazySegmentTree<int, int> lsg(lm, -inf, 0); for (int i = 0; i < lm; i++) lsg.set(i, i - 1); lsg.build(); set<pair<int, int>> sp; multiset<int> ms; while (kkt--) { int x, y; scanf( %d %d , &x, &y); int t = abs(x - k) + y; if (sp.find({x, y}) == sp.end()) { sp.emplace(x, y); lsg.update(0, t + 1, 1); ms.emplace(t); } else { sp.erase(sp.find({x, y})); lsg.update(0, t + 1, -1); ms.erase(ms.find(t)); } if (ms.empty()) puts( 0 ); else { int mx = lsg.query(0, *ms.rbegin() + 1); printf( %d n , max(n, mx) - n); } } return 0; }
#include <bits/stdc++.h> using namespace std; unordered_map<int, int> mp; int cnt[200005]; int a[200005]; int num[200005]; int l, r, t; int tot = 0; int lz[200005]; int ans[200005]; int A, B; int be[200005]; struct Query { int l, r, id, t; Query() {} Query(int _l, int _r, int _id, int _t) { l = _l, r = _r, id = _id, t = _t; } bool operator<(const Query &rhs) const { return be[l] == be[rhs.l] ? (be[r] == be[rhs.r] ? t < rhs.t : r < rhs.r) : l < rhs.l; } } q[200005]; struct Change { int x, y, lz; Change() {} Change(int _x, int _y, int _lz) { x = _x, y = _y, lz = _lz; } } p[200005]; int getid(int x) { if (!mp.count(x)) mp[x] = ++tot; return mp[x]; } void add(int x, int k) { if (num[x]) cnt[num[x]]--; num[x] += k; if (num[x]) cnt[num[x]]++; } void change(int x, int k) { if (l <= x && r >= x) { add(a[x], -1); add(k, 1); } a[x] = k; } int getres() { for (int i = 1;; i++) { if (cnt[i] == 0) return i; } } int main() { int n, m; cin >> n >> m; int len = pow(n, 0.6666); for (int i = 1; i <= n; i++) { int x; scanf( %d , &x); lz[i] = a[i] = getid(x); be[i] = (i - 1) / len + 1; } for (int i = 1; i <= m; i++) { int op, x, y; scanf( %d%d%d , &op, &x, &y); if (op == 1) { q[++A] = Query(x, y, A, B); } else { y = getid(y); p[++B] = Change(x, y, lz[x]); lz[x] = y; } } sort(q + 1, q + 1 + A); l = 1, r = 0, t = 0; for (int i = 1; i <= A; i++) { while (t < q[i].t) change(p[t + 1].x, p[t + 1].y), t++; while (t > q[i].t) change(p[t].x, p[t].lz), t--; while (l < q[i].l) add(a[l], -1), l++; while (l > q[i].l) add(a[l - 1], 1), l--; while (r < q[i].r) add(a[r + 1], 1), r++; while (r > q[i].r) add(a[r], -1), r--; ans[q[i].id] = getres(); } for (int i = 1; i <= A; i++) { cout << ans[i] << endl; } }
#include <bits/stdc++.h> using namespace std; int N, M, K; int Ar[110][110]; int Temp[110][110]; int Dn[110]; int Res = -1; int f() { int rev = 0; for (int i = 1, a, b; i <= N; i++) { a = 0; b = 0; for (int j = 1; j <= M; j++) { a += (Ar[i][j] == Dn[j]); b += (Ar[i][j] != Dn[j]); } rev += min(a, b); } return rev; } int main() { scanf( %d%d%d , &N, &M, &K); for (int i = 1; i <= N; i++) for (int j = 1; j <= M; j++) scanf( %d , &Temp[i][j]); if (N < M) { for (int i = 1; i <= N; i++) for (int j = 1; j <= M; j++) Ar[j][i] = Temp[i][j]; int temp = N; N = M; M = temp; } else for (int i = 1; i <= N; i++) for (int j = 1; j <= M; j++) Ar[i][j] = Temp[i][j]; if (N <= K) { for (int i = 0, mi = (1 << M); i < mi; i++) { for (int j = 1; j <= M; j++) Dn[j] = (i & (1 << (j - 1))) != 0; int temp = f(); if (temp <= K && (Res == -1 || temp < Res)) Res = temp; } } else { for (int i = 1; i <= N; i++) { for (int j = 1; j <= M; j++) Dn[j] = Ar[i][j]; int temp = f(); if (temp <= K && (Res == -1 || temp < Res)) Res = temp; } } printf( %d n , Res); return 0; }
#include <bits/stdc++.h> using namespace std; const int maxn = 1e5 + 4; int n, c[maxn]; string s[maxn]; long long dp[maxn][2]; long long best(int ind, bool rev) { if (ind == n) { return 0; } if (dp[ind][rev] != -1) { return dp[ind][rev]; } string t = s[ind - 1]; if (rev) { reverse(t.begin(), t.end()); } string v = s[ind]; reverse(v.begin(), v.end()); if (s[ind] < t && v < t) { return dp[ind][rev] = 1e17; } if (s[ind] >= t && v >= t) { return dp[ind][rev] = min(c[ind] + best(ind + 1, true), best(ind + 1, false)); } if (s[ind] >= t) { return dp[ind][rev] = best(ind + 1, false); } return dp[ind][rev] = c[ind] + best(ind + 1, true); } int main() { cin >> n; for (int i = 0; i < n; i++) { cin >> c[i]; } for (int i = 0; i < n; i++) { cin >> s[i]; } memset(dp, -1, sizeof dp); long long res1 = c[0] + best(1, true); long long res2 = best(1, false); long long res = min(res1, res2); if (res > 1e15) { res = -1; } cout << res; }
#include <bits/stdc++.h> using namespace std; template <class T> inline T abs(T x) { return x < 0 ? -x : x; } const double EPS = 1e-9; int n, m, a[55], b[55], mx, ans, x; double cur; int main() { scanf( %d , &n); for (int i = 0; i < n; ++i) scanf( %d , a + i); scanf( %d , &m); for (int i = 0; i < m; ++i) scanf( %d , b + i); mx = 0; ans = 0; for (int i = 0; i < n; ++i) for (int j = 0; j < m; ++j) { cur = (b[j] + 0.) / a[i]; if (abs((int)cur - cur) < EPS) { x = (int)cur; if (x > mx) { mx = x; ans = 1; } else if (x == mx) ++ans; } } printf( %d , ans); return 0; }
#include <bits/stdc++.h> using namespace std; vector<int> get(int n) { if (n == 1) { return {1}; } if (n == 2) { return {3, 4}; } vector<int> a; if (n % 2 == 0) { int k = n / 2; for (int i = 1; i <= 2 * k - 1; i++) { a.push_back(1); } a.push_back(k - 1); } else { int k = n / 2; for (int i = 1; i <= 2 * k - 1; i++) { a.push_back(1); } a.push_back(2); a.push_back(k + 1); } return a; } int main() { ios::sync_with_stdio(0); cin.tie(0); int n, m; cin >> n >> m; vector<int> a = get(n), b = get(m); for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { cout << a[i] * b[j] << ; } cout << n ; } }
#include <bits/stdc++.h> using namespace std; int main() { int n, m; cin >> n >> m; string a; vector<string> v, b; bool u = false, l = false; for (int i = 0; i < 4 * n; i++) { cin >> a; int k = 0; u = false; for (int j = (int)a.length() - 1; j >= 0; j--) { if (a[j] == a || a[j] == e || a[j] == i || a[j] == o || a[j] == u ) k++; if (k >= m) { v.push_back(a.substr(j)); u = true; break; } } if (!u) { l = true; } } if (l) { cout << NO ; return 0; } for (int i = 0; i < n; i++) { if (v[i * 4] == v[i * 4 + 1] && v[i * 4 + 1] == v[i * 4 + 2] && v[i * 4 + 2] == v[i * 4 + 3]) { continue; } if (v[i * 4] == v[i * 4 + 1] && v[i * 4 + 2] == v[i * 4 + 3]) { b.push_back( aabb ); continue; } if (v[i * 4 + 0] == v[i * 4 + 3] && v[i * 4 + 1] == v[i * 4 + 2]) { b.push_back( abba ); continue; } if (v[i * 4 + 0] == v[i * 4 + 2] && v[i * 4 + 1] == v[i * 4 + 3]) { b.push_back( abab ); continue; } cout << NO ; return 0; } if ((int)b.size() == 0) { cout << aaaa ; return 0; } bool h = true; for (int i = 1; i < (int)b.size(); i++) { if (b[i] != b[i - 1]) { h = false; break; } } if (h) cout << b[0]; else cout << NO ; return 0; }
#include <bits/stdc++.h> #pragma GCC optimize( Ofast ) using namespace std; mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count()); template <typename T> bool uax(T& a, T b) { if (a < b) { a = b; return true; } return false; } template <typename T> bool uin(T& a, const T b) { if (a > b) { a = b; return true; } return false; } template <typename T1, typename T2> istream& operator>>(istream& in, pair<T1, T2>& p) { in >> p.first >> p.second; return in; } template <typename T1, typename T2> ostream& operator<<(ostream& out, pair<T1, T2>& p) { out << p.first << << p.second; return out; } const int N = 200 + 7; int n; vector<int> g[N]; vector<int> p[N]; int sz[N]; int ans[N]; vector<int> wr; int s[N]; bool used[N]; int last_ind = 0; int arr[N]; void del(int x) { used[x] = true; for (int i = 0; i < p[x].size(); i++) { s[p[x][i]]--; if (s[p[x][i]] == 1) { arr[last_ind++] = p[x][i]; } } } bool solve(int x) { last_ind = 0; for (int i = 0; i <= n; i++) { s[i] = sz[i]; used[i] = false; } ans[0] = x; del(x); for (int i = 1; i < n; i++) { if (last_ind != 1) { return false; } int ind = arr[0]; int cur = 0; for (int j = 0; j < g[ind].size(); j++) { if (!used[g[ind][j]]) cur = g[ind][j]; } ans[i] = cur; wr.clear(); for (int j = 0; j < sz[ind]; j++) { wr.push_back(ans[i - j]); } sort(wr.begin(), wr.end()); for (int j = 0; j < g[ind].size(); j++) { if (g[ind][j] != wr[j]) return false; } last_ind = 0; del(cur); } for (int i = 0; i < n; i++) { cout << ans[i] << ; } cout << n ; return true; } int main() { ios_base::sync_with_stdio(false); cin.tie(0); long long T; cin >> T; while (T--) { fill(p, p + n + 1, vector<int>()); cin >> n; int k; for (int i = 0; i < n - 1; i++) { cin >> k; g[i].resize(k); sz[i] = k; for (int j = 0; j < k; j++) { cin >> g[i][j]; p[g[i][j]].push_back(i); } } for (int i = 1; i <= n; i++) { if (solve(i)) { break; } } } }
#include <bits/stdc++.h> int query(long long q) { printf( ? %lld n , q); fflush(stdout); int gcd; scanf( %d , &gcd); return gcd; } void printAnswer(int answer) { printf( ! %d n , answer); fflush(stdout); } const int MAX_PRIMES = 617; const int MAX_X = 1000 * 1000 * 1000; const long long MAX_QUERY = 1000LL * 1000LL * 1000LL * 1000LL * 1000LL * 1000LL; bool isPrime[1 + MAX_PRIMES]; int main() { for (int i = 2; i <= MAX_PRIMES; i++) { isPrime[i] = true; } std::vector<long long> queries; queries.push_back(1); for (int p = 2; p <= MAX_PRIMES; p++) { if (isPrime[p]) { for (int m = p * p; m <= MAX_PRIMES; m += p) { isPrime[m] = false; } if (queries.back() <= MAX_QUERY / p) { long long b = queries.back(); queries.pop_back(); queries.push_back(b * p); } else { queries.push_back(p); } } } int t; scanf( %d , &t); for (int _ = 0; _ < t; _++) { std::vector<int> primeDivs; for (long long q : queries) { int gcd = query(q); for (int p = 2; p <= MAX_PRIMES; p++) { if (gcd % p == 0) { primeDivs.push_back(p); while (gcd % p == 0) { gcd /= p; } } } } for (int &p : primeDivs) { int copy = p; while (p <= MAX_X / copy) { p *= copy; } } if (primeDivs.size() % 2 == 1) { primeDivs.push_back(1); } int sureAnswer = 1; for (int i = 0; i < (int)primeDivs.size(); i += 2) { long long q = (long long)primeDivs[i] * primeDivs[i + 1]; int gcd = query(q); for (int p = 2; p <= MAX_PRIMES; p++) { int exp = 0; while (gcd % p == 0) { gcd /= p; exp++; } sureAnswer *= exp + 1; } } int guessAnswer = std::max(sureAnswer + 7, sureAnswer * 2); printAnswer(guessAnswer); primeDivs.clear(); } return 0; }
#include <bits/stdc++.h> using namespace std; long long ar[500005]; int main() { int n; scanf( %d , &n); for (int i = 0; i < n; i++) { scanf( %lld , &ar[i]); } string s; cin >> s; long long gain = 0; long long loss = 0; long long bob = 0; for (int i = 0; i < s.length(); i++) { if (s[i] == B ) { bob += ar[i]; } } long long ma = 0; for (int i = 0; i < s.length(); i++) { if (s[i] == A ) { gain += ar[i]; } else { loss += ar[i]; } ma = max(ma, gain - loss); } gain = 0; loss = 0; for (int i = s.length() - 1; i >= 0; i--) { if (s[i] == A ) { gain += ar[i]; } else { loss += ar[i]; } ma = max(ma, gain - loss); } bob += ma; printf( %lld , bob); }
#include <bits/stdc++.h> using namespace std; const int MX = 100 + 3; int n, m, k; bool mat[MX][MX], tmp[MX][MX]; void solve1() { int q = (1 << m); int cnt = 0; int ans = 20; for (int z = 0; z < q; z++) { cnt = 0; memset(tmp, false, sizeof(tmp)); for (int j = 0; j < m; j++) { if (z & (1 << j)) tmp[0][j] = true; if (tmp[0][j] != mat[0][j]) cnt++; } for (int i = 1; i < n; i++) { int p = 0; for (int j = 0; j < m; j++) { tmp[i][j] = !tmp[i - 1][j]; if (tmp[i][j] != mat[i][j]) p++; } p = min(p, m - p); cnt += p; } ans = min(cnt, ans); } if (ans > k) cout << -1 << endl; else cout << ans << endl; exit(0); } void swp() { for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) tmp[i][j] = mat[i][j]; for (int i = 0; i < m; i++) for (int j = 0; j < n; j++) mat[i][j] = tmp[j][i]; swap(n, m); } void solve2() { int ans = 20; int cnt = 0; if (n > k) { for (int i = 0; i < n; i++) { cnt = 0; memset(tmp, false, sizeof(tmp)); for (int j = 0; j < m; j++) tmp[i][j] = mat[i][j]; for (int k = 0; k < n; k++) { if (k != i) { int p = 0; for (int j = 0; j < m; j++) { tmp[k][j] = !tmp[i][j]; if (tmp[k][j] != mat[k][j]) p++; } p = min(p, m - p); cnt += p; } } ans = min(ans, cnt); } } else { swp(); memset(tmp, false, sizeof(tmp)); for (int i = 0; i < n; i++) { cnt = 0; for (int j = 0; j < m; j++) tmp[i][j] = mat[i][j]; for (int k = 0; k < n; k++) { if (k != i) { int p = 0; for (int j = 0; j < m; j++) { tmp[k][j] = !tmp[i][j]; if (tmp[k][j] != mat[k][j]) p++; } p = min(p, m - p); cnt += p; } } ans = min(ans, cnt); } } if (ans <= k) cout << ans << endl; else cout << -1 << endl; exit(0); } int main() { cin >> n >> m >> k; for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) cin >> mat[i][j]; if (n <= k && m <= k) solve1(); else solve2(); return 0; }
#include <bits/stdc++.h> const int Maxn = 500000; int n; struct Answer { int l, r; } a[Maxn + 5]; int len; void work(int left, int right) { if (left == right) { return; } int mid = (left + right) >> 1; work(left, mid); work(mid + 1, right); for (int i = left; i <= mid; i++) { a[++len].l = i; a[len].r = mid + (i - left + 1); } } int main() { scanf( %d , &n); if (n <= 2) { puts( 0 ); return 0; } int lim = 1; while (lim <= n) { lim <<= 1; } lim >>= 1; work(1, lim); int m = n - lim; if (m > 0) { int sz = 1; while (sz < m) { sz <<= 1; } work(n - sz + 1, n); } printf( %d n , len); for (int i = 1; i <= len; i++) { printf( %d %d n , a[i].l, a[i].r); } return 0; }
#include <bits/stdc++.h> using namespace std; template <class c> struct rge { c b, e; }; template <class c> rge<c> range(c i, c j) { return rge<c>{i, j}; } template <class c> auto dud(c* x) -> decltype(cerr << *x, 0); template <class c> char dud(...); struct debug { template <class c> debug& operator<<(const c&) { return *this; } }; void solve() { long long n, m; cin >> n >> m; long long ost = m % 10; set<int> o; for (int i = 0; i <= 10; ++i) { o.insert((i * ost) % 10); } long long sum = 0; for (auto x : o) sum += x; long long d = n / m; if (n == 0) cout << 0 << n ; else { long long res = sum * (d / o.size()); for (int i = 0; i < (d % o.size()); ++i) { res += ((i + 1) * m) % 10; } cout << res << n ; } } int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); int t; cin >> t; while (t--) { solve(); } }
#include <bits/stdc++.h> using namespace std; long long t[100005], T[100005], x[100005], c[100005]; long long n, m; int main() { while (scanf( %lld%lld , &n, &m) != EOF) { int i; int a, b; long long sum = 0; for (i = 1; i <= n; i++) scanf( %lld%lld%lld%lld , &t[i], &T[i], &x[i], &c[i]); for (i = 1; i <= n; i++) { if (t[i] >= T[i]) { sum += (c[i] + x[i] * m); } else { if (t[i] + m <= T[i]) sum += c[i]; else { long long a, b; long long cha = T[i] - t[i]; long long d = m % (T[i] - t[i]); long long w = m / (T[i] - t[i]); if (d) a = (w + 1) * c[i]; else a = (w * c[i]); b = x[i] * m + c[i]; sum += min(a, b); } } } printf( %I64d n , sum); } }
#include <bits/stdc++.h> using namespace std; const double PI = acos(-1); struct myHash { template <class T1, class T2> size_t operator()(const pair<T1, T2>& p) const { auto hash1 = hash<T1>{}(p.first); auto hash2 = hash<T2>{}(p.second); return hash1 ^ hash2; } }; class segTree { vector<long long int> a; vector<long long int> tree; vector<long long int> lazy; long long int sel; long long int minRange(long long int left, long long int right) { return min(left, right); } long long int maxRange(long long int left, long long int right) { return max(left, right); } long long int rangeSum(long long int left, long long int right) { return left + right; } void build(long long int index, long long int start, long long int end) { if (start > end) { return; } if (start == end) { tree[index] = a[start]; return; } long long int mid = (start + end) / 2; build(2 * index, start, mid); build(2 * index + 1, mid + 1, end); long long int left = tree[2 * index]; long long int right = tree[2 * index + 1]; if (sel == 0) { tree[index] = minRange(tree[2 * index], tree[2 * index + 1]); } else if (sel == 1) { tree[index] = maxRange(tree[2 * index], tree[2 * index + 1]); } else if (sel == 2) { tree[index] = rangeSum(tree[2 * index], tree[2 * index + 1]); } } long long int query(long long int index, long long int start, long long int end, long long int l, long long int r) { if (lazy[index] != 0) { if (sel == 0) { tree[index] += lazy[index]; } else if (sel == 1) { tree[index] += lazy[index]; } else if (sel == 2) { tree[index] += (end - start + 1) * lazy[index]; } if (start != end) { lazy[2 * index] += lazy[index]; lazy[2 * index + 1] += lazy[index]; } lazy[index] = 0; } if (l > end || r < start) { if (sel == 0) { return LLONG_MAX; } else if (sel == 1) { return LLONG_MIN; } else if (sel == 2) { return 0; } } if (start >= l && end <= r) { return tree[index]; } long long int mid = (start + end) / 2; long long int left = query(2 * index, start, mid, l, r); long long int right = query(2 * index + 1, mid + 1, end, l, r); if (sel == 0) { return minRange(left, right); } else if (sel == 1) { return maxRange(left, right); } else if (sel == 2) { return rangeSum(left, right); } } void update(long long int index, long long int start, long long int end, long long int l, long long int r, long long int inc) { if (lazy[index] != 0) { if (sel == 0) { tree[index] += lazy[index]; } else if (sel == 1) { tree[index] += lazy[index]; } else if (sel == 2) { tree[index] += (r - l + 1) * lazy[index]; } if (start != end) { lazy[2 * index] += lazy[index]; lazy[2 * index + 1] += lazy[index]; } lazy[index] = 0; } if (l <= start and end <= r) { if (sel == 0) { tree[index] += inc; } else if (sel == 1) { tree[index] += inc; } else { tree[index] += (end - start + 1) * inc; } if (start != end) { lazy[2 * index] += inc; lazy[2 * index + 1] += inc; } return; } if (r < start || l > end) { return; } if (start == end) { tree[index] += inc; return; } long long int mid = (start + end) / 2; update(2 * index, start, mid, l, r, inc); update(2 * index + 1, mid + 1, end, l, r, inc); if (sel == 0) { tree[index] = minRange(tree[2 * index], tree[2 * index + 1]); } else if (sel == 1) { tree[index] = maxRange(tree[2 * index], tree[2 * index + 1]); } else if (sel == 2) { tree[index] = rangeSum(tree[2 * index], tree[2 * index + 1]); } } public: segTree(vector<long long int> a, long long int sel) { this->a = a; tree.reserve(4 * a.size() + 1); lazy.reserve(4 * a.size() + 1); for (int i = 0; i < 4 * a.size() + 1; i++) { lazy[i] = 0; } this->sel = sel; } void build() { build(1, 0, a.size() - 1); } long long int query(long long int l, long long int r) { return query(1, 0, a.size() - 1, l, r); } void update(long long int l, long long int r, long long int inc) { update(1, 0, a.size() - 1, l, r, inc); } void update(long long int pos, long long int inc) { update(pos, pos, inc); } }; long long int power(long long int b, long long int p, long long int m = 1000000007) { long long int res = 1; while (p > 0) { if (p & 1) { res = (res * b) % m; } b = (b * b) % m; p = p >> 1; } return res; } long long int modInverse(long long int n, long long int m = 1000000007) { return power(n, m - 2, m); } bool mySort(pair<int, int> p1, pair<int, int> p2) { if (p1.first < p2.first) { return true; } else if (p1.first == p2.first and p1.second < p2.second) { return true; } return false; } long long int lis(vector<long long int>& v) { long long int n = v.size(); vector<long long int> dp(n); dp[0] = 1; long long int ans = 1; for (int i = 1; i < n; i++) { long long int m = 0; for (int j = i - 1; j >= 0; j--) { if (v[j] < v[i]) { m = max(m, dp[j]); } } dp[i] = 1 + m; if (ans < dp[i]) { ans = dp[i]; } } return ans; } vector<long long int> sieve(long long int n) { vector<bool> v(n + 1, false); v[2] = true; for (int i = 3; i <= n; i += 2) { v[i] = true; } for (int i = 3; i <= n; i += 2) { if (v[i]) { for (int j = i * i; j <= n; j += 2 * i) { v[j] = false; } } } v[1] = false; v[0] = false; vector<long long int> primes; for (int i = 0; i < v.size(); i++) { if (v[i]) { primes.push_back(i); } } return primes; } long long int gcd(long long int a, long long int b) { while (b > 0) { long long int r = a % b; a = b; b = r; } return a; } long long int lcm(long long int a, long long int b) { long long int g = gcd(a, b); return (a * b) / g; } vector<long long int> segSieve(long long int l, long long int r) { long long int lim = sqrt(r); if (l < 2) { l = 2; } vector<long long int> s = sieve(lim); vector<bool> v(r - l + 1, true); for (long long int i = 0; i < s.size(); i++) { for (long long int j = 0; j < v.size(); j++) { if ((j + l) % s[i] == 0 && (j + l) != s[i]) { v[j] = false; } } } vector<long long int> primes; for (int i = 0; i < v.size(); i++) { if (v[i]) { primes.push_back(i + l); } } return primes; } vector<pair<long long int, long long int>> primeFactors(long long int n) { vector<long long int> primes = sieve(sqrt(n)); long long int p = primes[0]; vector<pair<long long int, long long int>> f; int i = 0; while (p * p <= n) { long long int count = 0; while (n % p == 0) { count++; n /= p; } if (count > 0) { f.push_back(make_pair(p, count)); } i++; p = primes[i]; } if (n > 1) { f.push_back(make_pair(n, 1)); } return f; } vector<long long int> factors(long long int n) { long long int lim = sqrt(n); vector<long long int> f; for (int i = 2; i <= lim; i++) { if (n % i == 0) { f.push_back(i); f.push_back(n / i); } } return f; } long long int ceilAB(long long int a, long long int b) { return (a + b - 1) / b; } long long int low_bound(vector<long long int>& v, long long int start, long long int end, long long int n) { if (start > end) { return -1; } long long int mid = (start + end) / 2; if (v[mid] == n) { return mid; } else if (v[mid] > n) { long long int index = low_bound(v, start, mid - 1, n); return index; } else { long long int index = low_bound(v, mid + 1, end, n); if (index == -1) { return mid; } return index; } } void fastIO() { ios_base::sync_with_stdio(false); cin.tie(NULL); } int main(void) { long long int n; cin >> n; string s; cin >> s; cout << n + 1 << endl; return 0; }
#include <bits/stdc++.h> using namespace std; char ss[100050]; char b[12][12]; int len[12]; int n, m; bool g[100050][11]; bool f[100050][11]; int dp[100050]; struct Node { int a, b; }; int main() { int ll, pos; bool tmp; scanf( %s , ss); n = strlen(ss); scanf( %d , &m); for (int i = 0; i < m; i++) { scanf( %s , b[i]); len[i] = strlen(b[i]); } memset(f, false, sizeof(f)); for (int i = 0; i < n; i++) { for (int j = 1; j <= 10 && i - j + 1 >= 0; j++) f[i][j] = true; for (int j = 0; j < m; j++) { if (i + 1 >= len[j]) { tmp = true; for (int k = 0; k < len[j]; k++) { if (ss[i + k + 1 - len[j]] != b[j][k]) { tmp = false; break; } } if (tmp) f[i][len[j]] = false; } } if (!i) dp[i] = 1; else dp[i] = dp[i - 1] + 1; for (int j = 1; j <= 10 && i + 1 >= j; j++) if (!f[i][j]) { dp[i] = j - 1; break; } } Node ans; ans.a = ans.b = 0; pos = 0; for (int i = 0; i < n; i++) { pos = max(pos, i - dp[i] + 1); if (i - pos + 1 > 0 && i - pos + 1 >= ans.b) { ans.a = pos; ans.b = i - pos + 1; } } printf( %d %d n , ans.b, ans.a); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); int t; cin >> t; while (t--) { string s1; cin >> s1; int p1 = 0, p2 = 0, c1, c2; set<pair<pair<int, int>, pair<int, int> > > s; int c = 0; for (int i = 0; i < s1.size(); i++) { if (s1[i] == N ) { c2 = p2 + 1; c1 = p1; } else if (s1[i] == S ) { c2 = p2 - 1; c1 = p1; } else if (s1[i] == E ) { c1 = p1 + 1; c2 = p2; } else if (s1[i] == W ) { c1 = p1 - 1; c2 = p2; } if (s.find(make_pair(make_pair(c1, c2), make_pair(p1, p2))) != s.end() || s.find(make_pair(make_pair(p1, p2), make_pair(c1, c2))) != s.end()) { c = c + 1; } else { c = c + 5; s.insert(make_pair(make_pair(p1, p2), make_pair(c1, c2))); } p1 = c1; p2 = c2; } cout << c << n ; } }
#include <bits/stdc++.h> using namespace std; long long ans; long long cnt(long long i, long long n, long long count) { long long c = 0, j = i, k = n; while (k / i > 0) { c += k / i; k /= i; } c /= count; return c; } void factorize(long long n, long long p) { long long count = 0; while (!(n % 2)) { n >>= 1; count++; } if (count) { ans = min(ans, cnt(2, p, count)); } long long y = n; for (long long int i = 3; i * i <= y; i++) { count = 0; while (n % i == 0) { count++; n = n / i; } if (count) { ans = min(ans, cnt(i, p, count)); } } if (n > 2) { ans = min(ans, cnt(n, p, 1)); } return; } int main() { ios_base::sync_with_stdio(0); cin.tie(NULL); cout.tie(NULL); long long n, b; cin >> n >> b; ans = LLONG_MAX; factorize(b, n); if (ans != LLONG_MAX) cout << ans << endl; else cout << 0 << endl; }
#include <bits/stdc++.h> using namespace std; long long N, K; long long s1, s2, p1, p2; long long Get(long long now, long long to) { if (now <= to << 1) return 0; long long re = 0; s1 = 1; s2 = 0; p1 = now; p2 = now - 1; while (p2 >= to << 1) { if (p2 == to << 1) return s1 + re; if (p1 & 1) { re += s1 + s2; s1 = (s1 << 1) + s2; } else { re += s1 + s2; s2 = (s2 << 1) + s1; } p2 = (p1 >> 1) - 1; p1 = (p1 >> 1); } return re; } long long solve(long long l, long long r, long long p, long long k) { long long mid = (l + r) >> 1; if (k == 1) return mid; long long tmp = Get(mid - l, p), Tmp = Get(r - mid, p + 1); if (k > tmp + Tmp + 1) return solve(mid + 1, r, p, k - tmp - 1); else return solve(l, mid - 1, p, k - Tmp - 1); } int main() { scanf( %lld%lld , &N, &K); if (K == 1) { printf( 1 ); return 0; } if (K == 2) { printf( %lld , N); return 0; } N -= 2; K -= 2; long long l = 0, r = (N >> 1) + 1; while (r - l > 1) { long long mid = (l + r) >> 1; if (Get(N, mid) < K) r = mid; else l = mid; } printf( %lld , solve(1, N, l, K) + 1); }
#include <bits/stdc++.h> using namespace std; const int maxn = 2000001; int N, M, cur, F, a[maxn], del[maxn]; int c[maxn]; inline int lowbit(int x) { return x & -x; } inline void add(int x, int d) { for (; x < maxn; x += lowbit(x)) { c[x] += d; } } inline int seek(int k) { int ans = 0, sum = 0; for (int i = 23; i >= 0; i--) { ans += 1 << i; if (ans > maxn || sum + c[ans] >= k) ans -= 1 << i; else sum += c[ans]; } return ans + 1; } int main() { scanf( %d%d , &M, &N); for (int i = 1; i <= N; ++i) { scanf( %d , &del[i]); } while (M--) { int d; scanf( %d , &d); if (d == -1) { int x = upper_bound(del + 1, del + N + 1, cur) - del; for (int i = x - 1; i > 0; --i) { cur--; int t = seek(del[i]); add(t, -1); a[t] = -1; } } else { cur++; add(++F, 1); a[F] = d; } } if (cur == 0) { printf( Poor stack! n ); } else { for (int i = 1; i <= cur; ++i) { printf( %d , a[seek(i)]); } } return 0; }
#include <bits/stdc++.h> using namespace std; int dx[] = {-1, 1, 0, 0}; int dy[] = {0, 0, -1, 1}; long long int sizes[100001]; long long int arr[100001]; bool ok = true; long long int A[100001]; pair<long long int, long long int> B[100001]; long long int root(long long int i) { while (i != arr[i]) i = arr[i]; return (i); } void Union(long long int i, long long int j) { long long int root_i = root(i), root_j = root(j); if (root_i == root_j) return; if (sizes[root_i] > sizes[root_j]) swap(root_i, root_j); sizes[root_j] += sizes[root_i]; arr[root_i] = arr[root_j]; return; } long long int Arr[100001]; bool solve(long long int n) { if (n == 1) return (true); set<long long int> st; for (long long int i = 0; i < n; i++) { long long int m = (Arr[i] + i) % n; if (m < 0) m += n; if (st.count(m)) return (false); st.insert(m); } return (true); } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); long long int t; cin >> t; while (t--) { string s; cin >> s; set<pair<pair<long long int, long long int>, pair<long long int, long long int> > > st; long long int ans = 0, x = 0, y = 0; for (long long int i = 0; i < s.size(); i++) { long long int a, b, c, d; if (s[i] == N ) { a = x; b = y + 1; c = 0; d = 1; } else if (s[i] == S ) { a = x; b = y - 1; c = 0; d = -1; } else if (s[i] == W ) { a = x + 1; b = y; c = 1; d = 0; } else if (s[i] == E ) { a = x - 1; b = y; c = -1; d = 0; } if (st.count(pair<pair<long long int, long long int>, pair<long long int, long long int> >( pair<long long int, long long int>(x, y), pair<long long int, long long int>(a, b)))) ans++; else if (st.count(pair<pair<long long int, long long int>, pair<long long int, long long int> >( pair<long long int, long long int>(a, b), pair<long long int, long long int>(x, y)))) ans++; else ans += 5; st.insert(pair<pair<long long int, long long int>, pair<long long int, long long int> >( pair<long long int, long long int>(x, y), pair<long long int, long long int>(a, b))); x += c; y += d; } cout << ans << n ; } return (0); }
#include <bits/stdc++.h> using namespace std; using ll = long long; const ll mod = 1e9L + 7; const int N = 121, M = 1211; int x[N], y[N]; ll dp[N][M]; ll c[M][M]; int main() { for (int i = 0; i < M; i++) { c[i][0] = 1; for (int j = 1; j <= i; j++) c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod; } ios ::sync_with_stdio(0); int n; cin >> n; for (int i = 1; i <= n; i++) cin >> x[i]; for (int i = 1; i <= n; i++) cin >> y[i]; dp[0][0] = 1; for (int i = 0; i <= n; i++) for (int j = 0; j < M; j++) for (int k = 0; k <= y[i + 1] && j + x[i + 1] - k >= 0; k++) { dp[i + 1][j + x[i + 1] - k] += dp[i][j] * c[j + x[i + 1]][k]; dp[i + 1][j + x[i + 1] - k] %= mod; } ll ans = dp[n + 1][0]; int m = accumulate(x, x + n + 1, 0); for (int i = 1; i <= n; i++) { ans *= c[m][x[i]]; ans %= mod; m -= x[i]; } cout << ans << n ; }
#include <bits/stdc++.h> #pragma GCC optimize( Ofast,no-stack-protector,unroll-loops ) #pragma GCC optimize( no-stack-protector,fast-math ) using namespace std; const int N = 5e5 + 100, OO = 724249387, T = 4500 + 100, M = 1e9 + 7, P = 6151, SQ = 280, lg = 30; map<int, int> mp; int dp[N], l[N], r[N], t[N], seg[4][N << 2], lazy[4][N << 2]; vector<pair<int, int> > v[N]; void shift(int c, int id) { seg[id][c << 1] += lazy[id][c]; seg[id][c << 1 | 1] += lazy[id][c]; lazy[id][c << 1] += lazy[id][c]; lazy[id][c << 1 | 1] += lazy[id][c]; lazy[id][c] = 0; } void upd(int id, int c, int b, int e, int l, int r, int t) { if (e <= l || r <= b) return; if (l <= b && e <= r) { seg[id][c] += t; lazy[id][c] += t; return; } int mid = (b + e) >> 1; shift(c, id); upd(id, c << 1, b, mid, l, r, t), upd(id, c << 1 | 1, mid, e, l, r, t); seg[id][c] = max(seg[id][c << 1 | 1], seg[id][c << 1]); } int get(int id, int c, int b, int e, int l, int r) { if (r <= b || e <= l) return 0; if (l <= b && e <= r) return seg[id][c]; int mid = (b + e) >> 1; shift(c, id); return max(get(id, c << 1, b, mid, l, r), get(id, c << 1 | 1, mid, e, l, r)); } int32_t main() { ios::sync_with_stdio(false), cin.tie(0), cout.tie(0); int n; cin >> n; set<int> st; st.insert(0); for (int i = 0; i < n; i++) { cin >> l[i] >> r[i] >> t[i]; st.insert(l[i]), st.insert(r[i]); } int cnt = 0; for (auto u : st) mp[u] = cnt++; for (int i = 0; i < n; i++) { l[i] = mp[l[i]], r[i] = mp[r[i]]; v[r[i]].push_back({l[i], t[i]}); } for (int i = 1; i < cnt; i++) { for (auto u : v[i]) upd(u.second, 1, 0, cnt, 0, u.first, +1); dp[i] = max(get(1, 1, 0, cnt, 0, i), get(2, 1, 0, cnt, 0, i)); upd(1, 1, 0, cnt, i, i + 1, dp[i]), upd(2, 1, 0, cnt, i, i + 1, dp[i]); } cout << dp[cnt - 1] << endl; return 0; }
#include <bits/stdc++.h> using namespace std; const int MAXL = 1e5; int main() { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); ; long long int k, p; long long int ans = 0; cin >> k >> p; for (int i = 1; i <= k; i++) { int x = i; string str1, str2; while (x) { str1 += (x % 10 + 0 ); x /= 10; } for (int j = str1.size() - 1; j >= 0; j--) str2 += str1[j]; str2 += str1; long long int sum = 0; for (int j = 0; j < str2.size(); j++) sum = sum * 10 + str2[j] - 0 ; ans = (ans + sum) % p; } cout << ans << endl; }
#include <bits/stdc++.h> using namespace std; std::mt19937 rnd( (int)std::chrono::steady_clock::now().time_since_epoch().count()); long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); } const int MAXH = 100000; const int MAXW = 100000; const int MAXDIM = MAXH >= MAXW ? MAXH : MAXW; const int MAXQ = 100000; const int MAXS = 4 * MAXDIM; int h, w, nq; char initlft[MAXH + 1]; char initrgt[MAXH + 1]; char inittop[MAXW + 1]; char initbot[MAXW + 1]; char qside[MAXQ]; int ql[MAXQ], qr[MAXQ], qans[MAXQ + 1]; struct SegNode { int cost[2][2][2][2]; bool lazyfliptop, lazyflipbot; int cntblue[2], cntred[2]; }; struct SegTree { int n; int crosscost, lftcost[2], rgtcost[2]; char inittop[MAXDIM + 1]; char initbot[MAXDIM + 1]; SegNode sval[MAXS]; void sfliptop(int x) { swap(sval[x].cntblue[0], sval[x].cntred[0]); for (int lftcol = (0); lftcol < (2); ++lftcol) for (int rgtcol = (0); rgtcol < (2); ++rgtcol) for (int botflip = (0); botflip < (2); ++botflip) swap(sval[x].cost[lftcol][rgtcol][0][botflip], sval[x].cost[lftcol][rgtcol][1][botflip]); sval[x].lazyfliptop = !sval[x].lazyfliptop; } void sflipbot(int x) { swap(sval[x].cntblue[1], sval[x].cntred[1]); for (int lftcol = (0); lftcol < (2); ++lftcol) for (int rgtcol = (0); rgtcol < (2); ++rgtcol) for (int topflip = (0); topflip < (2); ++topflip) swap(sval[x].cost[lftcol][rgtcol][topflip][0], sval[x].cost[lftcol][rgtcol][topflip][1]); sval[x].lazyflipbot = !sval[x].lazyflipbot; } void spush(int x) { if (sval[x].lazyfliptop) sfliptop(2 * x + 1), sfliptop(2 * x + 2), sval[x].lazyfliptop = false; if (sval[x].lazyflipbot) sflipbot(2 * x + 1), sflipbot(2 * x + 2), sval[x].lazyflipbot = false; } void spull(int x) { const SegNode &a = sval[2 * x + 1]; const SegNode &b = sval[2 * x + 2]; for (int side = (0); side < (2); ++side) sval[x].cntblue[side] = a.cntblue[side] + b.cntblue[side]; for (int side = (0); side < (2); ++side) sval[x].cntred[side] = a.cntred[side] + b.cntred[side]; for (int lftcol = (0); lftcol < (2); ++lftcol) for (int rgtcol = (0); rgtcol < (2); ++rgtcol) for (int topflip = (0); topflip < (2); ++topflip) for (int botflip = (0); botflip < (2); ++botflip) { int cur = INT_MAX; for (int midcol1 = (0); midcol1 < (2); ++midcol1) for (int midcol2 = (0); midcol2 < (2); ++midcol2) { int acost = a.cost[lftcol][midcol1][topflip][botflip]; int bcost = b.cost[midcol2][rgtcol][topflip][botflip]; int ccost = midcol1 == midcol2 ? 0 : crosscost; if (acost == INT_MAX || bcost == INT_MAX) continue; cur = min(cur, acost + bcost + ccost); } sval[x].cost[lftcol][rgtcol][topflip][botflip] = cur; } } void sinit(int x, int l, int r) { sval[x].lazyfliptop = sval[x].lazyflipbot = false; if (l == r) { int sa = inittop[l] == B ? 0 : 1; int sb = initbot[l] == B ? 0 : 1; sval[x].cntblue[0] = sa == 0 ? 1 : 0, sval[x].cntred[0] = 1 - sval[x].cntblue[0]; sval[x].cntblue[1] = sb == 0 ? 1 : 0, sval[x].cntred[1] = 1 - sval[x].cntblue[1]; for (int lftcol = (0); lftcol < (2); ++lftcol) for (int rgtcol = (0); rgtcol < (2); ++rgtcol) for (int topflip = (0); topflip < (2); ++topflip) for (int botflip = (0); botflip < (2); ++botflip) { int cur; if (lftcol == rgtcol) { int a = sa; if (topflip) a = 1 - a; int b = sb; if (botflip) b = 1 - b; cur = (a == lftcol ? 0 : 1) + (b == lftcol ? 0 : 1); } else { cur = INT_MAX; } sval[x].cost[lftcol][rgtcol][topflip][botflip] = cur; } } else { int m = l + (r - l) / 2; sinit(2 * x + 1, l, m); sinit(2 * x + 2, m + 1, r); spull(x); } } void sflip(int x, int l, int r, int L, int R, bool istop) { if (L <= l && r <= R) { if (istop) sfliptop(x); else sflipbot(x); } else { int m = l + (r - l) / 2; spush(x); if (L <= m) sflip(2 * x + 1, l, m, L, R, istop); if (m + 1 <= R) sflip(2 * x + 2, m + 1, r, L, R, istop); spull(x); } } void init() { sinit(0, 0, n - 1); } void flip(int l, int r, bool istop) { sflip(0, 0, n - 1, l, r, istop); } int calc() { int ret = INT_MAX; for (int lftcol = (0); lftcol < (2); ++lftcol) for (int rgtcol = (0); rgtcol < (2); ++rgtcol) { int cur = sval[0].cost[lftcol][rgtcol][0][0]; if (cur == INT_MAX) continue; cur += lftcost[lftcol]; cur += rgtcost[rgtcol]; ret = min(ret, cur); } return ret; } }; SegTree stopbot, slftrgt; int calc() { stopbot.lftcost[0] = slftrgt.sval[0].cntred[0], stopbot.lftcost[1] = slftrgt.sval[0].cntblue[0]; stopbot.rgtcost[0] = slftrgt.sval[0].cntred[1], stopbot.rgtcost[1] = slftrgt.sval[0].cntblue[1]; slftrgt.lftcost[0] = stopbot.sval[0].cntred[0], slftrgt.lftcost[1] = stopbot.sval[0].cntblue[0]; slftrgt.rgtcost[0] = stopbot.sval[0].cntred[1], slftrgt.rgtcost[1] = stopbot.sval[0].cntblue[1]; return min(stopbot.calc(), slftrgt.calc()); } void solve() { stopbot.n = w, stopbot.crosscost = h; for (int i = (0); i <= (w); ++i) stopbot.inittop[i] = inittop[i], stopbot.initbot[i] = initbot[i]; stopbot.init(); slftrgt.n = h, slftrgt.crosscost = w; for (int i = (0); i <= (h); ++i) slftrgt.inittop[i] = initlft[i], slftrgt.initbot[i] = initrgt[i]; slftrgt.init(); qans[0] = calc(); for (int i = (0); i < (nq); ++i) { char side = qside[i]; int l = ql[i], r = qr[i]; if (side == U ) stopbot.flip(l, r, true); if (side == D ) stopbot.flip(l, r, false); if (side == L ) slftrgt.flip(l, r, true); if (side == R ) slftrgt.flip(l, r, false); qans[i + 1] = calc(); } } void run() { scanf( %d%d%d , &h, &w, &nq); scanf( %s , initlft); scanf( %s , initrgt); scanf( %s , inittop); scanf( %s , initbot); for (int i = (0); i < (nq); ++i) scanf( %c%d%d , &qside[i], &ql[i], &qr[i]), --ql[i], --qr[i]; solve(); for (int i = (0); i <= (nq); ++i) printf( %d n , qans[i]); } void stress() { h = MAXH, w = MAXW, nq = MAXQ; for (int i = (0); i < (h); ++i) initlft[i] = BR [rnd() % 2]; initlft[h] = 0 ; for (int i = (0); i < (h); ++i) initrgt[i] = BR [rnd() % 2]; initrgt[h] = 0 ; for (int i = (0); i < (w); ++i) inittop[i] = BR [rnd() % 2]; inittop[w] = 0 ; for (int i = (0); i < (w); ++i) initbot[i] = BR [rnd() % 2]; initbot[w] = 0 ; for (int i = (0); i < (nq); ++i) { qside[i] = UDLR [rnd() % 4]; int dim = qside[i] == U || qside[i] == D ? w : h; ql[i] = rnd() % dim, qr[i] = rnd() % dim; if (ql[i] > qr[i]) swap(ql[i], qr[i]); } solve(); printf( done n ); } int main() { run(); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; cout << n / 2 * 3 << endl; }
#include <bits/stdc++.h> using namespace std; const double eps = 1e-9; struct _hash { int operator()(const complex<double> &p) const { return p.real() * 20001 + p.imag(); } }; int n; complex<double> p[100]; unordered_set<complex<double>, _hash> pnts; double ans = -1; inline int compare(const double &a, const double &b) { if (fabs(a - b) < eps) return 0; return a < b ? -1 : 1; } bool intersect(const complex<double> &a, const complex<double> &b, const complex<double> &p, const complex<double> &q, complex<double> &ret) { double d1 = ((conj(p - a) * (b - a)).imag()); double d2 = ((conj(q - a) * (b - a)).imag()); ret = (d1 * q - d2 * p) / (d1 - d2); return (fabs(d1 - d2) > eps); } complex<double> findCenter(const complex<double> &a, const complex<double> &b, const complex<double> &c) { complex<double> m1 = (((a) + (b)) / 2.0); complex<double> m2 = (((b) + (c)) / 2.0); complex<double> p1 = (complex<double>(-(((b) - (a))).imag(), (((b) - (a))).real())); complex<double> p2 = (complex<double>(-(((c) - (b))).imag(), (((c) - (b))).real())); complex<double> r; assert(intersect(m1, m1 + p1, m2, m2 + p2, r)); return r; } void check(const complex<double> &center, const double &r) { double minDist = 1e9; for (int i = 0; i < n; ++i) minDist = min(minDist, (hypot((((p[i]) - (center))).real(), (((p[i]) - (center))).imag()))); if (compare(minDist, r) < 0) return; assert(compare(r, minDist) == 0); ans = max(ans, r); } int main() { scanf( %d , &n); for (int i = 0; i < n; ++i) { int x, y; scanf( %d %d , &x, &y); pnts.insert(p[i] = complex<double>(x, y)); } for (int i = 0; i < n; ++i) for (int j = i + 1; j < n; ++j) for (int k = j + 1; k < n; ++k) { complex<double> triangle[3] = {p[i], p[j], p[k]}; for (int a = 0; a < 3; ++a) { int b = (a + 1) % 3; int c = (b + 1) % 3; double d = ((conj(((triangle[b]) - (triangle[a]))) * (((triangle[c]) - (triangle[a])))) .real()); if (d < 0) goto next; if (d == 0) { if (!compare((hypot((((triangle[b]) - (triangle[a]))).real(), (((triangle[b]) - (triangle[a]))).imag())), (hypot((((triangle[c]) - (triangle[a]))).real(), (((triangle[c]) - (triangle[a]))).imag())))) { { complex<double> p = ((triangle[a]) - (triangle[b])); complex<double> m = ((triangle[c]) - (triangle[b])); complex<double> _4th = conj(p / m) * m; if (pnts.find(_4th) == pnts.end()) goto next; { complex<double> center = (((triangle[b]) + (triangle[c])) / 2.0); check(center, (hypot((((triangle[0]) - (center))).real(), (((triangle[0]) - (center))).imag()))); } } } goto next; } } { complex<double> center = findCenter(triangle[0], triangle[1], triangle[2]); check(center, (hypot((((triangle[0]) - (center))).real(), (((triangle[0]) - (center))).imag()))); } next:; } printf( %.17lf n , ans); return 0; }
#include <bits/stdc++.h> using namespace std; const int MAXN = 400; int x[MAXN], y[MAXN]; inline bool lt(int i, int xx, int yy) { return x[i] < xx || (x[i] == xx && y[i] < yy); } inline bool gt(int i, int xx, int yy) { return x[i] > xx || (x[i] == xx && y[i] > yy); } void mysort(int l, int r) { if (l < r) { int pivot = int((rand() / (1.0 + RAND_MAX)) * (r - l + 1)) + l; int xx = x[pivot]; int yy = y[pivot]; int i = l; int j = r; while (1) { while (lt(i, xx, yy)) ++i; while (gt(j, xx, yy)) --j; if (i <= j) { swap(x[i], x[j]); swap(y[i], y[j]); ++i; --j; } else { break; } } mysort(l, j); mysort(i, r); } } bool outside(int xx, int xlo, int xhi) { return xx < xlo || xx > xhi; } bool outside(int xx, int yy, int xlo, int xhi, int ylo, int yhi) { return outside(xx, xlo, xhi) || outside(yy, ylo, yhi); } const int MAXSTEPS = 1000000; char steps[MAXSTEPS + 1]; int dy[] = {1, 0, -1, 0}; int dx[] = {0, 1, 0, -1}; string stepcode = URDL ; const int OFFSET = 120; bool board[2 * OFFSET + 1][2 * OFFSET + 1]; int from[2 * OFFSET + 1][2 * OFFSET + 1]; int n; bool tree(int xx, int yy) { pair<int*, int*> p_ = equal_range(x, x + n, xx); int p = p_.first - x; int q = p_.second - x; cerr << tree: << xx << << yy << << p << << q << n ; if (p < n && x[p] == xx) { int i = lower_bound(y + p, y + q, yy) - y; cerr << i << n ; return (i < q && y[i] == yy); } return false; } int main() { int vx, vy, sx, sy; cin >> vx >> vy >> sx >> sy >> n; if (n == 0) { puts( -1 ); return 0; } int orig_vx = vx; int orig_vy = vy; int orig_sx = sx; int orig_sy = sy; for (int i = 0; i < n; ++i) { cin >> x[i] >> y[i]; } mysort(0, n - 1); for (int i = 0; i < n; ++i) { cerr << x[i] << << y[i] << n ; } cerr << n ; int xlo = x[0]; int xhi = x[n - 1]; int ylo = *min_element(y, y + n); int yhi = *max_element(y, y + n); int step = 0; if (!outside(vx, vy, xlo, xhi, ylo, yhi) || !outside(sx, sy, xlo, xhi, ylo, yhi)) { for (int i = 0; i < n; ++i) { (board[(x[i]) + OFFSET][(y[i]) + OFFSET]) = 1; } memset(from, 0xff, sizeof from); queue<pair<int, int> > Q; Q.push(make_pair(vx, vy)); (from[(vx) + OFFSET][(vy) + OFFSET]) = 1; while (!Q.empty()) { pair<int, int> tmp = Q.front(); Q.pop(); int u = tmp.first; int v = tmp.second; for (int d = 0; d < 4; ++d) { int r = u + dx[d]; int c = v + dy[d]; if (r + OFFSET < 0 || c + OFFSET < 0 || r > OFFSET || c > OFFSET || (from[(r) + OFFSET][(c) + OFFSET]) != -1 || (board[(r) + OFFSET][(c) + OFFSET])) { continue; } (from[(r) + OFFSET][(c) + OFFSET]) = d; if (r == sx && c == sy) { goto BFS_DONE; } Q.push(make_pair(r, c)); } } BFS_DONE:; if ((from[(sx) + OFFSET][(sy) + OFFSET]) == -1) { puts( -1 ); return 0; } vector<int> D; int xx = sx; int yy = sy; while (xx != vx || yy != vy) { D.push_back((from[(xx) + OFFSET][(yy) + OFFSET])); xx -= dx[D.back()]; yy -= dy[D.back()]; } reverse(D.begin(), D.end()); cerr << D.size() << n ; int at = 0; while ((!outside(vx, vy, xlo, xhi, ylo, yhi) || !outside(sx, sy, xlo, xhi, ylo, yhi)) && (vx != sx || vy != sy)) { assert(at < int(D.size())); cerr << at << << D[at] << n ; steps[step++] = stepcode[D[at]]; cerr << vx << << vy << << sx << << sy << n ; vx += dx[D[at]]; vy += dy[D[at]]; cerr << vx << << vy << << sx << << sy << n ; assert(!tree(vx, vy)); if (!tree(sx + dx[D[at]], sy + dy[D[at]])) { sx += dx[D[at]]; sy += dy[D[at]]; D.push_back(D[at]); } cerr << vx << << vy << << sx << << sy << n ; cerr << n ; ++at; } } if (vx != sx || vy != sy) { int d = -1; if ((vx > xhi || outside(vy, ylo, yhi)) && (sx > xhi || outside(sy, ylo, yhi))) { d = 1; } else if ((vx < xlo || outside(vy, ylo, yhi)) && (sx < xlo || outside(sy, ylo, yhi))) { d = 3; } else if ((vy > yhi || outside(vx, xlo, xhi)) && (sy > yhi || outside(sx, xlo, xhi))) { d = 0; } else { assert((vy < ylo || outside(vx, xlo, xhi)) && (vy < ylo || outside(sx, xlo, xhi))); d = 2; } vx += 500 * dx[d]; vy += 500 * dy[d]; sx += 500 * dx[d]; sy += 500 * dy[d]; for (int i = 0; i < 500; ++i) { steps[step++] = stepcode[d]; } cerr << vx << << vy << << sx << << sy << n ; if (d != 0) { if (d == 2) { for (int i = 0; i < 500; ++i) { steps[step++] = R ; } } vy += 1000; sy += 1000; for (int i = 0; i < 1000; ++i) { steps[step++] = U ; } cerr << vx << << vy << << sx << << sy << n ; if (d == 2) { for (int i = 0; i < 500; ++i) { steps[step++] = L ; } } else { d = (d + 2) % 4; cerr << bla << d << n ; cerr << vx << << vy << << sx << << sy << n ; vx += 500 * dx[d]; vy += 500 * dy[d]; sx += 500 * dx[d]; sy += 500 * dy[d]; for (int i = 0; i < 500; ++i) { steps[step++] = stepcode[d]; } cerr << vx << << vy << << sx << << sy << n ; } } } cerr << vx << << vy << << sx << << sy << n ; if (vx != sx) { if (vx > sx) { vx += 500; sx += 500; for (int i = 0; i < 500; ++i) { steps[step++] = R ; } int k = sy - y[n - 1]; vy -= k; sy -= k; for (int i = 0; i < k; ++i) { steps[step++] = D ; } while (vx != sx) { --vx; steps[step++] = L ; if (sx - 1 > x[n - 1]) { --sx; } } } else { vx -= 500; sx -= 500; for (int i = 0; i < 500; ++i) { steps[step++] = L ; } int k = sy - y[0]; vy -= k; sy -= k; for (int i = 0; i < k; ++i) { steps[step++] = D ; } while (vx != sx) { ++vx; steps[step++] = R ; if (sx + 1 < x[0]) { ++sx; } } } } cerr << vx << << vy << << sx << << sy << n ; assert(vx == sx); if (vy != sy) { if (vy > sy) { vy += 2000; sy += 2000; for (int i = 0; i < 2000; ++i) { steps[step++] = U ; } int top = 0; for (int i = 1; i < n; ++i) { if (y[i] > y[top]) { top = i; } } if (vx > x[top]) { int k = vx - x[top]; vx -= k; sx -= k; for (int i = 0; i < k; ++i) { steps[step++] = L ; } } else { int k = -(vx - x[top]); vx += k; sx += k; for (int i = 0; i < k; ++i) { steps[step++] = R ; } } while (vy != sy) { --vy; steps[step++] = D ; if (sy - 1 > y[top]) { --sy; } } } else { vy -= 2000; sy -= 2000; for (int i = 0; i < 2000; ++i) { steps[step++] = D ; } int bot = 0; for (int i = 1; i < n; ++i) { if (y[i] < y[bot]) { bot = i; } } if (vx > x[bot]) { int k = vx - x[bot]; vx -= k; sx -= k; for (int i = 0; i < k; ++i) { steps[step++] = L ; } } else { int k = -(vx - x[bot]); vx += k; sx += k; for (int i = 0; i < k; ++i) { steps[step++] = R ; } } while (vy != sy) { ++vy; steps[step++] = U ; if (sy + 1 < y[bot]) { ++sy; } } } } cerr << vx << << vy << << sx << << sy << n ; int xx = orig_vx; int yy = orig_vy; for (int s = 0; s < step; ++s) { int d = stepcode.find(steps[s]); xx += dx[d]; yy += dy[d]; } cerr << xx << << yy << expect << vx << << vy; assert(xx == vx && yy == vy); xx = orig_sx; yy = orig_sy; for (int s = 0; s < step; ++s) { int d = stepcode.find(steps[s]); xx += dx[d]; yy += dy[d]; if (tree(xx, yy)) { xx -= dx[d]; yy -= dy[d]; } } cerr << xx << << yy << expect << sx << << sy; assert(xx == sx && yy == sy); puts(steps); return 0; }
#include <bits/stdc++.h> int main() { int n, i, cnt = 0; float y; scanf( %d , &n); int p[n]; for (i = 1; i <= n; i++) { scanf( %d , &p[i]); cnt += p[i]; } y = (float)cnt / (float)n; printf( %f , y); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { string s; cin >> s; string res = ; if (s.find( . ) == string::npos) { s += . ; } int d = s.find( . ); int i = d - 1; int c = 0; while (i >= 0) { if (s[i] != - ) res = s[i] + res; c++; if (c == 3 && i > 0) { if (i - 1 >= 0 && s[i - 1] != - ) res = , + res; c = 0; } i--; } res += . ; int dc = s.length() - 1 - d; if (dc == 0) { res += 00 ; } else if (dc == 1) { res += s[d + 1]; res += 0 ; } else if (dc >= 2) { res += s[d + 1]; res += s[d + 2]; } res = $ + res; if (s[0] == - ) res = ( + res + ) ; cout << res << endl; }
#include <bits/stdc++.h> using namespace std; int dp[505][505], dp2[505]; void solve() { int n; cin >> n; vector<int> a(n); for (auto &i : a) cin >> i; memset(dp, 0, sizeof(dp)); for (int i = 0; i < n; i++) dp[i][i] = a[i]; for (int i = 1; i < n; i++) { for (int j = i - 1; j >= 0; j--) { for (int k = i; k > j; k--) { if (dp[k][i] and dp[k][i] == dp[j][k - 1]) dp[j][i] = dp[k][i] + 1; } } } memset(dp2, INT_MAX, sizeof(dp2)); for (int i = 0; i <= n; i++) dp2[i] = i + 1; for (int i = 0; i < n; i++) { for (int j = 0; j <= i; j++) { if (dp[j][i]) { if (j == 0) dp2[i] = 1; else dp2[i] = min(dp2[i], dp2[j - 1] + 1); } } } cout << dp2[n - 1]; } int main() { int t; t = 1; while (t--) { solve(); } return 0; }
#include <bits/stdc++.h> using namespace std; const long long INF = (long long)1e18; const int mod = (int)1e9 + 7; const int MAXN = (int)1e5 + 5; long long n; const int bs = 350; int a[MAXN]; int mp[600][MAXN]; vector<int> ls[1000]; void swp(int l, int r) { int size = 0, i = 0; vector<int> tmp1, tmp2; for (i = 0; i <= (n - 1) / bs; i++) { if (size + ls[i].size() > r) { break; } size += ls[i].size(); } long long sayi = 0; for (int j = 0; j < ls[i].size(); j++) { mp[i][ls[i][j]] = 0; if (j + size == r) { sayi = ls[i][j]; continue; } tmp1.push_back(ls[i][j]); } ls[i].clear(); for (int j : tmp1) { ls[i].push_back(j); mp[i][j]++; } size = 0; i = 0; for (i = 0; i <= (n - 1) / bs; i++) { if (size + ls[i].size() > l) { break; } size += ls[i].size(); } if (l == n - 1) { ls[(l / bs)].push_back(sayi); mp[l / bs][sayi]++; return; } for (int j = 0; j < ls[i].size(); j++) { mp[i][ls[i][j]] = 0; if (j + size == l) { tmp2.push_back(sayi); } tmp2.push_back(ls[i][j]); } ls[i].clear(); for (int j : tmp2) { ls[i].push_back(j); mp[i][j]++; } } long long get(long long ind, long long k) { if (ind < 0) return 0; long long ans = 0; int size = 0; int yer; for (int i = 0; i <= (n - 1) / bs; i++) { if (size + ls[i].size() > ind) { yer = i; break; } size += ls[i].size(); ans += mp[i][k]; } for (int i = 0; i + size <= ind; i++) { ans += (ls[yer][i] == k); } return ans; } int main() { ios_base::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr); cin >> n; for (int i = 0; i < n; i++) { cin >> a[i]; ls[i / bs].push_back(a[i]); mp[i / bs][a[i]]++; } int lastans = 0; int q; cin >> q; for (int i = 0; i < q; i++) { if (i % bs == 0) { vector<int> tmp; for (int i = 0; i <= (n - 1) / bs; i++) { for (auto j = ls[i].begin(); j < ls[i].end(); j++) { tmp.push_back(*j); mp[i][*j] = 0; } } for (int j = 0; j < n; j++) { if (j % bs == 0) { ls[j / bs].clear(); } mp[j / bs][tmp[j]]++; ls[j / bs].push_back(tmp[j]); } } int a; cin >> a; if (a == 1) { int l, r; cin >> l >> r; l = (l + lastans - 1 + n) % n; r = (r + lastans - 1 + n) % n; if (l > r) swap(l, r); swp(l, r); } else { int l, r, k; cin >> l >> r >> k; l = (l + lastans - 1 + n) % n; r = (r + lastans - 1 + n) % n; k = 1 + (k + lastans - 1 + n) % n; if (l > r) swap(l, r); lastans = get(r, k) - get(l - 1, k); cout << lastans << n ; } } }
#include <bits/stdc++.h> using namespace std; int main() { string name; int counter = 0; cin >> name; for (int i = 0; i < name.length() / 2; i++) { if (name[i] != name[name.length() - 1 - i]) counter++; } if (name.length() % 2 == 0) { if (counter == 1) cout << YES n ; else cout << NO n ; } else { if (counter == 1 || counter == 0) cout << YES n ; else cout << NO n ; } return 0; }
#include <bits/stdc++.h> using namespace std; long long modpow(long long a, long long b, long long mod = (long long)(1e9 + 7)) { if (!b) return 1; a %= mod; return modpow(a * a % mod, b / 2, mod) * (b & 1 ? a : 1) % mod; } mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); const int mxn = 1100; char string1[mxn]; char string2[mxn]; int xt1[mxn], xt2[mxn], xt3[mxn]; int bound[mxn]; int n, m; void solution() { long long answer = 0; scanf( %d , &n); scanf( %d , &m); for (int i = 0; i < n; i++) { scanf( %s , string2); long long composite = 0; for (int j = 0; j < m; j++) { if (string2[j] != string1[j]) { xt1[j] = xt2[j]; xt2[j] = xt3[j]; xt3[j] = 1; } else { xt3[j]++; } if (j > 0) { if (string2[j] == string2[j - 1]) bound[j]++; else bound[j] = 0; } if (xt1[j] >= xt2[j] && xt2[j] == xt3[j]) { composite++; if (bound[j] < xt3[j] * 3) composite = 1; } else composite = 0; string1[j] = string2[j]; answer += composite; } } cout << answer << endl; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); solution(); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int t; cin >> t; while (t--) { int n; cin >> n; if (n == 2 || n == 3 || n == 4 || n == 5 || n == 6 || n == 7) cout << 1 << endl; else if (n % 7 == 1) cout << ((n - 1) / 7) + 1 << endl; else cout << (n / 7) + 1 << endl; } }
#include <bits/stdc++.h> using namespace std; using ll = long long; const int N = 1e5 + 5; struct edge { int u, v; ll w; edge(int u, int v, ll w) : u(u), v(v), w(w) {} }; int n, m, k, closestP[N], par[N]; ll d[N], res; bool is1portal; vector<int> portal; vector<edge> adj[N], edges; int root(int v) { return (par[v] < 0) ? v : (par[v] = root(par[v])); } void join(int x, int y) { if ((x = root(x)) == (y = root(y))) return; if (par[x] > par[y]) swap(x, y); par[x] += par[y]; par[y] = x; } int main() { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); cin >> n >> m; for (int i = 1; i <= m; ++i) { int u, v, w; cin >> u >> v >> w; adj[u].emplace_back(u, v, w); adj[v].emplace_back(v, u, w); } cin >> k; for (int i = 1; i <= k; ++i) { int p; cin >> p; portal.emplace_back(p); if (p == 1) is1portal = true; } priority_queue<pair<ll, pair<int, int>>> q; for (int i = 1; i <= n; ++i) d[i] = 1e18; for (int p : portal) q.push({d[p] = 0, {p, p}}); while (!q.empty()) { int u = q.top().second.first; int p = q.top().second.second; q.pop(); if (closestP[u]) continue; closestP[u] = p; for (edge e : adj[u]) { if (d[e.v] > d[u] + e.w) { d[e.v] = d[u] + e.w; q.push({-d[e.v], {e.v, p}}); } } } for (int u = 1; u <= n; ++u) { for (edge e : adj[u]) { edges.emplace_back(closestP[u], closestP[e.v], d[u] + d[e.v] + e.w); } } sort(edges.begin(), edges.end(), [](const edge &x, const edge &y) { return x.w < y.w; }); for (int i = 1; i <= n; ++i) par[i] = -1; for (edge e : edges) { if (root(e.u) != root(e.v)) { join(e.u, e.v); res += e.w; } } if (!is1portal) res += d[1]; cout << res; return 0; }
#include <bits/stdc++.h> using namespace std; signed main() { ios_base::sync_with_stdio(false); cin.tie(NULL); long long n; cin >> n; vector<long long> a(n); long long sums = 0; for (long long i = 0; i < n; i++) { cin >> a[i]; sums += a[i]; } if (sums % 2 == 0) { long long maxs = -1; for (long long i = 0; i < n; i++) { if (a[i] > maxs) maxs = a[i]; } if (maxs > sums - maxs) { cout << NO n ; } else { cout << YES n ; } } else { cout << NO n ; } }
#include <bits/stdc++.h> using namespace std; int n; string t; map<string, int> mp; int solve(int l, int r) { int val = 0; for (int i = r - 1; i >= l; i--) { if (t[i] == ( ) val++; if (t[i] == ) ) val--; if (!val && (t[i] == + || t[i] == - )) { int L = solve(l, i); int R = solve(i + 1, r); if (L && R && (t[i] == + || R > 1)) return 1; else return 0; } } for (int i = r - 1; i >= l; i--) { if (t[i] == ( ) val++; if (t[i] == ) ) val--; if (!val && (t[i] == * || t[i] == / )) { int L = solve(l, i); int R = solve(i + 1, r); if (L > 1 && R > 1 && (t[i] == * || R > 2)) return 2; else return 0; } } string x = t.substr(l, r - l); if (t[l] == ( ) { if (solve(l + 1, r - 1)) return 3; return 0; } if (mp.count(x)) return mp[x]; return 3; } int Get() { string tmp; getline(cin, tmp); int len = tmp.length(); t = ; for (int i = 0; i < len; i++) if (tmp[i] != ) t += tmp[i]; return solve(0, t.length()); } int main() { scanf( %d , &n); string s; for (int i = 1; i <= n; i++) { scanf( #%*s ); cin >> s; mp[s] = Get(); } if (Get()) puts( OK ); else puts( Suspicious ); return 0; }
#include <bits/stdc++.h> using namespace std; mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count()); const double eps = 0.00001; const int MOD = 1000000007; const int INF = 1000055555; const long long LLINF = 1223372000000000555; const int N = 1e5 + 1e4; const int M = 1234; const int MAGIC = 10; vector<int> merge(vector<int> a, vector<int> b) { vector<int> v; int i = 0, j = 0; while (i < a.size() || j < b.size()) { if (v.size() == MAGIC) break; if (i == a.size()) v.push_back(b[j++]); else if (j == b.size()) v.push_back(a[i++]); else if (a[i] < b[j]) v.push_back(a[i++]); else v.push_back(b[j++]); if (v.size() > 1 && v[v.size() - 2] == v.back()) v.pop_back(); } return v; } vector<int> g[N]; vector<int> arr[N][20]; int tin[N], tout[N], timer = 0; int up[N][20]; void dfs(int v, int p) { tin[v] = ++timer; up[v][0] = p; for (int i = 1; i < 20; i++) { up[v][i] = up[up[v][i - 1]][i - 1]; int UP = up[v][i - 1]; arr[v][i] = merge(arr[v][i - 1], arr[UP][i - 1]); } for (int u : g[v]) { if (u != p) dfs(u, v); } tout[v] = ++timer; } bool upper(int a, int b) { return (tin[a] <= tin[b] && tout[a] >= tout[b]); } int LCA(int a, int b) { if (upper(a, b)) return a; if (upper(b, a)) return b; for (int i = 19; i >= 0; i--) { if (!upper(up[a][i], b)) a = up[a][i]; } return up[a][0]; } void out(vector<int> &v, int a) { int k = min(a, ((int)v.size())); cout << k << ; for (int i = 0; i < k; i++) { cout << v[i] << ; } cout << endl; } void solve() { int n, m, q; cin >> n >> m >> q; for (int i = 1; i < n; i++) { int u, v; cin >> u >> v; g[u].push_back(v); g[v].push_back(u); } for (int i = 1; i <= m; i++) { int x; cin >> x; arr[x][0].push_back(i); } for (int i = 1; i <= n; i++) { if (arr[i][0].size() > MAGIC) arr[i][0].resize(MAGIC); } dfs(1, 1); while (q--) { int u, v, a; cin >> u >> v >> a; if (v == u) { out(arr[v][0], a); continue; } int lca = LCA(u, v); if (u == lca) { vector<int> vv; for (int i = 19; i >= 0; i--) { if (!upper(up[v][i], lca) && up[v][i]) { vv = merge(vv, arr[v][i]); v = up[v][i]; } } vv = merge(vv, arr[u][0]); vv = merge(vv, arr[v][0]); out(vv, a); continue; } if (v == lca) { vector<int> vv; for (int i = 19; i >= 0; i--) { if (!upper(up[u][i], lca)) { vv = merge(vv, arr[u][i]); u = up[u][i]; } } vv = merge(vv, arr[u][0]); vv = merge(vv, arr[v][0]); out(vv, a); continue; } vector<int> vv = arr[lca][0]; for (int i = 19; i >= 0; i--) { if (!upper(up[v][i], lca)) { vv = merge(vv, arr[v][i]); v = up[v][i]; } } for (int i = 19; i >= 0; i--) { if (!upper(up[u][i], lca)) { vv = merge(vv, arr[u][i]); u = up[u][i]; } } vv = merge(vv, arr[u][0]); vv = merge(vv, arr[v][0]); out(vv, a); } } int main() { ios_base::sync_with_stdio(false); int T = 1; while (T--) { solve(); } return 0; }
#include <bits/stdc++.h> using namespace std; const int MAXN = 100010; template <class T, class Comp = less<T> > struct monoqueue { deque<pair<T, int> > dq; Comp comp; int left, right; bool one_index; monoqueue(bool ind1) : dq(), comp(), left(ind1), right(ind1), one_index(ind1) {} void push(T t) { while (!dq.empty() && comp(t, dq.back().first)) { dq.pop_back(); } dq.push_back(make_pair(t, right++)); } template <class Iterator> void push(Iterator i, Iterator j) { for (; i != j; i++) { push(*i); } } void pop() { assert(!empty()); if (dq.front().second == left) { dq.pop_front(); } left++; } T get() { assert(!empty()); return dq.front().first; } int getind() { assert(!empty()); return dq.front().second; } int size() { return right - left; } bool empty() { return left == right; } void clear() { dq.clear(); left = right = 0; } }; int N, S, L; int arr[MAXN]; int upto[MAXN]; monoqueue<int> dqmin(true); monoqueue<int, greater<int> > dqmax(true); int dp[MAXN]; int main() { if (fopen( input.txt , r )) { freopen( input.txt , r , stdin); } ios_base::sync_with_stdio(false); cin >> N >> S >> L; for (int i = 1; i <= N; i++) { cin >> arr[i]; } for (int i = 1; i <= N; i++) { dqmin.push(arr[i]); dqmax.push(arr[i]); while (!dqmin.empty() && dqmax.get() - dqmin.get() > S) { dqmin.pop(); dqmax.pop(); } int m = dqmin.left; if (m >= i - L + 2) { m = i - L + 2; } upto[i] = m; } fill_n(dp + 1, N, MAXN); dqmin.clear(); for (int i = L; i <= N; i++) { dqmin.push(dp[i - L]); while (dqmin.left < upto[i] - 1) { dqmin.pop(); } if (dqmin.empty() || dqmin.get() == MAXN) { dp[i] = MAXN; } else { dp[i] = dqmin.get() + 1; } } int ans = dp[N]; cout << (ans == MAXN ? -1 : ans) << endl; }
#include <bits/stdc++.h> using namespace std; const int N = 200010; bool good[N], need[N]; int n; void ask(vector<int> &v) { printf( %d , (int)v.size()); for (int i = 0; i < (int)v.size(); i++) { printf( %d , v[i]); good[v[i]] = true; } puts( ); fflush(stdout); int idx; scanf( %d , &idx); for (int i = 0; i < (int)v.size(); i++) { good[idx] = false; idx++; if (idx > n) idx = 1; } } int main() { scanf( %d , &n); if (n <= 3) { puts( 0 ); fflush(stdout); return 0; } int cur, best = 0, k; for (int sz = 1; sz < n; sz++) { cur = ((n + sz) / (sz + 1)); cur = n - cur - sz; if (cur > best) { best = cur; k = sz; } } for (int i = 1; i < n; i += k + 1) { for (int j = i; j < min(n, i + k); j++) need[j] = true; } vector<int> v; while (true) { cur = 0; for (int l = 1; l <= n; l++) if (good[l]) cur++; if (cur >= best) break; v.clear(); for (int i = 1; i <= n; i++) { if (need[i] && !good[i]) v.push_back(i); } ask(v); } puts( 0 ); fflush(stdout); return 0; }
#include <bits/stdc++.h> using namespace std; long long a1, a2, b1, b2, c1, c2; struct Point { long long x, y; Point(long long x = 0, long long y = 0) : x(x), y(y) {} }; int exgcd(int a, int b, int& x, int& y) { if (b == 0) { x = 1; y = 0; return a; } int d = exgcd(b, a % b, x, y); int t = x; x = y; y = t - a / b * y; return d; } int dcmp(int x) { if (x == 0) return 0; return x < 0 ? -1 : 1; } Point operator+(const Point& a, const Point& b) { return Point(a.x + b.x, a.y + b.y); } Point ans[5]; int main() { scanf( %lld %lld %lld %lld %lld %lld , &a1, &a2, &b1, &b2, &c1, &c2); ans[1] = Point(b1 - a1, b2 - a2); ans[2] = Point(b1 - a2, b2 + a1); ans[3] = Point(b1 + a1, b2 + a2); ans[4] = Point(b1 + a2, b2 - a1); if (c1 == 0 && c2 == 0) { for (int i = 1; i <= 4; i++) if (ans[i].x == 0 && ans[i].y == 0) { printf( YES n ); return 0; } printf( NO n ); return 0; } for (int i = 1; i <= 4; i++) { long long t1, t2; if ((c1 * ans[i].x + c2 * ans[i].y) % (c1 * c1 + c2 * c2) != 0) continue; t1 = (c1 * ans[i].x + c2 * ans[i].y) / (c1 * c1 + c2 * c2); if ((c2 * ans[i].x - c1 * ans[i].y) % (c1 * c1 + c2 * c2) != 0) continue; t2 = (c2 * ans[i].x - c1 * ans[i].y) / (c1 * c1 + c2 * c2); printf( YES n ); return 0; } printf( NO n ); return 0; }
#include <bits/stdc++.h> using namespace std; string s; int n, ans, x = 201, y = 201, u[405][405]; int main() { scanf( %d , &n); cin >> s; for (int i = 0; i < n; ++i) { ans += u[x][y]; ++u[x][y]; if (s[i] == U ) ++x; if (s[i] == D ) --x; if (s[i] == R ) ++y; if (s[i] == L ) --y; } ans += u[x][y]; cout << ans; return 0; }
#include <bits/stdc++.h> using namespace std; template <class T> bool umin(T& a, const T& b) { return a > b ? a = b, true : false; } template <class T> bool umax(T& a, const T& b) { return a < b ? a = b, true : false; } template <long long sz> using tut = array<long long, sz>; void usaco(string s) { freopen((s + .in ).c_str(), r , stdin); freopen((s + .out ).c_str(), w , stdout); ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); } const long long N = 2e5 + 5; const long long mod = (119 << 23) + 1; const long long inf = LLONG_MAX; const long double Pi = acos(-1); void add(long long& a, long long b, long long mod = ::mod) { a = (a + b) % mod; } void sub(long long& a, long long b, long long mod = ::mod) { a = ((a - b) % mod + mod) % mod; } void mul(long long& a, long long b, long long mod = ::mod) { a = (a * 1ll * b) % mod; } long long n, m, k, t, q, ans, res, a[N]; long long rr[N]; void solve(long long t_case) { cin >> n >> k; for (long long i = 1; i <= n; i++) { cin >> a[i]; } auto check2 = [&](long long b, long long a) -> long long { return (a - 3ll * b * b - 1); }; auto check = [&](long long mm) -> bool { long long cnt = 0; for (long long i = 1; i <= n; i++) { long long l = 0, r = a[i]; while (l < r) { long long m = (l + r + 1) >> 1; if (check2(m, a[i]) >= mm) l = m; else r = m - 1; } rr[i] = l; cnt += l; } return (cnt >= k); }; long long l = -inf, r = inf; while (l < r) { long long m = (l + r + 1) >> 1; if (check(m)) l = m; else r = m - 1; } check(l); long long cnt = 0; for (long long i = 1; i <= n; i++) cnt += rr[i]; cnt -= k; for (long long i = 1; i <= n && cnt; i++) { if (rr[i] && check2(rr[i], a[i]) == l) cnt--, rr[i]--; } for (long long i = 1; i <= n; i++) cout << rr[i] << ; cout << n ; } signed main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); if (0) { long long t; cin >> t; for (long long t_case = 1; t_case <= t; t_case++) solve(t_case); } else solve(1); return 0; }
#include <bits/stdc++.h> using namespace std; int32_t main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); long long n, m, val, sum = 0; cin >> n; vector<long long> v, q; for (long long i = 0; i < n; i++) { cin >> val; v.push_back(val); sum += val; } sort(v.begin(), v.end()); reverse(v.begin(), v.end()); cin >> m; for (long long i = 0; i < m; i++) { cin >> val; cout << sum - v[val - 1] << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; struct vt { int p; int a; int b; }; int main() { int n, index; cin >> n; int a[n + 5], b[200005]; for (int i = 1; i < 200005; i++) { b[i] = 0; } int maxd = 0; for (int i = 1; i <= n; i++) { cin >> a[i]; b[a[i]]++; } for (int i = n; i >= 1; i--) { if (maxd < b[a[i]]) { maxd = b[a[i]]; index = i; } } if (maxd == n) cout << 0 ; else if (maxd == 1) { int u = 0; vt x[n + 5]; for (int i = 2; i <= n; i++) { if (a[i] == a[i - 1]) continue; if (a[i] > a[i - 1]) { x[u].p = 2; x[u].a = i; x[u].b = i - 1; u++; a[i] = a[i - 1]; } else if (a[i] < a[i - 1]) { x[u].p = 1; x[u].a = i; x[u].b = i - 1; u++; a[i] = a[i - 1]; } } cout << u << endl; for (int i = 0; i < u; i++) { cout << x[i].p << << x[i].a << << x[i].b << endl; } } else { int u = 0; vt x[n + 5]; for (int i = index - 1; i >= 1; i--) { if (a[i] == a[i + 1]) continue; if (a[i] > a[i + 1]) { x[u].p = 2; x[u].a = i; x[u].b = i + 1; u++; a[i] = a[i + 1]; } else if (a[i] < a[i + 1]) { x[u].p = 1; x[u].a = i; x[u].b = i + 1; u++; a[i] = a[i + 1]; } } for (int i = index + 1; i <= n; i++) { if (a[i] == a[i - 1]) continue; if (a[i] > a[i - 1]) { x[u].p = 2; x[u].a = i; x[u].b = i - 1; u++; a[i] = a[i - 1]; } else if (a[i] < a[i - 1]) { x[u].p = 1; x[u].a = i; x[u].b = i - 1; u++; a[i] = a[i - 1]; } } cout << u << endl; for (int i = 0; i < u; i++) { cout << x[i].p << << x[i].a << << x[i].b << endl; } } }
#include <bits/stdc++.h> using namespace std; bitset<300000010> su; int main() { su[1] = 1; int l, r, ans = 0; cin >> l >> r; if (l < 3 && r > 1) ans++; for (int i = 3; i * i <= r; i += 2) if (!su[i]) for (long long j = 1LL * i * i; j <= r; j += i << 1) su[j] = 1; while (l % 4 != 1) l++; for (int i = l; i <= r; i += 4) if (!su[i]) ans++; cout << ans; return 0; }
#include <bits/stdc++.h> using namespace std; int power(long long x, unsigned int y, int p) { long long res = 1; x = x % p; if (x == 0) return 0; while (y > 0) { if (y & 1) res = (res * x) % p; y = y >> 1; x = (x * x) % p; } return res; } int main() { long long n, p; cin >> n >> p; cout << (power(3, n, p) * 1ll + p * 1ll - 1ll) % p; return 0; }
#include <bits/stdc++.h> using namespace std; const int maxn = 1e6 + 10; string s1, s2; int n, m; long long dp[maxn][3][3]; int p1[maxn], p2[maxn]; int f(char a) { return a == G ? 0 : (a == R ? 1 : 2); } void init(const string s, int n, const string t, int m, int p[]) { p[0] = 0; while (p[0] < m && s[0] != t[p[0]]) p[0]++; p[0] = min(p[0], m - 1); for (int i = 1; i < n; i++) { p[i] = p[i - 1] + 1; while (p[i] < m && s[i] != t[p[i]]) p[i]++; p[i] = min(p[i], m - 1); } } int main() { cin >> s1; cin >> s2; n = s1.size(); m = s2.size(); init(s1, n, s2, m, p1); init(s2, m, s1, n, p2); memset(dp, 0ll, sizeof(dp)); for (int i = 1; i < m; i++) { for (int j = 0; j < 3; j++) { for (int k = 0; k < 3; k++) { if (f(s2[i - 1]) == j && f(s2[i]) == k) dp[i][j][k] = dp[i - 1][j][k] + 1; else dp[i][j][k] = dp[i - 1][j][k]; } } } long long ret = 0; int l = 0, r; for (int i = 0; i < n; i++) { r = p1[i]; while (l < m && p2[l] < i) l++; ret += max(r - l + 1, 0); if (i && l <= r) { int j = f(s1[i - 1]), k = f(s1[i]); if (j != k) { ret -= dp[r][k][j]; if (l - 1 >= 0) ret += dp[l - 1][k][j]; } } } cout << ret << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int house[300010]; int main() { ios::sync_with_stdio(0); cin.tie(0); int n; cin >> n; int a, b, c, d; for (int i = 0; i < n; ++i) cin >> house[i]; a = house[0]; d = house[n - 1]; if (a != d) { cout << n - 1 << endl; return 0; } int i = 0; while (house[++i] == a) ; int j = n; while (house[--j] == d) ; cout << max(n - i - 1, j + 1 - 1) << endl; }
#include <bits/stdc++.h> using namespace std; const int dl = 10069; void bib() { for (int i = 0; i < (int)10; i++) { cout << a ; } } const int M = 4 * 3 * 100 * 1000 + 10; int seg[M]; int ans[M / 2]; int n, m; void battle(int s, int e, int winner, int l = 0, int r = n, int id = 1) { if (s >= r || e <= l) return; if (seg[id] != -1) return; if (s <= l && r <= e && (winner < l || winner >= r)) { seg[id] = winner; } if (r - l < 2) return; int mid = (r + l) / 2; battle(s, e, winner, l, mid, id * 2); battle(s, e, winner, mid, r, id * 2 + 1); } void print(int l = 0, int r = n, int id = 1) { if (r - l == 1) { ans[l] = seg[id] + 1; return; } int mid = (l + r) / 2; print(l, mid, id * 2); print(mid, r, id * 2 + 1); } int main() { ios::sync_with_stdio(false); cin >> n >> m; for (int i = 0; i < (int)M; i++) seg[i] = -1; for (int i = 0; i < (int)m; i++) { int l, r, x; cin >> l >> r >> x; l--; x--; battle(l, r, x); } print(); for (int i = 0; i < (int)n; i++) { cout << ans[i] << ; } return 0; }
#include <bits/stdc++.h> using namespace std; const int maxn = 1e5 + 10; int a[510]; int dp[510][510]; int dfs(int l, int r) { if (dp[l][r] != -1) { return dp[l][r]; } if (l > r) { return 0; } if (l == r) { return 1; } int mi = 1 + dfs(l + 1, r); if (a[l] == a[l + 1]) { mi = min(mi, 1 + dfs(l + 2, r)); } for (int i = l + 2; i <= r; ++i) { if (a[i] == a[l]) { mi = min(mi, dfs(l + 1, i - 1) + dfs(i + 1, r)); } } return dp[l][r] = mi; } int main() { int n; scanf( %d , &n); for (int i = 0; i < n; ++i) { scanf( %d , &a[i]); } memset(dp, -1, sizeof(dp)); printf( %d n , dfs(0, n - 1)); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); int t; cin >> t; while (t--) { long long n, a, b, c, d; cin >> n >> a >> b >> c >> d; int x = 0; if (((c + d) < n * (a - b)) || ((c - d) > n * (a + b))) cout << No << endl; else cout << Yes << endl; } return 0; }
#include <bits/stdc++.h> using namespace std; #pragma comment(linker, /STACK:36777216 ) template <class T> inline void RD(T &); template <class T> inline void OT(const T &); template <class T> inline T &_RD(T &x) { RD(x); return x; } inline int RD() { int x; return _RD(x); } inline void RF(double &x) { scanf( %lf , &x); } inline double _RF(double &x) { scanf( %lf , &x); return x; } inline double RF() { double x; return _RF(x); } inline void RC(char &c) { scanf( %c , &c); } inline char _RC(char &c) { scanf( %c , &c); return c; } inline char RC() { char c; return _RC(c); } inline void RS(char *s) { scanf( %s , s); } template <class T0, class T1> inline void RD(T0 &x0, T1 &x1) { RD(x0), RD(x1); } template <class T0, class T1, class T2> inline void RD(T0 &x0, T1 &x1, T2 &x2) { RD(x0), RD(x1), RD(x2); } template <class T0, class T1, class T2, class T3> inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3) { RD(x0), RD(x1), RD(x2), RD(x3); } template <class T0, class T1, class T2, class T3, class T4> inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4) { RD(x0), RD(x1), RD(x2), RD(x3), RD(x4); } template <class T0, class T1, class T2, class T3, class T4, class T5> inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5) { RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5); } template <class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void RD(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5, T6 &x6) { RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5), RD(x6); } template <class T0, class T1> inline void OT(T0 &x0, T1 &x1) { OT(x0), OT(x1); } template <class T0, class T1, class T2> inline void OT(T0 &x0, T1 &x1, T2 &x2) { OT(x0), OT(x1), OT(x2); } template <class T0, class T1, class T2, class T3> inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3) { OT(x0), OT(x1), OT(x2), OT(x3); } template <class T0, class T1, class T2, class T3, class T4> inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4) { OT(x0), OT(x1), OT(x2), OT(x3), OT(x4); } template <class T0, class T1, class T2, class T3, class T4, class T5> inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5) { OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5); } template <class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void OT(T0 &x0, T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5, T6 &x6) { OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5), OT(x6); } template <class T> inline void RST(T &A) { memset(A, 0, sizeof(A)); } template <class T0, class T1> inline void RST(T0 &A0, T1 &A1) { RST(A0), RST(A1); } template <class T0, class T1, class T2> inline void RST(T0 &A0, T1 &A1, T2 &A2) { RST(A0), RST(A1), RST(A2); } template <class T0, class T1, class T2, class T3> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3) { RST(A0), RST(A1), RST(A2), RST(A3); } template <class T0, class T1, class T2, class T3, class T4> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4) { RST(A0), RST(A1), RST(A2), RST(A3), RST(A4); } template <class T0, class T1, class T2, class T3, class T4, class T5> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5) { RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5); } template <class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void RST(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6) { RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5), RST(A6); } template <class T> inline void CLR(priority_queue<T, vector<T>, less<T> > &Q) { while (!Q.empty()) Q.pop(); } template <class T> inline void CLR(priority_queue<T, vector<T>, greater<T> > &Q) { while (!Q.empty()) Q.pop(); } template <class T> inline void CLR(T &A) { A.clear(); } template <class T0, class T1> inline void CLR(T0 &A0, T1 &A1) { CLR(A0), CLR(A1); } template <class T0, class T1, class T2> inline void CLR(T0 &A0, T1 &A1, T2 &A2) { CLR(A0), CLR(A1), CLR(A2); } template <class T0, class T1, class T2, class T3> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3) { CLR(A0), CLR(A1), CLR(A2), CLR(A3); } template <class T0, class T1, class T2, class T3, class T4> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4) { CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4); } template <class T0, class T1, class T2, class T3, class T4, class T5> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5) { CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5); } template <class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void CLR(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6) { CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5), CLR(A6); } template <class T> inline void CLR(T &A, int n) { for (int i = 0; i < int(n); ++i) CLR(A[i]); } template <class T> inline void FLC(T &A, int x) { memset(A, x, sizeof(A)); } template <class T0, class T1> inline void FLC(T0 &A0, T1 &A1, int x) { FLC(A0, x), FLC(A1, x); } template <class T0, class T1, class T2> inline void FLC(T0 &A0, T1 &A1, T2 &A2) { FLC(A0), FLC(A1), FLC(A2); } template <class T0, class T1, class T2, class T3> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3) { FLC(A0), FLC(A1), FLC(A2), FLC(A3); } template <class T0, class T1, class T2, class T3, class T4> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4) { FLC(A0), FLC(A1), FLC(A2), FLC(A3), FLC(A4); } template <class T0, class T1, class T2, class T3, class T4, class T5> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5) { FLC(A0), FLC(A1), FLC(A2), FLC(A3), FLC(A4), FLC(A5); } template <class T0, class T1, class T2, class T3, class T4, class T5, class T6> inline void FLC(T0 &A0, T1 &A1, T2 &A2, T3 &A3, T4 &A4, T5 &A5, T6 &A6) { FLC(A0), FLC(A1), FLC(A2), FLC(A3), FLC(A4), FLC(A5), FLC(A6); } template <class T> inline void SRT(T &A) { sort(A.begin(), A.end()); } template <class T, class C> inline void SRT(T &A, C B) { sort(A.begin(), A.end(), B); } const int MOD = 1000000007; const int INF = 0x3f3f3f3f; const long long INF_64 = 0x3f3f3f3f3f3f3f3fLL; const double EPS = 1e-8; const double OO = 1e15; const double PI = acos(-1.0); template <class T> inline void checkMin(T &a, const T b) { if (b < a) a = b; } template <class T> inline void checkMax(T &a, const T b) { if (b > a) a = b; } template <class T, class C> inline void checkMin(T &a, const T b, C c) { if (c(b, a)) a = b; } template <class T, class C> inline void checkMax(T &a, const T b, C c) { if (c(a, b)) a = b; } template <class T> inline T min(T a, T b, T c) { return min(min(a, b), c); } template <class T> inline T max(T a, T b, T c) { return max(max(a, b), c); } template <class T> inline T min(T a, T b, T c, T d) { return min(min(a, b), min(c, d)); } template <class T> inline T max(T a, T b, T c, T d) { return max(min(a, b), max(c, d)); } template <class T, class C> inline T min_cp(T a, T b, C cp) { return min(a, b, cp); } template <class T, class C> inline T min_cp(T a, T b, T c, C cp) { return min_cp(min_cp(a, b, cp), c, cp); } template <class T, class C> inline T min_cp(T a, T b, T c, T d, C cp) { return min_cp(min_cp(a, b, cp), min_cp(c, d, cp), cp); } template <class T, class C> inline T max_cp(T a, T b, C cp) { return max(a, b, cp); } template <class T, class C> inline T max_cp(T a, T b, T c, C cp) { return max_cp(max_cp(a, b, cp), c, cp); } template <class T, class C> inline T max_cp(T a, T b, T c, T d, C cp) { return max_cp(max_cp(a, b, cp), max_cp(c, d, cp), cp); } template <class T> inline T sqr(T a) { return a * a; } template <class T> inline T cub(T a) { return a * a * a; } int Ceil(int x, int y) { return (x - 1) / y + 1; } inline bool _1(int x, int i) { return x & 1 << i; } inline bool _1(long long x, int i) { return x & 1LL << i; } inline long long _1(int i) { return 1LL << i; } inline long long _U(int i) { return _1(i) - 1; }; template <class T> inline T low_bit(T x) { return x & -x; } template <class T> inline T high_bit(T x) { T p = low_bit(x); while (p != x) x -= p, p = low_bit(x); return p; } template <class T> inline T cover_bit(T x) { T p = 1; while (p < x) p <<= 1; return p; } inline int count_bits(int x) { x = (x & 0x55555555) + ((x & 0xaaaaaaaa) >> 1); x = (x & 0x33333333) + ((x & 0xcccccccc) >> 2); x = (x & 0x0f0f0f0f) + ((x & 0xf0f0f0f0) >> 4); x = (x & 0x00ff00ff) + ((x & 0xff00ff00) >> 8); x = (x & 0x0000ffff) + ((x & 0xffff0000) >> 16); return x; } inline int count_bits(long long x) { x = (x & 0x5555555555555555LL) + ((x & 0xaaaaaaaaaaaaaaaaLL) >> 1); x = (x & 0x3333333333333333LL) + ((x & 0xccccccccccccccccLL) >> 2); x = (x & 0x0f0f0f0f0f0f0f0fLL) + ((x & 0xf0f0f0f0f0f0f0f0LL) >> 4); x = (x & 0x00ff00ff00ff00ffLL) + ((x & 0xff00ff00ff00ff00LL) >> 8); x = (x & 0x0000ffff0000ffffLL) + ((x & 0xffff0000ffff0000LL) >> 16); x = (x & 0x00000000ffffffffLL) + ((x & 0xffffffff00000000LL) >> 32); return x; } int reverse_bits(int x) { x = ((x >> 1) & 0x55555555) | ((x << 1) & 0xaaaaaaaa); x = ((x >> 2) & 0x33333333) | ((x << 2) & 0xcccccccc); x = ((x >> 4) & 0x0f0f0f0f) | ((x << 4) & 0xf0f0f0f0); x = ((x >> 8) & 0x00ff00ff) | ((x << 8) & 0xff00ff00); x = ((x >> 16) & 0x0000ffff) | ((x << 16) & 0xffff0000); return x; } long long reverse_bits(long long x) { x = ((x >> 1) & 0x5555555555555555LL) | ((x << 1) & 0xaaaaaaaaaaaaaaaaLL); x = ((x >> 2) & 0x3333333333333333LL) | ((x << 2) & 0xccccccccccccccccLL); x = ((x >> 4) & 0x0f0f0f0f0f0f0f0fLL) | ((x << 4) & 0xf0f0f0f0f0f0f0f0LL); x = ((x >> 8) & 0x00ff00ff00ff00ffLL) | ((x << 8) & 0xff00ff00ff00ff00LL); x = ((x >> 16) & 0x0000ffff0000ffffLL) | ((x << 16) & 0xffff0000ffff0000LL); x = ((x >> 32) & 0x00000000ffffffffLL) | ((x << 32) & 0xffffffff00000000LL); return x; } using namespace std; class bignum { friend istream &operator>>(istream &, bignum &); friend ostream &operator<<(ostream &, const bignum &); friend bignum operator+(const bignum &, const bignum &); friend bignum operator-(const bignum &, const bignum &); friend bignum operator*(const bignum &, const bignum &); friend bignum operator/(const bignum &, const bignum &); friend bignum operator%(const bignum &, const bignum &); friend bignum operator+(const bignum &, const int &); friend bignum operator-(const bignum &, const int &); friend bignum operator*(const bignum &, const int &); friend bignum operator/(const bignum &, const int &); friend bignum operator%(const bignum &, const int &); friend bool operator==(const bignum &, const bignum &); friend bool operator!=(const bignum &, const bignum &); friend bool operator<(const bignum &, const bignum &); friend bool operator>(const bignum &, const bignum &); friend bool operator<=(const bignum &, const bignum &); friend bool operator>=(const bignum &, const bignum &); friend bool operator==(const bignum &, const int &); friend bool operator!=(const bignum &, const int &); friend bool operator<(const bignum &, const int &); friend bool operator>(const bignum &, const int &); friend bool operator<=(const bignum &, const int &); friend bool operator>=(const bignum &, const int &); friend int do_comp(const bignum &, const int &); friend int do_comp(const bignum &, const bignum &); friend void divide(const bignum &, const bignum &, bignum &, bignum &); friend bignum pow(bignum, int); public: inline bignum(){}; inline bignum(int s) { while (s != 0) { data.push_back(s % 100000000); s /= 100000000; } if (data.empty()) data.push_back(0); } inline bignum(long long s) { while (s != 0) { data.push_back(int(s % 100000000)); s /= 100000000; } if (data.empty()) data.push_back(0); } inline bignum(string s) { int t, i; data.clear(); for (i = int(s.size()) - 8; i > 0; i -= 8) { istringstream(s.substr(i, 8)) >> t; data.push_back(t); } istringstream(s.substr(0, i + 8)) >> t; data.push_back(t); } void operator=(const int); void operator=(const string); void operator=(const bignum); bignum &operator+=(const bignum &); bignum &operator-=(const bignum &); bignum &operator*=(const bignum &); bignum &operator/=(const bignum &); bignum &operator%=(const bignum &); bignum &operator+=(const int &); bignum &operator-=(const int &); bignum &operator*=(const int &); bignum &operator/=(const int &); bignum &operator%=(const int &); bignum &operator%=(const long long &); bool undefined(); int do_try(const int &); int do_try(const bignum &); void do_trim(); list<int> data; void add(const int a) { list<int>::iterator it = data.end(); it--; if ((*it) < 10) (*it) = a; else if ((*it) < 100) (*it) = (*it) % 10 + 10 * a; else if ((*it) < 1000) (*it) = (*it) % 100 + 100 * a; else if ((*it) < 10000) (*it) = (*it) % 1000 + 1000 * a; else if ((*it) < 100000) (*it) = (*it) % 10000 + 10000 * a; else if ((*it) < 1000000) (*it) = (*it) % 100000 + 100000 * a; else if ((*it) < 10000000) (*it) = (*it) % 1000000 + 1000000 * a; else if ((*it) < 100000000) (*it) = (*it) % 10000000 + 10000000 * a; } void clear() { data.clear(); } long long t() { if (data.size() == 1) return *data.begin(); else { list<int>::iterator it = data.begin(), jt = data.begin(); ++it; return (long long)(*it) * 100000000 + (*jt); } } int size() { list<int>::iterator it; int res = 0; for (it = data.begin(); it != data.end(); it++) res += 8; it--; if (*it >= 10000) { if ((*it) >= 1000000) { if (*it >= 10000000) ; else res--; } else { if ((*it) >= 100000) res -= 2; else res -= 3; } } else if ((*it) >= 100) { if (*it >= 1000) res -= 4; else res -= 5; } else { if ((*it) >= 10) res -= 6; else res -= 7; } return res; } void do_reserve(int a) { if (a <= 0) return; list<int>::iterator it; for (it = data.begin(); it != data.end() && a > 0; it++) a -= 8; if (it == data.end() && a >= 0) return; a += 8, it--; int f = 1; for (int i = 0; i < a; i++) f *= 10; (*it) %= f; data.erase(++it, data.end()); do_trim(); } void output() { list<int>::reverse_iterator i = data.rbegin(); printf( %d , *i); for (i++; i != data.rend(); i++) printf( %08d , *i); } }; inline void bignum::operator=(const bignum a) { data.clear(); for (list<int>::const_iterator i = a.data.begin(); i != a.data.end(); i++) { data.push_back(*i); } } inline void bignum::operator=(const string a) { (*this) = bignum(a); } inline void bignum::operator=(const int a) { (*this) = bignum(a); } inline istream &operator>>(istream &input, bignum &a) { string s; int t, i; input >> s; a.data.clear(); for (i = int(s.size()) - 8; i > 0; i -= 8) { istringstream(s.substr(i, 8)) >> t; a.data.push_back(t); } istringstream(s.substr(0, i + 8)) >> t; a.data.push_back(t); return input; } inline ostream &operator<<(ostream &output, const bignum &a) { list<int>::const_reverse_iterator i = a.data.rbegin(); output << *i; for (i++; i != a.data.rend(); i++) { if (*i >= 10000) { if (*i >= 1000000) { if (*i >= 10000000) cout << *i; else cout << 0 << *i; } else { if (*i >= 100000) cout << 00 << *i; else cout << 000 << *i; } } else { if (*i >= 100) { if (*i >= 1000) cout << 0000 << *i; else cout << 00000 << *i; } else { if (*i >= 10) cout << 000000 << *i; else cout << 0000000 << *i; } } } return output; } inline bool bignum::undefined() { return data.empty(); } inline int do_comp(const bignum &a, const bignum &b) { if (a.data.size() < b.data.size()) return -1; if (a.data.size() > b.data.size()) return 1; list<int>::const_reverse_iterator i; list<int>::const_reverse_iterator j; for (i = a.data.rbegin(), j = b.data.rbegin(); j != b.data.rend(); i++, j++) { if (*i < *j) return -1; if (*i > *j) return 1; } return 0; } inline int do_comp(const bignum &a, const int &b) { return do_comp(a, bignum(b)); } inline bool operator==(const bignum &a, const bignum &b) { return do_comp(a, b) == 0; } inline bool operator!=(const bignum &a, const bignum &b) { return do_comp(a, b) != 0; } inline bool operator<(const bignum &a, const bignum &b) { return do_comp(a, b) == -1; } inline bool operator>(const bignum &a, const bignum &b) { return do_comp(a, b) == 1; } inline bool operator<=(const bignum &a, const bignum &b) { return do_comp(a, b) != 1; } inline bool operator>=(const bignum &a, const bignum &b) { return do_comp(a, b) != -1; } inline bool operator==(const bignum &a, const int &b) { return do_comp(a, b) == 0; } inline bool operator!=(const bignum &a, const int &b) { return do_comp(a, b) != 0; } inline bool operator<(const bignum &a, const int &b) { return do_comp(a, b) == -1; } inline bool operator>(const bignum &a, const int &b) { return do_comp(a, b) == 1; } inline bool operator<=(const bignum &a, const int &b) { return do_comp(a, b) != 1; } inline bool operator>=(const bignum &a, const int &b) { return do_comp(a, b) != -1; } inline void bignum::do_trim() { while (data.size() > 1 && data.back() == 0) data.pop_back(); } inline bignum &bignum::operator+=(const bignum &a) { list<int>::iterator i; list<int>::const_iterator j; int t = 0; for (i = data.begin(), j = a.data.begin(); i != data.end() && j != a.data.end(); i++, j++) { *i += *j + t; t = *i / 100000000; *i %= 100000000; } while (i != data.end()) { *i += t; t = *i / 100000000; *i %= 100000000; i++; } while (j != a.data.end()) { data.push_back(t + *j); t = data.back() / 100000000; data.back() %= 100000000; j++; } if (t != 0) data.push_back(t); return *this; } inline bignum &bignum::operator-=(const bignum &a) { list<int>::iterator i; list<int>::const_iterator j; int t = 0; for (i = data.begin(), j = a.data.begin(); j != a.data.end(); i++, j++) { *i -= t + *j; if (*i >= 0) t = 0; else *i += 100000000, t = 1; } while (i != data.end()) { *i -= t; if (*i >= 0) t = 0; else *i += 100000000, t = 1; i++; } (*this).do_trim(); return *this; } inline bignum &bignum::operator+=(const int &a) { return (*this) += bignum(a); } inline bignum &bignum::operator-=(const int &a) { return (*this) -= bignum(a); } inline bignum operator+(const bignum &a, const bignum &b) { list<int>::const_iterator i, j; bignum c; int t = 0; for (i = a.data.begin(), j = b.data.begin(); i != a.data.end() && j != b.data.end(); i++, j++) { c.data.push_back(t + *i + *j); t = c.data.back() / 100000000; c.data.back() %= 100000000; } while (i != a.data.end()) { c.data.push_back(t + *i); t = c.data.back() / 100000000; c.data.back() %= 100000000; i++; } while (j != b.data.end()) { c.data.push_back(t + *j); t = c.data.back() / 100000000; c.data.back() %= 100000000; j++; } if (t != 0) c.data.push_back(t); return c; } inline bignum operator-(const bignum &a, const bignum &b) { list<int>::const_iterator i, j; bignum c; int t = 0; for (i = a.data.begin(), j = b.data.begin(); j != b.data.end(); i++, j++) { t = *i - t; if (t >= *j) c.data.push_back(t - *j), t = 0; else c.data.push_back(t + 100000000 - *j), t = 1; } while (i != a.data.end()) { t = *i - t; if (t >= 0) c.data.push_back(t), t = 0; else c.data.push_back(t + 100000000), t = 1; i++; } c.do_trim(); return c; } inline bignum operator*(const bignum &a, const bignum &b) { list<int>::const_iterator i, j; list<int>::iterator k, kk; bignum c; long long t = 0; for (int i = 0; i < a.data.size() + b.data.size(); i++) c.data.push_back(0); for (i = a.data.begin(), k = c.data.begin(); i != a.data.end(); i++, k++) { for (j = b.data.begin(), kk = k; j != b.data.end(); j++, kk++) { t += (long long)(*i) * (*j) + (*kk); *kk = int(t % 100000000); t /= 100000000; } *kk += t; t = 0; } c.do_trim(); return c; } inline int bignum::do_try(const bignum &a) { int l = 1, r = 99999999, m, t; while (l + 2 < r) { m = (l + r) / 2; t = do_comp(*this, a * bignum(m)); if (t == 0) return m; if (t < 0) r = m - 1; else l = m; } while (do_comp(*this, a * bignum(r)) < 0) r--; return r; } inline void divide(const bignum &a, const bignum &b, bignum &d, bignum &r) { list<int>::const_reverse_iterator i = a.data.rbegin(); int t; d = bignum(0); r = bignum(0); do { while (r < b && i != a.data.rend()) { d.data.push_front(0); r.data.push_front(*i); r.do_trim(); i++; } if (r >= b) { t = r.do_try(b); d.data.front() = t; r -= (b * bignum(t)); } } while (i != a.data.rend()); d.do_trim(); } inline bignum operator/(const bignum &a, const bignum &b) { bignum d, r; divide(a, b, d, r); return d; } inline bignum operator%(const bignum &a, const bignum &b) { bignum d, r; divide(a, b, d, r); return r; } inline bignum operator+(const bignum &a, const int &b) { return a + bignum(b); } inline bignum operator-(const bignum &a, const int &b) { return a - bignum(b); } inline bignum operator*(const bignum &a, const int &b) { return a * bignum(b); } inline bignum operator/(const bignum &a, const int &b) { return a / bignum(b); } inline bignum &bignum::operator*=(const bignum &a) { (*this) = (*this) * a; return *this; } inline bignum &bignum::operator/=(const bignum &a) { (*this) = (*this) / a; return *this; } inline bignum &bignum::operator%=(const bignum &a) { (*this) = (*this) % a; return *this; } inline bignum &bignum::operator*=(const int &a) { return (*this) *= bignum(a); } inline bignum &bignum::operator/=(const int &a) { return (*this) /= bignum(a); } inline bignum &bignum::operator%=(const long long &b) { return (*this) %= bignum(b); } inline bignum pow(bignum a, int b) { bignum c(1); while (b != 0) { if (b & 1) c *= a; a = a * a; b >>= 1; } return c; } inline int rand32() { return (bool(rand() & 1) << 30) | (rand() << 15) + rand(); } inline int random32(int l, int r) { return rand32() % (r - l + 1) + l; } inline int random(int l, int r) { return rand() % (r - l + 1) + l; } int dice() { return rand() % 6; } bool coin() { return rand() % 2; } template <class T> inline void RD(T &x) { char c; for (c = getchar(); c < 0 ; c = getchar()) ; x = c - 0 ; for (c = getchar(); c >= 0 ; c = getchar()) x = x * 10 + c - 0 ; } template <class T> inline void OT(const T &x) { printf( %d n , x); } const int maxn = 2; long long modo; class Mat { public: int Matn, Matm; long long a[maxn][maxn]; Mat() { Matn = 0; Matm = 0; memset(a, 0, sizeof(a)); } void output(); void init(); void initI(); Mat mul(const Mat &a); Mat power(const Mat &a, long long k); }; void Mat::output() { for (int i = 0; i < Matn; ++i) { for (int j = 0; j < Matm; ++j) { if (j != 0) printf( ); printf( %d , a[i][j]); } printf( n ); } } void Mat::init() { Matn = 0; Matm = 0; memset(a, 0, sizeof(a)); } Mat Mat::mul(const Mat &A) { Mat c; c.Matn = Matn; c.Matm = A.Matm; for (int i = 0; i < Matn; ++i) for (int j = 0; j < A.Matm; ++j) { for (int k = 0; k < Matm; ++k) { c.a[i][j] = (c.a[i][j] + (a[i][k] * A.a[k][j]) % modo) % modo; } } return c; } void Mat::initI() { memset(a, 0, sizeof(a)); for (int i = 0; i < Matn; ++i) a[i][i] = 1LL; } Mat Mat::power(const Mat &a, long long k) { Mat c = a, b; b.init(); b.Matn = a.Matn; b.Matm = a.Matm; b.initI(); while (k) { if (k & 1LL) b = b.mul(c); c = c.mul(c); k >>= 1LL; } return b; } long long gao(long long t) { if (t <= 1) return 1LL; Mat a; a.Matm = a.Matn = 2; a.a[0][0] = 1LL, a.a[1][0] = 1LL, a.a[0][1] = 1LL; a = a.power(a, t - 1LL); return a.a[0][0]; } long long l, r, k; void solve() { long long tmp, ans, tmp1; if ((r - l) / k <= 2000000) { for (long long i = (r - l) / (k - 1); i >= (r - l) / k; i--) { if ((r / i - (l - 1) / i) >= k) { ans = i; break; } } } else { for (long long i = k - 1; i <= 2000000; i++) { tmp = r / i; tmp1 = tmp * (i - k + 1); if (tmp1 >= l) { ans = tmp; break; } } } cout << gao(ans) % modo << endl; } int main() { while (cin >> modo >> l >> r >> k) solve(); }
#include <bits/stdc++.h> using namespace std; int n, a[1005]; bool t[1005]; int main() { scanf( %d , &n); for (int i = 0; i < n; i++) scanf( %d , &a[i]); memset(t, 0, sizeof(t)); int count = 0; int taken = 0; bool right = true; while (1) { if (right) { for (int i = 0; i < n; i++) { if (taken >= a[i] && !t[i]) { t[i] = true; taken++; } } } else { for (int i = n - 1; i >= 0; i--) { if (taken >= a[i] && !t[i]) { t[i] = true; taken++; } } } if (taken == n) break; count++; right = !right; } printf( %d n , count); return 0; }
#include <bits/stdc++.h> using namespace std; int N, speed, limit, t6, ans; stack<int> st; int main() { cin >> N; for (int t, i = 1; i <= N; i++) { scanf( %d , &t); if (t == 6) { t6++; } else if (t == 4) { t6 = 0; } else if (t == 2) { ans += t6; t6 = 0; } else if (t == 1) { scanf( %d , &speed); while (!st.empty() && speed > st.top()) { ans++; st.pop(); } } else if (t == 5) { while (!st.empty()) st.pop(); } else if (t == 3) { scanf( %d , &limit); st.push(limit); while (!st.empty() && speed > st.top()) { ans++; st.pop(); } } } cout << ans; return 0; }
#include <bits/stdc++.h> using namespace std; int n, t, dp[20][4][4][11][11]; int main() { scanf( %d%d , &n, &t); memset(dp, 0, sizeof(dp)); for (int i = 0; i != 4; ++i) for (int j = 0; j != 4; ++j) dp[1][i][j][0][0] = i != j; for (int i = 2; i != n; ++i) for (int j = 0; j != 4; ++j) for (int k = 0; k != 4; ++k) for (int l = 0; l <= t; ++l) for (int m = 0; m <= t; ++m) for (int o = 0; o != 4; ++o) dp[i][k][o][l + (j < k && k > o)][m + (j > k && k < o)] += k == o ? 0 : dp[i - 1][j][k][l][m]; int ans = 0; for (int i = 0; i != 4; ++i) for (int j = 0; j != 4; ++j) ans += dp[n - 1][i][j][t][t - 1]; printf( %d n , ans); return 0; }
#include <bits/stdc++.h> using namespace std; const long long INF = 0x3f3f3f3f; const int N = 2e5 + 10; const int M = 1e6 + 10; const long long mod = 1e9 + 7; const double PI = acos(-1); int sq = 3000; int cntq, cntc; map<int, int> mp; int vis[N]; int cnt[N]; int num[N]; int ans[N]; struct query { int l, r, z, id; } qq[N]; struct change { int x, y; } ch[N]; bool cmp1(query a, query b) { if (a.l / sq == b.l / sq) { if (a.r / sq == b.r / sq) return a.z < b.z; else return a.r < b.r; } else return a.l < b.l; } void update(int x, int y) { vis[cnt[num[x]]]--; cnt[num[x]] += y; vis[cnt[num[x]]]++; } void solve() { int l = 1, r = 1, c = 0, res; update(1, 1); for (int i = 1; i <= cntq; ++i) { while (r < qq[i].r) update(++r, 1); while (r > qq[i].r) update(r--, -1); while (l > qq[i].l) update(--l, 1); while (l < qq[i].l) update(l++, -1); while (c > qq[i].z) { if (ch[c].x >= l && ch[c].x <= r) update(ch[c].x, -1); swap(ch[c].y, num[ch[c].x]); if (ch[c].x >= l && ch[c].x <= r) update(ch[c].x, 1); c--; } while (c < qq[i].z) { c++; if (ch[c].x >= l && ch[c].x <= r) update(ch[c].x, -1); swap(ch[c].y, num[ch[c].x]); if (ch[c].x >= l && ch[c].x <= r) update(ch[c].x, 1); } res = 1; while (vis[res]) res++; ans[qq[i].id] = res; } } int main() { int n, q, tot = 0, x, op, l, r; scanf( %d%d , &n, &q); for (int i = 1; i <= n; ++i) { scanf( %d , &x); if (mp[x]) num[i] = mp[x]; else num[i] = mp[x] = ++tot; } for (int i = 1; i <= q; ++i) { scanf( %d%d%d , &op, &l, &r); if (op == 1) { ++cntq; qq[cntq] = {l, r, cntc, cntq}; } else { ++cntc; if (mp[r]) r = mp[r]; else r = mp[r] = ++tot; ch[cntc] = {l, r}; } } sort(qq + 1, qq + cntq + 1, cmp1); solve(); for (int i = 1; i <= cntq; ++i) printf( %d n , ans[i]); return 0; }
#include <bits/stdc++.h> using namespace std; vector<vector<int> > solve(int N) { vector<vector<int> > res(2, vector<int>(1, 1)); for (int n = 2, r = 0; n <= N; ++n) { res[r].push_back(n); ++r; if (r >= int((res).size())) { vector<int> new_row; for (const vector<int>& r : res) new_row.push_back(r.back()); res.push_back(new_row); r = 0; } } return res; } int main(int argc, char* argv[]) { ios_base::sync_with_stdio(false); cin.tie(nullptr); int N; cin >> N; vector<vector<int> > res = solve(N); cout << int((res).size()) << n ; for (const vector<int>& row : res) { for (int x : row) cout << x << ; cout << n ; } return 0; }
#include <bits/stdc++.h> using namespace std; const int MAXN = 505; int n, m; int v[MAXN]; int head[MAXN]; double e[MAXN * MAXN]; int a, b, c; int main() { while (scanf( %d%d , &n, &m) != EOF) { for (int i = 1; i <= n; i++) scanf( %d , &v[i]); for (int i = 1; i <= m; i++) { scanf( %d%d%d , &a, &b, &c); e[i] = 1.0 * (v[a] + v[b]) / c; } double ans = 0.0; for (int i = 1; i <= m; i++) ans = max(ans, e[i]); printf( %.12lf n , ans); } return 0; }
#include <bits/stdc++.h> using namespace std; struct debugger { template <typename T> debugger& operator,(const T& v) { cerr << v << ; return *this; } } debug1; template <typename T1, typename T2> inline ostream& operator<<(ostream& os, const pair<T1, T2>& p) { return os << ( << p.first << , << p.second << ) ; } template <typename T> inline ostream& operator<<(ostream& os, const vector<T>& v) { bool first = true; os << [ ; for (typename vector<T>::const_iterator ii = v.begin(); ii != v.end(); ++ii) { if (!first) os << , ; os << *ii; first = false; } return os << ] ; } const long long inf = numeric_limits<long long>::min(); const int NN = 112345; long long dp[NN][3], cnt[NN]; bool vis[NN][3]; long long f(int x, int last) { last = ((cnt[x - 1] == 0 and last == 0) ? 2 : last); if (cnt[x] == 0 and last == 0) return inf; if (x > 100000) return 0LL; if (vis[x][last]) return dp[x][last]; vis[x][last] = true; long long ans = 0; if (last == 0) { ans = cnt[x] * (long long)x; ans += f(x + 1, 1); } else if (last == 1) ans = f(x + 1, 2); else { ans = max(ans, f(x + 1, 0)); if (cnt[x] > 0) { long long add = cnt[x] * (long long)x; ans = max(ans, add + f(x + 1, 1)); } } dp[x][last] = ans; return ans; } void solve() { int n, num; cin >> n; for (int i = 0; i < n; ++i) { cin >> num; cnt[num]++; } long long ans = f(1, 2); cout << ans << n ; } int main() { solve(); return 0; }
#include <bits/stdc++.h> using namespace std; signed main() { ios_base::sync_with_stdio(false); cin.tie(0); int n, m, a, b; cin >> n >> m >> a >> b; int ans = 3; if (a % m == 1 && b % m == 0) { ans = min(ans, 1); } if (a % m == 1 || b % m == 0) { ans = min(ans, 2); } int bf = (a - 1) / m; int bs = (b - 1) / m; if (bf == bs) { ans = min(ans, 1); } if (bf + 1 == bs) { ans = min(ans, 2); } if (a % m == 1 && b == n) { ans = min(ans, 1); } if (b == n) { ans = min(ans, 2); } int p1 = (a - 1) % m; int p2 = (b - 1) % m; if (p1 == p2 + 1) { ans = min(ans, 2); } if (m == 1) { ans = min(ans, 1); } cout << ans; }
#include <bits/stdc++.h> using namespace std; const int N = 2e5; vector<int> g[N]; int deg[N]; int cnt[N]; void dfs(int v, int &l) { for (int i = 0; i < g[v].size(); i++) { cnt[g[v][i]] = l + 1; l++; dfs(g[v][i], l); l--; } } int main() { ios_base::sync_with_stdio(), cout.tie(NULL), cin.tie(NULL); ; int n; cin >> n; for (int i = 1; i <= n; i++) { cin >> deg[i]; if (deg[i] != -1) { g[deg[i]].push_back(i); } } int ans = 1; for (int i = 1; i <= n; i++) { if (deg[i] == -1) { int level = 1; dfs(i, level); } } for (int i = 1; i <= n; i++) { ans = max(ans, cnt[i]); } cout << ans << endl; }
#include <bits/stdc++.h> using namespace std; template <class T> inline bool getmin(T *a, const T &b) { if (b < *a) { *a = b; return true; } return false; } template <class T> inline bool getmax(T *a, const T &b) { if (b > *a) { *a = b; return true; } return false; } template <class T> inline void read(T *a) { char c; while (isspace(c = getchar())) { } bool flag = 0; if (c == - ) flag = 1, *a = 0; else *a = c - 48; while (isdigit(c = getchar())) *a = *a * 10 + c - 48; if (flag) *a = -*a; } const int mo = 1000000007; template <class T> T pow(T a, T b, int c = mo) { T res = 1; for (T i = 1; i <= b; i <<= 1, a = 1LL * a * a % c) if (b & i) res = 1LL * res * a % c; return res; } const int N = 100100; int n; int a[N]; int s1[N], s2[N]; pair<int, int> ans[N]; int check(int x) { int j = 0, i = 1, num1 = 0, num2 = 0, last = 0; while (i <= n) { int l = i, r = n, res = 0; while (l <= r) { int mid = (l + r) >> 1; if (max(s1[mid] - s1[j], s2[mid] - s2[j]) >= x) res = mid, r = mid - 1; else l = mid + 1; } if (!res) return 0; if (s1[res] - s1[j] == x) ++num1, last = 1; else ++num2, last = 2; j = res, i = res + 1; } if (num1 > num2 && last == 1) return num1; else if (num2 > num1 && last == 2) return num2; return 0; } int main() { cin >> n; for (int i = (1); i <= (n); ++i) { read(a + i); s1[i] = s1[i - 1] + (a[i] == 1); s2[i] = s2[i - 1] + (a[i] == 2); } int m = 0; for (int i = (1); i <= (n); ++i) { int z = check(i); if (z) ans[++m] = std::make_pair(z, i); } sort(ans + 1, ans + m + 1); cout << m << endl; for (int i = (1); i <= (m); ++i) printf( %d %d n , ans[i].first, ans[i].second); return 0; }
#include <bits/stdc++.h> using namespace std; const int inf = 1e9; int n, m, dis[55][55], fast[55], slow[55], g1, g2, s1, s2; long long f[55][55][55]; bool cang[55], cans[55], canb[55]; long long work(int g, int b, int su, int sd) { memset(f, 0, sizeof(f)); memset(cang, false, sizeof(cang)); memset(cans, false, sizeof(cans)); memset(canb, false, sizeof(canb)); for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { if (i == j) { continue; } if (dis[i][j] <= g) { cang[i] = true; } if (dis[i][j] > su && dis[i][j] < sd) { cans[i] = true; } if (dis[i][j] >= b) { canb[i] = true; } } } f[0][0][0] = 1; for (int i = 1; i <= n; i++) { for (int j = 0; j <= i; j++) { for (int k = 0; j + k <= i; k++) { if (cang[i]) { f[i][j + 1][k] += f[i - 1][j][k]; } if (cans[i]) { f[i][j][k + 1] += f[i - 1][j][k]; } if (canb[i]) { f[i][j][k] += f[i - 1][j][k]; } } } } long long res = 0; for (int i = g1; i <= g2; i++) { for (int j = s1; j <= s2; j++) { res += f[n][i][j]; } } return res; } int main() { scanf( %d%d , &n, &m); for (int i = 1; i < n; i++) { for (int j = i + 1; j <= n; j++) { dis[i][j] = dis[j][i] = inf; } } for (int i = 0; i < m; i++) { int x, y, w; scanf( %d%d%d , &x, &y, &w); dis[x][y] = dis[y][x] = w; } scanf( %d%d%d%d , &g1, &g2, &s1, &s2); for (int k = 1; k <= n; k++) { for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]); } } } for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { if (dis[i][j] < inf) { dis[i][j] = dis[i][j] * n + i; } } } for (int i = 1; i <= n; i++) { fast[i] = inf; slow[i] = -inf; for (int j = 1; j <= n; j++) { if (i == j) { continue; } fast[i] = min(fast[i], dis[i][j]); slow[i] = max(slow[i], dis[i][j]); } } long long ans = 0; for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { ans += work(fast[i], slow[j], fast[i], slow[j]) - work(fast[i] - 1, slow[j], fast[i], slow[j]) - work(fast[i], slow[j] + 1, fast[i], slow[j]) + work(fast[i] - 1, slow[j] + 1, fast[i], slow[j]); } } cout << ans << endl; return 0; }
#include <bits/stdc++.h> using namespace std; stack<int> S; int n, m, q, x, y; struct rs_tree { int hed[200005], ver[600005], nxt[600005], tot, cnt; int dep[200005], fa[200005], top[200005], siz[200005], son[200005]; void push(int x, int y) { ver[++tot] = y; nxt[tot] = hed[x]; hed[x] = tot; } void dfs1(int now, int en) { dep[now] = dep[en] + 1; fa[now] = en; for (int i = hed[now]; i; i = nxt[i]) { if (ver[i] == en) continue; dfs1(ver[i], now); if (son[now] == 0 || siz[son[now]] < siz[ver[i]]) son[now] = ver[i]; siz[now] += siz[ver[i]]; } return; } void dfs2(int now, int TOP) { top[now] = TOP; if (son[now]) dfs2(son[now], TOP); for (int i = hed[now]; i; i = nxt[i]) { if (ver[i] == fa[now] || ver[i] == son[now]) continue; dfs2(ver[i], ver[i]); } return; } int find_lca(int x, int y) { int sum = dep[x] + dep[y]; while (top[x] != top[y]) { if (dep[top[x]] < dep[top[y]]) swap(x, y); x = fa[top[x]]; } if (dep[x] > dep[y]) swap(x, y); sum -= (2 * dep[x] - 1); return sum >> 1; } } RST; struct graph { int hed[100005], ver[1000005], nxt[1000005], tot; int dfn[100005], low[100005], num, cnt, vis[100005]; void push(int x, int y) { ver[++tot] = y; nxt[tot] = hed[x]; hed[x] = tot; } void dfs(int now, int en) { S.push(now); dfn[now] = low[now] = ++cnt; vis[now] = 1; for (int i = hed[now]; i; i = nxt[i]) { if (!dfn[ver[i]]) { dfs(ver[i], now); low[now] = min(low[now], low[ver[i]]); if (low[ver[i]] >= dfn[now]) { num++; int z; do { z = S.top(); S.pop(); RST.push(z, num); RST.push(num, z); vis[z] = 0; } while (z != ver[i]); RST.push(now, num); RST.push(num, now); } } else if (vis[ver[i]]) low[now] = min(low[now], dfn[ver[i]]); } } void tarjan() { num = n; cnt = 0; dfs(1, 0); } } G; int main() { scanf( %d%d%d , &n, &m, &q); for (int i = 1; i <= m; i++) { scanf( %d%d , &x, &y); G.push(x, y); G.push(y, x); } G.tarjan(); RST.dfs1(1, 0); RST.dfs2(1, 1); for (int i = 1; i <= q; i++) { scanf( %d%d , &x, &y); printf( %d n , RST.find_lca(x, y)); } return 0; }
#include <bits/stdc++.h> using namespace std; long long i, j, m, n, p, q, r, ans, l, ch = 1; string s; int f; vector<long long> v; int main() { cin >> s; l = s.size(); f = s.find( bear , 0); while (f >= 0) { p = f + 1; ch = abs(p - ch) + 1; q = p + 3; r = (l - q) + 1; ans += (r * ch); ch = p + 1; f = s.find( bear , ch); } cout << ans; }
#include <bits/stdc++.h> using namespace std; inline long long read() { long long num = 0, neg = 1; char c = getchar(); while (!isdigit(c)) { if (c == - ) neg = -1; c = getchar(); } while (isdigit(c)) { num = (num << 3) + (num << 1) + c - 0 ; c = getchar(); } return num * neg; } const long long mod = 998244353; long long n, a[100010], m, g[300010], f[300010], ans; inline long long qpow(long long x, long long k) { long long res = 1; while (k) { if (k & 1) res = res * x % mod; x = x * x % mod; k >>= 1; } return res; } int main() { n = read(); g[0] = n - 1; for (int i = 1; i <= n; i++) a[i] = read(), m += a[i]; for (int i = 1; i <= m; i++) g[i] = (m * (n - 1) % mod + (n - 1) * i % mod * g[i - 1] % mod) % mod * qpow(m - i, mod - 2) % mod; f[m] = g[m]; for (int i = m - 1; i >= 0; i--) f[i] = (f[i + 1] + g[i]) % mod; for (int i = 1; i <= n; i++) ans = (ans + f[a[i]]) % mod; ans = (ans - ((n - 1) * f[0] % mod) + mod) % mod; printf( %lld n , ans * qpow(n, mod - 2) % mod); return 0; }
#include <bits/stdc++.h> using namespace std; const double EPS = 1e-8; const int maxn = 105; int n, m, a, b, c; char mat[maxn][maxn]; void draw(int x, int y, char c) { mat[x][y] = mat[x + 1][y] = mat[x][y + 1] = mat[x + 1][y + 1] = c; } void gao() { if (n * m % 2 == 1) { puts( IMPOSSIBLE ); return; } int tot = a * 2 + b * 2 + c * 4; if (tot < n * m) { puts( IMPOSSIBLE ); return; } int i, j, k; memset(mat, 0, sizeof mat); for (i = 0; i < n / 2; ++i) { int x0 = i * 2; if (i % 2 == 0) { for (j = 0; j < m / 2; ++j) { int y0 = j * 2; draw(x0, y0, j % 2 == 1 ? a : b ); --c; } } else { for (j = 0; j < m / 2; ++j) { int y0 = j * 2; draw(x0, y0, j % 2 == 1 ? c : d ); --c; } } } if (n % 2 == 1 || m % 2 == 1) { if (n % 2 == 1) { for (i = 0; i < m / 2; ++i) { mat[n - 1][i * 2] = mat[n - 1][i * 2 + 1] = (i % 2 ? e : f ); --a; } } else { for (i = 0; i < n / 2; ++i) { mat[i * 2][m - 1] = mat[i * 2 + 1][m - 1] = (i % 2 ? e : f ); --b; } } } bool flg = 1; if (c < 0) { for (i = 0; i < n / 2 && c < 0; ++i) { int x0 = i * 2; if (i % 2 == 0) { for (j = 0; j < m / 2 && c < 0; ++j) { int y0 = j * 2; if (a > b) { a -= 2; if (j % 2 == 1) { mat[x0][y0] = mat[x0][y0 + 1] = g ; mat[x0 + 1][y0] = mat[x0 + 1][y0 + 1] = h ; } else { mat[x0][y0] = mat[x0][y0 + 1] = x ; mat[x0 + 1][y0] = mat[x0 + 1][y0 + 1] = y ; } ++c; } else { b -= 2; if (j % 2 == 1) { mat[x0][y0] = mat[x0 + 1][y0] = g ; mat[x0][y0 + 1] = mat[x0 + 1][y0 + 1] = h ; } else { mat[x0][y0] = mat[x0 + 1][y0] = x ; mat[x0][y0 + 1] = mat[x0 + 1][y0 + 1] = y ; } ++c; } } } else { for (j = 0; j < m / 2 && c < 0; ++j) { int y0 = j * 2; if (a > b) { a -= 2; if (j % 2 == 1) { mat[x0][y0] = mat[x0][y0 + 1] = i ; mat[x0 + 1][y0] = mat[x0 + 1][y0 + 1] = j ; } else { mat[x0][y0] = mat[x0][y0 + 1] = k ; mat[x0 + 1][y0] = mat[x0 + 1][y0 + 1] = l ; } ++c; } else { b -= 2; if (j % 2 == 1) { mat[x0][y0] = mat[x0 + 1][y0] = i ; mat[x0][y0 + 1] = mat[x0 + 1][y0 + 1] = j ; } else { mat[x0][y0] = mat[x0 + 1][y0] = k ; mat[x0][y0 + 1] = mat[x0 + 1][y0 + 1] = l ; } ++c; } } } } } if (a < 0 || b < 0 || c < 0) puts( IMPOSSIBLE ); else for (i = 0; i < n; ++i) puts(mat[i]); } int main() { while (cin >> n >> m >> a >> b >> c) { gao(); } return 0; }
#include <bits/stdc++.h> const int pi = acos(-1); const long long MOD = 1000000007; const int M = 100005; const int N = 1000006; using namespace std; int n, m, x, y, ans; string s; char a[55][55]; bool vis[55][55]; vector<string> v; void calc(int i, string s) { if (i == 4) { v.push_back(s); return; } bool u = 0, d = 0, l = 0, r = 0; for (int i = 0; i < s.size(); i++) { if (s[i] == u ) u = 1; if (s[i] == d ) d = 1; if (s[i] == l ) l = 1; if (s[i] == r ) r = 1; } if (!u) calc(i + 1, s + u ); if (!d) calc(i + 1, s + d ); if (!l) calc(i + 1, s + l ); if (!r) calc(i + 1, s + r ); } int bfs(string k) { map<char, char> lol; lol[ 0 ] = k[0]; lol[ 1 ] = k[1]; lol[ 2 ] = k[2]; lol[ 3 ] = k[3]; queue<pair<int, pair<int, int> > > q; q.push(make_pair(0, make_pair(x, y))); while (!q.empty()) { int x = q.front().second.first; int y = q.front().second.second; int i = q.front().first; q.pop(); if (x < 0 || x >= n || y < 0 || y >= m) return 0; if (a[x][y] == # ) return 0; if (a[x][y] == E ) return 1; if (i >= s.size()) return 0; char lel = lol[s[i]]; if (lel == d ) q.push(make_pair(i + 1, make_pair(x + 1, y))); if (lel == u ) q.push(make_pair(i + 1, make_pair(x - 1, y))); if (lel == r ) q.push(make_pair(i + 1, make_pair(x, y + 1))); if (lel == l ) q.push(make_pair(i + 1, make_pair(x, y - 1))); } return 0; } int main() { cin >> n >> m; for (int i = 0; i < n; i++) scanf( %s , a[i]); cin >> s; calc(0, ); for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) if (a[i][j] == S ) { x = i; y = j; } for (int i = 0; i < v.size(); i++) ans += bfs(v[i]); cout << ans; return 0; }
#include <bits/stdc++.h> using namespace std; using namespace std; bool solve(int); int main() { int test = 0; while (solve(test++)) ; return 0; } const int N = 100 * 1000 + 5; const int INF = int(1e9); int n, b, m; pair<int, int> a[N]; struct edge { int to, f, c, rev; }; const int V = 1000 * 1000 + 3; vector<edge> g[V]; int lev[V]; int head, tail, q[V]; inline bool bfs(int s, int t) { memset(lev, 63, sizeof(lev)); head = tail = 0; lev[s] = 0; q[head++] = s; while (head != tail) { int v = q[tail++]; for (int i = 0; i < int(int(g[v].size())); ++i) if (g[v][i].f < g[v][i].c && lev[g[v][i].to] > lev[v] + 1) { lev[g[v][i].to] = lev[v] + 1; q[head++] = g[v][i].to; } } return lev[t] < INF / 2; } inline void add(int from, int to, int c) { edge f = {to, 0, c, int(g[to].size())}; edge b = {from, 0, 0, int(g[from].size())}; g[from].push_back(f); g[to].push_back(b); } int ptr[V]; int dfs(int v, int t, int f) { if (v == t) return f; for (; ptr[v] < int(g[v].size()); ptr[v]++) { edge& e = g[v][ptr[v]]; if (e.f == e.c || lev[e.to] != lev[v] + 1) continue; int df = dfs(e.to, t, min(f, e.c - e.f)); if (df > 0) { e.f += df; g[e.to][e.rev].f -= df; return df; } } return 0; } inline int dinic(int s, int t) { int ans = 0; while (bfs(s, t)) { memset(ptr, 0, sizeof(ptr)); for (int f; (f = dfs(s, t, INF)) != 0; ans += f) ; } return ans; } int cnt5[N][5]; int calc(int r, int rem) { return cnt5[r][rem]; } bool solve(int) { if (!(cin >> m >> b >> n)) return false; for (int i = 0; i < int(n); ++i) { scanf( %d %d , &a[i].first, &a[i].second); a[i].first++; } a[n++] = pair<int, int>(b + 1, m); a[n++] = pair<int, int>(1, 0); int cv = 5; int S = cv++; int T = cv++; for (int i = 0; i < int(5); ++i) add(i, T, m / 5); for (int i = 0; i < int(N - 1); ++i) { for (int j = 0; j < int(5); ++j) cnt5[i + 1][j] = cnt5[i][j]; cnt5[i + 1][(i + 1) % 5]++; } sort(a, a + n); for (int i = 0; i < int(n - 1); ++i) { int lf = a[i].first; int rg = a[i + 1].first; int cnt = a[i + 1].second - a[i].second; if (rg - lf < cnt || cnt < 0) { puts( unfair ); return true; } if (cnt == 0) continue; int v[5]; for (int i = 0; i < int(5); ++i) { v[i] = calc(rg - 1, i) - calc(lf - 1, i); add(cv, i, v[i]); } add(S, cv, cnt); cv++; } puts(dinic(S, T) == m ? fair : unfair ); return true; }
#include <bits/stdc++.h> using namespace std; int n, m; int a[100]; long long ans; long long getval() { long long val = 0; for (int i = 0; i < n; ++i) { int mn = 100500; for (int j = i; j < n; ++j) { mn = min(mn, a[j]); val += mn; } } return val; } int main() { ios_base::sync_with_stdio(0); cin >> n >> m; for (int i = 0; i < n; ++i) { a[i] = i + 1; } do { long long val = getval(); ans = max(ans, val); } while (next_permutation(a, a + n)); cerr << ans = << ans << n ; do { long long val = getval(); if (val == ans) { if (m == 1) { for (int i = 0; i < n; ++i) { cout << a[i] << ; } cout << n ; return 0; } --m; } } while (next_permutation(a, a + n)); }
#include <bits/stdc++.h> using namespace std; int main() { long long n, t, x, y; long long pos_ji, pos_ou; while (~scanf( %lld%lld , &n, &t)) { while (t--) { scanf( %lld%lld , &x, &y); long long ji = n / 2 * n + (n + 1) / 2 + 1; long long ou = n / 2 * n + 1; pos_ji = (x - 1) * n + y; if (n % 2 != 0) { if (pos_ji % 2 == 0) printf( %lld n , ji + (pos_ji - 1) / 2); else printf( %lld n , (pos_ji + 1) / 2); } else { if (x % 2 != 0 && y % 2 != 0) { printf( %lld n , (x / 2) * n + (y + 1) / 2); } else if (x % 2 != 0 && y % 2 == 0) { printf( %lld n , ou + (x / 2) * n + (y - 1) / 2); } else if (x % 2 == 0 && y % 2 != 0) { printf( %lld n , ou + n / 2 + (x - 2) / 2 * n + y / 2); } else printf( %lld n , n / 2 + (x - 2) / 2 * n + y / 2); } } } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(0); ; int precision = numeric_limits<double>::digits10; ; int n, a, b; cin >> n >> a >> b; cout << (a + b - 1 + 100 * n) % n + 1; }
#include <bits/stdc++.h> using namespace std; int q, tipe, temp, x, k, s; vector<int> v; set<int> cek; int val[100000 + 5]; map<pair<int, pair<int, int> >, int> temp2; int gcd(int a, int b) { if (b == 0) return a; return gcd(b, a % b); } int main() { scanf( %d , &q); while (q--) { scanf( %d , &tipe); if (tipe == 1) { scanf( %d , &temp); if (!val[temp]) { val[temp] = true; cek.insert(temp); temp2.clear(); } } else { scanf( %d %d %d , &x, &k, &s); if (x % k != 0 or x >= s) printf( -1 n ); else { if (temp2[make_pair(x, make_pair(k, s))]) { printf( %d n , temp2[make_pair(x, make_pair(k, s))]); continue; } int xam = -1; int res = -1; auto its = cek.upper_bound(s - x); int it = *its; if (it <= 0 or it < (s - x) / k) { for (auto b = cek.begin(); b != its and (*b) + x <= s; ++b) { if (xam < ((*b) ^ x) and gcd(*b, x) % k == 0) { xam = ((*b) ^ x); res = *b; } } } else { for (int i = k; i <= 100000 and i + x <= s; i += k) { if (val[i] and xam < (i ^ x)) { xam = (i ^ x); res = i; } } } temp2[make_pair(x, make_pair(k, s))] = res; printf( %d n , res); } } } }
#include <bits/stdc++.h> using namespace std; const int MAXN = 200010; pair<double, double> A[MAXN]; int n, r, ord[MAXN], st[MAXN]; bool comp(int a, int b) { if (A[a].first != A[b].first) return A[a].first < A[b].first; return A[a].second < A[b].second; } int ccw(pair<double, double> a, pair<double, double> b, pair<double, double> c) { double tmp = a.first * b.second + b.first * c.second + c.first * a.second - a.second * b.first - b.second * c.first - c.second * a.first; if (tmp > 0) return 1; if (tmp < 0) return -1; return 0; } int main() { scanf( %d , &n); int i, m, ni; for (i = 1; i <= n; i++) scanf( %lf%lf , &A[i].first, &A[i].second); ni = n; scanf( %d , &m); for (i = 1; i <= m; i++) scanf( %lf%lf , &A[n + i].first, &A[n + i].second); n += m; for (i = 1; i <= n; i++) ord[i] = i; sort(ord + 1, ord + n + 1, comp); st[++r] = ord[1]; st[++r] = ord[2]; for (i = 3; i <= n; i++) { while (r >= 2 && ccw(A[st[r - 1]], A[st[r]], A[ord[i]]) > 0) r--; st[++r] = ord[i]; } for (i = n - 1; i >= 1; i--) { while (r >= 2 && ccw(A[st[r - 1]], A[st[r]], A[ord[i]]) > 0) r--; st[++r] = ord[i]; } r--; for (i = 1; i <= r; i++) if (st[i] > ni) { printf( NO n ); return 0; } printf( YES n ); return 0; }
#include <bits/stdc++.h> using namespace std; char s[200001], s1[200001]; int n, m, sum, gang, ans[200001], cnt; int main() { scanf( %s , s1 + 1); m = strlen(s1 + 1); for (int i = 1; i <= m; i++) { if (s1[i] == ( || s1[i] == ) ) s[++n] = s1[i]; if (s1[i] == # ) { s[++n] = ) ; s[++n] = # ; cnt++; } } sum = 0; int now = cnt + 1; for (int i = n; i; i--) { if (s[i] == ) ) { gang++; } if (s[i] == ( ) { if (gang) gang--; else sum++; } if (s[i] == # ) { if (sum > 0) ans[now] = sum; sum = 0; now--; } if ((now > cnt) && (sum > 0)) exit(puts( -1 )); } if (gang) exit(puts( -1 )); ans[now] = sum; sum = 0; for (int i = 1; i <= cnt; i++) printf( %d n , ans[i] + 1); }
#include <bits/stdc++.h> using namespace std; long long n; long long Tree[1000001]; long long arr[200001]; void add(long long x, long long val) { for (; x <= n; x += x & (-x)) Tree[x] += val; return; } long long get(long long x) { long long sum = 0; for (; x > 0; x -= x & (-x)) sum += Tree[x]; return sum; } void solve() { long long x = 1; if (get(1) == 0) { cout << 1 << n ; return; } while (x < n) { long long curr_val = get(x) * 2; if (get(x + 1) == curr_val) { cout << x + 1 << n ; return; } long long lo = x + 1; long long hi = n; long long lo_bound; while (lo <= hi) { if (lo == hi) { lo_bound = lo; break; } long long mi = (lo + hi) / 2; if (get(mi) < curr_val) lo = mi + 1; else hi = mi; } long long k = lo_bound - 1; x = (x == k) ? (k + 1) : k; } cout << -1 << n ; } int main() { ios::sync_with_stdio(false); cin.tie(0); long long q; memset(Tree, 0, sizeof Tree); cin >> n >> q; for (long long i = 1; i <= n; i++) { cin >> arr[i]; add(i, arr[i]); } long long x, y; while (q--) { cin >> x >> y; add(x, y - arr[x]); arr[x] = y; solve(); } return 0; }
#include<bits/stdc++.h> #include<unordered_map> using namespace std; typedef long long ll; typedef vector<ll> vll; const ll M = 1000000007; bool compare(vll x, vll y) { if (x[0] < y[0]) { return true; } return false; } void solve() { vector<vll> v(3); ll n1, n2, n3; cin >> n1 >> n2 >> n3; vll v1(n1), v2(n2), v3(n3); ll f1 = 0, f2 = 0; ll tsum = 0; for (ll i = 0; i < n1; i++) { cin >> v1[i]; tsum += v1[i]; } for (ll i = 0; i < n2; i++) { cin >> v2[i]; tsum += v2[i]; } for (ll i = 0; i < n3; i++) { cin >> v3[i]; tsum += v3[i]; } sort(v1.begin(), v1.end()); sort(v2.begin(), v2.end()); sort(v3.begin(), v3.end()); v[0] = v1; v[1] = v2; v[2] = v3; sort(v.begin(), v.end(), compare); // for (int i = 0; i < 3; i++) { for (int j = 1; j < v[0].size(); j++) { f1 += v[0][j]; } for (int j = 1; j < v[1].size(); j++) { f2 += v[1][j]; } // } ll sub = 0; if (f1 == 0) { sub = 2 * v[0][0]; } else if (f1 > 0 && f2 == 0) { if (v[1][0] > f1) { sub = 2 * v[0][0] + 2 * f1; } else { sub = 2 * v[1][0]; } } else { sub = 2 * min(f2, v[0][0]) + 2 * min(f1, v[1][0]); } if (v[2].size() == 1) { sub = min(sub , 2 * v[2][0]); } cout << tsum - sub << endl; } int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); // This macro supported by cc, cf, cses #ifndef ONLINE_JUDGE freopen( in.txt , r , stdin); freopen( out.txt , w , stdout); #endif // int tt; // cin >> tt; // for(int i = 1; i <= tt; i++) { solve(); // } return 0; }
#include <bits/stdc++.h> using namespace std; const int MOD = 1e9 + 7; int main() { cin.tie(0), cout.tie(0); ios::sync_with_stdio(false); int t; cin >> t; while (t--) { int u = 0, l = 0, d = 0; string s; cin >> s; for (int i = 0; i < s.size(); i++) { if (s[i] >= a && s[i] <= z ) { l++; } if (s[i] >= A && s[i] <= Z ) { u++; } if (s[i] >= 0 && s[i] <= 9 ) { d++; } } for (int i = 0; i < s.size(); i++) { if (s[i] >= a && s[i] <= z && l > 1) { if (!u) { s[i] = A ; u++; } else if (!d) { s[i] = 0 ; d++; } } else if (s[i] >= A && s[i] <= Z && u > 1) { if (!l) { s[i] = a ; l++; } else if (!d) { s[i] = 0 ; d++; } } else if (s[i] >= 0 && s[i] <= 9 && d > 1) { if (!l) { s[i] = a ; l++; } else if (!u) { s[i] = A ; u++; } } } cout << s << endl; } }
#include <bits/stdc++.h> using namespace std; int main() { string s, s2; cin >> s; cin >> s2; vector<char> v, t; for (int i = 0; i < s.length(); i++) { v.push_back(s[i]); } vector<char>::iterator it; int i = 0; for (it = v.end() - 1; it >= v.begin(); it--) { t.push_back(*it); } int cnt = 0, n = s.length(); for (int i = 0; i < n; i++) { if (t[i] == s2[i]) cnt++; } if (cnt == n) cout << YES ; else cout << NO ; return 0; }
#include <bits/stdc++.h> using namespace std; int32_t main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); ; long long n, sum; cin >> n >> sum; long long temp = 0; long long cnt = 0; while (temp < sum) { if (temp + n <= sum) { temp += n; cnt++; } else { n--; } } cout << cnt << n ; ; return 0; }
#include <bits/stdc++.h> namespace competitive_programming { inline namespace utility {} namespace debugging {} namespace io {} } // namespace competitive_programming namespace competitive_programming::utility { class timer { private: std::chrono::time_point<std::chrono::steady_clock> begin, end; public: timer() : begin(), end() {} ~timer() {} }; } // namespace competitive_programming::utility constexpr bool test_cases = true; void yes() { std::cout << YES n ; } void no() { std::cout << NO n ; } auto solve() -> void { int64_t x, y; std::cin >> x >> y; if (x - y < 2) no(); else yes(); } int main() { std::ios::sync_with_stdio(false); std::cin.tie(nullptr); std::cout.precision(10); std::cerr.precision(10); std::cout << std::fixed << std::boolalpha; std::cerr << std::fixed << std::boolalpha; competitive_programming::timer t; int32_t cases = 1; if (test_cases) std::cin >> cases; while (cases--) solve(); return 0; }
#include <bits/stdc++.h> using namespace std; int n, m; string s[2000]; string t[2000]; int main() { cin >> n >> m; for (int i = 0; i < n; i++) cin >> s[i]; for (int j = 0; j < m; j++) { bool flag = true; for (int i = 0; i < n - 1; i++) { if (s[i][j] > s[i + 1][j]) { flag = false; break; } } if (flag) { for (int i = 0; i < n; i++) t[i] += s[i][j]; for (int k = j + 1; k < m; k++) { flag = true; for (int f = 0; f < n - 1; f++) if (t[f] + s[f][k] > t[f + 1] + s[f + 1][k]) { flag = false; break; } if (flag) { for (int f = 0; f < n; f++) t[f] += s[f][k]; } } break; } } cout << m - t[0].length(); return 0; }
#include <bits/stdc++.h> using namespace std; int main() { int t; cin >> t; while (t--) { long long n, m; cin >> n >> m; long long a[n][m], f1 = 0; for (long long i = 0; i < n; i++) { for (long long j = 0; j < m; j++) { cin >> a[i][j]; if (a[i][j] > 4) f1 = 1; } } if (f1) { cout << NO << endl; continue; } for (long long i = 0; i < n; i++) { for (long long j = 0; j < m; j++) { long long c = a[i][j]; if ((i == 0 && j == 0) || (i == 0 && j == m - 1) || (i == n - 1 && j == m - 1) || (i == n - 1 && j == 0)) { if (c > 2) f1 = 1; else a[i][j] = 2; } else if ((i == n - 1 || i == 0 || j == 0 || j == m - 1)) { if (a[i][j] > 3) f1 = 1; else a[i][j] = 3; } else a[i][j] = 4; } } if (f1) { cout << NO << endl; continue; } else { cout << YES << endl; for (long long i = 0; i < n; i++) { for (long long j = 0; j < m; j++) { cout << a[i][j] << ; } cout << endl; } } } return 0; }
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); long long int n, k, i; cin >> n >> k; vector<long long int> num(k + 1); long long int maxi = 1e18; long long int ind = -1; for (i = 1; i <= k; i++) { cin >> num[i]; if (n % num[i] < maxi) { maxi = n % num[i]; ind = i; } } cout << ind << << n / num[ind] << endl; }
#include <bits/stdc++.h> using namespace std; const int sz = 2e5 + 10; int pr[sz], si[sz], ar[sz][3]; bool us[sz]; bool comp(int a, int b) { return ar[a][2] > ar[b][2]; } int find_se(int v) { if (pr[v] == v) return v; else { pr[v] = find_se(pr[v]); return pr[v]; } } void unite(int v, int v2) { if (v != v2) { if (si[v] < si[v2]) swap(v, v2); pr[v2] = v, si[v] += si[v2]; } } int main() { int n, m, an = 0; cin >> n >> m; int p[m]; for (int a = 0; a < n; a++) { pr[a] = a, si[a] = 1, us[a] = 0; } for (int a = 0; a < m; a++) { p[a] = a; for (int b = 0; b < 3; b++) scanf( %d , &ar[a][b]); ar[a][0]--, ar[a][1]--; } sort(p, p + m, comp); for (int a = 0; a < m; a++) { int i = p[a]; int l = find_se(ar[i][0]), r = find_se(ar[i][1]), va = ar[i][2]; if (l == r) { if (us[l] == 0) { us[l] = 1, an += va; } } else if (us[l] == 1 and us[r] == 0) { us[r] = 1, an += va; } else if (us[l] == 0 and us[r] == 1) { us[l] = 1, an += va; } else if (us[l] == 0 and us[r] == 0) { unite(l, r), an += va; } } cout << an; }
#include <bits/stdc++.h> using namespace std; int n, x, y; int a[1000]; bool inrange(int v) { return (v >= x && v <= y); } int main() { ios ::sync_with_stdio(false); cin >> n; for (int i = 1; i <= n; i++) { cin >> a[i]; a[i] = a[i - 1] + a[i]; } cin >> x >> y; for (int i = 1; i <= n; i++) if (inrange(a[i - 1]) && inrange(a[n] - a[i - 1])) { cout << i; return 0; } cout << 0; return 0; }
#include <bits/stdc++.h> using namespace std; int n, kangaroo[500000]; int main() { cin >> n; for (int _n = n, i = 0; i < _n; ++i) cin >> kangaroo[i]; sort(kangaroo, kangaroo + n); int middle = (n / 2) - !(n % 2); int i = middle, j = n - 1; while (i >= 0 && j > middle) { if (kangaroo[i] * 2 <= kangaroo[j]) j--; i--; } cout << j + 1 << endl; return 0; }
#include <bits/stdc++.h> using namespace std; const long long int mod = 1e9 + 7; const long double PI = 3.141592653589793; int main() { ios_base::sync_with_stdio(false); long long int t; cin >> t; long long int l = 0, r = 0; set<long long int> le, ri; vector<long long int> v(2e5 + 10); while (t--) { char a; long long int b; cin >> a >> b; if (l == 0 && r == 0) { v[b] = 1; l++; r++; continue; } if (a == L ) { l++; le.insert(b); v[b] = l; } else if (a == R ) { r++; ri.insert(b); v[b] = r; } else { auto k = le.find(b); if (k != le.end()) cout << min(l - (v[b] - 1), r + (v[b] - 1)) - 1; else cout << min(r - (v[b] - 1), l + (v[b] - 1)) - 1; cout << n ; } } cerr << Time Lapsed : << 1.0 * clock() / CLOCKS_PER_SEC << n ; return 0; }
#include <bits/stdc++.h> using namespace std; long long int c[104][104]; long long int dp[104][104 * 104]; long long int mul[104][104]; long long int pw(long long int x, long long int y) { long long int ans(1); while (y) { if (y & 1) ans = (ans * x) % 1000000007; x = (x * x) % 1000000007; y >>= 1; } return ans; } int main() { long long int n, m, k; cin >> n >> m >> k; c[1][0] = c[1][1] = 1; for (long long int i(2); i <= 100; ++i) { c[i][i] = c[i][0] = 1; c[i][1] = i; for (long long int j(2); j < i; ++j) { c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % 1000000007; } } for (long long int i(0); i < n; ++i) { for (long long int j(0); j <= n; ++j) { mul[i][j] = pw(c[n][j], (m - i - 1) / n + 1); } } dp[0][0] = 1; for (long long int i(0); i < n; ++i) { for (long long int j(0); j <= k; ++j) { if (dp[i][j] == 0) continue; for (long long int kk(0); kk <= n && j + kk <= k; ++kk) { dp[i + 1][j + kk] = (dp[i + 1][j + kk] + dp[i][j] * mul[i][kk]) % 1000000007; } } } cout << dp[n][k] << endl; return 0; }
#include <bits/stdc++.h> using namespace std; int n, len1, len2, ans; string s; int main() { cin >> n; getline(cin, s), getline(cin, s); while (len1 < s.size()) { len2 = len1 + n - 1; while (len2 > len1) if (s[len2] == . || s[len2] == ? || s[len2] == ! ) { len1 = len2 + 2; break; } else len2--; if (len2 == len1) return puts( Impossible ), 0; ans++; } cout << ans << endl; }
#include <bits/stdc++.h> using namespace std; const int MAXN = 300005; int n, ip[MAXN], p[MAXN], q[MAXN]; int tree[4 * MAXN], flag[4 * MAXN]; void push(int i, int L, int R) { if (L < R) { flag[2 * i] += flag[i]; flag[2 * i + 1] += flag[i]; } tree[i] += flag[i]; flag[i] = 0; } void update(int i, int L, int R, int u, int v, int val) { push(i, L, R); if (R < u || v < L) return; if (u <= L && R <= v) { flag[i] += val; push(i, L, R); return; } int mid = (L + R) / 2; update(2 * i, L, mid, u, v, val); update(2 * i + 1, mid + 1, R, u, v, val); tree[i] = max(tree[2 * i], tree[2 * i + 1]); } int main() { scanf( %d , &n); for (int i = 0; i < n; i++) { scanf( %d , &p[i]); p[i]--; ip[p[i]] = i; } int j = n - 1; update(1, 0, n - 1, 0, ip[j], 1); for (int i = 0; i < n; i++) { scanf( %d , &q[i]); q[i]--; if (i > 0) printf( ); printf( %d , j + 1); if (i != n - 1) { update(1, 0, n - 1, 0, q[i], -1); while (true) { if (tree[1] > 0) { break; } else { j--; update(1, 0, n - 1, 0, ip[j], 1); } } } } printf( n ); return 0; }
#include <bits/stdc++.h> using namespace std; const int maxn = 1e6 + 5; struct Node { int p; vector<int> v; Node() { p = 0, v = {1}; } inline int size() { return v.size(); } }; vector<int> G[maxn]; int ans[maxn]; void merge(Node& a, Node b) { b.v.push_back(0); if (a.size() < b.size()) swap(a, b); int shift = a.size() - b.size(); for (int i = 0; i < b.size(); i++) { a.v[i + shift] += b.v[i]; if (a.v[i + shift] >= a.v[a.p]) a.p = i + shift; } } Node dfs(int u, int fa) { Node cur; for (auto& v : G[u]) { if (v != fa) { merge(cur, dfs(v, u)); } } ans[u] = cur.size() - cur.p - 1; return cur; } int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); int n; cin >> n; for (int i = 1; i < n; i++) { int u, v; cin >> u >> v; G[u].push_back(v), G[v].push_back(u); } dfs(1, 0); for (int i = 1; i <= n; i++) { cout << ans[i] << n ; } }
#include <bits/stdc++.h> using namespace std; int sad = 0; int* visited; vector<int>* adj; void dfs(int curr, int prev) { visited[curr] = 1; for (auto& e : adj[curr]) { if (e == prev) continue; if (visited[e]) sad++; else dfs(e, curr); } } int main() { int n, k; cin >> n >> k; visited = new int[n]; memset(visited, 0, n * sizeof(int)); adj = new vector<int>[n]; unordered_set<string> chk; int dups = 0; for (int i = 0; i < k; i++) { int a, b; scanf( %d%d , &a, &b); int tmp = min(a, b); int tmp2 = max(a, b); string key = to_string(tmp) + to_string(tmp2); if (chk.count(key)) { dups++; continue; } chk.insert(key); adj[a - 1].push_back(b - 1); adj[b - 1].push_back(a - 1); } for (int i = 0; i < n; i++) { if (visited[i]) continue; dfs(i, -1337); } cout << sad / 2 + dups; }
#include <bits/stdc++.h> using namespace std; int vis[10100]; int dist[10100]; int pre[10100], cntt[30]; char str[10100]; struct Edge { int u, v, c, cost, next; } edge[1000100]; int anss, head[10100], cnt; void init() { cnt = 0; memset(head, -1, sizeof(head)); } void addedge(int u, int v, int c, int cost) { edge[cnt].u = u; edge[cnt].v = v; edge[cnt].cost = cost; edge[cnt].c = c; edge[cnt].next = head[u]; head[u] = cnt++; edge[cnt].u = v; edge[cnt].v = u; edge[cnt].cost = -cost; edge[cnt].c = 0; edge[cnt].next = head[v]; head[v] = cnt++; } bool spfa(int begin, int end) { int u, v; queue<int> q; for (int i = 0; i <= end + 2; i++) { pre[i] = -1; vis[i] = 0; dist[i] = 99999999; } vis[begin] = 1; dist[begin] = 0; q.push(begin); while (!q.empty()) { u = q.front(); q.pop(); vis[u] = 0; for (int i = head[u]; i != -1; i = edge[i].next) { if (edge[i].c > 0) { v = edge[i].v; if (dist[v] > dist[u] + edge[i].cost) { dist[v] = dist[u] + edge[i].cost; pre[v] = i; if (!vis[v]) { vis[v] = true; q.push(v); } } } } } return dist[end] != 99999999; } int MCMF(int begin, int end) { int ans = 0, flow; int flow_sum = 0; while (spfa(begin, end)) { flow = 99999999; for (int i = pre[end]; i != -1; i = pre[edge[i].u]) if (edge[i].c < flow) flow = edge[i].c; for (int i = pre[end]; i != -1; i = pre[edge[i].u]) { edge[i].c -= flow; edge[i ^ 1].c += flow; } ans += dist[end] * flow; flow_sum += flow; } anss = flow_sum; return ans; } int main() { int n, m, a, b, c, cost, i, j, cc, len; scanf( %s , str); len = strlen(str); init(); for (i = 0; i < strlen(str); i++) cntt[str[i] - 97]++; scanf( %d , &n); for (i = n + 1; i <= n + 26; i++) addedge(i, n + 27, cntt[i - n - 1], 0); for (i = 1; i <= n; i++) { scanf( %s%d , str, &cc); addedge(0, i, cc, i); memset(cntt, 0, sizeof(cntt)); for (j = 0; j < strlen(str); j++) cntt[str[j] - 97]++; for (j = 0; j < 26; j++) addedge(i, n + 1 + j, cntt[j], 0); } int z = MCMF(0, n + 27); if (anss == len) printf( %d n , z); else printf( -1 ); return 0; }
#include <bits/stdc++.h> using namespace std; const int N = 2e5 + 100; char s[N]; int n, m, t[N]; int a[N * 4], b[N * 4], ab[N * 4], ba[N * 4], aba[N * 4], tag[N * 4]; void pushup(int now) { a[now] = max(a[(now << 1)], a[(now << 1 | 1)]); b[now] = min(b[(now << 1)], b[(now << 1 | 1)]); ab[now] = max(ab[(now << 1)], max(ab[(now << 1 | 1)], a[(now << 1)] - 2 * b[(now << 1 | 1)])); ba[now] = max(ba[(now << 1)], max(ba[(now << 1 | 1)], a[(now << 1 | 1)] - 2 * b[(now << 1)])); aba[now] = max(max(aba[(now << 1)], aba[(now << 1 | 1)]), max(ab[(now << 1)] + a[(now << 1 | 1)], ba[(now << 1 | 1)] + a[(now << 1)])); } void build(int now, int l, int r) { if (l + 1 == r) { a[now] = b[now] = t[l]; ab[now] = ba[now] = -t[l]; return; } int mid = (l + r) >> 1; build((now << 1), l, mid); build((now << 1 | 1), mid, r); pushup(now); } void down(int now, int val) { a[now] += val; b[now] += val; ab[now] -= val; ba[now] -= val; tag[now] += val; } void pushdown(int now) { down((now << 1), tag[now]); down((now << 1 | 1), tag[now]); tag[now] = 0; } void Insert(int now, int l, int r, int a, int b, int val) { if (a <= l && b >= r - 1) { down(now, val); return; } int mid = (l + r) >> 1; pushdown(now); if (a < mid) Insert((now << 1), l, mid, a, b, val); if (b >= mid) Insert((now << 1 | 1), mid, r, a, b, val); pushup(now); } int main() { int x, y, z; scanf( %d%d , &n, &m); n = n * 2 - 2; scanf( %s , s + 1); for (int i = 1; i <= n; ++i) { if (s[i] == ( ) t[i] = t[i - 1] + 1; else t[i] = t[i - 1] - 1; Insert(1, 1, n + 1, i, i, t[i]); } printf( %d n , aba[1]); for (int i = 0; i < m; ++i) { scanf( %d%d , &x, &y); if (x > y) swap(x, y); if (s[x] == ( ) z = -2; else z = 2; Insert(1, 1, n + 1, x, y - 1, z); swap(s[x], s[y]); printf( %d n , aba[1]); } return 0; }
#include <bits/stdc++.h> using namespace std; const double eps(1e-8), Inf(1e10); const double pi(3.14159265358979); const int N = 6060; struct point { double x, y; } p[N + N] = {}; int n, q, k = 0, a, b, x[N] = {}; double ans[N] = {}; void init() { cin >> n >> q >> a >> b; for (int i = 1; i <= n; ++i) cin >> x[i]; } void work() { p[++k] = {1.0, 2.0 * (-x[1])}; p[++k] = {Inf, 2.0 * (Inf - x[1])}; ans[1] = x[1]; double zero = x[1]; for (int i = 2, d = 1; i <= n; ++i) { for (int j = k; j > d; --j) p[j + 2] = p[j]; k += 2; p[d + 1] = {zero, 0}; p[d + 2] = {zero, 0}; for (int j = 1; j <= d + 1; ++j) p[j].x += a; for (int j = d + 2; j <= k; ++j) p[j].x += b; for (int j = 1; j <= k; ++j) p[j].y += 2 * (p[j].x - x[i]); if (p[1].y > 0) zero = p[1].x, d = 0; else { for (d = 1; p[d].y * p[d + 1].y > 0; ++d) ; zero = (-p[d].y) / (p[d + 1].y - p[d].y) * (p[d + 1].x - p[d].x) + p[d].x; } ans[i] = zero; } ans[n] = min<double>(ans[n], q); for (int i = n - 1; i >= 1; --i) { ans[i] = max(ans[i + 1] - b, ans[i]); ans[i] = min(ans[i + 1] - a, ans[i]); } double sum = 0; for (int i = 1; i <= n; ++i) sum += (x[i] - ans[i]) * (x[i] - ans[i]); for (int i = 1; i <= n; ++i) printf( %.6f , ans[i]); printf( n%.6f n , sum); } int main() { init(); work(); return 0; }
#include <bits/stdc++.h> int n, m, num; char tab[100][100]; int xx[10000][4]; int yy[10000][4]; int ch[100][100]; int id[100][100]; int getdir(int cd, int dd) { if (cd == 1) return (dd + 1) % 4; else return dd; } int main() { scanf( %d %d , &n, &num); for (int i = 0; i < n; i++) { scanf( %s , tab[i]); m = strlen(tab[i]); for (int j = 0; j < m; j++) { tab[i][j] -= 0 ; } } int count = 1; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if (tab[i][j] == 0) { id[i][j] = 0; continue; } if (i - 1 >= 0 && tab[i - 1][j] == tab[i][j]) { id[i][j] = id[i - 1][j]; } else if (j - 1 >= 0 && tab[i][j - 1] == tab[i][j]) { id[i][j] = id[i][j - 1]; } else { id[i][j] = count++; xx[id[i][j]][0] = i; yy[id[i][j]][0] = j; xx[id[i][j]][1] = i; yy[id[i][j]][3] = j; } if ((i + 1 >= n || tab[i][j] != tab[i + 1][j]) && (j + 1 >= m || tab[i][j] != tab[i][j + 1])) { yy[id[i][j]][1] = j; xx[id[i][j]][3] = i; xx[id[i][j]][2] = i; yy[id[i][j]][2] = j; } } } int tx, ty, cd = 0, dd = 1; int pos = id[tx][ty]; for (int p = 0; p < num; p++) { int dir = getdir(cd, dd); tx = xx[pos][dir]; ty = yy[pos][dir]; int dx, dy; if (dd == 0) { dx = -1; dy = 0; } if (dd == 1) { dx = 0; dy = 1; } if (dd == 2) { dx = 1; dy = 0; } if (dd == 3) { dx = 0; dy = -1; } if (tx + dx < 0 || tx + dx >= n || ty + dy < 0 || ty + dy >= m || id[tx + dx][ty + dy] == 0) { if (cd == 0) { cd = 1; } else { cd = 0; dd += 1; dd %= 4; } } else { pos = id[tx + dx][ty + dy]; tx += dx; ty += dy; } } printf( %d n , tab[tx][ty]); }
#include bits/stdc++.h using namespace std; using ll = long long; using pii = pair<int,int>; using pll = pair<ll,ll>; template<typename T> int sz(const T &a){return int(a.size());} const int MN=601; int dist[MN]; bool used[MN]; int arr[MN][MN]; int main(){ cin.tie(NULL); ios_base::sync_with_stdio(false); int n,m,a,b,c; cin>>n>>m; for(int i=0;i<n;i++)for(int j=0;j<n;j++)arr[i][j]=INT_MAX; for(int i=1;i<=m;i++){ cin>>a>>b>>c; arr[a][b]=c; } for(int i=0;i<n;i++){ for(int j=0;j<n;j++)dist[j]=INT_MAX,used[j]=false; dist[i]=0; for(int level=1;level<n;level++){ int cur=-1; for(int j=0;j<n;j++){ if(!used[j]&&(cur==-1||dist[j]<dist[cur]))cur=j; } used[cur]=true; int mi=INT_MAX; for(int j=0;j<n;j++)if(arr[cur][(j-dist[cur]%n+n)%n]!=INT_MAX)mi=min(mi,arr[cur][(j-dist[cur]%n+n)%n]+n-1-j); for(int j=0;j<n;j++){ mi=min(mi+1,arr[cur][(j-dist[cur]%n+n)%n]); dist[j]=min(dist[j],dist[cur]+mi); } } for(int j=0;j<n;j++)printf( %d%c ,dist[j], n [j==n-1]); } return 0; }