solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const long long mod = 1e17 + 7;
const long long N = 1e5 + 5;
long long a[N], b[N], n, k;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k;
for (long long i = 0; i < (n); ++i) cin >> a[i];
for (long long i = 0; i < (n); ++i) cin >> b[i];
long long mx = 0, beg = 0, en = 2e9 + 5, mid;
while (beg < en) {
mid = (beg + en) / 2;
long long c = 0;
for (long long i = 0; i < (n); ++i) {
c += max(a[i] * mid - b[i], 0LL);
if (c > k) break;
}
if (c <= k) {
beg = mid + 1;
mx = max(mx, mid);
} else
en = mid;
}
cout << mx << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
namespace {}
int main() {
int n;
cin >> n;
long long sum = 0;
for (int i = 9; n > 0; i *= 10) {
sum += n;
n -= i;
}
cout << sum;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
stack<long long> S;
bool vis[222222];
long long n, R[222222], L[222222], H[222222], PA[222222], SA[222222],
PL[222222], SL[222222], tot;
long long TOT, LA[222222], NE[444444], EN[444444], LE[444444], d;
long long GM(long long x, long long y, long long z) {
if (x >= y && x >= z) return x;
if (y >= z) return y;
return z;
}
void ADD(long long x, long long y, long long z) {
TOT++;
EN[TOT] = y;
LE[TOT] = z;
NE[TOT] = LA[x];
LA[x] = TOT;
}
long long DFS(long long x, long long f) {
if (vis[x]) return x;
vis[x] = 1;
S.push(x);
for (long long i = LA[x]; i; i = NE[i])
if (EN[i] != f) {
long long y = DFS(EN[i], x);
if (y) return y;
}
S.pop();
return 0;
}
long long DFSH(long long x, long long f) {
long long A = 0, B = 0;
for (long long i = LA[x]; i; i = NE[i])
if (EN[i] != f) {
B = max(B, DFSH(EN[i], x) + LE[i]);
if (A < B) swap(A, B);
}
d = max(A + B, d);
return A;
}
void FSON(long long x) {
long long A = 0, B = 0;
for (long long i = LA[R[x]]; i; i = NE[i])
if (EN[i] != R[x - 1] && EN[i] != R[x + 1]) {
long long y = DFSH(EN[i], R[x]);
B = max(B, y + LE[i]);
if (A < B) swap(A, B);
}
H[x] = A;
d = max(d, A + B);
}
int main() {
long long i, j, x, y, z, Maxl, TL, ans;
scanf("%I64d", &n);
for (i = 1; i <= n; i++) {
scanf("%I64d%I64d%I64d", &x, &y, &z);
ADD(x, y, z);
ADD(y, x, z);
}
x = DFS(1, 0);
while (!S.empty()) {
R[++tot] = S.top();
S.pop();
if (R[tot] == x) break;
}
R[tot + 1] = R[1];
R[0] = R[tot];
for (i = 1; i <= tot; i++)
for (j = LA[R[i]]; j; j = NE[j])
if (EN[j] == R[i + 1]) {
L[i] = LE[j];
break;
}
for (i = 1; i <= tot; i++) FSON(i);
PA[1] = PL[1] = H[1];
SA[tot] = SL[tot] = H[tot];
SA[tot + 1] = -1e18;
SL[tot + 1] = -1e18;
TL = 0;
for (i = 2; i <= tot; i++) TL += L[i - 1], PL[i] = max(PL[i - 1], TL + H[i]);
TL = 0;
for (i = tot; i >= 1; i--) TL += L[i], SL[i] = max(SL[i + 1], TL + H[i]);
Maxl = H[1];
for (i = 2; i <= tot; i++) {
Maxl += L[i - 1];
PA[i] = max(PA[i - 1], H[i] + Maxl);
Maxl = max(Maxl, H[i]);
}
Maxl = H[tot];
for (i = tot - 1; i >= 1; i--) {
Maxl += L[i];
SA[i] = max(SA[i + 1], H[i] + Maxl);
Maxl = max(Maxl, H[i]);
}
ans = max(d, PA[tot]);
for (i = 1; i <= tot; i++)
ans = min(ans, GM(max(d, PA[i]), SA[i + 1], PL[i] + SL[i + 1]));
cout << ans;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 100005;
const long long M = 1000000007;
const long long dx[4] = {1, 0, -1, 0};
const long long dy[4] = {0, 1, 0, -1};
string s[1000];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
for (long long i = 0; i < n; i++) cin >> s[i];
bool f;
long long cnt = 0;
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++)
if (s[i][j] == '*') cnt++;
for (long long i = 1; i < n - 1; i++)
for (long long j = 1; j < m - 1; j++) {
if (s[i][j] == '*') {
bool f1 = 1;
for (long long k = 0; k < 4; k++) {
if (s[i + dx[k]][j + dy[k]] == '.') f1 = 0;
}
long long k, ans = 0;
if (f1) {
k = 1;
while ((i - k) >= 0) {
if (s[i - k][j] == '*')
ans++;
else
break;
k++;
}
k = 1;
while ((i + k) < n) {
if (s[i + k][j] == '*')
ans++;
else
break;
k++;
}
k = 1;
while ((j - k) >= 0) {
if (s[i][j - k] == '*')
ans++;
else
break;
k++;
}
k = 1;
while ((j + k) < m) {
if (s[i][j + k] == '*')
ans++;
else
break;
k++;
}
if (ans == cnt - 1)
f = 1;
else
f = 0;
if (f)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
return 0;
}
}
}
cout << "NO"
<< "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a;
vector<long long> x;
int n, m;
bool solve(long long maxn) {
for (int i = 0; i < n; ++i) x[i] = a[i];
x[n - 1] = min(m - 1LL, x[n - 1] + maxn);
for (int i = n - 2; i >= 0; --i) {
if (x[i] <= x[i + 1])
x[i] += min(x[i + 1] - x[i], maxn);
else {
if (maxn - m + x[i] < 0) return false;
x[i] = min(x[i + 1], maxn - m + x[i]);
}
}
return true;
}
signed main() {
ios_base ::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
a.resize(n);
x.resize(n);
for (int i = 0; i < n; ++i) cin >> a[i];
long long lo = 0, hi = 1LL << 40;
while (lo < hi) {
auto mid = (lo + hi) / 2;
if (solve(mid))
hi = mid;
else
lo = mid + 1;
}
cout << hi << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e3 + 5;
const long long mo = 998244353;
int n, m, k;
int a[maxn], c[maxn];
int ans, tmp, cnt;
int flag;
long long dp[maxn][maxn];
template <typename T>
inline void read(T &X) {
X = 0;
int w = 0;
char ch = 0;
while (!isdigit(ch)) {
w |= ch == '-';
ch = getchar();
}
while (isdigit(ch)) X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
if (w) X = -X;
}
void solve() {
read(n);
for (int i = (1); i <= (n); i++) {
read(a[i]);
}
sort(a + 1, a + 1 + n);
dp[0][0] = 1;
for (int i = (1); i <= (n); i++) {
long long sum = dp[i - 1][0];
int t = 0;
for (int j = (1); j <= (n); j++) {
while (t < n && a[t + 1] * 2 <= a[j]) {
t++;
sum += dp[i - 1][t];
}
dp[i][j] = (dp[i][j] + sum) % mo;
if (t - i + 2 > 0)
dp[i][j] = (dp[i][j] + dp[i - 1][j] * (t - i + 2) % mo) % mo;
}
}
printf("%lld\n", dp[n][n]);
}
int main() {
int T = 1, cas = 1;
while (T--) {
solve();
}
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
long long f[2][1000051], ff[1000051], fac[1000051], invfac[1000051];
const int mod = 1e9 + 7;
inline long long qpow(long long x, int p) {
long long res = 1;
while (p) {
if (p & 1) res = res * x % mod;
x = x * x % mod;
p >>= 1;
}
return res;
}
inline long long inv(long long x) { return qpow(x, mod - 2); }
inline void pre(int lim) {
ff[1] = 2;
ff[2] = 4;
for (int i = 3; i <= lim; ++i)
ff[i] = (ff[i - 2] * i % mod + ff[i - 1]) % mod;
fac[0] = 1;
fac[1] = 1;
for (long long i = 2; i <= lim; ++i) {
fac[i] = fac[i - 1] * i % mod;
invfac[i] = inv(fac[i]);
}
}
inline void getans(int x, int y) {
if (x - y < 3) {
cout << fac[x] << endl;
return;
}
int pos = x - y - 1;
cout << ff[pos] * fac[x] % mod * invfac[pos + 1] % mod << endl;
}
int n, c2;
inline void solve() {
cin >> n;
pre(n);
c2 = 0;
for (int i = 1, tmp; i <= n; ++i) {
cin >> tmp;
if (tmp == 2) ++c2;
}
getans(n, c2);
}
int main() { solve(); }
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 18) + 100;
int n, a[N], lim, fa[N], g[N], h[N], size[N];
pair<int, int> f[N];
priority_queue<pair<int, int> > que;
template <class T>
inline void read(T &x) {
x = 0;
char ch = getchar(), w = 0;
while (!isdigit(ch)) w = (ch == '-'), ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
x = w ? -x : x;
return;
}
int find(int x) {
if (x < 0) return -1;
return x == fa[x] ? x : fa[x] = find(fa[x]);
}
inline pair<int, int> merge(pair<int, int> a, pair<int, int> b) {
pair<int, int> ret(-1, -1);
ret.first = max(a.first, b.first);
if (find(ret.first) != find(a.first) && a.first > ret.second)
ret.second = a.first;
if (find(ret.first) != find(a.second) && a.second > ret.second)
ret.second = a.second;
if (find(ret.first) != find(b.first) && b.first > ret.second)
ret.second = b.first;
if (find(ret.first) != find(b.second) && b.second > ret.second)
ret.second = b.second;
return ret;
}
int main() {
int x;
read(n);
long long ans = 0;
for (register int i = 1; i <= n; ++i) {
read(x), ++a[x], fa[x] = x;
while (1 << lim <= x) ++lim;
ans -= x, size[x] = 1;
}
++a[0], size[0] = 1;
for (register int i = 1; i <= lim; ++i) {
for (register int j = 0; j < 1 << lim; ++j)
f[j] = make_pair(a[j] ? j : -1, -1), g[j] = -1, h[j] = 0;
for (register int j = 0; j < lim; ++j)
for (register int k = 0; k < 1 << lim; ++k)
if (k & (1 << j)) f[k] = merge(f[k], f[k ^ (1 << j)]);
for (register int j = 0; j < 1 << lim; ++j) {
if (!a[j]) continue;
pair<int, int> w = f[j ^ ((1 << lim) - 1)];
x = find(w.first) == find(j) ? w.second : w.first;
if (h[find(j)] < j + x) h[find(j)] = j + x, g[find(j)] = x;
}
for (register int j = 0; j < 1 << lim; ++j)
if (g[j] != -1) que.emplace(h[j], j);
while (que.size()) {
int j = que.top().second;
que.pop();
if (find(j) != find(g[j])) {
long long x = size[j] == 1 ? a[j] : 1,
y = size[find(g[j])] == 1 ? a[g[j]] : 1;
ans += (x + y - 1) * h[j], fa[find(g[j])] = j,
size[j] += size[find(g[j])];
}
}
}
cout << ans << endl;
return 0;
}
| 27 |
#include <bits/stdc++.h>
using namespace std;
int h;
long long n, ans;
bool move(int height, long long &q) {
int cnt = 0;
long long tmp = q;
while (tmp) {
cnt++;
tmp >>= 1;
}
tmp = q >> (cnt - 2);
if (tmp == 2) {
q -= 1ll << cnt - 2;
return true;
} else {
q -= 1ll << cnt - 1;
return false;
}
}
void dfs(int height, long long q, bool left) {
ans++;
if (height == 1 || q == 1) return;
long long t = (1ll << height - 1) - 1;
bool l = move(height, q);
ans += (l != left) * t;
dfs(height - 1, q, !l);
}
int main() {
cin >> h >> n;
n += (1ll << h) - 1;
h++;
dfs(h, n, 1);
cout << ans - 1 << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int a, b, c, d, e, f, dummy;
cin >> dummy >> a >> b;
cin >> c >> dummy >> d;
cin >> e >> f >> dummy;
int x = (d + f) / 2;
int y = b - f + x;
int z = a + x - d;
cout << x << " " << a << " " << b << endl;
cout << c << " " << y << " " << d << endl;
cout << e << " " << f << " " << z << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) {
int n;
cin >> n;
vector<long long int> a(n);
for (long long int i = 0; i < n; i++) cin >> a[i];
int m;
cin >> m;
vector<long long int> b(m);
for (long long int i = 0; i < m; i++) cin >> b[i];
vector<long long int> c(n);
c[0] = a[0];
for (long long int i = 1; i < n; i++) {
c[i] = c[i - 1] + a[i];
}
for (long long int i = 0; i < m; i++) {
if (binary_search((c).begin(), (c).end(), b[i])) {
cout << lower_bound((c).begin(), (c).end(), b[i]) - c.begin() + 1
<< '\n';
} else {
cout << upper_bound((c).begin(), (c).end(), b[i]) - c.begin() + 1
<< '\n';
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 150005, M = 150005, LOG = 21;
template <class T>
void read(T &x) {
int sgn = 1;
char ch;
x = 0;
for (ch = getchar(); (ch < '0' || ch > '9') && ch != '-'; ch = getchar())
;
if (ch == '-') ch = getchar(), sgn = -1;
for (; '0' <= ch && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
x *= sgn;
}
template <class T>
void write(T x) {
if (x < 0)
putchar('-'), write(-x);
else if (x < 10)
putchar(x + '0');
else
write(x / 10), putchar(x % 10 + '0');
}
struct edge {
int to, nxt;
} tree[N << 1];
int n, m, k, s[M], t[M], w[M], head[N], cnt = 0;
void addedge(int u, int v) {
edge e = {v, head[u]};
tree[head[u] = cnt++] = e;
}
int euler[N << 1], id[N], dep[N << 1], Log2[N << 1], rmq[N << 1][LOG], tot = 0;
void dfs1(int u, int fa) {
id[u] = tot, euler[tot++] = u;
for (int i = head[u]; ~i; i = tree[i].nxt) {
int v = tree[i].to;
if (v != fa) {
dep[v] = dep[u] + 1;
dfs1(v, u);
euler[tot++] = u;
}
}
}
void init() {
Log2[1] = 0;
for (int i = 2; i <= tot; i++) Log2[i] = Log2[i >> 1] + 1;
for (int i = 0; i < tot; i++) rmq[i][0] = euler[i];
for (int i = 0; i < tot; i++) {
for (int j = 1; (1 << j) <= i + 1; j++) {
if (dep[rmq[i][j - 1]] <= dep[rmq[i - (1 << (j - 1))][j - 1]])
rmq[i][j] = rmq[i][j - 1];
else
rmq[i][j] = rmq[i - (1 << (j - 1))][j - 1];
}
}
}
int lca(int u, int v) {
int l = id[u], r = id[v];
if (l > r) swap(l, r);
int label = Log2[r - l + 1];
if (dep[rmq[r][label]] <= dep[rmq[l + (1 << label) - 1][label]])
return rmq[r][label];
else
return rmq[l + (1 << label) - 1][label];
}
long long ans = 0ll;
int key[M << 1], sz[M << 1], ch1[M << 1][2], rt1[N];
vector<int> vec[N];
int merge1(int u, int v) {
if (!u) return v;
if (!v) return u;
if (key[u] < key[v]) swap(u, v);
ch1[u][1] = merge1(ch1[u][1], v);
swap(ch1[u][0], ch1[u][1]);
sz[u] = sz[ch1[u][0]] + sz[ch1[u][1]] + 1;
return u;
}
int pop(int u) { return merge1(ch1[u][0], ch1[u][1]); }
void dfs2(int u, int fa) {
rt1[u] = 0;
for (int i = 0; i < vec[u].size(); i++) {
if (dep[w[vec[u][i] >> 1]] <= dep[u] - k) {
ans += sz[rt1[u]], rt1[u] = merge1(rt1[u], vec[u][i]);
}
}
for (int i = head[u]; ~i; i = tree[i].nxt) {
int v = tree[i].to;
if (v != fa) {
dfs2(v, u);
while (rt1[v] && key[rt1[v]] > dep[u] - k) rt1[v] = pop(rt1[v]);
ans += 1ll * sz[rt1[u]] * sz[rt1[v]], rt1[u] = merge1(rt1[u], rt1[v]);
}
}
}
vector<int> node_list[N], route_list[N], vtree[N];
int mn_dep[N << 3], stk[N], top = 0;
bool cmp(int u, int v) { return id[u] < id[v]; }
void build(int l, int r, int now) {
int mid = l + r >> 1;
if (l == r)
mn_dep[now] = dep[euler[mid]];
else {
build(l, mid, now << 1), build(mid + 1, r, now << 1 | 1);
mn_dep[now] = min(mn_dep[now << 1], mn_dep[now << 1 | 1]);
}
}
int sgt[M * LOG * 2], ch2[M * LOG * 2][2], rt2[N], tim = 0;
int get_l(int l, int r, int now1, int now2, int val) {
int mid = l + r >> 1;
if (l == r)
return mn_dep[now1] >= val ? sgt[now2] : 0;
else if (mn_dep[now1 << 1 | 1] >= val)
return get_l(l, mid, now1 << 1, ch2[now2][0], val) + sgt[ch2[now2][1]];
else
return get_l(mid + 1, r, now1 << 1 | 1, ch2[now2][1], val);
}
int get_r(int l, int r, int now1, int now2, int val) {
int mid = l + r >> 1;
if (l == r)
return mn_dep[now1] >= val ? sgt[now2] : 0;
else if (mn_dep[now1 << 1] >= val)
return get_r(mid + 1, r, now1 << 1 | 1, ch2[now2][1], val) +
sgt[ch2[now2][0]];
else
return get_r(l, mid, now1 << 1, ch2[now2][0], val);
}
struct info {
int u;
pair<int, int> pi, pi1, pi2;
};
pair<int, int> get_info(int l, int r, int now1, int now2, int val) {
return make_pair(get_l(l, r, now1, now2, val), get_r(l, r, now1, now2, val));
}
int newsgt(int pos, int l, int r) {
int rt = ++tim, mid = l + r >> 1;
sgt[rt] = 1, ch2[rt][0] = ch2[rt][1] = 0;
if (l < r) {
if (pos <= mid)
ch2[rt][0] = newsgt(pos, l, mid);
else
ch2[rt][1] = newsgt(pos, mid + 1, r);
}
return rt;
}
info merge2(int l, int r, int now, int u, int v, int val, int sgn) {
info res;
if (!u) {
res.u = v, res.pi.second = sgt[v];
if (v) res.pi2 = get_info(l, r, now, v, val);
return res;
}
if (!v) {
res.u = u, res.pi.first = sgt[u];
if (u) res.pi1 = get_info(l, r, now, u, val);
return res;
}
int mid = l + r >> 1;
if (l < r) {
info lch = merge2(l, mid, now << 1, ch2[u][0], ch2[v][0], val, sgn);
info rch = merge2(mid + 1, r, now << 1 | 1, ch2[u][1], ch2[v][1], val, sgn);
res.u = u;
res.pi =
make_pair(lch.pi.first + rch.pi.first, lch.pi.second + rch.pi.second);
res.pi1.first = mn_dep[now << 1 | 1] >= val ? lch.pi1.first + rch.pi.first
: rch.pi1.first;
res.pi1.second = mn_dep[now << 1] >= val ? rch.pi1.second + lch.pi.first
: lch.pi1.second;
res.pi2.first = mn_dep[now << 1 | 1] >= val ? lch.pi2.first + rch.pi.second
: rch.pi2.first;
res.pi2.second = mn_dep[now << 1] >= val ? rch.pi2.second + lch.pi.second
: lch.pi2.second;
ch2[u][0] = lch.u, ch2[u][1] = rch.u, sgt[u] += sgt[v];
ans += 1ll * sgn * lch.pi1.first * rch.pi2.second +
1ll * sgn * lch.pi2.first * rch.pi1.second;
return res;
} else {
if (mn_dep[now] >= val) {
ans += 1ll * sgn * sgt[u] * sgt[v];
res.pi1.first = res.pi1.second = sgt[u];
res.pi2.first = res.pi2.second = sgt[v];
}
res.u = u, res.pi = make_pair(sgt[u], sgt[v]), sgt[u] += sgt[v];
return res;
}
}
void build_info(int rt) {
node_list[rt].push_back(1);
sort(node_list[rt].begin(), node_list[rt].end(), cmp),
sgt[0] = ch2[0][0] = ch2[0][1] = 0;
int tmp = unique(node_list[rt].begin(), node_list[rt].end()) -
node_list[rt].begin();
node_list[rt].resize(tmp);
for (int i = 0; i < route_list[rt].size(); i++) {
int j = route_list[rt][i];
vec[s[j]].push_back(j << 1), vec[t[j]].push_back(j << 1 | 1);
}
vector<int> extend_list = node_list[rt];
stk[top = 1] = 1;
for (int i = 0; i < node_list[rt].size(); i++) {
int u = node_list[rt][i], v = lca(u, stk[top]);
while (top > 1 && id[stk[top - 1]] >= id[v]) {
vtree[stk[top - 1]].push_back(stk[top]);
top--;
}
if (stk[top] != v) vtree[v].push_back(stk[top]), stk[top] = v;
if (v != u) stk[++top] = u;
extend_list.push_back(v);
}
while (top > 1) vtree[stk[top - 1]].push_back(stk[top]), top--;
node_list[rt] = extend_list;
}
int f[N];
void dfs3(int u, int rt) {
rt2[u] = f[u] = 0;
for (int i = 0; i < vec[u].size(); i++) {
if (dep[u] - dep[rt] >= k) ans -= f[u]++;
int v = vec[u][i] & 1 ? s[vec[u][i] >> 1] : t[vec[u][i] >> 1];
if (u != rt)
rt2[u] = merge2(0, tot - 1, 1, rt2[u], newsgt(id[v], 0, tot - 1),
k - dep[u] + dep[rt] * 2, 1)
.u;
}
for (int i = 0; i < vtree[u].size(); i++) {
int v = vtree[u][i];
dfs3(v, rt);
if (dep[u] - dep[rt] >= k) ans -= 1ll * f[u] * f[v];
f[u] += f[v];
if (u != rt)
rt2[u] =
merge2(0, tot - 1, 1, rt2[u], rt2[v], k - dep[u] + dep[rt] * 2, 1).u;
}
}
void dfs4(int u, int rt) {
rt2[u] = 0;
for (int i = 0; i < vec[u].size(); i++) {
int v = vec[u][i] & 1 ? s[vec[u][i] >> 1] : t[vec[u][i] >> 1];
if (u != rt && id[v] < id[u]) {
rt2[u] = merge2(0, tot - 1, 1, rt2[u], newsgt(id[v], 0, tot - 1),
max(dep[rt] + 1, k - dep[u] + dep[rt] * 2), -1)
.u;
}
}
for (int i = 0; i < vtree[u].size(); i++) {
int v = vtree[u][i];
dfs4(v, rt);
if (u != rt)
rt2[u] = merge2(0, tot - 1, 1, rt2[u], rt2[v],
max(dep[rt] + 1, k - dep[u] + dep[rt] * 2), -1)
.u;
}
}
void clear_info(int rt) {
for (int i = 0; i < node_list[rt].size(); i++) {
int u = node_list[rt][i];
vec[u].clear();
vtree[u].clear();
}
route_list[rt].clear(), node_list[rt].clear();
}
int main() {
read(n), read(m), read(k);
for (int i = 1; i <= n; i++) head[i] = -1;
for (int i = 1; i < n; i++) {
int u, v;
read(u), read(v);
addedge(u, v), addedge(v, u);
}
for (int i = 1; i <= m; i++) {
read(s[i]), read(t[i]);
sz[i << 1] = sz[i << 1 | 1] = 1;
ch1[i << 1][0] = ch1[i << 1][1] = 0;
ch1[i << 1 | 1][0] = ch1[i << 1 | 1][1] = 0;
}
dep[1] = 0, dfs1(1, 0), init();
for (int i = 1; i <= m; i++) {
w[i] = lca(s[i], t[i]);
key[i << 1] = key[i << 1 | 1] = dep[w[i]];
vec[s[i]].push_back(i << 1);
vec[t[i]].push_back(i << 1 | 1);
}
sz[0] = 0, dfs2(1, 0);
for (int i = 1; i <= m; i++) {
node_list[w[i]].push_back(s[i]);
node_list[w[i]].push_back(t[i]);
route_list[w[i]].push_back(i);
}
for (int i = 1; i <= n; i++) vec[i].clear();
build(0, tot - 1, 1);
for (int i = 1; i <= n; i++) {
build_info(i);
tim = 0, dfs3(i, i);
tim = 0, dfs4(i, i);
clear_info(i);
}
write(ans), putchar('\n');
return 0;
}
| 27 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
int a, b, c;
cin >> n >> a >> b >> c;
n *= 2;
long long ans = 0;
for (int i = 0; i <= a; i++) {
for (int j = 0; j <= b; j++) {
int nn = n - i * 1 - j * 2;
if (nn < 0) continue;
if (nn % 4 == 0) {
if (nn / 4 <= c) ans++;
}
}
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, k, cnt, bo[130];
char nam[110], s[110], ans[11000];
bool check() {
int maxx = 0, len = strlen(nam), jilu = 0;
cnt = -1;
char ch;
memset(bo, 0, sizeof(bo));
bo[(int)nam[0]] = false;
for (int i = 1; i <= len - 1; i++) {
if (nam[i] == nam[i - 1]) jilu++;
bo[(int)nam[i]] = 1;
if ((int)nam[i] > maxx) maxx = (int)nam[i];
}
if (maxx - 97 + 1 > k) return false;
ch = nam[0];
for (int i = 97; i <= 97 + k - 1; i++)
if (!bo[i]) {
ch = (char)i;
break;
}
if (jilu == len - 1) {
int t = nam[0] - 'a' + 1;
if (t == k)
ch = char(97 + t - 2);
else
ch = char(97 + t);
}
int kk = 0, len2 = strlen(s);
jilu = 0;
while (s[kk] != '1') ans[kk] = ch, kk++, cnt++;
for (int i = kk; i <= len2 - 1; i++) {
if (s[i] == '1' && cnt < i) {
for (int j = 0; j <= len - 1; j++) ans[++cnt] = nam[j];
} else if (s[i] == '1' && cnt >= i) {
if (cnt - i + 1 >= len) {
for (int j = 0; j <= len - 1; j++)
if (nam[j] != ans[i + j]) return false;
} else {
for (int j = 0; j <= len - 1; j++) {
if (i + j <= cnt) {
if (ans[i + j] != nam[j]) return false;
} else
ans[++cnt] = nam[j];
}
}
} else if (s[i] == '0' && cnt < i) {
jilu++;
ans[++cnt] = ch;
}
if (cnt > n) return false;
}
if (k == 1 && jilu != 0) return false;
for (int i = 0; i <= len2 - 1; i++)
if (s[i] == '0') {
if (cnt - i + 1 < len) break;
bool bo = false;
for (int j = 0; j <= len - 1; j++)
if (ans[i + j] != nam[j]) {
bo = true;
break;
}
if (!bo) return false;
}
if (cnt < n)
for (int i = cnt + 1; i <= n; i++) ans[++cnt] = ch;
return true;
}
int main() {
while (scanf("%d%d", &n, &k) != EOF) {
scanf("%s", nam);
n--;
scanf("%s", s);
if (!check())
printf("No solution\n");
else {
for (int i = 0; i <= n; i++) printf("%c", ans[i]);
printf("\n");
}
}
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const double PI = acos(-1.0);
const double EPS = 1e-6;
struct Point {
LL x, y;
};
struct Vec {
LL x, y;
double rad;
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<Point> x(n);
for (int i = 0; i < n; ++i) cin >> x[i].x >> x[i].y;
LL ans = 1LL * n * (n - 1) * (n - 2) * (n - 3) * (n - 4) / 24;
for (int i = 0; i < n; ++i) {
vector<Vec> rad;
for (int j = 0; j < n; ++j) {
if (i == j) continue;
Vec v{x[j].x - x[i].x, x[j].y - x[i].y};
v.rad = atan2(v.y, v.x);
rad.push_back(v);
v.rad += 2 * PI;
rad.push_back(v);
}
sort(rad.begin(), rad.end(), [](const Vec& a, const Vec& b) {
if (abs(a.rad - b.rad) > EPS) return a.rad < b.rad;
return a.x * b.y - a.y * b.x > 0;
});
int r = 0;
LL temp = 0;
for (int l = 0; l < n - 1; ++l) {
while (rad[r].rad < rad[l].rad + PI - EPS) ++r;
while (rad[l].x * rad[r].y - rad[r].x * rad[l].y > 0) ++r;
int a = r - l - 1;
if (a < 3) continue;
temp += 1LL * a * (a - 1) * (a - 2) / 6;
}
ans -= temp;
}
cout << ans << endl;
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, l, r;
cin >> n >> a >> b;
int ans[n + 1];
for (int i = 1; i <= n; i++) ans[i] = 2;
for (int i = 0; i < a; i++) {
cin >> r;
ans[r] = 1;
}
for (int i = 0; i < b; i++) cin >> l;
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 200000;
struct Res {
int len1, a1, common2, len2, a2, b2, common3, len3, a3, b3, c3, common4, len4,
a4, b4, c4, d4;
Res() { len1 = common2 = len2 = common3 = len3 = common4 = len4 = 0; }
};
int n;
vector<int> adj[MAXN];
void upd4(Res &res, int common, int len, int a, int b, int c, int d) {
if (common < res.common4 || common == res.common4 && len <= res.len4) return;
res.common4 = common, res.len4 = len, res.a4 = a, res.b4 = b, res.c4 = c,
res.d4 = d;
}
void upd3(Res &res, int common, int len, int a, int b, int c) {
if (common < res.common3 || common == res.common3 && len <= res.len3) return;
res.common3 = common, res.len3 = len, res.a3 = a, res.b3 = b, res.c3 = c;
}
void upd2(Res &res, int common, int len, int a, int b) {
if (common < res.common2 || common == res.common2 && len <= res.len2) return;
res.common2 = common, res.len2 = len, res.a2 = a, res.b2 = b;
}
void upd1(Res &res, int len, int a) {
if (len <= res.len1) return;
res.len1 = len, res.a1 = a;
}
Res dfs(int at, int par) {
Res ret;
upd1(ret, 1, at);
for (int i = (0); i < (((int)(adj[at]).size())); ++i) {
int to = adj[at][i];
if (to == par) continue;
Res cur = dfs(to, at);
if (cur.len4 > 0)
upd4(ret, cur.common4, cur.len4, cur.a4, cur.b4, cur.c4, cur.d4);
if (ret.len2 > 0 && cur.len2 > 0)
upd4(ret, ret.common2 + cur.common2, ret.len2 + cur.len2, ret.a2, ret.b2,
cur.a2, cur.b2);
if (ret.len3 > 0)
upd4(ret, ret.common3, ret.len3 + cur.len1, ret.a3, ret.b3, ret.c3,
cur.a1);
if (cur.len3 > 0)
upd4(ret, cur.common3, cur.len3 + ret.len1, cur.a3, cur.b3, cur.c3,
ret.a1);
if (cur.len3 > 0)
upd3(ret, cur.common3, cur.len3 + 1, cur.a3, cur.b3, cur.c3);
if (cur.len2 > 0 && ret.len1 > 1)
upd3(ret, cur.common2 + 1, cur.len2 + 1 + ret.len1, cur.a2, cur.b2,
ret.a1);
if (ret.len2 > 0)
upd3(ret, ret.common2, ret.len2 + cur.len1, ret.a2, ret.b2, cur.a1);
if (cur.len2 > 0) upd2(ret, cur.common2 + 1, cur.len2 + 2, cur.a2, cur.b2);
if (ret.len1 > 1) upd2(ret, 1, cur.len1 + 1 + ret.len1, cur.a1, ret.a1);
upd1(ret, cur.len1 + 1, cur.a1);
}
return ret;
}
Res solve() { return dfs(0, -1); }
void run() {
scanf("%d", &n);
for (int i = (0); i < (n - 1); ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a, --b;
adj[a].push_back(b);
adj[b].push_back(a);
}
Res ans = solve();
printf("%d %d\n", ans.a4 + 1, ans.c4 + 1);
printf("%d %d\n", ans.b4 + 1, ans.d4 + 1);
}
int main() {
run();
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int sqrt_ceil(int n) {
int temp = int(sqrt(n));
while (temp * temp < n) temp++;
return temp;
}
int main() {
int a, b;
cin >> a >> b;
bool found = false;
for (int x_1 = 1; x_1 < a; x_1++) {
int y_1 = sqrt_ceil(a * a - x_1 * x_1);
if (x_1 * x_1 + y_1 * y_1 == a * a && (x_1 * b) % a == 0 &&
(y_1 * b) % a == 0) {
int x_2 = -(y_1 * b) / a;
int y_2 = (x_1 * b) / a;
if (y_1 != y_2) {
cout << "YES\n";
cout << "0 0\n";
cout << x_1 << ' ' << y_1 << '\n';
cout << x_2 << ' ' << y_2;
found = true;
break;
}
}
}
if (!found) cout << "NO";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s;
cin >> n >> s;
if (s == "0") {
cout << "0\n";
return 0;
}
int cnt1 = 0;
for (int i = 0; i < s.length(); ++i) {
if (s[i] == '1') cnt1++;
}
int cnt0 = n - cnt1;
cout << 1;
for (int i = 1; i <= cnt0; ++i) cout << 0;
cout << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void freac() {}
const int DX[] = {+1, 0, -1, 0, +1, +1, -1, -1};
const int DY[] = {0, +1, 0, -1, +1, -1, +1, -1};
const int INF = (int)1e9 + 123;
const long long INFL = (long long)1e18 + 123;
const double EPS = 1e-9;
int main() {
freac();
ios_base ::sync_with_stdio(0);
cin.tie(NULL);
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long sum = 0;
for (int i = 0; i < n; i++)
sum = (sum + (long long)a[i] * a[n - 1 - i]) % 10007;
cout << sum << endl;
return false;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> p[110000];
int N;
long long rmax[110000], rmin[110000], bmax[110000], bmin[110000];
bool possible(long long d) {
int i, j;
long long ma, mi;
for (i = 0; i < N; i++) {
j = upper_bound(p, p + N,
pair<long long, long long>(p[i].first + d, 3000000000LL)) -
p;
ma = -3000000000LL;
mi = 3000000000LL;
if (i) ma = max(ma, rmax[i - 1]), mi = min(mi, rmin[i - 1]);
if (j < N) ma = max(ma, bmax[j]), mi = min(mi, bmin[j]);
if (ma - mi <= d) return true;
}
return false;
}
int main() {
int i, a, b;
long long high, low, mid;
scanf("%d", &N);
for (i = 0; i < N; i++) {
scanf("%d%d", &a, &b);
p[i] = pair<long long, long long>(a + b, a - b);
}
sort(p, p + N);
rmax[0] = rmin[0] = p[0].second;
for (i = 1; i < N; i++) {
rmax[i] = max(rmax[i - 1], p[i].second);
rmin[i] = min(rmin[i - 1], p[i].second);
}
bmax[N - 1] = bmin[N - 1] = p[N - 1].second;
for (i = N - 2; i >= 0; i--) {
bmax[i] = max(bmax[i + 1], p[i].second);
bmin[i] = min(bmin[i + 1], p[i].second);
}
high = 3000000000LL;
low = 0;
while (high > low + 1) {
mid = (high + low) / 2;
if (possible(mid))
high = mid;
else
low = mid;
}
if (possible(low))
printf("%lf\n", low / 2.0);
else
printf("%lf\n", high / 2.0);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
string number;
cin >> number;
long long count = 0;
if (number[0] % 4 == 0) {
count++;
}
for (unsigned i = 1; i < number.length(); i++) {
if (number[i] % 4 == 0) {
count++;
}
string str = number.substr(i - 1, 2);
int test = stoi(str);
if (test % 4 == 0) {
count += i;
}
}
cout << count;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const long long SIZE = 100000;
const int INF = 0x3f3f3f3f;
const long long ll_INF = 0x3f3f3f3f3f3f3f3f;
const long double PI = acos(-1);
const long long MAXN = numeric_limits<long long>::max();
const long long MAX = 2000000;
void solve() {
string s, t;
cin >> s >> t;
long long n = s.size();
long long dis = 0;
for (long long i = 0; i < n; i++) {
if (s[i] != t[i]) dis++;
}
if (dis % 2 != 0)
cout << "impossible" << endl;
else {
long long num = dis / 2;
long long a[n], b[n];
for (long long i = 0; i < n; i++) a[i] = s[i] - '0';
for (long long i = 0; i < n; i++) b[i] = t[i] - '0';
long long d = 0;
for (long long i = 0; i < n; i++) {
if (a[i] != b[i] && d != num) {
if (a[i] == 1)
a[i] = 0;
else
a[i] = 1;
d++;
}
if (d == num) break;
}
for (long long i = 0; i < n; i++) cout << a[i];
}
}
int main() {
std::ios::sync_with_stdio(false);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, i, x, d, h, y = 2, val = -1, ans = 0;
cin >> n >> d >> h;
x = d - h;
if (d > 2 * h || (d == h && h == 1 && n > 2)) {
cout << -1 << "\n";
return 0;
}
while (h--) {
cout << y - 1 << " " << y;
cout << "\n";
y++;
}
for (i = 0; i < x; i++) {
if (i == 0) {
d = 1;
cout << 1 << " " << y << "\n";
} else {
cout << y - 1 << " " << y << "\n";
d = y - 1;
}
y++;
}
for (i = y; i <= n; i++) cout << d << " " << i << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct cnt {
string cn;
int pn, gs, gm;
int nm;
} cc[4];
bool myop(const cnt &c1, const cnt &c2) {
if (c1.pn != c2.pn) return (c1.pn > c2.pn);
int gd1 = c1.gs - c1.gm, gd2 = c2.gs - c2.gm;
if (gd1 != gd2) return (gd1 > gd2);
if (c1.gs != c2.gs) return (c1.gs > c2.gs);
return (c1.cn.compare(c2.cn) < 0);
}
int nc, s[2], mgs, mgm;
string ln, c[2], ot;
stringstream ss;
char buf;
bool am[2];
int main(int argc, char const *argv[]) {
nc = 0;
mgs = mgm = -1;
for (int i = 0; i < 5; i++) {
getline(cin, ln);
ss.clear();
ss.str(ln);
ss >> c[0] >> c[1] >> s[0] >> buf >> s[1];
am[0] = am[1] = false;
for (int j = 0; j < nc; j++)
for (int k = 0; k < 2; k++)
if (!cc[j].cn.compare(c[k])) {
if (s[k] > s[1 - k]) cc[j].pn += 3;
if (s[k] == s[1 - k]) cc[j].pn += 1;
cc[j].gs += s[k];
cc[j].gm += s[1 - k];
cc[j].nm++;
am[k] = true;
}
for (int j = 0; j < 2; j++)
if (!am[j]) {
cc[nc].cn = c[j];
if (s[j] > s[1 - j]) cc[nc].pn = 3;
if (s[j] == s[1 - j]) cc[nc].pn = 1;
if (s[j] < s[1 - j]) cc[nc].pn = 0;
cc[nc].gs = s[j];
cc[nc].gm = s[1 - j];
cc[nc].nm = 1;
nc++;
}
}
for (int i = 0; i < 4; i++)
if (!cc[i].cn.compare("BERLAND"))
cc[i].pn += 3;
else if (cc[i].nm == 2)
ot = cc[i].cn;
for (int ngd = 1; ngd <= 30 && mgs == -1; ngd++) {
for (int ngm = 0; ngm <= 30 && mgs == -1; ngm++) {
for (int i = 0; i < 4; i++) {
if (!cc[i].cn.compare("BERLAND")) {
cc[i].gs += ngm + ngd;
cc[i].gm += ngm;
}
if (!cc[i].cn.compare(ot)) {
cc[i].gs += ngm;
cc[i].gm += ngm + ngd;
}
}
sort(cc, cc + 4, myop);
for (int i = 0; i < 4; i++) {
if (!cc[i].cn.compare("BERLAND")) {
cc[i].gs -= ngm + ngd;
cc[i].gm -= ngm;
}
if (!cc[i].cn.compare(ot)) {
cc[i].gs -= ngm;
cc[i].gm -= ngm + ngd;
}
}
if (!cc[0].cn.compare("BERLAND") || !cc[1].cn.compare("BERLAND")) {
mgs = ngm + ngd;
mgm = ngm;
}
}
}
if (-1 == mgs)
cout << "IMPOSSIBLE" << endl;
else
cout << mgs << ":" << mgm << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using pli = pair<ll, int>;
using pil = pair<int, ll>;
using pll = pair<ll, ll>;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
auto solve = [&]() {
int N, M;
cin >> N >> M;
vector<tuple<int, int, int>> events;
for (int i = 0; i < M; i++) {
int p, l, r;
cin >> p >> l >> r;
p--, r++;
events.emplace_back(l, 1, p);
events.emplace_back(r, 0, p);
}
sort(events.begin(), events.end());
map<int, int> cnt;
vector<pii> edges;
for (auto [x, op, i] : events) {
if (op == 1) {
auto it = cnt.lower_bound(i);
if (it == cnt.end() || it->first != i) {
if (it != cnt.begin()) {
edges.emplace_back(prev(it)->first, i);
}
if (it != cnt.end()) {
edges.emplace_back(i, it->first);
}
}
cnt[i]++;
} else {
auto it = cnt.find(i);
it->second--;
if (it != cnt.begin() && next(it) != cnt.end()) {
edges.emplace_back(prev(it)->first, next(it)->first);
}
if (it->second == 0) {
cnt.erase(it);
}
}
}
sort(edges.begin(), edges.end());
vector<int> dp(N, 1), p(N, -1);
for (auto [u, v] : edges) {
if (dp[v] < dp[u] + 1) {
dp[v] = dp[u] + 1;
p[v] = u;
}
}
vector<int> keep(N);
int pnt = max_element(dp.begin(), dp.end()) - dp.begin();
while (pnt >= 0) {
keep[pnt] = 1;
pnt = p[pnt];
}
vector<int> seq;
for (int i = 0; i < N; i++) {
if (!keep[i]) {
seq.push_back(i);
}
}
cout << int(seq.size()) << '\n';
;
for (int i = 0; i < int(seq.size()); i++) {
cout << seq[i] + 1 << " \n"[i == int(seq.size()) - 1];
}
};
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
char s[200000];
long long al[27];
long long nu[15];
int main() {
scanf("%s", s);
int len = strlen(s);
memset(nu, 0, sizeof(nu));
memset(al, 0, sizeof(al));
for (int i = 0; i < len; i++) {
if (s[i] >= 'a' && s[i] <= 'z') {
al[s[i] - 'a']++;
} else {
nu[s[i] - '0']++;
}
}
long long sum = 0;
for (int i = 0; i < 26; i++) {
sum += al[i] * al[i];
}
for (int i = 0; i < 10; i++) {
sum += nu[i] * nu[i];
}
printf("%I64d\n", sum);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int mat[105][105];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &mat[i][j]);
int k = 2;
while (n % k == 0) {
int flag = 1;
for (int j = 1; j <= m; j++)
for (int i = 1; i <= n / k; i++)
if (mat[i][j] != mat[2 * n / k - i + 1][j]) {
flag = 0;
break;
}
if (!flag) break;
k *= 2;
}
k /= 2;
printf("%d\n", n / k);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
stack<time_t> time_stack;
void startTimer() { time_stack.push(clock()); }
double stopTimer() {
double time = clock() - time_stack.top();
time_stack.pop();
return time / double(CLOCKS_PER_SEC);
}
double sqr(double x) { return x * x; }
set<int> solve(vector<int> a, vector<int> b) {
int n = a.size() / 2;
set<int> ans;
int l = 0, r = 0;
long long sum = 0;
while (l < n && r < 2 * n) {
sum += a[r] - b[r];
if (sum < 0) {
sum = 0;
l = r + 1;
} else if (r - l == n - 1) {
ans.insert(l);
do {
sum -= a[l] - b[l];
l++;
} while (sum < 0);
}
r++;
}
return ans;
}
int main() {
startTimer();
ios::sync_with_stdio(false);
string TASK = "immediate";
cout.precision(9);
cout << fixed;
int n;
cin >> n;
vector<int> a(2 * n), b(2 * n);
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i + n] = a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
b[i + n] = b[i];
}
set<int> ans = solve(a, b);
vector<int> tmp(2 * n);
tmp[0] = a[0];
for (int i = n - 1; i > 0; i--) tmp[n - i] = a[i];
a = tmp;
for (int i = 0; i < n; i++) a[i + n] = a[i];
reverse(b.begin(), b.end());
set<int> ans1 = solve(a, b);
for (auto it : ans1) {
if (it == 0)
ans.insert(it);
else
ans.insert(n - it);
}
cout << ans.size() << endl;
for (auto it : ans) cout << it + 1 << " ";
cout << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int pre[int(2e5) + 10], num[(int(2e5)) + 10];
int main() {
istream& in = cin;
in >> n >> k;
int p = n - 1 - k;
if (p == 0) {
cout << 2 << endl;
for (int i = 2; i <= n; ++i) cout << 1 << " " << i << endl;
} else {
if (p == 1) {
cout << 3 << endl;
cout << 1 << " " << 2 << endl;
for (int i = 3; i <= n; ++i) {
if (i % 2 == 0) {
cout << 1 << " " << i << endl;
} else {
cout << 2 << " " << i << endl;
}
}
} else {
if (p <= k) {
cout << 4 << endl;
for (int i = 2; i < 2 + p; ++i) {
cout << 1 << " " << i << endl;
}
for (int i = 1; i <= p; ++i) {
cout << i + 1 << " " << 1 + p + i << endl;
}
for (int i = 2 + p + p; i <= n; ++i) cout << 1 << " " << i << endl;
} else {
int x = p / k;
int y = p % k;
if (y == 0) {
cout << 2 * x + 2 << endl;
} else if (y == 1) {
cout << x + x + 3 << endl;
} else {
cout << x + x + 4 << endl;
}
for (int i = 1; i <= k; ++i) {
pre[i] = n;
}
for (int i = n - 1; i > k; --i) {
int d = (i % k) + 1;
cout << i << " " << pre[d] << endl;
pre[d] = i;
}
for (int i = 1; i <= k; ++i) cout << i << " " << pre[i] << endl;
}
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
mt19937 rnf(2106);
const int N = 200005;
int n;
int a[N];
char s[N];
pair<int, char> ans[N];
void solv() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
cin >> (s + 1);
sort(a + 1, a + n + 1);
deque<int> l, r;
for (int i = 1; i <= n; ++i) {
if (i % 2 == n % 2)
r.push_back(a[i]);
else
l.push_back(a[i]);
}
if (s[n] == 'L') swap(l, r);
for (int i = n; i > 1; --i) {
if (s[i] == 'R') {
if (s[i - 1] == 'R') {
if (i % 2 == 0) {
ans[i] = make_pair(l.front(), 'L');
l.pop_front();
} else {
ans[i] = make_pair(r.front(), 'R');
r.pop_front();
}
} else {
ans[i] = make_pair(r.back(), 'R');
r.pop_back();
}
} else {
if (s[i - 1] == 'L') {
if (i % 2 == 0) {
ans[i] = make_pair(r.front(), 'R');
r.pop_front();
} else {
ans[i] = make_pair(l.front(), 'L');
l.pop_front();
}
} else {
ans[i] = make_pair(l.back(), 'L');
l.pop_back();
}
}
}
if (!r.empty())
ans[1] = make_pair(r.back(), 'R');
else if (!l.empty())
ans[1] = make_pair(l.back(), 'L');
else
assert(false);
for (int i = 1; i <= n; ++i)
cout << ans[i].first << ' ' << ans[i].second << "\n";
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0);
int tt = 1;
while (tt--) solv();
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a[100010];
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
int c2;
c2 = n - k;
if (c2 < 0) {
c2 = 0;
}
int ans = 0;
for (int i = 0; i < c2; ++i) {
ans = max(ans, a[i] + a[c2 * 2 - i - 1]);
}
for (int i = c2 * 2; i < n; ++i) {
ans = max(ans, a[i]);
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (~scanf("%d", &n)) {
printf("%d\n", 2 * n - n / 2);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int MAXN = 1e5 + 5;
const int MAXV = 1e7 + 5;
int n, q, qn, a[MAXN];
int hd[MAXN], nxt[MAXN << 1], to[MAXN << 1], ec = 0;
void adde(int u, int v) {
to[++ec] = v;
nxt[ec] = hd[u];
hd[u] = ec;
}
int fa[MAXN][22], dep[MAXN];
void dfs(int x, int f) {
fa[x][0] = f;
for (int e = hd[x]; e; e = nxt[e]) {
int y = to[e];
if (y == f) continue;
dep[y] = dep[x] + 1;
dfs(y, x);
}
}
int getlca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 20; ~i; i--)
if (dep[x] - (1 << i) >= dep[y]) x = fa[x][i];
if (x == y) return x;
for (int i = 20; ~i; i--)
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
return fa[x][0];
}
vector<pair<int, int> > fac[MAXN];
struct Query {
int w, x, id, mul;
} qu[MAXN << 2];
int qpow(int x, int e) {
int ret = 1;
while (e) {
if (e & 1) ret = 1ll * ret * x % MOD;
x = 1ll * x * x % MOD;
e >>= 1;
}
return ret;
}
int ans[MAXN];
int sum[MAXV / 5][24];
vector<int> qv[MAXN];
int pid[MAXV], pr[MAXV / 5], pcnt = 0;
bitset<MAXV> vis;
void prework() {
for (int i = 2; i < MAXV; i++) {
if (!vis[i]) {
pr[++pcnt] = i;
pid[i] = pcnt;
}
for (int j = 1; j <= pcnt && pr[j] * i < MAXV; j++) {
vis[pr[j] * i] = 1;
if (i % pr[j] == 0) break;
}
}
}
void calc(int x) {
for (__typeof(fac[x].begin()) it = fac[x].begin(); it != fac[x].end(); it++)
sum[pid[it->first]][it->second]++;
for (__typeof(qv[x].begin()) it = qv[x].begin(); it != qv[x].end(); it++) {
int id = *it, tmp = qu[id].w;
vector<pair<int, int> > ff;
for (int i = 2; i * i <= tmp; i++) {
if (tmp % i == 0) {
int cnt = 0;
while (tmp % i == 0) tmp /= i, cnt++;
ff.push_back(make_pair(i, cnt));
}
}
if (tmp > 1) ff.push_back(make_pair(tmp, 1));
int tot_mul = 1;
for (int i = 0; i < ff.size(); i++) {
int pw = 1, val = ff[i].first;
for (int j = 1; j <= ff[i].second; j++) pw *= ff[i].first;
for (int j = 1; val < MAXV; j++, val *= ff[i].first) {
int cnt = sum[pid[ff[i].first]][j];
int mul = qpow(min(val, pw), cnt);
tot_mul = 1ll * tot_mul * mul % MOD;
}
}
if (qu[id].mul == 1)
ans[qu[id].id] = 1ll * ans[qu[id].id] * tot_mul % MOD;
else
ans[qu[id].id] = 1ll * ans[qu[id].id] * qpow(tot_mul, MOD - 2) % MOD;
}
for (int e = hd[x]; e; e = nxt[e]) {
int y = to[e];
if (y == fa[x][0]) continue;
calc(y);
}
for (__typeof(fac[x].begin()) it = fac[x].begin(); it != fac[x].end(); it++)
sum[pid[it->first]][it->second]--;
}
int main() {
prework();
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
adde(u, v);
adde(v, u);
}
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
int tmp = a[i];
for (int j = 2; j * j <= tmp; j++) {
if (tmp % j == 0) {
int cnt = 0;
while (tmp % j == 0) tmp /= j, cnt++;
fac[i].push_back(make_pair(j, cnt));
}
}
if (tmp > 1) fac[i].push_back(make_pair(tmp, 1));
}
dfs(1, 0);
for (int i = 1; i <= 20; i++)
for (int j = 1; j <= n; j++) fa[j][i] = fa[fa[j][i - 1]][i - 1];
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
ans[i] = 1;
int lca = getlca(u, v);
qu[++qn] = {w, u, i, 1};
qu[++qn] = {w, v, i, 1};
qu[++qn] = {w, lca, i, -1};
if (lca != 1) qu[++qn] = {w, fa[lca][0], i, -1};
}
for (int i = 1; i <= qn; i++) qv[qu[i].x].push_back(i);
calc(1);
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1e4 + 10;
int a[MAX_N];
int check(int p) {
int ans = 0;
for (int i = 0; i < MAX_N; i++) ans += a[i] * abs(i - p);
return ans;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, m, d;
cin >> n >> m >> d;
for (int i = 0, q; i < n * m; i++) {
int x;
cin >> x;
if (i && q - x % d)
return cout << -1 << endl, 0;
else
q = x % d;
x /= d;
a[x]++;
}
int l = 0, r = 10000;
for (int i = 0; i < 200; i++) {
int m1 = (2 * l + r) / 3, m2 = (2 * r + l) / 3;
if (check(m1) < check(m2))
r = m2;
else
l = m1;
}
cout << check((l + r) / 2) << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool ckmax(T& x, T y) {
return x < y ? x = y, 1 : 0;
}
template <class T>
bool ckmin(T& x, T y) {
return x > y ? x = y, 1 : 0;
}
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = 0;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return f ? x : -x;
}
const int N = 200005;
const int T = N << 2;
int n, m, a[N], ans;
long long y;
int miv[T], tag[T];
long long sum[T];
inline void pushup(int p) {
miv[p] = min(miv[(p << 1)], miv[(p << 1 | 1)]);
sum[p] = sum[(p << 1)] + sum[(p << 1 | 1)];
}
void build(int l = 1, int r = n, int p = 1) {
if (l == r) {
sum[p] = miv[p] = a[l];
return;
}
int mid = (l + r) >> 1;
build(l, mid, (p << 1)), build(mid + 1, r, (p << 1 | 1));
pushup(p);
}
inline void pushdown(int p, int l, int r) {
if (tag[p]) {
int mid = (l + r) >> 1;
tag[(p << 1)] = tag[p], sum[(p << 1)] = 1ll * (mid - l + 1) * tag[p],
miv[(p << 1)] = tag[p];
tag[(p << 1 | 1)] = tag[p], sum[(p << 1 | 1)] = 1ll * (r - mid) * tag[p],
miv[(p << 1 | 1)] = tag[p];
tag[p] = 0;
}
}
int solve1(int d, int l = 1, int r = n, int p = 1) {
if (l == r) return l;
int mid = (l + r) >> 1;
pushdown(p, l, r);
if (d >= miv[(p << 1)])
return solve1(d, l, mid, (p << 1));
else
return solve1(d, mid + 1, r, (p << 1 | 1));
}
void cov(int ql, int qr, int d, int l = 1, int r = n, int p = 1) {
if (ql > qr) return;
if (ql <= l && r <= qr) {
miv[p] = d, sum[p] = 1ll * d * (r - l + 1), tag[p] = d;
return;
}
pushdown(p, l, r);
int mid = (l + r) >> 1;
if (ql <= mid) cov(ql, qr, d, l, mid, (p << 1));
if (mid < qr) cov(ql, qr, d, mid + 1, r, (p << 1 | 1));
pushup(p);
}
inline long long query_sum(int ql, int qr, int l = 1, int r = n, int p = 1) {
if (ql > qr) return 0;
if (ql <= l && r <= qr) return sum[p];
pushdown(p, l, r);
int mid = (l + r) >> 1;
long long res = 0;
if (ql <= mid) res += query_sum(ql, qr, l, mid, (p << 1));
if (mid < qr) res += query_sum(ql, qr, mid + 1, r, (p << 1 | 1));
return res;
}
int CNT;
inline void solve(int l = 1, int r = n, int p = 1) {
++CNT;
if (sum[p] <= y) return y -= sum[p], ans += r - l + 1, void();
if (l == r) return;
pushdown(p, l, r);
if (miv[p] <= y) {
int mid = (l + r) >> 1;
if (miv[(p << 1)] <= y) solve(l, mid, (p << 1));
if (miv[(p << 1 | 1)] <= y) solve(mid + 1, r, (p << 1 | 1));
}
}
signed main() {
n = read(), m = read();
for (int i = 1, iend = n; i <= iend; ++i) a[i] = read();
build();
while (m--) {
int opt = read(), x = read();
y = read();
if (opt == 1)
cov(solve1(y), x, y);
else
y += query_sum(1, x - 1), ans = 0, solve(), printf("%d\n", ans - x + 1);
}
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
long long d, m;
cin >> d >> m;
long long ans = 1, i = 0;
while ((1 << i + 1) <= d) ans = (ans * (1 + (1 << i++))) % m;
ans = (ans * (1 + (d - (1 << i) + 1))) % m;
cout << (ans + m - 1) % m << '\n';
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int fun(int m, int n) {
int cnt = 0;
for (int i = 1; i * i <= m; i++) {
if (i * i == m) {
if (i > n) cnt++;
} else if (m % i == 0) {
if (i > n) cnt++;
if (m / i > n) cnt++;
}
}
return cnt;
}
int main() {
int a, b;
scanf("%d%d", &a, &b);
if (a == b) {
printf("infinity\n");
return 0;
} else if (a < b) {
printf("0\n");
return 0;
} else
printf("%d", fun(a - b, b));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const int maxn = 200000 + 10;
int col[2][maxn];
int row[2][maxn];
vector<pair<int, int> > G[maxn];
int p[2][maxn];
int co[maxn];
int vis[maxn];
stack<int> S;
int n;
int dfs(int u, int c) {
co[u] = c;
S.push(u);
for (auto e : G[u]) {
int nc = c;
if (e.second) nc = c ^ 1;
if (co[e.first] == -1) {
if (dfs(e.first, nc) == maxn) return maxn;
} else {
if (co[e.first] != nc) return maxn;
}
}
return 0;
}
inline void solve() {
map<int, int> ff;
for (auto i = (0); i < (2); ++i) {
for (auto j = (1); j <= (n); ++j) col[i][j] = -1, row[i][j] = -1;
}
for (auto i = (0); i < (2); ++i) {
for (auto j = (1); j <= (n); ++j) {
if (ff.count(p[i][j]) == 0) ff[p[i][j]] = 0;
if (++ff[p[i][j]] == 3) {
puts("-1");
return;
}
if (col[0][p[i][j]] == -1) {
col[0][p[i][j]] = j;
row[0][p[i][j]] = i;
} else {
col[1][p[i][j]] = j;
row[1][p[i][j]] = i;
}
}
}
for (auto i = (1); i <= (n); ++i) {
co[i] = -1;
if (row[0][i] == row[1][i]) {
G[col[0][i]].push_back({col[1][i], 1});
G[col[1][i]].push_back({col[0][i], 1});
} else {
G[col[0][i]].push_back({col[1][i], 0});
G[col[1][i]].push_back({col[0][i], 0});
}
}
int ans = 0;
for (; !S.empty();) S.pop();
vector<int> ops;
for (auto i = (1); i <= (n); ++i) {
if (vis[i]) continue;
pair<int, vector<int> > tmp2, tmp;
tmp.first = dfs(i, 0);
for (; !S.empty(); S.pop()) {
if (co[S.top()] == 1) tmp.second.push_back(S.top());
tmp.first += co[S.top()], co[S.top()] = -1;
}
tmp2.first = dfs(i, 1);
for (; !S.empty(); S.pop()) {
if (co[S.top()] == 1) tmp2.second.push_back(S.top());
tmp2.first += co[S.top()], vis[S.top()] = 1;
}
int cc = min(tmp.first, tmp2.first);
if (cc >= maxn) {
puts("-1");
return;
}
if (tmp.first == cc) {
for (auto e : tmp.second) ops.push_back(e);
} else {
for (auto e : tmp2.second) ops.push_back(e);
}
ans += cc;
}
printf("%d\n", ans);
for (auto e : ops) printf("%d ", e);
puts("");
}
int main(void) {
int T;
scanf("%d", &(T));
for (; T--;) {
scanf("%d", &(n));
for (auto i = (1); i <= (n); ++i) G[i].clear(), vis[i] = 0;
for (auto i = (0); i < (2); ++i)
for (auto j = (1); j <= (n); ++j) scanf("%d", &(p[i][j]));
solve();
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int N = 222222;
int a[N], f[N];
int main() {
int n, i, x, ans;
scanf("%d", &n);
for (i = 1; i <= n; i = i + 1) scanf("%d", a + i);
ans = 0;
for (i = n; i >= 1; i = i - 1) {
if (!f[i]) {
ans++;
x = i;
while (x) {
f[x] = 1;
x = a[x];
}
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int Mod = 1000000009;
int z[2][35][35][35][35], u[2][35][35][35][35];
int us, p[4], up[4], np[4];
int n, h;
int main() {
scanf("%d%d", &n, &h);
z[1][0][0][0][0] = 1;
us++;
u[1][0][0][0][0] = us;
for (int i = 1; i <= n; i++) {
int now = i % 2;
int nxt = 1 - now;
int nus = us + 1;
for (p[0] = 0; p[0] <= h; p[0]++) {
for (p[1] = p[0]; p[1] <= h; p[1]++) {
for (p[2] = p[1]; p[2] <= h; p[2]++) {
for (p[3] = p[2]; p[3] <= h; p[3]++) {
if (u[now][p[0]][p[1]][p[2]][p[3]] == us &&
z[now][p[0]][p[1]][p[2]][p[3]]) {
for (int i = 0; i < 4; i++) {
up[i] = min(h, p[i] + 1);
}
for (int i = 0; i < 4; i++) {
memcpy(np, up, sizeof(up));
if (p[i] < h) {
np[i] = 0;
for (int j = i; j > 0 && np[j] < np[j - 1]; j--) {
swap(np[j], np[j - 1]);
}
}
if (u[nxt][np[0]][np[1]][np[2]][np[3]] != nus) {
u[nxt][np[0]][np[1]][np[2]][np[3]] = nus;
z[nxt][np[0]][np[1]][np[2]][np[3]] = 0;
}
z[nxt][np[0]][np[1]][np[2]][np[3]] +=
z[now][p[0]][p[1]][p[2]][p[3]];
if (z[nxt][np[0]][np[1]][np[2]][np[3]] >= Mod) {
z[nxt][np[0]][np[1]][np[2]][np[3]] -= Mod;
}
}
}
}
}
}
}
us++;
}
int ans = 0;
int now = (n + 1) % 2;
for (p[0] = 0; p[0] < h; p[0]++) {
for (p[1] = p[0]; p[1] <= h; p[1]++) {
for (p[2] = p[1]; p[2] <= h; p[2]++) {
for (p[3] = p[2]; p[3] <= h; p[3]++) {
if (u[now][p[0]][p[1]][p[2]][p[3]] == us) {
ans += z[now][p[0]][p[1]][p[2]][p[3]];
ans %= Mod;
}
}
}
}
}
printf("%d\n", ans);
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e6, big = 1e18;
long long val[maxn], t[4 * maxn + 5], sum[4 * maxn + 5];
void build(long long v, long long l, long long r) {
if (l == r - 1) {
sum[v] = 0;
t[v] = val[l];
return;
}
long long m = (l + r) / 2;
build(2 * v, l, m);
build(2 * v + 1, m, r);
t[v] = max(t[2 * v], t[2 * v + 1]);
sum[v] = 0;
}
void upd(long long v, long long l, long long r, long long tl, long long tr,
long long c) {
if (tr <= l || tl >= r) return;
if (tl >= l && tr <= r) {
sum[v] += c;
return;
}
long long tm = (tl + tr) / 2;
upd(2 * v, l, r, tl, tm, c);
upd(2 * v + 1, l, r, tm, tr, c);
t[v] = max(t[2 * v] + sum[2 * v], t[2 * v + 1] + sum[2 * v + 1]);
}
long long get(long long v, long long l, long long r, long long tl,
long long tr) {
if (tr <= l || tl >= r) return -big;
if (tl >= l && tr <= r) return t[v] + sum[v];
long long tm = (tl + tr) / 2;
return max(get(2 * v, l, r, tl, tm), get(2 * v + 1, l, r, tm, tr)) + sum[v];
}
void solve() {
long long n, m;
cin >> n >> m;
long long a[n], b[m];
for (long long i = 0; i < n; ++i) cin >> a[i];
for (long long i = 0; i < m; ++i) cin >> b[i];
for (long long i = 0; i < maxn; ++i) val[i] = 0;
build(1, 0, 1e6);
for (long long i = 0; i < n; ++i) upd(1, 0, a[i], 0, 1e6, 1);
for (long long i = 0; i < m; ++i) upd(1, 0, b[i], 0, 1e6, -1);
long long q;
cin >> q;
while (q) {
--q;
long long type, v, id;
cin >> type >> id >> v;
--id;
if (type == 1) {
upd(1, 0, a[id], 0, 1e6, -1);
a[id] = v;
upd(1, 0, a[id], 0, 1e6, 1);
} else {
upd(1, 0, b[id], 0, 1e6, 1);
b[id] = v;
upd(1, 0, b[id], 0, 1e6, -1);
}
long long l = -1, r = 1e6;
while (l < r - 1) {
long long mid = (l + r) / 2;
if (get(1, mid, 1e6, 0, 1e6) > 0)
l = mid;
else
r = mid;
}
if (l == -1)
cout << "-1\n";
else
cout << l + 1 << '\n';
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 14 |
#include <bits/stdc++.h>
namespace IO {
template <typename T>
inline void read(T &x) {
x = 0;
int f = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
x *= f;
return;
}
template <typename T>
inline void write(T x = 0) {
T wr[51];
wr[0] = 0;
if (x < 0) putchar('-'), x = -x;
if (!x) putchar(48);
while (x) wr[++wr[0]] = x % 10, x /= 10;
while (wr[0]) putchar(48 + wr[wr[0]--]);
return;
}
} // namespace IO
using IO::read;
using IO::write;
using namespace std;
const int N = 1e6 + 11;
int T, n, now;
int a[N], b[N], ans[N];
int main() {
read(T);
while (T--) {
ans[0] = 0;
read(n);
for (register int i = 1; i <= n; ++i) scanf("%01d", a + i);
for (register int i = 1; i <= n; ++i) scanf("%01d", b + i);
a[n + 1] = 0;
b[n + 1] = 0;
for (register int i = 1; i <= n; ++i)
if (a[i] != a[i + 1]) ans[++ans[0]] = i;
for (register int i = n; i >= 1; --i)
if (b[i] != b[i + 1]) ans[++ans[0]] = i;
for (register int i = 0; i <= ans[0]; ++i) printf("%d ", ans[i]);
puts("");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
int get(char ch) {
if (ch >= '0' && ch <= '9')
return ch - '0';
else
return ch - 'a' + 10;
}
char str[15];
int num[15], now[15], sum[1048576];
long long Pow[15];
long long f[1048576];
signed main() {
scanf("%s", str + 1);
int n = strlen(str + 1);
int Cnt = 0;
for (int i = 1; i <= n; i++)
num[n - i + 1] = get(str[i]), Cnt += num[n - i + 1];
Pow[1] = 1;
for (int i = 2; i <= n; i++) Pow[i] = 1ll * Pow[i - 1] * 16;
long long ans = 1e18;
for (int i = 0; i < (1 << (n - 1)); i++) {
bool cando = 1;
for (int j = 1; j <= n; j++) now[j] = num[j];
for (int j = 1; j < n; j++)
if (i & (1 << (j - 1))) now[j] -= 16, now[j + 1]++;
int cnt = 0;
for (int j = 1; j <= n; j++) cnt += now[j];
if (cnt) continue;
if (__builtin_popcount(i) != (Cnt / 15)) continue;
for (int j = 0; j < (1 << n); j++) f[j] = 1e18;
f[0] = 0;
sum[0] = 0;
for (int j = 1; j < (1 << n); j++) {
for (int l = 1; l <= n; l++)
if (j & (1 << (l - 1))) {
int &p = sum[j ^ (1 << (l - 1))];
sum[j] = p + now[l];
if (p >= 0 && p < 16)
f[j] = std::min(f[j],
((1ll * sum[j ^ (1 << (l - 1))]) << ((l - 1) * 4)) +
f[j ^ (1 << (l - 1))]);
}
}
ans = std::min(ans, f[(1 << n) - 1]);
}
if (ans == 1e18) {
puts("NO");
return 0;
}
for (int i = 1; i <= n; i++) str[i] = '0';
int tem = n;
while (ans) {
str[tem] = (ans % 16 < 10) ? ans % 16 + '0' : (ans % 16 - 10 + 'a');
ans /= 16;
--tem;
}
for (int i = 1; i <= n; i++) putchar(str[i]);
}
| 25 |
#include <bits/stdc++.h>
using namespace std;
struct node {
string str;
int l;
int r;
} a[15];
int main() {
string s;
int n;
cin >> s;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i].str >> a[i].l >> a[i].r;
int ans = 0;
map<string, int> mp;
for (int i = 0; i < s.size(); i++)
for (int j = 1; j <= s.size() - i; j++) {
string str = s.substr(i, j);
int k;
for (k = 0; k < n; k++) {
int cnt = 0;
int tmp;
for (int v = 0; v < a[k].str.size();) {
tmp = a[k].str.find(str, v);
if (tmp == string::npos)
break;
else {
v = tmp + 1;
cnt++;
}
}
if (cnt < a[k].l || cnt > a[k].r) break;
}
if (k == n) {
mp[str] = 1;
}
}
cout << mp.size() << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = int(1e5 + 5);
int a[N];
pair<int, int> b[N];
bool used[N];
int main() {
ios_base::sync_with_stdio(0);
int k, n;
cin >> n >> k;
long long B;
cin >> B;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n - 1; i++) {
b[i] = make_pair(a[i], i);
}
sort(b, b + n - 1);
reverse(b, b + n - 1);
long long sum = 0;
for (int i = 0; i < k; i++) {
sum += b[i].first;
used[b[i].second] = true;
}
for (int i = 0; i < n; i++) {
if (!used[i]) sum += a[i] - b[k - 1].first;
if (sum > B) {
cout << i + 1 << endl;
return 0;
}
if (!used[i]) sum -= a[i] - b[k - 1].first;
}
cout << n << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, b, d, i, sum = 0, count = 0;
cin >> n >> b >> d;
int x[n];
for (i = 0; i < n; i++) {
cin >> x[i];
}
for (i = 0; i < n; i++) {
if (x[i] > b)
continue;
else
sum += x[i];
if (sum > d) {
sum = 0;
count++;
}
}
cout << count;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, x;
cin >> n >> a;
if (a % 2 == 1)
x = (a - 1) / 2 + 1;
else
x = (n - a) / 2 + 1;
cout << x << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
int read() {
static int ch, x;
while ((ch = getchar()) < 48) {
}
x = ch ^ 48;
while ((ch = getchar()) >= 48) x = (((x << 2) + x) << 1) + (ch ^ 48);
return x;
}
const int INF = 0x3f3f3f3f;
struct edge {
int next, to;
} e[100010 << 1];
int ei;
int l[100010], r[100010], head[100010];
char col[100010];
bool dfs(const int &f) {
for (int i = head[f]; i; i = e[i].next) {
const int t = e[i].to;
if (col[t]) {
if (col[t] ^ col[f] ^ 3) return false;
} else {
col[t] = col[f] ^ 3;
dfs(t);
}
}
return true;
}
int main() {
const int L = read(), U = read(), n = read();
int m = read();
int val1 = 0, val2 = INF;
for (int i = 1; i <= n; ++i) {
val1 = std::max(val1, l[i] = read());
val2 = std::min(val2, r[i] = read());
}
while (m--) {
const int x = read(), y = read();
(e[++ei].next = head[x], e[ei].to = (y), head[x] = ei);
(e[++ei].next = head[y], e[ei].to = (x), head[y] = ei);
}
if (val1 + val2 > U) val2 = U - val1;
if (val1 + val2 < L) val1 = L - val2;
if (val1 < 0 || val2 < 0) {
puts("IMPOSSIBLE");
return 0;
}
for (int i = 1; i <= n; ++i) {
const bool c1 = l[i] <= val1 && val1 <= r[i],
c2 = l[i] <= val2 && val2 <= r[i];
if (!c1 && !c2) {
puts("IMPOSSIBLE");
return 0;
}
if (c1 && !c2) col[i] = 49;
if (c2 && !c1) col[i] = 50;
}
for (int i = 1; i <= n; ++i) {
if (col[i] && !dfs(i)) {
puts("IMPOSSIBLE");
return 0;
}
}
for (int i = 1; i <= n; ++i) {
if (!col[i]) {
col[i] = 49;
if (!dfs(i)) {
puts("IMPOSSIBLE");
return 0;
}
}
}
printf("POSSIBLE\n%d %d\n%s\n", val1, val2, col + 1);
return 0;
}
| 24 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-12;
int a, b, c, d;
double ans, g[2];
int main() {
scanf("%d%d%d%d", &a, &b, &c, &d);
g[0] = 1.0 * a / b, g[1] = 1.0 * (d - c) / d;
double tmp = 1;
while (tmp > eps) {
ans += tmp * g[0];
tmp *= (1 - g[0]) * g[1];
}
printf("%.12lf\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long double ans = 0;
vector<int> v;
int n, u, tmp, ek = -1, ei, ej, pti;
int main() {
ios::sync_with_stdio(false);
cin >> n >> u;
for (int i = 0; i < n; i++) {
cin >> tmp;
v.push_back(tmp);
}
pti = n - 2;
for (int i = n - 1; i > 1; i--) {
pti = min(pti, i - 2);
while (pti >= 0 && v[i] - v[pti] <= u) {
ek = v[i];
ej = v[pti + 1];
ei = v[pti];
if (ek - ei != 0)
ans = max(ans, (long double)(ek - ej) / (long double)(ek - ei));
pti--;
}
}
if (ek == -1) {
cout << -1 << endl;
return 0;
}
cout << setprecision(50) << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int LEN = 200005;
char STR[LEN], *ST = STR, *ED = STR;
inline char gc() {
if (ST == ED) {
ED = (ST = STR) + fread(STR, 1, LEN, stdin);
if (ST == ED) return EOF;
}
return *ST++;
}
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int N = 1000005;
int a[N], top;
int d[N], n;
int num[N];
int Mx, cnt;
long long ans;
int main() {
n = read();
for (int i = 1; i <= n; ++i) {
a[i] = read();
if (Mx < a[i]) {
Mx = a[i];
cnt = i;
}
}
for (int i = cnt; i <= n; ++i) d[i - cnt] = a[i];
for (int i = 1; i <= cnt; ++i) d[n - cnt + i] = a[i];
top = 1;
a[top] = d[0];
num[top] = 1;
for (int i = 1; i <= n; ++i) {
while (top > 0 && a[top] < d[i]) {
ans += num[top];
--top;
}
if (top > 0 && a[top] == d[i]) {
ans += num[top];
num[top]++;
if (top > 1) ++ans;
} else {
if (top > 0) ++ans;
a[++top] = d[i];
num[top] = 1;
}
}
if (num[1] == 2) ans -= num[2];
ans -= num[1] - 1;
printf("%lld\n", ans);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b;
pair<int, pair<int, int> > A[400001];
pair<int, pair<int, int> > B[400001];
map<int, int> T;
map<int, int> P;
set<int> TT;
set<int> PP;
vector<pair<pair<int, int>, int> > Q[400001];
vector<pair<pair<int, int>, int> > W[400001];
int R[400001];
int F[800000];
int I[800000];
void Add(int x) { PP.insert(x); }
void Set(int t, int x, int id, int i, int l, int r) {
if (l == r) {
F[i] = x;
I[i] = id;
} else {
int tm = (l + r) / 2;
if (t <= tm)
Set(t, x, id, i * 2, l, tm);
else
Set(t, x, id, i * 2 + 1, tm + 1, r);
if (F[i * 2] >= F[i * 2 + 1]) {
F[i] = F[i * 2];
I[i] = I[i * 2];
} else {
F[i] = F[i * 2 + 1];
I[i] = I[i * 2 + 1];
}
}
}
int Max(int l, int r, int i, int tl, int tr) {
if (l == tl && r == tr) return F[i];
int tm = (tl + tr) / 2;
if (r <= tm) return Max(l, r, i * 2, tl, tm);
if (l > tm) return Max(l, r, i * 2 + 1, tm + 1, tr);
return max(Max(l, tm, i * 2, tl, tm), Max(tm + 1, r, i * 2 + 1, tm + 1, tr));
}
int Index(int l, int r, int x, int i, int tl, int tr) {
if (l > r) return -1;
if (tl == tr) {
if (F[i] >= x) return I[i];
return -1;
}
int tm = (tl + tr) / 2;
if (r <= tm)
return Index(l, r, x, i * 2, tl, tm);
else if (l > tm)
return Index(l, r, x, i * 2 + 1, tm + 1, tr);
else {
if (Max(l, tm, i * 2, tl, tm) >= x) return Index(l, tm, x, i * 2, tl, tm);
return Index(tm + 1, r, x, i * 2 + 1, tm + 1, tr);
}
}
int main() {
cin >> n >> m;
for (int(i) = (0); (i) < (n); ++(i)) {
cin >> A[i].second.first >> A[i].second.second >> A[i].first;
TT.insert(A[i].first);
Add(A[i].second.first);
Add(A[i].second.second);
}
for (int(i) = (0); (i) < (m); ++(i)) {
cin >> B[i].second.first >> B[i].second.second >> B[i].first;
TT.insert(B[i].first);
Add(B[i].second.first);
Add(B[i].second.second);
}
set<int>::iterator it;
a = 0;
b = 0;
for (it = TT.begin(); it != TT.end(); it++) {
int t = *it;
T[t] = a;
a++;
}
for (it = PP.begin(); it != PP.end(); it++) {
int t = *it;
P[t] = b;
b++;
}
for (int(i) = (0); (i) < (n); ++(i))
Q[P[A[i].second.first]].push_back(
make_pair(make_pair(P[A[i].second.second], T[A[i].first]), i));
for (int(i) = (0); (i) < (m); ++(i))
W[P[B[i].second.first]].push_back(
make_pair(make_pair(P[B[i].second.second], T[B[i].first]), i));
for (int(i) = (0); (i) < (800000); ++(i)) {
I[i] = -1;
F[i] = -1000000000;
}
for (int(i) = (0); (i) < (b); ++(i)) {
for (int(j) = (0); (j) < (Q[i].size()); ++(j))
Set(Q[i][j].first.second, Q[i][j].first.first, Q[i][j].second, 1, 0,
a - 1);
for (int(j) = (0); (j) < (W[i].size()); ++(j)) {
int t;
t = Index(W[i][j].first.second, a - 1, W[i][j].first.first, 1, 0, a - 1);
if (t != -1) t++;
R[W[i][j].second] = t;
}
}
for (int(i) = (0); (i) < (m); ++(i)) cout << R[i] << ' ';
cout << endl;
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
x = 0;
int f = 1;
char ch = getchar();
while (ch != 45 && (ch > '9' || ch < '0')) ch = getchar();
if (ch == 45) {
f = -1, ch = getchar();
}
while (ch <= '9' && ch >= '0') {
x = x * 10 + ch - 48;
ch = getchar();
}
x *= f;
}
const int N = 2005;
int i, j, k, n, s, t, m;
int f[N], g[N], lstf[N], lstg[N], dir[N], a[N], b[N];
int cnt[N], pos[N][N];
int getpos(int x) {
return lower_bound(pos[a[x]] + 1, pos[a[x]] + cnt[a[x]] + 1, x) - pos[a[x]];
}
int getnext(int x) {
int p = getpos(x) + 1;
p = (p - 1) % cnt[a[x]] + 1;
return pos[a[x]][p];
}
int getpre(int x) {
int p = getpos(x) - 1;
if (p == 0) p += cnt[a[x]];
return pos[a[x]][p];
}
int getdist(int x, int y, int dir = -1) {
if (dir == -1) return min(abs(x - y), n - abs(x - y));
if (dir == 1) return n * (x > y) + y - x;
if (dir == 0) return n * (y > x) + x - y;
}
void printroad(int x, int y, int dir) {
if (x == y) {
printf("+0\n");
return;
}
if (dir == 0) printf("-%d\n", getdist(x, y, dir));
if (dir == 1) printf("+%d\n", getdist(x, y, dir));
}
void print(int p, int dep = 0) {
if (dep == m) return;
int np = lstg[p];
print(lstf[np], dep + 1);
if (getdist(lstf[np], np, 1) > getdist(lstf[np], np, 0))
printroad(lstf[np], np, 0);
else
printroad(lstf[np], np, 1);
if (np == p) return;
if (dir[p] == 0) {
int now = np;
while (getnext(now) != p) {
printroad(now, getnext(now), 1);
now = getnext(now);
}
printroad(now, getpre(np), 0);
now = getpre(np);
while (now != p) {
printroad(now, getpre(now), 0);
now = getpre(now);
}
} else {
int now = np;
while (getpre(now) != p) {
printroad(now, getpre(now), 0);
now = getpre(now);
}
printroad(now, getnext(np), 1);
now = getnext(np);
while (now != p) {
printroad(now, getnext(now), 1);
now = getnext(now);
}
}
}
signed main() {
memset(g, 1, sizeof(g)), memset(f, 1, sizeof(f));
read(n), read(s);
for (i = 1; i <= n; i++) read(a[i]), b[i] = a[i];
sort(b + 1, b + n + 1), m = unique(b + 1, b + n + 1) - b - 1;
for (i = 1; i <= n; i++) a[i] = lower_bound(b + 1, b + m + 1, a[i]) - b;
for (i = 1; i <= n; i++) pos[a[i]][++cnt[a[i]]] = i;
for (i = 1; i <= n; i++) {
if (a[i] != 1) continue;
f[i] = getdist(s, i), lstf[i] = s;
}
for (int col = 1; col <= m; col++) {
for (i = 1; i <= n; i++) {
int dis, dis2, nextpos, prepos, w;
if (a[i] != col) continue;
for (j = 1; j <= n; j++) {
if (a[j] != col || i == j) continue;
prepos = getpre(i), nextpos = getnext(i);
dis = i - j;
if (dis < 0) dis += n;
dis2 = j - nextpos;
if (dis2 < 0) dis2 += n;
dis2 *= 2;
w = dis2 + dis + f[j];
if (w < g[i]) g[i] = w, lstg[i] = j, dir[i] = 1;
dis = j - i;
if (dis < 0) dis += n;
dis2 = prepos - j;
if (dis2 < 0) dis2 += n;
dis2 *= 2;
w = dis2 + dis + f[j];
if (w < g[i]) g[i] = w, lstg[i] = j, dir[i] = 0;
}
}
if (cnt[col] == 1) {
g[pos[col][1]] = f[pos[col][1]];
lstg[pos[col][1]] = pos[col][1];
}
for (i = 1; i <= n; i++) {
if (a[i] != col + 1) continue;
for (j = 1; j <= n; j++) {
if (a[j] != col) continue;
if (g[j] + getdist(i, j) < f[i])
f[i] = g[j] + getdist(i, j), lstf[i] = j;
}
}
}
int ans = 1000000000, opt;
for (i = 1; i <= n; i++) {
if (a[i] != m) continue;
if (g[i] < ans) opt = i, ans = g[i];
}
printf("%d\n", ans);
print(opt);
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long int ans = 0;
map<long long int, long long int> mp, ml;
long long int n, m;
cin >> n >> m;
for (long long int i = 1; i <= n; i++) {
mp[i % 5]++;
}
for (long long int i = 1; i <= m; i++) {
ml[i % 5]++;
}
for (long long int i = 1; i <= n; i++) {
long long int rem = (5 - i % 5) % 5;
ans += ml[rem];
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long ans, f[310][2][2];
char s[310];
int n;
long long get(int x, int y) {
memset(f, 0, sizeof f);
f[0][x][y] = 1;
for (int i = 0; i <= n; i++)
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++) {
if ((s[i] == 'A' && (k == 0 || (k == 1 && j == 0))) ||
(s[i] == 'B' && j == 1 && k == 1))
f[i + 1][k][0] += f[i][j][k];
if ((s[i] == 'A' && j == 0 && k == 1) ||
(s[i] == 'B' && (k == 0 || (k == 1 && j == 1))))
f[i + 1][k][1] += f[i][j][k];
}
return f[n][x][y];
}
int main() {
scanf("%s", s);
n = strlen(s);
s[n] = s[0];
ans = get(0, 0) + get(0, 1) + get(1, 0) + get(1, 1);
cout << ans << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200000;
struct BIT {
int n, sum;
vector<int> a, c;
inline void init(int _n) {
n = _n;
a = c = vector<int>(n + 1, 0);
}
inline void update(int i, int val) {
val -= a[i];
a[i] += val;
sum += val;
for (++i; i <= n; i += i & -i) {
c[i] += val;
}
}
inline int query(int i) {
int ret = 0;
for (; i > 0; i &= i - 1) {
ret += c[i];
}
return ret;
}
inline int query(int i, int j) { return query(j) - query(i); }
};
int H, M, n;
int chainN;
int c1[MAXN], c2[MAXN];
vector<int> chain[MAXN];
BIT bit[MAXN];
int main() {
scanf("%d%d%d", &H, &M, &n);
chainN = 0;
memset(c1, -1, sizeof(c1));
for (int i = 0; i < H; ++i) {
if (c1[i] == -1) {
for (int j = i; c1[j] == -1; j = (j + M) % H) {
c1[j] = chainN;
c2[j] = (int)chain[chainN].size();
chain[chainN].push_back(j);
}
++chainN;
}
}
for (int i = 0; i < chainN; ++i) {
bit[i].init((int)chain[i].size());
}
map<int, int> chainID, chainOffset;
long long res = 0;
for (int i = 0; i < n; ++i) {
int id, hash;
char buf[2];
scanf("%s%d", buf, &id);
if (buf[0] == '+') {
scanf("%d", &hash);
int cid = c1[hash], offset = c2[hash], sz = (int)chain[cid].size();
int pl, pr;
if (bit[cid].query(offset, sz) == sz - offset) {
res += sz - offset;
pl = 0;
pr = offset;
} else {
pl = offset;
pr = sz;
}
while (pl + 1 < pr) {
int pm = pl + (pr - pl) / 2;
if (bit[cid].query(pl, pm) == pm - pl) {
res += pm - pl;
pl = pm;
} else {
pr = pm;
}
}
chainID[id] = cid;
chainOffset[id] = pl;
bit[chainID[id]].update(chainOffset[id], 1);
} else {
bit[chainID[id]].update(chainOffset[id], 0);
}
}
printf("%I64d\n", res);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int a[10005];
int main() {
int n, m;
cin >> n >> m;
bool ans = true;
while (m--) {
int k;
cin >> k;
bool flag = true;
for (int i = 0; i < k; i++) {
cin >> a[i];
for (int j = 0; j < i; j++) {
if (a[i] == -a[j]) {
flag = false;
}
}
}
if (flag) ans = false;
}
if (ans) {
cout << "NO\n";
} else {
cout << "YES\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 4e18;
const long long N = 2e5 + 10;
void testCase() {
long long n, m, ta, tb, k;
cin >> n >> m >> ta >> tb >> k;
vector<long long> a(n), b(m), c(m);
for (long long &i : a) cin >> i, i += ta;
for (long long i = 0; i < m; i++) cin >> b[i], c[i] = b[i] + tb;
if (k >= min(n, m)) {
cout << -1;
return;
}
long long ans = -1;
long long j = 0;
for (long long i = 0; i < min(k + 1, n); i++) {
long long rem = k - i;
while (j < m and b[j] < a[i]) j++;
if (m - j <= rem) {
ans = -1;
break;
} else
ans = max(ans, c[j + rem]);
}
cout << ans;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
long long t_c = 1;
while (t_c--) testCase();
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
string s[1005];
bool check(char x, char y) {
if (isalpha(x)) x = tolower(x);
if (isalpha(y)) y = tolower(y);
if (x == '0' && y == 'o' || x == 'o' && y == '0') return true;
if (x == '1' && y == 'l' || x == '1' && y == 'i' || x == 'l' && y == 'i' ||
x == 'l' && y == '1' || x == 'i' && y == '1' || x == 'i' && y == 'l')
return true;
return false;
}
bool judge(char x, char y) {
if (isalpha(x)) x = tolower(x);
if (isalpha(y)) y = tolower(y);
if (x == y) return 1;
return 0;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int flag = 0, n;
string t;
cin >> t >> n;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++) {
if (s[i].size() == t.size()) {
int cnt = 0;
for (int k = 0; k < s[i].size(); k++) {
if (judge(s[i][k], t[k]))
cnt++;
else {
if (check(s[i][k], t[k]))
cnt++;
else
break;
}
}
if (cnt == s[i].size()) flag = 1;
}
}
if (flag)
puts("No");
else
puts("Yes");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, int> m;
int num_x, num_y, res, x_1, x_2, y_1, y_2;
int main() {
for (int i = 1; i <= 4; i++) {
cin >> x_1 >> y_1 >> x_2 >> y_2;
m[make_pair(x_1, y_1)]++;
m[make_pair(x_2, y_2)]++;
if (x_1 != x_2 && y_1 != y_2) {
printf("No");
return 0;
}
if (x_1 == x_2) num_x++;
if (y_1 == y_2) num_y++;
if (m[make_pair(x_1, y_1)] == 2) res++;
if (m[make_pair(x_2, y_2)] == 2) res++;
}
if (num_x != 2 || num_y != 2) {
printf("No");
return 0;
}
if (res == 4) {
printf("YES");
return 0;
}
printf("No");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
const long long mod = 1e9 + 7;
const long long inf = 1e18 + 10;
int l[N], r[N], v[N], lzy[4 * N], n;
pair<int, int> seg[4 * N];
vector<int> V[N], R[N];
void build(int l = 0, int r = n, int id = 1) {
if (r - l == 1) {
seg[id] = make_pair(0, l);
return;
}
int mid = (l + r) / 2;
build(l, mid, 2 * id);
build(mid, r, 2 * id + 1);
seg[id] = make_pair(0, l);
}
void shift(int id, int l, int r) {
seg[id].first += lzy[id];
if (r - l == 1) {
lzy[id] = 0;
return;
}
lzy[2 * id] += lzy[id];
lzy[2 * id + 1] += lzy[id];
lzy[id] = 0;
}
void upd(int l, int r, int val, int s = 0, int e = n, int id = 1) {
shift(id, s, e);
if (e <= l || r <= s) return;
if (l <= s && e <= r) {
lzy[id] += val;
shift(id, s, e);
return;
}
int mid = (s + e) / 2;
upd(l, r, val, s, mid, 2 * id);
upd(l, r, val, mid, e, 2 * id + 1);
seg[id] = max(seg[2 * id], seg[2 * id + 1]);
}
pair<int, int> get(int l, int r, int s = 0, int e = n, int id = 1) {
shift(id, s, e);
if (e <= l || r <= s) return make_pair(-1, -1);
if (l <= s && e <= r) return seg[id];
int mid = (s + e) / 2;
return max(get(l, r, s, mid, 2 * id), get(l, r, mid, e, 2 * id + 1));
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> l[i] >> v[i] >> r[i];
V[v[i]].push_back(i);
R[r[i] + 1].push_back(i);
}
n = N;
build();
pair<int, pair<int, int> > ans = make_pair(0, make_pair(0, 0));
for (int i = 1; i < N; i++) {
for (int j : V[i]) upd(l[j], v[j] + 1, 1);
for (int j : R[i]) upd(l[j], v[j] + 1, -1);
pair<int, int> p = get(1, i + 1);
ans = max(ans, make_pair(p.first, make_pair(p.second, i)));
}
cout << ans.first << '\n';
for (int i = 0; i < n; i++)
if (ans.second.first <= v[i] && v[i] <= ans.second.second &&
l[i] <= ans.second.first && ans.second.second <= r[i])
cout << i + 1 << ' ';
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
bool can_win(long long s, long long e) {
if (s > e) return true;
if (e % 2) return 1 - s % 2;
long long f = e / 2;
long long x = e / 4;
if (s > f) return s % 2;
if (s > x) return 1;
return can_win(s, x);
}
bool can_lose(long long s, long long e) {
if (s * 2 > e) return 1;
return can_win(s, e / 2);
}
pair<int, int> can(long long s, long long e) {
return {can_win(s, e), can_lose(s, e)};
}
pair<int, int> ans;
pair<long long, long long> q[100010];
int t;
int main() {
cin >> t;
for (int i = 1; i <= t; ++i) cin >> q[i].first >> q[i].second;
ans = can(q[t].first, q[t].second);
for (int i = t - 1; i >= 1; --i) {
pair<int, int> nans;
nans.first = false;
nans.second = false;
pair<int, int> win = can(q[i].first, q[i].second);
if (win.second) {
nans.first |= ans.first;
nans.second |= ans.second;
}
if (win.first) {
nans.first |= !ans.first;
nans.second |= !ans.second;
}
ans = nans;
}
cout << ans.first << ' ' << ans.second;
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
string color = "VIBG";
cout << "YOR";
n -= 3;
for (int i = 0; i < n; i++) {
cout << color[i % 4];
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 111111;
char ch[N];
int sum[N];
int main() {
int n, l, r, len;
while (cin >> ch + 1) {
scanf("%d", &n);
sum[0] = 0;
len = strlen(ch + 1);
for (int i = 1; i < len; i++)
if (ch[i] == ch[i + 1])
sum[i] = sum[i - 1] + 1;
else
sum[i] = sum[i - 1];
while (n--) {
scanf("%d%d", &l, &r);
printf("%d\n", sum[r - 1] - sum[l - 1]);
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
void solve() {
long long a, b;
cin >> a >> b;
long long arr1[6] = {0};
long long arr2[6] = {0};
long long q1 = a / 5;
long long q2 = b / 5;
long long r1 = a % 5;
long long r2 = b % 5;
for (long long i = 1; i <= 5; i++) {
arr1[i] = q1;
arr2[i] = q2;
if (i <= r1) arr1[i]++;
if (i <= r2) arr2[i]++;
}
long long ans = 0;
for (long long i = 1; i <= 4; i++) {
ans += (arr1[i] * arr2[5 - i]);
}
ans += (arr1[5] * arr2[5]);
cout << ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool compare(long long int x, long long int y) { return x > y; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t = 1;
while (t--) {
long long int i = 0, j = 0, k = 0, l = 0, z = 0;
long long int n, m = 0;
cin >> n >> m;
string a = "", b = "";
string c = "4", d = "5";
{
z = n;
while (z > 0) {
if (z >= 5) {
a = a + c;
b = b + d;
swap(c, d);
z = z - 4;
} else {
a = a + "45";
b = b + "55";
z = 0;
}
}
cout << a << endl;
cout << b << endl;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char ch[200001];
map<int, int> lozh, prav;
int n, m, x, t, tp, sch = 1, c, a[200001];
bool d[200001];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
cin >> ch[i];
cin >> a[i];
if (ch[i] == '+') {
lozh[a[i]]++;
t++;
} else {
prav[a[i]]++;
tp++;
}
}
for (int i = 1; i <= n; ++i) {
if (lozh[i] + tp - prav[i] == m && prav[i] + t - lozh[i] == n - m) {
d[i] = true;
c++;
}
}
for (int i = 1; i <= n; ++i) {
if ((d[a[i]] == true && ch[i] == '-' && c == 1) ||
(!d[a[i]] && ch[i] == '+'))
printf("Lie\n");
else {
if (d[a[i]] == true && c > 1)
printf("Not defined\n");
else
printf("Truth\n");
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (1 << 17);
int a[maxn], pos[maxn], n, b[maxn];
struct num {
int idx, val;
bool operator<(const num &mtp) const { return val > mtp.val; }
};
priority_queue<num> q1, q2;
int out[maxn];
void read() {
int i;
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
pos[a[i]] = i;
}
for (i = 1; i <= n; ++i) {
scanf("%d", &b[i]);
}
}
void solve() {
int i;
num tmp;
tmp.idx = maxn + 1;
tmp.val = maxn + 1;
q1.push(tmp);
q2.push(tmp);
for (i = 1; i <= n; ++i) {
if (i > pos[b[i]]) {
tmp.idx = i;
tmp.val = i - pos[b[i]];
q1.push(tmp);
} else {
tmp.idx = i;
tmp.val = pos[b[i]] - i;
q2.push(tmp);
}
}
printf("%d\n", min(q1.top().val, q2.top().val));
int k = 0;
for (i = 1; i < n; ++i) {
k++;
tmp.idx = i;
tmp.val = n - pos[b[i]] + k;
q1.push(tmp);
out[i] = 1;
while ((q1.top().val - k) == 0) {
tmp.idx = q1.top().idx;
tmp.val = (-1) * k;
q2.push(tmp);
out[q1.top().idx] = 0;
q1.pop();
}
while (out[q2.top().idx]) q2.pop();
printf("%d\n", min(q1.top().val - k, q2.top().val + k));
}
}
int main() {
read();
solve();
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
int n;
bool check(int x) {
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) return false;
}
return true;
}
int pw(int a, int b) {
if (b == 0) return 1;
if (b == 1) return a;
int res = pw(a, b / 2);
if (b % 2 == 0)
return (int)(1LL * res * res % n);
else
return (int)(1LL * res * res % n * a % n);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
if (n == 1)
return cout << "YES\n1", 0;
else if (n == 4)
return cout << "YES\n1\n3\n2\n4", 0;
if (!check(n)) return cout << "NO", 0;
cout << "YES\n1\n";
for (int i = 2; i < n; i++) {
int now = 1LL * i * pw(i - 1, n - 2) % n;
cout << now << "\n";
}
cout << n;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-13;
const long double PI = acos(-1);
const int INF = (int)1e9;
const long long INFF = (long long)1e15;
const int mod = 998244353;
const int MXN = (int)5e2 + 7;
vector<int> edge[MXN];
int ck[MXN][10], num[MXN], dep[MXN], cntp;
int dp[MXN][MXN][11];
int buf[MXN][11];
int n, k;
char s[MXN];
void pre(int u) {
for (int v : edge[u]) {
dep[v] = dep[u] + 1;
pre(v);
num[u] += num[v];
}
}
void sol(int u, int v) {
for (int i = 0; i <= dep[u]; i++)
for (int j = 0; j <= k; j++) buf[i][j] = dp[u][i][j];
for (int i = 0; i <= dep[u]; i++) {
for (int k1 = k; k1 >= 0; k1--) {
for (int k2 = 0; k1 - k2 >= 0; k2++) {
dp[u][i][k1] = max(dp[u][i][k1], buf[i][k1 - k2] + dp[v][i][k2]);
dp[u][i][k1] = max(dp[u][i][k1], buf[i][k1 - k2] + dp[v][i + 1][k2]);
}
}
}
}
void dfs(int u) {
for (int v : edge[u]) {
dfs(v);
sol(u, v);
}
for (int i = 1; i <= dep[u]; i++) {
for (int j = k; j >= 1; j--) {
dp[u][i][j] = max(dp[u][i][j], dp[u][0][j - 1] + num[u] * i);
}
}
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%s", s + 1);
int p = 0;
for (int i = 1; s[i]; i++) {
int ch = s[i] - '0';
if (!ck[p][ch]) {
ck[p][ch] = ++cntp;
edge[p].push_back(cntp);
}
p = ck[p][ch];
}
int v;
scanf("%d", &v);
num[p] += v;
}
pre(0);
dfs(0);
int ans = 0;
for (int i = 0; i <= k; i++) ans = max(ans, dp[0][0][i]);
ans = -ans;
for (int i = 1; i <= cntp; i++) ans += num[i];
printf("%d\n", ans);
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
struct outFloat {
int precision;
long double value;
outFloat(long double v, int p) : precision(p), value(v) {}
};
const int inf = 123456789;
const long long llInf = 123456789012345678;
const long double pi = 3.14159265358979323846;
const int maxN = 2000000;
int init() {
ios_base::sync_with_stdio(0);
srand(time(NULL));
return 0;
}
int initializer = init();
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &p) {
for (int i = 0; i < p.size(); i++) is >> p[i];
return is;
}
class inputer {
private:
istream *istr;
public:
inputer(istream &is) : istr(&is) {}
template <typename T>
void get(T &n) {
(*istr) >> n;
}
template <typename T, typename... Args>
void get(T &n, Args &...args) {
get(n);
get(args...);
}
template <typename... Args>
void getLn(Args &...args) {
get(args...);
getLn();
}
template <typename T>
operator T() {
T n;
get(n);
return n;
}
void getLn() {
string s;
getline(cin, s);
}
template <typename T>
void getv(vector<T> &v, int size) {
v.resize(size);
(*istr) >> v;
}
};
string delim = " ";
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << p.first << delim << p.second;
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &p) {
for (int i = 0; i < p.size(); i++) {
if (i != 0) os << delim;
os << p[i];
}
return os;
}
ostream &operator<<(ostream &os, const outFloat &of) {
os << setprecision(of.precision) << of.value;
return os;
}
class outputer {
private:
ostream *ostr;
public:
outputer(ostream &os) : ostr(&os) {}
template <typename T>
void put(const T &n) {
(*ostr) << n;
}
template <typename T, typename... Args>
void put(const T &n, const Args &...args) {
put(n);
put(args...);
}
template <typename... Args>
void putLn(const Args &...args) {
put(args...);
putLn();
}
template <typename T>
outputer &operator=(const T &n) {
put(n);
return *this;
}
void putLn() { (*ostr) << "\n"; }
template <typename T>
void putv(vector<T> v, int size, string delim) {
for (int i = 0; i < size; i++) {
if (i != 0) (*ostr) << delim;
(*ostr) << v[i];
}
}
};
inputer in(cin);
outputer out(cout);
char getChar() {
char c = 0;
while (c <= ' ') cin >> c;
return c;
}
bool willItBeAC() {
return true;
;
}
int getMyRating() { return 2121; }
bool prime(long long n) {
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
vector<long long> divs(long long n) {
vector<long long> v;
long long i = 2;
while (i * i <= n)
if (n % i == 0) {
n /= i;
v.push_back(i);
} else
i++;
v.push_back(n);
return v;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long extGcd(long long a, long long b, long long &x, long long &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long x1, y1, d = extGcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
template <typename T>
class fenwick {
private:
vector<T> t;
int n;
public:
fenwick(int nn) { init(nn); }
void init(int nn) {
n = nn;
t.assign(n, 0);
}
T sum(int r) {
T result = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) result += t[r];
return result;
}
void inc(int i, T delta) {
for (; i < n; i = (i | (i + 1))) t[i] += delta;
}
T sum(int l, int r) { return sum(r) - sum(l - 1); }
T get(int i) { return sum(i, i); }
void put(int i, T v) { inc(i, v - sum(i, i)); }
int size() { return n; }
};
int main() {
long double px = in, py = in, vx = in, vy = in, a = in, b = in, c = in,
d = in;
long double k = sqrt(vy * vy + vx * vx);
out.putLn(outFloat(px + vx * b / k, 10), ' ', outFloat(py + vy * b / k, 10));
out.putLn(outFloat(px - vy * a / 2 / k, 10), ' ',
outFloat(py + vx * a / 2 / k, 10));
out.putLn(outFloat(px - vy * c / 2 / k, 10), ' ',
outFloat(py + vx * c / 2 / k, 10));
out.putLn(outFloat(px - vy * c / 2 / k - vx * d / k, 10), ' ',
outFloat(py + vx * c / 2 / k - vy * d / k, 10));
out.putLn(outFloat(px + vy * c / 2 / k - vx * d / k, 10), ' ',
outFloat(py - vx * c / 2 / k - vy * d / k, 10));
out.putLn(outFloat(px + vy * c / 2 / k, 10), ' ',
outFloat(py - vx * c / 2 / k, 10));
out.putLn(outFloat(px + vy * a / 2 / k, 10), ' ',
outFloat(py - vx * a / 2 / k, 10));
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n;
const int MAX_N = 50;
long long answer[MAX_N + 1];
int main() {
answer[2] = 3LL;
answer[3] = 5LL;
answer[4] = 25LL;
answer[5] = 59LL;
answer[6] = 97LL;
answer[7] = 239LL;
answer[8] = 95LL;
answer[9] = 119LL;
answer[10] = 507LL;
answer[11] = 3487LL;
answer[12] = 7333LL;
answer[13] = 4313LL;
answer[14] = 9541LL;
answer[15] = 32057LL;
answer[16] = 53035LL;
answer[17] = 189143LL;
answer[18] = 486961LL;
answer[19] = 602161LL;
answer[20] = 692181LL;
answer[21] = 3749685LL;
answer[22] = 5666119LL;
answer[23] = 2612725LL;
answer[24] = 28939211LL;
answer[25] = 48906931LL;
answer[26] = 130097631LL;
answer[27] = 223561211LL;
answer[28] = 339419171LL;
answer[29] = 478475725LL;
answer[30] = 1513517851LL;
answer[31] = 4151082213LL;
answer[32] = 3067098099LL;
answer[33] = 815774593LL;
answer[34] = 30919633783LL;
answer[35] = 6639234397LL;
answer[36] = 63406103045LL;
answer[37] = 196974070485LL;
answer[38] = 160715692415LL;
answer[39] = 649067163679LL;
answer[40] = 1968703023731LL;
answer[41] = 4199885479225LL;
answer[42] = 5260526710483LL;
answer[43] = 11350565584815LL;
answer[44] = 18000475705097LL;
answer[45] = 30474977225109LL;
answer[46] = 13504636890057LL;
answer[47] = 33940824593261LL;
answer[48] = 20636564487877LL;
answer[49] = 18707714161455LL;
answer[50] = 20540225290239LL;
int k;
cin >> k;
for (int i = 0; i < k; ++i) {
if (i > 0) cout << " ";
cout << ((answer[k] >> (k - 1 - i)) & 1);
}
cout << endl;
for (int i = 0; i < k; ++i) {
if (i > 0) cout << " ";
cout << 1;
}
cout << endl;
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[200001];
long long int vis[200001];
void bfs(int i, vector<long long int> &x) {
x[i] = 0;
queue<int> q;
q.push(i);
vis[i] = 1;
while (!q.empty()) {
int j = q.front();
q.pop();
for (int k = 0; k < adj[j].size(); k++) {
if (vis[adj[j][k]] == 0) {
vis[adj[j][k]] = 1;
x[adj[j][k]] = 1 + x[j];
q.push(adj[j][k]);
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, k;
cin >> n >> m >> k;
vector<int> s(k);
for (int i = 0; i < k; i++) cin >> s[i];
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
vector<long long int> d1(n + 1, 0);
vector<long long int> d2(n + 1, 0);
bfs(1, d1);
memset(vis, 0, sizeof(vis));
bfs(n, d2);
vector<pair<int, int> > ans(k);
for (int i = 0; i < k; i++) {
ans[i] = make_pair(d1[s[i]] - d2[s[i]], s[i]);
}
sort(ans.begin(), ans.end());
vector<long long int> mx(k);
for (int i = k - 1; i >= 0; i--) {
if (i == (k - 1))
mx[i] = d2[ans[i].second];
else {
mx[i] = max(mx[i + 1], d2[ans[i].second]);
}
}
long long int xx = -1 * 100000000000000;
for (int i = 0; i < (k - 1); i++) {
xx = max(xx, d1[ans[i].second] + mx[i + 1]);
}
xx = min(xx + 1, d1[n]);
cout << xx << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, v;
cin >> n >> v;
long long int i, a, b, cnt = 0, t[3025] = {0};
for (i = 0; i < n; i++) {
cin >> a >> b;
t[a] += b;
}
long long int prev = 0;
cnt = 0;
for (i = 1; i < 3025; i++) {
int t1 = t[i];
if (t1 + prev <= v) {
cnt = cnt + t1 + prev;
prev = 0;
} else {
cnt = cnt + v;
if (v < prev) {
prev = t1;
} else {
prev = t1 - (v - prev);
}
}
}
cout << cnt << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int digits(long long int n) { return floor(log10(double(n))) + 1; }
void faster() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
long long int modularExponentiation(long long int x, long long int n,
long long int M) {
long long int result = 1;
while (n > 0) {
if (n % 2 == 1) {
result = ((result % M) * (x % M)) % M;
}
x = ((x % M) * (x % M)) % M;
n = n / 2;
}
return result % M;
}
long long int d, x, y;
void extendedEuclid(long long int A, long long int B) {
if (B == 0) {
d = A;
x = 1;
y = 0;
} else {
extendedEuclid(B, A % B);
int temp = x;
x = y;
y = temp - (A / B) * y;
}
}
long long int nCrModp(long long int n, long long int r) {
if (r > n - r) r = n - r;
long long int C[r + 1];
memset(C, 0, sizeof(C));
C[0] = 1;
for (long long int i = 1; i <= n; i++) {
for (long long int j = min(i, r); j > 0; j--) {
C[j] = (C[j] + C[j - 1]);
}
}
return C[r];
}
long long int modInverse(long long int A, long long int M) {
extendedEuclid(A, M);
return (x % M + M) % M;
}
long long int sumdigits(long long int n) {
long long int ans = 0;
while (n > 0) {
ans += n % 10;
n = n / 10;
}
return ans;
}
long long int less_power2(long long int n) {
long long int i = 1;
while (i * 2 <= n) {
i = i * 2;
}
return i;
}
bool isPrime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
int visited[100] = {0};
vector<int> adj[100];
void dfs(int v, int dest, string s) {
if (v == dest) {
cout << s << endl;
return;
}
visited[v] = 1;
for (auto x : adj[v]) {
if (visited[x] == 0) {
char z = x + '0';
s += z;
dfs(x, dest, s);
}
}
visited[v] = 0;
}
int main() {
long long int arr[4];
cin >> arr[0] >> arr[1] >> arr[2] >> arr[3];
sort(arr, arr + 4);
long long int z = -1;
if (arr[0] + arr[1] > arr[2]) {
z = 1;
cout << "TRIANGLE";
return 0;
} else if (arr[0] + arr[1] == arr[2])
z = 0;
if (arr[1] + arr[2] > arr[3]) {
z = 1;
cout << "TRIANGLE";
return 0;
} else if (arr[1] + arr[2] == arr[3])
z = 0;
if (arr[0] + arr[1] > arr[3]) {
z = 1;
cout << "TRIANGLE";
return 0;
} else if (arr[0] + arr[1] == arr[3])
z = 0;
if (arr[0] + arr[2] > arr[3]) {
z = 1;
cout << "TRIANGLE";
return 0;
} else if (arr[0] + arr[2] == arr[3])
z = 0;
if (z == 0)
cout << "SEGMENT";
else
cout << "IMPOSSIBLE";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int NB = 30;
const string str = "BRY";
int n, N, m, q, i, j, k, e, pos, cnt, w[1010][3], a[4040][1010], b[4040],
c[4040], r[3030];
char op[7];
void setone(int i, int j) { a[i][j / NB] |= (1 << (j % NB)); }
int main() {
scanf("%d%d", &n, &q);
N = (n * 3 - 1) / NB;
for (i = 0; i < n; i++, m++) {
for (j = 0; j < 3; j++) {
setone(m, i * 3 + j);
w[i][j] = j;
}
b[m] = 1;
}
while (q--) {
scanf("%s", op);
scanf("%d", &k);
for (i = 0; i < k; i++) {
scanf("%d", &pos);
--pos;
if (op[0] == 'm') {
for (j = 0; j < 3; j++) setone(m + j, pos * 3 + w[pos][j]);
} else if (op[0] == 'Y') {
swap(w[pos][0], w[pos][2]);
} else if (op[1] == 'Y') {
swap(w[pos][1], w[pos][2]);
} else {
swap(w[pos][0], w[pos][1]);
}
}
if (op[0] == 'm') {
if (k % 2 == 0)
for (j = 0; j < 3; j++) b[m + j] = 1;
scanf("%s", op);
if (op[0] == 'B') {
b[m] ^= 1;
} else if (op[0] == 'R') {
b[m + 1] ^= 1;
} else if (op[0] == 'Y') {
b[m + 2] ^= 1;
} else
for (j = 0; j < 3; j++) b[m + j] ^= 1;
m += 3;
}
}
for (i = 0; i < m; i++) {
for (j = 0; j <= N; j++)
if (a[i][j]) break;
c[i] = j * NB;
if (j > N) {
if (b[i] == 1) {
puts("NO");
return 0;
}
continue;
}
for (pos = 0; pos < NB; pos++)
if ((a[i][j] >> pos) & 1) break;
c[i] += pos;
for (k = i + 1; k < m; k++)
if ((a[k][j] >> pos) & 1) {
for (e = j; e <= N; e++) a[k][e] ^= a[i][e];
b[k] ^= b[i];
}
}
for (i = m - 1; i >= 0; i--)
if (c[i] < n * 3) {
for (j = n * 3 - 1; j > c[i]; j--)
if (r[j]) b[i] ^= ((a[i][j / NB] >> (j % NB)) & 1);
r[c[i]] = b[i];
}
puts("YES");
for (i = 0; i < n; i++) {
for (cnt = j = 0; j < 3; j++)
if (r[i * 3 + j] == 1) {
++cnt;
pos = j;
}
if (cnt == 3)
putchar('.');
else
putchar(str[pos]);
}
return 0;
}
| 24 |
#include <bits/stdc++.h>
int main() {
int i, n, k, a = 0, max = 0;
scanf("%d%d", &n, &k);
int ma[n * 2];
for (i = 0; i < n * 2; i++) {
scanf("%d", &ma[i]);
if (ma[i] == 0) ma[i] = 100;
}
for (i = 0; i < n * 2 - 1; i = i + 2) {
if (k > ma[i] || (k >= ma[i] && ma[i + 1] == 100)) {
a = 1;
if ((100 - ma[i + 1]) > max) max = 100 - ma[i + 1];
}
}
if (a == 1)
printf("%d", max);
else
printf("-1");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void past_code();
int main() {
int q, x, y, c = 0, l = 0, ans = 100000;
string s, t = "RGB";
cin >> q;
while (q--) {
ans = 1000000;
l = 0, c = 0;
cin >> x >> y;
cin >> s;
for (int i = y - 1; i < s.length(); i++) {
for (int j = i - y + 1; j <= i; j++) {
if (s[j] != t[c % 3]) {
l++;
c++;
} else
c++;
}
ans = min(ans, l);
l = 0;
c = 1;
for (int j = i - y + 1; j <= i; j++) {
if (s[j] != t[c % 3]) {
l++;
c++;
} else
c++;
}
ans = min(ans, l);
l = 0;
c = 2;
for (int j = i - y + 1; j <= i; j++) {
if (s[j] != t[c % 3]) {
l++;
c++;
} else
c++;
}
ans = min(ans, l);
l = 0;
c = 0;
}
cout << ans << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long x, y, n;
long long geta(long long b) {
if ((b * x * 2) % (y) == 0) return (int(double(b * x) / double(y)));
return (round(double(b * x) / double(y)));
}
pair<long long int, long long int> diff(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
return (make_pair(abs(((a.first) * (b.second)) - ((b.first) * (a.second))),
((a.second) * (b.second))));
}
int comp(pair<int, int> a, pair<int, int> b) {
pair<long long int, long long int> d1 = diff(make_pair(x, y), a);
pair<long long int, long long int> d2 = diff(make_pair(x, y), b);
if (d1.first * d2.second == d2.first * d1.second)
return (0);
else if (d1.first * d2.second > d2.first * d1.second)
return (1);
else
return (-1);
}
bool compartor(pair<int, int> a, pair<int, int> b) {
int k = comp(a, b);
if (!k) {
if (!(a.second - b.second)) {
return (a.first < b.first);
} else {
return (a.second < b.second);
}
} else {
if (k == 1)
return (0);
else if (k == -1)
return (1);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
cin >> x >> y >> n;
vector<pair<long long int, long long int> > fractions;
for (long long i = 1; i < n + 1; i++) {
fractions.push_back(make_pair(geta(i), i));
}
sort(fractions.begin(), fractions.end(), compartor);
cout << fractions[0].first << '/' << fractions[0].second;
cout << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ '0');
ch = getchar();
}
return x * f;
}
vector<int> G[5005];
inline void AddEdge(int u, int v) { G[u].push_back(v); }
int dp[5005][5005][2];
int sz[5005], leave;
void dfs(int u, int father) {
for (register int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
if (v != father) {
dfs(v, u);
sz[u] += sz[v];
}
}
if (!sz[u]) {
dp[u][1][1] = dp[u][0][0] = 0;
leave++;
sz[u] = 1;
return;
} else {
dp[u][0][0] = dp[u][0][1] = 0;
}
for (register int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
if (v != father) {
for (register int j = sz[u]; j >= 0; --j) {
int a = 0x3f3f3f3f, b = 0x3f3f3f3f;
for (register int k = 0; k <= min(sz[v], j); ++k) {
a = min(a, dp[u][j - k][0] + min(dp[v][k][0], dp[v][k][1] + 1));
b = min(b, dp[u][j - k][1] + min(dp[v][k][1], dp[v][k][0] + 1));
}
dp[u][j][0] = a, dp[u][j][1] = b;
}
}
}
}
int main() {
memset(dp, 0x3f, sizeof(dp));
int n = read();
for (register int i = 1; i < n; ++i) {
int u = read(), v = read();
AddEdge(u, v), AddEdge(v, u);
}
for (register int i = 1; i <= n; ++i) {
if (G[i].size() > 1) {
dfs(i, 0);
printf("%d\n", min(dp[i][leave / 2][0], dp[i][leave / 2][1]));
return 0;
}
}
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1600;
struct point {
int x, y, pos;
};
point a[maxn], Global;
int ans[maxn], cnt[maxn], n;
vector<int> g[maxn];
long long sqr(long long x) { return x * 1ll * x; }
long long vect(point p1, point p2, point p3) {
return (p2.x - p1.x) * 1ll * (p3.y - p1.y) -
(p3.x - p1.x) * 1ll * (p2.y - p1.y);
}
long long len(point p1, point p2) {
return sqr(p1.x - p2.x) + sqr(p1.y - p2.y);
}
bool cmp(point p1, point p2) {
if (vect(Global, p1, p2) > 0 ||
(vect(Global, p1, p2) == 0 && len(Global, p1) < len(Global, p2)))
return true;
return false;
}
void rec(int l, int v, int p) {
int u = l;
for (int i = l; i < l + cnt[v]; ++i)
if (a[i].y < a[u].y || (a[i].y == a[u].y && a[i].x < a[u].x)) u = i;
swap(a[u], a[l]);
Global = a[l];
sort(a + l + 1, a + l + cnt[v], cmp);
ans[a[l].pos] = v;
int pref = 1, to;
for (int i = 0; i < (int)g[v].size(); ++i) {
to = g[v][i];
if (to == p) continue;
rec(l + pref, to, v);
pref += cnt[to];
}
return;
}
void dfs(int v, int p) {
cnt[v] = 1;
int to;
for (int i = 0; i < (int)g[v].size(); ++i) {
to = g[v][i];
if (to == p) continue;
dfs(to, v);
cnt[v] += cnt[to];
}
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
int u, v;
for (int i = 1; i < n; ++i) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 1; i <= n; ++i) {
cin >> a[i].x >> a[i].y;
a[i].pos = i;
}
dfs(1, -1);
rec(1, 1, -1);
for (int i = 1; i <= n; ++i) cout << ans[i] << ' ';
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int arr[26] = {}, arr2[26] = {}, ans = 0;
string s, s2;
cin >> s >> s2;
for (int i = 0; i < max(s.size(), s2.size()); i++) {
if (i < s.size()) arr[s[i] - 'a']++;
if (i < s2.size()) arr2[s2[i] - 'a']++;
}
for (int i = 0; i < 26; i++) {
if (arr2[i] >= arr[i] && arr[i] != 0)
ans += arr[i];
else if (arr2[i] < arr[i] && arr2[i] != 0)
ans += arr2[i];
else if (arr2[i] > arr[i] && arr[i] == 0)
return cout << "-1\n", 0;
}
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e5 + 10;
struct TnT {
int a, b, num;
} T[M];
bool cmp(TnT x, TnT y) { return x.a > y.a; }
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> T[i].a;
T[i].num = i + 1;
}
for (int i = 0; i < n; i++) {
cin >> T[i].b;
}
sort(T, T + n, cmp);
if (n % 2 == 0) {
cout << n / 2 + 1 << endl;
cout << T[0].num;
for (int i = 1; i < n - 2; i += 2) {
if (T[i].b < T[i + 1].b) {
cout << ' ' << T[i + 1].num;
} else {
cout << ' ' << T[i].num;
}
}
cout << ' ' << T[n - 1].num << endl;
} else {
cout << n / 2 + 1 << endl;
cout << T[0].num;
for (int i = 1; i < n - 1; i += 2) {
if (T[i].b < T[i + 1].b) {
cout << ' ' << T[i + 1].num;
} else {
cout << ' ' << T[i].num;
}
}
cout << endl;
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, n, ans, cn1, cn2, cn3, t;
string s, s1, s2;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long u1, d1, u2, d2, w, h;
cin >> w >> h >> u1 >> d1 >> u2 >> d2;
if (d2 > d1) {
swap(d1, d2);
swap(u1, u2);
}
ans = 0;
for (int i = h; i >= 1; i--) {
w += i;
if (i == d1) {
w -= u1;
if (w < 0) w = 0;
}
if (i == d2) {
w -= u2;
if (w < 0) w = 0;
}
}
cout << w << endl;
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << "s.\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
map<unsigned long long int, unsigned long long int> m;
unsigned long long int n, k, x, y;
cin >> n;
for (unsigned long long int i = 0; i < n; i++) {
cin >> x >> y;
m[x] = max(m[x], y);
}
cin >> k;
for (unsigned long long int i = 0; i < k; i++) {
cin >> x >> y;
m[x] = max(m[x], y);
}
unsigned long long int ans = 0;
for (auto a : m) {
ans += a.second;
;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 28;
const double INF = 1e12, EPS = 1e-9;
void run() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cout << (i ? i : n) << (i == n - 1 ? "\n" : " ");
}
int main() { run(); }
| 9 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
int arr[n], brr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
brr[i] = arr[i];
}
sort(brr, brr + n);
int min = brr[0];
for (int i = 0; i < n; i++) {
if (arr[i] % min) {
if (arr[i] != brr[i]) {
cout << "NO" << endl;
return;
}
}
}
cout << "YES" << endl;
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, d, i, j, k, l, m, n;
long long have[100005], need[100005], temp[100005];
bool valid(long long cur) {
long long sum = 0;
for (i = 0; i < n; i++) {
temp[i] = max(0ll, (cur * need[i]) - have[i]);
sum += temp[i];
if (temp[i] > k or sum > k) return false;
}
return true;
}
int main() {
cin >> n >> k;
for (i = 0; i < n; i++) cin >> need[i];
for (i = 0; i < n; i++) cin >> have[i];
long long low = 0;
long long high = (long long)2.5e9;
while (low < high) {
long long mid = (low + high + 1) / 2;
if (valid(mid))
low = mid;
else
high = mid - 1;
}
cout << low << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, x[100001], c[100001], hl[100001], ans;
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) hl[i] = 1e9;
for (int i = 1; i <= n; i++) {
cin >> x[i] >> c[i];
hl[x[i]] = min(c[i], hl[x[i]]);
}
for (int i = 1; i <= m; i++) ans += hl[i];
ans = min(ans, k);
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int X = 0, w = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') w = -1;
c = getchar();
}
while (c >= '0' && c <= '9') X = (X << 3) + (X << 1) + c - '0', c = getchar();
return X * w;
}
int h[20];
int a, b;
int n;
int ans = 2147483647;
int sta[1010], top = 0;
int ans_op[1010], s_op = 0;
inline void Dfs(int p, int s) {
if (s >= ans) return;
if (p == n) {
if (h[n] < 0 && s < ans) {
ans = s;
memcpy(ans_op, sta, sizeof(ans_op));
s_op = ans;
}
return;
}
int End_ = max(max(h[p - 1] / b, h[p + 1] / b), h[p] / a) + 1;
for (register int i = 0; i <= End_; i++) {
if (h[p - 1] - b * i < 0) {
h[p - 1] -= b * i, h[p] -= a * i, h[p + 1] -= b * i;
for (register int j = 1; j <= i; j++) sta[++top] = p;
Dfs(p + 1, s + i);
h[p - 1] += b * i, h[p] += a * i, h[p + 1] += b * i;
for (register int j = 1; j <= i; j++) top--;
}
}
}
int main() {
n = read(), a = read(), b = read();
for (register int i = 1; i <= n; i++) h[i] = read();
Dfs(2, 0);
printf("%d\n", ans);
for (register int i = 1; i <= s_op; i++) printf("%d ", ans_op[i]);
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string second;
cin >> second;
long long int i = 0, n, a = 0, b = 0, count = 0, c = 0, d = 0, k = 0, p = 0;
p = second.size();
n = second.size();
if (n < 4) {
cout << "-1";
return 0;
}
if (second.find('[') == string::npos) {
cout << "-1";
return 0;
}
if (second.find(']') == string::npos) {
cout << "-1";
return 0;
}
for (i = 0; i < n; i++) {
if (second[i] != '[') {
count++;
} else {
a = i;
break;
}
}
for (i = n - 1; i >= 0; i--) {
if (second[i] != ']')
count++;
else {
b = i;
break;
}
}
if (b <= a) {
cout << "-1";
return 0;
}
second = second.substr(a, b - a + 1);
n = second.size();
if (n < 4) {
cout << "-1";
return 0;
}
for (i = 0; i < n; i++) {
if (second[i] == ':') k++;
}
if (k <= 1) {
cout << "-1";
return 0;
}
for (i = 1; i < n; i++) {
if (second[i] != ':')
count++;
else {
c = i;
break;
}
}
for (i = n - 2; i >= 0; i--) {
if (second[i] != ':')
count++;
else {
d = i;
break;
}
}
string str = second.substr(c, d - c + 1);
for (i = 1; i < str.size() - 1; i++) {
if (str[i] != '|') count++;
}
cout << p - count;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int bnd = 128;
const int P = (int)5e4 + 10;
pair<bool, vector<int> > work(const vector<int> &a, int p) {
const int n = (int)(a).size();
int mcan[bnd][p], prev[bnd][p];
int current[bnd][p];
memset(mcan, -1, sizeof mcan);
memset(prev, -1, sizeof prev);
mcan[a[0]][a[0] % p] = 0;
vector<int> coef(n);
for (int i = 0; i < int(n); ++i) {
int cur = a[i];
coef[i] = 1;
while (cur > 0) {
cur /= 10;
coef[i] *= 10;
}
}
for (int i = 0; i < int(n); ++i)
if (i > 0) {
if (mcan[0][0] != -1) break;
memcpy(current, mcan, sizeof mcan);
for (int xr = 0; xr < int(bnd); ++xr)
for (int rem = 0; rem < int(p); ++rem)
if (current[xr][rem] != -1) {
int nxr = (xr ^ a[i]), nrem = (coef[i] * rem + a[i]) % p;
if (mcan[nxr][nrem] == -1) {
prev[nxr][nrem] = rem;
mcan[nxr][nrem] = i;
}
}
if (mcan[a[i]][a[i] % p] == -1) mcan[a[i]][a[i] % p] = i;
}
if (mcan[0][0] == -1) return make_pair(false, vector<int>());
vector<int> res;
int curxor = 0, currem = 0;
while (currem != -1) {
res.push_back(mcan[curxor][currem]);
int nxor = (curxor ^ a[res.back()]);
currem = prev[curxor][currem];
curxor = nxor;
}
reverse((res).begin(), (res).end());
return make_pair(true, res);
}
void solve(int n) {
int p;
cin >> p;
vector<int> a(n);
for (int i = 0; i < int(n); ++i) cin >> a[i];
vector<int> small, where;
for (int i = 0; i < int(n); ++i)
if (a[i] < bnd) {
small.push_back(a[i]);
where.push_back(i);
}
pair<bool, vector<int> > res = work(small, p);
if (!res.first)
cout << "No\n";
else {
cout << "Yes\n";
cout << (int)(res.second).size() << '\n';
for (int ids : res.second) cout << where[ids] + 1 << ' ';
cout << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
while (cin >> n) solve(n);
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
#pragma warning(disable : 4996)
#pragma comment(linker, "/STACK:16777216")
#pragma warning(disable : 4996)
#pragma comment(linker, "/STACK:16777216")
const int INF = 2000000000;
const long long LINF = 2000000000000000000;
const long double LDINF = 2e18;
template <typename T>
void print(vector<T>& a) {
for (int i = 0; i < a.size(); i++) cout << a[i] << ' ';
}
template <typename T>
void print(deque<T>& a) {
for (int i = 0; i < a.size(); i++) cout << a[i] << ' ';
}
template <typename T>
void print(vector<vector<T>>& a) {
for (int i = 0; i < a.size(); i++) {
for (int j = 0; j < a[i].size(); j++) cout << a[i][j] << ' ';
cout << '\n';
}
}
template <typename T>
void input(vector<T>& a) {
for (int i = 0; i < a.size(); i++) cin >> a[i];
}
template <typename T>
void input(deque<T>& a) {
for (int i = 0; i < a.size(); i++) cin >> a[i];
}
template <typename T>
void input(vector<vector<T>>& a) {
for (int i = 0; i < a.size(); i++)
for (int j = 0; j < a[i].size(); j++) cin >> a[i][j];
}
long long mod1 = 1000001011;
long long mod = 1e9 + 7;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
long long GetNum(char ch) {
if (ch >= 'a' && ch <= 'z') return ch - 'a';
return ch - 'A' + 26;
}
long long n, m, k;
vector<vector<long long>> mult(vector<vector<long long>>& A,
vector<vector<long long>>& B) {
vector<vector<long long>> C(m, vector<long long>(m, 0));
for (int i = 0; i < m; i++)
for (int j = 0; j < m; j++)
for (int k = 0; k < m; k++) {
C[i][j] += A[i][k] * B[k][j];
C[i][j] %= mod;
}
return C;
}
vector<vector<long long>> BinPow(vector<vector<long long>>& A, long long n) {
if (n == 1) return A;
if (n % 2 == 0) {
vector<vector<long long>> A1 = BinPow(A, n / 2);
return mult(A1, A1);
} else {
vector<vector<long long>> A1 = BinPow(A, n - 1);
return mult(A1, A);
}
}
void solve() {
cin >> n >> m >> k;
vector<vector<long long>> mat(m, vector<long long>(m, 1));
for (int i = 0; i < k; i++) {
char a, b;
cin >> a >> b;
mat[GetNum(b)][GetNum(a)] = 0;
}
vector<vector<long long>> F(m, vector<long long>(1, 1));
n--;
if (n == 0) {
long long ans = 0;
for (int i = 0; i < m; i++) {
ans += F[i][0];
ans %= mod;
}
cout << ans;
return;
}
vector<vector<long long>> T = BinPow(mat, n);
F = mult(T, F);
long long ans = 0;
for (int i = 0; i < m; i++) {
ans += F[i][0];
ans %= mod;
}
cout << ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tst = 1;
while (tst--) solve();
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7, INF = 1e9 + 7;
int n, h, a, b, k;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> h >> a >> b >> k;
for (int i = 0; i < k; ++i) {
int ta, fa, tb, fb;
cin >> ta >> fa >> tb >> fb;
if (ta == tb) {
cout << abs(fa - fb) << '\n';
} else {
if (a <= fa && fa <= b || a <= fb && fb <= b)
cout << abs(fa - fb) + abs(ta - tb) << '\n';
else {
if (abs(fa - a) < abs(fa - b))
cout << abs(fa - a) + abs(fb - a) + abs(ta - tb) << '\n';
else
cout << abs(fa - b) + abs(fb - b) + abs(ta - tb) << '\n';
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, ans = 0;
cin >> a >> b;
for (int i = 1; i <= a; i++) {
if (i % 2 == 1)
for (int j = 0; j < b; j++) cout << '#';
if (i % 2 == 0) {
if (ans == 0) {
for (int j = 0; j < b - 1; j++) cout << '.';
cout << '#';
ans = 1;
} else if (ans == 1) {
cout << '#';
for (int j = 0; j < b - 1; j++) cout << '.';
ans = 0;
}
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1e18;
long long int mul(long long int a, long long int b) {
return ((a % mod) * (b % mod)) % mod;
}
long long int add(long long int a, long long int b) {
return ((a % mod) + (b % mod)) % mod;
}
long long int sub(long long int a, long long int b) {
return ((a % mod) - (b % mod) + mod) % mod;
}
long long int pre[200005], post[200005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, dfbkfb;
cin >> n >> dfbkfb;
long long int a[n + 1];
for (long long int i = 1; i <= n; i++) {
cin >> a[i];
}
for (long long int i = 0; i < 200005; i++) {
pre[i] = 1e18;
}
for (long long int i = 1; i <= n; i++) {
pre[a[i]] = min(pre[a[i]], i);
post[a[i]] = max(post[a[i]], i);
}
long long int k = 1;
long long int out = 0;
while (k <= n) {
long long int i = k;
long long int j = k;
map<long long int, long long int> m;
while (i <= j) {
j = max(j, post[a[i]]);
m[a[i]]++;
i++;
}
long long int ma = 0;
for (auto it = m.begin(); it != m.end(); it++) {
ma = max(ma, (it->second));
}
out += (j - k + 1) - ma;
k = j + 1;
}
cout << out;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int x[55];
bool can[500002];
int steps[5000002];
int main() {
int N, K;
scanf("%d%d", &N, &K);
for (int i = 1; i <= N; ++i) scanf("%d", &x[i]);
sort(x + 1, x + N + 1);
int bestSum = 0;
for (int i = 1; i <= N; ++i)
if (bestSum + K >= x[i])
bestSum += x[i];
else
break;
can[0] = 1;
for (int i = 1; i <= N; ++i)
for (int j = bestSum; j >= 0; --j)
if (can[j]) can[j + x[i]] = 1;
int now = 0;
for (int i = 1; i <= bestSum; ++i) {
if (now < i - K) now = i - K;
while (now < i && !can[now]) ++now;
if (now == i) break;
steps[i] = steps[now] + 1;
}
printf("%d %d", bestSum, steps[bestSum]);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long ar[200009];
set<long long> ss, st;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) cin >> ar[i];
for (long long i = 1; i < n; i++) {
long long x = abs(ar[i] - ar[i + 1]);
if (x == 0) {
cout << "NO" << endl;
return 0;
}
if (x > 1) st.insert(x);
}
if (st.size() == 0)
cout << "YES\n1 1000000000" << endl;
else if (st.size() == 1) {
long long xx = *(st.begin());
ss.clear();
for (long long i = 1; i < n; i++) {
long long x = ar[i], y = ar[i + 1];
if (abs(x - y) == 1) {
if (x % xx == 1) {
if (y != x + 1) {
cout << "NO" << endl;
return 0;
}
} else if (x % xx == 0) {
if (y != x - 1) {
cout << "NO" << endl;
return 0;
}
}
}
}
cout << "YES\n1000000000 " << xx << endl;
} else
cout << "NO" << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long mul(long long a, long long b) {
a %= mod;
b %= mod;
return (a * b) % mod;
}
struct vertex {
long long S[6];
public:
vertex() {
S[0] = 1;
fill(S + 1, S + 6, 0);
}
vertex(long long p, long long v) {
S[0] = v % mod;
for (int i = 0; i < (5); i++) S[i + 1] = mul(S[i], p + 1);
}
vertex operator+(const vertex& o) {
vertex ret;
for (int i = 0; i < (6); i++) ret.S[i] = (S[i] + o.S[i]) % mod;
return ret;
}
};
ostream& operator<<(ostream& st, const vertex& v) {
st << "(";
for (int i = 0; i < (6); i++) {
if (i) st << " ,";
st << v.S[i];
}
st << " )";
return st;
}
const int MAX = 1e5 + 1e3;
vertex ST[MAX << 2];
long long A[MAX], LAZY[MAX << 2], C[6][6];
int n, m;
long long SUMPOW[6][MAX];
vertex build(int node, int s, int e) {
LAZY[node] = -1;
if (s == e) return ST[node] = vertex(s + 0LL, A[s]);
int m = (s + e) >> 1, left = node << 1, right = left | 1;
return ST[node] = build(left, s, m) + build(right, m + 1, e);
}
void update(int node, int s, int e, long long v) {
v %= mod;
LAZY[node] = v;
for (int i = 0; i < (6); i++) {
long long tmp = SUMPOW[i][e] - SUMPOW[i][s - 1];
if (tmp < 0) tmp += mod;
ST[node].S[i] = mul(v, tmp);
}
}
void forward(int node, int s, int e) {
if (LAZY[node] == -1) return;
int m = (s + e) >> 1, left = node << 1, right = left | 1;
update(left, s, m, LAZY[node]);
update(right, m + 1, e, LAZY[node]);
LAZY[node] = -1;
}
void update(int node, int s, int e, int l, int r, long long v) {
if (l <= s && e <= r) return update(node, s, e, v);
forward(node, s, e);
int m = (s + e) >> 1, left = node << 1, right = left | 1;
if (r <= m)
update(left, s, m, l, r, v);
else if (m < l)
update(right, m + 1, e, l, r, v);
else
update(left, s, m, l, m, v), update(right, m + 1, e, m + 1, r, v);
ST[node] = ST[left] + ST[right];
}
vertex query(int node, int s, int e, int l, int r) {
if (l <= s && e <= r) return ST[node];
forward(node, s, e);
int m = (s + e) >> 1, left = node << 1, right = left | 1;
if (r <= m)
return query(left, s, m, l, r);
else if (m < l)
return query(right, m + 1, e, l, r);
else
return query(left, s, m, l, m) + query(right, m + 1, e, m + 1, r);
}
void init() {
scanf("%d %d", &n, &m);
for (int i = 0; i < (n); i++) scanf("%I64d", A + i + 1);
build(1, 1, n);
for (int i = 0; i < (n + 1); i++) {
long long j = 1;
for (int p = 0; p < (6); p++) {
SUMPOW[p][i] = j;
if (i) {
SUMPOW[p][i] += SUMPOW[p][i - 1];
if (SUMPOW[p][i] >= mod) SUMPOW[p][i] -= mod;
}
j *= i + 1;
j %= mod;
}
}
for (int i = 0; i < (6); i++) {
C[i][0] = 1;
for (int j = (1); j <= (i); j++) C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
}
}
int main() {
init();
char s[3];
int l, r, x;
while (m--) {
scanf("%s %d %d %d", s, &l, &r, &x);
if (s[0] == '=')
update(1, 1, n, l, r, x);
else {
vertex Q = query(1, 1, n, l, r);
long long ans = 0, q = 1;
for (int i = 0; i < (x + 1); i++) {
ans += mul(C[x][i], mul(q, Q.S[x - i]));
ans %= mod;
q *= -l;
q %= mod;
if (q < 0) q += mod;
}
printf("%I64d\n", ans);
}
}
return 0;
}
| 17 |
Subsets and Splits