func_code_string
stringlengths 59
71.4k
|
|---|
#include <bits/stdc++.h> using namespace std; struct node { int to, nxt, v; } e[1000005]; queue<int> que; int n, m, head[1000005], cnt, l, r, vis[1000005], pre[1000005], tot; int sum, ans[1000005], ppp, minn = 1023456789, dfn[1000005], id[1000005]; inline void add(int from, int to, int v) { e[++cnt].nxt = head[from]; head[from] = cnt; e[cnt].to = to; e[cnt].v = v; } inline int dfs(int p, int val, int fa) { pre[p] = tot; vis[p] = 1; for (int i = head[p]; i; i = e[i].nxt) { if (e[i].v > val) { if (pre[e[i].to] == tot && !vis[e[i].to]) { continue; } if ((pre[e[i].to] == tot && vis[e[i].to]) || dfs(e[i].to, val, fa)) return 1; } } vis[p] = 0; return 0; } inline void work(int val) { for (int i = 1; i <= m; i++) if (e[i].v > val) dfn[e[i].to]++; for (int i = 1; i <= n; i++) if (!dfn[i]) que.push(i); while (!que.empty()) { int u = que.front(); que.pop(); id[u] = ++sum; for (int i = head[u]; i; i = e[i].nxt) { if (e[i].v > val) { dfn[e[i].to]--; if (!dfn[e[i].to]) que.push(e[i].to); } } } } int main() { scanf( %d%d , &n, &m); for (int i = 1; i <= m; i++) { int x, y, z; scanf( %d%d%d , &x, &y, &z); add(x, y, z); r = max(r, z); } l = 0; int fl; while (l < r) { fl = 0; tot++; sum = 0; int mid = (l + r) >> 1; for (int i = 1; i <= n; i++) { if (pre[i] != tot && dfs(i, mid, i)) { fl = 1; break; } } if (!fl) { r = mid; } else { l = mid + 1; } } printf( %d , r); sum = 0; work(r); for (int i = 1; i <= n; i++) { for (int j = head[i]; j; j = e[j].nxt) { if (e[j].v <= r) { if (id[e[j].to] < id[i]) { ans[++ppp] = j; } } } } printf( %d n , ppp); sort(ans + 1, ans + ppp + 1); for (int i = 1; i <= ppp; i++) printf( %d , ans[i]); return 0; }
|
#include <bits/stdc++.h> using namespace std; void exec() { int n, k; cin >> n >> k; map<int, int> es; for (int i = 1; i <= k + 1; i++) { string query = ? ; for (int j = 1; j <= k + 1; j++) { if (j == i) { continue; } query += + to_string(j); } cout << query << endl; int pos, a; cin >> pos >> a; es[a] += 1; } int mmax = -1; int m = 0; for (auto i = es.begin(); i != es.end(); ++i) { if (mmax < i->first) { mmax = i->first; m = i->second; } } cout.flush(); cout << ( ! + to_string(m)) << endl; } void solve() { int t = 1; for (int i = 0; i < t; i++) { exec(); } } int main() { solve(); return 0; }
|
#include <bits/stdc++.h> using namespace std; string to_string(string s) { return + s + ; } string to_string(const char *s) { return to_string((string)s); } string to_string(bool b) { return (b ? true : false ); } template <typename A, typename B> string to_string(pair<A, B> p) { return ( + to_string(p.first) + , + to_string(p.second) + ) ; } template <typename A> string to_string(A v) { bool first = true; string res = { ; for (const auto &x : v) { if (!first) { res += , ; } first = false; res += to_string(x); } res += } ; return res; } void debug_out() { cerr << endl; } template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) { cerr << << to_string(H); debug_out(T...); } const int md = (int)1e9 + 7; inline void add(int &a, int b) { a += b; if (a >= md) a -= md; } inline void sub(int &a, int b) { a -= b; if (a < 0) a += md; } inline int mul(int a, int b) { return (int)((long long)a * b % md); unsigned long long x = (long long)a * b; unsigned xh = (unsigned)(x >> 32), xl = (unsigned)x, d, m; asm( divl %4; n t : =a (d), =d (m) : d (xh), a (xl), r (md)); return m; } inline int power(int a, long long b) { int res = 1; while (b > 0) { if (b & 1) { res = mul(res, a); } a = mul(a, a); b >>= 1; } return res; } inline int inv(int a) { a %= md; if (a < 0) a += md; int b = md, u = 0, v = 1; while (a) { int t = b / a; b -= t * a; swap(a, b); u -= t * v; swap(u, v); } assert(b == 1); if (u < 0) u += md; return u; } template <typename T> class graph { public: struct edge { int from; int to; T cost; }; vector<edge> edges; vector<vector<int>> g; int n; function<bool(int)> ignore; graph(int _n) : n(_n) { g.resize(n); ignore = nullptr; } virtual int add(int from, int to, T cost) = 0; virtual void set_ignore_edge_rule(const function<bool(int)> &f) { ignore = f; } virtual void reset_ignore_edge_rule() { ignore = nullptr; } }; template <typename T> class forest : public graph<T> { public: using graph<T>::edges; using graph<T>::g; using graph<T>::n; forest(int _n) : graph<T>(_n) {} int add(int from, int to, T cost = 1) { assert(0 <= from && from < n && 0 <= to && to < n); int id = (int)edges.size(); assert(id < n - 1); g[from].push_back(id); g[to].push_back(id); edges.push_back({from, to, cost}); return id; } }; template <typename T> class dfs_forest : public forest<T> { public: using forest<T>::edges; using forest<T>::g; using forest<T>::n; using forest<T>::ignore; vector<int> pv; vector<int> pe; vector<int> order; vector<int> pos; vector<int> end; vector<int> sz; vector<int> root; vector<int> depth; vector<T> dist; dfs_forest(int _n) : forest<T>(_n) {} void init() { pv = vector<int>(n, -1); pe = vector<int>(n, -1); order.clear(); pos = vector<int>(n, -1); end = vector<int>(n, -1); sz = vector<int>(n, 0); root = vector<int>(n, -1); depth = vector<int>(n, -1); dist = vector<T>(n); } void clear() { pv.clear(); pe.clear(); order.clear(); pos.clear(); end.clear(); sz.clear(); root.clear(); depth.clear(); dist.clear(); } private: void do_dfs(int v) { pos[v] = (int)order.size(); order.push_back(v); sz[v] = 1; for (int id : g[v]) { if (id == pe[v] || (ignore != nullptr && ignore(id))) { continue; } auto &e = edges[id]; int to = e.from ^ e.to ^ v; depth[to] = depth[v] + 1; dist[to] = dist[v] + e.cost; pv[to] = v; pe[to] = id; root[to] = (root[v] != -1 ? root[v] : to); do_dfs(to); sz[v] += sz[to]; } end[v] = (int)order.size() - 1; } void do_dfs_from(int v) { depth[v] = 0; dist[v] = T{}; root[v] = v; pv[v] = pe[v] = -1; do_dfs(v); } public: void dfs(int v, bool clear_order = true) { if (pv.empty()) { init(); } else { if (clear_order) { order.clear(); } } do_dfs_from(v); } void dfs_all() { init(); for (int v = 0; v < n; v++) { if (depth[v] == -1) { do_dfs_from(v); } } assert((int)order.size() == n); } }; template <typename T> class lca_forest : public dfs_forest<T> { public: using dfs_forest<T>::edges; using dfs_forest<T>::g; using dfs_forest<T>::n; using dfs_forest<T>::pv; using dfs_forest<T>::pos; using dfs_forest<T>::end; using dfs_forest<T>::depth; int h; vector<vector<int>> pr; lca_forest(int _n) : dfs_forest<T>(_n) {} inline void build_lca() { assert(!pv.empty()); int max_depth = 0; for (int i = 0; i < n; i++) { max_depth = max(max_depth, depth[i]); } h = 1; while ((1 << h) <= max_depth) { h++; } pr.resize(n); for (int i = 0; i < n; i++) { pr[i].resize(h); pr[i][0] = pv[i]; } for (int j = 1; j < h; j++) { for (int i = 0; i < n; i++) { pr[i][j] = (pr[i][j - 1] == -1 ? -1 : pr[pr[i][j - 1]][j - 1]); } } } inline bool anc(int x, int y) { return (pos[x] <= pos[y] && end[y] <= end[x]); } inline int lca(int x, int y) { assert(!pr.empty()); if (anc(x, y)) { return x; } if (anc(y, x)) { return y; } for (int j = h - 1; j >= 0; j--) { if (pr[x][j] != -1 && !anc(pr[x][j], y)) { x = pr[x][j]; } } return pr[x][0]; } }; template <typename T> class fenwick { public: vector<T> fenw; int n; fenwick(int _n) : n(_n) { fenw.resize(n); } void modify(int x, T v) { while (x < n) { fenw[x] += v; x |= (x + 1); } } T get(int x) { T v{}; while (x >= 0) { v += fenw[x]; x = (x & (x + 1)) - 1; } return v; } }; int main() { ios::sync_with_stdio(false); cin.tie(0); const int MAX = (int)1e7 + 10; vector<int> prime_div(MAX); for (int i = 0; i < MAX; i++) { prime_div[i] = i; } for (int i = 2; i * i < MAX; i++) { if (prime_div[i] == i) { for (int j = i * i; j < MAX; j += i) { if (prime_div[j] == j) { prime_div[j] = i; } } } } vector<int> pos(MAX); vector<int> primes; for (int i = 2; i < MAX; i++) { if (prime_div[i] == i) { pos[i] = (int)primes.size(); primes.push_back(i); } } vector<vector<pair<int, int>>> at(primes.size()); int n; cin >> n; lca_forest<int> g(n); for (int i = 0; i < n - 1; i++) { int x, y; cin >> x >> y; x--; y--; g.add(x, y); } g.dfs(0); g.build_lca(); for (int i = 0; i < n; i++) { int foo; cin >> foo; while (foo > 1) { int d = prime_div[foo]; int cc = 0; while (foo % d == 0) { foo /= d; cc++; } at[pos[d]].emplace_back(cc, i); } } int tt; cin >> tt; vector<int> u(tt), v(tt), lca(tt); vector<int> res(tt, 1); for (int i = 0; i < tt; i++) { int foo; cin >> u[i] >> v[i] >> foo; u[i]--; v[i]--; lca[i] = g.lca(u[i], v[i]); while (foo > 1) { int d = prime_div[foo]; int cc = 0; while (foo % d == 0) { foo /= d; cc++; } for (int j = 1; j <= cc; j++) { at[pos[d]].emplace_back(j, ~i); } } } fenwick<int> fenw(n); for (int it = 0; it < (int)primes.size(); it++) { if (at[it].empty()) { continue; } sort(at[it].rbegin(), at[it].rend()); for (auto &p : at[it]) { int id = p.second; if (id >= 0) { fenw.modify(g.pos[id], 1); fenw.modify(g.end[id] + 1, -1); } else { id = ~id; int cnt = fenw.get(g.pos[u[id]]) + fenw.get(g.pos[v[id]]) - fenw.get(g.pos[lca[id]]); if (lca[id] != 0) { cnt -= fenw.get(g.pos[g.pv[lca[id]]]); } res[id] = mul(res[id], power(primes[it], cnt)); } } for (auto &p : at[it]) { int id = p.second; if (id >= 0) { fenw.modify(g.pos[id], -1); fenw.modify(g.end[id] + 1, +1); } } } for (int i = 0; i < tt; i++) { cout << res[i] << n ; } return 0; }
|
#include <bits/stdc++.h> using namespace std; const int maxn = 105000; int a[maxn], ans[maxn]; int n, p, res1, res2; bool judge1(int k) { int sum = 0; for (int i = 1; i <= n; i++) { if (a[i] <= k) sum++; else { int tmp = a[i] - k; sum -= tmp; if (sum < 0) return 0; k += tmp; sum++; } } return 1; } bool judge2(int k) { int sum = 0; for (int i = 1; i <= n; i++) { if (a[i] <= k) { sum++; if (sum >= p) return 0; } else { int tmp = a[i] - k; sum -= tmp; k += tmp; sum++; } } return 1; } void solve() { scanf( %d %d , &n, &p); int max_v = 0; for (int i = 1; i <= n; i++) { scanf( %d , &a[i]); max_v = max(max_v, a[i]); } sort(a + 1, a + n + 1); int l = 1, r = max_v; while (l <= r) { int mid = l + r >> 1; if (judge1(mid)) r = mid - 1; else l = mid + 1; } res1 = l; r = max_v; while (l <= r) { int mid = l + r >> 1; if (judge2(mid)) l = mid + 1; else r = mid - 1; } res2 = r; printf( %d n , res2 - res1 + 1); for (int i = res1; i <= res2; i++) printf( %d , i); printf( n ); } int main() { solve(); return 0; }
|
#include <bits/stdc++.h> using namespace std; int b[1100000], a[1100000], pre[1100000]; int main() { int n, m, k, i, j, s, cnt, len = 0, max = 0; long long ans = 0; scanf( %d%d%d , &n, &m, &k); for (i = 1; i <= m; ++i) { scanf( %d , &s); b[s] = 1; } b[n] = 1; for (i = 1; i < n; ++i) if (b[i]) pre[i] = pre[i - 1]; else pre[i] = i; for (i = 1; i < n; ++i) { if (b[i]) ++len; else len = 0; if (len > max) max = len; } for (i = 1; i <= k; ++i) scanf( %d , &a[i]); if (max == 0) max = 1; else ++max; for (i = max; i <= k; ++i) { cnt = 0; j = 0; if (b[j]) continue; while (j < n) { ++cnt; if (!b[j]) j = j + i; else j = pre[j] + i; } if (ans == 0) ans = (long long)cnt * a[i]; else if ((long long)cnt * a[i] < ans) ans = (long long)cnt * a[i]; } if (ans > 0) printf( %I64d , ans); else printf( -1 ); return 0; }
|
#include <bits/stdc++.h> int main() { std::ios::sync_with_stdio(false); std::cin.tie(nullptr); int32_t n, m, k; std::cin >> n >> m >> k; if (n % 2 == 0) { std::cout << Marsel n ; } else { bool avail = k == 1; for (int32_t i = 2; i * i <= m; ++i) { if (m % i == 0) { avail |= m / i >= k; break; } } if (m >= k * 2 && avail) { std::cout << Timur n ; } else { std::cout << Marsel n ; } } }
|
#include <bits/stdc++.h> using namespace std; const int N = 1 << 19; const double PI = acos(-1); int n, x; int a[N]; vector<long long> f, g, h; long long res[N]; int rev[N]; void calc_rev(int n, int logn) { for (int i = 0; i < n; ++i) { rev[i] = 0; for (int j = 0; j < logn; ++j) if (i >> j & 1) { rev[i] |= 1 << logn - j - 1; } } } void fft(complex<double> a[], int n, bool invert) { for (int i = 0; i < n; ++i) if (i < rev[i]) { swap(a[i], a[rev[i]]); } for (int len = 2; len <= n; len <<= 1) { double alpha = 2 * PI / len * (invert ? -1 : 1); complex<double> wl = complex<double>(cos(alpha), sin(alpha)); for (int i = 0; i < n; i += len) { complex<double> w = complex<double>(1); for (int j = 0; j < (len >> 1); ++j) { complex<double> u = a[i + j], v = a[i + j + (len >> 1)] * w; a[i + j] = u + v; a[i + j + (len >> 1)] = u - v; w *= wl; } } } if (invert) for (int i = 0; i < n; ++i) a[i] /= n; } vector<long long> mult(vector<long long> a, vector<long long> b) { static complex<double> fa[N], fb[N], fc[N]; int na = a.size(), nb = b.size(); int n = 1, logn = 0; while (n < max(na, nb)) n <<= 1, logn++; n <<= 1, logn++; calc_rev(n, logn); for (int i = 0; i < n; ++i) fa[i] = fb[i] = complex<double>(0); for (int i = 0; i < na; ++i) fa[i] = complex<double>(a[i]); for (int i = 0; i < nb; ++i) fb[i] = complex<double>(b[i]); fft(fa, n, false); fft(fb, n, false); for (int i = 0; i < n; ++i) fc[i] = fa[i] * fb[i]; fft(fc, n, true); vector<long long> res; for (int i = 0; i < na + nb - 1; ++i) res.push_back((long long)(fc[i].real() + 0.5)); return res; } int main() { ios_base::sync_with_stdio(false); cin >> n >> x; f.assign(n + 1, 0), g.assign(n + 1, 0); f[0] = g[n] = 1; for (int i = 1; i <= n; ++i) { cin >> a[i]; a[i] = a[i - 1] + (a[i] < x); f[a[i]]++, g[n - a[i]]++; } h = mult(f, g); for (int i = 0; i <= n; ++i) res[0] += f[i] * (f[i] - 1) / 2; for (int i = 1; i <= n; ++i) res[i] = h[i + n]; for (int i = 0; i <= n; ++i) cout << res[i] << ; cout << n ; }
|
#include <bits/stdc++.h> using namespace std; int n, m, k, cla[30], a[200 + 5], hd[2 * 200 + 5], len = 0; char s[30]; struct Edge { int v, net; } e[2 * 160000 + 5]; void addi(int u, int v) { e[len] = (Edge){v, hd[u]}; hd[u] = len++; } void add(int u, int v) { addi(u, v); addi(v <= n ? n + v : v - n, u <= n ? n + u : u - n); } template <class T> void read(T &x) { char ch; bool ok; for (ok = 0, ch = getchar(); !isdigit(ch); ch = getchar()) if (ch == - ) ok = 1; for (x = 0; isdigit(ch); x = x * 10 + ch - 0 , ch = getchar()) ; if (ok) x = -x; } int col[200 + 5], col_cpy[200 + 5]; bool dfs(int u, int ty) { if (col_cpy[u] != -1) return col_cpy[u] == ty; col_cpy[u] = ty; for (int i = hd[ty * n + u]; ~i; i = e[i].net) { int v = e[i].v; if (!(v > n ? dfs(v - n, 1) : dfs(v, 0))) return 0; } return 1; } int fl = 0, mx[2]; bool chk(int x, int ty) { if (fl || ty) return 1; for (int i = (x), en = (n); i <= en; ++i) { if (col_cpy[i] == -1) { if (mx[!cla[a[i]]] > a[i]) return 1; continue; } if (mx[col_cpy[i]] > a[i]) return 1; if (mx[col_cpy[i]] < a[i]) return 0; } return 1; } bool chk(int x, int ty, int tty) { memcpy(col_cpy, col, sizeof col); if (dfs(x, ty) && chk(x + 1, tty)) { memcpy(col, col_cpy, sizeof col_cpy); return 1; } return 0; } int as[200 + 5]; int main() { memset(hd, -1, sizeof hd); scanf( %s , s + 1); k = strlen(s + 1); int mn = 0; for (int i = (1), en = (k); i <= en; ++i) { cla[i] = s[i] == C ; if (cla[i] != cla[1] && !mn) mn = i; mx[cla[i]] = max(mx[cla[i]], i); } read(n); read(m); for (int i = (1), en = (m); i <= en; ++i) { int x, y, xx, yy; char c; read(x); cin >> c; y = c == C ; read(xx); cin >> c; yy = c == C ; add(x + n * y, xx + n * yy); if (y != yy && !mx[yy]) { puts( -1 ); return 0; } } memset(col, -1, sizeof col); for (int i = (1), en = (n); i <= en; ++i) { char c; cin >> c; a[i] = c - a + 1; } for (int i = (1), en = (n); i <= en; ++i) { if (fl) { if (chk(i, cla[1], 1)) as[i] = 1; else if (chk(i, !cla[1], 1)) as[i] = mn; else { puts( -1 ); return 0; } } else { int tem = 0, tem1 = 0; for (int j = (a[i] + 1), en = (k); j <= en; ++j) { if (cla[j] != cla[a[i]]) { if (!tem) tem = j; } else { if (!tem1) tem1 = j; } } if (chk(i, cla[a[i]], 0)) as[i] = a[i]; else { if (tem > tem1) swap(tem, tem1); if (tem && chk(i, cla[tem], 1)) as[i] = tem; else if (tem1 && chk(i, cla[tem1], 1)) as[i] = tem1; else { puts( -1 ); return 0; } } } fl |= as[i] > a[i]; } for (int i = (1), en = (n); i <= en; ++i) putchar( a + as[i] - 1); return 0; }
|
#include <bits/stdc++.h> using namespace std; struct Exam { int s, d, c, id; bool operator<(const Exam &e1) const { return d < e1.d; } }; const int N = 105; int n, m, to[N]; Exam e[N]; int main() { cin >> n >> m; for (int i = 1; i <= m; i++) { cin >> e[i].s >> e[i].d >> e[i].c; e[i].id = i; to[e[i].d] = m + 1; } sort(e + 1, e + m + 1); for (int i = 1; i <= m; i++) { int cnt = 0; for (int j = e[i].s; j < e[i].d; j++) { if (to[j] == 0) { to[j] = e[i].id; if (++cnt == e[i].c) break; } } if (cnt < e[i].c) { cout << -1 << endl; return 0; } } for (int i = 1; i <= n; i++) cout << to[i] << ; cout << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; const int INF = 0x3f3f3f3f; const long long INFF = 0x3f3f3f3f3f3f3f3fll; const long long M = 1e9 + 7; const long long maxn = 5007; const double eps = 0.00000001; long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; } template <typename T> inline T abs(T a) { return a > 0 ? a : -a; } template <typename T> inline T powMM(T a, T b) { T ret = 1; for (; b; b >>= 1ll, a = a * a % M) ret = 1ll * ret * a % M; return ret; } vector<int> edge[maxn]; vector<long long> dp1[maxn], dp2[maxn]; long long now1[maxn], now2[maxn]; long long a[maxn], b[maxn], m; int num[maxn], ans; void dfs(int x) { num[x] = 1; dp1[x].resize(maxn, INFF); dp2[x].resize(maxn, INFF); dp1[x][1] = a[x]; dp1[x][0] = 0; dp2[x][1] = a[x] - b[x]; dp2[x][0] = INFF; int i, j; for (int v : edge[x]) { dfs(v); for (i = 0; i <= num[x]; i++) now1[i] = dp1[x][i], now2[i] = dp2[x][i]; for (i = 0; i <= num[x]; i++) for (j = 1; j <= num[v]; j++) { dp1[x][i + j] = min(dp1[x][i + j], now1[i] + dp1[v][j]); dp2[x][i + j] = min(dp2[x][i + j], now2[i] + min(dp1[v][j], dp2[v][j])); } vector<long long>().swap(dp1[v]); vector<long long>().swap(dp2[v]); num[x] += num[v]; } } int n; int i, j, k; int main() { scanf( %d%I64d , &n, &m); for (i = 1; i <= n; i++) { scanf( %I64d%I64d , &a[i], &b[i]); if (i != 1) { int v; scanf( %d , &v); edge[v].push_back(i); }; } dfs(1); ans = 0; for (i = 1; i <= n; i++) if (dp1[1][i] <= m || dp2[1][i] <= m) ans = max(ans, i); printf( %d , ans); }
|
#include <bits/stdc++.h> const double PI = acos(-1); using namespace std; template <class T> ostream& operator<<(ostream& out, vector<T> v) { out << v.size() << n ; for (auto e : v) out << e << n ; return out; } struct point { long long x, y; point() {} point(const point& a) { x = a.x, y = a.y; } point(long long _x, long long _y) { x = _x; y = _y; } point operator-(point a) { return point(x - a.x, y - a.y); } point operator+(point a) { return point(x + a.x, y + a.y); } }; ostream& operator<<(ostream& out, point p) { return out << ( << p.x << << p.y << ) ; } long double dist(point a, point b) { long double X = a.x - b.x; long double Y = a.y - b.y; return sqrt(X * X + Y * Y); } istream& operator>>(istream& in, point& p) { return in >> p.x >> p.y; } long double area(point a, point b, point c) { return a.x * b.y + b.x * c.y + c.x * a.y - a.y * b.x - b.y * c.x - c.y * a.x; } const long long N = 100100; point p1, p2, p[N]; long long n, k, use[N]; vector<pair<long long, long long> > v[5]; long long lg(long long a) { if (a % 2 == 1) a++; a /= 2; return max(1LL, a); } int main() { ios_base::sync_with_stdio(false); cin >> n >> k; for (long long i = 1; i <= n; i++) { cin >> p1 >> p2; p[i] = p1 + p2; } for (long long i = 1; i <= n; i++) { v[0].push_back({p[i].x, i}); v[1].push_back({p[i].x, i}); } for (long long i = 1; i <= n; i++) { v[2].push_back({p[i].y, i}); v[3].push_back({p[i].y, i}); } sort(v[0].begin(), v[0].end()); sort(v[1].begin(), v[1].end(), greater<pair<long long, long long> >()); sort(v[2].begin(), v[2].end()); sort(v[3].begin(), v[3].end(), greater<pair<long long, long long> >()); long long ans = 1e18 + 100; for (long long i = 0; i < (1 << (2 * k)); i++) { long long order[12], msk = i, used[12]; for (long long j = 1; j <= k; j++) { order[j] = msk % 4; msk /= 4; } long long d[] = {v[0][0].first, v[1][0].first, v[2][0].first, v[3][0].first}; for (long long j = 1; j <= k; j++) { long long p = order[j], ind = 0; while (use[v[order[j]][ind].second]) ind++; use[v[p][ind].second] = 1; used[j] = v[p][ind].second; } for (int j = 0; j < 4; j++) { int ind = 0; while (use[v[j][ind].second]) ind++; d[j] = v[j][ind].first; } ans = min(ans, lg(d[1] - d[0]) * lg(d[3] - d[2])); for (long long j = 1; j <= k; j++) use[used[j]] = 0; } cout << ans << n ; }
|
#include <bits/stdc++.h> using namespace std; string s[51]; int n, m; bool check(int i, int j) { for (int k = 1; k <= n; ++k) if (s[k][j] == # && s[k] != s[i]) return false; return true; } signed main() { ios::sync_with_stdio(false); cin >> n >> m; for (int i = 1; i <= n; ++i) cin >> s[i]; for (int i = 1; i <= n; ++i) for (int j = 0; j <= m - 1; ++j) if (s[i][j] == # ) if (!check(i, j)) { cout << No ; return 0; } cout << Yes ; return 0; }
|
#include <bits/stdc++.h> using namespace std; template <typename T> T gcd(T a, T b) { while (a > 0 && b > 0) { if (a > b) a %= b; else b %= a; } return a + b; } void YES_NO(bool YES_NO, bool isExit = true) { if (YES_NO) cout << YES << endl; else cout << NO << endl; if (isExit) { exit(0); } } void Yes_No(bool Yes_No, bool isExit = true) { if (Yes_No) cout << Yes << endl; else cout << No << endl; if (isExit) { exit(0); } } void yes_no(bool yes_no, bool isExit = true) { if (yes_no) cout << yes << endl; else cout << no << endl; if (isExit) { exit(0); } } int main() { string s, t; cin >> s; cin >> t; int cnt = 0; for (int i = 0; i < s.size(); ++i) { if (s[i] != t[i]) { ++cnt; } } if (cnt % 2 == 1) { cout << impossible << endl; return 0; } cnt /= 2; string ans = s; for (int i = 0; i < s.size(); ++i) { if (s[i] != t[i] && cnt) { ans[i] = t[i]; --cnt; } } cout << ans << endl; return 0; }
|
#include <bits/stdc++.h> int r, g, b; int mins; int total; int tour; int cycles; int main() { scanf( %d %d %d , &r, &g, &b); if (r >= 2) { r -= 2; } else if (r == 1) { r -= 1; } mins = 30; tour = 1; total = r + g + b; while (total > 0) { if (tour == 1) { if (g >= 2) { g -= 2; } else if (g == 1) { g -= 1; } tour = 2; } else if (tour == 2) { if (b >= 2) { b -= 2; } else if (b == 1) { b -= 1; } tour = 0; } else if (tour == 0) { if (r >= 2) { r -= 2; } else if (r == 1) { r -= 1; } tour = 1; } total = r + g + b; cycles++; } mins += cycles; printf( %d , mins); }
|
#include <bits/stdc++.h> using namespace std; int cap[1000000], flow[1000000]; int to[1000000], _prev[1000000], last[10000], used[10000], level[10000]; struct MaxFlow { int V, E; MaxFlow(int n) { int i; V = n; E = 0; for ((i) = 0; (i) < (int)(V); (i)++) last[i] = -1; } void add_edge(int x, int y, int f) { cap[E] = f; flow[E] = 0; to[E] = y; _prev[E] = last[x]; last[x] = E; E++; cap[E] = 0; flow[E] = 0; to[E] = x; _prev[E] = last[y]; last[y] = E; E++; } bool bfs(int s, int t) { int i; for ((i) = 0; (i) < (int)(V); (i)++) level[i] = -1; queue<int> q; q.push(s); level[s] = 0; while (!q.empty()) { int x = q.front(); q.pop(); for (i = last[x]; i >= 0; i = _prev[i]) if (level[to[i]] == -1 && cap[i] > flow[i]) { q.push(to[i]); level[to[i]] = level[x] + 1; } } return (level[t] != -1); } int dfs(int v, int t, int f) { int i; if (v == t) return f; for (i = used[v]; i >= 0; used[v] = i = _prev[i]) if (level[to[i]] > level[v] && cap[i] > flow[i]) { int tmp = dfs(to[i], t, min(f, cap[i] - flow[i])); if (tmp > 0) { flow[i] += tmp; flow[i ^ 1] -= tmp; return tmp; } } return 0; } int maxflow(int s, int t) { int i; while (bfs(s, t)) { for ((i) = 0; (i) < (int)(V); (i)++) used[i] = last[i]; while (dfs(s, t, (1 << 29)) != 0) ; } int ans = 0; for (i = last[s]; i >= 0; i = _prev[i]) ans += flow[i]; return ans; } }; int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1}; int X, Y; string board[30]; int dist[30][30][30][30]; int A, B; int cx, cy, ct; int ax[500], ay[500], at[500]; int bx[500], by[500], bt[500]; queue<int> q; void bfs(int s, int t) { int i, j; for ((i) = 0; (i) < (int)(X); (i)++) for ((j) = 0; (j) < (int)(Y); (j)++) dist[s][t][i][j] = (1 << 29); if (board[s][t] == # ) return; dist[s][t][s][t] = 0; q.push(s); q.push(t); while (!q.empty()) { int x = q.front(); q.pop(); int y = q.front(); q.pop(); for ((i) = 0; (i) < (int)(4); (i)++) { int x2 = x + dx[i], y2 = y + dy[i]; if (x2 >= 0 && x2 < X && y2 >= 0 && y2 < Y && board[x2][y2] != # && dist[s][t][x2][y2] == (1 << 29)) { dist[s][t][x2][y2] = dist[s][t][x][y] + 1; q.push(x2); q.push(y2); } } } } bool check(long long T) { int i, j, k; MaxFlow mf(A + A + 2 * (X * Y) + 2); int V = A + A + 2 * (X * Y) + 2; for ((i) = 0; (i) < (int)(A); (i)++) mf.add_edge(V - 2, i, 1); for ((i) = 0; (i) < (int)(A); (i)++) mf.add_edge(A + i, V - 1, 1); for ((i) = 0; (i) < (int)(X * Y); (i)++) mf.add_edge(A + A + i, A + A + X * Y + i, 1); for ((i) = 0; (i) < (int)(A); (i)++) for ((j) = 0; (j) < (int)(X); (j)++) for ((k) = 0; (k) < (int)(Y); (k)++) { int d = dist[ax[i]][ay[i]][j][k]; if (d != (1 << 29) && (long long)d * at[i] <= T) mf.add_edge(i, A + A + j * Y + k, 1); } for ((i) = 0; (i) < (int)(A); (i)++) for ((j) = 0; (j) < (int)(X); (j)++) for ((k) = 0; (k) < (int)(Y); (k)++) { int d = dist[bx[i]][by[i]][j][k]; if (d != (1 << 29) && (long long)d * bt[i] <= T) mf.add_edge(A + A + X * Y + j * Y + k, A + i, 1); } int f = mf.maxflow(V - 2, V - 1); return (f == A); } int main(void) { int i, j; cin >> X >> Y >> A >> B; for ((i) = 0; (i) < (int)(X); (i)++) cin >> board[i]; for ((i) = 0; (i) < (int)(X); (i)++) for ((j) = 0; (j) < (int)(Y); (j)++) bfs(i, j); cin >> cx >> cy >> ct; for ((i) = 0; (i) < (int)(A); (i)++) cin >> ax[i] >> ay[i] >> at[i]; for ((i) = 0; (i) < (int)(B); (i)++) cin >> bx[i] >> by[i] >> bt[i]; cx--; cy--; for ((i) = 0; (i) < (int)(A); (i)++) { ax[i]--; ay[i]--; } for ((i) = 0; (i) < (int)(B); (i)++) { bx[i]--; by[i]--; } if (A < B) { ax[A] = cx; ay[A] = cy; at[A] = ct; A++; } else { bx[B] = cx; by[B] = cy; bt[B] = ct; B++; } if (A != B) { cout << -1 << endl; return 0; } long long low = -1, high = (1ll << 40); while (high - low > 1) { long long mid = (low + high) / 2; if (check(mid)) high = mid; else low = mid; } if (high == (1ll << 40)) high = -1; cout << high << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; const int INF = 1e9; const long long LINF = 1e18; int n, m, k; bool noted[13]; bool connected[13][13]; int cnt = 0; set<long long> st; set<set<int>> sets; vector<int> vec[13]; long long pw[13]; bool visitedd[13]; map<long long, bool> visiteddd[13][13]; void bruteforce_string(int u, int v, int d, long long code) { if (d == n / 2) { if (!connected[u][v]) return; cnt++; st.insert(code); return; } for (int x : vec[u]) for (int y : vec[v]) { if (x == y) continue; if (visitedd[x] || visitedd[y]) continue; long long nx = min(x, y); long long ny = max(x, y); long long ncode = code + (ny << (4LL * nx)); if (!visiteddd[nx][ny][ncode]) { visiteddd[nx][ny][ncode] = 1; visitedd[x] = 1; visitedd[y] = 1; bruteforce_string(nx, ny, d + 1, ncode); visitedd[x] = 0; visitedd[y] = 0; } } } int cnt2 = 0; map<set<int>, bool> visited; void bruteforce_striling(set<int> st) { visited[st] = 1; if (st.size() == 1) return; for (auto it = st.begin(); it != st.end(); it++) { auto jt = it; ++jt; for (; jt != st.end(); jt++) { set<int> nt = st; nt.erase(*it); nt.erase(*jt); nt.insert(*it + *jt); if (!visited[nt]) bruteforce_striling(nt); } } } long long P(int n, int k) { long long res = 1; for (int i = 0; i < k; i++) res = (res * (n - i)); return res; } int main() { pw[0] = 1; for (int i = 1; i <= 12; i++) pw[i] = pw[i - 1] * 13; scanf( %d %d %d n , &n, &m, &k); for (int i = 1; i <= m; i++) { int u, v; scanf( %d %d , &u, &v); vec[u].push_back(v); vec[v].push_back(u); connected[u][v] = connected[v][u] = 1; } for (int i = 1; i <= n; i++) { for (int j = i + 1; j <= n; j++) { visitedd[i] = 1; visitedd[j] = 1; bruteforce_string(i, j, 1, ((1LL * j) << (4 * i))); visitedd[i] = 0; visitedd[j] = 0; } } for (auto it : st) { set<int> temp; for (int i = 1; i <= 12; i++) { int u = i; int v = ((it >> (4LL * i)) & 15); if (v) temp.insert((1 << u) + (1 << v)); } sets.insert(temp); } for (auto it : sets) { if (!visited[it]) bruteforce_striling(it); } long long res = 0; for (auto it : visited) { res += P(k, it.first.size()); } printf( %lld n , res); }
|
#include <bits/stdc++.h> using namespace std; char s[2000005], str[2000005]; int pre[2000005]; int find(int x) { return x == pre[x] ? x : pre[x] = find(pre[x]); } int main() { int n, q, x; while (scanf( %d , &n) != EOF) { for (int i = 1; i < 2000005; i++) pre[i] = i; int maxx = 0; while (n--) { scanf( %s%d , str, &q); int len = strlen(str); while (q--) { scanf( %d , &x); maxx = max(maxx, x + len); for (int i = find(x); i < x + len; i = pre[i] = find(i + 1)) s[i] = str[i - x]; } } for (int i = 1; i < maxx; i++) { if (s[i] == 0 ) s[i] = a ; } printf( %s , s + 1); } return 0; }
|
#include <bits/stdc++.h> using namespace std; const int N = 1e5 + 500; int n, s, deg[N], cnt; int main() { scanf( %d%d , &n, &s); for (int i = 1; i < n; i++) { int x, y; scanf( %d%d , &x, &y); deg[x]++; deg[y]++; } for (int i = 1; i <= n; i++) if (deg[i] == 1) cnt++; if (n == 2) printf( %.10lf n , (double)s); else printf( %.10lf n , (double)(2 * s) / (double)cnt); }
|
#include <bits/stdc++.h> using namespace std; const int maxn = 2e5 + 50; const int magic = 2500; struct Node { int from, to, delta, add; Node(int from, int to, int delta, int add) : from(from), to(to), delta(delta), add(add) {} }; int n, a[maxn], c[maxn], q[maxn], id[maxn], b[maxn], ans[maxn], Q; vector<Node> All; void BuildInterval() { for (auto&& x : All) for (int i = x.from; i <= x.to; ++i) b[id[i]] -= x.delta, ans[id[i]] += x.add; for (int i = 1; i <= Q; ++i) id[i] = i; sort(id + 1, id + Q + 1, [&](const int& x, const int& y) { return b[x] < b[y]; }); All.clear(); All.push_back(Node(1, Q, 0, 0)); } int main(int argc, char* argv[]) { scanf( %d , &n); for (int i = 1; i <= n; ++i) scanf( %d%d , c + i, q + i), id[i] = i; sort(id + 1, id + n + 1, [&](const int& x, const int& y) { return q[x] > q[y] || (q[x] == q[y] && c[x] < c[y]); }); for (int i = 1; i <= n; ++i) a[i] = c[id[i]]; scanf( %d , &Q); for (int i = 1; i <= Q; ++i) scanf( %d , b + i); BuildInterval(); for (int i = 1; i <= n; ++i) { for (int j = 0, limit = All.size(); j < limit; ++j) { if (All[j].from > All[j].to) continue; if (b[id[All[j].from]] - All[j].delta >= a[i]) All[j].delta += a[i], ++All[j].add; else if (b[id[All[j].to]] - All[j].delta >= a[i]) { int l = All[j].from + 1, r = All[j].to; while (l < r) { int mid = l + r >> 1; if (b[id[mid]] - All[j].delta >= a[i]) r = mid; else l = mid + 1; } All.push_back(Node(l, All[j].to, All[j].delta + a[i], All[j].add + 1)); All[j].to = l - 1; } } if (All.size() > magic || i == n) BuildInterval(); } for (int i = 1; i <= Q; ++i) printf( %d , ans[i]); puts( ); return 0; }
|
#include <bits/stdc++.h> using namespace std; const int INF = 0x3f3f3f3f, N = 3.1e5; int n, m, dis[N], fm[N]; vector<int> vec[N]; void bfs() { memset(dis, 0x3f, sizeof(dis)); queue<int> q; q.push(1); dis[1] = 0; while (!q.empty()) { int u = q.front(); q.pop(); for (int v : vec[u]) if (dis[v] == INF) dis[v] = dis[u] + 1, fm[v] = u, q.push(v); } } int x[N], y[N], fa[N], sz[N], d[N]; bool vis[N]; int find(int u) { return u == fa[u] ? u : fa[u] = find(fa[u]); } int main() { ios::sync_with_stdio(0); cin.tie(0); cin >> n >> m; for (int i = 1; i <= m; i++) cin >> x[i] >> y[i], vec[x[i]].push_back(y[i]), vec[y[i]].push_back(x[i]); bfs(); stack<int> s; if (dis[n] <= 4) for (int i = n; i; i = fm[i]) s.push(i); else { bool ok = 0; for (int i = 1; i <= n; i++) if (dis[i] == 2) { s.push(n); s.push(1); s.push(i); s.push(fm[i]); s.push(1); ok = 1; break; } if (!ok) { for (int i = 1; i <= n; i++) fa[i] = i, sz[i] = 1; for (int i = 1; i <= m; i++) if (x[i] != 1 && y[i] != 1 && dis[x[i]] == 1 && dis[y[i]] == 1) { int u = x[i], v = y[i]; d[u]++, d[v]++; int fv = find(v), fu = find(u); if (fu == fv) continue; fa[fv] = fu, sz[fu] += sz[fv]; } for (int i = 1; i <= n; i++) if (dis[i] == 1 && d[i] != sz[find(i)] - 1) { for (int v : vec[i]) if (v != 1) vis[v] = 1; for (int v : vec[i]) if (v != 1) { bool Get = 0; for (int vv : vec[v]) if (vv != 1 && vv != i && !vis[vv]) { s.push(n); s.push(i); s.push(vv); s.push(v); s.push(i); s.push(1); Get = 1; break; } if (Get) break; } break; } } } cout << int(s.size() - 1) << endl; while (!s.empty()) cout << s.top() << , s.pop(); return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int t; cin >> t; while (t-- > 0) { int n, m; cin >> n; int a[n]; for (int i = 0; i < n; i++) { cin >> a[i]; } int i = 0, t = 0, f = 0; while (i < n - 1) { if (a[0] != 1) { f = 1; cout << First n ; break; } else if (a[0] == 1) { while (i < n - 1 && a[i] == 1) { t++; i++; } break; } i++; } if (t % 2 == 0 && f == 0) { cout << First n ; } else if (t % 2 == 1 && f == 0) { cout << Second n ; } } return 0; }
|
#include <bits/stdc++.h> #pragma GCC optimize( O3 ) #pragma GCC target( popcnt ) using namespace std; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); int n; cin >> n; vector<pair<char, int>> arr; for (int i = 0; i < 2 * n; i++) { char sym; cin >> sym; int tmp; if (sym == + ) { tmp = 1; } else { cin >> tmp; } arr.emplace_back(sym, tmp); } reverse(arr.begin(), arr.end()); stack<int> mys; string s = YES ; vector<int> ans; for (int i = 0; i < int(arr.size()); i++) { char sym; int x; tie(sym, x) = arr[i]; if (sym == + ) { if (mys.empty()) { s = NO ; break; } ans.push_back(mys.top()); mys.pop(); } else { if (!mys.empty() && mys.top() < x) { s = NO ; break; } mys.push(x); } } cout << s << n ; if (s == YES ) { reverse(ans.begin(), ans.end()); for (auto ele : ans) { cout << ele << ; } } }
|
#include <bits/stdc++.h> using namespace std; int main() { int q; cin >> q; int l[500], r[500], d[500], ans[500]; for (int i = 0; i < q; i++) { cin >> l[i] >> r[i] >> d[i]; int quo; if (d[i] < l[i]) { ans[i] = d[i]; } else { quo = int(r[i] / d[i]); ans[i] = d[i] * (quo + 1); } } for (int i = 0; i < q; i++) { cout << ans[i] << endl; } return 0; }
|
#include <bits/stdc++.h> using namespace std; long long n, v[100010], c[100010], l[100010], r, mx = 0; map<long long, long long> dp, path, acp; vector<long long> ans, vt[3 * 100010]; void getdp(long long x) { long long i, ss; dp.clear(); path.clear(); acp.clear(); for (i = 0; i < vt[x].size(); i++) { dp[l[vt[x][i]]] = dp[l[vt[x][i]] + c[vt[x][i]]] = -1000000000000000000; path[l[vt[x][i]]] = path[l[vt[x][i]] + c[vt[x][i]]] = -1; acp[vt[x][i]] = -1; } dp[0] = 0; for (ss = 0; ss < vt[x].size(); ss++) { i = vt[x][ss]; if (l[i] == 0) { if (v[i] > dp[l[i] + c[i]] || path[l[i] + c[i]] == -1) { dp[l[i] + c[i]] = v[i]; path[l[i] + c[i]] = i; acp[i] = -1; } } else { if (path[l[i]] == -1) { continue; } if (dp[l[i]] + v[i] > dp[l[i] + c[i]] || path[l[i] + c[i]] == -1) { dp[l[i] + c[i]] = dp[l[i]] + v[i]; path[l[i] + c[i]] = i; acp[i] = path[l[i]]; } } } i = path[x]; if (dp[x] > mx) { mx = dp[x]; ans.clear(); while (i != -1) { ans.push_back(i); i = acp[i]; } } return; } int main() { long long i, j, mx = 0; scanf( %lld , &n); for (i = 0; i < n; i++) { scanf( %lld%lld%lld%lld , &v[i], &c[i], &l[i], &r); vt[c[i] + l[i] + r].push_back(i); } for (i = 0; i <= 300000; i++) { if (vt[i].empty()) { continue; } getdp(i); } sort(ans.begin(), ans.end()); printf( %lld n , (long long)ans.size()); for (i = 0; i < ans.size(); i++) { printf( %lld , ans[i] + 1); } puts( ); return 0; }
|
#include <bits/stdc++.h> using namespace std; const int N = 300005, M = 25; const long long p = 998244353ll; inline long long expo(long long a, int b = 998244351) { long long c = 1ll; while (b) { if (b & 1) c = c * a % p; b >>= 1; a = a * a % p; } return c; } long long FAC[N], IFA[N]; inline long long comb(int a, int b) { return (b < 0 || b > a) ? 0ll : (FAC[a] * (IFA[b] * IFA[a - b] % p) % p); } vector<int> L[N], R[N]; int I[N], C[M << 1]; long long E[M], ss; inline void dfs(int m, long long a, int w = 1) { if (m) { dfs(m - 1, a, w); if ((ss & E[m]) == E[m]) dfs(m - 1, a & (~E[m]), -w); } else { C[__builtin_popcountll(a)] += w; } } int main() { int n, m, i, a, b, c = 0, f = 0, c0 = 0, c1 = 0; long long ans = 0ll, s1 = 0ll; vector<int>::iterator d; scanf( %d%d , &n, &m); FAC[0] = 1ll; for (i = (1); i <= (n); ++i) FAC[i] = FAC[i - 1] * i % p; IFA[n] = expo(FAC[n]); for (i = (n); i >= (1); --i) IFA[i - 1] = IFA[i] * i % p; for (i = (1); i <= (n); ++i) { scanf( %d%d , &a, &b); L[a].push_back(i); R[b].push_back(i); } for (i = (1); i <= (m); ++i) { scanf( %d%d , &a, &b); if (!I[a]) I[a] = ++c; if (!I[b]) I[b] = ++c; E[i] = (1ll << I[a]) | (1ll << I[b]); } C[0] = 1; for (i = (1); i <= (n); ++i) { for (d = L[i].begin(); d != L[i].end(); ++d) { a = *d; if (I[a]) { ++c1; f = 1; s1 |= 1ll << I[a]; } ++c0; } if (f) { for (a = (0); a <= (c1); ++a) C[a] = 0; ss = s1; dfs(m, s1); f = 0; } for (a = (0); a <= (c1); ++a) ans = (ans + (C[c1 - a] + p) * comb(c0 - a, i - a)) % p; for (d = R[i].begin(); d != R[i].end(); ++d) { a = *d; if (I[a]) { --c1; f = 1; s1 ^= 1ll << I[a]; } --c0; } } printf( %lld , ans); return 0; }
|
#include <bits/stdc++.h> using namespace std; void ga(int N, int *A) { for (int i(0); i < N; i++) cin >> A[i]; } int main(void) { ios_base::sync_with_stdio(false); string num; getline(cin, num); int ln = num.length(); int b = 0; int st = 0; int en = ln; bool dot = 0; for (char e : num) { dot = dot or (e == . ); } for (int i(0); i < ln; i++) { if (num[i] != 0 ) { st = i; break; } } for (int i = ln - 1; i > 0; i--) { if (num[i] != 0 ) { en = i + 1; break; } }; ; if (num[st] == . ) { b--; for (int i(st + 1); i < ln; i++) { if (num[i] != 0 ) { st = i; break; } b--; } cout << num[st] << (en - st - 1 == 0 ? : . ) << num.substr(st + 1, en - st - 1) << E << b << endl; return 0; } else { b--; for (int i(st); i < ln; i++) { if (num[i] == . ) { en--; num.erase(i, 1); break; } b++; }; for (int i = en - 1; i >= 0; i--) { if (num[i] != 0 ) { ; en = i + 1; break; } } cout << num[st] << (en - st - 1 == 0 ? : . ) << num.substr(st + 1, en - st - 1) << (b == 0 ? : E + to_string(b)) << endl; } return 0; }
|
#include <bits/stdc++.h> using namespace std; int n, m; int a[1000005]; inline int Pow_Log(int x, int p) { int sol = 1; while (p) { if (p & 1) { sol = (1LL * sol * x) % 1000000009; --p; } p >>= 1; x = (1LL * x * x) % 1000000009; } return sol; } int main() { int i, j, sol = 1, x; cin.sync_with_stdio(0); cin >> n >> m; x = Pow_Log(2, m); for (i = 1; i <= n; ++i) { --x; if (x < 0) x += 1000000009; sol = (1LL * sol * x) % 1000000009; } cout << sol; return 0; }
|
#include <bits/stdc++.h> using namespace std; long long int n, m, a, b, c, d, k, x, y, z, ans = 0, total = 0; long long int arr[201000] = {0}; int main(void) { cin >> n >> m; for (int i = 0; i < n; i++) cin >> arr[i]; sort(arr, arr + n); a = (n / 2); ans += abs(arr[a] - m); for (int i = a + 1; i < n; i++) { if (arr[i] < m) { ans += abs(arr[i] - m); } else { break; } } for (int i = a - 1; i >= 0; i--) { if (arr[i] > m) { ans += abs(arr[i] - m); } else { break; } } cout << ans << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; string file[10005]; unordered_map<string, pair<int, int> > ss; unordered_map<string, bool> sk; void deal(const string &in, int loc) { sk.clear(); int len = in.size(); string temp; for (int i = 1; i <= len; ++i) { for (int j = 0; j <= len - i; ++j) { temp.clear(); for (int k = j; k < i + j; ++k) { temp.push_back(in[k]); } auto &flag = sk[temp]; if (flag) continue; else { flag = true; auto it = ss.find(temp); if (it == ss.end()) { ss.emplace(make_pair(temp, make_pair(loc, 1))); } else ++it->second.second; } } } } string quest; int main() { int n, m; ios::sync_with_stdio(false); cin >> n; for (int i = 0; i < n; ++i) { cin >> file[i]; deal(file[i], i); } cin >> m; while (m--) { cin >> quest; auto it = ss.find(quest); if (it != ss.end()) { cout << it->second.second << << file[it->second.first] << n ; } else { cout << 0 - n ; } } return 0; }
|
#define DEBUG 0 #include <bits/stdc++.h> using namespace std; #if DEBUG // basic debugging macros int __i__,__j__; #define printLine(l) for(__i__=0;__i__<l;__i__++){cout<< - ;}cout<<endl #define printLine2(l,c) for(__i__=0;__i__<l;__i__++){cout<<c;}cout<<endl #define printVar(n) cout<<#n<< : <<n<<endl #define printArr(a,l) cout<<#a<< : ;for(__i__=0;__i__<l;__i__++){cout<<a[__i__]<< ;}cout<<endl #define print2dArr(a,r,c) cout<<#a<< : n ;for(__i__=0;__i__<r;__i__++){for(__j__=0;__j__<c;__j__++){cout<<a[__i__][__j__]<< ;}cout<<endl;} #define print2dArr2(a,r,c,l) cout<<#a<< : n ;for(__i__=0;__i__<r;__i__++){for(__j__=0;__j__<c;__j__++){cout<<setw(l)<<setfill( )<<a[__i__][__j__]<< ;}cout<<endl;} // advanced debugging class // debug 1,2, A , test ; class _Debug { public: template<typename T> _Debug& operator,(T val) { cout << val << endl; return *this; } }; #define debug _Debug(), #else #define printLine(l) #define printLine2(l,c) #define printVar(n) #define printArr(a,l) #define print2dArr(a,r,c) #define print2dArr2(a,r,c,l) #define debug #endif // define #define MAX_VAL 999999999 #define MAX_VAL_2 999999999999999999LL #define EPS 1e-6 #define mp make_pair #define pb push_back // typedef typedef unsigned int UI; typedef long long int LLI; typedef unsigned long long int ULLI; typedef unsigned short int US; typedef pair<int,int> pii; typedef pair<LLI,LLI> plli; typedef vector<int> vi; typedef vector<LLI> vlli; typedef vector<pii> vpii; typedef vector<plli> vplli; // ---------- END OF TEMPLATE ---------- #define MOD 1000000007 int modPow(int b,int e) { int r = 1; while (e > 0) { if (e & 1) r = ((LLI) r*b) % MOD; e >>= 1; b = ((LLI) b*b) % MOD; } return r; } int fact[41],C[41][41],ways[40]; int p[40],v[40],occ[41],occ2[41]; int dp[1000000]; int main() { int i; int n; scanf( %d ,&n); for (i = 0; i < n; i++) scanf( %d ,&p[i]),p[i]--; int j,k; fact[0] = 1; for (i = 1; i <= n; i++) fact[i] = ((LLI) i*fact[i-1]) % MOD; for (i = 0; i <= n; i++) { C[i][0] = 1; for (j = 1; j <= i; j++) C[i][j] = (C[i-1][j-1]+C[i-1][j]) % MOD; } for (i = 0; i < n; i++) { for (j = 0; j <= i; j++) { ways[i] += ((((LLI) C[i][j]*fact[j]) % MOD)*fact[n-j-1]) % MOD; ways[i] %= MOD; } } for (i = 0; i < n; i++) { if (!v[i]) { int u = i,c = 0; while (!v[u]) v[u] = 1,u = p[u],c++; occ[c]++; } } int s = 1; for (i = 1; i <= n; i++) s *= occ[i]+1; dp[0] = 1; for (i = 1; i < s; i++) { int t = i,s2 = 1,sum = 0; for (j = 1; j <= n; j++) { occ2[j] = t % (occ[j]+1),s2 *= occ2[j]+1,sum += occ2[j]*j; t /= occ[j]+1; } for (j = 1; j < s2; j++) { int t2 = j,sum2 = 0,num = 0,j2 = 0,pp = 1; LLI c = 1; for (k = 1; k <= n; k++) { int occ3 = t2 % (occ2[k]+1); c *= C[occ2[k]][occ3],c %= MOD,num += occ3,sum2 += occ3*k; j2 += (occ2[k]-occ3)*pp; t2 /= occ2[k]+1,pp *= occ[k]+1; } if (!(num & 1)) c = MOD-c; c *= dp[j2],c %= MOD; dp[i] += (c*modPow(ways[sum-sum2],sum2)) % MOD,dp[i] %= MOD; } } printf( %d n ,dp[s-1]); return 0; }
|
#include <bits/stdc++.h> using namespace std; long long n, a[100069]; int main() { long long t, rr, i; bool bad; scanf( %lld , &t); for (rr = 0; rr < t; rr++) { scanf( %lld , &n); for (i = 1; i <= n * 4; i++) { scanf( %lld , a + i); } sort(a + 1, a + n * 4 + 1); bad = 0; for (i = 1; i <= n * 4; i += 2) { if (a[i] != a[i + 1]) { bad = 1; break; } } for (i = 3; i <= n * 2; i += 2) { if (a[i] * a[n * 4 + 1 - i] != a[1] * a[n * 4]) { bad = 1; break; } } if (bad) { printf( NO n ); } else { printf( YES n ); } } }
|
#include <bits/stdc++.h> using namespace std; int n, m, len, kmpA[100010], ans, kmpB[100010], mxA[100010], mxB[100010]; char S[100010], A[100010], B[100010]; int main() { scanf( %s , S + 1); n = strlen(S + 1); scanf( %d , &m); while (m--) { scanf( %s , A); kmpA[0] = -1; len = strlen(A); if (len == 1) continue; for (int i = 1, k = -1; i <= len; i++) { while (k != -1 && A[i - 1] != A[k]) k = kmpA[k]; k++; kmpA[i] = k; } for (int i = 0; i <= len - 1; i++) B[len - 1 - i] = A[i]; kmpB[0] = -1; for (int i = 1, k = -1; i <= len; i++) { while (k != -1 && B[i - 1] != B[k]) k = kmpB[k]; k++; kmpB[i] = k; } for (int i = 1, k = 0; i <= n; i++) { while (k != -1 && S[i] != A[k]) k = kmpA[k]; k++; mxA[i] = k; } for (int i = n, k = 0; i >= 1; i--) { while (k != -1 && S[i] != B[k]) k = kmpB[k]; k++; mxB[i] = k; } for (int i = 1; i <= n; i++) mxA[i] = max(mxA[i - 1], mxA[i]); for (int i = n; i >= 1; i--) mxB[i] = max(mxB[i + 1], mxB[i]); bool flag = false; for (int i = 1; i <= n + 1; i++) { if (mxA[i - 1] + mxB[i] >= len) { flag = true; break; } } ans += flag; } cout << ans; return 0; }
|
#include <bits/stdc++.h> using namespace std; bitset<1005> tt[30]; unordered_map<bitset<1005>, int> ff; pair<bitset<1005>, int> ar[1000005]; int bc[1000005]; void print(bitset<1005> t) { for (int i = 0; i < 12; ++i) { if (t[i]) { putchar( 1 ); } else { putchar( 0 ); } } putchar( n ); } int construct(int l, int r, bool isG) { bitset<1005> tmp; ar[0] = {tmp, 0}; int cc = 1; for (int i = l; i <= r; ++i) { int ind = i; if (isG) { ind -= l; } int tcc = cc; for (int j = 0; j < cc; ++j) { ar[tcc++] = {ar[j].first ^ tt[i], (1 << ind) + ar[j].second}; } cc = tcc; } if (!isG) { for (int i = 0; i < cc; ++i) { if (!ff.count(ar[i].first)) { ff[ar[i].first] = bc[ar[i].second]; } else { ff[ar[i].first] = min(ff[ar[i].first], bc[ar[i].second]); } } } return cc; } void solve() { int n, s, d; scanf( %d %d %d , &n, &s, &d); for (int i = 0; i < s; ++i) { int x; scanf( %d , &x); while (x--) { int t; scanf( %d , &t); tt[i][t - 1] = 1; } } bc[0] = 0; for (int i = 1; i < 1000005; ++i) { bc[i] = bc[i / 2] + (i & 1); } int g = min(s - 1, 18); construct(0, g, 0); int sz = construct(g + 1, s - 1, 1); while (d--) { bitset<1005> tmp; int x; scanf( %d , &x); while (x--) { int t; scanf( %d , &t); tmp[t - 1] = 1; } const int inf = 1e9; int ret = inf; for (int i = 0; i < sz; ++i) { if (ff.count(tmp ^ ar[i].first)) { ret = min(ret, bc[ar[i].second] + ff[tmp ^ ar[i].first]); } } if (ret == inf) { ret = -1; } printf( %d n , ret); } } int main() { solve(); 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 n1, n2, n3; cin >> n1 >> n2 >> n3; vector<long long> a, b, c; for (long long i = (0); i < (n1); i++) { long long m; cin >> m; a.push_back(m); } for (long long i = (0); i < (n2); i++) { long long m; cin >> m; b.push_back(m); } for (long long i = (0); i < (n3); i++) { long long m; cin >> m; c.push_back(m); } sort(a.begin(), a.end()); sort(b.begin(), b.end()); sort(c.begin(), c.end()); long long ans = 9e18L; long long fans = 9e18L; for (long long i = (0); i < (n1); i++) { long long x = a[i]; long long yi = lower_bound(b.begin(), b.end(), x) - b.begin(); long long zi = upper_bound(c.begin(), c.end(), x) - c.begin(); zi--; if (zi >= 0 && zi < n3 && yi >= 0 && yi < n2) { long long y = b[yi]; long long z = c[zi]; ans = (x - y) * (x - y) + (x - z) * (x - z) + (z - y) * (z - y); fans = min(fans, ans); } } for (long long i = (0); i < (n1); i++) { long long x = a[i]; long long yi = upper_bound(b.begin(), b.end(), x) - b.begin(); long long zi = lower_bound(c.begin(), c.end(), x) - c.begin(); yi--; if (zi >= 0 && zi < n3 && yi >= 0 && yi < n2) { long long y = b[yi]; long long z = c[zi]; ans = (x - y) * (x - y) + (x - z) * (x - z) + (z - y) * (z - y); fans = min(fans, ans); } } for (long long i = (0); i < (n2); i++) { long long x = b[i]; long long yi = lower_bound(a.begin(), a.end(), x) - a.begin(); long long zi = upper_bound(c.begin(), c.end(), x) - c.begin(); zi--; if (zi >= 0 && zi < n3 && yi >= 0 && yi < n1) { long long y = a[yi]; long long z = c[zi]; ans = (x - y) * (x - y) + (x - z) * (x - z) + (z - y) * (z - y); fans = min(fans, ans); } } for (long long i = (0); i < (n2); i++) { long long x = b[i]; long long yi = upper_bound(a.begin(), a.end(), x) - a.begin(); long long zi = lower_bound(c.begin(), c.end(), x) - c.begin(); yi--; if (zi >= 0 && zi < n3 && yi >= 0 && yi < n1) { long long y = a[yi]; long long z = c[zi]; ans = (x - y) * (x - y) + (x - z) * (x - z) + (z - y) * (z - y); fans = min(fans, ans); } } for (long long i = (0); i < (n3); i++) { long long x = c[i]; long long yi = upper_bound(b.begin(), b.end(), x) - b.begin(); long long zi = lower_bound(a.begin(), a.end(), x) - a.begin(); yi--; if (zi >= 0 && zi < n1 && yi >= 0 && yi < n2) { long long y = b[yi]; long long z = a[zi]; ans = (x - y) * (x - y) + (x - z) * (x - z) + (z - y) * (z - y); fans = min(fans, ans); } } for (long long i = (0); i < (n3); i++) { long long x = c[i]; long long yi = lower_bound(b.begin(), b.end(), x) - b.begin(); long long zi = upper_bound(a.begin(), a.end(), x) - a.begin(); zi--; if (zi >= 0 && zi < n1 && yi >= 0 && yi < n2) { long long y = b[yi]; long long z = a[zi]; ans = (x - y) * (x - y) + (x - z) * (x - z) + (z - y) * (z - y); fans = min(fans, ans); } } cout << fans << n ; } }
|
#include <bits/stdc++.h> using namespace std; mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count()); const int INF = 2e9; int main() { ios_base::sync_with_stdio(0); cin.tie(0); int n, p; cin >> n >> p; vector<int> a(n); for (int i = 0; i < (int)(n); i++) cin >> a[i]; sort((a).begin(), (a).end()); int l = -INF, r = INF; for (int i = 0; i < (int)(n); i++) { l = max(l, a[i] - i); if (p - 1 <= i) r = min(r, a[i] - i + (p - 1)); } vector<int> ans; for (int i = l; i < r; i++) ans.push_back(i); cout << ((int)(ans).size()) << endl; for (auto x : ans) cout << x << ; return 0; }
|
#include <bits/stdc++.h> using namespace std; int getReverted(int num) { bool bin[8] = {0}; for (int j = 0; num != 0; j++) { bin[j] = num % 2; num /= 2; } for (int j = 0; j < 8; j++) { num += (int)bin[j] * pow(2, 7 - j); } return num; } int strSize(char *str) { int i; for (i = 0; str[i] != 0 ; i++) ; return i; } int main() { char str[101]; int last = 0, result, size, reverted; scanf( %[^ n]s , str); size = strSize(str); for (int i = 0; str[i] != 0 ; i++) { reverted = getReverted(str[i]); result = (last - reverted) % 256; if (result < 0) while (result < 0) result += 256; cout << result; if (i != size - 1) cout << endl; last = getReverted(str[i]); } return 0; }
|
#include <bits/stdc++.h> using namespace std; string getmin(string prev, string cur) { if (prev.length() < cur.length()) { for (int i = 0; i < cur.length(); i++) { if (cur[i] == ? ) cur[i] = (i == 0) ? 1 : 0 ; } return cur; } if (prev.length() > cur.length()) return ; int fmsm = 100; for (int i = 0; i < cur.length(); i++) { if (cur[i] == ? ) continue; if (cur[i] != prev[i]) { fmsm = i; break; } } int nm = 0; for (int i = 0; i < cur.length(); i++) { if (i == fmsm) { if (cur[i] < prev[i]) nm++; } if (cur[i] == ? ) { if (i < fmsm) nm = nm * 10 + prev[i] - 0 ; else { nm *= 10; } } } if (fmsm == 100) nm++; for (int i = cur.length() - 1; i >= 0; i--) { if (cur[i] == ? ) { cur[i] = 0 + nm % 10; nm /= 10; } } if (nm) return ; return cur; } int main() { int n; scanf( %d , &n); string cur = ; vector<string> nums; for (int i = 0; i < n; i++) { char ch[32]; scanf( %s , ch); string chs(ch); string x = getmin(cur, chs); if (x.empty()) { printf( NO n ); return 0; } nums.push_back(x); cur = x; } printf( YES n ); for (int i = 0; i < n; i++) printf( %s n , nums[i].c_str()); return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { ios::sync_with_stdio(0); int t, ang; cin >> t; while (t--) { cin >> ang; int ans = -1; for (int i = 3; i <= 360; ++i) { int k = ang * i / 180; if ((ang * i) % 180 == 0 && 360 % i == 0 && 1 <= k && k <= i - 2) { ans = i; break; } } cout << ans << endl; } return 0; }
|
#include <bits/stdc++.h> using namespace std; const int N = 1e3 + 1; char a[N], b[N]; vector<int> g[26]; bool vis[26][26]; vector<pair<char, char> > sol; char go[26]; int main() { scanf( %s%s , a, b); int n = strlen(a); for (int i = 0; i < n; ++i) { if (a[i] == b[i]) continue; int x = a[i] - a ; int y = b[i] - a ; g[x].push_back(y); g[y].push_back(x); } bool can = true; for (int i = 0; i < 26 && can; ++i) { sort(g[i].begin(), g[i].end()); g[i].resize(unique(g[i].begin(), g[i].end()) - g[i].begin()); can &= g[i].size() <= 1; } if (!can) { puts( -1 ); return 0; } for (int i = 0; i < 26; ++i) if (!g[i].empty()) { int x = min(i, g[i][0]), y = max(i, g[i][0]); if (vis[x][y]) continue; go[x] = y + a ; go[y] = x + a ; vis[x][y] = true; sol.push_back(make_pair(x + a , y + a )); } else go[i] = i + a ; for (int i = 0; i < 26 && can; ++i) { can &= go[a[i] - a ] == b[i]; can &= go[b[i] - a ] == a[i]; } if (!can) { puts( -1 ); return 0; } printf( %d n , (int)sol.size()); for (int i = 0; i < (int)sol.size(); ++i) printf( %c %c n , sol[i].first, sol[i].second); return 0; }
|
#include <bits/stdc++.h> using namespace std; void solve() { int n, k; cin >> n >> k; long long a[n * k]; for (int i = 0; i < n * k; i++) { cin >> a[i]; } long long sum = 0; int jump = ((n + 1) / 2); if (n % 2 == 0) jump++; int count = 0; for (int i = n * k - jump; count < k; i -= jump) { sum += a[i]; count++; } cout << sum << endl; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); int t; cin >> t; while (t--) { solve(); } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n; string input, temp; bool f1, f2; cin >> n; getline(cin, input); for (int i = 0; i < n; i++) { f1 = false; f2 = false; getline(cin, input); if (input.length() > 4) { temp = input.substr(0, 5); if (temp == miao. ) f2 = true; temp = input.substr(input.length() - 5, 5); if (temp == lala. ) f1 = true; } if (f1 && !f2) cout << Freda s << endl; else if (f2 && !f1) cout << Rainbow s << endl; else cout << OMG>.< I don t know! << endl; } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; int arr[n]; for (int i = 0; i < n; i++) { cin >> arr[i]; } sort(arr, arr + n); int runsum = 0; int pen = 0; int k = 0; while (runsum <= 350 && ((runsum + arr[k]) <= 710) && k < n) runsum += arr[k++]; if (runsum <= 350) { cout << k << 0 << endl; } else { runsum -= 350; pen += runsum; while ((runsum + arr[k]) <= 360 && k < n) { runsum += arr[k++]; pen += runsum; } cout << k << << pen << endl; } }
|
#include <bits/stdc++.h> using namespace std; int temp1[26]; int temp2[1001][26]; set<int> myset[1001]; set<int> empty; vector<int> myvec; int main() { int n; cin >> n; string str; cin >> str; int m; cin >> m; string arr[m]; for (int i = 0; i < m; i++) { cin >> arr[i]; } for (int i = 0; i < n; i++) { if (str[i] != * ) { temp1[str[i] - a ] = 1; } } for (int i = 0; i < m; i++) { for (int j = 0; j < n; j++) { if (str[j] == * ) { if (temp1[arr[i][j] - a ] == 1) { myset[i] = empty; break; } else { myset[i].insert(arr[i][j] - a ); temp2[i][arr[i][j] - a ] = 1; } } else { if (str[j] != arr[i][j]) { myset[i] = empty; break; } } } } for (int i = 0; i < m; i++) { if (myset[i].empty() == false) { myvec.push_back(i); } } int ans = 0; int size = myvec.size(); for (int j = 0; j < 26; j++) { int cnt = 0; for (int i = 0; i < size; i++) { if (temp2[myvec[i]][j] == 1) { cnt++; } } if (cnt == size) { ans++; } } cout << ans << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; const int MAXN = 1e5 + 100; vector<int> G[MAXN]; map<int, int> cnt; bool vis[MAXN]; int sz; int cN, c[MAXN], b[MAXN]; int dp[MAXN]; void dfs(int u) { vis[u] = true; sz++; for (int i = 0; i < G[u].size(); i++) { int v = G[u][i]; if (!vis[v]) dfs(v); } } inline int smin(int &a, int b) { return a = min(a, b); } bool lucky(int x) { while (x) { if (x % 10 != 7 && x % 10 != 4) return false; x /= 10; } return true; } int main() { ios::sync_with_stdio(false); cout.tie(0); cin.tie(0); int n, m; cin >> n >> m; for (int i = 0; i < m; i++) { int a, b; cin >> a >> b; a--; b--; G[a].push_back(b); G[b].push_back(a); } for (int u = 0; u < n; u++) if (!vis[u]) { sz = 0; dfs(u); cnt[sz]++; } for (map<int, int>::iterator iter = cnt.begin(); iter != cnt.end(); iter++) { int x = iter->first, pw = 1; int temp = iter->second; while (temp >= pw) { c[cN++] = x * pw, b[cN - 1] = pw, temp -= pw; pw *= 2; } if (temp) { c[cN++] = x * temp; b[cN - 1] = temp; } } fill(dp, dp + MAXN, -1u / 4); dp[0] = 0; for (int i = 0; i < cN; i++) { int val = c[i]; for (int j = MAXN - 1; j >= 0; j--) if (val + j < MAXN) smin(dp[j + val], dp[j] + b[i]); } int ans = -1u / 4; for (int i = 1; i < MAXN; i++) if (lucky(i)) smin(ans, dp[i]); cout << (ans < MAXN ? ans - 1 : -1) << endl; }
|
#include <bits/stdc++.h> using namespace std; int read() { int xx = 0, ff = 1; char ch = getchar(); while (ch > 9 || ch < 0 ) { if (ch == - ) ff = -1; ch = getchar(); } while (ch >= 0 && ch <= 9 ) { xx = xx * 10 + ch - 0 ; ch = getchar(); } return xx * ff; } int N, K, f[110][100010]; struct Segment { int L, R; } S[110]; int q[100010], head, tail; int main() { N = read(), K = read(); for (int i = 1; i <= K; i++) S[i].L = read(), S[i].R = read(); for (int j = 0; j <= N; j++) f[0][j] = (1 << 29); f[0][0] = 0; for (int i = 1; i <= K; i++) { for (int j = 0; j <= N; j++) f[i][j] = f[i - 1][j]; head = 1, tail = 0; for (int j = 0; j <= S[i].R; j++) { if (j <= N) { while (head <= tail && f[i - 1][j] <= f[i - 1][q[tail]]) tail--; q[++tail] = j; } while (head <= tail && q[head] <= j - (S[i].R - S[i].L + 1)) head++; if (head <= tail) f[i][j] = min(f[i][j], f[i - 1][q[head]] + 2); } head = 1, tail = 0; for (int j = S[i].R; j >= 0; j--) { if (S[i].R - j <= N) { while (head <= tail && f[i - 1][S[i].R - j] <= f[i - 1][q[tail]]) tail--; q[++tail] = S[i].R - j; } while (head <= tail && q[head] <= S[i].L - (j + 1)) head++; if (head <= tail) f[i][j] = min(f[i][j], f[i][q[head]] + 1); } } if (f[K][N] >= (1 << 29)) puts( Hungry ); else { puts( Full ); printf( %d n , f[K][N]); } return 0; }
|
#include<bits/stdc++.h> #define pb push_back using namespace std; typedef long long ll; const int maxn=1e6+100; const int M=1000000007; typedef array<int,41> A; bool vis[50]; int f[50],n,mx,F[50][50],G[50][50],p[50],nf[50],inv[50]; int ways[50][50][50]; map<A,int> dp[41][41][41]; void add(int &x,int y){x+=y;if (x>=M)x-=M;} int C(int x,int y){ if (y<0||y>x) return 0; return 1ll*f[x]*nf[y]%M*nf[x-y]%M; } void init(){ inv[1]=1; for (int i=2;i<=n;i++) inv[i]=M-1ll*(M/i)*inv[M%i]%M; f[0]=nf[0]=1; for (int i=1;i<=n;i++) f[i]=1ll*f[i-1]*i%M,nf[i]=1ll*nf[i-1]*inv[i]%M; F[0][0]=f[n-1]; for (int i=0;i<=n-1;i++) for (int j=1;j+i<=n-1;j++){ F[i][j]=0; for (int x=0;x<=i;x++) for (int y=0;y<=j;y++){ add(F[i][j],1ll*C(i,x)*C(j,y)%M*f[n-1-x-y]%M*f[x+y]%M); if (!y) add(G[i][j],1ll*C(i,x)*C(j,y)%M*f[n-1-x-y]%M*f[x+y]%M); } } for (int i=0;i<=n-1;i++) for (int j=0;j+i<=n-1;j++){ int x=1,y=1; for (int k=1;k<=n;k++){ x=1ll*x*F[i][j]%M; y=1ll*y*G[i][j]%M; ways[i][j][k]=(x-y+M)%M; } } } int solve(int lasttot,int tot,int block,A a){ if (dp[lasttot][tot][block].find(a)!=dp[lasttot][tot][block].end()){ return dp[lasttot][tot][block][a]; } int ret=0,sum=n; for (int i=1;i<=mx;i++) sum-=a[i]*i; if (sum==n) return dp[lasttot][tot][block][a]=nf[block]; A tmp=a; for (int i=1;i<=mx;i++) { if (a[i]){ tmp[i]--; add(ret,1ll*ways[sum-tot-lasttot][lasttot][i]*a[i]%M*solve(lasttot,tot+i,block+1,tmp)%M); if (block) add(ret,1ll*ways[sum-tot][tot][i]*a[i]%M*nf[block]%M*solve(tot,i,1,tmp)%M); tmp[i]++; } } return dp[lasttot][tot][block][a]=ret; } int main(){ scanf( %d ,&n); init(); for (int i=1;i<=n;i++) scanf( %d ,&p[i]); A a; for (int i=0;i<=40;i++) a[i]=0; for (int i=1;i<=n;i++) if (!vis[i]){ int w=0,tmp=i; while (!vis[tmp]){ w++; vis[tmp]=1; tmp=p[tmp]; } a[w]++; mx=max(mx,w); } printf( %d n ,solve(0,0,0,a)); return 0; }
|
#include <bits/stdc++.h> using namespace std; signed main() { ios_base::sync_with_stdio(false); cin.tie(NULL); string s; cin >> s; long long l = s.length(); vector<char> s1; long long pos = -1; for (long long i = 0; i < l; i++) { if (s[i] == a ) pos = i; else s1.push_back(s[i]); } long long l2 = s1.size(); long long ri = l - 1 - pos; long long le = l2 - ri; if (l2 % 2 != 0 || le > ri) cout << :( ; else { long long j = l2 / 2; bool flag = true; for (long long i = 0; i < j; i++) { if (s1[i] != s1[i + j]) { flag = false; break; } } if (!flag) cout << :( ; else { for (long long i = 0; i < l - j; i++) cout << s[i]; } } }
|
#include <bits/stdc++.h> using namespace std; struct node { long long x, y; int id; bool operator<(const node& b) const { if (y != b.y) return y < b.y; else return x < b.x; } } a[210000], b[210000], c, d[210000]; vector<node> q; int n, num, last; int ans[210000]; set<node> s; int main() { cin >> n; for (int i = 1; i <= n; i++) cin >> a[i].x >> a[i].y, a[i].id = i, d[i] = a[i]; sort(a + 1, a + 1 + n); for (int i = n; i >= 1; i--) if (a[i].x > last) last = a[i].x, b[++num] = a[i]; reverse(b + 1, b + 1 + num); for (int i = 1; i <= num; i++) { while (q.size() > 1) { node c = q[q.size() - 1], d = q[q.size() - 2]; if ((c.y - d.y) * d.x * b[i].y * (c.x - b[i].x) < (b[i].y - c.y) * b[i].x * d.y * (d.x - c.x)) q.pop_back(); else break; } q.push_back(b[i]); } num = 0; for (int i = 0; i < q.size(); i++) s.insert(q[i]); for (int i = 1; i <= n; i++) if (s.count(d[i])) printf( %d , i); return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int t; cin >> t; while (t--) { int n, a, b; cin >> n >> a >> b; int N = n; if (abs(a - b) > 1) { cout << -1 << n ; continue; } if (a + b > n - 2) { cout << -1 << n ; continue; } bool flag = false; if (a < b) { swap(a, b); flag = true; } int A = a; int B = b; int sol[n]; int i = 1; while (a--) { sol[i] = n; i += 2; n--; } i = 2; int temp = 1; while (b--) { sol[i] = temp; i += 2; temp++; } sol[0] = B + 1; temp = B + 2; int index = A + B + 1; if (B == A) { while (index != N) { sol[index] = temp; temp++; index++; } } else { temp = N - A; while (index != N) { sol[index] = temp; temp--; index++; } } if (flag) { for (int i = 0; i < N; i++) { sol[i] = N + 1 - sol[i]; } } for (int i = 0; i < N; i++) { cout << sol[i] << ; } cout << n ; } cerr << Time : << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC << ms n ; return 0; }
|
#include <bits/stdc++.h> char str[110]; int main() { int len, t, _max = 0; scanf( %s , str); len = strlen(str); for (int i = 0; i < len; i++) for (int j = i + 1; j < len; j++) { t = 0; while (str[i + t] == str[j + t]) t++; if (t > _max) _max = t; } printf( %d , _max); return 0; }
|
#include <bits/stdc++.h> using namespace std; const long long N = 100; long long n, m, dp[N][N], a[N][N], b[N][N], c[N], len; char go[N][N][N]; char str[N << 1]; inline long long read() { long long sym = 0, res = 0; char ch = 0; while (!isdigit(ch)) sym |= (ch == - ), ch = getchar(); while (isdigit(ch)) res = (res << 3) + (res << 1) + (ch ^ 48), ch = getchar(); return sym ? -res : res; } void file() { freopen( read.in , r , stdin); freopen( write.out , w , stdout); } long long power(long long a, long long x) { long long res = 1; while (x) { if (x & 1) res *= a; a *= a; x >>= 1; } return res; } void write(long long now, long long x, long long y, char ch) { if (now == 0) { printf( %c , ch); return; } if (go[now][x][y] == H ) write(now - 1, x - 1, y, H ); else write(now - 1, x, y - 1, M ); if (now != len) printf( %c , ch); } signed main() { n = read(); len = n << 1; scanf( %s , str + 1); for (long long i = 1; i <= len; i++) { c[i] = str[i] - 0 ; } for (long long i = 1; i <= n; i++) { a[i][i] = a[i - 1][i - 1] + c[i] * power(10, n - i); go[i][i][0] = H ; b[i][i] = b[i - 1][i - 1] + c[i] * power(10, n - i); go[i][0][i] = M ; } for (long long i = 1; i <= len; i++) { for (long long j = max(i - n, 1ll); j <= min(i - 1ll, n); j++) { long long k = i - j, ta = c[i] * power(10, n - j), tb = c[i] * power(10, n - k); if (a[i - 1][j - 1] + ta + b[i - 1][k] > b[i - 1][k - 1] + tb + a[i - 1][j]) { a[i][j] = a[i - 1][j - 1] + ta; b[i][k] = b[i - 1][k]; go[i][j][k] = H ; } else { b[i][k] = b[i - 1][k - 1] + tb; a[i][j] = a[i - 1][j]; go[i][j][k] = M ; } } } write(len, n, n, ); return 0; }
|
#include<bits/stdc++.h> #define ll long long #define vi vector<int> #define vl vector<ll> #define pb push_back #define FASTANDFURIOUS ios_base::sync_with_stdio(0); cin.tie(NULL); cout.tie(NULL); #define rep(i,a,b) for(ll i=a;i<b;i++) #define For(i,n) for(ll i=0;i<n;i++) #define MOD 1000000007 #define MAX 100001 #define pll pair <ll,ll> #define pii pair <int,int> #define dbg(x) cout << #x << : << x << endl; #define fi first #define se second #define read(n,v) For(i,n)cin>>v[i] #define mkp make_pair #define YES cout<< YES n ; #define NO cout<< NO n ; #define No cout<< No n ; #define Yes cout<< Yes n ; #define INF 1e18 using namespace std; ll ncr2(ll n, ll k ) { if (k > n) return 0; if (k * 2 > n) k = n-k; if (k == 0) return 1; ll result = n; for(ll i = 2; i <= k; ++i ) { result = result * (n-i+1); result /= i; } return result; } ll pow(ll x, unsigned int y, int p){ ll 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; } ll _pow(ll a, ll b){ if(!b) return 1; ll temp = _pow(a, b / 2); temp = (temp * temp); if(b % 2) return (a * temp); return temp; } ll invmod(ll a,ll m){ return pow(a,m-2,m); } ll feelthepower(ll x,ll y){ ll res = 1LL; while(y){ if(y&1){ res = (res*1LL*x)%MOD; } x = (x*1LL*x)%MOD; y/=2; } return res; } // ll ncr(ll n,ll r) // { // if(n<r) // return 0; // ll ans=fac[n]; // ans*=invmod(fac[n-r],MOD); // ans%=MOD; // ans*=invmod(fac[r],MOD); // ans%=MOD; // return ans; // } bool has(int kek,int d){ while(kek){ int temp = kek%10; if(temp == d){ return true; } kek/=10; } return false; } signed main(){ FASTANDFURIOUS; #ifndef ONLINE_JUDGE freopen( input.txt , r , stdin); freopen( output.txt , w , stdout); #endif int tc=1; cin>>tc; For(ti,tc){ int n,d; cin>>n>>d; For(i,n){ string s; cin>>s; if(s.length()>2){ cout<< YES n ; } else{ int req = stoi(s); int flag=0; while(req>=0){ if(has(req,d)){ flag=1; break; } else{ req-=d; } } if(flag){ cout<< YES n ; } else{ cout<< NO n ; } } } } }
|
#include <bits/stdc++.h> using namespace std; long long int a1, b1, a2, b2; int main() { scanf( %lld %lld , &a1, &b1); scanf( %lld %lld , &a2, &b2); long long int p, q, ans = 0; p = (a1 * b1); q = (a2 * b2); long long int tp = 0, tq = 0, thp = 0, thq = 0; while ((p % 3) == 0) { p = (p / 3); thp++; } while ((q % 3) == 0) { q = (q / 3); thq++; } while ((p % 2) == 0) { p = (p / 2); tp++; } while ((q % 2) == 0) { q = (q / 2); tq++; } p = (a1 * b1); q = (a2 * b2); long long int x; if (thp > thq) { tp = tp + (thp - thq); ans = ans + (thp - thq); x = (thp - thq); while (x--) { if ((a1 % 3) == 0) a1 = ((a1 / 3) * 2); else b1 = ((b1 / 3) * 2); } } else if (thq > thp) { tq = tq + (thq - thp); ans = ans + (thq - thp); x = (thq - thp); while (x--) { if ((a2 % 3) == 0) a2 = ((a2 / 3) * 2); else b2 = ((b2 / 3) * 2); } } if (tp > tq) { ans = ans + (tp - tq); x = (tp - tq); while (x--) { if ((a1 % 2) == 0) a1 = (a1 / 2); else b1 = (b1 / 2); } } else { ans = ans + (tq - tp); x = (tq - tp); while (x--) { if ((a2 % 2) == 0) a2 = (a2 / 2); else b2 = (b2 / 2); } } if ((a1 * b1) == (a2 * b2)) { printf( %lld n , ans); printf( %lld %lld n , a1, b1); printf( %lld %lld n , a2, b2); } else printf( -1 n ); return 0; }
|
#include <bits/stdc++.h> using namespace std; const long long mod = 1e9 + 7; int t, k, l[1005], r[1005], lenl, lenr; long long f[1005][1005][2]; long long dfs(int *x, int Index, int d, int q, int lim) { if (Index < 1) return (long long)q; if (!lim && f[Index][d][q] != -1) return f[Index][d][q]; long long res = 0; int up = lim ? x[Index] : 9; for (int i = 0; i <= up; i++) { if (i != 4 && i != 7) res = (res + dfs(x, Index - 1, max(d - 1, 0), q, lim && i == up)) % mod; else res = (res + dfs(x, Index - 1, k, q || d, lim && i == up)) % mod; } if (!lim) f[Index][d][q] = res; return res; } long long solve(int *x, int len) { return dfs(x, len, 0, 0, 1); } int main() { scanf( %d %d , &t, &k); memset(f, -1, sizeof f); while (t--) { char now[1005]; scanf( %s , now + 1); lenl = strlen(now + 1); for (int i = 1; i <= lenl; i++) l[lenl - i + 1] = now[i] - 48; scanf( %s , now + 1); lenr = strlen(now + 1); for (int i = 1; i <= lenr; i++) r[lenr - i + 1] = now[i] - 48; l[1]--; int Index = 1; while (l[Index] < 0) { l[Index] = 9; l[Index + 1]--; Index++; } if (Index == lenl && !l[Index]) lenl--; printf( %lld n , (solve(r, lenr) - solve(l, lenl) + mod) % mod); } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n, m; cin >> n >> m; long long ans = 0; for (int i = (0); i < (n); ++i) { long long t, T, x, cost; cin >> t >> T >> x >> cost; if (t >= T) { ans += cost + m * x; continue; } long long aux1 = cost; if (m > (T - t)) aux1 += m * x; long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1; aux2 *= cost; ans += min(aux1, aux2); } cout << ans << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; pair<pair<int, int>, int> a[100001]; pair<int, int> ans[100001]; int n, m, i, j, k, l, r, t, last, b[100001], x, y; map<int, pair<int, int> > mp; int main() { cin >> n >> m; for (i = 0; i < m; i++) { cin >> a[i].first.first >> a[i].first.second; a[i].first.second = 1 - a[i].first.second; b[i] = a[i].first.first; a[i].second = i; } sort(a, a + m); if (a[0].first.second || a[1].first.second) { cout << -1; return 0; } k = 3; for (i = 2; i < m; i++) { if (a[i].first.second) { if (t == (k - 2) * (k - 1) / 2) { cout << -1; return 0; } t++; continue; } k++; } t = 2; for (i = 0; i < m; i++) { if (!a[i].first.second) { ans[a[i].second].first = t - 1; ans[a[i].second].second = t; t++; } } x = 3; y = 1; for (i = 0; i < m; i++) { if (!a[i].first.second) continue; ans[a[i].second].first = y; ans[a[i].second].second = x; y++; if (x == y + 1) { x++; y = 1; } } for (i = 0; i < m; i++) { cout << ans[i].first << << ans[i].second << endl; } }
|
#include <bits/stdc++.h> using namespace std; const int inv = 1000000000; const int minv = -inv; const int max_n = 500000 + 5; const int max_cn2 = max_n / 2 + 5; int n, cn2, fn2; int a[max_cn2]; int x; long long q[max_cn2]; int main() { scanf( %d , &n); cn2 = (n + 1) / 2; fn2 = n / 2; long long suma = 0ll; for (int i = 0; i < cn2; ++i) { scanf( %d , &a[i]); suma += ((long long)(a[i])); } scanf( %d , &x); suma += ((long long)(fn2)) * ((long long)(x)); if (suma > 0ll) { printf( %d n , n); return 0; } if (x >= 0) { printf( %d n , -1); return 0; } q[0] = 0ll; for (int i = 1; i < n - fn2; ++i) q[i] = min(q[i - 1] + ((long long)(a[i - 1] - x)), 0ll); long long rsum = ((long long)(fn2)) * ((long long)(x)); for (int k = fn2 + 1; k < n; ++k) { rsum += ((long long)(a[n - k])); if (rsum + q[n - k] > 0ll) { printf( %d n , k); return 0; } } printf( %d n , -1); return 0; }
|
#include <bits/stdc++.h> using namespace std; const int INF = 1000 * 1000 * 1000 + 7; const long long LINF = 1LL * INF * INF; const int MAX = 1e5 + 7; const double PI = acos(-1.); const double EPS = 1e-7; const int MOD = 998244353; const int MAXF = 1000000000; int dx[] = {1, -1, 0, 0}; int dy[] = {0, 0, -1, 1}; bool isInField(int x, int y) { return 1 <= x && x <= MAXF && 1 <= y && y <= MAXF; } bool isWhite(int x, int y) { return x % 2 == y % 2; } void solve() { int black, white; cin >> black >> white; map<pair<int, int>, int> was; vector<pair<int, int> > ans; int sX = 200000, sY = 200000; if (black > white) { sX++; --black; } else { --white; } ans.emplace_back(sX, sY); was[{sX, sY}] = 1; while (black > 0 && white > 0) { --black; --white; ++sX; ans.emplace_back(sX, sY); was[{sX, sY}] = 1; ++sX; ans.emplace_back(sX, sY); was[{sX, sY}] = 1; } for (int i = 0; i < (((int)ans.size())); ++i) { int x = ans[i].first; int y = ans[i].second; for (int j = 0; j < (4); ++j) { int a = x + dx[j]; int b = y + dy[j]; if (black > 0) { if (!was.count({a, b}) && !isWhite(a, b)) { --black; ans.emplace_back(a, b); was[{a, b}] = 1; } } else if (white > 0) { if (!was.count({a, b}) && isWhite(a, b)) { --white; ans.emplace_back(a, b); was[{a, b}] = 1; } } } } if (black != 0 || white != 0) { cout << NO n ; return; } cout << YES n ; for (auto [x, y] : ans) { cout << x << << y << endl; } } int main() { ios_base::sync_with_stdio(0); int q; cin >> q; while (q--) { solve(); } return 0; }
|
#include <bits/stdc++.h> using namespace std; typedef long long ll; #define mod 1000000007 int main(){ int n;cin>>n; int summ = 0; while(n>9){ int summ = 0; while(n>9){ summ = summ + n%10; n = n/10; } summ = summ + n; n = summ; } cout<<n; return 0; }
|
#include <bits/stdc++.h> using namespace std; int32_t main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); double d, L, v1, v2; cin >> d >> L >> v1 >> v2; double distance; int i, r; cout << fixed << setprecision(20) << (L - d) / (v1 + v2); return 0; }
|
#include <bits/stdc++.h> using namespace std; int key; long long dis[1000]; struct pt { long long x, y, z; } f[8], point[8]; long long meow(int a, int b) { long long ta, tb, tc; ta = f[a].x - f[b].x; tb = f[a].y - f[b].y; tc = f[a].z - f[b].z; return (ta * ta + tb * tb + tc * tc); } int chk() { int i, j, cnta, cntb, cntc, k; long long dis, sq2, sq3, ik; for (i = 0; i < 8; i++) { for (j = 0; j < 8; j++) { if (i != j && f[i].x == f[j].x && f[i].y == f[j].y && f[i].z == f[j].z) return false; } } for (i = 0; i < 8; i++) { for (j = 0; j < 8; j++) { dis = meow(i, j); cnta = cntb = cntc = 0; for (k = 0; k < 8; k++) { ik = meow(i, k); if (ik == dis) cnta++; if (ik == dis * 2) cntb++; if (ik == dis * 3) cntc++; } if (cnta == 3 && cntb == 3 && cntc == 1) break; } if (j == 8) return false; } return true; } void go(int r) { if (r == 8) { if (chk()) { key = 1; cout << YES << endl; for (int i = 0; i < 8; i++) cout << f[i].x << << f[i].y << << f[i].z << endl; } return; } f[r] = point[r]; go(r + 1); if (key) return; swap(f[r].x, f[r].y); go(r + 1); if (key) return; swap(f[r].y, f[r].z); go(r + 1); if (key) return; swap(f[r].x, f[r].y); go(r + 1); if (key) return; swap(f[r].y, f[r].z); go(r + 1); if (key) return; swap(f[r].x, f[r].y); go(r + 1); return; } int main() { int i; for (i = 0; i < 8; i++) cin >> point[i].x >> point[i].y >> point[i].z; key = 0; f[0] = point[0]; go(1); if (!key) cout << NO << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; template <typename T> void read(T &x) { x = 0; char c; for (c = getchar(); !isdigit(c); c = getchar()) ; for (; isdigit(c); c = getchar()) x = x * 10 + c - 0 ; } const int N = 255, P = 998244353, oo = 0x3f3f3f3f; int mul(int a, int b) { return 1ll * a * b % P; } int add(int a, int b) { a += b; return a >= P ? a - P : a; } int sub(int a, int b) { a -= b; return a < 0 ? a + P : a; } int gcd(int a, int b) { return !b ? a : gcd(b, a % b); } namespace Dinic { const int S = N * N; struct Edge { int d, cap, nxt; } es[S << 2]; int vn, g[S], lev[S], itr[S], q[S], h, t, en = 1; void add(int s, int d, int cap) { es[++en] = (Edge){d, cap, g[s]}, g[s] = en; es[++en] = (Edge){s, 0, g[d]}, g[d] = en; } void bfs(int s) { int v; memset(lev, -1, sizeof(lev)); h = t = 0; q[t++] = s; lev[s] = 0; while (h < t) { v = q[h++]; for (int i = g[v], d = es[i].d; i; i = es[i].nxt, d = es[i].d) { if (es[i].cap > 0 && lev[d] < 0) { lev[d] = lev[v] + 1; q[t++] = es[i].d; } } } } int dfs(int v, int t, int f) { if (v == t) return f; for (int &i = itr[v]; i; i = es[i].nxt) { if (es[i].cap <= 0 || lev[es[i].d] <= lev[v]) continue; int a = dfs(es[i].d, t, min(es[i].cap, f)); if (a <= 0) continue; es[i].cap -= a; es[i ^ 1].cap += a; return a; } return 0; } int sol(int s, int t) { int i, res = 0, a; while (true) { bfs(s); if (lev[t] < 0) break; for (i = 0; i <= vn; ++i) itr[i] = g[i]; for (a = dfs(s, t, oo); a > 0; a = dfs(s, t, oo)) { res += a; } } return res; } } // namespace Dinic using namespace Dinic; int n, m; vector<int> xx, yy; struct Rec { int x1, y1, x2, y2; } rec[N]; int f(vector<int> &a, int x) { return lower_bound(a.begin(), a.end(), x) - a.begin() + 1; } int main(int argc, char *argv[]) { scanf( %d%d , &n, &m); for (int i = 1; i <= (m); ++i) { int x1, y1, x2, y2; scanf( %d%d%d%d , &x1, &y1, &x2, &y2); --x1, --y1; xx.push_back(x1), xx.push_back(x2); yy.push_back(y1), yy.push_back(y2); rec[i] = (Rec){x1, y1, x2, y2}; } xx.push_back(0), yy.push_back(0); sort(xx.begin(), xx.end()), sort(yy.begin(), yy.end()); xx.erase(unique(xx.begin(), xx.end()), xx.end()); yy.erase(unique(yy.begin(), yy.end()), yy.end()); int sx = xx.size(), sxy = sx + yy.size(), src = sxy + m + 1, snk = src + 1; vn = snk; for (int i = 1; i < (xx.size()); ++i) { add(src, i + 1, xx[i] - xx[i - 1]); } for (int i = 1; i < (yy.size()); ++i) { add(sx + i + 1, snk, yy[i] - yy[i - 1]); } for (int i = 1; i <= (m); ++i) { int x1 = rec[i].x1, x2 = rec[i].x2, y1 = rec[i].y1, y2 = rec[i].y2; x1 = f(xx, x1); x2 = f(xx, x2); y1 = f(yy, y1); y2 = f(yy, y2); for (int j = x1 + 1; j <= x2; ++j) add(j, sxy + i, oo); for (int j = y1 + 1; j <= y2; ++j) add(sxy + i, sx + j, oo); } cout << sol(src, snk) << endl; }
|
#include <bits/stdc++.h> using namespace std; const int INF = 1e9; const int MX = 3001; map<pair<int, int>, bool> forbidden[MX]; struct Graph { int d[MX][MX]; int parent[MX][MX]; vector<int> adj[MX]; void addEdge(int u, int v) { adj[u].push_back(v); adj[v].push_back(u); } vector<int> bfs(int s, int n) { for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { d[i][j] = INF; parent[i][j] = -1; } } d[n][s] = 0; deque<pair<int, int>> q; q.push_back({n, s}); while (!q.empty()) { int a = q.front().first; int b = q.front().second; q.pop_front(); for (int c : adj[b]) { if (d[b][c] == INF && !forbidden[a][{b, c}]) { d[b][c] = d[a][b] + 1; parent[b][c] = a; q.push_back({b, c}); } } } int minDistance = INF; for (int i = 0; i < n; i++) { minDistance = min(minDistance, d[i][n - 1]); } if (minDistance == INF) return {}; int prev = -1; for (int i = 0; i < n; i++) { if (d[i][n - 1] == minDistance) { prev = i; break; } } vector<int> path = {n}; int cur = n - 1; while (prev != n) { path.push_back(prev + 1); int aux = prev; prev = parent[prev][cur]; cur = aux; } reverse(path.begin(), path.end()); return path; } } G; int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); int n, m, k; cin >> n >> m >> k; for (int i = 0; i < m; i++) { int u, v; cin >> u >> v; u--; v--; G.addEdge(u, v); } for (int i = 0; i < k; i++) { int a, b, c; cin >> a >> b >> c; a--; b--; c--; forbidden[a][{b, c}] = true; } vector<int> path = G.bfs(0, n); cout << (int)path.size() - 1 << n ; for (int u : path) cout << u << ; cout << n ; return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { ios::sync_with_stdio(0); cout.tie(0); cin.tie(0); cout.precision(10); bool vozr = 1, ub = 1, same; int n; cin >> n; vector<int> a(n); for (int i = 0; i < n; i++) { cin >> a[i]; if (i != 0 && a[i] > a[i - 1]) ub = 0; if (i != 0 && a[i] < a[i - 1]) vozr = 0; } if (n <= 2 || (vozr && ub)) { cout << -1 << n ; return 0; } if (vozr) { same = 1; for (int i = 2; i < n - 1; i++) { if (a[i] != a[i - 1]) same = 0; } if (same) { if (a[n - 2] == a[n - 1]) cout << 1 << << n - 1 << n ; else cout << n - 1 << << n << n ; } else cout << 1 << << n << n ; } else if (ub) { same = 1; for (int i = 2; i < n - 1; i++) { if (a[i] != a[i - 1]) same = 0; } if (same) { if (a[n - 2] == a[n - 1]) cout << 1 << << 2 << n ; else cout << n - 1 << << n << n ; } else cout << 1 << << n << n ; } else { if (n == 3) { if (a[0] == a[2]) cout << -1 << n ; else cout << 1 << << 3 << n ; } else { int minn = 1100000000, maxx = -1, id1, id2; for (int i = 0; i < n; i++) { if (a[i] < minn) { minn = a[i]; id1 = i; } if (a[i] >= maxx) { maxx = a[i]; id2 = i; } } if (id1 == 0) { if (id2 == n - 1) cout << 1 << << n << n ; else { if (id2 == 1) cout << 2 << << 3 << n ; else cout << 2 << << id2 + 1 << n ; } } else { if (id1 == 1) cout << 2 << << 3 << n ; else cout << 2 << << id1 + 1 << n ; } } } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); long long n; while (cin >> n) { string s; cin >> s; long long a0 = 0, a1 = 0, a2 = 0; for (long long i = 0; i < s.size(); i++) { if (s[i] == 0 ) { a0++; } else if (s[i] == 1 ) { a1++; } else { a2++; } } long long d = s.size() / 3; long long x = 0, y = 0, z = 0; for (long long i = s.size() - 1; i >= 0; i--) { if (s[i] == 1 ) { if (a1 > d && a2 < d) { s[i] = 2 ; a2++; a1--; } } if (s[i] == 0 ) { if (a0 > d && a2 < d) { s[i] = 2 ; a2++; a0--; } } } for (long long i = 0; i < s.size(); i++) { if (s[i] == 1 ) { if (a1 > d && a0 < d) { s[i] = 0 ; a0++; a1--; } } if (s[i] == 2 ) { if (a2 > d && a0 < d) { s[i] = 0 ; a0++; a2--; } } } for (long long i = 0; i < s.size(); i++) { if (s[i] == 2 ) { if (a2 > d && a1 < d) { s[i] = 1 ; a1++; a2--; } } if (s[i] == 0 ) { if (a0 > d && a1 < d && x >= d) { s[i] = 1 ; a1++; a0--; } x++; } } cout << s << endl; } return 0; }
|
#include <bits/stdc++.h> using namespace std; void err(istream_iterator<string> it) {} template <typename T, typename... Args> void err(istream_iterator<string> it, T a, Args... args) { cerr << *it << = << a << endl; err(++it, args...); } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); int n, m, a; cin >> n >> m; vector<int> cost(m); for (int i = 0; i < m; i++) cin >> a >> cost[i]; sort(cost.begin(), cost.end(), greater<int>()); int k = 1; while (true) { int nxtk = k + 1; int need = nxtk * (nxtk - 1) / 2; if (nxtk % 2 == 0) need += nxtk / 2 - 1; if (need <= (n - 1) && nxtk <= m) k = nxtk; else break; } long long res = 0; for (int i = 0; i < k; i++) res += cost[i]; cout << res; }
|
#include <bits/stdc++.h> using namespace std; const int N = 1e+6 + 5; int lp[N], ans = 1e+9; set<int> factors; void factorise(int n, int isv) { int cnt = 0, ans = 0, n1 = n; while (n % 2 == 0) { cnt++; n = n / 2; } if (cnt) { ans = max(ans, 2); if (isv) factors.insert(2); } for (int i = 3; i * i <= n; i++) { cnt = 0; while (n % i == 0) { cnt++; n = n / i; } if (cnt) { ans = max(ans, i); if (isv) factors.insert(i); } } if (n > 1) { ans = max(ans, n); if (isv) factors.insert(n); } lp[n1] = ans; } int main() { int x; cin >> x; for (int i = 2; i <= x; i++) factorise(i, i == x); for (auto it : factors) { int i = x - it + 1; for (i; i <= x; i++) { if (lp[i] != i) ans = min(ans, i - lp[i] + 1); } } cout << ans; }
|
#include <bits/stdc++.h> using namespace std; int a, s, d, f, g, h, j, k, l, i, n, m; int main() { cin >> n >> m >> k; l = n * m * k / 100; for (i = 0; i < n; i++) { if (l > m) { cout << m; l = l - m; } else if (l > 0) { cout << l; l = 0; } else cout << 0; cout << ; } }
|
#include<bits/stdc++.h> using namespace std; #define ll long long template <typename Arg1> //print with endl void pn(Arg1&& arg1) { cout<<arg1<< n ;} template <typename Arg1, typename... Args> void pn(Arg1&& arg1, Args&&... args) { cout<<arg1<< n ; pn(args...); } //print with space template <typename Arg1> void ps(Arg1&& arg1) { cout<<arg1<< ;} template <typename Arg1, typename... Args> void ps(Arg1&& arg1, Args&&... args) { cout<<arg1<< ; ps(args...); } template <typename Arg1> void pvs(Arg1&& arg1, ll n) { for(ll i=0;i<n;i++)ps(arg1[i]); } template <typename Arg1> void pvn(Arg1&& arg1, ll n) { for(ll i=0;i<n;i++)pn(arg1[i]); } ll sum(ll n){ ll v=0; while(n!=0){ v+=(n%10); n/=10; } return v; } ll log(ll n, ll b) { ll c=0; while(n>(b-1)) { c++; n/=b; } return c; } #define fast ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); #define mod 1000000007 //10^9+7 #define st string #define ull unsigned long long #define pb push_back #define mp make_pair #define vi vector <int> #define vll vector <long long> #define f0(i,a) for(i=0;i<a;i++) #define f1(i,a) for(i=1;i<=n;i++) #define all(a) a.begin(),a.end() #define sz(a) a.size() #define lb lower_bound #define ub upper_bound #define pl pair<ll,ll> #define vpl vector<pl> #define ff first #define ss second #define um unordered_map #define dsort(v) sort(v); reverse(v); #define maxall(v) *max_element(all(v)) #define minall(v) *min_element(all(v)) #define gcd(a,b) __gcd(a,b) #define lcm(a,b) a/__gcd(a,b)*b #define Y YES #define N NO #define endl n #define debug(x) cout << #x << : << x << nl; const ll MOD = 998244353; const ll inf = 1e18; const ll MAX = 2e5 + 1; ll GCD(ll a,ll b){ if(b==0) return a; else return GCD(b,a%b); } ll mulmod(ll x,ll n,ll M) { ll result=1; while(n>0) { if(n% 2 ==1) result=(result * x)%M; x=(x*x)%M; n=n/2; } return result; } ///////////////////////// bool isPowerOfTwo(ll n) { if (n == 0) return 0; while (n != 1) { if (n%2 != 0) return 0; n = n/2; } return 1; } void solve(){ ll i; ll n; cin>>n; vll v(n); f0(i,n) cin>>v[i]; f0(i,n){ if(v[i]&1) cout<<v[i]<< ; } f0(i,n){ if(!(v[i]&1)) cout<<v[i]<< ; } cout<<endl; } int main(){ fast; #ifdef Local freopen( inp.txt , r , stdin); // freopen( out.txt , w , stdin); #endif // solve();/* ll t; cin>>t; for(ll tt=1;tt<=t;tt++) { // cout<< Case # <<tt<< : ; solve(); } //*/ }
|
#include <bits/stdc++.h> using namespace std; char str[40], ans[2][40], p[40]; int pre[40], sum[40]; int main() { scanf( %s , str); int L = 0, R = 0; bool mark = true; memset(pre, -1, sizeof(pre)); for (int i = 0; i < 27; i++) { int a = str[i] - A ; sum[a]++; if (pre[a] == -1) pre[a] = i; else { L = pre[a]; R = i; if (R - 1 == L) { mark = false; } } } int k = 0; for (int i = 0; i < 26; i++) { if (sum[i] == 0 || sum[i] > 2) mark = false; if (sum[i] == 2) k++; } if (k != 1 || !mark) { printf( Impossible n ); return 0; } R = 26 - R; int cnt = 0; if (L > R) { int o = 0; for (int i = 26; i >= 0; i--) { p[o++] = str[i]; } for (int i = 0; i < 27; i++) str[i] = p[i]; swap(L, R); } int num = R - L; if (num & 1) { num = (num / 2) + 1; int i; for (i = num;; i++) { if (cnt == L) break; ans[0][i] = str[cnt++]; } int flag = i - 1; ans[1][i - 1] = str[cnt++]; for (; i < 13; i++) ans[0][i] = str[cnt++]; for (int i = 12; i > flag; i--) { ans[1][i] = str[cnt++]; } cnt++; for (int i = flag - 1; i >= 0; i--) ans[1][i] = str[cnt++]; if (num) { for (int i = 0; i < num; i++) ans[0][i] = str[cnt++]; } } else { num = num / 2; int i; for (i = num;; i++) { if (cnt == L) break; ans[0][i] = str[cnt++]; } int flag = i; ans[1][i] = str[cnt++]; for (; i < 13; i++) ans[0][i] = str[cnt++]; for (int i = 12; i > flag; i--) { ans[1][i] = str[cnt++]; } cnt++; for (int i = flag - 1; i >= 0; i--) ans[1][i] = str[cnt++]; if (num) { for (int i = 0; i < num; i++) ans[0][i] = str[cnt++]; } } if (L == 0 && R == 0) { cnt = 0; for (int i = 0; i < 13; i++) ans[0][i] = str[cnt++]; for (int i = 12; i >= 0; i--) ans[1][i] = str[cnt++]; } for (int i = 0; i < 2; i++) { for (int j = 0; j < 13; j++) printf( %c , ans[i][j]); printf( n ); } }
|
#include <bits/stdc++.h> using namespace std; int N; vector<int> V; bool Do() { while (V.size() > 0 && V.back() % 2 == 0) V.pop_back(); if (V.size() == 0) return false; int sum = 0; int p = -1; for (int i = 0; i < V.size(); ++i) { if (V[i] % 2 && i < V.size() - 1) p = i; sum += V[i]; } if (sum % 2 == 0) return true; else if (p == -1) return false; else { for (int i = p; i + 1 < V.size(); ++i) V[i] = V[i + 1]; V.pop_back(); return true; } } int main() { int nr_t, nr; char c; cin >> nr_t; for (int i = 1; i <= nr_t; ++i) { cin >> N; for (int j = 1; j <= N; ++j) { cin >> c; V.push_back(c - 0 ); } if (!Do()) cout << -1 << n ; else { for (int i = 0; i < V.size(); ++i) cout << V[i]; cout << n ; } V.clear(); } return 0; }
|
#include <bits/stdc++.h> using namespace std; void toogle(vector<vector<int> >& v, int i, int j) { if (v[i][j] == 1) { v[i][j] = 0; } else if (v[i][j] == 0) { v[i][j] = 1; } } int main() { vector<vector<int> > v(3, vector<int>(3, 1)); int i, j, e; for (i = 0; i < 3; i++) { for (j = 0; j < 3; j++) { cin >> e; if (e % 2 == 0) { continue; } else { toogle(v, i, j); if (i - 1 >= 0) toogle(v, i - 1, j); if (j - 1 >= 0) toogle(v, i, j - 1); if (i + 1 < 3) toogle(v, i + 1, j); if (j + 1 < 3) toogle(v, i, j + 1); } } } for (i = 0; i < 3; i++) { for (j = 0; j < 3; j++) { cout << v[i][j]; } cout << endl; } }
|
#include <bits/stdc++.h> using namespace std; struct edge { int to, next; } e[200010]; int n, m, q, cnt, father[100010], fa[100010][30], a[100010], dis[100010], deep[100010], head[100010]; inline void add(int u, int v) { cnt++; e[cnt].to = v; e[cnt].next = head[u]; head[u] = cnt; } inline int find(int x) { return father[x] == x ? x : father[x] = find(father[x]); } inline void dfs(int u) { deep[u] = deep[fa[u][0]] + 1; for (int i = head[u]; i; i = e[i].next) { int v = e[i].to; if (!deep[v]) { fa[v][0] = u; dfs(v); if (find(u) == find(v)) a[u] |= a[v]; } else if (deep[v] < deep[u] - 1) { if ((deep[u] + deep[v] + 1) & 1) a[u] = 1; for (int x = find(u); deep[x] > deep[v] + 1; x = find(x)) father[x] = fa[x][0]; } } } inline void dfs2(int u) { dis[u] += a[u]; for (int i = head[u]; i; i = e[i].next) { int v = e[i].to; if (deep[v] != deep[u] + 1) continue; if (find(u) == find(v)) a[v] |= a[u]; dis[v] = dis[u]; dfs2(v); } } inline int LCA(int x, int y) { if (deep[x] > deep[y]) swap(x, y); for (int i = 20; i >= 0; i--) if (deep[fa[y][i]] >= deep[x]) y = fa[y][i]; if (x == y) return x; for (int i = 20; i >= 0; i--) if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i]; return fa[x][0]; } inline bool check(int u, int v) { if (!LCA(u, v)) return 0; if ((deep[u] + deep[v]) & 1) return 1; if (dis[u] + dis[v] - 2 * dis[LCA(u, v)]) return 1; return 0; } int main() { scanf( %d%d , &n, &m); for (int i = 1; i <= n; i++) father[i] = i; for (int i = 1, x, y; i <= m; i++) { scanf( %d%d , &x, &y); add(x, y); add(y, x); } for (int i = 1; i <= n; i++) if (!deep[i]) dfs(i), dfs2(i); for (int i = 1; i <= 20; i++) for (int j = 1; j <= n; j++) fa[j][i] = fa[fa[j][i - 1]][i - 1]; scanf( %d , &q); while (q--) { int x, y; scanf( %d%d , &x, &y); if (check(x, y)) puts( Yes ); else puts( No ); } return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { ios::sync_with_stdio(false); int n, x; vector<int> a, b, c; cin >> n; for (int i = 0; i < n; i++) { cin >> x; if (x == 1) a.push_back(i + 1); else if (x == 2) b.push_back(i + 1); else c.push_back(i + 1); } int res = min({a.size(), b.size(), c.size()}); cout << res << endl; for (int i = 0; i < res; i++) { cout << a[i] << << b[i] << << c[i] << endl; } return 0; }
|
#include <bits/stdc++.h> #pragma GCC optimize( Ofast ) using namespace std; const int N = 1e6 + 100; pair<int, int> seg[4 * N]; int lazy[4 * N]; void shift(int nod) { lazy[nod * 2] += lazy[nod]; lazy[nod * 2 + 1] += lazy[nod]; seg[nod * 2].first += lazy[nod]; seg[nod * 2 + 1].first += lazy[nod]; seg[nod * 2].second += lazy[nod]; seg[nod * 2 + 1].second += lazy[nod]; lazy[nod] = 0; } void upd(int nod, int l, int r, int L, int R, int val) { if (l >= R || L >= r) { return; } if (l >= L && r <= R) { seg[nod].first += val; seg[nod].second += val; lazy[nod] += val; return; } shift(nod); int mid = (r + l) / 2; upd(nod * 2, l, mid, L, R, val); upd(nod * 2 + 1, mid, r, L, R, val); seg[nod].first = max(seg[nod * 2].first, seg[nod * 2 + 1].first); seg[nod].second = min(seg[nod * 2].second, seg[nod * 2 + 1].second); } int a[N]; int32_t main() { ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0); int n; cin >> n; int cnt = 1; int to = 0, tc = 0; for (int i = 0; i < n; i++) { char c; cin >> c; if (c == ( ) { if (a[cnt] == 1) { if (to != tc || seg[1].second < 0) { cout << -1 << n ; } else { cout << seg[1].first << n ; } continue; } if (a[cnt] == 2) { upd(1, 1, N, cnt, N, +2); tc--; } else { upd(1, 1, N, cnt, N, 1); } a[cnt] = 1; to++; } if (c == ) ) { if (a[cnt] == 2) { if (to != tc || seg[1].second < 0) { cout << -1 << n ; } else { cout << seg[1].first << n ; } continue; } if (a[cnt] == 1) { upd(1, 1, N, cnt, N, -2); to--; } else { upd(1, 1, N, cnt, N, -1); } tc++; a[cnt] = 2; } if (c == R ) { cnt++; } if (c == L ) { cnt--; } if (c >= a && c <= z ) { if (a[cnt] == 1) { a[cnt] = 0; upd(1, 1, N, cnt, N, -1); to--; } if (a[cnt] == 2) { a[cnt] = 0; upd(1, 1, N, cnt, N, +1); tc--; } } cnt = max(cnt, (int)1); if (to != tc || seg[1].second < 0) { cout << -1 << n ; } else { cout << seg[1].first << n ; } } }
|
#include <bits/stdc++.h> using namespace std; int a[1000001] = {0}, n; int main() { cin >> n; long long sum = 0; long s = 0, s1 = 0, s2 = 0, s3 = 0; for (int k = 1; k <= n; ++k) { cin >> a[k], sum += a[k]; if (a[k] == 1) ++s; else if (a[k] == 2) ++s1; else if (a[k] == 3) ++s3; else if (a[k] == 4) s2++; } s3 += min(s, s1); ; if (sum == 1 || sum == 2 || sum == 5) { cout << -1; return 0; } sum = 0; sum += min(s, s1); s1 = s1 - s; if (s1 < 0) s = -s1, s1 = 0; else s = 0; if (s > 0) { sum += s - s / 3; if (s == 1 && s3 == 0) ++sum; } if (s1 > 0) { sum += s1 - s1 / 3; if (s1 % 3 == 1 && s2 == 0) ++sum; } cout << sum; return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n; long long k; cin >> n >> k; k -= (long long)n * (n + 1) / 2; if (k < 0) { cout << -1 << endl; return 0; } long long sum = (long long)n * (n + 1) / 2; vector<int> ans; for (int i = n - 1; i >= 0; i--) { int add = max(0, n - 1 - (n - 1 - i) * 2); if (k > add) { ans.push_back(i); ans[n - 1 - i] = i; k -= add; sum += add; } else { for (int j = 0; j < i; j++) { ans.push_back(j); } ans.insert(ans.begin() + (n - 1 - i) + (add - k), i); sum += k; break; } } cout << sum << endl; for (int i = 0; i < n; i++) { cout << i + 1; if (i < n - 1) { cout << ; } } cout << endl; for (int i = 0; i < n; i++) { cout << ans[i] + 1; if (i < n - 1) { cout << ; } } cout << endl; }
|
#include <bits/stdc++.h> using namespace std; const int N = 1e4 + 10; int cnt[100 + 2][N + 2]; string s[100 + 2]; set<int> on[100 + 2], of[100 + 2]; int main() { ios_base::sync_with_stdio(0); cin.tie(0); int n, m; cin >> n >> m; for (int i = 1; i <= n; i++) { cin >> s[i]; s[i] = # + s[i] + # ; for (int j = 1; j <= m; j++) { if (s[i][j] == . ) of[i].insert(j); else on[i].insert(j); } on[i].insert(0); on[i].insert(m + 1); of[i].insert(-1); of[i].insert(m + 2); } long long ans = 0; int a = 1, b = 1, d = 1; while (true) { if (clock() > CLOCKS_PER_SEC * 0.8) cout << Never n , exit(0); if (a == n) break; if (d) { int cr = *on[a].lower_bound(b); int nx = *of[a + 1].lower_bound(b); if (nx < cr) { ans += nx - b + 1; a++; b = nx; } else { ans += cr - b; b = cr - 1; d ^= 1; if (s[a][cr] == + ) { on[a].erase(cr); s[a][cr] = . ; of[a].insert(cr); } } } else { auto it1 = on[a].upper_bound(b); auto it2 = of[a + 1].upper_bound(b); it1--, it2--; int cr = *it1, nx = *it2; if (nx > cr) { ans += b - nx + 1; a++; b = nx; } else { ans += b - cr; b = cr + 1; d ^= 1; if (s[a][cr] == + ) { on[a].erase(cr); s[a][cr] = . ; of[a].insert(cr); } } } } cout << ans << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; long long mod = 998244353; struct bucket { long long size, minm; vector<long long> off; vector<long long> dps; vector<long long> pre; bucket(long long b) { size = b; off = vector<long long>(b); pre = vector<long long>(b); dps = vector<long long>(b); minm = 0; } void updoff(long long p, long long l, long long r) { assert(l >= 0 && l < size && r >= 0 && r < size && l <= r); long long nmnm = INT_MAX; for (long long j = l; j <= r; ++j) nmnm = min(nmnm, minm + off[j] + p); for (long long j = 0; j < l; ++j) nmnm = min(nmnm, minm + off[j]); for (long long j = r + 1; j < size; ++j) nmnm = min(nmnm, minm + off[j]); for (long long j = 0; j < l; ++j) off[j] = off[j] + minm - nmnm; for (long long j = l; j <= r; ++j) off[j] = off[j] + minm + p - nmnm; for (long long j = r + 1; j < size; ++j) off[j] = off[j] + minm - nmnm; minm = nmnm; pre = vector<long long>(size); for (long long j = 0; j < size; ++j) pre[off[j]] = (pre[off[j]] + dps[j]) % mod; for (long long j = 1; j < size; ++j) pre[j] = (pre[j] + pre[j - 1]) % mod; } void upddp(long long idx, long long newdp) { dps[idx] = newdp; pre = vector<long long>(size); for (long long j = 0; j < size; ++j) pre[off[j]] = (pre[off[j]] + dps[j]) % mod; for (long long j = 1; j < size; ++j) pre[j] = (pre[j] + pre[j - 1]) % mod; } }; void update_offset(vector<bucket> &ds, long long n, long long l, long long r, long long p, long long b) { assert(l <= r); long long j = r / b; ds[j].updoff(p, max(l, j * b) - j * b, r - j * b); j--; while (j * b > l) { ds[j].minm += p; j--; } if (l >= j * b && l < (j + 1) * b) ds[j].updoff(p, l - j * b, b - 1); } long long query(vector<bucket> &ds, long long n, long long r, long long b, long long k) { long long j = r / b; long long ret = 0; while (j >= 0) { long long idx = k - ds[j].minm; if (idx >= 0) ret = (ret + ds[j].pre[min(idx, b - 1)]) % mod; j--; } return ret; } int32_t main() { long long n, k; cin >> n >> k; long long b = sqrt(n); long long m = ceil((double)n / b); vector<long long> a(n); for (auto &x : a) cin >> x; vector<bucket> ds; for (long long i = 0; i < m; ++i) { bucket B = bucket(b); ds.push_back(B); } vector<long long> lo(n + 1, -1); vector<long long> llo(n + 1, -1); vector<long long> dp(n); dp[0] = 1; lo[a[0]] = 0; ds[0].updoff(1, 0, 0); ds[0].upddp(0, 1); if ((1 / b) < m) ds[1 / b].upddp(1 - (1 / b) * b, 1); for (long long i = 1; i < n; ++i) { if (lo[a[i]] != -1) update_offset(ds, n, llo[a[i]] + 1, lo[a[i]], -1, b); update_offset(ds, n, lo[a[i]] + 1, i, 1, b); dp[i] = query(ds, n, i, b, k); long long j = (i + 1) / b; if (j < m) ds[j].upddp((i + 1) - j * b, dp[i]); llo[a[i]] = lo[a[i]]; lo[a[i]] = i; } cout << dp[n - 1]; }
|
#include <bits/stdc++.h> using namespace std; char s[100005]; int main() { int n; cin >> n; int k = min(n, 4); for (int i = 0; i < k; i++) for (int j = i; j < n; j += 4) s[j] = i + a ; s[n] = 0 ; cout << s << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n, i, j, s = 0, o; cin >> n; char *a[n + 1], str[n + 1]; for (i = 0; i < n; i++) { cin >> str; a[i] = (char *)malloc(n + 1); strcpy(a[i], str); } for (i = 0; i < n && s == 0; i++) for (j = 0; j < n && s == 0; j++) { o = 0; if (j != 0 && a[i][j - 1] == o ) o++; if ((j != n - 1) && a[i][j + 1] == o ) o++; if (i != 0 && a[i - 1][j] == o ) o++; if ((i != n - 1) && a[i + 1][j] == o ) o++; if (o % 2 != 0) s = 1; } if (s) cout << NO ; else cout << YES ; }
|
#include <bits/stdc++.h> using namespace std; const int MOD = 1e9 + 7; const int SIZE = 1e6 + 10; vector<pair<int, int> > headd[10][2]; bitset<10000000> used; int ad[10000000]; bool valid(long long x) { int lt = x % 10; x /= 10; int flag = 0; while (x) { int tmp = x % 10; x /= 10; if (tmp < lt) { if (flag == -1) return false; flag = -1; } else if (tmp > lt) { if (flag == 1) return false; flag = 1; } else return false; lt = tmp; } return true; } int check(int st, long long N, int ud, long long& K, long long need) { if (need >= 10000000) return -1; int ker = lower_bound((headd[st][ud]).begin(), (headd[st][ud]).end(), make_pair((int)need, 0)) - headd[st][ud].begin(); int ker2 = lower_bound((headd[st][ud]).begin(), (headd[st][ud]).end(), make_pair((int)need + 1, 0)) - headd[st][ud].begin(); if (ker2 - ker < K) { K -= ker2 - ker; return -1; } for (int i = (ker); i < (((int)(headd[st][ud]).size())); ++i) { K--; if (K == 0) return headd[st][ud][i].second; } return -1; } int main() { long long N, K; cin >> N >> K; if (N > (1e14 + 3) / K) { puts( -1 ); return 0; } if (N > 10000000) { for (long long now = N; now < 100000000000000LL; now += N) { if (valid(now)) { K--; if (!K) { cout << now << endl; return 0; } } } cout << -1 << endl; return 0; } int tmp[8] = {}; for (int i = (1); i < (10000000); ++i) { tmp[0]++; int now = 0; while (tmp[now] == 10) { tmp[now] = 0; now++; tmp[now]++; } bool err = 0; for (int j = (1); j < (6); ++j) { if ((tmp[j] - tmp[j - 1]) * (tmp[j] - tmp[j + 1]) <= 0) { err = 1; break; } } if (!err) { headd[tmp[6]][(tmp[6] < tmp[5]) ? 1 : 0].push_back(make_pair(i % N, i)); } } for (int i = 0; i < (10); ++i) for (int j = 0; j < (2); ++j) sort((headd[i][j]).begin(), (headd[i][j]).end()); for (long long now = 1; now < 10000000; now++) { if ((now / 10) % 10 == now % 10) continue; int ha = ((now / 10) % 10) < (now % 10) ? 1 : -1; if (now < 10 || (used[now / 10] && (ad[now / 10] != ha))) { if (now < 10) ha = 0; if (now % N == 0) { K--; if (K == 0) { cout << now << endl; return 0; } } ad[now] = ha; used[now] = 1; } } for (int i = (1); i < (10000000); ++i) { if (used[i]) { int tail = i % 10; int flag = 0; if (i >= 10) { if ((i / 10) % 10 < tail) flag = 1; else flag = -1; } long long r = (i * 10000000LL) % N; long long need = N - r; if (need == N) need = 0; if (flag != -1) { for (int j = 0; j < (tail); ++j) { int res = check(j, N, 1, K, need); if (res >= 0) { printf( %d%07d n , i, res); return 0; } } } if (flag != 1) for (int j = (tail + 1); j < (10); ++j) { int res = check(j, N, 0, K, need); if (res >= 0) { printf( %d%07d n , i, res); return 0; } } } } puts( -1 ); return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; int foot = n / 36; float b = n % 36; int kkk = b / 3; double kk = kkk + 0.5; float inch = b / 3; if (inch >= kk) inch = ceil(inch); else if (inch < kk) inch = floor(inch); int sss = (float)(inch); if (sss % 12 == 0) { inch = 0; foot += (sss / 12); } cout << foot << << inch; return 0; }
|
#include <bits/stdc++.h> using namespace std; const double pi = 3.14159265359; long long max(long long a, long long b) { if (a >= b) return a; else return b; } long long min(long long a, long long b) { if (a <= b) return a; else return b; } bool valid(int i, int j, long long n, long long m) { if (i >= 0 && i < n && j >= 0 && j < m) return 1; else return 0; } void yes() { cout << YES << n ; } void no() { cout << NO << n ; } vector<unsigned long long> divisor(10000007); void printDivisors(long long n) { for (int i = 1; i <= sqrt(n); i++) { if (n % i == 0) { if (n / i == i) { divisor[n] += i; } else { divisor[n] += i; divisor[n] += n / i; } } } } bool prime[1200000]; map<long long, long long> primes; void SieveOfEratosthenes(long long n = 1200000) { memset(prime, true, sizeof(prime)); prime[1] = false; for (int p = 2; p * p < n; p++) { if (prime[p] == true) { for (int i = p * 2; i < n; i += p) prime[i] = false; } } for (int i = 1; i < n + 1; i++) if (prime[i]) { primes[i]++; } } int gcd(long long a, long long b) { if (!b) return a; return gcd(b, a % b); } string toBinary(long long n) { string r; while (n != 0) { r = (n % 2 == 0 ? 0 : 1 ) + r; n /= 2; } return r; } bool isPrime(long long n) { if (n <= 1) return false; if (n <= 3) return true; if (n % 2 == 0 || n % 3 == 0) return false; for (int i = 5; i * i <= n; i = i + 6) if (n % i == 0 || n % (i + 2) == 0) return false; return true; } map<long long, long long> PF; void primeFactors(long long n) { while (n % 2 == 0) { PF[2]++; n = n / 2; } for (int i = 3; i <= sqrt(n); i = i + 2) { while (n % i == 0) { PF[i]++; n = n / i; } } if (n > 2) PF[n]++; } long double intlog(long long base, long long x) { long double ans1 = log10(x), ans2 = log10(base); return (long double)(ans1 / ans2); } bool IsPowerOfTwo(long long x) { return (x & (x - 1)) == 0; } map<long long, long long> LN; void GetLuckyNumbers(string s) { if (s.size() > 10) return; GetLuckyNumbers(s + 4 ); if (s != ) LN[stoll(s)]++; GetLuckyNumbers(s + 7 ); if (s != ) LN[stoll(s)]++; } unsigned long long toDecimal(unsigned long long n) { unsigned long long num = n; unsigned long long dec_value = 0; unsigned long long base = 1; int temp = num; while (temp) { unsigned long long last_digit = temp % 10; temp = temp / 10; dec_value += last_digit * base; base = base * 2; } return dec_value; } long double power(long double b, long long p) { if (p == 0) return 1; else if (p == 1) return b; long double a = power(b, p / 2); if (p % 2 == 0) return (a) * (a); return (b) * (a) * (a); } long largest_power_of_two(long N) { N = N | (N >> 1); N = N | (N >> 2); N = N | (N >> 4); N = N | (N >> 8); return (N + 1) >> 1; } long long cnt(string s) { long long c = 0; for (int i = 0; i < s.size(); i++) c += s[i] - 0 ; return c; } bool ispal(string s) { for (int i = 0; i < s.size() / 2; i++) { if (s[i] != s[s.size() - i - 1]) return false; } return true; } map<string, long long> substrings; void subString(string s, long long n) { for (int i = 0; i < n; i++) for (int len = 1; len <= n - i; len++) { substrings[s.substr(i, len)]++; } } bool check_divisabilty_prefix(string str, long long a) { long long len = str.size(); vector<int> lr(len + 1, 0); lr[0] = (str[0] - 0 ) % a; for (int i = 1; i < len; i++) lr[i] = ((lr[i - 1] * 10) % a + (str[i] - 0 )) % a; if (lr[len - 1] == 0) return 1; return 0; } bool check_divisabilty_suffix(string str, long long b) { long long len = str.size(); vector<long long> rl(len + 1, 0); rl[len - 1] = (str[len - 1] - 0 ) % b; int power10 = 10; for (int i = len - 2; i >= 0; i--) { rl[i] = (rl[i + 1] + (str[i] - 0 ) * power10) % b; power10 = (power10 * 10) % b; } if (rl[0] == 0) return 1; return 0; } bool isSubSeq(int idx1, int idx2, string s1, string s2) { if (idx2 == s2.size()) return true; if (idx1 == s1.size()) return false; if (s1[idx1] == s2[idx2]) return isSubSeq(idx1 + 1, idx2 + 1, s1, s2); else return isSubSeq(idx1 + 1, idx2, s1, s2); } vector<long long> v; long long bs(long long st, long long en, long long rq, long long val) { long long ans; while (st <= en) { long long mid = (st + en) / 2; long long aa = v[mid] - v[rq]; if (aa <= val) { st = mid + 1; ans = mid; } else en = mid - 1; } return abs(ans - rq); } bool isPerfectSquare(long double x) { if (x >= 0) { long long sr = sqrt(x); return (sr * sr == x); } return false; } long long fn(long long s) { if (s < 10) return s; long long pr = 1; while (s) { if (s % 10) pr *= (s % 10); s /= 10; } return fn(pr); } int main() { ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); ; vector<vector<long long> > v(11, vector<long long>(1e6 + 1, 0)); for (int i = 1; i <= 1000000; i++) { v[fn(i)].push_back(i); } int n; long long x; cin >> x; while (x--) { long long start, endd, nm; cin >> start >> endd >> nm; long long lower = lower_bound(v[nm].begin(), v[nm].end(), start) - v[nm].begin(); long long upper = lower_bound(v[nm].begin(), v[nm].end(), endd) - v[nm].begin(); if (v[nm][upper] == endd) { cout << (upper - lower) + 1 << endl; } else { cout << upper - lower << endl; } } return 0; }
|
#include <bits/stdc++.h> using namespace std; string a, b; int f1[100005], f2[100005], res, p1, p2, k, dp2[100005]; int main() { cin >> a >> b; int n = a.length(); int m = b.length(); a = # + a; b = # + b; int p = 1; for (int i = 1; i <= m; i++) { if (p > n) break; while (a[p] != b[i] && p <= n) p++; if (p <= n) f1[i] = p; p++; } p = n; for (int i = 1; i <= max(m, n); i++) f2[i] = -1; for (int i = m; i >= 1; i--) { if (p < 1) break; while (a[p] != b[i] && p >= 1) p--; if (p >= 1) f2[i] = p; p--; } for (int i = 1; i <= m; i++) if (res < i && f1[i] > 0) { res = i; p1 = 1; p2 = i; k = 1; } for (int i = 1; i <= max(m, n); i++) dp2[i] = n + 1; p = n; for (int i = m; i >= 1; i--) { if (p < 1) break; while (a[p] != b[i] && p >= 1) p--; if (p >= 1) dp2[i] = p; p--; } for (int i = 1; i <= m; i++) if (res < (m - i + 1) && dp2[i] < n + 1) { res = (m - i + 1); p1 = i; p2 = m; k = 1; } int z = 0; int x = 0; for (int i = 1; i <= m; i++) { z = max(z, i + 1); while (x <= n && a[x] != b[i]) x++; if (x > n) break; x++; while (f2[z] < x) z++; int ans = i + 1 + m - z; if (res < ans) { res = ans; p1 = i; p2 = z; k = 2; } } if (k == 1) for (int i = p1; i <= p2; i++) cout << b[i]; else if (k == 2) { for (int i = 1; i <= p1; i++) cout << b[i]; for (int i = p2; i <= m; i++) cout << b[i]; } else cout << - ; return 0; }
|
#include <bits/stdc++.h> using namespace std; template <typename INT> struct TripleDXY { INT d, x, y; TripleDXY(INT _d = 0, INT _x = 0, INT _y = 0) : d(_d), x(_x), y(_y) {} }; template <typename INT> TripleDXY<INT> egcd(INT a, INT b) { bool neg_a = a < 0; if (neg_a) a = -a; bool neg_b = b < 0; if (neg_b) b = -b; INT x = 0, lastx = 1; INT y = 1, lasty = 0; while (b != 0) { INT t = b; INT q = a / b; b = a % b; a = t; t = x; x = lastx - q * x; lastx = t; t = y; y = lasty - q * y; lasty = t; } return TripleDXY<INT>(a, neg_a ? -lastx : lastx, neg_b ? -lasty : lasty); } long long ChooseMod(int n, int k, int M) { long long res = 1; for (int i = 1; i <= k; ++i, --n) { TripleDXY<int> R = egcd(i, M); assert(R.d == 1); res = (res * n) % M; res = (res * R.x) % M; if (res < 0) res += M; } return res; } int N, K; long long A[2004]; long long R[2004]; long long F[2004]; int main(int argc, char* argv[]) { ios_base::sync_with_stdio(false); cin.tie(NULL); cin >> N >> K; F[0] = 1; for (int i = 1; i < N; ++i) { F[i] = ChooseMod(K - 1 + i, i, 1000000007); } for (int i = 0; i < N; ++i) cin >> A[i]; R[0] = A[0] % 1000000007; for (int i = 1; i < N; ++i) { R[i] = 0; for (int j = 0; j <= i; ++j) { R[i] += (A[j] * F[i - j]); R[i] %= 1000000007; } } for (int i = 0; i < N; ++i) cout << R[i] << ; cout << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { ios_base::sync_with_stdio(0); cin.tie(0); string s1; cin >> s1; string s2; cin >> s2; string s3; cin >> s3; vector<pair<char, int> > cnt(26); for (int i = int(0); i < int(int(s1.size())); i++) { char c = s1[i]; int pos = tolower(c) - a ; cnt[pos].second += 0; cnt[pos].first = c; } for (int i = int(0); i < int(int(s2.size())); i++) { char c = s2[i]; int pos = tolower(c) - a ; cnt[pos].second += 0; cnt[pos].first = c; } for (int i = int(0); i < int(int(s3.size())); i++) { char c = s3[i]; int pos = tolower(c) - a ; cnt[pos].second += 1; cnt[pos].first = c; } for (int i = int(0); i < int(int(s1.size())); i++) { for (int j = int(0); j < int(26); j++) { if (s1[i] == cnt[j].first) { cnt[j].second -= 1; } } } for (int i = int(0); i < int(int(s2.size())); i++) { for (int j = int(0); j < int(26); j++) { if (s2[i] == cnt[j].first) { cnt[j].second -= 1; } } } for (int i = int(0); i < int(26); i++) { if (cnt[i].second < 0 || cnt[i].second > 0) { cout << NO ; return 0; } } cout << YES ; }
|
#include <bits/stdc++.h> using namespace std; long long ar[5000005]; int main() { string s; cin >> s; long long sz = s.size(); long long cnt = 0; for (int i = 0; i < sz; i++) { long long l = 0, w = 0; for (int j = i; j < sz; j++) { if (s[j] == ( ) l++; else if (s[j] == ) ) l--; else w++; if (w > l && w != 0) { w--; l++; } if (l < 0) break; if (w == l) cnt++; } } cout << cnt << endl; }
|
#include <bits/stdc++.h> using namespace std; void __print(int x) { cerr << x; } void __print(long x) { cerr << x; } void __print(long long x) { cerr << x; } void __print(unsigned x) { cerr << x; } void __print(unsigned long x) { cerr << x; } void __print(unsigned long long x) { cerr << x; } void __print(float x) { cerr << x; } void __print(double x) { cerr << x; } void __print(long double x) { cerr << x; } void __print(char x) { cerr << << x << ; } void __print(const char* x) { cerr << << x << ; } void __print(const string& x) { cerr << << x << ; } void __print(bool x) { cerr << (x ? true : false ); } template <typename T, typename V> void __print(const pair<T, V>& x) { cerr << { ; __print(x.first); cerr << , ; __print(x.second); cerr << } ; } template <typename T> void __print(const T& x) { int f = 0; cerr << { ; for (auto& i : x) cerr << (f++ ? , : ), __print(i); cerr << } ; } void _print() { cerr << ] n ; } template <typename T, typename... V> void _print(T t, V... v) { __print(t); if (sizeof...(v)) cerr << , ; _print(v...); } template <class A> void read(vector<A>& v); template <class A, size_t S> void read(array<A, S>& a); template <class T> void read(T& x) { cin >> x; } void read(double& d) { string t; read(t); d = stod(t); } void read(long double& d) { string t; read(t); d = stold(t); } template <class H, class... T> void read(H& h, T&... t) { read(h); read(t...); } template <class A> void read(vector<A>& x) { for (auto& a : x) read(a); } template <class A, size_t S> void read(array<A, S>& x) { for (auto& a : x) read(a); } const int MAXN = 2e5 + 5; long long mod = 1e9 + 7; vector<long long> gr[200005]; void solve() { long long n; cin >> n; vector<long long> a(n); read(a); long long val = 0; for (long long i = int(1); i < int(n); i++) { if (a[i] < a[i - 1]) { val += a[i - 1] - a[i]; } if (val > a[0]) { cout << NO << n ; return; } } cout << YES << n ; } int main() { ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); long long test; test = 1; cin >> test; while (test--) { solve(); } }
|
#include <bits/stdc++.h> #define il inline #define ll long long const int N=2e5+5,B=316; int n,q,b[N],c[N]; ll a[N],lz[N]; il int jump(int x){return x?std::max(a[x]-lz[x/B],0ll):-1;} il void rebuild(int x,int v) { if (c[x]+v>B) return ; c[x]+=v; int i; for (i=x*B; i<x*B+B; i++) b[i]=jump(i)<x*B?i:b[jump(i)]; } il void add(int x,int y,int v) { int i; for (i=x/B*B; i<x; i++) a[i]+=v; for (i=y+1; i<y/B*B+B; i++) a[i]+=v; for (i=x/B; i<=y/B; i++) lz[i]+=v,rebuild(i,i!=x/B&&i!=y/B); } il int LCA(int x,int y) { for ( ; b[x]!=b[y]; x=jump(b[x])) if (jump(b[x])<jump(b[y])) std::swap(x,y); for ( ; x!=y; x=jump(x)) if (x<y) std::swap(x,y); return x; } int main() { scanf( %d%d ,&n,&q),a[0]=-1; int i,x,y,k; for (i=1; i<n; i++) scanf( %d ,a+i),a[i]--; for (add(0,n-1,0); q; q--) if (scanf( %d%d%d ,&i,&x,&y),i>1) printf( %d n ,LCA(x-1,y-1)+1); else scanf( %d ,&k),add(x-1,y-1,k); return 0; }
|
#include <bits/stdc++.h> using namespace std; struct pi { bool dir; int node; int edge; }; const int mxn = 200005; int n; vector<pi> graph[mxn]; int dp1[mxn]; vector<int> vv; int ans = 1000000000; void dfs1(int v, int p) { for (int i = 0; i < graph[v].size(); i++) { pi u = graph[v][i]; if (u.node == p) continue; dfs1(u.node, v); dp1[v] += dp1[u.node]; if (u.dir) dp1[v]++; } } void dfs2(int v, int p, int l) { int temp = l + dp1[v]; if (ans == (n - 1) - temp) vv.push_back(v); else if (ans > (n - 1) - temp) { vv.clear(); vv.push_back(v); ans = (n - 1) - temp; } for (int i = 0; i < graph[v].size(); i++) { pi u = graph[v][i]; if (u.node == p) continue; int something = temp - dp1[u.node]; if (u.dir) something--; else something++; dfs2(u.node, v, something); } } int main() { scanf( %d , &n); for (int i = 1; i < n; i++) { int x, y; scanf( %d%d , &x, &y); pi temp; temp.dir = 1; temp.node = y; temp.edge = i; graph[x].push_back(temp); temp.dir = 0; temp.node = x; graph[y].push_back(temp); } dfs1(1, 1); dfs2(1, 1, 0); printf( %d n , ans); sort(vv.begin(), vv.end()); printf( %d , vv[0]); for (int i = 1; i < vv.size(); i++) printf( %d , vv[i]); printf( n ); return 0; }
|
#include <bits/stdc++.h> using namespace std; using ll = long long; using pi = pair<ll, ll>; const ll inf = 0x3f3f3f3f3f3f3f3f; const ll minf = 0xc0c0c0c0c0c0c0c0; ll A[400400]; ll B[400400]; inline bool between(ll le, ll ri, ll first) { return le <= first && first <= ri; } signed main() { ios::sync_with_stdio(0); cin.tie(0); ll n; cin >> n; for (ll i = 1; i <= n; i++) cin >> A[i]; ll res = 0; for (ll bit = 0; bit <= 24; bit++) { memcpy(B, A, sizeof(ll) * (n + 5)); ll mask = (1 << (bit + 1)) - 1; for (ll i = 1; i <= n; i++) { B[i] &= mask; } sort(B + 1, B + n + 1); ll cnt = 0; for (ll i = 1; i <= n; i++) { cnt += (upper_bound(B + 1, B + n + 1, (1 << bit + 1) - 1 - B[i]) - B) - (lower_bound(B + 1, B + n + 1, (1 << bit) - B[i]) - B); if ((1 << bit) - B[i] <= B[i] && B[i] <= (1 << bit + 1) - 1 - B[i]) --cnt; cnt += (upper_bound(B + 1, B + n + 1, (1 << bit + 2) - 2 - B[i]) - B) - (lower_bound(B + 1, B + n + 1, (1 << bit) + (1 << bit + 1) - B[i]) - B); if (((1 << bit) + (1 << bit + 1)) - B[i] <= B[i] && B[i] <= (1 << bit + 2) - 2 - B[i]) --cnt; } assert(cnt % 2 == 0); cnt /= 2; if (cnt & 1) res |= (1 << bit); } cout << res << n ; return 0; }
|
#include <bits/stdc++.h> using namespace std; void work(); int main() { work(); return 0; } char S[222222]; char T[222222]; int t[256][256]; void work() { int n; while (scanf( %d , &n) == 1) { memset(t, 0, sizeof(t)); int ans = 0; scanf( %s%s , S + 1, T + 1); for (int i = (1), END = (n); i <= END; i++) if (S[i] != T[i]) { ans++; t[S[i]][T[i]] = i; } bool two = false; for (int i = ( a ), END = ( z ); i <= END; i++) for (int j = (i + 1), END = ( z ); j <= END; j++) if (t[i][j] && t[j][i]) { two = true; printf( %d n%d %d n , ans - 2, t[i][j], t[j][i]); i = 256; j = 256; } if (two) continue; for (int i = ( A ), END = ( Z ); i <= END; i++) for (int j = (i + 1), END = ( Z ); j <= END; j++) if (t[i][j] && t[j][i]) { two = true; printf( %d n%d %d n , ans - 2, t[i][j], t[j][i]); i = 256; j = 256; } if (two) continue; bool one = false; for (int i = ( a ), END = ( z ); i <= END; i++) { int pos = -1; for (int j = ( a ), END = ( z ); j <= END; j++) if (t[i][j]) pos = t[i][j]; if (pos == -1) continue; for (int j = ( a ), END = ( z ); j <= END; j++) if (t[j][i]) { one = true; printf( %d n%d %d n , ans - 1, pos, t[j][i]); i = j = 256; } } if (one) continue; for (int i = ( A ), END = ( Z ); i <= END; i++) { int pos = -1; for (int j = ( A ), END = ( Z ); j <= END; j++) if (t[i][j]) pos = t[i][j]; if (pos == -1) continue; for (int j = ( A ), END = ( Z ); j <= END; j++) if (t[j][i]) { one = true; printf( %d n%d %d n , ans - 1, pos, t[j][i]); i = j = 256; } } if (one) continue; printf( %d n%d %d n , ans, -1, -1); } }
|
#include <bits/stdc++.h> using namespace std; int h; int seq[200010]; int par[200010]; int cur, cur_par, rem = -1, rem_par; int main() { scanf( %d , &(h)); for (int i = 0; i < h + 1; i++) scanf( %d , &(seq[i])); cur_par = 1; cur = 1; for (int i = 0; i < h; i++) { if (rem == -1 && seq[i] > 1 && seq[i + 1] > 1) { puts( ambiguous ); rem = cur; rem_par = cur_par; } for (int j = 0; j < seq[i + 1]; j++) par[cur + j] = cur_par; cur += seq[i + 1]; cur_par = cur; } if (rem == -1) { puts( perfect ); return 0; } for (int i = 0; i < cur; i++) printf( %d , par[i]); puts( ); par[rem] = rem_par - 1; for (int i = 0; i < cur; i++) printf( %d , par[i]); }
|
#include <bits/stdc++.h> using namespace std; const int MAXN = 2e5 + 10; long long a[MAXN], dp[MAXN]; int main() { long long n, ans = 0; cin >> n; for (int i = 0; i < n; i++) cin >> a[i]; for (int i = n - 2; i >= 0; i--) { dp[i] = dp[i + 1]; if (a[i + 1] == 0) dp[i]++; } for (int i = 0; i < n; i++) if (a[i] == 1) ans += dp[i]; cout << ans; }
|
#include <bits/stdc++.h> using namespace std; void FastIO() { ios_base::sync_with_stdio(false); cin.tie(0); cout.precision(20); } int main() { FastIO(); int A, B; while (cin >> A >> B) { int M = min(A, B); int N = max(A - M, B - M); cout << M << << N / 2 << endl; } return 0; return 0; }
|
#include <bits/stdc++.h> using namespace std; const int inf = 0x3f3f3f3f; int n, m, a[16][11234], b[16][16], c[16][16], dp[1 << 16][16]; void solve(int u) { for (int i = 0; i < 1 << n; ++i) for (int j = 0; j < n; ++j) dp[i][j] = 0; dp[1 << u][u] = inf; for (int i = 0; i < 1 << n; ++i) for (int j = 0; j < n; ++j) if (dp[i][j]) for (int k = 0; k < n; ++k) if (!(i >> k & 1)) dp[i | (1 << k)][k] = max(dp[i | (1 << k)][k], min(dp[i][j], b[j][k])); } int main() { scanf( %d%d , &n, &m); for (int i = 0; i < n; ++i) for (int j = 0; j < m; ++j) scanf( %d , &a[i][j]); if (n == 1) { int res = inf; for (int j = 0; j < m - 1; ++j) res = min(res, abs(a[0][j] - a[0][j + 1])); printf( %d n , res); return 0; } for (int i = 0; i < n; ++i) for (int j = 0; j < n; ++j) if (i != j) { b[i][j] = c[i][j] = inf; for (int k = 0; k < m; ++k) b[i][j] = min(b[i][j], abs(a[i][k] - a[j][k])); for (int k = 0; k < m - 1; ++k) c[i][j] = min(c[i][j], abs(a[i][k] - a[j][k + 1])); } int res = 0; for (int i = 0; i < n; ++i) { solve(i); for (int j = 0; j < n; ++j) if (i != j) res = max(res, min(c[i][j], dp[(1 << n) - 1][j])); } cout << res << endl; return 0; }
|
#include <bits/stdc++.h> using namespace std; long long m, loc, t; long long now; class SegTree { private: long long F2(long long k) { return 1 << (long long)ceil(log2(k)); } vector<long long> seg; void Merge(long long cur) { seg[cur] = seg[2 * cur] + seg[2 * cur + 1]; } public: SegTree(long long n) { m = F2(n); for (long long i = 0; i < 2 * m + 2; i++) seg.push_back(0); } void Add(long long loc, long long cur = 1, long long l = 1, long long r = m) { if (r < l || r < loc || loc < l) return; else if (l == r) return void(seg[cur]++); long long mid = (l + r) / 2; Add(loc, 2 * cur, l, mid); Add(loc, 2 * cur + 1, mid + 1, r); Merge(cur); } long long Get(long long a, long long b, long long cur = 1, long long l = 1, long long r = m) { if (r < l || r < a || b < l) return 0; else if (a <= l && r <= b) return seg[cur]; long long mid = (l + r) / 2; long long x = Get(a, b, 2 * cur, l, mid); long long y = Get(a, b, 2 * cur + 1, mid + 1, r); return x + y; } long long BinarySearch(long long a, long long l = 1, long long r = now) { if (r < l) return a; long long mid = (l + r) / 2; if (!Get(a + 1, mid)) return max(mid, BinarySearch(a, mid + 1, r)); return BinarySearch(a, l, mid - 1); } }; vector<pair<long long, long long>> v; int main() { long long q; cin >> q; while (q--) { long long n; cin >> n; now = n; loc = 0; long long a[n + 1]; v.clear(); SegTree s(n); for (long long i = 0; i < n; i++) { cin >> t; if (t < loc) s.Add(i + 1); loc = t; a[i + 1] = t; } loc = 2; long long ans = 1; long long last = 1, cur = 0; while (loc <= n) { if (last == 0) swap(last, cur), ans++; last--; long long now = s.BinarySearch(loc + 1); if (loc == n) now = loc; else if (a[loc + 1] < a[loc]) now = loc; cur += now - loc + 1; loc = now + 1; } cout << ans << endl; } return 0; }
|
#include <bits/stdc++.h> using namespace std; int n, T, t[1005] = {0}, v; int main() { std::ios::sync_with_stdio(false); scanf( %d , &n); for (int i = 1; i <= n; i++) { scanf( %d , &v); t[v]++; } scanf( %d , &T); int ans = 0, sum = 0; for (int i = 1; i <= 1000; i++) { sum += t[i]; if (i > T + 1) sum -= t[i - T - 1]; if (sum > ans) ans = sum; } printf( %d n , ans); return 0; }
|
#include <bits/stdc++.h> using namespace std; int main() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); int q; cin >> q; while (q--) { int n, k; cin >> n >> k; int s[n]; char c; for (int i = 0; i < n; i++) { cin >> c; if (c == R ) s[i] = 0; else if (c == G ) s[i] = 1; else s[i] = 2; } int counter1 = 0; int counter2 = 0; int counter3 = 0; int myMin = k; for (int l = 0; l < k; l++) { if (s[l] != l % 3) { counter1++; } if (s[l] != (l + 1) % 3) { counter2++; } if (s[l] != (l + 2) % 3) { counter3++; } } myMin = min(myMin, min(counter1, min(counter2, counter3))); for (int j = 0; j < n - k; j++) { if (j % 3 != s[j]) { counter1--; } if ((k + j) % 3 != s[j + k]) { counter1++; } if ((j + 1) % 3 != s[j]) { counter2--; } if ((k + j + 1) % 3 != s[j + k]) { counter2++; } if ((j + 2) % 3 != s[j]) { counter3--; } if ((k + j + 2) % 3 != s[j + k]) { counter3++; } myMin = min(myMin, min(counter1, min(counter2, counter3))); } cout << myMin << endl; } return 0; }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.