solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
long long gm[101][101][100];
int nxt[101][101][100];
long long ds[101][101][100];
struct subj {
int c, n;
long long a, b;
};
vector<subj> s;
bool operator<(const subj& x, const subj& y) { return x.c < y.c; }
long long getmax(int x, long long d, int left) {
if (left == 0) return d;
int p = (int)(d - s[x].a);
if (ds[x][p][left]) return gm[x][p][left];
long long res = -1;
long long tr;
for (int i = 0; i < x; i++) {
if (s[i].c == s[x].c) continue;
if (s[i].a <= d - k && d - k <= s[i].b &&
(tr = getmax(i, d - k, left - 1)) > res) {
res = tr;
nxt[x][p][left] = i;
ds[x][p][left] = d - k;
}
if (d % k == 0 && s[i].a <= d / k && d / k <= s[i].b &&
(tr = getmax(i, d / k, left - 1)) > res) {
res = tr;
nxt[x][p][left] = i;
ds[x][p][left] = d / k;
}
}
if (!ds[x][p][left]) ds[x][p][left] = -1;
if (res != -1) res += d;
return gm[x][p][left] = res;
}
void trace(int x, long long d, int left) {
if (left) {
int x2 = nxt[x][d - s[x].a][left];
long long d2 = ds[x][d - s[x].a][left];
trace(x2, d2, left - 1);
}
cout << s[x].n << " " << d << endl;
}
int main() {
cin >> n >> m >> k;
s.resize(m);
for (int i = 0; i < m; i++) {
cin >> s[i].a >> s[i].b >> s[i].c;
s[i].n = i + 1;
}
sort(s.begin(), s.end());
long long res = -1, tr;
long long ri, rj;
for (int i = 0; i < m; i++)
for (long long j = s[i].a; j <= s[i].b; j++)
if ((tr = getmax(i, j, n - 1)) > res) {
res = tr;
ri = i;
rj = j;
}
if (res > -1) {
cout << "YES" << endl;
trace(ri, rj, n - 1);
} else
cout << "NO" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int pts[10] = {25, 18, 15, 12, 10, 8, 6, 4, 2, 1};
int n, m, r;
int sum[1000], a[1000], b[1000];
string name[1000];
int g[1000][50];
map<string, int> all;
inline int get(string s) {
if (all.count(s)) return all[s];
a[r] = r;
b[r] = r;
all[s] = r;
name[r] = s;
r++;
return r - 1;
}
bool cmp1(int i, int j) {
if (sum[i] != sum[j]) return sum[i] > sum[j];
for (int k = 0; k < 50; k++)
if (g[i][k] != g[j][k]) return g[i][k] > g[j][k];
}
bool cmp2(int i, int j) {
if (g[i][0] != g[j][0]) return g[i][0] > g[j][0];
if (sum[i] != sum[j]) return sum[i] > sum[j];
for (int k = 1; k < 50; k++)
if (g[i][k] != g[j][k]) return g[i][k] > g[j][k];
}
int main() {
int i, j, k;
cin >> n;
for (i = 0; i < n; i++) {
cin >> m;
for (j = 0; j < m; j++) {
string s;
cin >> s;
int x = get(s);
if (j < 10) sum[x] += pts[j];
g[x][j]++;
}
}
sort(a, a + r, cmp1);
sort(b, b + r, cmp2);
cout << name[a[0]] << endl << name[b[0]] << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char change(char w);
bool hop(int g, int h, char w, int u, int v, char D);
queue<pair<pair<int, int>, int> > qu;
int d[1010][1010][4], n, m, X1, Y1, X2, Y2;
char ch[1010][1010];
int p[4] = {1, -1, 0, 0};
int q[4] = {0, 0, 1, -1};
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
for (int i = (1), _b = (n); i <= _b; i++)
for (int j = (1), _b = (m); j <= _b; j++) {
cin >> ch[i][j];
for (int k = (0), _b = (3); k <= _b; k++) d[i][j][k] = 1000000000;
}
cin >> X1 >> Y1 >> X2 >> Y2;
qu.push(pair<pair<int, int>, int>(pair<int, int>(X1, Y1), 0));
d[X1][Y1][0] = 0;
while (!qu.empty()) {
pair<pair<int, int>, int> r = qu.front();
qu.pop();
int g = r.first.first;
int h = r.first.second;
int l = r.second;
char w = ch[g][h];
for (int i = (1), _b = (l); i <= _b; i++) w = change(w);
int o = (l + 1) % 4;
if (d[g][h][o] > d[g][h][l] + 1) {
d[g][h][o] = d[g][h][l] + 1;
qu.push(pair<pair<int, int>, int>(pair<int, int>(g, h), o));
}
if (w == '+') {
for (int i = (0), _b = (3); i <= _b; i++) {
int u = g + p[i];
int v = h + q[i];
if (u > 0 && u <= n && v > 0 && v <= m) {
char D = ch[u][v];
for (int j = (1), _b = (l); j <= _b; j++) D = change(D);
if (hop(g, h, w, u, v, D))
if (d[u][v][l] > d[g][h][l] + 1) {
d[u][v][l] = d[g][h][l] + 1;
qu.push(pair<pair<int, int>, int>(pair<int, int>(u, v), l));
}
}
}
} else if (w == '-') {
for (int i = (2), _b = (3); i <= _b; i++) {
int u = g + p[i];
int v = h + q[i];
if (u > 0 && u <= n && v > 0 && v <= m) {
char D = ch[u][v];
for (int j = (1), _b = (l); j <= _b; j++) D = change(D);
if (hop(g, h, w, u, v, D))
if (d[u][v][l] > d[g][h][l] + 1) {
d[u][v][l] = d[g][h][l] + 1;
qu.push(pair<pair<int, int>, int>(pair<int, int>(u, v), l));
}
}
}
} else if (w == '|') {
for (int i = (0), _b = (1); i <= _b; i++) {
int u = g + p[i];
int v = h + q[i];
if (u > 0 && u <= n && v > 0 && v <= m) {
char D = ch[u][v];
for (int j = (1), _b = (l); j <= _b; j++) D = change(D);
if (hop(g, h, w, u, v, D))
if (d[u][v][l] > d[g][h][l] + 1) {
d[u][v][l] = d[g][h][l] + 1;
qu.push(pair<pair<int, int>, int>(pair<int, int>(u, v), l));
}
}
}
} else if (w == '^') {
int u = g + p[1];
int v = h + q[1];
if (u > 0 && u <= n && v > 0 && v <= m) {
char D = ch[u][v];
for (int j = (1), _b = (l); j <= _b; j++) D = change(D);
if (hop(g, h, w, u, v, D))
if (d[u][v][l] > d[g][h][l] + 1) {
d[u][v][l] = d[g][h][l] + 1;
qu.push(pair<pair<int, int>, int>(pair<int, int>(u, v), l));
}
}
} else if (w == '>') {
int u = g + p[2];
int v = h + q[2];
if (u > 0 && u <= n && v > 0 && v <= m) {
char D = ch[u][v];
for (int j = (1), _b = (l); j <= _b; j++) D = change(D);
if (hop(g, h, w, u, v, D))
if (d[u][v][l] > d[g][h][l] + 1) {
d[u][v][l] = d[g][h][l] + 1;
qu.push(pair<pair<int, int>, int>(pair<int, int>(u, v), l));
}
}
} else if (w == 'v') {
int u = g + p[0];
int v = h + q[0];
if (u > 0 && u <= n && v > 0 && v <= m) {
char D = ch[u][v];
for (int j = (1), _b = (l); j <= _b; j++) D = change(D);
if (hop(g, h, w, u, v, D))
if (d[u][v][l] > d[g][h][l] + 1) {
d[u][v][l] = d[g][h][l] + 1;
qu.push(pair<pair<int, int>, int>(pair<int, int>(u, v), l));
}
}
} else if (w == '<') {
int u = g + p[3];
int v = h + q[3];
if (u > 0 && u <= n && v > 0 && v <= m) {
char D = ch[u][v];
for (int j = (1), _b = (l); j <= _b; j++) D = change(D);
if (hop(g, h, w, u, v, D))
if (d[u][v][l] > d[g][h][l] + 1) {
d[u][v][l] = d[g][h][l] + 1;
qu.push(pair<pair<int, int>, int>(pair<int, int>(u, v), l));
}
}
} else if (w == 'L') {
for (int i = (0), _b = (2); i <= _b; i++) {
int u = g + p[i];
int v = h + q[i];
if (u > 0 && u <= n && v > 0 && v <= m) {
char D = ch[u][v];
for (int j = (1), _b = (l); j <= _b; j++) D = change(D);
if (hop(g, h, w, u, v, D))
if (d[u][v][l] > d[g][h][l] + 1) {
d[u][v][l] = d[g][h][l] + 1;
qu.push(pair<pair<int, int>, int>(pair<int, int>(u, v), l));
}
}
}
} else if (w == 'U') {
for (int i = (0), _b = (3); i <= _b; i++) {
if (i == 1) continue;
int u = g + p[i];
int v = h + q[i];
if (u > 0 && u <= n && v > 0 && v <= m) {
char D = ch[u][v];
for (int j = (1), _b = (l); j <= _b; j++) D = change(D);
if (hop(g, h, w, u, v, D))
if (d[u][v][l] > d[g][h][l] + 1) {
d[u][v][l] = d[g][h][l] + 1;
qu.push(pair<pair<int, int>, int>(pair<int, int>(u, v), l));
}
}
}
} else if (w == 'R') {
for (int i = (0), _b = (3); i <= _b; i++) {
if (i == 2) continue;
int u = g + p[i];
int v = h + q[i];
if (u > 0 && u <= n && v > 0 && v <= m) {
char D = ch[u][v];
for (int j = (1), _b = (l); j <= _b; j++) D = change(D);
if (hop(g, h, w, u, v, D))
if (d[u][v][l] > d[g][h][l] + 1) {
d[u][v][l] = d[g][h][l] + 1;
qu.push(pair<pair<int, int>, int>(pair<int, int>(u, v), l));
}
}
}
} else if (w == 'D') {
for (int i = (1), _b = (3); i <= _b; i++) {
int u = g + p[i];
int v = h + q[i];
if (u > 0 && u <= n && v > 0 && v <= m) {
char D = ch[u][v];
for (int j = (1), _b = (l); j <= _b; j++) D = change(D);
if (hop(g, h, w, u, v, D))
if (d[u][v][l] > d[g][h][l] + 1) {
d[u][v][l] = d[g][h][l] + 1;
qu.push(pair<pair<int, int>, int>(pair<int, int>(u, v), l));
}
}
}
}
}
int z = 1000000000;
for (int i = (0), _b = (3); i <= _b; i++) z = min(z, d[X2][Y2][i]);
if (z == 1000000000) z = -1;
cout << z;
return 0;
}
char change(char w) {
if (w == '+') return w;
if (w == '-') return '|';
if (w == '|') return '-';
if (w == '^') return '>';
if (w == '>') return 'v';
if (w == 'v') return '<';
if (w == '<') return '^';
if (w == 'L') return 'U';
if (w == 'U') return 'R';
if (w == 'R') return 'D';
if (w == 'D') return 'L';
if (w == '*') return w;
}
bool hop(int g, int h, char w, int u, int v, char D) {
if (g == u) {
if (h < v) {
if (w == '+' || w == '-' || w == '>' || w == 'L' || w == 'U' || w == 'D')
if (D == '+' || D == '-' || D == '<' || D == 'U' || D == 'R' ||
D == 'D')
return true;
return false;
} else {
if (w == '+' || w == '-' || w == '<' || w == 'R' || w == 'U' || w == 'D')
if (D == '+' || D == '-' || D == '>' || D == 'U' || D == 'L' ||
D == 'D')
return true;
return false;
}
} else {
if (g < u) {
if (w == '+' || w == '|' || w == 'v' || w == 'L' || w == 'U' || w == 'R')
if (D == '+' || D == '|' || D == '^' || D == 'D' || D == 'R' ||
D == 'L')
return true;
return false;
} else {
if (w == '+' || w == '|' || w == '^' || w == 'R' || w == 'L' || w == 'D')
if (D == '+' || D == '|' || D == 'v' || D == 'U' || D == 'L' ||
D == 'R')
return true;
return false;
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX_LL = 1LL << 60;
const int MAXN = 200020;
struct tnode {
long long x, p;
} a[MAXN];
int q[MAXN];
bool cmp(tnode a, tnode b) { return a.x < b.x; }
int main() {
int m;
long long d, n;
scanf("%I64d%I64d%d", &d, &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%I64d%I64d", &a[i].x, &a[i].p);
}
a[0].x = 0;
a[0].p = 0;
memset(q, 0, sizeof(q));
sort(a, a + m + 1, cmp);
int now = 0, end = 1, top = 1, sta = 1;
long long tank = 0, total = 0, ans = MAX_LL;
bool flag = true;
while (now < m) {
if (d <= a[now].x + n) {
long long tmp = 0;
if (tank < d - a[now].x) {
tmp = (d - a[now].x - tank) * a[now].p;
}
if (total + tmp < ans) {
ans = total + tmp;
}
}
if (sta <= m) {
if ((sta == now + 1) && (a[sta].x > a[now].x + n)) {
flag = false;
break;
}
while (a[sta].x <= a[now].x + n) {
while (a[q[top]].p >= a[sta].p) {
top--;
if (top < end) break;
}
q[++top] = sta;
sta++;
if (top == end) break;
if (sta > m) break;
}
}
if (q[end] == now) {
end++;
total += (n - tank) * a[now].p;
tank = n - a[q[end]].x + a[now].x;
} else {
total += (a[q[end]].x - a[now].x - tank) * a[now].p;
tank = 0;
}
now = q[end];
}
if (d <= a[now].x + n) {
long long tmp = 0;
if (tank < d - a[now].x) {
tmp = (d - a[now].x - tank) * a[now].p;
}
if (total + tmp < ans) {
ans = total + tmp;
}
}
if ((flag) && (ans < MAX_LL)) {
printf("%I64d\n", ans);
} else {
printf("-1\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
double a, b, c, s, x, y, z, sum;
cin >> s >> a >> b >> c;
sum = a + b + c;
if (sum == 0) {
x = y = 0;
z = s;
} else {
x = a / sum * s;
y = b / sum * s;
z = c / sum * s;
}
printf("%.12lf %.12lf %.12lf", x, y, z);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[2005], b[2005], sum, k, n;
bool ok(int d) {
for (int i = 1; i <= n; i++) b[i] = 1;
for (int i = 2; i <= n; i++) {
for (int j = 1; j < i; j++) {
if (abs(a[i] - a[j]) <= (long long)(i - j) * d)
b[i] = max(b[i], b[j] + 1);
}
}
sum = 0;
for (int i = 1; i <= n; i++) sum = max(sum, b[i]);
return n - sum <= k;
}
int main() {
int l = 0, r = 2 * 1000000000;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
while (l <= r) {
int Mid = ((long long)l + r) / 2;
if (ok(Mid))
r = Mid - 1;
else
l = Mid + 1;
}
printf("%d\n", l);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, d, m;
long long a[100001], c[100001];
bool cmp(const long long &x, const long long &y) { return x > y; }
int main() {
scanf("%d%d%d", &n, &d, &m);
++d;
int l = 0, r = 0;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (x <= m)
a[++l] = x;
else
c[++r] = x;
}
sort(a + 1, a + l + 1, cmp);
sort(c + 1, c + r + 1, cmp);
for (int i = 1; i <= l; i++) a[i] += a[i - 1];
for (int i = 1; i <= r; i++) c[i] += c[i - 1];
long long ans = 0;
for (int i = 0; i <= l; i++) {
long long res = a[i];
if (i != n) {
int x = (n - i - 1) / d + 1;
if (x <= r)
res += c[x];
else
continue;
}
ans = max(ans, res);
}
printf("%lld\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T modinv(T a, T n) {
T i = n, v = 0, d = 1;
while (a > 0) {
T t = i / a, x = a;
a = i % x;
i = x;
x = d;
d = v - t * x;
v = x;
}
return (v + n) % n;
}
long long modpow(long long n, long long k, long long mod) {
long long ans = 1;
while (k > 0) {
if (k & 1) ans = (ans * n) % mod;
k >>= 1;
n = (n * n) % mod;
}
return ans % mod;
}
template <class T>
string str(T Number) {
string Result;
ostringstream convert;
convert << Number;
Result = convert.str();
return Result;
}
int StringToNumber(const string &Text) {
istringstream ss(Text);
int result;
return ss >> result ? result : 0;
}
template <class T>
inline vector<pair<T, int> > FACTORISE(T n) {
vector<pair<T, int> > R;
for (T i = 2; n > 1;) {
if (n % i == 0) {
int C = 0;
for (; n % i == 0; C++, n /= i)
;
R.push_back(make_pair(i, C));
}
i++;
if (i > n / i) i = n;
}
if (n > 1) R.push_back(make_pair(n, 1));
return R;
}
template <class T>
inline T TOTIENT(T n) {
vector<pair<T, int> > R = FACTORISE(n);
T r = n;
for (int i = 0; i < R.size(); i++) r = r / R[i].first * (R[i].first - 1);
return r;
}
template <class T>
inline T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
double rnd(float d) { return floor(d + 0.49); }
int main() {
int a, m;
cin >> a >> m;
int x = gcd(a, m);
while (m % 2 == 0) m = m / 2;
if (x % m == 0)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void copyfile(int a, int b, vector<pair<int, int> > &hd, int &freeguy,
vector<pair<int, int> > &result) {
hd[b] = hd[a];
hd[a] = make_pair(-1, -1);
result.push_back(make_pair(a, b));
freeguy = a;
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
vector<pair<int, int> > hd(n, make_pair(-1, -1));
for (int i = 0; i < m; i++) {
int mb;
scanf("%d", &mb);
for (int j = 0; j < mb; j++) {
int b;
scanf("%d", &b);
b--;
hd[b] = make_pair(i, j);
}
}
vector<pair<int, int> > result;
int freeguy = -1;
for (int i = 0; i < n; i++)
if (hd[i].first == -1) freeguy = i;
int now = 0;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
int pos = find(hd.begin(), hd.end(), make_pair(i, j)) - hd.begin();
if (pos == n) break;
if (hd[now].first == -1) {
copyfile(pos, now, hd, freeguy, result);
} else if (pos == now) {
} else {
copyfile(now, freeguy, hd, freeguy, result);
copyfile(pos, now, hd, freeguy, result);
}
now++;
}
}
printf("%d\n", (int)result.size());
for (int i = 0; i < (int)result.size(); i++)
printf("%d %d\n", result[i].first + 1, result[i].second + 1);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
long long gcd(long long x, long long y) { return (!y) ? x : gcd(y, x % y); }
long long lcm(long long x, long long y) { return ((x / gcd(x, y) * y)); }
int arr[1001][1001];
int solve(int i, int j, int n, int m) {
if (i == n) return j;
int x = arr[i][j];
arr[i][j] = 2;
if (x == 1)
return solve(i, j + 1, n, m);
else if (x == 2)
return solve(i + 1, j, n, m);
else
return solve(i, j - 1, n, m);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t = 1;
while (t--) {
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cin >> arr[i][j];
}
while (k--) {
int x;
cin >> x;
--x;
cout << solve(0, x, n, m) + 1 << " ";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> adj[200001];
vector<long long> adj1[64];
long long n;
long long parent[200001];
long long helper() {
long long ans = INT_MAX;
for (long long i = 1; i <= n; i++) {
vector<long long> dist(n + 2, (long long)(1e9));
vector<long long> par(n + 1, -1);
dist[i] = 0;
queue<long long> q;
q.push(i);
while (!q.empty()) {
long long x = q.front();
q.pop();
for (long long child : adj[x]) {
if (dist[child] == (long long)(1e9)) {
dist[child] = 1 + dist[x];
par[child] = x;
q.push(child);
} else if (par[x] != child and par[child] != x)
ans = min(ans, dist[x] + dist[child] + 1);
}
}
}
if (ans == INT_MAX)
return -1;
else
return ans;
}
void solve() {
cin >> n;
bool ok = 0;
for (long long i = 1; i <= n; i++) {
long long a;
cin >> a;
long long ind = 0;
if (a == 0) {
i--, n--;
continue;
}
while (a > 0) {
if (a & 1) {
adj1[ind].push_back(i);
if (adj1[ind].size() > 1) ok = 1;
if (adj1[ind].size() >= 3) {
cout << 3 << endl;
exit(0);
}
}
a /= 2;
ind++;
}
}
if (!ok) {
cout << -1 << endl;
return;
}
long long cal = 0;
for (long long i = 0; i < 64; i++) {
assert(adj1[i].size() < 3);
if (adj1[i].size() == 2) {
long long val1 = adj1[i][0];
long long val2 = adj1[i][1];
adj[val1].push_back(val2);
adj[val2].push_back(val1);
cal++;
}
}
assert(cal < 64);
cout << helper() << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long modpow(long long base, long long exp, long long modulus) {
base %= modulus;
long long result = 1;
while (exp > 0) {
if (exp & 1) result = (result * base) % modulus;
base = (base * base) % modulus;
exp >>= 1;
}
return result;
}
int main() {
int t;
cin >> t;
while (t--) {
string second;
cin >> second;
map<char, int> m;
string ss = "";
int c = 1;
for (int i = 0; i < second.length(); i++) {
if (second[i] == second[i + 1])
c++;
else {
if (m[second[i]] == 0) {
if (c % 2) {
ss += second[i];
m[second[i]] = 1;
}
}
c = 1;
}
}
sort(ss.begin(), ss.end());
cout << ss << "\n";
}
return false;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
vector<pair<int, int> > vec[1001];
int dist[1001][1001];
int vis[1001];
int n, m, k;
vector<pair<int, int> > des;
struct compare {
bool operator()(const pair<int, int> &a, const pair<int, int> &b) const {
return (a.first > b.first);
}
};
void dijkstra(int src) {
int a, b, c, i, j, k;
int u, v, w;
priority_queue<pair<int, int>, vector<pair<int, int> >, compare> q;
memset(vis, 0, sizeof(vis));
q.push(pair<int, int>(0, src));
while (!q.empty()) {
pair<int, int> temp = q.top();
q.pop();
u = temp.second;
w = temp.first;
if (vis[u] == 1)
continue;
else
vis[u] = 1;
for (i = 0; i < vec[u].size(); i++) {
v = vec[u][i].first;
w = vec[u][i].second;
if (dist[src][v] > dist[src][u] + w) {
dist[src][v] = dist[src][u] + w;
q.push(pair<int, int>(dist[src][v], v));
}
}
}
return;
}
int main() {
int a, b, c, i, j, w, sum = 0, mn, p, q, cur, temp;
int u, v;
cin >> n >> m >> k;
for (i = 0; i <= n; i++) {
for (j = 0; j <= n; j++) dist[i][j] = INT_MAX;
}
for (i = 1; i <= n; i++) dist[i][i] = 0;
for (i = 0; i < m; i++) {
cin >> a >> b >> w;
vec[a].push_back(pair<int, int>(b, w));
vec[b].push_back(pair<int, int>(a, w));
}
for (i = 0; i < k; i++) {
cin >> a >> b;
des.push_back(pair<int, int>(a, b));
}
for (i = 1; i <= n; i++) {
dijkstra(i);
}
sum = INT_MAX;
for (j = 1; j <= n; j++) {
for (p = 0; p < vec[j].size(); p++) {
cur = 0;
a = j;
b = vec[j][p].first;
for (i = 0; i < k; i++) {
u = des[i].first;
v = des[i].second;
temp = min(dist[u][a] + dist[v][b], dist[v][a] + dist[u][b]);
cur += min(temp, dist[u][v]);
}
sum = min(sum, cur);
}
}
cout << sum << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 998244353;
int lim = 1000000;
int main(){
std::ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin>>n;
vector<ll> nd(n+1,0);
for(int i=1;i<=n;++i){
for(int j=2*i;j<=n;j+=i){
++nd[j];
}
}
vector<ll> res(n+1,0);
ll sum = 1;
res[0]=1;
for(int i=1;i<=n;++i){
res[i]=(sum+nd[i])%MOD;
sum=(sum+res[i])%MOD;
}
cout<<res[n]<<flush;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char **argv) {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
int Rows[n], Col[m], X[k];
for (int i = 0; i < n; i++) Rows[i] = -1;
for (int j = 0; j < m; j++) Col[j] = -1;
for (int i = 0; i < k; i++) {
X[i] = 0;
int t, rc;
scanf("%d%d%d", &t, &rc, &X[i]);
if (t == 1)
Rows[rc - 1] = i;
else
Col[rc - 1] = i;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (max(Rows[i], Col[j]) == -1)
cout << 0 << " ";
else
printf("%d ", X[max(Rows[i], Col[j])]);
}
printf("\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
const int INF = 0x3f3f3f3f;
int n;
long long k;
long long pri[N], pn;
int cnt[N], ts[N];
long long a[N];
pair<int, long long> dp[N][1 << 13];
int path[N][1 << 13][2];
int s[N];
int ans[N], an;
void print(int n, int s) {
if (n == 0) return;
print(n - 1, path[n][s][0]);
if (path[n][s][1]) ans[an++] = path[n][s][1];
}
int tmp[20], tn;
int get(int a, int b) {
tn = 0;
for (int i = 0; i < pn; i++) {
tmp[tn++] = min(cnt[i], a % (cnt[i] + 1) + b % (cnt[i] + 1));
a /= (cnt[i] + 1);
b /= (cnt[i] + 1);
}
int ans = 0;
for (int i = tn - 1; i >= 0; i--) ans = ans * (cnt[i] + 1) + tmp[i];
return ans;
}
int main() {
while (~scanf("%d%lld", &n, &k)) {
if (k == 1) {
long long Min = 1;
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
if (a[i] < a[Min]) Min = i;
}
printf("1\n%lld\n", Min);
continue;
}
for (long long i = 2; i * i <= k; i++) {
if (k % i == 0) {
pri[pn++] = i;
while (k % i == 0) {
k /= i;
cnt[pn - 1]++;
}
}
}
if (k != 1) {
cnt[pn] = 1;
pri[pn++] = k;
}
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
s[i] = 0;
long long aa = a[i];
for (int j = pn - 1; j >= 0; j--) {
s[i] *= (cnt[j] + 1);
while (aa % pri[j] == 0) {
aa /= pri[j];
s[i]++;
}
}
}
ts[0] = cnt[0] + 1;
for (int i = 1; i < pn; i++) ts[i] = (cnt[i] + 1) * ts[i - 1];
for (int j = 0; j < ts[pn - 1]; j++) dp[0][j] = make_pair(INF, 0LL);
dp[0][0] = make_pair(0, 0LL);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < ts[pn - 1]; j++) dp[i][j] = make_pair(INF, 0LL);
for (int j = 0; j < ts[pn - 1]; j++) {
pair<int, long long> sb =
make_pair(dp[i - 1][j].first + 1, dp[i - 1][j].second + a[i]);
int jj = get(j, s[i]);
if (dp[i][jj] > sb) {
dp[i][jj] = sb;
path[i][jj][0] = j;
path[i][jj][1] = i;
}
if (dp[i][j] > dp[i - 1][j]) {
dp[i][j] = dp[i - 1][j];
path[i][j][0] = j;
path[i][j][1] = 0;
}
}
}
if (dp[n][ts[pn - 1] - 1].first == INF)
printf("-1\n");
else {
an = 0;
print(n, ts[pn - 1] - 1);
printf("%d\n", an);
for (int i = 0; i < an; i++) printf("%d ", ans[i]);
printf("\n");
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
map<long long, long long> mp, st, en;
long long n;
int main() {
cin >> n;
long long x, y, xx;
vector<pair<long long, long long>> vect;
for (long long i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
vect.push_back({a, b});
}
sort((vect).begin(), (vect).end());
for (long long i = 0; i < n; i++) {
x = vect[i].first;
y = vect[i].second;
xx = x;
if (en[x] == 1) {
x--;
}
st[xx] = 1;
en[y] = 1;
mp[x]++;
mp[y]--;
}
long long cnt = 0, maxi = 0;
for (auto i : mp) {
cnt += i.second;
maxi = max(cnt, maxi);
}
if (maxi <= 2)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> e[30];
int vis[30];
vector<int> ord;
bool dfs(int v) {
if (vis[v] == 2) return true;
if (vis[v] == 1) return false;
vis[v] = 1;
for (int u : e[v]) {
if (!dfs(u)) return false;
}
vis[v] = 2;
ord.push_back(v);
return true;
}
int main() {
int n;
cin >> n;
vector<string> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
bool ok = 1;
for (int i = 0; i < n - 1; i++) {
int j = 0;
while (j < a[i].size() && j < a[i + 1].size() && a[i + 1][j] == a[i][j])
++j;
if (j == a[i + 1].size() && j < a[i].size())
ok = 0;
else if (j < a[i].size() && j < a[i + 1].size()) {
e[a[i][j] - 'a'].push_back(a[i + 1][j] - 'a');
}
}
for (int i = 0; i < 26; i++) ok &= dfs(i);
if (!ok)
cout << "Impossible\n";
else {
reverse((ord).begin(), (ord).end());
for (int i = 0; i < 26; i++) cout << char(ord[i] + 'a');
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
double a[N], b[N];
char s[N];
int n, m;
int main() {
scanf("%d%s", &n, &s);
m = n;
for (int i = 0; i < n; i++) a[i] = s[i] - '0';
for (int i = 2; i <= n; i++)
if (m % i == 0) {
while (i >= 2 && m % i == 0) m /= i;
for (int j = 0; j < n; j++) b[j] = a[j];
for (int j = 0; j < n; j++) a[j] = b[(j + n / i) % n] - b[j];
}
for (int i = 0; i < n; i++)
if (fabs(a[i]) > 1e-8) return puts("NO"), 0;
puts("YES");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
//int dirs[4][2]={{-1,0},{1,0},{0,-1},{0,1}};
//int dirs[8][2]={{-1,0},{0,-1},{0,1},{1,0},{1,1},{-1,-1},{-1,1},{1,-1}};
long long modd=1e9+7;
vector<int> dsu;
vector<int> height;
vector<bool> has_loop;
int find_leader(int u)
{
if(dsu[u]==u) return u;
return dsu[u]=find_leader(dsu[u]);
}
void voeg_samen(int u, int v)
{
u=find_leader(u);
v=find_leader(v);
if(u==v) return;
if(height[u]>height[v])
{
dsu[v]=u;
if(has_loop[v]) has_loop[u]=true;
}
else if(height[u]<height[v])
{
dsu[u]=v;
if(has_loop[u]) has_loop[v]=true;
}
else
{
dsu[u]=v;
height[v]++;
if(has_loop[u]) has_loop[v]=true;
}
}
int main()
{
//ios::sync_with_stdio(false);
//freopen("inp.in","r",stdin);
//freopen("outp.out","w",stdout);
int n, m;
scanf("%d %d", &n, &m);
dsu.assign(m,-1);
has_loop.assign(m,false);
height.assign(m,0);
for(int i=0; i<m; i++)
{
dsu[i]=i;
}
vector<int> ans_indices;
for(int i=0; i<n; i++)
{
int k;
scanf("%d", &k);
if(k==1)
{
int u;
scanf("%d", &u);
u--;
int leader=find_leader(u);
if(has_loop[leader])
{
continue;
}
else
{
has_loop[leader]=true;
ans_indices.push_back(i);
}
}
else
{
int u, v;
scanf("%d %d", &u, &v);
u--;
v--;
int ld1=find_leader(u);
int ld2=find_leader(v);
//cerr << u << " " << v << endl;
//cerr << ld1 << " " << ld2 << " " << has_loop[ld1] << " " << has_loop[ld2] << endl;
if((has_loop[ld1]&&has_loop[ld2])||ld1==ld2)
{
continue;
}
else
{
voeg_samen(ld1,ld2);
ans_indices.push_back(i);
}
}
/*for(int j=0; j<m; j++)
{
int ld=find_leader(j);
cerr << j << " has loop: " << has_loop[ld] << endl;
}
cerr << endl;*/
}
long long pow_two=1;
for(int i=0; i<ans_indices.size(); i++)
{
pow_two=(pow_two*2)%modd;
}
int a2=ans_indices.size();
printf("%I64d %d\n",pow_two,a2);
for(int i=0; i<ans_indices.size(); i++)
{
if(i != 0) printf(" ");
printf("%d",ans_indices[i]+1);
}
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5, mod = 998244353;
int f[N][2], pw[N], w[N], tmp1[N], tmp2[N], n, k;
void make(int n) {
f[0][1] = 1;
for (int i = 1; i <= n; i++) {
f[i][0] = 1ll * f[i - 1][1] * (k - 1) % mod;
f[i][1] = (f[i - 1][0] + 1ll * (k - 2) * f[i - 1][1]) % mod;
}
pw[0] = 1;
for (int i = 1; i <= n; i++) pw[i] = 1ll * pw[i - 1] * (k - 1) % mod;
}
int calc(int w[], int n) {
int i = 1, j = n;
for (; i <= n && w[i] == -1; i++)
;
if (i > n) return 1ll * pw[n - 1] * k % mod;
for (; w[j] == -1; j--)
;
int ans = 1ll * pw[i - 1] * pw[n - j] % mod;
for (int k; i < j;) {
k = i + 1;
while (w[k] == -1) k++;
if (w[k] == w[i])
ans = 1ll * ans * f[k - i - 1][0] % mod;
else
ans = 1ll * ans * f[k - i - 1][1] % mod;
i = k;
}
return ans;
}
int main() {
scanf("%d%d", &n, &k);
make(n);
for (int i = 1; i <= n; i++) scanf("%d", w + i);
int n1 = 0, n2 = 0;
for (int i = 1; i <= n; i += 2) tmp1[++n1] = w[i];
for (int i = 2; i <= n; i += 2) tmp2[++n2] = w[i];
cout << 1ll * calc(tmp1, n1) * calc(tmp2, n2) % mod << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
double x, y;
Point(double _x, double _y) : x(_x), y(_y) {}
Point() {}
} P[1000];
int x[1000], y[1000], z[1000];
int n, m;
Point chg(int a, int b, int c, int d, int e, int f) {
if (a == 0 && b == 0) return Point(d, e);
if (b == 0 && c == 0) return Point(e, f);
if (c == 0 && a == 0) return Point(f, d);
double t = -(a * d + b * e + c * f + 0.0) / (a * a + b * b + c * c);
double x = d + t * a, y = e + t * b, z = f + t * c;
double aa = sqrt(x * x + y * y + z * z), bb = sqrt(b * b + c * c),
cc = sqrt(x * x + (c + y) * (c + y) + (z - b) * (z - b));
if (fabs(aa) < 1e-8) return Point(0, 0);
double ang = acos((aa * aa + bb * bb - cc * cc) / (2 * aa * bb));
if (x < 0) ang = -ang;
return Point(aa * cos(ang), aa * sin(ang));
}
Point GetC(double a, double b, double c, double d, double e, double f) {
return Point((c * e - b * f) / (a * e - d * b),
(d * c - a * f) / (b * d - a * e));
}
double Dis(const Point &A, const Point &B) {
return sqrt((A.x - B.x) * (A.x - B.x) + (A.y - B.y) * (A.y - B.y));
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%d%d%d", x + i, y + i, z + i);
for (int j = 0; j < m; ++j) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
for (int i = 0; i < n; ++i) P[i] = (chg(a, b, c, x[i], y[i], z[i]));
random_shuffle(P, P + n);
Point C = P[0];
double R = 0;
for (int i = 1, j, k; i < n; ++i)
if (Dis(P[i], C) > R + 1e-12) {
C = P[i];
R = 0;
for (j = 0; j < i; ++j)
if (Dis(P[j], C) > R + 1e-12) {
C = Point((P[i].x + P[j].x) / 2, (P[i].y + P[j].y) / 2);
R = Dis(P[j], C);
for (k = 0; k < j; ++k)
if (Dis(C, P[k]) > R + 1e-12) {
C = GetC(P[j].x - P[i].x, P[j].y - P[i].y,
-(P[i].x * P[i].x + P[i].y * P[i].y - P[j].x * P[j].x -
P[j].y * P[j].y) /
2,
P[k].x - P[i].x, P[k].y - P[i].y,
-(P[i].x * P[i].x + P[i].y * P[i].y - P[k].x * P[k].x -
P[k].y * P[k].y) /
2);
R = Dis(P[k], C);
}
}
}
printf("%.9lf\n", R);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m, mark[4][155], ok;
char s[4][155];
void dfs(int x, int y) {
if (ok) return;
if (y >= n) {
ok = 1;
return;
}
if (mark[x][y] || s[x][y + 1] != '.') return;
mark[x][y] = 1;
if (s[x][y + 2] == '.' && s[x][y + 3] == '.') dfs(x, y + 3);
if (x - 1 >= 1 && s[x - 1][y + 1] == '.' && s[x - 1][y + 2] == '.' &&
s[x - 1][y + 3])
dfs(x - 1, y + 3);
if (x + 1 <= 3 && s[x + 1][y + 1] == '.' && s[x + 1][y + 2] == '.' &&
s[x + 1][y + 3])
dfs(x + 1, y + 3);
}
void solve() {
scanf("%d%d", &n, &m);
int x;
for (int i = 1; i <= 3; i++) {
scanf("%s", s[i] + 1);
if (s[i][1] == 's') x = i;
for (int j = n + 1; j <= n + 3; j++) s[i][j] = '.';
}
memset(mark, 0, sizeof(mark));
ok = 0;
dfs(x, 1);
if (ok)
printf("YES\n");
else
printf("NO\n");
}
int main() {
int T;
scanf("%d", &T);
while (T--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,inline,unroll-loops,fast-math")
using namespace std;
class Node {
public:
Node *s[2];
Node *p;
Node *q;
Node(void) {
s[0] = s[1] = p = q = NULL;
return;
}
bool Relation(void) { return this == p->s[1]; }
};
int n;
Node a[100020];
vector<pair<int, int> > e[100020];
vector<pair<long long, long long> > b[100020];
long long c[100020], d[100020];
int l[100020], r[100020], p[100020], f[100020 << 1];
void SetSegwin(int p, int v) {
for (f[p += n] = v; p >>= 1;) f[p] = max(f[p << 1], f[p << 1 | 1]);
return;
}
int MaxSegwin(int l, int r) {
int o;
for (o = 0, l += n, r += n + 1; l < r; l >>= 1, r >>= 1) {
if (l & 1) o = max(o, f[l++]);
if (r & 1) o = max(o, f[--r]);
}
return o;
}
void RotateLCT(Node *x) {
Node *p;
int k;
p = x->p;
k = x->Relation();
x->q = p->q;
p->q = NULL;
x->p = p->p;
if (x->p) x->p->s[p->Relation()] = x;
p->s[k] = x->s[!k];
if (p->s[k]) p->s[k]->p = p;
x->s[!k] = p;
p->p = x;
return;
}
void SplayLCT(Node *x) {
while (x->p)
if (x->p->p) {
if (x->Relation() == x->p->Relation())
RotateLCT(x->p);
else
RotateLCT(x);
RotateLCT(x);
} else
RotateLCT(x);
return;
}
void ExposeLCT(Node *x) {
SplayLCT(x);
if (x->s[1]) {
x->s[1]->q = x;
x->s[1]->p = NULL;
x->s[1] = NULL;
}
return;
}
bool SpliceLCT(Node *x, int w) {
int p, t;
SplayLCT(x);
if (!x->q) return false;
p = (int)(x->q - a);
t = MaxSegwin(l[p], r[p]);
b[p].push_back(make_pair(!t ? 1 : t + d[p] + 1, w + d[p]));
ExposeLCT(x->q);
x->q->s[1] = x;
x->p = x->q;
x->q = NULL;
return true;
}
void AccessLCT(Node *x, int w) {
while (SpliceLCT(x, w))
;
return;
}
void DFS(int x) {
static int k;
int i, v;
l[x] = k++;
for (i = 0; i < (signed)e[x].size(); i++) {
v = e[x][i].first;
d[v] = d[x] + e[x][i].second;
p[v] = x;
if (i == (signed)e[x].size() - 1) {
a[v].p = &a[x];
a[x].s[1] = &a[v];
} else
a[v].q = &a[x];
DFS(v);
}
r[x] = k - 1;
return;
}
int main(void) {
int m, u, v, w;
int i, j;
long long t;
vector<pair<long long, long long> > s;
priority_queue<long long> r;
priority_queue<long long, vector<long long>, greater<long long> > q;
scanf("%d %d", &n, &m);
for (i = 1; i < n; i++) {
scanf("%d %d %d", &u, &v, &w);
e[u].push_back(make_pair(v, w));
}
DFS(1);
while (m--) {
scanf("%d %d", &u, &w);
AccessLCT(&a[u], w);
if (u != 1) SetSegwin(l[p[u]], w);
}
for (i = 1; i <= n; i++)
for (j = 0; j < (signed)b[i].size(); j++) s.push_back(b[i][j]);
sort(s.begin(), s.end());
for (t = 1, i = j = 0; i < (signed)s.size() || !q.empty();) {
for (; i < (signed)s.size() && s[i].first == t; i++) q.push(s[i].second);
if (!q.empty()) {
if (q.top() < t) {
for (; !r.empty() && r.top() >= q.top(); r.pop()) j--;
printf("%lld %d\n", q.top(), j);
return 0;
}
j++;
r.push(q.top());
q.pop();
}
if (q.empty()) {
if (i == (signed)s.size()) break;
t = s[i].first;
} else
t++;
}
printf("-1 %d\n", (int)s.size());
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> ans;
int main() {
long long p, k;
cin >> p >> k;
k = -k;
while (p) {
long long md = p % k;
p /= k;
if (md < 0) {
md += abs(k);
p++;
}
ans.push_back(md);
}
printf("%d\n", (int)ans.size());
for (int i = 0; i < ans.size(); i++) printf("%lld ", ans[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
double a, b, l;
double eps = 1e-8;
double func(double x) {
return (x * a + sqrt(l * l - x * x) * b - sqrt(l * l - x * x) * x) / l;
}
double tsearch(double l, double r) {
if (r - l < eps) return (l + r) / 2;
double a = (2 * l + r) / 3;
double b = (l + 2 * r) / 3;
if (func(a) < func(b)) return tsearch(l, b);
return tsearch(a, r);
}
void solve() {
cin >> a >> b >> l;
if (l <= b) {
printf("%.9lf", min(a, l));
return;
}
if (l <= a) {
printf("%.9lf", min(b, l));
return;
}
double ans = func(tsearch(0, l));
if (ans < eps)
printf("My poor head =(\n");
else
printf("%.9lf\n", min(ans, l));
}
int main() {
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > A, B;
vector<int> R, T;
map<pair<int, int>, int> ID, P;
int f(int first, int second) { return (first + second); }
void build(int ver, int p, int q) {
int med = (p + q) / 2, left = 2 * ver + 1, rigth = 2 * ver + 2;
if (p == q) {
T[ver] = 1;
return;
}
build(left, p, med);
build(rigth, med + 1, q);
T[ver] = f(T[left], T[rigth]);
}
void update(int ver, int p, int q, int valor, int i) {
int med = (p + q) / 2, left = 2 * ver + 1, rigth = 2 * ver + 2;
if (p == q && p == i) {
T[ver] = valor;
return;
}
if (i <= med)
update(left, p, med, valor, i);
else
update(rigth, med + 1, q, valor, i);
T[ver] = f(T[left], T[rigth]);
}
int query(int ver, int p, int q, int l, int r) {
int med = (p + q) / 2, left = 2 * ver + 1, rigth = 2 * ver + 2;
if (l == p && r == q) return T[ver];
if (r <= med) return query(left, p, med, l, r);
if (l > med) return query(rigth, med + 1, q, l, r);
return f(query(left, p, med, l, med), query(rigth, med + 1, q, med + 1, r));
}
int main() {
int n;
while (cin >> n) {
T.resize(3 * n);
build(0, 0, n - 1);
A.resize(n);
B.resize(n);
R.resize(n);
ID.clear();
P.clear();
int first, second;
for (int i = 0; i < n; i++) {
cin >> first >> second;
A[i] = pair<int, int>(second, first);
B[i] = pair<int, int>(first, second);
ID[pair<int, int>(first, second)] = i;
}
sort(A.begin(), A.end());
sort(B.begin(), B.end());
for (int i = 0; i < n; i++) P[B[i]] = i;
for (int i = 0; i < n; i++) swap(A[i].first, A[i].second);
for (int i = n - 1; i >= 0; i--) {
update(0, 0, n - 1, 0, P[A[i]]);
int a = 0, b = n - 1, c;
int k = -1, res = 0;
if ((A[i].first) < (B[0].first)) k = 0;
if ((A[i].first) >= (B[n - 1].first)) k = n;
if (k == -1) {
while (b - a > 1) {
c = (a + b) / 2;
if ((A[i].first) >= (B[c].first))
a = c;
else
b = c;
}
k = b;
}
if (k < n) res += query(0, 0, n - 1, k, n - 1);
R[ID[A[i]]] = res;
}
for (int i = 0; i < n; i++) cout << R[i] << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, ans, mid, mn, mx, T, sum, h1, h2, e[1234567], b[1234567],
c[1234567], d[1 << 20], k, i, j, l, r, h, a[1234567], w, x, y, z, res,
par[1234567], cnt, sz[1234567];
bool used[1234567];
vector<long long> v[1234567], vec1;
string s1, s;
vector<pair<long long, long long> > vp[1234567];
bool ok;
long long cc[323456][30];
set<long long> st;
int main() {
cin >> s;
for (long long k = 0; k <= s.size() - 1; k++) {
i = k + 1;
for (long long j = 'a' - 'a'; j <= 'z' - 'a'; j++) cc[i][j] = cc[i - 1][j];
cc[i][s[k] - 'a']++;
}
cin >> T;
while (T--) {
cin >> l >> r;
long long cnt = 0;
for (long long j = 'a' - 'a'; j <= 'z' - 'a'; j++) {
if (cc[l - 1][j] != cc[r][j]) cnt++;
}
if (cnt > 2 || s[l - 1] != s[r - 1] || l == r)
puts("Yes");
else
puts("No");
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, a[100005] = {0}, ans;
int main() {
int i, j, k, h;
scanf("%d", &n);
ans = 1, h = 1;
scanf("%d", &j);
a[j] = 1;
for (i = 2; i <= n; i++) {
scanf("%d", &k);
if (k == j)
h++;
else if (k == j + 1)
h = min(i - a[k - 2], h + 1);
else if (k == j - 1)
h = min(i - a[k + 2], h + 1);
a[k] = i;
j = k;
ans = max(ans, h);
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300005, INF = 99999999;
const long long P = 1e9 + 7;
template <typename T>
inline void read(T& first, char s = getchar()) {
for (first = 0; s > '9' || s < '0';) s = getchar();
while (s <= '9' && s >= '0') first = first * 10 + s - '0', s = getchar();
}
template <typename T>
bool chkmin(T& a, T b) {
return b < a ? a = b, 1 : 0;
}
template <typename T>
bool chkmax(T& a, T b) {
return b > a ? a = b, 1 : 0;
}
int a, b;
int la, lb;
bool check(int first) {
bool v[7] = {0};
int X = first;
for (int i = (int)(1); i <= (int)(la + lb); ++i) {
int second = X % 7;
if (v[second]) {
return 0;
}
v[second] = 1;
X /= 7;
}
int A = 0, B = 0, base = 1;
for (int i = (int)(1); i <= (int)(lb); ++i) {
int second = first % 7;
B += base * second;
first /= 7;
base *= 7;
}
A = first;
return A < a && B < b;
}
int main() {
cin >> a >> b;
int A = a - 1, B = b - 1;
while (A) la++, A /= 7;
while (B) lb++, B /= 7;
chkmax(la, 1), chkmax(lb, 1);
if (la + lb > 7) {
cout << 0 << endl;
return 0;
}
int ans = 0;
for (int i = (int)(0); i < (int)(pow(7, la + lb)); ++i) {
ans += check(i);
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2005;
vector<int> edge[maxn], root;
int n, ans = 0, a;
void dfs(int node, int par, int depth) {
depth++;
ans = max(depth, ans);
for (int v : edge[node]) {
if (v == par) {
continue;
}
dfs(v, node, depth);
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a;
if (a == -1) {
root.push_back(i);
continue;
}
edge[a].push_back(i);
edge[i].push_back(a);
}
for (int i = 0; i < root.size(); i++) dfs(root[i], -1, 0);
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long target = n + k + 1;
long long sqrtar = sqrt(2 * target);
cout << n - sqrtar + 1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int MOD = 1e9 + 7;
const int MAXN = 1e6 + 3;
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) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long power(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = res * x;
y = y >> 1;
x = x * x;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
set<int> x;
for (long long i = 0; i < (n); ++i) {
int a;
cin >> a;
x.insert(a);
}
cout << x.size() << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int t, j;
scanf("%d", &t);
for (j = 1; j <= t; j++) {
int n, d = 0, i;
char a[100000], b[100000], c[100000];
scanf("%s %s %s", a, b, c);
n = strlen(a);
for (i = 0; i < n; i++) {
if (a[i] == c[i] || b[i] == c[i]) d++;
if (a[i] == b[i] && b[i] != c[i]) break;
}
if (d == n)
printf("YES\n");
else
printf("NO\n");
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool isPowerOfTwo(long long n) { return (ceil(log2(n)) == floor(log2(n))); }
long long binpow(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res *= a;
a = a * a;
b >>= 1;
}
return res;
}
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
bool x = false;
if ((a.second * a.first) < b.second * b.first) {
x = true;
}
return x;
}
int main() {
long long n;
cin >> n;
long long arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
vector<long long> v;
long long x = 1;
for (long long i = 0; i + 1 < n; i++) {
if (arr[i] == arr[i + 1])
x++;
else {
v.push_back(x);
x = 1;
}
}
v.push_back(x);
long long now;
long long best = 0;
for (long long i = 0; i + 1 < v.size(); i++) {
now = min(v[i], v[i + 1]);
best = max(best, now);
}
cout << best * 2 << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool appeared[10000000] = {false};
void print_s1(int s1) { cout << setfill('0') << setw(9) << s1 << endl; }
int main(void) {
int a, b, mod;
cin >> a >> b >> mod;
int suffix = 1000000000;
int m = suffix % mod;
int curr_m = 0;
bool p1_win = false;
int s1 = a;
int limit = min(a, mod);
if (b < mod && m != 0) {
for (int i = 1; i <= limit; i++) {
curr_m = (curr_m + m) % mod;
if (appeared[curr_m]) {
break;
} else {
appeared[curr_m] = true;
}
if (curr_m != 0 && curr_m + b < mod) {
p1_win = true;
s1 = i;
break;
}
int step = (mod - curr_m) / m;
curr_m = (curr_m + m * step) % mod;
i += step;
}
}
if (p1_win) {
cout << 1 << " ";
print_s1(s1);
} else {
cout << 2 << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int gao(int n, int k, int t) {
int m = 2 * (n - 1);
int x = t / m * m;
int y = t % m;
if (k >= 1 + y) {
x += k - 1;
} else if (k <= n - (y - (n - 1))) {
x += (n - 1) + (n - k);
} else {
x += m + k - 1;
}
return x;
}
int main() {
int n, m, a, b, c;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%d%d%d", &a, &b, &c);
if (a != b) {
c = gao(m, a, c);
c = gao(m, b, c);
}
printf("%d\n", c);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long binpow(long long a, long long b) {
long long exp = 1000000007;
a %= exp;
long long res = 1;
while (b > 0) {
if (b & 1) res = ((res) * (a)) % exp;
a = ((a) * (a)) % exp;
b >>= 1;
}
return res;
}
bool isprime(long long x) {
for (long long d = 2; d * d <= x; d++) {
if (x % d == 0) return false;
}
return true;
}
unsigned int cntsb(unsigned int n) {
unsigned int count = 0;
while (n) {
count += n & 1;
n >>= 1;
}
return count;
}
int LCSubStr(string X, string Y, int m, int n) {
int LCSuff[m + 1][n + 1];
int result = 0;
for (int i = 0; i <= m; i++) {
for (int j = 0; j <= n; j++) {
if (i == 0 || j == 0)
LCSuff[i][j] = 0;
else if (X[i - 1] == Y[j - 1]) {
LCSuff[i][j] = LCSuff[i - 1][j - 1] + 1;
result = max(result, LCSuff[i][j]);
} else
LCSuff[i][j] = 0;
}
}
return result;
}
void solve(int cas) {}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int number = 0;
int n;
cin >> n;
float ans = 0;
for (int i = 1; i < n + 1; i++) {
ans += 1 / (float(i));
}
printf("%.10f", ans);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a / gcd(a, b) * b); }
bool sorta(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
bool sortd(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second > b.second);
}
void printarr(long long arr[], long long n) {
for (int i = 0; i < n; i++) cout << arr[i] << " ";
cout << "\n";
}
string decToBinary(int n) {
string s = "";
int i = 0;
while (n > 0) {
s = to_string(n % 2) + s;
n = n / 2;
i++;
}
return s;
}
long long binaryToDecimal(string n) {
string num = n;
long long dec_value = 0;
int base = 1;
int len = num.length();
for (int i = len - 1; i >= 0; i--) {
if (num[i] == '1') dec_value += base;
base = base * 2;
}
return dec_value;
}
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;
}
bool isPowerOfTwo(int n) {
if (n == 0) return false;
return (ceil(log2(n)) == floor(log2(n)));
}
void asquare() {
long long n;
cin >> n;
string s;
cin >> s;
long long ones = 0, twos = 0;
char arr[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
arr[i][j] = 'A';
}
}
bool ok = false;
for (int i = 0; i < n; i++) {
if (s[i] == '1')
ones++;
else
twos++;
}
if (twos == 1 || twos == 2) {
cout << "NO\n";
} else {
long long x = 1;
cout << "YES\n";
for (int i = 0; i < n; i++) {
x = 1;
for (int j = i; j < n; j++) {
if (i == j) {
arr[i][j] = 'X';
continue;
}
if (s[i] == '1') {
arr[i][j] = '=';
arr[j][i] = '=';
} else {
if (x == 1 && s[j] == '2') {
arr[i][j] = '+';
arr[j][i] = '-';
x = 2;
} else {
arr[i][j] = '-';
arr[j][i] = '+';
}
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cout << arr[i][j];
}
cout << "\n";
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
asquare();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, sum;
int main() {
cin >> n;
while (n != 0) {
if (n % 8 == 1) sum++;
n /= 8;
}
cout << sum;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int sig(double x) { return (x > 1e-8) - (x < -1e-8); }
struct P {
double x, y;
P(double a = 0, double b = 0) : x(a), y(b) {}
P operator+(const P &a) const { return P(x + a.x, y + a.y); }
P operator-(const P &a) const { return P(x - a.x, y - a.y); }
double operator*(const P &a) const { return x * a.x + y * a.y; }
double operator^(const P &a) const { return x * a.y - y * a.x; }
int operator<(const P &a) const {
if (a.x != x)
return x < a.x;
else
return y < a.y;
}
};
P a, b, w1, w2, m1, m2;
int inter(P a, P b, P c, P d) {
int ok = 1;
ok = ok && (min(a.x, b.x) <= max(c.x, d.x) + 1e-8);
ok = ok && (max(a.x, b.x) >= min(c.x, d.x) - 1e-8);
ok = ok && (min(a.y, b.y) <= max(c.y, d.y) + 1e-8);
ok = ok && (max(a.y, b.y) >= min(c.y, d.y) - 1e-8);
ok = ok && (sig(((b - a) ^ (c - a)) * ((b - a) ^ (d - a))) <= 0);
ok = ok && (sig(((d - c) ^ (b - c)) * ((d - c) ^ (a - c))) <= 0);
return ok;
}
P change(P t) {
double d, e, f, g;
e = m2.y - m1.y, f = m1.x - m2.x, g = m2.x * m1.y - m1.x * m2.y;
d = e * e + f * f;
P ans;
ans.x = f * f * t.x - e * e * t.x - 2 * e * f * t.y - 2 * e * g;
ans.x /= d;
ans.y = e * e * t.y - f * f * t.y - 2 * e * f * t.x - 2 * f * g;
ans.y /= d;
return ans;
}
int main() {
while (~scanf("%lf%lf%lf%lf", &a.x, &a.y, &b.x, &b.y)) {
scanf("%lf%lf%lf%lf", &w1.x, &w1.y, &w2.x, &w2.y);
scanf("%lf%lf%lf%lf", &m1.x, &m1.y, &m2.x, &m2.y);
if (sig((m1 - a) ^ (m2 - a)) * sig((m1 - b) ^ (m2 - b)) == 0) {
if (!inter(a, b, w1, w2))
printf("YES\n");
else
printf("NO\n");
continue;
}
int flag = 1;
if (inter(a, b, w1, w2) || inter(a, b, m1, m2)) {
flag = 0;
P b1 = change(b), w11 = change(w1), w22 = change(w2);
if (inter(a, b1, m1, m2) && !inter(a, b1, w1, w2) &&
!inter(a, b1, w11, w22))
flag = 1;
}
if (flag)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int next, val;
};
int edge[200010][2];
vector<Edge> V[200010];
int dp[200010][2];
int ans;
void dfs1(int u, int pre, int r) {
dp[u][0] = 0;
for (int i = 0; i < V[u].size(); i++) {
int son = V[u][i].next;
if (son == pre || son == r) continue;
dfs1(son, u, r);
dp[u][0] += dp[son][0] + V[u][i].val;
}
}
void dfs2(int u, int pre, int i, int r) {
if (u == pre)
dp[u][1] = dp[u][0];
else {
if (V[pre][i].val == 1)
dp[u][1] = dp[pre][1] - 1;
else
dp[u][1] = dp[pre][1] + 1;
}
ans = min(ans, dp[u][1]);
for (int i = 0; i < V[u].size(); i++) {
int son = V[u][i].next;
if (son == pre || son == r) continue;
dfs2(son, u, i, r);
}
}
int main() {
int n;
while (cin >> n) {
if (n == 1) {
cout << 0 << endl;
continue;
}
for (int i = 1; i <= n; i++) V[i].clear();
for (int i = 1; i < n; i++) {
cin >> edge[i][0] >> edge[i][1];
Edge E;
E.next = edge[i][1];
E.val = 0;
V[edge[i][0]].push_back(E);
E.next = edge[i][0];
E.val = 1;
V[edge[i][1]].push_back(E);
}
int minn = (1 << 30);
for (int i = 1; i < n; i++) {
int u = edge[i][0], v = edge[i][1];
int ans1, ans2;
ans = (1 << 30);
dfs1(u, u, v);
dfs2(u, u, -1, v);
ans1 = ans;
ans = (1 << 30);
dfs1(v, v, u);
dfs2(v, v, -1, u);
ans2 = ans;
minn = min(ans1 + ans2, minn);
}
cout << minn << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
struct node {
int d[60];
node operator+(const node& t) const {
node tmp;
for (int i = 0; i < 60; i++)
tmp.d[i] = this->d[i] + t.d[(i + (this->d[i])) % 60];
return tmp;
}
} a[maxn * 4];
void up(int k, int l, int r, int p, int val) {
if (l == r) {
for (int i = 0; i < 60; i++) {
if (i % val == 0)
a[k].d[i] = 2;
else
a[k].d[i] = 1;
}
} else {
int m = (l + r) / 2;
if (p <= m)
up(k << 1, l, m, p, val);
else if (p > m)
up(k << 1 | 1, m + 1, r, p, val);
a[k] = a[k << 1] + a[k << 1 | 1];
}
}
node qu(int k, int l, int r, int L, int R) {
if (l >= L && r <= R) return a[k];
int m = (l + r) / 2;
if (R <= m)
return qu(k << 1, l, m, L, R);
else if (L > m)
return qu(k << 1 | 1, m + 1, r, L, R);
return qu(k << 1, l, m, L, R) + qu(k << 1 | 1, m + 1, r, L, R);
}
int main() {
int n, q;
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
up(1, 1, n, i, x);
}
cin >> q;
while (q--) {
char aa;
int bb, cc;
cin >> aa >> bb >> cc;
if (aa == 'A') {
printf("%d\n", qu(1, 1, n, bb, cc - 1).d[0]);
} else {
up(1, 1, n, bb, cc);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> V(1000001, 1);
for (int i = 1; i < 1000000; ++i)
for (int j = 2; i * j < 1000001; ++j) ++V[i * j];
long long res = 0;
int a, b, c;
cin >> a >> b >> c;
for (int i = 1; i <= a; ++i)
for (int j = 1; j <= b; ++j)
for (int k = 1; k <= c; ++k) res += V[i * j * k];
cout << res;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
long long icount = 0;
int main(void) {
cin >> n >> k;
if (k >= n / 2) {
cout << (n - 1) * n / 2 << endl;
return 0;
}
for (int i = 0; i < k; i++) {
icount += (n - i * 2 - 1) * 2;
icount--;
}
cout << icount << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
string second;
cin >> n >> k;
cin >> second;
int len = second.length();
int a[len];
int present[26];
for (int i = 0; i < 26; ++i) {
present[i] = 0;
}
for (int i = 0; i < len; ++i) {
a[i] = second[i];
present[second[i] - 'a']++;
}
char ch = *min_element(a, a + len);
if (n < k) {
cout << second;
for (int i = 1; i <= k - n; ++i) {
cout << ch;
}
cout << endl;
} else {
string s1 = second;
int stop = -1;
for (int i = k - 1; i >= 0; i--) {
for (int j = second[i] - 'a' + 1; j < 26; j++) {
if (present[j]) {
s1[i] = j + 'a';
stop = i;
break;
}
}
if (stop > 0) {
break;
}
}
for (int j = 0; j <= min(stop, k - 1); ++j) {
cout << s1[j];
}
for (int j = min(stop, k - 1) + 1; j < k; ++j) {
cout << ch;
}
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long powermodm(long long x, long long n, long long M) {
long long result = 1;
while (n > 0) {
if (n % 2 == 1) result = (result * x) % M;
x = (x * x) % M;
n = n / 2;
}
return result;
}
long long power(long long _a, long long _b) {
long long _r = 1;
while (_b) {
if (_b % 2 == 1) _r = (_r * _a);
_b /= 2;
_a = (_a * _a);
}
return _r;
}
long long gcd(long long a, long long b) {
while (a && b) a > b ? a %= b : b %= a;
return a + b;
}
long long lcm(long long a, long long b) {
return (max(a, b) / gcd(a, b)) * min(a, b);
}
long long dp[1005][2010][4];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, k;
cin >> n >> k;
long long M = 998244353;
dp[1][1][0] = 1;
dp[1][2][1] = 1;
dp[1][1][2] = 1;
dp[1][2][3] = 1;
for (long long i = 2; i <= n; i++) {
for (long long j = 1; j <= k; j++) {
dp[i][j][0] = (dp[i - 1][j][0] + dp[i - 1][j][1] + dp[i - 1][j - 1][2] +
dp[i - 1][j][3]) %
M;
dp[i][j][1] =
(dp[i - 1][j - 1][0] + dp[i - 1][j][1] + dp[i - 1][j - 1][2]) % M;
if (j >= 2) dp[i][j][1] = (dp[i - 1][j - 2][3] + dp[i][j][1]) % M;
dp[i][j][2] = (dp[i - 1][j - 1][0] + dp[i - 1][j][1] + dp[i - 1][j][2] +
dp[i - 1][j][3]) %
M;
dp[i][j][3] =
(dp[i - 1][j - 1][0] + dp[i - 1][j - 1][2] + dp[i - 1][j][3]) % M;
if (j >= 2) dp[i][j][3] = (dp[i - 1][j - 2][1] + dp[i][j][3]) % M;
}
}
long long ans = (dp[n][k][0] + dp[n][k][1] + dp[n][k][2] + dp[n][k][3]) % M;
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-8;
const int INF = ~0U >> 2;
const int MAXN = 1e6 + 10;
int main() {
int a, b;
while (~scanf("%d%d", &a, &b)) {
bool flag = false;
int x2, x3, y2, y3, sx;
if (a > b) {
int tx = a;
a = b;
b = tx;
}
double a1 = (double)a, b1 = (double)b, temp;
for (int i = a; i >= -a; i--) {
x2 = i;
sx = (double)i;
temp = sqrt(a1 * a1 - sx * sx);
y2 = (int)temp;
if (y2 * y2 + x2 * x2 != a * a) continue;
for (int j = -b; j <= 0; j++) {
x3 = j;
sx = (double)j;
temp = sqrt(b1 * b1 - sx * sx);
y3 = (int)temp;
if (y3 * y3 + x3 * x3 != b * b ||
(x2 - x3) * (x2 - x3) + (y2 - y3) * (y2 - y3) != a * a + b * b)
continue;
if (x2 != x3 && y2 != y3 && x2 && y2 && x3 && y3) {
flag = true;
break;
}
}
if (flag) break;
}
if (flag) {
printf("YES\n");
printf("%d %d\n%d %d\n%d %d\n", 0, 0, x2, y2, x3, y3);
} else
printf("NO\n");
}
return 0;
}
| 4 |
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
bool find(long int A, long int B, int n, vector<long int> a, vector<long int> b) {
int64_t damage = 0;
for(int i = 0; i < n; i++) {
damage += int64_t(b[i] + A - 1) / A * a[i];
}
for(int i = 0; i < n; i++) {
if(B - (damage - a[i]) > 0)
return true;
}
return false;
}
int main() {
int t;
cin>>t;
while(t--) {
long int A, B;
int n;
cin>>A>>B>>n;
vector<long int> a(n);
vector<long int> b(n);
vector<long int> c(n);
long int res = 0, mx = 0;
for(int i = 0; i < n; i++)
cin>>a[i];
for(int i = 0; i < n; i++) {
cin>>b[i];
}
if(find(A, B, n, a, b))
cout<<"YES"<<"\n";
else
cout<<"NO"<<"\n";
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n, m;
int test = 0;
n = s.length();
m = s.find("1");
if (m == -1)
cout << "no";
else {
for (int i = m; i < n; i++) {
if (s[i] == '0') test++;
}
if (test >= 6)
cout << "yes";
else
cout << "no";
}
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long convertToNum(string s) {
long long val = 0;
for (int i = 0; i < (s.size()); i++) val = val * 10 + s[i] - '0';
return val;
}
char bu[50];
string convertToString(int a) {
sprintf(bu, "%d", a);
return string(bu);
}
long long GCD(long long x, long long y) {
if (!x) return y;
if (!y) return x;
if (x == y) return x;
if (x < y)
return GCD(x, y % x);
else
return GCD(x % y, y);
}
long long POW(long long x, long long y, long long Base) {
if (!y) return 1;
long long u = POW(x, y / 2, Base);
u = (u * u) % Base;
if (y & 1)
return (u * x) % Base;
else
return u;
}
void extended_euclid(long long A, long long B, long long &x, long long &y) {
if (A == 1 && B == 0) {
x = 1;
y = 0;
return;
}
if (A < B)
extended_euclid(B, A, y, x);
else {
long long xx, yy;
extended_euclid(A % B, B, xx, yy);
x = xx;
y = yy - (A / B) * xx;
}
}
void OPEN() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
long long N, L, V1, V2;
int a[201000];
long double res[201000];
bool leq(long double X, long double Y) { return abs(X - Y) < 1e-7 || X < Y; }
bool le(long double X, long double Y) { return abs(X - Y) > 1e-7 && X < Y; }
int main() {
cin >> N >> L >> V1 >> V2;
for (int i = (1); i <= (N); i++) scanf("%d", &a[i]);
if (N == 1) {
res[1] = (long double)L / ((long double)V1 / V2 + 1);
res[0] = 2 * L - res[1];
for (int i = (0); i <= (N); i++) {
printf("%.12lf\n", (double)(res[i] / (2 * L)));
}
return 0;
}
a[0] = a[N];
for (int i = (N + 1); i <= (2 * N); i++) a[i] = a[i - N];
int i = N + 1, j = 2 * N, type = 0;
long double delta = 0;
int sl;
while (true) {
if (i == 1 && type == 0) break;
if (!type) {
while (j >= i) {
long long X = (a[j] - a[i]);
if (X < 0) X += 2 * L;
if (X * (V1 + V2) < L * V2)
break;
else
j--;
}
if (j < i) {
i--;
type = 0;
continue;
}
sl = j - i + 1;
long double X = a[j] - a[i];
if (a[j] - a[i] < 0) X += 2 * L;
long double newX = (long double)(L) / ((long double)V1 / V2 + 1) - X;
long double newX2 = a[i] - a[i - 1];
if (a[i] < a[i - 1]) newX2 += 2 * L;
if (leq(newX, newX2)) {
res[sl] += newX;
delta = newX;
sl--;
type = 1;
} else {
res[sl] += newX2;
sl++;
i--;
delta = 0;
type = 0;
}
} else {
while (j >= i) {
long double X = delta + a[j] - a[i];
if (a[j] < a[i]) X += 2 * L;
if (le(X, (long double)L / ((long double)V1 / V2 + 1)))
break;
else
j--;
}
if (j < i) {
i--;
type = 0;
continue;
}
sl = j - i + 1;
long double X = delta + a[j] - a[i];
if (a[j] < a[i]) X += 2 * L;
long double newX = ((long double)(L) / ((long double)V1 / V2 + 1)) - X;
long double newX2 = a[i] - a[i - 1] - delta;
if (a[i] < a[i - 1]) newX2 += 2 * L;
if (leq(newX, newX2)) {
res[sl] += newX;
delta += newX;
sl--;
type = 1;
} else {
res[sl] += newX2;
sl++;
i--;
delta = 0;
type = 0;
}
}
}
res[0] = 2 * L;
for (int i = (1); i <= (N); i++) res[0] -= res[i];
for (int i = (0); i <= (N); i++) {
printf("%.12lf\n", (double)(res[i] / (2 * L)));
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
multiset<int> s;
multiset<int>::iterator it;
int a[100001], ans, b[100001];
int main() {
int n, x;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
a[x] = i;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
s.insert(i - a[b[i]]);
}
for (int i = 0; i < n; i++) {
it = s.lower_bound(i);
ans = 1e5 + 10;
if (it != s.end()) ans = min(ans, *it - i);
if (it != s.begin()) ans = min(ans, i - (*--it));
printf("%d\n", ans);
x = b[i + 1];
s.erase(s.find(i + 1 - a[x]));
s.insert(i + 1 - a[x] + n);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 2e5, MaxM = 4e5;
int n, all;
int pre[MaxM + 5], last[MaxN + 5], other[MaxM + 5];
bool vis[MaxN + 5];
int ans[MaxM + 5], num[MaxM + 5], used[MaxN + 5];
int seq[MaxM + 5];
vector<int> v[MaxN + 5];
void Build(int x, int y, int d) {
pre[++all] = last[x];
last[x] = all;
other[all] = y;
num[all] = d;
}
void Init() {
all = -1;
memset(last, -1, sizeof(last));
for (int i = 1; i <= n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
Build(u, v, i);
Build(v, u, i);
}
}
void Bfs(int s) {
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) v[i].clear();
int head = 1, tail = 0;
seq[++tail] = s;
vis[s] = true;
while (head <= tail) {
int now = seq[head];
int ed = last[now], dr;
int tot = 0;
while (ed != -1) {
dr = other[ed];
if (!vis[dr]) {
++tot;
if (used[now] == tot) ++tot;
ans[num[ed]] = tot;
used[dr] = tot;
seq[++tail] = dr;
vis[dr] = true;
}
ed = pre[ed];
}
head++;
}
int MaX = 0;
for (int i = 1; i <= n - 1; i++)
v[ans[i]].push_back(i), MaX = max(MaX, ans[i]);
printf("%d\n", MaX);
for (int i = 1; i <= MaX; i++) {
printf("%d ", v[i].size());
for (int j = 0; j < v[i].size(); j++) printf("%d ", v[i][j]);
printf("\n");
}
}
int main() {
while (~scanf("%d", &n)) {
Init();
Bfs(1);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
char st[100];
int len = 0, i, j, temp = 0;
scanf("%s", st);
len = strlen(st);
for (i = 0; i < len; i += 2) {
for (j = 0; j < len - 1; j += 2) {
if (st[j] > st[j + 2]) {
temp = st[j];
st[j] = st[j + 2];
st[j + 2] = temp;
}
}
}
printf("%s", st);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N, A, B, X, Ans = 0, C = 0;
int main() {
cin >> N >> A >> B;
for (int i = 1; i <= N; i++) {
cin >> X;
if (X == 1) {
if (A > 0)
A--;
else if (B > 0)
C++, B--;
else if (C > 0)
C--;
else
Ans++;
} else {
if (B > 0)
B--;
else
Ans += 2;
}
}
cout << Ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string s;
cin >> s;
bool hasCW = false, hasCCW = false;
for (int i = 0; i < n; i++) {
if (s[i] == '<') {
hasCCW = true;
}
if (s[i] == '>') {
hasCW = true;
}
}
if (hasCW && hasCCW) {
int cnt = 0, sum = 0;
vector<int> v;
for (int i = 0; i < n; i++) {
if (s[i] == '-' && s[i + 1] == '-') {
cnt++;
}
if (s[i] == '-' && s[i + 1] != '-') {
cnt++;
v.push_back(cnt);
cnt = 0;
}
}
for (int i = 0; i < v.size(); i++) {
sum = sum + v[i] + 1;
}
if (s[0] == '-' && s[n - 1] == '-') {
cout << sum - 1 << endl;
} else {
cout << sum << endl;
}
} else {
cout << n << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int INF = 1e9;
int main() {
long long n, k, ans = 0;
cin >> n >> k;
bool t = 0;
ans += n * 2 / k + (t = (n * 2 % k));
ans += n * 5 / k + (t = (n * 5 % k));
ans += n * 8 / k + (t = (n * 8 % k));
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
map<string, int> points, goals, missed, cnt;
string s;
while (getline(cin, s)) {
stringstream ss(s);
string team1, team2, ngoals;
ss >> team1 >> team2 >> ngoals;
int goal1 = ngoals[0] - '0';
int goal2 = ngoals[2] - '0';
cnt[team1]++, cnt[team2]++;
goals[team1] += goal1;
goals[team2] += goal2;
missed[team1] += goal2;
missed[team2] += goal1;
if (goal1 == goal2) {
points[team1] += 1;
points[team2] += 1;
} else if (goal1 > goal2)
points[team1] += 3;
else
points[team2] += 3;
}
string team1 = "BERLAND";
string team2 = "";
map<string, int>::iterator it;
for (it = cnt.begin(); it != cnt.end(); it++) {
if (it->second != 3 && it->first != "BERLAND") team2 = it->first;
}
bool g = 0;
for (int diff = 1; diff < 200; diff++) {
for (int Y = 0; Y < 200; Y++) {
int X = diff + Y;
goals[team1] += X;
goals[team2] += Y;
missed[team1] += Y;
missed[team2] += X;
points[team1] += 3;
vector<pair<int, pair<int, pair<int, string> > > > x;
map<string, int>::iterator it;
for (it = cnt.begin(); it != cnt.end(); it++) {
string name = it->first;
x.push_back(
make_pair(-points[name], make_pair(-(goals[name] - missed[name]),
make_pair(-goals[name], name))));
}
sort(x.begin(), x.end());
if (x[0].second.second.second == "BERLAND" ||
x[1].second.second.second == "BERLAND") {
cout << X << ":" << Y << endl;
g = 1;
goto end;
}
points[team1] -= 3;
missed[team1] -= Y;
missed[team2] -= X;
goals[team1] -= X;
goals[team2] -= Y;
}
}
end:;
if (!g) cout << "IMPOSSIBLE" << endl;
}
| 5 |
#include <bits/stdc++.h>
int n, b[500005], c[500005];
std::vector<int> e[500005];
int t[500005 << 2];
inline void build(int p, int L, int R) {
if (L == R) {
t[p] = c[L];
return;
}
int mid = (L + R) >> 1;
build(p << 1, L, mid);
build(p << 1 | 1, mid + 1, R);
t[p] = std::max(t[p << 1], t[p << 1 | 1]);
}
inline int sch(int p, int L, int R, int l, int r, int x) {
if (t[p] <= x || L > r || R < l) return -1;
if (L == R) return L;
int mid = (L + R) >> 1;
if (t[p << 1] > x)
return sch(p << 1, L, mid, l, r, x);
else
return sch(p << 1 | 1, mid + 1, R, l, r, x);
}
inline void del(int p, int L, int R, int x) {
if (L == R) {
t[p] = -1;
return;
}
int mid = (L + R) >> 1;
if (x <= mid)
del(p << 1, L, mid, x);
else
del(p << 1 | 1, mid + 1, R, x);
t[p] = std::max(t[p << 1], t[p << 1 | 1]);
}
int A[500005], tot;
bool vis[500005];
inline void dfs(int u) {
if (vis[u]) return;
vis[u] = 1;
while (e[u].size()) {
dfs(e[u].back());
e[u].pop_back();
}
while (1) {
int v = sch(1, 1, n, 1, b[u] - 1, u);
if (v != -1) {
del(1, 1, n, v);
if (!vis[v]) dfs(v);
} else
break;
}
A[++tot] = u;
}
int a[500005];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) c[i] = n + 1;
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
if (b[i] == -1) b[i] = n + 1;
if (b[i] <= n) e[b[i]].push_back(i);
c[b[i]] = i;
}
build(1, 1, n);
for (int i = 1; i <= n; i++) dfs(i);
for (int i = 1; i <= n; i++) a[A[i]] = i;
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
puts("");
}
| 11 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("-ffloat-store")
using namespace std;
clock_t time_p = clock();
void aryanc403() {
time_p = clock() - time_p;
cerr << "Time Taken : " << (float)(time_p) / CLOCKS_PER_SEC << "\n";
}
const long long int INF = 0xFFFFFFFFFFFFFFFL;
long long int seed;
mt19937 rng(seed = chrono::steady_clock::now().time_since_epoch().count());
inline long long int rnd(long long int l = 0, long long int r = INF) {
return uniform_int_distribution<long long int>(l, r)(rng);
}
class CMP {
public:
bool operator()(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
return !(a.first < b.first || a.first == b.first && a.second <= b.second);
}
};
void add(map<long long int, long long int> &m, long long int x,
long long int cnt = 1) {
auto jt = m.find(x);
if (jt == m.end())
m.insert({x, cnt});
else
jt->second += cnt;
}
void del(map<long long int, long long int> &m, long long int x,
long long int cnt = 1) {
auto jt = m.find(x);
if (jt->second <= cnt)
m.erase(jt);
else
jt->second -= cnt;
}
bool cmp(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
return a.first < b.first || (a.first == b.first && a.second < b.second);
}
const long long int mod = 1000000007L;
long long int T, n, i, j, k, in, cnt, l, r, u, v, x, y;
long long int m, q, h;
string s;
map<long long int, long long int> a;
void add(long long int x, long long int v) {
if (v == 0) return;
while (x) {
a[x] += v;
x /= 2;
}
}
long long int get(long long int x) {
auto it = a.find(x);
if (it == a.end()) return 0;
return it->second;
}
long double fnd(long long int h) {
long double ans = 0;
long long int v = 1, mx = 0, x, y, t = get(1), H = h;
h--;
while (h >= 0) {
x = get(2 * v);
y = get(2 * v + 1);
;
if ((x == y) || (t - x <= mx && t - y <= mx)) {
ans += 2 * max({mx, t - x, t - y}) * (long double)(1LL << h);
break;
} else if (x > y) {
;
ans += max(mx, t - y) * (1LL << h);
mx = max(mx, t - x);
t = x;
v *= 2;
} else {
ans += max(mx, t - x) * (1LL << h);
mx = max(mx, t - y);
t = y;
v = 2 * v + 1;
}
h--;
}
if (h == -1) {
ans += max(mx, t);
}
ans /= (1LL << H);
return ans;
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
{
cin >> h >> q;
while (q--) {
cin >> s;
if (s == "add") {
cin >> x >> y;
add(x, y);
} else
cout << std::fixed << std::setprecision(35) << fnd(h) << "\n";
}
}
aryanc403();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<long long> arr(n);
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr.begin(), arr.end());
int f = 1;
for (int i = 1; i < n; i++) {
int val = abs(arr[i] - arr[i - 1]);
if (val > 1) {
f = 0;
break;
}
}
if (f == 1)
cout << "YES\n";
else
cout << "NO\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int q_pow(int x, int n) {
int ret = 1;
for (; n; n >>= 1, x = (long long)x * x % 998244353)
if (n & 1) ret = (long long)ret * x % 998244353;
return ret;
}
int A[100005 << 2], B[100005 << 2], tmp[100005], tx[100005], ty[100005], Q, n,
m;
void NTT(int *a, int len, int flag) {
int i, j, k, t, w, x, tmp;
for (i = k = 0; i < len; i++) {
if (i > k) swap(a[i], a[k]);
for (j = len >> 1; (k ^= j) < j; j >>= 1)
;
}
for (k = 2; k <= len; k <<= 1) {
t = k >> 1;
x = q_pow(3, (998244353 - 1) / k);
if (flag == -1) x = q_pow(x, 998244353 - 2);
for (i = 0; i < len; i += k)
for (w = 1, j = i; j < i + t; j++) {
tmp = (long long)a[j + t] * w % 998244353;
a[j + t] = (a[j] - tmp + 998244353) % 998244353;
a[j] = (a[j] + tmp) % 998244353;
w = (long long)w * x % 998244353;
}
}
if (flag == -1)
for (t = q_pow(len, 998244353 - 2), i = 0; i < len; i++)
a[i] = (long long)t * a[i] % 998244353;
}
struct poly {
vector<int> a;
int len;
poly() {}
poly(int x) {
len = 1;
a.push_back(x);
}
void clear() {
len = 0;
a.clear();
}
void rev() { reverse(a.begin(), a.end()); }
void resize(int x) {
a.resize(x);
len = x;
}
poly operator+(const poly &b) const {
poly c;
c.len = max(len, b.len);
c.resize(c.len);
for (int i = 0; i < len; i++) c.a[i] = a[i];
for (int i = 0; i < b.len; i++) c.a[i] = (c.a[i] + b.a[i]) % 998244353;
return c;
}
poly operator-(const poly &b) const {
poly c;
c.len = max(len, b.len);
c.resize(c.len);
for (int i = 0; i < len; i++) c.a[i] = a[i];
for (int i = 0; i < b.len; i++)
c.a[i] = (c.a[i] - b.a[i] + 998244353) % 998244353;
return c;
}
poly operator*(const poly &b) const {
poly c;
c.len = len + b.len;
int n = 1;
while (n < c.len) n <<= 1;
for (int i = 0; i < len; i++) A[i] = a[i];
for (int i = len; i < n; i++) A[i] = 0;
for (int i = 0; i < b.len; i++) B[i] = b.a[i];
for (int i = b.len; i < n; i++) B[i] = 0;
NTT(A, n, 1);
NTT(B, n, 1);
for (int i = 0; i < n; i++) A[i] = (long long)A[i] * B[i] % 998244353;
NTT(A, n, -1);
for (int i = 0; i < c.len; i++) c.a.push_back(A[i]);
return c;
}
poly operator+(const int &b) const {
poly c;
c.len = len;
c.a = a;
(c.a[0] += b) %= 998244353;
return c;
}
poly operator*(const int &b) const {
poly c;
c.len = len;
for (int i = 0; i < len; i++)
c.a.push_back((long long)a[i] * b % 998244353);
return c;
}
void get_inv(poly &b, int n) {
if (n == 1) {
b.a.push_back(q_pow(a[0], 998244353 - 2));
b.len = 1;
return;
}
get_inv(b, n >> 1);
int t = n << 1;
int lim = min(len, n);
for (int i = 0; i < lim; i++) A[i] = a[i];
for (int i = lim; i < t; i++) A[i] = 0;
for (int i = 0; i < b.len; i++) B[i] = b.a[i];
for (int i = b.len; i < t; i++) B[i] = 0;
NTT(A, t, 1);
NTT(B, t, 1);
for (int i = 0; i < t; i++)
A[i] = (2 - (long long)A[i] * B[i] % 998244353 + 998244353) * B[i] %
998244353;
NTT(A, t, -1);
for (int i = 0; i < b.len; i++) b.a[i] = A[i];
for (int i = b.len; i < n; i++) b.a.push_back(A[i]);
b.len = n;
}
poly Dao() {
poly c;
c.len = len - 1;
for (int i = 0; i < c.len; i++)
c.a.push_back(a[i + 1] * (i + 1ll) % 998244353);
return c;
}
poly Jifen() {
poly c;
c.len = len + 1;
c.a.push_back(0);
for (int i = 0; i < len; i++)
c.a.push_back((long long)a[i] * q_pow(i + 1, 998244353 - 2) % 998244353);
return c;
}
poly get_ln(int len) {
poly b = Dao();
poly c;
get_inv(c, len);
return (b * c).Jifen();
}
void get_mod(int b) {
for (int i = b; i < len; i++) a.pop_back();
len = b;
}
int get_val(int x) {
int ret = a[0];
for (int i = 1, tmp = x; i < len; tmp = (long long)tmp * x % 998244353, i++)
ret = (ret + (long long)a[i] * tmp) % 998244353;
return ret;
}
poly operator/(poly b) {
rev();
b.rev();
poly c;
int n = 1;
while (n < (len - b.len + 1)) n <<= 1;
b.get_inv(c, n);
c.get_mod(len - b.len + 1);
n = 1;
while (n < len + c.len) n <<= 1;
for (int i = 0; i < len; i++) A[i] = a[i];
for (int i = len; i < n; i++) A[i] = 0;
for (int i = 0; i < c.len; i++) B[i] = c.a[i];
for (int i = c.len; i < n; i++) B[i] = 0;
NTT(A, n, 1);
NTT(B, n, 1);
for (int i = 0; i < n; i++) A[i] = (long long)A[i] * B[i] % 998244353;
NTT(A, n, -1);
for (int i = 0; i < c.len; i++) c.a[i] = A[i];
c.rev();
rev();
b.rev();
return c;
}
poly operator%(poly b) {
rev();
b.rev();
poly c;
int n = 1;
while (n < (len - b.len + 1)) n <<= 1;
b.get_inv(c, n);
c.get_mod(len - b.len + 1);
n = 1;
while (n < len + c.len) n <<= 1;
for (int i = 0; i < len; i++) A[i] = a[i];
for (int i = len; i < n; i++) A[i] = 0;
for (int i = 0; i < c.len; i++) B[i] = c.a[i];
for (int i = c.len; i < n; i++) B[i] = 0;
NTT(A, n, 1);
NTT(B, n, 1);
for (int i = 0; i < n; i++) A[i] = (long long)A[i] * B[i] % 998244353;
NTT(A, n, -1);
for (int i = 0; i < c.len; i++) c.a[i] = A[i];
c.rev();
rev();
b.rev();
for (int i = 0; i < c.len; i++) A[i] = c.a[i];
for (int i = c.len; i < n; i++) A[i] = 0;
for (int i = 0; i < b.len; i++) B[i] = b.a[i];
for (int i = b.len; i < n; i++) B[i] = 0;
NTT(A, n, 1);
NTT(B, n, 1);
for (int i = 0; i < n; i++) A[i] = (long long)A[i] * B[i] % 998244353;
NTT(A, n, -1);
c.len = b.len;
c.resize(c.len);
for (int i = 0; i < c.len; i++)
c.a[i] = (a[i] - A[i] + 998244353) % 998244353;
return c;
}
} a, b;
void get_rot(const poly &a, poly &b, int len) {
if (len == 1) {
b.a.push_back(1);
b.len = 1;
return;
}
get_rot(a, b, len >> 1);
poly c;
c.clear();
b.get_inv(c, len);
int t = len << 1;
for (int i = 0; i < len; i++) A[i] = a.a[i], B[i] = c.a[i];
for (int i = len; i < t; i++) A[i] = B[i] = 0;
NTT(A, t, 1);
NTT(B, t, 1);
for (int i = 0; i < t; i++) A[i] = (long long)A[i] * B[i] % 998244353;
NTT(A, t, -1);
for (int i = 0; i < b.len; i++) b.a[i] = (b.a[i] + A[i]) % 998244353;
for (int i = b.len; i < len; i++) b.a.push_back(A[i]);
b.len = len;
b = b * ((998244353 + 1) >> 1);
}
void get_exp(const poly &a, poly &b, int len) {
if (len == 1) {
b.a.push_back(1);
b.len = 1;
return;
}
get_exp(a, b, len >> 1);
b = b * ((a - b.get_ln(len)) + 1);
b.get_mod(len);
}
int main() {
scanf("%d%d", &n, &m);
int len = 1;
while (len <= m) len <<= 1;
a.resize(len);
a.a[0] = 1;
for (int i = 1, x; i <= n; i++) {
scanf("%d", &x);
if (x <= m) a.a[x] = 998244353 - 4;
}
get_rot(a, b, len);
b.a[0]++;
a.clear();
b.get_inv(a, len);
for (int i = 1; i <= m; i++) printf("%d\n", (a.a[i] << 1) % 998244353);
}
| 11 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int N = 100 + 17;
const int S = 1000 + 17;
const long double INF = 1e10;
long double drunk[N];
struct kek {
int a;
int p;
};
int n;
long double con, dur;
long double dp[N][S];
inline long double calc(long double dormit, int cnt, int s) {
return (dormit) + dp[cnt][s] / (dormit * con + 1.0) + 10.0 * (long double)cnt;
}
bool operator<(kek f, kek s) { return f.a > s.a; }
kek v[N];
inline void clr_dp() {
for (int i = 0; i < N; i++) {
for (int j = 0; j < S; j++) {
dp[i][j] = INF;
}
}
}
inline long double gt_min(int cnt, int s) {
long double lo = 0, hi = INF, mid, rs;
for (int i = 1; i <= 100; i++) {
mid = (lo + hi) * 0.5;
if (calc(mid, cnt, s) <= calc(mid - 0.0001, cnt, s)) {
rs = mid;
lo = mid;
} else {
hi = mid;
}
}
return calc(rs, cnt, s);
}
inline int gt() {
for (int s = 10 * n; s >= 0; s--) {
for (int cnt = n; cnt >= 0; cnt--) {
if (dp[cnt][s] == INF) continue;
if (gt_min(cnt, s) <= dur ||
dp[cnt][s] + 10.0 * (long double)cnt <= dur) {
return s;
}
}
}
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
drunk[0] = 1.0;
for (int i = 1; i < N; i++) drunk[i] = drunk[i - 1] * 1.111111111111;
int tests;
cin >> tests;
for (int tc = 1; tc <= tests; tc++) {
cin >> n;
cin >> con >> dur;
for (int i = 1; i <= n; i++) {
cin >> v[i].a >> v[i].p;
}
sort(v + 1, v + n + 1);
clr_dp();
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int cnt = n; cnt >= 0; cnt--) {
for (int s = 10 * n; s >= 0; s--) {
dp[cnt + 1][s + v[i].p] =
min(dp[cnt + 1][s + v[i].p],
dp[cnt][s] + (long double)v[i].a * drunk[cnt + 1]);
}
}
}
cout << gt() << "\n";
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (abs(b) < abs(a)) return gcd(b, a);
if (abs(b) % abs(a) == 0)
return a;
else
return gcd(abs(a), abs(b) % abs(a));
}
int main() {
int n, m;
cin >> n >> m;
vector<int> v1(n + 1), v2(m + 1);
for (int i = 0; i <= n; i++) cin >> v1[i];
for (int i = 0; i <= m; i++) cin >> v2[i];
if (n > m) {
if (v1[0] * v2[0] < 0) {
cout << "-";
}
cout << "Infinity";
} else if (n == m) {
int g = gcd(v1[0], v2[0]);
v1[0] /= g;
v2[0] /= g;
if (v2[0] < 0) {
v2[0] *= -1;
v1[0] *= -1;
}
cout << v1[0] << "/" << v2[0];
} else
cout << "0/1";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string q(string s) {
cout << "?"
<< " " << s << "\n";
string t;
cin >> t;
return t;
}
int main() {
string s1, s2, s3, t1, t2, t3, t;
cin >> t;
int n = t.size();
for (int i = int(0); i <= int(n - 1); i++) {
s1 += char('a' + i % 26);
s2 += char('a' + i / 26 % 26);
s3 += char('a' + i / (26 * 26) % 26);
}
t1 = q(s1);
t2 = q(s2);
t3 = q(s3);
int per[n];
for (int i = int(0); i <= int(n - 1); i++) {
per[i] = (t1[i] - 'a') + (t2[i] - 'a') * 26 + (t3[i] - 'a') * 26 * 26;
}
string s(n, 'a');
for (int i = int(0); i <= int(n - 1); i++) s[per[i]] = t[i];
cout << "!"
<< " " << s << "\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int ans[1005];
bool vis[1005];
int main() {
for (int i = 0; i < 1001; i++) ans[i] = 2e9;
int n;
scanf("%d", &n);
int len = 1;
for (int i = 1; i <= 10; i++) {
vector<int> vec1, vec2;
for (int j = 0; j < n; j++) {
if (j % (len * 2) < len)
vec1.push_back(j + 1);
else
vec2.push_back(j + 1);
}
memset(vis, 0, sizeof(vis));
if (vec1.size()) {
printf("%d\n", vec1.size());
fflush(stdout);
for (int j = 0; j < vec1.size(); j++) {
vis[vec1[j]] = 1;
printf("%d ", vec1[j]);
fflush(stdout);
}
printf("\n");
fflush(stdout);
for (int j = 1; j <= n; j++) {
int x;
scanf("%d", &x);
if (vis[j])
;
else
ans[j] = min(ans[j], x);
}
}
memset(vis, 0, sizeof(vis));
if (vec2.size()) {
printf("%d\n", vec2.size());
fflush(stdout);
for (int j = 0; j < vec2.size(); j++) {
vis[vec2[j]] = 1;
printf("%d ", vec2[j]);
fflush(stdout);
}
printf("\n");
fflush(stdout);
for (int j = 1; j <= n; j++) {
int x;
scanf("%d", &x);
if (vis[j])
;
else
ans[j] = min(ans[j], x);
}
}
len *= 2;
}
printf("-1\n");
fflush(stdout);
for (int i = 1; i <= n; i++) {
printf("%d ", ans[i]);
fflush(stdout);
}
printf("\n");
fflush(stdout);
return 0;
}
| 5 |
#include <bits/stdc++.h>
struct Answer {
int a, b;
};
int main() {
int n, q;
scanf("%d%d", &n, &q);
std::deque<int> deq;
for (int i = 0; i < n; i++) {
int ai;
scanf("%d", &ai);
deq.push_back(ai);
}
Answer answers[n];
for (int i = 0; i < n; i++) {
answers[i].a = deq[0];
answers[i].b = deq[1];
deq.pop_front();
deq.pop_front();
if (answers[i].a > answers[i].b) {
deq.push_front(answers[i].a);
deq.push_back(answers[i].b);
} else {
deq.push_front(answers[i].b);
deq.push_back(answers[i].a);
}
}
for (int i = 0; i < q; i++) {
long long mj;
scanf("%lld", &mj);
mj--;
if (mj < n) {
printf("%d %d\n", answers[mj].a, answers[mj].b);
} else {
printf("%d %d\n", deq[0], deq[1 + (mj - n) % (n - 1)]);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, a, b, c, d;
cin >> n >> k >> a >> b >> c >> d;
if (k <= n || n <= 4) return cout << -1, 0;
for (int i = 0; i < 2; i++) {
cout << a << " " << c << " ";
for (int j = 1; j <= n; j++) {
if (j != a && j != b && j != c && j != d) {
cout << j << " ";
}
}
cout << d << " " << b << endl;
swap(a, c);
swap(b, d);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, t;
cin >> t;
while (t > 0) {
t--;
int k = 0;
long long a, b;
cin >> a >> b;
if (b > a) swap(a, b);
if (a % b != 0)
cout << "-1" << endl;
else {
long long p = a / b;
while (p % 8 == 0) {
k++;
p = p / 8;
}
while (p % 4 == 0) {
k++;
p = p / 4;
}
while (p % 2 == 0) {
k++;
p = p / 2;
}
if (p != 1)
cout << "-1" << endl;
else
cout << k << endl;
}
k = 0;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using Int = long long;
constexpr static int mod = 1e9 + 7;
constexpr static int inf = (1 << 30) - 1;
constexpr static Int infll = (1LL << 61) - 1;
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
string ask(Int p, Int q) {
cout << '?' << ' ' << p << ' ' << q << endl;
string s;
cin >> s;
return s;
}
string ans(Int a) {
cout << '!' << ' ' << a << endl;
string s;
cin >> s;
return s;
}
int main() {
string cmd;
cin >> cmd;
while (1) {
if (cmd != "start") return 0;
Int k = 2;
cmd = ask(0, 1);
if (cmd == "x") {
cmd = ans(1);
}
if (cmd == "start") continue;
Int left = 1;
while (left <= 1e9) {
cmd = ask(left, 2 * left);
if (cmd == "x") break;
if (cmd == "end" or cmd == "e") return 0;
left *= 2;
}
Int right = min(2 * left, (Int)1e9);
while (right - left > 1) {
Int mid = (left + right) / 2;
cmd = ask(left, mid);
if (cmd == "end" or cmd == "e") return 0;
if (cmd == "x") {
right = mid;
} else {
left = mid;
}
}
cmd = ans(right);
if (cmd == "end" or cmd == "e") return 0;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline bool isSquare(T x) {
T y = sqrt(x + 0.5);
return (y * y) == x;
}
template <class T1, class T2>
inline T1 gcd(T1 a, T2 b) {
return b ? gcd(b, a % b) : a;
}
template <class T1, class T2>
inline T1 eqMin(T1 &x, const T2 &y) {
if (T1(y) < x) return x = y;
return x;
}
template <class T1, class T2>
inline T1 eqMax(T1 &x, const T2 &y) {
if (T1(y) > x) return x = y;
return x;
}
template <class T1, class T2>
inline T1 min(const T1 &x, const T2 &y) {
return x < (T1)y ? x : (T1)y;
}
template <class T1, class T2>
inline T1 max(T1 &x, const T2 &y) {
return x > (T1)y ? x : (T1)y;
}
template <typename T>
inline T getint() {
T x = 0, p = 1;
char ch;
do {
ch = getchar();
} while (ch <= ' ');
if (ch == '-') p = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * p;
}
struct _flag_t {
string val;
} const _1d{", "}, _2d{"\n "};
_flag_t _flag = _1d;
ostream &operator<<(ostream &os, _flag_t flag) {
_flag = flag;
return os;
}
template <class It>
ostream &_out(ostream &os, It f, It l) {
if (f == l) return os << "{}";
_flag_t cur_flag = _flag;
os << _1d << "{ " << *f;
for (; ++f != l; os << cur_flag.val << *f)
;
return os << " }";
}
template <class C>
auto operator<<(ostream &os, C const &cont)
-> decltype(begin(cont), end(cont), cont.size(), declval<ostream &>()) {
return _out(os, begin(cont), end(cont));
}
ostream &operator<<(ostream &os, string const &s) { return os << s.data(); }
template <class X, class Y>
ostream &operator<<(ostream &os, pair<X, Y> const &p) {
return os << "[" << p.first << ", " << p.second << "]";
}
const double PI = acos(-1);
const double EPS = 1e-8;
const int INF = (int)2e9;
const int MOD = (int)998244353;
const int MAXN = (int)2e5 + 10;
int n, k;
int a[MAXN];
bool used[MAXN];
long long ans = 1;
void input() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
}
void check() {
for (int i = 3; i <= n; i++) {
if (a[i] != -1 && a[i - 2] != -1) {
if (a[i] == a[i - 2]) {
cout << 0;
exit(0);
}
}
}
}
long long f(int x, int y, int n) {
if (x == 0 && y == 0) {
long long result = k;
for (int i = 1; i < n; i++) {
result = (result * (k - 1)) % MOD;
}
return result;
}
if (x == 0 || y == 0) {
long long result = 1;
for (int i = 1; i <= n; i++) {
result = (result * (k - 1)) % MOD;
}
return result;
}
if (k == 2 && x != y) {
return 0;
}
vector<long long> dp(n + 2, 0);
dp[1] = 1;
for (int i = 2; i <= n + 1; i++) {
dp[i] = (dp[i - 1] * (k - 2) + dp[i - 2] * (k - 1)) % MOD;
}
if (x == y) {
if (n % 2) {
return (dp[n + 1] + 1) % MOD;
} else {
return (dp[n + 1] - 1 + MOD) % MOD;
}
}
return dp[n + 1];
}
void solve() {
for (int i = 1; i <= n; i++) {
if (used[i]) continue;
if (a[i] != -1) continue;
int cnt = 0;
for (int j = i; a[j] == -1; j += 2, cnt++) used[j] = true;
int x = 0, y = 0;
if (i - 2 >= 1) x = a[i - 2];
if (i + cnt * 2 <= n) y = a[i + cnt * 2];
ans = (ans * f(x, y, cnt)) % MOD;
}
}
int main() {
ios_base::sync_with_stdio(false);
input();
check();
solve();
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 15;
const long long int inf = 1e18;
vector<string> a(100);
long long int n, m;
vector<vector<long long int> > vis(100, vector<long long int>(100));
vector<long long int> dx = {0, -1, 1, 0};
vector<long long int> dy = {1, 0, 0, -1};
void dfs(long long int x, long long int y, long long int px, long long int py,
char col) {
for (long long int i = 0; i < 4; i++) {
long long int nx = x + dx[i];
long long int ny = y + dy[i];
if (nx >= 0 and ny >= 0 and nx < n and ny < m) {
if (a[nx][ny] == col and !(nx == px and ny == py)) {
if (vis[nx][ny]) {
cout << "Yes";
exit(0);
} else {
vis[nx][ny] = true;
dfs(nx, ny, x, y, col);
}
}
}
}
}
void solve() {
cin >> n >> m;
for (long long int i = 0; i < n; i++) cin >> a[i];
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
if (!vis[i][j]) {
vis[i][j] = true;
dfs(i, j, 0, 0, a[i][j]);
}
}
}
cout << "No";
}
void debug(long long int tt) {}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int mark[100000 + 5], ara[100000 + 5];
int main() {
int i, j, k, n, l, gcd, mx = 0;
cin >> n;
for (i = 1; i <= n; i++) {
scanf("%d", &l);
ara[l]++;
}
if (ara[1] > 0) mx = 1;
for (i = 2; i <= 100000; i++) {
if (!mark[i]) {
gcd = ara[i];
for (j = i + i; j <= 100000; j += i) {
gcd += ara[j];
}
mx = max(gcd, mx);
}
}
cout << mx << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 1;
char ch = ' ';
while (!isdigit(ch)) {
ch = getchar();
if (ch == '-') f = -1;
}
while (isdigit(ch)) x = (x << 3) + (x << 1) + (ch ^ 48), ch = getchar();
return x * f;
}
long long n, m, k, a[500005], c[500005], d[500005];
bool check(long long mid) {
for (int i = 1; i <= n + 1; i++) d[i] = c[i];
long long now = 0, num = 0;
for (int i = 1; i <= n; i++) {
now += d[i];
if (num > k) return 0;
if (now < mid) {
d[min(n + 1, i + m * 2 + 1)] -= (mid - now);
num += (mid - now);
now = mid;
}
}
return num <= k;
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
a[i] = read();
c[max(1ll, i - m)] += a[i];
c[min(n + 1, i + m + 1)] -= a[i];
}
long long l = 0, r = 3e18, mid;
while (l < r) {
mid = (l + r + 1) >> 1;
if (check(mid))
l = mid;
else
r = mid - 1;
}
cout << l;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c = 0;
cin >> n;
vector<string> arr[2];
for (int i = 0; i < n; i++) {
string name, colour;
cin >> name >> colour;
arr[0].push_back(name);
arr[1].push_back(colour);
c++;
for (int j = i - 1; j >= 0; j--) {
if (arr[0][j] == arr[0][i] && arr[1][j] == arr[1][i]) {
c--;
break;
}
}
}
cout << c;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> construct(int st, vector<int> d) {
if (d.empty()) return vector<pair<int, int>>();
vector<pair<int, int>> res;
for (int i = 0; i < d[0]; i++) {
for (int j = st + i + 1; j <= st + d.back(); j++) {
res.push_back({st + i, j});
}
}
st += d[0];
for (int i = 1; i < d.size(); i++) d[i] -= d[0];
d.erase(d.begin());
if (d.size()) d.pop_back();
vector<pair<int, int>> res2 = construct(st, d);
for (auto u : res2) res.push_back(u);
return res;
}
void solve() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
auto ans = construct(1, v);
cout << ans.size() << endl;
for (auto a : ans) {
cout << a.first << " " << a.second << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t = 1;
while (t--) {
solve();
}
}
| 8 |
#include <bits/stdc++.h>
int main() {
long long n, x, y;
scanf("%I64d", &n);
scanf("%I64d %I64d", &x, &y);
if (((((x) > (y)) ? (x) : (y)) - 1) > (n - (((x) < (y)) ? (x) : (y)))) {
printf("Black\n");
} else {
printf("White\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e5 + 228;
const int INF = (int)1e9 + 228;
int dp[75][75][75][75];
int a[75][75];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= m; j++) {
for (int cnt = 0; cnt <= m / 2; cnt++) {
for (int ost = 0; ost < k; ost++) {
dp[i][j][cnt][ost] = -INF;
}
}
}
}
dp[1][0][0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int cnt = 0; cnt <= min(j, m / 2); cnt++) {
for (int ost = 0; ost < k; ost++) {
dp[i][j][cnt][ost] = dp[i][j - 1][cnt][ost];
int post = (ost - a[i][j] + 1000000 * k) % k;
if (cnt > 0) {
dp[i][j][cnt][ost] =
max(dp[i][j][cnt][ost], dp[i][j - 1][cnt - 1][post] + a[i][j]);
}
}
}
}
for (int cnt = 0; cnt <= m / 2; cnt++) {
for (int ost = 0; ost < k; ost++) {
dp[i + 1][0][0][ost] = max(dp[i + 1][0][0][ost], dp[i][m][cnt][ost]);
}
}
}
int ans = 0;
for (int cnt = 0; cnt <= m / 2; cnt++) {
ans = max(ans, dp[n][m][cnt][0]);
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline int read() {
int x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void wr(long long x) {
if (x < 0) {
putchar('-');
wr(-x);
return;
}
if (x >= 10) wr(x / 10);
putchar(x % 10 + '0');
}
inline void wrn(long long x) {
wr(x);
putchar('\n');
}
inline void wri(long long x) {
wr(x);
putchar(' ');
}
inline void wrn(long long x, long long y) {
wri(x);
wrn(y);
}
int n, m, f[3], x, ans;
signed main() {
n = read();
for (int i = 1; i <= n; i++) {
x = read();
f[x & 1]++;
}
ans = min(f[0], f[1]);
f[0] -= ans;
f[1] -= ans;
ans += f[1] / 3;
wrn(ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 210;
int n;
int p[MAXN], q[MAXN], d[MAXN];
bool bt[MAXN];
vector<int> pt[MAXN], et[MAXN];
bool Check(int k) {
for (int i = 0; i < pt[k].size(); i++)
if (!bt[pt[k][i]]) return false;
return true;
}
int Calc(int st) {
memset(bt, false, sizeof(bt));
int ans = n;
for (int tot = n; tot > 0; st = (st + 1) % 3, ans++) {
for (int i = 0; i < n; i++)
if (!bt[q[i]] && p[q[i]] == st && Check(q[i])) {
tot--;
bt[q[i]] = true;
}
if (tot == 0) break;
}
return ans;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> p[i];
p[i]--;
}
for (int i = 0, x, y; i < n; i++) {
cin >> y;
pt[i].clear();
for (int j = 0; j < y; j++) {
cin >> x;
x--;
pt[i].push_back(x);
et[x].push_back(i);
}
d[i] = pt[i].size();
}
int m = 0;
for (int i = 0; i < n; i++)
if (d[i] == 0) q[m++] = i;
for (int qh = 0, ql, z; m < n;) {
ql = m;
for (int i = qh; i < ql; i++) {
z = q[i];
for (int j = 0; j < et[z].size(); j++)
if ((--d[et[z][j]]) == 0) q[m++] = et[z][j];
}
qh = ql;
}
int res = min(min(Calc(0), Calc(1)), Calc(2));
cout << res << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e5 + 5;
int A[M];
char B[M];
int main() {
int n;
scanf("%d", &n);
for (int j = 0; j < n; j++) scanf("%d", &A[j]);
scanf("%s", B);
int cnt = 0;
for (int j = 0; j < n; j++)
if (B[j] == '1') cnt += A[j];
int ans = cnt, sum = 0, sum1 = 0;
for (int j = 0; j < n; j++) {
if (B[j] == '1') {
ans = max(ans, cnt - A[j] + sum1 - sum);
sum += A[j];
}
sum1 += A[j];
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int q;
map<long long, map<long long, long long>> mp;
int main() {
cin >> q;
while (q--) {
int ch;
cin >> ch;
if (ch == 1) {
long long u, v, w;
cin >> u >> v >> w;
set<long long> st;
long long cx = u;
while (cx) {
st.insert(cx);
cx = cx / 2;
}
cx = v;
long long intr;
while (cx) {
if (st.find(cx) != st.end()) {
intr = cx;
break;
}
cx = cx / 2;
}
cx = u;
while (cx != intr) {
mp[cx][cx / 2] += w;
mp[cx / 2][cx] += w;
cx = cx / 2;
}
cx = v;
while (cx != intr) {
mp[cx][cx / 2] += w;
mp[cx / 2][cx] += w;
cx = cx / 2;
}
} else {
long long u, v;
cin >> u >> v;
set<long long> st;
long long cx = u;
while (cx) {
st.insert(cx);
cx = cx / 2;
}
cx = v;
long long intr;
while (cx) {
if (st.find(cx) != st.end()) {
intr = cx;
break;
}
cx = cx / 2;
}
long long sum = 0;
cx = u;
while (cx != intr) {
sum += mp[cx][cx / 2];
cx = cx / 2;
}
cx = v;
while (cx != intr) {
sum += mp[cx][cx / 2];
cx = cx / 2;
}
cout << sum << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e3 + 10;
const int mod = 1e9 + 7;
int n, m, s[maxn];
bool cow[maxn][maxn];
long long cnt0[maxn], cnt1[maxn], psum[maxn][maxn];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
scanf("%d", &s[i]);
}
for (int i = 0; i < m; i++) {
int f, h;
scanf("%d%d", &f, &h);
cow[f][h] = true;
}
for (int i = 1; i < maxn; i++) {
for (int j = 1; j < maxn; j++) {
psum[i][j] = psum[i][j - 1];
if (cow[i][j]) psum[i][j]++;
}
}
for (int i = 0; i < n; i++) {
cnt1[s[i]]++;
}
int mx = 0;
long long vay = 1;
for (int i = 1; i < maxn; i++) {
if (psum[i][cnt1[i]] > 0) {
mx++;
vay = vay * psum[i][cnt1[i]] % mod;
}
}
for (int i = 0; i < n; i++) {
cnt1[s[i]]--;
cnt0[s[i]]++;
if (!cow[s[i]][cnt0[s[i]]]) continue;
int t = 1;
long long w = 1;
if (cnt1[s[i]] > 0) {
if (cnt1[s[i]] >= cnt0[s[i]] && psum[s[i]][cnt1[s[i]]] > 1) {
t++;
w = w * (psum[s[i]][cnt1[s[i]]] - 1) % mod;
} else if (cnt1[s[i]] < cnt0[s[i]] && psum[s[i]][cnt1[s[i]]] > 0) {
t++;
w = w * psum[s[i]][cnt1[s[i]]] % mod;
}
}
for (int j = 1; j < maxn; j++)
if (j != s[i]) {
if (psum[j][cnt0[j]] == 1 && psum[j][cnt1[j]] == 1) {
t++;
w = w * 2 % mod;
} else if (psum[j][cnt0[j]] > 0 && psum[j][cnt1[j]] > 0) {
t += 2;
long long a, b;
if (psum[j][cnt0[j]] > psum[j][cnt1[j]]) {
a = psum[j][cnt0[j]];
b = psum[j][cnt1[j]];
} else {
a = psum[j][cnt1[j]];
b = psum[j][cnt0[j]];
}
w = w * b % mod * (a - 1) % mod;
} else if (psum[j][cnt0[j]] > 0) {
t++;
w = w * psum[j][cnt0[j]] % mod;
} else if (psum[j][cnt1[j]] > 0) {
t++;
w = w * psum[j][cnt1[j]] % mod;
}
}
if (t > mx) {
mx = t;
vay = w;
} else if (t == mx) {
vay = (vay + w) % mod;
}
}
cout << mx << ' ' << vay << endl;
return 0;
}
| 8 |
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define vint vector<ll>
#define pint pair<ll,ll>
#define vpint vector<pint>
#define ppint pair<pint,ll>
#define pb push_back
#define all(v) v.begin(),v.end()
#define ios cin.sync_with_stdio(false),cin.tie(NULL)
#define f_(i,m,n) for(ll i=m;i<n;i++)
#define ff first
#define ss second
const int MOD = 1e9 + 7;
/*const int N = 300500;
const int mod = 1000000007;
ll fact[N];
ll invFact[N];
ll fast_pow(ll a, ll p) {
ll res = 1;
while (p) {
if (p % 2 == 0) {
a = (a * a) % mod;
p /= 2;
} else {
res = (res * a) % mod;
p--;
}
}
return res;
}
ll nck(ll n, ll k) {
if (k > n) {
return 0;
}
return fact[n] * invFact[k] % mod * invFact[n - k] % mod;
}
*/
void solve(){
ll n;
cin>>n;
while(n%2 == 0){
n/= 2;
}
if(n!= 1){
cout<<"YES"<<endl;
return;
}
cout<<"NO"<<endl;
return;
}
int main(){
ios;
ll t;
//t=1;
cin>>t;
while(t--){
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int maxn = 100005;
const char f0[] =
"What are you doing at the end of the world? Are you busy? Will you save "
"us?";
const char fi1[] = "What are you doing while sending \"";
const char fi2[] = "\"? Are you busy? Will you send \"";
const char fi3[] = "\"?";
const int f0len = strlen(f0);
const int fi1len = strlen(fi1);
const int fi2len = strlen(fi2);
const int fi3len = strlen(fi3);
long long len[maxn];
int main() {
int i = 1, q, n;
len[0] = f0len;
long long k;
scanf("%d", &q);
while (q--) {
scanf("%d%I64d", &n, &k);
for (; i <= n; i++)
if (len[i - 1] == -1)
len[i] = -1;
else {
len[i] = len[i - 1] * 2 + fi1len + fi2len + fi3len;
if (len[i] > 1e18) len[i] = -1;
}
for (; n; n--)
if (k <= fi1len) {
printf("%c", fi1[k - 1]);
break;
} else if (k <= fi1len + len[n - 1] || len[n - 1] == -1)
k -= fi1len;
else if (k <= fi1len + len[n - 1] + fi2len) {
printf("%c", fi2[k - fi1len - len[n - 1] - 1]);
break;
} else if (k <= fi1len + len[n - 1] + fi2len + len[n - 1])
k -= fi1len + len[n - 1] + fi2len;
else if (k <= fi1len + len[n - 1] + fi2len + len[n - 1] + fi3len) {
printf("%c", fi3[k - fi1len - len[n - 1] - fi2len - len[n - 1] - 1]);
break;
} else {
printf(".");
break;
}
if (!n) printf("%c", (k <= f0len) ? f0[k - 1] : '.');
}
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
const int maxm = 1e6 + 10;
const int inf = 0x3f3f3f3f;
const long long mod = 998244353;
const int maxblock = sqrt(maxn) + 10;
const double eps = 1e-7;
const long long INF = 1e16;
long long n, m, l, r;
long long qpow(long long a, long long b, long long p) {
a %= p;
long long res = 1;
while (b) {
if (b & 1) res = res * a % p;
b >>= 1;
a = a * a % p;
}
return res;
}
int main() {
scanf("%lld %lld %lld %lld", &n, &m, &l, &r);
if ((n * m) % 2 == 1) {
long long res = qpow(r - l + 1, n * m, mod);
printf("%lld\n", res);
} else {
long long res = qpow(r - l + 1, n * m, mod);
long long a = (r - l + 1);
int flag = a % 2;
a /= 2;
long long res1;
if (flag) {
res1 = qpow(2 * a + 1, n * m, mod) + 1;
res1 = (res1 % mod);
res1 = (res1 * qpow(2, mod - 2, mod)) % mod;
} else {
res1 = qpow(a, n * m, mod);
res1 = (res1 * qpow(2, n * m - 1, mod)) % mod;
}
printf("%lld\n", res1);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, c;
cin >> a >> c;
vector<int> va, vc;
while (a) {
va.push_back(a % 3);
a /= 3;
}
while (c) {
vc.push_back(c % 3);
c /= 3;
}
if (va.size() < vc.size()) {
int len = vc.size() - va.size();
for (int i = 0; i < len; i++) va.push_back(0);
} else if (va.size() > vc.size()) {
int len = va.size() - vc.size();
for (int i = 0; i < len; i++) vc.push_back(0);
}
vector<int> vb;
for (int i = 0; i < va.size(); i++) {
if (vc[i] >= va[i]) {
vb.push_back(vc[i] - va[i]);
} else {
vb.push_back(3 + vc[i] - va[i]);
}
}
int b(0);
for (int i = vb.size() - 1; i >= 0; i--) {
b = 3 * b + vb[i];
}
cout << b << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200001;
long long a[N + 1], tree[4 * N], lazy[4 * N];
void build(int idx, int l, int r) {
if (l == r)
tree[idx] = a[l];
else {
int m = (l + r) / 2;
build(2 * idx, l, m);
build(2 * idx + 1, m + 1, r);
tree[idx] = min(tree[2 * idx], tree[2 * idx + 1]);
}
}
void push(int idx) {
tree[2 * idx] += lazy[idx];
lazy[2 * idx] += lazy[idx];
tree[2 * idx + 1] += lazy[idx];
lazy[2 * idx + 1] += lazy[idx];
lazy[idx] = 0;
}
void update(int idx, int l, int r, int ql, int qr, long long val) {
if (ql > qr) return;
if (l == ql && r == qr) {
tree[idx] += val;
lazy[idx] += val;
} else {
push(idx);
int m = (l + r) / 2;
update(2 * idx, l, m, ql, min(qr, m), val);
update(2 * idx + 1, m + 1, r, max(ql, m + 1), qr, val);
tree[idx] = min(tree[2 * idx], tree[2 * idx + 1]);
}
}
long long query(int idx, int l, int r, int ql, int qr) {
if (ql > qr) return 1000000000000000000;
if (l == ql && r == qr)
return tree[idx];
else {
push(idx);
int m = (l + r) / 2;
return min(query(2 * idx, l, m, ql, min(qr, m)),
query(2 * idx + 1, m + 1, r, max(ql, m + 1), qr));
}
}
int main() {
int n;
scanf("%d ", &n);
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
build(1, 1, n);
int m;
scanf("%d ", &m);
while (m--) {
char c[105];
fgets(c, 100, stdin);
int id = 0;
long long now[3], temp = 0;
bool b = 0;
for (int i = 0;; i++) {
if (c[i] == '-') {
b = 1;
continue;
}
if (c[i] == ' ' || c[i] == '\n') {
now[id++] = temp;
temp = 0;
} else
temp = 10 * temp + (c[i] - '0');
if (c[i] == '\n') break;
}
if (b) now[2] *= -1;
now[0]++;
now[1]++;
if (id == 2) {
long long res;
if (now[0] <= now[1])
res = query(1, 1, n, now[0], now[1]);
else
res = min(query(1, 1, n, 1, now[1]), query(1, 1, n, now[0], n));
printf("%I64d\n", res);
} else {
if (now[0] <= now[1])
update(1, 1, n, now[0], now[1], now[2]);
else {
update(1, 1, n, 1, now[1], now[2]);
update(1, 1, n, now[0], n, now[2]);
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
int q;
int s;
struct st {
int a;
int b;
long long int cost;
};
vector<st> v[100002 * 4][2];
int node[100002];
inline void init(int b, int l, int r) {
v[b][1].push_back({b, 0, 0});
if (l + 1 == r) {
node[l] = b;
return;
}
init(b * 2 + 1, l, (l + r) >> 1);
init(b * 2 + 2, (l + r) >> 1, r);
v[b][1].push_back({b * 2 + 1, 1, 0});
v[b][1].push_back({b * 2 + 2, 1, 0});
v[b * 2 + 1][0].push_back({b, 0, 0});
v[b * 2 + 2][0].push_back({b, 0, 0});
v[b * 2 + 1][0].push_back({b, 0, 0});
v[b * 2 + 2][0].push_back({b, 0, 0});
}
inline void add1(int b, int l, int r, int ll, int rr, int x, long long int c) {
if (r <= ll || rr <= l) return;
if (ll <= l && r <= rr) {
v[x][0].push_back({b, 1, c});
return;
}
add1(b * 2 + 1, l, (l + r) >> 1, ll, rr, x, c);
add1(b * 2 + 2, (l + r) >> 1, r, ll, rr, x, c);
}
inline void add2(int b, int l, int r, int ll, int rr, int x, long long int c) {
if (r <= ll || rr <= l) return;
if (ll <= l && r <= rr) {
v[b][0].push_back({x, 1, c});
return;
}
add2(b * 2 + 1, l, (l + r) >> 1, ll, rr, x, c);
add2(b * 2 + 2, (l + r) >> 1, r, ll, rr, x, c);
}
long long int dist[100002 * 4][2];
int main() {
cin >> n >> q >> s;
s--;
init(0, 0, n);
while (q--) {
int ty;
scanf("%d", &ty);
if (ty == 1) {
int v, u, w;
scanf("%d%d%d", &v, &u, &w);
v--;
u--;
add1(0, 0, n, u, u + 1, node[v], w);
continue;
}
if (ty == 2) {
int v, l, r, w;
scanf("%d%d%d%d", &v, &l, &r, &w);
l--;
r--;
v--;
add1(0, 0, n, l, r + 1, node[v], w);
}
if (ty == 3) {
int v, l, r, w;
scanf("%d%d%d%d", &v, &l, &r, &w);
l--;
r--;
v--;
add2(0, 0, n, l, r + 1, node[v], w);
}
}
for (int i = 0; i < 100002 * 4; i++) {
dist[i][0] = dist[i][1] = LLONG_MAX;
}
queue<pair<int, int> > q;
q.push(make_pair(node[s], 1));
dist[node[s]][1] = 0;
while (!q.empty()) {
int a = q.front().first;
int b = q.front().second;
q.pop();
vector<st> &vv = v[a][b];
for (int i = 0; i < vv.size(); i++) {
int x = vv[i].a;
int yy = vv[i].b;
long long int nex = dist[a][b] + vv[i].cost;
if (dist[x][yy] > nex) {
dist[x][yy] = nex;
q.push(make_pair(x, yy));
}
}
}
for (int i = 0; i < n; i++) {
if (i) {
printf(" ");
}
if (dist[node[i]][0] == LLONG_MAX) {
printf("-1");
} else {
printf("%lld", dist[node[i]][0]);
}
}
puts("");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, k, cnt = 0, m, a, b, start = -1, stop = -1;
cin >> n;
int arr[n];
for (i = 0; i < n; i++) {
cin >> arr[i];
}
for (i = 0; i < n - 1; i++) {
if (arr[i] > arr[i + 1]) {
start = i;
cnt++;
while (i < n - 1 && arr[i] > arr[i + 1]) {
i++;
}
stop = i;
}
if (start != -1 && stop != -1 && stop != n - 1) {
if (arr[start] > arr[stop + 1]) {
cnt++;
}
}
}
if (cnt == 0) {
cout << "yes" << endl << "1 1";
} else if (cnt == 1) {
if (start != 0) {
if (stop != n - 1) {
if (arr[stop] > arr[start - 1]) {
cout << "yes" << endl << start + 1 << " " << stop + 1;
return 0;
} else {
cout << "no";
return 0;
}
}
if (arr[stop] > arr[start - 1]) {
cout << "yes" << endl << start + 1 << " " << stop + 1;
return 0;
} else {
cout << "no";
return 0;
}
}
cout << "yes" << endl << start + 1 << " " << stop + 1;
} else {
cout << "no";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, t, c = 0, q = -1;
cin >> n >> k;
vector<long long int> a, b;
map<long long int, int> d;
for (int i = 0; i < n; i++) {
cin >> t;
a.push_back(t);
}
sort(a.begin(), a.end());
for (long long int i = 0; i < n; i++) {
if (!d[a[i]]) {
d[a[i] * k] = 1;
c++;
}
}
cout << c;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int n, k;
bool vis[2][maxn];
char wall[2][maxn];
bool dfs(int d, int p, int lev) {
if (p >= n) return true;
int j = p + k, i = d ^ 1;
if (j >= n || (!vis[i][j] && wall[i][j] == '-' && lev + 1 < j)) {
if (j < n) vis[i][j] = true;
if (dfs(i, j, lev + 1)) return true;
}
j = p + 1;
if (j >= n || (!vis[d][j] && wall[d][j] == '-' && lev + 1 < j)) {
if (j < n) vis[d][j] = true;
if (dfs(d, j, lev + 1)) return true;
}
j = p - 1;
if (j >= n || (!vis[d][j] && wall[d][j] == '-' && lev + 1 < j)) {
if (j < n) vis[d][j] = true;
if (dfs(d, j, lev + 1)) return true;
}
return false;
}
int main() {
scanf("%d %d", &n, &k);
scanf("%s %s", wall[0], wall[1]);
memset(vis, false, sizeof(vis));
vis[0][0] = true;
if (dfs(0, 0, -1)) {
printf("YES\n");
} else
printf("NO\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long k;
cin >> k;
bool d = 1;
int z = 0;
while (k != 0) {
if (k % 10 != 4 && k % 10 != 7) {
int h = 2;
} else {
z++;
}
k = k / 10;
}
if (z == 0) {
d = 0;
}
while (z != 0) {
if (z % 10 != 4 && z % 10 != 7) {
d = 0;
}
z /= 10;
}
if (d) {
cout << "YES";
} else {
cout << "NO";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int n;
cin >> n;
int k[n];
for (int i = 0; i < n; i++) cin >> k[i];
int time[n];
for (int i = 0; i < n; i++) {
time[i] = 15 * k[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < k[i]; j++) {
int a;
cin >> a;
time[i] += 5 * a;
}
}
int ans = 1e9;
for (int i = 0; i < n; i++) {
ans = min(ans, time[i]);
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> v[200005];
vector<long long int> v1[200005];
long long int d[200005];
long long int s, t;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, m, a, b, k;
cin >> n >> m;
for (long long int i = 0; i < m; i++) {
cin >> a >> b;
v[b].push_back(a);
v1[a].push_back(b);
}
cin >> k;
for (long long int i = 0; i <= n; i++) d[i] = 1000000000000000000;
long long int* arr = new long long int[k];
for (long long int i = 0; i < k; i++) cin >> arr[i];
s = arr[0], t = arr[k - 1];
queue<long long int> q;
q.push(t);
d[t] = 0;
vector<bool> u(n + 1);
u[t] = 1;
while (!q.empty()) {
a = q.front();
q.pop();
for (auto j : v[a]) {
if (!u[j]) {
d[j] = d[a] + 1;
u[j] = 1;
q.push(j);
}
}
}
long long int st = 0, e = 0, temp = d[s];
for (long long int i = 1; i < k; i++) {
if (temp - 1 != d[arr[i]]) {
st++;
e++;
} else {
for (auto j : v1[arr[i - 1]]) {
if (j != arr[i] && d[j] == temp - 1) {
e++;
break;
}
}
}
temp = d[arr[i]];
}
cout << st << " " << e << "\n";
;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void test(vector<int> a, vector<int> b, int n) {
int flag = 0;
int diff = 0;
int i = 0;
for (i = 0; i < n; i++) {
if (a[i] == b[i]) {
if (!flag) {
continue;
} else {
break;
}
}
if (a[i] != b[i]) {
if (!flag) {
flag = 1;
diff = b[i] - a[i];
continue;
}
if (flag) {
if (diff == b[i] - a[i]) {
continue;
} else {
cout << "NO" << endl;
return;
}
}
}
}
if (i == n - 1 && diff >= 0) {
cout << "YES" << endl;
return;
}
if (diff >= 0) {
for (; i < n; i++) {
if (a[i] != b[i]) {
cout << "NO" << endl;
return;
}
}
cout << "YES" << endl;
return;
}
cout << "NO" << endl;
return;
}
int main() {
int t = 0;
cin >> t;
while (t--) {
int n = 0;
cin >> n;
vector<int> a(n, 0);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<int> b(n, 0);
for (int i = 0; i < n; i++) {
cin >> b[i];
}
test(a, b, n);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, p[300000], q[300000];
vector<pair<int, int> > v;
void deb() {
for (int i = 0; i < n; i++) cout << p[i] + 1 << " ";
cout << endl;
}
void sw(int i, int j) {
int t;
v.push_back(pair<int, int>(i, j));
t = p[i];
p[i] = p[j];
p[j] = t;
q[p[i]] = i;
q[p[j]] = j;
}
void mo(int v) {
while (q[v] != v) {
if (abs(q[v] - v) >= n / 2) {
sw(q[v], v);
} else {
if (q[v] < n / 2) {
sw(q[v], n - 1);
} else {
sw(q[v], 0);
}
}
}
}
int main(void) {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> p[i];
p[i]--;
q[p[i]] = i;
}
for (int i = 0; i < n / 2; i++) {
mo(n / 2 - 1 - i);
mo(n / 2 + i);
}
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
cout << v[i].first + 1 << " " << v[i].second + 1 << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[10000];
int main() {
ios_base::sync_with_stdio(0);
long long n, q;
cin >> n >> q;
while (q--) {
long long x;
cin >> x;
if (x % 2)
cout << (x + 1) / 2 << endl;
else {
long long mv = n - x / 2;
long long id = x;
while (mv) {
id += mv;
if (mv % 2) break;
mv /= 2;
}
cout << (id + 1) / 2 << endl;
}
}
}
| 4 |
#include <bits/stdc++.h>
#ifdef ALGO
#include "el_psy_congroo.hpp"
#else
#define DUMP(...) 1145141919810
#define CHECK(...) (__VA_ARGS__)
#endif
template<int MOD>
struct Integral {
int v_ = 0;
template<typename T> Integral(T v) : v_(norm(v)) { // Implicit conversion is allowed.
static_assert(std::is_integral<T>::value, "input should be an integral.");
}
Integral() = default;
~Integral() = default;
template<typename T> T norm(T v) const {
if (v >= MOD) v -= MOD;
if (v < 0) v += MOD;
if (v >= MOD || v < 0) v = (v % MOD + MOD) % MOD;
return v;
}
int val() const { return v_; }
Integral operator + (const Integral& rhs) const { return Integral(val() + rhs.val()); }
Integral operator - (const Integral& rhs) const { return Integral(val() - rhs.val()); }
Integral operator * (const Integral& rhs) const { return Integral(val() * 1LL * rhs.val()); }
Integral operator / (const Integral& rhs) const { return *this * rhs.inv(); }
Integral& operator += (const Integral& rhs) { return *this = *this + rhs; }
Integral& operator -= (const Integral& rhs) { return *this = *this - rhs; }
Integral& operator *= (const Integral& rhs) { return *this = *this * rhs; }
Integral& operator /= (const Integral& rhs) { return *this = *this / rhs; }
bool operator == (const Integral& rhs) const { return val() == rhs.val(); }
bool operator != (const Integral& rhs) const { return !(*this == rhs); }
const Integral operator - () const { return Integral(-val()); }
const Integral operator ++ () { v_ = norm(v_ + 1); return *this; }
const Integral operator ++ (int) { Integral ret = *this; ++(*this); return ret; }
const Integral operator -- () { v_ = norm(v_ - 1); return *this; }
const Integral operator -- (int) { Integral ret = *this; --(*this); return ret; }
Integral power(long long b) const {
long long ret = 1 % MOD, a = v_;
for ( ; b; b >>= 1, a = a * a % MOD) if (b & 1) ret = ret * a % MOD; return ret;
}
Integral inv() const { return power(MOD - 2); }
};
template<int MOD>
std::string to_string(const Integral<MOD>& v) {
return std::string("Integral{v=") + std::to_string(v.val()) + "}";
}
template<int MOD, bool kAllowBruteForce = false>
struct Binomial {
std::vector<Integral<MOD>> factor, inv_factor;
explicit Binomial(int n = 0) : factor(n + 1), inv_factor(n + 1) {
factor[0] = 1;
for (int i = 1; i <= n; ++i) factor[i] = factor[i - 1] * i;
inv_factor[n] = factor[n].inv();
for (int i = n; i >= 1; --i) inv_factor[i - 1] = inv_factor[i] * i;
}
~Binomial() = default;
template<typename T>
Integral<MOD> operator () (T a, T b) const {
if (a < b || b < 0) return 0;
if (a < factor.size()) return factor[a] * inv_factor[b] * inv_factor[a - b];
if constexpr(!kAllowBruteForce) {
throw std::out_of_range("Binomial");
} else {
b = std::min(b, a - b);
Integral<MOD> ret = 1;
for (T i = 1; i <= b; ++i) ret = ret * (a + 1 - i) / i;
return ret;
}
}
};
template<int MOD>
struct PowerTable : public std::vector<Integral<MOD>> {
PowerTable(int n, const Integral<MOD>& g) {
static_assert(sizeof(PowerTable) == sizeof(std::vector<Integral<MOD>>), "");
this->resize(n + 1);
this->at(0) = 1;
this->at(1) = g;
for (int i = 2; i < this->size(); ++i) this->at(i) = this->at(i - 1) * this->at(1);
}
};
const int MOD = 1e9 + 7;
using Mint = Integral<MOD>;
using Binom = Binomial<MOD>;
// Binom binom(200000);
// PowerTable<MOD> pw2(200000, 2);
const int kN = 5000 + 5;
Mint way[kN][kN];
Mint coef[kN];
int a[kN];
int n, k, q;
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::istream& reader = std::cin;
reader >> n >> k >> q;
for (int i = 1; i <= n; ++i) reader >> a[i];
for (int i = 1; i <= n; ++i) way[0][i] = 1;
for (int i = 1; i <= k; ++i) {
for (int j = 1; j <= n; ++j) {
way[i][j] = way[i - 1][j - 1] + way[i - 1][j + 1];
}
}
for (int i = 0; i <= k; ++i) {
for (int j = 1; j <= n; ++j)
coef[j] += way[i][j] * way[k - i][j];
}
Mint sum = 0;
for (int i = 1; i <= n; ++i)
sum += coef[i] * a[i];
while (q--) {
int i, x;
reader >> i >> x;
sum += coef[i] * (x - a[i]);
a[i] = x;
printf("%d\n", sum.val());
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int t[N], n, a[N], p[N];
int v[N * 4], S[N * 4];
long long SS[N * 4];
void change(int x) {
for (; x <= n; x += x & (-x)) ++t[x];
}
int ask(int x) {
int s = 0;
for (; x; x -= x & (-x)) s += t[x];
return s;
}
void build(int k, int l, int r) {
S[k] = r - l + 1;
if (l == r) return;
int mid = (l + r) / 2;
build(k * 2, l, mid);
build(k * 2 + 1, mid + 1, r);
}
void erase(int k, int l, int r, int p) {
--S[k];
if (l == r) return;
int mid = (l + r) / 2;
if (p <= mid)
erase(k * 2, l, mid, p);
else
erase(k * 2 + 1, mid + 1, r, p);
SS[k] = SS[k * 2] + SS[k * 2 + 1] + 1ll * v[k * 2] * S[k * 2 + 1];
}
void change(int k, int l, int r, int p) {
++v[k];
if (l == r) return;
int mid = (l + r) / 2;
if (p <= mid)
change(k * 2, l, mid, p);
else
change(k * 2 + 1, mid + 1, r, p);
SS[k] = SS[k * 2] + SS[k * 2 + 1] + 1ll * v[k * 2] * S[k * 2 + 1];
}
long long ask(int k, int l, int r, int lim, int val) {
if (l == r) {
if (!S[k]) return 0;
return min(val, lim - val);
}
int mid = (l + r) / 2;
if (min(val + v[k * 2], lim - val - v[k * 2]) == val + v[k * 2]) {
long long ans = SS[k * 2] + 1ll * S[k * 2] * val;
return ans + ask(k * 2 + 1, mid + 1, r, lim, val + v[k * 2]);
} else {
long long ans =
-SS[k * 2 + 1] + 1ll * S[k * 2 + 1] * (lim - val - v[k * 2]);
return ans + ask(k * 2, l, mid, lim, val);
}
}
int main() {
scanf("%d", &n);
for (int i = (int)(1); i <= (int)(n); i++) scanf("%d", &a[i]), p[a[i]] = i;
build(1, 1, n);
long long ans = 0;
for (int i = (int)(1); i <= (int)(n); i++) {
ans += i - 1 - ask(p[i]);
change(p[i]);
erase(1, 1, n, p[i]);
change(1, 1, n, p[i]);
printf("%lld ", ans + ask(1, 1, n, i, 0));
}
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.