solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<long long> v(n);
for (auto &it : v) cin >> it;
long long ans = v[n - 1];
long long prev = v[n - 1];
for (int i = n - 2; i >= 0; i--) {
long long x = min(prev - 1, v[i]);
if (x == 0) break;
ans += x;
prev = x;
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
long long ans, f[100010], i, tot, g[100010], a, b, c, n, j;
void exgcd(long long a, long long b, long long &x, long long &y) {
long long t;
if (b == 0) {
x = 1;
y = 0;
return;
}
exgcd(b, a % b, x, y);
t = x;
x = y;
y = t - a / b * y;
}
long long cnt(int a, int b) {
long long u, v, w, x, y;
u = f[a];
w = 1000000007;
v = (f[b] * f[a - b]) % 1000000007;
exgcd(v, w, x, y);
x = (x % 1000000007 + 1000000007) % 1000000007;
x = (x * u) % 1000000007;
return x;
}
void dfs(long long x, long long y, long long z) {
long long i;
if (a / x - 1 < b - 1) return;
if (z == 0)
ans = (ans + cnt(a / x - 1, b - 1)) % 1000000007;
else
ans = (ans - cnt(a / x - 1, b - 1) + 1000000007) % 1000000007;
for (i = y; i <= tot; i++)
if (x * g[i] <= a) dfs(x * g[i], i + 1, 1 - z);
}
int main() {
scanf("%I64d", &n);
f[0] = 1;
for (i = 1; i <= 100000; i++) f[i] = f[i - 1] * i % 1000000007;
for (i = 1; i <= n; i++) {
ans = 0;
scanf("%I64d%I64d", &a, &b);
c = a;
tot = 0;
for (j = 2; j <= sqrt(a); j++)
if (c % j == 0) {
tot++;
g[tot] = j;
while (c % j == 0) c = c / j;
}
if (c > 1) {
tot++;
g[tot] = c;
}
dfs(1, 1, 0);
printf("%I64d\n", ans);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
long long n, T, i, j, k, ct, cn = 1, nn, r = 0;
cin >> n >> T;
ct = T;
vector<long long> t(n), q(n);
for (i = 0; i < n; ++i) {
cin >> t[i] >> q[i];
}
for (i = 0; i < n; ++i) {
for (j = 0; j < n - 1; ++j) {
if (t[j] < t[j + 1]) {
swap(t[j], t[j + 1]);
swap(q[j], q[j + 1]);
}
}
}
vector<vector<long long> > v(n + 1, vector<long long>(n + 1, -1));
while (ct > t[0]) {
cn *= 2;
if (cn > n) {
cn = n;
}
--ct;
}
v[0][cn] = 0;
for (i = 0; i < n; ++i) {
ct = t[i];
nn = 1;
if (i != n - 1) {
for (j = ct; j > t[i + 1]; --j) {
nn *= 2;
if (nn > n) {
nn = n;
}
}
}
for (j = 0; j <= n; ++j) {
if (v[i][j] != -1) {
v[i + 1][min(j * nn, n)] = max(v[i + 1][min(j * nn, n)], v[i][j]);
if (j != 0) {
v[i + 1][min((j - 1) * nn, n)] =
max(v[i + 1][min((j - 1) * nn, n)], v[i][j] + q[i]);
}
}
}
}
for (i = 0; i <= n; ++i) {
r = max(r, v[n][i]);
}
cout << r << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
using namespace std;
template <class T>
using rque = priority_queue<T, vector<T>, greater<T>>;
template <class T>
bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmax(T &a, const T &b) {
if (b > a) {
a = b;
return 1;
}
return 0;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
if (b == 0) return a;
long long cnt = a % b;
while (cnt != 0) {
a = b;
b = cnt;
cnt = a % b;
}
return b;
}
long long extGCD(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long d = extGCD(b, a % b, y, x);
y -= a / b * x;
return d;
}
struct UnionFind {
vector<long long> data;
int num;
UnionFind(int sz) {
data.assign(sz, -1);
num = sz;
}
bool unite(int x, int y) {
x = find(x), y = find(y);
if (x == y) return (false);
if (data[x] > data[y]) swap(x, y);
data[x] += data[y];
data[y] = x;
num--;
return (true);
}
int find(int k) {
if (data[k] < 0) return (k);
return (data[k] = find(data[k]));
}
long long size(int k) { return (-data[find(k)]); }
bool same(int x, int y) { return find(x) == find(y); }
};
template <int mod>
struct ModInt {
int x;
ModInt() : x(0) {}
ModInt(int64_t y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}
ModInt &operator+=(const ModInt &p) {
if ((x += p.x) >= mod) x -= mod;
return *this;
}
ModInt &operator-=(const ModInt &p) {
if ((x += mod - p.x) >= mod) x -= mod;
return *this;
}
ModInt &operator*=(const ModInt &p) {
x = (int)(1LL * x * p.x % mod);
return *this;
}
ModInt &operator/=(const ModInt &p) {
*this *= p.inverse();
return *this;
}
ModInt operator-() const { return ModInt(-x); }
ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }
ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }
ModInt &operator++() { return *this += ModInt(1); }
ModInt operator++(int) {
ModInt tmp = *this;
++*this;
return tmp;
}
ModInt &operator--() { return *this -= ModInt(1); }
ModInt operator--(int) {
ModInt tmp = *this;
--*this;
return tmp;
}
ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }
ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }
bool operator==(const ModInt &p) const { return x == p.x; }
bool operator!=(const ModInt &p) const { return x != p.x; }
ModInt inverse() const {
int a = x, b = mod, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return ModInt(u);
}
ModInt pow(int64_t n) const {
ModInt ret(1), mul(x);
while (n > 0) {
if (n & 1) ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &p) { return os << p.x; }
friend istream &operator>>(istream &is, ModInt &a) {
int64_t t;
is >> t;
a = ModInt<mod>(t);
return (is);
}
static int get_mod() { return mod; }
};
long long mpow2(long long x, long long n, long long mod) {
long long ans = 1;
while (n != 0) {
if (n & 1) ans = ans * x % mod;
x = x * x % mod;
n = n >> 1;
}
return ans;
}
long long modinv2(long long a, long long mod) {
long long b = mod, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= mod;
if (u < 0) u += mod;
return u;
}
constexpr int mod = 1000000007;
using mint = ModInt<mod>;
mint mpow(mint x, long long n) {
mint ans = 1;
while (n != 0) {
if (n & 1) ans *= x;
x *= x;
n = n >> 1;
}
return ans;
}
long long k;
mint solve(long long n, long long m, long long r, long long c) {
if (n == r && m == c) return mpow(k, n * m);
if (2 * r - n <= 0 || 2 * c - m <= 0) return mpow(k, n * m - r * c);
return solve(r, c, 2 * r - n, 2 * c - m) * mpow(k, 2 * (n - r) * (m - c));
}
int main() {
ios::sync_with_stdio(false);
std::cin.tie(nullptr);
cout << fixed << setprecision(15);
long long n, m, r, c, ax, ay, bx, by;
cin >> n >> m >> k >> r >> c >> ax >> ay >> bx >> by;
if (ax > bx) {
ax = n + 1 - ax;
bx = n + 1 - bx;
}
if (ay > by) {
ay = n + 1 - ay;
by = n + 1 - by;
}
long long cn = bx + r - ax, cm = by + c - ay;
mint ans = mpow(k, n * m - cn * cm);
ans *= solve(cn, cm, r, c);
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
template <typename T1, typename T2>
inline void mine(T1& x, T2 y) {
if (y < x) x = y;
}
template <typename T1, typename T2>
inline void maxe(T1& x, T2 y) {
if (x < y) x = y;
}
template <typename T1, typename T2>
inline bool chkmin(T1& x, const T2& y) {
if (x > y) {
x = y;
return 1;
}
return 0;
}
template <typename T1, typename T2>
inline bool chkmax(T1& x, const T2& y) {
if (x < y) {
x = y;
return 1;
}
return 0;
}
using namespace std;
const int MOD[]{1000000007, 998233353};
const int BASE[]{257, 239};
const int INF = 1000000050;
const long long BIG = (long long)2e18 + 50;
const double EPS = 1e-9;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
ostream& operator<<(ostream& out, const vector<int>& b) {
for (auto k : b) out << k << " ";
return out;
}
istream& operator>>(istream& in, pair<int, int>& b) {
in >> b.first >> b.second;
return in;
}
ostream& operator<<(ostream& out, const pair<int, int>& b) {
out << "{" << b.first << ", " << b.second << "}";
return out;
}
inline int add(int a, int b, int mod) {
a += b;
if (a >= MOD[mod]) return a - MOD[mod];
return a;
}
inline int mult(int a, int b, int mod) { return 1ll * a * b % MOD[mod]; }
inline int sub(int a, int b, int mod) {
a -= b;
if (a < 0) return a + MOD[mod];
return a;
}
const int MXN = 100010;
const int MXC = 1000200;
string s[MXN];
vector<vector<int> > h[MXN];
int pw[MXC][2];
vector<int> dp[MXN];
vector<int> kek[MXN];
vector<int> get(int i, int x, int len) {
if (x < len) {
vector<int> res = h[i][len + 1];
for (int m = 0; m < 1; ++m) {
int dx = mult(s[i][x], pw[len - x][m], m);
int dpref = mult(h[i][x][m], mult(pw[len - x][m], BASE[m] - 1, m), m);
res[m] = sub(res[m], add(dx, dpref, m), m);
}
return res;
} else {
return h[i][len];
}
}
bool cmp(int i1, int j1, int i2, int j2) {
int len1 = ((int)s[i1].size()) - (j1 < (int)s[i1].size());
int len2 = ((int)s[i2].size()) - (j2 < (int)s[i2].size());
int len = min(len1, len2);
int l = 0;
int r = len + 1;
while (r - l > 1) {
int m = (l + r) / 2;
if (get(i1, j1, m) == get(i2, j2, m))
l = m;
else
r = m;
}
if (l < len) {
int ind1 = l + (j1 <= l);
int ind2 = l + (j2 <= l);
assert(s[i1][ind1] != s[i2][ind2]);
return s[i1][ind1] < s[i2][ind2];
}
return (len1 < len2) || (len1 == len2 && i1 < i2);
}
int i;
bool ccmp(int a, int b) { return cmp(i, a, i, b); }
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
for (int b = 0; b < 1; ++b) {
pw[0][b] = 1;
for (int it = 1; it < MXC; ++it) {
pw[it][b] = mult(pw[it - 1][b], BASE[b], b);
}
}
for (i = 0; i < n; ++i) {
cin >> s[i];
h[i] = vector<vector<int> >(s[i].size() + 1, vector<int>(1, 0));
for (int b = 0; b < 1; ++b)
for (int j = 1; j <= s[i].size(); ++j)
h[i][j][b] = add(mult(h[i][j - 1][b], BASE[b], b), s[i][j - 1], b);
for (int j = 0; j < s[i].size() + 1; ++j) kek[i].push_back(j);
sort(kek[i].begin(), kek[i].end(), ccmp);
if (!i) {
dp[i] = vector<int>(s[i].size() + 1, 1);
continue;
}
int pref = 0;
int it = 0;
dp[i] = vector<int>(s[i].size() + 1, 0);
for (int j = 0; j < kek[i].size(); ++j) {
while (it < kek[i - 1].size() &&
cmp(i - 1, kek[i - 1][it], i, kek[i][j])) {
pref = add(pref, dp[i - 1][kek[i - 1][it]], 0);
++it;
}
dp[i][kek[i][j]] = pref;
}
}
int ans = 0;
for (int x : dp[n - 1]) ans = add(ans, x, 0);
cout << ans << '\n';
}
| 10 |
#include <bits/stdc++.h>
using std::vector;
namespace IO_base {
const int MAXB = 1 << 10;
char gbuf[MAXB], *ps = gbuf, *pt = gbuf;
inline char Getchar() {
if (ps == pt) {
ps = gbuf;
pt = gbuf + fread(gbuf, 1, MAXB, stdin);
}
return (ps == pt) ? EOF : *ps++;
}
} // namespace IO_base
namespace IO_number {
long long read() {
long long x = 0;
char c = IO_base::Getchar();
bool f = 0;
while (c < '0' || c > '9')
(c == '-') ? f = 1, c = IO_base::Getchar() : c = IO_base::Getchar();
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (48 ^ c), c = IO_base::Getchar();
return (f) ? -x : x;
}
} // namespace IO_number
using namespace IO_number;
const int MAXN = 1e5, MAXA = 1e9;
const int MAXN_Seg = (30 * MAXN + 30 * MAXN) + 20;
namespace SegmentTree {
int tot = 1;
int ls[MAXN_Seg], rs[MAXN_Seg];
long long sum[MAXN_Seg];
int cnt[MAXN_Seg];
int new_node() { return ++tot; }
inline void pushup(const int &x) {
sum[x] = (sum[ls[x]] + sum[rs[x]]);
cnt[x] = (cnt[ls[x]] + cnt[rs[x]]);
}
int modify(const int &pos, const int &typ, const int &nl = 0,
const int &nr = MAXA, int x = 1) {
if (!x) x = new_node();
if (nl == nr)
return cnt[x] += typ, sum[x] += typ * pos, x;
else {
const int mid = (nl + nr) >> 1;
if (pos <= mid)
ls[x] = modify(pos, typ, nl, mid, ls[x]);
else
rs[x] = modify(pos, typ, mid + 1, nr, rs[x]);
pushup(x);
return x;
}
}
long long query_capacity(const int &limit, const int &nl = 0,
const int &nr = MAXA, const int &x = 1) {
if (!x) return 0;
if (nl == nr)
return 1ll * limit * cnt[x] - sum[x];
else {
const int mid = (nl + nr) >> 1;
if (limit <= mid)
return query_capacity(limit, nl, mid, ls[x]);
else
return (1ll * limit * cnt[ls[x]] - sum[ls[x]]) +
query_capacity(limit, mid + 1, nr, rs[x]);
}
}
int query_kth(const int &k, const int &nl = 0, const int &nr = MAXA,
const int &x = 1) {
if (nl == nr)
return nl;
else {
const int mid = (nl + nr) >> 1;
if (k <= cnt[ls[x]])
return query_kth(k, nl, mid, ls[x]);
else
return query_kth(k - cnt[ls[x]], mid + 1, nr, rs[x]);
}
}
} // namespace SegmentTree
using namespace SegmentTree;
int main() {
const int n = read(), m = read();
vector<int> arr(n);
for (int i = 0; i < n; ++i) arr[i] = read(), modify(arr[i], 1);
for (int tt = 0; tt < m; ++tt) {
const int op = read();
if (op == 1) {
const int p = read() - 1, x = read();
modify(arr[p], -1);
arr[p] = x;
modify(arr[p], 1);
} else {
const long long v = read();
int l = 0, r = n - 1;
int ans = n;
while (l <= r) {
const int mid = (l + r) >> 1;
if (query_capacity(query_kth(mid + 1)) >= v)
ans = std::min(ans, mid), r = mid - 1;
else
l = mid + 1;
}
const int tmp = query_kth(ans + 1 - 1);
printf("%.5lf\n", tmp + 1.0 * (v - query_capacity(tmp)) / (ans + 1 - 1));
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool ok(int n, int m) {
bool vis[11];
memset(vis, 0, sizeof(vis));
char nn[11], mm[11];
sprintf(nn, "%d", n);
for (int i = 0; nn[i]; i++) {
vis[nn[i] - '0'] = true;
}
sprintf(mm, "%d", m);
for (int i = 0; mm[i]; i++) {
if (vis[mm[i] - '0']) return true;
}
return false;
}
int main() {
int n;
scanf("%d", &n);
int ans = 0;
for (int i = 1; i * i <= n; i++) {
if (n % i == 0) {
if (ok(n, i)) ans++;
if (i * i != n) {
if (ok(n, n / i)) ans++;
}
}
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while ((c < '0' || c > '9') && (c != '-')) c = getchar();
if (c == '-') f = -1, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * f;
}
const int N = 150010;
int n, a[N];
vector<int> e[N];
struct line {
long long k, b;
inline long long f(long long x) { return 1ll * k * x + b; }
};
struct Tree {
line v[N];
int rt, tot, ls[N], rs[N];
inline void Clear() { rt = tot = 0; }
inline void insert(int &u, long long l, long long r, line x) {
if (!u) return v[u = ++tot] = x, ls[tot] = rs[tot] = 0, void(0);
long long mid = l + r >> 1;
if (x.f(mid) > v[u].f(mid)) swap(v[u], x);
if (x.f(l) > v[u].f(l))
insert(ls[u], l, mid, x);
else if (x.f(r) > v[u].f(r))
insert(rs[u], mid + 1, r, x);
}
inline long long Query(int u, long long l, long long r, long long x) {
if (!u) return 0;
long long mid = l + r >> 1;
if (x <= mid)
return max(v[u].f(x), Query(ls[u], l, mid, x));
else
return max(v[u].f(x), Query(rs[u], mid + 1, r, x));
}
} T;
bool vis[N];
int Siz, siz[N], rt, mx[N];
inline void FindRoot(int u, int fa) {
siz[u] = 1, mx[u] = 0;
for (auto v : e[u])
if (v != fa && !vis[v]) {
FindRoot(v, u), siz[u] += siz[v];
mx[u] = max(mx[u], siz[v]);
}
mx[u] = max(mx[u], Siz - siz[u]);
if (mx[u] < mx[rt]) rt = u;
}
int dep[N];
long long ans, s1[N], pre[N], s2[N];
inline void dfs1(int u, int fa) {
dep[u] = dep[fa] + 1, s1[u] = s1[fa] + 1ll * a[u] * dep[u];
pre[u] = pre[fa] + a[u];
ans = max(ans, T.Query(T.rt, 1, 1e12, pre[u]) + s1[u]);
for (auto v : e[u])
if (v != fa && !vis[v]) {
dfs1(v, u);
}
}
inline void dfs2(int u, int fa, int rt) {
s2[u] = s2[fa] + (pre[u] - a[rt]);
ans = max(ans, s2[u] + 1ll * a[rt] * dep[u]);
T.insert(T.rt, 1, 1e12, (line){dep[u] - 1, s2[u]});
for (auto v : e[u])
if (v != fa && !vis[v]) {
dfs2(v, u, rt);
}
}
inline void solve(int u) {
vis[u] = 1;
T.Clear();
s1[u] = a[u], dep[u] = 1, s2[u] = 0, pre[u] = a[u];
for (register int i = (0); i < (((int)(e[u]).size())); i++)
if (!vis[e[u][i]]) {
dfs1(e[u][i], u), dfs2(e[u][i], u, u);
}
T.Clear();
for (register int i = (((int)(e[u]).size()) - 1); i >= (0); i--)
if (!vis[e[u][i]]) {
dfs1(e[u][i], u), dfs2(e[u][i], u, u);
}
for (auto v : e[u])
if (!vis[v]) {
Siz = siz[v], rt = 0, FindRoot(v, u), solve(rt);
}
}
int main() {
n = read();
for (register int i = (1); i < (n); i++) {
int x = read(), y = read();
e[x].push_back(y), e[y].push_back(x);
}
for (register int i = (1); i <= (n); i++) a[i] = read();
Siz = mx[0] = n, FindRoot(1, 0), solve(rt);
printf("%lld\n", ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000005;
const double eps = 1e-11;
const long long oo = 1e11 + 7;
const int mod = 1e9 + 7;
long long n, v[MAX];
long long dp0[MAX], dp1[MAX];
vector<int> g[MAX];
void dfs(int node) {
long long sum = 0;
long long par = 0, impar = 0, ipar, iipar;
for (int i = 0; i < g[node].size(); ++i) {
int to = g[node][i];
dfs(to);
if (i == 0) {
par = dp0[to];
impar = dp1[to];
} else {
ipar = par;
iipar = impar;
par = max(dp1[to] + iipar, par);
par = max(dp0[to] + ipar, par);
impar = max(dp1[to] + ipar, impar);
impar = max(dp0[to] + iipar, impar);
}
}
dp1[node] = max(impar, v[node] + par);
dp0[node] = par;
}
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
cin >> n;
long long x, y;
for (int i = 1; i <= n; i++) {
cin >> x >> y;
if (x != -1) {
g[x].push_back(i);
}
v[i] = y;
}
dfs(1);
cout << max(dp1[1], dp0[1]) << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool isprime(long long n) {
for (long long i = 2; i <= sqrt(n); i++) {
if (n % i == 0) return false;
}
return true;
}
bool prm[10000007];
long long N = 10000000;
void sieve() {
prm[1] = 1;
for (long long i = 2; i <= sqrt(N); i++) {
if (prm[i] == 0) {
for (long long j = i + i; j <= N; j = j + i) prm[j] = 1;
}
}
}
long long bm(long long b, long long p) {
long long namira;
if (p == 0) return 1;
if (p % 2 == 0) {
namira = bm(b, p / 2);
return ((namira % 1000000007) * (namira % 1000000007)) % 1000000007;
} else {
return ((b % 1000000007) * (bm(b, p - 1) % 1000000007)) % 1000000007;
}
}
long long arr[200010];
long long a[200010];
long long tree1[200010 * 3];
void init(long long node, long long b, long long e) {
if (b == e) {
tree1[node] = 1;
return;
}
long long Left = node * 2;
long long Right = node * 2 + 1;
long long mid = (b + e) / 2;
init(Left, b, mid);
init(Right, mid + 1, e);
tree1[node] = tree1[Left] + tree1[Right];
}
long long query(long long node, long long b, long long e, long long i) {
if (a[b] > i) return 0;
if (a[e] <= i) {
return tree1[node];
}
long long Left = node * 2;
long long Right = node * 2 + 1;
long long mid = (b + e) / 2;
long long p1 = query(Left, b, mid, i);
long long p2 = query(Right, mid + 1, e, i);
return p1 + p2;
}
void update(long long node, long long b, long long e, long long i,
long long newvalue) {
if (i > e || i < b) return;
if (b >= i && e <= i) {
tree1[node] = newvalue;
return;
}
long long Left = node * 2;
long long Right = node * 2 + 1;
long long mid = (b + e) / 2;
update(Left, b, mid, i, newvalue);
update(Right, mid + 1, e, i, newvalue);
tree1[node] = tree1[Left] + tree1[Right];
}
int main() {
long long a[100010], b[100010], n, i, r, c;
scanf("%I64d", &n);
for (i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
b[i] = 0;
}
b[0] = 0;
b[n + 1] = 0;
for (i = n; i >= 1; i--) {
b[a[i]] = 1;
b[a[i]] = b[a[i]] + b[a[i] + 1];
}
r = n - (*max_element(b, b + n + 1));
printf("%I64d\n", r);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void _print(long long t) { cerr << t; }
void _print(int t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(long double t) { cerr << t; }
void _print(double t) { cerr << t; }
void _print(unsigned long long t) { cerr << t; }
template <class T, class V>
void _print(pair<T, V> p);
template <class T>
void _print(vector<T> v);
template <class T>
void _print(set<T> v);
template <class T, class V>
void _print(map<T, V> v);
template <class T>
void _print(multiset<T> v);
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ",";
_print(p.second);
cerr << "}";
}
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
long long gcd(long long a, long long b) {
if (b > a) {
return gcd(b, a);
}
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
long long mexpo(long long a, long long b, long long m) {
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % m;
a = (a * a) % m;
b = b >> 1;
}
return res;
}
vector<int> prime;
void seive(long long n) {
int lp[n + 1];
for (int i = 2; i <= n; ++i) {
if (lp[i] == 0) {
lp[i] = i;
prime.push_back(i);
}
for (int j = 0;
j < (int)prime.size() && prime[j] <= lp[i] && i * prime[j] <= n; ++j)
lp[i * prime[j]] = prime[j];
}
}
int main() {
clock_t begin = clock();
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int k;
cin >> k;
int n = 20000000;
for (int i = 1; i <= n; i++) {
int sum = 0;
int num = i;
while (num) {
sum += num % 10;
num /= 10;
}
if (sum == 10) {
k--;
}
if (k == 0) {
cout << i << "\n";
break;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
static long long int INF = 1e9 + 7;
using namespace std;
template <typename T>
bool comp(T a, T b) {
if (a < b) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int n;
cin >> n;
vector<int> v(1000001, 0);
int two = 0, four = 0;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
two -= v[a] / 2;
four -= v[a] / 4;
v[a]++;
two += v[a] / 2;
four += v[a] / 4;
}
int q;
cin >> q;
while (q--) {
int ch = false, ch1 = false;
char c;
int a;
cin >> c >> a;
two -= v[a] / 2;
four -= v[a] / 4;
if (c == '+')
v[a]++;
else
v[a]--;
two += v[a] / 2;
four += v[a] / 4;
if (four >= 1 && two >= 4)
cout << "yEs";
else
cout << "nO";
cout << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double dinf = 1e200;
void mytimer(string task) {}
void ext(int c) {}
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 0; i < (n); ++i) {
int a, b, t;
cin >> a >> b >> t;
if (a == b) {
cout << t << '\n';
continue;
}
int res = abs(a - b);
int t0 = (a < b) ? (a - 1) : (m - 1 + m - a);
res += t + (2 * m - 2 - (t - t0 + 2 * m - 2) % (2 * m - 2)) % (2 * m - 2);
cout << res << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, z;
cin >> x >> y >> z;
if ((x > y) && ((x - y) > z)) {
cout << "+";
} else {
if ((x < y) && ((y - x) > z)) {
cout << "-";
} else {
if ((x == y) && (z == 0)) {
cout << "0";
} else {
cout << "?";
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, cnt[5], res;
string a, b;
int main() {
cin >> n;
cin >> a >> b;
for (int i = 0; i < n; ++i) ++cnt[a[i] - '0'];
for (int i = 0; i < n; ++i) {
if (b[i] == '0') {
if (a[i] == '0')
res += cnt[1];
else
res += cnt[0];
--cnt[a[i] - '0'];
}
}
cout << res;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char c = getchar();
long long x = 0;
bool f = 0;
for (; !isdigit(c); c = getchar()) f ^= !(c ^ 45);
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
if (f) x = -x;
return x;
}
long long n, m;
struct edge {
long long to, nxt, w;
} e[100005 << 1];
long long tot, head[100005];
inline void adde(long long u, long long v, long long w) {
e[++tot] = (edge){v, head[u], w};
head[u] = tot;
}
double res;
long long sz[100005], wsz[100005];
inline bool cmp(long long a, long long b) {
return wsz[a] * sz[b] < wsz[b] * sz[a];
}
void dfs(long long u, long long pa) {
vector<long long> o;
sz[u] = 1;
for (long long i = head[u]; i; i = e[i].nxt) {
long long v = e[i].to;
if (v == pa) continue;
dfs(v, u);
o.push_back(v);
res += e[i].w * sz[v];
sz[u] += sz[v];
wsz[v] += e[i].w * 2;
wsz[u] += wsz[v];
}
sort(o.begin(), o.end(), cmp);
long long now = sz[u] - 1;
for (auto v : o) {
now -= sz[v];
res += wsz[v] * now;
}
}
signed main() {
n = read();
for (register long long i = (2); i <= (n); ++i) {
long long u = read(), v = read(), w = read();
adde(u, v, w), adde(v, u, w);
}
dfs(1, 0);
printf("%.12lf", 1.0 * res / (n - 1));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> A, P;
int ans;
struct node {
struct node *a[2];
int cnt;
};
struct node *get_n() {
struct node *tmp = new node;
for (int i = 0; i < 2; i++) tmp->a[i] = NULL;
tmp->cnt = 0;
return tmp;
}
void inser(struct node *root, string s) {
struct node *tmp = root;
int n = s.size();
for (int i = 0; i < n; i++) {
int pos = s[i] - '0';
if (tmp->a[pos] == NULL) tmp->a[pos] = get_n();
tmp = tmp->a[pos];
}
tmp->cnt++;
return;
}
struct node *delet(struct node *root, string &s, int pos) {
if (pos == 30) {
root->cnt--;
if (root->cnt == 0) root = NULL;
return root;
}
struct node *tmp;
if (s[pos] == '0') {
if (root->a[0] != NULL) {
tmp = delet(root->a[0], s, pos + 1);
if (tmp == NULL) {
root->a[0] = NULL;
if (root->a[1] == NULL) root = NULL;
}
} else {
ans += (1 << (29 - pos));
tmp = delet(root->a[1], s, pos + 1);
if (tmp == NULL) {
root->a[1] = NULL;
if (root->a[0] == NULL) root = NULL;
}
}
} else {
if (root->a[1] != NULL) {
tmp = delet(root->a[1], s, pos + 1);
if (tmp == NULL) {
root->a[1] = NULL;
if (root->a[0] == NULL) root = NULL;
}
} else {
ans += (1 << (29 - pos));
tmp = delet(root->a[0], s, pos + 1);
if (tmp == NULL) {
root->a[0] = NULL;
if (root->a[1] == NULL) root = NULL;
}
}
}
return root;
}
signed main() {
struct node *root = get_n();
int n;
scanf("%d", &n);
A.resize(n);
P.resize(n);
for (int i = 0; i < n; i++) scanf("%d", &A[i]);
for (int i = 0; i < n; i++) {
scanf("%d", &P[i]);
string s;
int x = P[i];
while (x > 0) {
if (x % 2 == 1)
s = s + "1";
else
s = s + "0";
x /= 2;
}
while (s.size() < 30) s = s + "0";
reverse(s.begin(), s.end());
inser(root, s);
}
for (int i = 0; i < n; i++) {
string s;
int x = A[i];
while (x > 0) {
if (x % 2 == 1)
s = s + "1";
else
s = s + "0";
x /= 2;
}
while (s.size() < 30) s = s + "0";
reverse(s.begin(), s.end());
ans = 0;
root = delet(root, s, 0);
printf("%d ", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline long long input() {
int32_t x;
scanf("%d", &x);
return x;
}
inline long long in() {
int32_t x;
scanf("%d", &x);
return x;
}
const long long maxn = 2e5 + 10;
const long long mod = 1e9 + 7;
long long a[maxn], b[maxn];
int32_t main() {
long long n = in();
long long sum = 0;
for (long long i = 0; i < n; i++) a[i] = in(), sum += a[i];
for (long long i = 0; i < n; i++) b[i] = in();
sort(b, b + n, greater<long long>());
long long ss = b[0] + b[1];
if (ss >= sum)
return cout << "YES\n", 0;
else
cout << "NO\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T extgcd(T a, T b, T& x, T& y) {
for (T u = y = 1, v = x = 0; a;) {
T q = b / a;
swap(x -= q * u, u);
swap(y -= q * v, v);
swap(b -= q * a, a);
}
return b;
}
template <class T>
T mod_inv(T a, T m) {
T x, y;
extgcd(a, m, x, y);
return (m + x % m) % m;
}
long long mod_pow(long long a, long long n, long long mod) {
long long ret = 1;
long long p = a % mod;
while (n) {
if (n & 1) ret = ret * p % mod;
p = p * p % mod;
n >>= 1;
}
return ret;
}
template <long long mod, long long primitive_root>
class NTT {
public:
long long get_mod() const { return mod; }
void _ntt(vector<long long>& a, long long sign) {
const long long n = ((long long)(a).size());
const long long g = primitive_root;
long long h = (long long)mod_pow(g, (mod - 1) / n, mod);
if (sign == -1) h = (long long)mod_inv(h, mod);
long long i = 0;
for (long long j = 1; j < n - 1; ++j) {
for (long long k = n >> 1; k > (i ^= k); k >>= 1)
;
if (j < i) swap(a[i], a[j]);
}
for (long long m = 1; m < n; m *= 2) {
const long long m2 = 2 * m;
const long long base = mod_pow(h, n / m2, mod);
long long w = 1;
for (long long x = 0; x < (m); x++) {
for (long long s = x; s < n; s += m2) {
long long u = a[s];
long long d = a[s + m] * w % mod;
a[s] = u + d;
if (a[s] >= mod) a[s] -= mod;
a[s + m] = u - d;
if (a[s + m] < 0) a[s + m] += mod;
}
w = w * base % mod;
}
}
for (auto& x : a)
if (x < 0) x += mod;
}
void ntt(vector<long long>& input) { _ntt(input, 1); }
void intt(vector<long long>& input) {
_ntt(input, -1);
const long long n_inv = mod_inv(((long long)(input).size()), mod);
for (auto& x : input) x = x * n_inv % mod;
}
vector<long long> convolution(const vector<long long>& a,
const vector<long long>& b) {
long long ntt_size = 1;
while (ntt_size < ((long long)(a).size()) + ((long long)(b).size()))
ntt_size *= 2;
vector<long long> _a = a, _b = b;
_a.resize(ntt_size);
_b.resize(ntt_size);
ntt(_a);
ntt(_b);
for (long long i = 0; i < (ntt_size); i++) {
(_a[i] *= _b[i]) %= mod;
}
intt(_a);
return _a;
}
vector<long long> powup(const vector<long long>& a, long long exponent) {
long long ntt_size = 1;
while (ntt_size < (((long long)(a).size()) * exponent)) ntt_size *= 2;
vector<long long> _a = a;
_a.resize(ntt_size);
ntt(_a);
for (long long i = 0; i < (ntt_size); i++) {
_a[i] = mod_pow(_a[i], exponent, mod);
}
intt(_a);
return _a;
}
};
vector<long long> mul(vector<long long> a, vector<long long> b, long long mod) {
for (auto& x : a) x %= mod;
for (auto& x : b) x %= mod;
NTT<167772161, 3> ntt1;
NTT<469762049, 3> ntt2;
NTT<1224736769, 3> ntt3;
auto x = ntt1.convolution(a, b);
auto y = ntt2.convolution(a, b);
auto z = ntt3.convolution(a, b);
const long long m1 = ntt1.get_mod(), m2 = ntt2.get_mod(), m3 = ntt3.get_mod();
const long long m1_inv_m2 = mod_inv<long long>(m1, m2);
const long long m12_inv_m3 = mod_inv<long long>(m1 * m2, m3);
const long long m12_mod = m1 * m2 % mod;
vector<long long> ret(((long long)(x).size()));
for (long long i = 0; i < (((long long)(x).size())); i++) {
long long v1 = (y[i] - x[i]) * m1_inv_m2 % m2;
if (v1 < 0) v1 += m2;
long long v2 = (z[i] - (x[i] + m1 * v1) % m3) * m12_inv_m3 % m3;
if (v2 < 0) v2 += m3;
long long constants3 = (x[i] + m1 * v1 + m12_mod * v2) % mod;
if (constants3 < 0) constants3 += mod;
ret[i] = constants3;
}
return ret;
}
vector<long long> exppoly(vector<long long> base, long long e, long long mod) {
vector<long long> ans = {1};
while (e > 0) {
if (e % 2 == 1) {
ans = mul(ans, base, mod);
e--;
} else {
base = mul(base, base, mod);
e /= 2;
}
}
return ans;
}
const long long MOD = 1000000007LL;
int main() {
ios_base::sync_with_stdio(false);
long long a, b, k, t;
cin >> a >> b >> k >> t;
vector<long long> v;
for (long long x = 0; x < 2 * k + 1; x++) v.push_back(1);
vector<long long> got = exppoly(v, t, MOD);
long long len = got.size();
vector<long long> suf = got;
for (long long x = len - 2; x >= 0; x--) suf[x] = (suf[x] + suf[x + 1]) % MOD;
long long ans = 0;
for (long long x = 0; x < len; x++) {
long long me = b + x;
long long youneed = max(0LL, me + 1 - a);
if (youneed >= len) continue;
ans += (got[x] * suf[youneed]);
ans %= MOD;
}
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int f(int x1, int y1, int x2, int y2, int x, int y) {
return ((long long)(x2 - x1) * (long long)(y - y1) -
(long long)(y2 - y1) * (long long)(x - x1) >
0);
}
int main() {
int n, vx[100010], vy[100010], a[100010], k[100010], t, p, x, y;
long long ans;
cin >> n;
for (int i = (0); i < (n); ++i) scanf("%d%d", &vx[i], &vy[i]);
cin >> t;
for (int i = (0); i < (t); ++i) {
cin >> x >> y;
p = 1;
for (int j = (0); j < (n); ++j) k[j] = 0;
for (int j = (0); j < (n); ++j) {
while (1) {
if (p % n == j % n) {
p = -1;
break;
}
if (f(vx[j], vy[j], vx[p % n], vy[p % n], x, y)) {
a[j] = p;
break;
}
k[p % n] = max(k[p % n], p - j);
p++;
}
if (p == -1) break;
}
if (p == -1)
cout << "0" << endl;
else {
ans = 0;
for (int j = (0); j < (n); ++j)
ans += (long long)(k[j] - a[j] + j + 1) * (long long)a[j] +
(long long)n * (long long)max(0, a[j] - n);
cout << ans / 3 << endl;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, d, ans[5005], son[5005], dep[5005];
int main() {
int T;
cin >> T;
while (T--) {
scanf("%d%d", &n, &d);
int log = 0, mn = 0;
for (int i = 0; (1 << (i + 1)) - 1 <= n; ++i) {
log = i;
mn += (1 << i) * i;
}
mn += (n - (1 << (log + 1)) + 1) * (log + 1);
int all = (0 + n - 1) * n / 2;
if (mn > d || d > all) {
printf("NO\n");
continue;
}
printf("YES\n");
dep[1] = 0;
for (int i = 2; i <= n; ++i) {
ans[i] = i - 1;
son[i - 1] = 1;
dep[i] = i - 1;
}
son[n] = 0;
while (all > d) {
int now = 1;
for (int i = 1; i <= n; ++i) {
if (son[i]) continue;
if (dep[i] > dep[now]) now = i;
}
int mn = now;
for (int i = 1; i <= n; ++i) {
if (son[i] >= 2) continue;
if (all - dep[now] + dep[i] + 1 >= d) {
if (dep[i] < dep[mn]) mn = i;
}
}
if (mn == now) break;
son[mn]++;
son[ans[now]]--;
ans[now] = mn;
all -= dep[now] - dep[mn] - 1;
dep[now] = dep[mn] + 1;
}
for (int i = 2; i <= n; ++i) {
printf("%d%s", ans[i], i == n ? "\n" : " ");
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 17;
const int MX = (int)1e6 + 17;
const int MOD = (int)1e9 + 7;
const long long oo = LLONG_MAX;
const int INF = INT_MAX;
const long double Pi = 3.14159265358979323846264338327950288419716939937510;
const int di[4] = {-1, 0, 1, 0};
const int dj[4] = {0, 1, 0, -1};
inline long long IN() {
long long x = 0, ch = getchar(), f = 1;
while (!isdigit(ch) && (ch != '-') && (ch != EOF)) ch = getchar();
if (ch == '-') {
f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
inline void OUT(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10)
OUT(x / 10), putchar(x % 10 + '0');
else
putchar(x + '0');
}
void IOI2017() {}
int n, m, l, r;
char a[MX];
struct T {
int l, r, s;
} t[MX * 4];
inline T Merge(T x, T y) {
int add = min(x.l, y.r);
T ans;
ans.s = x.s + y.s + add;
ans.l = x.l + y.l - add;
ans.r = x.r + y.r - add;
return ans;
}
inline void build(int v = 1, int tl = 1, int tr = n) {
if (tl == tr) {
if (a[tl] == '(')
t[v].l++;
else
t[v].r++;
} else {
int tm = (tl + tr) >> 1;
build(v << 1, tl, tm);
build((v << 1) + 1, tm + 1, tr);
t[v] = Merge(t[v << 1], t[(v << 1) + 1]);
}
}
inline T get(int l, int r, int v = 1, int tl = 1, int tr = n) {
if (l <= tl && tr <= r) return t[v];
if (tl > r || tr < l)
return {0, 0, 0};
else {
int tm = tl + tr >> 1;
return Merge(get(l, r, v << 1, tl, tm),
get(l, r, (v << 1) + 1, tm + 1, tr));
}
}
int main() {
gets(a);
n = (int)strlen(a);
for (int i = n; i > 0; i--) a[i] = a[i - 1];
build();
m = IN();
while (m--) {
l = IN(), r = IN();
OUT(get(l, r).s << 1), putchar('\n');
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 20;
long long int n, a[N], b[N], sum1, sum2;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum1 += a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
sort(b, b + n);
reverse(b, b + n);
sum2 = b[0] + b[1];
if (sum2 >= sum1) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = int(3e5) + 9;
int n;
long long a[N];
int b[N];
int cnt[2][N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
b[i] = __builtin_popcountll(a[i]);
}
long long res = 0;
int sufSum = 0;
cnt[0][n] = 1;
for (int i = n - 1; i >= 0; --i) {
int sum = 0, mx = 0;
int lstJ = i;
int add = 0;
for (int j = i; j < n && j - i < 65; ++j) {
sum += b[j];
mx = max(mx, b[j]);
if (mx > sum - mx && sum % 2 == 0) --add;
lstJ = j;
}
sufSum += b[i];
add += cnt[sufSum & 1][i + 1];
res += add;
cnt[0][i] = cnt[0][i + 1];
cnt[1][i] = cnt[1][i + 1];
if (sufSum & 1)
++cnt[1][i];
else
++cnt[0][i];
}
cout << res << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void rd(T &x) {
int fl = 1;
x = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') fl = -fl;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + c - '0';
x *= fl;
}
template <class T>
inline void wr(T x) {
if (x < 0) x = -x, putchar('-');
if (x < 10) {
putchar(x + '0');
return;
}
int tmp[40] = {0}, cnt = 0;
while (x) tmp[cnt++] = x % 10, x /= 10;
for (register int i = cnt - 1; i >= 0; --i) putchar(tmp[i] + '0');
}
const int N = 105;
int T, n, ans = 1e9 + 1, a[N], b[N];
int main() {
rd(T);
while (T--) {
rd(n);
ans = 1e9 + 1;
for (register int i = 1; i <= n; ++i) rd(a[i]);
ans = a[1];
for (register int i = 2; i <= n; ++i) ans &= a[i];
wr(ans);
puts("");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int a[1000], kol = 1;
a[0] = -10;
for (int i = 0; i < s.size(); ++i)
if (s[i] == '@')
if (i - a[kol - 1] < 3)
cout << "No solution", exit(0);
else
a[kol++] = i;
for (int i = kol - 2; i > 0; --i) s.insert(a[i] + 2, ",");
if (kol == 1 || s[0] == '@' || s[s.size() - 1] == '@')
cout << "No solution";
else
cout << s;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, int> > del1, del2, del3, del4;
long long n1, p, q, r, mn = -1, mx = -1;
void rec_find2(int n) {
int i, j, sz, sz2;
long long tmp;
if (n == (int)del2.size()) {
p = q = r = 1;
sz = del2.size();
for (i = 0; i < sz; i++) {
for (j = 0; j < del3[i].second; j++) p *= del3[i].first;
for (j = 0; j < del4[i].second; j++) q *= del4[i].first;
for (j = 0; j < del2[i].second - del4[i].second; j++) r *= del2[i].first;
}
tmp = (p + 1) * (q + 2) * (r + 2);
if (mx == -1 || tmp - n1 > mx) {
mx = tmp - n1;
}
if (mn == -1 || tmp - n1 < mn) {
mn = tmp - n1;
}
return;
}
for (i = 0; i <= del2[n].second; i++) {
del4.push_back(make_pair(del2[n].first, i));
rec_find2(n + 1);
del4.pop_back();
}
return;
}
void rec_find(int n) {
int i, sz, sz2;
if (n == (int)del1.size()) {
sz = del3.size();
del2.clear();
for (i = 0; i < sz; i++)
del2.push_back(make_pair(del1[i].first, del1[i].second - del3[i].second));
rec_find2(0);
return;
}
for (i = 0; i <= del1[n].second; i++) {
del3.push_back(make_pair(del1[n].first, i));
rec_find(n + 1);
del3.pop_back();
}
return;
}
void factor(long long n) {
long long i;
for (i = 2; i * i <= n; i++) {
if (!(n % i)) {
del1.push_back(make_pair(i, 0));
while (!(n % i)) {
del1[del1.size() - 1].second++;
n /= i;
}
}
}
if (n > 1) del1.push_back(make_pair(n, 1));
}
int main() {
int i, sz;
scanf("%I64d", &n1);
factor(n1);
rec_find(0);
printf("%I64d %I64d\n", mn, mx);
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
void fileio(const string &s) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
inline int read() {
int x = 0;
bool flag = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') flag = 0;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return (flag ? x : ~(x - 1));
}
int n;
signed main() {
n = read();
if (n & 1)
cout << n / 2;
else {
int x = sizeof(int) * 8 - __builtin_clz(n) - 1;
cout << (n - (1 << x)) / 2;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const long long mod = 1e9 + 7;
const long long N = 5e5 + 10;
void solve() {
long long n;
string s, t = "hard";
cin >> n >> s;
vector<long long> a(n);
for (long long i = 0; i < n; ++i) cin >> a[i];
vector<vector<long long> > dp(n + 10, vector<long long>(5, inf));
dp[0][0] = 0;
for (long long i = 1; i <= n; ++i) {
char c = s[i - 1];
for (long long j = 0; j < 5; ++j) dp[i][j] = dp[i - 1][j];
for (long long j = 0; j < 5; ++j)
if (c == t[j]) dp[i][j] = dp[i - 1][j] + a[i - 1];
for (long long j = 0; j < 4; ++j)
if (c == t[j]) dp[i][j + 1] = min(dp[i][j + 1], dp[i - 1][j]);
}
long long ans = inf;
for (long long i = 0; i < 4; ++i) ans = min(ans, dp[n][i]);
cout << ans;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long tt = 1;
while (tt--) {
solve();
cout << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2000000009;
const int Max = 1000007;
const double PI = acos(-1.0);
int trck[6];
int main() {
int i, j, k, l, temp, t, n, m, caseno = 0, ans;
string str;
while (cin >> n) {
memset(trck, 0, sizeof(trck));
for (i = 0; i < n; i++) {
cin >> k;
trck[k]++;
}
for (i = 0; i < n; i++) {
cin >> k;
trck[k]--;
}
ans = 0;
for (i = 1; i <= 5; i++) {
if (trck[i] & 1) {
ans = -1;
break;
}
ans += abs(trck[i]) >> 1;
}
if (ans > 0) ans /= 2;
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, l = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cout << l;
if (l) {
l = 0;
} else {
l = 1;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool ckmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
namespace debug {
void __print(int x) { cerr << x; }
void __print(long long 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 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 z : x) cerr << (f++ ? "," : ""), __print(z);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
} // namespace debug
using namespace debug;
const char nl = '\n';
void solve() { cout << "even" << endl; }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int testCases = 1;
while (testCases--) solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long int have;
long long int c[100002];
long long int w[100002];
priority_queue<pair<pair<long long int, int>, long long int>,
vector<pair<pair<long long int, int>, long long int> >,
greater<pair<pair<long long int, int>, long long int> > >
q;
long long int pay[100002];
int main() {
cin >> n;
scanf("%lld", &have);
for (int i = 0; i < n; i++) {
scanf("%lld", &c[i]);
}
for (int i = 0; i < n; i++) {
scanf("%lld", &w[i]);
}
long long int cost = 0;
for (int i = 0; i < n; i++) {
long long int need = (c[i] % 100);
need %= 100;
have -= need;
if (need != 0LL) q.push(make_pair(make_pair(w[i] * (100 - need), i), i));
while (have < 0) {
auto f = q.top();
q.pop();
cost += f.first.first;
have += 100LL;
}
}
printf("%lld\n", cost);
while (q.size()) {
pay[q.top().first.second] = c[q.top().first.second] % 100LL;
q.pop();
}
for (int i = 0; i < n; i++) {
long long int note = c[i] / 100;
long long int coin = pay[i];
if (coin < c[i] % 100) {
note++;
}
printf("%lld %lld\n", note, coin);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
#include <stdlib.h>
using namespace std;
typedef long long int ll;
typedef long double ld;
#define rep(i,a,b) for(ll i=a;i<=b;++i)
#define rev(i,a,b) for(ll i=a;i>=b;i--)
#define pll pair<ll,ll>
#define vll vector<ll>
#define sll set<ll>
#define vpll vector<pll>
#define F first
#define S second
#define pb push_back
#define mp make_pair
#define ln length()
#define M 1000000007
ll n, p1[300004],p2[300004],bit1[600004],bit2[600004];
ll st2[300004],fin2[300004], dfscntr2;
vll ch1[300005],ch2[300005];
ll ans,finans;
void dfs(ll st) {
st2[st] = ++dfscntr2;
for(ll v : ch2[st]) dfs(v);
fin2[st] = ++dfscntr2;
}
void updateb1(ll p,ll v){
for(ll i=p;i<=2*n;i+=(i&-i)) bit1[i] += v;
}
ll qryb1(ll p){
ll ret=0;
for(ll i=p;i;i-=(i&-i)) ret+=bit1[i];
return ret;
}
ll sumb1(ll l, ll r) {
return qryb1(r) - qryb1(l-1);
}
void updateb2(ll p,ll v){
for(ll i=p;i<=2*n;i+=(i&-i)) bit2[i] += v;
}
ll qryb2(ll p){
ll ret=0;
for(ll i=p;i;i-=(i&-i)) ret+=bit2[i];
return ret;
}
ll sumb2(ll l, ll r) {
return qryb2(r) - qryb2(l-1);
}
void findans(ll v) {
ll curans = ans;
ll par = 0;
if (v == 1) {
ans = 1;
} else {
par = sumb2(1, st2[v]-1);
if(sumb1(st2[v], fin2[v]) == 0) {
if(!par) ans++;
else if (sumb1(st2[par], fin2[par]) > 1) ans++;
}
}
if(par) {
updateb2(st2[par], -par);
updateb2(fin2[par], par);
}
// add
updateb1(st2[v], 1);
updateb2(st2[v], v);
updateb2(fin2[v], -v);
finans = max(finans, ans);
for(ll vv : ch1[v]) findans(vv);
ans = curans;
// removal
if(par) {
updateb2(st2[par], par);
updateb2(fin2[par], -par);
}
updateb1(st2[v], -1);
updateb2(st2[v], -v);
updateb2(fin2[v], v);
}
int main() {
ios :: sync_with_stdio(false); cin.tie(0);
ll t;cin>>t;while(t--) {
cin>>n;
rep(i,1,n) {
ch1[i].clear();
ch2[i].clear();
bit1[i] = bit2[i] = 0;
}
dfscntr2 = ans = finans = 0;
rep(i,2,n) {cin>>p1[i]; ch1[p1[i]].pb(i);}
rep(i,2,n) {cin>>p2[i]; ch2[p2[i]].pb(i);}
dfs(1);
findans(1);
cout<<finans<<'\n';
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.14159265358979323846, eps = 0.000001;
const long long M = 1e9 + 7, I = 1e18;
const int mxn = 1e6, mxn1 = 1e7, lg = 20;
long long arr[mxn + 1], ans[mxn + 1];
int l = 0, r;
bool vis[mxn + 1];
vector<long long> smp;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
ans[1] = 1;
for (int i = 2; i <= mxn; i++) {
if (!vis[i]) {
smp.push_back(i);
for (long long j = (long long)i * (long long)i; j <= mxn; j += i)
vis[j] = 1;
}
if (smp[0] * smp[0] > i) {
ans[i] = (int)smp.size() + 1;
continue;
}
r = (int)smp.size();
while (r - l > 1) {
long long m = (r + l) / 2;
if (smp[m] * smp[m] <= i)
l = (int)m;
else
r = (int)m;
}
ans[i] = (int)smp.size() - l;
}
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int k;
cin >> k;
cout << ans[k] << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
namespace IO {
template <class A, class B>
ostream &operator<<(ostream &out, pair<A, B> a) {
out << a.first << " " << a.second;
return out;
}
template <class A, class B>
ostream &operator<<(ostream &out, vector<pair<A, B>> a) {
for (pair<A, B> x : a) out << x.first << " " << x.second << '\n';
return out;
}
template <class A>
ostream &operator<<(ostream &out, vector<A> a) {
for (A x : a) out << x << ' ';
return out;
}
template <class A, class B>
istream &operator>>(istream &in, pair<A, B> &a) {
in >> a.first >> a.second;
return in;
}
template <class A>
istream &operator>>(istream &in, vector<A> &a) {
for (A &x : a) in >> x;
return in;
}
} // namespace IO
using namespace IO;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void solve() {
int n;
cin >> n;
vector<int> a(n * 2);
cin >> a;
vector<int> odd, even;
for (int i = (0); i < (int)(n * 2); ++i) {
if (a[i] % 2)
odd.push_back(i);
else
even.push_back(i);
}
if (odd.size() % 2) {
odd.pop_back();
even.pop_back();
} else if (odd.size() >= 2) {
odd.pop_back();
odd.pop_back();
} else {
even.pop_back();
even.pop_back();
}
for (int i = 0; i < odd.size(); i += 2) {
cout << odd[i] + 1 << " " << odd[i + 1] + 1 << '\n';
}
for (int i = 0; i < even.size(); i += 2) {
cout << even[i] + 1 << " " << even[i + 1] + 1 << '\n';
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(30);
int q = 1;
cin >> q;
while (q--) solve();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long ch(long long a[], long long n) {
for (long long i = 0; i < n - 1; i++) {
if (a[i + 1] < a[i]) return 0;
}
return 1;
}
bool comp(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
if (a.second != b.second) return (a.second > b.second);
return (a.first > b.first);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, i, j, k;
cin >> n;
long long a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
if (n == 1) {
cout << 1;
return 0;
}
long long count, max = 0;
for (i = 0; i < n; i++) {
count = 1;
k = i;
for (j = i - 1; j >= 0; j--) {
if (a[j] <= a[k])
count++;
else
break;
k--;
}
k = i;
for (j = i + 1; j < n; j++) {
if (a[j] <= a[k])
count++;
else
break;
k++;
}
if (max < count) max = count;
}
cout << max;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, x, y;
map<pair<int, int>, bool> m;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x >> y;
m[make_pair(x, x + y)] = true;
}
for (map<pair<int, int>, bool>::iterator it = m.begin(); it != m.end();
it++) {
bool c = it->second;
if (c) {
pair<int, int> p = it->first;
swap(p.first, p.second);
if (m[p]) {
cout << "YES";
return 0;
}
}
}
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << 2 * n - 1 << " 2" << endl << 1 << " " << 2 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100100;
long long seg[maxn << 2];
long long A[maxn];
long long tmp[maxn];
long long id[maxn];
map<long long, int> M;
const double PI = acos(-1);
void PushUp(int rt) { seg[rt] = max(seg[rt << 1], seg[rt << 1 | 1]); }
void update(int p, long long x, int l, int r, int rt) {
if (l == r) {
seg[rt] = x;
return;
}
int m = (l + r) >> 1;
if (p <= m)
update(p, x, l, m, rt << 1);
else
update(p, x, m + 1, r, rt << 1 | 1);
PushUp(rt);
}
long long query(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) return seg[rt];
int m = (l + r) >> 1;
long long res = 0;
if (L <= m) res = max(res, query(L, R, l, m, rt << 1));
if (R > m) res = max(res, query(L, R, m + 1, r, rt << 1 | 1));
return res;
}
int main() {
int n;
cin >> n;
long long r, h;
for (int i = 0; i < n; i++) {
cin >> r >> h;
A[i] = tmp[i] = r * r * h;
}
sort(tmp, tmp + n);
int cnt = 0;
M[tmp[0]] = 1;
id[1] = tmp[0];
for (int i = 1; i < n; i++) {
if (tmp[i] == tmp[cnt]) continue;
tmp[++cnt] = tmp[i];
M[tmp[i]] = cnt + 1;
id[cnt + 1] = tmp[i];
}
long long x;
int idx;
for (int i = 0; i < n; i++) {
idx = M[A[i]];
if (idx == 1)
update(1, A[i], 1, n, 1);
else {
x = query(1, idx - 1, 1, n, 1);
update(idx, A[i] + x, 1, n, 1);
}
}
printf("%.8lf\n", query(1, n, 1, n, 1) * PI);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using LL = int64_t;
const int INF = 0x3f3f3f3f;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m, k;
cin >> n >> m >> k;
vector<int> ans(105, 0);
for (int i = 1; i <= n; i++) cin >> ans[i];
int sum = 10;
for (int i = 1; i <= n; i++) {
if (m - i > 0 && ans[m - i] <= k && ans[m - i] != 0) {
cout << sum;
break;
} else if (ans[m + i] <= k && m + i <= n && ans[m + i] != 0) {
cout << sum;
break;
}
sum += 10;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using ll = long long;
class Solver {
int p;
public:
Solver() { cin >> p; }
public:
void solve() { cout << 2 << " " << p - 1 << "\n"; }
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
Solver solver;
solver.solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char s[3][100005];
int len_short, len_long, b[100005];
void preprocess(char *s1) {
int i = 0, j = -1;
b[0] = -1;
while (i < len_short) {
while (j >= 0 && s1[i] != s1[j]) j = b[j];
i++;
j++;
b[i] = j;
}
}
char ans[3 * 100005];
void kmp(char *s1, char *s2) {
int i = 0, j = 0;
while (i < len_long) {
while (j >= 0 && s2[i] != s1[j]) j = b[j];
i++;
j++;
if (j == len_short) return;
}
for (; j < len_short; ++j) {
ans[len_long++] = s1[j];
}
}
int main() {
int mini;
while (scanf("%s%s%s", &s[0], &s[1], &s[2]) != EOF) {
int p[3] = {0, 1, 2};
mini = 1 << 30;
do {
strcpy(ans, s[p[0]]);
len_long = strlen(s[p[0]]);
len_short = strlen(s[p[1]]);
preprocess(s[p[1]]);
kmp(s[p[1]], ans);
len_short = strlen(s[p[2]]);
preprocess(s[p[2]]);
kmp(s[p[2]], ans);
mini = min(mini, len_long);
} while (next_permutation(p, p + 3));
printf("%d\n", mini);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> prime, power;
long long N;
long long exgcd(long long a, long long b, long long& x, long long& y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long g = exgcd(b, a % b, x, y);
long long t = x;
x = y;
y = t - (a / b) * y;
return g;
}
int main() {
cin >> N;
long long n = N;
for (long long i = 2; i * i <= N; i++)
if (n % i == 0) {
prime.push_back(i);
power.push_back(0);
do {
n /= i;
*power.rbegin() += 1;
} while (n % i == 0);
}
if (n > 1) {
prime.push_back(n);
power.push_back(0);
}
if (prime.size() <= 1) {
puts("NO");
return 0;
}
puts("YES");
long long a = 1;
for (int i = 0; i < power[0]; i++) a *= prime[0];
long long b = N / a;
long long x, y;
exgcd(a, b, x, y);
puts("2");
y *= N - 1;
x *= N - 1;
if (x < 1) {
long long t = (b - x) / b;
x += t * b;
y -= t * a;
} else if (y < 1) {
long long t = (a - y) / a;
y += t * a;
x -= t * b;
}
printf("%lld %lld\n", y, a);
printf("%lld %lld\n", x, b);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int i, j, n, k, y, q;
long long arb[800005], a[200005], aux, rs, gmb, x;
void update(int left, int right, int nod) {
if (left == right)
arb[nod] = y;
else {
int pivot = (left + right) / 2;
if (x <= pivot)
update(left, pivot, 2 * nod);
else
update(pivot + 1, right, 2 * nod + 1);
arb[nod] = arb[2 * nod] | arb[2 * nod + 1];
}
}
void query(int left, int right, int nod) {
if (left >= x && right <= y)
aux |= arb[nod];
else {
int pivot = (left + right) / 2;
if (x <= pivot) query(left, pivot, 2 * nod);
if (y > pivot) query(pivot + 1, right, 2 * nod + 1);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> q;
for (i = 1; i <= n; ++i) cin >> a[i], y = a[i], x = i, update(1, n, 1);
for (rs = arb[1], i = 1; i <= n; ++i) {
aux = 0;
x = 1;
y = i - 1;
if (x <= y) query(1, n, 1);
x = i + 1;
y = n;
if (x <= y) query(1, n, 1);
for (gmb = a[i] * q, j = 1; j <= k; ++j) rs = max(rs, aux | gmb), gmb *= q;
}
cout << rs << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1000000007;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
int n, i;
cin >> n;
string s;
cin >> s;
int bracket0 = 0, bracket1 = 0;
for (i = 0; i < n; i++) {
if (s[i] == '(') {
if (bracket0 > bracket1) {
bracket1++;
cout << 1;
} else {
bracket0++;
cout << 0;
}
} else {
if (bracket0 > 0) {
bracket0--;
cout << 0;
} else {
bracket1--;
cout << 1;
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
long long ans = k;
long long q = 0;
long long p = 0;
for (int i = 0;; i++) {
if (ans / n == p / n) break;
q = p;
p = ans;
ans += ans / n - q / n;
}
cout << ans << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
cin >> n >> a >> b >> c;
n--;
if (!n)
puts("0");
else {
int m = min(a, b);
cout << m + (n - 1) * (min(c, m)) << endl;
}
}
| 0 |
#include <bits/stdc++.h>
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) x = x * 10 + (c ^ 48), c = getchar();
}
using namespace std;
int n;
int h[501000];
inline bool cmp(const int x, const int y) { return x > y; }
priority_queue<int, vector<int>, greater<int> > q;
int opt[501000 << 1], otot, cnt, ctmp;
inline void Update() {
while (otot) q.push(opt[otot]), --otot;
cnt += ctmp;
ctmp = 0;
}
signed main() {
read(n);
for (int i = 1; i <= n; ++i) read(h[i]);
sort(h + 1, h + 1 + n, cmp);
for (int i = 1; i <= n; ++i) {
if (h[i] != h[i - 1]) Update();
if (cnt) {
opt[++otot] = h[i];
--cnt;
continue;
}
if (q.size() && h[i] > q.top()) {
q.pop();
opt[++otot] = h[i];
++cnt;
continue;
}
if (q.size() && h[i] == h[i + 1] && h[i] + h[i] > q.top()) {
opt[++otot] = q.top();
opt[++otot] = h[i] + h[i] - q.top();
q.pop();
++i;
continue;
}
++ctmp;
}
Update();
long long ans = 0;
while (q.size()) ans -= q.top(), q.pop();
for (int i = 1; i <= n; ++i) ans += h[i];
printf("%lld\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
long long int i, n, f;
string s;
cin >> s;
n = s.length();
map<char, long long int> m;
for (i = 0; i < n; i++) {
m[s[i]]++;
}
if (m.size() == 1 || m.size() > 4) {
cout << "No" << endl;
} else if (m.size() == 2) {
f = 0;
for (auto e : m) {
if (e.second < 2) {
f = 1;
}
}
if (f == 1)
cout << "No" << endl;
else {
cout << "Yes" << endl;
}
} else if (m.size() == 3) {
f = 0;
for (auto e : m) {
if (e.second >= 2) {
f = 1;
}
}
if (f == 1)
cout << "Yes" << endl;
else {
cout << "No" << endl;
}
} else if (m.size() == 4)
cout << "Yes" << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int col[505];
pair<int, int> mn[505][505];
pair<int, int> min(pair<int, int> a, pair<int, int> b) {
if (a.first < b.first) return a;
return b;
}
long long memo[505][505];
long long dp(int l, int r) {
if (l == r) return 1;
if (memo[l][r] != -1) return memo[l][r];
int m = mn[l][r].second;
long long lft;
if (l <= m - 1)
lft = dp(l, m - 1) * 2 % 998244353;
else
lft = 1;
for (int i = (l); i <= (m - 2); i++) {
lft = (lft + dp(l, i) * dp(i + 1, m - 1) % 998244353) % 998244353;
}
long long rgt;
if (m + 1 <= r)
rgt = dp(m + 1, r) * 2 % 998244353;
else
rgt = 1;
for (int i = (m + 2); i <= (r); i++) {
rgt = (rgt + dp(m + 1, i - 1) * dp(i, r)) % 998244353;
}
return memo[l][r] = lft * rgt % 998244353;
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = (1); i <= (m); i++) scanf("%d", &col[i]);
for (int i = (1); i <= (m); i++) {
mn[i][i] = {col[i], i};
for (int j = (i + 1); j <= (m); j++) {
mn[i][j] = min(mn[i][j - 1], {col[j], j});
}
}
memset(memo, -1, sizeof(memo));
printf("%d\n", dp(1, m));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 9;
int st[N], en[N], a[N], par[N], rid[N], root[N];
struct ST {
pair<int, int> t[4 * N];
void build(int n, int b, int e) {
if (b == e) {
t[n] = {0, b};
return;
}
int mid = (b + e) >> 1, l = n << 1, r = l | 1;
build(l, b, mid);
build(r, mid + 1, e);
t[n] = max(t[l], t[r]);
}
void upd(int n, int b, int e, int i, int x) {
if (b > i || e < i) return;
if (b == e && b == i) {
t[n] = {x, b};
return;
}
int mid = (b + e) >> 1, l = n << 1, r = l | 1;
upd(l, b, mid, i, x);
upd(r, mid + 1, e, i, x);
t[n] = max(t[l], t[r]);
}
pair<int, int> query(int n, int b, int e, int i, int j) {
if (b > j || e < i) return {0, 0};
if (b >= i && e <= j) return t[n];
int mid = (b + e) >> 1, l = n << 1, r = l | 1;
auto L = query(l, b, mid, i, j);
auto R = query(r, mid + 1, e, i, j);
return max(L, R);
}
} t;
int find(int u) {
if (par[u] == u) return u;
return par[u] = find(par[u]);
}
int T, I;
vector<int> g[N];
void merge(int u, int v) {
u = find(u);
v = find(v);
if (u == v) return;
++T;
g[T].push_back(u);
g[T].push_back(v);
par[u] = T;
par[v] = T;
return;
}
bool vis[N];
void dfs(int u) {
vis[u] = 1;
st[u] = I + 1;
for (auto v : g[u]) {
dfs(v);
}
if (st[u] == I + 1) {
++I;
rid[I] = u;
}
en[u] = I;
}
pair<int, int> ed[N];
int ty[N], x[N];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, q;
cin >> n >> m >> q;
T = n;
for (int i = 1; i <= 2 * n; i++) par[i] = i;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
ed[i] = {u, v};
}
set<int> se;
for (int i = 1; i <= m; i++) {
se.insert(i);
}
for (int i = 1; i <= q; i++) {
cin >> ty[i] >> x[i];
if (ty[i] == 2) {
se.erase(x[i]);
}
}
for (auto x : se) {
merge(ed[x].first, ed[x].second);
}
for (int i = q; i >= 1; i--) {
if (ty[i] == 2) {
merge(ed[x[i]].first, ed[x[i]].second);
} else
root[i] = find(x[i]);
}
for (int i = T; i >= 1; i--) {
if (!vis[i]) dfs(i);
}
t.build(1, 1, n);
for (int i = 1; i <= n; i++) {
t.upd(1, 1, n, i, a[rid[i]]);
}
for (int i = 1; i <= q; i++) {
if (ty[i] == 1) {
auto f = t.query(1, 1, n, st[root[i]], en[root[i]]);
t.upd(1, 1, n, f.second, 0);
cout << f.first << '\n';
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
if (n == 1 || n == 2) {
cout << n;
return 0;
}
long long ans;
if (n % 2 == 0 && n % 3 == 0)
ans = (n - 1) * (n - 2) * (n - 3);
else if (n % 2 == 0 && n % 3 != 0)
ans = (n) * (n - 1) * (n - 3);
else
ans = n * (n - 1) * (n - 2);
cout << ans;
}
| 4 |
#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--) {
int n, i, j, k;
cin >> n;
int a[n];
vector<pair<int, int>> v;
for (i = 0; i < n; i++) {
cin >> a[i];
v.push_back({a[i], i});
}
sort(v.begin(), v.end());
if (v[0].first + v[1].first <= v[v.size() - 1].first ||
v[0].first + v[v.size() - 1].first <= v[1].first ||
v[v.size() - 1].first + v[1].first <= v[1].first) {
cout << 1 << " " << 2 << " " << v.size() << endl;
} else
cout << -1 << endl;
}
}
| 0 |
#include <iostream>
#include <string>
#include <sstream>
#include <iomanip>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <queue>
#include <stack>
#include <vector>
#include <map>
#include <set>
#include <functional>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
#include <numeric>
#include <cassert>
#pragma warning(disable:4996)
#define ALL(a) a.begin(),a.end()
#define fill(a) for(int i=0;i<n;i++)cin>>a[i];
using namespace std;
#define MOD 1000000007
const long long INF = 2e18;
int query(int x) {
cout << "? " << x << "\n";
fflush(stdout);
int p;
cin >> p;
return p;
}
void answer(int x) {
cout << "! " << x << "\n";
fflush(stdout);
}
int main()
{
//ios::sync_with_stdio(false);
//cin.tie(0);
#define int long long
int n;
cin >> n;
if (n == 1) {
cout << "! 1\n";
exit(0);
}
int x = query(1), y = query(n);
int p = query(2);
if (p > x)answer(1), exit(0);
p = query(n - 1);
if (p > y)answer(n), exit(0);
int l = 2, r = n-1;
while (l <= r) {
int mid = (l + r) / 2;
int a = query(mid - 1), b = query(mid), c = query(mid + 1);
if (a > b && c > b)answer(mid), exit(0);
if (a < b && b < c)r = mid - 1;
else l = mid + 1;
}
assert(false);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const int N = 5e2 + 3;
const long long p = 998244353;
int n;
long long a[N];
map<long long, long long> prime;
set<long long> s;
std::vector<long long> v;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
double eps = 1e-6;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
long long er = (long long)(pow(a[i], 0.5) + eps);
long long san = (long long)(pow(a[i], 1.0 / 3) + eps);
long long si = (long long)(pow(a[i], 0.25) + eps);
if (si * si * si * si == a[i])
prime[si] += 4;
else if (san * san * san == a[i])
prime[san] += 3;
else if (er * er == a[i])
prime[er] += 2;
else {
v.push_back(a[i]);
}
}
sort(v.begin(), v.end());
int m = unique(v.begin(), v.end()) - v.begin();
long long ans = 1;
for (int i = 0; i < m; i++) {
long long cnt = 0, f1 = 0, f2 = 0;
for (int j = 1; j <= n; j++)
if (v[i] == a[j]) cnt++;
for (int j = 1; j <= n; j++) {
if (v[i] == a[j]) continue;
if (gcd(v[i], a[j]) > 1) {
f1 = gcd(v[i], a[j]), f2 = v[i] / f1;
break;
}
}
if (!f1 && !f2) {
ans = ans * (1 + cnt) % p * (1 + cnt) % p;
} else
prime[f1] += cnt, prime[f2] += cnt;
}
for (auto i = prime.begin(); i != prime.end(); i++) {
ans = ans * (1 + (i->second)) % p;
}
cout << ans << endl;
cout.flush();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
for (int i = 0; i < t; i++) {
long long n, k;
cin >> n >> k;
if (n < k * k) {
cout << "NO" << '\n';
} else if (n % 2 != k % 2) {
cout << "NO" << '\n';
} else {
cout << "YES" << '\n';
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
template <class T>
using pq = priority_queue<T>;
template <class T>
using pqg = priority_queue<T, vector<T>, greater<T>>;
template <class T>
bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
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 first = 0;
cerr << '{';
for (auto& i : x) cerr << (first++ ? ", " : ""), __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...);
}
const int MOD = 1000000007;
const char nl = '\n';
const int MX = 100001;
void solve() {
long long n;
cin >> n;
cout << 0 - (n - 1) << " " << n << "\n";
}
int main() {
cin.tie(0)->sync_with_stdio(0);
cin.exceptions(cin.failbit);
int T = 1;
cin >> T;
cout << setprecision(20);
while (T--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int dp[30005][505];
int gems[200005];
int max1;
int m2;
int fun(int pos, int prev1) {
if (pos > max1) {
return 0;
}
if (dp[pos][prev1] != -1) {
return dp[pos][prev1];
}
int ret = gems[pos];
int req = prev1 - 250 + m;
if ((pos + req) <= max1) ret = max(ret, gems[pos] + fun(pos + req, prev1));
if (req >= 2 && (pos + req - 1) <= max1) {
ret = max(ret, gems[pos] + fun(pos + req - 1, prev1 - 1));
}
if ((pos + req + 1) <= max1)
ret = max(ret, gems[pos] + fun(pos + req + 1, prev1 + 1));
dp[pos][prev1] = ret;
return ret;
}
int main() {
int i, pos, j;
scanf("%d %d", &n, &m);
max1 = 0;
m2 = 0;
for (i = 0; i < n; i++) {
scanf("%d", &pos);
gems[pos]++;
max1 = max(max1, pos);
}
for (i = 0; i <= 30000; i++) {
for (j = 0; j <= 500; j++) {
dp[i][j] = -1;
}
}
int ans = fun(m, 250);
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
inline long long pow(long long a, long long b) {
if (b == 1) return a;
long long tmp = pow(a, b >> 1);
tmp = (tmp * tmp) % mod * (b & 1 ? a : 1) % mod;
return tmp;
}
int n, m;
int a[100005];
long long ans = 0, res = 1;
int main() {
scanf("%d%d", &n, &m);
long long t1 = pow(m, mod - 2), t2 = pow(2, mod - 2);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
long long tmp;
scanf("%I64d", &tmp);
if (tmp == 0 && a[i] == 0) {
ans = (ans + res * (1 - t1 + mod) % mod * t2 % mod) % mod;
res = res * t1 % mod;
} else if (tmp > 0 && a[i] > 0) {
if (tmp > a[i]) {
printf("%I64d", ans);
return 0;
} else if (tmp < a[i]) {
printf("%I64d", (ans + res) % mod);
return 0;
}
} else if (a[i] == 0) {
ans = (ans + res * (m - tmp) % mod * t1 % mod) % mod;
res = res * t1 % mod;
} else {
ans = (ans + res * (a[i] - 1) % mod * t1 % mod) % mod;
res = res * t1 % mod;
}
}
printf("%I64d", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[200100], n, m, s, d, run[200100], jump[200100], l = 0;
int main() {
scanf("%d%d%d%d", &n, &m, &s, &d);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
if (a[0] - 1 < s) {
printf("IMPOSSIBLE");
return 0;
}
for (int i = 0; i < n; i++) {
int t = i;
while (i < n - 1 && a[i + 1] - a[i] - 2 < s) i++;
jump[l] = a[i] - a[t] + 2;
run[l] = (i + 1 < n) ? (a[i + 1] - a[i] - 2) : (m - a[i] - 1);
if (jump[l] > d) {
printf("IMPOSSIBLE");
return 0;
}
l++;
}
printf("RUN %d\n", a[0] - 1);
for (int i = 0; i < l; i++) {
printf("JUMP %d\n", jump[i]);
if (run[i]) printf("RUN %d\n", run[i]);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
constexpr static int MAXN = 1e6 + 10;
constexpr static int INF = 1e9;
int n, m;
vector<int> adj[MAXN];
int dist[MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v, t;
cin >> u >> v >> t;
u--, v--;
if (u == v) continue;
adj[2 * v + 0].push_back(2 * u + t);
adj[2 * v + 1].push_back(2 * u + t);
}
for (int i = 0; i < 2 * n; i++) dist[i] = INF;
int src = 2 * n - 2;
dist[src] = 0;
vector<int> q;
q.push_back(src);
string s(n, '?');
for (int i = 0; i < q.size(); i++) {
int u = q[i];
for (int v : adj[u]) {
if (s[v / 2] == '?') {
s[v / 2] = '0' + (1 - v % 2);
continue;
}
int parity = s[v / 2] - '0';
if (parity != v % 2) continue;
if (dist[v] == INF) {
dist[v] = dist[u] + 1;
q.push_back(v);
}
}
}
for (int i = 0; i < n; i++)
if (s[i] == '?') s[i] = '0';
int md = dist[s[0] - '0'];
cout << (md == INF ? -1 : md) << endl;
cout << s << endl;
}
| 8 |
#include <bits/stdc++.h>
#define FAST ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define ll long long int
#define pb push_back
#define pob pop_back
#define ub upper_bound
#define lb lower_bound
#define mp make_pair
#define f0(i,n) for(i=0;i<n;i++)
#define rf0(i,n) for(i=n-1;i>=0;i--)
#define f2(i,n) for(i=1;i<n;i++)
#define f1(i,n) for(i=1;i<=n;i++)
#define fab(i,a,b) for(i=a;i<=b;i++)
#define shr ll t;cin>>t; while(t--)
#define fi first
#define sc second
#define pll pair<ll,ll>
#define vll vector<ll>
#define vpll vector<pll>
#define all(v) v.begin(),v.end()
#define mod 1000000007
#define dev(a) for(auto it:a)cout<<it<<" "
#define prec(nm,prc) cout<<fixed << setprecision(nm)<<prc
#define print(a) cout<<a<<endl;
#define nl '\n'
using namespace std;
bool comp(pll &a,pll &b)
{
return (a.sc<b.sc);
}
ll power(ll n,ll p)
{
if(p==0)
return 1;
else
{
ll ans=power(n,p/2)%mod;
ans=(ans*ans)%mod;
if(p%2==0)
return ans;
else
return ans=(ans*n)%mod;
}
}
bool isPrime(ll n)
{
if (n <= 1)
return false;
if (n <= 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
for (ll i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
/********************HAR HAR MAHADEV***********JAI BAJRANG BALI************************/
int main()
{
FAST;
/* ifstream cin;
cin.open("input.txt");
ofstream cout;
cout.open("output.txt");
*/
shr
{
ll i,j,n,a,b,c,c1,d,m,sum=0,temp,k,k2,k1,ans=0,cnt=0,r=0,e=0,f;
string str,stri,om,s;
map<ll,ll>mp,mp1;
set<ll>st; vector<vll> v;
cin>>n>>k; ll x[n][2];
f0(i,n)
{
cin>>x[i][0]>>x[i][1];
}
f0(i,n)
{
vll vk;
f0(j,n)
{
if(i!=j)
{
vk.pb(abs(x[i][0]-x[j][0])+abs(x[i][1]-x[j][1]));
}
}
v.pb(vk);
r++;
}
f0(i,v.size())
{
ll p=*max_element(all(v[i]));
if(p<=k){e=1;break;}
}
if(e==1)cout<<1;
else cout<<-1;
cout<<endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2 * 1e5 + 10;
long long t[2][4 * N], a, b;
void update(int l, int r, int j, int pos, int val) {
if (r < pos || pos < l) return;
if (pos <= l && r <= pos) {
t[0][j] = min(a, t[0][j] + val);
t[1][j] = min(b, t[1][j] + val);
return;
}
int mid = (l + r) >> 1;
update(l, mid, 2 * j, pos, val);
update(mid + 1, r, 2 * j + 1, pos, val);
if (l != r) {
t[0][j] = t[0][2 * j] + t[0][2 * j + 1];
t[1][j] = t[1][2 * j] + t[1][2 * j + 1];
}
}
long long getSum(int l, int r, int j, int x, int y, int wh) {
if (r < x || y < l) return 0LL;
if (x <= l && r <= y) {
return t[wh][j];
}
int mid = (l + r) >> 1;
long long X = getSum(l, mid, (j << 1), x, y, wh);
long long Y = getSum(mid + 1, r, ((j << 1) | 1), x, y, wh);
return X + Y;
}
int n, k, q;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k >> a >> b >> q;
for (int i = 0; i < q; i++) {
int type;
cin >> type;
if (type == 1) {
int di, ai;
cin >> di >> ai;
update(1, n, 1, di, ai);
} else {
int p;
cin >> p;
long long res = getSum(1, n, 1, 1, p - 1, 1);
res += getSum(1, n, 1, p + k, n, 0);
cout << res << "\n";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
vector<char> a(9 * 9);
vector<int> full(9), used(9 * 9);
for (int i = 0; i < 81; i++) {
cin >> a[i];
if (a[i] == '.') continue;
int x = i / 9, y = i % 9;
full[(x / 3) * 3 + y / 3]++;
used[i] = 1;
}
int x, y;
cin >> x >> y;
x--;
y--;
bool f = 1;
int numa = (x / 3) * 3 + y / 3;
int numb = (x % 3) * 3 + y % 3;
if (full[numb] == 9) f = 0;
for (int i = 0; i < 81; i++) {
x = i / 9;
y = i % 9;
int cur = (x / 3) * 3 + y / 3;
if ((f) && (cur == numb) && (used[i] == 0)) a[i] = '!';
if ((!f) && (used[i] == 0)) a[i] = '!';
cout << a[i];
if ((i % 3 == 2) && (i % 9 != 8)) cout << " ";
if (i % 9 == 8) cout << "\n";
if (i % 27 == 26) cout << "\n";
}
return (0);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200007;
vector<int> g[MAXN], gr[MAXN];
int cnt[MAXN], ans;
vector<int> res;
void dfs1(int v, int p = -1) {
int i, to;
cnt[v] = 0;
for (i = 0; i < g[v].size(); i++) {
to = g[v][i];
if (to == p) continue;
dfs1(to, v);
cnt[v] += (cnt[to] + 1);
}
for (i = 0; i < gr[v].size(); i++) {
to = gr[v][i];
if (to == p) continue;
dfs1(to, v);
cnt[v] += cnt[to];
}
}
void dfs2(int v, int p = -1, int now = 0) {
int i, to;
if ((now + cnt[v]) == ans) res.push_back(v);
if ((now + cnt[v]) > ans) {
res.clear();
res.push_back(v);
ans = now + cnt[v];
}
for (i = 0; i < g[v].size(); i++) {
to = g[v][i];
if (to == p) continue;
dfs2(to, v, now + cnt[v] - cnt[to] - 1);
}
for (i = 0; i < gr[v].size(); i++) {
to = gr[v][i];
if (to == p) continue;
dfs2(to, v, now + cnt[v] - cnt[to] + 1);
}
}
int main() {
int n, i, s, t;
cin >> n;
for (i = 0; i < n - 1; i++) {
cin >> s >> t;
g[s].push_back(t);
gr[t].push_back(s);
}
dfs1(1);
ans = 0;
dfs2(1);
cout << n - 1 - ans << endl;
sort(res.begin(), res.end());
for (i = 0; i < res.size(); i++) cout << res[i] << " ";
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-9, PI = acos(-1.);
const int INF = 0x3f3f3f3f, MOD = 1e9 + 7;
const int N = 1e5 + 5;
int n, s, x, t[N], val[N], nex[N];
int best, bestv;
int main() {
scanf("%d%d%d", &n, &s, &x);
vector<int> v;
for (int i = 1; i <= n; i++) v.push_back(i);
srand(time(0));
random_shuffle(v.begin(), v.end());
int a = 1;
printf("? %d\n", s);
fflush(stdout);
scanf("%d%d", &val[s], &nex[s]);
t[s] = 1;
t[nex[s]] = 1;
if (val[s] >= x) {
printf("! %d\n", val[s]);
fflush(stdout);
return 0;
}
int p = 0;
best = s, bestv = val[s];
while (x - bestv > 2000 - a and a < 1900) {
while (t[v[p]]) p++;
if (p >= n) break;
int cur = v[p];
printf("? %d\n", cur);
fflush(stdout);
scanf("%d%d", &val[cur], &nex[cur]);
t[cur] = 1;
t[nex[cur]] = 1;
if (val[cur] <= x and val[cur] > bestv) {
if (nex[cur] == -1) {
printf("! -1\n");
fflush(stdout);
return 0;
}
best = cur, bestv = val[cur];
}
a++;
}
while (bestv < x and a < 1999 and nex[best] != -1) {
best = nex[best];
printf("? %d\n", best);
fflush(stdout);
scanf("%d%d", &bestv, &nex[best]);
a++;
}
if (bestv < x)
printf("! -1\n");
else
printf("! %d\n", bestv);
fflush(stdout);
return 0;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> G[100005];
int color[100005];
long long sum;
void init() {
for (int i = 0; i < 100005; i++) {
G[i].clear();
color[i] = -1;
}
}
int ranse() {
queue<int> q;
q.push(1);
color[1] = 2;
while (!q.empty()) {
int a = q.front();
q.pop();
for (int i = 0; i < G[a].size(); i++) {
if (color[G[a][i]] == color[a]) {
return 1;
} else {
if (color[G[a][i]] == -1) {
color[G[a][i]] = -color[a];
q.push(G[a][i]);
}
}
}
}
return 0;
}
int main() {
int m;
while (cin >> m) {
sum = 0;
init();
for (int i = 0; i < m - 1; i++) {
int s, t;
cin >> s >> t;
G[s].push_back(t);
G[t].push_back(s);
}
if (ranse() == 0) {
for (int i = 0; i < 100005; i++) {
if (color[i] == 2) {
sum++;
}
}
long long num = sum * (m - sum);
cout << num - (m - 1) << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0) {
return b;
} else {
return gcd(b % a, a);
}
}
int main() {
int a, aCopy;
cin >> a;
long long summ = 0;
long long znam = a - 2;
for (int i = 2; i <= a - 1; i++) {
aCopy = a;
while (aCopy != 0) {
summ += (aCopy % i);
aCopy /= i;
}
}
long long g = gcd(znam, summ);
cout << summ / g << '/' << znam / g;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 * 100 + 5;
vector<int> adj[N];
int H[N], p[N], l;
void dfs(int v, int par, int h) {
++H[h];
l = max(l, h);
for (int i = 0; i < (int)(adj[v]).size(); ++i)
if (adj[v][i] != par) dfs(adj[v][i], v, h + 1);
}
int main() {
ios::sync_with_stdio(false);
int n, k, p, a, b, OK, Mk;
cin >> n >> k >> p;
if (!k) {
cout << 0 << endl;
return 0;
}
Mk = OK = k;
for (int i = 1; i < n; ++i) {
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
dfs(1, 0, 1);
for (int i = l; i > 1; --i) {
for (int j = 0; j < H[i]; ++j) {
p -= l - i;
--k;
while (p < 0) {
k += H[l];
--l;
p += OK - k;
}
Mk = min(Mk, k);
if (!k) {
cout << OK << endl;
return 0;
}
}
}
cout << OK - Mk << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
const int maxn = 5009;
int a[maxn];
int howmany[maxn];
int res[maxn];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) {
for (int j = 0; j < maxn; j++) howmany[j] = 0;
int ma = 0;
int node = 10000000;
for (int j = i; j < n; j++) {
howmany[a[j]]++;
if (howmany[a[j]] > ma) {
ma = howmany[a[j]];
node = a[j];
res[a[j]]++;
} else if (howmany[a[j]] == ma) {
if (a[j] <= node) {
node = a[j];
res[a[j]]++;
} else {
res[node]++;
}
} else {
res[node]++;
}
}
}
for (int i = 1; i <= n; i++) {
printf("%d ", res[i]);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int x1, y_1, r1, x2, y2, r2;
long double dis;
int main() {
cin >> x1 >> y_1 >> r1;
cin >> x2 >> y2 >> r2;
dis = sqrt((long double)((x2 - x1) * (x2 - x1) + (y2 - y_1) * (y2 - y_1)));
if (dis + 1e-9 < abs(r1 - r2))
printf("%.15lf\n", (double)((abs(r1 - r2) - dis) / 2));
else if (dis + 1e-9 <= r1 + r2)
printf("%.15lf\n", 0.0);
else
printf("%.15lf\n", (double)((dis - r1 - r2) / 2));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (1 << 18);
long long c[MAXN + 5], sum;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int N, K;
cin >> N >> K;
for (int i = 0; i < (1 << N); i++) {
cin >> c[i];
sum += c[i];
}
cout << fixed << setprecision(6) << (double)sum / (1 << N) << '\n';
for (int i = 0; i < K; i++) {
long long id, x;
cin >> id >> x;
sum -= c[id];
c[id] = x;
sum += x;
cout << fixed << setprecision(6) << (double)sum / (1 << N) << '\n';
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = (long long)1e9 + 7;
void solve() {
int n;
cin >> n;
int a[n], b[n - 1], c[n - 2];
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < n - 1; ++i) {
cin >> b[i];
}
for (int i = 0; i < n - 2; ++i) {
cin >> c[i];
}
sort(a, a + n);
sort(b, b + n - 1);
sort(c, c + n - 2);
int ans = a[n - 1];
for (int i = 0; i < n - 1; ++i) {
if (a[i] == b[i]) {
continue;
} else {
ans = a[i];
break;
}
}
cout << ans << '\n';
ans = b[n - 2];
for (int i = 0; i < n - 2; ++i) {
if (c[i] == b[i]) {
continue;
} else {
ans = b[i];
break;
}
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int test = 1;
while (test--) {
solve();
cout << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bitset<23000> a, b, c, e;
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
getchar();
for (int i = 0; i < n; i++, getchar())
for (int j = 0; j < m; j++) {
char s = getchar();
(s == '#' ? b : a).set(i * m + j);
(s == 'E' ? e.set(i * m + j) : 0);
}
c = a;
for (int i = 0; i < k; i++) {
char s = getchar();
if (c == e) {
printf("%d\n", i);
return 0;
}
if (s == 'U')
c = ((c >> m) & a) | (c & (b << m));
else if (s == 'L')
c = ((c >> 1) & a) | (c & (b << 1));
else if (s == 'D')
c = ((c << m) & a) | (c & (b >> m));
else if (s == 'R')
c = ((c << 1) & a) | (c & (b >> 1));
}
if (c == e)
printf("%d\n", k);
else
printf("%d\n", -1);
fclose(stdin);
fclose(stdout);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
if (n < 15) {
cout << "NO"
<< "\n";
continue;
}
if (((n - 20) % 14) == 0 or ((n - 19) % 14) == 0 or ((n - 18) % 14) == 0 or
((n - 17) % 14) == 0 or ((n - 16) % 14) == 0 or ((n - 15) % 14) == 0)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long maxN = 2e5 + 5;
struct edge {
long long node_to, w;
edge() {}
edge(long long node_to, long long w) {
this->node_to = node_to;
this->w = w;
}
};
long long n, m, a[maxN], par, weight, dist[maxN], cnt_starting[maxN],
cnt_ending[maxN], ans[maxN], current_cnt;
vector<long long> path;
vector<edge> graph[maxN];
void compute_dists(long long node, long long current_dist) {
dist[node] = current_dist;
long long next_node, next_w;
for (long long i = 0; i < graph[node].size(); i++) {
next_node = graph[node][i].node_to;
next_w = graph[node][i].w;
compute_dists(next_node, current_dist + next_w);
}
}
void bin_search(long long node) {
long long le = 0, ri = (long long)path.size() - 1, mid, highest = -1,
current_dist;
while (le <= ri) {
mid = (le + ri) / 2;
current_dist = dist[node] - dist[path[mid]];
if (current_dist <= a[node]) {
highest = mid;
ri = mid - 1;
} else
le = mid + 1;
}
if (highest == -1) return;
cnt_ending[path[highest]]++;
cnt_starting[node]++;
}
void dfs1(long long node) {
bin_search(node);
path.push_back(node);
long long next_node;
for (long long i = 0; i < graph[node].size(); i++) {
next_node = graph[node][i].node_to;
dfs1(next_node);
}
path.pop_back();
}
void dfs2(long long node) {
long long next_node;
for (long long i = 0; i < graph[node].size(); i++) {
next_node = graph[node][i].node_to;
current_cnt = 0;
dfs2(next_node);
ans[node] += current_cnt;
}
if (graph[node].size() == 0) {
ans[node] = 0;
current_cnt = cnt_starting[node];
} else
current_cnt = ans[node] + cnt_starting[node] - cnt_ending[node];
}
int main() {
ios_base::sync_with_stdio(NULL);
cin.tie(NULL);
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
for (long long i = 2; i <= n; i++) {
cin >> par >> weight;
graph[par].push_back(edge(i, weight));
}
compute_dists(1, 0);
dfs1(1);
dfs2(1);
for (long long i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
double p[5006], dp[5006][5006], ans = 0;
int t[5006], n, T;
int main() {
memset(dp, 0, sizeof(dp));
memset(p, 0, sizeof(p));
ios_base::sync_with_stdio(false);
cin >> n >> T;
for (int i = 1; i <= n; i++) {
cin >> p[i] >> t[i];
p[i] /= 100;
}
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
double res = 0, q = pow(1 - p[i], t[i] - 1);
for (int j = 0; j <= T; j++) {
if (j >= t[i]) {
dp[i][j] += dp[i - 1][j - t[i]] * q;
res -= dp[i - 1][j - t[i]] * q;
}
dp[i][j] += res * p[i];
res *= (1 - p[i]);
if (j < T) res += dp[i - 1][j];
}
dp[i - 1][T] += res;
}
for (int i = 1; i <= n; i++) ans += dp[i][T] * i;
for (int i = 1; i < T; i++) ans += dp[n][i] * n;
cout << fixed << setprecision(10) << ans;
}
| 8 |
#include <bits/stdc++.h>
const int MaxN = 60;
int N, M;
bool A[MaxN][MaxN], Vis[MaxN][MaxN];
bool getc() {
char ch;
while (ch = getchar(), ch != '#' && ch != '.')
;
return ch == '#';
}
void Dfs(int x, int y) {
if (x <= 0 || y <= 0 || x > N || y > M) return;
if (!A[x][y] || Vis[x][y]) return;
Vis[x][y] = 1;
Dfs(x + 1, y);
Dfs(x - 1, y);
Dfs(x, y + 1);
Dfs(x, y - 1);
}
bool check() {
int Cnt = 0;
memset(Vis, 0, sizeof(Vis));
for (register int i = 1; i <= N; i++)
for (register int j = 1; j <= M; j++) {
if (A[i][j] && !Vis[i][j]) Dfs(i, j), Cnt++;
}
return Cnt >= 2;
}
int main() {
scanf("%d %d", &N, &M);
int Cnt = 0;
for (register int i = 1; i <= N; i++)
for (register int j = 1; j <= M; j++) A[i][j] = getc(), Cnt += A[i][j];
if (Cnt <= 2) {
puts("-1");
return 0;
}
for (register int i = 1; i <= N; i++)
for (register int j = 1; j <= M; j++)
if (A[i][j]) {
A[i][j] = 0;
if (check()) {
puts("1");
return 0;
}
A[i][j] = 1;
}
puts("2");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n, i;
cin >> n;
long long a[2 * n];
for (i = 0; i < 2 * n; i++) {
cin >> a[i];
}
sort(a, a + (2 * n));
cout << a[n] - a[n - 1] << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long sum = 1, n;
int main() {
cin >> n;
for (int i = 1; i <= (int)(n - 1); i++) {
sum = (sum * 3) % 1000003;
}
cout << sum;
fclose(stdin);
fclose(stdout);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> row(n);
vector<int> col(n);
long long sum = 0;
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
for (int x = 0; x < s.size(); ++x) {
if (s[x] == 'C') {
col[i]++;
row[x]++;
}
}
}
for (int i = 0; i < row.size(); ++i) {
sum += row[i] * (row[i] - 1) / 2;
}
for (int i = 0; i < col.size(); ++i) {
sum += col[i] * (col[i] - 1) / 2;
}
cout << sum << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long pow(long long x, long long y) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (ans * x);
y = y >> 1;
x = (x * x);
}
return ans;
}
long long modpow(long long x, long long y, long long p = 1000000007) {
long long ans = 1;
x = x % p;
while (y > 0) {
if (y & 1) ans = (ans * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return ans;
}
long long xxx, yyy, ggg;
void extendedEuclid(long long a, long long b) {
if (b == 0) {
ggg = a;
xxx = 1;
yyy = 0;
} else {
extendedEuclid(b, a % b);
long long temp = xxx;
xxx = yyy;
yyy = temp - (a / b) * yyy;
}
}
long long modinverse(long long a, long long p = 1000000007) {
extendedEuclid(a, p);
if (ggg == 1 && p != 1)
return (xxx + p) % p;
else
return -1;
}
long long madd(long long a, long long b, long long m = 1000000007) {
return ((a % m) + (b % m)) % m;
}
long long msub(long long a, long long b, long long m = 1000000007) {
return ((a % m) - (b % m) + m) % m;
}
long long mmult(long long a, long long b, long long m = 1000000007) {
return ((a % m) * (b % m)) % m;
}
long long mdiv(long long a, long long b, long long m = 1000000007) {
return ((a % m) * modinverse((b % m), m)) % m;
}
long long stree[4 * 1000005];
long long query(long long node, long long start, long long end, long long l,
long long r) {
if (l > end || start > r) return 0;
if (l <= start && end <= r) return stree[node];
long long mid = (start + end) / 2;
long long p1 = query(2 * node + 1, start, mid, l, r);
long long p2 = query(2 * node + 2, mid + 1, end, l, r);
return madd(p1, p2);
}
void update(long long node, long long start, long long end, long long idx,
long long val) {
if (start == end) {
stree[node] = madd(stree[node], val);
} else {
long long mid = (start + end) / 2;
if (start <= idx && idx <= mid)
update(2 * node + 1, start, mid, idx, val);
else
update(2 * node + 2, mid + 1, end, idx, val);
stree[node] = madd(stree[2 * node + 1], stree[2 * node + 2]);
}
}
vector<long long> adj[1000005];
long long solve() {
long long n, m;
cin >> n >> m;
pair<long long, long long> a[m];
for (long long i = 0; i < m; i++) cin >> a[i].first >> a[i].second;
sort(a, a + m);
map<long long, bool> visited;
vector<long long> v;
for (long long i = 0; i < m; i++) {
if (visited[a[i].first] == false) v.push_back(a[i].first);
if (visited[a[i].second] == false) v.push_back(a[i].second);
visited[a[i].first] = true;
visited[a[i].second] = true;
}
if (visited[0] == false) v.push_back(0);
if (visited[n] == false) v.push_back(n);
sort(v.begin(), v.end());
map<long long, long long> pos;
for (long long i = 0; i < v.size(); i++) pos[v[i]] = i;
for (long long i = 0; i < m; i++)
adj[pos[a[i].second]].push_back(pos[a[i].first]);
update(0, 0, 1000005 - 1, pos[0], 1);
for (long long i = 0; i < v.size(); i++) {
for (long long j = 0; j < adj[i].size(); j++) {
long long temp = query(0, 0, 1000005 - 1, adj[i][j], i - 1);
update(0, 0, 1000005 - 1, i, temp);
}
}
cout << query(0, 0, 1000005 - 1, pos[n], pos[n]) << "\n";
return 0;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
long long t = 1;
while (t-- != 0) {
long long stat = solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int C = 26;
void add(int &x, int y) {
x += y;
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
}
int fix(int x) {
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
return x;
}
int pw(int a, int b) {
int ret = 1;
while (b) {
if (b & 1) ret = 1ll * ret * a % MOD;
b >>= 1;
a = 1ll * a * a % MOD;
}
return ret;
}
const int MAXN = 1e3 + 10;
int n, dp[MAXN], p[MAXN];
void solve() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> p[i], --p[i];
int ans = 0;
for (int i = 0; i < n; i++) {
dp[i] = 1;
for (int j = p[i]; j < i; j++) add(dp[i], dp[j]);
add(ans, dp[i]);
}
add(ans, ans);
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int te = 1;
for (int w = 1; w <= te; w++) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const double eps = 1e-9;
int Start[210000];
int End[210000];
int Midi[210000];
int Ch[210000][2];
int Max1[210000];
int Max2[210000];
int Create(int p, int a, int b) {
Start[p] = a;
End[p] = b;
Max1[p] = -oo;
Max2[p] = 0;
int p1 = p + 1;
if (b - a > 1) {
Midi[p] = (a + b) / 2;
Ch[p][0] = p1;
p1 = Create(p1, a, Midi[p]);
Ch[p][1] = p1;
p1 = Create(p1, Midi[p], b);
}
return p1;
}
void Add1(int p, int pos, int val) {
if (pos < Start[p] || pos >= End[p]) {
return;
} else if (End[p] - Start[p] > 1) {
if (pos < Midi[p])
Add1(Ch[p][0], pos, val);
else
Add1(Ch[p][1], pos, val);
}
Max1[p] = max(Max1[p], val);
}
void Add2(int p, int pos, int val) {
if (pos < Start[p] || pos >= End[p]) {
return;
} else if (End[p] - Start[p] > 1) {
if (pos < Midi[p])
Add2(Ch[p][0], pos, val);
else
Add2(Ch[p][1], pos, val);
}
Max2[p] = max(Max2[p], val);
}
int Get1(int p, int pos) {
if (pos >= End[p] - 1) {
return Max1[p];
} else if (pos >= Start[p] && End[p] - Start[p] > 1) {
return max(Get1(Ch[p][0], pos), Get1(Ch[p][1], pos));
} else
return -oo;
}
int Get2(int p, int pos) {
if (pos >= End[p] - 1) {
return Max2[p];
} else if (pos >= Start[p] && End[p] - Start[p] > 1) {
return max(Get2(Ch[p][0], pos), Get2(Ch[p][1], pos));
} else
return -oo;
}
int a[110000];
int b[110000];
int main() {
int n = 0;
int v = 0;
scanf("%d", &n);
set<long long> B;
vector<pair<long long, long long> > E;
B.insert(0);
for (int i = (0); i < (n); i++) {
scanf("%d%d", &a[i], &b[i]);
}
scanf("%d", &v);
for (int i = (0); i < (n); i++) {
E.push_back(
make_pair(-(a[i] - b[i] * (long long)v), a[i] + b[i] * (long long)v));
B.insert(a[i] + b[i] * (long long)v);
}
Create(0, 0, n + 5);
map<long long, int> M;
int Nu = 0;
for (__typeof__((B).begin()) i = (B).begin(); i != (B).end(); i++) {
M[*i] = Nu;
Nu++;
}
sort((E).begin(), (E).end());
bool S = false;
int O1 = 0;
int O2 = 0;
for (int i = (0); i < (n); i++) {
if (S == false && E[i].first >= 0) {
S = true;
Add1(0, M[0], 0);
}
int Ma = Get1(0, M[E[i].second]) + 1;
O1 = max(O1, Ma);
Add1(0, M[E[i].second], Ma);
Ma = Get2(0, M[E[i].second]) + 1;
O2 = max(O2, Ma);
Add2(0, M[E[i].second], Ma);
}
printf("%d %d\n", O1, O2);
return 0;
}
| 7 |
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int,int>pii;
const int mod = 1e9+7;
const int inf = 1e9+100;
const int N = 3e5+5;
int main(){
ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
int n,k;
cin>>n>>k;
string cur = "aa";
for(int i=2; i<=k; i++){
char ch = char('a'+i-1);
cur += ch;
for(int j=i-1; j>=1; j--){
cur += ch;
cur += char('a'+j-1);
}
}
string ans;
for(int i=0, j=0; i<n; i++, j++){
if(j==cur.size()) j = 1;
ans += cur[j];
}
cout<<ans<<"\n";
}
/*
*/
| 4 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<int, vector<int>, greater<int> > q, s[3005], v[3005];
int main() {
int n, m, x, y;
while (~scanf("%d%d", &n, &m)) {
for (int i = 1; i <= m; i++)
while (!s[i].empty()) s[i].pop();
for (int i = 1; i <= n; i++) {
scanf("%d%d", &x, &y);
s[x].push(y);
}
long long ans = 1ll << 55;
for (int i = 1; i <= n; i++) {
while (!q.empty()) q.pop();
for (int j = 1; j <= m; j++) v[j] = s[j];
int cnt = v[1].size();
long long temp = 0;
for (int j = 2; j <= m; j++) {
while (v[j].size() >= i) {
temp = temp + v[j].top();
v[j].pop();
cnt++;
}
}
if (cnt > i) continue;
for (int j = 2; j <= m; j++) {
while (v[j].size() >= i) {
temp = temp + v[j].top();
v[j].pop();
cnt++;
}
}
for (int j = 2; j <= m; j++) {
while (!v[j].empty()) {
q.push(v[j].top());
v[j].pop();
}
}
while (cnt < i && !q.empty()) {
temp += q.top();
q.pop();
cnt++;
}
if (cnt == i) {
ans = min(ans, temp);
}
}
printf("%I64d\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int a = -1;
bool found = false;
cin >> s;
for (int i = 0; i < s.size(); i++) {
a = stoi(s.substr(i, 1));
if (a % 8 == 0) {
found = true;
break;
}
for (int j = i + 1; j < s.size(); j++) {
a = stoi(s.substr(i, 1) + s.substr(j, 1));
if (a % 8 == 0) {
found = true;
break;
}
for (int k = j + 1; k < s.size(); k++) {
a = stoi(s.substr(i, 1) + s.substr(j, 1) + s.substr(k, 1));
if (a % 8 == 0) {
found = true;
break;
}
}
if (found) {
break;
}
}
if (found) {
break;
}
}
if (found) {
cout << "YES" << endl;
cout << a << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[10000001];
int main() {
int n, ans = -1e9;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i * 3 <= n; i++) {
if (n % i == 0) {
for (int j = 1; j <= i; j++) {
int sum = 0;
for (int k = j; k <= n; k += i) {
sum += a[k];
}
ans = max(ans, sum);
}
}
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long a[444444], cot[444444];
void pushdown(int rt) {
if (cot[rt]) {
cot[rt << 1] = cot[rt];
cot[rt << 1 | 1] = cot[rt];
a[rt << 1] = cot[rt];
a[rt << 1 | 1] = cot[rt];
cot[rt] = 0;
}
}
void pushup(int rt) { a[rt] = max(a[rt << 1], a[rt << 1 | 1]); }
void build(int L, int R, int rt) {
cot[rt] = 0;
if (L == R) {
scanf("%I64d", &a[rt]);
return;
}
int m;
m = (L + R) >> 1;
build(L, m, rt << 1);
build(m + 1, R, rt << 1 | 1);
pushup(rt);
}
void update(int L, int R, int l, int r, long long c, int rt) {
if (l <= L && R <= r) {
cot[rt] = c;
a[rt] = c;
return;
}
pushdown(rt);
int m;
m = (L + R) >> 1;
if (l <= m) update(L, m, l, r, c, rt << 1);
if (r > m) update(m + 1, R, l, r, c, rt << 1 | 1);
pushup(rt);
}
long long query(int L, int R, int l, int r, int rt) {
long long ret = 0;
if (l <= L && R <= r) return a[rt];
pushdown(rt);
int m;
m = (L + R) >> 1;
if (l <= m) ret = query(L, m, l, r, rt << 1);
if (r > m) ret = max(ret, query(m + 1, R, l, r, rt << 1 | 1));
return ret;
}
int main() {
int n, m;
while (scanf("%d", &n) != EOF) {
build(1, n, 1);
scanf("%d", &m);
while (m--) {
long long w, h;
scanf("%I64d%I64d", &w, &h);
long long tmp = query(1, n, 1, w, 1);
update(1, n, 1, w, tmp + h, 1);
printf("%I64d\n", tmp);
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
s += '@';
char delimiter = '@';
vector<string> str;
string acc = "";
for (int i = 0; i < s.size(); i++) {
if (s[i] == delimiter) {
str.push_back(acc);
acc = "";
} else
acc += s[i];
}
int f = 0;
vector<string> ans;
string prev, curr, next;
if (str.size() > 1) {
for (vector<string>::iterator itr = str.begin(); itr != str.end(); itr++) {
string x;
x = *itr;
if (itr == str.begin() && x.size() >= 1) {
prev = x;
prev += '@';
continue;
} else if (x.size() > 1 && itr != str.end() - 1) {
int l = x.size();
curr = x.substr(0, (l / 2));
next = x.substr(l / 2);
prev.append(curr);
ans.push_back(prev);
prev = next;
prev += '@';
continue;
} else if (x.size() >= 1 && itr == str.end() - 1) {
curr = x;
prev.append(curr);
ans.push_back(prev);
} else
f = 1;
}
} else
f = 1;
if (f == 0) {
vector<string>::iterator itr;
for (itr = ans.begin(); itr != ans.end() - 1; itr++) {
cout << *itr << ",";
}
cout << *itr;
} else {
cout << "No solution";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int par[150008], sz[150008];
int n;
deque<int> dq[150008];
int find(int u) { return (par[u] == u) ? u : find(par[u]); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
sz[i] = 1;
par[i] = i;
dq[i].push_back(i);
}
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
int x = find(u);
int y = find(v);
if (x == y) {
continue;
}
int mn = min(x, y);
if (sz[y] > sz[x]) {
sz[y] += sz[x];
par[x] = y;
for (int i = 0; i < dq[x].size(); i++) {
dq[y].push_front(dq[x][i]);
par[dq[x][i]] = y;
}
} else {
if (sz[x] == sz[y]) {
if (x > y) {
swap(x, y);
}
}
sz[x] += sz[y];
par[y] = x;
for (int i = 0; i < dq[y].size(); i++) {
dq[x].push_back(dq[y][i]);
par[dq[y][i]] = x;
}
}
}
int pos = -1;
for (int i = 1; i <= n; i++) {
if (dq[i].size() == n) {
pos = i;
break;
}
}
for (int i = 0; i < dq[pos].size(); i++) {
cout << dq[pos][i] << " ";
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long a[200001], n;
string s, t;
bool check(long long m) {
string temp = s;
for (long long i = 0; i < m; ++i) {
temp[a[i] - 1] = '.';
}
long long i = 0, j = 0;
while (i < n && j < t.size()) {
if (temp[i] == '.') {
++i;
continue;
} else if (temp[i] == t[j]) {
++i;
++j;
} else
++i;
}
return j == t.size();
}
void solve() {
cin >> s >> t;
n = s.size();
for (long long i = 0; i < n; ++i) cin >> a[i];
long long l = 0, r = n, m, ans = 0;
while (l <= r) {
m = l + (r - l) / 2;
if (check(m)) {
ans = max(ans, m);
l = m + 1;
} else {
r = m - 1;
}
}
cout << ans << "\n";
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int n;
int main() {
cin >> n;
int x;
for (int i = 0; i < n; i++) {
cin >> x;
v.push_back(x);
}
sort(v.begin(), v.end());
int i = 0;
int l = 0;
while (i < n - 1) {
if (v[i] == v[i + 1]) {
l++;
i += 2;
continue;
}
++i;
}
cout << l / 2 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n;
struct pmod {
int v, fa;
} a[500];
struct dmod {
int px, fa;
} b[500];
int fa[500], ans[500];
string mp[500];
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
void un(int a, int b) {
a = find(a);
b = find(b);
if (a != b) fa[a] = b;
}
bool cmp(pmod a, pmod b) {
if (a.fa == b.fa)
return a.v < b.v;
else
return a.fa < b.fa;
}
bool cmp2(dmod a, dmod b) {
if (a.fa == b.fa)
return a.px < b.px;
else
return a.fa < b.fa;
}
int main() {
while (cin >> n) {
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].v);
fa[i] = i;
b[i].px = i;
}
for (int i = 1; i <= n; i++) {
cin >> mp[i];
for (int j = 0; j < n; j++) {
if (mp[i][j] == '1') {
un(i, j + 1);
}
}
}
for (int i = 1; i <= n; i++) {
fa[i] = find(i);
a[i].fa = fa[i];
b[i].fa = fa[i];
}
sort(a + 1, a + 1 + n, cmp);
sort(b + 1, b + 1 + n, cmp2);
for (int i = 1; i <= n; i++) {
ans[b[i].px] = a[i].v;
}
for (int i = 1; i < n; i++) cout << ans[i] << " ";
cout << ans[n] << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double sq(double a) { return a * a; }
struct pii {
double x, y;
};
pii mp(double x, double y) {
pii ret;
ret.x = x;
ret.y = y;
return ret;
}
pii operator-(pii a, pii b) { return mp(a.x - b.x, a.y - b.y); }
pii operator+(pii a, pii b) { return mp(a.x + b.x, a.y + b.y); }
pii operator*(pii a, double b) { return mp(a.x * b, a.y * b); }
pii operator*(double a, pii b) { return mp(b.x * a, b.y * a); }
double mol(pii a) { return sqrt(sq(a.x) + sq(a.y)); }
double chaji(pii a, pii b) { return a.x * b.y - a.y * b.x; }
double dianji(pii a, pii b) { return a.x * b.x + a.y * b.y; }
pii A, B, V1, V2;
double V, T;
void read(pii *p) {
double x, y;
scanf("%lf%lf", &x, &y);
p->x = x;
p->y = y;
}
int main() {
read(&A);
read(&B);
scanf("%lf%lf", &V, &T);
read(&V1);
read(&V2);
double l = 0, r = 1000000000.0;
for (int I = 1; I <= 10000; I++) {
double mid = (l + r) / 2.0;
pii pos;
if (mid > T)
pos = V1 * T + V2 * (mid - T);
else
pos = V1 * mid;
pii fly = B - A - pos;
double dist = mol(fly);
if (dist / V <= mid)
r = mid;
else
l = mid;
}
printf("%.18lf\n", l);
getchar();
getchar();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
int main() {
int n, a, b, k;
scanf("%d %d %d %d\n", &n, &a, &b, &k);
string s;
getline(cin, s);
int pos = 0;
std::vector<int> shots;
int last = -1;
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
int l = last;
int r = i;
pos += (r - l - 1) / b;
for (int j = 0; j < (r - l - 1) / b; j++)
shots.push_back(l + b * (j + 1));
last = i;
}
}
int l = last;
int r = n;
pos += (r - l - 1) / b;
for (int i = 0; i < (r - l - 1) / b; i++) shots.push_back(l + b * (i + 1));
printf("%d\n", pos - a + 1);
for (int i = 0; i < pos - a + 1; i++) printf("%d ", shots[i] + 1);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int lev[100005];
void dfs(int u, int p, int **memo, int log, vector<int> *g) {
memo[u][0] = p;
for (int i = 1; i <= log; i++) memo[u][i] = memo[memo[u][i - 1]][i - 1];
for (int v : g[u]) {
if (v != p) {
lev[v] = lev[u] + 1;
dfs(v, u, memo, log, g);
}
}
}
int lca(int u, int v, int log, int **memo) {
if (lev[u] < lev[v]) swap(u, v);
for (int i = log; i >= 0; i--)
if ((lev[u] - pow(2, i)) >= lev[v]) u = memo[u][i];
if (u == v) return u;
for (int i = log; i >= 0; i--) {
if (memo[u][i] != memo[v][i]) {
u = memo[u][i];
v = memo[v][i];
}
}
return memo[u][0];
}
int main() {
int n;
cin >> n;
vector<int> g[n + 1];
int log = (int)ceil(log2(n));
int **memo = new int *[n + 1];
for (int i = 0; i < n + 1; i++) memo[i] = new int[log + 1];
for (int i = 0; i <= n; i++) memset(memo[i], -1, sizeof memo[i]);
int a, b;
for (int i = 0; i < n - 1; i++) {
cin >> a >> b;
g[b].push_back(a);
g[a].push_back(b);
}
dfs(1, 1, memo, log, g);
int q;
cin >> q;
while (q--) {
int x, y, k;
cin >> x >> y >> a >> b >> k;
int lc = lca(a, b, log, memo);
int disab = *(lev + a) + *(lev + b) - (*(lev + lc)) - (*(lev + lc));
if (disab == k) {
cout << "YES\n";
continue;
} else if (disab < k) {
if ((k - disab) % 2 == 0) {
cout << "YES\n";
continue;
}
}
lc = lca(a, x, log, memo);
int disax = *(lev + a) + *(lev + x) - (*(lev + lc)) - (*(lev + lc));
int lc1 = lca(y, b, log, memo);
int disyb = *(lev + y) + *(lev + b) - (*(lev + lc1)) - (*(lev + lc1));
disab = 1 + disax + disyb;
if (disab == k) {
cout << "YES\n";
continue;
} else if (disab < k) {
if ((k - disab) % 2 == 0) {
cout << "YES\n";
continue;
}
}
lc = lca(a, y, log, memo);
disax = *(lev + a) + *(lev + y) - (*(lev + lc)) - (*(lev + lc));
lc1 = lca(x, b, log, memo);
disyb = *(lev + x) + *(lev + b) - (*(lev + lc1)) - (*(lev + lc1));
disab = 1 + disax + disyb;
if (disab == k) {
cout << "YES\n";
continue;
} else if (disab < k) {
if ((k - disab) % 2 == 0) {
cout << "YES\n";
continue;
}
}
cout << "NO\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
const int INF = 1e9;
const int N = 2e5 + 5;
using namespace std;
int Exp(int x, int y) {
int ans = 1;
for (int i = 1; i <= y; i++) ans *= x;
return ans;
}
vector<bool> check_prime(N + 1, true);
void Seive() {
check_prime[0] = false;
check_prime[1] = false;
for (long long i = 2; i * i <= N; i++) {
if (check_prime[i]) {
for (long long j = i * i; j <= N; j += i) check_prime[j] = false;
}
}
}
bool prime(int x) {
bool ok = true;
if (x < 2) return false;
if (x == 2)
return true;
else {
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
return false;
}
}
return true;
}
}
int dp[1000000];
int h[1000000];
void solve(int tc) {
string s;
cin >> s;
long long x = 0;
long long y = 0;
for (long long i = 0; i <= s.size() - 1; i++) {
if (s.substr(i, 5) == "metal") {
y += x;
}
if (s.substr(i, 5) == "heavy") {
x++;
}
}
cout << y << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
for (int i = 1; i <= t; i++) {
solve(i);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int n;
int a[N];
int main() {
int T;
cin >> T;
while (T--) {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
bool flag = false;
for (int i = 1; i < n - 1; i++)
if (a[i] < a[i + 1] && a[i + 1] > a[i + 2]) {
puts("YES");
cout << i << " " << i + 1 << " " << i + 2 << endl;
flag = true;
break;
}
if (!flag) puts("NO");
}
return 0;
}
| 0 |