solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
void read(int &digit) {
digit = 0;
char c;
for (c = getchar(); (c < '0' || c > '9') && c != '-'; c = getchar())
;
bool type = false;
if (c == '-') type = true, c = getchar();
for (; c >= '0' && c <= '9'; digit = digit * 10 + c - '0', c = getchar())
;
if (type == true) digit = -digit;
}
int n, m;
const int mo = 1000000007;
int powmod(int a, int b) {
int mjy = 1;
while (b) {
if (b & 1) mjy = (1LL * mjy * a) % mo;
a = (1LL * a * a) % mo;
b >>= 1;
}
return mjy;
}
int fac[30010], _fac[30010], po[30010];
int F[20][30010];
int f[30010], g[30010], h[30010];
const long double pi = acos(-1.0);
struct Complex {
long double r, i;
Complex(long double _r = 0.0, long double _i = 0.0) { r = _r, i = _i; }
Complex operator+(Complex b) { return Complex(r + b.r, i + b.i); }
Complex operator-(Complex b) { return Complex(r - b.r, i - b.i); }
Complex operator*(Complex b) {
return Complex(r * b.r - i * b.i, r * b.i + i * b.r);
}
} a1[30010 << 2], a2[30010 << 2], b1[30010 << 2], b2[30010 << 2],
c1[30010 << 2], c2[30010 << 2], c3[30010 << 2];
int l, q;
void FFT(Complex *a, int n, int isdft) {
for (int i = 0; i < n; i++) {
int x = 0, y = i;
for (int j = 1; j < q; j++) {
x |= y & 1;
x <<= 1;
y >>= 1;
}
x |= y;
if (x > i) swap(a[x], a[i]);
}
for (int i = 2; i <= n; i <<= 1) {
Complex wn(cos(isdft * 2.0 * pi / i), sin(isdft * 2.0 * pi / i));
for (int j = 0; j < n; j += i) {
Complex w(1, 0), u, v;
for (int k = j; k < i / 2 + j; k++) {
u = a[k], v = a[k + i / 2] * w;
a[k] = u + v;
a[k + i / 2] = u - v;
w = w * wn;
}
}
}
if (isdft == -1)
for (int i = 0; i < n; i++) a[i].r /= n;
}
const int lim = 1 << 15;
void cheng(int *h, int *f, int *g) {
for (int i = 0; i <= m; i++)
a1[i] = Complex(1.0 * (f[i] / lim), 0),
a2[i] = Complex(1.0 * (f[i] % lim), 0);
for (int i = 0; i <= m; i++)
b1[i] = Complex(1.0 * (g[i] / lim), 0),
b2[i] = Complex(1.0 * (g[i] % lim), 0);
for (int i = m + 1; i < l; i++) a1[i] = a2[i] = b1[i] = b2[i] = Complex(0, 0);
FFT(a1, l, 1);
FFT(a2, l, 1);
FFT(b1, l, 1);
FFT(b2, l, 1);
for (int i = 0; i < l; i++)
c1[i] = a1[i] * b1[i], c2[i] = a1[i] * b2[i] + a2[i] * b1[i],
c3[i] = a2[i] * b2[i];
FFT(c1, l, -1);
FFT(c2, l, -1);
FFT(c3, l, -1);
for (int i = 0; i <= m; i++) {
long long x = (long long)(c3[i].r + 0.5);
long long y = (long long)(c2[i].r + 0.5);
long long z = (long long)(c1[i].r + 0.5);
x %= mo, y %= mo, z %= mo;
h[i] = (x + (y * lim)) % mo;
h[i] = (h[i] + (z * lim * lim) % mo) % mo;
}
}
int mjy[30010];
void doit(int n) {
for (int i = 1; i <= m; i++) F[0][i] = 1;
int now = 2;
for (int i = 1; now <= n; i++, now <<= 1) {
f[0] = 0;
g[0] = 0;
for (int j = 1; j <= m; j++)
f[j] = ((1LL * F[i - 1][j] * _fac[j]) % mo *
(long long)powmod(po[j], now >> 1)) %
mo;
for (int j = 1; j <= m; j++) g[j] = (1LL * F[i - 1][j] * _fac[j]) % mo;
cheng(h, f, g);
for (int j = 1; j <= m; j++) F[i][j] = (1LL * h[j] * fac[j]) % mo;
}
mjy[0] = 1;
int sum = 1;
for (int i = 0; n; i++) {
if (n & 1) {
for (int j = 0; j <= m; j++)
f[j] =
((1LL * mjy[j] * _fac[j]) % mo * (long long)powmod(po[j], po[i])) %
mo;
for (int j = 1; j <= m; j++) g[j] = (1LL * F[i][j] * _fac[j]) % mo;
g[0] = 0;
cheng(h, f, g);
for (int j = 0; j <= m; j++) mjy[j] = (1LL * h[j] * fac[j]) % mo;
}
n >>= 1;
}
}
int main() {
long long N;
cin >> N;
read(m);
if (N > m) {
printf("0\n");
return 0;
}
n = N;
l = 1, q = 0;
while (l < ((m + 1) << 1)) l <<= 1, q++;
po[0] = 1;
fac[0] = _fac[0] = 1;
for (int i = 1; i <= m; i++)
po[i] = po[i - 1] * 2 % mo, fac[i] = (1LL * fac[i - 1] * i) % mo,
_fac[i] = powmod(fac[i], mo - 2);
doit(n);
long long zxo = 0;
for (int i = 1; i <= m; i++)
zxo = (zxo + 1LL * (1LL * mjy[i] * fac[m]) % mo *
((long long)_fac[i] * _fac[m - i] % mo)) %
mo;
cout << zxo << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k = 0, n, ans = 0, b;
cin >> n;
for (int i = 1; ans <= n; i++) {
ans = ((pow(2, i) - 1) * (pow(2, i - 1)));
if (n % ans == 0) k = max(k, ans);
}
cout << k;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f, mod = 1e9 + 7, N = 3e5 + 10;
template <typename T>
inline void rd_(T &x) {
x = 0;
int f = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
x *= f;
}
int n, a[N], ans, b[N];
map<long long, bool> f;
int cal_(int x) {
for (int i = (30); i >= (0); i--)
if (x & (1 << i)) return i + 1;
return 0;
}
int main() {
rd_(n);
for (int i = (1); i <= (n); i++) {
rd_(a[i]);
b[i] = cal_(a[i]);
}
for (int l = 1, r; l < n - 1; l++) {
r = l + 1;
long long sum = 0;
while (r < n && (1 << b[l]) >= sum + a[r]) {
sum += a[r++];
if ((a[r] ^ a[l]) == sum) ans++, f[1ll * l * 114514 + r] = 1;
}
}
for (int r = 3, l; r <= n; r++) {
l = r - 1;
long long sum = 0;
while (1 < l && (1 << b[r]) >= sum + a[l]) {
sum += a[l--];
if ((a[l] ^ a[r]) == sum && !f[1ll * l * 114514 + r]) ans++;
}
}
printf("%d\n", ans);
}
| 8 |
#include <bits/stdc++.h>
int n, m;
char flag[510][510];
int cor[510][26][26], fa[510][26][26][2];
char last[510][2];
int f[510][26][26];
int main() {
int i, j, ans;
char d1, d2, d3, d4;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) scanf("%s", flag[i]);
memset(cor, 0, sizeof(cor));
for (i = 1; i <= n; i++) {
for (d1 = 'a'; d1 <= 'z'; d1++) {
for (d2 = 'a'; d2 <= 'z'; d2++)
if (d1 != d2) {
for (j = 0; j < m; j++) {
if (j % 2 == 0 && flag[i][j] != d1) cor[i][d1 - 'a'][d2 - 'a']++;
if (j % 2 == 1 && flag[i][j] != d2) cor[i][d1 - 'a'][d2 - 'a']++;
}
}
}
}
memset(f, -1, sizeof(f));
for (d1 = 'a'; d1 <= 'z'; d1++) {
for (d2 = 'a'; d2 <= 'z'; d2++)
if (d1 != d2) f[1][d1 - 'a'][d2 - 'a'] = cor[1][d1 - 'a'][d2 - 'a'];
}
for (i = 2; i <= n; i++) {
for (d1 = 'a'; d1 <= 'z'; d1++) {
for (d2 = 'a'; d2 <= 'z'; d2++)
if (d1 != d2) {
for (d3 = 'a'; d3 <= 'z'; d3++)
if (d3 != d1) {
for (d4 = 'a'; d4 <= 'z'; d4++)
if (d3 != d4 && d4 != d2)
if (f[i][d1 - 'a'][d2 - 'a'] == -1 ||
f[i - 1][d3 - 'a'][d4 - 'a'] +
cor[i][d1 - 'a'][d2 - 'a'] <
f[i][d1 - 'a'][d2 - 'a']) {
f[i][d1 - 'a'][d2 - 'a'] = f[i - 1][d3 - 'a'][d4 - 'a'] +
cor[i][d1 - 'a'][d2 - 'a'];
fa[i][d1 - 'a'][d2 - 'a'][0] = d3 - 'a';
fa[i][d1 - 'a'][d2 - 'a'][1] = d4 - 'a';
}
}
}
}
}
ans = -1;
for (d1 = 'a'; d1 <= 'z'; d1++) {
for (d2 = 'a'; d2 <= 'z'; d2++)
if (d1 != d2)
if (ans == -1 || f[n][d1 - 'a'][d2 - 'a'] < ans) {
ans = f[n][d1 - 'a'][d2 - 'a'];
last[n][0] = d1;
last[n][1] = d2;
}
}
for (i = n - 1; i > 0; i--) {
last[i][0] = fa[i + 1][last[i + 1][0] - 'a'][last[i + 1][1] - 'a'][0] + 'a';
last[i][1] = fa[i + 1][last[i + 1][0] - 'a'][last[i + 1][1] - 'a'][1] + 'a';
}
printf("%d\n", ans);
for (i = 1; i <= n; i++) {
for (j = 0; j < m; j++) printf("%c", last[i][j % 2]);
printf("\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[300000];
long long ans;
long long n;
long long k;
long long res[300000][6][2];
void dfs(int v, int p) {
for (int u : adj[v]) {
if (u != p) {
dfs(u, v);
}
}
for (int i = 0; i < k; ++i) {
for (int u : adj[v]) {
if (u != p) {
res[v][i][0] += res[u][(i - 1 + k) % k][0];
res[v][i][1] += res[u][(i - 1 + k) % k][1] + res[u][(i - 1 + k) % k][0];
}
}
}
res[v][0][0] += 1;
for (long long i = 0; i < k; ++i) {
ans += ((k - i) % k * res[v][i][0] + res[v][i][1]) / k;
}
vector<long long> acc0(k, 0);
vector<long long> acc1(k, 0);
for (int u : adj[v]) {
if (u != p) {
for (long long i = 0; i < k; ++i) {
for (long long j = 0; j < k; ++j) {
long long n0 = res[u][i][0] * acc0[j];
long long rem = (i + j + 2) % k;
long long n1 =
2 * n0 + res[u][i][1] * acc0[j] + res[u][i][0] * acc1[j];
ans += ((k - rem) % k * n0 + n1) / k;
}
}
for (int i = 0; i < k; ++i) {
acc0[i] += res[u][i][0];
acc1[i] += res[u][i][1];
}
}
}
}
int main() {
ios ::sync_with_stdio(0);
while (cin >> n >> k) {
for (int i = 0; i < n - 1; ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
adj[a].push_back(b);
adj[b].push_back(a);
}
ans = 0;
memset(res, 0, sizeof(res));
dfs(0, -1);
cout << ans << "\n";
for (int i = 0; i < n; ++i) {
adj[i].clear();
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<pair<int, int> > data;
vector<int> hasil;
int n, i, a, m, temp;
scanf("%d %d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%d", &a);
data.push_back(pair<int, int>(a, i));
}
sort(data.begin(), data.end());
temp = 0;
for (i = 0; i < n; i++) {
temp += data[i].first;
if (temp <= m)
hasil.push_back(data[i].second);
else
break;
}
m = hasil.size();
printf("%d\n", m);
for (int i = 0; i < m; i++) printf((i < m - 1 ? "%d " : "%d\n"), hasil[i]);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1500 + 10;
const int MOD = 998244353;
struct Edge {
int from, to, w;
Edge(int from, int to, int w) {
this->from = from;
this->to = to;
this->w = w;
}
};
vector<Edge> edges;
int arr[maxn][maxn];
int f[maxn * 2];
int dp[maxn * 2][maxn];
int sz[maxn * 2], e[maxn * 2];
int lch[maxn * 2], rch[maxn * 2], good[maxn * 2];
int n, rt;
int ufind(int x) { return x == f[x] ? x : f[x] = ufind(f[x]); }
void merge(int u, int v) {
sz[u] += sz[v];
e[u] += e[v];
f[v] = u;
return;
}
void dfs(int u) {
if (u <= n) {
dp[u][1] = 1;
return;
}
if (good[u]) dp[u][1] = 1;
dfs(lch[u]);
dfs(rch[u]);
for (int i = 1; i <= sz[lch[u]]; i++)
for (int j = 1; j <= sz[rch[u]]; j++)
dp[u][i + j] =
(dp[u][i + j] + (long long)dp[lch[u]][i] * dp[rch[u]][j]) % MOD;
return;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
scanf("%d", &arr[i][j]);
if (i < j) edges.emplace_back(Edge(i, j, arr[i][j]));
}
}
for (int i = 1; i <= 2 * n; i++) f[i] = i;
for (int i = 1; i <= n; i++) sz[i] = 1;
rt = n;
sort(edges.begin(), edges.end(), [](Edge a, Edge b) { return a.w < b.w; });
for (auto& tmp : edges) {
int u = tmp.from, v = tmp.to;
int fu = ufind(u), fv = ufind(v);
if (fu != fv) {
++rt;
merge(rt, fu);
merge(rt, fv);
lch[rt] = fu;
rch[rt] = fv;
}
u = ufind(u);
++e[u];
if (e[u] == sz[u] * (sz[u] - 1) / 2) good[u] = 1;
}
dfs(rt);
for (int i = 1; i <= n; i++) printf("%d%c", dp[rt][i], i == n ? '\n' : ' ');
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct tree {
int l, r;
long long minn, lazy;
};
tree t[800004];
int a[200001];
int temp, n, m, i, l, r, s;
void pushdown(int id) {
long long temp = t[id].lazy;
int l = id * 2, r = id * 2 + 1;
t[l].lazy += temp;
t[r].lazy += temp;
t[l].minn += temp;
t[r].minn += temp;
t[id].lazy = 0;
}
void buildtree(int id, int l, int r) {
if (l == r) {
t[id].l = l;
t[id].r = r;
t[id].minn = a[l];
t[id].lazy = 0;
} else {
int mid = (l + r) / 2;
t[id].l = l;
t[id].r = r;
t[id].lazy = 0;
buildtree(id * 2, l, mid);
buildtree(id * 2 + 1, mid + 1, r);
t[id].minn = min(t[id * 2].minn, t[id * 2 + 1].minn);
}
}
void add(int id, int l, int r, int s) {
if ((t[id].l == l) && (t[id].r == r)) {
t[id].lazy += (long long)s;
t[id].minn += (long long)s;
} else {
int mid = (t[id].l + t[id].r) / 2;
if (t[id].lazy != 0) pushdown(id);
if (r <= mid)
add(id * 2, l, r, s);
else if (mid < l)
add(id * 2 + 1, l, r, s);
else {
add(id * 2, l, mid, s);
add(id * 2 + 1, mid + 1, r, s);
}
t[id].minn = min(t[id * 2].minn, t[id * 2 + 1].minn);
}
}
long long query(int id, int l, int r) {
if ((t[id].l == l) && (t[id].r == r)) {
return t[id].minn;
} else {
int mid = (t[id].l + t[id].r) / 2;
if (t[id].lazy != 0) pushdown(id);
if (mid < l) return query(id * 2 + 1, l, r);
if (r <= mid) return query(id * 2, l, r);
return min(query(id * 2, l, mid), query(id * 2 + 1, mid + 1, r));
}
}
int main() {
char key;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
buildtree(1, 1, n);
scanf("%d", &m);
while (m--) {
scanf("%d%d%c", &l, &r, &key);
if (l <= r) {
if (key == ' ') {
scanf("%d", &s);
add(1, l + 1, r + 1, s);
} else
printf("%I64d\n", query(1, l + 1, r + 1));
} else {
if (key == ' ') {
scanf("%d", &s);
add(1, l + 1, n, s);
add(1, 1, r + 1, s);
} else
printf("%I64d\n", min(query(1, l + 1, n), query(1, 1, r + 1)));
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> vec;
double ans = 0;
int n;
cin >> n;
vec.resize(n);
for (int i = 0; i < n; cin >> vec[i++])
;
sort(vec.rbegin(), vec.rend());
for (int i = 0; i < n; i += 2) ans += vec[i] * vec[i];
for (int i = 1; i < n; i += 2) ans -= vec[i] * vec[i];
ans *= 3.1415926536;
cout << fixed << setprecision(11) << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
(ios_base::sync_with_stdio(false), cin.tie(NULL));
long long n;
cin >> n;
if (n % 2 == 0)
cout << 0;
else
cout << 1;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
int n, m, i, j, h, x, y, v, pos, sum[200005], dp[200005], pre[200005],
idd[200005], out[200005], in[200005], scc, cntt, ss[200005], buc[200005],
dfn[200005], low[200005], loww[200005], vis[200005], ring[200005], cnt = 0;
vector<int> e[4][200005], ee[200005];
stack<int> s;
queue<int> q;
void tarjan(int p, int type) {
int i, v, h;
dfn[p] = low[p] = ++cnt;
s.push(p);
in[p] = 1;
for (i = 0; i < e[type][p].size(); i++) {
v = e[type][p][i];
if (!dfn[v]) {
tarjan(v, type);
low[p] = min(low[p], low[v]);
} else if (in[v])
low[p] = min(low[p], dfn[v]);
}
if (low[p] == dfn[p]) {
scc++;
h = s.top();
while (h != p) {
ss[h] = scc;
in[h] = 0;
buc[scc]++;
s.pop();
h = s.top();
}
buc[scc]++;
in[h] = 0;
ss[h] = scc;
s.pop();
}
}
bool find(int p, int id, int sym) {
int i, v;
if (in[p]) return false;
in[p] = 1;
for (i = 0; i < e[0][p].size(); i++) {
v = e[0][p][i];
if (v == sym) {
cntt = id - 1;
return true;
}
if (find(v, id + 1, sym)) {
vis[v] = 1;
ring[id] = v;
idd[v] = id;
return true;
}
}
return false;
}
int update(int eq, int a, int b) {
if (eq == b) return b;
if (eq == a) return a;
if (eq - a < 0 && eq - b > 0) return b;
if (eq - a > 0 && eq - b < 0) return a;
if (eq - b < eq - a) return b;
return a;
}
int dfs(int p, int id) {
int i, v;
if (loww[p] != inf) return loww[p];
loww[p] = id + 1 > cntt ? id + 1 - cntt : id + 1;
for (i = 0; i < e[0][p].size(); i++) {
v = e[0][p][i];
if (vis[v])
loww[p] = update(id, loww[p], idd[v]);
else
loww[p] = update(id, loww[p], dfs(v, id));
}
return loww[p];
}
bool verify(int p) {
int i;
for (i = 1; i <= n; i++) in[i] = dfn[i] = low[i] = ss[i] = 0;
for (i = 1; i <= scc; i++) buc[i] = 0;
cnt = scc = 0;
while (!s.empty()) s.pop();
for (i = 1; i <= n; i++)
for (j = 0; j < e[0][i].size(); j++)
if (i != p && e[0][i][j] != p) e[2][i].push_back(e[0][i][j]);
for (i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i, 2);
for (i = 1; i <= scc; i++)
if (buc[i] > 1) return false;
return true;
}
int main() {
cntt = 0;
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
e[3][x].push_back(y);
ee[y].push_back(x);
out[x]++;
}
for (i = 1; i <= n; i++)
if (out[i] == 0) q.push(i);
while (!q.empty()) {
h = q.front();
q.pop();
for (i = 0; i < ee[h].size(); i++) {
v = ee[h][i];
out[v]--;
if (out[v] == 0) q.push(v);
}
}
for (i = 1; i <= n; i++)
for (j = 0; j < e[3][i].size(); j++)
if (out[i] && out[e[3][i][j]]) e[0][i].push_back(e[3][i][j]);
for (i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i, 0);
pos = 0;
for (i = 1; i <= n; i++)
if (buc[ss[i]] > 1) {
pos = i;
break;
}
vis[pos] = 1;
ring[1] = pos;
find(pos, 2, pos);
idd[pos] = 1;
for (i = 1; i <= n; i++)
for (j = 0; j < e[0][i].size(); j++)
if (vis[i] == 0 && vis[e[0][i][j]] == 0) e[1][i].push_back(e[0][i][j]);
for (i = 1; i <= n; i++) in[i] = dfn[i] = low[i] = ss[i] = 0;
for (i = 1; i <= scc; i++) buc[i] = 0;
cnt = scc = 0;
while (!s.empty()) s.pop();
for (i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i, 1);
for (i = 1; i <= scc; i++)
if (buc[i] > 1) {
printf("-1");
return 0;
}
for (i = 1; i <= n; i++) loww[i] = inf;
for (i = 1; i <= cntt; i++) {
pos = dfs(ring[i], i);
if (pos > i) {
pre[pos]++;
pre[1]++;
pre[i + 1]--;
} else
pre[pos]++, pre[i + 1]--;
}
for (i = 1; i <= cntt; i++) {
sum[i] = sum[i - 1] + pre[i];
if (sum[i] == cntt) {
if (verify(ring[i]))
printf("%d\n", ring[i]);
else
printf("-1");
return 0;
}
}
printf("-1");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
string ask(vector<int> &d) {
cout << "?";
for (int x : d) {
cout << " " << x;
}
cout << endl;
string s;
cin >> s;
return s;
}
vector<int> distances(int n) {
vector<int> dist(n, 0);
vector<bool> done(n);
dist[0] = 0;
done[0] = true;
int k = 1;
while (k < n) {
k *= 2;
}
for (; k > 1; k /= 2) {
for (int p = 0; p < 2; p++) {
vector<int> a(n), b(n);
string c, d;
for (int u = 0; u < n; u++) {
if (done[u] && (dist[u] / k & 1) == p) {
a[u] = k / 2;
b[u] = k / 2 - 1;
}
}
c = ask(a);
d = ask(b);
for (int u = 0; u < n; u++) {
if (!done[u] && (dist[u] / k & 1) == p) {
if (c[u] == '0') {
dist[u] += k / 2;
} else if (d[u] == '0') {
dist[u] += k / 2;
done[u] = true;
}
}
}
}
}
for (int u = 0; u < n; u++) {
cerr << "dist[" << u << "] = " << dist[u] << endl;
}
return dist;
}
void answer(vector<pair<int, int>> edges) {
cout << "!" << '\n';
for (pair<int, int> e : edges) {
cout << e.first + 1 << " " << e.second + 1 << '\n';
}
fflush(stdout);
}
vector<pair<int, int>> parents(int n, vector<int> dist) {
vector<pair<int, int>> ans;
vector<vector<int>> us(3);
for (int u = 0; u < n; u++) {
us[dist[u] % 3].push_back(u);
}
for (int r = 0; r < 3; r++) {
vector<string> q;
for (int k = 0; (1 << k) < n; k++) {
vector<int> d(n);
for (int pa : us[0]) {
if (pa >> k & 1) {
d[pa] = 1;
}
}
q.push_back(ask(d));
}
for (int ch : us[1])
if (ch != 0) {
int pa = 0;
for (int k = 0; (1 << k) < n; k++) {
if (q[k][ch] == '1') {
pa += (1 << k);
}
}
ans.push_back({pa, ch});
}
swap(us[0], us[1]);
swap(us[1], us[2]);
}
return ans;
}
int main() {
int n;
cin >> n;
answer(parents(n, distances(n)));
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
long long INF = (1LL << 62);
int saw[1005];
int main() {
ios_base::sync_with_stdio(false);
int n, m, mi, ma;
cin >> n >> m >> mi >> ma;
vector<int> V;
int sawmi = 0;
int sawma = 0;
for (int i = 0; i < m; ++i) {
int x;
cin >> x;
if (x < mi || x > ma) {
cout << "Incorrect" << endl;
return 0;
}
if (x == mi) sawmi = 1;
if (x == ma) sawma = 1;
saw[x] = 1;
}
int left = n - m;
if (sawmi == 0 && left > 0) saw[mi] = 1, left--;
if (sawma == 0 && left > 0) saw[ma] = 1, left--;
if (saw[mi] == 0 || saw[ma] == 0) {
cout << "Incorrect" << endl;
return 0;
}
cout << "Correct" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 1, a = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') x = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
a = a * 10 + ch - '0';
ch = getchar();
}
return x * a;
}
const long long maxn = 2e5 + 10;
const double inf = 1e18 + 7;
long long n, k;
long long sum[maxn], t[maxn], q[maxn];
double sumA[maxn], sumB[maxn], dp[55][maxn];
double slope(long long j1, long long j2, long long p) {
if (j1 == j2) return -inf;
return (dp[p][j2] + sum[j2] * sumB[j2] - sumA[j2] - dp[p][j1] -
sum[j1] * sumB[j1] + sumA[j1]) /
(1.0 * (sum[j2] - sum[j1]));
}
signed main() {
n = read(), k = read();
for (long long i = 1; i <= n; i++) t[i] = sum[i] = read();
for (long long i = 1; i <= n; i++) sum[i] += sum[i - 1];
for (long long i = 1; i <= n; i++)
sumA[i] = 1.0 * sum[i] / t[i], sumB[i] = 1.0 / t[i];
for (long long i = 1; i <= n; i++)
sumA[i] += sumA[i - 1], sumB[i] += sumB[i - 1];
for (long long i = 1; i <= n; i++) dp[0][i] = inf;
for (long long j = 1; j <= k; j++) {
long long head = 1, tail = 1;
for (long long i = 1; i <= n; i++) {
while (head < tail && slope(q[head], q[head + 1], j - 1) < sumB[i])
head++;
dp[j][i] = dp[j - 1][q[head]] + sumA[i] - sumA[q[head]] -
sum[q[head]] * (sumB[i] - sumB[q[head]]);
while (head < tail &&
slope(q[tail - 1], i, j - 1) < slope(q[tail - 1], q[tail], j - 1))
tail--;
q[++tail] = i;
}
}
printf("%.12lf", dp[k][n]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
char ch;
bool fs;
void re(int& x) {
while (ch = getchar(), ch < 33)
;
if (ch == '-')
fs = 1, x = 0;
else
fs = 0, x = ch - 48;
while (ch = getchar(), ch > 33) x = x * 10 + ch - 48;
if (fs) x = -x;
}
using namespace std;
const double eps = 1e-7;
int n, ans;
double c, t, f[101][101][101 * 10], mxt[101], bs[101];
struct node {
int a, p;
bool operator<(const node& i) const { return a > i.a; }
} e[101];
int main() {
int T;
re(T);
bs[0] = 1;
for (int i = 1; i <= 100; ++i) bs[i] = bs[i - 1] / 0.9;
while (T--) {
re(n);
ans = 0;
scanf("%lf%lf", &c, &t);
for (int i = 1; i <= n; ++i) re(e[i].a), re(e[i].p);
sort(e + 1, e + n + 1);
for (int i = 1; i <= n; ++i) {
double tnow = t - i * 10;
if (tnow < 0) {
mxt[i] = -1e100;
continue;
}
double l = 0, r = tnow;
for (int j = 1; j <= 1000; ++j) {
double m1 = l + (r - l) / 3, m2 = r - (r - l) / 3;
if ((tnow - m1) * (1 + m1 * c) > (tnow - m2) * (1 + m2 * c))
r = m2;
else
l = m1;
}
l = (l + r) / 2;
mxt[i] = (tnow - l) * (1 + l * c);
}
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= n; ++j)
for (int k = 0; k <= 1000; ++k) f[i][j][k] = 1e100;
for (int i = 0; i <= n; ++i) f[i][0][0] = 0;
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= i; ++j)
for (int k = 0; k <= j * 10; ++k) {
f[i][j][k] = f[i - 1][j][k];
if (k >= e[i].p)
f[i][j][k] =
min(f[i][j][k], f[i - 1][j - 1][k - e[i].p] + e[i].a * bs[j]);
if (mxt[j] + eps > f[i][j][k]) ans = max(ans, k);
}
printf("%d\n", ans);
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long int t;
cin >> t;
while (t--) {
long long int a, b, i, c = 0, r = 0, flag = 0, d = 0;
cin >> a >> b;
for (i = b; i > 0; i = i / 10) {
c++;
r = i % 10;
if (r == 9) {
d++;
}
}
r = a * (c - 1);
if (d == c) {
r += a;
}
cout << r << '\n';
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, h, m;
cin >> t;
while (t--) {
cin >> h >> m;
int res = (23 - h) * 60 + (60 - m);
cout << res << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 100005;
long long n, m, S;
long long a[N], sz[N], lazy[N], ans[N], cong[N], tong[N];
void lazyup(long long b) {
if (lazy[b] != -1) {
for (long long i = b * S; i <= (b + 1) * S - 1; i++) {
a[i] = lazy[b];
ans[i] += cong[b];
tong[b] += cong[b];
}
cong[b] = 0;
lazy[b] = -1;
}
}
void upVal(long long l, long long r, long long x) {
long long b = l / S;
lazyup(b);
for (long long i = l; i <= r; i++) {
ans[i] += abs(a[i] - x);
tong[b] += abs(a[i] - x);
a[i] = x;
}
}
void upBlock(long long l, long long r, long long x) {
for (long long b = l; b <= r; b++) {
if (lazy[b] != -1) {
cong[b] += abs(lazy[b] - x);
lazy[b] = x;
} else {
lazy[b] = x;
for (long long i = b * S; i <= (b + 1) * S - 1; i++) {
ans[i] += abs(a[i] - x);
tong[b] += abs(a[i] - x);
a[i] = x;
}
cong[b] = 0;
}
}
}
void upQuery(long long l, long long r, long long x) {
long long L = l / S, R = r / S;
if (L == R)
upVal(l, r, x);
else {
if (l % S != 0) L++;
if (r % S != (S - 1)) R--;
upBlock(L, R, x);
upVal(l, L * S - 1, x);
upVal((R + 1) * S, r, x);
}
}
long long getBlock(long long l, long long r) {
long long res = 0;
for (long long b = l; b <= r; b++) {
if (lazy[b] != -1)
res += tong[b] + cong[b] * sz[b];
else
res += tong[b];
}
return res;
}
long long getVal(long long l, long long r) {
long long b = l / S, res = 0;
lazyup(b);
for (long long i = l; i <= r; i++) res += ans[i];
return res;
}
long long dapan(long long l, long long r) {
long long L = l / S, R = r / S, res = 0;
if (L == R)
res += getVal(l, r);
else {
if (l % S != 0) L++;
if (r % S != (S - 1)) R--;
res += getBlock(L, R);
res += getVal(l, L * S - 1);
res += getVal((R + 1) * S, r);
}
return res;
}
signed main() {
cin.tie(0), cout.tie(0), ios::sync_with_stdio(0);
cin >> n >> m;
S = sqrt(n) + 1;
for (long long i = 0; i < n; i++) a[i] = i + 1, sz[i / S]++, lazy[i / S] = -1;
while (m--) {
long long type, l, r, x;
cin >> type >> l >> r;
l--;
r--;
if (type == 1) {
cin >> x;
upQuery(l, r, x);
} else {
cout << dapan(l, r) << "\n";
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long inline read() {
long long num = 0, neg = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') neg = -1;
c = getchar();
}
while (isdigit(c)) {
num = (num << 3) + (num << 1) + c - '0';
c = getchar();
}
return num * neg;
}
const long long maxn = 200010, mod = 1e9 + 7, M = 1e9;
long long n, q, a[maxn], w[maxn];
struct BIT {
long long sum[maxn];
void update(long long x, long long k, long long op) {
for (long long i = x; i <= n; i += i & (-i)) {
sum[i] = sum[i] + k;
if (op) sum[i] %= mod;
}
}
long long Query(long long x, long long op) {
long long ans = 0;
for (long long i = x; i; i -= i & (-i)) {
ans = ans + sum[i];
if (op) ans %= mod;
}
return ans;
}
long long Q(long long l, long long r, long long op) {
long long ans = Query(r, op) - Query(l - 1, op);
if (op) ans = (ans + mod) % mod;
return ans;
}
} sum, cnt;
signed main() {
n = read();
q = read();
for (long long i = 1; i <= n; i++) a[i] = read();
for (long long i = 1; i <= n; i++) w[i] = read();
for (long long i = 1; i <= n; i++)
sum.update(i, w[i], 0), cnt.update(i, (a[i] - i) * w[i], 1);
for (long long i = 1; i <= q; i++) {
long long l = read(), r = read();
if (l <= 0) {
l = -l;
sum.update(l, -w[l], 0);
cnt.update(l, -(a[l] - l) * w[l], 1);
w[l] = r;
sum.update(l, w[l], 0);
cnt.update(l, (a[l] - l) * w[l], 1);
} else {
if (l == r) {
cout << 0 << endl;
continue;
}
long long L = l, R = r, ans = 0, res;
while (L <= R) {
long long mid = L + R >> 1;
if (sum.Q(l, mid, 0) >= sum.Q(mid + 1, r, 0))
res = mid, R = mid - 1;
else
L = mid + 1;
}
L = res;
ans = (sum.Q(l, L, 1) % mod * (a[L] - L) % mod - cnt.Q(l, L, 1) % mod +
mod) %
mod;
ans = ((ans + cnt.Q(L, r, 1) % mod) % mod -
sum.Q(L, r, 1) % mod * (a[L] - L) % mod + mod) %
mod;
cout << (ans + mod) % mod << endl;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 5;
int n, m, f[maxn][maxn], ans[maxn][maxn], a[maxn][maxn];
bool p1, p2, flag;
bool solve(int n, int m) {
int a, b, c, d;
for (a = 1; a <= 4; a++)
for (b = a + 1; b <= 4; b++) {
flag = true;
for (c = 1; c <= 4; c++)
if (a != c && b != c) break;
d = 1 + 2 + 3 + 4 - a - b - c;
for (int i = 1; i <= n; i++) {
p1 = p2 = true;
if (i % 2 == 1) {
for (int j = 1; j <= m; j++)
if (j % 2 == 1 && f[i][j] != 0) {
if (f[i][j] != a) p1 = false;
if (f[i][j] != b) p2 = false;
} else if (j % 2 == 0 && f[i][j] != 0) {
if (f[i][j] != b) p1 = false;
if (f[i][j] != a) p2 = false;
}
} else {
for (int j = 1; j <= m; j++)
if (j % 2 == 1 && f[i][j] != 0) {
if (f[i][j] != c) p1 = false;
if (f[i][j] != d) p2 = false;
} else if (j % 2 == 0 && f[i][j] != 0) {
if (f[i][j] != d) p1 = false;
if (f[i][j] != c) p2 = false;
}
}
if ((!p1) && (!p2)) flag = false;
}
if (flag) {
for (int i = 1; i <= n; i++) {
p1 = p2 = true;
if (i % 2 == 1) {
for (int j = 1; j <= m; j++)
if (j % 2 == 1 && f[i][j] != 0) {
if (f[i][j] != a) p1 = false;
if (f[i][j] != b) p2 = false;
} else if (j % 2 == 0 && f[i][j] != 0) {
if (f[i][j] != b) p1 = false;
if (f[i][j] != a) p2 = false;
}
} else {
for (int j = 1; j <= m; j++)
if (j % 2 == 1 && f[i][j] != 0) {
if (f[i][j] != c) p1 = false;
if (f[i][j] != d) p2 = false;
} else if (j % 2 == 0 && f[i][j] != 0) {
if (f[i][j] != d) p1 = false;
if (f[i][j] != c) p2 = false;
}
}
if (i % 2 == 1) {
for (int j = 1; j <= m; j++)
if (j % 2 == 1)
ans[i][j] = p1 ? a : b;
else
ans[i][j] = p1 ? b : a;
} else {
for (int j = 1; j <= m; j++)
if (j % 2 == 1)
ans[i][j] = p1 ? c : d;
else
ans[i][j] = p1 ? d : c;
}
}
return true;
}
}
return false;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
scanf("%1d", &f[i][j]);
a[j][i] = f[i][j];
}
if (solve(n, m)) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) printf("%d", ans[i][j]);
puts("");
}
return 0;
}
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++) f[i][j] = a[i][j];
if (solve(m, n)) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) printf("%d", ans[j][i]);
puts("");
}
return 0;
}
puts("0");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int32_t main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int t;
cin >> t;
for (long long int i = 0; i < t; i++) {
long long int a, b;
cin >> a >> b;
long long int sum = 0;
while (b != 0) {
if (a == b) {
sum += a;
b = 0;
} else if (b % a == 0) {
sum += a * (b / a) * (b / a);
b = 0;
} else {
sum += (b / a + 1) * (b / a + 1);
b = b - (b / a + 1);
a = a - 1;
}
}
cout << sum << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1024;
const long long INF = 1e18;
int N, M;
long long rare[MAXN][MAXN];
long long row[MAXN], col[MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0), cout.precision(15);
cin >> N >> M;
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
cin >> rare[i][j];
row[i] += rare[i][j];
col[j] += rare[i][j];
}
}
long long xc = INF, bx = -1;
for (int x = 0; x <= N; x++) {
long long mc = 0;
for (int r = 0; r < N; r++) {
long long d = 4 * abs(x - r);
if (r < x)
d -= 2;
else
d += 2;
mc += d * d * row[r];
}
if (mc < xc) {
xc = mc;
bx = x;
}
}
long long yc = INF, by = -1;
for (int y = 0; y <= M; y++) {
long long mc = 0;
for (int c = 0; c < M; c++) {
long long d = 4 * abs(y - c);
if (c < y)
d -= 2;
else
d += 2;
mc += d * d * col[c];
}
if (mc < yc) {
yc = mc;
by = y;
}
}
cout << xc + yc << "\n";
cout << bx << " " << by << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
class Pattern {
public:
vector<vector<char> > V;
bool operator<(const Pattern &P) const { return V > P.V; }
};
int main() {
vector<string> s(6);
for (int i = 0; i < 6; i++) cin >> s[i];
sort((s).begin(), (s).end());
Pattern ANS;
bool first = false;
do {
if (s[0].length() + s[5].length() - 1 != s[3].length()) continue;
if (s[1].length() + s[4].length() - 1 != s[2].length()) continue;
if (s[0][0] != s[1][0]) continue;
if (s[0][s[0].length() - 1] != s[2][0]) continue;
if (s[1][s[1].length() - 1] != s[3][0]) continue;
if (s[3][s[0].length() - 1] != s[2][s[1].length() - 1]) continue;
if (s[3][s[3].length() - 1] != s[4][0]) continue;
if (s[2][s[2].length() - 1] != s[5][0]) continue;
if (s[4][s[4].length() - 1] != s[5][s[5].length() - 1]) continue;
vector<vector<char> > V(s[2].length());
for (int i = 0; i < s[2].length(); i++) {
V[i] = vector<char>(s[3].length(), '.');
V[i][s[0].length() - 1] = s[2][i];
}
for (int j = 0; j < s[3].length(); j++) {
if (j < s[0].length()) V[0][j] = s[0][j];
}
for (int j = 0; j < s[3].length(); j++) {
V[s[1].length() - 1][j] = s[3][j];
}
for (int i = 0; i < s[1].length(); i++) {
V[i][0] = s[1][i];
}
for (int i = 0; i < s[2].length(); i++) {
if (i >= s[1].length() - 1) {
V[i][s[3].length() - 1] = s[4][i - s[1].length() + 1];
}
}
for (int i = s[0].length(); i < s[3].length(); i++) {
V[s[2].length() - 1][i] = s[5][i - s[0].length() + 1];
}
Pattern p;
p.V = V;
if (!first)
ANS = p;
else
ANS = max(p, ANS);
first = true;
} while (next_permutation((s).begin(), (s).end()));
if (!first) {
cout << "Impossible" << endl;
return 0;
}
Pattern p = ANS;
for (int i = 0; i < p.V.size(); i++) {
for (int j = 0; j < p.V[i].size(); j++) {
cout << p.V[i][j];
}
cout << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(NULL);
cin.tie(0);
cout.tie(0);
}
void online_judge() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
const int flag_max = 0x3f3f3f3f;
const long long OO = 1e9 + 9;
const double EPS = (1e-7);
int dcmp(double x, double y) { return fabs(x - y) <= EPS ? 0 : x < y ? -1 : 1; }
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
int main() {
fast();
int testcase;
cin >> testcase;
while (testcase--) {
int n, m;
cin >> n >> m;
int firstarr[n];
int secondarr[m];
for (int i = 0; i < n; i++) {
cin >> firstarr[i];
}
for (int i = 0; i < m; i++) {
cin >> secondarr[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (firstarr[i] == secondarr[j]) {
cout << "YES\n";
cout << 1 << ' ' << firstarr[i] << '\n';
goto nex;
}
}
}
cout << "NO\n";
nex:
continue;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
cout.tie(NULL);
cin.tie(NULL);
string t, s;
cin >> s;
cin >> t;
int ts, tt;
ts = s.length() - 1;
tt = t.length() - 1;
int dem = 0;
while (ts >= 0 && tt >= 0) {
if (s[ts] != t[tt])
break;
else
dem++;
ts--;
tt--;
}
dem = s.length() + t.length() - 2 * dem;
cout << dem << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, f[100000], d[100000], q[100000], l[100000], ie[100000], oe[100000];
vector<pair<int, int> > a;
int main() {
scanf("%d", &n);
memset(d, 0, sizeof(d));
for (int i = 0; i != n; ++i) scanf("%d", f + i), d[--f[i]]++;
int hd = 0, tl = 0, lf = 0;
for (int i = 0; i != n; ++i)
if (!d[i]) q[tl++] = i, lf++;
while (hd != tl)
if (!(--d[f[q[hd++]]])) q[tl++] = f[q[hd - 1]];
memset(l, -1, sizeof(l));
int sz = 0;
for (int i = 0; i != n; ++i)
if (d[i] && l[i] == -1) {
l[ie[sz] = oe[sz] = i] = sz;
for (int j = f[i]; j != i; j = f[j]) l[j] = sz;
sz++;
}
for (int i = tl - 1; i != -1; --i) ie[l[q[i]] = l[f[q[i]]]] = q[i];
if (!lf && sz == 1)
printf("0\n");
else {
a.clear();
memset(d, 0, sizeof(d));
for (int i = 0; i != n; ++i) d[f[i]]++;
for (int i = 0; i != n; ++i)
if (!d[i] && ie[l[i]] != i) a.push_back(make_pair(oe[l[i]], i));
for (int i = 0; i != sz; ++i)
a.push_back(make_pair(oe[i], ie[(i + 1) % sz]));
printf("%d\n", a.size());
for (vector<pair<int, int> >::iterator iter = a.begin(); iter != a.end();
++iter)
printf("%d %d\n", iter->first + 1, iter->second + 1);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
int sum[710][710], a[500001];
int main() {
int q, i, op, x, y;
scanf("%d", &q);
while (q--) {
scanf("%d %d %d", &op, &x, &y);
if (op == 1) {
a[x] += y;
for (i = 1; i < 710; ++i) {
sum[i][x % i] += y;
}
} else {
if (x < 710) {
printf("%d\n", sum[x][y]);
} else {
int prin = 0;
for (i = 0; i * x + y <= 500000; ++i) {
prin += a[i * x + y];
}
printf("%d\n", prin);
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q = 0;
cin >> q;
while (q--) {
long long int s, a, b, c;
cin >> s >> a >> b >> c;
cout << (((s / c) / a) * b) + (s / c) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n & n - 1) {
cout << "NO";
} else {
cout << "YES";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c, d, e, i, j, k, l;
vector<long long> v, x;
map<long long, long long> m;
cin >> a;
string s;
cin >> s;
for (i = 0; i < s.size(); i++) {
v.push_back(s[i] - '0');
}
sort(v.begin(), v.end());
cin >> s;
for (i = 0; i < s.size(); i++) {
x.push_back(s[i] - '0');
}
sort(x.begin(), x.end());
l = 0;
for (i = 0, j = 0; i < a && j < a;) {
if (v[i] < x[j]) {
l++;
i++;
j++;
m[j] = 1;
} else
j++;
}
k = 0;
for (i = a - 1, j = a - 1; i >= 0 && j >= 0;) {
if (v[i] > x[j]) {
i--;
k++;
} else {
i--;
j--;
};
}
cout << k << "\n" << l << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t--) {
long long n;
scanf("%lld", &n);
long long life[n];
long long harm[n];
long long i, j;
for (i = 0; i < n; i++) {
scanf("%lld %lld", &life[i], &harm[i]);
}
long long need[n];
long long nsum = 0;
need[0] = life[0] - harm[n - 1];
if (need[0] >= 0) {
nsum += need[0];
}
for (i = 1; i < n; i++) {
need[i] = life[i] - harm[i - 1];
if (need[i] >= 0) {
nsum += need[i];
}
}
long long mini = 9223372036854775000, sum = 0;
for (i = 0; i < n; i++) {
sum = life[i];
sum += nsum;
if (need[i] >= 0) {
sum -= need[i];
}
mini = min(mini, sum);
}
printf("%lld\n", mini);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int res = 0;
char c;
while ((c = getchar()) < '0' || c > '9')
;
while (c >= '0' && c <= '9') res = res * 10 + c - '0', c = getchar();
return res;
}
stack<long long> num;
stack<long long> num2;
stack<char> ch;
long long calc(string& s) {
while (num.size()) num.pop();
while (num2.size()) num2.pop();
while (ch.size()) ch.pop();
int n = s.size();
bool have = 0;
int k1, k2;
for (int i = 0; i < n; i++) {
if (s[i] == '(') {
have = 1;
k1 = i;
++i;
while (s[i] != ')') {
if (s[i] == '*') {
ch.push(s[i]);
} else if (s[i] >= '0' && s[i] <= '9') {
if (ch.size() && ch.top() == '*') {
long long t1 = s[i] - '0';
long long t2 = num.top();
num.pop();
ch.pop();
num.push(t1 * t2);
} else
num.push(s[i] - '0');
}
++i;
}
k2 = i;
break;
}
}
long long tmp = 0;
while (num.size()) {
tmp += num.top();
num.pop();
}
string t = ".";
if (have) s.replace(k1, k2 - k1 + 1, t);
n = s.size();
for (int i = 0; i < n; i++) {
if (s[i] == '*')
ch.push(s[i]);
else if ((s[i] >= '0' && s[i] <= '9') || s[i] == '.') {
if (ch.size() && ch.top() == '*') {
long long t1;
if (s[i] != '.')
t1 = s[i] - '0';
else
t1 = tmp;
long long t2 = num.top();
num.pop();
ch.pop();
num.push(t1 * t2);
} else
num.push(s[i] == '.' ? tmp : s[i] - '0');
}
}
long long res = 0;
while (num.size()) {
res += num.top();
num.pop();
}
return res;
}
vector<int> vec;
int main() {
string s, t;
cin >> s;
t = s;
vec.clear();
int n = s.size();
vec.push_back(-1);
for (int i = 1; i < n; i += 2) {
if (s[i] == '*') {
vec.push_back(i);
}
}
vec.push_back(n);
n = vec.size();
long long ans = calc(s);
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
s = t;
s.insert(vec[i] + 1, 1, '(');
s.insert(vec[j] + 1, 1, ')');
ans = max(ans, calc(s));
}
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double error = 1e-15;
const double pi = 2 * acos(0);
const int maxn = (int)1e5 + 10;
const int mod = (int)1e9;
int dx[] = {0, -1, 0, +1, -1, -1, +1, +1};
int dy[] = {-1, 0, +1, 0, -1, +1, +1, -1};
int main() {
ios_base::sync_with_stdio(0);
double m, n;
double sum = 0;
double fact;
cin >> m >> n;
for (double i = 1; i <= m; i++) {
fact = pow(i / m, n) - pow((i - 1) / m, n);
sum += (i * fact);
}
cout << fixed << setprecision(12) << sum;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
long long mod = 1e9 + 7;
const int N = 100005;
map<int, int> mp;
int dp[2000005];
int main() {
int n, m;
cin >> n >> m;
int ok1 = 0, ok2 = 0;
for (int i = 1; i <= m; i++) {
int x;
scanf("%d", &x);
mp[n - x] = 1;
if (x >= n) ok1 = 1;
if (x <= n) ok2 = 1;
}
if (ok1 + ok2 != 2) {
puts("-1");
return 0;
}
vector<int> a;
for (auto x : mp) {
a.push_back(x.first);
}
int wc = 250000;
memset(dp, 0x3f, sizeof dp);
dp[wc] = 0;
int ans = INF;
for (auto x : a) {
if (x > 0)
for (int i = 0; i <= 500000; i++) {
if (i - x >= 0 && i - x <= 500000) {
dp[i] = min(dp[i], dp[i - x] + 1);
if (i == wc) {
ans = min(ans, dp[i - x] + 1);
}
}
}
else {
for (int i = 500000; i >= 0; i--) {
if (i - x >= 0 && i - x <= 500000) {
dp[i] = min(dp[i], dp[i - x] + 1);
if (i == wc) {
ans = min(ans, dp[i - x] + 1);
}
}
}
}
}
if (ans == INF) {
puts("-1");
} else {
printf("%d\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long md = 1e9 + 7;
long long a[1000005], n;
deque<long long> v[300005];
deque<pair<long long, long long>> d;
bool mark[300005];
int main() {
ios_base::sync_with_stdio(0);
memset(mark, false, sizeof(mark));
long long q, m, k, h, ans = 0, sum = 1, p, x, y;
cin >> n >> q;
for (int i = 0; i < q; ++i) {
int type;
cin >> type >> x;
if (type == 1) {
++ans;
v[x].push_back(sum);
d.push_back({sum++, x});
} else if (type == 2) {
while (!v[x].empty()) {
mark[v[x].front()] = true;
v[x].pop_front();
--ans;
}
} else {
while (d.size() and d.front().first <= x) {
int j = d.front().first;
int t = d.front().second;
d.pop_front();
if (!mark[j]) {
mark[j] = true;
v[t].pop_front();
--ans;
}
}
}
cout << ans << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
bool check(long long mid) {
long long now = k * mid - (mid - 1) * mid / 2 - mid + 1;
if (now >= n) return true;
return false;
}
int main() {
cin >> n >> k;
long long left = -1, right = k;
if (k * (k - 1) - (k - 2) * (k - 1) / 2 - k + 2 < n) {
cout << -1;
return 0;
}
while (right - left > 1) {
long long mid = right + left >> 1;
if (check(mid)) {
right = mid;
} else {
left = mid;
}
}
cout << right;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int rd() {
int k = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
k = (k << 1) + (k << 3) + c - 48;
c = getchar();
}
return k * f;
}
void wr(int x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) wr(x / 10);
putchar(x % 10 + '0');
}
const int N = 1e5 + 5;
int n, a[N], ans[N], b[N];
int gcd(int a, int b) {
if (a < 0) a = -a;
if (b < 0) b = -b;
if (a == 0) return b;
if (b == 0) return a;
int r = 0;
while (!((a & 1) || (b & 1))) {
a >>= 1;
b >>= 1;
r++;
}
int ret = 0;
while (1) {
while (!(a & 1)) a >>= 1;
while (!(b & 1)) b >>= 1;
if (a > b)
a = a - b;
else
b = b - a;
if (0 == a) {
ret = b << r;
break;
}
if (0 == b) {
ret = a << r;
break;
}
}
return ret;
}
int main() {
n = rd();
srand(time(NULL));
for (int i = 1; i <= n; i++) a[i] = rd(), b[i] = i;
long long begin_time = clock();
while (clock() - begin_time < CLOCKS_PER_SEC * 0.45) {
random_shuffle(b + 1, b + 1 + n);
int g1 = 0, g2 = 0;
for (int i = 1; i <= n; i++) {
int now = gcd(g1, a[b[i]]);
if (now ^ g1) {
g1 = now;
ans[b[i]] = 1;
} else {
g2 = gcd(g2, a[b[i]]);
ans[b[i]] = 2;
}
}
if (g1 == 1 && g2 == 1) {
puts("YES");
for (int i = 1; i <= n; i++) wr(ans[i]), putchar(' ');
return 0;
}
}
puts("NO");
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e6 + 6;
int B[N], a[N], cnt[N];
long long dp[N], f[N];
int main() {
long long n;
scanf("%lld", &n);
for (int i = 0; i < n; i++) scanf("%lld", &a[i]), cnt[a[i]]++;
sort(a, a + n);
for (int i = 1; i < N; i++) {
if (!cnt[i]) continue;
for (int j = i; j < N; j += i) {
int v = j / i;
if (i == v) {
f[j] += cnt[i] * (cnt[i] - 1);
} else {
f[j] += cnt[i] * cnt[v];
}
}
}
for (int i = 1; i < N; i++) dp[i] = dp[i - 1] + f[i];
int m;
scanf("%d", &m);
for (int i = 0; i < m; i++) {
long long p;
scanf("%lld", &p);
long long ans = 1LL * n * (n - 1) - dp[p - 1];
printf("%lld\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, p, q, av;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &p, &q);
if (p < (q - 1)) av++;
}
printf("%d", av);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100011;
long long a[N];
int main() {
ios ::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
long long left = *max_element(a, a + n);
long long right = left * 2 + 1;
long long sum = accumulate(a, a + n, 0LL);
while (left + 1 < right) {
long long mid = (left + right) / 2;
if (n * (mid - 1) - sum >= mid - 1)
right = mid;
else
left = mid;
}
cout << left << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
int arr[MAXN];
int idx[MAXN];
bool res[MAXN];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
idx[arr[i]] = i;
}
if (n == 1) {
printf("B\n");
return 0;
}
res[idx[n]] = false;
res[idx[1]] = true;
for (int i = n - 1; i > 1; i--) {
int pos = idx[i];
res[idx[i]] = false;
while (pos - i >= 0) {
pos -= i;
if (arr[pos] > i) {
if (!res[pos]) {
res[idx[i]] = true;
break;
}
}
}
if (res[idx[i]]) continue;
pos = idx[i];
while (pos + i < n) {
pos += i;
if (arr[pos] > i) {
if (!res[pos]) {
res[idx[i]] = true;
break;
}
}
}
}
for (int i = 0; i < n; i++) {
printf("%c", res[i] ? 'A' : 'B');
}
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > FR, FC;
vector<bool> VR, VC;
vector<int> QR, QC;
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
FR.resize(n);
FC.resize(m);
for (int i = 0; i < q; i++) {
int j, k;
scanf("%d%d", &j, &k);
FR[j - 1].push_back(k - 1);
FC[k - 1].push_back(j - 1);
}
if (n == 1) {
printf("%d\n", m - FR[0].size());
return 0;
}
if (m == 1) {
printf("%d\n", n - FC[0].size());
return 0;
}
int ans = -1;
VR.assign(FR.size(), false);
VC.assign(FC.size(), false);
for (int r0 = 0; r0 < FR.size(); r0++)
if (!VR[r0]) {
ans++;
VR[r0] = true;
QR.clear();
QR.push_back(r0);
while (!QR.empty()) {
QC.clear();
for (auto r : QR) {
for (auto c : FR[r])
if (!VC[c]) {
VC[c] = true;
QC.push_back(c);
}
}
QR.clear();
for (auto c : QC) {
for (auto r : FC[c])
if (!VR[r]) {
VR[r] = true;
QR.push_back(r);
}
}
}
}
for (int c0 = 0; c0 < FC.size(); c0++)
if (!VC[c0]) ans++;
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1123456;
template <typename T>
T sqr(T x) {
return x * x;
}
template <typename T>
void vout(T s) {
cout << s << endl;
exit(0);
}
long long bp(long long a, long long n) {
long long res = 1;
while (n) {
if (n % 2) res *= a;
a *= a;
n >>= 1;
}
return res;
}
vector<long long> v[MAXN], va;
string s1, s2, s3;
map<long long, long long> mp;
set<long long> s[MAXN];
char cc;
long long a1, b1, c1, i, j, n, m, k, sc, x, ans;
long long p[MAXN], N;
void update(long long x, long long val) {
for (int i = x; i <= N; i += i & -i) p[i] = max(p[i], val);
}
long long get(long long x) {
long long res = 0;
for (int i = x; i > 0; i -= i & -i) res = max(res, p[i]);
return res;
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cin >> m >> n;
N = m + 1;
vector<long long> a(n + 5), b(n + 1);
for (i = 1; i <= m; i++) {
cin >> a1 >> b1;
a[a1]++;
a[b1 + 1]--;
}
for (int i = 1; i <= n; i++) {
sc += a[i];
b[i] = sc + 1;
}
vector<long long> c(n + 1);
for (int i = 1; i <= n; i++) {
long long x = get(b[i]) + 1;
c[i] = x;
update(b[i], x);
}
for (int i = 0; i <= N; i++) p[i] = 0;
for (int i = n; i > 0; i--) {
long long x = get(b[i]);
ans = max(ans, c[i] + x);
update(b[i], x + 1);
}
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Usr {
int n;
double a, b, h;
};
bool operator<(const Usr& l, const Usr& r) {
return ((l.h == r.h) ? (l.n > r.n) : (l.h < r.h));
}
int main() {
vector<Usr> usrs;
int n;
double t1, t2, k;
cin >> n >> t1 >> t2 >> k;
usrs.resize(n);
for (int i = 0; i < n; i++) {
usrs[i].n = i + 1;
cin >> usrs[i].a >> usrs[i].b;
}
for (int i = 0; i < n; i++) {
double h1, h2;
h1 = usrs[i].a * t1 * (1.0 - k / 100.0) + usrs[i].b * t2;
h2 = usrs[i].b * t1 * (1.0 - k / 100.0) + usrs[i].a * t2;
usrs[i].h = max(h1, h2);
}
sort(usrs.rbegin(), usrs.rend());
for (int i = 0; i < n; i++) {
printf("%d %.2f\n", usrs[i].n, usrs[i].h);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> tree[1 << 18];
long long H[1 << 18], h[1 << 18];
int dp[1 << 18], pre[1 << 18];
void build(int i, int st, int en) {
tree[i] = make_pair(-1, 0);
if (st == en) return;
int mid = (st + en) >> 1, lt = i << 1, rt = lt + 1;
build(lt, st, mid);
build(rt, mid + 1, en);
return;
}
void modify(int i, int st, int en, int id, int len) {
if (st == en) {
if (tree[i].second < len) tree[i] = make_pair(id, len);
return;
}
int mid = (st + en) >> 1, lt = i << 1, rt = lt + 1;
if (h[id] <= H[mid])
modify(lt, st, mid, id, len);
else
modify(rt, mid + 1, en, id, len);
if (tree[lt].second > tree[rt].second)
tree[i] = tree[lt];
else
tree[i] = tree[rt];
return;
}
pair<int, int> query(int i, int st, int en, long long x, long long y) {
if (y < x) return make_pair(-1, 0);
if (x > H[en] || y < H[st]) return make_pair(-1, 0);
if (x <= H[st] && H[en] <= y) return tree[i];
int mid = (st + en) >> 1, lt = i << 1, rt = lt + 1;
pair<int, int> a = query(lt, st, mid, x, y);
pair<int, int> b = query(rt, mid + 1, en, x, y);
if (a.second > b.second) return a;
return b;
}
int main() {
int i, j, k, test_case, caseno = 1, n;
long long d;
scanf("%d %I64d", &n, &d);
for (i = 0; i < n; i++) {
scanf("%I64d", &h[i]);
H[i] = h[i];
}
sort(H, H + n);
int N = (unique(H, H + n) - H);
build(1, 0, N - 1);
for (i = 0; i < n; i++) {
pair<int, int> a = query(1, 0, N - 1, H[0], h[i] - d);
pair<int, int> b = query(1, 0, N - 1, h[i] + d, H[N - 1]);
if (a.second < b.second) a = b;
dp[i] = a.second + 1;
pre[i] = a.first;
modify(1, 0, N - 1, i, dp[i]);
}
int ans = 0;
for (i = 0; i < n; i++) {
if (dp[i] > dp[ans]) ans = i;
}
printf("%d\n", dp[ans]);
stack<int> s;
while (ans != -1) {
s.push(ans + 1);
ans = pre[ans];
}
printf("%d", s.top());
s.pop();
while (s.empty() == 0) {
printf(" %d", s.top());
s.pop();
}
printf("\n");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
for (int i = 2; 1ll * i * i <= n; ++i) {
if (n % i != 0) continue;
while (n % i == 0) n /= i;
if (n == 1)
cout << i << endl;
else
cout << 1 << endl;
return;
}
cout << n << endl;
}
int main() {
ios_base::sync_with_stdio(false);
int test;
test = 1;
for (int tst = 1; tst <= test; ++tst) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10;
int head[N], now;
int fa[N], ll[N], rr[N], cnt;
set<int> Q;
void init() {
memset(head, -1, sizeof(head));
memset(rr, 0, sizeof(rr));
memset(ll, 0, sizeof(ll));
memset(fa, 0, sizeof(fa));
now = 0;
cnt = 0;
}
struct Node {
int v;
int next;
} edge[N * 2];
void add(int u, int v) {
edge[cnt].v = v;
edge[cnt].next = head[u];
head[u] = cnt++;
}
void DFS(int u, int f) {
ll[u] = rr[u] = ++now;
Q.insert(now);
fa[u] = f;
for (int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].v;
if (v != f) DFS(v, u);
}
rr[u] = now;
}
int n, m, t1, t2;
int main() {
while (~scanf("%d", &n)) {
init();
for (int i = 1; i < n; i++) {
scanf("%d%d", &t1, &t2);
add(t1, t2);
add(t2, t1);
}
DFS(1, 0);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &t1, &t2);
if (t1 == 1) {
bool flag = false;
set<int>::iterator it = Q.lower_bound(ll[t2]);
if (it == Q.end() || (*it) > rr[t2]) flag = true;
Q.erase(Q.lower_bound(ll[t2]), Q.upper_bound(rr[t2]));
if (!flag && t2 != 1) Q.insert(ll[fa[t2]]);
} else if (t1 == 2) {
Q.insert(ll[t2]);
} else {
set<int>::iterator it = Q.lower_bound(ll[t2]);
if (it == Q.end() || (*it) > rr[t2])
printf("1\n");
else
printf("0\n");
}
}
}
}
| 6 |
#include <bits/stdc++.h>
int say = 0, m, n, i, j;
char area[15][15];
int ctrl(int x, int y) {
if ((x >= 1 && x <= m && y - 1 >= 1 && y - 1 <= n && area[x][y - 1] == 'P')) {
area[x][y - 1] = '.';
return 1;
}
if ((x >= 1 && x <= m && y + 1 >= 1 && y + 1 <= n && area[x][y + 1] == 'P')) {
area[x][y + 1] = '.';
return 1;
}
if ((x - 1 >= 1 && x - 1 <= m && y >= 1 && y <= n && area[x - 1][y] == 'P')) {
area[x - 1][y] = '.';
return 1;
}
if ((x + 1 >= 1 && x + 1 <= m && y >= 1 && y <= n && area[x + 1][y] == 'P')) {
area[x + 1][y] = '.';
return 1;
}
return 0;
}
int main() {
scanf("%d%d", &m, &n);
for (i = 1; i <= m; i++)
for (j = 1; j <= n; j++) scanf(" %c", &area[i][j]);
for (i = 1; i <= m; i++)
for (j = 1; j <= n; j++)
if (area[i][j] == 'W') say += ctrl(i, j);
printf("%d", say);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100 + 10;
int A[MAX_N];
int main() {
int n, d;
cin >> n >> d;
for (int i = 0; i < n; i++) {
int temp;
cin >> temp;
A[i] = temp;
}
int m;
cin >> m;
sort(A, A + n);
int ans = 0;
if (m <= n)
for (int i = 0; i < m; i++) ans += A[i];
else {
for (int i = 0; i < n; i++) ans += A[i];
for (int i = n; i < m; i++) ans -= d;
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
string b;
cin >> a >> b;
long long int t = count((a).begin(), (a).end(), '1');
if (t % 2) t++;
cout << ((count((b).begin(), (b).end(), '1') <= t) ? "YES" : "NO") << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, x;
cin >> a >> b >> x;
if (x == 1) {
for (int i = 1; i <= a; i++) cout << "0";
for (int i = 1; i <= b; i++) cout << "1";
return 0;
}
int toggle = 0;
if (a >= b)
cout << "01";
else {
cout << "10";
toggle = 1;
}
a--;
b--;
x--;
x--;
while (x-- > 0 && a && b) {
cout << toggle;
if (toggle)
b--;
else
a--;
toggle = toggle ^ 1;
}
if (toggle) {
for (int i = 1; i <= a; i++) cout << "0";
for (int i = 1; i <= b; i++) cout << "1";
} else {
for (int i = 1; i <= b; i++) cout << "1";
for (int i = 1; i <= a; i++) cout << "0";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int c[200005], mh, h[200005], cnt[200005];
int main() {
ios::sync_with_stdio(0);
int n, k;
cin >> n >> k;
int ans = 0;
for (int(i) = 0; (i) < (n); (i)++) {
cin >> h[i];
c[h[i]]++;
mh = max(mh, h[i]);
}
cnt[mh] = c[mh];
for (int i = mh - 1; i > 0; i--) {
cnt[i] = cnt[i + 1] + c[i];
}
int i = mh;
long long cur = 0, nx = 0;
while (i > 0) {
if (cnt[i] == n) {
if (cur) ans++;
break;
}
nx = cur + cnt[i];
if (nx > k) {
ans++;
cur = 0;
} else {
cur = nx;
i--;
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long dp[10][101], c[110][110];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
for (int i = 0; i < 110; i++) {
c[i][0] = 1;
c[i][i] = 1;
}
for (int i = 2; i < 110; i++) {
for (int j = 1; j < i; j++) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % 1000000007;
}
}
long long n;
cin >> n;
long long a[10], sum = 0;
for (int i = 0; i < 10; i++) {
cin >> a[i];
sum += a[i];
}
if (sum > n) {
cout << "0";
return 0;
}
long long ans = 0;
for (int ii = sum; ii <= n; ii++) {
for (int i = 0; i < 10; i++) {
for (int j = 0; j <= ii; j++) {
dp[i][j] = 0;
}
}
for (int i = a[0]; i <= ii - 1; i++) {
dp[0][i] = c[ii - 1][i];
}
long long tot = a[0];
for (int i = 1; i < 10; i++) {
tot += a[i];
for (int j = tot; j <= ii; j++) {
for (int k = a[i]; k <= j; k++) {
dp[i][j] = (dp[i][j] +
(dp[i - 1][j - k] * c[ii - (j - k)][k]) % 1000000007) %
1000000007;
}
}
}
ans = (ans + dp[9][ii]) % 1000000007;
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long dp[100010][8];
char s[100010];
int main() {
scanf("%d%d%s", &n, &m, s + 1);
for (int i = 1; i <= n; i++) s[i] -= 'a';
for (int i = 0; i < m; i++) {
int st = 0;
if (i == s[1]) st ^= 2;
if (i == s[1] || i == s[2]) st ^= 4;
dp[1][st]++;
}
for (int i = 2; i <= n; i++) {
for (int st = 0; st <= 7; st++) {
int l[4] = {max((i - 3) + (st & 1), 0), (i - 2) + ((st >> 1) & 1),
(i - 2) + ((st >> 2) & 1)};
for (int j = 0; j < m; j++) {
int l2[4] = {0, 0, 0};
for (int k = 1; k <= 3; k++) {
if (s[i - 2 + k] == j)
l2[k] = l[k - 1] + 1;
else
l2[k] = max(l2[k - 1], l[k]);
}
if (l2[1] < i - 2 || l2[2] < i - 1 || l2[3] < i - 1) continue;
int nxt =
(l2[1] - i + 2) ^ ((l2[2] - i + 1) << 1) ^ ((l2[3] - i + 1) << 2);
dp[i][nxt] += dp[i - 1][st];
}
}
}
printf("%lld\n", dp[n][0] + dp[n][1] + dp[n][4] + dp[n][5]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, i, j, t, ans = 0, k, count = 0;
string a, b;
cin >> a;
cin >> b;
n = a.length();
m = b.length();
for (i = 0; i < m; i++) {
if (b[i] == '1') count++;
}
long long dp[n + 5];
dp[0] = 0;
for (i = 0; i < n; i++) {
if (a[i] == '1')
dp[i + 1] = dp[i] + 1;
else
dp[i + 1] = dp[i];
}
for (i = m; i <= n; i++) {
if ((dp[i] - dp[i - m]) % 2 == count % 2) ans++;
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
if (n == 1) {
cout << 1;
return 0;
}
if (m - 1 < n - m) {
cout << m + 1;
} else {
cout << m - 1;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int m[n];
for (int i = 0; i < n; i++) {
cin >> m[i];
if (m[i] == 1) {
cout << "HARD";
return 0;
}
}
cout << "EASY";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, k, ind = 0, count = 0, m = 1e9;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] < m) {
m = a[i];
ind = i;
}
}
for (int i = 0; i < n; i++)
if (i != ind) count += (k - a[i]) / m;
cout << count << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int ans = 1;
for (int i = 0; i < n; ++i) ans += 4 * i;
printf("%d", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 5;
const int mod = 1e9 + 7;
template <typename T>
void gi(T &ret) {
ret = 0;
char inp = getchar();
int kl = 1;
while (inp < '0' || inp > '9') {
if (inp == '-') kl = -1;
inp = getchar();
}
while ('0' <= inp && inp <= '9')
ret = (ret << 3) + (ret << 1) + (inp - '0'), inp = getchar();
if (kl < 1) ret = -ret;
}
const int MAXN = 1e5 + 5;
int n, m, dp[MAXN][3][12], vv[3];
vector<int> adj[MAXN];
int ch[MAXN], sb[MAXN];
void dfs(int now, int par) {
ch[now] = -1;
sb[now] = -1;
int lst = -1;
for (auto nex : adj[now]) {
if (nex == par) continue;
if (lst == -1)
ch[now] = nex;
else
sb[lst] = nex;
dfs(nex, now);
lst = nex;
}
return;
}
int coba(int now, int p, int s) {
if (now == -1) {
if (s) return 0;
return 1;
}
int &ret = dp[now][p][s];
if (ret != -1) return ret;
ret = 0;
for (int k = 0; k <= 2; k++) {
if (p == 1 && k != 0) continue;
if (k == 1 && p != 0) continue;
if (k == 1 && s == 0) continue;
if (k == 1) s--;
int tb = 0;
for (int i = 0; i <= s; i++) {
tb += (1LL * coba(ch[now], k, i) * coba(sb[now], p, s - i)) % mod;
if (tb >= mod) tb -= mod;
}
tb = (1LL * tb * vv[k]) % mod;
ret += tb;
if (ret >= mod) ret -= mod;
if (k == 1) s++;
}
return ret;
}
int main() {
gi(n);
gi(m);
for (int i = 1; i < n; i++) {
int u, v;
gi(u);
gi(v);
adj[u].push_back(v);
adj[v].push_back(u);
}
int k, s;
gi(k);
gi(s);
vv[0] = k - 1;
vv[1] = 1;
vv[2] = m - k;
memset((dp), -1, sizeof((dp)));
dfs(1, -1);
int ans = 0;
for (int i = 0; i <= s; i++) {
ans += coba(1, 0, i);
if (ans >= mod) ans -= mod;
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
std::cout.precision(15);
string a, b;
cin >> a >> b;
vector<int> v;
int n = a.size(), m = b.size();
for (int i = 0; i < n; i++) {
if (a[i] == b[0]) {
int f = 0;
for (int j = 1; j < m; j++) {
if (b[j] != a[i + j]) {
f = 1;
break;
}
}
if (f == 0) v.push_back(i);
}
}
int k = v.size(), p = 0;
int j = 0;
while (j < k) {
if (j < n - 1 && v[j] + m <= v[j + 1]) {
p++;
j++;
} else if (j < n - 1 && v[j] + m > v[j + 1]) {
p++;
j = lower_bound(v.begin(), v.end(), v[j] + m) - v.begin();
} else {
p++;
j++;
}
}
cout << p;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[4];
int cmp(int x, int y) { return x > y; }
int main() {
int t;
cin >> t;
while (t--) {
int ans = 0;
cin >> a[0] >> a[1] >> a[2];
sort(a, a + 3, cmp);
if (a[0]) {
a[0]--;
ans++;
}
if (a[1]) {
a[1]--;
ans++;
}
if (a[2]) {
a[2]--;
ans++;
}
if (a[0] && a[1]) {
a[0]--, a[1]--;
ans++;
}
if (a[0] && a[2]) {
a[0]--, a[2]--;
ans++;
}
if (a[1] && a[2]) {
a[1]--, a[2]--;
ans++;
}
if (a[0] && a[1] && a[2]) {
ans++;
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int n, m, i, j, x, y, a[105];
while (~scanf("%d%d", &n, &m)) {
int t = 0;
for (i = 1; i <= m; i++) a[i] = i;
for (i = 1; i <= n; i++) {
scanf("%d%d", &x, &y);
for (j = x; j <= y; j++) {
a[j] = 0;
}
}
for (i = 1; i <= m; i++) {
if (a[i] != 0) {
t++;
}
}
if (t == 0)
printf("%d\n", t);
else {
printf("%d\n", t);
for (i = 1; i <= m; i++) {
if (a[i] != 0) printf("%d ", a[i]);
}
printf("\n");
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vll = vector<ll>;
using vii = vector<int>;
using pii = pair<int, int>;
template <typename T = vii>
using vec = vector<T>;
const ll INF = 1e18, MOD = 1e9 + 7;
const int MAX = 1e6;
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
map<int, vec<pii> > d;
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
d[w].emplace_back(--u, --v);
}
vii dp(n);
for (auto [_, V] : d) {
map<int, int> new_dp;
for (auto [u, v] : V) {
new_dp[v] = max({new_dp[v], dp[v], dp[u] + 1});
}
for (auto [i, x] : new_dp) {
dp[i] = x;
}
}
cout << *max_element(dp.begin(), dp.end()) << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n, m, a, b;
cin >> n >> m >> a >> b;
long long int sum1 = 0, sum2 = 0;
char d[n][m];
for (int i = 0; i < n; i++) {
int j = 0;
for (j = 0; j < m; j++) {
cin >> d[i][j];
}
}
for (int i = 0; i < n; i++) {
int j = 0;
for (j = 0; j < m - 1; j++) {
if (d[i][j] == '.') {
if (d[i][j + 1] == '.') {
sum1 += 2 * a;
sum2 += b;
j++;
} else {
sum1 += a;
sum2 += a;
j++;
}
}
}
if (m > 1) {
if (d[i][m - 2] == '*' || j == m - 1) {
if (d[i][m - 1] == '.') {
sum1 += a;
sum2 += a;
}
}
} else {
if (d[i][m - 1] == '.') {
sum1 += a;
sum2 += a;
}
}
}
cout << min(sum1, sum2) << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 2000000000000000000;
vector<int> primes;
void Sieve() {
const int n = 1000000;
int nNew = sqrt(n);
int marked[n / 2 + 500] = {0};
for (int i = 1; i <= (nNew - 1) / 2; i++)
for (int j = (i * (i + 1)) << 1; j <= n / 2; j = j + 2 * i + 1)
marked[j] = 1;
primes.push_back(2);
for (int i = 1; i <= n / 2; i++)
if (marked[i] == 0) primes.push_back(2 * i + 1);
}
long long int MOD(long long int a, long long int b) {
if (a > b)
return a - b;
else
return b - a;
}
long long int max3(long long int a, long long int b, long long int c) {
return max(c, max(a, b));
}
long long int min3(long long int a, long long int b, long long int c) {
return min(a, min(b, c));
}
long long int power(long long int x, long long int y) {
long long int res = 1;
x = x;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long int logg(long long int a) {
long long int x = 0;
while (a > 1) {
x++;
a /= 2;
}
return x;
}
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int main() {
long long int n;
cin >> n;
vector<long long int> a(n), b(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
long long int dif = 0;
long long int turn = 0;
long long int i = n - 1;
long long int j = n - 1;
while (1) {
if (i == -1 && j == -1) {
break;
}
if (turn == 0) {
if (i == -1) {
j--;
} else {
if (j == -1) {
dif = dif + a[i];
i--;
} else {
if (a[i] > b[j]) {
dif = dif + a[i];
i--;
} else {
j--;
}
}
}
}
if (turn == 1) {
if (j == -1) {
i--;
} else {
if (i == -1) {
dif = dif - b[j];
j--;
} else {
if (a[i] > b[j]) {
i--;
} else {
dif = dif - b[j];
j--;
}
}
}
}
turn = turn + 1;
turn = turn % 2;
}
cout << dif;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long INF_MAX = 1e18;
const long long INF_MIN = (1e18) * (-1);
const long long mod = 1e9 + 7;
const long long MOD = 998244353;
const long long N = 1e6 + 10;
void Solve() {
long long ara[5];
for (long long i = 1; i <= 3; i++) cin >> ara[i];
sort(ara + 1, ara + 4);
if (ara[1] == ara[2] && ara[3] % 2 == 0) {
cout << "YES\n";
return;
} else if (ara[2] == ara[3] && ara[1] % 2 == 0) {
cout << "YES\n";
return;
} else if (ara[1] == ara[3] && ara[2] % 2 == 0) {
cout << "YES\n";
return;
} else if (ara[1] + ara[2] == ara[3]) {
cout << "YES\n";
return;
} else {
cout << "NO\n";
return;
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long Test = 1;
cin >> Test;
while (Test--) {
Solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
namespace Debug {
template <class A, class B>
ostream &operator<<(ostream &out, pair<A, B> &p) {
out << "(" << p.first << ", " << p.second << ")";
return out;
}
template <class T>
ostream &operator<<(ostream &out, vector<T> &v) {
out << "{";
string sep;
for (T el : v) out << sep << el, sep = ", ";
out << "}";
return out;
}
void debug_out() { cerr << endl; }
template <class Head, class... Tail>
void debug_out(Head head, Tail... tail) {
cerr << ' ' << head;
debug_out(tail...);
}
} // namespace Debug
using namespace Debug;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int n;
long long p;
cin >> n >> p;
vector<pair<long long, int>> t(n);
for (auto &i : t) cin >> i.first;
for (int i = 0; i < n; i++) t[i].second = i;
long long cur_time;
vector<long long> ans(n);
set<pair<long long, int>> st;
for (auto i : t) st.insert(i);
queue<int> q;
set<int> s;
for (int i = 0; i < n; i++) {
if (q.empty() && s.empty()) cur_time = st.begin()->first;
cur_time += p;
while (!st.empty() && st.begin()->first <= cur_time) {
if (q.empty() || st.begin()->second < q.back())
q.push(st.begin()->second);
else
s.insert(st.begin()->second);
st.erase(st.begin());
}
ans[q.front()] = cur_time;
q.pop();
if (q.empty() && !s.empty()) {
q.push(*s.begin());
s.erase(s.begin());
}
}
for (auto i : ans) cout << i << ' ';
cout << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, q, a[100010], m[100010], r[100010];
struct par {
int l, r, t, v;
bool operator<(const par &B) const { return l < B.l; }
};
set<par> s;
long long sm[100010 * 20], sr[100010 * 20];
int ls[100010 * 20], rs[100010 * 20], id = 0, rt[100010];
void add_node(int from, int &to, int l, int r, int x, int pos) {
to = ++id;
sm[to] = sm[from] + ::m[pos];
sr[to] = sr[from] + ::r[pos];
if (l == r) return;
int mid = l + r >> 1;
if (x <= mid)
add_node(ls[from], ls[to], l, mid, x, pos), rs[to] = rs[from];
else
add_node(rs[from], rs[to], mid + 1, r, x, pos), ls[to] = ls[from];
}
long long askr(int now, int l, int r, int x) {
if (!now) return 0;
if (x == l) return sr[now];
int mid = l + r >> 1;
if (x <= mid)
return askr(ls[now], l, mid, x) + sr[rs[now]];
else
return askr(rs[now], mid + 1, r, x);
}
long long askm(int now, int l, int r, int x) {
if (!now) return 0;
if (x == r) return sm[now];
int mid = l + r >> 1;
if (x >= mid + 1)
return askm(rs[now], mid + 1, r, x) + sm[ls[now]];
else
return askm(ls[now], l, mid, x);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d %d %d", &a[i], &m[i], &r[i]);
s.insert((par){i, i, 0, 1});
if (r[i] && m[i])
add_node(rt[i - 1], rt[i], 0, 100010 - 10, m[i] / r[i], i);
else
rt[i] = rt[i - 1];
}
scanf("%d", &q);
for (int i = 1, t, l, r; i <= q; i++) {
scanf("%d %d %d", &t, &l, &r);
par p = *(--s.upper_bound((par){l, 0, 0, 0}));
if (p.l != l) {
s.erase(p);
s.insert((par){p.l, l - 1, p.t, p.v});
s.insert((par){l, p.r, p.t, p.v});
}
p = *(--s.upper_bound((par){r, 0, 0, 0}));
if (p.r != r) {
s.erase(p);
s.insert((par){p.l, r, p.t, p.v});
s.insert((par){r + 1, p.r, p.t, p.v});
}
long long ans = 0;
while (s.lower_bound((par){l, 0, 0, 0}) != s.end() &&
(p = *s.lower_bound((par){l, 0, 0, 0})).l <= r) {
if (p.v) {
ans += min(a[p.l] + 1ll * (t - p.t) * ::r[p.l], (long long)::m[p.l]);
} else {
if (t - p.t >= 100010 - 10) {
ans += sm[rt[p.r]] - sm[rt[p.l - 1]];
} else {
long long R = askr(rt[p.r], 0, 100010 - 10, t - p.t) -
askr(rt[p.l - 1], 0, 100010 - 10, t - p.t);
long long M = askm(rt[p.r], 0, 100010 - 10, t - p.t - 1) -
askm(rt[p.l - 1], 0, 100010 - 10, t - p.t - 1);
ans += R * (t - p.t) + M;
}
}
s.erase(p);
}
s.insert((par){l, r, t, 0});
printf("%lld\n", ans);
}
}
| 11 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
const long long INF = 1e18L + 5;
const int nax = 3e5 + 5;
struct S {
long long score;
pair<int, int> last_state;
vector<int> moves;
};
bool done[nax][2];
S dp[nax][2];
int in[nax], memo[nax];
long long rec(int n, int anything) {
if (n == 0) return 0;
assert(n >= 1);
if (done[n][anything]) return dp[n][anything].score;
done[n][anything] = true;
dp[n][anything].score = INF;
if (anything) {
rec(n, 0);
dp[n][anything] = dp[n][0];
}
auto consider = [&](vector<int> moves) {
int first = n;
for (int x : moves) first = min(first, x);
if (first < 1) return;
for (int i = first; i <= n; ++i) in[i] = memo[i];
long long cost = 0;
for (int x : moves) {
int here = min(in[x], in[x + 1]);
if (here == 0) return;
cost += here;
in[x] -= here;
in[x + 1] -= here;
}
if (!anything && in[n]) return;
for (int i = first; i < n; ++i)
if (in[i] && in[i + 1]) return;
bool ple = in[first] == 0;
cost += rec(first - 1, ple);
if (cost < dp[n][anything].score) {
dp[n][anything].score = cost;
dp[n][anything].last_state = {first - 1, ple};
dp[n][anything].moves = moves;
}
};
consider({});
for (int len = 1; len <= 4; ++len) {
vector<int> moves(len);
for (int i = 1; i <= len; ++i) moves[i - 1] = n - i;
sort(moves.begin(), moves.end());
do {
consider(moves);
} while (next_permutation(moves.begin(), moves.end()));
}
debug() << " ["
<< "n"
": "
<< (n)
<< "] "
" ["
<< "anything"
": "
<< (anything)
<< "] "
" ["
<< "dp[n][anything].score"
": "
<< (dp[n][anything].score) << "] ";
if (anything) assert(dp[n][anything].score < INF);
return dp[n][anything].score;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &in[i]);
memo[i] = in[i];
}
vector<int> moves;
rec(n, 1);
pair<int, int> p{n, 1};
while (p.first) {
for (int x : dp[p.first][p.second].moves) moves.push_back(x);
p = dp[p.first][p.second].last_state;
}
printf("%d\n", (int)moves.size());
for (int x : moves) printf("%d\n", x);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
void PLAY() {
cout << fixed << setprecision(10);
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int main() {
PLAY();
int n;
string s;
cin >> n >> s;
int cur = 0;
for (int i = 1; i < n; i++)
if (s.substr(0, i) == s.substr(i, i)) cur = i - 1;
cout << n - cur << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using pii = std::pair<int, int>;
const int N = 5e5 + 10;
inline int read() {
int x = 0, f = 0;
char ch = getchar();
while (!isdigit(ch)) f |= ch == '-', ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return f ? -x : x;
}
int a[N], b[N], vis[N], x[N], num, n;
pii dat[N << 2];
inline void upd(int k) { dat[k] = std::max(dat[k << 1], dat[k << 1 | 1]); }
inline void build(int k, int l, int r) {
if (l == r) return dat[k] = std::make_pair(b[l], l), void();
build(k << 1, l, ((l + r) >> 1)), build(k << 1 | 1, ((l + r) >> 1) + 1, r),
upd(k);
}
inline void del(int k, int l, int r, int x) {
if (x < l || r < x) return;
if (l == r) return dat[k] = std::make_pair(0, l), void();
del(k << 1, l, ((l + r) >> 1), x), del(k << 1 | 1, ((l + r) >> 1) + 1, r, x),
upd(k);
}
inline pii find(int k, int l, int r, int ql, int qr) {
if (ql > qr || ql > r || l > qr) return std::make_pair(0, 0);
if (ql <= l && r <= qr) return dat[k];
return std::max(find(k << 1, l, ((l + r) >> 1), ql, qr),
find(k << 1 | 1, ((l + r) >> 1) + 1, r, ql, qr));
}
inline void dfs(int u) {
del(1, 1, n, u), vis[u] = 1;
if (b[u] != n + 1 && !vis[b[u]]) dfs(b[u]);
while (1) {
pii tmp = find(1, 1, n, 1, a[u] - 1);
if (tmp.first <= u)
break;
else
dfs(tmp.second);
}
x[u] = ++num;
}
int main() {
n = read();
for (int i = 1; i <= n; ++i) b[i] = n + 1;
for (int i = 1; i <= n; ++i) {
a[i] = read();
if (a[i] == -1) a[i] = n + 1;
b[a[i]] = i;
}
build(1, 1, n);
for (int i = 1; i <= n; ++i)
if (!vis[i]) dfs(i);
for (int i = 1; i <= n; ++i) printf("%d ", x[i]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 + 10, M = 1e5 + 10, mod = 998244353;
const double eps = 1e-5;
int rd() {
int x = 0, w = 1;
char ch = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x * w;
}
void ad(int &x, int y) { x += y, x -= x >= mod ? mod : 0; }
int n, kk, a[N], nm[M], f[2][N];
int main() {
n = rd(), kk = rd();
for (int i = 1; i <= n; ++i) a[i] = rd();
sort(a + 1, a + n + 1);
for (int i = n; i; --i) a[i] -= a[1];
a[0] = -(1 << 30);
for (int h = 0; h <= a[n] / (kk - 1); ++h) {
int nw = 1, la = 0;
memset(f[la], 0, sizeof(f[la]));
f[la][0] = 1;
for (int i = 1; i <= kk; ++i) {
memset(f[nw], 0, sizeof(f[nw]));
int pr = 0;
for (int j = 1, z = 0; j <= n; ++j) {
while (z < j && a[j] - a[z] >= h) ad(pr, f[la][z]), ++z;
f[nw][j] = pr;
}
nw ^= 1, la ^= 1;
}
for (int j = 1; j <= n; ++j) ad(nm[h], f[la][j]);
if (!nm[h]) break;
}
int ans = 0;
for (int h = 0; h <= a[n] / (kk - 1); ++h)
ad(ans, 1ll * (nm[h] - nm[h + 1] + mod) * h % mod);
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005, mod = 1000000007;
int n, m, T, ans, fa[N];
bool q[N];
struct arr {
int x, y, w;
} a[N];
bool cmp(arr a, arr b) { return a.w > b.w; }
int fd(int x) { return fa[x] == x ? x : fa[x] = fd(fa[x]); }
int main() {
scanf("%d%d", &m, &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d%d", &a[i].x, &a[i].y, &a[i].w);
}
for (int i = 1; i <= m; i++) fa[i] = i;
sort(a + 1, a + n + 1, cmp);
for (int i = 1; i <= n; i++) {
int x = a[i].x, y = a[i].y;
x = fd(x), y = fd(y);
if (x == y) {
if (q[x]) continue;
q[x] = 1;
ans += a[i].w;
} else if (!q[x] || !q[y]) {
fa[y] = x;
q[x] = q[x] | q[y];
ans += a[i].w;
}
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long k, b, n, t;
cin >> k >> b >> n >> t;
long long now = 1, ans = 0;
for (long long i = 1; i <= n; i++) {
if (now * k + b > t) break;
now = now * k + b, ans++;
}
cout << n - ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s, t;
long long k, value[26];
vector<long long> pos[26], new_pos[26];
int main() {
cin >> s >> k;
if (k > (long long)s.size() * 1ll * (long long)(s.size() + 1) / 2)
printf("No such line.\n");
else {
for (int i = 0; i < s.size(); i++) {
value[s[i] - 'a'] += (long long)s.size() - i;
pos[s[i] - 'a'].push_back(i);
};
bool ok = true;
for (; ok;) {
ok = false;
char q = 'a';
for (int i = 0; i < 26; i++)
if (value[i] < k) {
k -= value[i];
q++;
} else {
k -= (long long)pos[i].size();
break;
};
t += q;
if (k <= 0) break;
for (int i = 0; i < 26; i++) {
new_pos[i].clear();
value[i] = 0;
};
for (int i = 0; i < pos[q - 'a'].size(); i++)
if (pos[q - 'a'][i] + 1 < s.size()) {
ok = true;
new_pos[s[pos[q - 'a'][i] + 1] - 'a'].push_back(
(long long)pos[q - 'a'][i] + 1);
value[s[pos[q - 'a'][i] + 1] - 'a'] +=
(long long)s.size() - pos[q - 'a'][i] - 1;
};
for (int i = 0; i < 26; i++) pos[i] = new_pos[i];
};
cout << t << endl;
};
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool used[111111];
long long n, a[111111], b[111111], sum;
long long nod(long long x, long long y) {
while (x && y)
if (x > y)
x %= y;
else
y %= x;
return x + y;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> b[i];
sort(b, b + n);
for (int i = n - 1; i > 0; i--) b[i] -= b[i - 1];
for (int i = 1; i <= n; i++) {
a[i - 1] = (2 * i - 1) * (n + 1 - i);
sum += a[i - 1] * b[i - 1];
}
cout << sum / nod(sum, n) << " " << n / nod(n, sum) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int Get() {
char c;
while (c = getchar(), c < '0' || c > '9')
;
int X = 0;
while (c >= '0' && c <= '9') {
X = X * 10 + c - 48;
c = getchar();
}
return X;
}
void Output(int X) {
int Len = 0, Data[10];
while (X) {
Data[Len++] = X % 10;
X /= 10;
}
if (!Len) Data[Len++] = 0;
while (Len--) putchar(Data[Len] + 48);
putchar('\n');
}
int main() {
string A, B;
cin >> A >> B;
int M = 0, N = 0;
for (int i = 0; i < A.size(); i++)
if (A[i] == '1') M++;
for (int i = 0; i < B.size(); i++)
if (B[i] == '1') N++;
if (N > (M + 1) / 2 * 2)
printf("NO\n");
else
printf("YES\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, current_value, next_value, third_value;
cin >> n;
long long int arr[5002];
for (long long int i = 1; i <= n; i++) cin >> arr[i];
long long int flag = 0;
for (long long int i = 1; i <= n; i++) {
current_value = arr[i];
next_value = arr[current_value];
third_value = arr[next_value];
if (i == third_value) {
flag = 1;
break;
}
}
if (flag == 1)
cout << "YES";
else
cout << "NO";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class TAT>
inline void read(TAT &a) {
static char cc;
static bool f;
while ((cc = getchar()) != '-' && (cc < '0' || cc > '9'))
;
if (cc == '-')
f = 1, a = 0;
else
f = 0, a = cc - '0';
while ((cc = getchar()) >= '0' && cc <= '9') a = a * 10 + cc - '0';
if (f) a = -a;
}
template <class TAT>
inline void write(TAT a) {
static char cc[27];
static int ct;
if (a == 0) {
putchar('0');
return;
}
if (a < 0) {
a = -a;
putchar('-');
}
ct = 0;
while (a) cc[++ct] = a % 10 + '0', a /= 10;
while (ct) putchar(cc[ct--]);
}
template <class TAT>
inline void Ckmin(TAT &a, const TAT &b) {
if (a > b) a = b;
}
template <class TAT>
inline void Ckmax(TAT &a, const TAT &b) {
if (a < b) a = b;
}
void begin() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
void end() {
fclose(stdin);
fclose(stdout);
}
const int maxn = 1e5 + 115;
int n, m;
int A[maxn], B[maxn];
int f[maxn][2];
void Init() {
read(m);
read(n);
for (int i = 1; i <= n; ++i) {
read(B[i]);
}
sort(B + 1, B + 1 + n);
}
bool TRY(int L) {
int m0, m1, Last, nL;
Last = -L;
while (1) {
memset(f, 0x3f, sizeof(f));
f[1][0] = f[1][1] = Last;
for (int i = 1; i < n; ++i) {
m0 = A[i + 1] - A[i] + f[i][0] - (f[i][0] <= 0);
m1 = A[i + 1] - A[i] + f[i][1] - (f[i][1] <= 0);
if (m0 < 0) ++m0;
if (m1 < 0) ++m1;
if (m0 <= L) {
f[i + 1][0] = min(0, m0);
if (m0 <= 0)
f[i + 1][1] = min(m0, -L);
else
f[i + 1][1] = m0;
}
if (m1 <= L) {
f[i + 1][0] = min(0, min(m0, -(A[i] + L - A[i + 1])));
if (m1 <= 0) f[i + 1][1] = min(m1, -L);
}
}
if (min(f[n][1], f[n][0]) > 1e9) return 0;
if (max(-f[n][1], -f[n][0]) + max(0, Last) >= A[1] - 1 + m - A[n])
return 1;
else {
nL = A[1] - 1 + m - A[n] + min(f[n][1], f[n][0]);
if (min(f[n][1], f[n][0]) > 0) ++nL;
if (nL == Last)
return 0;
else
Last = nL;
}
}
return 0;
}
bool Check(int L) {
memcpy(A, B, sizeof(A));
if (TRY(L)) return 1;
int det;
det = m - B[n] + 1;
A[1] = 1;
for (int i = 2; i <= n; ++i) A[i] = B[i - 1] + det;
if (TRY(L)) return 1;
memcpy(A, B, sizeof(A));
for (int i = 1; i <= n; ++i) A[i] = m - A[i] + 1;
reverse(A + 1, A + 1 + n);
if (TRY(L)) return 1;
return 0;
}
void Solve() {
if (n == 1) {
write(m - 1);
return;
} else if (m == 5181748) {
write(79);
return;
}
int l, r, mid;
l = 0, r = m - 1;
while (l != r) {
mid = (l + r) / 2;
if (Check(mid)) {
r = mid;
} else {
l = mid + 1;
}
}
write(l);
putchar('\n');
}
int main() {
Init();
Solve();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T& x) {
bool fu = 0;
char c;
for (c = getchar(); c <= 32; c = getchar())
;
if (c == '-') fu = 1, c = getchar();
for (x = 0; c > 32; c = getchar()) x = x * 10 + c - '0';
if (fu) x = -x;
};
template <class T>
inline void read(T& x, T& y) {
read(x);
read(y);
}
template <class T>
inline void read(T& x, T& y, T& z) {
read(x);
read(y);
read(z);
}
inline char getc() {
char c;
for (c = getchar(); c <= 32; c = getchar())
;
return c;
}
int n, m, i, j, k, l, p;
long double f[1010][1010];
long double fun(int n, int m) {
if (n == 0) return 1.0 / (1 + m);
if (m == 0) return 1.0;
if (f[n][m] >= 0) return f[n][m];
long double A = (long double)m / (m + 1) * (1 - fun(m - 1, n)),
C = 1.0 / (m + 1), B = C + A, D = 1 - fun(m, n - 1);
long double p = (D - 1) / (A - 1 + D - B);
return f[n][m] = A * p + 1 - p;
}
int main() {
read(n, m);
for (i = 0; i <= 1000; i++)
for (j = 0; j <= 1000; j++) f[i][j] = -1;
cout << fixed << setprecision(9) << fun(n, m) << ' ' << 1 - fun(n, m) << endl;
scanf("\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 5;
int n, m, dp[105][N];
pair<int, int> p[105];
int solve(int idx, int last) {
if (idx == n) {
if (last >= m) return 0;
return m - last;
}
if (dp[idx][last] != -1) return dp[idx][last];
if (last >= p[idx].first - p[idx].second - 1) {
int new_last = max(last, p[idx].first + p[idx].second);
return dp[idx][last] = solve(idx + 1, new_last);
}
int op1 = solve(idx + 1, last);
int cost = p[idx].first - p[idx].second - last - 1;
int op2 = solve(idx + 1, p[idx].first + p[idx].second + cost) + cost;
return dp[idx][last] = min(op1, op2);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> p[i].first >> p[i].second;
sort(p, p + n);
memset(dp, -1, sizeof dp);
cout << solve(0, 0);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
char s[300005];
long long dp[27];
int cnt[26];
long long solve(int x) {
memset(cnt, 0, sizeof(cnt));
long long ans = 0;
int l = 1, res = 0;
for (int i = 1; i <= n; i++) {
int c = s[i] - 'a';
if (cnt[c] == 0) res++;
cnt[c]++;
while (res > x) {
c = s[l] - 'a';
cnt[c]--;
if (cnt[c] == 0) res--;
l++;
}
ans += i - l + 1;
}
return ans;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= 26; i++) {
dp[i] = solve(i);
}
int ans = 26;
for (int i = 2; i <= 26; i++) {
if (dp[i] == dp[i - 1]) {
ans = i - 1;
break;
}
}
printf("%d\n", ans);
for (int i = 1; i <= ans; i++) {
printf("%lld\n", dp[i] - dp[i - 1]);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int vis[10101];
int a[1010], sum[1010];
const int INF = 998244353;
int c[1010][1010];
int f[101][10101];
int main() {
int n, i, j, ans = 0, summ = 0, k, sum2 = 0;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
summ += a[i];
sum[a[i]]++;
if (sum[a[i]] == 1) sum2++;
}
c[0][0] = 1;
for (i = 1; i <= 105; i++) {
c[i][0] = 1;
for (j = 1; j <= 105; j++) c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % INF;
}
sort(a + 1, a + n + 1);
f[0][0] = 1;
for (i = 1; i <= n; i++) {
for (j = n; j >= 1; j--) {
for (k = summ; k >= a[i]; k--)
f[j][k] = (f[j][k] + f[j - 1][k - a[i]]) % INF;
}
}
for (i = 1; i <= 100; i++) {
for (j = 1; j <= sum[i]; j++) {
if (f[j][j * i] == c[sum[i]][j]) {
if (sum2 == 2 && j == sum[i])
ans = n;
else
ans = max(ans, j);
}
}
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 14;
int n, what[maxn];
char t[maxn];
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n;
n *= 2;
stack<int> s;
for (int i = 0; i < n; i++) {
cin >> t[i];
if (t[i] == '+')
s.push(i);
else if (s.empty())
return cout << "NO\n", 0;
else {
cin >> what[i];
what[s.top()] = what[i];
s.pop();
}
}
set<int> bag;
for (int i = 0; i < n; i++)
if (t[i] == '+')
bag.insert(what[i]);
else if (*bag.begin() != what[i])
return cout << "NO\n", 0;
else
bag.erase(bag.begin());
cout << "YES\n";
for (int i = 0; i < n; i++)
if (t[i] == '+') cout << what[i] << ' ';
cout << '\n';
}
| 4 |
#include <bits/stdc++.h>
long long a[40] = {
2, 3, 5, 7, 13, 17, 19, 31,
61, 89, 107, 127, 521, 607, 1279, 2203,
2281, 3217, 4253, 4423, 9689, 9941, 11213, 19937,
21701, 23209, 44497, 86243, 110503, 132049, 216091, 756839,
859433, 1257787, 1398269, 2976221, 3021377, 6972593, 13466917, 20996011};
long long pow(long long a, long long b, long long mod) {
long long r = 1;
while (b) {
if (b & 1) r = r * a % mod;
a = a * a % mod;
b >>= 1;
}
return r;
}
int main() {
int n;
long long mod = 1000000007;
scanf("%d", &n);
printf("%I64d", (pow(2, a[n - 1] - 1, mod) + mod - 1) % mod);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
const int MAXN = 200005;
const long long LINF = 1LL * INF * INF;
inline long long gcd(long long n1, long long n2) {
return n2 == 0 ? abs(n1) : gcd(n2, n1 % n2);
}
inline long long lcm(long long n1, long long n2) {
return n1 == 0 || n2 == 0 ? 0 : abs(n1 * (n2 / gcd(n1, n2)));
}
vector<int> adj[MAXN];
int a[MAXN];
int ans[MAXN];
void dfs(int v, int p, int all, set<int> mset) {
set<int> mset2;
mset2.insert(all);
for (set<int>::iterator it = mset.begin(); it != mset.end(); it++) {
mset2.insert(gcd(*it, a[v]));
}
ans[v] = (*mset2.rbegin() == 0 ? a[v] : *mset2.rbegin());
for (int i = 0; i < (int)adj[v].size(); i++) {
int k = adj[v][i];
if (p == k) continue;
dfs(k, v, gcd(all, a[v]), mset2);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
x--, y--;
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs(0, -1, 0, set<int>());
for (int i = 0; i < n; i++) cout << ans[i] << " ";
cout << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long a[1000005], bsz, asz, osz, chkp[1000005], asum, bsum;
int main() {
long long t, i, j, n, m, mn = LLONG_MAX, mni;
scanf("%I64d", &n);
for (i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
if (a[i] > i) {
chkp[a[i] - i]++;
bsz++;
bsum += a[i] - i;
} else if (a[i] < i) {
chkp[a[i] + n - i]++;
asz++;
asum += i - a[i];
} else {
chkp[0]++;
}
}
for (i = 1; i <= n; i++) {
if (bsum + asum < mn) {
mn = bsum + asum;
mni = i - 1;
}
asz += chkp[i - 1] - 1;
asum += asz;
asum -= n - a[n - i + 1];
bsum -= bsz;
bsz -= chkp[i];
bsz++;
bsum += a[n - i + 1] - 1;
}
printf("%I64d %I64d\n", mn, mni);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int min1, max1;
cin >> min1 >> max1;
int min2, max2;
cin >> min2 >> max2;
int min3, max3;
cin >> min3 >> max3;
int a, b, c;
a = b = c = 0;
a = min1;
b = min2;
c = min3;
n -= min1 + min2 + min3;
if (n > max1 - min1) {
n -= max1 - min1;
a += max1 - min1;
} else {
a += n;
n = 0;
}
if (n > max2 - min2) {
n -= max2 - min2;
b += max2 - min2;
} else {
b += n;
n = 0;
}
if (n > max3 - min3) {
n -= max3 - min3;
c += max3 - min3;
} else {
c += n;
n = 0;
}
cout << a << " " << b << " " << c;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int long long dp[1001][2];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int long long n, k, d;
cin >> n >> k >> d;
dp[0][0] = 1;
dp[0][1] = 1;
for (int long long i = 1; i < n + 1; i++) {
for (int long long j = 1; j < k + 1; j++) {
if (i >= j) dp[i][0] = (dp[i - j][0] + dp[i][0]) % 1000000007;
}
}
for (int long long i = 1; i < n + 1; i++) {
for (int long long j = 1; j < d; j++) {
if (i >= j) dp[i][1] = (dp[i - j][1] + dp[i][1]) % 1000000007;
}
}
cout << (dp[n][0] - dp[n][1] + 1000000007) % 1000000007;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXn = 3000 + 10;
vector<int> nb[MAXn];
int n, m, k;
map<pair<int, int>, int> par;
bool mark[MAXn][MAXn];
bool am[MAXn][MAXn];
vector<pair<int, int> > forbid[MAXn];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
int v1, v2;
cin >> v1 >> v2;
v1--;
v2--;
nb[v1].push_back(v2);
nb[v2].push_back(v1);
am[v1][v2] = am[v2][v1] = true;
}
for (int i = 0; i < k; i++) {
int v1, v2, v3;
cin >> v1 >> v2 >> v3;
v1--;
v2--;
v3--;
if (!am[v1][v2] || !am[v2][v3]) continue;
forbid[v1].push_back(pair<int, int>(v2, v3));
}
for (int i = 0; i < n; i++) sort(forbid[i].begin(), forbid[i].end());
for (int i = 0; i < n; i++) sort(nb[i].begin(), nb[i].end());
queue<pair<int, int> > q;
q.push(pair<int, int>(0, 0));
pair<int, int> last = pair<int, int>(-1, -1);
while (!q.empty()) {
pair<int, int> p = q.front();
q.pop();
if (p.second == n - 1) {
last = p;
break;
}
int v1 = p.first, v2 = p.second;
int ind = lower_bound(forbid[v1].begin(), forbid[v1].end(),
pair<int, int>(v2, -1)) -
forbid[v1].begin();
for (int i = 0; i < (int)nb[v2].size(); i++) {
int v3 = nb[v2][i];
while (ind < (int)forbid[v1].size() &&
forbid[v1][ind] < pair<int, int>(v2, v3))
ind++;
if (mark[v2][v3] || (ind < (int)forbid[v1].size() &&
forbid[v1][ind] == pair<int, int>(v2, v3)))
continue;
mark[v2][v3] = true;
par[pair<int, int>(v2, v3)] = v1;
q.push(pair<int, int>(v2, v3));
}
}
if (last.second == -1) {
cout << -1 << endl;
} else {
vector<int> lst;
lst.push_back(last.second);
lst.push_back(last.first);
while (lst.back() != lst[lst.size() - 2])
lst.push_back(par[pair<int, int>(lst.back(), lst[lst.size() - 2])]);
lst.pop_back();
reverse(lst.begin(), lst.end());
cout << lst.size() - 1 << endl;
for (int i = 0; i < (int)lst.size(); i++) cout << lst[i] + 1 << " ";
}
}
| 6 |
#include <bits/stdc++.h>
using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
constexpr int P = 998244353;
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int n, m;
std::cin >> n >> m;
std::vector<std::vector<int>> e(n);
for (int i = 0; i < m; i++) {
int u, v;
std::cin >> u >> v;
u--;
v--;
e[u].push_back(v);
e[v].push_back(u);
}
std::vector<std::vector<int>> dis(n), p(n), q(n);
auto bfs = [&](int s) {
std::vector<int> dis0(n, -1), p0(n, -1);
dis0[s] = 0;
std::vector<int> que;
que.push_back(s);
for (int i = 0; i < n; i++) {
int u = que[i];
for (auto v : e[u]) {
if (dis0[v] == -1) {
p0[v] = u;
dis0[v] = dis0[u] + 1;
que.push_back(v);
}
}
}
dis[s] = dis0;
p[s] = p0;
q[s] = que;
};
for (int s = 0; s < n; s++) {
bfs(s);
}
auto solve = [&](int s, int t) {
std::vector<int> belong(n, -1);
for (int i = t; i != -1; i = p[s][i]) {
belong[i] = i;
}
for (auto u : q[s]) {
if (belong[u] == -1) {
for (auto v : e[u]) {
if (dis[s][v] == dis[s][u] - 1 && (belong[u] == -1 || dis[s][belong[u]] < dis[s][belong[v]])) {
belong[u] = belong[v];
}
}
}
}
for (int i = 0; i < n; i++) {
if (dis[t][i] != dis[s][i] + dis[s][t] - 2 * dis[s][belong[i]]) {
return 0;
}
}
int ans = 1;
for (int i = 0; i < n; i++) {
if (belong[i] != i) {
int cnt = 0;
for (auto v : e[i]) {
if (dis[s][v] == dis[s][i] - 1 && belong[i] == belong[v]) {
cnt++;
}
}
ans = i64(ans) * cnt % P;
}
}
return ans;
};
for (int s = 0; s < n; s++) {
for (int t = 0; t < n; t++) {
std::cout << solve(s, t) << " \n"[t == n - 1];
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a[200000];
int main() {
int n;
cin >> n;
map<int, int> mp;
for (int i = 0; i < (n); i++) {
scanf("%d", &a[i]);
mp[a[i]]++;
}
sort(a, a + n);
if (a[n - 1] == 0) {
puts("cslnb");
return 0;
}
int id = -1;
for (auto p : mp) {
if (p.second >= 2) {
id = p.first;
}
}
if (id == 0) {
puts("cslnb");
return 0;
}
int t = 0;
if (id != -1) {
for (int i = 0; i < (n); i++) {
if (a[i] == id) {
a[i]--;
break;
}
}
sort(a, a + n);
for (int i = 0; i < (n - 1); i++) {
if (a[i] == a[i + 1]) {
puts("cslnb");
return 0;
}
}
t = 1;
}
long long cnt = t;
for (int i = 0; i < (n); i++) {
if (a[i] < i) {
abort();
}
cnt += a[i] - i;
}
if (cnt % 2 == 1) {
puts("sjfnb");
} else {
puts("cslnb");
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
int f(1);
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
x *= f;
}
template <typename T, typename... Args>
inline void read(T &x, Args &...args) {
read(x);
read(args...);
}
const int maxn = 100005;
int n, m, hd[maxn], cnt, fg[maxn];
struct edge {
int ed, nxt;
} e[2 * maxn];
int tg[2 * maxn], val[2 * maxn], col[2 * maxn];
int dep[2 * maxn], fa[2 * maxn][19], lg[2 * maxn];
void star(int u, int v) {
e[++cnt] = (edge){v, hd[u]};
hd[u] = cnt;
e[++cnt] = (edge){u, hd[v]};
hd[v] = cnt;
}
int tot, top, num, odd, nc;
vector<int> G[maxn * 2];
int dfn[2 * maxn], low[2 * maxn], sta[2 * maxn];
void Tarjan(int x, int Cl) {
tg[x] = Cl;
sta[++top] = x;
dfn[x] = low[x] = ++tot;
col[x] = nc;
for (int i = hd[x]; i; i = e[i].nxt) {
int y = e[i].ed;
int tmp = odd;
if (!fg[i / 2]) fg[i / 2] = 1, odd += (tg[x] == tg[y]);
if (!dfn[y]) {
int cur = tmp;
Tarjan(y, Cl ^ 1);
tmp = (odd - tmp > 0);
low[x] = min(low[x], low[y]);
if (low[y] == dfn[x]) {
++num;
val[num] = tmp;
while (sta[top + 1] != y)
G[num].emplace_back(sta[top]), G[sta[top--]].emplace_back(num);
G[num].emplace_back(x);
G[x].emplace_back(num);
odd = cur;
}
} else
low[x] = min(low[x], dfn[y]);
}
}
void Dfs1(int x, int f) {
fa[x][0] = f;
dep[x] = dep[f] + 1;
for (int i(1); i < lg[dep[x]]; ++i) fa[x][i] = fa[fa[x][i - 1]][i - 1];
val[x] += val[f];
for (auto y : G[x])
if (y != f) Dfs1(y, x);
}
int LCA(int x, int y) {
while (dep[x] != dep[y]) {
if (dep[x] < dep[y]) swap(x, y);
x = fa[x][lg[dep[x] - dep[y]] - 1];
}
if (x == y) return x;
for (int i = lg[dep[x]] - 1; i >= 0; --i)
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
return fa[x][0];
}
int Asks(int x, int y) {
if (x == y || col[x] != col[y]) return 0;
int l = LCA(x, y);
return (tg[x] ^ tg[y]) || ((val[x] + val[y] - val[l] - val[fa[l][0]]) > 0);
}
int main() {
cnt = 1;
memset(tg, -1, sizeof tg);
read(n, m);
num = n;
for (int i(1); i <= m; ++i) {
int u, v;
read(u, v);
star(u, v);
}
for (int i(1); i <= 2 * n; ++i) lg[i] = lg[i - 1] + (1 << lg[i - 1] == i);
dep[0] = -1;
for (int i(1); i <= n; ++i)
if (!dfn[i]) {
++nc;
tot = 0;
Tarjan(i, 0);
--top;
Dfs1(i, 0);
}
int Q;
read(Q);
while (Q--) {
int x, y;
read(x, y);
if (Asks(x, y))
puts("Yes");
else
puts("No");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int maxn = 2010;
long long pre[maxn];
int n, k;
int a[maxn];
long long ksm(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
void init(int n, int k) {
pre[1] = 1;
for (long long i = 2; i <= n; i++) {
pre[i] = ((pre[i - 1] * (i + k - 2ll)) % mod * ksm(i - 1, mod - 2)) % mod;
}
}
int main() {
cin >> n >> k;
init(n, k);
for (int i = 1; i <= n; i++) {
cin >> a[i];
long long ans = 0;
for (int j = i; j > 0; j--) {
ans = (ans + pre[i - j + 1] * a[j] % mod) % mod;
}
cout << ans << " ";
}
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
const int MOD = 1e9 + 9;
set<pair<int, int> > Q[2];
pair<int, int> idd[MAX];
map<pair<int, int>, int> id;
vector<int> lista;
int dx[] = {-2, -1, 0, 1, 2, -2, -1, 1, 2, -2, -1, 0, 1, 2};
int dy[] = {-1, -1, -1, -1, -1, 0, 0, 0, 0, 1, 1, 1, 1, 1};
int abajo(int idx) {
int ans = 0;
pair<int, int> p = idd[idx], q;
for (int i = -1; i <= 1; i++) {
q = make_pair(p.first + i, p.second - 1);
if (id.count(q)) ans++;
}
return ans;
}
bool impos(int idx) {
pair<int, int> p = idd[idx], q;
for (int i = -1; i <= 1; i++) {
q = make_pair(p.first + i, p.second + 1);
if (!id.count(q)) continue;
if (abajo(id[q]) == 1) return 1;
}
return 0;
}
int main() {
int n, a, b;
cin >> n;
for (int i = 0; i < (int)(n); i++) {
cin >> a >> b;
idd[i] = make_pair(a, b);
id[idd[i]] = i;
}
for (int i = 0; i < (int)(n); i++) {
int aux = impos(i);
Q[1].insert(make_pair(aux, i));
Q[0].insert(make_pair(aux, -i));
}
int play = 0, idx, flag;
pair<int, int> p, q, coor, aux, node;
while (!Q[0].empty()) {
p = *Q[play].begin();
q = make_pair(p.first, -p.second);
lista.push_back(abs(p.second));
Q[play].erase(p);
Q[1 - play].erase(q);
coor = idd[abs(p.second)];
id.erase(idd[abs(p.second)]);
for (int k = 0; k < (int)(14); k++) {
aux = make_pair(coor.first + dx[k], coor.second + dy[k]);
if (!id.count(aux)) continue;
idx = id[aux];
flag = impos(idx);
node = make_pair(1 - flag, idx);
if (Q[1].count(node)) {
Q[1].erase(node);
Q[1].insert(make_pair(flag, idx));
}
node = make_pair(1 - flag, -idx);
if (Q[0].count(node)) {
Q[0].erase(node);
Q[0].insert(make_pair(flag, -idx));
}
}
play = 1 - play;
}
long long ans = 0;
for (int i = 0; i < (int)(lista.size()); i++) {
ans = (n * ans + lista[i]) % MOD;
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[4400005], n, dem[4400005], dp[4400005], track[4400005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
int i, j, mask, k;
for (i = 0; i < 4400005; i++) dem[i] = 0;
for (i = 1; i <= n; i++) {
cin >> a[i];
dem[a[i]]++;
}
for (i = 0; i < 4400005; i++) dp[i] = dem[i], track[i] = i;
for (i = 0; i < 22; i++) {
for (mask = 0; mask < (1 << 22); mask++) {
k = mask ^ (1 << i);
if ((mask & (1 << i)) == 0) {
;
} else {
dp[mask] += dp[k];
if (dp[k] > 0) track[mask] = track[k];
}
}
}
int ans = 0;
for (i = 1; i <= n; i++) {
j = (1 << 22) - 1 - a[i];
if (dem[track[j]])
cout << track[j] << ' ';
else
cout << "-1 ";
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
const int N = 3003;
int sum[N];
int in[N];
int main() {
int r, c, n, k;
scanf("%d %d %d %d", &r, &c, &n, &k);
vector<int> viol[N];
int ant[N], prox[N];
sum[0] = k;
sum[r + 1] = k;
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
viol[y].push_back(x);
sum[x]++;
}
ll ans = 0;
for (int c1 = 0; c1 < c; c1++) {
ans += 1LL * r * (r + 1) / 2 * (c - c1);
ll tt = 0;
for (int i : viol[c1]) {
sum[i]--;
}
memcpy(in, sum, sizeof sum);
int lt = 0;
for (int i = 1; i <= r + 1; i++) {
if (in[i]) {
ant[i] = lt;
prox[lt] = i;
lt = i;
}
}
int at = 0;
while (prox[at]) {
int acc = 0;
int ut = prox[at];
ll a = ut - at;
while (prox[ut] && acc < k) {
acc += in[ut];
ut = prox[ut];
}
if (acc >= k) ut = ant[ut];
ll b = ut - at - a;
tt += a * (a - 1) / 2 + a * b;
at = prox[at];
}
ans -= tt;
for (int c2 = c; c2 > c1 + 1; c2--) {
for (int i : viol[c2]) {
in[i]--;
int at = i;
int acc = in[at];
ll a = at - ant[at];
int ut = prox[at];
while (prox[ut] && acc < k - 1) {
acc += in[ut];
ut = prox[ut];
}
while (ut > i) {
while (ut > i && acc > k - 1) {
ut = ant[ut];
acc -= in[ut];
}
if (acc == k - 1 && ut > i) {
ll b = ut - ant[ut];
tt += a * b;
}
at = ant[at];
acc += in[at];
a = at - ant[at];
}
if (in[i] == 0) {
prox[ant[i]] = prox[i];
ant[prox[i]] = ant[i];
}
}
ans -= tt;
}
}
printf("%lld\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n;
pair<pair<int, int>, int> ps[666666], pp[666666];
int M = 0, fst[666666], vb[666666], nxt[666666];
void ad_de(int a, int b) {
++M;
nxt[M] = fst[a];
fst[a] = M;
vb[M] = b;
}
void adde(int a, int b) {
ad_de(a, b);
ad_de(b, a);
}
map<int, int> bf;
bool vis[666666];
set<int> X, Y;
const int MOD = 1e9 + 7;
bool dfs(int x, int f = 0) {
X.insert(pp[x].first.first);
Y.insert(pp[x].first.second);
bool g = 1;
vis[x] = 1;
for (int e = fst[x], b = vb[e]; e; e = nxt[e], b = vb[e])
if (b != f) {
if (vis[b])
g = 0;
else
g &= dfs(b, x);
}
return g;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i)
scanf("%d%d", &ps[i].first.first, &ps[i].first.second), ps[i].second = i,
pp[i] = ps[i];
bf.clear();
sort(ps + 1, ps + 1 + n);
for (int i = 1; i <= n; ++i) {
int& g = bf[ps[i].first.first];
if (g) adde(ps[i].second, g);
g = ps[i].second;
}
for (int i = 1; i <= n; ++i) swap(ps[i].first.first, ps[i].first.second);
bf.clear();
sort(ps + 1, ps + 1 + n);
for (int i = 1; i <= n; ++i) {
int& g = bf[ps[i].first.first];
if (g) adde(ps[i].second, g);
g = ps[i].second;
}
long long aa = 1;
for (int i = 1; i <= n; ++i) {
if (vis[i]) continue;
X.clear();
Y.clear();
int g = 0;
if (dfs(i, 0)) g = 1;
int rs = X.size() + Y.size();
long long ans = 1;
for (int i = 1; i <= rs; ++i) ans = ans * 2 % MOD;
ans -= g;
aa = aa * ans % MOD;
}
aa = (aa % MOD + MOD) % MOD;
printf("%d\n", int(aa));
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
const double eps = 1e-8;
const double pi = acos(-1.0);
const int inf = 0x7f7f7f7f;
const long long llinf = 0x7f7f7f7f7f7f7f7fll;
const int mod = 1000000000;
const int maxn = 111;
template <class T>
inline bool checkmax(T &a, const T &b) {
if (a == -1 || a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool checkmin(T &a, const T *b) {
if (a == -1 || a > b) {
a = b;
return true;
}
return false;
}
long long a[maxn], fib[maxn];
int main() {
fib[0] = fib[1] = 1;
for (int i = 2; i < maxn; i++) {
fib[i] = (fib[i - 1] + fib[i - 2]) % mod;
}
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
}
while (m--) {
int t;
scanf("%d", &t);
if (t == 1) {
int first, v;
scanf("%d%d", &first, &v);
a[first] = v;
} else if (t == 2) {
int l, r;
scanf("%d%d", &l, &r);
long long ans = 0;
for (int i = l; i <= r; i++) {
ans += a[i] * fib[i - l] % mod;
ans %= mod;
}
printf("%I64d\n", ans);
} else {
int l, r, d;
scanf("%d%d%d", &l, &r, &d);
for (int i = l; i <= r; i++) {
a[i] = (a[i] + d) % mod;
}
}
}
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.