solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int N = 1e3 + 5;
int t, n;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
cin >> n;
int low = 2, high = 5e4, mid, j;
while (low <= high) {
mid = low + high >> 1;
if (1ll * mid * (mid - 1) / 2 <= n)
j = mid, low = mid + 1;
else
high = mid - 1;
}
int rem = n - 1ll * j * (j - 1) / 2;
cout << "133";
while (rem--) cout << "7";
j -= 2;
while (j--) cout << "3";
cout << "7\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 20;
long long dp[maxn][maxn];
long long p10[maxn];
int n;
string a;
void precalculate() {
p10[0] = 1;
for (int i = 1; i < maxn; i++) p10[i] = p10[i - 1] * 10;
}
void print(int i, int j) {
if (i == 0 && j == 0) return;
if (i > 0 && dp[i][j] == dp[i - 1][j] + (long long)(a[2 * n - i - j] - '0') *
p10[i - 1]) {
cout << 'H';
print(i - 1, j);
} else {
cout << 'M';
print(i, j - 1);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout.precision(16);
if (0) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
precalculate();
cin >> n >> a;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
if (i == 0 && j == 0) continue;
if (i > 0)
dp[i][j] =
max(dp[i - 1][j] + (long long)(a[2 * n - i - j] - '0') * p10[i - 1],
dp[i][j]);
if (j > 0)
dp[i][j] =
max(dp[i][j - 1] + (long long)(a[2 * n - i - j] - '0') * p10[j - 1],
dp[i][j]);
}
}
print(n, n);
cout << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 202020;
long long int a1[MAXN], a2[MAXN], tmp, a0[MAXN];
int cnt1, cnt2, cnt0, n;
char ch[2];
long long int cal(long long int x) {
if (x > 0) return x;
return 0;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld%s", &tmp, ch);
if (ch[0] == 'P')
a0[++cnt0] = tmp;
else if (ch[0] == 'B')
a1[++cnt1] = tmp;
else
a2[++cnt2] = tmp;
}
if (!cnt0) {
printf("%lld", a1[cnt1] - a1[1] + a2[cnt2] - a2[1]);
return 0;
}
if (!cnt1 && !cnt2) {
printf("%lld", a0[cnt0] - a0[1]);
return 0;
}
if (cnt0 == 1) {
long long int ans = 0;
if (cnt1) ans += max(a1[cnt1], a0[cnt0]) - min(a1[1], a0[1]);
if (cnt2) ans += max(a2[cnt2], a0[cnt0]) - min(a2[1], a0[1]);
printf("%lld", ans);
return 0;
}
a0[0] = a1[0] = a2[0] = -1e10;
a1[cnt1 + 1] = a2[cnt2 + 1] = 1e10;
long long int ans = cal(a0[1] - a1[1]) + cal(a0[1] - a2[1]);
ans += cal(a1[cnt1] - a0[cnt0]) + cal(a2[cnt2] - a0[cnt0]);
int p1, p2;
p1 = p2 = 1;
for (int i = 1; i < cnt0; i++) {
long long int tem, temx, temy;
tem = temx = temy = 0;
while (a1[p1] < a0[i]) p1++;
while (a2[p2] < a0[i]) p2++;
if (a1[p1] > a0[i + 1])
temx = a0[i + 1] - a0[i];
else {
temx = a1[p1] - a0[i];
while (a1[p1 + 1] < a0[i + 1]) {
p1++;
temx = max(temx, a1[p1] - a1[p1 - 1]);
}
temx = max(temx, a0[i + 1] - a1[p1]);
}
if (a2[p2] > a0[i + 1])
temy = a0[i + 1] - a0[i];
else {
temy = a2[p2] - a0[i];
while (a2[p2 + 1] < a0[i + 1]) {
p2++;
temy = max(temy, a2[p2] - a2[p2 - 1]);
}
temy = max(temy, a0[i + 1] - a2[p2]);
}
long long int len = a0[i + 1] - a0[i];
ans += min(2 * len, 3 * len - temx - temy);
}
printf("%lld", ans);
}
| 7 |
#define _CRT_SECURE_NO_WARNINGS
#include<bits/stdc++.h>
#define int long long
#define endl '\n'
using namespace std;
int const MAXN = 1e5, MOD = 998244353;
int t, n, jc[MAXN + 1] = { 1 };
string s;
int qPow(int a, int b, int c) {
int ret = 1;
while (b) {
if (b & 1) {
ret = ret * a % c;
}
a = a * a % c;
b >>= 1;
}
return ret;
}
int inv(int a, int mod) {
return qPow(a, mod - 2, mod);
}
int C(int n, int m) {
return jc[n] * inv(jc[n - m], MOD) % MOD * inv(jc[m], MOD) % MOD;
}
signed main() {
//freopen("1.txt", "r", stdin);
ios::sync_with_stdio(0);
cin.tie(0);
cin >> t;
for (int i = 1;i <= MAXN;i++) {
jc[i] = jc[i - 1] * i % MOD;
}
while (t--) {
cin >> n;
cin >> s;
int x = 0, y = 0, cnt = 0;
for (int i = 0;i < n;i++) {
if (s[i] == '0') {
x++;
y += cnt / 2;
cnt = 0;
}
else {
cnt++;
}
}
y += cnt / 2;
cout << C(x + y, x) << endl;
}
return 0;
} | 5 |
#include <bits/stdc++.h>
using namespace std;
int k, en, a[30];
long long S, ans, f[30];
map<long long, int> mp[30];
void dfs1(int st, int op, long long sum) {
if (sum > S || op > k) return;
if (st == en) {
mp[op][sum]++;
return;
}
dfs1(st + 1, op, sum);
dfs1(st + 1, op, sum + a[st]);
if (a[st] < 20) dfs1(st + 1, op + 1, sum + f[a[st]]);
}
void dfs2(int st, int op, long long sum) {
int i;
if (sum > S || op > k) return;
if (st == en) {
for (i = 0; i <= k - op; i++)
if (mp[i].count(S - sum)) ans += mp[i][S - sum];
return;
}
dfs2(st + 1, op, sum);
dfs2(st + 1, op, sum + a[st]);
if (a[st] < 20) dfs2(st + 1, op + 1, sum + f[a[st]]);
}
int main() {
int i, j, n;
f[0] = 1;
for (i = 1; i <= 20; i++) f[i] = f[i - 1] * i;
scanf("%d%d%I64d", &n, &k, &S);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
en = n / 2, ans = 0;
dfs1(0, 0, 0);
en = n;
dfs2(n / 2, 0, 0);
printf("%I64d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int a[100002];
int main() {
long long int n, ans = 0, k;
int i;
scanf("%lld", &n);
scanf("%lld", &k);
for (i = 1; i <= n; i++) scanf("%lld", &a[i]);
sort(a + 1, a + 1 + n);
for (i = 1; i <= n; i++) {
if (k <= 1)
ans += a[i];
else
ans += (a[i] * k);
k--;
}
printf("%lld", ans);
}
| 2 |
#include <bits/stdc++.h>
const int N = 1e5 + 5, S = 1 << 18;
template <class Type1, class Type2>
inline bool cmin(Type1 &a, const Type2 &b) {
return b < a ? (a = b, true) : false;
}
template <class Type1, class Type2>
inline bool cmax(Type1 &a, const Type2 &b) {
return a < b ? (a = b, true) : false;
}
int read() {
int a = 0;
unsigned char c;
while ((c = getchar() - '0') > 9)
;
while (a = a * 10 + c, (c = getchar() - '0') <= 9)
;
return a;
}
int n, k, head[N], next[N], ans = 1;
long long p[N], q[N];
int l[S], r[S];
long long min[S], max[S], val[S], tag[S];
void do_inc(int i, long long v) {
tag[i] += v;
max[i] += v;
val[i] += v;
}
void pushdown(int i) {
if (tag[i]) {
do_inc(i << 1, tag[i]);
do_inc(i << 1 | 1, tag[i]);
tag[i] = 0;
}
}
long long eval(int i, long long pmax) {
if (l[i] == r[i]) return std::max(pmax + min[i], tag[i]);
pushdown(i);
return max[i << 1] <= pmax
? std::min(pmax + min[i << 1], eval(i << 1 | 1, pmax))
: std::min(eval(i << 1, pmax), val[i]);
}
void pushup(int i) {
max[i] = std::max(max[i << 1], max[i << 1 | 1]);
min[i] = std::min(min[i << 1], min[i << 1 | 1]);
val[i] = eval(i << 1 | 1, max[i << 1]);
}
void build(int i, int ll, int rr) {
l[i] = ll;
r[i] = rr;
if (ll == rr) {
min[i] = -q[ll];
max[i] = q[ll];
} else {
int mid = (ll + rr) / 2;
build(i << 1, ll, mid);
build(i << 1 | 1, mid + 1, rr);
pushup(i);
}
}
int query(int i, long long pmax) {
if (l[i] == r[i]) return l[i];
pushdown(i);
return eval(i << 1 | 1, std::max(pmax, max[i << 1])) > k
? query(i << 1, pmax)
: query(i << 1 | 1, std::max(pmax, max[i << 1]));
}
void increase_w(int i, int pos, long long val) {
if (l[i] == r[i]) {
tag[i] += val;
return;
}
pushdown(i);
increase_w(i << 1 | pos > (l[i] + r[i]) / 2, pos, val);
pushup(i);
}
void increase(int i, int ql, int qr, long long qv) {
if (ql > r[i] || qr < l[i]) return;
if (ql <= l[i] && qr >= r[i]) return do_inc(i, qv);
pushdown(i);
increase(i << 1, ql, qr, qv);
increase(i << 1 | 1, ql, qr, qv);
pushup(i);
}
void dfs(int x) {
increase(1, 1, x, -1e18);
increase_w(1, x + 1, -1e18);
cmax(ans, query(1, -1e18) - x);
increase(1, 1, x, 1e18);
increase_w(1, x + 1, 1e18);
int last = x;
for (int y = head[x]; ~y; last = y, y = next[y]) {
increase_w(1, x, p[last] - p[y]);
increase(1, x, n, p[y] - p[last]);
dfs(y);
}
increase_w(1, x, p[last] - p[x]);
increase(1, x, n, p[x] - p[last]);
}
int main() {
static int d[N], a[N], stack[N];
n = read(), k = read();
for (int i = 1; i < n; ++i) d[i] = read();
for (int i = 1; i <= n; ++i) a[i] = read();
for (int i = 1; i < n; ++i) p[i] = p[i - 1] + a[i] - d[i];
for (int i = 2; i <= n; ++i) q[i] = q[i - 1] + a[i] - d[i - 1];
memset(head, -1, (n + 1) * sizeof(int));
for (int i = n, nstk = 0; i--;) {
while (nstk && p[i] <= p[stack[nstk - 1]]) --nstk;
int f = nstk ? stack[nstk - 1] : n;
stack[nstk++] = i;
next[i] = head[f];
head[f] = i;
}
build(1, 1, n);
for (int i = head[n]; ~i; i = next[i]) dfs(i);
printf("%d\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int bitx[32], bity[32], bitk[32];
long long dp[32][2][2][2], dp1[32][2][2][2], f[32];
pair<long long, long long> dfs(int pos, int limit1, int limit2, int limit3) {
if (pos == 0) return make_pair(1, 0);
if (dp[pos][limit1][limit2][limit3] != -1)
return make_pair(dp[pos][limit1][limit2][limit3],
dp1[pos][limit1][limit2][limit3]);
int x = limit1 ? bitx[pos] : 1;
int y = limit2 ? bity[pos] : 1;
long long ret = 0;
long long ret1 = 0;
for (int i = 0; i <= x; ++i) {
for (int j = 0; j <= y; ++j) {
if (limit3 && (i ^ j) > bitk[pos]) continue;
pair<long long, long long> t =
dfs(pos - 1, limit1 && (i == x), limit2 && (j == y),
limit3 && ((i ^ j) == bitk[pos]));
(ret += t.first) %= mod;
(ret1 += t.second + ((i ^ j) ? f[pos - 1] : 0) * t.first % mod) %= mod;
}
}
dp[pos][limit1][limit2][limit3] = ret,
dp1[pos][limit1][limit2][limit3] = ret1;
return make_pair(ret, ret1);
}
long long solve(long long x, long long y, long long k) {
memset(dp, -1, sizeof(dp));
if (x < 0 || y < 0) return 0;
memset(bitx, 0, sizeof(bitx));
memset(bity, 0, sizeof(bity));
memset(bitk, 0, sizeof(bitk));
int lenx = 0;
while (x) {
bitx[++lenx] = x & 1;
x >>= 1;
}
int leny = 0;
while (y) {
bity[++leny] = y & 1;
y >>= 1;
}
int lenk = 0;
while (k) {
bitk[++lenk] = k & 1;
k >>= 1;
}
pair<long long, long long> t = dfs(31, 1, 1, 1);
return (t.first + t.second) % mod;
}
int main() {
f[0] = 1;
for (int i = 1; i < 31; ++i) f[i] = f[i - 1] * 2 % mod;
int T, x1, y1, x2, y2, k;
scanf("%d", &T);
memset(dp, -1, sizeof(dp));
while (T--) {
scanf("%d%d%d%d%d", &x1, &y1, &x2, &y2, &k);
x1--;
y1--;
x2--;
y2--;
k--;
printf("%I64d\n", ((solve(x2, y2, k) - solve(x1 - 1, y2, k) -
solve(x2, y1 - 1, k) + solve(x1 - 1, y1 - 1, k)) %
mod +
mod) %
mod);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, q;
long long a[300005];
long long dp[300005][5];
long long solve(int cur, int sign) {
if (cur >= n) {
return 0;
}
if (dp[cur][sign] != -1) {
return dp[cur][sign];
}
long long ans = -1 * 1e15;
ans = max(ans, solve(cur + 1, sign));
ans = max(ans, a[cur] * (sign == 1 ? 1 : -1) + solve(cur + 1, 1 - sign));
return dp[cur][sign] = ans;
}
int main() {
int test;
scanf("%d", &test);
while (test--) {
memset(dp, -1, sizeof(dp));
scanf("%d%d", &n, &q);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
}
printf("%lld\n", solve(0, 1));
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2;
cin >> s1 >> s2;
if (s1 == s2)
cout << -1;
else
cout << max(s2.size(), s1.size());
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
bool ada[105];
int main(){
ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
int t,n,m,a;
cin >> t;
while(t--){
cin >> n >> m;
memset(ada,0,sizeof(ada));
for(int i=1;i<=n;i++){
cin >> a;
ada[a]=true;
}
int ans=0;
for(int i=1;i<=m;i++){
cin >> a;
if(ada[a])ans++;
}
cout << ans << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 1, M = 5e3 + 1;
int n, m, a[N], l[M], r[M], d[N], ans[M];
int z[1000001];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 1; i <= 1000000; ++i) z[i] = z[i - 1] ^ i;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= m; ++i) cin >> l[i] >> r[i];
for (int i = 1; i <= n; ++i) {
d[i - 1] = 0;
for (int j = i; j <= n; ++j) {
if (a[i] < a[j])
d[j] = max(d[j - 1], z[a[j]] ^ z[a[i] - 1]);
else
d[j] = max(d[j - 1], z[a[j] - 1] ^ z[a[i]]);
}
for (int j = 1; j <= m; ++j)
if (i >= l[j]) ans[j] = max(ans[j], d[r[j]]);
}
for (int i = 1; i <= m; ++i) cout << ans[i] << "\n";
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int dz[] = {0, 0, 0, 0, -1, 1}, dx[] = {-1, 0, 1, 0, 0, 0},
dy[] = {0, -1, 0, 1, 0, 0};
int k, n, m;
char plate[10][10][10];
bool seen[10][10][10];
int dfs(int x, int y, int z) {
int ret = 1;
seen[z][x][y] = true;
for (int i = 0; i < (int)(6); i++) {
int az = z + dz[i], ax = x + dx[i], ay = y + dy[i];
if (az < 0 || k <= az || ax < 0 || n <= ax || ay < 0 || m <= ay) continue;
if (plate[az][ax][ay] == '#' || seen[az][ax][ay]) continue;
ret += dfs(ax, ay, az);
}
return ret;
}
int main() {
while (cin >> k >> n >> m) {
for (int i = 0; i < (int)(k); i++)
for (int j = 0; j < (int)(n); j++)
for (int l = 0; l < (int)(m); l++) cin >> plate[i][j][l];
int x, y;
cin >> x >> y;
memset(seen, 0, sizeof(seen));
cout << dfs(x - 1, y - 1, 0) << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct dat {
int in, out, w, v, str;
void get() { scanf("%d%d%d%d%d", &in, &out, &w, &str, &v); }
bool operator<(const dat x) const {
if (out != x.out)
return out < x.out;
else
return in > x.in;
}
};
dat p[503];
int dp[501][1001], n, s, li[1002], sv[502], ans;
int main() {
scanf("%d%d", &n, &s);
for (int i = 1; i <= n; i++) p[i].get();
p[n + 1].in = 0, p[n + 1].out = 3 * n;
p[n + 1].w = 0, p[n + 1].str = s;
p[n + 1].v = 0;
n++;
sort(p + 1, p + n + 1);
for (int i = 1; i <= n; i++)
for (int j = i - 1; j >= 0; j--)
if (p[i].in >= p[j].out) {
li[i] = j;
break;
}
for (int i = 1; i <= n; i++)
for (int j = p[i].w; j <= s; j++) {
for (int k = 1; k < i; k++) {
sv[k] = sv[k - 1];
if (p[i].str >= j - p[i].w && p[k].in >= p[i].in)
sv[k] = max(sv[k], sv[li[k]] + dp[k][j - p[i].w]);
}
dp[i][j] = sv[i - 1] + p[i].v;
if (j) dp[i][j] = max(dp[i][j - 1], dp[i][j]);
ans = max(dp[i][j], ans);
}
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int No_butt, button, count = 0;
bool flag = true;
cin >> No_butt;
vector<int> butt;
if (No_butt == 1) {
cin >> button;
if (button == 1) {
cout << "YES";
} else {
cout << "NO";
}
}
if (No_butt > 1) {
for (int i = 0; i < No_butt; i++) {
cin >> button;
butt.push_back(button);
}
for (int j = 0; j < butt.size(); j++) {
if (butt[j] == 0) {
count++;
if (count > 1) {
flag = false;
}
if (No_butt == 0) {
flag = false;
}
}
}
if (flag == true && count == 1) {
cout << "YES";
} else {
cout << "NO";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, a[100010];
int main() {
while (scanf("%d", &n) != EOF) {
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
sort(a, a + n);
if (n == 1) {
if (a[0] == 1)
puts("2");
else
puts("1");
} else {
if (a[n - 1] == 1)
a[n - 1] = 2;
else
a[n - 1] = 1;
sort(a, a + n);
for (int i = 0; i < n; ++i)
printf("%d%c", a[i], (i == n - 1) ? '\n' : ' ');
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2 * 105000;
const int INF = (int)1e9;
int n, m, num;
int k, q;
int tree[4 * MAXN];
bool ans[MAXN];
int x[MAXN], y[MAXN], xx[MAXN], yy[MAXN];
vector<pair<pair<pair<int, int>, pair<int, int> >, int> > v;
vector<int> lx[MAXN];
vector<int> ly[MAXN];
int getMin(int l, int r) {
l = num + l - 1;
r = num + r - 1;
int res = INF;
while (l <= r) {
if (l & 1) {
res = min(res, tree[l]);
l++;
}
if (r % 2 == 0) {
res = min(res, tree[r]);
r--;
}
l /= 2;
r /= 2;
}
return res;
}
void update(int pos, int val) {
pos = num + pos - 1;
tree[pos] = val;
pos /= 2;
while (pos >= 1) {
tree[pos] = min(tree[pos * 2], tree[pos * 2 + 1]);
pos /= 2;
}
}
int main() {
scanf("%d %d %d %d", &n, &m, &k, &q);
num = 1;
while (num < max(n, m)) num *= 2;
for (int i = 1; i <= k; i++) {
int x, y;
scanf("%d %d", &x, &y);
lx[x].push_back(y);
ly[y].push_back(x);
}
for (int i = 1; i <= q; i++) {
scanf("%d %d %d %d", &x[i], &y[i], &xx[i], &yy[i]);
}
for (int i = 1; i <= q; i++) {
v.push_back(make_pair(
make_pair(make_pair(xx[i], x[i]), make_pair(yy[i], y[i])), i));
}
sort(v.begin(), v.end());
int p = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (int)lx[i].size(); j++) {
int cur = lx[i][j];
update(cur, i);
}
while (p < (int)v.size() && v[p].first.first.first == i) {
int l = v[p].first.second.first, r = v[p].first.second.second;
swap(l, r);
int from = v[p].first.first.second;
if (getMin(l, r) >= from) ans[v[p].second] = true;
p++;
}
}
memset(tree, 0, sizeof(tree));
for (int i = 0; i < q; i++) {
swap(v[i].first.first, v[i].first.second);
}
sort(v.begin(), v.end());
p = 0;
for (int i = 1; i <= m; i++) {
for (int j = 0; j < (int)ly[i].size(); j++) {
int cur = ly[i][j];
update(cur, i);
}
while (p < (int)v.size() && v[p].first.first.first == i) {
int l = v[p].first.second.first, r = v[p].first.second.second;
swap(l, r);
int from = v[p].first.first.second;
if (getMin(l, r) >= from) ans[v[p].second] = true;
p++;
}
}
for (int i = 1; i <= q; i++) {
if (ans[i])
puts("YES");
else
puts("NO");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, a, r, m;
cin >> n >> a >> r >> m;
m = min(m, a + r);
long long sum = 0;
vector<int> h;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
sum += x;
h.push_back(x);
}
sort(h.begin(), h.end());
h.push_back(h.back() + 1);
long long cur = 0, ans = LONG_LONG_MAX;
for (int i = 0; i <= n; i++) {
if (i > 0 && h[i] != h[i - 1]) {
int kmax = h[i] - 1;
if (kmax >= h[i - 1] && kmax * n >= sum) {
ans = min(ans, (sum - cur - kmax * (n - i)) * m + a * (kmax * n - sum));
}
int kmin = h[i - 1];
if (kmin * n < sum) kmin = (sum + n - 1) / n;
if (kmin < h[i]) {
ans = min(ans, (sum - cur - kmin * (n - i)) * m + a * (kmin * n - sum));
}
}
cur += h[i];
}
h.pop_back();
reverse(h.begin(), h.end());
h.push_back(h.back() - 1);
cur = 0;
for (int i = 0; i <= n; i++) {
if (i > 0 && h[i] != h[i - 1]) {
int kmin = h[i] + 1;
if (kmin <= h[i - 1] && kmin * n <= sum) {
ans = min(ans, (cur - sum + kmin * (n - i)) * m + r * (sum - kmin * n));
}
int kmax = h[i - 1];
if (kmax * n > sum) kmax = sum / n;
if (kmax > h[i]) {
ans = min(ans, (cur - sum + kmax * (n - i)) * m + r * (sum - kmax * n));
}
}
cur += h[i];
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 100;
string a, b;
map<char, int> d;
long long hashb[maxn], hasht[maxn], power[maxn];
int z[maxn], base, coso;
void readinp() {
getline(cin, a);
getline(cin, b);
}
void printa() { cout << a << endl; }
void init() {
base = 1e9 + 7;
coso = 29;
power[0] = 1;
for (int i = 1; i <= b.size(); i++) {
hashb[i] = (hashb[i - 1] * coso + b[i - 1]) % base;
power[i] = (power[i - 1] * coso) % base;
}
}
long long gethasht(int i, int j) {
return ((hasht[j] - (hasht[i - 1] * power[j - i + 1]) % base + base) % base);
}
void process() {
init();
for (int i = 0; i < a.size(); i++) {
d[a[i]]++;
}
string t;
t.clear();
for (int i = 0; i < b.size(); i++) {
if (d[b[i]] > 0) {
t.push_back(b[i]);
d[b[i]]--;
hasht[i + 1] = (hasht[i] * coso + b[i]) % base;
} else {
printa();
return;
}
}
int countn = a.size() - b.size();
int i = 1;
int j = b.size() - 1;
while (countn > 0) {
countn--;
int id = 0;
while (i <= j) {
if (j - i + 1 == b.size()) i++;
if (gethasht(i + 1, j + 1) == hashb[j - i + 1]) {
id = j - i + 1;
break;
}
i++;
}
if (d[b[id]] > 0) {
t.push_back(b[id]);
j++;
hasht[j + 1] = (hasht[j] * coso + t[j]) % base;
d[b[id]]--;
} else {
break;
}
}
cout << t;
while (d['0']--) {
cout << '0';
}
while (d['1']--) cout << '1';
}
int main() {
readinp();
if (a.size() < b.size())
printa();
else
process();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 5;
const long long mod = 1e9 + 7;
long long n, m, ans, fa[N], b[N], c[N];
inline long long read() {
long long ret = 0, f = 0;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = 1;
c = getchar();
}
while (isdigit(c)) {
ret = ret * 10 + c - 48;
c = getchar();
}
if (f) return -ret;
return ret;
}
long long find(long long x) {
if (fa[x] == x) return x;
fa[x] = find(fa[x]);
return fa[x];
}
signed main() {
n = read();
m = read();
for (long long i = 0; i <= 2 * n + 3; i++) fa[i] = i;
for (long long i = 1; i <= m; i++) {
long long x = read(), y = read(), opt = 0;
long long xx, yy, xxx, yyy;
char c;
scanf("%c", &c);
if (c == 'x')
opt = 0;
else
opt = 1;
if (x <= y) {
xx = 1;
yy = y - x + 1;
} else {
yy = 1;
xx = x - y + 1;
yy += xx - 1;
xx = 1;
}
if (x <= n - y + 1) {
xxx = 1;
yyy = y + x - 1;
} else {
yyy = n;
xxx = x - (n - y);
yyy -= xxx - 1;
xxx = 1;
}
yy++;
yyy++;
yy -= 2;
if (opt == 0) {
fa[find(2 * yy)] = find(2 * yyy);
fa[find(2 * yy + 1)] = find(2 * yyy + 1);
} else {
fa[find(2 * yy)] = find(2 * yyy + 1);
fa[find(2 * yy + 1)] = find(2 * yyy);
}
}
for (long long i = 0; i <= n + 1; i++)
if (find(2 * i) == find(2 * i + 1)) {
puts("0");
return 0;
}
for (long long i = 0; i <= 2 * n + 3; i++)
if (find(i) == i) ans++;
ans /= 2;
ans -= 2;
long long res = 1;
for (long long i = 1; i <= ans; i++) res = res * 2 % mod;
cout << res;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int k = 0;
for (int i = 1; i < n; i++) {
if (a[i] % a[0] != 0) {
k = 1;
break;
}
}
if (k == 1)
cout << -1;
else
cout << a[0];
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const int maxn = 200005;
const int maxm = 10005;
struct node {
long long minn, maxx;
friend bool operator<(node a, node b) { return a.maxx > b.maxx; }
int id;
} a[maxn];
struct node2 {
long long bi;
int id;
} b[maxn];
int vis[maxn], ans[maxn];
long long x[maxn], y[maxn];
bool cmp(node a, node b) { return a.minn < b.minn; }
bool cmp2(node2 a, node2 b) { return a.bi < b.bi; }
int main() {
int n, m;
scanf("%d%d", &n, &m);
priority_queue<node> q;
for (int i = 0; i < n; i++) scanf("%lld%lld", &x[i], &y[i]);
for (int i = 0; i < m; i++) {
scanf("%lld", &b[i].bi);
b[i].id = i;
}
for (int i = 1; i < n; i++) {
a[i].id = i;
a[i].minn = x[i] - y[i - 1];
a[i].maxx = y[i] - x[i - 1];
}
int cnt = 0;
int flag = 0;
sort(a + 1, a + n, cmp);
sort(b, b + m, cmp2);
int j = 1;
for (int i = 0; i < m; i++) {
while (j < n && a[j].minn <= b[i].bi && b[i].bi <= a[j].maxx) {
q.push(a[j]);
j++;
}
if (q.size() == 0) continue;
node now = q.top();
q.pop();
if (now.maxx < b[i].bi) {
flag = 1;
break;
}
cnt++;
ans[now.id] = b[i].id;
}
if (cnt < n - 1) {
printf("No\n");
return 0;
}
if (flag == 1) {
printf("No\n");
} else {
printf("Yes\n");
for (int i = 1; i < n; i++) printf("%d ", ans[i] + 1);
printf("\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct cc {
int first;
int second;
};
bool io(cc x, cc y) { return x.first < y.first; }
int main() {
int n;
cin >> n;
int k;
cin >> k;
cc a[n];
for (int i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i + 1;
}
int b[n];
for (int i = 0; i < n; i++) {
b[i] = a[i].first;
}
if (n == 1) {
cout << 0 << ' ' << 0;
return 0;
}
int m = 0;
while (k--) {
sort(b, b + n);
if (b[0] == b[n - 1] || b[n - 1] == b[0] + 1) {
break;
}
m++;
b[0]++;
b[n - 1]--;
}
sort(b, b + n);
cout << b[n - 1] - b[0] << ' ' << m << endl;
while (m--) {
sort(a, a + n, io);
cout << a[n - 1].second << ' ' << a[0].second << endl;
a[0].first++;
a[n - 1].first--;
}
}
| 3 |
#include <bits/stdc++.h>
const int MaxN = 100000;
struct Graph {
int cnte;
int Head[MaxN + 5], To[MaxN * 2 + 5], Next[MaxN * 2 + 5];
inline void addEdge(int from, int to) {
cnte++;
To[cnte] = to;
Next[cnte] = Head[from];
Head[from] = cnte;
}
};
int N;
int Dep[MaxN + 5], Deg[MaxN + 5], HaveLeaf[MaxN + 5];
Graph G;
void init() {
scanf("%d", &N);
for (int i = 1; i < N; ++i) {
int u, v;
scanf("%d %d", &u, &v);
G.addEdge(u, v);
G.addEdge(v, u);
Deg[u]++, Deg[v]++;
}
}
void dfs(int u, int f) {
for (int i = G.Head[u]; i; i = G.Next[i]) {
int v = G.To[i];
if (v == f) continue;
Dep[v] = Dep[u] + 1;
dfs(v, u);
}
}
void solve() {
dfs(1, 0);
bool haveOddLeaf = false, haveEvenLeaf = false;
for (int i = 1; i <= N; ++i) {
if (Deg[i] != 1) continue;
if (Dep[i] & 1)
haveOddLeaf = true;
else
haveEvenLeaf = true;
}
if (haveOddLeaf && haveEvenLeaf)
printf("%d ", 3);
else
printf("%d ", 1);
int locked = 0;
for (int i = 1; i <= N; ++i) {
if (Deg[i] != 1) continue;
int v = G.To[G.Head[i]];
HaveLeaf[v]++;
}
for (int i = 1; i <= N; ++i)
if (HaveLeaf[i] != 0) locked += HaveLeaf[i] - 1;
printf("%d\n", N - 1 - locked);
}
int main() {
init();
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string dectobin(long long x) {
string p = "";
if (x == 0) {
return "0";
}
while (x != 0) {
if (x % 2 == 0) {
p = '0' + p;
} else {
p = '1' + p;
}
x = x / 2;
}
return p;
}
long long b[5010][5010];
long long h[5010];
int main() {
long long n, k;
cin >> n >> k;
long long arr[n];
for (int i = 0; i < n; ++i) {
cin >> arr[i];
++h[arr[i]];
if (h[arr[i]] > k) {
cout << "NO";
return 0;
}
}
cout << "YES\n";
long long f = 0;
for (long long i = 0; i < n; ++i) {
while (b[arr[i]][f % k + 1] > 0) {
++f;
}
cout << f % k + 1 << " ";
++b[arr[i]][f % k + 1];
++f;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int x, n, p;
double p1, p2;
double ans;
double f[201][259][259][2];
inline bool xlow(int x, int t) { return (x & (1 << t - 1)) != 0; }
int number(int x, int l) {
bool t = xlow(x, l);
int nn = 0;
while (xlow(x, l) == t) {
l++;
nn++;
}
return nn;
}
int len(int j, int k, int c) {
if (j == 0) {
if (c == 0)
return 7 + k;
else
return 8;
}
for (int ii = 1; ii <= 8; ii++)
if (xlow(j, ii)) return ii - 1;
}
int main() {
scanf("%d%d%d", &x, &n, &p);
p2 = p / 100.0;
p1 = 1 - p2;
if (!xlow(x, 8) && xlow(x, 9))
f[0][x & 255][number(x, 9)][1] = 1;
else
f[0][x & 255][number(x, 8)][0] = 1;
for (int i = 0; i < n; i++)
for (int j = 0; j <= 255; j++)
for (int k = 1; k <= 232; k++)
for (int c = 0; c <= 1; c++) {
if (f[i][j][k][c] == 0) continue;
int jj, kk, cc;
jj = j + 1;
if (xlow(jj, 8) && c == 1) {
cc = 0;
kk = k + 1;
}
if (xlow(jj, 8) && c == 0) {
cc = 0;
if (xlow(j, 8))
kk = k;
else
kk = 1;
}
if (!xlow(jj, 8) && c) {
cc = 1;
kk = k;
}
if (!xlow(jj, 8) && !c) {
cc = 0;
kk = k;
}
jj &= 255;
f[i + 1][jj][kk][cc] += f[i][j][k][c] * p1;
jj = j * 2;
if (!xlow(j, 8) && c == 1) {
cc = 0;
kk = !xlow(j, 7) + 1;
}
if (!xlow(j, 8) && c == 0) {
cc = 0;
if (!xlow(j, 7))
kk = k + 1;
else
kk = 1;
}
if (xlow(j, 8)) {
if (!xlow(j, 7)) {
kk = k;
cc = 1;
} else {
cc = 0;
kk = k + 1;
}
}
jj &= 255;
f[i + 1][jj][kk][cc] += f[i][j][k][c] * p2;
}
for (int j = 0; j <= 255; j++)
for (int k = 1; k <= 240; k++)
for (int c = 0; c <= 1; c++)
if (f[n][j][k][c] > 0) ans += f[n][j][k][c] * len(j, k, c);
printf("%.16f\n", ans);
}
| 8 |
#include <bits/stdc++.h>
typedef struct p {
int x;
int y;
} Punto;
void calculo(Punto vec[], int n, long long int j);
void cargarvector(Punto vec[], int n);
int main() {
int n, i;
long long int j;
scanf("%d", &n);
scanf("%I64d", &j);
Punto vec[n + 1];
cargarvector(vec, n + 1);
calculo(vec, n + 1, j);
printf("%d %d", vec[0].x, vec[0].y);
return 0;
}
void cargarvector(Punto vec[], int n) {
int i;
for (i = 0; i < n; i++) {
scanf("%d", &vec[i].x);
scanf("%d", &vec[i].y);
}
}
void calculo(Punto vec[], int n, long long int j) {
int i, p;
i = 1;
j = j % ((n - 1) * 2);
for (p = 0; p < j; p++) {
vec[0].x = 2 * vec[i].x - vec[0].x;
vec[0].y = 2 * vec[i].y - vec[0].y;
if (i == n - 1) {
i = 0;
}
i = i + 1;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool bsearch(vector<long long> v1, int m) {
long long ans = 0;
int k;
for (k = 0; k < m + 1; k++) ans += v1[k];
for (k = m + 1; k < v1.size(); k++) {
if (ans >= v1[k])
ans += v1[k];
else
return false;
}
return true;
}
void solve() {
long long p, d, n;
cin >> p >> d;
n = p - d;
long long ans = p;
long long f = p;
int x = p % 10;
long long j = 0;
if (x != 9) {
x++;
if (ans - x >= n) {
ans -= x;
f = ans;
} else {
cout << ans;
return;
}
}
j++;
string s;
stringstream ss;
ss << ans;
ss >> s;
long long m = 10;
int k = s.size() - 1;
int z = 0;
while (k >= 0) {
int y = s[k] - 48;
if (y == 9)
z++;
else
break;
k--;
}
while (ans - m >= n && j < s.size()) {
ans -= m;
stringstream sp;
sp << ans;
sp >> s;
int y = s[s.size() - j - 1] - 48;
if (y == 9) {
k = s.size() - 1;
int w = 0;
while (k >= 0) {
int y = s[k] - 48;
if (y == 9)
w++;
else
break;
k--;
}
if (w > z) {
z = w;
f = ans;
}
j++;
m *= 10;
}
}
cout << f;
return;
}
int main() {
int t, i;
t = 1;
for (i = 0; i < t; i++) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
double p, dp[N][N];
int n, t;
double solve(int rem, int time) {
if (!time) return n - rem;
double &ret = dp[rem][time];
if (ret == ret) return ret;
double ans;
if (rem)
ans = solve(rem - 1, time - 1) * p + solve(rem, time - 1) * (1 - p);
else
ans = solve(rem, time - 1);
return ret = ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> p >> t;
memset(dp, -1, sizeof dp);
cout << fixed << setprecision(6) << solve(n, t);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
const ll N = 1e7;
ll prime[N];
ll tot_fact[N];
ll power(ll x, ll y) {
ll temp;
if (y == 0) return 1;
temp = power(x, y / 2);
if (y % 2 == 0)
return (temp % MOD * temp % MOD) % MOD;
else
return ((x % MOD * temp % MOD) % MOD * temp % MOD) % MOD;
}
void solve() {
ll a, b, n, x;
cin >> a >> b >> n >> x;
ll tans = power(a, n);
if (a == 1) {
cout << (x % MOD + (n % MOD * b % MOD) % MOD) % MOD;
return;
}
ll p = (tans - 1) % MOD;
ll tt = power(a - 1, MOD - 2);
ll t = (tt % MOD * p % MOD) % MOD;
ll ans = ((tans % MOD * x % MOD) % MOD + (b % MOD * t) % MOD) % MOD;
cout << ans;
}
int main() {
int t = 1;
while (t--) solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int T;
int main() {
ios_base::sync_with_stdio(0);
cin >> T;
while (T--) {
int n;
cin >> n;
string stroka;
cin >> stroka;
int ans = 0;
string temp = stroka;
sort(temp.begin(), temp.end());
for (int i = 0; i < n; i++)
if (temp[i] != stroka[i]) ans++;
cout << ans << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const int mod = inf + 7;
const double eps = 1e-9;
const double pi = acos(-1.0);
long long read_long() {
long long ans = 0;
char c;
bool started = false;
bool is_negative = false;
while (true) {
c = getchar();
if ((c < '0' || c > '9') && c != '-' && !started) continue;
if ((c < '0' || c > '9') && c != '-' && started) break;
if (started) {
ans = ans * 10;
}
started = true;
if (c == '-')
is_negative = true;
else
ans += c - '0';
}
if (is_negative) ans *= -1;
return ans;
}
char tmp[200200];
vector<vector<int> > ans;
deque<int> ones;
string second;
int n;
int main() {
scanf("%s", tmp);
second = tmp;
n = (int)second.size();
set<pair<int, int> > st;
for (int i = 0; i < n; i++) {
if (second[i] == '0') {
if (ans.empty()) {
vector<int> t;
t.push_back(i + 1);
ans.push_back(t);
st.insert(make_pair(i + 1, (int)ans.size() - 1));
} else if (ones.size() > 0) {
int x = ones.front();
ones.pop_front();
if ((*st.begin()).first > x) {
ones.push_front(x);
vector<int> t;
t.push_back(i + 1);
ans.push_back(t);
st.insert(make_pair(i + 1, (int)ans.size() - 1));
} else {
__typeof(st.begin()) it = st.lower_bound(make_pair(x, -1));
it--;
int best = (*it).second;
st.erase(make_pair(ans[best].back(), best));
ans[best].push_back(x);
ans[best].push_back(i + 1);
st.insert(make_pair(i + 1, best));
}
} else {
vector<int> t;
t.push_back(i + 1);
ans.push_back(t);
st.insert(make_pair(i + 1, (int)ans.size() - 1));
}
} else {
ones.push_back(i + 1);
}
}
if (ones.size() > 0)
printf("-1\n");
else {
printf("%d\n", (int)ans.size());
for (__typeof(ans.begin()) it = ans.begin(); it != ans.end(); it++) {
vector<int> v = *it;
printf("%d", (int)v.size());
for (__typeof(v.begin()) it2 = v.begin(); it2 != v.end(); it2++)
printf(" %d", *it2);
printf("\n");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
using namespace chrono;
long long int advceil(long long int num, long long int den) {
return (num % den == 0 ? num / den : num / den + 1);
}
long long int lstbt(long long int val) {
long long int msk = val & (val - 1);
return log2(val ^ msk);
}
long long int modexpo(long long int a, long long int b) {
long long int res = 1;
while (b > 0) {
if (b & 1) res = (res % 1000000007 * a % 1000000007) % 1000000007;
a = (a % 1000000007 * a % 1000000007);
b /= 2;
}
return res;
}
long long int expo(long long int a, long long int b) {
long long int res = 1;
while (b > 0) {
if (b & 1) res = (res * a);
a = (a * a);
b /= 2;
}
return res;
}
long long int gcd(long long int a, long long int b) {
return a == 0 ? b : gcd(b % a, a);
}
vector<long long int> CALCfactor(long long int n) {
vector<long long int> factor(n + 2, 0);
for (long long int i = 4; i <= n; i += 2) factor[i] = 2;
for (long long int j = 3; j <= n; j += 2) {
if (factor[j]) continue;
for (long long int i = 2 * j; i <= n; i += j) factor[i] = j;
}
return factor;
}
vector<long long int> CALCprimeNUM(long long int n) {
vector<long long int> factor = CALCfactor(n);
vector<long long int> primeNUM;
primeNUM.reserve(n + 2);
for (long long int i = 2; i <= n; i++)
if (!factor[i]) primeNUM.push_back(i);
return primeNUM;
}
vector<long long int> CALCprimeFACTOR(long long int n) {
vector<long long int> factor = CALCfactor(n);
vector<long long int> ans;
while (factor[n] != 0) {
ans.push_back(factor[n]);
n /= factor[n];
}
ans.push_back(n);
return ans;
}
vector<long long int> unique(vector<long long int> x) {
sort(x.begin(), x.end());
set<long long int> s;
vector<long long int> ans;
ans.reserve(x.size());
for (auto elem : x) s.insert(elem);
for (auto elem : s) ans.push_back(elem);
return ans;
}
vector<long long int> ZALGO(string s, string pat) {
long long int lens = pat.length();
pat += char(36);
pat += s;
s = pat;
vector<long long int> pref(s.length() + 1, 0);
pref[0] = s.length();
long long int spt = -1;
long long int ept = -1;
long long int processCnt = 0;
for (long long int i = 1; i < s.length(); i++) {
bool isdone = false;
if (i <= ept and i >= spt) {
if (pref[i - spt] + i <= ept) pref[i] = pref[i - spt], isdone = true;
processCnt++;
}
if (!isdone) {
long long int ptr = i;
long long int lo = 0;
while (s[lo] == s[ptr]) ptr++, lo++, processCnt++;
if (ept < ptr - 1) {
spt = i;
ept = ptr - 1;
}
pref[i] = lo;
}
}
vector<long long int> ans;
ans.reserve(s.length() - lens);
for (long long int i = lens + 1; i < s.length(); i++) ans.push_back(pref[i]);
return ans;
}
void spclSort(
vector<pair<pair<long long int, long long int>, long long int>> &v) {
long long int n = v.size();
{
vector<long long int> cnt(n);
for (auto elem : v) {
cnt[elem.first.second]++;
}
vector<pair<pair<long long int, long long int>, long long int>> a_new(n);
vector<long long int> pos(cnt.size());
pos[0] = 0;
for (long long int i = 1; i < cnt.size(); i++) {
pos[i] = cnt[i - 1] + pos[i - 1];
}
for (auto elem : v) {
a_new[pos[elem.first.second]] = elem;
pos[elem.first.second]++;
}
v = a_new;
}
{
vector<long long int> cnt(n, 0);
for (auto elem : v) {
cnt[elem.first.first]++;
}
vector<pair<pair<long long int, long long int>, long long int>> a_new(n);
vector<long long int> pos(cnt.size());
pos[0] = 0;
for (long long int i = 1; i < cnt.size(); i++) {
pos[i] = cnt[i - 1] + pos[i - 1];
}
for (auto elem : v) {
a_new[pos[elem.first.first]] = elem;
pos[elem.first.first]++;
}
v = a_new;
}
}
pair<vector<vector<long long int>>, vector<vector<long long int>>> getOrdering(
string s) {
s += char(36);
vector<vector<long long int>> dp;
dp.reserve(log2(s.length()) + 3);
vector<vector<long long int>> dp2;
dp2.reserve(log2(s.length()) + 3);
vector<long long int> ordering(s.length()), eqClass(s.length());
{
vector<pair<char, long long int>> temp(s.length());
for (long long int i = 0; i < s.length(); i++) temp[i] = {s[i], i};
sort(temp.begin(), temp.end());
for (long long int i = 0; i < temp.size(); i++)
ordering[temp[i].second] = i;
eqClass[temp[0].second] = 0;
for (long long int i = 1; i < temp.size(); i++) {
if (temp[i].first != temp[i - 1].first)
eqClass[temp[i].second] = eqClass[temp[i - 1].second] + 1;
else
eqClass[temp[i].second] = eqClass[temp[i - 1].second];
}
dp.push_back(ordering);
dp2.push_back(eqClass);
}
long long int k = 1;
while ((1 << (k - 1)) < s.length()) {
vector<pair<pair<long long int, long long int>, long long int>> arr(
s.length());
for (long long int i = 0; i < s.length(); i++) {
arr[i] = {{eqClass[i], eqClass[(i + (1 << (k - 1))) % s.length()]}, i};
}
spclSort(arr);
for (long long int i = 0; i < s.length(); i++) ordering[arr[i].second] = i;
eqClass[arr[0].second] = 0;
for (long long int i = 1; i < s.size(); i++) {
if (arr[i].first != arr[i - 1].first)
eqClass[arr[i].second] = eqClass[arr[i - 1].second] + 1;
else
eqClass[arr[i].second] = eqClass[arr[i - 1].second];
}
dp.push_back(ordering);
dp2.push_back(eqClass);
k++;
}
return {dp, dp2};
}
vector<long long int> sortOrdering(vector<vector<long long int>> dp) {
vector<long long int> arr = dp[dp.size() - 1];
vector<long long int> ans(arr.size());
long long int cnt = 0;
for (auto elem : arr) {
ans[elem] = cnt;
cnt++;
}
return ans;
}
vector<long long int> getLps(string pat) {
long long int i = 1;
long long int j = 0;
vector<long long int> lps(pat.length(), 0);
lps[0] = 0;
while (i < pat.length()) {
if (pat[i] == pat[j])
lps[i] = j + 1, i++, j++;
else if (j == 0)
lps[i] = 0, i++;
else
j = lps[j - 1];
}
return lps;
}
bool comp(long long int a, long long int b) { return a > b; }
void solve() {
long long int n;
cin >> n;
vector<long long int> arr(n);
for (long long int i = 0; i < n; i++) cin >> arr[i];
;
long long int lo = 0;
long long int hi = n - 1;
long long int ans = -1;
while (lo <= hi) {
long long int mid = (lo + hi) / 2;
bool canweplace = true;
vector<long long int> freq(n + 1, 0);
for (long long int i = 0; i < n; i++) freq[arr[i]]++;
set<pair<long long int, long long int>,
greater<pair<long long int, long long int>>>
s;
for (long long int i = 0; i <= n; i++)
if (freq[i] > 0) s.insert({freq[i], i});
vector<long long int> b;
b.reserve(n + 1);
b.push_back(-1);
for (long long int i = 1; i <= n; i++) {
if (i > mid + 1 and freq[b[i - mid - 1]]) {
s.insert({freq[b[i - mid - 1]], b[i - mid - 1]});
}
if (s.empty()) {
canweplace = false;
break;
}
pair<long long int, long long int> elem = *(s.begin());
s.erase(s.begin());
b.push_back(elem.second);
freq[elem.second]--;
}
if (canweplace) {
}
if (canweplace) {
ans = mid;
lo = mid + 1;
} else {
hi = mid - 1;
}
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
auto start1 = high_resolution_clock::now();
long long int t;
cin >> t;
while (t--) solve();
auto stop1 = high_resolution_clock::now();
auto duration = duration_cast<microseconds>(stop1 - start1);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf_int = 2e9;
const long long inf_ll = 2e18;
int Gcd(int p, int q) { return q == 0 ? p : Gcd(q, p % q); }
int Pow(int p, int q) {
int ans = 1;
while (q) {
if (q & 1) ans = ans * p;
p = p * p;
q >>= 1;
}
return ans;
}
inline int read() {
int ra, fh;
char rx;
rx = getchar(), ra = 0, fh = 1;
while ((rx < '0' || rx > '9') && rx != '-') rx = getchar();
if (rx == '-') fh = -1, rx = getchar();
while (rx >= '0' && rx <= '9') ra *= 10, ra += rx - 48, rx = getchar();
return ra * fh;
}
bitset<1005> bit[1005];
bitset<1005> s;
int ans[100005], op[100005], a[100005], b[100005];
vector<int> v[100005];
void dfs(int x) {
if (x == 0) {
for (int i = 0; i < v[x].size(); i++) {
ans[v[x][i]] = ans[x];
dfs(v[x][i]);
}
}
if (op[x] == 1) {
int flag = 0;
if (!bit[a[x]][b[x]]) {
flag = 1;
ans[x]++;
bit[a[x]][b[x]] = 1;
}
for (int i = 0; i < v[x].size(); i++) {
ans[v[x][i]] = ans[x];
dfs(v[x][i]);
}
if (flag) bit[a[x]][b[x]] = 0;
} else if (op[x] == 2) {
int flag = 0;
if (bit[a[x]][b[x]]) {
flag = 1;
ans[x]--;
bit[a[x]][b[x]] = 0;
}
for (int i = 0; i < v[x].size(); i++) {
ans[v[x][i]] = ans[x];
dfs(v[x][i]);
}
if (flag) bit[a[x]][b[x]] = 1;
} else if (op[x] == 3) {
ans[x] -= bit[a[x]].count();
bit[a[x]] ^= s;
ans[x] += bit[a[x]].count();
for (int i = 0; i < v[x].size(); i++) {
ans[v[x][i]] = ans[x];
dfs(v[x][i]);
}
bit[a[x]] ^= s;
} else {
for (int i = 0; i < v[x].size(); i++) {
ans[v[x][i]] = ans[x];
dfs(v[x][i]);
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = (1), _ed = (m); i <= _ed; i++) s[i] = 1;
for (int i = (1), _ed = (q); i <= _ed; i++) {
op[i] = read();
if (op[i] == 1 || op[i] == 2) {
a[i] = read(), b[i] = read();
} else
a[i] = read();
if (op[i] == 4) {
v[a[i]].push_back(i);
} else {
v[i - 1].push_back(i);
}
}
dfs(0);
for (int i = (1), _ed = (q); i <= _ed; i++) printf("%d\n", ans[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b;
cin >> a >> b;
if (a % 2 != 0) a++;
if (abs(a - b) < 2) {
cout << "-1" << endl;
return 0;
} else {
cout << a << " " << a + 1 << " " << a + 2 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[4] = {0};
string s;
cin >> n >> s;
if (n % 4)
cout << "===";
else {
string ans = s, x = "";
for (int i = 0; i < n; i++) {
if (s[i] == 'A')
a[0]++;
else if (s[i] == 'C')
a[1]++;
else if (s[i] == 'G')
a[2]++;
else if (s[i] == 'T')
a[3]++;
}
for (int i = 0; i < 4; i++) {
if (a[i] > n / 4) {
ans = "===";
break;
}
}
if (ans != "===") {
x.insert(0, n / 4 - a[0], 'A');
x.insert(0, n / 4 - a[1], 'C');
x.insert(0, n / 4 - a[2], 'G');
x.insert(0, n / 4 - a[3], 'T');
for (int i = 0; i < n; i++) {
if (s[i] == '?') {
s[i] = x[0];
x.erase(0, 1);
}
}
ans = s;
}
cout << ans;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
long long a[n + 1];
map<int, int> freq;
int mx = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
freq[a[i]]++;
mx = max(mx, freq[a[i]]);
}
int pos;
for (int i = 1; i <= n; i++) {
if (freq[a[i]] == mx) {
pos = i;
break;
}
}
vector<pair<int, pair<int, int> > > ans;
for (int i = pos; i >= 2; i--) {
if (a[i] == a[i - 1]) {
continue;
} else if (a[i] < a[i - 1]) {
ans.push_back({2, {i - 1, i}});
a[i - 1] = a[i];
} else {
ans.push_back({1, {i - 1, i}});
a[i - 1] = a[i];
}
}
for (int i = pos; i < n; i++) {
if (a[i] == a[i + 1]) {
continue;
} else if (a[i] < a[i + 1]) {
ans.push_back({2, {i + 1, i}});
a[i + 1] = a[i];
} else {
ans.push_back({1, {i + 1, i}});
a[i + 1] = a[i];
}
}
cout << (int)ans.size() << endl;
for (auto it : ans) {
cout << it.first << " " << it.second.first << " " << it.second.second
<< endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long pw(long long b, long long p) {
if (!p) return 1;
long long sq = pw(b, p / 2);
sq *= sq;
if (p % 2) sq *= b;
return sq;
}
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
long long sd(long long x) { return x < 10 ? x : x % 10 + sd(x / 10); }
long long lcm(long long a, long long b) { return ((a * b) / gcd(a, b)); }
long long cnt1, cnt2, x, y, LCM;
long long BS() {
LCM = x * y;
long long s = 0, e = 1e18, m, b, ft, rf, st, rs, rem;
while (s <= e) {
m = s + (e - s) / 2;
ft = m / y - m / LCM;
st = m / x - m / LCM;
rf = max(0LL, cnt1 - ft);
rs = max(0LL, cnt2 - st);
rem = m - ft - st - m / LCM;
if (rem >= rf + rs) {
b = m;
e = m - 1;
} else
s = m + 1;
}
return b;
}
int main() {
cin >> cnt1 >> cnt2 >> x >> y;
printf("%lld\n", BS());
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct arr {
int W[10];
};
arr MAX, C[4 * 200005];
vector<int> a[200005], V[200005];
int cnt[200005], T[200005], P[20][200005], pos[200005], num, B[200005],
d[200005];
int n, m, q;
void DFS1(int u, int par) {
cnt[u] = 1;
for (int i = 0; i < a[u].size(); i++) {
int v = a[u][i];
if (v == par) continue;
T[v] = T[u] + 1;
P[0][v] = u;
DFS1(v, u);
cnt[u] += cnt[v];
}
}
void DFS2(int u, int par) {
int Ma = 0;
pos[u] = ++num;
d[num] = u;
if (B[u] == 0) B[u] = pos[u];
for (int i = 0; i < a[u].size(); i++) {
int v = a[u][i];
if (v == par) continue;
if (cnt[Ma] < cnt[v] || Ma == 0) Ma = v;
}
if (Ma == 0) return;
B[Ma] = B[u];
DFS2(Ma, u);
for (int i = 0; i < a[u].size(); i++) {
int v = a[u][i];
if (v == par || v == Ma) continue;
DFS2(v, u);
}
}
int PAR(int u, int h) {
int hi = T[u] - h;
for (int i = 0; i < 20; i++)
if (((hi >> i) & 1)) u = P[i][u];
return u;
}
int LCA(int u, int v) {
if (T[u] < T[v]) swap(u, v);
u = PAR(u, T[v]);
if (u == v) return u;
for (int i = 19; i >= 0; i--)
if (P[i][u] != P[i][v]) {
u = P[i][u];
v = P[i][v];
}
return P[0][u];
}
arr Merge(arr P, arr Q) {
arr R;
int pos1 = 0, pos2 = 0;
for (int i = 0; i < 10; i++) {
if (P.W[pos1] > Q.W[pos2]) {
R.W[i] = Q.W[pos2];
pos2++;
} else {
R.W[i] = P.W[pos1];
pos1++;
}
}
return R;
}
void Update(int node, int l, int r, int pos, int Val) {
if (l == r && l == pos) {
for (int i = 0; i < 10; i++)
if (C[node].W[i] >= Val) swap(C[node].W[i], Val);
return;
}
if (l > pos || r < pos) return;
int g = (l + r) / 2;
Update(node * 2, l, g, pos, Val);
Update(node * 2 + 1, g + 1, r, pos, Val);
C[node] = Merge(C[2 * node], C[2 * node + 1]);
}
arr Get_Val(int node, int l, int r, int d, int c) {
if (d <= l && r <= c) return C[node];
if (d > r || l > c) return MAX;
int g = (l + r) / 2;
arr u = Get_Val(node * 2, l, g, d, c);
arr v = Get_Val(node * 2 + 1, g + 1, r, d, c);
return Merge(u, v);
}
arr Get(int u, int par) {
arr r = MAX;
while (T[d[B[u]]] > T[par]) {
r = Merge(r, Get_Val(1, 1, n, B[u], pos[u]));
u = P[0][d[B[u]]];
}
r = Merge(r, Get_Val(1, 1, n, pos[par], pos[u]));
return r;
}
int main() {
cin >> n >> m >> q;
int u, v, A;
for (int i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
a[u].push_back(v);
a[v].push_back(u);
}
for (int i = 0; i < 10; i++) MAX.W[i] = 1e9;
DFS1(1, 0);
for (int j = 1; j < 20; j++)
for (int i = 1; i <= n; i++) P[j][i] = P[j - 1][P[j - 1][i]];
DFS2(1, 0);
for (int i = 1; i <= m; i++) {
scanf("%d", &u);
V[u].push_back(i);
}
for (int i = 0; i < 4 * 200005; i++) C[i] = MAX;
for (int i = 1; i <= n; i++)
for (int j = 0; j < V[i].size(); j++) Update(1, 1, n, pos[i], V[i][j]);
while (q--) {
scanf("%d%d%d", &u, &v, &A);
if (T[u] > T[v]) swap(u, v);
int par = LCA(u, v);
arr P = Get(u, par), Q = MAX;
if (u != v) Q = Get(v, PAR(v, T[par] + 1));
P = Merge(P, Q);
for (int i = 9; i >= -1; i--) {
if (i == -1) {
A = -1;
break;
}
if (P.W[i] != 1e9) {
A = min(A - 1, i);
break;
}
}
printf("%d ", A + 1);
for (int i = 0; i <= A; i++) printf("%d ", P.W[i]);
printf("\n");
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a;
cin >> a;
if (a < 13)
cout << setprecision(14) << pow(2, a);
else
cout << setprecision(36) << 8092 * pow(2, a - 13);
}
| 5 |
#include <bits/stdc++.h>
int main() {
long long int n, m, i, boy[100000], girl[100000],
bmax = INT_MIN, bmax2 = INT_MIN, gmin = INT_MAX, bsum = 0, gsum = 0, ans;
scanf("%I64d %I64d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%I64d", &boy[i]);
if (boy[i] > bmax) {
bmax2 = bmax;
bmax = boy[i];
} else if (bmax2 < boy[i]) {
bmax2 = boy[i];
}
bsum += boy[i];
}
for (i = 1; i <= m; i++) {
scanf("%I64d", &girl[i]);
if (girl[i] < gmin) gmin = girl[i];
gsum += girl[i];
}
if (gmin < bmax) {
printf("-1\n");
} else {
ans = bsum * m;
ans += gsum;
ans -= bmax * m;
if (bmax < gmin) {
ans += (bmax - bmax2);
}
printf("%I64d\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, l, r, u, x, y;
int dp[100000];
pair<int, int> a[100000];
int b[100000];
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
cout.tie();
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> x >> y;
a[i] = make_pair(x, y);
b[max(x - y, 0)] += 1;
b[min(x + y, m)] -= 1;
}
for (int i = 1; i <= m; i++) b[i] += b[i - 1];
dp[m] = 0;
for (int i = m - 1; i >= 0; i--) {
dp[i] = m - i;
if (b[i] > 0) {
dp[i] = dp[i + 1];
continue;
}
for (int j = 1; j <= n; j++) {
l = a[j].first - a[j].second;
if (i >= l) continue;
r = a[j].first + a[j].second;
u = l - i - 1;
dp[i] = min(dp[i], u + dp[min(m, r + u)]);
}
}
cout << dp[0];
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e19;
long long inf = 1e19;
long long get_pow(long long a, long long b) {
long long ans = 1;
while (b > 0) {
if (b % 2 == 1) ans = (ans * a) % mod;
b /= 2;
a = (a * a) % mod;
}
return ans;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
long long o = 0, z = 0;
for (long long i = 0; i < n; i++) {
if (a[i] == 0) z++;
if (a[i] == 1) o++;
}
if (z == n)
cout << 0 << endl;
else
cout << o * get_pow(2, z) << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1007;
long double sum[MAXN];
int n, m, cnt[MAXN], must[MAXN], may[MAXN], sum_may, sum_must;
long double dp[MAXN][MAXN];
vector<pair<int, int>> items;
long double comb(int n, int m) { return exp(-sum[n] + sum[n - m] + sum[m]); }
int main() {
for (int i = 1; i < MAXN; i++) {
sum[i] += sum[i - 1] + log(i);
}
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int x;
cin >> cnt[i];
for (int j = 0; j < cnt[i]; j++) {
cin >> x;
items.push_back({x, i});
}
}
sort(items.rbegin(), items.rend());
int V = items[n - 1].first;
for (auto &item : items) {
if (item.first > V) {
must[item.second]++;
sum_must++;
} else if (item.first == V) {
may[item.second]++;
sum_may++;
}
}
dp[0][0] = 1;
for (int i = 1; i <= m; i++) {
dp[i][0] = dp[i - 1][0] * comb(cnt[i], must[i]);
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n - sum_must; j++) {
if (may[i]) {
dp[i][j] = dp[i - 1][j] * comb(cnt[i], must[i]) +
dp[i - 1][j - 1] * comb(cnt[i], must[i] + 1);
} else {
dp[i][j] = dp[i - 1][j] * comb(cnt[i], must[i]);
}
}
}
cout << setprecision(12) << dp[m][n - sum_must] * comb(sum_may, n - sum_must)
<< endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &t) {
t = 0;
char ch = getchar();
int f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
do {
(t *= 10) += ch - '0';
ch = getchar();
} while ('0' <= ch && ch <= '9');
t *= f;
}
const int maxn = (1e5) + 10;
int n, q, ans;
bool d[2][maxn];
int main() {
read(n);
read(q);
int x, y, delta;
while (q--) {
read(x);
read(y);
x--;
if (d[x][y])
delta = -1;
else
delta = 1;
d[x][y] ^= 1;
for (int i = -1; i <= 1; i++)
if (d[x ^ 1][y + i]) ans += delta;
if (!ans)
printf("Yes\n");
else
printf("No\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
char s[maxn], t[maxn];
int p[maxn], q[maxn], r[maxn];
int main() {
int n, m, k, d;
scanf("%s%d", s, &m);
n = strlen(s);
while (m--) {
scanf("%d%d", &k, &d);
for (int i = 0; i < n; i++) p[i] = q[i] = i;
int id = 0;
for (int i = 0; i < d; i++) {
for (int j = i; j < k; j += d) p[id++] = j;
}
int last = p[0];
for (int i = 0; i < n - 1; i++) p[i] = p[i + 1];
p[n - 1] = last;
int pw = n - k + 1;
while (pw > 0) {
if (pw & 1) {
for (int i = 0; i < n; i++) r[i] = q[p[i]];
for (int i = 0; i < n; i++) q[i] = r[i];
}
for (int i = 0; i < n; i++) r[i] = p[p[i]];
for (int i = 0; i < n; i++) p[i] = r[i];
pw >>= 1;
}
for (int i = 0; i < n; i++) t[i] = s[q[(k + i - 1) % n]];
for (int i = 0; i < n; i++) s[i] = t[i];
puts(s);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n, s1, s2, x;
scanf("%d%d", &m, &n);
s1 = m * n;
s2 = 2;
x = s1 / s2;
printf("%d\n", x);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int A, B, k;
string s1, s2;
int qzh[800008][4];
int r[800008];
int a1[800008], a2[800008];
const char ch1[5] = {'A', 'C', 'G', 'T'};
struct c {
double r, i;
c() {}
c(double rr, double ii) { r = rr, i = ii; }
c operator+(const c &x) { return c(r + x.r, i + x.i); }
c operator-(const c &x) { return c(r - x.r, i - x.i); }
c operator*(const c &x) { return c(r * x.r - i * x.i, r * x.i + i * x.r); }
c operator/(const int &x) { return c(r / x, i / x); }
};
c f[4][800008];
c g[4][800008];
c w[800008];
int l = 1, tmp = 0;
const double pi = 3.1415926535;
int res[800008];
void FFT(c a[], int type) {
for (int i = 0; i < l; i++)
if (r[i] > i) swap(a[i], a[r[i]]);
for (int len = 1, t = l >> 1; len < l; len <<= 1, t >>= 1) {
for (int i = 0; i < l; i += (len << 1)) {
for (int j = 0; j < len; j++) {
c ww = w[t * j];
ww.i = ww.i * type;
c x = a[i + j];
c y = a[i + j + len] * ww;
a[i + j] = x + y;
a[i + j + len] = x - y;
}
}
}
if (type == -1)
for (int i = 0; i < l; i++) a[i] = a[i] / l;
}
int main() {
scanf("%d%d%d", &A, &B, &k);
cin >> s1 >> s2;
for (int i = 0; i < B / 2; i++) swap(s2[i], s2[B - i - 1]);
for (int i = 0; i < A; i++)
for (int j = 0; j <= 3; j++) {
if (s1[i] == ch1[j]) {
a1[i] = j;
}
}
for (int i = 0; i < B; i++)
for (int j = 0; j <= 3; j++) {
if (s2[i] == ch1[j]) {
a2[i] = j;
}
}
for (int i = 0; i < B; i++) g[a2[i]][i].r = 1.0;
for (int i = 0; i < A; i++) {
for (int j = 0; j < 4; j++) qzh[i][j] = qzh[i - 1][j];
qzh[i][a1[i]]++;
}
for (int i = 0; i < A; i++) {
int left = max(i - k - 1, -1), right = min(i + k, A - 1);
for (int j = 0; j < 4; j++)
if (qzh[right][j] - qzh[left][j] > 0) f[j][i].r = 1.0;
}
for (; l < A + B; tmp++, l <<= 1)
;
for (int i = 0; i < l; i++) {
r[i] = (r[i >> 1] >> 1) | ((i & 1) << (tmp - 1));
w[i] = c(cos(2 * pi * i / l), sin(2 * pi * i / l));
}
for (int j = 0; j < 4; j++) FFT(f[j], 1), FFT(g[j], 1);
for (int i = 0; i < l; i++)
for (int j = 0; j < 4; j++) f[j][i] = f[j][i] * g[j][i];
for (int j = 0; j < 4; j++) FFT(f[j], -1);
for (int i = 0; i < l; i++)
for (int j = 0; j < 4; j++) res[i] = res[i] + (int)(f[j][i].r + 0.5);
int ans = 0;
for (int i = 0; i < l; i++)
if (res[i] == B) ans++;
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
namespace MaxFlow {
const int maxn = 3575;
const int maxm = maxn * 4 + maxn * 100;
struct node {
int to, next;
long long c;
} e[maxm];
int hd[maxn], cnt, n, cur[maxn], dis[maxn], q[maxn], l, r, x;
void addedge(int x, int y, long long c) {
e[++cnt] = (node){y, hd[x], c}, hd[x] = cnt;
e[++cnt] = (node){x, hd[y], 0}, hd[y] = cnt;
}
bool bfs() {
for (int i = 1; i <= n; i++) dis[i] = 0;
dis[1] = 1, q[l = r = 1] = 1;
while (l <= r) {
x = q[l++];
for (int i = hd[x]; i; i = e[i].next)
if (e[i].c > 0 && !dis[e[i].to])
dis[e[i].to] = dis[x] + 1, q[++r] = e[i].to;
}
return (dis[n] > 0);
}
long long dinic(int x, long long f) {
if (x == n) return f;
for (int &i = cur[x]; i; i = e[i].next)
if (e[i].c > 0 && dis[e[i].to] == dis[x] + 1) {
long long nw = dinic(e[i].to, min(f, e[i].c));
if (nw > 0) return e[i].c -= nw, e[i ^ 1].c += nw, nw;
}
return 0;
}
long long solve() {
long long ans = 0, nw;
while (bfs()) {
for (int i = 1; i <= n; i++) cur[i] = hd[i];
while (nw = dinic(1, inf)) ans += nw;
}
return ans;
}
} // namespace MaxFlow
int h, n, m;
int Point(int x, int y) { return 1 + (x - 1) * (h + 2) + y; }
int main() {
cin >> n >> h >> m;
int T = n * (h + 2) + 2 + m;
MaxFlow::n = T, MaxFlow::cnt = 1;
for (int i = 1; i <= n; i++) {
MaxFlow::addedge(1, Point(i, 1), inf);
MaxFlow::addedge(Point(i, h + 2), T, inf);
}
for (int i = 2; i <= h + 2; i++) {
for (int j = 1; j <= n; j++) {
MaxFlow::addedge(Point(j, i - 1), Point(j, i), h * h - (i - 2) * (i - 2));
}
}
int cnt = 1 + n * (h + 2);
int l, r, x, c;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d%d", &l, &r, &x, &c);
++cnt;
for (int j = l; j <= r; j++) {
MaxFlow::addedge(Point(j, x + 2), cnt, inf);
}
MaxFlow::addedge(cnt, T, c);
}
long long ans = n * h * h;
ans -= MaxFlow::solve();
cout << ans;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const long long INF = 1e17;
vector<int> sm;
unordered_map<int, int> dp;
inline int pack(int l, int r, int k) { return (l << 19) + (r << 7) + k; }
int calc(int l, int r, int k);
inline int othersMove(int l, int r, int k) {
if (r - l + 1 < k) return 0;
if (r - l + 1 == k) return calc(l, r - k, k) - sm[r] + sm[r - k];
return min(calc(l, r - k, k) - sm[r] + sm[r - k],
calc(l, r - k - 1, k + 1) - sm[r] + sm[r - k - 1]);
}
int calc(int l, int r, int k) {
if (dp.count(pack(l, r, k))) return dp[pack(l, r, k)];
if (r - l + 1 < k) return 0;
if (r - l + 1 == k)
return othersMove(l + k, r, k) + sm[l + k - 1] - sm[l - 1];
dp[pack(l, r, k)] =
max(othersMove(l + k, r, k) + sm[l + k - 1] - sm[l - 1],
othersMove(l + k + 1, r, k + 1) + sm[l + k] - sm[l - 1]);
return dp[pack(l, r, k)];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n;
sm.resize(n + 1, 0);
for (int i = 1; i <= n; i++) {
cin >> sm[i];
sm[i] += sm[i - 1];
}
cout << calc(1, n, 1) << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
double ans, num, dp[4][10005], f[10005];
int i, j, n, k, a[2005], maxn, minn = 1e9;
int main() {
scanf("%d", &n);
num = 1.0 / (1ll * (n - 1) * n / 2);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
maxn = max(maxn, a[i]);
minn = min(minn, a[i]);
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
if (a[i] > a[j]) {
dp[1][a[i] - a[j]] += num;
dp[2][a[i] - a[j]] += num;
}
}
}
for (i = 1; i <= maxn - minn; i++) {
for (j = 1; j <= maxn - minn; j++) {
dp[3][i + j] += dp[1][i] * dp[2][j];
}
}
for (i = 1; i <= 2 * (maxn - minn); i++) f[i] = f[i - 1] + dp[3][i];
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
if (a[i] > a[j]) ans += f[a[i] - a[j] - 1] * num;
}
}
printf("%.10lf", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
int a[100000 + 10];
bool b[100000 + 10];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int i = 1; i <= n; ++i) {
char t;
do t = getchar();
while (t != '0' && t != '1');
b[i] = (t == '0');
}
LL l = -1000000000, r = 1000000000;
for (int i = 5; i <= n; ++i) {
if (b[i] != b[i - 1]) {
if (b[i]) {
LL x = min(a[i], min(a[i - 1], min(a[i - 2], min(a[i - 3], a[i - 4]))));
r = min(r, x - 1);
} else {
LL x = max(a[i], max(a[i - 1], max(a[i - 2], max(a[i - 3], a[i - 4]))));
l = max(l, x + 1);
}
}
}
cout << l << ' ' << r << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 50;
int main() {
long long u, v;
scanf("%lld%lld", &u, &v);
if (u > v || ((v - u) % 2)) return printf("-1"), 0;
if (!u && !v) return printf("0"), 0;
if (u == v) return printf("1\n%lld", u), 0;
long long k = (v - u) / 2;
if (k & u) {
printf("3\n%lld %lld %lld", u, k, k);
} else {
printf("2\n%lld %lld", u + k, k);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1e9;
const int MOD = 1000000007;
const int N = 100010;
const int OFFSET = 1;
int n, k, a[N], b[N], dp[102][N][2], seg[2][4 * N];
void update(int n, int s, int e, int type, int at, int val) {
if (s > at || e < at) return;
if (s == e) {
seg[type][n] = val;
return;
}
update(2 * n, s, (s + e) / 2, type, at, val);
update(2 * n + 1, (s + e) / 2 + 1, e, type, at, val);
seg[type][n] = min(seg[type][2 * n], seg[type][2 * n + 1]);
}
int get(int n, int s, int e, int type, int l, int r) {
if (s > r || e < l) return oo;
if (s >= l && e <= r) return seg[type][n];
return min(get(2 * n, s, (s + e) / 2, type, l, r),
get(2 * n + 1, (s + e) / 2 + 1, e, type, l, r));
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < k; ++i) {
scanf("%d%d", &a[i], &b[i]);
}
for (int rem = 1; rem <= n; ++rem) dp[k][rem][0] = dp[k][rem][1] = oo;
a[k] = 2 * n + 1;
for (int idx = k - 1; idx >= 0; --idx) {
for (int rem = 0; rem <= n; ++rem)
for (int t = 0; t <= 1; ++t)
update(1, 1, (n + OFFSET), t, rem + OFFSET, dp[idx + 1][rem][t]);
for (int rem = 0; rem <= n; ++rem) {
for (int t = 0; t <= 1; ++t) {
int &ret = dp[idx][rem][t];
int len = b[idx] - a[idx] + 1;
int len2 = a[idx + 1] - b[idx] - 1;
ret = oo;
if (t == 0) {
ret = get(1, 1, (n + OFFSET), t, (rem + OFFSET), (rem + OFFSET));
}
if (t == 1) {
ret = get(1, 1, (n + OFFSET), t, ((rem - (len + len2)) + OFFSET),
((rem - (len + len2)) + OFFSET));
}
pair<int, int> rn = make_pair(rem - (len - !t), rem - 1);
ret = min(ret, (t == 0 ? 2 : 1) +
get(1, 1, (n + OFFSET), (t == 0 ? t : t ^ 1),
rn.first + OFFSET, rn.second + OFFSET));
pair<int, int> sn = make_pair(rem - (len + len2 - 1), rem - (t + len2));
ret = min(ret, (t == 1 ? 2 : 1) +
get(1, 1, (n + OFFSET), (t == 1 ? t : t ^ 1),
sn.first + OFFSET, sn.second + OFFSET));
}
}
}
if (dp[0][n][0] == oo) {
puts("Hungry");
return 0;
}
puts("Full");
printf("%d\n", dp[0][n][0]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, k;
cin >> n >> k;
long long a[n], atmax[n];
for (long long i = 0; i < n; i++) cin >> a[i];
long long notes = 0, sum = 0;
for (long long i = 0; i < n - 1; i++) {
long long v1 = pow(10, a[i]);
long long v2 = pow(10, a[i + 1]);
long long val = v2 / v1 - 1;
atmax[i] = val;
}
for (long long i = 0; i < n; i++) {
if (i == n - 1) {
long long left = k - notes + 1;
long long val = pow(10, a[i]);
sum += (val * left);
break;
}
if (notes + atmax[i] <= k) {
long long val = pow(10, a[i]);
sum += (val * atmax[i]);
notes += atmax[i];
} else {
long long left = k - notes + 1;
long long val = pow(10, a[i]);
sum += (val * left);
break;
}
}
cout << sum << '\n';
}
int32_t main() {
long long t;
cin >> t;
while (t--) solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 18;
int n, pos;
long long A[N];
long long B[N];
vector<long long> Va, Vb;
long long point;
int Rank;
void Input() {
cin >> n >> pos;
for (int i = 1; i <= n; i++) cin >> A[i];
for (int i = 1; i <= n; i++) cin >> B[i];
}
void Output() {
point = A[pos] + B[1];
Rank = 1;
Va.push_back(0);
Vb.push_back(1);
for (int i = 1; i <= n; i++) {
if (i != pos) Va.push_back(A[i]);
if (i != 1) Vb.push_back(B[i]);
}
vector<long long> xs, dh;
int id = 0;
for (int i = 1; i < Va.size(); i++) {
if (Va[i] > point) {
id = i;
Rank++;
}
}
for (int i = id + 1; i < Va.size(); i++) {
long long x = Va[i];
long long y = Vb[i];
xs.push_back(x);
dh.push_back(y);
}
sort(dh.begin(), dh.end());
for (int it = 0; it < xs.size(); it++) {
long long val = xs[it] + dh[it];
if (val > point) Rank++;
}
cout << Rank;
}
int main() {
ios ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
Input();
Output();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int tam = 100010;
const int MOD = 1000000007;
const int MOD1 = 998244353;
const double EPS = 1e-9;
const double PI = acos(-1);
long long dp[2][210][1010];
int ar[210];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> ar[i];
sort(ar, ar + n);
int now, last, x, ant;
bool bo = true;
dp[0][0][0] = 1;
for (int i = 1; i < n + 1; i++) {
now = i % 2;
last = abs(now - 1);
x = ar[i - 1];
if (bo) ant = x;
bo = false;
x = x - ant;
ant = ar[i - 1];
for (int j = 0; j < n + 1; j++) {
for (int k = 0; k < 1003; k++) {
dp[now][j][k] = 0;
if (j > 0 && x * (j - 1) <= k)
dp[now][j][k] =
(dp[now][j][k] + dp[last][j - 1][k - x * (j - 1)]) % MOD;
if (j < n && x * (j + 1) <= k)
dp[now][j][k] =
(dp[now][j][k] + (j + 1) * dp[last][j + 1][k - x * (j + 1)]) %
MOD;
if (x * j <= k)
dp[now][j][k] =
(dp[now][j][k] + (j + 1) * dp[last][j][k - x * j] % MOD) % MOD;
}
}
}
long long res = 0;
for (int i = 0; i < k + 1; i++) {
res = (res + dp[n % 2][0][i]) % MOD;
}
cout << res << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int b[201];
int main() {
int n;
char a[201];
while (cin >> n) {
int sum = 0;
memset(b, 0, sizeof(b));
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
if (a[i] == 'X') b[i] = 1;
}
for (int i = 0; i < n; i++) sum += b[i];
if (sum == (n / 2)) {
printf("0\n");
for (int i = 0; i < n; i++) printf("%c", a[i]);
printf("\n");
} else if (sum > (n / 2)) {
int counts = sum - (n / 2);
printf("%d\n", counts);
for (int i = 0; i < n; i++) {
if (a[i] == 'X' && counts) {
printf("x");
counts--;
continue;
}
printf("%c", a[i]);
}
printf("\n");
} else if (sum < (n / 2)) {
int counts = (n / 2) - sum;
printf("%d\n", counts);
for (int i = 0; i < n; i++) {
if (a[i] == 'x' && counts) {
printf("X");
counts--;
continue;
}
printf("%c", a[i]);
}
printf("\n");
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7, INF = 0x3f3f3f3f;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long qpow(long long a, long long n) {
long long r = 1 % P;
for (a %= P; n; a = a * a % P, n >>= 1)
if (n & 1) r = r * a % P;
return r;
}
long long inv(long long first) {
return first <= 1 ? 1 : inv(P % first) * (P - P / first) % P;
}
inline int rd() {
int first = 0;
char p = getchar();
while (p < '0' || p > '9') p = getchar();
while (p >= '0' && p <= '9') first = first * 10 + p - '0', p = getchar();
return first;
}
const int N = 1e6 + 10;
struct _ {
int l, r, id;
bool operator<(const _ &rhs) const {
if (l == rhs.l) return id < rhs.id;
return l < rhs.l;
}
} a[N][4];
set<_> s[4];
int dfs(set<_> L[4]) {
if (L[0].size() <= 1) return 1;
set<_> R[4];
set<_>::iterator it[4];
int m[4];
for (int i = 0; i <= 3; ++i) {
it[i] = L[i].begin();
m[i] = it[i]++->r;
}
int sz = L[0].size();
for (int i = 1; i <= sz - 1; ++i)
for (int j = 0; j <= 3; ++j) {
if (it[j]->l >= m[j]) {
for (auto t = L[j].begin(); t != it[j];) {
int id = t++->id;
for (int k = 0; k <= 3; ++k)
R[k].insert(a[id][k]), L[k].erase(a[id][k]);
}
return dfs(L) && dfs(R);
}
m[j] = max(m[j], it[j]++->r);
}
return 0;
}
int main() {
int n = rd();
for (int i = 1; i <= n; ++i) {
int x1 = rd(), y1 = rd(), x2 = rd(), y2 = rd();
a[i][0] = {x1, x2, i};
a[i][1] = {-x2, -x1, i};
a[i][2] = {y1, y2, i};
a[i][3] = {-y2, -y1, i};
for (int j = 0; j <= 3; ++j) s[j].insert(a[i][j]);
}
cout << (dfs(s) ? "YES" : "NO") << '\n';
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long int n, k, l, r;
vector<pair<long long int, long long int>> v;
vector<pair<long long int, long long int>> res;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (long long int i = 0; i < n; ++i) {
cin >> l >> r;
v.push_back({l, -1});
v.push_back({r, +1});
}
sort(v.begin(), v.end());
long long int prev = -1, cur = 0;
for (long long int i = 0; i < (long long int)v.size(); ++i) {
cur -= v[i].second;
if (cur + v[i].second < k && cur >= k) {
prev = v[i].first;
}
if (cur + v[i].second >= k && cur < k) {
res.push_back({prev, v[i].first});
prev = -1;
}
}
cout << (long long int)res.size() << '\n';
for (long long int i = 0; i < (long long int)res.size(); ++i)
cout << res[i].first << ' ' << res[i].second << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, n, m;
cin >> t;
while (t--) {
long long sum = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) {
int n1;
cin >> n1;
sum += n1;
}
int ans = min(sum, m);
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> vi;
int app[300000 + 5] = {0};
int qq[300000 + 5] = {0};
int nn[300000 + 5];
int main() {
std::ios::sync_with_stdio(false);
int n, q;
cin >> n >> q;
int ty, xt;
int ans = 0;
int st = 0;
for (int i = 0; i < n + 5; ++i) {
app[i] = 0;
qq[i] = -1;
}
for (int i = 0; i < q; ++i) {
cin >> ty >> xt;
if (ty == 1) {
vi.push_back(xt);
nn[xt] = vi.size() - 1;
++app[xt];
++ans;
} else if (ty == 2) {
ans -= app[xt];
app[xt] = 0;
qq[xt] = nn[xt];
} else {
for (int i = st; i < xt; ++i) {
if (i > qq[vi[i]]) {
--ans;
--app[vi[i]];
}
}
st = st > xt ? st : xt;
}
cout << ans << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k, j, i, m, q, ii, timer, fldgjdflgjhrthrl, y;
int min1, max1;
long double a[100500], b[100500];
long double ansa[100500], ansb[100500];
int main() {
cin >> n;
long double suma = 0, sumb = 1;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++) cin >> b[i];
long double cura = 0, curb = 0;
for (i = 0; i < n - 1; i++) {
suma += a[i];
sumb -= b[i];
long double A = 1;
long double B = sumb - suma - 1;
long double C = suma;
long double D = B * B - 4 * A * C;
long double fldgjdflgjhrthrl = (-B + sqrt(D)) / (2. * A);
long double fldgjdflgrtyrtyjl = (-B - sqrt(D)) / (2. * A);
fldgjdflgjhrthrl -= cura;
fldgjdflgrtyrtyjl -= curb;
ansa[i] = fldgjdflgjhrthrl;
ansb[i] = fldgjdflgrtyrtyjl;
cura += fldgjdflgjhrthrl;
curb += fldgjdflgrtyrtyjl;
}
ansa[n - 1] = 1 - cura;
ansb[n - 1] = 1 - curb;
for (i = 0; i < n; i++) printf("%.8f ", (double)ansa[i]);
cout << endl;
for (i = 0; i < n; i++) printf("%.8f ", (double)ansb[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int N = 505;
long long dp[N][N], ans[N][N];
int a[N], loc[N];
inline long long mul(long long x, long long y) { return x * y % 998244353; }
inline long long add(long long x, long long y) {
long long res = x + y;
if (res >= 998244353) res -= 998244353;
return res;
}
inline long long sub(long long x, long long y) {
long long res = x + 998244353 - y;
if (res >= 998244353) res -= 998244353;
return res;
}
long long fac[N], inv[N];
long long mod_pow(long long x, long long p) {
long long res = 1;
while (p > 0) {
if (p & 1) res = res * x % 998244353;
p >>= 1;
x = x * x % 998244353;
}
return res;
}
inline long long comb(long long n, long long k) {
long long res = mul(fac[n], inv[k]);
res = mul(res, inv[n - k]);
return res;
}
struct solver {
long long gans(int l, int r) {
if (l >= r) return 1;
if (!ans[l][r]) {
int bestv = INT_MAX, bestind = -1;
for (int i = l; i <= (int)r; ++i) {
if (a[i] < bestv) {
bestv = a[i];
bestind = i;
}
}
ans[l][r] = mul(gdp(l, bestind - 1), gdp(bestind + 1, r));
}
return ans[l][r];
}
long long gdp(int l, int r) {
if (l > r) return 1;
if (l == r) return 2;
if (!dp[l][r]) {
for (int i = l - 1; i <= (int)r; ++i) {
dp[l][r] = add(dp[l][r], mul(gans(l, i), gans(i + 1, r)));
}
}
return dp[l][r];
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, m;
cin >> n >> m;
for (int i = 1; i <= (int)n; ++i) {
cin >> a[i];
loc[a[i]] = i;
}
for (int i = 1; i <= (int)n; ++i) dp[i][i] = 1;
for (int i = 1; i <= (int)n; ++i) ans[i][i] = 1;
fac[0] = inv[0] = 1;
for (int i = 1; i <= (int)n; ++i) {
fac[i] = mul(fac[i - 1], i);
inv[i] = mod_pow(fac[i], 998244353 - 2);
}
solver solve;
long long res = solve.gans(1, n);
cout << res << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a;
cin >> n;
vector<int> nums(8, 0);
for (int i = 0; i < n; i++) {
cin >> a;
nums[a]++;
}
if (nums[7] > 0 || nums[5] > 0) {
cout << -1;
return 0;
}
if (nums[2] < nums[4]) {
cout << -1;
return 0;
}
if (nums[1] == nums[2] + nums[3] && nums[1] == nums[4] + nums[6]) {
if (nums[2] - nums[4] + nums[3] != nums[6]) {
cout << -1;
} else {
while (nums[4] > 0) {
cout << 1 << ' ' << 2 << ' ' << 4 << endl;
nums[4]--;
nums[2]--;
}
while (nums[2] > 0) {
cout << 1 << ' ' << 2 << ' ' << 6 << endl;
nums[2]--;
}
while (nums[3] > 0) {
cout << 1 << ' ' << 3 << ' ' << 6 << endl;
nums[3]--;
}
}
} else {
cout << -1;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
typename std::set<T>::const_iterator GetNearestTo(const std::set<T>& data,
const T& t) {
auto upper = data.lower_bound(t);
if (upper == data.begin() || (*upper) == t) return upper;
auto lower = upper;
--lower;
if (data.end() == lower || (t - (*lower)) < ((*upper) - t)) return lower;
if (upper == data.end() && data.size() > 0) return (--upper);
return upper;
}
int main() {
double a, b, c;
cin >> a >> b >> c;
if (a == 0) {
if (b == 0) {
if (c == 0) {
cout << "-1" << endl;
return 0;
} else {
cout << "0" << endl;
return 0;
}
} else {
cout << "1" << endl;
double x = (-c) / b;
printf("%0.6f\n", x);
return 0;
}
} else {
double d = b * b - 4 * a * c;
if (d < 0) {
cout << "0" << endl;
return 0;
}
d = sqrt(d);
double p = (-b + d);
double q = (-b - d);
p = p / 2 / a;
q = q / 2 / a;
if (p == q) {
cout << "1" << endl;
printf("%0.6f\n", p);
return 0;
} else {
cout << "2" << endl;
if (p > q) {
printf("%0.6f\n", q);
printf("%0.6f\n", p);
return 0;
} else {
printf("%0.6f\n", p);
printf("%0.6f\n", q);
return 0;
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> pre, nxt;
int n, m, k;
vector<pair<long long, vector<long long> > > v;
int main() {
scanf("%d%d%d", &n, &m, &k);
v.resize(n);
for (int i = 0; i < n; i++) scanf("%I64d", &v[i].first);
for (int i = 0; i < n; i++) {
v[i].second.resize(m);
for (int j = 0; j < m; j++) scanf("%I64d", &v[i].second[j]);
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
pre.resize(1 << m), nxt.resize(1 << m);
fill(pre.begin(), pre.end(), -1e18);
pre[0] = 0;
for (int i = 0; i < n; i++) {
fill(nxt.begin(), nxt.end(), -1e18);
for (int j = 0; j < (1 << m); j++) {
if (__builtin_popcount(j) > i) continue;
if (i - __builtin_popcount(j) < k)
nxt[j] = max(nxt[j], pre[j] + v[i].first);
else
nxt[j] = max(nxt[j], pre[j]);
for (int k = 0; k < m; k++) {
if (j & (1 << k)) continue;
nxt[j | (1 << k)] = max(nxt[j | (1 << k)], pre[j] + v[i].second[k]);
}
}
swap(pre, nxt);
}
printf("%I64d", pre[(1 << m) - 1]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cout << x; }
void __print(long x) { cout << x; }
void __print(long long x) { cout << x; }
void __print(unsigned x) { cout << x; }
void __print(unsigned long x) { cout << x; }
void __print(unsigned long long x) { cout << x; }
void __print(float x) { cout << x; }
void __print(double x) { cout << x; }
void __print(long double x) { cout << x; }
void __print(char x) { cout << '\'' << x << '\''; }
void __print(const char *x) { cout << '\"' << x << '\"'; }
void __print(const string &x) { cout << '\"' << x << '\"'; }
void __print(bool x) { cout << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cout << '{';
__print(x.first);
cout << ',';
__print(x.second);
cout << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cout << '{';
for (auto &i : x) cout << (f++ ? "," : ""), __print(i);
cout << "}";
}
void _print() { cout << "\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cout << ", ";
_print(v...);
}
const int mod = 1e9 + 7, mxn = 1e5 + 1;
int solve() {
int n, x;
cin >> n >> x;
vector<int> v[n + 1];
for (long long i = (1); i < (n); ++i) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
char win;
if (v[x].size() == 1)
win = 'a';
else {
int moves = n - v[x].size() - 1;
moves += v[x].size() - 1;
if (moves % 2 == 0)
win = 'a';
else
win = 'b';
}
if (n == 1) win = 'a';
if (win == 'a')
cout << "Ayush\n";
else
cout << "Ashish\n";
return 0;
}
int main() {
ios_base::sync_with_stdio(NULL);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
int t, x, s;
cin >> t >> x >> s;
printf("%s\n", (s != t + 1 && s >= t && (s - t) % x < 2) ? "YES" : "NO");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
const ll MOD = 1000000007;
int main() {
int tt;
cin >> tt;
while (tt--) {
ll n;
cin >> n;
vector<ll> vec(n);
ll mini = LONG_LONG_MAX;
ll cnt = 0;
for (int i = 0; i < n; i++) {
cin >> vec[i];
mini = min(mini, vec[i]);
}
sort(vec.begin(), vec.end());
ll cur = vec[1];
for (int i = 2; i < n; i++) {
cur = cur & vec[i];
}
if (cur != vec[0]) {
cout << 0 << endl;
continue;
}
for (int i = 0; i < n; i++) if (vec[i] == mini) cnt++;
ll ans = cnt * (cnt - 1);
for (ll i = 1; i <= n - 2; i++) {
ans = (ans * i) % MOD;
}
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long Arr[1000005];
void set22(long long n) {
for (long long i = 1; i < n + 1; i++) Arr[i] = i;
}
long long root(long long i) {
while (Arr[i] != i) {
Arr[i] = Arr[Arr[i]];
i = Arr[i];
}
return i;
}
void union1(long long A, long long B) {
long long root_A = root(A);
long long root_B = root(B);
Arr[root_A] = root_B;
}
bool find(long long A, long long B) {
if (root(A) == root(B))
return true;
else
return false;
}
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(0);
cout << fixed;
cout << setprecision(12);
long long n;
cin >> n;
long long a[n], b[n];
bool flag = true;
long long suma = 0, sumb = 0;
for (long long i = 0; i < n; i++) {
cin >> a[i];
suma += a[i];
}
for (long long i = 0; i < n; i++) {
cin >> b[i];
sumb += b[i];
}
if (suma < sumb) flag = false;
if (flag)
cout << "YES";
else
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
float a, b, c, d, e, f, n, i;
scanf("%f%f%f%f%f%f", &a, &b, &c, &d, &e, &f);
n = (d / c) * b;
i = (f / e) * n;
if (i > a || (c == 0 && d > 0) || (a == 0 && d > 0 && b != 0))
printf("Ron");
else
printf("Hermione");
return (0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long ar[100007];
long long br[100007];
int main() {
string h;
cin >> h;
int u, r;
u = r = 0;
for (int i = 0; i < h.length(); i++) {
if (h[i] == 'U') u++;
if (h[i] == 'D') u--;
if (h[i] == 'R') r++;
if (h[i] == 'L') r--;
}
if ((abs(u) + abs(r)) % 2)
cout << -1;
else
cout << (abs(u) + abs(r)) / 2;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int amt[52];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
map<char, int> lehmap;
int n;
string flats;
cin >> n;
cin >> flats;
for (int i = 0; i < flats.size(); i++) {
lehmap[flats[i]]++;
}
int amt = lehmap.size();
if (n == 1) {
cout << "1" << endl;
return 0;
} else if (n == 2) {
if (amt == 1)
cout << "1" << endl;
else
cout << "2" << endl;
return 0;
}
if (amt == 1) {
cout << "1" << endl;
return 0;
}
map<char, int> existing;
int ptr1 = 0, ptr2 = 1;
existing[flats[0]]++;
existing[flats[1]]++;
int mini = INT_MAX;
while (ptr2 != flats.size()) {
if (ptr1 == ptr2) {
ptr2++;
existing[flats[ptr2]]++;
} else if (existing.size() == amt) {
int x = ptr2 - ptr1;
mini = min(mini, x);
existing[flats[ptr1]]--;
if (existing[flats[ptr1]] == 0) existing.erase(flats[ptr1]);
ptr1++;
} else {
ptr2++;
existing[flats[ptr2]]++;
}
}
cout << mini + 1 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[110];
int i, j, n;
while (~scanf("%d", &n)) {
memset(a, 0, sizeof(a));
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
int ans = 0;
if (n < 3 || n % 2 == 0)
printf("-1\n");
else {
for (i = n; i >= 1; i--) {
if (a[i] > 0) ans = ans + a[i];
if (a[i] < 0) continue;
if (i % 2) {
a[i - 1] = a[i - 1] - a[i];
a[i / 2] = a[i / 2] - a[i];
} else
a[i / 2] = a[i / 2] - a[i];
}
printf("%d\n", ans);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long dp[n + 1];
vector<long long> v;
for (int i = 1; i <= n; i++) {
cin >> dp[i];
dp[i] += dp[i - 1];
}
for (int i = k; i <= n; i++) v.push_back(dp[i] - dp[i - k]);
long long ans = 0, mx = 0, l, r, z;
for (int i = k, j = 0; i < v.size(); i++, j++) {
if (v[j] > mx) {
mx = v[j];
z = j;
}
if (ans < mx + v[i]) {
ans = mx + v[i];
l = z;
r = i;
}
}
cout << l + 1 << " " << r + 1 << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void debug(int* a, int n) {
for (int i = 0; i < n; i++) cout << a[i] << " ";
cout << '\n';
}
void debug(vector<int> b, int n) {
for (int i = 0; i < n; i++) cout << b[i] << " ";
cout << '\n';
}
const long long INF = 1e18;
const int inf = 1e9;
map<long long, string> ss;
int main() {
ios_base::sync_with_stdio(false);
long long n, i, j, count;
cin >> n;
string ans = to_string(n);
for (i = 2; i <= n; i++) {
if (i * i > n) break;
j = i;
count = 1;
while (j <= n) {
string s1 = to_string(i) + '^' + to_string(count);
long long l1 = n / j;
long long l2 = n - (j * l1);
string s2;
if (ss.find(j) == ss.end()) {
s2 = to_string(j);
if (s2.length() > s1.length()) s2 = s1;
ss[j] = s2;
} else if (ss[j].length() > s1.length()) {
ss[j] = s1;
}
if (j == n) {
if (s1.length() < ans.length()) ans = s1;
} else if (l2 == 0) {
s2 = s1;
s1 = s1 + '*' + to_string(l1);
if (s1.length() < ans.length()) ans = s1;
if (ss.find(l1) != ss.end()) {
s2 = s2 + '*' + ss[l1];
if (s2.length() < ans.length()) ans = s2;
}
} else if (l1 == 1) {
s2 = s1;
s1 = s1 + '+' + to_string(l2);
if (s1.length() < ans.length()) ans = s1;
if (ss.find(l2) != ss.end()) {
s2 = s2 + '+' + ss[l2];
if (s2.length() < ans.length()) ans = s2;
}
} else {
string s11 = s1 + '*' + to_string(l1) + '+' + to_string(l2);
if (s11.length() < ans.length()) ans = s11;
if (ss.find(l2) != ss.end()) {
s11 = s1 + '*' + to_string(l1) + '+' + ss[l2];
if (s11.length() < ans.length()) ans = s11;
}
if (ss.find(l1) != ss.end()) {
s11 = s1 + '*' + ss[l1] + '+' + to_string(l2);
if (s11.length() < ans.length()) ans = s11;
}
if (ss.find(l1) != ss.end() && ss.find(l2) != ss.end()) {
s11 = s1 + '*' + ss[l1] + '+' + ss[l2];
if (s11.length() < ans.length()) ans = s11;
}
}
long long tt = n - j;
if (ss.find(tt) != ss.end()) {
s1 = s1 + '+' + ss[tt];
if (s1.length() < ans.length()) ans = s1;
}
j = j * i;
count++;
}
}
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
bool isprm(long long x) {
bool flag = true;
for (long long i = 2; i <= sqrt(x); i++) {
if (x % i == 0) return false;
}
return true;
}
using namespace std;
signed main() {
long long a;
cin >> a;
bool flg = isprm(a);
if (a == 2 || a == 3)
cout << 1;
else if (a % 2 == 0 && a >= 4)
cout << 2;
else if (flg == true)
cout << 1;
else if (isprm(a - 2) && a % 2 == 1)
cout << 2;
else
cout << 3;
return 0;
}
| 4 |
#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
using namespace std;
#define mp make_pair
#define f first
#define s second
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define FOR(i,a,b) for(int i = (a); i < (b); ++i)
#define F0R(i,a) FOR(i,0,a)
#define ROF(i,a,b) for (int i = (b)-1; i >= (a); --i)
#define R0F(i,a) ROF(i,0,a)
#define SIZE 100001
vector<long long> primes;
bool isPrime[SIZE + 1];
void sieve() {
FOR(i, 2, SIZE) {
if(isPrime[i] == true) {
primes.pb(i);
for(long long j = (long long)i * i; j < SIZE ; j += i) isPrime[j] = false;
}
}
}
int main() {
FOR(i, 1, SIZE) isPrime[i] = true;
sieve();
ios_base::sync_with_stdio(false);
int t; cin >> t;
while(t --) {
long long n; cin >> n;
long long temp = n;
int maxNum = 0;
long long num = 0;
for(int i=0;i<primes.size();i++) {
int cnt = 0;
while(n % primes[i] == 0) {
cnt ++;
n /= primes[i];
}
if(maxNum < cnt) {
maxNum = cnt;
num = primes[i];
}
}
if(n > 1) {
if(maxNum < 1) {
maxNum = 1;
num = n;
}
}
cout << maxNum << endl;
for(int i=0;i<maxNum - 1;i ++) {
cout << num << " ";
temp /= num;
}
cout << temp << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 1e5 + 10;
long long int x[mx], y[mx];
int ox[mx], oy[mx];
bool cmpx(int i, int j) {
if (x[i] != x[j]) return x[i] < x[j];
return y[i] < y[j];
}
bool cmpy(int i, int j) {
if (y[i] != y[j]) return y[i] < y[j];
return x[i] < x[j];
}
int hx, tx, hy, ty;
bool used[mx];
long long int ans = -1;
void clr() {
while (used[ox[hx]]) hx++;
while (used[ox[tx]]) tx--;
while (used[oy[hy]]) hy++;
while (used[oy[ty]]) ty--;
}
void gen(int n) {
int ohx = hx, otx = tx, ohy = hy, oty = ty;
clr();
if (n == 0) {
long long int w = max(1ll, (x[ox[tx]] - x[ox[hx]] + 1) >> 1);
long long int h = max(1ll, (y[oy[ty]] - y[oy[hy]] + 1) >> 1);
long long int bet = w * h;
if (ans == -1 || bet < ans) ans = bet;
} else {
used[ox[hx++]] = 1;
gen(n - 1);
used[ox[--hx]] = 0;
used[ox[tx--]] = 1;
gen(n - 1);
used[ox[++tx]] = 0;
used[oy[hy++]] = 1;
gen(n - 1);
used[oy[--hy]] = 0;
used[oy[ty--]] = 1;
gen(n - 1);
used[oy[++ty]] = 0;
}
hx = ohx, tx = otx, hy = ohy, ty = oty;
}
int main() {
int n, k;
long long int x1, y1, x2, y2;
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%lld %lld %lld %lld", &x1, &y1, &x2, &y2);
x[i] = (x1 + x1 + x2 + x2) >> 1;
y[i] = (y1 + y1 + y2 + y2) >> 1;
ox[i] = oy[i] = i;
}
sort(ox, ox + n, cmpx);
sort(oy, oy + n, cmpy);
hx = 0, tx = n - 1;
hy = 0, ty = n - 1;
gen(k);
ans = max(ans, 1ll);
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e3 + 9;
const int INF = 1e6 + 33;
int dis[MAXN][MAXN];
int dp[MAXN][5];
vector<int> tab[MAXN];
bitset<MAXN> odw;
queue<int> Q;
pair<int, int> maxi2[MAXN][4];
pair<int, pair<int, int> > maxi[MAXN][3];
int main() {
int n, m, a, b;
cin >> n >> m;
for (int i = 0; i < m; i++) {
scanf("%d %d", &a, &b);
a--;
b--;
tab[a].push_back(b);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) dis[i][j] = -INF;
for (int k = 0; k < 3; k++) maxi[i][k].first = maxi2[i][k].first = -INF;
maxi2[i][3].first = -INF;
}
int poz;
for (int i = 0; i < n; i++) {
odw.reset();
dis[i][i] = 0;
odw[i] = true;
Q.push(i);
while (!Q.empty()) {
poz = Q.front();
Q.pop();
for (int j = 0; j < int(tab[poz].size()); j++) {
if (!odw[tab[poz][j]]) {
dis[i][tab[poz][j]] = dis[i][poz] + 1;
odw[tab[poz][j]] = true;
Q.push(tab[poz][j]);
}
}
}
}
pair<pair<int, int>, pair<int, int> > ans;
int wyn = 0, tmp;
if (n == 4) {
int per[4] = {0, 1, 2, 3};
for (int i = 0; i < 24; i++) {
tmp = 0;
for (int j = 1; j < 4; j++) {
tmp += dis[per[j - 1]][per[j]];
}
if (tmp > wyn) {
wyn = tmp;
ans = make_pair(make_pair(per[0], per[1]), make_pair(per[2], per[3]));
}
next_permutation(per, per + 4);
}
cout << ans.first.first + 1 << " " << ans.first.second + 1 << " "
<< ans.second.first + 1 << " " << ans.second.second + 1 << endl;
return 0;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if ((i == j) || (dis[i][j] == -INF)) continue;
if (dis[i][j] >= maxi2[i][0].first) {
maxi2[i][3] = maxi2[i][2];
maxi2[i][2] = maxi2[i][1];
maxi2[i][1] = maxi2[i][0];
maxi2[i][0] = make_pair(dis[i][j], j);
} else if (dis[i][j] >= maxi2[i][1].first) {
maxi2[i][3] = maxi2[i][2];
maxi2[i][2] = maxi2[i][1];
maxi2[i][1] = make_pair(dis[i][j], j);
} else if (dis[i][j] >= maxi2[i][2].first) {
maxi2[i][3] = maxi2[i][2];
maxi2[i][2] = make_pair(dis[i][j], j);
} else if (dis[i][j] >= maxi2[i][3].first) {
maxi2[i][3] = make_pair(dis[i][j], j);
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if ((i == j) || (dis[i][j] == -INF)) continue;
tmp = dis[i][j];
for (int k = 0; k < 4; k++) {
if (maxi2[j][k].second != i) {
if (maxi2[j][k].first + tmp >= maxi[i][0].first) {
maxi[i][2] = maxi[i][1];
maxi[i][1] = maxi[i][0];
maxi[i][0].first = maxi2[j][k].first + tmp;
maxi[i][0].second = make_pair(j, maxi2[j][k].second);
} else if (maxi2[j][k].first + tmp > maxi[i][1].first) {
maxi[i][2] = maxi[i][1];
maxi[i][1].first = maxi2[j][k].first + tmp;
maxi[i][1].second = make_pair(j, maxi2[j][k].second);
} else if (maxi2[j][k].first + tmp >= maxi[i][2].first) {
maxi[i][2].first = maxi2[j][k].first + tmp;
maxi[i][2].second = make_pair(j, maxi2[j][k].second);
}
}
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if ((i == j) || (dis[i][j] == -INF)) continue;
tmp = dis[i][j];
for (int k = 0; k < 3; k++) {
if ((maxi[j][k].second.first != i) && (maxi[j][k].second.second != i)) {
if (wyn <= maxi[j][k].first + tmp) {
ans.first = make_pair(i, j);
ans.second = maxi[j][k].second;
wyn = maxi[j][k].first + tmp;
}
}
}
}
}
cout << ans.first.first + 1 << " " << ans.first.second + 1 << " "
<< ans.second.first + 1 << " " << ans.second.second + 1 << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
long long int ciel(double a) {
long long int ret = a;
if (a - ret > 0.0000000001) ret++;
return ret;
}
long long int gcd(long long int a, long long int b) {
if (a < b) return gcd(b, a);
if (a % b == 0) return b;
return gcd(b, a % b);
}
double fgcd(double a, double b) {
if (fabs(a) < fabs(b)) return fgcd(b, a);
if (fabs(b) < 0.0001) return a;
return fgcd(b, fmod(a, b));
}
bool db_db_cmp(double a, double b) {
return (a + 0.0000000001 > b && a - 0.0000000001 < b);
}
long long int fact[100005];
void generate_factorials() {
fact[0] = fact[1] = 1;
for (int i = 2; i <= 100005 - 1; i++)
fact[i] = ((fact[i - 1] * i) % 1000000007);
}
long long int pow(long long int n, long long int p) {
if (p == 0) return 1;
if (n <= 1) return n;
long long int res = 1;
while (p) {
if (p & 1) res = res * n;
n = n * n;
p /= 2;
}
return res;
}
long long int mod_pow(long long int n, long long int p) {
if (p == 0) return 1;
if (n <= 1) return n;
long long int res = 1;
while (p) {
if (p & 1) res = ((res * n) % 1000000007);
n = ((n * n) % 1000000007);
p /= 2;
}
return res;
}
long long int get_inverse(long long int n) {
return mod_pow(n, 1000000007 - 2);
}
long long int get_nCr(long long int n, long long int r) {
return ((fact[n] * get_inverse(((fact[r] * fact[n - r]) % 1000000007))) %
1000000007);
}
using namespace std;
void preprocess() {}
void init() {}
void solve(int test_case) {
init();
int a;
cin >> a;
if (a == 1) {
cout << 1 << endl;
return;
}
if (a == 2) {
cout << 3 << endl;
return;
}
if (a == 3) {
cout << 5 << endl;
return;
}
int maxi = 1, n = 1;
while (maxi < a) {
n += 2;
maxi = n / 2;
maxi *= n;
maxi = (maxi + 1) / 2;
maxi *= 2;
int temp = n / 2;
maxi += n / 2;
if (!(temp & 1)) {
maxi++;
}
}
cout << n << endl;
}
int main() {
preprocess();
int t = 1;
for (int i = 1; i <= t; i++) {
solve(i);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<pair<int, int> > G[100010];
int color[100010];
int dfs(int x, int c) {
if (color[x] != -1) return color[x] == c;
color[x] = c;
int nn = G[x].size();
for (int i = 0; i < nn; i++) {
int f = G[x][i].first, s = G[x][i].second;
if (!dfs(f, s ? c : 1 - c)) return false;
}
return 1;
}
int main() {
while (~scanf("%d%d", &n, &m)) {
int a, b, c;
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &a, &b, &c);
G[a].push_back(make_pair(b, c));
G[b].push_back(make_pair(a, c));
}
memset(color, -1, sizeof color);
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (color[i] == -1) {
if (dfs(i, 0))
cnt++;
else {
cnt = 0;
break;
}
}
}
int ans = cnt ? 1 : 0;
for (int i = 0; i < cnt - 1; i++) {
ans = ans * 2 % 1000000007;
}
printf("%d\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
char sky[500][500 + 1];
int stars[500][500];
int dy[] = {0, -1, 1, 0, 0};
int dx[] = {0, 0, 0, 1, -1};
int main() {
cin >> n >> m >> k;
for (int i = (0); i < (n); ++i) cin >> sky[i];
for (int i = (1); i < (n - 1); ++i)
for (int j = (1); j < (m - 1); ++j) {
bool yes = true;
for (int k = (0); k < (5); ++k)
if (!(yes = sky[i + dy[k]][j + dx[k]] == '1')) break;
if (yes) stars[i][j] = 1;
}
for (int i = (1); i < (n); ++i)
for (int j = (0); j < (m); ++j) stars[i][j] += stars[i - 1][j];
long long int res = 0;
for (int i1 = (0); i1 < (n); ++i1)
for (int i2 = (i1 + 2); i2 < (n); ++i2) {
long long int sum = 0;
for (int j1 = 0, j2 = 1; j1 < m; ++j1) {
while (sum < k) {
++j2;
if (j2 >= m) break;
sum += stars[i2 - 1][j2 - 1] - stars[i1][j2 - 1];
}
if (j2 >= m) break;
res += m - j2;
sum -= stars[i2 - 1][j1 + 1] - stars[i1][j1 + 1];
}
}
cout << res << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
void solve();
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed << setprecision(10);
long long t = 1;
while (t--) {
solve();
;
}
cerr << "Time : " << 1000 * (double)clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
void solve() {
long long n;
cin >> n;
vector<long long> a(n), b(n);
for (long long i = 0; i < (long long)n; i++) cin >> a[i];
for (long long i = 0; i < (long long)n; i++) cin >> b[i];
vector<long long> s(n + 1);
for (long long i = 1; i < (long long)n + 1; i++) s[i] += s[i - 1] + a[i - 1];
reverse((b).begin(), (b).end());
vector<long long> seen(n, 0);
set<pair<long long, long long> > l;
set<pair<long long, long long> > r;
long long mx = 0;
vector<long long> ans;
for (auto i : b) {
ans.push_back(mx);
i--;
seen[i] = 1;
long long cl = i;
long long cr = i;
if (i != 0 && seen[i - 1]) {
auto it = prev(r.lower_bound({i - 1, n + 1}));
assert(it->first == i - 1);
cl = it->second;
r.erase(it);
l.erase({it->second, it->first});
}
if (i != n - 1 && seen[i + 1]) {
auto it = prev(l.lower_bound({i + 1, n + 1}));
assert(it->first == i + 1);
cr = it->second;
l.erase(it);
r.erase({it->second, it->first});
}
l.insert({cl, cr});
r.insert({cr, cl});
mx = max(mx, s[cr + 1] - s[cl]);
(seen);
(cl);
(cr);
;
}
(mx);
reverse((ans).begin(), (ans).end());
for (auto e : ans) cout << e << "\n";
assert(mx == s.back());
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long d1, d2, d3, sum, sumot, sumf, sump;
cin >> d1 >> d2 >> d3;
sum = d1 + d2 + d3;
sumot = (d1 + d2) * 2;
sumf = (d2 + d3) * 2;
sump = (d1 + d3) * 2;
if (sum <= sumot && sum < sumf && sum < sump) {
cout << sum << endl;
}
if (sumot < sum && sumot < sumf && sumot < sump) {
cout << sumot << endl;
}
if (sumf < sum && sumf < sumot && sumf < sump) {
cout << sumf << endl;
}
if (sump < sum && sump < sumot && sump < sumf) {
cout << sump << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n = 0;
cin >> n;
vector<int> piles(n);
for (int i = 0; i < n; i++) {
cin >> piles[i];
}
int k = 0;
while (k < n && piles[k] == 1) {
k++;
}
cout << ((k == n) ^ (k % 2) ? "Second" : "First") << '\n';
}
int main() {
int t = 0;
cin >> t;
for (int i = 0; i < t; i++) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long w, a[9], ans;
void rua(long long i, long long x) {
if (i > 8) {
ans = max(ans, x);
return;
}
for (long long j = min(a[i], (w - x) / i), k = 1; j >= 0 && k <= 8; j--, k++)
rua(i + 1, x + i * j);
}
int main() {
cin >> w;
for (long long i = 1; i <= 8; i++) cin >> a[i];
rua(1, 0);
return printf("%I64d\n", ans), 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
int TN = 1;
int a[N];
int ans[N];
int n, k, cnt;
vector<int> d;
vector<int> v[N];
set<pair<int, int> > dp;
set<pair<int, int> >::iterator j;
void dfs(int cur) {
int x = (1 < cur - k) ? cur - k : 1;
int y = (n > cur + k) ? cur + k : n;
j = dp.end();
if (!dp.empty()) {
j--;
x = (j->second + 1 > x) ? j->second + 1 : x;
}
if (x <= y) {
cnt += (y - x);
cnt++;
dp.insert(make_pair(x, y));
}
ans[cur] = cnt;
for (int i = 0; i < v[cur].size(); i++) {
dfs(v[cur][i]);
}
if (x <= y) {
cnt -= y - x;
cnt--;
dp.erase(make_pair(x, y));
}
}
void solve() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == 0) {
d.push_back(i);
continue;
}
v[a[i]].push_back(i);
}
for (int i = 0; i < d.size(); i++) {
dfs(d[i]);
}
for (int i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
while (TN--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int ans, tot, head[N], ver[N], Next[N], val[N], n, m, deg[N];
queue<int> q[2];
bool vis[N];
inline void add(int x, int y) {
ver[++tot] = y;
Next[tot] = head[x];
head[x] = tot;
deg[y]++;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) scanf("%d", &val[i]);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
x++;
y++;
add(y, x);
}
for (int i = 1; i <= n; i++)
if (!deg[i]) q[val[i]].push(i);
while ((!q[0].empty()) || (!q[1].empty())) {
while (!q[0].empty()) {
int x = q[0].front();
q[0].pop();
vis[x] = true;
for (int i = head[x]; i; i = Next[i]) {
int y = ver[i];
if (vis[y]) continue;
if (!(--deg[y])) q[val[y]].push(y);
}
}
if (!q[1].empty()) {
ans++;
while (!q[1].empty()) {
int x = q[1].front();
q[1].pop();
vis[x] = true;
for (int i = head[x]; i; i = Next[i]) {
int y = ver[i];
if (vis[y]) continue;
if (!(--deg[y])) q[val[y]].push(y);
}
}
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int m1 = int(sqrt(float(n)));
int m2;
if (m1 * m1 == n) {
m2 = m1;
} else if (m1 * (m1 + 1) >= n) {
m2 = m1 + 1;
} else {
m1++;
m2 = m1;
}
for (int i = 1; i <= m1; i++) {
for (int j = min(m2 * i, n); j > m2 * (i - 1); j--) {
cout << j;
if (j != n - n % m2 + 1) {
cout << " ";
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using ii = pair<int, int>;
const int oo = 0x3f3f3f3f;
const ll OO = ll(oo) * oo;
const int N = 100005;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int n = int((s).size());
ll odds = 0, evens = 0;
ll a[2] = {0, 0};
ll b[2] = {0, 0};
for (int i = 0; i < n; i++) {
int diff = 1 - (i & 1);
int same = i & 1;
if (s[i] == 'a') {
a[same]++;
evens += a[diff];
odds += a[same];
} else {
b[same]++;
evens += b[diff];
odds += b[same];
}
}
cout << evens << ' ' << odds << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
const double pi = 3.141592653589793238462643383279502884197;
inline int readInt() {
int ans = 0, c, f = 1;
while (!isdigit(c = getchar()))
if (c == '-') f *= -1;
do ans = ans * 10 + c - '0';
while (isdigit(c = getchar()));
return ans * f;
}
void FFT(std::complex<double> *A, int len, int opt) {
for (int i = 1, j = 0; i < len; ++i) {
for (int k = len; ~j & k; j ^= k >>= 1)
;
if (i < j) std::swap(A[i], A[j]);
}
for (int h = 2; h <= len; h <<= 1) {
std::complex<double> wn =
std::complex<double>(cos(opt * 2 * pi / h), sin(opt * 2 * pi / h));
for (int j = 0; j < len; j += h) {
std::complex<double> w = 1.0;
for (int i = 0; i < (h >> 1); ++i) {
std::complex<double> _t1 = A[j + i], _t2 = A[j + i + (h >> 1)] * w;
A[j + i] = _t1 + _t2;
A[j + i + (h >> 1)] = _t1 - _t2;
w *= wn;
}
}
}
if (opt == -1)
for (int i = 0; i < len; ++i) A[i] /= len;
}
const int N = 1000000;
int n, x;
std::complex<double> F[N], G[N];
long long Ans[N];
int main() {
n = readInt(), x = readInt();
int S = 0;
F[0] = 1.0;
for (int i = 0; i < n; ++i) F[S += readInt() < x] += 1.0;
for (int i = 0; i <= n; ++i) G[n - i] = F[i];
int len = 1;
while (len <= n * 2) len <<= 1;
FFT(F, len, 1);
FFT(G, len, 1);
for (int i = 0; i < len; ++i) F[i] *= G[i];
FFT(F, len, -1);
long long ans = n;
ans = ans * (n + 1) / 2;
for (int i = 1; i <= n; ++i) ans -= Ans[i] = F[n + i].real() + 0.1;
printf("%I64d\n", ans);
for (int i = 1; i <= n; ++i) printf("%I64d\n", Ans[i]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
struct mint {
int x;
mint(int x = 0) : x(x) {}
};
inline mint operator+(mint a, mint b) {
return a.x + b.x < MOD ? a.x + b.x : a.x + b.x - MOD;
}
inline mint operator-(mint a) { return MOD - a.x; }
inline mint operator-(mint a, mint b) { return a + -b; }
inline mint operator*(mint a, mint b) { return 1LL * a.x * b.x % MOD; }
inline mint operator<<(mint x, long long y) {
mint r = 1;
for (; y; y >>= 1, x = x * x)
if (y & 1) r = r * x;
return r;
}
inline mint operator~(mint x) { return x << MOD - 2; }
inline mint operator/(mint a, mint b) { return a * ~b; }
inline mint& operator+=(mint& a, mint b) { return a = a + b; }
inline mint& operator-=(mint& a, mint b) { return a = a - b; }
inline mint& operator*=(mint& a, mint b) { return a = a * b; }
inline mint& operator<<=(mint& x, int y) { return x = x << y; }
inline mint& operator/=(mint& a, mint b) { return a = a / b; }
char a[600000 + 5], b[600000 + 5];
int u[600000 + 5], p[600000 + 5], pn;
long long n;
mint ans, S, s, F[600000 + 5], R[600000 + 5], mu[600000 + 5];
inline mint C(int n, int m) { return F[n] * R[m] * R[n - m]; }
inline int gcd(int x, int y) { return y ? gcd(y, x % y) : x; }
int main() {
int i, j, sa = 0, sb = 0, ac = 0, bc = 0, x, y;
scanf("%s%s%lld", a, b, &n);
for (F[0] = i = 1; i <= 600000; ++i) F[i] = F[i - 1] * i;
for (R[i = 600000] = ~F[600000]; i--;) R[i] = R[i + 1] * (i + 1);
for (mu[1] = 1, i = 2; i <= n; ++i) {
if (!u[i]) mu[p[++pn] = i] = MOD - 1;
for (j = 1; i * p[j] <= n; ++j)
if (u[i * p[j]] = 1, i % p[j])
mu[i * p[j]] = -mu[i];
else
break;
}
for (i = 0; a[i]; ++i) a[i] == 'A' ? ++sa : (--sb, a[i] == '?' ? ++ac : 0);
for (i = 0; b[i]; ++i) b[i] == 'A' ? --sa : (++sb, b[i] == '?' ? ++bc : 0);
if (sa == sb) {
for (i = 1; i <= n; S += s * (mint(2) << i++))
for (s = 0, j = 1; j <= n / i; ++j)
s += mu[j] * (n / i / j) * (n / i / j);
ans = ((mint(2) << n + 1) - 2) * ((mint(2) << n + 1) - 2) - S;
for (i = 0; a[i]; ++i) {
if (a[i] == '?' && b[i] == '?') ans *= 2;
if (a[i] != '?' && b[i] != '?' && a[i] != b[i]) ans = 0;
}
}
for (i = -bc; i <= ac; ++i) {
x = sa + i;
y = sb + i;
if (!x && !y) ans += S * C(ac + bc, ac - i);
if (1LL * x * y <= 0) continue;
if (x < 0) x = -x, y = -y;
ans +=
((mint(2) << n / (max(x, y) / gcd(x, y)) + 1) - 2) * C(ac + bc, ac - i);
}
printf("%d", ans);
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long f[5] = {0};
long long x_min = -100000;
long long x_max = 100000;
long long y_min = -100000;
long long y_max = 100000;
long long x, y, a, b, c, d;
for (long long i = 0; i < n; i++) {
cin >> x >> y >> a >> b >> c >> d;
if (!a) x_min = max(x, x_min);
if (!b) y_max = min(y, y_max);
if (!c) x_max = min(x, x_max);
if (!d) y_min = max(y, y_min);
}
if (x_min <= x_max && y_min <= y_max) {
cout << 1 << " " << x_min << " " << y_min << endl;
} else {
cout << 0 << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int MAX_N = 1000005;
int r[MAX_N], q[MAX_N], N, Q;
int ds[4 * MAX_N], bit[MAX_N], del[MAX_N], delc;
void upd(int p, int b, int e, int i, int v) {
if (b == e)
ds[p] = v;
else {
int m = (b + e) / 2;
if (i <= m)
upd(2 * p, b, m, i, v);
else
upd(2 * p + 1, m + 1, e, i, v);
ds[p] = ds[2 * p] + ds[2 * p + 1];
}
}
int find(int p, int b, int e, int i) {
if (b == e) return b;
int m = (b + e) / 2;
if (ds[2 * p] >= i)
return find(2 * p, b, m, i);
else
return find(2 * p + 1, m + 1, e, i - ds[2 * p]);
}
int main() {
scanf("%d %d", &Q, &N);
for (int i = 0; i < N; ++i) scanf("%d", r + i);
for (int i = 0; i < Q; ++i) {
scanf("%d", q + i);
if (q[i] >= 0) {
upd(1, 0, Q - 1, i, 1);
bit[i] = q[i];
} else {
bit[i] = -1;
for (delc = 0; delc < N; ++delc) {
if (r[delc] > ds[1]) break;
del[delc] = find(1, 0, Q - 1, r[delc]);
}
for (--delc; delc >= 0; --delc) {
upd(1, 0, Q - 1, del[delc], 0);
bit[del[delc]] = -1;
}
}
}
int ok = 0;
for (int i = 0; i < Q; ++i) {
if (bit[i] >= 0) {
printf("%d", bit[i]);
ok = 1;
}
}
if (!ok) printf("Poor stack!");
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
int p[1 << 12], q[1 << 12], pos[1 << 12], v[1 << 12], a[1 << 12], n, s;
void swap(int &x, int &y) { return x ^= y, y ^= x, void(x ^= y); }
void fix(int x, int y) {
int d = q[x] ^ v[x], k = pos[d];
if (k == x) return;
if (k == y) return swap(p[x], p[y]), swap(pos[p[x]], pos[p[y]]);
swap(p[x], p[k]), swap(pos[p[x]], pos[p[k]]), swap(q[y], q[k]);
return fix(k, y);
}
int main() {
scanf("%d", &n), n = 1 << n;
for (int i = 0; i < n; i++)
scanf("%d", a + i), s ^= a[i], p[i] = q[i] = pos[i] = i;
if (s) return printf("Fou\n"), 0;
printf("Shi\n");
for (int i = 0; i < n - 1; i++)
if (v[i] != a[i]) {
int x = v[i] ^ a[i];
v[i] ^= x, v[i + 1] ^= x;
fix(i, i + 1);
}
for (int i = 0; i < n; i++) printf("%d ", p[i]);
printf("\n");
for (int i = 0; i < n; i++) printf("%d ", q[i]);
printf("\n");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const int N = 1000000;
ld dp[N + 5];
int uses[N + 5];
string s;
int n, L;
void calc(ld d) {
for (int i = 1; i <= n; i++) {
uses[i] = uses[i - 1];
dp[i] = dp[i - 1];
if (s[i - 1] == '0') dp[i]++;
ld nv;
int us;
if (i < L) {
nv = i - d;
us = 1;
} else {
nv = L - d + dp[i - L];
us = 1 + uses[i - L];
}
if (nv > dp[i]) {
dp[i] = nv;
uses[i] = us;
}
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0);
cout.precision(10);
cout << fixed;
int k;
cin >> n >> k >> L;
k = min(k, (n + L - 1) / L);
cin >> s;
for (auto &c : s) {
if ('a' <= c && c <= 'z')
c = '0';
else
c = '1';
}
ld l = -2e7, r = 2e7;
int tries = 50;
int res = 0;
while (tries--) {
ld mid = (l + r) / 2;
calc(mid);
if (uses[n] < k)
r = mid;
else if (uses[n] > k)
l = mid;
else {
l = r = mid;
break;
}
}
res = max(res, int(round(dp[n] + k * l)));
for (auto &c : s) {
if (c == '0')
c = '1';
else
c = '0';
}
l = -2e7, r = 2e7;
tries = 50;
while (tries--) {
ld mid = (l + r) / 2;
calc(mid);
if (uses[n] < k)
r = mid;
else if (uses[n] > k)
l = mid;
else {
l = r = mid;
break;
}
}
res = max(res, int(round(dp[n] + k * l)));
cout << n - res << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> MP;
int cnt;
struct ajme {
int num;
string ko;
ajme(int a, string bzvz) {
num = a;
ko = bzvz;
}
bool operator<(const ajme &t) const { return ko < t.ko; }
};
vector<ajme> PERO;
struct cvor {
int ko, hm;
cvor(int a, int b) {
ko = a;
hm = b;
}
};
struct node {
int num;
vector<cvor> niz;
node(int a) { num = a; }
};
vector<node> v;
void F(string s) {
string st;
stringstream ss;
int broj, ko;
ss << s;
ss >> s;
s = s.substr(0, s.size() - 1);
cnt++;
MP[s] = cnt;
PERO.push_back(ajme(cnt, s));
node tmp = cnt;
while (1) {
bool B = false;
ss >> s;
ss >> st;
if (st[st.size() - 1] == ',') B = true;
if (B) st = st.substr(0, st.size() - 1);
stringstream ss2;
ss2 << st;
ss2 >> broj;
ko = MP[s];
tmp.niz.push_back(cvor(ko, broj));
if (!B) break;
}
v.push_back(tmp);
}
vector<vector<int> > G;
void PROBAJ(int x) {
int ko, hm;
for (int i = 0; i < v.size(); i++) {
bool B = true;
for (int j = 0; j < v[i].niz.size(); j++) {
ko = v[i].niz[j].ko;
hm = v[i].niz[j].hm;
if (G[x][ko] < hm) {
B = false;
break;
}
}
if (!B) continue;
for (int j = 0; j < v[i].niz.size(); j++) {
ko = v[i].niz[j].ko;
hm = v[i].niz[j].hm;
G[x][ko] -= hm;
}
ko = v[i].num;
G[x][ko]++;
}
}
int main() {
int k, n, m, q, t, z;
string s;
cin >> k >> n >> m >> q;
G.resize(k + 1, vector<int>(n + m + 1));
for (int i = 0; i < n; i++) {
cnt++;
cin >> s;
PERO.push_back(ajme(cnt, s));
MP[s] = cnt;
}
getline(cin, s);
for (int i = 0; i < m; i++) {
getline(cin, s);
F(s);
}
for (int i = 0; i < q; i++) {
cin >> t >> s;
z = MP[s];
G[t][z]++;
PROBAJ(t);
}
int hm;
sort(PERO.begin(), PERO.end());
for (int i = 1; i <= k; i++) {
hm = 0;
for (int j = 0; j < G[i].size(); j++)
if (G[i][j]) hm++;
cout << hm << endl;
for (int j = 0; j < PERO.size(); j++)
if (G[i][PERO[j].num])
cout << PERO[j].ko << " " << G[i][PERO[j].num] << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
int fac[2000010], a[2000010];
const int mod = 1000000007;
int ans = 0;
int fpow(int i, int j) {
int ret;
if (j == 0) return 1;
ret = fpow(i, j / 2);
ret = (long long)ret * ret % mod;
if (j % 2 == 1) ret = (long long)ret * i % mod;
return ret;
}
int inv(int i) {
if (a[i] != 0)
return a[i];
else {
a[i] = fpow(fac[i], mod - 2);
return a[i];
}
}
int calc(int i, int j) {
int ret;
ret = (long long)fac[i] * inv(j) % mod * inv(i - j) % mod;
return ret;
}
int main() {
int i, j, s = 0;
fac[0] = 1;
for (i = 1; i <= 2000000; i++) fac[i] = (long long)fac[i - 1] * i % mod;
scanf("%d", &n);
ans = ((long long)fpow(2, n + 1) - 1 + mod) % mod;
ans %= mod;
s = fpow(2, n);
a[n] = fpow(fac[n], mod - 2);
for (i = n + 1; i <= 2 * n; i++) {
s = ((long long)s * 2 - calc(i - 1, n) - calc(i - 1, i - 1 - n)) % mod;
ans = ((long long)ans + s + mod) % mod;
}
cout << ans << endl;
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.