solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long bit[4][1005][1005];
int parity(int x, int y) {
int res = 0;
if (x % 2) res += 1;
if (y % 2) res += 2;
return res;
}
void update(int x, int y, long long val) {
int y1;
int a = parity(x, y);
while (x <= n) {
y1 = y;
while (y1 <= n) {
bit[a][x][y1] ^= val;
y1 += (y1 & -y1);
}
x += (x & -x);
}
}
long long read(int x, int y) {
long long sum = 0;
int a = parity(x, y);
while (x) {
int y1 = y;
while (y1) {
sum ^= bit[a][x][y1];
y1 -= (y1 & -y1);
}
x -= x & -x;
}
return sum;
}
int main() {
int i, type, x1, x2, y1, y2;
scanf("%d", &n), scanf("%d", &m);
long long v;
for (i = 0; i < m; i++) {
scanf("%d", &type), scanf("%d", &x1), scanf("%d", &y1), scanf("%d", &x2),
scanf("%d", &y2);
if (type == 2) {
scanf("%I64d", &v);
update(x2 + 1, y2 + 1, v);
update(x1, y1, v);
update(x1, y2 + 1, v);
update(x2 + 1, y1, v);
} else {
printf("%I64d\n", read(x2, y2) ^ read(x1 - 1, y1 - 1) ^ read(x1 - 1, y2) ^
read(x2, y1 - 1));
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct IO_Tp {
const static int _I_Buffer_Size = 20 << 20;
char _I_Buffer[_I_Buffer_Size], *_I_pos;
IO_Tp() : _I_pos(_I_Buffer) { fread(_I_Buffer, 1, _I_Buffer_Size, stdin); }
IO_Tp &operator>>(int &res) {
while (!isdigit(*_I_pos)) ++_I_pos;
res = *_I_pos++ & 15;
while (isdigit(*_I_pos)) (res *= 10) += *_I_pos++ & 15;
return *this;
}
IO_Tp &operator>>(char *res) {
while (isspace(*_I_pos)) ++_I_pos;
while (!isspace(*_I_pos)) *res++ = *_I_pos++;
*res = '\0';
return *this;
}
} IO;
const int N = 12, M = 100005;
int n, m;
int c[N][M];
int re[M], ce[M];
int deg[N][M];
bool cr[N][M], cd[N][M], tag[N][M][4];
int ans[M];
vector<pair<int, int>> modi[M];
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
bool &cango(int x, int y, int dir) {
if (dir == 0)
return cr[x][y];
else if (dir == 1)
return cd[x][y];
else if (dir == 2)
return cr[x][y - 1];
else
return cd[x - 1][y];
}
struct Que {
int que[N * M * 2];
int l, r;
Que() : l(), r() {}
void push(int x) { que[r++] = x; }
void pop() { ++l; }
int front() { return que[l]; }
bool empty() { return l == r; }
} q;
void release() {
while (!q.empty()) {
int x, y;
x = q.front();
q.pop();
y = q.front();
q.pop();
if (deg[x][y] < 1) continue;
--deg[x][y];
for (int dir = 0; dir < 4; ++dir)
if (cango(x, y, dir)) {
cango(x, y, dir) = false;
if (--deg[x + dx[dir]][y + dy[dir]] == 1) {
q.push(x + dx[dir]);
q.push(y + dy[dir]);
}
break;
}
}
}
int fw[M];
int lowBit(int k) { return k & -k; }
void ch(int k) {
for (; k <= m; k += lowBit(k)) ++fw[k];
}
int qry(int k) {
int ret = 0;
for (; k; k -= lowBit(k)) ret += fw[k];
return ret;
}
int main() {
int qr;
IO >> n >> m >> qr;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) IO >> c[i][j];
for (int j = 1; j <= m; ++j) {
for (int i = 2; i <= n; ++i)
if (c[i][j] == c[i - 1][j]) {
++ce[j];
++deg[i][j];
++deg[i - 1][j];
cd[i - 1][j] = true;
}
if (j > 1) {
for (int i = 1; i <= n; ++i)
if (c[i][j] == c[i][j - 1]) {
++re[j];
++deg[i][j];
++deg[i][j - 1];
cr[i][j - 1] = true;
}
}
ce[j] += ce[j - 1];
re[j] += re[j - 1];
}
for (int i = 1; i <= n; ++i) c[i][0] = c[i][m + 1] = -1;
for (int j = 1; j <= m; ++j) c[0][j] = c[n + 1][j] = -1;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (deg[i][j] == 1) {
q.push(i);
q.push(j);
}
release();
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
release();
while (deg[i][j] > 1) {
int dir = 0;
while (!cango(i, j, dir)) ++dir;
cango(i, j, dir) = false;
if (--deg[i][j] == 1) {
q.push(i);
q.push(j);
}
int mn = j, mx = j;
int x = i, y = j, gx = x + dx[dir], gy = y + dy[dir];
if (--deg[gx][gy] == 1) {
q.push(gx);
q.push(gy);
}
while (x != gx || y != gy) {
while (!cango(x, y, dir)) dir = (dir + 1) % 4;
if (tag[x][y][dir]) break;
tag[x][y][dir] = true;
x += dx[dir];
y += dy[dir];
mn = min(mn, y);
mx = max(mx, y);
dir = (dir + 3) % 4;
if (x == i && y == j) break;
}
if (x == gx && y == gy) {
modi[mn].emplace_back(mx, -1);
}
release();
}
}
for (int i = 1; i <= qr; ++i) {
int l, r;
IO >> l >> r;
int vertices = (r - l + 1) * n, edges = ce[r] - ce[l - 1] + re[r] - re[l];
ans[i] = vertices - edges;
modi[l].emplace_back(r, i);
}
for (int i = m; i; --i)
for (const auto &pr : modi[i])
if (pr.second == -1)
ch(pr.first);
else
ans[pr.second] += qry(pr.first);
for (int i = 1; i <= qr; ++i) printf("%d\n", ans[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long x[100000 + 5], d[100000 + 5];
int s[100000 + 5], top, f[100000 + 5];
long long v0[100000 + 5], v1[100000 + 5];
int main() {
int n, i, j;
double ans = 1e11;
scanf("%d", &n);
for (i = 0; i <= n + 1; i++) scanf("%lld", &x[i]);
for (i = 1; i <= n; i++) scanf("%lld", &d[i]);
s[++top] = 0;
for (i = 1; i <= n; i++) {
while (top > 1 && x[i] - x[f[s[top]]] > 2 * d[s[top]]) top--;
v0[i] = 2 * d[i] - (x[i] - x[s[top]]);
f[i] = s[top];
while (top > 1 && d[i] * 2 + x[f[i]] >= d[s[top]] * 2 + x[f[s[top]]]) top--;
s[++top] = i;
}
top = 0;
s[++top] = n + 1;
memset(f, 0, sizeof(f));
for (i = n; i >= 1; i--) {
while (top > 1 && x[f[s[top]]] - x[i] > 2 * d[s[top]]) top--;
v1[i] = 2 * d[i] - (x[s[top]] - x[i]);
f[i] = s[top];
while (top > 1 && d[i] * 2 - x[f[i]] >= d[s[top]] * 2 - x[f[s[top]]]) top--;
s[++top] = i;
}
for (i = 1; i <= n; i++)
if (v0[i] >= 0 && v1[i] >= 0 && v0[i] + v1[i] - 2 * d[i] >= 0) {
printf("0\n");
return 0;
}
v0[0] = v1[n + 1] = 1e10;
top = 0;
s[++top] = 0;
for (i = 1; i <= n + 1; i++) {
int l = 1, r = top, id = 1;
while (l <= r) {
int mid = (l + r) >> 1;
if (v0[s[mid]] + x[s[mid]] >= x[i] - v1[i])
l = mid + 1, id = mid;
else
r = mid - 1;
}
if (v1[i] > 0) {
ans = min(ans, (x[i] - x[s[id]]) / 2.0);
}
if (v0[i] > 0) {
while (top > 0 && v0[i] + x[i] >= v0[s[top]] + x[s[top]]) top--;
s[++top] = i;
}
}
printf("%.4lf\n", ans);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
int arr[m];
for (int i = 0; i < m; i++) cin >> arr[i];
long long res = arr[0];
for (int i = 1; i < m; i++) {
if (arr[i] - arr[i - 1] < 0) {
res += (n - arr[i - 1]) + arr[i];
} else
res += (arr[i] - arr[i - 1]);
}
cout << res - 1 << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[100];
pair<int, int> b[100];
int triangle_area_2(int x1, int y1, int x2, int y2, int x3, int y3) {
return (x2 - x1) * (y3 - y1) - (y2 - y1) * (x3 - x1);
}
int main() {
int mnx = 1000000;
int mxx = -1000000;
int mny = 10000000;
int mxy = -1000000;
for (int i = 1; i <= 4; i++) {
cin >> a[i].first >> a[i].second;
if (mnx > a[i].first) mnx = a[i].first;
if (mxx < a[i].first) mxx = a[i].first;
if (mny > a[i].second) mny = a[i].second;
if (mxy < a[i].second) mxy = a[i].second;
}
int mmnx = 1000000;
int mmxx = -1000000;
int mmny = 10000000;
int mmxy = -1000000;
for (int i = 1; i <= 4; i++) {
cin >> b[i].first >> b[i].second;
if (mmnx > b[i].first) mmnx = b[i].first;
if (mmxx < b[i].first) mmxx = b[i].first;
if (mmny > b[i].second) mmny = b[i].second;
if (mmxy < b[i].second) mmxy = b[i].second;
}
b[5].first = (mmxx + mmnx) / 2;
b[5].second = (mmxy + mmny) / 2;
for (int i = 1; i <= 5; i++) {
if (b[i].first <= mxx && b[i].first >= mnx && b[i].second <= mxy &&
b[i].second >= mny) {
cout << "YES" << endl;
return 0;
}
}
pair<int, int> ans;
ans.first = (mxx + mnx) / 2;
ans.second = (mxy + mny) / 2;
int k = ans.first;
int l = ans.second;
ans.first = l + k;
ans.second = k - l;
a[5].first = ans.first;
a[5].second = ans.second;
mnx = 1000000;
mxx = -1000000;
mny = 10000000;
mxy = -1000000;
for (int i = 1; i <= 4; i++) {
int x = a[i].first;
int y = a[i].second;
a[i].first = x + y;
a[i].second = x - y;
x = b[i].first;
y = b[i].second;
b[i].first = x + y;
b[i].second = x - y;
if (mnx > b[i].first) mnx = b[i].first;
if (mxx < b[i].first) mxx = b[i].first;
if (mny > b[i].second) mny = b[i].second;
if (mxy < b[i].second) mxy = b[i].second;
if (mmnx > a[i].first) mmnx = a[i].first;
if (mmxx < a[i].first) mmxx = a[i].first;
if (mmny > a[i].second) mmny = a[i].second;
if (mmxy < a[i].second) mmxy = a[i].second;
}
for (int i = 1; i <= 5; i++) {
if (a[i].first <= mxx && a[i].first >= mnx && a[i].second <= mxy &&
a[i].second >= mny) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char x[50];
int main() {
scanf("%s", x);
int len = strlen(x);
bool isZ = true;
if (x[0] != '9') {
int a = x[0] - '0';
int b = 9 - (x[0] - '0');
x[0] = min(a, b) + '0';
}
for (int i = 1; i < len; ++i) {
int a = x[i] - '0';
int b = 9 - (x[i] - '0');
x[i] = min(a, b) + '0';
}
cout << x;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long w, w1;
cin >> w;
for (w1 = 1; w1 <= w; w1++) {
long long n, i;
cin >> n;
for (i = 1; i <= n; i++) cout << "1 ";
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
map<string, int> s;
int par[(int)1e5 + 7], br[(int)1e5 + 7], e[(int)1e5 + 7];
int fp(int a) {
if (a == -1) return -1;
if (par[a] == a)
return a;
else
par[a] = fp(par[a]);
return par[a];
}
void Merge(int a, int b) {
a = fp(a);
b = fp(b);
if (a == b) return;
if (br[a] > br[b]) {
par[b] = a;
br[a] += br[b];
} else {
par[a] = b;
br[b] += br[a];
}
if (e[a] != -1 && e[b] != -1) Merge(e[a], e[b]);
e[a] = max(fp(e[a]), fp(e[b])), e[b] = e[a];
}
void split(int a, int b) {
b = fp(b);
a = fp(a);
if (e[a] != -1)
Merge(e[a], b);
else
e[a] = b;
if (e[b] != -1)
Merge(e[b], a);
else
e[b] = a;
}
int main() {
scanf("%d %d %d", &n, &m, &q);
for (int i = 0; i < n; i++) {
string a;
cin >> a;
s[a] = i;
}
for (int i = 0; i < n; i++) par[i] = i, br[i] = 1, e[i] = -1;
int t, a, b;
string aa, bb;
for (int i = 0; i < m; i++) {
scanf("%d", &t);
cin >> aa;
cin >> bb;
a = s[aa], b = s[bb];
a = fp(a), b = fp(b);
if (t == 2 && a == b) printf("NO\n");
if (t == 2 && b != a) {
printf("YES\n");
split(a, b);
}
if (t == 1 && fp(e[a]) == b) printf("NO\n");
if (t == 1 && fp(e[a]) != b) {
Merge(a, b);
printf("YES\n");
}
}
for (int i = 0; i < q; i++) {
int a, b;
string aa, bb;
cin >> aa;
cin >> bb;
a = s[aa], b = s[bb];
if (fp(a) == fp(b))
printf("1\n");
else if (e[fp(a)] == fp(b) || e[fp(b)] == fp(a))
printf("2\n");
else
printf("3\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int ans, N, Need[150][150];
char A[200002], B[200002];
int main() {
cin >> N;
cin >> A;
cin >> B;
for (int i = 0; i < N; ++i) {
if (A[i] != B[i]) {
Need[A[i]][B[i]] = i + 1;
++ans;
}
}
for (int i = 0; i < N; ++i) {
if (A[i] != B[i]) {
if (Need[B[i]][A[i]]) {
cout << ans - 2 << '\n' << i + 1 << ' ' << Need[B[i]][A[i]] << '\n';
return 0;
}
}
}
for (int i = 0; i < N; ++i) {
if (A[i] != B[i]) {
for (char j = 'a'; j <= 'z'; ++j) {
if (Need[B[i]][j]) {
cout << ans - 1 << '\n' << i + 1 << ' ' << Need[B[i]][j] << '\n';
return 0;
}
}
}
}
cout << ans << '\n' << "-1 -1\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, neg, c, pos, res, posi;
long long arr[105], x, a;
int main() {
c = 1;
scanf("%I64d", &n);
for (int i = 0; i < n; i++) {
scanf("%I64d%I64d", &x, &a);
if (x < 0) {
neg++;
arr[c] = (x * 1000000) - a;
c++;
} else {
arr[c] = x * 1000000 + a;
c++;
pos++;
}
}
sort(arr + 1, arr + n + 1);
if (neg > pos) {
posi = neg + 1;
while (neg != 0 && pos != -1) {
res += (arr[neg--] % 1000000) * -1;
res += arr[posi++] % 1000000;
pos--;
}
} else {
posi = neg + 1;
while (neg != -1 && pos != 0) {
res += arr[posi++] % 1000000;
res += (arr[neg--] % 1000000) * -1;
pos--;
}
}
printf("%I64d\n", res);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar(), f = 0;
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') f = 1;
for (; c >= '0' && c <= '9'; c = getchar())
x = (x << 1) + (x << 3) + (c ^ 48);
if (f) x = -x;
}
int n, a[200005], cn[200005], zs, mx, buf[400005], *tim, tn[2000005];
inline void solve(int cl) {
memset(tim - n - 1, -1, (n + 1) << 3);
if (cl == zs)
return;
else
tim[0] = 0;
for (int i = 1, w = 0; i <= n; i++) {
if (a[i] == zs)
w--;
else if (a[i] == cl)
w++;
if (~tim[w])
mx = max(mx, i - tim[w]);
else
tim[w] = i;
}
}
inline void work(int tm) {
int cnt = 0;
memset(tn, 0, sizeof(tn));
for (int i = 1, l = 1; i <= n; i++) {
cnt += ++tn[a[i]] == tm;
while (l <= i && tn[a[i]] > tm) cnt -= tn[a[l]]-- == tm, l++;
if (cnt > 1) mx = max(mx, i - l + 1);
}
}
int main() {
read(n);
for (int i = 1; i <= n; i++) read(a[i]), cn[a[i]]++;
const int sz = sqrt(n);
for (int i = 1; i <= n; i++)
if (cn[zs] < cn[i]) zs = i;
tim = buf + 200001;
for (int i = 1; i <= n; i++)
if (cn[i] > sz) solve(i);
for (int i = 1; i <= sz; i++) work(i);
return printf("%d\n", mx), 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
scanf("%d %d", &N, &M);
int mn = 0, mx = 0, ch = 0;
for (int i = 0; i < N; i++) {
int query;
scanf("%d", &query);
ch += query;
mn = min(mn, ch);
mx = max(mx, ch);
}
int res = M - mx + mn + 1;
if (res < 0)
printf("0");
else
printf("%d", res);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, f;
cin >> a >> b >> c >> d >> e >> f;
if ((a * c * e < b * d * f) || (a == 0 && b * d > 0) || (c == 0 && d > 0)) {
cout << "Ron";
} else {
cout << "Hermione";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 111, mod = 998244353;
char s[N];
int dig[N], n;
int gcd(int x, int y) { return x ? gcd(y % x, x) : y; }
map<pair<int, int>, int> dp[2][2][10][10];
void add(int& var, int val) {
var += val;
if (var >= mod) var -= mod;
}
int to1[10], to2[10];
long long solve(int x, int y) {
memset(dp, 0, sizeof dp);
int c = 0, b = 1;
memset(to1, 0, sizeof to1);
memset(to2, 0, sizeof to2);
for (int i = 1; i * y < 10; ++i) {
to1[i * x] = 1 << (i - 1);
to2[i * y] = 1 << (i - 1);
}
for (int lebih = 0; lebih < 2; ++lebih) {
for (int l = 0; l < x; ++l) {
for (int r = 0; r < y; ++r) {
dp[c][lebih][l][r].clear();
}
}
}
dp[c][0][0][0][{0, 0}] = 1;
for (int i = 0; i < n; ++i) {
swap(c, b);
for (int lebih = 0; lebih < 2; ++lebih) {
for (int l = 0; l < x; ++l) {
for (int r = 0; r < y; ++r) {
dp[c][lebih][l][r].clear();
}
}
}
for (int lebih = 0; lebih < 2; ++lebih) {
for (int l = 0; l < x; ++l) {
for (int r = 0; r < y; ++r) {
for (auto it : dp[b][lebih][l][r]) {
int now = it.second;
int maska = it.first.first, maskb = it.first.second;
if (now == 0) continue;
for (int k = 0; k < 10; ++k) {
int ll = l + x * k, rr = r + y * k;
int dl = ll % 10, dr = rr % 10;
ll /= 10;
rr /= 10;
int more = 0;
if (dr > dig[i])
more = 1;
else if (dr == dig[i])
more = lebih;
int mmaska = maska, mmaskb = maskb;
if (mmaska != -1) {
mmaska |= to1[dl];
mmaskb |= to2[dr];
if (mmaska & mmaskb) mmaska = mmaskb = -1;
}
add(dp[c][more][ll][rr][{mmaska, mmaskb}], now);
}
}
}
}
}
}
int ans = 0;
for (auto it : dp[c][0][0][0]) {
auto mask = it.first;
if (mask.first & mask.second) add(ans, it.second);
}
return ans;
}
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < n; ++i) dig[n - 1 - i] = s[i] - '0';
dig[n] = 0;
long long ans = 0;
for (int x = 1; x <= 9; ++x) {
for (int y = x; y <= 9; ++y) {
if (gcd(x, y) != 1) continue;
long long res = solve(x, y);
ans = (ans + res) % mod;
if (x != y) ans = (ans + res) % mod;
}
}
printf("%lld\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
long long ast = 1;
for (int i = 1; i < n; i++) ast *= 2;
int a[102];
long long l = 0, r = n - 1;
long long l1 = 1;
long long r1 = ast;
int k = 1;
while (r >= l) {
long long tm = (l1 + r1) / 2;
if (tm >= m) {
a[l] = k;
l++;
r1 = tm;
} else {
a[r] = k;
r--;
l1 = tm;
}
k++;
}
for (int i = 0; i < n; i++) cout << a[i] << " ";
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string solve(const string &s) {
int n = s.length();
deque<int> pos[2];
for (int i = 0; i < n; i++) pos[s[i] - '0'].push_back(i);
for (int i = 0; i < n - 2; i++) {
if (i & 1) {
if (pos[0].empty()) return "11";
pos[0].pop_front();
} else {
if (pos[1].empty()) return "00";
pos[1].pop_front();
}
}
if (pos[0].empty()) return "11";
if (pos[1].empty()) return "00";
if (pos[0].front() < pos[1].front()) return "01";
return "10";
}
int main() {
string s;
cin >> s;
int n = s.length();
set<string> an;
string r = s;
for (auto &u : r)
if (u == '?') u = '0';
an.insert(solve(r));
r = s;
for (auto &u : r)
if (u == '?') u = '1';
an.insert(solve(r));
r = s;
int cnt0 = 0, cnt1 = 0;
for (auto u : s)
if (u == '0')
++cnt0;
else if (u == '1')
++cnt1;
int need0 = n / 2, need1 = n - need0;
for (auto &u : r) {
if (u == '?') {
if (cnt0 < need0) {
u = '0';
++cnt0;
} else {
u = '1';
++cnt1;
}
}
}
an.insert(solve(r));
r = s;
cnt0 = 0, cnt1 = 0;
for (auto u : s)
if (u == '0')
++cnt0;
else if (u == '1')
++cnt1;
for (auto &u : r) {
if (u == '?') {
if (cnt1 < need1) {
u = '1';
++cnt1;
} else {
u = '0';
++cnt0;
}
}
}
an.insert(solve(r));
for (string u : an) printf("%s\n", u.c_str());
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > psi(10), dp;
vector<int> a;
int n;
int valMx(int i, int eleg, int m) {
if (eleg == (1 << 8) - 1 || (i == n && m == 0)) return 0;
if (i >= n) return -1e9;
if (dp[i][eleg] > -2e9) return dp[i][eleg];
int mx = valMx(i + 1, eleg, m), k = a[i];
if (!(eleg & (1 << k - 1))) {
int l = lower_bound(psi[k].begin(), psi[k].end(), i) - psi[k].begin();
if (l + m - 1 < psi[k].size())
mx = max(mx, valMx(psi[k][l + m - 1] + 1, (eleg | (1 << k - 1)), m) + m);
if (l + m < psi[k].size())
mx = max(mx, valMx(psi[k][l + m] + 1, (eleg | (1 << k - 1)), m) + m + 1);
}
return dp[i][eleg] = mx;
}
int obtRes() {
int i = 0, j = 1000, m = (i + j) / 2;
for (int l = 0; l < 12; l++) {
dp = vector<vector<int> >(n + 2, vector<int>(1 << 8, -2e9));
if (valMx(0, 0, m) >= 0)
i = m;
else
j = m;
m = (i + j) / 2;
dp = vector<vector<int> >(n + 2, vector<int>(1 << 8, -2e9));
}
return valMx(0, 0, m);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
a = vector<int>(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
psi[a[i]].push_back(i);
}
cout << obtRes() << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
vector<pair<long long, int> > veki;
int bp[40];
long long fakt[53], inv[53];
long long gcd(long long a, long long b) {
long long t;
while (a) {
t = a;
a = b % a;
b = t;
}
return b;
}
long long inverz(long long first) {
long long s = first;
long long ret = 1ll;
for (int i = 0; i < 32; i++) {
if (bp[i]) ret = (ret * s) % mod;
s = (s * s) % mod;
}
return ret;
}
int main() {
long long n;
cin >> n;
for (long long i = 2ll; i * i <= n; i++) {
if (n % i == 0ll) {
int ai = 0;
while (n % i == 0) {
ai++;
n /= i;
}
veki.push_back(make_pair(i, ai));
}
}
if (n > 1) veki.push_back(make_pair(n, 1));
int q;
cin >> q;
fakt[0] = 1ll;
int br = 0;
int k = mod - 2;
while (k) {
bp[br] = k % 2;
k /= 2;
br++;
}
for (long long i = 1ll; i < 51; i++) {
fakt[i] = (fakt[i - 1] * i) % mod;
}
for (long long i = 1ll; i < 51; i++) {
inv[i] = inverz(fakt[i]);
}
for (int i = 0; i < q; i++) {
long long first, second;
cin >> first >> second;
long long g = gcd(first, second);
long long x1 = first / g;
long long y1 = second / g;
int brx = 0, bry = 0;
long long sx = 1ll, sy = 1ll;
for (int j = 0; j < veki.size(); j++) {
if (x1 % veki[j].first == 0ll) {
int ax = 0;
while (x1 % veki[j].first == 0ll) {
ax++;
brx++;
x1 /= veki[j].first;
}
sx = (sx * inv[ax]) % mod;
}
if (y1 % veki[j].first == 0ll) {
int ay = 0;
while (y1 % veki[j].first == 0ll) {
ay++;
bry++;
y1 /= veki[j].first;
}
sy = (sy * inv[ay]) % mod;
}
}
sx = (sx * fakt[brx]) % mod;
sy = (sy * fakt[bry]) % mod;
cout << (sx * sy) % mod << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool prime(long long n) {
for (long long i = 2; i <= sqrt(n); i++) {
if (n % i == 0) return false;
}
return true;
}
void CyBerForCe() {
long long n;
cin >> n;
if (!prime(n)) {
if (n % 2)
cout << n + 9 << " 9\n";
else
cout << n + 4 << " 4\n";
} else {
if (n == 2)
cout << "6 4\n";
else
cout << n + 9 << " 9\n";
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
CyBerForCe();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long k;
vector<pair<long long, long long> > A;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k;
A.assign(n, {0, 0});
for (pair<long long, long long> &x : A) {
cin >> x.first;
}
for (pair<long long, long long> &x : A) {
cin >> x.second;
}
sort(begin(A), end(A),
[](pair<long long, long long> x, pair<long long, long long> y) {
return x.second < y.second ||
(x.second == y.second && x.first < y.first);
});
long long cnt = 1;
for (int i = 1; i < n; i++) {
if (A[i].second < i + 1) {
cout << "No";
return 0;
}
if (A[i].second != A[i - 1].second) {
if (cnt > 1) {
if (A[i].first - A[i - 1].first < 2ll) {
cout << "No";
return 0;
}
} else {
if (A[i].first - A[i - 1].first < 1ll) {
cout << "No";
return 0;
}
}
if (A[i - 1].second != i) {
cout << "No";
return 0;
}
cnt = 1;
} else {
cnt++;
}
}
cout << "Yes\n";
long long sc = 1;
for (int i = 1; i < n; i++) {
if (A[i].second != A[i - 1].second) {
if (sc > 1) {
for (int j = i - sc + 1; j < i; j++) {
cout << A[j].first + k << " ";
}
cout << A[i - 1].first + k + 1ll << " ";
} else {
cout << A[i - 1].first + k << " ";
}
sc = 1;
} else {
sc++;
}
}
if (sc > 1) {
for (int j = n - sc + 1; j < n; j++) {
cout << A[j].first + k << " ";
}
cout << A[n - 1].first + k + 1 << " ";
} else {
cout << A[n - 1].first + k << " ";
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, n;
cin >> t;
while (t--) {
cin >> n;
if (n == 1 || n == 0) {
cout << "0" << endl;
} else {
if (n & 1) {
cout << n / 2 << endl;
} else {
cout << n / 2 - 1 << endl;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> m;
int main() {
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
if (n <= 3 || n == 5 || n == 7)
cout << -1;
else if (n == 11)
cout << -1;
else if (n % 4 == 0)
cout << n / 4;
else if (n % 4 == 1)
cout << n / 4 - 1;
else if (n % 4 == 2)
cout << n / 4;
else
cout << n / 4 - 1;
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool isprime(long long n) {
if (n == 1) return 0;
if (n == 2) return 1;
if (n % 2 == 0) return 0;
for (long long i = 3; i * i <= n; i += 2) {
if (n % i == 0) {
return 0;
}
}
return 1;
}
int main() {
int t;
cin >> t;
while (t--) {
long long a, b;
cin >> a >> b;
if (a - b == 1) {
if (isprime(a + b)) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} else {
cout << "NO" << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[27];
string s;
string s1;
int t;
int main() {
cin >> t;
for (int tt = 0; tt < t; tt++) {
for (int i = 0; i < 27; i++) {
v[i].clear();
}
cin >> s;
cin >> s1;
for (int i = 0; i < s.size(); i++) {
v[s[i] - 'a'].push_back(i);
}
int pos = 0;
int count = 0;
std::vector<int>::iterator pos2;
int pos3 = 0;
bool good = true;
for (int i = 0; i < s1.size(); i++) {
if (v[s1[i] - 'a'].size() == 0) {
cout << "-1" << endl;
good = false;
break;
}
pos2 =
std::lower_bound(v[s1[i] - 'a'].begin(), v[s1[i] - 'a'].end(), pos);
pos3 = pos2 - v[s1[i] - 'a'].begin();
if (pos3 > v[s1[i] - 'a'].size() - 1 || (v[s1[i] - 'a'][pos3]) < pos) {
count++;
i--;
pos = 0;
} else {
pos = (v[s1[i] - 'a'][pos3]) + 1;
}
}
if (good) cout << count + 1 << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dx[4] = {-1, 1, 0, 0}, dy[4] = {0, 0, -1, 1};
long long n, m, i, j, k, ans, fx[1005], fy[1005], tx[1005], ty[1005], x, nx, ny;
int mp[5005][5005];
char op;
vector<long long> allx, ally;
void bfs(int x, int y) {
queue<int> qx, qy;
qx.push(x);
qy.push(y);
int i;
while (!qx.empty()) {
int x = qx.front(), y = qy.front();
qx.pop();
qy.pop();
if (!mp[x][y]) mp[x][y] = 2;
for (i = 0; i < 4; i++) {
int xx = x + dx[i], yy = y + dy[i];
if (xx > -1 && yy > -1 && xx <= allx.size() + 5 &&
yy <= ally.size() + 5) {
if (!mp[xx][yy]) {
qx.push(xx);
qy.push(yy);
mp[xx][yy] = 2;
}
}
}
}
}
int main() {
scanf("%I64d", &n);
for (i = 1; i <= n; i++) {
scanf(" %c%d", &op, &x);
fx[i] = nx;
fy[i] = ny;
if (op == 'L') {
ny -= x;
}
if (op == 'R') {
ny += x;
}
if (op == 'U') {
nx -= x;
}
if (op == 'D') {
nx += x;
}
tx[i] = nx;
ty[i] = ny;
if (fx[i] > tx[i]) swap(fx[i], tx[i]);
if (fy[i] > ty[i]) swap(fy[i], ty[i]);
tx[i]++;
ty[i]++;
}
for (i = 1; i <= n; i++) {
allx.push_back(fx[i]);
ally.push_back(fy[i]);
allx.push_back(tx[i]);
ally.push_back(ty[i]);
}
sort(allx.begin(), allx.end());
allx.resize(unique(allx.begin(), allx.end()) - allx.begin());
sort(ally.begin(), ally.end());
ally.resize(unique(ally.begin(), ally.end()) - ally.begin());
allx.insert(allx.begin(), allx[0] - 1);
ally.insert(ally.begin(), ally[0] - 1);
allx.push_back(allx.back() + 1);
ally.push_back(ally.back() + 1);
for (i = 1; i <= n; i++) {
fx[i] = upper_bound(allx.begin(), allx.end(), fx[i]) - allx.begin();
fy[i] = upper_bound(ally.begin(), ally.end(), fy[i]) - ally.begin();
tx[i] = upper_bound(allx.begin(), allx.end(), tx[i]) - allx.begin();
ty[i] = upper_bound(ally.begin(), ally.end(), ty[i]) - ally.begin();
for (j = fx[i]; j < tx[i]; j++) {
for (k = fy[i]; k < ty[i]; k++) {
mp[j][k] = 1;
}
}
}
bfs(0, 0);
for (i = 1; i < allx.size(); i++) {
for (j = 1; j < ally.size(); j++) {
if (mp[i][j] != 2) {
ans += (allx[i] - allx[i - 1]) * (ally[j] - ally[j - 1]);
}
}
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int arr[121];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int N, c, ans = 0;
cin >> N >> c;
for (int i = 1; i <= N; i++) {
cin >> arr[i];
}
for (int i = 1; i < N; i++) {
ans = max(arr[i] - c - arr[i + 1], ans);
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class A>
void pr(A a) {
cout << a;
cout << '\n';
}
template <class A, class B>
void pr(A a, B b) {
cout << a << ' ';
pr(b);
}
template <class A, class B, class C>
void pr(A a, B b, C c) {
cout << a << ' ';
pr(b, c);
}
template <class A, class B, class C, class D>
void pr(A a, B b, C c, D d) {
cout << a << ' ';
pr(b, c, d);
}
template <class A>
void PR(A a, long long n) {
for (int i = (int)(0); i < (int)(n); i++) {
if (i) cout << ' ';
cout << a[i];
}
cout << '\n';
}
long long check(long long n, long long m, long long x, long long y) {
return x >= 0 && x < n && y >= 0 && y < m;
}
const long long MAX = 1000000007, MAXL = 1LL << 61, dx[4] = {-1, 0, 1, 0},
dy[4] = {0, 1, 0, -1};
const int m = 1000001;
bool u[m];
void Main() {
long long n;
cin >> n;
for (int i = (int)(0); i < (int)(n); i++) {
long long x;
cin >> x;
u[x] = 1;
}
vector<long long> ans;
for (int i = (int)(1); i < (int)(m); i++) {
if (u[i] && !u[m - i]) {
ans.push_back(m - i);
n--;
}
}
for (int i = (int)(1); i < (int)(m); i++) {
if (n && !u[i] && !u[m - i]) {
ans.push_back(i);
ans.push_back(m - i);
n -= 2;
}
}
pr(ans.size());
PR(ans, ans.size());
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
Main();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int input[101][4], n, owakon[101] = {0}, ans = 1, minprice = 9999;
cin >> n;
for (int i = 1; i <= n; i++)
for (int j = 0; j < 4; j++) cin >> input[i][j];
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) {
if (input[i][0] < input[j][0] && input[i][1] < input[j][1] &&
input[i][2] < input[j][2])
owakon[i] = 1;
if (input[i][0] > input[j][0] && input[i][1] > input[j][1] &&
input[i][2] > input[j][2])
owakon[j] = 1;
}
for (int i = 1; i <= n; i++) {
if (!owakon[i]) {
if (input[i][3] < minprice) {
minprice = input[i][3];
ans = i;
}
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
ios::sync_with_stdio(false);
cin.tie(nullptr);
long long int n, p, k, i, count = 0;
vector<long long int> a;
cin >> n >> p >> k;
for (i = 0; i < n; i++) {
long long int temp;
cin >> temp;
a.push_back(temp);
}
map<long long int, long long int> m;
for (i = 0; i < n; i++) {
long long int val;
val = (((long long int)pow(((long long int)pow(a[i], 2) % p), 2) % p) -
((k * a[i]) % p) + p) %
p;
count += m[val];
m[val]++;
}
cout << count << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void __f(const char* na, Arg1&& arg1, Args&&... args) {
const char* c = strchr(na + 1, ',');
cerr.write(na, c - na) << " : " << arg1 << " , ";
__f(c + 1, args...);
}
const int mod = 1e9 + 7;
const int inf = 1e9;
const long long INF = 1e18;
const int N = 1e5 + 5;
struct node {
int cnt;
bool endmark;
node* nxt[2];
node() {
cnt = 0;
endmark = false;
for (int i = 0; i < 2; i++) nxt[i] = NULL;
}
} * root;
template <typename T>
class trie_int {
public:
int mx_bit = -1;
trie_int(int sz) {
mx_bit = sz;
root = new node();
}
inline bool check(T n, int pos) { return (bool)(n & (1LL << pos)); }
inline T on(T n, int pos) { return n |= (1LL << pos); }
inline void del(node* cur) {
for (int i = 0; i < 2; i++) {
if (cur->nxt[i]) del(cur->nxt[i]);
}
delete (cur);
}
inline void insert(T num) {
node* cur = root;
for (int i = mx_bit; i >= 0; i--) {
int id = check(num, i);
if (cur->nxt[id] == NULL) {
cur->nxt[id] = new node();
}
cur = cur->nxt[id];
}
cur->endmark = true;
}
};
int a[N];
int solve(node* cur, int bit) {
if (cur->nxt[0] == NULL && cur->nxt[1] == NULL)
return 0;
else if (cur->nxt[0] == NULL) {
return solve(cur->nxt[1], bit - 1);
} else if (cur->nxt[1] == NULL) {
return solve(cur->nxt[0], bit - 1);
} else {
int res = 0;
res = min(solve(cur->nxt[1], bit - 1), solve(cur->nxt[0], bit - 1));
res += (1 << bit);
return res;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
trie_int<int> tr(30);
for (int i = 1; i <= n; i++) tr.insert(a[i]);
cout << solve(root, 30) << "\n";
tr.del(root);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
int fa[200003];
int nowl, nowr, nowans;
int f[200003][23];
int dep[200003];
inline int lca(int a, int b) {
if (dep[a] < dep[b]) {
swap(a, b);
}
int x = dep[a] - dep[b];
for (int i = 0; i <= 20; i++) {
if (x & (1 << i)) {
a = f[a][i];
}
}
for (int i = 20; i >= 0; i--) {
if (f[a][i] != f[b][i]) {
a = f[a][i], b = f[b][i];
}
}
if (a == b) {
return a;
}
return f[a][0];
}
inline int ju(int a, int b) {
if (a == b) {
return 0;
}
int ca = lca(a, b);
return dep[a] + dep[b] - 2 * dep[ca];
}
int main() {
cin >> n;
nowl = 1, nowr = 1;
nowans = 0;
f[1][0] = 0;
dep[1] = 1;
for (int i = 2; i <= n; i++) {
cin >> fa[i];
dep[i] = dep[fa[i]] + 1;
f[i][0] = fa[i];
for (int j = 1; j <= 20; j++) {
f[i][j] = f[f[i][j - 1]][j - 1];
}
if (ju(nowl, i) >= nowans && ju(nowl, i) >= ju(nowr, i)) {
nowans = ju(nowl, i);
nowr = i;
}
if (ju(nowr, i) >= nowans && ju(nowr, i) >= ju(nowl, i)) {
nowans = ju(nowr, i);
nowl = i;
}
cout << nowans << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int dp[100005] = {0};
int pos[100005];
for (int i = 0; i < 100005; i++) pos[i] = 100003;
int ans = 0;
for (int i = 0; i < n; i++) {
dp[i] = 1;
for (int j = 2; j * j <= a[i]; j++) {
if (a[i] % j == 0) {
dp[i] = max(dp[i], dp[pos[j]] + 1);
dp[i] = max(dp[i], dp[pos[a[i] / j]] + 1);
pos[j] = i;
pos[a[i] / j] = i;
}
}
pos[a[i]] = i;
ans = max(ans, dp[i]);
}
cout << ans << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353, N = 505;
int add(int x, int y) {
x += y;
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
return x;
}
int mul(int x, int y) { return (x * 1ll * y) % MOD; }
int power(int n, int m, int p) {
int res = 1;
while (m > 0) {
if (m & 1) res = (res * 1ll * n) % p;
n = (n * 1ll * n) % p;
m /= 2;
}
return res;
}
int fact[N], invfact[N];
void init() {
fact[0] = fact[1] = 1;
int i;
for (i = 2; i < N; i++) fact[i] = (fact[i - 1] * 1ll * i) % MOD;
i--;
invfact[i] = power(fact[i], MOD - 2, MOD);
for (i--; i >= 0; i--) invfact[i] = (invfact[i + 1] * 1ll * (i + 1)) % MOD;
}
int ncr(int n, int r) {
if (r > n || n < 0 || r < 0) return 0;
return mul(fact[n], mul(invfact[r], invfact[n - r]));
}
int dp[N][N];
int calc(int n, int x) {
if (n == 1) return 0;
if (x < n) return add(power(x, n, MOD), -power(x - 1, n, MOD));
if (dp[n][x] == -1) {
int res = calc(n, x - (n - 1));
for (int i = 1; i < n; i++) {
int rem = n - i;
res = add(res, mul(calc(i, x - n + 1),
mul(ncr(n, rem), power(n - 1, rem, MOD))));
}
dp[n][x] = res;
}
return dp[n][x];
}
int solve() {
int n, x;
cin >> n >> x;
memset(dp, -1, sizeof(dp));
int res = 0;
for (int i = 1; i <= x; i++) res = add(res, calc(n, i));
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
init();
cout << solve() << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, a[30], k, mid;
long long goal, ans;
long long fact[21];
map<long long, int> mpA[30], mpB[30];
int ssLen = 0, vLen = 0;
void getMpA(int pos, int used, long long sum) {
if (sum > goal || used > k) return;
if (pos == mid) {
mpA[used][sum]++, vLen++;
return;
}
getMpA(pos + 1, used, sum);
getMpA(pos + 1, used, sum + a[pos]);
if (a[pos] <= 18) getMpA(pos + 1, used + 1, sum + fact[a[pos]]);
}
void getMpB(int pos, int used, long long sum) {
if (sum > goal || used > k) return;
if (pos == n) {
mpB[used][sum]++;
return;
}
getMpB(pos + 1, used, sum);
getMpB(pos + 1, used, sum + a[pos]);
if (a[pos] <= 18) getMpB(pos + 1, used + 1, sum + fact[a[pos]]);
}
int main() {
fact[0] = 1;
for (long long i = 1ll; i < 21ll; i++) fact[i] = fact[i - 1] * i;
cin >> n >> k >> goal;
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
mid = n / 2;
getMpA(0, 0, 0ll);
getMpB(mid, 0, 0ll);
ans = 0ll;
for (int i = 0; i <= k; i++)
for (typeof(mpA[i].begin()) it = mpA[i].begin(); it != mpA[i].end(); it++)
for (int j = 0; j <= k - i; j++)
if (mpB[j].find(goal - (it->first)) != mpB[j].end())
ans += 1ll * (it->second) * mpB[j][goal - (it->first)];
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string s;
int a[27], vis[27];
int main() {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
cin >> s;
vector<int> v;
for (int i = 0; i < 27; i++) a[i] = vis[i] = 0;
int cnt = 0;
for (int i = 0; i < n; i++) {
a[s[i] - 'a']++;
}
for (int i = 1; i <= k; i++)
if (k % i == 0) v.push_back(i);
int maxv = 0;
if (k % n == 0) maxv = max(maxv, n);
for (int i = 1; i <= n; i++) {
for (auto u : v) {
if (u % i == 0) {
maxv = max(maxv, i);
}
if (i % u == 0) {
int xx = i / u, tmp = 0;
for (int j = 0; j <= 26; j++) {
tmp += a[j] / xx;
}
if (tmp >= u) maxv = max(maxv, i);
}
}
}
cout << maxv << endl;
}
}
| 5 |
#include <bits/stdc++.h>
const int MOD = 998244353;
const int MAX = 5005;
int C[MAX][MAX];
inline long long calc(int _x, int _y) {
int m = std::min(_x, _y);
long long ret = 0, fac = 1;
for (int i = 0; i <= m; i++) {
ret += (((long long)C[_x][i] * C[_y][i]) % MOD * fac) % MOD;
ret %= MOD;
fac *= i + 1;
fac %= MOD;
}
return ret;
}
int main() {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
for (int i = 0; i <= 5000; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % MOD;
}
int ans = ((calc(a, b) * calc(a, c)) % MOD * calc(b, c)) % MOD;
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline void read(register int *n) {
register char c;
*n = 0;
do {
c = getchar();
} while (c < '0' || c > '9');
do {
*n = c - '0' + *n * 10;
c = getchar();
} while (c >= '0' && c <= '9');
}
int dp[40][1 << 6][1 << 6], w;
int f(int row, int prev, int have) {
if (row == -1) return (prev == (1 << w) - 1) ? 0 : 100;
int &res = dp[row][prev][have];
if (res != -1) return res;
res = 100;
for (register int mask = (0); mask < (int)(1 << w); ++mask) {
int cover = (mask | (mask << 1) | (mask >> 1) | have) & ((1 << w) - 1);
if ((mask | prev) == (1 << w) - 1)
res = min(f(row - 1, cover, mask) + __builtin_popcount(mask), res);
}
return res;
}
int main(int argv, char **argc) {
memset(dp, -1, sizeof dp);
int n, m;
cin >> n >> m;
if (n > m) swap(n, m);
w = n;
cout << m * n - f(m - 1, (1 << w) - 1, 0) << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
cin.tie(NULL);
cout.tie(NULL);
int n, m, k;
cin >> n >> m >> k;
vector<int> a(n);
vector<int> b(m);
vector<int> aNum(n + 1, 0);
vector<int> bNum(m + 1, 0);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < m; i++) {
cin >> b[i];
}
int tempCnt = 0;
for (int i = 0; i < n; i++) {
if (a[i] != 0) {
tempCnt++;
if (i == n - 1)
for (int j = 1; j <= tempCnt; j++) aNum[j] += (tempCnt - j + 1);
} else if (a[i] == 0) {
for (int j = 1; j <= tempCnt; j++) aNum[j] += (tempCnt - j + 1);
tempCnt = 0;
}
}
tempCnt = 0;
for (int i = 0; i < m; i++) {
if (b[i] != 0) {
tempCnt++;
if (i == m - 1)
for (int j = 1; j <= tempCnt; j++) bNum[j] += (tempCnt - j + 1);
} else if (b[i] == 0) {
for (int j = 1; j <= tempCnt; j++) bNum[j] += (tempCnt - j + 1);
tempCnt = 0;
}
}
if (true) {
vector<int> nums;
for (int i = 1; i <= sqrt(k); i++) {
if (k % i == 0) {
nums.push_back(i);
if (i != (k / i)) nums.push_back(k / i);
}
}
int sizeNum = nums.size() - 1;
int temp = nums[sizeNum];
long long int sum = 0;
while (sizeNum >= 0) {
temp = nums[sizeNum];
int tempB = (k / temp);
if ((temp * tempB) != k || temp > n || tempB > m) {
sizeNum--;
continue;
}
sum += ((long long)aNum[temp] * (long long)bNum[tempB]);
sizeNum--;
}
cout << sum;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 44;
const int X[] = {1, 0, -1, 0, 1, -1, 1, -1};
const int Y[] = {0, 1, 0, -1, 1, 1, -1, -1};
const int mod = 1e9 + 7;
const int INF = INT_MAX;
vector<int> g[N];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
if (n == 2 || n == 3) return cout << (n == 2 ? "YES" : "NO"), 0;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
u--, v--;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 0; i < n; i++) {
if (g[i].size() == 2) {
cout << "NO";
return 0;
}
}
cout << "YES";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int count, i, a[26], b[26];
char s1[1100], s2[1100];
while (scanf("%s", s1) == 1) {
getchar();
scanf("%s", s2);
getchar();
count = 0;
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
for (i = 0; s1[i] != '\0'; i++) {
a[s1[i] - 'a']++;
}
for (i = 0; s2[i] != '\0'; i++) {
b[s2[i] - 'a']++;
}
int flag = 1;
for (i = 0; i < 26; i++)
if (!a[i] && b[i]) {
printf("-1\n");
flag = 0;
break;
} else
count += min(a[i], b[i]);
if (flag) printf("%d\n", count);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 1000000;
long long na, nb, nc, res;
vector<long long> a, b, c;
long long cal2(long long x) { return x * x; }
long long cal(long long x, long long y, long long z) {
return cal2(x - y) + cal2(y - z) + cal2(z - x);
}
void calc(long long val, long long x, long long y, long long u, long long v) {
for (int i = x; i <= y; i++)
for (int j = u; j <= v; j++) res = min(res, cal(val, b[i], c[j]));
}
void solve2() {
long long j = 0, k = 0;
for (auto h : a) {
while (j < b.size() && b[j] < h) j++;
while (k < c.size() && c[k] < h) k++;
long long x = max((long long)0, j - 1),
y = min((long long)(b.size() - 1), j + 1);
long long u = max((long long)0, k - 1),
v = min((long long)(c.size() - 1), k + 1);
calc(h, x, y, u, v);
}
}
void solve() {
a.clear();
b.clear();
c.clear();
cin >> na >> nb >> nc;
a.assign(na, 0);
b.assign(nb, 0);
c.assign(nc, 0);
for (int i = 0; i < na; i++) cin >> a[i];
for (int i = 0; i < nb; i++) cin >> b[i];
for (int i = 0; i < nc; i++) cin >> c[i];
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(c.begin(), c.end());
a.erase(unique(a.begin(), a.end()), a.end());
b.erase(unique(b.begin(), b.end()), b.end());
c.erase(unique(c.begin(), c.end()), c.end());
res = 9000000000000000000;
solve2();
swap(a, b);
solve2();
swap(a, c);
solve2();
cout << res << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long T = 1;
cin >> T;
for (int i = 1; i <= T; i++) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool SR(int &x) { return scanf("%d", &x) == 1; }
bool SR(long long &x) { return scanf("%lld", &x) == 1; }
bool SR(double &x) { return scanf("%lf", &x) == 1; }
bool SR(char *s) { return scanf("%s", s) == 1; }
bool RI() { return true; }
template <typename I, typename... T>
bool RI(I &x, T &...tail) {
return SR(x) && RI(tail...);
}
void SP(const int x) { printf("%d", x); }
void SP(const long long x) { printf("%lld", x); }
void SP(const double x) { printf("%.16lf", x); }
void SP(const char *s) { printf("%s", s); }
void PL() { puts(""); }
template <typename I, typename... T>
void PL(const I x, const T... tail) {
SP(x);
if (sizeof...(tail)) putchar(' ');
PL(tail...);
}
const int maxn = 1e5 + 5;
struct Node {
static Node mem[maxn], *pmem;
int dep;
Node *fail, *to[2];
int who;
Node() : dep(-1), fail(0), to{NULL, NULL}, who(-1) {}
Node(int _d, int _w) : dep(_d), fail(0), to{NULL, NULL}, who(_w) {}
} Node::mem[maxn], *Node::pmem = Node::mem;
struct AC {
AC() { root = new (Node::pmem++) Node(-1, -1); }
Node *root;
void add(const string &s, int id) {
Node *pt = root;
for (int i = 0; i < int(((int)(s).size())); i++) {
if (!pt->to[s[i] - 'a'])
pt->to[s[i] - 'a'] = new (Node::pmem++) Node(1 + pt->dep, -1);
pt = pt->to[s[i] - 'a'];
}
pt->who = id;
}
void build() {
queue<Node *> q;
q.push(root);
root->fail = root;
while (((int)(q).size())) {
Node *pt = q.front();
q.pop();
for (int i = 0; i < int(2); i++)
if (pt->to[i]) q.push(pt->to[i]);
if (pt->dep == -1) {
for (int i = 0; i < int(2); i++)
if (pt->to[i]) pt->to[i]->fail = root;
for (int i = 0; i < int(2); i++)
if (!pt->to[i]) pt->to[i] = root;
} else {
for (int i = 0; i < int(2); i++)
if (pt->to[i]) {
Node *&cur = pt->to[i]->fail;
for (cur = pt->fail; cur != root && !cur->to[i]; cur = cur->fail)
;
if (cur->to[i]) cur = cur->to[i];
}
for (int i = 0; i < int(2); i++)
if (!pt->to[i]) {
Node *&cur = pt->to[i];
for (cur = pt->fail; cur != root && !cur->to[i]; cur = cur->fail)
;
if (cur->to[i]) cur = cur->to[i];
}
}
}
}
} ac;
const int MOD = 1e9 + 7;
const int i2 = MOD - MOD / 2;
int add(const int &a, const int &b) {
return a + b < MOD ? a + b : a + b - MOD;
}
int mul(const int &a, const int &b) { return 1LL * a * b % MOD; }
int sig;
int dp[maxn];
void find_occur(const string &s, int ans[]) {
memset(dp, 0, sizeof(int) * sig);
Node *pt = ac.root;
for (char c : s) {
pt = pt->to[c - 'a'];
dp[pt - Node::mem]++;
}
vector<int> odr(sig);
for (int i = 0; i < int(sig); i++) odr[i] = i;
sort((odr).begin(), (odr).end(),
[&](int i, int j) { return Node::mem[i].dep > Node::mem[j].dep; });
for (int i : odr)
dp[Node::mem[i].fail - Node::mem] =
add(dp[Node::mem[i].fail - Node::mem], dp[i]);
for (int i = 0; i < int(sig); i++)
if (~Node::mem[i].who) ans[Node::mem[i].who] = dp[i];
}
long long n;
int m;
string s[maxn];
void read() {
RI(n, m);
for (int i = 0; i < int(m); i++) {
static char in[maxn];
RI(in);
s[i] = in;
}
}
string os[maxn];
int om;
void build() {
om = m;
for (int i = 0; i < int(m); i++) os[i] = s[i];
sort(s, s + m);
m = unique(s, s + m) - s;
for (int i = 0; i < int(m); i++) ac.add(s[i], i);
ac.build();
sig = Node::pmem - Node::mem;
}
array<array<int, 3>, 3> operator*(const array<array<int, 3>, 3> &a,
const array<array<int, 3>, 3> &b) {
array<array<int, 3>, 3> ret;
for (int i = 0; i < int(3); i++)
for (int j = 0; j < int(3); j++) ret[i][j] = 0;
for (int i = 0; i < int(3); i++)
for (int j = 0; j < int(3); j++)
for (int k = 0; k < int(3); k++)
ret[i][k] = add(ret[i][k], mul(a[i][j], b[j][k]));
return ret;
}
int ans[maxn];
string f[maxn];
void sol_small() {
f[1] = "a";
f[2] = "b";
for (int i = (3); i <= int(26); i++) f[i] = f[i - 1] + f[i - 2];
if (n <= 26) {
find_occur(f[n], ans);
} else {
static int tmp[4][maxn];
for (int i = (27); i <= int(29); i++) f[i] = f[i - 1] + f[i - 2];
for (int i = 0; i < int(4); i++) find_occur(f[i + 26], tmp[i]);
array<array<int, 3>, 3> X, A;
X[0][0] = 0;
X[0][1] = 0;
X[0][2] = 1;
X[1][0] = 1;
X[1][1] = 0;
X[1][2] = 2;
X[2][0] = 0;
X[2][1] = 1;
X[2][2] = 0;
A[0][0] = 1;
A[0][1] = 0;
A[0][2] = 0;
A[1][0] = 0;
A[1][1] = 1;
A[1][2] = 0;
A[2][0] = 0;
A[2][1] = 0;
A[2][2] = 1;
for (long long b = n - 26; b; b >>= 1, X = X * X)
if (b & 1) A = A * X;
for (int i = 0; i < int(m); i++) {
int dlt = tmp[3][i];
dlt = add(dlt, MOD - tmp[1][i]);
dlt = add(dlt, MOD - tmp[1][i]);
dlt = add(dlt, MOD - tmp[0][i]);
dlt = mul(dlt, i2);
int a[] = {tmp[0][i], tmp[1][i], tmp[2][i]};
for (int j = 0; j < int(3); j++) a[j] = add(a[j], dlt);
int res = 0;
for (int j = 0; j < int(3); j++) res = add(res, mul(a[j], A[j][0]));
res = add(res, MOD - dlt);
ans[i] = res;
}
}
}
void sol() {
sol_small();
for (int i = 0; i < int(om); i++) {
int id = lower_bound(s, s + m, os[i]) - s;
PL(ans[id]);
}
}
int main() {
read();
build();
sol();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
long long t;
cin >> n >> t;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
int largest = 0;
int current_sum = 0;
int start = 0, last;
for (int i = 0; i < n; i++) {
last = i;
current_sum += a[i];
while (current_sum > t) {
current_sum -= a[start];
start++;
}
if ((last - start + 1) > largest) {
largest = last - start + 1;
}
}
cout << largest;
return 0;
}
| 3 |
#include <bits/stdc++.h>
std::mt19937 rng(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
const int MOD = 490019;
const int ms = 1 << 20;
const double PI = acosl(-1.0);
struct Complex {
double real, imag;
Complex(double a = 0, double b = 0) : real(a), imag(b) {}
Complex operator+(const Complex &o) const {
return Complex(real + o.real, imag + o.imag);
}
Complex operator-(const Complex &o) const {
return Complex(real - o.real, imag - o.imag);
}
Complex operator*(const Complex &o) const {
return Complex(real * o.real - imag * o.imag,
real * o.imag + imag * o.real);
}
Complex operator/(double o) const { return Complex(real / o, imag / o); }
void operator*=(Complex o) { *this = *this * o; }
void operator/=(double o) { real /= o, imag /= o; }
};
int bits[ms * 4];
void pre(int n) {
int LOG = 0;
while (1 << (LOG + 1) < n) {
LOG++;
}
for (int i = 1; i < n; i++) {
bits[i] = (bits[i >> 1] >> 1) | ((i & 1) << LOG);
}
}
void fft(std::vector<Complex> &a, bool inv = false) {
int n = a.size();
for (int i = 0; i < n; i++) {
int to = bits[i];
if (to > i) {
std::swap(a[to], a[i]);
}
}
double angle = inv ? -PI : PI;
for (int len = 1; len < n; len *= 2) {
Complex delta(cosl(angle / len), sinl(angle / len));
for (int i = 0; i < n; i += 2 * len) {
Complex cur_root = 1;
for (int j = 0; j < len; j++) {
Complex u = a[i + j], v = a[i + j + len] * cur_root;
a[i + j] = u + v;
a[i + j + len] = u - v;
cur_root *= delta;
}
}
}
if (inv) {
for (int i = 0; i < n; i++) a[i] /= n;
}
}
int fexp(long long x, long long e, long long mod) {
long long ans = 1;
for (; e > 0; e /= 2) {
if (e & 1) ans = ans * x % mod;
x = x * x % mod;
}
return (int)ans;
}
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
int g[ms], inv[ms];
int rs[ms], val[ms], p[3][ms];
int table[2][491][499];
int curt[3];
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
int root = 7;
int n, m, c;
std::cin >> n >> m >> c;
for (int i = 0; i < MOD - 1; i++) {
g[i] = gcd(i, MOD - 1);
}
for (int i = 0; i < MOD - 1; i++) {
rs[i] = fexp(root, i, MOD - 1);
}
std::vector<int> A(MOD - 1, 0);
std::vector<int> B(MOD - 1, 0);
for (int i = 0; i < n; i++) {
int v;
std::cin >> v;
int pos = fexp(i, 2, MOD - 1);
A[pos] += v;
A[pos] %= MOD;
}
for (int i = 0; i < m; i++) {
int v;
std::cin >> v;
int pos = fexp(i, 3, MOD - 1);
B[pos] += v;
B[pos] %= MOD;
}
std::vector<int> dvs;
for (int i = 1; i <= MOD - 1; i++) {
if ((MOD - 1) % i == 0) {
dvs.push_back(i);
}
}
int primes[] = {2, 491, 499};
for (int i = 1; i < MOD - 1; i++) {
table[i % 2][i % 491][i % 499] = i;
}
assert(2 * 491 * 499 == MOD - 1);
for (int k = 0; k < 3; k++) {
int pr = primes[k];
for (int j = 1; rs[j] % pr != 1; j++) {
p[k][rs[j] % pr] = j;
}
for (int j = 2; j < pr; j++) {
assert(p[k][j] < MOD - 1 && p[k][j] != 0);
}
}
long long ans = 0;
std::vector<Complex> poly;
for (auto f : dvs) {
for (auto s : dvs) {
int curG = lcm(f, s);
if (curG == MOD - 1) {
long long vals[2] = {0, 0};
for (int i = 0; i < MOD - 1; i++) {
if (g[i] == f && A[i]) {
vals[0] += A[i];
}
if (g[i] == s && B[i]) {
vals[1] += B[i];
}
}
if (vals[0] && vals[1]) {
ans = (ans + vals[0] * vals[1]) % MOD;
}
continue;
}
int tot = (MOD - 1) / curG;
int size = 1;
int mx1 = -1, mx2 = -1;
for (int i = 0; i < MOD - 1; i++) {
int pos = 0;
for (int j = 1; j < 3; j++) {
if (tot % primes[j] != 0) continue;
pos = pos * (2 * primes[j] - 1) + p[j][i % primes[j]];
}
if (g[i] == f && A[i] && mx1 < pos) mx1 = pos;
if (g[i] == s && B[i] && mx2 < pos) mx2 = pos;
}
if (mx1 == -1 || mx2 == -1) continue;
while (size - 1 < mx1 + mx2) size += size;
assert(size <= ms);
poly.assign(size, 0);
for (int i = 0; i < MOD - 1; i++) {
int pos = 0;
for (int j = 1; j < 3; j++) {
if (tot % primes[j] != 0) continue;
pos = pos * (2 * primes[j] - 1) + p[j][i % primes[j]];
}
if (g[i] == f && A[i]) {
int nxt = int(poly[pos].real + 0.5);
nxt = (nxt + A[i] + MOD) % MOD;
poly[pos].real = nxt;
}
if (g[i] == s && B[i]) {
assert(pos <= mx2);
int nxt = int(poly[pos].imag + 0.5);
nxt = (nxt + B[i] + MOD) % MOD;
poly[pos].imag = nxt;
}
}
pre(size);
fft(poly);
for (int i = 0; i < size; i++) {
poly[i] *= poly[i];
}
fft(poly, true);
long long wtf = 0;
for (int i = 0; i < size; i++) {
int cur = (int)((long long)(poly[i].imag + 0.5) / 2 % MOD);
if (cur == 0) continue;
int v = i;
for (int j = 2; j >= 0; j--) {
if (tot % primes[j] == 0) {
curt[j] = v % (2 * primes[j] - 1) % (primes[j] - 1);
v /= 2 * primes[j] - 1;
curt[j] = rs[curt[j]] % primes[j];
} else {
curt[j] = 0;
}
}
v = table[curt[0]][curt[1]][curt[2]];
v = fexp(c, v, MOD);
wtf = (wtf + (long long)v * cur) % MOD;
}
ans = (ans + wtf) % MOD;
}
}
ans = (ans % MOD + MOD) % MOD;
std::cout << ans << std::endl;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
int n, cur = 0;
cin >> n;
for (int i = 0; i < n; i++) {
int a, b;
scanf("%d %d", &a, &b);
if (cur + a <= 500) {
cur += a;
printf("A");
} else {
cur -= b;
printf("G");
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int MAXN = 10000 + 5;
int p[1010];
bool vis[1010];
int dfs(int rt) {
vis[rt] = true;
if (vis[p[rt]]) return p[rt];
return dfs(p[rt]);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &p[i]);
for (int i = 1; i <= n; i++) {
memset(vis, false, sizeof(vis));
if (i > 1) printf(" ");
printf("%d", dfs(i));
}
puts("");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int N = 2e5 + 100;
vector<int> g[N];
int a[N], good[N];
long long ans[N];
int sizes[N], par[N];
vector<int> take[N], vals[N];
int n;
int getPar(int v) {
if (v == par[v]) return v;
return (par[v] = getPar(par[v]));
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
for (int i = 0; i < N; i++) {
par[i] = i;
sizes[i] = 1;
}
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
vals[a[i]].push_back(i);
}
for (int i = 1; i < n; i++) {
int v, u;
cin >> v >> u;
v--;
u--;
g[v].push_back(u);
g[u].push_back(v);
}
for (int i = 1; i < N; i++) {
for (int j = i; j < N; j += i) {
take[i].insert(take[i].end(), vals[j].begin(), vals[j].end());
}
}
for (int i = 1; i < N; i++) {
long long cur = 0;
for (auto v : take[i]) {
good[v] = 1;
cur++;
}
auto get = [&](int x) { return 1ll * x * (x + 1) / 2; };
auto add_edge = [&](int v, int u) {
v = getPar(v);
u = getPar(u);
if (v == u) return;
cur -= get(sizes[v]);
cur -= get(sizes[u]);
if (sizes[v] < sizes[u]) swap(v, u);
par[u] = v;
sizes[v] += sizes[u];
sizes[u] = 0;
cur += get(sizes[v]);
};
for (auto v : take[i]) {
for (auto u : g[v]) {
if (good[u]) {
add_edge(v, u);
}
}
}
for (auto v : take[i]) {
good[v] = 0;
par[v] = v;
sizes[v] = 1;
}
ans[i] = cur;
}
for (int i = N - 1; i >= 1; i--) {
for (int j = i + i; j < N; j += i) {
ans[i] -= ans[j];
}
}
for (int i = 1; i < N; i++) {
if (ans[i]) {
cout << i << ' ' << ans[i] << '\n';
}
}
}
| 8 |
#include <bits/stdc++.h>
long long n, m, ans = 1, pw[30] = {3};
int main() {
scanf("%lld %lld", &n, &m);
for (int i = 1; i < 30; i++) pw[i] = (pw[i - 1] * pw[i - 1]) % m;
for (long long i = 0; i < 30; i++)
if (n & (1 << i)) ans = (ans * pw[i]) % m;
printf("%lld\n", (ans + m - 1) % m);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
long long qp(long long a, long long b) {
long long x = 1;
a %= MOD;
b %= (MOD - 1);
while (b < 0) b += MOD - 1;
while (b) {
if (b & 1) x = x * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return x;
}
int mu[666666];
bool ip[666666];
long long ps(long long k, long long n) {
if (k == 1) return n + 1;
return (qp(k, n + 1) - 1) * qp(k - 1, MOD - 2) % MOD;
}
long long ps(long long k, long long l, long long r) {
return qp(k, l) * ps(k, r - l) % MOD;
}
long long pp(long long k, long long n) {
return (n * qp(k, n + 1) - ps(k, 1, n)) % MOD * qp(k - 1, MOD - 2) % MOD;
long long ans = 0;
for (int i = 1; i <= n; ++i) ans += i * qp(k, i), ans %= MOD;
return ans;
}
long long su(long long l, long long r) {
l %= MOD;
r %= MOD;
return (l + r) * (r - l + 1) / 2 % MOD;
}
int main() {
int n, k;
cin >> n >> k;
if (n == 1) {
puts("0");
return 0;
}
if (k == 1) {
long long w = n - 1;
w = w * w % MOD;
cout << w << "\n";
return 0;
}
for (int i = 1; i <= n; ++i) mu[i] = 1;
for (int i = 2; i <= n; ++i)
if (!ip[i]) {
for (int j = i; j <= n; j += i) {
ip[j] = 1;
if ((j / i) % i == 0)
mu[j] = 0;
else
mu[j] = -mu[j];
}
}
long long ans = 0;
for (int s = 1; s <= n; ++s) {
int u = (n + s) / s, r = (n - 1) / s;
long long cd = 0, ap = 0;
for (int x = 1; x <= r; ++x) {
long long ux = u / x, rx = r / x;
long long K = qp(k, x * s);
long long R = min(ux, rx + 1);
cd += mu[x] * su(1, R - 1);
ap += mu[x] * K * pp(K, R - 1);
cd += mu[x] * rx * (ux - R);
ap += mu[x] * rx * ps(K, R + 1, ux);
cd %= MOD;
ap %= MOD;
}
cd %= MOD, ap %= MOD;
ans += qp(k, s) * cd;
ans -= ap * qp(k, -n);
ans %= MOD;
}
for (int i = 1; i < n; ++i) ans += ps(k, i + 1 - n, i + n - 1 - n);
ans = ans % MOD * qp(k, n * (long long)(MOD - 2)) % MOD;
ans = (ans % MOD + MOD) % MOD;
cout << ans << "\n";
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int dp[100010];
long long val[100010];
int n, s;
struct Tree {
int l, r;
int Max, Min;
int DP;
} tree[100010 * 4];
void Build(int l, int r, int ss) {
tree[ss].l = l;
tree[ss].r = r;
tree[ss].DP = 1000000000;
if (l == r) {
tree[ss].Max = tree[ss].Min = val[l];
return;
}
int mid = l + r >> 1;
Build(l, mid, ss << 1);
Build(mid + 1, r, ss << 1 | 1);
tree[ss].Max = max(tree[ss << 1].Max, tree[ss << 1 | 1].Max);
tree[ss].Min = min(tree[ss << 1].Min, tree[ss << 1 | 1].Min);
}
int Find(int l, int r, int ss) {
if (l == tree[ss].l && r == tree[ss].r) {
return tree[ss].DP;
}
int mid = (tree[ss].l + tree[ss].r) >> 1;
if (r <= mid) {
return Find(l, r, ss << 1);
} else if (l > mid) {
return Find(l, r, ss << 1 | 1);
} else {
return min(Find(l, mid, ss << 1), Find(mid + 1, r, ss << 1 | 1));
}
}
void Update(int pos, int x, int ss) {
if (pos == tree[ss].l && tree[ss].l == tree[ss].r) {
tree[ss].DP = x;
return;
}
int mid = (tree[ss].l + tree[ss].r) >> 1;
if (pos <= mid) {
Update(pos, x, ss << 1);
} else if (pos > mid) {
Update(pos, x, ss << 1 | 1);
}
tree[ss].DP = min(tree[ss << 1].DP, tree[ss << 1 | 1].DP);
}
int Find_Max(int l, int r, int ss) {
if (l == tree[ss].l && r == tree[ss].r) {
return tree[ss].Max;
}
int mid = (tree[ss].l + tree[ss].r) >> 1;
if (r <= mid) {
return Find_Max(l, r, ss << 1);
} else if (l > mid) {
return Find_Max(l, r, ss << 1 | 1);
} else {
return max(Find_Max(l, mid, ss << 1), Find_Max(mid + 1, r, ss << 1 | 1));
}
}
int Find_Min(int l, int r, int ss) {
if (l == tree[ss].l && r == tree[ss].r) {
return tree[ss].Min;
}
int mid = (tree[ss].l + tree[ss].r) >> 1;
if (r <= mid) {
return Find_Min(l, r, ss << 1);
} else if (l > mid) {
return Find_Min(l, r, ss << 1 | 1);
} else {
return min(Find_Min(l, mid, ss << 1), Find_Min(mid + 1, r, ss << 1 | 1));
}
}
bool Judge(int k, int i) {
int Max, Min;
Max = Find_Max(k, i, 1);
Min = Find_Min(k, i, 1);
return Max - Min <= s;
}
int main() {
int dif;
while (scanf("%d%d%d", &n, &s, &dif) != EOF) {
for (int i = 1; i <= n; i++) {
scanf("%d", &val[i]);
}
Build(1, n, 1);
memset(dp, -1, sizeof(dp));
dp[0] = 0;
Update(1, 0, 1);
for (int i = 1; i <= n; i++) {
int l = 1, r = (i - dif + 1), mid;
if (l > r || !Judge(r, i)) {
continue;
}
while (l < r) {
mid = (l + r) >> 1;
if (Judge(mid, i)) {
r = mid;
} else {
l = mid + 1;
}
}
dp[i] = Find(r, i - dif + 1, 1) + 1;
if (i != n) {
Update(i + 1, dp[i], 1);
}
}
if (dp[n] > n) {
puts("-1");
} else {
printf("%d\n", dp[n]);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 100;
int Z[MAX], F[MAX], SZ;
string Str;
void ZArray() {
int L, R, K;
L = 0, R = 0, K = 0;
for (int i = 1; i < SZ; i++) {
if (i > R) {
L = R = i;
while (Str[R] == Str[R - L]) R++;
Z[i] = R - L;
R--;
} else {
K = i - L;
if (Z[K] < R - i + 1)
Z[i] = Z[K];
else {
L = i;
while (Str[R] == Str[R - L]) R++;
Z[i] = R - L;
R--;
}
}
}
}
int main() {
cin >> Str;
SZ = Str.size();
ZArray();
int pos_min = 0;
for (int i = 0; i < SZ; i++) {
if (Z[i] > 0) F[Z[i]]++, pos_min = max(pos_min, Z[i]);
}
int sz = 0;
string tt, ans;
for (int i = SZ - 1; i >= 1; i--) {
if (Z[i] + i == SZ && ((F[Z[i]] > 1) || (pos_min > Z[i]))) {
if (Z[i] > sz) {
sz = Z[i];
}
}
}
if (!sz)
cout << "Just a legend";
else
cout << Str.substr(0, sz);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200001;
int n, a, sum[N], score;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a);
sum[i] = sum[i - 1] + a;
}
score = sum[n];
for (int i = n - 2; i; i--) score = max(sum[i + 1] - score, score);
printf("%d\n", score);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int sum[4010] = {0}, dp[30000010], n;
inline int read() {
int s = 0, w = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') w = -1;
for (; isdigit(c); c = getchar()) s = (s << 1) + (s << 3) + (c ^ 48);
return s * w;
}
int Hash(int a, int b, int c, int d) {
return ((((a * 4000ll) + b) * 100 + c) * 2 + d) % 29999999;
}
int dfs(int l, int r, int x, int k) {
if (r - l + 1 < x) return 0;
if (r - l + 1 == x) return (sum[r] - sum[l - 1]) * (k ? -1 : 1);
int sta = Hash(l, r, x, k);
if (~dp[sta]) return dp[sta];
if (k) {
int ans = dfs(l, r - x, x, 0) - (sum[r] - sum[r - x + 1 - 1]);
if (l + x <= r)
ans = min(ans, dfs(l, r - x - 1, x + 1, 0) - (sum[r] - sum[r - x - 1]));
return dp[sta] = ans;
} else {
int ans = dfs(l + x, r, x, 1) + (sum[l + x - 1] - sum[l - 1]);
if (l + x <= r)
ans = max(ans, dfs(l + x + 1, r, x + 1, 1) + (sum[l + x] - sum[l - 1]));
return dp[sta] = ans;
}
}
int main() {
n = read();
memset(dp, -1, sizeof(dp));
for (int i = 1; i <= n; ++i) sum[i] = read(), sum[i] += sum[i - 1];
printf("%d\n", dfs(1, n, 1, 0));
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main() {
int w, h, i, k, a = 0;
scanf("%d %d %d", &w, &h, &k);
for (i = 1; i <= k; i++) {
a = a + (w * 2) + (h - 2) * 2;
w = w - 4;
h = h - 4;
}
printf("%d\n", a);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int tc;
cin >> tc;
while (tc-- > 0) {
int n;
cin >> n;
vector<int> a(n), b(n);
unordered_map<int, int> fra, frb;
for (int i = 0; i < n; i++) {
cin >> a[i];
fra[a[i]]++;
}
for (int i = 0; i < n; i++) {
cin >> b[i];
frb[b[i]]++;
}
if (fra != frb || ((n & 1) == 1 && a[n / 2] != b[n / 2])) {
cout << "No" << '\n';
continue;
}
map<pair<int, int>, int> ma, mb;
for (int i = 0; i < n / 2; i++) {
ma[{min(a[i], a[n - i - 1]), max(a[i], a[n - i - 1])}]++;
mb[{min(b[i], b[n - i - 1]), max(b[i], b[n - i - 1])}]++;
}
cout << (ma == mb ? "Yes" : "No") << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n;
const long long N = 5005;
long long two[N], res[N];
long long dp[N];
bool ch(long long x, long long y) {
return res[x] % res[y] == 0 &&
(two[y] <= y - x - 1 || two[y] - two[x] == y - x);
}
signed main() {
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> res[i];
while (res[i] % 2 == 0) two[i]++, res[i] /= 2;
}
memset(dp, 10, sizeof(dp));
dp[0] = 0;
for (long long i = 1; i <= n; i++) {
dp[i] = i - 1;
for (long long j = 1; j < i; j++) {
if (ch(j, i)) {
dp[i] = min(dp[i], dp[j] + (i - j - 1));
}
}
}
long long minv = n;
for (long long i = 1; i <= n; i++) minv = min(minv, dp[i] + n - i);
cout << minv << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const int MAX_N = 32000;
int n, l[305], c[305];
vector<bool> isPrime(MAX_N, true);
int primes[MAX_N], pcnt = 0;
vector<int> f[305];
int m[305], DP[305][1 << 10];
void getPrimes() {
isPrime[0] = isPrime[1] = false;
for (int i = 2; i < MAX_N; ++i)
if (isPrime[i]) {
primes[pcnt++] = i;
for (int j = i + i; j < MAX_N; j += i) isPrime[j] = false;
}
}
int dp(int d, int mask, int i) {
if (d == n) {
if (mask == (1 << f[i].size()) - 1) return 0;
return oo;
}
int &res = DP[d][mask];
if (res != -1) return res;
res = oo;
res = min(res, dp(d + 1, mask, i));
res = min(res, dp(d + 1, mask | m[d], i) + c[d]);
return res;
}
int main() {
getPrimes();
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &l[i]);
for (int i = 0; i < n; ++i) scanf("%d", &c[i]);
int ans = oo;
for (int i = 0; i < n; ++i) {
int x = l[i];
for (int j = 0; j < pcnt; ++j) {
if (x % primes[j] == 0) {
f[i].push_back(primes[j]);
while (x % primes[j] == 0) x /= primes[j];
}
if (x == 1) break;
}
if (x != 1) f[i].push_back(x);
memset(m, 0, sizeof m);
for (int j = 0; j < n; ++j) {
for (int k = 0; k < (int)f[i].size(); ++k)
if (l[j] % f[i][k] != 0) m[j] |= 1 << k;
}
memset(DP, -1, sizeof DP);
ans = min(ans, c[i] + dp(0, 0, i));
}
if (ans == oo) ans = -1;
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline long long mod(long long n, long long m) {
long long ret = n % m;
if (ret < 0) ret += m;
return ret;
}
long long gcd(long long a, long long b) {
return (b == 0LL ? a : gcd(b, a % b));
}
long long exp(long long a, long long b, long long m) {
if (b == 0LL) return 1LL;
if (b == 1LL) return mod(a, m);
long long k = mod(exp(a, b / 2, m), m);
if (b & 1LL) {
return mod(a * mod(k * k, m), m);
} else
return mod(k * k, m);
}
int n;
const int N = 300100, MX = 31, inf = 1e9;
int a[N];
int dp[N][MX + 10];
int solve(int id, int j) {
if (id > n) return 0;
int& x = dp[id][j];
if (x != -1) return x;
if (j >= MX) {
return x = solve(id + 1, j - a[id]);
}
x = inf;
if (j > 0) {
int put = min(j, a[id]);
x = solve(id + 1, j - put) + a[id] - put;
}
return x = min(x, solve(id + 1, j + a[id] / 10) + a[id]);
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
memset(dp, -1, sizeof(dp));
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] /= 100;
}
cout << 100LL * solve(1, 0) << "\n";
}
| 8 |
#include <bits/stdc++.h>
int main() {
int n, a, sum;
scanf("%d", &n);
int k = 0;
int arr[100];
for (int i = n - 100; i <= n; i++) {
sum = a = i;
while (a != 0) {
sum += a % 10;
a /= 10;
}
if (sum == n) {
arr[k++] = i;
}
}
printf("%d\n", k);
for (int i = 0; i < k; i++) {
printf("%d\n", arr[i]);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int x[110], y[110];
char str[110];
int main() {
int a, b;
scanf("%d%d", &a, &b);
scanf("%s", str);
int len = strlen(str);
int i;
x[0] = y[0] = 0;
if (a == 0 && b == 0) {
printf("Yes\n");
} else {
for (i = 0; i < len; i++) {
if (str[i] == 'U') {
x[i + 1] = x[i];
y[i + 1] = y[i] + 1;
} else if (str[i] == 'D') {
x[i + 1] = x[i];
y[i + 1] = y[i] - 1;
} else if (str[i] == 'L') {
x[i + 1] = x[i] - 1;
y[i + 1] = y[i];
} else {
x[i + 1] = x[i] + 1;
y[i + 1] = y[i];
}
}
bool judge = false;
for (i = 0; i <= len; i++) {
if (x[len] == 0 && y[len] == 0) {
if (x[i] == a && y[i] == b) judge = true;
} else if (x[len] == 0) {
if (x[i] == a && 0 == (b - y[i]) % y[len] &&
((long long)(b - y[i]) * y[len]) >= 0)
judge = true;
} else if (y[len] == 0) {
if (y[i] == b && 0 == (a - x[i]) % x[len] &&
((long long)(a - x[i]) * x[len]) >= 0)
judge = true;
} else {
if (0 == (b - y[i]) % y[len] && ((long long)(b - y[i]) * y[len]) >= 0 &&
0 == (a - x[i]) % x[len] && ((long long)(a - x[i]) * x[len]) >= 0 &&
((a - x[i]) / x[len]) == ((b - y[i]) / y[len]))
judge = true;
}
if (judge) break;
}
if (judge)
printf("Yes\n");
else
printf("No\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int nextInt() {
int x = 0, p = 1;
char c;
do {
c = getchar();
} while (c <= 32);
if (c == '-') {
p = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + (c - '0');
c = getchar();
}
return x * p;
}
const int N = 510;
const int INF = 1000000000, mod = 1000000000;
const long long LLINF = 1000000000000000000ll;
int n, m, k;
char s[N][N];
int c[N][N];
int f(int x, int y) { return x >= 0 && y >= 0 && x < n && y < m ? c[x][y] : 0; }
int isStar(int x, int y) {
if (x < 2 || y < 2) return 0;
return s[x - 1][y] == '1' && s[x][y - 1] == '1' && s[x - 1][y - 1] == '1' &&
s[x - 2][y - 1] == '1' && s[x - 1][y - 2] == '1';
}
int calc(int xa, int ya, int xb, int yb) {
if (xa < 0) return 0;
return f(xb, yb) - f(xa - 1, yb) - f(xb, ya - 1) + f(xa - 1, ya - 1);
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; ++i) {
scanf("\n%s", s[i]);
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
c[i][j] = f(i - 1, j) + f(i, j - 1) - f(i - 1, j - 1) + isStar(i, j);
}
}
long long answer = 0LL;
for (int l = 0; l < n; ++l) {
for (int r = l + 2; r < n; ++r) {
int rj = 0;
for (int lj = 0; lj < m; ++lj) {
while (rj < m && calc(l + 2, lj + 2, r, rj) < k) rj++;
answer += m - rj;
}
}
}
printf("%I64d\n", answer);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long f = 1, x = 0;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int MAXN = 1e5 + 5;
struct node {
long long x, y;
node(long long x_ = 0, long long y_ = 0) {
x = x_;
y = y_;
}
} p[MAXN];
inline long long cross(node a, node b) { return a.x * b.y - b.x * a.y; }
inline node operator-(node a, node b) { return node(a.x - b.x, a.y - b.y); }
int n;
bool cmp(node a, node b) {
if (a.x == b.x)
return a.y > b.y;
else
return a.x < b.x;
}
int sta[MAXN], top;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
n = read();
for (int i = 1; i <= n; ++i)
p[i].x = read(), p[i].y = read() - p[i].x * p[i].x;
sort(p + 1, p + n + 1, cmp);
for (int i = 1; i <= n; ++i) {
if (p[i].x == p[i - 1].x) continue;
while (top >= 2 &&
cross(p[sta[top]] - p[sta[top - 1]], p[i] - p[sta[top]]) >= 0)
top--;
sta[++top] = i;
}
cout << max(0, top - 1) << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
const double PI = 3.141592653589793238462643383279502884197;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, c = 1;
long long ans;
vector<int> x;
cin >> n;
pair<int, int> a[n];
for (int i = 0; i < n; i++) cin >> a[i].first, a[i].second = i;
sort(a, a + n);
for (int i = 1; i < n; i++) {
if (a[i].second > a[i - 1].second)
c++;
else {
int j = i - 1, c2 = 1, ind = a[i].second;
i++;
while (i < n && a[i].first == a[i - 1].first && a[i].second < a[j].second)
c2++, ind = a[i].second, i++;
while (i < n && a[i].first == a[i - 1].first && a[i].second > a[j].second)
c++, i++;
x.push_back(c);
c = c2;
i--;
a[i].second = ind;
}
}
ans = n;
for (unsigned int i = 0; i < x.size(); i++) {
n -= x[i];
ans += n;
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, x, y, a, b, l, r, mid, koef, cx, cy, bx, by, tx, ty, s1, s2,
change;
long long nod(int x, int y) {
long long r;
while (y != 0) {
r = x % y;
x = y;
y = r;
}
return x;
}
int main() {
cin >> n >> m >> x >> y >> a >> b;
long long nd = nod(a, b);
a /= nd;
b /= nd;
koef = min(n / a, m / b);
a = a * koef;
b = b * koef;
cx = (a + 1) / 2;
cy = (b + 1) / 2;
bx = x - cx;
by = y - cy;
tx = x + (a - cx);
ty = y + (b - cy);
if (bx < 0) {
change = 0 - bx;
bx = 0;
tx += change;
}
if (tx > n) {
change = tx - n;
tx = n;
bx -= change;
}
if (by < 0) {
change = 0 - by;
by = 0;
ty += change;
}
if (ty > m) {
change = ty - m;
ty = m;
by -= change;
}
cout << bx << " " << by << " " << tx << " " << ty << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 10;
const int maxbit = 33;
struct node {
node *Next[2];
long long cnt;
};
struct Trie {
node *root;
void init() {
root = new node;
root->Next[0] = root->Next[1] = NULL;
}
void ins(long long x) {
node *p = root;
for (int i = maxbit; i >= 0; i--) {
int id = (x & (1LL << i)) ? 1 : 0;
if (p->Next[id] == NULL) {
node *q = new node;
for (int j = 0; j < 2; j++) q->Next[j] = NULL;
p->Next[id] = q;
p = p->Next[id];
p->cnt = 1;
} else {
p = p->Next[id];
p->cnt++;
}
}
}
long long dfs(node *p, long long x, long long k, int deep) {
if (p == NULL) return 0;
if (deep == -1) return p->cnt;
int bx = (x & (1LL << deep)) ? 1 : 0, bk = (k & (1LL << deep)) ? 1 : 0;
long long res = 0;
if (bx == 1 && bk == 1) {
res += dfs(p->Next[0], x, k, deep - 1);
} else if (bx == 1 && bk == 0) {
res += dfs(p->Next[1], x, k, deep - 1) +
((p->Next[0] != NULL) ? p->Next[0]->cnt : 0);
} else if (bx == 0 && bk == 1) {
res += dfs(p->Next[1], x, k, deep - 1);
} else {
res += dfs(p->Next[0], x, k, deep - 1) +
((p->Next[1] != NULL) ? p->Next[1]->cnt : 0);
}
return res;
}
} trie;
long long sum[MAXN];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%I64d", &sum[i]);
sum[i] ^= sum[i - 1];
}
long long ans = 0;
trie.init();
trie.ins(0);
for (int i = 1; i <= n; i++) {
long long tmp = trie.dfs(trie.root, sum[i], k, maxbit);
ans += tmp;
trie.ins(sum[i]);
}
printf("%I64d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
signed solve() {
long long z, o;
cin >> z >> o;
if (o > 2 * z + 2 || z > o + 1)
cout << -1;
else {
while (o < 2 * z && o && z) {
cout << "01";
z--;
o--;
}
if (z && !o)
cout << 0;
else if (o == 2 * z && o)
for (long long j = 0; j < z; ++j) cout << "011";
else {
for (long long j = 0; j < o - 2 * z; ++j) cout << "1";
for (long long j = 0; j < z; ++j) cout << "011";
}
}
return 0;
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long t = 1;
while (t--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const int M = (1 << 19) + 10;
const int mod = 998244353;
int n, k, a[N];
long long inv;
inline long long MUL(long long a, long long b) {
if (!a || !b) return 0;
a = a * b;
if (a >= mod) a = a % mod;
return a;
}
long long pow_mod(long long x, int p) {
long long s = 1;
while (p) {
if (p & 1) {
s = MUL(s, x);
}
x = MUL(x, x);
p >>= 1;
}
return s;
}
int r[M];
void init(int n, int k) {
for (int i = 0; i < n; i++) {
r[i] = (r[i >> 1] >> 1) | ((i & 1) << (k - 1));
}
}
void ntt(long long A[], int fn, int op) {
for (int i = 0; i < fn; i++) {
if (i < r[i]) swap(A[i], A[r[i]]);
}
long long wn, w, t;
for (int h = 2, m = 1; h <= fn; h <<= 1, m <<= 1) {
wn = pow_mod(3, (mod - 1) / h);
for (int i = 0; i < fn; i += h) {
w = 1;
for (int j = i; j < i + m; j++) {
t = MUL(w, A[j + m]);
A[j + m] = A[j] - t + mod;
if (A[j + m] >= mod) A[j + m] -= mod;
A[j] = A[j] + t;
if (A[j] >= mod) A[j] -= mod;
w = MUL(w, wn);
}
}
}
if (op == -1) {
int g = fn >> 1;
for (int i = 1; i < g; i++) {
swap(A[i], A[fn - i]);
}
inv = pow_mod(fn, mod - 2);
for (int i = 0; i < fn; i++) {
A[i] = MUL(A[i], inv);
}
}
}
long long S[M];
long long solve(int p) {
memset(S, 0, sizeof(S));
S[0] = 1;
S[1] = (k - 2) % mod;
S[2] = 1;
int fn = 1, q = 0;
int lim = n * 2;
while (fn < lim) fn <<= 1, q++;
init(fn, q);
ntt(S, fn, 1);
for (int i = 0; i < fn; i++) {
S[i] = pow_mod(S[i], p);
}
ntt(S, fn, -1);
int ed = p * 2 + 1;
int st = p + 1;
long long ret = 0;
for (int i = st; i <= ed; i++) {
ret = ret + S[i];
}
return ret % mod;
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
}
a[0] = a[n];
if (k == 1) {
puts("0");
return 0;
}
int p = 0;
for (int i = 1; i <= n; i++) {
if (a[i] == a[i - 1]) {
p++;
}
}
int q = n - p;
long long ans = solve(q);
printf("%I64d\n", ans * pow_mod(k, p) % mod);
return 0;
}
| 8 |
#include <bits/stdc++.h>
int A[26];
int B[27];
char s[100001], p[100001];
int main() {
int i, j, sl, pl, t = 0, flag;
gets(s);
gets(p);
sl = strlen(s);
pl = strlen(p);
for (i = 0; p[i]; i++) {
A[p[i] - 'a']++;
}
if (pl <= sl) {
for (j = 0; j < pl; j++) {
if (s[j] == '?')
B[26]++;
else {
B[s[j] - 'a']++;
}
}
flag = 0;
for (j = 0; j < 26; j++) {
if (A[j] < B[j]) {
flag = 1;
break;
}
}
if (!flag) {
t++;
}
}
for (i = 1; s[i] && i + pl <= sl; i++) {
flag = 0;
if (s[i - 1] == '?')
B[26]--;
else
B[s[i - 1] - 'a']--;
if (s[i + pl - 1] == '?')
B[26]++;
else
B[s[i + pl - 1] - 'a']++;
for (j = 0; j < 26; j++) {
if (A[j] < B[j]) {
flag = 1;
break;
}
}
if (!flag) {
t++;
}
}
printf("%d", t);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, i, mi, ma, x;
cin >> n;
int m[n + 1];
for (i = 1; i <= n; i++) {
cin >> x;
m[x] = i;
}
int a[n + 1];
a[1] = 1;
a[n] = 1;
mi = m[1];
ma = m[1];
for (i = 2; i < n; i++) {
mi = min(mi, m[i]);
ma = max(ma, m[i]);
if ((ma - mi) == i - 1) {
a[i] = 1;
} else {
a[i] = 0;
}
}
for (i = 1; i <= n; i++) {
cout << a[i];
}
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e4 + 10;
int a[maxn];
int b[maxn];
struct E {
int to, next;
} ed[maxn * 2];
int head[maxn];
int tot;
void J(int a, int b) {
ed[++tot].to = b;
ed[tot].next = head[a];
head[a] = tot;
}
long long sum1[maxn];
long long sum2[maxn];
int cnt[maxn];
struct Node {
long long sum1;
long long sum2;
int cnt;
};
map<int, Node> mp[maxn];
int f[maxn];
int T_size;
int sz[maxn];
int t[maxn][21];
int dep[maxn];
void get_t(int x, int fa) {
dep[x] = dep[fa] + 1;
t[x][0] = fa;
for (int i = 1; i <= 20; i++) t[x][i] = t[t[x][i - 1]][i - 1];
for (int i = head[x]; i; i = ed[i].next) {
if (ed[i].to == fa) continue;
get_t(ed[i].to, x);
}
}
int lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
int k = dep[x] - dep[y];
int id = 0;
while (k) {
if (k & 1) x = t[x][id];
id++;
k >>= 1;
}
if (x == y) return x;
for (int i = 20; i >= 0; i--)
if (t[x][i] != t[y][i]) {
x = t[x][i];
y = t[y][i];
}
return t[x][0];
}
int dis(int x, int y) { return dep[x] + dep[y] - 2 * dep[lca(x, y)]; }
int rt;
int mx[maxn];
int vis[maxn];
void get_rt(int x, int fa) {
sz[x] = 1;
mx[x] = 0;
for (int i = head[x]; i; i = ed[i].next) {
if (ed[i].to == fa || vis[ed[i].to]) continue;
get_rt(ed[i].to, x);
sz[x] += sz[ed[i].to];
mx[x] = max(mx[x], sz[ed[i].to]);
}
mx[x] = max(mx[x], T_size - sz[x]);
if (!rt || mx[x] < mx[rt]) rt = x;
}
void get_sz(int x, int fa) {
sz[x] = 1;
for (int i = head[x]; i; i = ed[i].next) {
if (ed[i].to == fa || vis[ed[i].to]) continue;
get_sz(ed[i].to, x);
sz[x] += sz[ed[i].to];
}
}
void Dfs(int x) {
vis[x] = 1;
get_sz(x, 0);
for (int i = head[x]; i; i = ed[i].next) {
if (vis[ed[i].to]) continue;
rt = 0;
T_size = sz[x];
get_rt(ed[i].to, x);
f[rt] = x;
Dfs(rt);
}
}
void updtree(int x, int val) {
int col = a[x];
for (int u = x;; u = f[u]) {
Node &tmp = mp[u][col];
tmp.cnt += val;
if (!tmp.cnt)
mp[u].erase(col);
else {
tmp.sum1 += val * dis(x, u);
tmp.sum2 += val * dis(x, f[u]);
}
if (u == f[u]) break;
}
}
void updans(int x, int val) {
int col = a[x];
Node d1 = mp[x][col];
int tmp1 = x;
int tmp2 = f[x];
long long ans = d1.sum1;
while (tmp1 != tmp2) {
Node d2 = mp[tmp2][col];
ans += 1ll * (d2.cnt - d1.cnt) * dis(tmp2, x) + (d2.sum1 - d1.sum2);
tmp1 = tmp2;
d1 = d2;
tmp2 = f[tmp2];
}
cnt[col] += val;
sum1[col] += val * dep[x];
sum2[col] += val * ans * 2;
}
void modify(int x, int val) {
if (val == 1) {
updtree(x, val);
updans(x, val);
} else {
updans(x, val);
updtree(x, val);
}
}
int main() {
int m, q, c, n;
scanf("%d%d%d%d", &n, &m, &q, &c);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 2; i <= n; i++) {
int p;
scanf("%d", &p);
J(p, i);
J(i, p);
}
get_t(1, 0);
T_size = n;
get_rt(1, 0);
f[rt] = rt;
Dfs(rt);
for (int i = 1; i <= n; i++) modify(i, 1);
for (int i = 1; i <= m; i++) scanf("%d", &b[i]);
for (int i = 1; i <= q; i++) {
int opt;
scanf("%d", &opt);
if (opt == 1) {
int x, y;
scanf("%d%d", &x, &y);
modify(x, -1);
a[x] = y;
modify(x, 1);
} else {
int k;
scanf("%d", &k);
long long ans = sum1[k] * cnt[k] - sum2[k] / 2;
ans = ans * b[k] * b[k];
ans += 1ll * n * c * c;
ans -= 1ll * 2 * b[k] * c * sum1[k];
printf("%.10lf\n", 1.0 * ans / n);
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
string scan();
const int mod = 1000000007;
const int MAXN = 10010;
int sta[MAXN], stb[MAXN];
long long s, x;
long long memo[MAXN][2];
long long bt(int i, int rem) {
if (i > 52 && rem == 0) return 1;
if (i == 60) return 0;
long long &ret = memo[i][rem];
if (ret != -1) return ret;
ret = 0;
if (sta[i] == 1 && ((rem + 1) % 2) == stb[i])
return ret = 2 * bt(i + 1, (rem + 1) / 2);
if (sta[i] == 1) return rem = 0;
if ((rem + 2) % 2 == stb[i]) ret += bt(i + 1, (rem + 2) / 2);
if (rem % 2 == stb[i]) ret += bt(i + 1, 0);
return ret;
}
int main() {
memset(memo, -1, sizeof memo);
long long a, b;
cin >> a >> b;
s = a, x = b;
for (int i = 0; a; a /= 2, i++) stb[i] = a % 2;
for (int i = 0; b; b /= 2, i++) sta[i] = b % 2;
cout << bt(0, 0) - (s == x ? 2 : 0) << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 7;
const long long INF = 1e18 + 7;
int n, a[MAXN], d[MAXN] = {}, k, l = 1, r = 0;
long long f[MAXN], g[MAXN], ans = 0;
void add(long long &a, const long long &b) {
a += b;
if (a > INF) a = INF;
}
long long sum(long long a, long long b) {
a += b;
if (a > INF) a = INF;
return a;
}
void cost(int newl, int newr) {
while (r < newr) ans += 1LL * (d[a[++r]]++);
while (r > newr) ans -= 1LL * (--d[a[r--]]);
while (l > newl) ans += 1LL * (d[a[--l]]++);
while (l < newl) ans -= 1LL * (--d[a[l++]]);
}
void calc(int l, int r, int mn, int mx) {
if (l > r) return;
int mid = (l + r) >> 1, opt = 0;
for (int i = min(mx, mid - 1); i >= mn; --i) {
cost(i + 1, mid);
if (g[i] + ans < f[mid]) f[mid] = g[i] + ans, opt = i;
}
calc(l, mid - 1, mn, opt);
calc(mid + 1, r, opt, mx);
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; ++i) cin >> a[i];
g[0] = f[0] = 0;
for (int i = 1; i <= n; ++i) f[i] = g[i] = INF;
for (int i = 1; i <= k; ++i) {
calc(1, n, 0, n);
for (int j = 1; j <= n; ++j) g[j] = f[j], f[j] = INF;
}
cout << g[n];
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
long long mod = 1000000007LL;
long long mod2 = 998244353LL;
int n;
int dp[100005];
int sum[100005];
int main() {
cin >> n;
dp[0] = 0;
sum[0] = 0;
for (int i = 1; i <= n; ++i) {
if (i == 1) {
dp[i] = 0;
sum[i] = 0;
} else {
vector<int> vals;
vals.clear();
for (int k = 2; k * k <= 2 * i; ++k) {
int det = i - k * (k - 1) / 2;
if (det >= 0 && det % k == 0 && det / k >= 1) {
int a = det / k;
vals.push_back(sum[a + k - 1] ^ sum[a - 1]);
}
}
sort(vals.begin(), vals.end());
int pre = 0;
for (int j = 0; j < vals.size(); ++j) {
if (vals[j] > pre) {
break;
} else {
if (vals[j] == pre) pre++;
}
}
dp[i] = pre;
sum[i] = sum[i - 1] ^ dp[i];
}
}
if (dp[n] == 0) {
cout << -1 << endl;
} else {
int k;
for (k = 2; k * k <= 2 * n; ++k) {
int det = n - k * (k - 1) / 2;
if (det >= 0 && det % k == 0 && det / k >= 1) {
int a = det / k;
if ((sum[a + k - 1] ^ sum[a - 1]) == 0) {
printf("%d\n", k);
break;
}
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 81, inf = 1e9;
int dp[2][maxn][maxn][maxn];
int g[maxn][maxn];
int main() {
ios::sync_with_stdio(0), cin.tie(0);
memset(dp, 63, sizeof dp);
memset(g, 63, sizeof g);
int n, k;
cin >> n >> k;
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
u--, v--;
g[u][v] = min(g[u][v], w);
}
for (int i = 0; i < n; i++) {
dp[0][0][i][n - 1] = 0;
dp[1][0][i][0] = 0;
}
for (int len = 0; len + 1 <= k; len++) {
for (int tp = 0; tp < 2; tp++) {
for (int v = 0; v < n; v++) {
for (int lim = 0; lim < n; lim++) {
if (dp[tp][len][v][lim] >= inf) continue;
int l, r;
if (tp == 0)
l = v + 1, r = lim;
else
l = lim, r = v - 1;
for (int ne = l; ne <= r; ne++) {
for (int xp = 0; xp < 2; xp++) {
int n_lim;
if (xp == 0)
n_lim = r;
else
n_lim = l;
dp[xp][len + 1][ne][n_lim] = min(dp[xp][len + 1][ne][n_lim],
dp[tp][len][v][lim] + g[v][ne]);
}
}
}
}
}
}
int ans = inf;
for (int tp = 0; tp < 2; tp++)
for (int v = 0; v < n; v++)
for (int lim = 0; lim < n; lim++) ans = min(ans, dp[tp][k - 1][v][lim]);
if (ans >= inf) ans = -1;
cout << ans << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
int dx2[] = {1, -1, -1, 1, 0, 0, -1, 1};
int dy2[] = {1, -1, 1, -1, 1, -1, 0, 0};
int kmx[] = {-1, -1, 1, 1, 2, -2, 2, -2};
int kmy[] = {2, -2, 2, -2, -1, -1, 1, 1};
int bishopX[] = {-1, 1, -1, 1};
int bishopY[] = {-1, -1, 1, 1};
class Timer {
public:
clock_t T;
Timer() { T = clock(); }
~Timer() {
fprintf(stderr, "\n%.3f\n", double(clock() - T) / CLOCKS_PER_SEC);
}
};
int read() {
int x;
scanf("%d", &x);
return x;
}
long long readL() {
long long x;
scanf("%lld", &x);
return x;
}
const int N = 1005;
int n, m, a[N], l[N], r[N];
int main() {
n = read();
int sm = 0;
for (int i = 0; i < n; i++) a[i] = read(), sm += a[i];
sort(a, a + n);
m = read();
for (int j = 0; j < m; j++) {
l[j] = read(), r[j] = read();
if (sm >= l[j] && sm <= r[j]) {
printf("%d\n", sm);
return 0;
}
if (sm <= r[j]) {
printf("%d\n", l[j]);
return 0;
}
}
printf("-1\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
struct Edge {
Edge(int x = -1, int y = -1, int id = -1) : x(x), y(y), id(id) {}
int other(int tx) { return x + y - tx; }
int x, y, id;
};
struct NodeV {
NodeV(int st = -1, int en = -1, int id = -1) : st(st), en(en), id(id) {}
int st, en, id;
};
struct Graph {
Graph() {}
Edge edge[MAXN];
int cntEdge;
vector<int> ng[MAXN];
void addEdge(int x, int y) {
int id = cntEdge++;
ng[x].push_back(id);
ng[y].push_back(id);
edge[id] = Edge(x, y, id);
}
int dfsTime;
int n;
int stTime[MAXN], enTime[MAXN];
void runDfs() {
dfsTime = 0;
dfs(0, -1);
}
void dfs(int x, int par) {
stTime[x] = dfsTime++;
for (int i = 0; i < ng[x].size(); i++) {
int u = edge[ng[x][i]].other(x);
if (u != par) dfs(u, x);
}
enTime[x] = dfsTime;
}
vector<int> delE(int eId) {
int v = edge[eId].x;
if (stTime[edge[eId].x] < stTime[edge[eId].y]) v = edge[eId].y;
int ql = stTime[v], qr = enTime[v];
askRet.clear();
if (ql) askSeg(ql, 0, ql, qr, 1, 0, n, 0);
if (qr < n) askSeg(qr, ql, qr, n, 1, 0, n, 1);
return askRet;
}
bool remEdge[MAXN];
vector<NodeV> seg[2][MAXN * 4];
void addSeg(int ql, int qr, const NodeV& nd, int x, int s, int e, int id) {
if (ql <= s && e <= qr) {
seg[id][x].push_back(nd);
return;
}
int mid = (s + e) >> 1;
if (ql < mid) addSeg(ql, qr, nd, x * 2, s, mid, id);
if (qr > mid) addSeg(ql, qr, nd, x * 2 + 1, mid, e, id);
}
vector<int> askRet;
void askSeg(int plc, int ql, int qm, int qr, int x, int s, int e, int sid) {
while (seg[sid][x].size() > 0 && seg[sid][x].back().st >= ql &&
seg[sid][x].back().st < qm && seg[sid][x].back().en >= qm &&
seg[sid][x].back().en < qr) {
int id = seg[sid][x].back().id;
if (!remEdge[id]) {
remEdge[id] = true;
askRet.push_back(id);
}
seg[sid][x].pop_back();
}
if (e - s < 2) return;
int mid = (s + e) >> 1;
if (plc < mid)
askSeg(plc, ql, qm, qr, x * 2, s, mid, sid);
else
askSeg(plc, ql, qm, qr, x * 2 + 1, mid, e, sid);
}
} g[2];
bool compEn(NodeV x, NodeV y) {
return x.en == y.en ? x.st < y.st : x.en > y.en;
}
bool compSt(NodeV x, NodeV y) {
return x.st == y.st ? x.en > y.en : x.st < y.st;
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
g[0].n = g[1].n = n;
for (int o = 0; o < 2; o++) {
for (int i = 0; i < n - 1; i++) {
int x;
cin >> x;
x--;
g[o].addEdge(x, i + 1);
}
g[o].runDfs();
}
for (int id = 0; id < 2; id++) {
vector<NodeV> cur;
for (int i = 0; i < n - 1; i++) {
const Edge& e = g[id].edge[i];
cur.push_back(NodeV(g[id ^ 1].stTime[e.x], g[id ^ 1].stTime[e.y], e.id));
if (cur.back().st >= cur.back().en) swap(cur.back().st, cur.back().en);
}
sort(cur.begin(), cur.end(), compEn);
for (int i = 0; i < cur.size(); i++)
g[id ^ 1].addSeg(cur[i].st + 1, cur[i].en + 1, cur[i], 1, 0, n, 0);
sort(cur.begin(), cur.end(), compSt);
for (int i = 0; i < cur.size(); i++)
g[id ^ 1].addSeg(cur[i].st + 1, cur[i].en + 1, cur[i], 1, 0, n, 1);
}
vector<int> curRem[2];
{
int id;
cin >> id;
id--;
curRem[0].push_back(id);
g[1].remEdge[id] = true;
}
int id = 0;
while (!curRem[id].empty()) {
cout << (id ? "Red" : "Blue") << '\n';
for (int i = 0; i < curRem[id].size(); i++) {
const Edge& e = g[id].edge[curRem[id][i]];
cout << e.id + 1 << " ";
}
curRem[id ^ 1].clear();
for (int i = 0; i < curRem[id].size(); i++) {
const Edge& e = g[id].edge[curRem[id][i]];
vector<int> tmp = g[id].delE(e.id);
for (int j = 0; j < tmp.size(); j++) curRem[id ^ 1].push_back(tmp[j]);
}
cout << '\n';
sort(curRem[id ^ 1].begin(), curRem[id ^ 1].end());
id ^= 1;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, z;
while (scanf("%d%d%d", &x, &y, &z) != EOF) {
int a, b, c;
c = (int)sqrt((double)z * y / x);
a = y / c;
b = z / c;
printf("%d\n", 4 * a + 4 * b + 4 * c);
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std ;
typedef long long ll ;
const int maxn = 1050 ;
int a , b , n ;
struct node{
int a , b ;
};
void solve(){
cin >> a >> b >> n ;
vector<node> v(n) ;
for(auto &e : v) cin >> e.a ;
for(auto &e : v) cin >> e.b ;
ll res = b ;
int p = 0 ;
for(auto &e : v){
ll t = 1ll * e.a * ((e.b + a - 1) / a) ;
res -= t ;
p = max(p , e.a) ;
}
if(res + p > 0) cout << "YES" << endl ;
else cout << "NO" << endl ;
}
int main(){
int t ;
cin >> t ;
while(t--){
solve() ;
}
return 0 ;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int64_t mod = 998244353;
int64_t mul(int64_t a, int64_t b) { return a * b % mod; }
int64_t add(int64_t a, int64_t b) { return (a + b) % mod; }
int64_t bpow(int64_t x, int64_t n) {
return n ? n % 2 ? x * bpow(x, n - 1) % mod : bpow(x * x % mod, n / 2) : 1;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int64_t n;
cin >> n;
int64_t a[n], b[n];
for (int64_t i = 0; i < n; i++) {
cin >> a[i];
b[i] = -1;
}
int64_t q;
cin >> q;
vector<int64_t> last = {0}, val = {0};
for (int64_t i = 0; i < q; i++) {
int64_t t;
cin >> t;
if (t == 1) {
int64_t p, x;
cin >> p >> x;
a[p - 1] = x;
b[p - 1] = i;
} else {
int64_t x;
cin >> x;
last.push_back(i);
val.push_back(x);
}
}
int64_t m = last.size();
vector<int64_t> rev(m);
rev.back() = val.back();
for (int64_t i = m - 2; i >= 0; i--) {
rev[i] = max(rev[i + 1], val[i]);
}
for (int64_t i = 0; i < n; i++) {
if (b[i] >= last.back()) {
cout << a[i] << ' ';
} else {
auto it = lower_bound(begin(last), end(last), b[i]) - begin(last);
cout << max(a[i], rev[it]) << ' ';
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int n, m;
char s[102][10004];
int L[102][10004], R[102][10004];
inline int min(int a, int b) { return a < b ? a : b; }
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%s", s[i] + 1);
bool found1 = 0;
for (int j = 1; j <= m; ++j) {
if (s[i][j] == '1') {
found1 = 1;
break;
}
}
if (!found1) {
puts("-1");
return 0;
}
}
for (int i = 1; i <= n; ++i) {
R[i][0] = 1000000;
for (int j = 1; j <= m; ++j) {
if (s[i][j] == '1')
R[i][j] = 0;
else
R[i][j] = R[i][j - 1] + 1;
}
R[i][0] = R[i][m];
for (int j = 1; j <= m; ++j) {
R[i][j] = min(R[i][j], R[i][j - 1] + 1);
}
L[i][m + 1] = 1000000;
for (int j = m; j >= 1; --j) {
if (s[i][j] == '1')
L[i][j] = 0;
else
L[i][j] = L[i][j + 1] + 1;
}
L[i][m + 1] = L[i][1];
for (int j = m; j >= 1; --j) {
L[i][j] = min(L[i][j], L[i][j + 1] + 1);
}
}
int Ans = 0x7fffffff;
for (int i = 1; i <= m; ++i) {
int tmp = 0;
for (int j = 1; j <= n; ++j) {
tmp += min(L[j][i], R[j][i]);
}
Ans = min(Ans, tmp);
}
printf("%d\n", Ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize "O3"
#pragma GCC target "tune=native"
using namespace std;
template <typename... As>
struct tpl : public std::tuple<As...> {
using std::tuple<As...>::tuple;
tpl() {}
tpl(std::tuple<As...> const& b) { std::tuple<As...>::operator=(b); }
template <typename T = tuple<As...> >
typename tuple_element<0, T>::type const& x() const {
return get<0>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<0, T>::type& x() {
return get<0>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<1, T>::type const& y() const {
return get<1>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<1, T>::type& y() {
return get<1>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<2, T>::type const& z() const {
return get<2>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<2, T>::type& z() {
return get<2>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<3, T>::type const& w() const {
return get<3>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<3, T>::type& w() {
return get<3>(*this);
}
};
using lli = long long int;
using llu = long long unsigned;
using pii = tpl<lli, lli>;
using piii = tpl<lli, lli, lli>;
using piiii = tpl<lli, lli, lli, lli>;
using vi = vector<lli>;
using vii = vector<pii>;
using viii = vector<piii>;
using vvi = vector<vi>;
using vvii = vector<vii>;
using vviii = vector<viii>;
template <class T>
using min_queue = priority_queue<T, vector<T>, greater<T> >;
template <class T>
using max_queue = priority_queue<T>;
template <size_t... I>
struct my_index_sequence {
using type = my_index_sequence;
static constexpr array<size_t, sizeof...(I)> value = {{I...}};
};
namespace my_index_sequence_detail {
template <typename I, typename J>
struct concat;
template <size_t... I, size_t... J>
struct concat<my_index_sequence<I...>, my_index_sequence<J...> >
: my_index_sequence<I..., (sizeof...(I) + J)...> {};
template <size_t N>
struct make_index_sequence
: concat<typename make_index_sequence<N / 2>::type,
typename make_index_sequence<N - N / 2>::type>::type {};
template <>
struct make_index_sequence<0> : my_index_sequence<> {};
template <>
struct make_index_sequence<1> : my_index_sequence<0> {};
} // namespace my_index_sequence_detail
template <class... A>
using my_index_sequence_for =
typename my_index_sequence_detail::make_index_sequence<sizeof...(A)>::type;
template <class T, size_t... I>
void print_tuple(ostream& s, T const& a, my_index_sequence<I...>) {
using swallow = int[];
(void)swallow{0, (void(s << (I == 0 ? "" : ", ") << get<I>(a)), 0)...};
}
template <class T>
ostream& print_collection(ostream& s, T const& a);
template <class... A>
ostream& operator<<(ostream& s, tpl<A...> const& a);
template <class... A>
ostream& operator<<(ostream& s, tuple<A...> const& a);
template <class A, class B>
ostream& operator<<(ostream& s, pair<A, B> const& a);
template <class T, size_t I>
ostream& operator<<(ostream& s, array<T, I> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& operator<<(ostream& s, vector<T> const& a) {
return print_collection(s, a);
}
template <class T, class U>
ostream& operator<<(ostream& s, multimap<T, U> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& operator<<(ostream& s, multiset<T> const& a) {
return print_collection(s, a);
}
template <class T, class U>
ostream& operator<<(ostream& s, map<T, U> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& operator<<(ostream& s, set<T> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& print_collection(ostream& s, T const& a) {
s << '[';
for (auto it = begin(a); it != end(a); ++it) {
s << *it;
if (it != prev(end(a))) s << " ";
}
return s << ']';
}
template <class... A>
ostream& operator<<(ostream& s, tpl<A...> const& a) {
s << '(';
print_tuple(s, a, my_index_sequence_for<A...>{});
return s << ')';
}
template <class... A>
ostream& operator<<(ostream& s, tuple<A...> const& a) {
s << '(';
print_tuple(s, a, my_index_sequence_for<A...>{});
return s << ')';
}
template <class A, class B>
ostream& operator<<(ostream& s, pair<A, B> const& a) {
return s << "(" << get<0>(a) << ", " << get<1>(a) << ")";
}
const int K = 7010;
using bs = bitset<K + 1>;
const int N = 1e5 + 16;
bs A[N];
const int MAXPRIME = K;
vi primes;
bool sieve[MAXPRIME + 1];
int divs[MAXPRIME + 1];
bool mu[MAXPRIME + 1];
void calcPrimes() {
for (lli i = (2); i <= (lli)(MAXPRIME); ++i) sieve[i] = 1;
for (lli i = (1); i <= (lli)(MAXPRIME); ++i) mu[i] = 1;
for (lli i = (2); i <= (lli)(MAXPRIME); ++i)
if (sieve[i]) {
primes.push_back(i);
divs[i] = i;
int k = 2;
while (i * k <= MAXPRIME) {
sieve[i * k] = 0;
divs[i * k] = i;
k += 1;
}
k = 1;
while (i * i * k <= MAXPRIME) {
mu[i * i * k] = 0;
k += 1;
}
}
}
bs pre[K + 1], masks[K + 1];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
vvi divs(K + 1);
for (lli i = (1); i <= (lli)(K); ++i)
for (lli j = (1); j <= (lli)(i); ++j)
if (i % j == 0) {
divs[i].push_back(j);
}
for (lli v = (1); v <= (lli)(K); ++v) {
pre[v] = 0;
pre[v][v] = 1;
for (lli i = (1); i <= (lli)(K); ++i)
if (pre[v][i])
for (int j : divs[i])
if (j < i) pre[v][j] = !pre[v][j];
}
calcPrimes();
vi mus;
for (lli k = (1); k <= (lli)(K); ++k)
if (mu[k]) mus.push_back(k);
for (lli v = (1); v <= (lli)(K); ++v) {
masks[v] = 0;
for (int k : mus) {
if (k * v > K) break;
masks[v][k * v] = 1;
}
}
int n, q;
cin >> n >> q;
for (lli i = 0; i < (lli)(q); ++i) {
int ty;
cin >> ty;
if (ty == 1) {
int x, v;
cin >> x >> v;
A[x] = pre[v];
} else if (ty == 2) {
int x, y, z;
cin >> x >> y >> z;
A[x] = A[y] ^ A[z];
} else if (ty == 3) {
int x, y, z;
cin >> x >> y >> z;
A[x] = A[y] & A[z];
} else {
int x, v;
cin >> x >> v;
cout << ((A[x] & masks[v]).count() & 1);
}
}
cout << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
for (auto &v : vec) is >> v;
return is;
}
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
const int mx = 1e6 + 5;
const int INF = 1000000007;
long long power(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = (res * x) % 1000000007;
y >>= 1;
x = (x * x) % 1000000007;
}
return (res % 1000000007);
}
void solve() {
long long n;
cin >> n;
long long ans = n / 10 + (n % 10 == 9 ? 1 : 0);
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
cin >> t;
while (t--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005, inf = 1e9;
int n, m, q, t;
char s0[N], s1[N];
struct seg {
int f;
struct nd {
int v[2][2][2], s[2][2];
nd() {}
nd(int v0, int v1) {
v[0][0][0] = v0 + v1, v[0][1][1] = !v0 + !v1;
v[1][0][0] = v0 + !v1, v[1][1][1] = !v0 + v1;
v[0][0][1] = v[0][1][0] = v[1][0][1] = v[1][1][0] = inf;
s[0][v0] = s[1][v1] = 1;
s[0][!v0] = s[1][!v1] = 0;
}
friend nd operator+(nd a, nd b) {
nd c;
for (int i = 0; i < 2; i++) {
for (int x = 0; x < 2; x++) {
for (int y = 0; y < 2; y++) {
c.v[i][x][y] = inf;
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++)
c.v[i][x][y] = min(c.v[i][x][y],
a.v[i][x][j] + b.v[i][k][y] + (j != k) * t);
}
}
}
for (int i = 0; i < 2; i++)
for (int x = 0; x < 2; x++) c.s[i][x] = a.s[i][x] + b.s[i][x];
return c;
}
} tr[N << 2];
int tag[N << 2];
void at(int k, int r) {
tag[k] ^= r;
if (r & 1) {
for (int i = 0; i < 2; i++) swap(tr[k].s[i][0], tr[k].s[i][1]);
for (int i = 0; i < 2; i++)
for (int y = 0; y < 2; y++) swap(tr[k].v[i][0][y], tr[k].v[i][1][!y]);
r ^= 3;
}
if (r & 2) {
swap(tr[k].s[1][0], tr[k].s[1][1]);
for (int x = 0; x < 2; x++)
for (int y = 0; y < 2; y++) swap(tr[k].v[0][x][y], tr[k].v[1][x][y]);
}
}
void pd(int k) {
if (tag[k]) {
at(k << 1, tag[k]);
at(k << 1 | 1, tag[k]);
tag[k] = 0;
}
}
void build(int k, int l, int r) {
if (l == r) {
tr[k] = nd(s0[l] == 'R', s1[l] == 'R');
return;
}
int mid = l + r >> 1;
build(k << 1, l, mid);
build(k << 1 | 1, mid + 1, r);
t = f;
tr[k] = tr[k << 1] + tr[k << 1 | 1];
}
void upd(int k, int l, int r, int a, int b, int x) {
if (l == a && r == b) {
at(k, x);
return;
}
pd(k);
int mid = l + r >> 1;
if (b <= mid)
upd(k << 1, l, mid, a, b, x);
else if (a > mid)
upd(k << 1 | 1, mid + 1, r, a, b, x);
else
upd(k << 1, l, mid, a, mid, x),
upd(k << 1 | 1, mid + 1, r, mid + 1, b, x);
t = f;
tr[k] = tr[k << 1] + tr[k << 1 | 1];
}
} t1, t2;
int sol() {
int ans = inf;
for (int x = 0; x < 2; x++) {
for (int y = 0; y < 2; y++) {
ans =
min(ans, t1.tr[1].v[0][x][y] + t2.tr[1].s[0][!x] + t2.tr[1].s[1][!y]);
ans =
min(ans, t2.tr[1].v[0][x][y] + t1.tr[1].s[0][!x] + t1.tr[1].s[1][!y]);
}
}
return ans;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
scanf("%s%s", s0 + 1, s1 + 1);
t1.f = m, t1.build(1, 1, n);
scanf("%s%s", s0 + 1, s1 + 1);
t2.f = n, t2.build(1, 1, m);
printf("%d\n", sol());
while (q--) {
char b[5];
int l, r;
scanf("%s%d%d", b, &l, &r);
if (b[0] == 'L') t1.upd(1, 1, n, l, r, 1);
if (b[0] == 'R') t1.upd(1, 1, n, l, r, 2);
if (b[0] == 'U') t2.upd(1, 1, m, l, r, 1);
if (b[0] == 'D') t2.upd(1, 1, m, l, r, 2);
printf("%d\n", sol());
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
int main() {
int n, m, i, a;
int f[105] = {0};
scanf("%d%d", &n, &m);
while (m--) {
scanf("%d", &a);
for (i = a; i <= n; i++)
if (f[i] == 0) f[i] = a;
}
for (i = 1; i < n; i++) printf("%d ", f[i]);
printf("%d\n", f[n]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 10005, MAXM = 2005;
bool Q[MAXN];
vector<int> E[MAXN];
char s[MAXM][MAXM];
int Num[MAXN][3], Bel[MAXN], Ch[MAXN], cnt, N, tot, root, cur;
void Dfs(int Cur) {
Num[Cur][0] = Num[Cur][1] = Num[Cur][2] = 0;
if (Cur <= N) {
Bel[Cur] = (s[cur][Cur] == '1');
Num[Cur][Bel[Cur]]++;
return;
}
int f0 = 1, f1 = 1;
for (vector<int>::iterator i = E[Cur].begin(); i != E[Cur].end(); i++) {
Dfs(*i);
Num[Cur][Bel[*i]]++;
if (Bel[*i]) f0 = 0;
if (Bel[*i] != 1) f1 = 0;
}
if (f0)
Bel[Cur] = 0;
else if (!f1)
Bel[Cur] = 2;
else
Bel[Cur] = 1;
}
int Get(int Cur, vector<int> &Lk) {
if (Num[Cur][2] > 1) return 1;
if (Q[Cur]) {
vector<int>::iterator Fr = E[Cur].begin();
if (Bel[*Fr] != 1 && Num[Cur][1] || Bel[*Fr] != 2 && !Num[Cur][1])
reverse(E[Cur].begin(), E[Cur].end());
Fr = E[Cur].begin();
for (int i = 1; i <= Num[Cur][1]; i++) {
if (Bel[*Fr] != 1) return 1;
Lk.push_back(*Fr);
Fr++;
}
bool Flag = 0;
for (; Fr != E[Cur].end(); Fr++) {
if (!Flag && Num[Cur][2] && Bel[*Fr] != 2) return 1;
if (Bel[*Fr] == 2) {
Flag = 1;
if (Get(*Fr, Lk)) return 1;
} else
Lk.push_back(*Fr);
}
return 0;
}
if (Num[Cur][1]) {
int t1 = ++tot;
for (vector<int>::iterator i = E[Cur].begin(); i != E[Cur].end(); i++)
if (Bel[*i] == 1) E[t1].push_back(*i);
if (E[t1].size() == 1) t1 = E[t1][0];
Lk.push_back(t1);
}
for (vector<int>::iterator i = E[Cur].begin(); i != E[Cur].end(); i++)
if (Bel[*i] == 2 && Get(*i, Lk)) return 1;
if (Num[Cur][0]) {
int t2 = ++tot;
for (vector<int>::iterator i = E[Cur].begin(); i != E[Cur].end(); i++)
if (!Bel[*i]) E[t2].push_back(*i);
if (E[t2].size() == 1) t2 = E[t2][0];
Lk.push_back(t2);
}
return 0;
}
int Getr(int Cur, vector<int> &Lk) {
int tmp = Lk.size();
if (!Get(Cur, Lk)) {
reverse(Lk.begin() + tmp, Lk.end());
return 0;
}
return 1;
}
int Getl(int Cur, vector<int> &Lk) { return Get(Cur, Lk); }
int Calc(int Cur) {
if (Cur <= N) return 0;
if (Num[Cur][2] > 2) return 1;
if (Num[Cur][1] + Num[Cur][2] == 1) {
for (vector<int>::iterator i = E[Cur].begin(); i != E[Cur].end(); i++)
if (Bel[*i]) return Calc(*i);
}
vector<int> Tmp;
Tmp.clear();
if (Q[Cur]) {
bool End = 0, One = 0;
for (vector<int>::iterator i = E[Cur].begin(); i != E[Cur].end(); i++) {
if (End && Bel[*i]) return 1;
if (One && !Bel[*i]) End = 1;
if (Bel[*i] == 2) {
if (!One) {
if (Getr(*i, Tmp)) return 1;
} else if (Getl(*i, Tmp))
return 1;
} else
Tmp.push_back(*i);
if (Bel[*i]) One = 1;
}
E[Cur] = Tmp;
return 0;
} else {
int t1 = ++tot;
Q[t1] = 1;
for (vector<int>::iterator i = E[Cur].begin(); i != E[Cur].end(); i++)
if (Bel[*i] == 2) {
if (Getr(*i, E[t1])) return 1;
break;
}
if (Num[Cur][1]) {
int t2 = ++tot;
for (vector<int>::iterator i = E[Cur].begin(); i != E[Cur].end(); i++)
if (Bel[*i] == 1) E[t2].push_back(*i);
if (E[t2].size() == 1) t2 = E[t2][0];
E[t1].push_back(t2);
}
int Fl = 0;
for (vector<int>::iterator i = E[Cur].begin(); i != E[Cur].end(); i++)
if (Bel[*i] == 2) {
if (!Fl)
Fl = 1;
else {
if (Getl(*i, E[t1])) return 1;
break;
}
}
if (E[t1].size() == 1) t1 = E[t1][0];
Tmp.push_back(t1);
for (vector<int>::iterator i = E[Cur].begin(); i != E[Cur].end(); i++)
if (!Bel[*i]) Tmp.push_back(*i);
}
E[Cur] = Tmp;
return 0;
}
void Get_Order(int Cur) {
if (Cur <= N) {
Ch[++cnt] = Cur;
return;
}
for (vector<int>::iterator i = E[Cur].begin(); i != E[Cur].end(); i++)
Get_Order(*i);
}
int main() {
scanf("%d", &N);
root = tot = N + 1;
for (int i = 1; i <= N; i++) E[tot].push_back(i);
for (int i = 1; i <= N; i++) {
scanf("%s", s[i] + 1);
cur = i, Dfs(root);
if (Calc(root)) {
printf("NO\n");
return 0;
}
}
Get_Order(root);
printf("YES\n");
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= N; j++) printf("%c", s[i][Ch[j]]);
printf("\n");
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
struct data {
int siz;
int old;
int par;
};
vector<data> t;
void remake(int v) { t[v] = {1, 0, v}; }
void make(int v) { t.push_back({1, 0, v}); }
int fin(int v) {
if (v == t[v].par)
return v;
else {
t[v].par = fin(t[v].par);
return t[v].par;
}
}
void uni(int x, int y, int z) {
int xx = fin(x);
int yy = fin(y);
if (t[xx].par != t[yy].par) {
if (t[xx].siz > t[yy].siz) swap(xx, yy);
t[xx].par = yy;
if (t[xx].siz == t[yy].siz) t[yy].siz++;
t[yy].old = z;
}
}
vector<pair<int, pair<int, int> > > vec;
int ans = 0;
int a, b, c, n, m;
vector<int> q;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 0; i < 2 * n; i++) make(i);
for (int i = 0; i < m; i++) {
cin >> a >> b >> c;
vec.push_back(make_pair(c, make_pair(a - 1, b - 1)));
}
sort(vec.begin(), vec.end());
for (int l = 0, r = 0; r < m; l = r) {
while (r < m && vec[l].first == vec[r].first) r++;
for (int i = l; i < r; i++) {
int v1 = vec[i].second.first, v2 = vec[i].second.second,
cost = vec[i].first;
if (fin(v1) == fin(v2)) continue;
if (fin(n + fin(v1)) != fin(n + fin(v2))) {
q.push_back(fin(n + fin(v1)));
q.push_back(fin(n + fin(v2)));
uni(n + fin(v1), n + fin(v2), 1);
} else
ans++;
}
while (q.size() != 0) {
remake(q[q.size() - 1]);
q.pop_back();
}
for (int i = l; i < r; i++) {
int v1 = vec[i].second.first, v2 = vec[i].second.second,
cost = vec[i].first;
if (fin(v1) != fin(v2)) {
uni(v1, v2, cost);
}
}
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, q, ans, rightEnd[300010], pref[300010], inTime[300010],
outTime[300010], t;
stack<long long> st;
vector<vector<long long> > gr;
void dfs(long long x, long long par) {
++t;
inTime[x] = t;
st.push(x);
for (auto i : gr[x]) {
if (i == par) {
continue;
}
if (!outTime[i] and inTime[i] and inTime[x] > inTime[i]) {
long long tmpMin = i, tmpMax = i;
while (!st.empty()) {
long long tmp = st.top();
tmpMin = min(tmpMin, tmp);
tmpMax = max(tmpMax, tmp);
st.pop();
if (tmp == i) {
break;
}
}
rightEnd[tmpMin] = tmpMax;
} else if (!inTime[i]) {
dfs(i, x);
}
}
++t;
outTime[x] = t;
if (!st.empty() and st.top() == x) {
st.pop();
}
}
signed main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
cin >> n >> m;
gr.resize(n + 1, vector<long long>());
for (long long i = 0; i < m; ++i) {
long long x, y;
cin >> x >> y;
gr[x].push_back(y);
gr[y].push_back(x);
}
for (long long i = 1; i <= n; ++i) {
rightEnd[i] = n + 2;
}
for (long long i = 1; i <= n; ++i) {
if (!inTime[i]) {
dfs(i, -1);
}
}
for (long long i = n - 1; i; --i) {
rightEnd[i] = min(rightEnd[i + 1], rightEnd[i]);
}
for (long long i = 1; i <= n; ++i) {
pref[i] = pref[i - 1] + rightEnd[i] - i;
}
cin >> q;
while (q--) {
long long l, r;
cin >> l >> r;
long long l1 = l, r1 = r, tmp = r;
while (l1 <= r1) {
long long mid = (l1 + r1) / 2;
if (rightEnd[mid] > r) {
r1 = mid - 1;
tmp = mid;
} else {
l1 = mid + 1;
}
}
ans = pref[tmp - 1] - pref[l - 1];
ans += ((r - tmp + 1) * (r - tmp + 2)) / 2;
cout << ans << '\n';
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long n, x, a[2][200] = {0};
cin >> n;
for (long i = 1; i <= n; i++) {
cin >> x;
long t = max(a[0][i - 1], a[1][i - 1]);
a[0][i] = a[1][i] = t;
if ((x >> 1) == 1) a[0][i] = max(a[0][i], a[1][i - 1] + 1);
if ((x & 1) == 1) a[1][i] = max(a[1][i], a[0][i - 1] + 1);
}
cout << n - max(a[0][n], a[1][n]);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
lint pw(lint n, lint k) {
if (k == 0) return 1;
if (k & 1) return n * pw(n, k - 1);
lint res = pw(n, k / 2);
return res * res;
}
lint get_block_size_up_to_nth_block(lint n) {
lint lg = log10(n);
lint add = 0;
lint res = 0;
for (lint len = 0; len <= lg; len++) {
lint cnt = (len == lg) ? n - lint(pw(10ll, len)) + 1
: lint(pw(10ll, len + 1)) - lint(pw(10ll, len));
res += add * cnt + ((cnt * (cnt + 1)) / 2) * (len + 1);
add += cnt * (len + 1);
}
return res;
}
lint get_in_block(lint n) {
lint lg = log10(n);
lint add = 0;
lint res = 0;
for (lint len = 0; len <= lg; len++) {
lint cnt = (len == lg) ? n - lint(pw(10ll, len)) + 1
: lint(pw(10ll, len + 1)) - lint(pw(10ll, len));
res += cnt * (len + 1);
}
return res;
}
char solve(lint k) {
lint le = 1, ri = 1e9;
lint block = 0;
while (le <= ri) {
lint mid = (le + ri) / 2;
if (get_block_size_up_to_nth_block(mid) >= k) {
block = mid;
ri = mid - 1;
} else {
le = mid + 1;
}
}
k -= get_block_size_up_to_nth_block(block - 1);
le = 1, ri = 1e9;
lint ans = -1;
while (le <= ri) {
lint mid = (le + ri) / 2;
if (get_in_block(mid) >= k) {
ans = mid;
ri = mid - 1;
} else {
le = mid + 1;
}
}
return to_string(ans)[k - get_in_block(ans - 1) - 1];
}
int main() {
lint q;
cin >> q;
for (int i = 0; i < q; i++) {
lint k;
cin >> k;
cout << solve(k) << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int main() {
int n;
cin >> n;
int a[n];
int gc;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
gc = a[0];
for (int i = 0; i < n; i++) {
gc = gcd(gc, a[i]);
}
if (gc == 1) {
int cnt = 0;
int ans = 0;
for (int i = 0; i < n; i++) {
if (a[i] & 1) {
cnt++;
} else {
ans += ((cnt + 1) / 2 + (cnt % 2));
cnt = 0;
}
}
ans += ((cnt + 1) / 2 + (cnt % 2));
cout << "YES" << endl;
cout << ans;
} else {
cout << "YES" << endl;
cout << "0";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, l, c, d, p, nl, np;
cin >> n >> k >> l >> c >> d >> p >> nl >> np;
int ans = 0, value1, value2;
value1 = k * l;
value2 = c * d;
int x, y, z;
x = value1 / nl;
y = value2;
z = p / np;
ans = min(x, min(y, z)) / n;
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N, M, G, R;
int S[10004];
struct State {
int loc, t;
int cost;
bool operator<(const State& s) const { return cost > s.cost; }
};
const int INF = 1e9 + 2;
int D[10004][1002];
int dijkstra() {
for (int m = 0, _n = (M + 1); m < _n; ++m)
for (int g = 0, _n = (G + 2); g < _n; ++g) D[m][g] = INF;
for (int m = 0, _n = (M + 1); m < _n; ++m)
for (int g = 0, _n = (G + 2); g < _n; ++g) D[m][g] = INF;
D[0][G] = 0;
priority_queue<State> pq;
pq.push({0, G, 0});
while (!pq.empty()) {
State cur = pq.top();
pq.pop();
int cost = D[cur.loc][cur.t];
if (cur.loc == M - 1) return cost;
if (cost < cur.cost) continue;
{
int req_t = S[cur.loc + 1] - S[cur.loc];
if (req_t <= cur.t) {
State nxt = {cur.loc + 1, cur.t - req_t, cost + req_t};
if (nxt.t == 0) {
nxt.t = G;
if (nxt.loc < M - 1) nxt.cost += R;
}
if (D[nxt.loc][nxt.t] > nxt.cost) {
D[nxt.loc][nxt.t] = nxt.cost;
pq.push(nxt);
}
}
}
if (cur.loc > 0) {
int req_t = S[cur.loc] - S[cur.loc - 1];
if (req_t <= cur.t) {
State nxt = {cur.loc - 1, cur.t - req_t, cost + req_t};
if (nxt.t == 0) {
nxt.t = G;
if (nxt.loc < M - 1) nxt.cost += R;
}
if (D[nxt.loc][nxt.t] > nxt.cost) {
D[nxt.loc][nxt.t] = nxt.cost;
pq.push(nxt);
}
}
}
}
return -1;
}
int main(int argc, char* argv[]) {
scanf("%d %d", &N, &M);
for (int j = 0, _n = (M); j < _n; ++j) scanf("%d", S + j);
scanf("%d %d", &G, &R);
sort(S, S + M);
assert(S[0] == 0);
assert(S[M - 1] == N);
long long res = dijkstra();
printf("%lld\n", res);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long int inf = (1LL << 60) - 1;
const long long int N = 3e5 + 5;
vector<pair<long long int, long long int>> graph[N];
vector<bool> visited(N);
long long int arr[N], b[N];
long long int n, m, k;
bool cmp(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
return a.second < b.second;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int T = 1;
while (T--) {
cin >> n >> k;
string s;
cin >> s;
set<char> st;
for (long long int i = 0; i < k; i++) {
char x;
cin >> x;
st.insert(x);
}
long long int i = 0;
long long int ans = 0;
while (i < n) {
if (st.find(s[i]) != st.end()) {
long long int j = i;
while (j < n && st.find(s[j]) != st.end()) j++;
long long int res = j - i;
ans += res * (res + 1) / 2;
i = j;
} else {
i++;
}
}
cout << ans << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int getint() {
int f = 1, x = 0;
char ch = getchar();
while ('0' > ch || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return f * x;
}
int head[1123456];
int tot;
struct edge {
int to, next;
} e[1123456];
void insert(int x, int y) {
e[++tot].to = y;
e[tot].next = head[x];
head[x] = tot;
e[++tot].to = x;
e[tot].next = head[y];
head[y] = tot;
}
int d[1123456], n, w[1123456], isst[1123456];
int ans = 1;
void solve(int x, int fa, int m) {
int k;
{
register int l, r, mid;
r = m + 1, l = 0;
while (l + 1 < r) {
mid = (l + r) >> 1;
if (d[mid] >= w[x])
r = mid;
else
l = mid;
}
k = r;
}
ans = max(ans, k);
m = max(m, k);
int t = d[k];
d[k] = w[x];
for (int i = head[x]; i; i = e[i].next) {
if (e[i].to != fa) solve(e[i].to, x, m);
}
d[k] = t;
}
void dfs(int x, int fa, int mn) {
if (isst[x]) {
if (mn <= w[x]) {
d[1] = w[x];
solve(fa, x, 1);
d[1] = 1123450;
} else {
solve(x, 0, 0);
}
}
mn = min(w[x], mn);
for (int i = head[x]; i; i = e[i].next) {
if (e[i].to != fa) dfs(e[i].to, x, mn);
}
}
int main() {
n = getint();
for (register int i = 1; i <= n; i++) w[i] = getint();
for (register int i = 1; i < n; i++) insert(getint(), getint());
for (register int i = 1; i <= n; i++) d[i] = 1123450;
for (register int x = 1; x <= n; x++) {
isst[x] = 1;
for (register int i = head[x]; i; i = e[i].next) {
if (w[e[i].to] < w[x]) isst[x] = 0;
}
}
dfs(1, 0, 1123450);
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int ar[1010][1010];
vector<long long int> bc;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int i, j, k, n, m, t;
cin >> n;
for (i = (0); i < (n); i++) {
for (j = (0); j < (n); j++) {
cin >> ar[i][j];
}
}
long long int a1s = (ar[0][1] * ar[0][2]) / ar[1][2];
long long int a1 = sqrt(a1s);
if (a1 * a1 != a1s) {
a1++;
}
bc.push_back(a1);
for (i = (2); i < (n + 1); i++) {
long long int to = ar[0][i - 1];
long long int nu = to / a1;
bc.push_back(nu);
}
for (i = (0); i < (n); i++) {
cout << bc[i] << " ";
}
cout << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int partition(vector<int> &values, int left, int right) {
int pivotIndex = left + (right - left) / 2;
int pivotValue = values[pivotIndex];
int i = left, j = right;
int temp;
while (i <= j) {
while (values[i] < pivotValue) {
i++;
}
while (values[j] > pivotValue) {
j--;
}
if (i <= j) {
temp = values[i];
values[i] = values[j];
values[j] = temp;
i++;
j--;
}
}
return i;
}
void quicksort(vector<int> &values, int left, int right) {
if (left < right) {
int pivotIndex = partition(values, left, right);
quicksort(values, left, pivotIndex - 1);
quicksort(values, pivotIndex, right);
}
}
int main() {
int n;
cin >> n;
vector<int> t;
for (int i = 0; i < n; i++) {
int temp;
cin >> temp;
t.push_back(temp);
}
quicksort(t, 0, t.size() - 1);
int count = 0;
for (int i = 0; i < t.size() - 1;) {
int temp = t[i + 1] - t[i];
count = count + temp;
i = i + 2;
}
cout << count;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return x * f;
}
int n, m, dp[5005][5005], ans;
char s[5005], t[5005];
int main() {
n = read(), m = read();
scanf("%s", s + 1);
scanf("%s", t + 1);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (s[i] == t[j]) dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + 2);
dp[i][j] = max(dp[i][j], dp[i - 1][j] - 1);
dp[i][j] = max(dp[i][j], dp[i][j - 1] - 1);
ans = max(ans, dp[i][j]);
}
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[3];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int a, b, c;
cin >> a >> b >> c;
for (int i = 0; i <= a; i++) {
int x = i;
int y = a - i;
if (b - x >= 0 && b - x == c - y) {
cout << x << ' ' << b - x << ' ' << y << '\n';
return 0;
}
}
cout << "Impossible" << '\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
vector<pair<int, int> > adj[N];
int w[N];
long long dp[N][2], res;
void dfs1(int u, int par) {
dp[u][0] = w[u];
for (pair<int, int> v : adj[u]) {
if (v.first == par) continue;
dfs1(v.first, u);
dp[u][0] = max(dp[u][0], dp[v.first][0] + w[u] - v.second);
}
}
void dfs2(int u, int par) {
long long best = 0, se_best = 0;
for (pair<int, int> v : adj[u]) {
if (v.first == par) continue;
if (dp[v.first][0] + w[u] - v.second >= best) {
swap(best, se_best);
best = dp[v.first][0] + w[u] - v.second;
} else {
if (dp[v.first][0] + w[u] - v.second > se_best)
se_best = dp[v.first][0] + w[u] - v.second;
}
}
for (pair<int, int> v : adj[u]) {
if (v.first == par) continue;
dp[v.first][1] = max(0LL, dp[u][1] - 1LL * v.second);
if (best == w[u] + dp[v.first][0] - v.second && best != se_best) {
dp[v.first][1] = max(dp[v.first][1], se_best - v.second);
} else {
dp[v.first][1] = max(dp[v.first][1], best - v.second);
}
dfs2(v.first, u);
}
}
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> w[i];
for (int i = 1; i <= n - 1; ++i) {
int u, v, c;
cin >> u >> v >> c;
adj[u].push_back(pair<int, int>(v, c));
adj[v].push_back(pair<int, int>(u, c));
}
dfs1(1, -1);
dfs2(1, -1);
for (int i = 1; i <= n; ++i) res = max(res, dp[i][1] + dp[i][0]);
cout << res;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char c = getchar();
int x = 0;
bool f = 0;
for (; !isdigit(c); c = getchar()) f ^= !(c ^ 45);
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
if (f) x = -x;
return x;
}
struct modint {
int x;
modint(int o = 0) { x = o; }
modint &operator=(int o) { return x = o, *this; }
modint &operator+=(modint o) {
return x = x + o.x >= 1000000007 ? x + o.x - 1000000007 : x + o.x, *this;
}
modint &operator-=(modint o) {
return x = x - o.x < 0 ? x - o.x + 1000000007 : x - o.x, *this;
}
modint &operator*=(modint o) { return x = 1ll * x * o.x % 1000000007, *this; }
modint &operator^=(int b) {
modint a = *this, c = 1;
for (; b; b >>= 1, a *= a)
if (b & 1) c *= a;
return x = c.x, *this;
}
modint &operator/=(modint o) { return *this *= o ^= 1000000007 - 2; }
modint &operator+=(int o) {
return x = x + o >= 1000000007 ? x + o - 1000000007 : x + o, *this;
}
modint &operator-=(int o) {
return x = x - o < 0 ? x - o + 1000000007 : x - o, *this;
}
modint &operator*=(int o) { return x = 1ll * x * o % 1000000007, *this; }
modint &operator/=(int o) { return *this *= ((modint(o)) ^= 1000000007 - 2); }
template <class I>
friend modint operator+(modint a, I b) {
return a += b;
}
template <class I>
friend modint operator-(modint a, I b) {
return a -= b;
}
template <class I>
friend modint operator*(modint a, I b) {
return a *= b;
}
template <class I>
friend modint operator/(modint a, I b) {
return a /= b;
}
friend modint operator^(modint a, int b) { return a ^= b; }
friend bool operator==(modint a, int b) { return a.x == b; }
friend bool operator!=(modint a, int b) { return a.x != b; }
bool operator!() { return !x; }
modint operator-() { return x ? 1000000007 - x : 0; }
};
int n, mxs;
modint res, f[(1 << 20)];
inline void fwtand(modint *f, int n, int x) {
for (int l = 2, k = 1; l <= n; l <<= 1, k <<= 1)
for (int i = 0; i < n; i += l)
for (int j = 0; j < k; ++j) f[i + j] = f[i + j] + f[i + j + k] * x;
}
inline void fwtor(modint *f, int n, int x) {
for (int l = 2, k = 1; l <= n; l <<= 1, k <<= 1)
for (int i = 0; i < n; i += l)
for (int j = 0; j < k; ++j) f[i + j + k] = f[i + j + k] + f[i + j] * x;
}
inline void fwtxor(modint *f, int n, int x) {
for (int l = 2, k = 1; l <= n; l <<= 1, k <<= 1)
for (int i = 0; i < n; i += l)
for (int j = 0; j < k; ++j) {
modint a = f[i + j], b = f[i + j + k];
f[i + j] = (a + b) * x, f[i + j + k] = (a - b) * x;
}
}
int cnt[(1 << 20)];
char str[(1 << 20)];
signed main() {
n = read(), mxs = (1 << n);
scanf("%s", str);
for (register int i = (0); i <= (mxs - 1); ++i) f[i] = (str[i] - '0');
fwtxor(f, mxs, 1);
for (register int i = (0); i <= (mxs - 1); ++i) f[i] = f[i] * f[i];
fwtxor(f, mxs, 500000004);
for (register int i = (0); i <= (mxs - 1); ++i) {
if (i) cnt[i] = cnt[i >> 1] + (i & 1);
res += f[i] * (modint(2) ^ (n - cnt[i]));
}
res *= 3;
cout << res.x;
return 0;
}
| 10 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.