solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b;
cin >> n >> a >> b;
long long sega, segb;
long long tot = 0, tmp = n;
while (tmp != 1) {
tot++;
tmp /= 2;
}
if (a % 2 == 0) {
sega = a / 2;
} else {
sega = a / 2 + 1;
}
if (b % 2 == 0) {
segb = b / 2;
} else {
segb = b / 2 + 1;
}
long long level = 1;
if (sega == segb) {
if (level == tot) {
cout << "Final!" << endl;
return 0;
} else {
cout << level << endl;
return 0;
}
}
while (1) {
level++;
if (sega % 2 == 0) {
sega = sega / 2;
} else {
sega = sega / 2 + 1;
}
if (segb % 2 == 0) {
segb = segb / 2;
} else {
segb = segb / 2 + 1;
}
if (sega == segb) {
if (level == tot) {
cout << "Final!" << endl;
return 0;
} else {
cout << level << endl;
return 0;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
int in[N];
set<int> p;
multiset<int> s;
void print() {
if (p.size() > 0) {
int ret = *prev(p.end()) - *p.begin();
if (s.size() > 0) {
ret -= *prev(s.end());
}
printf("%d\n", ret);
} else {
printf("0\n");
}
}
void solve() {
int n, q;
scanf("%d %d", &n, &q);
for (int i = 0; i < n; ++i) {
scanf("%d", &in[i]);
}
sort(in, in + n);
for (int i = 0; i < n; ++i) {
if (i + 1 < n) {
s.insert(in[i + 1] - in[i]);
}
p.insert(in[i]);
}
print();
while (q--) {
int type, x;
scanf("%d %d ", &type, &x);
if (type == 1) {
set<int>::iterator it = p.lower_bound(x);
int a = -1, b = -1;
if (it != p.end()) {
b = *it;
s.insert(b - x);
}
if (it != p.begin()) {
it = prev(it);
a = *it;
s.insert(x - a);
}
if (a != -1 && b != -1) {
s.erase(s.find(b - a));
}
p.insert(x);
} else {
p.erase(x);
set<int>::iterator it = p.lower_bound(x);
int a = -1, b = -1;
if (it != p.end()) {
b = *it;
s.erase(s.find(b - x));
}
if (it != p.begin()) {
it = prev(it);
a = *it;
s.erase(s.find(x - a));
}
if (a != -1 && b != -1) {
s.insert(b - a);
}
}
print();
}
}
int main() {
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int mmin[100010][50];
long long sum[100010][50];
int son[100010][50];
long long poww[50];
void pre() {
poww[0] = 1;
for (int i = 1; i <= 40; i++) poww[i] = poww[i - 1] << 1;
}
long long n, k;
long long SUM;
int MMIN;
void solve(int h, long long k) {
SUM = 0, MMIN = 0;
MMIN = 2e9;
for (int i = 40; i >= 0; i--)
if (poww[i] <= k)
MMIN = min(MMIN, mmin[h][i]), SUM += sum[h][i], k -= poww[i],
h = son[h][i];
}
long long read() {
long long sum = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch <= '9' && ch >= '0') sum = sum * 10 + ch - '0', ch = getchar();
return sum;
}
int main() {
pre();
n = read(), k = read();
for (int i = 0; i < n; i++) son[i][0] = read();
for (int i = 0; i < n; i++) mmin[i][0] = sum[i][0] = read();
for (int i = 1; i <= 40; i++)
for (int j = 0; j < n; j++) {
son[j][i] = son[son[j][i - 1]][i - 1];
sum[j][i] = sum[son[j][i - 1]][i - 1] + sum[j][i - 1];
mmin[j][i] = min(mmin[j][i - 1], mmin[son[j][i - 1]][i - 1]);
}
for (int i = 0; i < n; i++) {
solve(i, k);
cout << SUM << " " << MMIN << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "inline")
using namespace std;
template <class T>
inline void read(T &x) {
int ch = 0, f = 0;
x = 0;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = 1;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - 48;
if (f) x = -x;
}
const int N = 1000005, M = 1000001;
struct Bit {
int s[N];
inline void add(int x) {
for (int i = x; i <= M; i += i & -i) s[i]++;
}
inline int query(int x) {
int res = 0;
for (int i = x; i; i -= i & -i) res += s[i];
return res;
}
} A, B;
int n;
int main() {
read(n);
long long ans = 0;
int tmp = 0;
for (int i = 1, k, x, mx, mn; i <= n; i++) {
read(k), mx = 0, mn = (0x7f7f7f7f);
int flag = 0;
while (k--) {
read(x);
if (x > mn) flag = 1;
mx = max(x, mx), mn = min(x, mn);
}
if (flag)
ans += 2 * i - 1, tmp++;
else {
ans += A.query(mx);
ans += B.query(M) - B.query(mn + 1);
A.add(mn + 1), B.add(mx + 1);
if (mx > mn) ans++;
ans += 2ll * tmp;
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
char s[1005];
int st[1005];
int main() {
gets(s + 1);
n = strlen(s + 1);
int i, j;
for (i = 1; i <= n; i++) {
if (s[i] == '<' || s[i] == '>') continue;
if (s[i] == '/') {
for (j = 1; j < st[0]; j++) printf(" ");
printf("</");
for (j = st[st[0]]; s[j] != '>'; j++) printf("%c", s[j]);
printf(">\n");
for (i++; s[i] >= 'a' && s[i] <= 'z'; i++)
;
st[0]--;
}
if (s[i] >= 'a' && s[i] <= 'z') {
st[++st[0]] = i;
for (j = 1; j < st[0]; j++) printf(" ");
printf("<");
for (j = st[st[0]]; s[j] != '>'; j++) printf("%c", s[j]);
printf(">\n");
for (i++; s[i] >= 'a' && s[i] <= 'z'; i++)
;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename _typer>
inline _typer read() {
_typer init = 0;
char ch = getchar(), k = 0;
for (; !isdigit(ch); ch = getchar()) k = (ch == '-');
for (; isdigit(ch); ch = getchar())
init = (init << 3) + (init << 1) + (ch ^ 48);
return k ? -init : init;
}
const long long N = 0, INF = 1e9;
int Get(int x, int y, int opr) {
if (opr == '|')
return x | y;
else if (opr == '&')
return x & y;
else if (opr == '^')
return x ^ y;
return 0;
}
int Work() {
int opr = getchar();
if (opr == '(') {
int ls = Work();
int opr = getchar();
int rs = Work(), ans = 0;
getchar();
for (register int i = (0), iend = (3); i <= iend; ++i)
if (ls & (1 << i))
for (register int j = (0), jend = (3); j <= jend; ++j)
if (rs & (1 << j)) ans |= (1 << Get(i, j, opr));
return ans;
} else {
if (opr == '1')
return 8;
else if (opr == '0')
return 1;
else
return 6;
}
}
int main() {
read<int>();
if (Work() & 6)
puts("YES");
else
puts("NO");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
int main() {
long long n, minn = 10000000000, maxx = 0;
set<long long> myset;
cin >> n;
long long a[1000010];
for (long long i = 1; i <= n; i++) {
cin >> a[i];
maxx = max(a[i], maxx);
minn = min(a[i], minn);
}
long long ans = 0;
for (long long i = 1; i <= n; i++) {
if (a[i] < maxx and a[i] > minn) {
ans++;
}
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int ch[300010][26];
int ans[300010], maxdep = 0;
int N;
int merge(vector<int> now) {
int res = now.size() - 1;
vector<int> next;
for (int i = 0; i < 26; i++) {
next.clear();
for (int j = 0; j < now.size(); j++)
if (ch[now[j]][i]) next.push_back(ch[now[j]][i]);
if (next.size() <= 1) continue;
res += merge(next);
}
return res;
}
void dfs(int x, int dep) {
vector<int> now;
now.clear();
maxdep = max(maxdep, dep);
for (int i = 0; i < 26; i++) {
if (!ch[x][i]) continue;
now.push_back(ch[x][i]);
}
int res = merge(now) + 1;
ans[dep] += res;
for (int i = 0; i < 26; i++) {
if (ch[x][i]) dfs(ch[x][i], dep + 1);
}
}
int main() {
scanf("%d", &N);
for (int i = 1; i < N; i++) {
int u, v;
char s[5];
scanf("%d%d", &u, &v);
scanf("%s", s);
ch[u][s[0] - 'a'] = v;
}
memset(ans, 0, sizeof(ans));
dfs(1, 1);
int maxres = 0, mp;
for (int i = 1; i <= maxdep; i++)
if (maxres < ans[i]) {
maxres = ans[i];
mp = i;
}
printf("%d\n%d\n", N - maxres, mp);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
const double EPS = 1e-7;
long long a[5000];
int pot2[5000];
int dp[5000];
int n;
void comp_pot2() {
for (int i = 0; i < n; i++) {
pot2[i] = 0;
long long tmp = a[i];
while (tmp % 2 == 0) {
pot2[i]++;
tmp /= 2;
}
}
}
bool valid(int j, int i) {
long long fi = a[i] >> pot2[i];
if (a[j] % fi) return false;
if (pot2[j] + i - j == pot2[i]) return true;
return pot2[i] < i - j;
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
comp_pot2();
for (int i = 0; i < n; i++) {
dp[i] = 1;
for (int j = 0; j < i; j++)
if (valid(j, i)) dp[i] = max(dp[i], dp[j] + 1);
}
int ans = 0;
for (int i = 0; i < n; i++) ans = max(ans, dp[i]);
cout << (n - ans) << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
mt19937_64 mrand(chrono::steady_clock::now().time_since_epoch().count());
const int N = 1e5 + 5;
int ch[N][2], rd[N], sz[N], val[N], a[N], fa[N], vis[N], tot = 0;
void pushup(int rt) { sz[rt] = 1 + sz[ch[rt][0]] + sz[ch[rt][1]]; }
void split(int rt, int k, int &x, int &y) {
if (!rt) {
x = y = 0;
return;
}
if (sz[ch[rt][0]] + 1 <= k) {
if (ch[rt][1]) fa[ch[rt][1]] = 0;
x = rt, split(ch[rt][1], k - sz[ch[rt][0]] - 1, ch[rt][1], y);
if (ch[rt][1]) fa[ch[rt][1]] = rt;
} else {
if (ch[rt][0]) fa[ch[rt][0]] = 0;
y = rt, split(ch[rt][0], k, x, ch[rt][0]);
if (ch[rt][0]) fa[ch[rt][0]] = rt;
}
pushup(rt);
}
int merge(int x, int y) {
if (!x || !y) return x + y;
if (rd[x] < rd[y]) {
ch[x][1] = merge(ch[x][1], y);
if (ch[x][1]) fa[ch[x][1]] = x;
pushup(x);
return x;
} else {
ch[y][0] = merge(x, ch[y][0]);
if (ch[y][0]) fa[ch[y][0]] = y;
pushup(y);
return y;
}
}
pair<int, int> get(int x) {
int p = x, pos = sz[ch[x][0]];
while (fa[p]) {
if (p == ch[fa[p]][1]) pos += sz[ch[fa[p]][0]] + 1;
p = fa[p];
}
return {p, pos};
}
int kth(int p, int k) {
while (k) {
if (k <= sz[ch[p][0]]) {
p = ch[p][0];
} else if (k == sz[ch[p][0]] + 1) {
return p;
} else {
k -= sz[ch[p][0]] + 1;
p = ch[p][1];
}
}
return -1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, q;
cin >> n >> q;
for (int i = 1; i <= n; ++i)
cin >> a[i], rd[i] = mrand() % INT_MAX, sz[i] = 1;
for (int i = 1; i <= n; ++i) {
if (vis[i]) continue;
int p = i, rt = 0;
while (!vis[p]) {
vis[p] = 1;
rt = merge(rt, p);
p = a[p];
}
}
while (q--) {
int op;
cin >> op;
if (op == 1) {
int x, y;
cin >> x >> y;
auto [rtx, px] = get(x);
auto [rty, py] = get(y);
if (rtx == rty) {
if (px > py) {
swap(px, py);
swap(x, y);
}
int l, m, r;
split(rtx, px + 1, l, r);
split(r, py - px, m, r);
merge(l, r);
} else {
int lx, rx, ly, ry;
split(rtx, px + 1, lx, rx);
split(rty, py + 1, ly, ry);
merge(merge(lx, ry), merge(ly, rx));
}
} else {
int x, k;
cin >> x >> k;
auto [rt, pos] = get(x);
pos = (pos + k) % sz[rt];
cout << kth(rt, pos + 1) << '\n';
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int Set(int N, int pos) { return N |= (1LL << pos); }
int Reset(int N, int pos) { return N &= ~(1LL << pos); }
bool Check(int N, int pos) { return N & (1LL << pos); }
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1}, dy[] = {1, -1, 0, 0, 1, -1, -1, 1};
long long n, ar[2001][2001], tot, s, dp1[2001][2001], M1 = 0, M = 0, tem;
long long x1, y11, x2, y2;
int main() {
ios_base::sync_with_stdio(false);
M = -1;
M1 = -1;
cin >> n;
for (int i(1), _n(n); i <= _n; ++i) {
for (int j(1), _n(n); j <= _n; ++j) {
cin >> ar[i][j];
}
}
for (int i = 1; i <= n; i += 2) {
s = i;
tot = 0;
for (int j = 1; j <= n && s <= n; j++) {
tot += ar[s][j];
s++;
}
s = i;
for (int j = 1; j <= n && s <= n; j++) {
dp1[s][j] = tot;
s++;
}
}
for (int i = 3; i <= n; i += 2) {
s = i;
tot = 0;
for (int j = 1; j <= n && s <= n; j++) {
tot += ar[j][s];
s++;
}
s = i;
for (int j = 1; j <= n && s <= n; j++) {
dp1[j][s] = tot;
s++;
}
}
for (int i = 1; i <= n; i += 2) {
s = i;
tot = 0;
for (int j = 1; j <= n && s >= 1; j++) {
tot += ar[s][j];
s--;
}
s = i;
for (int j = 1; j <= n && s >= 1; j++) {
dp1[s][j] += tot - ar[s][j];
tem = dp1[s][j];
if (tem > M1) {
M1 = tem;
x1 = s;
y11 = j;
}
s--;
}
}
int si;
if ((n % 2) == 0)
si = 2;
else
si = 3;
for (int i = si; i <= n; i += 2) {
s = i;
tot = 0;
for (int j = n; j >= 1 && s <= n; j--) {
tot += ar[j][s];
s++;
}
s = i;
for (int j = n; j >= 1 && s <= n; j--) {
dp1[s][j] += tot - ar[s][j];
tem = dp1[s][j];
if (tem > M1) {
M1 = tem;
x1 = s;
y11 = j;
}
s++;
}
}
memset(dp1, 0, sizeof(dp1));
for (int i = 2; i <= n; i += 2) {
s = i;
tot = 0;
for (int j = 1; j <= n && s <= n; j++) {
tot += ar[s][j];
s++;
}
s = i;
for (int j = 1; j <= n && s <= n; j++) {
dp1[s][j] = tot;
s++;
}
}
for (int i = 2; i <= n; i += 2) {
s = i;
tot = 0;
for (int j = 1; j <= n && s <= n; j++) {
tot += ar[j][s];
s++;
}
s = i;
for (int j = 1; j <= n && s <= n; j++) {
dp1[j][s] = tot;
s++;
}
}
for (int i = 2; i <= n; i += 2) {
s = i;
tot = 0;
for (int j = 1; j <= n && s >= 1; j++) {
tot += ar[s][j];
s--;
}
s = i;
for (int j = 1; j <= n && s >= 1; j++) {
tem = dp1[s][j] + tot - ar[s][j];
if (tem > M) {
M = tem;
x2 = s;
y2 = j;
}
s--;
}
}
if (n % 2 == 1)
si = 2;
else
si = 3;
for (int i = si; i <= n; i += 2) {
s = i;
tot = 0;
for (int j = n; j >= 1 && s <= n; j--) {
tot += ar[s][j];
s++;
}
s = i;
for (int j = n; j >= 1 && s <= n; j--) {
tem = dp1[s][j] + tot - ar[s][j];
if (tem > M) {
M = tem;
x2 = s;
y2 = j;
}
s++;
}
}
cout << M + M1 << endl;
cout << x1 << " " << y11 << " " << x2 << " " << y2 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[2510][2510], s[2510][2510], n, m, K, Pl[10], Pr[10];
char S[2510];
long long ans;
inline int Get(int x1, int x2, int y1, int y2) {
x1 = max(x1, 1);
x2 = min(x2, n);
y1 = max(y1, 1);
y2 = min(y2, m);
return s[x2][y2] - s[x2][y1 - 1] - s[x1 - 1][y2] + s[x1 - 1][y1 - 1];
}
void solve(int U, int D, int L, int R) {
if (U > D || L > R) return;
if (U == D && L == R) {
if (Get(U, D, L, R) == K) ans++;
return;
}
if (D - U > R - L) {
int mid = (U + D) >> 1;
for (int i = L; i <= R; i++) {
int s = 0;
for (int j = 1; j <= K + 2; j++) Pl[j] = U - 1, Pr[j] = D + 1;
Pl[0] = mid;
Pr[0] = mid + 1;
for (int j = i; j >= L; j--) {
s += a[mid][j];
if (s > K) break;
for (int k = K + 1; k; k--) {
Pl[k] = max(Pl[k], Pl[k + 1]);
for (; Pl[k] < mid && Get(Pl[k] + 1, mid, j, i) >= k; Pl[k]++)
;
}
for (int k = K + 1; k; k--) {
Pr[k] = min(Pr[k], Pr[k + 1]);
for (; Pr[k] > mid + 1 && Get(mid + 1, Pr[k] - 1, j, i) >= k; Pr[k]--)
;
}
for (int k = 0; k <= K; k++) {
int t = K - k;
if (Get(mid + 1, Pr[t], j, i) == t && Get(Pl[k], mid, j, i) == k)
ans += (long long)(Pl[k] - Pl[k + 1]) * (Pr[t + 1] - Pr[t]);
}
}
}
solve(U, mid, L, R);
solve(mid + 1, D, L, R);
} else {
int mid = (L + R) >> 1;
for (int i = U; i <= D; i++) {
int s = 0;
for (int j = 1; j <= K + 2; j++) Pl[j] = L - 1, Pr[j] = R + 1;
Pl[0] = mid;
Pr[0] = mid + 1;
for (int j = i; j >= U; j--) {
s += a[j][mid];
if (s > K) break;
for (int k = K + 1; k; k--) {
Pl[k] = max(Pl[k], Pl[k + 1]);
for (; Pl[k] < mid && Get(j, i, Pl[k] + 1, mid) >= k; Pl[k]++)
;
}
for (int k = K + 1; k; k--) {
Pr[k] = min(Pr[k], Pr[k + 1]);
for (; Pr[k] > mid + 1 && Get(j, i, mid + 1, Pr[k] - 1) >= k; Pr[k]--)
;
}
for (int k = 0; k <= K; k++) {
int t = K - k;
if (Get(j, i, mid + 1, Pr[t]) == t && Get(j, i, Pl[k], mid) == k)
ans += (long long)(Pl[k] - Pl[k + 1]) * (Pr[t + 1] - Pr[t]);
}
}
}
solve(U, D, L, mid);
solve(U, D, mid + 1, R);
}
}
int main() {
scanf("%d%d%d", &n, &m, &K);
for (int i = 1; i <= n; i++) {
scanf("%s", S + 1);
for (int j = 1; j <= m; j++) a[i][j] = S[j] - 48;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + a[i][j];
solve(1, n, 1, m);
printf("%I64d\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double PI = acos(-1);
const int INF = (int)1e9 + 7;
const int MAXN = (int)5e5 + 7;
int n, m;
vector<int> v[555];
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i += 2) {
if (i > n * 2)
v[1].push_back(i);
else
v[2].push_back(i);
}
for (int i = 2; i <= m; i += 2) {
if (i > n * 2)
v[3].push_back(i);
else
v[4].push_back(i);
}
for (int i = 0; i < n; i++) {
for (int j = 1; j <= 4; j++) {
if (v[j].size() > i) printf("%d ", v[j][i]);
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int nod(int x, int y) {
int i, j, m, t;
t = 0;
if (x < y) i = x + 1;
if (x >= y) i = y + 1;
while (t == 0) {
i = i - 1;
if (((x % i) == 0) && ((y % i) == 0)) t = 1;
}
return i;
}
int main(void) {
int x, y, s, t, l1, k;
long int a, b;
scanf("%d", &x);
scanf("%d", &y);
scanf("%ld", &a);
scanf("%ld", &b);
s = 0;
k = nod(x, y);
t = y * (x / k);
s = s + (b / t) - (a / t);
if ((a % t) == 0) s = s + 1;
printf("%d", s);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > adjlist(100001);
int parent[100001];
int ranks[100001];
bool compare(pair<int, int> a, pair<int, int> b) { return a.first > b.first; }
int find_set(int v) {
if (parent[v] == v) return v;
return parent[v] = find_set(parent[v]);
}
void union_set(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (ranks[a] < ranks[b]) swap(a, b);
parent[b] = a;
ranks[a] += ranks[b];
}
}
int main() {
int n, m, i, j, k;
cin >> n >> m;
int arr1[n + 1];
pair<int, int> arr2[n + 1];
for (i = 1; i <= n; i++) {
cin >> arr1[i];
arr2[i].first = arr1[i];
arr2[i].second = i;
parent[i] = i;
ranks[i] = 1;
}
sort(arr2 + 1, arr2 + n + 1, compare);
for (i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
adjlist[y].push_back(x);
adjlist[x].push_back(y);
}
long long int res = 0ll;
int vis[n + 1];
memset(vis, 0, sizeof vis);
for (i = 1; i <= n; i++) {
k = arr2[i].second;
vis[k] = 1;
for (j = 0; j < adjlist[k].size(); j++) {
int t = adjlist[k][j];
if (vis[t]) {
t = find_set(t);
int v = find_set(k);
if (t != v) {
res += arr2[i].first * 1ll * (ranks[t] * 1ll * ranks[v]);
union_set(t, v);
}
}
}
}
float res1 = res * 1.0;
res1 = (res * 2.0) / (n * 1.0 * (n - 1));
cout << fixed << setprecision(6) << res1 << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int main() {
ios::sync_with_stdio(false);
long long x;
cin >> x;
long long sq = sqrt(x);
long long sol = x;
long long a = 1;
long long b = x;
for (long long i = 1; i <= sq + 1; i++) {
if (x % i == 0) {
long long t = x / i;
if (gcd(t, i) == 1) {
if (sol > max(t, i)) {
sol = max(t, i);
a = t;
b = i;
}
}
}
}
cout << a << " " << b << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
double pi = acos(-1);
int main() {
double w, h, a;
while (scanf("%lf%lf%lf", &w, &h, &a) != EOF) {
if (a > 90.0) {
a = 180.0 - a;
}
if (a == 0.0 || a == 180.0) {
printf("%.9lf\n", w * h);
continue;
}
if (a == 90.0) {
if (w <= h) {
printf("%.9lf\n", w * w);
} else {
printf("%.9lf\n", h * h);
}
continue;
}
a = a * pi / 180.0;
if (w < h) {
swap(w, h);
}
if (a <= 2 * atan(h / w)) {
double t = (cos(a) + 1.0) / sin(a);
double x = (h - t * w) / (sin(a) - t * cos(a) - t);
double s1 = x * x * sin(a) * cos(a);
double y = (w - x * (1 + cos(a))) * cos(a) / sin(a);
double s2 = y * y * sin(a) / cos(a);
printf("%.9lf\n", w * h - s1 - s2);
} else {
double t = (cos(a) + 1.0) / sin(a);
double s1 = (w - h * t + h * cos(a) / sin(a)) * h;
printf("%.9lf\n", w * h - s1);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int t[800005], lazy[800005], tin[300005], tout[300005], timer = 0;
vector<int> g[300005];
void dfs(int v) {
tin[v] = timer;
timer++;
for (int to : g[v]) {
dfs(to);
}
tout[v] = timer;
}
void push(int v, int sz) {
if (!lazy[v]) return;
t[v * 2] = sz / 2 - t[v * 2];
t[(v * 2) + 1] = sz / 2 - t[(v * 2) + 1];
lazy[v * 2] ^= lazy[v];
lazy[(v * 2) + 1] ^= lazy[v];
lazy[v] = 0;
return;
}
long long sum(int v, int cl, int cr, int l, int r) {
if (cr <= l || cl >= r) return 0;
if (cl >= l && cr <= r) return t[v];
int mid = (cr + cl) / 2;
push(v, cr - cl);
return sum(v * 2, cl, mid, l, r) + sum(v * 2 + 1, mid, cr, l, r);
}
void modify(int v, int cl, int cr, int l, int r) {
if (cr <= l || cl >= r) return;
if (l <= cl && cr <= r) {
lazy[v] ^= 1;
t[v] = (cr - cl) - t[v];
return;
}
int mid = (cl + cr) / 2;
push(v, cr - cl);
modify(v * 2, cl, mid, l, r);
modify((v * 2) + 1, mid, cr, l, r);
t[v] = t[v * 2] + t[(v * 2) + 1];
}
int main() {
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int x;
cin >> x;
x--;
g[x].push_back(i);
}
dfs(0);
int tn = 1;
while (tn < n) {
tn *= 2;
}
for (int i = 0; i < n; i++) {
cin >> t[tin[i] + tn];
}
for (int i = tn - 1; i > 0; i--) {
t[i] = t[i * 2] + t[i * 2 + 1];
}
int m;
cin >> m;
while (m--) {
string s;
cin >> s;
if (s == "get") {
int x;
cin >> x;
x--;
cout << sum(1, 0, tn, tin[x], tout[x]) << endl;
} else {
int x;
cin >> x;
x--;
modify(1, 0, tn, tin[x], tout[x]);
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
char s[103];
while (scanf("%d", &t) != EOF) {
int k;
for (int j = 0; j < t; j++) {
scanf("%d", &k);
scanf("%s", s);
int best = 0, cur = 0;
for (int i = 1; i < k; i++) {
if (s[i] == 'P' && (s[i - 1] == 'A' || cur != 0))
cur++;
else if (s[i] == 'A' && cur != 0) {
best = max(best, cur);
cur = 0;
}
}
best = max(best, cur);
printf("%d\n", best);
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long x;
cin >> x;
for (long long i = 1; i <= 50; i++) {
long long val = abs(x + i);
while (val != 0) {
if (val % 10 == 8) {
cout << i;
return 0;
}
val /= 10;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int q;
cin >> q;
while (q--) {
long long int n;
cin >> n;
if (n == 1)
cout << "3" << endl;
else if (n == 2)
cout << "2" << endl;
else if (n == 3)
cout << "1" << endl;
else if (n % 2 == 0)
cout << "0" << endl;
else if (n % 2 == 1)
cout << "1" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
constexpr T lcm(T m, T n) {
return m / __gcd(m, n) * n;
}
template <typename I>
void join(ostream &ost, I s, I t, string d = " ") {
for (auto i = s; i != t; ++i) {
if (i != s) ost << d;
ost << *i;
}
ost << endl;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (auto &a : v) is >> a;
return is;
}
template <typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T, typename U>
bool chmin(T &a, const U &b) {
return (a > b ? a = b, true : false);
}
template <typename T, typename U>
bool chmax(T &a, const U &b) {
return (a < b ? a = b, true : false);
}
template <typename T, size_t N, typename U>
void fill_array(T (&a)[N], const U &v) {
fill((U *)a, (U *)(a + N), v);
}
class pt {
public:
double x, y;
pt() : x(0), y(0) {}
pt(double x, double y) : x(x), y(y) {}
};
pt operator+(const pt &a, const pt &b) { return pt(a.x + b.x, a.y + b.y); }
pt operator-(const pt &a, const pt &b) { return pt(a.x - b.x, a.y - b.y); }
pt operator-(const pt &a) { return pt(-a.x, -a.y); }
bool operator==(const pt &a, const pt &b) { return a.x == b.x and a.y == b.y; }
bool operator!=(const pt &a, const pt &b) { return !(a == b); }
double dot(const pt &a, const pt &b) { return a.x * b.x + a.y * b.y; }
double cross(const pt &a, const pt &b) { return a.x * b.y - a.y * b.x; }
ostream &operator<<(ostream &os, const pt &a) {
os << "(" << a.x << "," << a.y << ")";
return os;
}
vector<pt> upper_hull(vector<pt> pts) {
sort((pts).begin(), (pts).end(), [](const pt &a, const pt &b) {
return (a.x < b.x) or (a.x == b.x and a.y < b.y);
});
reverse((pts).begin(), (pts).end());
vector<pt> ret;
ret.push_back(pts.back());
pts.pop_back();
while (not pts.empty()) {
auto s = pts.back();
pts.pop_back();
if (ret.size() == 1) {
ret.push_back(s);
} else {
auto p = *(ret.end() - 2);
auto q = ret.back();
if (cross(q - p, s - p) <= 0) {
ret.push_back(s);
} else {
ret.pop_back();
pts.push_back(s);
}
}
}
return ret;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
while (cin >> n) {
vector<long long int> x(n), y(n);
for (int i = (0); i < (n); ++i) cin >> x[i] >> y[i];
vector<pt> pts(n);
for (int i = (0); i < (n); ++i) pts[i] = pt(x[i], y[i] - x[i] * x[i]);
auto uh = upper_hull(pts);
int ans = 0;
for (int i = (0); i < ((int)uh.size() - 1); ++i) {
if (uh[i].x - uh[i + 1].x != 0 and
(i == 0 or cross(uh[i] - uh[i - 1], uh[i + 1] - uh[i - 1]) != 0)) {
++ans;
}
}
cout << ans << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
const double eps = 1e-17;
int read() {
int s = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
s = s * 10 + ch - '0';
ch = getchar();
}
return s * f;
}
double dp[1010][1010];
void dfs(int n, int m) {
if (dp[n][m] > 0) return;
if (n == 0) {
dp[0][m] = 1.0 / (m + 1);
return;
}
if (m == 0) {
dp[n][0] = 1.0;
return;
}
dfs(m - 1, n);
dfs(m, n - 1);
double slope = dp[m][n - 1] / (dp[m][n - 1] + 1.0 / (m + 1));
dp[n][m] = slope * (double)m / (m + 1) * (1 - dp[m - 1][n]) + 1 - slope;
}
int main() {
n = read(), m = read();
dfs(n, m);
printf("%.12lf %.12lf", dp[n][m], 1.0 - dp[n][m]);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int q, i, dec = 0, inc = 0, t, S = 1000000;
cin >> q;
vector<long long int> vi(S);
for (i = 0; i < q; i++) {
string s;
long long int n;
cin >> s >> n;
if (i == 0) {
vi[n] = dec;
dec--;
inc++;
} else {
if (s == "L") {
vi[n] = dec;
dec--;
} else if (s == "R") {
vi[n] = inc;
inc++;
} else {
t = min(abs(vi[n] - inc), abs(vi[n] - dec));
cout << t - 1 << endl;
}
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int m1, y11, d1, m2, y2, d2,
mon[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
char in1[20], in2[20];
int cmp(int yy1, int yy2, int mm1, int mm2, int dd1, int dd2) {
if (yy1 > yy2) return 1;
if (yy1 < yy2) return 2;
if (mm1 > mm2) return 1;
if (mm1 < mm2) return 2;
if (dd1 > dd2) return 1;
if (dd1 < dd2) return 2;
return 0;
}
int leap(int y) {
if (y % 400 == 0 || (y % 100 != 0 && y % 4 == 0)) return 1;
return 0;
}
int main() {
scanf("%s %s", in1, in2);
int is = 0;
m1 = y11 = d1 = m2 = y2 = d2 = 0;
y11 += ((in1[0] - '0') * 1000 + (in1[1] - '0') * 100 + (in1[2] - '0') * 10 +
(in1[3] - '0'));
y2 += ((in2[0] - '0') * 1000 + (in2[1] - '0') * 100 + (in2[2] - '0') * 10 +
(in2[3] - '0'));
m1 += ((in1[5] - '0') * 10 + (in1[6] - '0'));
m2 += ((in2[5] - '0') * 10 + (in2[6] - '0'));
d1 += ((in1[8] - '0') * 10 + (in1[9] - '0'));
d2 += ((in2[8] - '0') * 10 + (in2[9] - '0'));
if (cmp(y11, y2, m1, m2, d1, d2) == 1) {
swap(y11, y2);
swap(m1, m2);
swap(d1, d2);
}
while (y11 != y2 || m1 != m2) {
m2--;
if (m2 == 0) {
m2 = 12;
y2--;
}
if (m2 == 2)
if (leap(y2))
d2 += 29;
else
d2 += 28;
else
d2 += (mon[m2]);
}
printf("%d\n", d2 - d1);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, h, t;
cin >> n >> m >> h >> t;
vector<vector<int>> ad(n);
vector<pair<int, int>> edge(m * 2);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--, b--;
if (ad[a].size() < 202) ad[a].push_back(b);
if (ad[b].size() < 202) ad[b].push_back(a);
edge[2 * i] = make_pair(a, b);
edge[2 * i + 1] = make_pair(b, a);
}
vector<bool> table(n);
for (int i = 0; i < m * 2; i++) {
int aa = 0, bb = 0, cc = 0;
int a = edge[i].first, b = edge[i].second;
aa = ad[a].size() - 1, bb = ad[b].size() - 1;
if (aa < h || bb < t) continue;
for (int ch : ad[b]) {
table[ch] = true;
}
for (int ch : ad[a]) {
if (table[ch]) cc++;
}
for (int ch : ad[b]) {
table[ch] = false;
}
aa -= cc, bb -= cc;
int dd = 0;
if (aa < h) {
if ((h - aa) > cc) continue;
cc -= h - aa;
dd += h - aa;
}
if ((bb + cc) < t) continue;
cout << "YES\n";
cout << a + 1 << " " << b + 1 << "\n";
for (int ch : ad[b]) {
table[ch] = true;
}
int count = 0;
int ccc = 0;
for (int ch : ad[a]) {
if (ch == b) continue;
if (table[ch]) {
if (dd <= ccc) continue;
ccc++;
table[ch] = false;
}
cout << ch + 1 << " ";
count++;
if (count == h) break;
}
cout << "\n";
count = 0;
for (int ch : ad[b]) {
if (ch == a || !table[ch]) continue;
cout << ch + 1 << " ";
count++;
if (count == t) break;
}
cout << "\n";
return 0;
}
cout << "NO\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6;
int n;
int dp[MAX + 3], pos[MAX + 3];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
cin >> pos[x];
}
if (pos[0] > 0) {
dp[0] = 1;
}
int ans = 0;
for (int i = 1; i <= MAX; i++) {
if (pos[i] == 0) {
dp[i] = dp[i - 1];
} else {
if (pos[i] >= i) {
dp[i] = 1;
} else {
dp[i] = dp[i - pos[i] - 1] + 1;
}
}
ans = max(ans, dp[i]);
}
cout << n - ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k, p, x, y, sum = 0, q = 0;
cin >> n >> k >> p >> x >> y;
vector<int> v(k);
for (auto &t : v) {
cin >> t;
sum += t;
if (t >= y) q++;
}
vector<int> ans;
if (q + n - k < (n + 1) / 2) {
cout << "-1\n";
return 0;
}
while (q < (n + 1) / 2) {
ans.push_back(y);
sum += y;
k++;
q++;
}
while (k < n) {
ans.push_back(1);
k++;
sum++;
}
if (sum > x) {
cout << "-1\n";
} else {
for (auto t : ans) cout << t << " ";
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MXN = (int)2e6 + 10;
const int INF = (int)1e9 + 7;
const double EPS = (double)1e-9;
char ch1[600][600];
char ch[300][300];
char ch2[300][300];
int n;
vector<pair<int, int> > ans;
vector<pair<int, int> > fig;
vector<pair<int, int> > dirs[300];
bool check(int x, int y) { return (x >= 0 && x < n && y >= 0 && y < n); }
bool checkAll() {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
ch2[i][j] = '.';
}
}
for (int i = 0; i < fig.size(); ++i) {
ch2[fig[i].first][fig[i].second] = 'o';
}
for (int i = 0; i < fig.size(); ++i) {
for (int j = 0; j < ans.size(); ++j) {
if (check(fig[i].first + ans[j].first, fig[i].second + ans[j].second) &&
ch2[fig[i].first + ans[j].first][fig[i].second + ans[j].second] !=
'o') {
ch2[fig[i].first + ans[j].first][fig[i].second + ans[j].second] = 'x';
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (ch[i][j] != ch2[i][j]) return false;
}
}
return true;
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
cin >> ch[i][j];
if (ch[i][j] == 'o') fig.push_back(make_pair(i, j));
}
}
for (int dx = -n; dx <= n; ++dx) {
for (int dy = -n; dy <= n; ++dy) {
bool boo = true;
int nx, ny;
for (int i = 0; i < fig.size(); ++i) {
nx = fig[i].first + dx;
ny = fig[i].second + dy;
if (check(nx, ny) && ch[nx][ny] == '.') {
boo = false;
break;
}
}
if (boo) {
ans.push_back(make_pair(dx, dy));
}
}
}
if (!checkAll()) {
printf("NO");
return 0;
}
printf("YES\n");
for (int i = 0; i < n + n - 1; ++i) {
for (int j = 0; j < n + n - 1; ++j) {
ch1[i][j] = '.';
}
}
for (int i = 0; i < ans.size(); ++i) {
if (n - 1 + ans[i].first >= 0 && n - 1 + ans[i].first < n + n - 1 &&
n - 1 + ans[i].second >= 0 && n - 1 + ans[i].second < n + n - 1)
ch1[n - 1 + ans[i].first][n - 1 + ans[i].second] = 'x';
}
ch1[n - 1][n - 1] = 'o';
for (int i = 0; i < n + n - 1; ++i) {
cout << ch1[i] << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int _min(int x, int y) { return x < y ? x : y; }
int _max(int x, int y) { return x > y ? x : y; }
int read() {
int s = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();
return s * f;
}
struct edge {
int x, y, next;
} e[110000];
int len, last[110000];
long long S, s[20][110000];
int L, a[110000], top[110000], ans;
int fa[20][110000], dep[110000];
void ins(int x, int y) {
e[++len].x = x, e[len].y = y;
e[len].next = last[x];
last[x] = len;
}
int jump(int x) {
long long u = S - a[x];
int now = L - 1;
for (int i = 18; i >= 0; i--) {
if (now >= (1 << i) && u >= s[i][x]) {
now -= (1 << i);
u -= s[i][x];
x = fa[i][x];
}
}
if (x)
return x;
else
return 1;
}
void dfs(int x) {
for (int i = 1; (1 << i) <= dep[x]; i++)
fa[i][x] = fa[i - 1][fa[i - 1][x]],
s[i][x] = s[i - 1][x] + s[i - 1][fa[i - 1][x]];
top[x] = jump(x);
for (int k = last[x]; k; k = e[k].next) {
int y = e[k].y;
dep[y] = dep[x] + 1;
s[0][y] = a[x];
dfs(y);
}
}
void getans(int x) {
int gg = 0;
for (int k = last[x]; k; k = e[k].next) {
int y = e[k].y;
getans(y);
if (top[y] == y) continue;
if (gg == 0)
gg = top[y];
else if (dep[gg] > dep[top[y]])
gg = top[y];
}
if (gg == 0) gg = top[x], ans++;
top[x] = gg;
}
int main() {
int n = read();
L = read();
cin >> S;
for (int i = 1; i <= n; i++) {
a[i] = read();
if (a[i] > S) {
printf("-1\n");
return 0;
}
}
for (int i = 2; i <= n; i++) ins(fa[0][i] = read(), i);
dep[1] = 1;
dfs(1);
getans(1);
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int ans = 0;
int i, j, n, m, k, z, t, x, y;
int a[211111];
int const d = -1e9;
vector<int> v[111111];
void dfs(int i) {
a[i] = 1;
for (int j = 0; j < (int)v[i].size(); j++)
if (a[v[i][j]] == 0) dfs(v[i][j]);
a[i] = 2;
printf("%d ", i);
}
int main() {
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%d %d", &x, &y);
v[x].push_back(y);
}
for (i = 1; i <= n; i++)
if (a[i] == 0) dfs(i);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int h, m, s, t1, t2;
bool avai, flag;
int main() {
int i, j, k;
scanf("%d%d%d%d%d", &h, &m, &s, &t1, &t2);
h %= 12;
h *= 10;
m *= 2;
s *= 2;
if (s != 0) ++m;
if (m != 0) ++h;
t1 %= 12;
t2 %= 12;
t1 *= 10;
t2 *= 10;
if (t1 > t2) {
swap(t1, t2);
}
flag = true;
for (i = t1; i <= t2; ++i) {
if (i == h || i == m || i == s) {
flag = false;
break;
}
}
avai = flag;
flag = true;
for (i = t2; i <= 120; ++i) {
if (i == h || i == m || i == s) {
flag = false;
break;
}
}
for (i = 0; i <= t1; ++i) {
if (i == h || i == m || i == s) {
flag = false;
break;
}
}
avai |= flag;
if (avai) {
printf("YES\n");
} else {
printf("NO\n");
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
void jabru() {
long long n;
cin >> n;
long long ans = LLONG_MAX;
for (long long j = 1; j * j <= n; j++) {
if (n % j == 0) {
long long here = max(j, n / j);
if (gcd(j, n / j) == 1) ans = min(ans, here);
}
}
cout << ans << " " << n / ans << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
t = 1;
while (t--) {
jabru();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
short m;
cin >> m;
while (m--) {
int k;
cin >> k;
string s = "";
for (int i = 0; i < k - 1; i++) {
s += "(";
}
for (int i = k; i < (k * 2) - 1; i++) {
s += ")";
}
cout << "()" << s << endl;
int it = 0;
it++;
k--;
while (k > 0) {
s.insert(it, "()");
cout << s << endl;
s.erase(it, 2);
k--;
it++;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long maxK = 15;
const long long maxN = 5000;
void bad() {
cout << "No" << '\n';
exit(0);
}
long long k, sum = 0, target;
vector<long long> Ns(maxK), Si(maxK);
vector<bool> dp((1 << maxK), false);
vector<long long> path((1 << maxK), -1);
vector<vector<pair<long long, pair<long long, long long>>>> cycles(1 << maxK);
vector<vector<long long>> ele(maxK, vector<long long>(maxN));
map<long long, long long> findEle;
vector<pair<long long, long long>> ans(maxK);
void findCycles() {
for (long long i = 0; i < k; i++) {
for (long long j = 0; j < Ns[i]; j++) {
long long mask = (1 << i);
long long prev = i;
bool pos = true;
long long findNext = target - Si[i] + ele[i][j];
vector<pair<long long, pair<long long, long long>>> connect;
while (1) {
if (!findEle.count(findNext)) {
pos = false;
break;
}
long long box = findEle[findNext];
if ((((1 << box) & mask) && (box != i)) ||
((box == i) && (findNext != ele[i][j]))) {
pos = false;
break;
}
if (box == i) {
connect.push_back({box, {prev, findNext}});
break;
}
connect.push_back({box, {prev, findNext}});
mask |= (1 << box);
prev = box;
findNext = target - Si[box] + findNext;
}
if (pos) {
dp[mask] = true;
cycles[mask] = connect;
}
}
}
}
void dfs(long long mask) {
if (cycles[mask].size()) {
for (auto i : cycles[mask]) {
ans[i.first] = {i.second.second, i.second.first + 1};
}
return;
}
long long one = path[mask];
long long two = (mask ^ path[mask]);
dfs(one);
dfs(two);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> k;
for (long long i = 0; i < k; i++) {
cin >> Ns[i];
for (long long j = 0; j < Ns[i]; j++) {
cin >> ele[i][j];
findEle[ele[i][j]] = i;
sum += ele[i][j];
Si[i] += ele[i][j];
}
}
if (sum % k) bad();
target = sum / k;
findCycles();
for (long long i = 1; i < (1 << k); i++) {
if (!dp[i]) continue;
for (long long j = i; j < (1 << k); j = i | (j + 1)) {
if (!dp[(j ^ i)]) continue;
dp[j] = true;
path[j] = i;
}
}
if (!dp[(1 << k) - 1]) bad();
cout << "Yes" << '\n';
dfs((1 << k) - 1);
for (long long i = 0; i < k; i++) {
cout << ans[i].first << " " << ans[i].second << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long INF = 2e9;
const long long N = 3e5 + 35;
void kudne() {
long long n;
cin >> n;
vector<pair<long long, long long>> st(n);
vector<long long> ed(n);
for (long long i = 0; i < n; ++i) {
cin >> st[i].first >> ed[i];
st[i].second = i;
}
sort(st.begin(), st.end());
long long m;
cin >> m;
vector<pair<long long, long long>> a(m);
vector<long long> b(m), v(m);
for (long long i = 0; i < m; ++i) {
cin >> a[i].first >> b[i] >> v[i];
a[i].second = i;
}
sort(a.begin(), a.end());
vector<long long> ans(n);
set<pair<long long, long long>> s;
long long id = 0;
for (long long i = 0; i < n; ++i) {
while (id < m && a[id].first <= st[i].first) {
long long k = a[id].second;
s.insert({b[k], k});
id++;
}
long long j = st[i].second;
auto it = s.lower_bound({ed[j], -1});
if (it == s.end()) {
cout << "NO";
return;
}
auto p = *it;
ans[j] = p.second + 1;
v[p.second]--;
if (!v[p.second]) s.erase(it);
}
cout << "YES\n";
for (long long x : ans) cout << x << " ";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long tc = 1;
for (long long i = 1; i <= tc; ++i) {
kudne();
if (i < tc) cout << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double A[2], B[2], C[2];
cin >> A[0] >> A[1] >> B[0] >> B[1] >> C[0] >> C[1];
double area2 = (B[0] - A[0]) * (C[1] - A[1]) - (B[1] - A[1]) * (C[0] - A[0]);
if (area2 > 0) cout << "LEFT\n";
if (area2 < 0) cout << "RIGHT\n";
if (area2 == 0) cout << "TOWARDS\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
#define ll long long int
#define fastIO ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define ff first
#define ss second
#define pb push_back
#define po pop_back()
#define lb lower_bound
#define ub upper_bound
#define nl "\n"
#define dbg(x) cout << (#x) << " = " << (x) << nl
#define yes cout << "YES\n"
#define no cout << "NO\n"
#define fl(i,a,b,c) for(int i=a;i<b;i+=c)
#define rl(i,a,b,c) for(int i=a;i>b;i-=c)
#define sn(a,l) fl(i,0,l,1) cin >> a[i]
#define pr(a,l) fl(i,0,l,1) cout << a[i] << ' '
#define all(a) a.begin(),a.end()
#define sz(a) (int)a.size()
#define test() int ts; cin>>ts; while(ts--)
const int INF = 1e9 + 1;
const int MOD = 1e9 + 7;
const int N = 2e5 + 5;
const int K = 20;
using namespace std;
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
// template<class T> using oset = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
// CODE BEGINS HERE ---
void solve()
{
int n, l, r, s;
cin >> n >> l >> r >> s;
int m = r-l+1;
if(s < ((m*(m+1))/2) || s > (m*n - (m*(m-1))/2))
{
cout << -1 << nl;
return;
}
vector<int> v(m);
fl(i,0,m,1)
v[i] = i+1;
int j = m-1;
int s1 = m*(m+1)/2;
while(s1 != s)
{
if(j == m-1 && v[j] == n)
j--;
if(j != m-1 && v[j] == (v[j+1]-1))
j--;
v[j]++;
s1++;
}
set<int> st;
fl(i,0,n,1)
st.insert(i+1);
vector<int> p(n);
fl(i,l-1,r,1)
{
p[i] = v.back();
st.erase(v.back());
v.po;
}
fl(i,0,l-1,1)
{
p[i] = *st.begin();
st.erase(st.begin());
}
fl(i,r,n,1)
{
p[i] = *st.begin();
st.erase(st.begin());
}
pr(p,n);
cout << nl;
}
int main()
{
fastIO
test()
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
long long ans = 0;
for (int i = 1; i < min(b, c); i++) {
ans += a;
a++;
}
ans *= 2;
for (int i = min(b, c); i <= max(b, c); i++) {
ans += a;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k, IT[1000000][32];
void update(int x, vector<int> p, int i, int l, int r) {
if (x < l || r < x) return;
if (l == r) {
for (int m = 0; m < (1 << k); ++m) {
int calc = 0;
for (int i = 0; i < k; ++i) (m & (1 << i)) ? calc += p[i] : calc -= p[i];
IT[i][m] = calc;
}
return;
}
update(x, p, 2 * i, l, (l + r) / 2);
update(x, p, 2 * i + 1, (l + r) / 2 + 1, r);
for (int m = 0; m < (1 << k); ++m)
IT[i][m] = max(IT[2 * i][m], IT[2 * i + 1][m]);
}
int get(int x, int y, int m, int i, int l, int r) {
if (y < l || r < x) return -1e9;
if (x <= l && r <= y) return IT[i][m];
int x1 = get(x, y, m, 2 * i, l, (l + r) / 2);
int x2 = get(x, y, m, 2 * i + 1, (l + r) / 2 + 1, r);
return max(x1, x2);
}
int ans(int l, int r) {
int res = 0;
for (int m = 0, x1, x2; m < (1 << k); ++m)
x1 = get(l, r, m, 1, 1, n), x2 = get(l, r, ((1 << k) - 1) ^ m, 1, 1, n),
res = max(res, x1 + x2);
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
vector<int> p;
for (int i = 0, x; i < k; ++i) cin >> x, p.push_back(x);
update(i, p, 1, 1, n);
p.clear();
}
int q;
cin >> q;
for (int t, i, l, r; q--;) {
cin >> t;
if (t == 1) {
cin >> i;
vector<int> p;
for (int i = 0, x; i < k; ++i) cin >> x, p.push_back(x);
update(i, p, 1, 1, n);
p.clear();
} else
cin >> l >> r, cout << ans(l, r) << '\n';
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
set<int>* merge(set<int>* a, set<int>* b) {
if (a->size() < b->size()) swap(a, b);
a->insert((*b).begin(), (*b).end());
delete b;
return a;
}
struct Node {
Node *go[27], *par;
int val, id;
vector<Node*> ch;
Node() {
memset(go, 0, sizeof go);
val = 0;
par = 0;
id = -1;
}
int nInclude;
set<int>* dfs() {
set<int>* st = new set<int>();
if (id != -1) {
st->insert(id);
}
for (vector<Node*>::iterator it = ch.begin(); it != ch.end(); it++)
st = merge(st, (*it)->dfs());
nInclude = st->size();
return st;
}
};
Node nodePool[400040], *cur = nodePool;
Node *root, *last;
void Init() {
root = last = cur++;
return;
}
void insert(int w, int id = -1) {
Node *p = last, *np = cur++;
np->val = p->val + 1;
np->id = id;
while (p && p->go[w] == 0) p->go[w] = np, p = p->par;
if (p == 0)
np->par = root;
else {
Node* q = p->go[w];
if (q->val == p->val + 1)
np->par = q;
else {
Node* nq = cur++;
memcpy(nq->go, q->go, sizeof q->go);
nq->val = p->val + 1;
nq->par = q->par;
q->par = np->par = nq;
while (p && p->go[w] == q) p->go[w] = nq, p = p->par;
}
}
last = np;
}
string a[100010];
int n, k;
int main() {
Init();
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> a[i];
for (int j = 0; j < a[i].size(); ++j) {
insert(a[i][j] - 'a', i);
}
insert(26);
}
for (Node* i = nodePool; i != cur; ++i)
if (i->par) i->par->ch.push_back(i);
root->dfs();
for (int i = 0; i < n; ++i) {
string& s = a[i];
int l = 0;
Node* c = root;
long long ans = 0;
for (int j = 0; j < s.size(); ++j) {
int w = s[j] - 'a';
if (c) {
c = c->go[w];
++l;
}
while (c && c->nInclude < k) {
c = c->par;
if (c)
l = c->val;
else
l = 0;
}
ans += l;
}
cout << ans << " ";
}
cout << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n % m; i++) cout << n / m + 1 << " ";
for (int i = n % m; i < m; i++) cout << n / m << " ";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int get(string s, int n, int k) {
int dp[3][n + 2];
sort(s.begin(), s.end());
dp[0][0] = 1;
dp[1][0] = s[0] - 'a' + 1;
for (int i = 1; i < n; i++) {
dp[0][i] = 1;
dp[1][i] = s[i] - 'a' + 1;
for (int j = 0; j < i; j++) {
if (s[i] - s[j] > 1 && dp[0][j] < k) {
if ((dp[1][i] > dp[1][j] + s[i] - 'a' + 1) || dp[0][j] >= dp[0][i]) {
dp[0][i] = dp[0][j] + 1;
dp[1][i] = dp[1][j] + s[i] - 'a' + 1;
}
}
}
}
int ans = INT_MAX;
for (int j = 0; j < n; j++) {
if (dp[0][j] == k) {
ans = min(ans, dp[1][j]);
}
}
if (ans == INT_MAX) return -1;
return ans;
}
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
cout << get(s, n, k) << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int M = 400005;
int gcd(int x, int y) { return !y ? x : gcd(y, x % y); }
int n;
bool mark[M];
int c[M];
int A[M], dp[M], cnt[M];
int Gcd[M];
int main() {
cin >> n;
for (int i = 0; i <= n; ++i) Gcd[i] = gcd(i, n);
for (int i = 0; i < n; ++i) cin >> A[i];
for (int i = n; i < n + n; ++i) A[i] = A[i - n];
long long ans = 0;
for (int d = 1; d <= n; ++d) {
if (n % d) continue;
memset(mark, 0, sizeof(mark));
for (int i = 0; i < d; ++i) {
int mx = 0;
for (int j = i; j < n + n; j += d)
if (A[j] > mx) mx = A[j];
for (int j = i; j < n + n; j += d)
if (A[j] == mx) mark[j] = true;
}
dp[0] = mark[0];
for (int i = 1; i < n + n; ++i) {
if (mark[i])
dp[i] = dp[i - 1] + 1;
else
dp[i] = 0;
dp[i] = min(dp[i], n - 1);
}
cnt[0] = 0;
for (int i = 1; i < n / d; ++i) cnt[i] = cnt[i - 1] + (Gcd[i * d] == d);
for (int i = n; i < n + n; ++i) ans += cnt[dp[i] / d];
}
cout << ans << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 6;
vector<pair<int, int>> g[N];
bool u[N];
int col[N];
void dfs(int v, int c) {
u[v] = 1;
col[v] = c;
for (auto e : g[v])
if (e.second == 1) {
int i = e.first;
if (!u[i]) dfs(i, c);
}
}
bool ok = true;
int a[N];
void bip(int v, int c) {
if (a[v]) {
if (a[v] != c) ok = false;
return;
}
a[v] = c;
for (auto e : g[v]) {
int i = e.first;
if (e.second == 1)
bip(i, c);
else
bip(i, -c);
}
}
int mod = 1e9 + 7;
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int k = 0; k < m; ++k) {
int i, j, t;
scanf("%d%d%d", &i, &j, &t);
--i;
--j;
g[j].push_back({i, t});
g[i].push_back({j, t});
}
int c = 0;
for (int i = 0; i < n; ++i)
if (!u[i]) {
dfs(i, c);
++c;
}
int cb = 0;
for (int i = 0; i < n; ++i)
if (!a[i]) {
bip(i, 1);
++cb;
}
if (!ok) {
cout << 0 << endl;
return 0;
}
long long ans = 1;
for (int i = 0; i < cb - 1; ++i) ans = ans * 2 % mod;
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, m;
cin >> a >> b;
for (int i = 0; i < a + 1; i++) cout << b + i + 1 << ' ';
for (int i = 0; i < b; i++) cout << b - i << ' ';
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
using namespace std;
template <typename _T>
inline void read(_T &f) {
f = 0;
_T fu = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') fu = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
f = (f << 3) + (f << 1) + (c & 15);
c = getchar();
}
f *= fu;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x < 10)
putchar(x + 48);
else
print(x / 10), putchar(x % 10 + 48);
}
template <typename T>
void print(T x, char t) {
print(x);
putchar(t);
}
template <typename T>
struct hash_map_t {
vector<T> v, val, nxt;
vector<int> head;
int mod, tot, lastv;
T lastans;
bool have_ans;
hash_map_t(int md = 0) {
head.clear();
v.clear();
val.clear();
nxt.clear();
tot = 0;
mod = md;
nxt.resize(1);
v.resize(1);
val.resize(1);
head.resize(mod);
have_ans = 0;
}
void clear() { *this = hash_map_t(mod); }
bool count(int x) {
int u = x % mod;
for (register int i = head[u]; i; i = nxt[i]) {
if (v[i] == x) {
have_ans = 1;
lastv = x;
lastans = val[i];
return 1;
}
}
return 0;
}
void ins(int x, int y) {
int u = x % mod;
nxt.push_back(head[u]);
head[u] = ++tot;
v.push_back(x);
val.push_back(y);
}
int qry(int x) {
if (have_ans && lastv == x) return lastans;
count(x);
return lastans;
}
};
const int N = 105, M = 2005;
vector<int> adj[M];
int pre[M], x[M], a[M], F[M], used[M];
int f[N][N];
int n, m, s, b, k, h;
int dfs1(int u) {
for (register unsigned i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (!used[v]) {
used[v] = 1;
if (!pre[v] || dfs1(pre[v])) {
pre[v] = u;
return 1;
}
}
}
return 0;
}
int main() {
memset(f, 0x3f, sizeof(f));
read(n);
read(m);
for (register int i = 1; i <= m; i++) {
int u, v;
read(u);
read(v);
f[u][v] = f[v][u] = 1;
}
for (register int i = 1; i <= n; i++) f[i][i] = 0;
for (register int k = 1; k <= n; k++) {
for (register int i = 1; i <= n; i++) {
for (register int j = 1; j <= n; j++) {
f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
}
}
}
read(s);
read(b);
read(k);
read(h);
for (register int i = 1; i <= s; i++) {
read(x[i]);
read(a[i]);
read(F[i]);
}
for (register int i = 1; i <= b; i++) {
int x, d;
read(x);
read(d);
for (register int j = 1; j <= s; j++) {
if (f[::x[j]][x] <= F[j] && a[j] >= d) {
adj[j].push_back(i + s);
adj[i + s].push_back(j);
}
}
}
int ans = 0;
for (register int i = 1; i <= s; i++) {
memset(used, 0, sizeof(used));
ans += dfs1(i);
}
if (1ll * ans * k <= 1ll * s * h)
cout << 1ll * ans * k << endl;
else
cout << 1ll * s * h << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
const int oo = 1e9 + 7;
int n, q;
int t[N];
string s;
struct Node {
int mn, mx, pre, suf, tot;
Node() {}
Node(int mn, int mx, int pre, int suf, int tot)
: mn(mn), mx(mx), pre(pre), suf(suf), tot(tot) {}
Node operator+(const Node &Other) const {
Node res;
res.mn = min(mn, Other.mn);
res.mx = max(mx, Other.mx);
res.pre = max(mx - 2 * Other.mn, max(pre, Other.pre));
res.suf = max(-2 * mn + Other.mx, max(suf, Other.suf));
res.tot = max(max(pre + Other.mx, mx + Other.suf), max(tot, Other.tot));
return res;
}
};
struct segTree {
Node tree[N << 3];
int lazy[N << 3];
void Build(int first, int low, int high) {
if (low == high) {
tree[first] = Node(t[low], t[low], -t[low], -t[low], 0);
} else {
int mid = low + high >> 1;
Build(first << 1, low, mid);
Build(first << 1 | 1, mid + 1, high);
tree[first] = tree[2 * first] + tree[2 * first + 1];
}
}
void Lazy(int first) {
tree[first].mn += lazy[first];
tree[first].mx += lazy[first];
tree[first].pre -= lazy[first];
tree[first].suf -= lazy[first];
lazy[2 * first] += lazy[first];
lazy[2 * first + 1] += lazy[first];
lazy[first] = 0;
}
void Update(int first, int l, int r, int i, int j, int val) {
Lazy(first);
if (l > j || r < i) return;
if (l >= i && r <= j) {
lazy[first] += val;
Lazy(first);
return;
}
int mid = l + r >> 1;
Update(2 * first, l, mid, i, j, val);
Update(2 * first + 1, mid + 1, r, i, j, val);
tree[first] = tree[2 * first] + tree[2 * first + 1];
}
} IT;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
if (fopen("test.inp", "r"))
freopen("test.inp", "r", stdin), freopen("test.out", "w", stdout);
cin >> n >> q;
cin >> s;
s = ' ' + s;
t[0] = 1;
n = 2 * n - 2;
for (int i = 1; i <= n; i++) {
char ch = s[i];
t[i] = t[i - 1];
if (ch == '(')
t[i]++;
else
t[i]--;
}
IT.Build(1, 1, n);
cout << IT.tree[1].tot << endl;
for (int i = 1; i <= q; i++) {
int u, v;
cin >> u >> v;
if (s[u] == '(')
IT.Update(1, 1, n, u, n, -2);
else
IT.Update(1, 1, n, u, n, 2);
if (s[v] == '(')
IT.Update(1, 1, n, v, n, -2);
else
IT.Update(1, 1, n, v, n, 2);
swap(s[u], s[v]);
cout << IT.tree[1].tot << endl;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int w = 1, s = 0;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') w = -1;
ch = getchar();
}
while (isdigit(ch)) {
s = s * 10 + ch - '0';
ch = getchar();
}
return w * s;
}
int R[1010], C[1010], n, cnt, pos1[1010], pos2[1010];
pair<pair<int, int>, pair<int, int> > Ans[1010];
int main() {
n = read();
for (register int i = 1; i <= n; ++i) R[i] = read(), pos1[R[i]] = i;
for (register int i = 1; i <= n; ++i) C[i] = read(), pos2[C[i]] = i;
for (register int i = 1; i <= n; ++i) {
int x = pos1[i], y = pos2[i];
if (x == y && x == i) continue;
Ans[++cnt] = make_pair(make_pair(x, i), make_pair(i, y));
R[x] = R[i];
C[y] = C[i];
pos1[R[x]] = x;
pos2[C[y]] = y;
}
cout << cnt << "\n";
for (register int i = 1; i <= cnt; ++i) {
cout << Ans[i].first.first << " " << Ans[i].first.second << " "
<< Ans[i].second.first << " " << Ans[i].second.second << "\n";
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long curMod;
long long mulMod(long long a, long long b) {
long long res = b & 1 ? a : 0, acc = a;
for (b >>= 1; b; b >>= 1) {
acc = (acc + acc) % curMod;
if (b & 1) res = (res + acc) % curMod;
}
return res;
}
struct Matrix {
long long ele[2][2];
} IdMat;
Matrix operator*(const Matrix &A, const Matrix &B) {
static Matrix ret;
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) {
ret.ele[i][j] = 0;
for (int k = 0; k < 2; k++)
ret.ele[i][j] =
(ret.ele[i][j] + mulMod(A.ele[i][k], B.ele[k][j])) % curMod;
}
return ret;
}
Matrix powMat(Matrix A, long long n) {
Matrix res = n & 1 ? A : IdMat;
for (n >>= 1; n; n >>= 1) {
A = A * A;
if (n & 1) res = res * A;
}
return res;
}
long long eval(long long n) {
if (n == 0) return 0;
IdMat.ele[0][0] = IdMat.ele[1][1] = 1;
Matrix R, T;
R.ele[0][0] = 1, R.ele[1][0] = 0;
R.ele[0][1] = R.ele[1][1] = 0;
T.ele[0][0] = T.ele[0][1] = T.ele[1][0] = 1;
T.ele[1][1] = 0;
T = powMat(T, n - 1);
R = T * R;
return R.ele[0][0];
}
long long brutePow(int x, int m) {
long long res = 1;
for (int i = 0; i < m; i++) res *= x;
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
int findPeriod(int M) {
static int f[11111];
f[0] = 0, f[1] = 1;
for (int i = 2;; i++) {
f[i] = (f[i - 1] + f[i - 2]) % M;
if (f[i - 1] == 0 && f[i] == 1) return i - 1;
}
}
long long calcPeriod(int m) {
return lcm(findPeriod(2) * brutePow(2, m - 1),
findPeriod(5) * brutePow(5, m - 1));
}
int nPos;
long long pos[10000], nxt[10000];
int g[1500];
int main() {
long long f;
scanf("%lld", &f);
g[0] = 0, g[1] = 1;
long long lim = calcPeriod(3);
for (int i = 2; i < lim; i++) g[i] = (g[i - 1] + g[i - 2]) % 1000;
for (int i = 0; i < lim; i++)
if (f % 1000 == g[i]) pos[nPos++] = i;
for (int m = 4; m <= 13; m++) {
long long preP = calcPeriod(m - 1);
curMod = brutePow(10, m);
int nNxt = 0;
for (int i = 0; i < nPos; i++)
for (int k = 0; k < 10; k++) {
long long t = pos[i] + k * preP;
if (eval(t) == f % curMod) nxt[nNxt++] = t;
}
nPos = nNxt;
memcpy(pos, nxt, sizeof(pos[0]) * nPos);
}
if (nPos == 0)
puts("-1");
else
printf(
"%lld"
"\n",
*min_element(pos, pos + nPos));
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c, d, k;
cin >> a >> b >> c >> d >> k;
if ((b < c) or (a > d)) {
cout << 0;
return 0;
}
if (max(a, c) <= k and min(b, d) >= k) {
cout << min(b, d) - max(a, c);
return 0;
} else {
cout << min(b, d) - max(a, c) + 1;
return 0;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long double n, val, pre, ans;
unordered_map<long double, long double> m;
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = (1); i <= (n); i++) {
cin >> val;
long double ignore = m[val] + m[val - 1] + m[val + 1];
long double ignVal =
m[val] * val + m[val - 1] * (val - 1) + m[val + 1] * (val + 1);
long double bef = i - 1 - ignore;
ans += bef * val - (pre - ignVal);
pre += val;
m[val]++;
}
cout << setprecision(0) << fixed << ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void ckMin(T &x, T y) {
x = min(x, y);
}
template <class T>
void ckMax(T &x, T y) {
x = max(x, y);
}
int main() {
ios_base::sync_with_stdio(false);
int n;
while (cin >> n) {
vector<pair<int, int> > v;
map<int, int> mp;
bool h3 = false;
int n3;
vector<int> n2;
for (int i = 0; i < (n); i++) {
int h;
cin >> h;
v.push_back(make_pair(h, i + 1));
mp[h]++;
}
for (map<int, int>::iterator it = mp.begin(); it != mp.end(); it++) {
if (it->second >= 3) {
h3 = true;
n3 = it->first;
} else if (it->second == 2) {
n2.push_back(it->first);
}
}
if (!h3 && n2.size() < 2) {
cout << "NO" << endl;
continue;
}
sort((v).begin(), (v).end());
cout << "YES" << endl;
if (h3) {
vector<int> pos;
for (int i = 0; i < ((int)v.size()); i++) {
cout << v[i].second << " ";
if (v[i].first == n3) {
pos.push_back(i);
}
}
cout << endl;
int a = pos[0], b = pos[1], c = pos[2];
swap(v[a], v[b]);
for (int i = 0; i < ((int)v.size()); i++) {
cout << v[i].second << " ";
}
cout << endl;
swap(v[b], v[c]);
for (int i = 0; i < ((int)v.size()); i++) {
cout << v[i].second << " ";
}
cout << endl;
} else {
vector<int> pos1, pos2;
for (int i = 0; i < ((int)v.size()); i++) {
cout << v[i].second << " ";
if (v[i].first == n2[0]) {
pos1.push_back(i);
} else if (v[i].first == n2[1]) {
pos2.push_back(i);
}
}
cout << endl;
int a = pos1[0], b = pos1[1];
swap(v[a], v[b]);
for (int i = 0; i < ((int)v.size()); i++) {
cout << v[i].second << " ";
}
cout << endl;
a = pos2[0], b = pos2[1];
swap(v[a], v[b]);
for (int i = 0; i < ((int)v.size()); i++) {
cout << v[i].second << " ";
}
cout << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void bug(string st = "bug") { cout << st << endl; }
const int MAXN = 100010;
struct EDGE {
int u, v, next;
bool del;
bool ok;
} edge[MAXN * 3];
int head[MAXN], cnt;
int n, m, sum = 0;
int s, tot = 100000000;
int idx[MAXN], temp[MAXN];
bool vis[MAXN];
int dist[MAXN];
void addedge(int u, int v, int ok) {
edge[cnt].u = u;
edge[cnt].v = v;
edge[cnt].next = head[u];
if (ok == 1)
edge[cnt].ok = 1;
else
edge[cnt].ok = 0;
edge[cnt].del = 0;
head[u] = cnt++;
}
void bfs() {
bool vis[MAXN];
for (int i = 0; i < MAXN; i++) dist[i] = 100000000;
memset(vis, 0, sizeof(vis));
dist[n] = 0;
queue<int> que;
que.push(n);
while (!que.empty()) {
int u = que.front();
que.pop();
vis[u] = 0;
for (int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].v;
if (dist[v] > dist[u] + 1) {
dist[v] = dist[u] + 1;
if (!vis[v]) {
vis[v] = 1;
que.push(v);
}
}
}
}
s = dist[1];
}
void dfs(int u, int depth, int good, int bad) {
if (depth + dist[u] != s) return;
if (depth == s && u == n) {
if (sum - good + bad < tot) {
tot = sum - good + bad;
for (int i = 0; i < s; i++) idx[i] = temp[i];
}
return;
}
for (int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].v;
if (!vis[v]) {
vis[v] = 1;
temp[depth] = i;
int goodtemp = good + (edge[i].ok == 1 ? 1 : 0);
int badtemp = bad + (edge[i].ok == 0 ? 1 : 0);
dfs(v, depth + 1, goodtemp, badtemp);
vis[v] = 0;
}
}
}
int main() {
cnt = 0;
cin >> n >> m;
memset(head, -1, sizeof(head));
for (int i = 1; i <= m; i++) {
int u, v, ok;
cin >> u >> v >> ok;
addedge(u, v, ok);
addedge(v, u, ok);
if (ok == 1) sum++;
}
bfs();
memset(vis, 0, sizeof(vis));
vis[1] = 1;
dfs(1, 0, 0, 0);
cout << tot << endl;
for (int i = 0; i < s; i++) {
bool flag = 0;
edge[idx[i]].del = 1;
edge[idx[i] ^ 1].del = 1;
if (edge[idx[i]].ok == 0)
cout << edge[idx[i]].u << " " << edge[idx[i]].v << " 1\n";
}
for (int i = 0; i < cnt; i += 2)
if (!edge[i].del && edge[i].ok == 1)
cout << edge[i].u << " " << edge[i].v << " 0\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string s;
int ln;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> s;
for (char c : s) {
if (c == '7')
ln++;
else if (c == '4')
ln++;
}
if (ln == 4 || ln == 7)
cout << "YES" << '\n';
else
cout << "NO" << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void add_self(int& a, int b) {
a += b;
if (a >= (int)1e9 + 7) a -= (int)1e9 + 7;
}
void solve() {
int l, r, x, y, k;
cin >> l >> r >> x >> y >> k;
for (int i = l; i <= r; i++) {
if (i % k != 0) continue;
int b = i / k;
if (x <= b && b <= y) {
cout << "YES";
return;
}
}
cout << "NO";
}
int main() {
ios::sync_with_stdio(false);
int q = 1;
for (int i = 1; i <= q; i++) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int INT_MAX_VAL = (int)1e20;
int INT_MIN_VAL = (int)-1e20;
long long LONG_MAX_VAL = (long long)1e20;
long long LONG_MIN_VAL = (long long)-1e20;
int main() {
int X[1000005] = {0};
bool was[1000005] = {0};
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> X[i];
was[X[i]] = 1;
}
long long s = 1000000;
vector<long long> Y;
long long last_ok = 1;
for (int i = 0; i < n; i++) {
long long inv = s + 1 - X[i];
if (!was[inv]) {
Y.push_back(inv);
was[inv] = true;
} else {
if (X[i] > s / 2) {
continue;
}
while (was[last_ok] || was[s - last_ok + 1]) {
last_ok++;
}
Y.push_back(last_ok);
Y.push_back(s - last_ok + 1);
was[last_ok] = true;
was[s - last_ok + 1] = true;
}
}
printf("%d\n", (int)Y.size());
for (vector<long long>::iterator it = Y.begin(); it != Y.end(); it++) {
printf("%I64d ", *it);
}
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
int a[n + 5], b[n + 5];
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
int k;
cin >> k;
for (int i = 0; i < n; i++) {
if (b[i] >= k) {
cout << n - i << endl;
return 0;
}
}
cout << 0 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
set<int> s;
int a, b, c, d;
cin >> a >> b >> c >> d;
s.insert(a);
s.insert(b);
s.insert(c);
s.insert(d);
cout << 4 - s.size();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int Mod = 1e9 + 7;
char s[1010], t[1010];
int k, n;
int dp[100010][2];
int judge(int x) {
for (int i = 1; i <= n; i++) {
if (t[i] != s[x])
return 0;
else {
x++;
if (x == n + 1) x = 1;
}
}
return 1;
}
int main() {
scanf("%s %s", s + 1, t + 1);
n = strlen(s + 1);
scanf("%d", &k);
dp[0][0] = 1;
for (int i = 1; i <= k; i++) {
dp[i][0] = 1ll * dp[i - 1][1] * (n - 1) % Mod;
dp[i][1] = (dp[i - 1][0] + 1ll * dp[i - 1][1] * (n - 2) % Mod) % Mod;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (judge(i)) {
if (i == 1)
ans = (ans + dp[k][0]) % Mod;
else
ans = (ans + dp[k][1]) % Mod;
}
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
const int inf = 1e9;
inline int read() {
int p = 0;
int f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
p = p * 10 + ch - '0';
ch = getchar();
}
return p * f;
}
int main() {
int t = read();
while (t--) {
int a = read();
int b = read();
int c = read();
int r = read();
if (a > b) swap(a, b);
int s = b - a;
int L = max(a, c - r);
int R = min(b, c + r);
if (c + r <= a || c - r >= b) {
printf("%d\n", s);
continue;
} else
printf("%d\n", s - (R - L));
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5, OO = 1e14;
const int di[] = {1, -1, 0, 0};
const int dj[] = {0, 0, 1, -1};
long long TC, n, m, k, a, b, c, cnt, u, mx, mn, ans, arr[N];
bool f, vis[N], mark[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> TC;
while (TC--) {
cin >> n >> m;
cnt = f = 0;
m += (2 * n);
for (int i = 1; i <= n && !f; i++) {
for (int j = i + 1; j <= n; j++) {
cout << i << ' ' << j << '\n';
if (++cnt == m) {
f = 1;
break;
}
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int dp[1000000 + 10];
int n;
int main() {
cin >> n;
for (int i = 1; i <= 9; i++) dp[i] = 1;
if (n == 0) {
cout << 0 << endl;
return 0;
}
if (n < 10) {
cout << 1 << endl;
return 0;
}
for (int i = 10; i <= n; i++) {
int f = i;
long long int min = 1000000000;
while (f >= 1) {
int h = f % 10;
if (dp[i - h] + 1 < min && h != 0) min = dp[i - h] + 1;
f = f / 10;
}
dp[i] = min;
}
cout << dp[n];
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long mypow(long long a, long long b) {
if (b == 0) return 1;
long long temp = mypow(a, b / 2);
temp = (temp * temp) % 1000000007LL;
if (b % 2 == 1) temp = (a * temp) % 1000000007LL;
return temp;
}
int mygcd(int a, int b) {
if (b == 0) return a;
return mygcd(b, a % b);
}
int cntBits(long long a) {
int ret = 0;
while (a > 0) {
ret++;
a /= 2;
}
return ret;
}
stack<int> stk;
int main() {
ios::sync_with_stdio(0);
int tt = 1, tcase;
for (tcase = 1; tcase <= tt; tcase++) {
vector<char> ans;
ans.clear();
string s;
cin >> s;
int i, arr[s.size() + 1];
arr[s.size() - 1] = s.size() - 1;
for (i = s.size() - 2; i >= 0; i--) {
if (s[i] >= s[arr[i + 1]])
arr[i] = arr[i + 1];
else
arr[i] = i;
}
for (i = 0; i <= s.size() - 1; i++) {
if (stk.empty())
stk.push(i);
else {
while (!stk.empty() && s[stk.top()] <= s[arr[i]]) {
ans.push_back(s[stk.top()]);
stk.pop();
}
stk.push(i);
}
}
while (!stk.empty()) {
ans.push_back(s[stk.top()]);
stk.pop();
}
for (i = 0; i <= ans.size() - 1; i++) cout << ans[i];
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int INF = 1000000000;
const int N = 1000000;
using namespace std;
int main() {
long long n;
cin >> n;
long long arr[n + 1];
for (long long i = 0; i < n; i++) {
cin >> arr[i];
}
long long dp[1000000] = {0};
dp[0] = 1;
for (long long i = 0; i < n; i++) {
vector<long long> divisors;
for (long long j = 1; j * j <= arr[i]; j++) {
if (arr[i] % j == 0) {
divisors.push_back(j);
if (j != arr[i] / j) {
divisors.push_back(arr[i] / j);
}
}
}
sort(divisors.begin(), divisors.end(), greater<int>());
for (long long j = 0; j < divisors.size(); j++) {
dp[divisors[j]] =
(dp[divisors[j]] + dp[divisors[j] - 1] + 1000000007) % 1000000007;
}
}
long long sum = 0;
for (long long i = 0; i < n; i++) {
sum = (sum + dp[i + 1] + 1000000007) % 1000000007;
}
cout << sum << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[20], n, s, x, y, i, j, d3[4] = {2, 4, 6}, d4[5] = {3, 6, 9, 12};
int t[5][5], ch = 100;
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n * n; i++) cin >> a[i];
sort(a, a + n);
bool f;
while (next_permutation(a, a + n * n) || ch) {
x = 0;
ch--;
f = true;
for (i = 0; i < n; i++)
for (j = 0; j < n; j++) t[i][j] = a[x++];
s = 0;
for (i = 0; i < n; i++) s += a[i];
for (i = 0; i < n && f; i++) {
x = y = 0;
for (j = 0; j < n && f; j++) x += t[i][j], y += t[j][i];
if (x != s || y != s) f = false;
}
if (!f) continue;
for (i = x = y = 0; i < n; i++) x += t[i][i], y += t[i][n - 1 - i];
if (x != s || y != s) continue;
cout << s << endl;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) cout << t[i][j] << ' ';
cout << endl;
}
return 0;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class C>
void mini(C& _a4, C _b4) {
_a4 = min(_a4, _b4);
}
template <class C>
void maxi(C& _a4, C _b4) {
_a4 = max(_a4, _b4);
}
long long dp[(1 << 12) + 10][11][64];
long long rF(int mask, int len, int base) {
if (dp[mask][base][len] == -1) {
if (__builtin_popcount(mask) > len) return 0;
if (mask == 0 && len == 0) return 1;
if (len == 0) return 0;
dp[mask][base][len] = 0;
for (int i = (0); i <= ((int)(base)-1); i++)
dp[mask][base][len] += rF(mask ^ (1 << i), len - 1, base);
}
return dp[mask][base][len];
}
long long qwery(long long val, int base) {
if (val == 0) return 0;
vector<int> cyfry;
while (val > 0) {
cyfry.push_back(val % base);
val /= base;
}
int mask = 0;
for (int y : cyfry) mask ^= (1 << y);
long long res = 0;
for (int i = 0; i < ((int)(cyfry).size()) - 1; ++i) {
mask ^= (1 << cyfry[i]);
for (int j = cyfry[i] - 1; j >= 0; --j) res += rF(mask ^ (1 << j), i, base);
}
int ord = cyfry[((int)(cyfry).size()) - 1] - 1;
for (int i = ((int)(cyfry).size()) - 1; i >= 0; --i) {
for (int j = ord; j > 0; --j) res += rF(1 << j, i, base);
ord = base - 1;
}
return res;
}
int main() {
for (int i = (0); i <= ((int)(1 << 11) - 1); i++)
for (int j = (0); j <= ((int)(11) - 1); j++)
for (int k = (0); k <= ((int)(64) - 1); k++) dp[i][j][k] = -1;
int q;
scanf("%d", &q);
for (int ii = (0); ii <= ((int)(q)-1); ii++) {
long long b, l, r;
scanf("%lld%lld%lld", &b, &l, &r);
printf("%lld\n", qwery(r + 1, b) - qwery(l, b));
}
if (0)
for (int i = (0); i <= ((int)(100) - 1); i++)
printf("%d: %lld\n", i, qwery(i, 10));
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, num = 0, tot = 0, cnt = 0, id[300010], in[300010], out[300010],
h[300010], d[300010], rel[300010];
long long tag[300010 << 2], ans[300010];
struct edge {
int to, next;
} mp[300010 << 1];
struct node {
int v, d, x;
} q[300010];
inline char gc() {
static char buf[1 << 16], *S, *T;
if (S == T) {
T = (S = buf) + fread(buf, 1, 1 << 16, stdin);
if (T == S) return EOF;
}
return *S++;
}
inline int read() {
int x = 0, f = 1;
char ch = gc();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = gc();
}
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = gc();
return x * f;
}
inline void ins(int x, int y) {
mp[++num].to = y;
mp[num].next = h[x];
h[x] = num;
mp[++num].to = x;
mp[num].next = h[y];
h[y] = num;
}
void dfs(int x) {
in[x] = ++tot;
rel[tot] = x;
for (int i = h[x]; i; i = mp[i].next) {
int y = mp[i].to;
if (d[y]) continue;
d[y] = d[x] + 1;
dfs(y);
}
out[x] = tot;
}
void pushdown(int v) {
if (tag[v]) {
tag[v << 1] += tag[v];
tag[v << 1 | 1] += tag[v];
tag[v] = 0;
}
}
void add(int v, int l, int r, int x, int y, int z) {
if (x <= l && r <= y) {
tag[v] += z;
return;
}
int mid = l + r >> 1;
pushdown(v);
if (x <= mid) add(v << 1, l, mid, x, y, z);
if (mid < y) add(v << 1 | 1, mid + 1, r, x, y, z);
}
void change(int v, int l, int r, int x) {
if (l == r) {
tag[v] = 0;
return;
}
int mid = l + r >> 1;
pushdown(v);
if (x <= mid)
change(v << 1, l, mid, x);
else
change(v << 1 | 1, mid + 1, r, x);
}
void query(int v, int l, int r) {
if (l == r) {
ans[rel[l]] = tag[v];
return;
}
int mid = l + r >> 1;
pushdown(v);
query(v << 1, l, mid);
query(v << 1 | 1, mid + 1, r);
}
inline bool cmp(int x, int y) { return d[x] < d[y]; }
inline bool cmp1(node x, node y) { return d[x.v] + x.d < d[y.v] + y.d; }
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
ins(x, y);
}
d[1] = 1;
dfs(1);
for (int i = 1; i <= n; i++) id[i] = i;
sort(id + 1, id + n + 1, cmp);
scanf("%d", &m);
for (int i = 1; i <= m; i++)
q[i].v = read(), q[i].d = read(), q[i].x = read();
sort(q + 1, q + m + 1, cmp1);
int j = 1;
for (int i = 1; i <= m; i++) {
while (j <= n && d[id[j]] <= d[q[i].v] + q[i].d)
change(1, 1, n, in[id[j]]), j++;
add(1, 1, n, in[q[i].v], out[q[i].v], q[i].x);
}
for (; j <= n; j++) change(1, 1, n, in[id[j]]);
query(1, 1, n);
for (int i = 1; i <= n; i++) printf("%I64d ", ans[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
bool Max(T1 &a, T2 b) {
return a < b ? a = b, 1 : 0;
}
template <typename T1, typename T2>
bool Min(T1 &a, T2 b) {
return a > b ? a = b, 1 : 0;
}
template <int MOD>
struct ModInt {
unsigned x;
ModInt() : x(0) {}
ModInt(signed sig) : x(sig) {}
ModInt(signed long long sig) : x(sig % MOD) {}
int get() const { return (int)x; }
ModInt pow(unsigned p) {
ModInt res = 1, a = *this;
while (p) {
if (p & 1) res *= a;
a *= a;
p >>= 1;
}
return res;
}
ModInt &operator+=(ModInt that) {
if ((x += that.x) >= MOD) x -= MOD;
return *this;
}
ModInt &operator-=(ModInt that) {
if ((x += MOD - that.x) >= MOD) x -= MOD;
return *this;
}
ModInt &operator*=(ModInt that) {
x = (unsigned long long)x * that.x % MOD;
return *this;
}
ModInt &operator/=(ModInt that) { return (*this) *= that.pow(MOD - 2); }
ModInt operator+(ModInt that) const { return ModInt(*this) += that; }
ModInt operator-(ModInt that) const { return ModInt(*this) -= that; }
ModInt operator*(ModInt that) const { return ModInt(*this) *= that; }
ModInt operator/(ModInt that) const { return ModInt(*this) /= that; }
};
const int N = 52, M = 100;
ModInt<1000000007> f[N][N], f2[N][N];
ModInt<1000000007> invf[N];
ModInt<1000000007> inv[N];
ModInt<1000000007> C(ModInt<1000000007> n, int k) {
ModInt<1000000007> ret = invf[k];
for (int i = 0; i < (k); ++i) {
ret *= n - i;
}
return ret;
}
void solve() {
int n, m;
cin >> n >> m;
invf[0] = 1;
for (int i = 1; i <= (n); ++i)
invf[i] = invf[i - 1] * i, inv[i] = (ModInt<1000000007>)1 / i;
invf[n] = (ModInt<1000000007>)1 / invf[n];
for (int i = n - 1; i >= (1); --i) invf[i] = invf[i + 1] * (i + 1);
f[0][1] = 1;
for (int i = 1; i <= (n); ++i)
for (int j = 1; j <= (i + 1); ++j) {
for (int ltn = 0; ltn <= (i - 1); ++ltn)
for (int lm = j; lm <= (ltn + 1); ++lm)
if (f[ltn][lm].x)
for (int rm = j; rm <= (lm > j ? j : i - ltn); ++rm) {
f2[i][j] += f[ltn][lm] * f[i - 1 - ltn][rm];
}
if (f2[i][j].x) {
for (int i2 = n; i2 >= (0); --i2)
for (int j2 = i2 + 1; j2 >= (1); --j2) {
ModInt<1000000007> comb = f[i2][j2];
for (int cnt = 1; i2 + cnt * i <= n; cnt++) {
comb *= f2[i][j] + cnt - 1;
comb *= inv[cnt];
f[i2 + cnt * i][j2 + cnt * j] += comb;
}
}
}
}
cout << f[n][m].x << '\n';
}
void init() {}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.setf(ios::fixed);
cout.precision(20);
init();
int TC = 1;
for (int TI = 1; TI <= (TC); ++TI) {
solve();
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b, c;
cin >> a >> b >> c;
if (a != b && b != c && c != a) {
cout << "?";
} else if (a == b && b == c) {
cout << "?";
} else {
if (a == "rock" && b == "paper" && c == "rock")
cout << "M";
else if (a == "paper" && b == "rock" && c == "rock")
cout << "F";
else if (a == "rock" && b == "rock" && c == "paper")
cout << "S";
else if (a == "scissors" && b == "paper" && c == "paper")
cout << "F";
else if (a == "paper" && b == "scissors" && c == "paper")
cout << "M";
else if (a == "paper" && b == "paper" && c == "scissors")
cout << "S";
else if (a == "rock" && b == "scissors" && c == "scissors")
cout << "F";
else if (a == "scissors" && b == "rock" && c == "scissors")
cout << "M";
else if (a == "scissors" && b == "scissors" && c == "rock")
cout << "S";
else
cout << "?";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char arr[6][26] = {};
int i, j, n;
cin >> n;
arr[0][0] = '+';
for (i = 1; i <= 24; i++) {
arr[0][i] = '-';
}
arr[0][25] = '+';
for (i = 1; i < 5; i++) {
arr[i][0] = '|';
}
for (i = 1; i < 5; i++) {
arr[i][25] = '|';
}
arr[5][0] = '+';
arr[5][25] = '+';
for (i = 1; i < 25; i++) {
arr[5][i] = '-';
}
arr[1][24] = 'D';
arr[2][24] = '.';
arr[3][24] = '.';
arr[4][24] = '.';
arr[3][23] = '.';
arr[1][23] = '|';
arr[2][23] = '|';
arr[4][23] = '|';
for (i = 1; i <= 4; i++) {
for (j = 1; j <= 21; j += 2) {
arr[i][j] = '#';
}
}
i = 1;
j = 1;
while (n > 0) {
if (i <= 4) {
if ((i == 3) && (j > 1)) {
i++;
}
arr[i][j] = 'O';
n--;
i++;
} else {
i = 1;
j = j + 2;
if (j > 22) {
break;
}
}
}
for (i = 1; i <= 4; i++) {
for (j = 2; j <= 22; j += 2) {
arr[i][j] = '.';
}
}
for (i = 3; i <= 21; i += 2) {
arr[3][i] = '.';
}
for (i = 0; i < 6; i++) {
for (j = 0; j < 26; j++) {
cout << arr[i][j];
if (i == 1 && j == 25) cout << ")";
if (i == 4 && j == 25) cout << ")";
}
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int a, b = 0, b1;
scanf("%d%d", &a, &b1);
while (b1) {
b *= 10;
b += b1 % 10;
b1 /= 10;
}
printf("%d\n", a + b);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, i;
cin >> t;
while (t--) {
cin >> n;
int x[n];
for (i = 0; i < n; i++) cin >> x[i];
sort(x, x + n);
for (i = n - 1; i >= 0; i--) cout << x[i] << " ";
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
int k, n;
char s[maxn], t[maxn];
int dp[maxn][26], vis[26], flag = 0;
;
void dfs(int pos, int pre, bool limt) {
if (flag) return;
if (pos == k) {
if (!limt) {
flag = 1;
for (int i = 0; i < k; ++i) printf("%c", t[i]);
puts("");
}
return;
}
int top = limt ? s[pos] - 'a' : 0;
if (limt && pos >= n) top = 0;
for (int i = top; i < 26; ++i) {
if (!vis[i]) continue;
t[pos] = i + 'a';
dfs(pos + 1, i, limt && i == s[pos] - 'a' && pos < n);
}
}
int main() {
scanf("%d%d", &n, &k);
scanf("%s", s);
for (int i = 0; i < n; ++i) {
vis[s[i] - 'a']++;
}
dfs(0, 0, 1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INFL = (int)1e9;
const long long int INFLL = (long long int)1e18;
const double INFD = numeric_limits<double>::infinity();
const double PI = 3.14159265358979323846;
bool nearlyeq(double x, double y) { return abs(x - y) < 1e-9; }
bool inrange(int x, int t) { return x >= 0 && x < t; }
long long int rndf(double x) {
return (long long int)(x + (x >= 0 ? 0.5 : -0.5));
}
long long int floorsqrt(long long int x) {
long long int m = (long long int)sqrt((double)x);
return m + (m * m <= x ? 0 : -1);
}
long long int ceilsqrt(long long int x) {
long long int m = (long long int)sqrt((double)x);
return m + (x <= m * m ? 0 : 1);
}
long long int rnddiv(long long int a, long long int b) {
return (a / b + (a % b * 2 >= b ? 1 : 0));
}
long long int ceildiv(long long int a, long long int b) {
return (a / b + (a % b == 0 ? 0 : 1));
}
long long int gcd(long long int m, long long int n) {
if (n == 0)
return m;
else
return gcd(n, m % n);
}
long long int lcm(long long int m, long long int n) {
return m * n / gcd(m, n);
}
int dist(int s, int t, int n) {
if (s <= t)
return t - s;
else
return t + n - s;
}
int main() {
int n, m;
cin >> n >> m;
vector<vector<long long int>> a(n);
for (int i = 0; i < (int)(m); i++) {
int s, t;
cin >> s >> t;
s--;
t--;
a[s].push_back(dist(s, t, n));
}
for (int i = 0; i < (int)(n); i++) {
sort(a[i].begin(), a[i].end());
}
vector<long long int> ans(n, 0);
for (int i = 0; i < (int)(n); i++) {
for (int j = 0; j < (int)(n); j++) {
if (a[j].size()) {
long long int buf = dist(i, j, n) + (a[j].size() - 1) * n + a[j][0];
ans[i] = max(ans[i], buf);
}
}
}
for (int extra_i = 0; extra_i < (int)(ans.size()); extra_i++) {
cout << ans[extra_i] << " ";
}
cout << endl;
;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 112345;
int n, m;
vector<int> tree[N], c_tree[N];
int tree_sz[N], ans[N], parent[N];
bool ok[N];
map<int, map<int, int>> dist;
void calc_dist(int u, int c, int p = 0, int d = 0) {
dist[c][u] = d;
for (int v : tree[u]) {
if (v != p and !ok[v]) {
calc_dist(v, c, u, d + 1);
}
}
}
int get_sizes(int u, int p) {
int sz = 0;
for (int v : tree[u]) {
if (v != p && !ok[v]) sz += get_sizes(v, u);
}
return tree_sz[u] = sz + 1;
}
int find_centroid(int u, int p, int sz) {
for (int v : tree[u]) {
if (v != p && !ok[v] && tree_sz[v] > sz / 2) return find_centroid(v, u, sz);
}
return u;
}
int build_ctree(int root) {
int sz = get_sizes(root, 0);
int centroid = find_centroid(root, 0, sz);
ok[centroid] = true;
calc_dist(centroid, centroid);
for (int v : tree[centroid]) {
if (!ok[v]) {
int child_centroid = build_ctree(v);
c_tree[centroid].emplace_back(child_centroid);
parent[child_centroid] = centroid;
}
}
return centroid;
}
void update(int x) {
for (int u = x; u != 0; u = parent[u]) {
ans[u] = min(ans[u], dist[u][x]);
}
}
int query(int x) {
int ret = 0x3f3f3f3f;
for (int u = x; u != 0; u = parent[u]) {
ret = min(ret, dist[u][x] + ans[u]);
}
return ret;
}
int main(void) {
ios_base::sync_with_stdio(false);
memset(ans, 0x3f, sizeof ans);
cin >> n >> m;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
tree[a].emplace_back(b);
tree[b].emplace_back(a);
}
parent[build_ctree(1)] = 0;
update(1);
for (int i = 0; i < m; i++) {
int t, x;
cin >> t >> x;
if (t == 1)
update(x);
else
cout << query(x) << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char s[30][30];
int map1[30][30];
int dp[(1 << 21)];
int pre[30][30], cost[30][30];
void chuli(int sta, int low) {
int temp;
for (int i = 1; i <= m; ++i) {
dp[sta] = min(dp[sta], dp[sta ^ (1 << low)] + map1[low][i]);
dp[sta] = min(dp[sta], dp[sta & (~pre[low][i])] + cost[low][i]);
}
}
void init() {
int temp, sum, maxn;
for (int i = 0; i < n; ++i)
for (int j = 1; j <= m; ++j) {
temp = 0;
sum = 0;
maxn = 0;
for (int k = 0; k < n; ++k)
if (s[k][j] == s[i][j]) {
sum += map1[k][j];
maxn = max(maxn, map1[k][j]);
temp ^= (1 << k);
}
pre[i][j] = temp;
cost[i][j] = sum - maxn;
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%s", s[i] + 1);
for (int i = 0; i < n; ++i)
for (int j = 1; j <= m; ++j) scanf("%d", &map1[i][j]);
init();
memset(dp, 0x3f, sizeof(dp));
dp[0] = 0;
for (int i = 1; i < (1 << n); ++i)
for (int k = 0; k < n; ++k)
if (i & (1 << k)) {
chuli(i, k);
break;
}
printf("%d\n", dp[(1 << n) - 1]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
char s[maxn];
int main() {
cin >> s;
int i = 0, len = strlen(s), m_num = 0, ans = 0;
while (s[i] == 'F') i++;
for (; i < len; i++) {
if (s[i] == 'M')
m_num++;
else
ans = max(ans + 1, m_num);
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1000005;
const long long int LG = 22;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
long long int dp[n + 1][n + 1];
for (long long int i = 0; i <= n; i++)
for (long long int j = 0; j <= n; j++) dp[i][j] = 100000000001;
for (long long int i = 0; i < n; i++) {
dp[i + 1][i + 1] = 0;
string s;
cin >> s;
for (long long int j = 0; j < s.length(); j++) {
if (s[j] == '1') {
dp[i + 1][j + 1] = 1;
}
}
}
for (long long int mid = 1; mid <= n; mid++) {
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= n; j++) {
dp[i][j] = min(dp[i][j], dp[i][mid] + dp[mid][j]);
}
}
}
long long int m;
cin >> m;
long long int a[m];
for (long long int i = 0; i < m; i++) cin >> a[i];
long long int x = a[0], y = 0, last = a[m - 1];
vector<long long int> v;
v.push_back(a[0]);
for (long long int i = 1; i < m; i++) {
long long int node = a[i], dist = i - y;
if (dp[x][node] == dist) continue;
v.push_back(a[i - 1]);
x = a[i - 1], y = i - 1;
}
cout << v.size() + 1 << endl;
for (auto i : v) cout << i << ' ';
cout << a[m - 1];
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
const int nax = 1e6 + 5;
vector<int> w[nax];
bool vis[nax];
bool whatever[nax];
void dfs(int a) {
assert(!vis[a]);
vis[a] = true;
for (int b : w[a])
if (!vis[b]) dfs(b);
}
long long choose2(long long x) { return x * (x - 1) / 2; }
int main() {
int n, m;
scanf("%d%d", &n, &m);
int loops = 0, ordinary = 0;
for (int i = 0; i < m; ++i) {
int a, b;
scanf("%d%d", &a, &b);
whatever[a] = whatever[b] = true;
if (a == b)
++loops;
else {
w[a].push_back(b);
w[b].push_back(a);
++ordinary;
}
}
for (int i = 1; i <= n; ++i)
if (whatever[i]) {
dfs(i);
break;
}
for (int i = 1; i <= n; ++i)
if (!vis[i] && whatever[i]) {
puts("0");
debug() << "not connected";
return 0;
}
long long answer = choose2(loops);
answer += (long long)loops * ordinary;
for (int i = 1; i <= n; ++i) answer += choose2(w[i].size());
printf("%lld\n", answer);
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n, q;
scanf("%d %d", &n, &q);
int a = 0, b = 1;
for (int i = 0; i < q; i++) {
int t, x;
scanf("%d", &t);
if (t == 1) {
scanf("%d", &x);
x = (x + n) % n;
a = (a + x) % n;
b = (b + x) % n;
} else {
a ^= 1;
b ^= 1;
}
}
int f[2];
f[a % 2] = (n - a) % n;
f[b % 2] = (n - b + 1) % n;
for (int i = 0; i < n; i++) {
printf("%d ", (f[i & 1] + i) % n + 1);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int n, m, s, l, r, L, i, j, p, ans;
int d[100010], f[100010], son[100010], x[100010], y[100010], z[100010];
int q[10000010];
int ed[200010], next[200010], w[200010];
void addedge(int i, int j, int k) {
ed[++p] = j, w[p] = k, next[p] = son[i], son[i] = p;
}
int main() {
scanf("%d%d%d", &n, &m, &s);
for (i = 1; i <= m; i++) {
scanf("%d%d%d", &x[i], &y[i], &z[i]);
addedge(x[i], y[i], z[i]), addedge(y[i], x[i], z[i]);
}
scanf("%d", &L);
memset(d, 127, sizeof(d));
f[s] = 1, d[s] = 0;
q[1] = s;
for (l = 0, r = 1; l < r;) {
i = q[++l];
f[i] = 0;
for (j = son[i]; j; j = next[j])
if (d[ed[j]] > d[i] + w[j]) {
d[ed[j]] = d[i] + w[j];
if (!f[ed[j]]) {
f[ed[j]] = 1;
q[++r] = ed[j];
}
}
}
for (i = 1; i <= n; i++)
if (d[i] == L) ans++;
for (i = 1; i <= m; i++) {
if (d[x[i]] + z[i] == d[y[i]]) {
if (d[x[i]] < L && d[y[i]] > L) ans++;
} else if (d[y[i]] + z[i] == d[x[i]]) {
if (d[y[i]] < L && d[x[i]] > L) ans++;
} else {
if (d[x[i]] < L && d[y[i]] + (z[i] - (L - d[x[i]])) >= L) ans++;
if (d[y[i]] < L && d[x[i]] + (z[i] - (L - d[y[i]])) >= L) ans++;
if (d[x[i]] < L && d[y[i]] < L && (L - d[x[i]]) + (L - d[y[i]]) == z[i])
ans--;
}
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 65;
long long Move1[maxn];
long long Move2[maxn];
inline void op1(int Lay, long long move, long long x, long long times) {
if (x != 0) Lay = log2(x) + 1;
long long Base = 1LL << (Lay - 1);
if (times == -1) {
move %= Base;
} else {
move = ((move % Base) * (times % Base)) % Base;
}
Move1[Lay] = ((Move1[Lay] + move) + Base) % Base;
Move2[Lay] = ((Move2[Lay] - move) + Base) % Base;
}
inline void op2(long long move, long long x) {
int Lay = log2(x) + 1;
for (int i = Lay, j = 0; i < 65; i++, j++) op1(i, move, 0, 1LL << j);
}
inline void op3(long long x) {
if (x == 1LL) {
puts("1");
return;
}
printf("%I64d", x);
int Lay = log2(x) + 1;
long long Base = 1LL << (Lay - 1);
long long pos = (((x - Base) + Move1[Lay]) + Base) % Base + Base;
while (!(pos == 3LL || pos == 2LL)) {
if (pos & 1)
pos = (pos - 1) >> 1;
else
pos = pos >> 1;
Lay = log2(pos) + 1;
Base = 1LL << (Lay - 1);
printf(" %I64d", ((pos - Base + Move2[Lay]) + Base) % Base + Base);
}
puts(" 1");
}
int main(void) {
int Q;
scanf("%d", &Q);
while (Q--) {
int command;
long long X, K;
scanf("%d", &command);
if (command == 1) {
scanf("%I64d %I64d", &X, &K);
op1(-1, K, X, -1);
} else if (command == 2) {
scanf("%I64d %I64d", &X, &K);
op2(K, X);
} else {
scanf("%I64d", &X);
op3(X);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
long long modPow(long long a, long long b);
long long modInv(long long a);
void solve() {
long long n, k;
cin >> n >> k;
string s;
cin >> s;
long long it = 1;
cout << n / 2 + k - 1 << "\n";
for (long long i = 0; i < n; i++) {
if (s[i] == '(') {
cout << it << " " << i + 1 << "\n";
it++;
}
}
for (long long i = 0; i < k - 1; i++) {
cout << (2 * i) + 2 << " " << n / 2 + (i) + 1 << "\n";
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long test = 1;
cin >> test;
while (test--) solve();
}
long long modPow(long long a, long long b) {
if (b == 0) return 1;
if (b % 2 == 0) {
long long x = a * a;
x %= 1000000007;
return modPow(x, b / 2);
}
return (a * modPow(a, b - 1)) % 1000000007;
}
long long modInv(long long a) { return modPow(a, 1000000007 - 2); }
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, n, d, sum = 0;
cin >> n >> d;
long long a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
for (i = 0; i < n; i++)
cout << a[i] - (min(a[i], d - (n - 1)) - max(1ll, d - (sum - a[i])) + 1)
<< " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
long long level = s.find('^');
long long left = 0, right = 0;
for (int k = 0; k < level; k++) {
if (s[k] != '=') {
left += (level - k) * (s[k] - '0');
}
}
for (int k = level + 1; k < s.size(); k++) {
if (s[k] != '=') {
right += (k - level) * (s[k] - '0');
}
}
if (left == right)
cout << "balance";
else if (left > right)
cout << "left";
else
cout << "right";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[100];
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
m++;
int ans = 0;
for (int i = 29; i >= 0; i--) {
if ((n >> i & 1) == 1 && (m >> i & 1) == 0) break;
if ((n >> i & 1) == 0 && (m >> i & 1) == 1) ans += 1 << i;
}
cout << ans << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long bit[100005];
void update(long long p, long long v) {
while (p < 100005) {
bit[p] = max(bit[p], v);
p += (p & (-p));
}
}
long long val(long long p) {
long long res = 0;
while (p > 0) {
res = max(res, bit[p]);
p -= (p & (-p));
}
return res;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
long long r[n], h[n];
long long v[n];
map<long long, long long> m;
for (long long i = 0; i < n; i++) {
cin >> r[i] >> h[i];
v[i] = r[i] * r[i] * h[i];
m[v[i]] = 1;
}
long long c = 1;
for (map<long long, long long>::iterator it = m.begin(); it != m.end(); it++)
it->second = c++;
memset(bit, 0, sizeof(bit));
double mm[n];
double mmax = 0;
for (long long i = 0; i < n; i++) {
mm[i] = val(m[v[i]] - 1) + v[i];
update(m[v[i]], mm[i]);
mmax = max(mmax, mm[i]);
}
mmax *= M_PI;
cout << setprecision(9) << mmax << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 0LL;
long long MOD = 1e18 + 0LL;
long long md = 1000000007;
const double PI = acos(-1);
long long poW(long long a, long long n) {
if (n == 0) return 1;
if (n % 2 == 0) {
long long b = poW(a, n / 2);
return (b * b) % md;
}
return (poW(a, n - 1) * a) % md;
}
bool cmp(const pair<int, int> &a, const pair<int, int> &b) {
if (a.first == b.first) return a.second > b.second;
return a.first < b.first;
}
bool isOdd(int n) { return (n % 2) != 0; }
template <class T>
void printVector(vector<T> &v, string s = "") {
cout << s;
for (int i = 0; i < ((int)((v).size())); i++) {
cout << v[i] << ' ';
}
printf("\n");
}
int toInt(string str) {
int num;
istringstream iss(str);
iss >> num;
return num;
}
template <class T>
string toStr(T par) {
ostringstream oss;
oss << par;
return oss.str();
}
void sieve(vector<int> &v) {
int i, j;
v.push_back(1);
bool visit[1002];
memset(visit, 0, sizeof(visit));
for (i = 2; i <= 1001; i++) {
if (!visit[i]) {
for (j = i * i; j <= 1001; j += i) {
visit[j] = 1;
}
v.push_back(i);
}
}
}
bool isPrime(int x) {
if (x < 2) return false;
for (int y = 2; y * y <= x; y++)
if (x % y == 0) return false;
return true;
}
bool trip(pair<int, pair<int, int> > p, pair<int, pair<int, int> > q) {
int id1 = p.first;
int id2 = q.first;
int val1 = p.second.first;
int val2 = q.second.first;
int sid1 = p.second.second;
int sid2 = q.second.second;
if (id1 == id2) {
return sid1 < sid2;
}
return val1 < val2;
}
long long maxSubArraySum(vector<int> &v) {
long long sum = 0, mx = 0;
for (int i = 0; i < ((int)((v).size())); i++) {
sum = max((long long)v[i], sum + v[i]);
mx = max(mx, sum);
}
return mx;
}
bool cmpl(pair<int, int> &p, pair<int, int> &q) {
if (p.first != q.first) return p.first < q.first;
return p.second < q.second;
}
bool cmpl2(pair<long long, long long> &p, pair<long long, long long> &q) {
long long a = p.first;
long long b = q.first;
return min(a, p.second) > min(b, q.second);
}
int bins(int k, int n, vector<int> &v) {
int lo = 0, hi = n - 1;
while (lo <= hi) {
int mid = (lo + hi + 1) / 2;
if (v[mid] == k) return mid;
if (v[mid] < k) {
lo = mid + 1;
} else
hi = mid - 1;
}
return -1;
}
void printPair(vector<pair<int, int> > &v) {
for (int i = 0; i < ((int)((v).size())); i++) {
cout << v[i].first << ' ' << v[i].second << endl;
}
cout << "-------\n";
}
int main() {
int cs = 0, tcs = 1;
while (cs < tcs) {
cs++;
int i, j, n;
cin >> n;
int a[n], b[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
j = 0;
for (i = 1; i < n; i += 2) {
b[i] = a[j];
j++;
}
for (i = 0; i < n; i += 2) {
b[i] = a[j];
j++;
}
int cnt = 0;
for (i = 1; i < (n - 1); i++) {
if (b[i] < b[i - 1] && b[i] < b[i + 1]) cnt++;
}
cout << cnt << "\n";
for (i = 0; i < n; i++) {
cout << b[i] << ' ';
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int read() {
char ch;
ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
int x = 0;
while (ch <= '9' && ch >= '0') x = x * 10 + ch - '0', ch = getchar();
return x;
}
int n;
int a[1001][1001];
long long int d[1001][1001];
int xs[10010];
long long int ans[10010];
int v[10010];
int main() {
memset(v, 0, sizeof(v));
n = read();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) d[i][j] = read();
for (int i = n; i >= 1; i--) xs[i] = read();
for (int i = 1; i <= n; i++) {
v[xs[i]] = 1;
for (int l = 1; l <= n; l++)
for (int ll = 1; ll <= n; ll++) {
if (d[l][ll] > d[l][xs[i]] + d[xs[i]][ll])
d[l][ll] = d[l][xs[i]] + d[xs[i]][ll];
if (v[l] == 1 && v[ll] == 1) ans[i] += d[l][ll];
}
}
for (int i = n; i >= 1; i--) cout << ans[i] << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 1; i <= t; i++) {
int n;
cin >> n;
vector<int> v;
for (int i = 1; i <= n; i *= 2) {
v.push_back(i);
n -= i;
}
if (n > 0) {
v.push_back(n);
sort(v.begin(), v.end());
}
int l = v.size();
cout << l - 1 << "\n";
for (int i = 1; i < l; i++) {
cout << v[i] - v[i - 1] << " ";
}
if (l > 1) cout << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int trp_add[n + 1], trp_xor[n + 1];
queue<int> q;
int sum = 0;
for (int i = 0; i < n; i++) {
cin >> trp_add[i] >> trp_xor[i];
sum += trp_add[i];
if (trp_add[i] == 1) q.push(i);
}
cout << sum / 2 << endl;
while (!q.empty()) {
int rt = q.front();
q.pop();
if (trp_add[rt] == 0) continue;
int tr = trp_xor[rt];
trp_add[tr]--;
if (trp_add[tr] == 1) q.push(tr);
trp_xor[tr] ^= rt;
cout << rt << " " << tr << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
int a, b, c, d, e;
cin >> a >> b >> c >> d >> e;
a /= 2;
int ans = 0;
if (d > e) {
ans = min(a, b) * d;
a -= min(a, b);
ans += min(a, c) * e;
} else {
ans = min(a, c) * e;
a -= min(a, c);
ans += min(a, b) * d;
}
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a[100 + 5], ans = 100000000;
int main() {
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a, a + n);
if (k == a[n - 1]) {
cout << 1 << endl;
return 0;
}
for (int i = 0; i < n; ++i) {
if (k % a[i] == 0) {
ans = min(ans, k / a[i]);
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, l, r;
long long ql, qr;
cin >> n >> l >> r >> ql >> qr;
int* a = new int[n + 5];
long long *suml = new long long[n + 5], *sumr = new long long[n + 5];
long long* maxs = new long long[n + 5];
suml[0] = 0;
sumr[n + 1] = 0;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) suml[i] = suml[i - 1] + (l * a[i]);
for (int i = n; i >= 1; i--) sumr[i] = sumr[i + 1] + (r * a[i]);
for (int i = 0; i < n + 1; i++) {
int lp = i, rp = n - i;
maxs[i] = suml[i] + sumr[i + 1];
if (lp < rp) {
if (lp + 1 < rp) {
maxs[i] += (rp - lp - 1) * qr;
}
}
if (rp < lp) {
if (rp + 1 < lp) {
maxs[i] += (lp - rp - 1) * ql;
}
}
}
long long min = maxs[0];
for (int i = 1; i < n + 1; i++) {
if (maxs[i] < min) min = maxs[i];
}
cout << min;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
long long a[1000];
long long b[1000];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
long long s1 = a[0];
long long s2 = b[0];
for (int i = 0; i < n; i++) {
s1 |= a[i];
s2 |= b[i];
}
cout << s1 + s2 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int tree[10000000];
int pos[1000005];
int offset;
int children[10000000];
int ans[1000005];
bool used[1000005];
void update(int p) {
if (!p) return;
children[p] = children[p * 2] + children[p * 2 + 1];
update(p / 2);
}
void Set(int p, int mark) {
if (pos[mark]) {
children[pos[mark]] = 0;
update(pos[mark] / 2);
}
tree[p] = mark;
pos[mark] = p;
children[p] = 1;
update(p / 2);
}
int Find(int p, int node) {
if (node >= (1 << 21)) return node;
if (p < children[node * 2]) return Find(p, node * 2);
return Find(p - children[node * 2], node * 2 + 1);
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
offset = (1 << 21) + m;
for (int i = 0; i < n; ++i) {
Set(offset + i, i);
ans[i] = -1;
used[i] = 0;
}
for (int i = 0; i < m; ++i) {
int x, y;
scanf("%d%d", &x, &y);
--x;
--y;
int curPos = Find(y, 1);
int curValue = ans[tree[curPos]];
if (curValue != -1 && curValue != x) {
puts("-1");
return 0;
}
ans[tree[curPos]] = x;
Set(offset - i - 1, tree[curPos]);
}
for (int i = 0; i < n; ++i) {
if (ans[i] == -1) continue;
if (used[ans[i]]) {
puts("-1");
return 0;
}
used[ans[i]] = 1;
}
int j = 0;
for (int i = 0; i < n; ++i) {
if (ans[i] != -1) continue;
while (used[j]) ++j;
ans[i] = j;
++j;
}
for (int i = 0; i < n; ++i) printf("%d ", ans[i] + 1);
printf("\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int k;
int mypow[10];
int mymax = 0;
char ok = 0;
int mycode(int i, int level) {
int z = level * 10 + i + 2;
if (ok) mymax = max(z, mymax);
return z;
}
char mat[1050][1050];
void join(int k, int level, int node) {
for (int i = 0; i < k; i++) {
mat[mycode(i, level)][node] = 'Y';
mat[node][mycode(i, level)] = 'Y';
}
}
int CON = 200;
int MAXLEVEL = 9;
void disperse(int k) {
int level = 0;
while (k > 0) {
if (k < 10)
join(k % 10, level, 0);
else
join(k % 10, level, level + CON);
mat[level + CON + 1][level + CON] = 'Y';
mat[level + CON][level + CON + 1] = 'Y';
k /= 10;
level++;
}
level -= 2;
mat[level + CON][0] = 'Y';
mat[0][level + CON] = 'Y';
}
int main() {
int x;
scanf("%d", &x);
mypow[0] = 1;
for (int i = 1; i < 10; i++) mypow[i] = mypow[i - 1] * 10;
for (int i = 0; i <= 1000; i++)
for (int j = 0; j <= 1000; j++) mat[i][j] = 'N';
for (int level = 0; level < MAXLEVEL; level++)
for (int i = 0; i < 10; i++) {
join(10, level + 1, mycode(i, level));
}
ok = 1;
disperse(x);
join(10, 0, 1);
mymax++;
mymax = 10 + CON;
printf("%d\n", mymax);
for (int i = 0; i < mymax; i++) {
for (int j = 0; j < mymax; j++) printf("%c", mat[i][j]);
printf("\n");
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
char s[81];
int a[81], c0, c1, c2, inf, ans;
int f[81][81][81][3];
void upd(int &x, int y) { x = min(x, y); }
int main() {
scanf("%d%s", &n, s + 1);
for (int i = 1; i <= n; i++) {
if (s[i] == 'K')
c0++, a[i] = 0;
else if (s[i] == 'V')
c1++, a[i] = 1;
else
c2++, a[i] = 2;
}
memset(f, 0x3f, sizeof(f));
inf = f[0][0][0][0];
f[0][0][0][2] = 0;
for (int i = 0; i <= c0; i++)
for (int j = 0; j <= c1; j++)
for (int k = 0; k <= c2; k++) {
int v[3], p[3], cnt = 0;
v[0] = i, v[1] = j, v[2] = k, p[0] = -1, p[1] = -1, p[2] = -1;
for (int w = 1, t; w <= n; w++) {
t = a[w];
if (v[t])
v[t]--;
else {
if (p[t] == -1) p[t] = cnt;
cnt++;
}
}
for (int w1 = 0; w1 <= 2; w1++)
if (f[i][j][k][w1] != inf)
for (int w2 = 0; w2 <= 2; w2++)
if ((w1 != 1 || w2 != 0) && p[w2] != -1) {
int i1 = (w2 == 0 ? i + 1 : i), j1 = (w2 == 1 ? j + 1 : j),
k1 = (w2 == 2 ? k + 1 : k);
upd(f[i1][j1][k1][w2], f[i][j][k][w1] + p[w2]);
}
}
ans = inf;
for (int i = 0; i <= 2; i++) ans = min(ans, f[c0][c1][c2][i]);
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int vst[100010], flag[100010];
int p[100010];
vector<int> vt;
int main() {
int n;
scanf("%d", &n);
vst[1] = 1;
for (int i = 2; i < 100010; i++) {
if (vst[i]) continue;
for (int j = 2 * i; j < 100010; j += i) vst[j] = 1;
}
int k = 0;
for (int i = 1; i <= n; i++) {
if (vst[i]) continue;
p[++k] = i;
}
int r = k + 1;
for (int i = 1; i <= k; i++) {
if (p[i] * 2 > n) {
r = i;
break;
}
}
int ans = n - k + r - 2;
printf("%d\n", ans / 2);
for (int i = 2; i < r; i++) {
int x = 0;
for (int j = 2 * p[i]; j <= n; j += p[i]) {
if (flag[j]) continue;
if (j % 2 == 0) continue;
if (x == 0) {
x = j;
continue;
} else if (x) {
printf("%d %d\n", x, j);
flag[j] = 1;
flag[x] = 1;
x = 0;
}
}
if (x) {
printf("%d %d\n", p[i], x);
flag[p[i]] = 1;
flag[x] = 1;
} else if (x == 0)
vt.push_back(p[i]);
}
for (int i = 0; i < vt.size(); i++) {
printf("%d %d\n", vt[i], 2 * vt[i]);
flag[2 * vt[i]] = 1;
flag[vt[i]] = 1;
}
int y = 0;
for (int i = 2; i <= n; i += 2) {
if (flag[i]) continue;
if (y == 0) {
y = i;
continue;
} else if (y) {
printf("%d %d\n", y, i);
y = 0;
flag[y] = 1;
flag[i] = 1;
continue;
}
}
return 0;
}
| 8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.