solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 400100;
const int mod = 1000000007;
const int inv = 500000004;
int add(int &a, int b) {
a += b;
if (a >= mod) {
a -= mod;
}
}
int rest(int &a, int b) {
a -= b;
if (a < 0) {
a += mod;
}
}
int mult(int a, int b) { return ((long long)a * (long long)b) % mod; }
int bpow(int b, int exp) {
if (exp == 0) {
return 1;
}
if (exp == 1) {
return b;
}
int ret = bpow(b, exp / 2);
ret = mult(ret, ret);
if (exp & 1) {
ret = mult(ret, b);
}
return ret;
}
int sgeom(int r, int n) {
int ret = bpow(r, n + 1);
rest(ret, 1);
rest(r, 1);
ret = mult(ret, bpow(r, mod - 2));
return ret;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
int k;
cin >> k;
int sz = s.size();
int sol = 0;
for (int p = 1; p <= sz; p++) {
if (s[p - 1] == '0' || s[p - 1] == '5') {
int tmp = sgeom(bpow(2, sz), k - 1);
tmp = mult(tmp, bpow(2, p - 1));
add(sol, tmp);
}
}
cout << sol << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int LOCAL = 0;
namespace mine {
const int INF = 0x3f3f3f3f;
int qread() {
int ans = 0;
char c = getchar();
while (c < '0' or c > '9') c = getchar();
while (c >= '0' and c <= '9') ans = ans * 10 + c - '0', c = getchar();
return ans;
}
void qwrite(int num) {
if (num >= 10) qwrite(num / 10);
putchar('0' + num % 10);
}
void qwriteln(int num) {
qwrite(num);
puts("");
}
const int MAX_N = 110000;
struct Nod {
int hou, dfn, tp, fa;
} p[MAX_N];
struct Edge {
int y, g;
} e[MAX_N * 2];
int ln = 0;
void ins(int x, int y) {
e[++ln] = (Edge){y, p[x].hou};
p[x].hou = ln;
}
int son[MAX_N], siz[MAX_N];
void pre(int x, int fa) {
siz[x] = 1;
p[x].fa = fa;
for (int k = p[x].hou; k > 0; k = e[k].g) {
int y = e[k].y;
if (y == fa) continue;
pre(y, x);
siz[x] += siz[y];
if (siz[y] > siz[son[x]]) son[x] = y;
}
}
int id = 0;
void getid(int x, int tp) {
p[x].dfn = ++id;
p[x].tp = tp;
if (son[x] > 0) getid(son[x], tp);
for (int k = p[x].hou; k > 0; k = e[k].g) {
int y = e[k].y;
if (p[y].dfn == 0 and y != son[x]) getid(y, y);
}
}
struct Data {
int sum, rmx;
};
Data merg(Data left, Data right) {
return (Data){left.sum + right.sum, max(left.rmx + right.sum, right.rmx)};
}
struct SegmentTree {
struct Nod {
int l, r;
Data s;
bool cl;
} p[MAX_N * 4];
void clear(int x) { p[x].s = (Data){-(p[x].r - p[x].l + 1), -1}; }
void build(int x, int l, int r) {
p[x].l = l;
p[x].r = r;
p[x].cl = 0;
clear(x);
if (l < r) {
int mid = (l + r) >> 1;
build(2 * x, l, mid);
build(2 * x + 1, mid + 1, r);
}
}
void pushdown(int x) {
clear(2 * x);
clear(2 * x + 1);
p[2 * x].cl = p[2 * x + 1].cl = 1;
p[x].cl = 0;
}
void change(int x, int pos, int c) {
if (p[x].l == p[x].r) {
p[x].s = (Data){c, c};
return;
}
if (p[x].cl) pushdown(x);
int mid = (p[x].l + p[x].r) >> 1;
if (pos <= mid)
change(2 * x, pos, c);
else
change(2 * x + 1, pos, c);
p[x].s = merg(p[2 * x].s, p[2 * x + 1].s);
}
void white(int x, int fl, int fr) {
if (p[x].l == fl and p[x].r == fr) {
clear(x);
p[x].cl = 1;
return;
}
if (p[x].cl) pushdown(x);
int mid = (p[x].l + p[x].r) >> 1;
if (fr <= mid)
white(2 * x, fl, fr);
else if (fl > mid)
white(2 * x + 1, fl, fr);
else
white(2 * x, fl, mid), white(2 * x + 1, mid + 1, fr);
p[x].s = merg(p[2 * x].s, p[2 * x + 1].s);
}
Data ask(int x, int fl, int fr) {
if (p[x].l == fl and p[x].r == fr) return p[x].s;
if (p[x].cl) pushdown(x);
int mid = (p[x].l + p[x].r) >> 1;
if (fr <= mid)
return ask(2 * x, fl, fr);
else if (fl > mid)
return ask(2 * x + 1, fl, fr);
else
return merg(ask(2 * x, fl, mid), ask(2 * x + 1, mid + 1, fr));
}
} sgt;
int getf(int x) {
Data now;
bool bk = 0;
while (x != 0) {
int tp = p[x].tp;
if (bk == 0)
now = sgt.ask(1, p[tp].dfn, p[x].dfn), bk = 1;
else
now = merg(sgt.ask(1, p[tp].dfn, p[x].dfn), now);
x = p[tp].fa;
}
return now.rmx;
}
void main() {
int n, q;
scanf("%d%d", &n, &q);
for (int i = 2; i <= n; i++) {
int fa = qread();
ins(fa, i);
ins(i, fa);
}
sgt.build(1, 1, n);
pre(1, 0);
getid(1, 1);
while (q--) {
int op, x;
scanf("%d%d", &op, &x);
if (op == 1) {
Data now = sgt.ask(1, p[x].dfn, p[x].dfn);
sgt.change(1, p[x].dfn, now.rmx + 1);
} else if (op == 2) {
sgt.white(1, p[x].dfn, p[x].dfn + siz[x] - 1);
if (x != 1) {
int now = getf(p[x].fa);
sgt.change(1, p[x].dfn, min(-1, -now - 1));
}
} else {
int col = getf(x);
if (col >= 0)
puts("black");
else
puts("white");
}
}
}
}; // namespace mine
int main() { mine::main(); }
| 12 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize(4)
using namespace std;
const int N = 1e3 + 5;
const int INF = 0x3f3f3f3f;
int a[N];
int main() {
int n, r;
scanf("%d %d", &n, &r);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int now = 1, ans = 0;
bool ff = true;
while (true) {
if (now > n) break;
int L = max(1, now - r + 1);
int R = min(n, now + r - 1);
bool f = false;
int nxt;
for (int i = R; i >= L; i--) {
if (a[i]) {
f = true;
nxt = i + r;
break;
}
}
if (f)
now = nxt, ans++;
else {
ff = false;
break;
}
}
if (ff)
printf("%d\n", ans);
else
printf("-1\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 111111;
const int INF = 1000000000, mod = 1000000007;
const long long LLINF = 1000000000000000000ll;
char s[8][8];
int can1[8][8], can2[8][8];
void bfs(int x, int y, int used[8][8]) {
queue<int> qx, qy, dist;
qx.push(x), qy.push(y);
dist.push(0);
while (!qx.empty()) {
x = qx.front(), y = qy.front();
int d = dist.front();
qx.pop();
qy.pop();
dist.pop();
if (x < 0 || x > 7 || y < 0 || y > 7) continue;
if (used[x][y] != -1) continue;
used[x][y] = d;
qx.push(x - 2);
qy.push(y - 2);
dist.push(d ^ 1);
qx.push(x - 2);
qy.push(y + 2);
dist.push(d ^ 1);
qx.push(x + 2);
qy.push(y - 2);
dist.push(d ^ 1);
qx.push(x + 2);
qy.push(y + 2);
dist.push(d ^ 1);
}
}
void solve() {
for (int i = 0; i < 8; ++i) {
gets(s[i]);
for (int j = 0; j < 8; ++j) {
can1[i][j] = can2[i][j] = -1;
}
}
int x1, x2, y1, y2;
x1 = x2 = y1 = y2 = -1;
for (int i = 0; i < 8; ++i) {
for (int j = 0; j < 8; ++j) {
if (s[i][j] == 'K') {
if (x1 == -1) {
x1 = i;
y1 = j;
} else {
x2 = i;
y2 = j;
}
}
}
}
bfs(x1, y1, can1);
bfs(x2, y2, can2);
bool flag = 0;
for (int i = 0; i < 8; ++i) {
for (int j = 0; j < 8; ++j) {
if (can1[i][j] == can2[i][j] && can1[i][j] != -1) {
flag = 1;
}
}
}
puts(flag ? "YES" : "NO");
gets(s[0]);
}
int main() {
int t;
scanf("%d\n", &t);
while (t-- > 0) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, element, last_el, lMax, lCurr;
cin >> n;
lMax = lCurr = 0;
for (i = 1, last_el = -1; i <= n; i++) {
cin >> element;
if (element >= last_el) {
lCurr++;
} else {
if (lCurr > lMax) lMax = lCurr;
lCurr = 1;
}
last_el = element;
}
if (lCurr > lMax) lMax = lCurr;
cout << lMax << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long p = 239;
const int ma = 16 * 1024;
int n, dp[76][76][76][3];
vector<int> pos[3];
string s;
int main() {
cin >> n;
cin >> s;
for (int i = 0; i < n; i++) {
if (s[i] == 'V')
pos[0].push_back(i);
else if (s[i] == 'K')
pos[1].push_back(i);
else
pos[2].push_back(i);
}
for (int i = 0; i < (int)pos[0].size() + 1; i++) {
for (int j = 0; j < (int)pos[1].size() + 1; j++) {
for (int k = 0; k < (int)pos[2].size() + 1; k++) {
if (i + j + k == 0) continue;
int cnti = i - 1, cntj = j - 1, cntk = k - 1;
for (int p = 0; p < j; p++) {
if (i && pos[1][p] < pos[0][i - 1]) cnti++;
if (k && pos[1][p] < pos[2][k - 1]) cntk++;
}
for (int p = 0; p < i; p++) {
if (j && pos[0][p] < pos[1][j - 1]) cntj++;
if (k && pos[0][p] < pos[2][k - 1]) cntk++;
}
for (int p = 0; p < k; p++) {
if (i && pos[2][p] < pos[0][i - 1]) cnti++;
if (j && pos[2][p] < pos[1][j - 1]) cntj++;
}
for (int q = 0; q < 3; q++) dp[i][j][k][q] = int(1e9);
if (i)
dp[i][j][k][0] = min(dp[i - 1][j][k][0],
min(dp[i - 1][j][k][1], dp[i - 1][j][k][2])) +
max(pos[0][i - 1] - cnti, 0);
if (j)
dp[i][j][k][1] = min(dp[i][j - 1][k][1], dp[i][j - 1][k][2]) +
max(pos[1][j - 1] - cntj, 0);
if (k)
dp[i][j][k][2] = min(dp[i][j][k - 1][0],
min(dp[i][j][k - 1][1], dp[i][j][k - 1][2])) +
max(pos[2][k - 1] - cntk, 0);
}
}
}
cout << min(min(dp[(int)pos[0].size()][(int)pos[1].size()][(int)pos[2].size()]
[0],
dp[(int)pos[0].size()][(int)pos[1].size()][(int)pos[2].size()]
[1]),
dp[(int)pos[0].size()][(int)pos[1].size()][(int)pos[2].size()][2])
<< "\n";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1002;
long long BIT[4][MAX][MAX];
int gp(int x, int y) {
if (x % 2) return y % 2 ? 0 : 1;
return y % 2 ? 2 : 3;
}
long long read(int x, int y) {
long long ret = 0, idx = gp(x, y);
while (x > 0) {
for (int yy = y; yy > 0; yy -= yy & -yy) ret ^= BIT[idx][x][yy];
x -= x & -x;
}
return ret;
}
void update(int x, int y, long long val) {
int idx = gp(x, y);
while (x < MAX) {
for (int yy = y; yy < MAX; yy += yy & -yy) {
BIT[idx][x][yy] ^= val;
}
x += x & -x;
}
}
int main() {
int n, m;
cin >> n >> m;
while (m--) {
int type;
scanf("%d", &type);
if (type == 2) {
int x1, y1, x2, y2;
long long val;
scanf("%d %d %d %d %lld", &x1, &y1, &x2, &y2, &val);
update(x1, y1, val);
update(x1, y2 + 1, val);
update(x2 + 1, y1, val);
update(x2 + 1, y2 + 1, val);
} else {
int x1, y1, x2, y2;
scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
long long ans = read(x2, y2) ^ read(x1 - 1, y1 - 1) ^ read(x1 - 1, y2) ^
read(x2, y1 - 1);
printf("%lld\n", ans);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int ct[1000010];
int r;
int f[1000010];
int g[1000010];
int C(int n, int m) {
if (m > n) return 0;
int vv = 1LL * g[n - m] * g[m] % 1000000007;
vv = 1LL * vv * f[n] % 1000000007;
return vv;
}
int calc() {
int ans = 1;
for (int i = 0; i <= r; i++) ans = 1LL * ans * f[ct[i]] % 1000000007;
int cnt = ct[0];
for (int i = 1; i <= r; i++) {
int add = C(cnt + ct[i], ct[i]) - C(cnt + ct[i] - 1, ct[i]);
if (add >= 1000000007) add -= 1000000007;
if (add < 0) add += 1000000007;
ans = 1LL * ans * add % 1000000007;
cnt += ct[i];
}
return ans;
}
int main() {
f[0] = 1;
for (int i = 1; i < 1000010; i++) f[i] = 1LL * f[i - 1] * i % 1000000007;
g[1000010 - 1] = power(f[1000010 - 1], 1000000007 - 2, 1000000007);
for (int i = 1000010 - 2; i >= 0; i--)
g[i] = 1LL * g[i + 1] * (i + 1) % 1000000007;
int n;
scanf("%d", &n);
int st = 1;
r = 0;
while (st <= n) {
r++;
st *= 2;
}
r--;
st = 1;
ct[r] = 1;
for (int i = 0; i < r; i++) {
ct[i] = n / st - (n / (st * 2));
st *= 2;
}
int ans = 0;
ans += calc();
if (ans >= 1000000007) ans -= 1000000007;
int v = 3 * (1 << (r - 1));
if (v <= n) {
for (int i = 1; i <= r; i++) {
ct[r] = 1;
int val = v;
for (int j = 1; j <= r; j++) {
int f;
if (j == i)
f = 3;
else
f = 2;
val /= f;
ct[r - j] = (n / val) - (n / (val * f));
}
ans += calc();
if (ans >= 1000000007) ans -= 1000000007;
}
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t;
cin >> t;
long long mi = 1, csk = 0;
while (t--) {
long long n;
cin >> n;
string s;
cin >> s;
long long odd = 0;
long long even = 0;
if (n & 1) {
for (long long i = 0; i < n; i += 2)
if ((s[i] - '0') & 1) odd++;
even = n - odd;
if (odd)
cout << "1\n";
else
cout << "2\n";
} else {
for (long long i = 1; i < n; i += 2)
if ((s[i] - '0') % 2 == 0) even++;
if (even)
cout << "2\n";
else
cout << "1\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int INF = 100000000;
double EPS = 1e-8;
int n, r, idx, jdx;
bool dup(vector<vector<int> > &x) {
for (int j = 0; j < n; ++j)
if (!(int)((x[j]).size())) return 0;
return 1;
}
void countp(vector<int> &y) {
int q = 0;
for (int i = 0; i < (int)((y).size()); ++i)
for (int j = i + 1; j < (int)((y).size()); ++j) {
if (y[i] > y[j]) q++;
}
if (q < r) {
idx = jdx;
r = q;
}
}
void dfs(vector<vector<int> > &x, vector<int> &y, int l) {
if (l == n) {
countp(y);
return;
}
for (int i = 0; i < (int)((x[l]).size()); ++i) {
y[l] = x[l][i];
dfs(x, y, l + 1);
}
}
int inv(vector<vector<int> > &x) {
int l = 0;
for (int i = 0; i < (int)((x[l]).size()); ++i) {
vector<int> y(n);
y[l] = x[l][i];
dfs(x, y, l + 1);
}
}
int main() {
for (; ~scanf("%d", &n);) {
r = INF;
vector<string> sa(n);
for (int i = 0; i < n; ++i) cin >> sa[i];
int m;
scanf("%d", &m);
for (int i = 0; i < m; ++i) {
jdx = i;
int k;
scanf("%d", &k);
vector<string> sb(k);
for (int j = 0; j < k; ++j) cin >> sb[j];
vector<vector<int> > x(n);
for (int j = 0; j < n; ++j)
for (int l = 0; l < k; ++l) {
if (sa[j] == sb[l]) x[j].push_back(l);
}
if (!dup(x)) continue;
inv(x);
}
if (r != INF) {
printf("%d\n", idx + 1);
cout << "[:";
for (int j = 0; j < n * (n - 1) / 2 + 1 - r; ++j) cout << "|";
cout << ":]" << endl;
} else {
cout << "Brand new problem!" << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4.1,sse4.2,avx,avx2,popcnt,tune=native")
using namespace std;
namespace t {
template <typename T>
inline const T gcd(T __m, T __n) {
while (__n != 0) {
T __t = __m % __n;
__m = __n;
__n = __t;
}
return __m;
}
template <typename T>
inline const T max(const T &a, const T &b) {
return a > b ? a : b;
}
template <typename T>
inline const T min(const T &a, const T &b) {
return a < b ? a : b;
}
template <typename T>
inline const T abs(const T &a) {
return a > 0 ? a : -a;
}
template <typename T>
inline void in(T &x) {
register T res = 0;
register int neg = 1;
char c = getchar();
for (; !isdigit(c); c = getchar()) {
if (c == '-') {
neg = -1;
}
}
for (; isdigit(c); c = getchar()) {
res = res * 10 + c - '0';
}
x = res * neg;
}
inline int read() {
register int res = 0, neg = 1;
char c = getchar();
for (; !isdigit(c); c = getchar()) {
if (c == '-') {
neg = -1;
}
}
for (; isdigit(c); c = getchar()) {
res = res * 10 + c - '0';
}
return res * neg;
}
} // namespace t
const int N = 10005;
long long n, m, a[N], b[N], c[N], d[N], ans, tot;
;
char s[N];
long long calc() {
long long cc = 0;
for (long long i = 1; i <= n; i++)
if (c[i]) {
ans += (c[i] - 1) * (m - c[i]) * 4;
for (long long j = i + 1; j <= n; j++)
if (!c[j] || c[j] < c[j - 1])
break;
else
cc += (c[i] - 1) * (m - c[j]) * 4;
for (long long j = i + 1; j <= n; j++)
if (!c[j] || c[j] > c[j - 1])
break;
else
cc += (c[j] - 1) * (m - c[i]) * 4;
}
return cc;
}
int main() {
scanf("%lld%lld", &n, &m);
for (long long i = 1; i <= n; i++) {
scanf("%s", s + 1);
for (long long j = 1; j <= m; j++) {
if (s[j] == '.') {
tot++, a[i]++, b[j]++;
} else {
c[i] = j, d[j] = i;
}
}
}
long long o, ct, su;
o = ct = su = 0;
for (long long i = 1; i <= n; i++) {
o += su * a[i], ct += a[i], su += ct;
}
ans = o * 2;
o = ct = su = 0;
for (long long i = 1; i <= m; i++) {
o += su * b[i], ct += b[i], su += ct;
}
ans += o * 2;
ans += calc();
swap(n, m);
for (long long i = 1; i <= n; i++) {
c[i] = d[i];
}
ans += calc();
printf("%.16lf", ((double)ans) / tot / tot);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k = 0, m;
char face[] = {'f', 'a', 'c', 'e'};
set<char> fc(face, face + 4);
set<char> fc1;
cin >> n >> m;
char a[1000][1000];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
fc1.insert(a[i][j]);
fc1.insert(a[i + 1][j]);
fc1.insert(a[i][j + 1]);
fc1.insert(a[i + 1][j + 1]);
if (fc1 == fc) k++;
fc1.erase(fc1.begin(), fc1.end());
}
cout << k;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << (n + 1) / 2 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int pr[111111], a[111111], b[111111], sum, n, m, i, l, j, kol, q, k, ans1, ans2,
siz, minl, r, kol1, kol2, dp[111111], nach, d[111111];
char c;
string s1, s2, s3, s4;
vector<int> v[111111];
int dfs(int a, int k) {
if (d[a] != 0) return k + d[a];
int i = 0, maxl = k;
pr[a] = 1;
for (i = 0; i < v[a].size(); i++) {
if (pr[v[a][i]] == 0) {
maxl = max(maxl, dfs(v[a][i], k + 1));
}
}
pr[a] = 0;
d[a] = maxl - k;
return maxl;
}
int main() {
cin >> n >> m;
minl = 999999999;
for (i = 1; i <= m; i++) {
scanf("%d %d", &a[i], &b[i]);
dp[b[i]] = 1;
}
for (i = 1; i <= n; i++) {
if (dp[i] == 0) nach = i;
}
l = 1;
r = m;
while (l != r) {
int mid = (l + r) / 2;
for (i = 1; i <= mid; i++) {
v[a[i]].push_back(b[i]);
}
kol = dfs(nach, 1);
for (i = 1; i <= n; i++) {
v[i].clear();
d[i] = 0;
}
if (kol == n) {
if (mid < minl) {
minl = mid;
}
}
if (kol < n)
l = mid + 1;
else
r = mid;
}
int mid = (l + r) / 2;
for (i = 1; i <= mid; i++) {
v[a[i]].push_back(b[i]);
dp[b[i]] = 1;
}
kol = dfs(nach, 1);
if (kol == n) {
if (mid < minl) {
minl = mid;
}
}
if (minl != 999999999)
cout << minl;
else
cout << -1;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 10;
int a[maxn];
int main() {
int n;
while (~scanf("%d", &n)) {
long long sum = 0;
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
long long cnt = 0;
for (int i = n - 1; i >= 0; i--) {
if (a[i] == 0)
cnt++;
else
sum += cnt;
}
printf("%I64d\n", sum);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000 + 5;
const int MAXM = 1000 + 5;
const long long INF = (long long)1e14 + 5;
vector<pair<int, long long> > edge[MAXN], edge2[MAXN];
int n, m;
int x, y;
int t[MAXN], c[MAXN];
long long dis[MAXN];
void predo() {
for (int i = 0; i < n; i++) {
fill(dis, dis + n, INF);
queue<int> q;
set<pair<int, int> > hash;
q.push(i);
dis[i] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (vector<pair<int, long long> >::const_iterator itr = edge[u].begin();
itr != edge[u].end(); itr++) {
if (dis[u] + itr->second < dis[itr->first] &&
dis[u] + itr->second <= t[i]) {
dis[itr->first] = dis[u] + itr->second;
if (hash.find(make_pair(i, itr->first)) == hash.end()) {
edge2[i].push_back(make_pair(itr->first, c[i]));
hash.insert(make_pair(i, itr->first));
}
q.push(itr->first);
}
}
}
}
}
class Cmp {
public:
bool operator()(const pair<int, long long>& lhs,
const pair<int, long long>& rhs) {
if (lhs.second != rhs.second) return lhs.second > rhs.second;
}
};
void dijkstra() {
priority_queue<pair<int, long long>, vector<pair<int, long long> >, Cmp> pq;
fill(dis, dis + n, INF);
dis[x] = 0;
pq.push(make_pair(x, 0));
while (!pq.empty()) {
int u = pq.top().first;
pq.pop();
if (u == y) break;
for (vector<pair<int, long long> >::const_iterator itr = edge2[u].begin();
itr != edge2[u].end(); itr++) {
if (dis[u] + itr->second < dis[itr->first]) {
dis[itr->first] = dis[u] + itr->second;
pq.push(make_pair(itr->first, dis[itr->first]));
}
}
}
printf("%I64d\n", dis[y] == INF ? -1 : dis[y]);
}
int main() {
while (cin >> n >> m) {
cin >> x >> y;
--x, --y;
for (int i = 0; i < n; i++) {
edge[i].clear();
edge2[i].clear();
}
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
--u, --v;
edge[u].push_back(make_pair(v, w));
edge[v].push_back(make_pair(u, w));
}
for (int i = 0; i < n; i++) cin >> t[i] >> c[i];
predo();
dijkstra();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long m, b;
int main() {
cin >> m >> b;
long long maxn = 0;
for (long long i = 0; i <= m * b; i++) {
long long j = -i / m + b;
if (m * j + i - m * b <= 0) {
long long ans = (i + 1) * (j + 1) * (i + j) / 2;
if (ans > maxn) maxn = ans;
}
}
cout << maxn << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
string solve(){
int n; cin >> n;
string a, b; cin >> a >> b;
vector<bool> can_swap(n, false);
int ones = 0;
int zeros = 0;
for (int i = 0; i < n; ++i){
if (a[i] == '1') ++ones;
else ++zeros;
if (ones == zeros) can_swap[i] = true;
}
bool upside = false;
for (int i = n - 1; i >= 0; --i){
if (upside && a[i] != b[i]) continue;
if (!upside && a[i] == b[i]) continue;
if (!can_swap[i]) return "NO";
upside = !upside;
}
return "YES";
}
int main(){
cin.sync_with_stdio(false);
int t; cin >> t;
while (t--) cout << solve() << "\n";
} | 2 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0;
int sign = 0;
char c = getchar();
for (; !isdigit(c); c = getchar()) {
sign |= c == '-';
}
for (; isdigit(c); c = getchar()) {
x = x * 10 + c - '0';
}
return sign ? -x : x;
}
const int ms = 1 << 22;
const int lim = (1 << 22) - 1;
int arr[ms], pai[ms], comps;
bool hav[ms];
bool vis[ms];
int find(int x) {
if (x == pai[x]) return x;
return pai[x] = find(pai[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x != y) {
--comps;
pai[x] = y;
}
}
void dfs(int u, int mask) {
if (hav[mask]) unite(u, mask);
if (vis[mask]) return;
vis[mask] = true;
if (mask == 0) return;
int last_bit = 31 - __builtin_clz(mask);
for (int i = last_bit; i >= 0; --i) {
int nmask = mask & (~(1 << i));
dfs(u, nmask);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
iota(pai, pai + ms, 0);
int n = read(), m = read();
comps = m;
for (int i = 0; i < m; ++i) {
arr[i] = read();
hav[arr[i]] = true;
}
for (int i = 0; i < m; ++i) {
dfs(arr[i], ~arr[i] & lim);
}
cout << comps << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
const int MAXN = 1e5 + 10;
struct info {
long long sm, mi;
friend info operator+(info a, info b) {
a.mi = std::min(a.mi, b.mi + a.sm);
a.sm += b.sm;
return a;
}
} tree[MAXN], val[MAXN];
int ls[MAXN], rs[MAXN], ds[MAXN];
int son[MAXN][2], fa[MAXN], idx;
int get(int x, int b = 1) { return son[fa[x]][b] == x; }
void update(int x) { tree[x] = tree[son[x][0]] + val[x] + tree[son[x][1]]; }
void rotate(int x) {
int y = fa[x], z = fa[y];
bool b = get(x);
if (z) son[z][get(y)] = x;
son[y][b] = son[x][!b], son[x][!b] = y;
fa[x] = z, fa[y] = x;
if (int t = son[y][b]) fa[t] = y;
update(y);
}
int rt;
void splay(int x, int to = 0) {
if (!x) return;
for (; fa[x] != to; rotate(x))
if (fa[fa[x]] != to) rotate(get(x) ^ get(fa[x]) ? x : fa[x]);
update(x);
if (to == 0) rt = x;
}
int lower_bound(int v, int up = 0) {
int now = rt, res = 0, lst = 0;
while (now) {
lst = now;
if (ls[now] <= v)
res = now, now = son[now][1];
else
now = son[now][0];
}
splay(lst, up), splay(res, up);
return res;
}
int leftmost(int x, int up = 0) {
while (son[x][0]) x = son[x][0];
splay(x, up);
return x;
}
void calcval(int u) {
val[u].sm = (long long)(rs[u] - ls[u]) * ds[u];
val[u].mi = std::min(val[u].sm, 0ll);
update(u);
}
int main() {
std::ios_base::sync_with_stdio(false), std::cin.tie(0);
std::cout << std::fixed << std::setprecision(8);
int Q;
std::cin >> Q;
rt = idx = 1;
ls[rt] = 1.5e9, rs[rt] = 1.5e9, ds[rt] = 0;
++idx;
ls[idx] = -1.5e9, rs[idx] = 1.5e9, ds[idx] = 0;
fa[idx] = rt, son[rt][0] = idx;
calcval(idx);
calcval(rt);
while (Q-- > 0) {
int opt, t, l, r;
long long v;
std::cin >> opt;
if (opt == 1) {
std::cin >> t >> v;
int at = lower_bound(t), u = ++idx, L, R;
ls[u] = t, ds[u] = v;
rs[u] = rs[at], rs[at] = t;
calcval(at);
R = son[at][1], fa[R] = son[at][1] = 0;
L = at;
son[u][0] = L;
fa[L] = u;
son[u][1] = R;
fa[R] = u;
calcval(rt = u);
} else if (opt == 2) {
std::cin >> t;
int at = lower_bound(t);
int L = lower_bound(t - 1, at), R = leftmost(son[at][1], at);
rs[L] = rs[at], calcval(L);
fa[R] = 0;
son[R][0] = L;
fa[L] = R, update(rt = R);
} else {
std::cin >> l >> r >> v;
if (!v) {
std::cout << l << '\n';
continue;
}
int R = lower_bound(r);
R = leftmost(son[R][1]);
int L = lower_bound(l - 1, R);
int u = son[L][1], lst = 0, ans = 0;
info pre = (info){0ll, 0ll};
while (u) {
lst = u;
info vn = pre + tree[son[u][0]] + val[u];
if (vn.mi + v <= 0)
ans = u, u = son[u][0];
else
pre = vn, u = son[u][1];
}
splay(lst, L);
splay(u = ans, L);
v += tree[son[u][0]].sm;
if (ans == 0 || v + (long long)ds[u] * (r - ls[u]) > 0)
std::cout << -1 << '\n';
else
std::cout << (-v / (double)ds[u] + ls[u]) << '\n';
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int inf = 50000000;
const int maxn = 200010;
long long n;
long long arr[maxn];
int main() {
int ans = 0;
long long p, d, kl, kr, i, j;
scanf("%lld", &n);
for (i = 1; i <= n; i++) scanf("%lld", &arr[i]);
for (i = 1; i <= n;) {
ans++;
kl = i;
while (kl <= n) {
if (arr[kl] != -1) break;
kl++;
}
kr = kl + 1;
while (kr <= n) {
if (arr[kr] != -1) break;
kr++;
}
if (kr > n) break;
if ((arr[kr] - arr[kl]) % (kr - kl)) {
i = kr;
continue;
}
d = (arr[kr] - arr[kl]) / (kr - kl);
if (arr[kl] - (d * (kl - i)) <= 0) {
i = kr;
continue;
}
while (kr <= n) {
p = arr[kl] + (kr - kl) * d;
if (p <= 0) {
i = kr;
break;
}
if (arr[kr] != -1 && p != arr[kr]) {
i = kr;
break;
}
kr++;
}
i = kr;
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int stmp;
const int MAX = 100000;
const int INF = 1000000001;
class tree {
public:
void init(int n) {
for (size = 1; size < n; size *= 2)
;
val.assign(2 * size, vector<int>());
}
void set(int pos, int v) { val[pos + size].push_back(v); }
void build() {
for (int i = (size - 1); i >= (1); --i) {
val[i].resize(val[2 * i].size() + val[2 * i + 1].size());
merge((val[2 * i]).begin(), (val[2 * i]).end(), (val[2 * i + 1]).begin(),
(val[2 * i + 1]).end(), val[i].begin());
}
}
int lower(int b, int e, int v) {
if (b == e) return 0;
return query(b + size, e + size, v);
}
int greater(int b, int e, int v) { return (e - b) - lower(b, e, v + 1); }
private:
int size;
vector<vector<int> > val;
int sth(int p, int v) {
return lower_bound((val[p]).begin(), (val[p]).end(), v) - val[p].begin();
}
int query(int p, int q, int v) {
if (p + 1 == q) return sth(p, v);
if (p & 1) return sth(p, v) + query(p + 1, q, v);
if (q & 1) return sth(q - 1, v) + query(p, q - 1, v);
return query(p / 2, q / 2, v);
}
};
int tab[MAX];
tree T;
int n;
long long k;
int main(int argc, char *argv[]) {
ios_base::sync_with_stdio(0);
cin >> n >> k;
T.init(n);
for (int i = 0; i < (n); ++i) {
cin >> tab[i];
T.set(i, tab[i]);
}
T.build();
long long total = 0;
for (int i = 0; i < (n); ++i) total += T.greater(0, i, tab[i]);
if (total <= k) {
cout << (long long)n * (n - 1) / 2 << endl;
return 0;
}
long long res = 0;
long long inv = 0;
int j = 1;
for (int i = (1); i <= (n - 1); ++i) {
while (j < n && total - inv > k) {
inv += T.greater(0, i, tab[j]) + T.lower(j + 1, n, tab[j]);
++j;
}
if (total - inv > k || j == n) break;
res += (n - j);
inv -= T.greater(0, i, tab[i]);
inv -= T.lower(j, n, tab[i]);
}
cout << res << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
const long double pi = 3.141592653589793238462643383L;
int main() {
std::cout << std::fixed << std::setprecision(12);
long double n, r;
std::cin >> n >> r;
const long double A = 1.0L / std::tan(pi / (2.0L * n));
const long double B = 1.0L / std::tan(pi / n);
std::cout << n * r * r / (A + B) << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
bool f[N][N];
int x[3005], y[3005];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x[i] >> y[i];
f[x[i] + 1000][y[i] + 1000] = true;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
if ((x[i] + x[j]) % 2 != 0 || (y[i] + y[j]) % 2 != 0) continue;
int x_md = (x[i] + x[j]) / 2;
int y_md = (y[i] + y[j]) / 2;
if (f[x_md + 1000][y_md + 1000] == 1) ans++;
}
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string second;
cin >> second;
string ans = "";
for (int i = 0; i < second.length(); i++) {
if (i == 0 && second[i] == '9')
ans += '9';
else {
int dig = second[i] - '0';
int an = min(dig, 9 - dig);
ans += an + '0';
}
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ans;
int main() {
cin >> n >> m;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
ans = m;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
ans = max(ans, int(m / a[i]) * a[j] + (m % a[i]));
}
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int c[100];
int dp[580005];
int main() {
int i, j, n, d;
while (scanf("%d%d", &n, &d) != EOF) {
memset(dp, 0, sizeof(dp));
int sum = 0;
for (i = 1; i <= n; i++) scanf("%d", &c[i]), sum += c[i];
dp[0] = 1;
for (i = 1; i <= n; i++) {
for (j = sum - c[i]; j >= 0; j--) {
if (dp[j]) dp[j + c[i]]++;
}
}
int now = 0, nn = 0;
while (1) {
int flag = 0;
for (i = now + d; i > now; i--) {
if (dp[i]) {
flag = 1;
break;
}
}
if (flag == 0) break;
now = i;
nn++;
}
cout << now << " " << nn << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long long int MOD = 1000000007;
int N, L;
int width[100], height[100];
long long int DP[100][2][3001];
long long int dp(int i, int o, int len) {
long long int& ans = DP[i][o][len];
if (ans != -1) return ans;
int w = width[i], h = height[i];
if (o == 1) swap(w, h);
if (w > len) return 0;
if (len == w) return ans = 1;
ans = 0;
for (int j = 0; j <= N - 1; ++j) {
if (i == j) continue;
if (width[j] == h) {
ans = (ans + dp(j, 0, len - w)) % MOD;
}
if (width[j] != height[j] and height[j] == h) {
ans = (ans + dp(j, 1, len - w)) % MOD;
}
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> N >> L;
for (int i = 0; i <= N - 1; ++i) cin >> width[i] >> height[i];
memset(DP, -1, sizeof DP);
long long int ways = 0;
for (int i = 0; i <= N - 1; ++i) {
ways = (ways + dp(i, 0, L)) % MOD;
if (width[i] != height[i]) {
ways = (ways + dp(i, 1, L)) % MOD;
}
}
cout << ways << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int inf_int = 2e9;
long long inf_ll = 1e18;
const double pi = 3.1415926535898;
bool debug = 0;
const int MAXN = 3e5 + 100000;
int mod = 1e9 + 9;
int L[MAXN], R[MAXN];
bool com(pair<int, int> a, pair<int, int> b) {
pair<int, int> x, y;
if (a.second == 0) {
x = {L[a.first], 0};
} else {
x = {R[a.first], 1};
}
if (b.second == 0) {
y = {L[b.first], 0};
} else {
y = {R[b.first], 1};
}
return x < y;
}
void solve() {
int n;
cin >> n;
int k;
cin >> k;
vector<pair<int, int> > a;
for (int i = 0; i < n; ++i) {
cin >> L[i] >> R[i];
a.push_back({i, 0});
a.push_back({i, 1});
}
sort(a.begin(), a.end(), com);
set<pair<int, int> > s1, s2;
int ans = 0;
for (int i = 0; i < a.size(); ++i) {
int ind = a[i].first;
if (a[i].second == 0) {
s2.insert({L[ind], ind});
} else {
if (s1.size() + s2.size() < k) {
} else {
while (s1.size() < k) {
s1.insert(*s2.begin());
s2.erase(s2.begin());
}
int l = max(s1.rbegin()->first, L[ind]);
if (R[ind] - l + 1 >= ans) {
ans = R[ind] - l + 1;
}
}
s1.erase({L[ind], ind});
s2.erase({L[ind], ind});
}
}
if (ans == 0) {
cout << ans << "\n";
for (int i = 1; i <= k; ++i) {
cout << i << " ";
}
return;
} else {
cout << ans << "\n";
for (int i = 0; i < a.size(); ++i) {
int ind = a[i].first;
if (a[i].second == 0) {
s2.insert({L[ind], ind});
} else {
if (s1.size() + s2.size() < k) {
} else {
while (s1.size() < k) {
s1.insert(*s2.begin());
s2.erase(s2.begin());
}
int l = max(s1.rbegin()->first, L[ind]);
if (R[ind] - l + 1 == ans) {
vector<int> res;
res.push_back(ind);
for (pair<int, int> x : s1) {
if (res.size() == k) break;
if (x.second != ind) {
res.push_back(x.second);
}
}
for (int v : res) {
cout << v + 1 << " ";
}
return;
}
}
s1.erase({L[ind], ind});
s2.erase({L[ind], ind});
}
}
}
}
int main() {
if (!debug) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int t = 1;
while (t--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long inf = 0x3f3f3f3f3f3f3f3f;
const int N = 5e5 + 10;
const long long mod = 1e9 + 7;
int n;
long long a[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
if (n == 1) {
printf("%d %d\n%lld\n", 1, 1, -a[1]);
printf("1 1\n0\n");
printf("1 1\n0\n");
return 0;
}
printf("%d %d\n", 1, n - 1);
for (int i = 1; i < n; i++)
printf("%lld%c", a[i] * (n - 1), " \n"[i == n - 1]);
printf("%d %d\n", n, n);
printf("%lld\n", -a[n]);
printf("%d %d\n", 1, n);
for (int i = 1; i < n; i++) printf("%lld ", -a[i] * n);
puts("0");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const int INF = 1e9;
int main() {
int n, m, c;
scanf("%d", &n);
scanf("%d", &m);
scanf("%d", &c);
vector<int> lhalf(n, INF);
vector<int> uhalf(n, INF);
while (m--) {
int a;
scanf("%d", &a);
if (a > c / 2) {
auto it = upper_bound(uhalf.begin(), uhalf.end(), c - a);
*it = c - a;
int idx = it - uhalf.begin();
printf("%d\n", n - idx);
fflush(stdout);
} else {
auto it = upper_bound(lhalf.begin(), lhalf.end(), a);
*it = a;
int idx = it - lhalf.begin();
printf("%d\n", idx + 1);
fflush(stdout);
}
if (count(lhalf.begin(), lhalf.end(), INF) +
count(uhalf.begin(), uhalf.end(), INF) <=
n)
break;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 222;
char s[MaxN], t[MaxN];
int cnts[11], cntt[11];
int main(void) {
int i;
scanf(" %s %s", t, s);
for (i = 0; i < strlen(t); i++) cntt[t[i] - '0']++;
for (i = 0; i < strlen(s); i++) cnts[s[i] - '0']++;
cntt[2] += cntt[5];
cntt[5] = 0;
cntt[6] += cntt[9];
cntt[9] = 0;
cnts[2] += cnts[5];
cnts[5] = 0;
cnts[6] += cnts[9];
cnts[9] = 0;
int res = 222;
for (i = 0; i < 10; i++)
if (cntt[i] > 0) res = min(res, cnts[i] / cntt[i]);
printf("%d\n", res);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long double x, y, z, a[13] = {0}, maxa = -1;
cin >> x >> y >> z;
a[1] = pow(y, z) * log(x);
a[2] = pow(z, y) * log(x);
a[3] = z * y * log(x);
a[4] = y * z * log(x);
a[5] = pow(x, z) * log(y);
a[6] = pow(z, x) * log(y);
a[7] = z * x * log(y);
a[8] = x * z * log(y);
a[9] = pow(x, y) * log(z);
a[10] = pow(y, x) * log(z);
a[11] = y * x * log(z);
a[12] = x * y * log(z);
int maxi = 0;
for (int i = 1; i <= 12; i++) {
if (a[i] > maxa) {
maxi = i;
maxa = a[i];
}
}
string s[13] = {"", "x^y^z", "x^z^y", "(x^y)^z", "(x^z)^y",
"y^x^z", "y^z^x", "(y^x)^z", "(y^z)^x", "z^x^y",
"z^y^x", "(z^x)^y", "(z^y)^x"};
cout << s[maxi];
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC target("avx")
template <int, typename T>
struct MINMAX {
T val;
MINMAX(T val) : val(val) {}
};
template <typename T>
MINMAX<1, T> MAX(T val) {
return MINMAX<1, T>(val);
};
template <typename T>
MINMAX<2, T> MIN(T val) {
return MINMAX<2, T>(val);
};
template <typename T, typename U>
inline T &operator|=(T &lhs, MINMAX<1, U> rhs) {
return lhs = max(lhs, rhs.val);
}
template <typename T, typename U>
inline T &operator|=(T &lhs, MINMAX<2, U> rhs) {
return lhs = min(lhs, rhs.val);
}
template <typename T, typename U>
istream &operator>>(istream &in, pair<T, U> &p) {
in >> p.first >> p.second;
return in;
}
template <typename T = int>
inline vector<T> READ(int n) {
vector<T> vec(n);
for (int i = 0; i < int(n); i++) cin >> vec[i];
return vec;
}
template <typename T>
using min_heap = priority_queue<T, vector<T>, greater<T> >;
const int INF = 1e9;
struct tree {
vector<int> p;
vector<pair<int, int> > ch;
int find(int u) {
if (p[u] == -1) return u;
return p[u] = find(p[u]);
}
void add() {
p.push_back(-1);
ch.push_back({-1, -1});
}
void join(int u, int v) {
int ru = find(u);
int rv = find(v);
if (ru == rv) return;
add();
p[ru] = p.size() - 1;
p[rv] = p.size() - 1;
ch.back() = {ru, rv};
}
void etr(vector<int> &in, vector<int> &out) {
in.assign(p.size(), -1);
out.assign(p.size(), -1);
int t = 0;
for (int i = 0; i < int(p.size()); i++) {
if (p[i] < 0) etr(i, t, in, out);
}
}
void etr(int u, int &t, vector<int> &in, vector<int> &out) {
in[u] = t++;
if (ch[u].first >= 0) {
etr(ch[u].first, t, in, out);
etr(ch[u].second, t, in, out);
}
out[u] = t++;
}
} T;
struct SegTree {
static const int H = 20;
static const int N = 1 << H;
pair<int, int> t[2 * N] = {};
private:
void update(int ID) { t[ID] = max(t[(ID << 1)], t[(ID << 1 | 1)]); }
public:
void setPoint(int pos, int val, int ID = 1, int L = 0, int R = N - 1) {
if (L == R) {
t[ID] = {val, pos};
return;
}
int mid = L + R >> 1;
if (pos <= mid)
setPoint(pos, val, ID * 2, L, mid);
else
setPoint(pos, val, ID * 2 + 1, mid + 1, R);
update(ID);
}
pair<int, int> queryMax(int from, int to, int ID = 1, int L = 0,
int R = N - 1) {
if (from <= L && to >= R) return t[ID];
pair<int, int> res = {0, -1};
int mid = L + R >> 1;
if (from <= mid) res |= MAX(queryMax(from, to, ID * 2, L, mid));
if (to > mid) res |= MAX(queryMax(from, to, ID * 2 + 1, mid + 1, R));
return res;
}
} st;
const int MAXN = 2e5 + 5;
vector<int> adj[MAXN];
int visited[MAXN] = {0};
void dfs(int u, map<int, int> &res) {
if (visited[u]) return;
visited[u] = 1;
if (res.count(u)) return;
int newid = res.size();
res[u] = newid;
for (int to : adj[u]) dfs(to, res);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout << fixed << setprecision(12);
int n, m, Q;
cin >> n >> m >> Q;
vector<int> p = READ(n);
vector<pair<int, int> > edges = READ<pair<int, int> >(m);
vector<pair<int, int> > qry = READ<pair<int, int> >(Q);
p.insert(p.begin(), 1e9);
for (int i = 0; i < int(n + 1); i++) T.add();
set<pair<int, int> > edgeDelete;
vector<pair<int, int> > edgeOrder;
for (auto q : qry) {
if (q.first == 1) continue;
;
pair<int, int> e = edges[q.second - 1];
edgeDelete.insert(e);
}
for (int i = 0; i < int(m); i++) {
pair<int, int> e = edges[i];
if (!edgeDelete.count(e)) {
T.join(e.first, e.second);
}
}
stack<int> qryRoot;
reverse((qry).begin(), (qry).end());
for (auto q : qry) {
if (q.first == 2) {
pair<int, int> e = edges[q.second - 1];
T.join(e.first, e.second);
}
if (q.first == 1) {
int rt = T.find(q.second);
qryRoot.push(rt);
}
}
reverse((qry).begin(), (qry).end());
vector<int> in, out;
T.etr(in, out);
for (int i = 0; i < int(n + 1); i++) st.setPoint(in[i], p[i]);
for (auto q : qry) {
if (q.first == 2) continue;
;
int u = qryRoot.top();
qryRoot.pop();
pair<int, int> mx = st.queryMax(in[u], out[u]);
cout << mx.first << endl;
if (mx.second >= 0) st.setPoint(mx.second, 0);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int Inf = 1000000000;
const int Maxn = 3005;
int n, k;
int p[Maxn];
bool alln100[Maxn], onen0[Maxn];
int dist[Maxn][Maxn];
vector<pair<int, int> > Q;
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &p[i]);
alln100[n + 1] = true;
onen0[n + 1] = false;
for (int i = n; i >= 1; i--) {
alln100[i] = p[i] != 100 && alln100[i + 1];
onen0[i] = p[i] != 0 || onen0[i + 1];
}
fill((int*)dist, (int*)dist + Maxn * Maxn, Inf);
dist[1][2] = 0;
Q.push_back(pair<int, int>(1, 2));
for (int i = 0; i < Q.size(); i++) {
pair<int, int> v = Q[i];
int d = dist[v.first][v.second];
if (v.second > n || d == k) continue;
if (alln100[v.second] && p[v.first] != 0 &&
d + 1 < dist[v.first][v.second + 1]) {
dist[v.first][v.second + 1] = d + 1;
Q.push_back(pair<int, int>(v.first, v.second + 1));
}
if (onen0[v.second] && p[v.first] != 100 &&
d + 1 < dist[v.second][v.second + 1]) {
dist[v.second][v.second + 1] = d + 1;
Q.push_back(pair<int, int>(v.second, v.second + 1));
}
if (onen0[v.second] && p[v.first] != 0 &&
d + 1 < dist[v.second + 1][v.second + 2]) {
dist[v.second + 1][v.second + 2] = d + 1;
Q.push_back(pair<int, int>(v.second + 1, v.second + 2));
}
}
printf("%d\n", Q.size());
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const double PI = acos(-1);
struct Point {
double x, y;
};
inline Point operator+(const Point &a, const Point &b) {
return {a.x + b.x, a.y + b.y};
}
inline Point operator-(const Point &a, const Point &b) {
return {a.x - b.x, a.y - b.y};
}
inline Point operator*(const Point &a, double b) { return {a.x * b, a.y * b}; }
inline Point operator/(const Point &a, double b) { return {a.x / b, a.y / b}; }
inline double cross(const Point &a, const Point &b) {
return a.x * b.y - a.y * b.x;
}
inline double dot(const Point &a, const Point &b) {
return a.x * b.x + a.y * b.y;
}
inline double dis(const Point &a) { return sqrt(dot(a, a)); }
inline double angle(const Point &a, const Point &b) {
return acos(dot(a, b) / dis(a) / dis(b));
}
inline double polar(const Point &a) { return atan2(a.y, a.x); }
inline double slope(const Point &a, const Point &b) {
return (b.y - a.y) / (b.x - a.x);
}
int n;
const double EPS = 1e-9;
Point a, b;
struct Node {
double v;
int fl;
} q[N * 2];
int idx;
template <typename T>
T read() {
T num = 0;
int ch = getchar();
T fl = 1;
while (!isdigit(ch) && ch != 45) ch = getchar();
if (ch == 45) fl = -1, ch = getchar();
while (isdigit(ch)) {
num = (num << 3) + (num << 1) + (ch - 48);
ch = getchar();
}
num *= fl;
return num;
}
int main() {
ios::sync_with_stdio(false);
a.x = read<int>();
a.y = read<int>();
b.x = read<int>(), b.y = read<int>();
Point midp = (a + b) / 2, offset = b - a;
offset = offset / dis(offset);
offset = {-offset.y, offset.x};
n = read<int>();
for (int i = 1; i <= n; i++) {
Point p;
int R;
p.x = read<int>(), p.y = read<int>(), R = read<int>();
int fl = cross(p - a, b - p) > 0;
double l = -1e12, r = 1e12;
for (int _ = 1; _ <= 80; ++_) {
double mid = (l + r) / 2;
Point o = midp + offset * mid;
if ((dis(p - o) > dis(a - o) + R) ^ fl)
l = mid;
else
r = mid;
}
q[++idx] = {l, fl ? -1 : 1};
l = -1e12, r = 1e12;
for (int _ = 1; _ <= 80; ++_) {
double mid = (l + r) / 2;
Point o = midp + offset * mid;
if ((dis(a - o) > dis(p - o) + R) ^ fl)
r = mid;
else
l = mid;
}
q[++idx] = {r, fl ? 1 : -1};
}
q[++idx] = {1e12, 0};
q[++idx] = {-1e12, 0};
q[++idx] = {0, 0};
double ans = 1e12;
sort(q, q + idx + 1, [](const Node &a, const Node &b) { return a.v < b.v; });
bool ok = 0;
int sum = 0;
for (int i = 1; i <= idx; i++) {
if (!sum) ok = 1, ans = min(ans, abs(q[i].v));
sum += q[i].fl;
if (!sum) ok = 1, ans = min(ans, abs(q[i].v));
}
if (!ok) {
cout << -1 << endl;
return 0;
} else
printf("%.10lf\n", dis(a - (midp + offset * ans)));
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.1415926535897932384626433832795;
const long long INF = 1000000000;
const double EPS = 1 / 1e9;
const long long MOD = 1000000007;
const int N = 1010;
long long comb[N][N];
int main() {
int n;
cin >> n;
vector<int> dp(n + 1), c(n + 1);
dp[1] = 1;
for (int i = 0; i < n; i++) cin >> c[i + 1];
comb[0][0] = 1;
for (int i = 1; i < N; i++) {
comb[i][0] = comb[i][i] = 1;
for (int j = 1; j < i; j++) {
comb[i][j] = (comb[i - 1][j] + comb[i - 1][j - 1]) % MOD;
}
}
int s = c[1];
for (int i = 2; i <= n; i++) {
s += c[i];
dp[i] = ((dp[i - 1] % MOD) * (comb[s - 1][c[i] - 1] % MOD) % MOD);
}
cout << dp[n];
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << ' ' << *it << " = " << a;
err(++it, args...);
}
template <typename T, typename U>
inline void min_self(T& x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
inline void max_self(T& x, U y) {
if (x < y) x = y;
}
template <class T1, class T2>
ostream& operator<<(ostream& out, pair<T1, T2> pair) {
return out << "(" << pair.first << ", " << pair.second << ")";
}
template <class T>
ostream& operator<<(ostream& out, vector<T> vec) {
for (auto& v : vec) out << v << ' ';
return out << "\n";
}
template <class T>
ostream& operator<<(ostream& out, set<T> vec) {
out << "(";
for (auto& v : vec) out << v << ", ";
return out << ")";
}
template <class L, class R>
ostream& operator<<(ostream& out, map<L, R> vec) {
out << "(";
for (auto& v : vec) out << "[" << v.first << ", " << v.second << "]";
return out << ")";
}
template <class A, class B>
istream& operator>>(istream& in, pair<A, B>& a) {
return in >> a.first >> a.second;
}
template <class A>
istream& operator>>(istream& in, vector<A>& a) {
for (A& i : a) in >> i;
return in;
}
template <class Container>
void split(const std::string& str, Container& cont, char delim = ',') {
stringstream ss(str);
string token;
while (std::getline(ss, token, delim)) {
cont.push_back(token);
}
}
long long px[4] = {-1, 0, 1, 0};
long long py[4] = {0, -1, 0, 1};
struct edge {
long long u, v, wt;
edge(long long a = 0, long long b = 0, long long c = 0) : u(a), v(b), wt(c) {}
bool operator<(edge const& other) { return wt < other.wt; }
friend ostream& operator<<(ostream& out, const edge& x) {
return out << "(" << x.u << ", " << x.v << ", " << x.wt << ")";
}
};
long long calc(long long num, long long parts, bool mode = true) {
long long quo = num / parts + 1;
long long rem = num % parts;
long long nt1 = rem, nt2 = parts - rem;
long long ans;
if (mode) {
ans = calc(num, parts - 1, false) - calc(num, parts, false);
} else {
ans = nt1 * quo * quo + nt2 * (quo - 1) * (quo - 1);
}
return ans;
}
void abcd() {
long long n, k, res = 0;
cin >> n >> k;
priority_queue<pair<long long, pair<long long, long long>>> pq;
for (long long i = 1; i <= n; i++) {
long long x;
cin >> x;
pq.push({calc(x, 2), {x, 1}});
}
k = k - n;
for (long long i = 1; i <= k; i++) {
long long prev = pq.top().first;
auto [num, parts] = pq.top().second;
pq.pop();
pq.push({calc(num, parts + 2), {num, parts + 1}});
}
while (!pq.empty()) {
auto [num, parts] = pq.top().second;
res += calc(num, parts, false);
pq.pop();
}
cout << res << '\n';
return;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) {
abcd();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int INF = 1000000000;
const int MOD = 1073741824;
const int M = INF;
const double RRR = 180.0 / PI;
vector<vector<pair<int, int> > > g;
vector<int> used;
void dfs(int v, int l, int r) {
used[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
if (g[v][i].second >= l && g[v][i].second <= r) {
continue;
}
int to = g[v][i].first;
if (!used[to]) {
dfs(to, l, r);
}
}
}
int main() {
double TIME_START = clock();
int n, m;
cin >> n >> m;
used.resize(n);
g.resize(n);
int a, b;
for (int i = 0; i < m; i++) {
cin >> a >> b;
a--;
b--;
g[a].push_back(make_pair(b, i));
g[b].push_back(make_pair(a, i));
}
int k;
cin >> k;
int l, r;
for (int i = 0; i < k; i++) {
cin >> l >> r;
l--;
r--;
int col = 0;
used.assign(n, 0);
for (int i = 0; i < n; i++) {
if (!used[i]) {
col++;
dfs(i, l, r);
}
}
cout << col << endl;
}
fprintf(stderr, "\n\n%.15lf\n\n",
(double)(clock() - TIME_START) / CLOCKS_PER_SEC);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool comparator(pair<int, float> a, pair<int, float> b) {
if (a.second == b.second) {
return (a.first < b.first);
}
return (a.second > b.second);
}
bool check(vector<int> arr) {
int n = arr.size();
if (n == 1) return true;
int d = arr[1] - arr[0];
for (int i = 2; i < n; i++)
if (arr[i] - arr[i - 1] != d) return false;
return true;
}
int main() {
ios::sync_with_stdio(false);
int n, m, x, y, z, sum = 0;
cin >> n >> m;
int arr[101] = {};
while (m--) {
cin >> x >> y >> z;
arr[x] += z;
arr[y] -= z;
}
for (int i = 0; i <= n; i++)
if (arr[i] > 0) sum += arr[i];
cout << sum << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int mu[100];
int pot[100];
int flag;
long long maxn;
long long pow(long long b, int e) {
long long r = 1;
flag = 0;
for (int i = 0; i < e; i++) {
if (r > maxn / b) {
flag = 1;
break;
}
r = r * b;
}
return r;
}
int main() {
mu[1] = 1;
for (int x = 1; x < 100; x++) {
for (int y = 2 * x; y < 100; y += x) {
mu[y] -= mu[x];
}
}
int T;
scanf("%d", &T);
while (T--) {
scanf("%lld", &maxn);
long long ans = maxn - 1;
for (int x = 2; x < 60; x++) {
long long qt = pow(maxn, 1.0 / x);
while (pow(qt + 1, x) <= maxn && !flag) qt++;
ans += mu[x] * (qt - 1);
}
printf("%lld\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline void R(int &x) {
x = 0;
int f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= f;
}
void Redirect() {
freopen(".in", "r", stdin);
freopen(".out", "w", stdout);
}
int n;
const int maxn = 200500;
int a[2][maxn];
int cur, nex;
int sta = 0;
int b[maxn];
const long long mod = int(1e9) + 7;
long long fac[maxn];
long long rev[maxn];
long long cnt[maxn];
long long qpow(long long x, long long n) {
long long ret = 1;
while (n) {
if (n & 1) {
ret = ret * x % mod;
}
x *= x;
x %= mod;
n >>= 1;
}
return ret;
}
int main() {
nex = 1;
R(n);
for (int i = 1; i <= n; ++i) {
R(a[cur][i]);
}
cerr << 1.0 * clock() / CLOCKS_PER_SEC << endl;
while (n % 4 != 0) {
if (n == 1) {
cout << a[cur][1] << endl;
return 0;
}
n--;
for (int i = 1; i <= n; ++i) {
if (sta == 0) {
a[nex][i] = a[cur][i] + a[cur][i + 1];
a[nex][i] %= mod;
} else {
a[nex][i] = a[cur][i] - a[cur][i + 1];
a[nex][i] = (a[nex][i] + mod) % mod;
}
sta ^= 1;
}
cur ^= 1;
nex ^= 1;
}
cerr << 1.0 * clock() / CLOCKS_PER_SEC << endl;
fac[0] = 1;
int qwq = ((n / 4) - 1) * 2 + 1;
for (int i = 1; i <= n; ++i) {
fac[i] = (fac[i - 1] * i) % mod;
}
for (int i = 0; i <= qwq; ++i) {
rev[i] = qpow(fac[i], mod - 2);
}
cerr << 1.0 * clock() / CLOCKS_PER_SEC << endl;
for (int i = 1; i <= (n / 2); ++i) {
if (i % 2 == 0) {
cnt[i] = cnt[i - 1] * -1;
if (sta) cnt[i] *= -1;
continue;
}
int k = i / 2;
cnt[i] = fac[qwq] * rev[k] % mod;
cnt[i] = cnt[i] * rev[qwq - k] % mod;
}
for (int i = (n / 2) + 1; i <= n; ++i) {
cnt[i] = abs(cnt[n + 1 - i]);
if ((sta == 0) && (i % 2 == 0)) cnt[i] *= -1;
}
long long ans = 0;
for (int i = 1; i <= n; ++i) {
ans += ((cnt[i] * a[cur][i]) % mod);
ans %= mod;
while (ans < 0) ans = (ans + mod * (ans / mod * -1 + 5)) % mod;
}
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
int YEAR[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int A[32][13][3];
int main(void) {
char S[100005] = "";
char* str;
int l, max = 0, md, mm, my;
memset(A, 0, 32 * 13 * 3 * sizeof(int));
scanf("%s", S);
l = strlen(S);
str = S;
while (str < S + l) {
int m, d, y;
while (str[0] < '0' && str[1] < '1' && str + 1 < S + l) str++;
if (str[2] != '-' && str + 2 < S + l) {
str++;
continue;
}
if (str[3] < '0' || str[4] < '0' || str + 4 >= S + l) {
str += 4;
continue;
}
m = (str[3] - '0') * 10 + (str[4] - '0');
if (m == 0 || m > 12) {
str += 3;
continue;
}
d = (str[0] - '0') * 10 + (str[1] - '0');
if (d == 0 || d > YEAR[m]) {
str += 3;
continue;
}
if (str[5] != '-') {
str += 4;
continue;
}
if (str[6] < '0' || str[7] < '0' || str[8] < '0' || str[9] < '0' ||
str + 9 >= S + l) {
str += 3;
continue;
}
y = (str[6] - '0') * 1000 + (str[7] - '0') * 100 + (str[8] - '0') * 10 +
(str[9] - '0');
if (y < 2013 || y > 2015) {
str += 8;
continue;
}
A[d][m][y - 2013]++;
str += 8;
}
for (int i = 0; i < 32; i++) {
for (int j = 0; j < 13; j++) {
for (int k = 0; k < 3; k++) {
int a = A[i][j][k];
if (a > max) {
max = a;
md = i;
mm = j;
my = 2013 + k;
}
}
}
}
printf("%02d-%02d-%d\n", md, mm, my);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, i, c[102], n, s = 0;
while (scanf("%d", &n) != EOF) {
s = 0;
for (i = 1; i < n; i++) {
scanf("%d", &c[i]);
}
scanf("%d%d", &a, &b);
for (i = a; i < b; i++) s = s + c[i];
printf("%d\n", s);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
int f, t = 0;
string ex;
string p;
getline(cin, p);
for (int cur = 0; cur < n; cur++) {
getline(cin, p);
int z = p.length();
int j = 0;
while (j < z && p[j] == ' ') j++;
if (j == z) continue;
if (p[j + 1] == 'r') {
t++;
} else if (p[j + 1] == 'h') {
int b = p.find("(", j) + 1;
int c = p.find(")", b + 1) - 1;
while (p[b] == ' ') b++;
while (p[c] == ' ') c--;
ex = p.substr(b, c - b + 1);
f = t;
} else if (p[j + 1] == 'a') {
if (t <= f) {
int b = p.find("(", j) + 1;
while (p[b] == ' ') b++;
int c = p.find(",", b + 1) - 1;
int c2 = c;
while (p[c] == ' ') c--;
string exd = p.substr(b, c - b + 1);
if (ex == exd) {
int d = p.find("\"", c2 + 2) + 1;
int e = p.find("\"", d + 1) - 1;
cout << p.substr(d, e - d + 1) << endl;
return 0;
}
}
t--;
f = min(f, t);
}
}
cout << "Unhandled Exception" << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int a[n + 1];
memset(a, 0, sizeof(a));
while (n) {
int x;
cin >> x;
a[x] = 1;
while (a[n]) {
cout << n-- << " ";
}
cout << endl;
}
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
template <class T>
inline void gmax(T &a, T b) {
if (b > a) a = b;
}
template <class T>
inline void gmin(T &a, T b) {
if (b < a) a = b;
}
using namespace std;
const int N = 100;
const double PI = acos(-1.0);
void fre() {
freopen("/Users/luras/Desktop/in.txt", "r", stdin);
freopen("/Users/luras/Desktop/out.txt", "w", stdout);
}
const int INF = 16843009;
int casenum, casei;
int n, a[N], x, y, flag, b[N];
int main() {
while (~scanf("%d", &n)) {
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
sort(a + 1, a + n + 1);
if (n == 0) {
printf("YES\n%d\n%d\n%d\n%d\n", 1, 1, 3, 3);
} else if (n == 4) {
if (a[1] * 3 == a[4] && a[2] + a[3] == a[1] * 4) {
printf("YES\n");
} else
printf("NO\n");
} else if (n == 1) {
printf("YES\n");
printf("%d\n%d\n%d\n", a[1], a[1] * 3, a[1] * 3);
} else if (n == 2) {
flag = 0;
for (int i = 1; i <= 1500; i++) {
for (int j = 1; j <= 1500; j++) {
b[1] = a[1];
b[2] = a[2];
b[3] = i;
b[4] = j;
sort(b + 1, b + 5);
if (b[1] * 3 == b[4] && b[2] + b[3] == b[1] * 4) {
x = i;
y = j;
flag = 1;
break;
}
}
if (flag) break;
}
if (flag)
printf("YES\n%d\n%d\n", x, y);
else
printf("NO\n");
} else {
flag = 0;
for (int i = 1; i <= 1500; i++) {
b[1] = a[1];
b[2] = a[2];
b[3] = a[3];
b[4] = i;
sort(b + 1, b + 5);
if (b[1] * 3 == b[4] && b[2] + b[3] == b[1] * 4) {
x = i;
flag = 1;
break;
}
}
if (flag)
printf("YES\n%d\n", x);
else
printf("NO\n");
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3003, maxc = 20, maxv = 100, mod = 1e9 + 7, maxa = 1005,
maxs = 820, maxb = 10, base = 737, base2 = 3079, mod3 = 998244353,
delt = 10513;
const long long inf = 2e16;
const int infint = 1e9 + 11;
long long max(long long x, long long y) { return (x > y ? x : y); }
long long min(long long x, long long y) { return (x < y ? x : y); }
int dp[maxn][maxn];
vector<int> v[maxn];
int a[maxn];
int solve(int l, int r) {
if (r - l == 0) {
dp[l][r] = 0;
return 0;
}
if (a[l] == a[r]) {
dp[l][r] = solve(l, r - 1);
return dp[l][r];
}
if (dp[l][r] >= 0) {
return dp[l][r];
}
dp[l][r] = infint;
int col = a[l];
for (int i = 0; i < v[col].size(); i++) {
int j = v[col][i];
if (j > r) {
break;
}
if (j < l) {
continue;
}
dp[l][r] = min(solve(l, j) + solve(j + 1, r) + 1, dp[l][r]);
}
return dp[l][r];
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
v[a[i]].push_back(i);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
dp[i][j] = -1;
}
}
cout << solve(0, n - 1) << endl;
for (int i = 0; i < n; i++) {
v[a[i]].clear();
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vll = vector<ll>;
constexpr int MOD = 1e9 + 7;
constexpr int INF = INT_MAX;
constexpr ll LLINF = LLONG_MAX;
template <class T>
inline bool setmin(T &a, T b) {
if (a > b) return a = b, 1;
return 0;
}
template <class T>
inline bool setmax(T &a, T b) {
if (a < b) return a = b, 1;
return 0;
}
namespace fastio {
template <class T>
istream &operator>>(istream &os, vector<T> &container) {
for (auto &u : container) os >> u;
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &container) {
for (auto &u : container) os << u << " ";
return os;
}
template <class T1, class T2>
inline istream &operator>>(istream &os, pair<T1, T2> &p) {
return os >> p.first >> p.second;
}
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << p.first << " " << p.second;
}
template <typename... args>
void re(args &...tail) {
((cin >> tail), ...);
}
template <typename... args>
void pr(args... tail) {
((cout << tail << " "), ...);
}
template <typename... args>
void prln(args... tail) {
((cout << tail << " "), ...);
cout << "\n";
}
} // namespace fastio
using namespace fastio;
namespace debug {
template <typename _T>
inline void _debug(const char *s, _T x) {
cerr << s << " = " << x << "\n";
}
template <typename _T, typename... args>
void _debug(const char *s, _T x, args... a) {
while (*s != ',') cerr << *s++;
cerr << " = " << x << ',';
_debug(s + 1, a...);
}
} // namespace debug
using namespace debug;
const int N = 1e5 + 7;
string s;
int n, q;
int nxt[N][26];
int dp[257][257][257];
string rel[3];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
re(n, q, s);
for (int i = (0); i <= (25); i++) nxt[n][i] = nxt[n + 1][i] = n;
for (int i = (n - 1); i >= (0); i--) {
for (int j = (0); j <= (25); j++) {
nxt[i][j] = (s[i] == 'a' + j ? i : nxt[i + 1][j]);
}
}
dp[0][0][0] = -1;
for (int _ = (1); _ <= (q); _++) {
char t;
int x;
re(t, x);
x--;
if (t == '+') {
char l;
re(l);
rel[x] += l;
int e0 = (int)(rel[0]).size(), e1 = (int)(rel[1]).size(),
e2 = (int)(rel[2]).size();
int b0 = (x == 0 ? e0 : 0);
int b1 = (x == 1 ? e1 : 0);
int b2 = (x == 2 ? e2 : 0);
for (int a = (b0); a <= (e0); a++) {
for (int b = (b1); b <= (e1); b++) {
for (int c = (b2); c <= (e2); c++) {
auto &v = dp[a][b][c];
v = n;
if (a) setmin(v, nxt[dp[a - 1][b][c] + 1][rel[0][a - 1] - 'a']);
if (b) setmin(v, nxt[dp[a][b - 1][c] + 1][rel[1][b - 1] - 'a']);
if (c) setmin(v, nxt[dp[a][b][c - 1] + 1][rel[2][c - 1] - 'a']);
}
}
}
} else {
rel[x].pop_back();
}
prln(dp[(int)(rel[0]).size()][(int)(rel[1]).size()][(int)(rel[2]).size()] <
n
? "YES"
: "NO");
}
exit(0);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, i, q, n;
cin >> q;
for (t = 1; t <= q; t++) {
cin >> n;
if (n == 1)
cout << "-1" << endl;
else if (n == 2)
cout << "-1" << endl;
else if (n == 3)
cout << "-1" << endl;
else if (n == 5)
cout << "-1" << endl;
else if (n == 7)
cout << "-1" << endl;
else if (n == 11)
cout << "-1" << endl;
else if (n % 4 == 0)
cout << n / 4 << endl;
else if (n % 4 == 1)
cout << (n - 5) / 4 << endl;
else if (n % 4 == 2)
cout << (n - 2) / 4 << endl;
else
cout << (n - 7) / 4 << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
register char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (48 ^ c), c = getchar();
return x;
}
int N, Q, SUM;
struct Chtholly {
int l, r;
mutable bool Day;
Chtholly(int A = 0, int B = -1, bool C = 1) : l(A), r(B), Day(C) {}
bool operator<(const Chtholly &binary) const { return l < binary.l; }
};
set<Chtholly> Holiday;
inline set<Chtholly>::iterator split(int pos) {
set<Chtholly>::iterator res = Holiday.lower_bound(Chtholly(pos));
if (res != Holiday.end() && res->l == pos) return res;
--res;
int L = res->l, R = res->r;
bool B = res->Day;
Holiday.erase(res);
Holiday.insert(Chtholly(L, pos - 1, B));
return Holiday.insert(Chtholly(pos, R, B)).first;
}
inline void assign(int L, int R, bool C) {
set<Chtholly>::iterator Lp = split(L), Rp = split(R + 1), p;
Lp = Holiday.lower_bound(Chtholly(L));
p = Lp;
for (; p != Rp; ++p) SUM -= (int)(p->Day) * (p->r - p->l + 1);
Holiday.erase(Lp, Rp);
Holiday.insert(Chtholly(L, R, C));
SUM += (int)(C) * (R - L + 1);
}
int main() {
N = read(), Q = read();
SUM = N;
Holiday.insert(Chtholly(1, N, 1));
while (Q--) {
int l = read(), r = read();
if (read() == 1)
assign(l, r, 0);
else
assign(l, r, 1);
printf("%d\n", SUM);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T gcd(T a, T b) {
return b == 0 ? a : gcd(b, a % b);
}
template <typename T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
T my_pow(T n, T p) {
if (p == 0) return 1;
T x = my_pow(n, p / 2);
x = (x * x);
if (p & 1) x = (x * n);
return x;
}
template <class T>
T big_mod(T n, T p, T m) {
if (p == 0) return (T)1;
T x = big_mod(n, p / 2, m);
x = (x * x) % m;
if (p & 1) x = (x * n) % m;
return x;
}
template <class T>
T extract(string s, T ret) {
stringstream ss(s);
ss >> ret;
return ret;
}
string itos(long long n) {
string s;
while (n) {
s += (n % 10 + 48);
n /= 10;
}
reverse(s.begin(), s.end());
return s;
}
long long stoi(string s) {
long long n = 0;
for (__typeof(s.size()) i = 0; i < (s.size()); i++) n = n * 10 + (s[i] - 48);
return n;
}
const int N = 5e5 + 5, MOD = 1e9 + 7;
long long ar[N], br[N];
long long a = 0, b = 0, c = 0, r = 0, rr = 0, f = 0, n, m, t = 0, ks = 0;
string s, ss;
priority_queue<long long> st;
struct info {
long long x, y, z;
} arr[N];
bool com(info a, info b) { return (a.x) < (b.x); }
int main() {
cin >> n >> m;
for (__typeof(n) i = 1; i <= (n); i++) cin >> br[i] >> ar[i];
long long ans = 0;
for (__typeof(n) i = 1; i <= (n); i++) {
arr[i].x = br[i];
arr[i].y = ar[i];
arr[i].z = i;
}
sort(arr + 1, arr + n + 1, com);
for (__typeof(n) i = 1; i <= (n); i++) {
if (st.size() < m)
st.push(-arr[i].y);
else if (st.size() >= m and -st.top() < arr[i].y) {
st.pop();
st.push(-arr[i].y);
}
if ((ans < (-st.top() - arr[i].x + 1) and st.size() >= m)) {
ans = (-st.top() - arr[i].x + 1);
r = arr[i].x;
}
}
cout << ans << endl;
if (not ans)
for (__typeof(m) i = 0; i < (m); i++) cout << i + 1 << " ";
for (__typeof(n) i = 1; i <= (n); i++) {
if (m <= 0 or not ans) break;
if (arr[i].x <= r and (ans + r - 1) <= arr[i].y) {
m--;
cout << arr[i].z << " ";
}
}
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 400;
char s[N + 9], t[N + 9];
int n, m;
void into() {
scanf("%s%s", s + 1, t + 1);
n = strlen(s + 1);
m = strlen(t + 1);
}
int dp[N + 9][N + 9];
void Get_dp(int p) {
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= p; ++j) dp[i][j] = -1;
dp[0][0] = p;
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= p; ++j) {
dp[i][j] = dp[i - 1][j];
if (j && s[i] == t[j]) dp[i][j] = max(dp[i][j], dp[i - 1][j - 1]);
if (dp[i - 1][j] ^ -1 && s[i] == t[dp[i - 1][j] + 1])
dp[i][j] = max(dp[i][j], dp[i - 1][j] + 1);
}
}
int ans;
void Get_ans() {
ans = 0;
for (int i = 0; i <= m; ++i) {
Get_dp(i);
if (dp[n][i] == m) {
ans = 1;
return;
}
}
}
void work() { Get_ans(); }
void outo() { puts(ans ? "YES" : "NO"); }
int main() {
int T;
scanf("%d", &T);
for (; T--;) {
into();
work();
outo();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i;
cin >> n;
int brr[3] = {0};
int arr[n];
for (i = 0; i < n; i++) {
cin >> arr[i];
brr[arr[i]]++;
}
if (brr[1] == 0)
cout << 0;
else {
if (brr[1] > brr[2])
cout << (brr[2] + ((brr[1] - brr[2]) / 3));
else
cout << brr[1];
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[5005], b[5005], n;
string s;
void print(int x, int y, int z, int w) {
for (int i = 1; i <= n; i++) {
int t = a[i] * 10 + b[i];
if (t == 11) {
if (w > 0) {
cout << i << " ";
w--;
}
} else if (t == 10) {
if (z > 0) {
cout << i << " ";
z--;
}
} else if (t == 1) {
if (y > 0) {
cout << i << " ";
y--;
}
} else if (t == 0) {
if (x > 0) {
cout << i << " ";
x--;
}
}
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
int c00 = 0, c01 = 0, c10 = 0, c11 = 0;
cin >> s;
for (int i = 1; i <= n; i++) a[i] = s[i - 1] - '0';
cin >> s;
for (int i = 1; i <= n; i++) {
b[i] = s[i - 1] - '0';
if (b[i]) {
if (a[i])
c11++;
else
c01++;
} else {
if (a[i])
c10++;
else
c00++;
}
}
for (int b0 = 0; b0 <= c01; b0++) {
for (int c0 = 0; c0 <= c10; c0++) {
int d0 = c01 + c11 - b0 - c0;
if (d0 & 1)
continue;
else
d0 /= 2;
int a0 = n / 2 - b0 - c0 - d0;
if (a0 >= 0 && a0 <= c00 && d0 >= 0 && d0 <= c11) {
if (c0 + d0 != (c01 - b0) + (c11 - d0)) continue;
print(a0, b0, c0, d0);
return 0;
}
}
}
printf("-1\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int ans;
bool call[2000];
string s;
int process(int x, string q) {
int i;
string name;
for (i = x; isalpha(s[i]); i++) name += s[i];
if (name == q) ans++;
if (s[i] == '.') return i;
while (1) {
if (i < (int)s.size() - 1 && s[i + 1] == '.') {
call[x] = true;
return i + 1;
}
if (!call[x]) process(i + 2 - (s[i] == ':'), name);
i = process(i + 2 - (s[i] == ':'), q);
}
return -1;
}
int main() {
cin >> s;
process(0, "");
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n, i, j, k;
cin >> n;
map<long long int, long long int> m;
long long int l = 5 * 100001;
for (i = 1; i < l; i++) {
m[i] = i;
}
vector<long long int> x(l);
vector<pair<long long int, long long int>> y(l);
vector<long long int> ans;
long long int t = n;
long long int a, b, c;
for (i = 0; i < t; i++) {
cin >> a >> b;
if (a == 2) {
cin >> c;
x[i] = 0;
y[i] = make_pair(b, c);
} else {
x[i] = b;
y[i] = make_pair(0, 0);
}
}
t = n;
for (i = t - 1; i >= 0; i--) {
if (x[i] != 0) {
ans.push_back(m[x[i]]);
} else {
pair<long long int, long long int> p = y[i];
m[p.first] = m[p.second];
}
}
reverse(ans.begin(), ans.end());
for (i = 0; i < ans.size(); i++) cout << ans[i] << " ";
cout << endl;
}
int main() {
long long int t = 1, i;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast,no-stack-protector")
using namespace std;
function<void(void)> ____ = []() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
};
template <typename T>
vector<T> &operator<<(vector<T> &__container, T x) {
__container.push_back(x);
return __container;
}
template <typename T>
ostream &operator<<(ostream &out, vector<T> &__container) {
for (T _ : __container) out << _ << ' ';
return out;
}
const int MAXN = 2e5 + 7;
char s[10];
void solve() {
cin >> s;
int s1 = 0, s2 = 0;
for (int i = 0; i < 3; i++) s1 += s[i] - '0', s2 += s[i + 3] - '0';
int ret = 0;
while (s1 != s2) {
if (s1 < s2) {
int a = 0, b = 3;
if (s[1] < s[0]) a = 1;
if (s[2] < s[a]) a = 2;
if (s[4] > s[3]) b = 4;
if (s[5] > s[b]) b = 5;
if ('9' - s[a] > s[b] - '0') {
if (s2 - s1 <= '9' - s[a]) {
ret++;
break;
} else {
s1 += '9' - s[a];
s[a] = '9';
ret++;
}
} else {
if (s2 - s1 <= s[b] - '0') {
ret++;
break;
} else {
s2 -= s[b] - '0';
s[b] = '0';
ret++;
}
}
} else {
swap(s1, s2);
for (int i = 0; i < 3; i++) swap(s[i], s[i + 3]);
}
}
cout << ret << "\n";
}
int main() {
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
const double pi = 3.14159265359;
const int INF = 0x3f3f3f3f;
using namespace std;
int main(void) {
vector<int> x, y;
map<int, set<int> > xx, yy;
int n, temp1, temp2, count = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> temp1 >> temp2;
x.push_back(temp1), y.push_back(temp2);
xx[temp1].insert(temp2);
yy[temp2].insert(temp1);
}
for (int i = 0; i <= n - 1; i++) {
if (xx[x[i]].find(y[i]) != --(xx[x[i]].end()) &&
xx[x[i]].find(y[i]) != xx[x[i]].begin() &&
yy[y[i]].find(x[i]) != --(yy[y[i]].end()) &&
yy[y[i]].find(x[i]) != yy[y[i]].begin())
count++;
}
cout << count << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
const int inf = (int)1e9;
const int mod = inf + 7;
const double eps = 1e-9;
const double pi = acos(-1.0);
int n, q;
vector<int> g[300100];
int cnt[300100], val[300100];
vector<pair<pair<int, int>, pair<int, int> > > t[4 * 300300];
int L[300300], R[300300];
vector<int> order;
void dfs(int v, int par) {
cnt[v] = 1;
val[v] = -inf;
order.push_back(v);
L[v] = (int)order.size() - 1;
for (__typeof(g[v].begin()) it = g[v].begin(); it != g[v].end(); it++) {
int to = *it;
if (to != par) {
dfs(to, v);
cnt[v] += cnt[to];
val[v] = max(val[v], cnt[to]);
}
}
R[v] = (int)order.size() - 1;
}
vector<pair<pair<int, int>, pair<int, int> > > merge(
vector<pair<pair<int, int>, pair<int, int> > > &a,
vector<pair<pair<int, int>, pair<int, int> > > &b, int addb) {
vector<pair<pair<int, int>, pair<int, int> > > c;
int i, j;
for (i = 0, j = 0; i < a.size() && j < b.size();) {
if (a[i] < b[j]) {
c.push_back(a[i++]);
} else {
c.push_back(make_pair(
b[j].first, make_pair(b[j].second.first, b[j].second.second + addb)));
j++;
}
}
while (i < a.size()) {
c.push_back(a[i++]);
}
while (j < b.size()) {
c.push_back(make_pair(
b[j].first, make_pair(b[j].second.first, b[j].second.second + addb)));
j++;
}
int x = -inf;
int ind = -1;
for (int i = 0; i < c.size(); i++) {
if (c[i].second.first > x) {
x = c[i].second.first;
ind = c[i].second.second;
}
c[i].second = make_pair(x, ind);
}
return c;
}
void build(int v, int tl, int tr) {
if (tl == tr) {
int x = order[tl];
t[v].push_back(make_pair(make_pair(val[x], cnt[x]), make_pair(cnt[x], 0)));
} else {
int mid = (tl + tr) >> 1;
build(2 * v, tl, mid);
build(2 * v + 1, mid + 1, tr);
t[v] = merge(t[2 * v], t[2 * v + 1], mid + 1 - tl);
}
}
void print(int v, int tl, int tr) {
printf("%d - %d %d == ", v, tl, tr);
for (int i = 0; i < t[v].size(); i++) {
printf("[(%d, %d), %d.%d] ", t[v][i].first.first, t[v][i].first.second,
t[v][i].second.first, t[v][i].second.second);
}
printf("\n");
if (tl == tr) {
return;
int x = order[tl];
} else {
int mid = (tl + tr) >> 1;
print(2 * v, tl, mid);
print(2 * v + 1, mid + 1, tr);
}
}
int get(vector<pair<pair<int, int>, pair<int, int> > > &a, int x, int y) {
if (a.empty()) return -1;
if (a[0].first.first > x) return -1;
int pos = 0;
int l = 1, r = (int)a.size() - 1;
while (l <= r) {
int mid = (l + r) >> 1;
if (a[mid].first.first <= x) {
pos = mid;
l = mid + 1;
} else
r = mid - 1;
}
if (a[pos].second.first >= y) return a[pos].second.second;
return -1;
}
int get(int v, int tl, int tr, int l, int r, int x, int y) {
if (l > r) return -1;
if (r < tl) return -1;
if (l > tr) return -1;
if (l <= tl && tr <= r) {
int res = get(t[v], x, y);
if (res == -1) return -1;
return tl + res;
}
int mid = (tl + tr) >> 1;
int ans1 = get(2 * v, tl, mid, l, r, x, y);
int ans2 = get(2 * v + 1, mid + 1, tr, l, r, x, y);
return max(ans1, ans2);
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 2; i <= n; i++) {
int x;
scanf("%d", &x);
x--;
g[x].push_back(i - 1);
g[i - 1].push_back(x);
}
dfs(0, -1);
build(1, 0, n - 1);
while (q--) {
int v;
scanf("%d", &v);
v--;
if (cnt[v] == 1) {
printf("%d\n", v + 1);
continue;
}
int x = cnt[v] / 2;
int y = (cnt[v] + 1) / 2;
int res = get(1, 0, n - 1, L[v], R[v], x, y);
assert(res != -1);
printf("%d\n", order[res] + 1);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, ans, p[200001], b[200001];
bool mark[200001], need = 1;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", p + i);
for (int i = 1; i <= n; i++) scanf("%d", b + i), need ^= b[i];
for (int i = 1; i <= n; i++)
if (!mark[i]) {
mark[i] = true;
ans++;
int v = i;
while ((v = p[v]) != i) mark[v] = true;
}
if (ans == 1) ans--;
printf("%d", ans + need);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using Int = long long;
struct FenwickTree {
vector<Int> A;
FenwickTree(int n) : A(n) {}
Int sum(int i) {
Int sum = 0;
while (i > 0) sum += A[i], i -= ((i) & -(i));
return sum;
}
void add(int i, Int k) {
while (i < A.size()) A[i] += k, i += ((i) & -(i));
}
};
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int N, M;
cin >> N >> M;
vector<int> T(N);
for (auto &t : T) cin >> t;
vector<pair<int, int>> X;
for (int i = 0; i < N; i++) X.emplace_back(T[i], i);
sort(begin(X), end(X));
vector<int> I(N);
for (int i = 0; i < N; i++) I[X[i].second] = i + 1;
FenwickTree A(N + 1), B(N + 1);
for (int i = 0; i < N; i++) {
auto k = I[i];
auto limit = M - T[i];
int ok = 0, ng = N + 1;
while (ng - ok > 1) {
int mid = (ng + ok) / 2;
if (A.sum(mid) <= limit) {
ok = mid;
} else {
ng = mid;
}
}
cout << i - B.sum(ok) << ' ';
A.add(k, T[i]);
B.add(k, 1);
}
cout << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 23;
const long long INF = 1e18 * 9;
const long long M = 3000 + 3;
const long long mod = 1e9 + 7;
long long dix[] = {-1, 1, 0, 0, -1, -1, 1, 1};
long long diy[] = {0, 0, 1, -1, 1, -1, 1, -1};
map<long long, long long> mp, mp1;
string s, ss;
long long n, m, x, y, k, a[N], dp[4];
vector<long long> ve;
void solve() {
long long ans = 0, ans2 = 0, f = -1, pos = 1, mx = 0;
cin >> n >> s;
for (long long i = 0; i < s.size(); i++) {
if (s[i] == 'a') dp[0] = (dp[0] + pos) % mod;
if (s[i] == 'b') dp[1] = (dp[1] + dp[0]) % mod;
if (s[i] == 'c') dp[2] = (dp[2] + dp[1]) % mod;
if (s[i] == '?') {
dp[2] = (dp[2] * 3 % mod + dp[1]) % mod;
dp[1] = (dp[1] * 3 % mod + dp[0]) % mod;
dp[0] = (dp[0] * 3 % mod + pos) % mod;
pos = (pos * 3) % mod;
}
}
cout << dp[2] << '\n';
}
signed main() {
ios::sync_with_stdio(0);
solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char table[2010][2010];
int deg[2010][2010];
int n, m;
int N;
int movx[] = {1, -1, 0, 0};
int movy[] = {0, 0, 1, -1};
int dir[] = {-1, -2, -3, -4};
bool valid(int x, int y) { return x >= 0 && x < n && y >= 0 && y < m; }
class pt {
public:
int x, y;
pt() {}
pt(int a, int b) {
x = a;
y = b;
}
};
bool v[2010][2010];
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", table[i]);
memset(deg, 0, sizeof(deg));
queue<pt> q;
N = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (table[i][j] != '.') continue;
N++;
for (int k = 0; k < 4; k++) {
int x = i + movx[k], y = j + movy[k];
if (valid(x, y) && table[x][y] == '.') deg[i][j]++;
}
if (deg[i][j] == 1) q.push(pt(i, j));
}
}
if (N % 2)
printf("Not unique\n");
else {
int total = 0;
while (!q.empty()) {
pt aux = q.front();
q.pop();
int x = aux.x, y = aux.y;
if (deg[x][y] <= 0) continue;
total++;
for (int i = 0; i < 4; i++) {
int nx = x + movx[i];
int ny = y + movy[i];
if (!valid(nx, ny)) continue;
if (table[nx][ny] == '*') continue;
if (deg[nx][ny] < 0) continue;
if (i == 0) {
deg[x][y] = -3, deg[nx][ny] = -4;
} else if (i == 1) {
deg[x][y] = -4, deg[nx][ny] = -3;
} else if (i == 2) {
deg[x][y] = -1, deg[nx][ny] = -2;
} else {
deg[x][y] = -2, deg[nx][ny] = -1;
}
for (int j = 0; j < 4; j++) {
int rx = nx + movx[j];
int ry = ny + movy[j];
if (table[rx][ry] == '*') continue;
if (!valid(rx, ry)) continue;
if (deg[rx][ry] < 0) continue;
deg[rx][ry]--;
if (deg[rx][ry] == 1) q.push(pt(rx, ry));
}
}
}
if (total != N / 2)
printf("Not unique\n");
else {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (table[i][j] == '*')
printf("*");
else if (deg[i][j] == -1)
printf("<");
else if (deg[i][j] == -2)
printf(">");
else if (deg[i][j] == -3)
printf("^");
else
printf("v");
}
printf("\n");
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int x;
vector<pair<int, int>> arr[27];
vector<pair<int, int>> v;
int dp[27];
bool ok(int c) {
for (auto i : arr[c]) {
for (auto a : v) {
if (x >= (i.first - a.first) * (i.first - a.first) +
(i.second - a.second) * (i.second - a.second))
return 1;
}
}
return 0;
}
int main() {
int n, m;
cin >> n >> m >> x;
char tmp;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
cin >> tmp;
if (tmp == 'S')
v.push_back(make_pair(i, j));
else
arr[tmp - 'a'].push_back(make_pair(i, j));
}
}
int q;
cin >> q;
string s;
cin >> s;
int out = 0;
x *= x;
for (auto i : s) {
int c = tolower(i) - 'a';
if (arr[c].empty()) return puts("-1");
if (isupper(i)) {
if (v.size() == 0) return puts("-1");
if (dp[c] == 0) {
if (!ok(c)) {
out++;
dp[c] = 1;
} else
dp[c] = -1;
} else if (dp[c] == 1)
out++;
}
}
cout << out;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int ctor(char n) {
switch (n) {
case '^':
return 0;
case '>':
return 1;
case 'v':
return 2;
case '<':
return 3;
}
}
int main() {
ios_base::sync_with_stdio(false);
string a, b;
int t;
cin >> a >> b >> t;
t %= 4;
if (t == 0 || t == 2) {
cout << "undefined" << endl;
} else if (t == 1) {
if (ctor(a[0]) == (ctor(b[0]) + 1) % 4) {
cout << "ccw" << endl;
} else {
cout << "cw" << endl;
}
} else if (t == 3) {
if (ctor(a[0]) == (ctor(b[0]) + 1) % 4) {
cout << "cw" << endl;
} else {
cout << "ccw" << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
while (cin >> n >> k) {
if (n * 2 == k)
cout << k / 2 << endl;
else {
if ((k - n * 2) >= n)
cout << 0 << endl;
else
cout << n - (k - n * 2) << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (1LL << 30) - 1;
const long long int LINF = (1LL << 62) - 1;
int A, B, N, L, T, M;
int check(int R) {
long long int num = R * 1LL * (R - 1) / 2 - (L - 1) * 1LL * (L - 2) / 2;
long long int sum = (R - L + 1) * 1LL * A + B * 1LL * num;
return ((A + (R - 1) * 1LL * B <= T) && (sum <= T * 1LL * M));
}
int main() {
int lo, hi, mi, sol;
cin.sync_with_stdio(false);
scanf("%d%d%d", &A, &B, &N);
while (N--) {
scanf("%d%d%d", &L, &T, &M);
lo = L, hi = (T - A) / B + 200;
sol = -1;
while (lo <= hi) {
mi = (lo + hi) / 2;
if (check(mi)) {
sol = max(sol, mi);
lo = mi + 1;
} else
hi = mi - 1;
}
printf("%d\n", sol);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int t, n, m, k, ans;
int tar[6005], nex[6005], fir[3005], cnt;
int siz[3005];
long long A[3005];
pair<int, long long> f[3005][3005], g[3005];
void Add(int a, int b) {
++cnt;
tar[cnt] = b;
nex[cnt] = fir[a];
fir[a] = cnt;
}
void Dfs(int r, int fa) {
siz[r] = 1;
for (int i = 1; i <= m; i++) f[r][i] = make_pair(-1, 0);
f[r][1] = make_pair(0, A[r]);
for (int i = fir[r]; i; i = nex[i]) {
int v = tar[i];
if (v != fa) {
Dfs(v, r);
int a = min(m, siz[r]), b = min(m, siz[v]);
for (int j = 1; j <= min(m, a + b); j++) g[j] = make_pair(-1, 0);
for (int j = 1; j <= a; j++) {
for (int k = 1; k <= min(b, m - j + 1); k++) {
if (j + k <= m)
g[j + k] = max(g[j + k], make_pair(f[r][j].first + f[v][k].first +
(f[v][k].second > 0),
f[r][j].second));
g[j + k - 1] =
max(g[j + k - 1], make_pair(f[r][j].first + f[v][k].first,
f[r][j].second + f[v][k].second));
}
}
for (int j = 1; j <= min(m, a + b); j++) f[r][j] = g[j];
siz[r] += siz[v];
}
}
}
int main() {
scanf("%d", &t);
for (; t--;) {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &k), A[i] = -k;
for (int i = 1; i <= n; i++) scanf("%d", &k), A[i] += k;
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
Add(u, v), Add(v, u);
}
Dfs(1, 0);
printf("%d\n", f[1][m].first + (f[1][m].second > 0));
for (int i = 1; i <= n; i++) fir[i] = 0;
cnt = 0;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long int q = 1e9 + 7;
int main() {
int n, m, k;
cin >> n >> m >> k;
long long int ans = 1;
if (k > n || k == 1) {
ans = 1;
for (int i = 1; i <= n; i++) {
ans = (ans * m) % q;
}
} else if (k % 2 == 0) {
if (k == n) {
for (int i = 1; i <= n / 2; i++) {
ans = (ans * m) % q;
}
} else {
ans = m;
}
} else if (k % 2 == 1) {
if (k == n) {
for (int i = 1; i <= n / 2 + 1; i++) {
ans = (ans * m) % q;
}
} else {
ans = m * m;
}
}
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string a, b;
int main() {
cin >> a >> b;
while (b.length() < a.length()) b = '0' + b;
while (a.length() < b.length()) a = '0' + a;
a = '0' + a;
b = '0' + b;
for (int i = 1; i < a.length(); i++) {
if (a[i] == '1' && a[i + 1] == '1') {
a[i - 1] = '1';
a[i] = '0';
a[i + 1] = '0';
}
}
for (int i = a.length() - 1; i >= 0; i--) {
if (a[i] == '1' && a[i + 1] == '1') {
a[i - 1] = '1';
a[i] = '0';
a[i + 1] = '0';
}
}
for (int i = 1; i < b.length(); i++) {
if (b[i] == '1' && b[i + 1] == '1') {
b[i - 1] = '1';
b[i] = '0';
b[i + 1] = '0';
}
}
for (int i = b.length() - 1; i >= 0; i--) {
if (b[i] == '1' && b[i + 1] == '1') {
b[i - 1] = '1';
b[i] = '0';
b[i + 1] = '0';
}
}
for (int i = 0; i < a.length(); i++) {
if (a[i] != b[i]) {
if (a[i] == '1')
cout << ">\n";
else
cout << "<\n";
return 0;
}
}
cout << "=\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
constexpr long double m_pi = 3.1415926535897932L;
constexpr long long MOD = 1000000007;
constexpr long long INF = 1LL << 61;
constexpr long double EPS = 1e-10;
template <typename T>
using vector2 = vector<vector<T>>;
template <typename T>
using vector3 = vector<vector2<T>>;
string operator*(const string& s, int k) {
if (k == 0) return "";
string p = (s + s) * (k / 2);
if (k % 2 == 1) p += s;
return p;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
struct Edge {
int to, rev;
long long cap;
Edge(int _to, long long _cap, int _rev) {
to = _to;
cap = _cap;
rev = _rev;
}
};
void add_edge(vector<vector<Edge>>& G, int from, int to, long long cap,
bool revFlag, long long revCap) {
G[from].push_back(Edge(to, cap, (long long)G[to].size() + (from == to)));
if (revFlag)
G[to].push_back(Edge(from, revCap, (long long)G[from].size() - 1));
}
long long max_flow_dfs(vector<vector<Edge>>& G, long long v, long long t,
long long f, vector<bool>& used) {
if (v == t) return f;
used[v] = true;
for (int i = 0; i < G[v].size(); ++i) {
Edge& e = G[v][i];
if (!used[e.to] && e.cap > 0) {
long long d = max_flow_dfs(G, e.to, t, min(f, e.cap), used);
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
long long max_flow(vector<vector<Edge>>& G, long long s, long long t) {
long long flow = 0;
for (;;) {
vector<bool> used(G.size());
for (long long(i) = (long long)(0); i < (long long)(used.size()); i++)
used[i] = false;
long long f = max_flow_dfs(G, s, t, INF, used);
if (f == 0) {
return flow;
}
flow += f;
}
}
void BellmanFord(vector<vector<Edge>>& G, long long s, vector<long long>& d,
vector<long long>& negative) {
d.resize(G.size());
negative.resize(G.size());
for (long long(i) = (long long)(0); i < (long long)(d.size()); i++)
d[i] = INF;
for (long long(i) = (long long)(0); i < (long long)(d.size()); i++)
negative[i] = false;
d[s] = 0;
for (long long(k) = (long long)(0); k < (long long)(G.size() - 1); k++) {
for (long long(i) = (long long)(0); i < (long long)(G.size()); i++) {
for (long long(j) = (long long)(0); j < (long long)(G[i].size()); j++) {
if (d[i] != INF && d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
}
}
}
}
for (long long(k) = (long long)(0); k < (long long)(G.size() - 1); k++) {
for (long long(i) = (long long)(0); i < (long long)(G.size()); i++) {
for (long long(j) = (long long)(0); j < (long long)(G[i].size()); j++) {
if (d[i] != INF && d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
negative[G[i][j].to] = true;
}
if (negative[i] == true) negative[G[i][j].to] = true;
}
}
}
}
void Dijkstra(vector<vector<Edge>>& G, long long s, vector<long long>& d) {
d.resize(G.size());
for (long long(i) = (long long)(0); i < (long long)(d.size()); i++)
d[i] = INF;
d[s] = 0;
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
q;
q.push(make_pair(0, s));
while (!q.empty()) {
pair<long long, long long> a = q.top();
q.pop();
if (d[a.second] < a.first) continue;
for (long long(i) = (long long)(0); i < (long long)(G[a.second].size());
i++) {
Edge e = G[a.second][i];
if (d[e.to] > d[a.second] + e.cap) {
d[e.to] = d[a.second] + e.cap;
q.push(make_pair(d[e.to], e.to));
}
}
}
}
void WarshallFloyd(vector<vector<Edge>>& G, vector<vector<long long>>& d) {
d.resize(G.size());
for (long long(i) = (long long)(0); i < (long long)(d.size()); i++)
d[i].resize(G.size());
for (long long(i) = (long long)(0); i < (long long)(d.size()); i++) {
for (long long(j) = (long long)(0); j < (long long)(d[i].size()); j++) {
d[i][j] = ((i != j) ? INF : 0);
}
}
for (long long(i) = (long long)(0); i < (long long)(G.size()); i++) {
for (long long(j) = (long long)(0); j < (long long)(G[i].size()); j++) {
chmin(d[i][G[i][j].to], G[i][j].cap);
}
}
for (long long(i) = (long long)(0); i < (long long)(G.size()); i++) {
for (long long(j) = (long long)(0); j < (long long)(G.size()); j++) {
for (long long(k) = (long long)(0); k < (long long)(G.size()); k++) {
if (d[j][i] != INF && d[i][k] != INF) chmin(d[j][k], d[j][i] + d[i][k]);
}
}
}
}
bool tsort(vector<vector<Edge>>& graph, vector<int>& order) {
int n = graph.size(), k = 0;
vector<int> in(n);
for (auto& es : graph)
for (auto& e : es) in[e.to]++;
priority_queue<int, vector<int>, greater<int>> que;
for (long long(i) = (long long)(0); i < (long long)(n); i++)
if (in[i] == 0) que.push(i);
while (que.size()) {
int v = que.top();
que.pop();
order.push_back(v);
for (auto& e : graph[v])
if (--in[e.to] == 0) que.push(e.to);
}
if (order.size() != n)
return false;
else
return true;
}
class Lca {
public:
const int n = 0;
const int log2_n = 0;
std::vector<std::vector<int>> parent;
std::vector<int> depth;
Lca() {}
Lca(const vector<vector<Edge>>& g, int root)
: n(g.size()),
log2_n(log2(n) + 1),
parent(log2_n, std::vector<int>(n)),
depth(n) {
dfs(g, root, -1, 0);
for (int k = 0; k + 1 < log2_n; k++) {
for (int v = 0; v < (int)g.size(); v++) {
if (parent[k][v] < 0)
parent[k + 1][v] = -1;
else
parent[k + 1][v] = parent[k][parent[k][v]];
}
}
}
void dfs(const vector<vector<Edge>>& g, int v, int p, int d) {
parent[0][v] = p;
depth[v] = d;
for (auto& e : g[v]) {
if (e.to != p) dfs(g, e.to, v, d + 1);
}
}
int get(int u, int v) {
if (depth[u] > depth[v]) std::swap(u, v);
for (int k = 0; k < log2_n; k++) {
if ((depth[v] - depth[u]) >> k & 1) {
v = parent[k][v];
}
}
if (u == v) return u;
for (int k = log2_n - 1; k >= 0; k--) {
if (parent[k][u] != parent[k][v]) {
u = parent[k][u];
v = parent[k][v];
}
}
return parent[0][u];
}
};
class UnionFind {
vector<int> data;
int num;
public:
UnionFind(int size) : data(size, -1), num(size) {}
bool unite(int x, int y) {
x = root(x);
y = root(y);
if (x != y) {
if (data[y] < data[x]) swap(x, y);
data[x] += data[y];
data[y] = x;
}
num -= (x != y);
return x != y;
}
bool findSet(int x, int y) { return root(x) == root(y); }
int root(int x) { return data[x] < 0 ? x : data[x] = root(data[x]); }
int size(int x) { return -data[root(x)]; }
int numSet() { return num; }
};
template <typename T, typename F>
class SegmentTree {
private:
T identity;
F merge;
long long n;
vector<T> dat;
public:
SegmentTree(F f, T id, vector<T> v) : merge(f), identity(id) {
int _n = v.size();
n = 1;
while (n < _n) n *= 2;
dat.resize(2 * n - 1, identity);
for (long long(i) = (long long)(0); i < (long long)(_n); i++)
dat[n + i - 1] = v[i];
for (int i = n - 2; i >= 0; i--)
dat[i] = merge(dat[i * 2 + 1], dat[i * 2 + 2]);
}
SegmentTree(F f, T id, int _n) : merge(f), identity(id) {
n = 1;
while (n < _n) n *= 2;
dat.resize(2 * n - 1, identity);
}
void set_val(int i, T x) {
i += n - 1;
dat[i] = x;
while (i > 0) {
i = (i - 1) / 2;
dat[i] = merge(dat[i * 2 + 1], dat[i * 2 + 2]);
}
}
T query(int l, int r) {
T left = identity, right = identity;
l += n - 1;
r += n - 1;
while (l < r) {
if ((l & 1) == 0) left = merge(left, dat[l]);
if ((r & 1) == 0) right = merge(dat[r - 1], right);
l = l / 2;
r = (r - 1) / 2;
}
return merge(left, right);
}
};
template <typename T>
class FenwickTree {
vector<T> data;
int n;
int p;
public:
FenwickTree(int n) : n(n) {
data.resize(n + 1LL, 0);
p = 1;
while (p < data.size()) p *= 2;
}
T sum(int k) {
T ret = 0;
for (; k > 0; k -= k & -k) ret += data[k];
return (ret);
}
T sum(int a, int b) { return sum(b) - sum(a); }
void add(int k, T x) {
for (++k; k <= n; k += k & -k) data[k] += x;
}
int lower_bound(long long w) {
if (w <= 0) return -1;
int x = 0;
for (int k = p / 2; k > 0; k /= 2) {
if (x + k <= n && data[x + k] < w) w -= data[x + k], x += k;
}
return x;
}
};
void divisor(long long n, vector<long long>& ret) {
for (long long i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) ret.push_back(n / i);
}
}
sort(ret.begin(), ret.end());
}
void prime_factorization(long long n, vector<pair<long long, long long>>& ret) {
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back({i, 0});
while (n % i == 0) {
n /= i;
ret[ret.size() - 1].second++;
}
}
}
if (n != 1) ret.push_back({n, 1});
}
inline long long mod_pow(long long x, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
inline long long mod_inv(long long x, long long mod) {
return mod_pow(x, mod - 2, mod);
}
class Combination {
public:
vector<long long> fact;
vector<long long> fact_inv;
long long mod;
long long nCr(long long n, long long r) {
if (n < r) return 0;
if (n < mod) return ((fact[n] * fact_inv[r] % mod) * fact_inv[n - r]) % mod;
long long ret = 1;
while (n || r) {
long long _n = n % mod, _r = r % mod;
n /= mod;
r /= mod;
(ret *= nCr(_n, _r)) %= mod;
}
return ret;
}
long long nPr(long long n, long long r) {
return (fact[n] * fact_inv[n - r]) % mod;
}
long long nHr(long long n, long long r) { return nCr(r + n - 1, r); }
Combination(long long _n, long long _mod) {
mod = _mod;
long long n = min(_n + 1, mod);
fact.resize(n);
fact[0] = 1;
for (long long(i) = (long long)(0); i < (long long)(n - 1); i++) {
fact[i + 1] = (fact[i] * (i + 1LL)) % mod;
}
fact_inv.resize(n);
fact_inv[n - 1] = mod_inv(fact[n - 1], mod);
for (int i = n - 1; i > 0; i--) {
fact_inv[i - 1] = fact_inv[i] * i % mod;
}
}
};
long long popcount(long long x) {
x = (x & 0x5555555555555555) + (x >> 1 & 0x5555555555555555);
x = (x & 0x3333333333333333) + (x >> 2 & 0x3333333333333333);
x = (x & 0x0F0F0F0F0F0F0F0F) + (x >> 4 & 0x0F0F0F0F0F0F0F0F);
x = (x & 0x00FF00FF00FF00FF) + (x >> 8 & 0x00FF00FF00FF00FF);
x = (x & 0x0000FFFF0000FFFF) + (x >> 16 & 0x0000FFFF0000FFFF);
x = (x & 0x00000000FFFFFFFF) + (x >> 32 & 0x00000000FFFFFFFF);
return x;
}
void solve() {}
int main() {
ios::sync_with_stdio(false);
std::cin.tie(0);
std::cout.tie(0);
long long n;
cin >> n;
vector<long long> a(n / 2);
for (long long(i) = (long long)(0); i < (long long)(n / 2); i++) cin >> a[i];
sort((a).begin(), (a).end());
long long ans = INF;
long long odd = 0, even = 0;
for (long long(i) = (long long)(0); i < (long long)(n / 2); i++) {
odd += abs(a[i] - 2 * i - 1);
even += abs(a[i] - 2 * i - 2);
}
cout << min(odd, even) << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 11;
const int MAXC = 2e5 + 10;
const int MAXM = 1e5 + 10;
const int Mod = 1e9 + 7;
const int base = 233 + rand();
inline void chk_mx(int &x, int y) {
if (x < y) x = y;
}
int n, m;
int c[MAXN];
int a[MAXN][MAXC];
inline int get_hsh(vector<int> tmp) {
int res = 0;
for (int i = 1; i <= n; i++) res = ((long long)res * base + tmp[i]) % Mod;
return res;
}
inline void get_val(vector<int> &tmp) {
int sum = 0;
for (int i = 1; i <= n; i++) sum += a[i][tmp[i]];
tmp[0] = -sum;
}
void solve() {
scanf("%d", &n);
static vector<int> Mx_pos;
Mx_pos.resize(n + 1);
for (int i = 1; i <= n; i++) {
scanf("%d", &c[i]);
for (int j = 1; j <= c[i]; j++) scanf("%d", &a[i][j]);
Mx_pos[i] = c[i];
}
static set<vector<int> > s;
static unordered_map<int, bool> mmp;
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
vector<int> tmp;
tmp.resize(n + 1);
for (int j = 1; j <= n; j++) scanf("%d", &tmp[j]);
mmp[get_hsh(tmp)] = true;
}
s.insert(Mx_pos);
while (!s.empty()) {
vector<int> vec = *s.begin();
s.erase(s.begin());
if (!mmp[get_hsh(vec)]) {
for (int i = 1; i <= n; i++) printf("%d ", vec[i]);
return;
}
for (int i = 1; i <= n; i++) {
vec[i]--;
if (vec[i] >= 1) {
get_val(vec);
s.insert(vec);
}
vec[i]++;
}
}
assert(false);
}
int main() {
srand(time(0));
int T = 1;
while (T--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool vis[102][102][102];
double dp[102][102][102];
double FF(int rock, int scs, int pap, int idx) {
if ((!rock && !scs) || (!scs && !pap) || (!pap && !rock)) {
if (idx == 0) {
if (rock)
return 1.0;
else
return 0.0;
} else if (idx == 1) {
if (scs)
return 1.0;
else
return 0.0;
} else {
if (pap)
return 1.0;
else
return 0.0;
}
}
if (vis[rock][scs][pap]) return dp[rock][scs][pap];
double ans = 0.0, temp, x, y;
int tot = (rock + scs + pap);
int rem = (tot * (tot - 1)) / 2;
rem -= (rock * (rock - 1)) / 2;
rem -= (scs * (scs - 1)) / 2;
rem -= (pap * (pap - 1)) / 2;
y = (double)rem;
int k = 0;
if (rock && scs) {
x = (double)rock * scs;
temp = x / y;
ans += temp * FF(rock, scs - 1, pap, idx);
}
if (scs && pap) {
x = (double)scs * pap;
temp = x / y;
ans += temp * FF(rock, scs, pap - 1, idx);
}
if (pap && rock) {
x = (double)pap * rock;
temp = x / y;
ans += temp * FF(rock - 1, scs, pap, idx);
}
vis[rock][scs][pap] = 1;
return dp[rock][scs][pap] = ans;
}
int main() {
int r, s, p;
scanf("%d %d %d", &r, &s, &p);
for (int i = 0; i < 3; i++) {
if (i) printf(" ");
memset(vis, 0, sizeof(vis));
double ans = FF(r, s, p, i);
printf("%0.15lf", ans);
}
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:167767260")
const int INF = 1000000000;
using namespace std;
bool z[100001];
int pre[100001], i, j, k, l, x, d, s, a[100001], n;
int main() {
cin >> n;
a[0] = 0;
memset(pre, -1, sizeof(pre));
for (i = 1; i <= 100000; i++) {
memset(z, false, sizeof(z));
for (k = 1; k <= i; k++) {
d = i - (k * (k + 1)) / 2;
if (d < 0) break;
if (d > 0 && d % (k + 1) == 0) {
x = d / (k + 1);
s = 0;
for (l = 0; l <= k; l++) {
s = s ^ a[l + x];
}
if (s == 0 && pre[i] == -1) pre[i] = k + 1;
if (s <= 100000) z[s] = true;
}
}
l = 0;
while (z[l] == true) l++;
a[i] = l;
}
if (a[n] == 0)
cout << "-1" << endl;
else
cout << pre[n] << endl;
}
| 6 |
/*
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/priority_queue.hpp>
using namespace __gnu_pbds;
__gnu_pbds::priority_queue<int, less<int>> pq;
gp_hash_table<int, int> mp;
*/
/** Begin fast allocation */
/*
const int mx_MEM = 10 * 1e7;
int mpos = 0;
char mem[mx_MEM];
inline void *operator new(size_t n) {
assert((mpos += n) <= mx_MEM);
return (void *) (mem + mpos - n);
}
inline void operator delete(void *) noexcept {} // must have!
*/
/** End fast allocation */
/** Pragmas */
// mt19937 gen(2281337);
//#pragma GCC optimize("O3", "Ofast", "unroll-loops", "unswitch-loops", "fast-math", "no-stack-protector")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,sse4.1,sse4.2,abm,mmx,avx")
// sse,sse2,sse3,ssse3,sse4,sse4.1,sse4.2,abm,mmx,
//#pragma comment(linker, "/STACK:66777216")
/*
* @author kamil.sharipov
*/
#include <bits/stdc++.h>
//#define int long long
#define all(x) (x).begin(), (x).end()
#define fo(i, a, b) for (int i = a; i < b; ++i)
#define ll long long
#define pii pair<int, int>
using namespace std;
signed main() {
#ifdef _LOCAL
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int t;
cin >> t;
for (int i = 0; i < t; ++i) {
ll n;
cin >> n;
vector<ll> a(n);
ll sm = 0;
ll mx = 0;
for (int j = 0; j < n; ++j) {
cin >> a[j];
sm += a[j];
mx = max(mx, a[j]);
}
if (mx * (n - 1) >= sm) {
cout << mx * (n - 1) - sm;
} else {
cout << (n - 1 - sm % (n - 1)) % (n - 1);
}
cout << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class A, class B>
A cvt(B x) {
stringstream ss;
ss << x;
A y;
ss >> y;
return y;
}
int n;
int d[1 << 16], x[1 << 16];
int main() {
scanf("%d", &n);
queue<int> q;
for (int i = 0; i < (n); i++) {
scanf("%d %d", &d[i], &x[i]);
if (d[i] == 1) q.push(i);
}
vector<pair<int, int> > f;
while (!q.empty()) {
int i = q.front();
q.pop();
if (d[i] != 1) continue;
int j = x[i];
f.push_back({i, j});
x[j] ^= i;
d[j]--;
if (d[j] == 1) q.push(j);
}
printf("%d\n", f.size());
for (auto ij : f) {
printf("%d %d\n", ij.first, ij.second);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline bool qu(const long long l, const long long r) {
cout << l << ' ' << r << endl;
string in;
cin >> in;
if (in[0] == 'Y') {
if (l == r) exit(0);
return true;
}
return false;
}
int main() {
srand(time(0));
long long n, k;
cin >> n >> k;
long long l = 1, r = n;
while (1) {
if (r - l + 1 <= 50) {
int x = rand() % (r - l + 1);
qu(l + x, l + x);
} else {
long long m = (l + r) / 2;
qu(l, m) ? r = m : l = m + 1;
}
l = max(1ll, l - k);
r = min(n, r + k);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 + 10;
int vis[N], pi[N], cnt, ans[N];
bool prime[N];
struct node {
int val, id;
bool operator<(const node &rh) const { return val > rh.val; }
} arr[30];
int main() {
memset(prime, 1, sizeof(prime));
for (int i = 2; i <= sqrt(N); ++i)
if (prime[i]) {
for (int j = i + i; j <= N; j += i + i) prime[j] = false;
}
for (int i = 2; i <= N; ++i)
if (prime[i]) pi[cnt++] = i;
char s[1111];
int num[111];
while (scanf("%s", s) != EOF) {
memset(num, 0, sizeof(num));
memset(vis, 0, sizeof(vis));
memset(ans, 0, sizeof(ans));
int len = strlen(s);
int q, all = 0;
bool ok;
for (int i = 0; pi[i] <= len; ++i) {
ok = false;
for (int j = 1; j <= len / pi[i]; ++j) {
if (ans[pi[i] * j]) {
ok = true;
q = ans[pi[i] * j];
break;
}
}
if (ok) {
for (int j = 1; j <= len / pi[i]; ++j) {
if (!ans[pi[i] * j]) {
ans[pi[i] * j] = q;
num[q]++;
}
}
} else {
++all;
for (int j = 1; j <= len / pi[i]; ++j) {
if (!ans[pi[i] * j]) {
ans[pi[i] * j] = all;
num[all]++;
}
}
}
}
for (int i = 0; s[i] != '\0'; ++i) vis[s[i] - 'a']++;
int m = 0;
for (int i = 0; i < 26; ++i)
if (vis[i]) {
arr[m].val = vis[i];
arr[m++].id = i;
}
char ss[1111];
ok = true;
for (int i = 1; i <= all; ++i) {
sort(arr, arr + m);
if (arr[0].val < num[i]) {
ok = false;
break;
}
for (int j = 0; j <= len; ++j)
if (ans[j] == i) {
ss[j] = arr[0].id + 'a';
arr[0].val--;
vis[arr[0].id]--;
}
}
if (ok) {
for (int i = 1; i <= len; ++i)
if (ans[i] == 0) {
for (int j = 0; j < 26; ++j)
if (vis[j]) {
vis[j]--;
ss[i] = j + 'a';
break;
}
}
ss[len + 1] = '\0';
puts("YES");
puts(&ss[1]);
} else
puts("NO");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2e5 + 7;
int head[inf], cnt = 0;
struct node {
int from, to;
int nxt;
} arr[2 * inf];
int ans[inf];
void addedge(int a, int b) {
arr[cnt].from = a;
arr[cnt].to = b;
arr[cnt].nxt = head[a];
head[a] = cnt++;
}
int main() {
memset(head, -1, sizeof(head));
int n;
int a, b, aa, bb;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d", &a, &b);
if (i == 0) aa = a, bb = b;
addedge(a, b);
addedge(b, a);
}
int one = 1, flag = 0;
int thenow = 2e5 + 7;
int p = 0;
while (one != 1 || flag == 0) {
flag = 1;
ans[p++] = one;
for (int i = head[one]; i != -1; i = arr[i].nxt) {
int to1 = arr[i].to;
if (to1 != thenow) {
thenow = one;
one = to1;
goto x;
}
}
x:;
}
if (ans[1] == aa || ans[2] == aa) {
for (int i = 0; i < n; i++) printf("%d ", ans[i]);
printf("\n");
} else {
for (int i = n - 1; i >= 0; i--) printf("%d ", ans[i]);
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, n, min = 1000000, x, y;
cin >> n;
d = sqrt(n);
if (n == 0) {
cout << "0"
<< " "
<< "0" << endl;
} else {
for (int i = 1; i <= d; i++) {
if (n % i == 0) {
b = n / i;
c = b - i;
if (b >= i) {
if (c <= min) {
min = c;
x = i;
y = b;
}
} else {
break;
}
}
}
cout << x << " " << y << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, ans = 0, x, y;
scanf("%lld%lld", &a, &b);
x = a;
y = b;
while (true) {
ans += x / y;
x = x % y;
if (x == 0) break;
if (x < y) swap(x, y);
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string s;
int m;
vector<int> ans;
bool check(int cl, int b, int turn) {
if (turn == m) return true;
for (int i = 1; i <= 10; i++)
if (s[i] == '1' && i > cl && i != b)
if (check(i - cl, i, turn + 1)) {
ans.push_back(i);
return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie();
cin >> s;
cin >> m;
s = ' ' + s;
if (check(0, 0, 0)) {
cout << "YES\n";
for (int i = ans.size() - 1; i > -1; i--) cout << ans[i] << ' ';
} else
cout << "NO\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
template <class T>
bool scanff(T &ret) {
char c;
int sgn;
T bit = 0.1;
if (c = getchar(), c == EOF) return 0;
while (c != '-' && c != '.' && (c < '0' || c > '9')) c = getchar();
sgn = (c == '-') ? -1 : 1;
ret = (c == '-') ? 0 : (c - '0');
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c - '0');
if (c == ' ' || c == '\n') {
ret *= sgn;
return 1;
}
while (c = getchar(), c >= '0' && c <= '9') ret += (c - '0') * bit, bit /= 10;
ret *= sgn;
return 1;
}
using namespace std;
long long inv[1000500];
long long mod = 1e6 + 3;
void init(long long p) {
inv[1] = 1;
for (int i = int(2); i <= int(p - 1); i++)
inv[i] = (p - (p / i)) * inv[p % i] % p;
}
int main() {
int n, c;
init(mod);
scanff(n);
scanff(c);
if (n == 1) {
printf("%d\n", c);
} else {
long long ans = 0;
long long pre = n;
long long sd = n;
long long xd = 1;
long long num = n;
ans += pre;
for (int i = int(2); i <= int(c); i++) {
sd++;
xd++;
pre = pre * sd * inv[xd] % mod;
num += pre;
num %= mod;
ans += num;
ans %= mod;
}
printf("%lld\n", num);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 7;
void Max(int &x, int y) {
if (x < y) x = y;
}
int n, deg[N], cnt[N], Fa[N], pnt[N], dep[N], g[N], f1[N], f2[N], sum[N],
mxd[N], sxd[N], glen[N];
vector<int> tmp[N], G[N], e[N];
void dfs1(int x) {
for (int v : e[x])
if (v ^ Fa[x]) {
Fa[v] = x, dfs1(v);
if (mxd[v] + 1 > mxd[x])
sxd[x] = mxd[x], mxd[x] = mxd[v] + 1;
else if (mxd[v] + 1 > sxd[x])
sxd[x] = mxd[v] + 1;
}
}
void dfs2(int x) {
if (x ^ 1) tmp[x].push_back(glen[x]);
for (int v : e[x])
if (v ^ Fa[x])
tmp[x].push_back(mxd[v] + 1),
glen[v] = max(glen[x], mxd[v] + 1 == mxd[x] ? sxd[x] : mxd[x]) + 1,
dfs2(v);
}
void work(int x) {
sort(tmp[x].begin(), tmp[x].end());
for (int now : tmp[x]) cnt[now]++;
int sz = tmp[x].size(), las = 0;
for (int now : tmp[x])
if (now ^ las) {
Max(f1[now - 1], sz), Max(f1[now], sz - cnt[now] + 1), Max(f2[now], sz);
sz -= cnt[now], las = now;
}
for (int now : tmp[x]) cnt[now]--;
}
int maxson[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1, iE = n; i <= iE; i++) f1[i] = f2[i] = 1, maxson[i] = -1e9;
for (int i = 1, iE = n - 1; i <= iE; i++) {
int u, v;
cin >> u >> v, deg[u]++, deg[v]++, e[u].push_back(v), e[v].push_back(u);
}
dfs1(1), dfs2(1);
for (int i = 1, iE = n; i <= iE; i++) Max(f1[0], deg[i] + 1), work(i);
for (int i = 1, iE = n; i <= iE; i++)
for (int t : tmp[i]) G[t].push_back(i);
for (int i = n, iE = 1; i >= iE; i--) {
for (int t : G[i]) {
int tmp = (glen[t] >= i) + (mxd[t] + 1 >= i);
sum[t]++, Max(maxson[Fa[t]], sum[t] - tmp);
Max(f2[i], sum[t] + maxson[t]), Max(f2[i], sum[t] + sum[Fa[t]] - tmp);
}
}
for (int i = n, iE = 1; i >= iE; i--)
Max(f1[i - 1], f1[i]), Max(f2[i - 1], f2[i]);
for (int i = 1, iE = n; i <= iE; i++)
if (i % 2)
cout << f1[i / 2] << " ";
else
cout << f2[i / 2] << " ";
cout << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long INFLL = 0x3f3f3f3f3f3f3f3fLL;
const int MAXN = 180;
struct et {
int t;
et* n;
et() {}
et(int _t, et* _n) : t(_t), n(_n) {}
} * e[MAXN + 10], store[MAXN * 2 + 10], *loc = store;
int n, k;
int fa[MAXN + 10];
int d[MAXN + 10];
void build(int x) {
for (et* i = e[x]; i; i = i->n)
if (i->t != fa[x]) {
fa[i->t] = x;
build(i->t);
}
}
long long f[MAXN + 10][MAXN + 10];
int choose[MAXN + 10];
void fun(int x) {
for (et* i = e[x]; i; i = i->n)
if (i->t != fa[x]) fun(i->t);
f[x][0] = INFLL;
for (int i = 1; i <= n; i++) {
int p = i;
while (p && p != x) p = fa[p];
if (!p) continue;
int dist = 0, prev = -1;
long long tmp = 0;
for (p = i; p != fa[x]; p = fa[p]) {
tmp += !dist ? k : d[dist];
for (et* j = e[p]; j; j = j->n)
if (j->t != fa[p] && j->t != prev) tmp += f[j->t][min(dist + 1, n - 1)];
prev = p;
dist++;
}
if (tmp < f[x][0]) {
choose[x] = i;
f[x][0] = tmp;
}
}
for (int i = 1; i < n; i++) {
long long tmp = d[i];
for (et* j = e[x]; j; j = j->n)
if (j->t != fa[x]) tmp += f[j->t][i + 1];
f[x][i] = min(f[x][0], tmp);
}
}
int ans[MAXN + 10];
void findAns(int x, int dist, int center) {
if (f[x][dist] == f[x][0]) {
int dst = 0, prev = -1;
for (int i = choose[x]; i != fa[x]; i = fa[i]) {
ans[i] = choose[x];
for (et* j = e[i]; j; j = j->n)
if (j->t != fa[i] && j->t != prev)
findAns(j->t, min(dst + 1, n - 1), choose[x]);
prev = i;
dst++;
}
} else {
ans[x] = center;
for (et* i = e[x]; i; i = i->n)
if (i->t != fa[x]) findAns(i->t, dist + 1, center);
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) scanf("%d", &d[i]);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
e[x] = new (loc++) et(y, e[x]);
e[y] = new (loc++) et(x, e[y]);
}
build(1);
fun(1);
cout << f[1][0] << endl;
findAns(1, 0, -1);
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int arr[n];
int want = n;
int found = 0;
int came = 0;
int f[N] = {};
cout << 1 << " ";
for (int i = 0; i < n; i++) {
int x;
cin >> x;
came++;
f[x] = 1;
if (x == want) {
int c = 0;
while (f[want] == 1 && want >= 1) {
want--;
found++;
}
}
cout << came - found + 1 << " ";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double pi = atan2(0.0, -1.0);
class Global {
public:
int bin_search(const vector<pair<int, int>>& mas, int x) {
size_t n = mas.size();
int middle, left, right;
int answer;
left = 0, right = n;
while (right - left > 1) {
middle = (right - left) / 2 + left;
if (mas[middle].first > x)
right = middle;
else
left = middle;
}
answer = left;
return answer;
}
int i, j, n, m, answer;
void solve() {
cin >> n >> m;
vector<int> a(n), sum(m);
vector<pair<int, int>> b(m);
for (auto& it : a) cin >> it;
for (auto& it : b) cin >> it.first >> it.second;
sort(b.begin(), b.end());
for (i = 0; i < m; ++i) {
if (i) sum[i] = sum[i - 1];
sum[i] += b[i].second;
}
for (const auto& it : a) {
i = bin_search(b, it);
if (b[i].first > it)
cout << "0 ";
else
cout << sum[i] << " ";
}
}
void head() {
int t = 1;
for (; t--;) {
solve();
}
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
vector<Global> global;
global.clear();
global.resize(1);
global[0].head();
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
int n, m;
vector<int> a;
bool chk(int c) {
int lst = a[0];
if (a[0] + c >= m) lst = 0;
for (int i = 1; i <= (n - 1); ++i) {
if (a[i] + c >= m + lst) continue;
if (a[i] < lst && a[i] + c >= lst) continue;
if (a[i] + c < lst) return false;
lst = a[i];
}
return true;
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin.exceptions(cin.failbit);
cin >> n >> m;
a.resize(n);
for (int i = 0; i < (n); ++i) cin >> a[i];
bool sorted = true;
for (int i = 0; i < (n); ++i) {
if (i != 0 && a[i - 1] > a[i]) sorted = false;
}
if (sorted) {
cout << 0 << endl;
return 0;
}
int lo = 0, hi = m, mid = (hi + lo) / 2;
while (hi - lo > 1) {
if (chk(mid))
hi = mid;
else
lo = mid;
mid = (hi + lo) / 2;
}
cout << hi << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("-O2")
using namespace std;
const int N = 2e5 + 5, MOD = 1e9 + 7;
const long double EPS = 1e-9;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int pow = 1;
vector<int> ans;
while (n) {
int rem = n % 10;
if (rem) ans.push_back(rem * pow);
n /= 10;
pow *= 10;
}
cout << ans.size();
cout << '\n';
for (auto i : ans) cout << i << ' ';
cout << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 2e6 + 5;
inline int gi() {
char c = getchar();
while (c < '0' || c > '9') c = getchar();
int sum = 0;
while ('0' <= c && c <= '9') sum = sum * 10 + c - 48, c = getchar();
return sum;
}
inline int fpow(int x, int k) {
int res = 1;
while (k) {
if (k & 1) res = (long long)res * x % mod;
k >>= 1;
x = (long long)x * x % mod;
}
return res;
}
int n, s, t;
int a[maxn], low[maxn], mx[maxn], num[maxn], vis[maxn];
void update(int p, int x) {
if (x > mx[p])
mx[p] = x, num[p] = 1;
else
num[p] += mx[p] == x;
}
int check(int x) {
for (int p, c; x > 1;) {
p = low[x];
c = 0;
while (x % p == 0) x /= p, ++c;
if (c == mx[p] && num[p] == 1) return 0;
}
return 1;
}
int main() {
n = gi();
s = 1;
for (int i = 1; i <= n; ++i) a[i] = gi();
sort(a + 1, a + n + 1);
for (int i = 2; i <= a[n]; ++i)
if (!low[i])
for (int j = i; j <= a[n]; j += i)
if (!low[j]) low[j] = i;
for (int i = n, v, x, p, c; i; --i)
if (mx[v = a[i]])
for (vis[i] = 1, x = v - 1; x > 1;
s = (long long)s * fpow(p, max(0, c - mx[p])) % mod, update(p, c)) {
p = low[x];
c = 0;
while (x % p == 0) x /= p, ++c;
}
else
update(v, 1), s = (long long)s * v % mod;
for (int i = 1; i <= n; ++i)
if ((vis[i] && check(a[i] - 1)) || (!vis[i] && check(a[i]))) t = 1;
printf("%d\n", (s + t) % mod);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int a[2010];
int main() {
int n, b;
scanf("%d %d", &n, &b);
for (int i = 0; i < n; i++) scanf("%d", a + i);
int ans = b;
int x = -1, y;
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) {
ans = max(ans, (b % a[i]) + b / a[i] * a[j]);
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 5;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
struct p {
int x, y;
} a[4];
int n, area;
char c[maxn][maxn];
char ch[] = {0, 'A', 'B', 'C'};
void show() {
cout << n << endl;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cout << c[i][j];
}
cout << endl;
}
exit(0);
}
void check(int id, int w) {
p b[2];
int cnt = 0, s = n - w;
for (int i = 1; i <= 3; i++) {
if (id != i) b[cnt++] = a[i];
}
if (b[0].x != b[1].x) {
if (b[0].y == b[1].y) {
swap(b[0].x, b[0].y);
swap(b[1].x, b[1].y);
} else if (b[0].x == b[1].y)
swap(b[1].y, b[1].x);
else if (b[1].x == b[0].y)
swap(b[0].x, b[0].y);
else
return;
}
int aa, bb;
if (id == 1)
aa = 2, bb = 3;
else if (id == 2)
aa = 1, bb = 3;
else
aa = 1, bb = 2;
if (b[0].x == n && b[0].y + b[1].y == w) {
for (int i = 1; i <= b[0].y; i++) {
for (int j = 1; j <= n; j++) c[s + i][j] = ch[aa];
}
for (int i = b[0].y + 1; i + s <= n; i++) {
for (int j = 1; j <= n; j++) c[s + i][j] = ch[bb];
}
show();
} else if (b[0].x == w && b[0].y + b[1].y == n) {
for (int i = s + 1; i <= n; i++) {
for (int j = 1; j <= b[0].y; j++) c[i][j] = ch[aa];
for (int j = b[0].y + 1; j <= n; j++) c[i][j] = ch[bb];
}
show();
}
if (b[0].y == b[1].y) {
swap(b[0].x, b[0].y);
swap(b[1].x, b[1].y);
} else
return;
if (b[0].x == n && b[0].y + b[1].y == w) {
for (int i = 1; i <= b[0].y; i++) {
for (int j = 1; j <= n; j++) c[s + i][j] = ch[aa];
}
for (int i = b[0].y + 1; i + s <= n; i++) {
for (int j = 1; j <= n; j++) c[s + i][j] = ch[bb];
}
show();
} else if (b[0].x == w && b[0].y + b[1].y == n) {
for (int i = s + 1; i <= n; i++) {
for (int j = 1; j <= b[0].y; j++) c[i][j] = ch[aa];
for (int j = b[0].y + 1; j <= n; j++) c[i][j] = ch[bb];
}
show();
}
}
int main() {
for (int i = 1; i <= 3; i++) {
cin >> a[i].x >> a[i].y;
n = max(n, max(a[i].x, a[i].y));
}
for (int i = 1; i <= 3; i++) {
if (a[i].x == n) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= a[i].y; k++) c[k][j] = ch[i];
}
check(i, n - a[i].y);
} else if (a[i].y == n) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= a[i].x; k++) c[k][j] = ch[i];
}
check(i, n - a[i].x);
}
}
puts("-1");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y, z, d;
node() {}
node(int x, int y, int z, int d) : x(x), y(y), z(z), d(d) {}
bool operator<(const node &a) const {
if (x == a.x) return y < a.y;
return x < a.x;
}
} p[600010];
int cmp(node a, node b) { return a.z < b.z; }
int cnt = 0;
queue<node> q;
node qq[4];
void add(int x, int y, int z, int d) {
if (x > y) swap(x, y);
p[cnt++] = node(x, y, z, d);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
add(x, y, z, i);
add(x, z, y, i);
add(y, z, x, i);
}
sort(p, p + cnt);
q.push(p[0]);
int mx = 0, pos1 = 0, pos2 = 0;
for (int i = 1; i <= cnt; i++)
if (p[i].x == p[i - 1].x && p[i].y == p[i - 1].y)
q.push(p[i]);
else {
memset(qq, 0, sizeof(qq));
while (!q.empty()) {
qq[0] = q.front();
sort(qq, qq + 4, cmp);
q.pop();
}
int p2 = 0;
for (int j = 2; j >= 0; j--)
if (qq[j].d != qq[j + 1].d) {
qq[3].z += qq[j].z;
p2 = qq[j].d;
break;
}
int tmp = min(qq[3].x, min(qq[3].y, qq[3].z));
if (tmp > mx) {
mx = tmp;
pos1 = qq[3].d;
pos2 = p2;
}
q.push(p[i]);
}
if (pos2 == 0)
printf("1\n%d\n", pos1);
else
printf("2\n%d %d\n", pos1, pos2);
}
| 4 |
#include <bits/stdc++.h>
const long long MOD = 1e9 + 7;
const long long MAXN = 1e6 + 1;
using namespace std;
long long readInt() {
bool minus1 = false;
long long result = 0;
char ch;
ch = getchar();
while (true) {
if (ch == '-') break;
if (ch >= '0' && ch <= '9') break;
ch = getchar();
}
if (ch == '-')
minus1 = true;
else
result = ch - '0';
while (true) {
ch = getchar();
if (ch < '0' || ch > '9') break;
result = result * 10 + (ch - '0');
}
if (minus1)
return -result;
else
return result;
}
const int N = 5005;
int usti[N];
int asti[N];
int onni[N];
int soli[N];
int USTI[N];
int ASTI[N];
int ONNI[N];
int SOLI[N];
char letter[N];
int num[N][N];
char a[N][N];
int main() {
int K = 0;
int n = readInt(), m = readInt();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
if (a[i][j] != '.') {
K++;
num[i][j] = K;
letter[K] = a[i][j];
}
}
}
int tmp;
for (int i = 1; i <= n; i++) {
tmp = -1;
for (int j = 1; j <= m; j++) {
if (a[i][j] != '.') {
soli[num[i][j]] = tmp, tmp = num[i][j];
}
}
tmp = -1;
for (int j = m; j >= 1; j--) {
if (a[i][j] != '.') {
onni[num[i][j]] = tmp, tmp = num[i][j];
}
}
}
for (int j = 1; j <= m; j++) {
tmp = -1;
for (int i = 1; i <= n; i++) {
if (a[i][j] != '.') {
usti[num[i][j]] = tmp, tmp = num[i][j];
}
}
tmp = -1;
for (int i = n; i >= 1; i--) {
if (a[i][j] != '.') {
asti[num[i][j]] = tmp, tmp = num[i][j];
}
}
}
int mx = 0;
int res = 0;
for (int i = 1; i <= K; i++) {
for (int j = 1; j <= K; j++) {
SOLI[j] = soli[j], ONNI[j] = onni[j], USTI[j] = usti[j],
ASTI[j] = asti[j];
}
int cnt = 0;
for (int z = i, j; z != -1; z = j) {
if (letter[z] == 'L') j = SOLI[z];
if (letter[z] == 'R') j = ONNI[z];
if (letter[z] == 'U') j = USTI[z];
if (letter[z] == 'D') j = ASTI[z];
if (ONNI[z] != -1) SOLI[ONNI[z]] = SOLI[z];
if (SOLI[z] != -1) ONNI[SOLI[z]] = ONNI[z];
if (USTI[z] != -1) ASTI[USTI[z]] = ASTI[z];
if (ASTI[z] != -1) USTI[ASTI[z]] = USTI[z];
cnt++;
}
if (cnt > mx) mx = cnt, res = 0;
if (cnt == mx) res++;
}
cout << mx << ' ' << res;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<vector<ll>> vll;
ll gcd(ll a, ll b) { for (; b; a %= b, swap(a, b)); return a; }
int dx[4] = { 1, -1, 0, 0 };
int dy[4] = { 0, 0, 1, -1 };
const ll MOD = 1e9 + 7;
ll n;
vector<int> graph[201];
int dist[201];
int par[20][201];
ll mpow(ll a, ll n)
{
if (n == 0) return 1;
ll res = mpow(a, n / 2);
res = res * res % MOD;
if (n % 2) res = res * a % MOD;
return res;
}
int lca(int a, int b)
{
int la = dist[a], lb = dist[b];
if (la > lb)
{
swap(a, b);
swap(la, lb);
}
int d = lb - la;
for (int k = 0; k < 10; k++)
{
if (d & (1 << k))
b = par[k][b];
}
if (a == b) return a;
for (int k = 9; k >= 0; k--)
{
if (par[k][a] == par[k][b]) continue;
a = par[k][a];
b = par[k][b];
}
return par[0][a];
}
ll dp[201][201];
ll solve(int a, int b)
{
ll& ret = dp[a][b];
if (ret != -1) return ret;
if (a == 0) return ret = 0;
if (b == 0) return ret = 1;
ll res1 = solve(a - 1, b);
ll res2 = solve(a, b - 1);
return ret = (res1 + res2) % MOD * mpow(2, MOD - 2) % MOD;
}
int main(void)
{
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> n;
memset(dp, -1, sizeof dp);
for (int i = 0; i <= n; i++) for (int j = 0; j <= n; j++)
solve(i, j);
for (int i = 0; i < n - 1; i++)
{
int u, v; cin >> u >> v;
graph[u].push_back(v);
graph[v].push_back(u);
}
ll ans = 0;
for (int v = 1; v <= n; v++)
{
ll res = 0;
memset(dist, -1, sizeof dist);
dist[v] = 0; par[0][v] = v;
queue<int> q; q.push(v);
while (!q.empty())
{
int cv = q.front(); q.pop();
for (int nv : graph[cv])
{
if (dist[nv] != -1) continue;
dist[nv] = dist[cv] + 1;
par[0][nv] = cv;
q.push(nv);
}
}
for (int k = 1; k < 10; k++)
{
for (int cv = 1; cv <= n; cv++)
par[k][cv] = par[k - 1][par[k - 1][cv]];
}
for (int va = 1; va <= n; va++)
{
for (int vb = va + 1; vb <= n; vb++)
{
int ca = va, cb = vb;
int l = lca(ca, cb);
ll ta = dist[ca] - dist[l];
ll tb = dist[cb] - dist[l];
ll tmp = solve(ta, tb);
res += tmp; res %= MOD;
}
}
res *= mpow(n, MOD - 2);
res %= MOD;
ans += res;
ans %= MOD;
}
cout << ans;
} | 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline bool smin(T &a, const T &b) {
return a > b ? a = b : a;
}
template <typename T>
inline bool smax(T &a, const T &b) {
return a < b ? a = b : a;
}
const int N = (int)3e5 + 5, mod = (int)0;
int ok[N], req[N], bl[N], br[N], bm[N], xcs[N], o[N], rev[N], xl[N], xr[N],
xc[N], seg[N << 2], alone[N], val[N], ans[N], eo[N];
pair<int, int> event[N * 4];
bool by_req(int a, int b) { return req[a] < req[b]; }
bool by_xc(int a, int b) { return xc[a] < xc[b]; }
void update(int pos, int first, int v = 1, int b = 0, int e = N) {
if (b + 1 == e) {
seg[v] = max(seg[v], first);
return;
}
int m = b + e >> 1, l = v << 1, r = l | 1;
if (pos < m) {
update(pos, first, l, b, m);
} else {
update(pos, first, r, m, e);
}
seg[v] = max(seg[l], seg[r]);
}
int query(int i, int j, int v = 1, int b = 0, int e = N) {
if (i >= e || b >= j) return 0;
if (i <= b && e <= j) return seg[v];
int m = b + e >> 1, l = v << 1, r = l | 1;
return max(query(i, j, l, b, m), query(i, j, r, m, e));
}
int main() {
ios_base::sync_with_stdio(0);
int n, bud;
cin >> n >> bud;
for (int j = 0; j < n; ++j) {
cin >> xl[j] >> xr[j] >> xc[j];
o[j] = j;
xcs[j] = xc[j];
}
int q;
cin >> q;
for (int j = 0; j < q; ++j)
cin >> req[j], bl[j] = 0, br[j] = 2e9 + 1, eo[j] = j;
sort(xcs, xcs + n);
sort(o, o + n, by_xc);
sort(eo, eo + q, by_req);
int pt = 0;
for (int j = 0; j < n; ++j) rev[o[j]] = j;
memset(ok, 0, sizeof ok);
memset(seg, 0, sizeof seg);
memset(alone, 0, sizeof alone);
memset(val, 0, sizeof val);
int sz = 0, c = 0;
for (int j = 0; j < n; ++j) {
event[sz++] = make_pair(xl[j], j << 2 | 0);
event[sz++] = make_pair(xr[j], j << 2 | 1);
}
event[sz++] = make_pair((int)2e9 + 1, 2);
set<int> op;
map<pair<int, int>, int> share;
sort(event, event + sz);
int last = 0;
int res = 0, add = 0;
for (int j = 0; j < sz; ++j) {
int pos = event[j].first, t = event[j].second;
if ((int)op.size() == 1) {
int o = *(op.begin());
if (xc[o] <= bud) {
val[o] += pos - last;
alone[o] += pos - last;
res = max(res, add + val[o]);
res = max(res, alone[o] + add);
int p = rev[o];
update(p, alone[o]);
int allow_r = upper_bound(xcs, xcs + n, bud - xc[o]) - xcs;
if (p < allow_r) {
res = max(res,
alone[o] + max(query(0, p), query(p + 1, allow_r)) + add);
} else {
res = max(res, alone[o] + query(0, allow_r) + add);
}
}
} else if ((int)op.size() == 2) {
auto it = op.begin();
int first = *it, second = *(++it);
if (xc[first] + xc[second] <= bud) {
share[make_pair(first, second)] += pos - last;
int g = share[make_pair(first, second)] + alone[first] + alone[second];
res = max(res, add + g);
val[first] = max(val[first], g);
val[second] = max(val[second], g);
}
} else if ((int)op.size() == 0) {
add += pos - last;
res += pos - last;
}
while (pt < q && res >= req[eo[pt]]) {
ans[eo[pt]] = pos - (res - req[eo[pt]]);
++pt;
}
if ((t & 3) == 0) {
op.insert(t >> 2);
} else if ((t & 3) == 1) {
op.erase(t >> 2);
} else if ((t & 3) == 2) {
int id = t >> 2;
if (req[id] <= res) {
ok[id] = 1;
} else {
ok[id] = 0;
}
--c;
if (!c) break;
} else {
assert(0);
}
last = pos;
}
for (int j = 0; j < q; ++j) cout << ans[j] << '\n';
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int nxt[200010 << 1], to[200010 << 1], head[200010], cnt;
long long w[200010 << 1];
void add(int u, int v, long long w1) {
nxt[++cnt] = head[u];
to[cnt] = v;
w[cnt] = w1;
head[u] = cnt;
}
long long b[62], bt;
void insert(long long x) {
for (int i = 60; i >= 0; i--)
if ((x >> i) & 1) {
if (!b[i]) {
b[i] = x;
++bt;
return;
} else
x ^= b[i];
}
}
bool vis[200010];
long long dis[200010];
int qid[200010], tot;
void dfs(int u) {
qid[++tot] = u;
vis[u] = true;
for (int i = head[u]; i; i = nxt[i]) {
int v = to[i];
if (vis[v]) {
insert(dis[u] ^ dis[v] ^ w[i]);
continue;
}
dis[v] = dis[u] ^ w[i];
dfs(v);
}
}
void clear() {
memset(b, 0, sizeof(b));
tot = bt = 0;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
long long w;
scanf("%d%d%lld", &u, &v, &w);
add(u, v, w), add(v, u, w);
}
long long ans = 0;
for (int i = 1; i <= n; i++)
if (!vis[i]) {
clear();
dfs(i);
bt = 1ll << bt;
for (int j = 0; j <= 60; j++) {
bool have = 0;
long long res = 0;
for (int k = 0; k <= 60; k++)
if ((b[k] >> j) & 1) have = true;
if (have)
res = 1ll * tot * (tot - 1) / 2 % 1000000007 * (bt / 2 % 1000000007) %
1000000007;
else {
for (int k = 1; k <= tot; k++) res += (dis[qid[k]] >> j) & 1;
res = 1ll * bt % 1000000007 * res % 1000000007 * (tot - res) %
1000000007;
}
ans = (ans + res * ((1ll << j) % 1000000007)) % 1000000007;
}
}
printf("%lld\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int mult(int a, int b, int p = 1000000007) { return ((a % p) * (b % p)) % p; }
int multbig(int a, int b, int mod) {
if (a == 0 or b == 0) return 0;
if (a == 1 or b == 1) return (a * b) % mod;
int cur = multbig(a, b / 2, mod);
cur = (2 * cur) % mod;
if (b % 2) cur = (cur + a) % mod;
return cur;
}
int add(int a, int b, int p = 1000000007) { return (a % p + b % p) % p; }
int fpow(int n, int k, int p = 1000000007) {
int r = 1;
for (; k; k >>= 1LL) {
if (k & 1LL) r = mult(r, n, p);
n = mult(n, n, p);
}
return r;
}
int inv(int a, int p = 1000000007) { return fpow(a, p - 2, p); }
int inv_euclid(int a, int m = 1000000007) {
int m0 = m;
int y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
int q = a / m;
int t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
vector<pair<int, int>> vvv;
pair<int, int> aa[200003];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < (int)m; i++) {
int p, q;
cin >> p >> q;
if (p > q) {
swap(p, q);
}
aa[i].first = p;
aa[i].second = q;
vvv.push_back(make_pair(p, q));
}
sort(vvv.begin(), vvv.end());
int f = 0;
for (int i = 2; i <= n; i++) {
if (n % i == 0) {
int lol = n / i;
vector<pair<int, int>> vv;
for (int i = 0; i < (int)m; i++) {
int p = aa[i].first + lol;
int q = aa[i].second + lol;
if (p > n) {
p = p - n;
}
if (q > n) {
q = q - n;
}
if (p > q) {
swap(p, q);
}
vv.push_back(make_pair(p, q));
}
sort(vv.begin(), vv.end());
if (vv == vvv) {
f = 1;
break;
}
}
}
if (f) {
cout << "Yes\n";
} else
cout << "No\n";
}
| 5 |
#include<bits/stdc++.h>
#define L(i, j, k) for(int i = (j); i <= (k); i++)
#define R(i, j, k) for(int i = (j); i >= (k); i--)
#define ll long long
#define sz(a) a.size()
#define vi vector<int>
using namespace std;const int N = 307, mod = 998244353, inv2 = (mod + 1) / 2;int n, Mid, ns = 1, val[N], dep[N], dp[N][N * 2], t[N * 2];vi e[N];
void dfs(int x, int fa) {memset(dp[x], 0, sizeof(dp[x])), dp[x][dep[x] + 1 + N] = 1, dp[x][dep[x] - Mid + N] = 1;
for(const int &v : e[x]) if(v != fa) { dep[v] = dep[x] + 1, dfs(v, x); vi A, B;L(i, -N, n) if(dp[x][i + N]) A.push_back(i);
L(i, -N, n) if(dp[v][i + N]) B.push_back(i);for(const int &a : A) for(const int &b : B)
(t[(a + b - 1 <= 2 * dep[x] ? min(a, b) : max(a, b)) + N] += (ll) dp[x][a + N] * dp[v][b + N] % mod) %= mod;L(i, -N, n) dp[x][i + N] = t[i + N], t[i + N] = 0;}}
int main() {ios::sync_with_stdio(false);cin.tie(0); cout.tie(0);cin >> n;L(i, 1, n - 1) {int u, v;cin >> u >> v;e[u].push_back(v), e[v].push_back(u);}
L(i, 1, n) {Mid = i, dfs(1, 0); L(a, -N, 0) (ns += dp[1][a + N]) %= mod;}
L(i, 1, n) ns = (ll) ns * inv2 % mod;ns = (mod + n - ns) % mod, cout << ns << "\n";return 0;} | 12 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.