text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = 2e9 + 5;
const int MAXN = 200010;
int T, n;
string s;
int width[MAXN], height[MAXN];
int maxwidth[MAXN], minwidth[MAXN];
int maxheight[MAXN], minheight[MAXN];
int best(int a[], int mx[], int mn[], char le, char ri) {
for (int i = 1; i <= n; i++) {
a[i] = a[i - 1];
if (s[i - 1] == ri) ++a[i];
if (s[i - 1] == le) --a[i];
}
for (int i = n; i >= 0; i--) {
mx[i] = max(mx[i + 1], a[i]);
mn[i] = min(mn[i + 1], a[i]);
}
int maxlen = 0, minlen = 0;
int bestlen = mx[0] - mn[0];
for (int i = 1; i < n; i++) {
maxlen = max(maxlen, a[i]);
minlen = min(minlen, a[i]);
int newmin, newmax;
newmax = max(mx[i + 1] - 1, maxlen);
newmin = min(mn[i + 1] - 1, min(a[i] - 1, minlen));
bestlen = min(bestlen, newmax - newmin);
newmax = max(mx[i + 1] + 1, max(a[i] + 1, maxlen));
newmin = min(mn[i + 1] + 1, minlen);
bestlen = min(bestlen, newmax - newmin);
}
return bestlen;
}
void solve() {
cin >> s;
n = s.length();
for (int i = 0; i <= n + 2; i++) {
height[i] = width[i] = 0;
maxwidth[i] = maxheight[i] = -INF;
minwidth[i] = minheight[i] = INF;
}
long long besth = best(height, maxheight, minheight, 'S', 'W');
long long bestw = best(width, maxwidth, minwidth, 'A', 'D');
long long oldw = maxwidth[0] - minwidth[0];
long long oldh = maxheight[0] - minheight[0];
long long ans = (oldw + 1) * (oldh + 1);
ans = min(ans, (oldw + 1) * (besth + 1));
ans = min(ans, (oldh + 1) * (bestw + 1));
cout << ans << "\n";
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin >> T;
while (T--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MXN = 2e5 + 10;
long long q, n, now, ans;
string s, dir = "WASD";
vector<long long> dr = {-1, 0, 1, 0}, dc = {0, -1, 0, 1};
long long rmin[MXN], rmax[MXN], cmin[MXN], cmax[MXN], rpos[MXN], cpos[MXN],
idx[MXN];
void solve() {
cin >> s;
n = s.size(), ans = 1e17;
cpos[0] = rpos[0] = cpos[n + 1] = rpos[n + 1] = 0;
cmin[0] = rmin[0] = cmin[n + 1] = rmin[n + 1] = 0;
cmax[0] = rmax[0] = cmax[n + 1] = rmax[n + 1] = 0;
for (int i = 0; i < n; i++) {
now = idx[s[i]];
rpos[i + 1] = rpos[i] + dr[now], cpos[i + 1] = cpos[i] + dc[now];
rmin[i + 1] = min(rmin[i], rpos[i + 1]),
rmax[i + 1] = max(rmax[i], rpos[i + 1]);
cmin[i + 1] = min(cmin[i], cpos[i + 1]),
cmax[i + 1] = max(cmax[i], cpos[i + 1]);
}
for (int i = n; ~i; i--) {
for (int j = 0; j < 4; j++) {
long long nowr = rpos[i] + dr[j], nowc = cpos[i] + dc[j];
long long minr = rmin[i], maxr = rmax[i], minc = cmin[i], maxc = cmax[i];
minr = min(minr, nowr), maxr = max(maxr, nowr);
minc = min(minc, nowc), maxc = max(maxc, nowc);
long long outr = nowr - rpos[i + 1], outc = nowc - cpos[i + 1];
minr = min(minr, rmin[i + 1] + outr),
maxr = max(maxr, rmax[i + 1] + outr);
minc = min(minc, cmin[i + 1] + outc),
maxc = max(maxc, cmax[i + 1] + outc);
ans = min(ans, (maxr - minr + 1) * (maxc - minc + 1));
}
if (i > 0) {
long long nw = idx[s[i - 1]] ^ 2;
rpos[i] = rpos[i + 1] + dr[nw], cpos[i] = cpos[i + 1] + dc[nw];
rmin[i] = min(rmin[i + 1], rpos[i]), rmax[i] = max(rmax[i + 1], rpos[i]);
cmin[i] = min(cmin[i + 1], cpos[i]), cmax[i] = max(cmax[i + 1], cpos[i]);
}
}
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
for (int i = 0; i < 4; i++) idx[dir[i]] = i;
cin >> q;
while (q--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.14159265358979323846;
const double eps = (1e-4);
int dcmp(long double x, long double y) {
if (abs(x - y) < eps) return 0;
if (x > y) return 1;
return -1;
}
string s;
enum { H, V };
map<int, vector<int> > m[2];
void pre() {
int v = 0, h = 0;
m[V][v].push_back(-1);
m[H][h].push_back(-1);
for (int i = 0; i < (int)(s).size(); ++i) {
if (s[i] == 'W') {
v++;
m[V][v].push_back(i);
} else if (s[i] == 'S') {
v--;
m[V][v].push_back(i);
} else if (s[i] == 'D') {
h++;
m[H][h].push_back(i);
} else {
h--;
m[H][h].push_back(i);
}
}
}
long long calc(int id) {
return 1LL * (m[id].rbegin()->first - m[id].begin()->first + 1);
}
long long f(const pair<int, vector<int> > &p1,
const pair<int, vector<int> > &p2) {
if ((p1.first == 0 && p2.first == 0)) return 1;
if (abs(p1.first - p2.first) == 1) return 2;
if (p1.second[0] < p2.second.back()) {
return abs(p1.first - p2.first) + 1;
}
return abs(p1.first - p2.first);
}
long long solve(int id) {
pair<int, vector<int> > p1 = *m[id].begin();
pair<int, vector<int> > p2 = *m[id].rbegin();
long long ret = calc(!id) * f(p1, p2);
ret = min(ret, calc(!id) * f(p2, p1));
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
for (int i = 0; i < 2; ++i) m[i].clear();
cin >> s;
pre();
long long ans = 1LL * calc(H) * calc(V);
ans = min(ans, solve(H));
ans = min(ans, solve(V));
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = (long long)1e9 + 7;
struct node {
int L;
int R;
int U;
int D;
};
int t;
long long ans;
string s;
node ds[200001], de[200001];
pair<int, int> cur[200001], ways[4] = {make_pair(0, 1), make_pair(0, -1),
make_pair(1, 0), make_pair(-1, 0)};
void gun(pair<int, int> coor, node& rec) {
if (coor.first <= rec.L) rec.L = coor.first;
if (coor.first >= rec.R) rec.R = coor.first;
if (coor.second >= rec.U) rec.U = coor.second;
if (coor.second <= rec.D) rec.D = coor.second;
}
void pun(pair<int, int> to, node& rec, pair<int, int> coor) {
rec.L += to.first;
rec.R += to.first;
rec.U += to.second;
rec.D += to.second;
gun(coor, rec);
}
void fun(node& X, node& Y) {
ans = min(ans, (max(X.R, Y.R) - min(X.L, Y.L) + 1) * 1LL *
(max(X.U, Y.U) - min(X.D, Y.D) + 1));
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
cin >> s;
int n = s.length();
memset(ds, 0, sizeof(ds));
cur[0].first = 0;
cur[0].second = 0;
for (int i = 1; i <= n; i++) {
cur[i].first = cur[i - 1].first;
cur[i].second = cur[i - 1].second;
if (s[i - 1] == 'W') cur[i].second++;
if (s[i - 1] == 'A') cur[i].first--;
if (s[i - 1] == 'S') cur[i].second--;
if (s[i - 1] == 'D') cur[i].first++;
ds[i].L = ds[i - 1].L;
ds[i].R = ds[i - 1].R;
ds[i].U = ds[i - 1].U;
ds[i].D = ds[i - 1].D;
gun(cur[i], ds[i]);
}
de[n].L = cur[n].first;
de[n].R = cur[n].first;
de[n].U = cur[n].second;
de[n].D = cur[n].second;
for (int i = n - 1; i >= 0; i--) {
de[i].L = de[i + 1].L;
de[i].R = de[i + 1].R;
de[i].U = de[i + 1].U;
de[i].D = de[i + 1].D;
gun(cur[i], de[i]);
}
ans = 1e18;
for (int i = 0; i <= n; i++) {
for (int j = 0; j < 4; j++) {
pair<int, int> tmp = ways[j];
node tmp2 = de[i];
pun(tmp, tmp2, cur[i]);
fun(ds[i], tmp2);
}
}
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int T;
char s[2000005];
int n;
int seq[2000005], top;
void Solve(int &nochange, int &onechange) {
onechange = 1e9;
int mmin = 0, mmax = 0, tmin = 0, tmax = 0;
for (int i = 1; i <= top; i++)
seq[i] += seq[i - 1], mmin = min(mmin, seq[i]), mmax = max(mmax, seq[i]);
nochange = mmax - mmin + 1;
int l = 0;
if (mmin) {
while (seq[l] != mmin) l++;
for (int i = 1; i < l; i++) tmax = max(tmax, seq[i]);
tmax = max(tmax, seq[l - 1] + 1);
for (; l <= top; l++) tmax = max(tmax, seq[l] + 1);
onechange = min(onechange, max(tmax, 0) - min(0, mmin + 1) + 1);
}
if (mmax) {
l = 0;
while (seq[l] != mmax) l++;
for (int i = 1; i < l; i++) tmin = min(tmin, seq[i]);
tmin = min(tmin, seq[l - 1] - 1);
for (; l <= top; l++) tmin = min(tmin, seq[l] - 1);
onechange = min(onechange, max(mmax - 1, 0) - min(0, tmin) + 1);
}
}
int main() {
scanf("%d", &T);
while (T--) {
int a, b, c, d;
scanf("%s", s + 1), n = strlen(s + 1);
top = 0;
for (int i = 1; i <= n; i++) {
if (s[i] == 'S')
seq[++top] = -1;
else if (s[i] == 'W')
seq[++top] = 1;
}
Solve(a, b);
top = 0;
for (int i = 1; i <= n; i++) {
if (s[i] == 'A')
seq[++top] = -1;
else if (s[i] == 'D')
seq[++top] = 1;
}
Solve(c, d);
printf("%lld\n", min(1ll * a * c, min(1ll * b * c, 1ll * a * d)));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void showVec(vector<int> &vec) {
for (int v : vec) cout << v << " ";
cout << endl;
}
void solve() {
string s;
cin >> s;
int n = s.length();
vector<pair<int, int> > lrp(n + 2), udp(n + 2);
vector<pair<int, int> > lrs(n + 2), uds(n + 2);
vector<int> hd(n + 2), vd(n + 2);
for (int i = 1; i <= n; ++i) {
hd[i] = hd[i - 1], vd[i] = vd[i - 1];
if (s[i - 1] == 'D')
hd[i]++;
else if (s[i - 1] == 'A')
hd[i]--;
else if (s[i - 1] == 'W')
vd[i]++;
else
vd[i]--;
lrp[i].first = min(lrp[i - 1].first, hd[i]);
lrp[i].second = max(lrp[i - 1].second, hd[i]);
udp[i].first = max(udp[i - 1].first, vd[i]);
udp[i].second = min(udp[i - 1].second, vd[i]);
}
for (int i = n; i; --i) {
lrs[i] = lrs[i + 1], uds[i] = uds[i + 1];
if (s[i - 1] == 'D')
lrs[i].first--, lrs[i].second++;
else if (s[i - 1] == 'A')
lrs[i].first++, lrs[i].second--;
else if (s[i - 1] == 'W')
uds[i].first++, uds[i].second--;
else
uds[i].first--, uds[i].second++;
if (lrs[i].first < 0) lrs[i].first = 0;
if (lrs[i].second < 0) lrs[i].second = 0;
if (uds[i].first < 0) uds[i].first = 0;
if (uds[i].second < 0) uds[i].second = 0;
}
int w = lrp[n].second - lrp[n].first + 1;
for (int i = 1; i <= n; ++i) {
int l = min(lrp[i].first, hd[i] + 1 - lrs[i + 1].first);
int r = max(lrp[i].second, hd[i] + 1 + lrs[i + 1].second);
w = min(w, r - l + 1);
}
for (int i = 1; i <= n; ++i) {
int l = min(lrp[i].first, hd[i] - 1 - lrs[i + 1].first);
int r = max(lrp[i].second, hd[i] - 1 + lrs[i + 1].second);
w = min(w, r - l + 1);
}
int h = udp[n].first - udp[n].second + 1;
for (int i = 1; i <= n; ++i) {
int u = max(udp[i].first, vd[i] + 1 + uds[i + 1].first);
int d = min(udp[i].second, vd[i] + 1 - uds[i + 1].second);
h = min(h, u - d + 1);
}
for (int i = 1; i <= n; ++i) {
int u = max(udp[i].first, vd[i] - 1 + uds[i + 1].first);
int d = min(udp[i].second, vd[i] - 1 - uds[i + 1].second);
h = min(h, u - d + 1);
}
cout << min(w * 1ll * (udp[n].first - udp[n].second + 1),
(lrp[n].second - lrp[n].first + 1) * 1ll * h)
<< endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T = 1;
cin >> T;
while (T--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
char s[N];
int n, m, i, j, k, T_T, x, y, nx, ny, mnx, mny, mxx, mxy, dx[4] = {1, -1, 0, 0},
dy[4] = {0, 0, 1, -1};
int Lx[N], Ly[N], Rx[N], Ry[N], Lmnx[N], Lmny[N], Lmxx[N], Lmxy[N], Rmnx[N],
Rmny[N], Rmxx[N], Rmxy[N];
long long ans;
void update() {
mnx = min(mnx, x);
mxx = max(mxx, x);
mny = min(mny, y);
mxy = max(mxy, y);
}
int main() {
for (scanf("%d", &T_T); T_T--;) {
scanf("%s", s + 1), n = strlen(s + 1);
mnx = mny = mxx = mxy = x = y = 0;
for (i = 1; i <= n; ++i) {
if (s[i] == 'W') x--;
if (s[i] == 'S') x++;
if (s[i] == 'A') y--;
if (s[i] == 'D') y++;
update();
Lx[i] = x;
Ly[i] = y;
Lmnx[i] = mnx;
Lmxx[i] = mxx;
Lmny[i] = mny;
Lmxy[i] = mxy;
}
ans = 1LL * (mxx - mnx + 1) * (mxy - mny + 1);
mnx = mny = mxx = mxy = x = y = 0;
for (i = n; i > 0; --i) {
if (s[i] == 'S') x--;
if (s[i] == 'W') x++;
if (s[i] == 'D') y--;
if (s[i] == 'A') y++;
Rx[i] = x;
Ry[i] = y;
update();
Rmnx[i] = mnx;
Rmxx[i] = mxx;
Rmny[i] = mny;
Rmxy[i] = mxy;
}
for (i = 1; i < n; ++i) {
nx = Lx[i];
ny = Ly[i];
for (k = 0; k < 4; ++k) {
x = nx + dx[k];
y = ny + dy[k];
mnx = Lmnx[i];
mny = Lmny[i];
mxx = Lmxx[i];
mxy = Lmxy[i];
update();
if (i == 5 && k == 0) {
}
mnx -= x;
mxx -= x;
mny -= y;
mxy -= y;
mxx = max(mxx, Rmxx[i + 1] - Rx[i + 1]);
mnx = min(mnx, Rmnx[i + 1] - Rx[i + 1]);
mxy = max(mxy, Rmxy[i + 1] - Ry[i + 1]);
mny = min(mny, Rmny[i + 1] - Ry[i + 1]);
if (i == 5 && k == 0) {
}
ans = min(ans, 1LL * (mxx - mnx + 1) * (mxy - mny + 1));
if (1LL * (mxx - mnx + 1) * (mxy - mny + 1) == 6) {
}
}
}
printf("%lld\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
string inp;
cin >> inp;
long long n = inp.size();
long long prex[n + 1], prey[n + 1];
long long prexmn[n + 1], prexmx[n + 1], preymn[n + 1], preymx[n + 1];
prex[0] = 0;
prey[0] = 0;
prexmn[0] = 0;
prexmx[0] = 0;
preymn[0] = 0;
preymx[0] = 0;
long long sufx[n + 1], sufy[n + 1];
long long sufxmn[n + 1], sufxmx[n + 1], sufymn[n + 1], sufymx[n + 1];
sufx[n] = 0;
sufy[n] = 0;
sufxmn[n] = 0;
sufxmx[n] = 0;
sufymn[n] = 0;
sufymx[n] = 0;
for (long long int i = 0; i < n; i++) {
if (inp[i] == 'W') {
prex[i + 1] = prex[i];
prey[i + 1] = prey[i] + 1;
}
if (inp[i] == 'S') {
prex[i + 1] = prex[i];
prey[i + 1] = prey[i] - 1;
}
if (inp[i] == 'A') {
prex[i + 1] = prex[i] - 1;
prey[i + 1] = prey[i];
}
if (inp[i] == 'D') {
prex[i + 1] = prex[i] + 1;
prey[i + 1] = prey[i];
}
prexmn[i + 1] = min(prexmn[i], prex[i + 1]);
prexmx[i + 1] = max(prexmx[i], prex[i + 1]);
preymn[i + 1] = min(preymn[i], prey[i + 1]);
preymx[i + 1] = max(preymx[i], prey[i + 1]);
}
for (long long i = n - 1; i >= 0; i--) {
if (inp[i] == 'W') {
sufx[i] = sufx[i + 1];
sufy[i] = sufy[i + 1] - 1;
}
if (inp[i] == 'S') {
sufx[i] = sufx[i + 1];
sufy[i] = sufy[i + 1] + 1;
}
if (inp[i] == 'A') {
sufx[i] = sufx[i + 1] + 1;
sufy[i] = sufy[i + 1];
}
if (inp[i] == 'D') {
sufx[i] = sufx[i + 1] - 1;
sufy[i] = sufy[i + 1];
}
sufxmn[i] = min(sufxmn[i + 1], sufx[i]);
sufxmx[i] = max(sufxmx[i + 1], sufx[i]);
sufymn[i] = min(sufymn[i + 1], sufy[i]);
sufymx[i] = max(sufymx[i + 1], sufy[i]);
}
long long ans = (prexmx[n] - prexmn[n] + 1) * (preymx[n] - preymn[n] + 1);
for (long long int i = 0; i < n + 1; i++) {
long long currx = prex[i];
long long curry = prey[i];
long long tmpx = currx + 1, tmpy = curry, mnx = min(prexmn[i], tmpx),
mxx = max(prexmx[i], tmpx), mny = min(preymn[i], tmpy),
mxy = max(preymx[i], tmpy);
long long tmp2x = tmpx - sufx[i];
long long tmp2y = tmpy - sufy[i];
long long xmn = min(mnx, tmp2x + sufxmn[i]);
long long xmx = max(mxx, tmp2x + sufxmx[i]);
long long ymn = min(mny, tmp2y + sufymn[i]);
long long ymx = max(mxy, tmp2y + sufymx[i]);
ans = min(ans, (xmx - xmn + 1) * (ymx - ymn + 1));
tmpx = currx - 1, tmpy = curry, mnx = min(prexmn[i], tmpx),
mxx = max(prexmx[i], tmpx), mny = min(preymn[i], tmpy),
mxy = max(preymx[i], tmpy);
tmp2x = tmpx - sufx[i];
tmp2y = tmpy - sufy[i];
xmn = min(mnx, tmp2x + sufxmn[i]);
xmx = max(mxx, tmp2x + sufxmx[i]);
ymn = min(mny, tmp2y + sufymn[i]);
ymx = max(mxy, tmp2y + sufymx[i]);
ans = min(ans, (xmx - xmn + 1) * (ymx - ymn + 1));
tmpx = currx, tmpy = curry + 1, mnx = min(prexmn[i], tmpx),
mxx = max(prexmx[i], tmpx), mny = min(preymn[i], tmpy),
mxy = max(preymx[i], tmpy);
tmp2x = tmpx - sufx[i];
tmp2y = tmpy - sufy[i];
xmn = min(mnx, tmp2x + sufxmn[i]);
xmx = max(mxx, tmp2x + sufxmx[i]);
ymn = min(mny, tmp2y + sufymn[i]);
ymx = max(mxy, tmp2y + sufymx[i]);
ans = min(ans, (xmx - xmn + 1) * (ymx - ymn + 1));
tmpx = currx, tmpy = curry - 1, mnx = min(prexmn[i], tmpx),
mxx = max(prexmx[i], tmpx), mny = min(preymn[i], tmpy),
mxy = max(preymx[i], tmpy);
tmp2x = tmpx - sufx[i];
tmp2y = tmpy - sufy[i];
xmn = min(mnx, tmp2x + sufxmn[i]);
xmx = max(mxx, tmp2x + sufxmx[i]);
ymn = min(mny, tmp2y + sufymn[i]);
ymx = max(mxy, tmp2y + sufymx[i]);
ans = min(ans, (xmx - xmn + 1) * (ymx - ymn + 1));
}
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int T;
cin >> T;
while (T--) {
string s;
cin >> s;
int x = 0, y = 0;
int n = s.length();
vector<pair<int, int>> kek(n + 1);
kek[0] = {0, 0};
for (int i = 0; i < n; i++) {
char c = s[i];
if (c == 'W') {
x++;
}
if (c == 'S') {
x--;
}
if (c == 'D') {
y++;
}
if (c == 'A') {
y--;
}
kek[i + 1] = {x, y};
}
vector<int> suf_x[2];
vector<int> suf_y[2];
suf_x[0].resize(n + 1);
suf_x[1].resize(n + 1);
suf_y[0].resize(n + 1);
suf_y[1].resize(n + 1);
suf_x[0][n] = suf_x[1][n] = kek[n].first;
suf_y[0][n] = suf_y[1][n] = kek[n].second;
for (int i = n - 1; i >= 0; i--) {
suf_x[0][i] = min(suf_x[0][i + 1], kek[i].first);
suf_x[1][i] = max(suf_x[1][i + 1], kek[i].first);
suf_y[0][i] = min(suf_y[0][i + 1], kek[i].second);
suf_y[1][i] = max(suf_y[1][i + 1], kek[i].second);
}
ll ans =
ll(suf_x[1][0] - suf_x[0][0] + 1) * (suf_y[1][0] - suf_y[0][0] + 1);
int lx = 0, rx = 0;
int ly = 0, ry = 0;
for (int i = 1; i <= n; i++) {
ans = min(ans, ll(max(suf_x[1][i] + 1, max(rx, kek[i - 1].first + 1)) -
min(lx, suf_x[0][i] + 1) + 1) *
(max(suf_y[1][i], ry) - min(ly, suf_y[0][i]) + 1));
ans =
min(ans, ll(max(suf_x[1][i] - 1, rx) -
min(min(lx, kek[i - 1].first - 1), suf_x[0][i] - 1) + 1) *
(max(suf_y[1][i], ry) - min(ly, suf_y[0][i]) + 1));
ans = min(ans,
ll(max(suf_x[1][i], rx) - min(lx, suf_x[0][i]) + 1) *
(max(suf_y[1][i] - 1, ry) -
min(min(ly, kek[i - 1].second - 1), suf_y[0][i] - 1) + 1));
ans = min(ans, ll(max(suf_x[1][i], rx) - min(lx, suf_x[0][i]) + 1) *
(max(suf_y[1][i] + 1, max(ry, kek[i - 1].second + 1)) -
min(ly, suf_y[0][i] + 1) + 1));
lx = min(lx, kek[i].first);
rx = max(rx, kek[i].first);
ly = min(ly, kek[i].second);
ry = max(ry, kek[i].second);
}
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 10;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 + 7;
string s;
int maxl, maxr, minl, minr;
int solve(int c1, int c2) {
maxl = maxr = minl = minr = 0;
int pos = 0;
int _max = 0, _min = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == c2) {
pos++;
} else if (s[i] == c1) {
pos--;
}
if (pos > _max) {
maxl = maxr = i;
_max = pos;
} else if (_max == pos) {
maxr = i;
}
if (_min > pos) {
_min = pos;
minl = minr = i;
} else if (_min == pos) {
minr = i;
}
}
return _max - _min + 1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
cin >> s;
int len = solve('W', 'S');
bool flag1 = false, flag2 = false;
if ((maxr < minl || maxl > minr) && len > 2) {
flag1 = true;
}
int len2 = solve('A', 'D');
if ((maxr < minl || maxl > minr) && len2 > 2) {
flag2 = true;
}
long long ans = (long long)len * len2;
if (flag1) {
ans = min((long long)(len - 1) * len2, ans);
}
if (flag2) {
ans = min((long long)(len2 - 1) * len, ans);
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
pair<int, int> solve(vector<int>& a) {
int n = (int)a.size();
int sum = 0, mx = 0, mn = 0;
for (int i = 0; i < n; ++i) {
sum += a[i];
mx = max(mx, sum);
mn = min(mn, sum);
}
int ans = mx - mn + 1;
sum = 0;
int lmx = -1, rmx, lmn = -1, rmn;
if (sum == mx) {
if (lmx == -1) lmx = 0;
rmx = 0;
}
if (sum == mn) {
if (lmn == -1) lmn = 0;
rmn = 0;
}
for (int i = 0; i < n; ++i) {
sum += a[i];
if (sum == mx) {
if (lmx == -1) lmx = i + 1;
rmx = i + 1;
}
if (sum == mn) {
if (lmn == -1) lmn = i + 1;
rmn = i + 1;
}
}
int delt = 0;
if (rmn + 1 < lmx || rmx + 1 < lmn) delt = -1;
return {ans, delt};
}
void solve() {
string s;
cin >> s;
vector<int> a, b;
for (char c : s) {
if (c == 'W')
a.push_back(1);
else if (c == 'S')
a.push_back(-1);
else if (c == 'A')
b.push_back(-1);
else if (c == 'D')
b.push_back(1);
}
pair<int, int> pa = solve(a), pb = solve(b);
cout << min((pa.first + pa.second) * 1LL * pb.first,
pa.first * 1LL * (pb.first + pb.second))
<< '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t;
cin >> t;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
string cmds;
struct Pos {
long long x, y;
Pos() {}
Pos(long long x, long long y) : x(x), y(y) {}
} lp[maxn], rp[maxn], p[maxn];
long long mnx[maxn], mxx[maxn], mny[maxn], mxy[maxn];
void calc() {
int n = cmds.size();
long long nx = 1, ny = 1;
lp[0] = rp[0] = p[0] = Pos(1, 1);
for (int i = 1; i <= cmds.size(); i++) {
lp[i] = lp[i - 1], rp[i] = rp[i - 1];
if (cmds[i - 1] == 'W') lp[i].x = min(lp[i].x, --nx);
if (cmds[i - 1] == 'S') rp[i].x = max(rp[i].x, ++nx);
if (cmds[i - 1] == 'A') lp[i].y = min(lp[i].y, --ny);
if (cmds[i - 1] == 'D') rp[i].y = max(rp[i].y, ++ny);
p[i] = Pos(nx, ny);
}
mnx[n] = mxx[n] = p[n].x;
mny[n] = mxy[n] = p[n].y;
for (int i = n - 1; i >= 0; i--)
mnx[i] = min(mnx[i + 1], p[i].x), mxx[i] = max(mxx[i + 1], p[i].x),
mny[i] = min(mny[i + 1], p[i].y), mxy[i] = max(mxy[i + 1], p[i].y);
long long ans = (rp[n].x - lp[n].x + 1) * (rp[n].y - lp[n].y + 1);
for (int i = 0; i < n; i++) {
Pos pos = p[i];
long long x1 = min(lp[i].x, mnx[i + 1]), y1 = min(lp[i].y, mny[i + 1]),
x2 = max(rp[i].x, mxx[i + 1]), y2 = max(rp[i].y, mxy[i + 1]);
if (cmds[i] == 'W') {
pos.x++;
x2 = max(pos.x, max(rp[i].x, mxx[i + 1] + 1));
x1 = min(lp[i].x, mnx[i + 1] + 1);
}
if (cmds[i] == 'S') {
pos.x--;
x1 = min(min(lp[i].x, mnx[i + 1] - 1), pos.x);
x2 = max(rp[i].x, mxx[i + 1] - 1);
}
if (cmds[i] == 'A') {
pos.y++;
y2 = max(max(rp[i].y, mxy[i + 1] + 1), pos.y);
y1 = min(lp[i].y, mny[i + 1] + 1);
}
if (cmds[i] == 'D') {
pos.y--;
y1 = min(min(lp[i].y, mny[i + 1] - 1), pos.y);
y2 = max(rp[i].y, mxy[i + 1] - 1);
}
ans = min(ans, (x2 - x1 + 1) * (y2 - y1 + 1));
}
printf("%I64d\n", ans);
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
cin >> cmds;
calc();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long h[200001];
long long v[200001];
pair<long long, long long> fh[200002];
pair<long long, long long> bh[200002];
pair<long long, long long> fv[200002];
pair<long long, long long> bv[200002];
void wk() {
long long n;
string s;
long long ans = 10000000000007;
long long i;
cin >> s, n = s.length();
for (i = 0; i <= n + 1; i++)
fh[i] = bh[i] = fv[i] = bv[i] =
pair<long long, long long>(10000000000007, -10000000000007);
fh[0] = fv[0] = pair<long long, long long>(0, 0);
long long cur = 0;
for (i = 0; i < n; i++) {
if (s[i] == 'A')
cur--;
else if (s[i] == 'D')
cur++;
h[i + 1] = cur;
}
cur = 0;
for (i = 0; i < n; i++) {
if (s[i] == 'W')
cur--;
else if (s[i] == 'S')
cur++;
v[i + 1] = cur;
}
for (i = 1; i <= n; i++) {
fh[i].first = min(fh[i - 1].first, h[i]);
fh[i].second = max(fh[i - 1].second, h[i]);
fv[i].first = min(fv[i - 1].first, v[i]);
fv[i].second = max(fv[i - 1].second, v[i]);
}
for (i = n; i >= 0; i--) {
bh[i].first = min(bh[i + 1].first, h[i]);
bh[i].second = max(bh[i + 1].second, h[i]);
bv[i].first = min(bv[i + 1].first, v[i]);
bv[i].second = max(bv[i + 1].second, v[i]);
}
long long cst = fv[n].second - fv[n].first + 1;
for (i = 1; i <= n + 1; i++) {
long long a = min(fh[i - 1].first, bh[i - 1].first - 1);
long long b = max(fh[i - 1].second, bh[i - 1].second - 1);
ans = min(ans, (b - a + 1) * cst);
a = min(fh[i - 1].first, bh[i - 1].first + 1);
b = max(fh[i - 1].second, bh[i - 1].second + 1);
ans = min(ans, (b - a + 1) * cst);
}
cst = fh[n].second - fh[n].first + 1;
for (i = 1; i <= n + 1; i++) {
long long a = min(fv[i - 1].first, bv[i - 1].first - 1);
long long b = max(fv[i - 1].second, bv[i - 1].second - 1);
ans = min(ans, (b - a + 1) * cst);
a = min(fv[i - 1].first, bv[i - 1].first + 1);
b = max(fv[i - 1].second, bv[i - 1].second + 1);
ans = min(ans, (b - a + 1) * cst);
}
cout << min(ans, (fv[n].second - fv[n].first + 1) *
(fh[n].second - fh[n].first + 1))
<< endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
long long ii;
cin >> t;
for (ii = 1; ii <= t; ii++) wk();
return 0;
}
|
#include <bits/stdc++.h>
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
template <class T>
inline void read(T& x) {
bool sign = 0;
char c = getchar();
while (c != '-' && (c > '9' || c < '0')) c = getchar();
if (c == '-')
x = 0, sign = 1;
else
x = c - '0';
while (c = getchar(), c >= '0' && c <= '9') x = x * 10 + c - '0';
if (sign) x *= -1;
}
using namespace std;
const int maxn = 2e5 + 10;
char s[maxn];
long long prex[maxn], prey[maxn];
int main() {
int t;
for (read(t); t--;) {
scanf("%s", s + 1);
int len = 0;
int mx[2][2] = {0, 0, 0, 0}, my[2][2] = {0, 0, 0, 0};
for (int i = 1; s[i]; ++i, ++len) {
prex[i] = prey[i] = 0;
switch (s[i]) {
case 'W':
prex[i] = 1;
break;
case 'S':
prex[i] = -1;
break;
case 'D':
prey[i] = 1;
break;
case 'A':
prey[i] = -1;
break;
}
prex[i] += prex[i - 1];
prey[i] += prey[i - 1];
if (prex[i] < prex[mx[0][0]])
mx[0][0] = mx[0][1] = i;
else if (prex[i] == prex[mx[0][1]])
mx[0][1] = i;
if (prex[i] > prex[mx[1][0]])
mx[1][0] = mx[1][1] = i;
else if (prex[i] == prex[mx[1][1]])
mx[1][1] = i;
if (prey[i] < prey[my[0][0]])
my[0][0] = my[0][1] = i;
else if (prey[i] == prey[my[0][1]])
my[0][1] = i;
if (prey[i] > prey[my[1][0]])
my[1][0] = my[1][1] = i;
else if (prey[i] == prey[my[1][1]])
my[1][1] = i;
}
long long res = (prex[mx[1][0]] - prex[mx[0][0]] + 1ll) *
(prey[my[1][0]] - prey[my[0][0]] + 1ll);
if (mx[1][0] > mx[0][1] || mx[1][1] < mx[0][0])
res = min(res, max(2ll, (prex[mx[1][0]] - prex[mx[0][0]])) *
(prey[my[1][0]] - prey[my[0][0]] + 1ll));
if (my[1][0] > my[0][1] || my[1][1] < my[0][0])
res = min(res, (prex[mx[1][0]] - prex[mx[0][0]] + 1ll) *
max(2ll, (prey[my[1][0]] - prey[my[0][0]])));
printf("%lld\n", res);
}
}
|
#include <bits/stdc++.h>
using namespace std;
char s[200010];
int minx[200010], maxx[200010], miny[200010], maxy[200010];
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%s", s);
int n = strlen(s);
int x = 0, y = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'W')
y++;
else if (s[i] == 'S')
y--;
else if (s[i] == 'A')
x--;
else if (s[i] == 'D')
x++;
minx[i] = maxx[i] = x, miny[i] = maxy[i] = y;
}
for (int i = n - 2; i >= 0; i--) {
minx[i] = min(minx[i], minx[i + 1]);
maxx[i] = max(maxx[i], maxx[i + 1]);
miny[i] = min(miny[i], miny[i + 1]);
maxy[i] = max(maxy[i], maxy[i + 1]);
}
long long delx = (max(maxx[0], 0) - min(minx[0], 0) + 1ll);
long long dely = (max(maxy[0], 0) - min(miny[0], 0) + 1ll);
long long ans = delx * dely;
x = 0, y = 0;
int max1 = 0, min1 = 0, max2 = 0, min2 = 0;
for (int i = 0; i < n; i++) {
int a = min(min1, minx[i] - 1), b = max(max1, maxx[i] - 1);
a = min(a, x - 1), b = max(b, x - 1);
ans = min(ans, (b - a + 1ll) * dely);
a = min(min1, minx[i] + 1), b = max(max1, maxx[i] + 1);
a = min(a, x + 1), b = max(b, x + 1);
ans = min(ans, (b - a + 1ll) * dely);
a = min(min2, miny[i] + 1), b = max(max2, maxy[i] + 1);
a = min(a, y + 1), b = max(b, y + 1);
ans = min(ans, delx * (b - a + 1ll));
a = min(min2, miny[i] - 1), b = max(max2, maxy[i] - 1);
a = min(a, y - 1), b = max(b, y - 1);
ans = min(ans, delx * (b - a + 1ll));
if (s[i] == 'W')
y++;
else if (s[i] == 'S')
y--;
else if (s[i] == 'A')
x--;
else if (s[i] == 'D')
x++;
min1 = min(min1, x), max1 = max(max1, x);
min2 = min(min2, y), max2 = max(max2, y);
}
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK: 1024000000,1024000000")
using namespace std;
inline int getint() {
int _x = 0;
char _tc = getchar();
while (_tc < '0' || _tc > '9') _tc = getchar();
while (_tc >= '0' && _tc <= '9') _x *= 10, _x += (_tc - '0'), _tc = getchar();
return _x;
}
const int N = 2e5 + 25;
int dx[4] = {0, 0, -1, 1};
int dy[4] = {-1, 1, 0, 0};
int pmx[N], pmn[N], smx[N], smn[N], n, sm[N];
char s[N];
map<char, int> m;
int solve(int* d, long long& nw) {
long long ans = -((long long)(0x3f3f3f3f3f3f3f3f));
pmx[0] = -((long long)(0x3f3f3f3f3f3f3f3f)),
pmn[0] = ((long long)(0x3f3f3f3f3f3f3f3f));
sm[1] = 0;
for (int i = 1; i <= n + 1; i++) {
if (i > 1) sm[i] = sm[i - 1] + d[m[s[i - 1]]];
pmx[i] = max(pmx[i - 1], sm[i]);
pmn[i] = min(pmn[i - 1], sm[i]);
}
ans = nw = pmx[n + 1] - pmn[n + 1] + 1;
smx[n + 2] = -((long long)(0x3f3f3f3f3f3f3f3f)),
smn[n + 2] = ((long long)(0x3f3f3f3f3f3f3f3f));
for (int i = n + 1; i; i--) {
smx[i] = max(smx[i + 1], sm[i]);
smn[i] = min(smn[i + 1], sm[i]);
}
long long nmx, nmn;
for (int i = 1; i <= n; i++) {
nmx = max(pmx[i], max(smx[i + 1], sm[i]) + 1);
nmn = min(pmn[i], min(smn[i + 1], sm[i]) + 1);
ans = min(ans, nmx - nmn + 1);
nmx = max(pmx[i], max(smx[i + 1], sm[i]) - 1);
nmn = min(pmn[i], min(smn[i + 1], sm[i]) - 1);
ans = min(ans, nmx - nmn + 1);
}
return ans;
}
int main() {
m['W'] = 0;
m['S'] = 1;
m['A'] = 2;
m['D'] = 3;
int T;
scanf("%d", &T);
while (T--) {
scanf("%s", s + 1);
n = strlen(s + 1);
long long a, b, c, d;
a = solve(dx, b);
c = solve(dy, d);
cout << min(b * d, min(a * d, b * c)) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
int main() {
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
int n = s.size();
vector<ll> yoko(1, 0), tate(1, 0);
int ct = 0, cy = 0;
for (int i = (int)(0); i < (int)(n); ++i) {
if (s[i] == 'W') tate.push_back(++ct);
if (s[i] == 'S') tate.push_back(--ct);
if (s[i] == 'A') yoko.push_back(++cy);
if (s[i] == 'D') yoko.push_back(--cy);
}
ll ans[2][2];
for (int k = (int)(0); k < (int)(2); ++k) {
int m = yoko.size();
vector<ll> fa(m + 1, -inf), fi(m + 1, inf), ba(m + 1, -inf),
bi(m + 1, inf);
for (int i = (int)(0); i < (int)(m); ++i) {
fa[i + 1] = max(fa[i], yoko[i]);
fi[i + 1] = min(fi[i], yoko[i]);
ba[m - i - 1] = max(ba[m - i], yoko[m - i - 1]);
bi[m - i - 1] = min(bi[m - i], yoko[m - i - 1]);
}
ans[k][0] = fa[m] - fi[m] + 1;
ans[k][1] = inf;
for (int i = (int)(0); i < (int)(m); ++i) {
ans[k][1] = min(ans[k][1],
max({yoko[i] + 1, fa[i + 1], ba[i + 1] + 1}) -
min({yoko[i] + 1, fi[i + 1], bi[i + 1] + 1}) + 1);
ans[k][1] = min(ans[k][1],
max({yoko[i] + 1, fa[i + 1], ba[i + 1] - 1}) -
min({yoko[i] + 1, fi[i + 1], bi[i + 1] - 1}) + 1);
}
yoko.swap(tate);
}
cout << min({ans[0][0] * ans[1][0], ans[0][1] * ans[1][0],
ans[0][0] * ans[1][1]})
<< "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long ww[4][4] = {
{-1, 0, -1, 0}, {1, 0, 1, 0}, {0, -1, 0, -1}, {0, 1, 0, 1}};
signed main() {
long long t;
cin >> t;
map<char, long long> xa, ya, za;
xa['W'] = 0;
xa['S'] = 0;
xa['A'] = -1;
xa['D'] = 1;
ya['W'] = 1;
ya['S'] = -1;
ya['A'] = 0;
ya['D'] = 0;
za['W'] = 0;
za['S'] = 1;
za['A'] = 2;
za['D'] = 3;
while (t > 0) {
t--;
long long a = 0, b = 0, c = 0, d = 0;
string s;
cin >> s;
long long x = 0, y = 0;
long long n = s.size();
long long dp[n + 4][4];
long long qp[n + 4][4];
long long val[n + 4][2];
long long ans = 1e18;
memset(dp, 0, sizeof(dp));
memset(val, 0, sizeof(val));
memset(qp, 0, sizeof(qp));
for (long long i = 0; i < s.size(); i++) {
x += xa[s[i]];
y += ya[s[i]];
val[i][0] = x;
val[i][1] = y;
a = min(x, a);
b = min(y, b);
c = max(x, c);
d = max(y, d);
qp[i][0] = a;
qp[i][1] = b;
qp[i][2] = c;
qp[i][3] = d;
}
long long o = 1, oo = 0;
ans = min(ans, (c - a + (long long)1) * (d - b + (long long)1));
long long aa[4];
aa[0] = 1e9;
aa[1] = 1e9;
aa[2] = -1e9;
aa[3] = -1e9;
for (long long i = n - 1; i >= 0; i--) {
if (i >= 0) {
long long x = val[i][0];
long long y = val[i][1];
aa[0] = min(x, aa[0]);
aa[1] = min(y, aa[1]);
aa[2] = max(x, aa[2]);
aa[3] = max(y, aa[3]);
for (long long j = 0; j < 4; j++) {
long long xx[4];
xx[0] = min(qp[i][0], aa[0] + ww[j][0]);
xx[1] = min(qp[i][1], aa[1] + ww[j][1]);
xx[2] = max(qp[i][2], aa[2] + ww[j][2]);
xx[3] = max(qp[i][3], aa[3] + ww[j][3]);
ans = min(ans, (xx[2] - xx[0] + o) * (xx[3] - xx[1] + o));
}
}
}
long long uu = (c - a + (long long)1) * (d - b + (long long)1);
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f3f3f3f3f;
long long T, len;
string s;
long long psa[200005];
long long psw[200005];
int main() {
ios::sync_with_stdio(false);
cin >> T;
while (T--) {
long long dad = 0, dws = 0;
long long mxa = 0, mia = 0, mxw = 0, miw = 0;
long long axf = -1, axl = INF, aif = -1, ail = INF, wxf = -1, wxl = INF,
wif = -1, wil = INF;
cin >> s;
len = s.length();
s = ' ' + s;
long long tx = 0, ty = 0;
for (long long i = 1; i <= len; i++) {
if (s[i] == 'W') ty--;
if (s[i] == 'S') ty++;
if (s[i] == 'A') tx--;
if (s[i] == 'D') tx++;
psa[i] = tx;
psw[i] = ty;
mxa = max(mxa, tx);
mia = min(mia, tx);
mxw = max(mxw, ty);
miw = min(miw, ty);
}
for (long long i = 0; i <= len; i++) {
if (psa[i] == mxa) axl = i;
if (psa[i] == mia) ail = i;
if (psw[i] == mxw) wxl = i;
if (psw[i] == miw) wil = i;
}
for (long long i = len; i >= 0; i--) {
if (psa[i] == mxa) axf = i;
if (psa[i] == mia) aif = i;
if (psw[i] == mxw) wxf = i;
if (psw[i] == miw) wif = i;
}
if (axl < aif || ail < axf) dad = 1;
if (wxl < wif || wil < wxf) dws = 1;
mxa++;
mxw++;
if (mxa - mia <= 2) dad = 0;
if (mxw - miw <= 2) dws = 0;
cout << min((mxa - mia - dad) * (mxw - miw),
(mxa - mia) * (mxw - miw - dws))
<< endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops", \
"omit-frame-pointer", "inline")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,sse4.1,sse4.2,popcnt,abm,mmx,avx,avx2,fma,tune=native")
#pragma GCC option("arch=native", "no-zero-upper")
using namespace std;
const long long mod = (long long)(1e9 + 7);
const long double eps = (1e-9);
const long long oo = (long long)(1e18);
long long solve(vector<int>& ac, long long w) {
vector<int> mi_ini;
vector<int> ma_ini;
vector<int> mi_fin;
vector<int> ma_fin;
int n = ac.size();
mi_ini.push_back(0);
ma_ini.push_back(0);
mi_fin.push_back(ac.back());
ma_fin.push_back(ac.back());
for (int i = 1; i < n; i++) {
mi_ini.push_back(min(mi_ini.back(), ac[i]));
ma_ini.push_back(max(ma_ini.back(), ac[i]));
}
for (int i = n - 2; i >= 0; i--) {
mi_fin.push_back(min(mi_fin.back(), ac[i]));
ma_fin.push_back(max(ma_fin.back(), ac[i]));
}
reverse((mi_fin).begin(), (mi_fin).end());
reverse((ma_fin).begin(), (ma_fin).end());
int res = ma_ini.back() - mi_ini.back() + 1;
for (int i = 1; i < n - 1; i++) {
int ma1 = max(ma_ini[i], ma_fin[i + 1] + 1);
int mi1 = min(mi_ini[i], mi_fin[i + 1] + 1);
ma1 = max(ma1, ac[i] + 1);
res = min(res, ma1 - mi1 + 1);
int ma2 = max(ma_ini[i], ma_fin[i + 1] - 1);
int mi2 = min(mi_ini[i], mi_fin[i + 1] - 1);
mi2 = min(mi2, ac[i] - 1);
res = min(res, ma2 - mi2 + 1);
}
return w * res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
string second;
cin >> second;
vector<int> ach;
vector<int> acv;
ach.push_back(0);
acv.push_back(0);
int n = second.size();
for (int i = 0; i < n; i++) {
int c = second[i];
if (c == 'W') acv.push_back(acv.back() + 1);
if (c == 'S') acv.push_back(acv.back() - 1);
if (c == 'D') ach.push_back(ach.back() + 1);
if (c == 'A') ach.push_back(ach.back() - 1);
}
int mih = 0;
int mah = 0;
int miv = 0;
int mav = 0;
for (auto v : ach) {
mih = min(mih, v);
mah = max(mah, v);
}
for (auto v : acv) {
miv = min(miv, v);
mav = max(mav, v);
}
long long dh = mah - mih + 1;
long long dv = mav - miv + 1;
cout << (min(solve(ach, dv), solve(acv, dh))) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 40000;
char s[200020];
int main() {
int t;
cin >> t;
while (t--) {
cin >> s;
int l = 0, r = 0, lmax = 0, lmin = 0, rmin = 0, rmax = 0, lmaxlen = 0,
lminlen = 0, rminlen = 0, rmaxlen = 0;
int n = strlen(s);
for (int i = 0; i < n; i++) {
if (s[i] == 'W') {
l++;
lmax = max(lmax, l);
} else if (s[i] == 'S') {
l--;
lmin = min(lmin, l);
} else if (s[i] == 'D') {
r++;
rmax = max(rmax, r);
} else {
r--;
rmin = min(rmin, r);
}
lmaxlen = max(lmaxlen, lmax - l);
lminlen = max(lminlen, l - lmin);
rmaxlen = max(rmaxlen, rmax - r);
rminlen = max(rminlen, r - rmin);
}
long long ans = 1ll * (lmax - lmin + 1) * (rmax - rmin + 1);
if (lmax - lmin > 1 && lmaxlen != lminlen) {
ans = min(ans, 1ll * (lmax - lmin) * (rmax - rmin + 1));
}
if (rmax - rmin > 1 && rmaxlen != rminlen) {
ans = min(ans, 1ll * (lmax - lmin + 1) * (rmax - rmin));
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const int INF = 1e9 + 9;
int T;
int n;
string s;
void ReadInput() {
cin >> s;
n = s.length();
}
void Solve() {
int first = 0, second = 0;
int l = 0, r = 0, up = 0, dw = 0;
int fl = 0, fr = 0, fup = 0, fdw = 0;
for (int i = 0; i < n; ++i) {
if (s[i] == 'W') {
if (++second > up) {
up = second;
fdw = 0;
fup = 1;
} else if (second == up)
fup = 1;
}
if (s[i] == 'A') {
if (--first < l) {
l = first;
fr = 0;
fl = 1;
} else if (first == l)
fl = 1;
}
if (s[i] == 'S') {
if (--second < dw) {
dw = second;
fup = 0;
fdw = 1;
} else if (second == dw)
fdw = 1;
}
if (s[i] == 'D') {
if (++first > r) {
r = first;
fl = 0;
fr = 1;
} else if (first == r)
fr = 1;
}
}
first = r - l + 1;
second = up - dw + 1;
long long ans = 1LL * first * second, k = ans;
if (first > 2 && fl * fr == 0) ans = k - second;
if (second > 2 && fup * fdw == 0 && k - first < ans) ans = k - first;
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> T;
while (T-- > 0) {
ReadInput();
Solve();
}
}
|
#include <bits/stdc++.h>
template <typename T>
class IntegerIterator {
public:
using value_type = T;
using difference_type = std::ptrdiff_t;
using pointer = T *;
using reference = T;
using iterator_category = std::input_iterator_tag;
explicit IntegerIterator(T value) : value(value) {}
IntegerIterator &operator++() {
++value;
return *this;
}
IntegerIterator operator++(int) {
IntegerIterator copy = *this;
++value;
return copy;
}
IntegerIterator &operator--() {
--value;
return *this;
}
IntegerIterator operator--(int) {
IntegerIterator copy = *this;
--value;
return copy;
}
T operator*() const { return value; }
bool operator==(IntegerIterator rhs) const { return value == rhs.value; }
bool operator!=(IntegerIterator rhs) const { return !(*this == rhs); }
private:
T value;
};
template <typename T>
class IntegerRange {
public:
IntegerRange(T begin, T end) : begin_(begin), end_(end) { ; }
IntegerIterator<T> begin() const { return IntegerIterator<T>(begin_); }
IntegerIterator<T> end() const { return IntegerIterator<T>(end_); }
private:
T begin_;
T end_;
};
template <typename T>
class ReversedIntegerRange {
using IteratorType = std::reverse_iterator<IntegerIterator<T>>;
public:
ReversedIntegerRange(T begin, T end) : begin_(begin), end_(end) { ; }
IteratorType begin() const {
return IteratorType(IntegerIterator<T>(begin_));
}
IteratorType end() const { return IteratorType(IntegerIterator<T>(end_)); }
private:
T begin_;
T end_;
};
template <typename T>
IntegerRange<T> range(T to) {
return IntegerRange<T>(0, to);
}
template <typename T>
IntegerRange<T> range(T from, T to) {
return IntegerRange<T>(from, to);
}
template <typename T>
IntegerRange<T> inclusiveRange(T to) {
return IntegerRange<T>(0, to + 1);
}
template <typename T>
IntegerRange<T> inclusiveRange(T from, T to) {
return IntegerRange<T>(from, to + 1);
}
template <typename T>
ReversedIntegerRange<T> downrange(T from) {
return ReversedIntegerRange<T>(from, 0);
}
template <typename T>
ReversedIntegerRange<T> downrange(T from, T to) {
return ReversedIntegerRange<T>(from, to);
}
template <typename T>
ReversedIntegerRange<T> inclusiveDownrange(T from) {
return ReversedIntegerRange<T>(from + 1, 0);
}
template <typename T>
ReversedIntegerRange<T> inclusiveDownrange(T from, T to) {
return ReversedIntegerRange<T>(from + 1, to);
}
using namespace std;
class CYouAreGivenAWASDString {
public:
void solve(std::istream &in, std::ostream &out) {
int t;
in >> t;
while (t--) {
string str;
in >> str;
int n = str.size();
vector<int> maxx1(n + 1), minx1(n + 1), maxy1(n + 1), miny1(n + 1),
maxx2(n + 1), maxy2(n + 1), minx2(n + 1), miny2(n + 1);
int x = 0, y = 0;
for (int i : range(n)) {
if (str[i] == 'W') {
y++;
} else if (str[i] == 'S') {
y--;
} else if (str[i] == 'A') {
x--;
} else {
x++;
}
minx1[i + 1] = min(minx1[i], x);
maxx1[i + 1] = max(maxx1[i], x);
miny1[i + 1] = min(miny1[i], y);
maxy1[i + 1] = max(maxy1[i], y);
}
minx2[n] = maxx2[n] = x;
miny2[n] = maxy2[n] = y;
for (int i : downrange(n)) {
if (str[i] == 'W') {
y--;
} else if (str[i] == 'S') {
y++;
} else if (str[i] == 'A') {
x++;
} else {
x--;
}
minx2[i] = min(minx2[i + 1], x);
maxx2[i] = max(maxx2[i + 1], x);
miny2[i] = min(miny2[i + 1], y);
maxy2[i] = max(maxy2[i + 1], y);
}
long long res =
(long long)(maxx1[n] - minx1[n] + 1) * (maxy1[n] - miny1[n] + 1);
for (int i : inclusiveRange(0, n)) {
for (int j : range(4)) {
int dx = 0, dy = 0;
if (j % 2 == 0) {
if (j / 2) {
dx = 1;
} else {
dx = -1;
}
} else {
if (j / 2) {
dy = 1;
} else {
dy = -1;
}
}
int maxX = max(maxx1[i], maxx2[i] + dx),
minX = min(minx1[i], minx2[i] + dx),
maxY = max(maxy1[i], maxy2[i] + dy),
minY = min(miny1[i], miny2[i] + dy);
res = min(res, (long long)(maxX - minX + 1) * (maxY - minY + 1));
}
}
out << res << "\n";
}
}
void setup() {}
};
int main() {
std::ios_base::sync_with_stdio(false);
CYouAreGivenAWASDString solver;
solver.setup();
std::istream &in(std::cin);
std::ostream &out(std::cout);
in.tie(nullptr);
out << std::fixed;
out.precision(20);
solver.solve(in, out);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
set<pii> A, B;
char b[201010];
int main() {
int T;
scanf("%d", &T);
while (T--) {
A.clear();
B.clear();
int x = 0, y = 0;
scanf("%s", b);
int n = strlen(b);
A.insert({x, 0});
B.insert({y, 0});
for (int i = 0; i < n; i++) {
if (b[i] == 'W')
y++;
else if (b[i] == 'S')
y--;
else if (b[i] == 'A')
x++;
else
x--;
A.insert({x, i + 1});
B.insert({y, i + 1});
}
long long ans = 1LL * (prev(A.end())->first - A.begin()->first + 1) *
(prev(B.end())->first - B.begin()->first + 1);
x = 0, y = 0;
int mx = 0, Mx = 0, my = 0, My = 0;
for (int i = 0; i < n; i++) {
int a = A.begin()->first, b = prev(A.end())->first, c = B.begin()->first,
d = prev(B.end())->first;
ans = min(ans, 1LL * (max(Mx, b + 1) - min(mx, a + 1) + 1) *
(max(My, d) - min(my, c) + 1));
ans = min(ans, 1LL * (max(Mx, b - 1) - min(mx, a - 1) + 1) *
(max(My, d) - min(my, c) + 1));
ans = min(ans, 1LL * (max(Mx, b) - min(mx, a) + 1) *
(max(My, d + 1) - min(my, c + 1) + 1));
ans = min(ans, 1LL * (max(Mx, b) - min(mx, a) + 1) *
(max(My, d - 1) - min(my, c - 1) + 1));
A.erase({x, i});
B.erase({y, i});
if (::b[i] == 'W')
y++;
else if (::b[i] == 'S')
y--;
else if (::b[i] == 'A')
x++;
else
x--;
Mx = max(Mx, x);
mx = min(mx, x);
My = max(My, y);
my = min(my, y);
}
printf("%lld\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2 * 1e5 + 1;
int v[INF];
int h[INF];
pair<int, long long int> diminui(int a, int arr[]) {
int mx = 0;
int mn = 0;
int pmx = 0;
int umn = 0;
for (int i = 0; i < a; i++) {
if (arr[i] > mx) {
mx = arr[i];
pmx = i;
} else if (arr[i] <= mn) {
mn = arr[i];
umn = i;
}
}
return make_pair(umn + 1 < pmx, mx - mn + 1);
}
int main() {
int t;
cin >> t;
while (t--) {
string str;
cin >> str;
int vp = 1, hp = 1;
for (int i = 0; i < str.size(); i++) {
if (str[i] == 'W') {
v[vp] = v[vp - 1] + 1;
vp++;
} else if (str[i] == 'S') {
v[vp] = v[vp - 1] - 1;
vp++;
} else if (str[i] == 'A') {
h[hp] = h[hp - 1] + 1;
hp++;
} else {
h[hp] = h[hp - 1] - 1;
hp++;
}
}
pair<int, int> a = diminui(hp, h);
pair<int, int> w = diminui(vp, v);
for (int i = 0; i < hp; i++) {
h[i] *= -1;
}
for (int i = 0; i < vp; i++) {
v[i] *= -1;
}
pair<int, int> d = diminui(hp, h);
pair<int, int> s = diminui(vp, v);
if (d.second > s.second) {
if (s.first || w.first) {
(s.second)--;
} else if (a.first || d.first) {
(a.second)--;
}
} else {
if (a.first || d.first) {
(a.second)--;
} else if (s.first || w.first) {
(s.second)--;
}
}
long long int ans = (long long int)a.second * s.second;
cout << ans << endl;
}
}
|
#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);
}
struct node {
int mx, tot, pre, suf;
node() { mx = tot = pre = suf = 0; }
node operator+(const node &o) const {
node res;
res.tot = tot + o.tot;
res.pre = max(pre, tot + o.pre);
res.suf = max(o.suf, o.tot + suf);
res.mx = max(mx, o.mx);
res.mx = max(res.mx, suf + o.pre);
return res;
}
};
template <class T>
struct ST {
vector<T> st;
int n;
T ini;
ST(int n, T ini) : st(2 * n, ini), n(n), ini(ini) {}
void upd(int pos, T val) {
for (st[pos += n] = val; pos /= 2;) st[pos] = st[2 * pos] + st[2 * pos + 1];
}
T query(int x, int y) {
T ra = ini, rb = ini;
for (x += n, y += n + 1; x < y; x /= 2, y /= 2) {
if (x & 1) ra = ra + st[x++];
if (y & 1) rb = st[--y] + rb;
}
return ra + rb;
}
};
node c(int x) {
node r;
r.mx = max(0, x);
r.suf = max(0, x);
r.pre = max(0, x);
r.tot = x;
return r;
}
void solve() {
string s;
cin >> s;
int n = s.size();
node nulo;
nulo.mx = nulo.pre = nulo.suf = nulo.tot = 0;
ST<node> D(n + 3, nulo), S(n + 3, nulo), A(n + 3, nulo), W(n + 3, nulo);
for (int i = 1; i <= n; i++) {
if (s[i - 1] == 'D') {
D.upd(i, c(1));
A.upd(i, c(-1));
} else if (s[i - 1] == 'A') {
D.upd(i, c(-1));
A.upd(i, c(1));
} else if (s[i - 1] == 'W') {
W.upd(i, c(1));
S.upd(i, c(-1));
} else {
W.upd(i, c(-1));
S.upd(i, c(1));
}
}
int dx = 0, dy = 0;
long long best = 1e15;
int maxx = 0, minx = 0, maxy = 0, miny = 0;
for (int i = 1; i <= n + 1; i++) {
int goy1 = W.query(i, n + 1).pre;
int goy2 = S.query(i, n + 1).pre;
int gox1 = D.query(i, n + 1).pre;
int gox2 = A.query(i, n + 1).pre;
int up = max(maxy, dy + goy1);
int down = min(miny, dy - goy2);
int right = max(maxx, dx + gox1);
int left = min(minx, dx - gox2);
D.upd(i - 1, c(1));
A.upd(i - 1, c(-1));
int R = max(maxx, dx + D.query(i - 1, n + 1).pre);
int L = min(minx, dx - A.query(i - 1, n + 1).pre);
best = min(best, 1LL * (up - down + 1) * (R - L + 1));
A.upd(i - 1, c(1));
D.upd(i - 1, c(-1));
R = max(maxx, dx + D.query(i - 1, n + 1).pre);
L = min(minx, dx - A.query(i - 1, n + 1).pre);
best = min(best, 1LL * (up - down + 1) * (R - L + 1));
W.upd(i - 1, c(1));
S.upd(i - 1, c(-1));
R = max(maxy, dy + W.query(i - 1, n + 1).pre);
L = min(miny, dy - S.query(i - 1, n + 1).pre);
best = min(best, 1LL * (right - left + 1) * (R - L + 1));
S.upd(i - 1, c(1));
W.upd(i - 1, c(-1));
R = max(maxy, dy + W.query(i - 1, n + 1).pre);
L = min(miny, dy - S.query(i - 1, n + 1).pre);
best = min(best, 1LL * (right - left + 1) * (R - L + 1));
if (i == n + 1) break;
if (s[i - 1] == 'D')
dx++;
else if (s[i - 1] == 'A')
dx--;
else if (s[i - 1] == 'S')
dy--;
else
dy++;
maxx = max(dx, maxx);
minx = min(dx, minx);
maxy = max(maxy, dy);
miny = min(miny, dy);
}
best = min(best, 1LL * (maxx - minx + 1) * (maxy - miny + 1));
cout << best << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t;
cin >> t;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1000000000000000000;
const long long N = 210000;
struct inf {
long long minx;
long long maxx;
long long miny;
long long maxy;
long long result() { return (maxx - minx + 1) * (maxy - miny + 1); }
};
inf combine(const inf& inf1, const inf& inf2) {
return {min(inf1.minx, inf2.minx), max(inf1.maxx, inf2.maxx),
min(inf1.miny, inf2.miny), max(inf1.maxy, inf2.maxy)};
}
pair<long long, long long> a[N];
inf t[4 * N];
pair<long long, long long> add[4 * N];
void build(long long v, long long l, long long r) {
if (l == r)
t[v] = {a[l].first, a[l].first, a[l].second, a[l].second};
else {
long long m = (l + r) / 2;
build(v * 2, l, m);
build(v * 2 + 1, m + 1, r);
t[v] = combine(t[v * 2], t[v * 2 + 1]);
}
}
void push(long long v, long long l, long long r) {
if (l != r) {
add[2 * v].first += add[v].first;
add[2 * v].second += add[v].second;
add[2 * v + 1].first += add[v].first;
add[2 * v + 1].second += add[v].second;
}
t[v].maxx += add[v].first;
t[v].maxy += add[v].second;
t[v].miny += add[v].second;
t[v].minx += add[v].first;
add[v] = {0, 0};
}
const inf NullVal = {INF, -INF, INF, -INF};
inf query(long long v, long long tl, long long tr, long long l, long long r) {
push(v, tl, tr);
if (l > r) return NullVal;
if (l == tl && r == tr) return t[v];
long long m = (tl + tr) / 2;
return combine(query(v * 2, tl, m, l, min(m, r)),
query(v * 2 + 1, m + 1, tr, max(m + 1, l), r));
}
void modify(long long v, long long tl, long long tr, long long l, long long r,
pair<long long, long long> val) {
push(v, tl, tr);
if (l > r) return;
if (tl == l && tr == r) {
add[v].first += val.first;
add[v].second += val.second;
push(v, tl, tr);
return;
}
long long m = (tl + tr) / 2;
modify(2 * v, tl, m, l, min(m, r), val);
modify(2 * v + 1, m + 1, tr, max(m + 1, l), r, val);
t[v] = combine(t[2 * v], t[2 * v + 1]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
for (long long i0 = 0; i0 < t; i0++) {
string s;
cin >> s;
long long x = 0;
long long y = 0;
a[0] = {0, 0};
for (long long i = 0; i < s.length(); i++) {
if (s[i] == 'W') {
y++;
}
if (s[i] == 'S') {
y--;
}
if (s[i] == 'D') {
x++;
}
if (s[i] == 'A') {
x--;
}
a[i + 1] = {x, y};
}
build(1, 0, s.length());
long long best = query(1, 0, s.length(), 0, s.length()).result();
for (long long i = 0; i < s.length(); i++) {
pair<long long, long long> tmp = a[i];
inf res;
if (s[i] == 'A') {
tmp.first++;
modify(1, 0, s.length(), i + 1, s.length(), {1, 0});
res = combine(query(1, 0, s.length(), 0, s.length()),
{tmp.first, tmp.first, tmp.second, tmp.second});
modify(1, 0, s.length(), i + 1, s.length(), {-1, 0});
}
if (s[i] == 'D') {
tmp.first--;
modify(1, 0, s.length(), i + 1, s.length(), {-1, 0});
res = combine(query(1, 0, s.length(), 0, s.length()),
{tmp.first, tmp.first, tmp.second, tmp.second});
modify(1, 0, s.length(), i + 1, s.length(), {1, 0});
}
if (s[i] == 'S') {
tmp.second++;
modify(1, 0, s.length(), i + 1, s.length(), {0, 1});
res = combine(query(1, 0, s.length(), 0, s.length()),
{tmp.first, tmp.first, tmp.second, tmp.second});
modify(1, 0, s.length(), i + 1, s.length(), {0, -1});
}
if (s[i] == 'W') {
tmp.second--;
modify(1, 0, s.length(), i + 1, s.length(), {0, -1});
res = combine(query(1, 0, s.length(), 0, s.length()),
{tmp.first, tmp.first, tmp.second, tmp.second});
modify(1, 0, s.length(), i + 1, s.length(), {0, 1});
}
best = min(best, res.result());
}
cout << best << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class SegTree {
public:
vector<long long> A;
vector<long long> st;
int n;
int left(int i) { return (i << 1); }
int right(int i) { return (i << 1) + 1; }
void build(int p, int L, int R) {
if (L == R)
st[p] = L;
else {
build(left(p), L, (L + R) / 2);
build(right(p), (L + R) / 2 + 1, R);
int p1 = st[left(p)];
int p2 = st[right(p)];
st[p] = A[p1] <= A[p2] ? p1 : p2;
}
}
SegTree(const vector<long long> &_A) {
A = _A;
n = _A.size();
st.assign(4 * n, -1);
build(1, 0, n - 1);
}
int rmq(int p, int L, int R, int i, int j) {
if (i > R || j < L) return -1;
if (L >= i && R <= j) return st[p];
int p1 = rmq(left(p), L, (L + R) / 2, i, j);
int p2 = rmq(right(p), (L + R) / 2 + 1, R, i, j);
if (p1 == -1) return p2;
if (p2 == -1) return p1;
return (A[p1] <= A[p2] ? p1 : p2);
}
int rmq(int i, int j) {
if (i < 0) i = 0;
return rmq(1, 0, n - 1, i, j);
}
int getIndex(int p, int L, int R, int pos) {
if (L == R) return p;
if (pos <= (L + R) / 2) return getIndex(left(p), L, (L + R) / 2, pos);
return getIndex(right(p), (L + R) / 2 + 1, R, pos);
}
void update(int pos, int value) {
A[pos] = value;
pos = getIndex(1, 0, n - 1, pos);
pos /= 2;
while (pos != 0) {
int p1 = st[left(pos)];
int p2 = st[right(pos)];
if (p1 >= 0 && p2 >= 0) st[pos] = A[p1] <= A[p2] ? p1 : p2;
pos /= 2;
}
}
};
class UnionFind {
public:
vector<int> rank;
vector<pair<int, int> > p;
UnionFind(int N) {
rank.assign(N, 0);
p.assign(N, pair<int, int>(0, 1));
for (int i = 0; i < N; i++) p[i].first = i;
}
int findSet(int i) {
return (p[i].first == i) ? i : (p[i].first = findSet(p[i].first));
}
bool isSameSet(int i, int j) { return findSet(i) == findSet(j); }
void unionSet(int i, int j) {
if (!isSameSet(i, j)) {
int x = findSet(i), y = findSet(j);
if (rank[x] > rank[y]) {
p[y].first = x;
p[x].second += p[y].second;
} else {
p[x].first = y;
p[y].second += p[x].second;
if (rank[x] == rank[y]) rank[y]++;
}
}
}
int getMaxId() {
int maxIn = 0;
for (int i = 0; i < p.size(); i++)
if (p[i].second > p[maxIn].second) maxIn = i;
return maxIn;
}
int getNum() {
set<int> par;
for (int i = 0; i < p.size(); i++) par.insert(p[i].first);
return par.size();
}
};
int main() {
int tc;
cin >> tc;
while (tc--) {
string str;
cin >> str;
int n = str.length();
n++;
str = " " + str;
int dpX[n];
int dpY[n];
dpY[0] = dpX[0] = 0;
int mnX = 0, mxX = 0, mnY = 0, mxY = 0;
for (int i = 1; i < n; i++) {
dpX[i] = dpX[i - 1];
dpY[i] = dpY[i - 1];
if (str[i] == 'D') dpX[i]++;
if (str[i] == 'A') dpX[i]--;
if (str[i] == 'W') dpY[i]++;
if (str[i] == 'S') dpY[i]--;
mnX = min(mnX, dpX[i]);
mxX = max(mxX, dpX[i]);
mnY = min(mnY, dpY[i]);
mxY = max(mxY, dpY[i]);
}
int fmxX, lmxX, fmnX, lmnX;
int fmxY, lmxY, fmnY, lmnY;
fmxX = lmxX = fmnX = lmxX = fmxY = lmxY = fmnY = lmxY = -1;
for (int i = 0; i < n; i++) {
if (dpX[i] == mxX) {
lmxX = i;
if (fmxX == -1) fmxX = i;
}
if (dpX[i] == mnX) {
lmnX = i;
if (fmnX == -1) fmnX = i;
}
if (dpY[i] == mxY) {
lmxY = i;
if (fmxY == -1) fmxY = i;
}
if (dpY[i] == mnY) {
lmnY = i;
if (fmnY == -1) fmnY = i;
}
}
bool x = (lmnX + 1 < fmxX || lmxX + 1 < fmnX);
bool y = (lmnY + 1 < fmxY || lmxY + 1 < fmnY);
int disX = mxX - mnX + 1;
int disY = mxY - mnY + 1;
if (disX <= 2) x = false;
if (disY <= 2) y = false;
if (disX >= disY) {
if (y)
disY--;
else if (x)
disX--;
} else {
if (x)
disX--;
else if (y)
disY--;
}
long long res = ((long long)disX) * disY;
cout << res << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long getArea(vector<int> &a, vector<int> &b) {
long long x =
*max_element(a.begin(), a.end()) - *min_element(a.begin(), a.end()) + 1;
long long y =
*max_element(b.begin(), b.end()) - *min_element(b.begin(), b.end()) + 1;
return x * y;
}
long long Solve(vector<int> v, vector<int> a) {
int cur = v[0], ind = 0;
for (int i = 1; i < (v.size()); i++)
if (v[i] > cur) {
cur = v[i];
ind = i;
}
for (int i = ind; i < (v.size()); i++) v[i]--;
v.push_back(cur - 2);
long long A = getArea(v, a);
for (int i = ind; i < (v.size()); i++) v[i]++;
v.pop_back();
for (int i = 1; i < (v.size()); i++)
if (v[i] < cur) {
cur = v[i];
ind = i;
}
for (int i = ind; i < (v.size()); i++) v[i]++;
v.push_back(cur + 2);
long long B = getArea(v, a);
return min(A, B);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
vector<int> H, V;
vector<long long> ans;
H.push_back(0);
V.push_back(0);
int curH = 0, curV = 0;
for (int i = 0; i < (s.size()); i++) {
if (s[i] == 'A') {
H.push_back(curH - 1);
curH--;
} else if (s[i] == 'D') {
H.push_back(curH + 1);
curH++;
} else if (s[i] == 'S') {
V.push_back(curV - 1);
curV--;
} else {
V.push_back(curV + 1);
curV++;
}
}
ans.push_back(getArea(H, V));
ans.push_back(Solve(H, V));
ans.push_back(Solve(V, H));
cout << *min_element(ans.begin(), ans.end()) << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int pL[maxn], sL[maxn], pR[maxn], sR[maxn];
int pU[maxn], sU[maxn], pD[maxn], sD[maxn];
char s[maxn];
int main() {
int t, n;
cin >> t;
while (t--) {
scanf("%s", s);
n = strlen(s);
int x = 0, y = 0;
for (int i = 0; i < n; i++) {
pL[i + 1] = pL[i], pR[i + 1] = pR[i];
pU[i + 1] = pU[i], pD[i + 1] = pD[i];
if (s[i] == 'W' || s[i] == 'S') {
if (s[i] == 'W')
y++;
else
y--;
pU[i + 1] = max(pU[i], y);
pD[i + 1] = min(pD[i], y);
} else {
if (s[i] == 'A')
x--;
else
x++;
pR[i + 1] = max(pR[i], x);
pL[i + 1] = min(pL[i], x);
}
}
sL[n] = sR[n] = x;
sU[n] = sD[n] = y;
for (int i = n - 1; i >= 0; --i) {
sL[i] = sL[i + 1], sR[i] = sR[i + 1];
sU[i] = sU[i + 1], sD[i] = sD[i + 1];
if (s[i] == 'W' || s[i] == 'S') {
if (s[i] == 'W')
y--;
else
y++;
sU[i] = max(sU[i + 1], y);
sD[i] = min(sD[i + 1], y);
} else {
if (s[i] == 'A')
x++;
else
x--;
sR[i] = max(sR[i + 1], x);
sL[i] = min(sL[i + 1], x);
}
}
x = (pR[n] - pL[n] + 1), y = (pU[n] - pD[n] + 1);
long long ans = (long long)x * y;
for (int i = 0; i < n; i++) {
int L, R, U, D;
ans = min(ans, (long long)x *
((max(pU[i], sU[i] + 1) - min(pD[i], sD[i] + 1)) + 1));
ans = min(ans, (long long)x *
((max(pU[i], sU[i] - 1) - min(pD[i], sD[i] - 1)) + 1));
ans = min(ans, (long long)y *
((max(pR[i], sR[i] + 1) - min(pL[i], sL[i] + 1)) + 1));
ans = min(ans, (long long)y *
((max(pR[i], sR[i] - 1) - min(pL[i], sL[i] - 1)) + 1));
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int T;
struct pos {
int x, y, fir1, fir2, las1, las2;
} maxi, mini, now;
string str;
int main() {
scanf("%d", &T);
while (T--) {
maxi.x = maxi.y = 0;
maxi.fir1 = mini.fir1 = maxi.fir2 = mini.fir2 = maxi.las1 = mini.las1 =
maxi.las2 = mini.las2 = -1;
mini.x = mini.y = 0;
now.x = now.y = 0;
cin >> str;
int siz = str.size();
for (int i = 0; i < siz; i++) {
if (str[i] == 'A') now.y--;
if (str[i] == 'S') now.x++;
if (str[i] == 'D') now.y++;
if (str[i] == 'W') now.x--;
if (now.x == mini.x) mini.las1 = i;
if (now.x == maxi.x) maxi.las1 = i;
if (now.y == mini.y) mini.las2 = i;
if (now.y == maxi.y) maxi.las2 = i;
if (now.x > maxi.x) maxi.x = now.x, maxi.las1 = i, maxi.fir1 = i;
if (now.y > maxi.y) maxi.y = now.y, maxi.las2 = i, maxi.fir2 = i;
if (now.x < mini.x) mini.x = now.x, mini.las1 = i, mini.fir1 = i;
if (now.y < mini.y) mini.y = now.y, mini.las2 = i, mini.fir2 = i;
}
if (maxi.x - mini.x < maxi.y - mini.y)
swap(maxi.x, maxi.y), swap(mini.x, mini.y), swap(maxi.las1, maxi.las2),
swap(mini.las1, mini.las2), swap(maxi.fir1, maxi.fir2),
swap(mini.fir1, mini.fir2);
if ((maxi.las2 < mini.fir2 || maxi.fir2 > mini.las2) && maxi.y - mini.y > 1)
printf("%lld\n", (maxi.y - mini.y) * (long long)(maxi.x - mini.x + 1));
else if ((maxi.las1 < mini.fir1 || maxi.fir1 > mini.las1) &&
maxi.x - mini.x > 1)
printf("%lld\n", (maxi.y - mini.y + 1) * (long long)(maxi.x - mini.x));
else
printf("%lld\n",
(maxi.y - mini.y + 1) * (long long)(maxi.x - mini.x + 1));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename F, typename S>
ostream &operator<<(ostream &os, const pair<F, S> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
typename vector<T>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &v) {
os << "[";
typename set<T>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_set<T> &v) {
os << "[";
typename unordered_set<T>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename F, typename S>
ostream &operator<<(ostream &os, const map<F, S> &v) {
os << "[";
typename map<F, S>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << it->first << ": " << it->second;
}
return os << "]";
}
template <typename F, typename S>
ostream &operator<<(ostream &os, const unordered_map<F, S> &v) {
os << "[";
typename unordered_map<F, S>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << it->first << ": " << it->second;
}
return os << "]";
}
int T;
string s;
void solve_q();
void read_input() {
cin >> T;
for (int i = 0; i < T; i++) solve_q();
}
pair<int, bool> process_string(char plus, char minus) {
int maxi = 0, mini = 0, cnt = 0, first_max = 0, last_max = 0, first_min = 0,
last_min = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == plus)
cnt++;
else if (s[i] == minus)
cnt--;
if (cnt > maxi) {
maxi = cnt;
first_max = i;
last_max = i;
} else if (cnt == maxi) {
last_max = i;
}
if (cnt < mini) {
mini = cnt;
first_min = i;
last_min = i;
} else if (cnt == mini) {
last_min = i;
}
}
int l = maxi - mini + 1;
bool can_decrease = false;
if (l > 2 && (last_max < first_min || last_min < first_max))
can_decrease = true;
return {l, can_decrease};
}
void solve_q() {
cin >> s;
int height, width;
bool can_decrease_height, can_decrease_width;
tie(height, can_decrease_height) = process_string('W', 'S');
tie(width, can_decrease_width) = process_string('D', 'A');
long long sol = (long long)height * (long long)width;
if (can_decrease_height)
sol = min(sol, (long long)(height - 1) * (long long)width);
if (can_decrease_width)
sol = min(sol, (long long)height * (long long)(width - 1));
cout << sol << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
read_input();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> dir = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
void solve() {
map<char, pair<int, int>> ma;
ma['W'] = {0, 1};
ma['A'] = {-1, 0};
ma['S'] = {0, -1};
ma['D'] = {1, 0};
string s;
cin >> s;
int n = s.length();
pair<int, int> pos[n + 1];
pos[0] = {0, 0};
for (int q = 0; q < n; q++) {
pos[q + 1].first = pos[q].first + ma[s[q]].first;
pos[q + 1].second = pos[q].second + ma[s[q]].second;
}
vector<vector<int>> extreme(n + 1);
for (int q = 0; q < 2; q++) {
extreme[n].push_back(pos[n].first);
extreme[n].push_back(pos[n].second);
}
for (int q = n - 1; q >= 0; q--) {
extreme[q].push_back(min(pos[q].first, extreme[q + 1][0]));
extreme[q].push_back(min(pos[q].second, extreme[q + 1][1]));
extreme[q].push_back(max(pos[q].first, extreme[q + 1][2]));
extreme[q].push_back(max(pos[q].second, extreme[q + 1][3]));
}
long long ans = (long long)(extreme[0][2] - extreme[0][0] + 1) *
(extreme[0][3] - extreme[0][1] + 1);
int lx = 0, ly = 0, hx = 0, hy = 0;
for (int q = 1; q <= n; q++) {
for (int w = 0; w < 4; w++) {
int llx = min(lx, dir[w].first + extreme[q][0]);
int lly = min(ly, dir[w].second + extreme[q][1]);
int hhx = max(hx, dir[w].first + extreme[q][2]);
int hhy = max(hy, dir[w].second + extreme[q][3]);
llx = min(llx, pos[q - 1].first + dir[w].first);
lly = min(lly, pos[q - 1].second + dir[w].second);
hhx = max(hhx, pos[q - 1].first + dir[w].first);
hhy = max(hhy, pos[q - 1].second + dir[w].second);
ans = min(ans, (long long)(hhx - llx + 1) * (hhy - lly + 1));
}
lx = min(lx, pos[q].first);
ly = min(ly, pos[q].second);
hx = max(hx, pos[q].first);
hy = max(hy, pos[q].second);
}
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool ok(vector<long long> v) {
int n = v.size();
for (int i = 0; i < n; ++i) v[i] = 2 * v[i] - 1;
int x = 0;
int mi = 0;
int ma = 0;
for (int i = 0; i < n; ++i) {
x += v[i];
if (mi > x) mi = x;
if (ma < x) ma = x;
}
if (ma - mi < 2) return false;
vector<long long> u(2, 0);
x = 0;
int i = 0;
while (x != ma && x != mi) {
x += v[i];
++i;
}
int fi = x;
int se = mi + ma - fi;
while (x != se) {
x += v[i];
++i;
}
while (i < n) {
x += v[i];
++i;
if (x == fi) return false;
}
return true;
}
long long f(vector<long long> v) {
int n = v.size();
for (int i = 0; i < n; ++i) v[i] = 2 * v[i] - 1;
int x = 0;
int mi = 0;
int ma = 0;
for (int i = 0; i < n; ++i) {
x += v[i];
if (mi > x) mi = x;
if (ma < x) ma = x;
}
return ma - mi + 1;
}
long long solve() {
string s;
cin >> s;
int n = s.length();
vector<long long> v(n);
for (int i = 0; i < n; ++i) {
if (s[i] == 'W') v[i] = 0;
if (s[i] == 'S') v[i] = 1;
if (s[i] == 'D') v[i] = 2;
if (s[i] == 'A') v[i] = 3;
}
vector<long long> a, b;
for (int i = 0; i < n; ++i) {
if (v[i] < 2)
a.push_back(v[i]);
else
b.push_back(v[i] - 2);
}
long long lenx = f(b);
long long leny = f(a);
long long res = lenx * leny;
if (ok(b)) res = min(res, (lenx - 1) * leny);
if (ok(a)) res = min(res, lenx * (leny - 1));
return res;
}
int main() {
ios_base::sync_with_stdio(false);
int t;
cin >> t;
while (t--) cout << solve() << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
getchar();
while (n--) {
string s;
int x, y, l, r, u, d, L, R, U, D;
x = y = l = r = u = d = L = R = U = D = 0;
getline(cin, s);
for (int i = 0; i < s.size(); i++) {
switch (s[i]) {
case 'A':
x--;
if (x < l) {
l = x;
L = 1;
R = 0;
} else if (x == l)
L = 1;
break;
case 'D':
x++;
if (x > r) {
r = x;
R = 1;
L = 0;
} else if (x == r)
R = 1;
break;
case 'W':
y++;
if (y > u) {
u = y;
U = 1;
D = 0;
} else if (y == u)
U = 1;
break;
case 'S':
y--;
if (y < d) {
d = y;
D = 1;
U = 0;
} else if (y == d)
D = 1;
break;
}
}
x = r - l + 1;
y = u - d + 1;
long long mi = 1LL * x * y, k1 = mi, k2 = mi;
if (x > 2 && L * R == 0) k1 = mi - y;
if (y > 2 && U * D == 0) k2 = mi - x;
cout << min(k1, k2) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int N = 200200;
int n, m;
int ANS[N];
int g[N];
vector<int> G[N];
int deg[N];
int q[N];
int topQ;
int id[N];
vector<int> a[N];
vector<pair<long long, int> > Q[N];
vector<pair<int, int> > b[N];
vector<int> pref[N];
void read() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &g[i]);
g[i]--;
deg[g[i]]++;
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
long long x;
int v;
scanf("%lld%d", &x, &v);
v--;
Q[v].push_back(make_pair(x, i));
}
}
void solveTree(int v) {
int big = -1;
for (int u : G[v]) {
if (big == -1 || (int)a[id[u]].size() > (int)a[id[big]].size()) big = u;
}
if (big == -1) {
id[v] = v;
} else {
id[v] = id[big];
}
int sz = (int)a[id[v]].size();
for (int u : G[v]) {
if (u == big) continue;
int z = id[u];
reverse(a[z].begin(), a[z].end());
for (int i = 0; i < (int)a[z].size(); i++) a[id[v]][sz - 1 - i] += a[z][i];
}
a[id[v]].push_back(1);
for (pair<long long, int> t : Q[v]) {
long long x = t.first;
if (x <= sz) ANS[t.second] = a[id[v]][sz - x];
}
int u = g[v];
G[u].push_back(v);
deg[u]--;
if (deg[u] == 0) q[topQ++] = u;
}
void solveCycle(vector<int> cycle) {
reverse(cycle.begin(), cycle.end());
int k = (int)cycle.size();
for (int i = 0; i < k; i++) {
b[i].clear();
pref[i].clear();
}
for (int t = 0; t < k; t++) {
int v = cycle[t];
int big = -1;
for (int u : G[v]) {
if (big == -1 || (int)a[id[u]].size() > (int)a[id[big]].size()) big = u;
}
if (big == -1) {
id[v] = v;
} else {
id[v] = id[big];
}
int sz = (int)a[id[v]].size();
for (int u : G[v]) {
if (u == big) continue;
int z = id[u];
reverse(a[z].begin(), a[z].end());
for (int i = 0; i < (int)a[z].size(); i++)
a[id[v]][sz - 1 - i] += a[z][i];
}
a[id[v]].push_back(1);
reverse(a[id[v]].begin(), a[id[v]].end());
for (int i = 0; i <= sz; i++) {
int p = (t + i) % k;
b[p].push_back(make_pair(i, a[id[v]][i]));
}
}
for (int i = 0; i < k; i++) {
sort(b[i].begin(), b[i].end());
pref[i].push_back(0);
for (pair<int, int> t : b[i]) pref[i].push_back(pref[i].back() + t.second);
}
for (int t = 0; t < k; t++) {
int v = cycle[t];
for (pair<long long, int> z : Q[v]) {
long long x = z.first;
int xx;
if (x > (long long)1e7) {
xx = x - ((x - (long long)1e7) / k) * k;
} else {
xx = x;
}
int p = (xx + t) % k;
int pos = lower_bound(b[p].begin(), b[p].end(), make_pair(xx, N)) -
b[p].begin();
ANS[z.second] = pref[p][pos];
}
}
}
int main() {
read();
for (int v = 0; v < n; v++)
if (deg[v] == 0) q[topQ++] = v;
for (int i = 0; i < topQ; i++) {
int v = q[i];
solveTree(v);
}
for (int v = 0; v < n; v++) {
if (deg[v] == 0) continue;
vector<int> all;
int u = v;
do {
all.push_back(u);
u = g[u];
} while (u != v);
solveCycle(all);
for (int u : all) deg[u] = 0;
}
for (int i = 0; i < m; i++) printf("%d\n", ANS[i]);
return 0;
}
|
#include <bits/stdc++.h>
using std::abs;
using std::array;
using std::cerr;
using std::cin;
using std::cout;
using std::generate;
using std::get;
using std::make_pair;
using std::make_tuple;
using std::map;
using std::max;
using std::max_element;
using std::min;
using std::min_element;
using std::pair;
using std::reverse;
using std::set;
using std::sort;
using std::string;
using std::swap;
using std::tuple;
using std::unique;
using std::vector;
template <typename T>
T input() {
T res;
cin >> res;
{};
return res;
}
template <typename IT>
void input_seq(IT b, IT e) {
std::generate(b, e,
input<typename std::remove_reference<decltype(*b)>::type>);
}
struct comp_t {
vector<int> cycle;
int size;
};
int main() {
std::iostream::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n = input<int>();
vector<int> go(n);
vector<vector<int>> graph(n);
vector<vector<int>> graph2(n);
for (int i = 0; i != n; ++i) {
go[i] = input<int>() - 1;
graph[go[i]].push_back(i);
graph2[go[i]].push_back(i);
graph2[i].push_back(go[i]);
}
vector<int> compid(n, -1);
vector<comp_t> comps;
int szcomp = 0;
std::function<void(int, int)> dfs = [&](int v, int c) {
++szcomp;
compid[v] = c;
for (int u : graph2[v])
if (compid[u] == -1) dfs(u, c);
};
vector<char> is_cycle(n, false);
vector<int> pos(n, -1);
for (int i = 0; i != n; ++i)
if (compid[i] == -1) {
szcomp = 0;
dfs(i, int((comps).size()));
comps.resize(int((comps).size()) + 1);
comps.back().size = szcomp;
vector<int> arr;
int p = i;
for (; pos[p] == -1; p = go[p]) {
pos[p] = int((arr).size());
arr.push_back(p);
}
arr.erase(arr.begin(), arr.begin() + pos[p]);
comps.back().cycle = arr;
for (int elem : arr) is_cycle[elem] = 1;
for (int i = 0; i != int((arr).size()); ++i) pos[arr[i]] = i;
}
vector<vector<tuple<int, int, int>>> buckets(int((comps).size()));
vector<vector<pair<int, int>>> notcycle(n);
int q = input<int>();
vector<int> answers(q, -1);
for (int i = 0; i != q; ++i) {
int64_t m;
int y;
cin >> m >> y;
--y;
if (is_cycle[y]) {
int clen = int((comps[compid[y]].cycle).size());
int total = comps[compid[y]].size;
if (m >= clen + total) m = total + (m - total) % clen;
buckets[compid[y]].emplace_back(m, pos[y], i);
} else
notcycle[y].emplace_back(m, i);
}
auto merge = [&](vector<int>& a, vector<int>& b) {
if (not(int((a).size()) >= int((b).size()))) swap(a, b);
for (int p = 0; p != int((b).size()); ++p)
a[int((a).size()) - int((b).size()) + p] += b[p];
};
std::function<vector<int>(int, vector<pair<int, int>>&, int, int)> solve =
[&](int v, vector<pair<int, int>>& go, int to, int len) {
go.emplace_back(len, to);
vector<int> res = {1};
for (int u : graph[v]) {
auto rs = solve(u, go, to, len + 1);
rs.push_back(0);
merge(res, rs);
}
for (auto elem : notcycle[v])
if (elem.first < int((res).size()))
answers[elem.second] = res[int((res).size()) - 1 - elem.first];
else
answers[elem.second] = 0;
return res;
};
for (int c = 0; c != int((comps).size()); ++c) {
sort(buckets[c].begin(), buckets[c].end());
vector<pair<int, int>> go;
for (int i = 0; i != int((comps[c].cycle).size()); ++i)
for (int u : graph[comps[c].cycle[i]])
if (not is_cycle[u]) solve(u, go, i, 1);
sort(go.begin(), go.end());
int ptr = 0;
vector<int> state(int((comps[c].cycle).size()), 1);
int curt = 0;
int off = 0;
for (auto quer : buckets[c]) {
while (curt != get<0>(quer)) {
++curt;
off -= 1;
if (off < 0) off += int((state).size());
while (ptr < int((go).size()) and go[ptr].first == curt) {
state[(go[ptr].second + off) % int((state).size())] += 1;
++ptr;
}
}
answers[get<2>(quer)] = state[(get<1>(quer) + off) % int((state).size())];
}
}
for (int i = 0; i != q; ++i) cout << answers[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[200005], q, ans[200005], root[200005], len[200005];
int cidx[200005], hang[200005];
long long m[200005];
basic_string<int> inv[200005], qry[200005];
basic_string<int> root_inv[200005], occ[200005], hang_inv[200005];
bool st[200005], cyc[200005];
void dfs1(int x) {
int y = a[x];
st[x] = 1;
if (root[y]) {
root[x] = root[y];
} else if (st[y]) {
root[x] = x;
} else {
dfs1(y);
root[x] = root[y];
}
st[x] = 0;
}
int el[200005], er[200005], et, dub[200005];
void dfs2(int x, int h) {
el[x] = et++;
hang[x] = h;
hang_inv[h] += x;
for (int y : inv[x]) {
if (!cyc[y]) {
dub[y] = dub[x] + 1;
dfs2(y, h);
}
}
er[x] = et;
}
struct ads {
int sz, l;
deque<int> w;
ads(int sz, int l) : sz(sz), l(l), w(sz) {}
void add(int x) { w[x]++; }
void prepare() {
for (int i = l; i < sz; i++) w[i] += w[i - l];
}
void extend() {
w.push_front(0);
sz++;
}
void wrap(int x) { w[x]++; }
int get(long long x) {
if (x >= sz) x -= (x - sz) / l * l + l;
return w[x];
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
inv[a[i]] += i;
}
cin >> q;
for (int i = 0; i < q; i++) {
int y;
cin >> m[i] >> y;
qry[y] += i;
}
for (int i = 1; i <= n; i++)
if (!root[i]) dfs1(i);
for (int i = 1; i <= n; i++) root_inv[root[i]] += i;
for (int i = 1; i <= n; i++) {
if (i == root[i]) {
int l = 1;
cyc[i] = 1;
for (int j = a[i]; j != i; j = a[j]) {
cidx[j] = l;
l++;
cyc[j] = 1;
}
len[i] = l;
}
}
for (int i = 1; i <= n; i++) {
if (cyc[i]) {
dfs2(i, i);
}
}
for (int i = 1; i <= n; i++) {
occ[dub[i]] += el[i];
}
for (int i = 0; i <= n; i++) sort(occ[i].begin(), occ[i].end());
for (int x = 1; x <= n; x++) {
if (!cyc[x]) {
for (int i : qry[x]) {
int d = min(200001ll, m[i] + dub[x]);
auto it1 = lower_bound(occ[d].begin(), occ[d].end(), el[x]);
auto it2 = lower_bound(occ[d].begin(), occ[d].end(), er[x]);
ans[i] = it2 - it1;
}
}
}
for (int x = 1; x <= n; x++) {
if (x == root[x]) {
int sz = root_inv[x].size(), l = len[x];
ads w(sz, l);
for (int y : root_inv[x]) {
int h = hang[y];
w.add(dub[y] + (cidx[h] == 0 ? 0 : l - cidx[h]));
}
w.prepare();
for (int _i = 0, y = x; _i < l; _i++) {
for (int i : qry[y]) {
ans[i] = w.get(m[i]);
}
y = a[y];
w.extend();
for (int z : hang_inv[y]) {
w.wrap(dub[z]);
}
}
}
}
for (int i = 0; i < q; i++) cout << ans[i] << '\n';
}
|
#include <bits/stdc++.h>
int n, q;
std::vector<int> a, pos, ans, rt, vis, cnt, sum;
std::vector<std::vector<int>> e;
std::vector<std::vector<std::pair<long long, int>>> queries;
void dfs1(int u) {
vis[u] = 1;
for (int v : e[u]) {
if (vis[v] == 0) {
dfs1(v);
} else if (vis[v] == 1) {
pos[v] = 1;
for (int i = u; i != v; i = a[i]) {
rt[i] = v;
++pos[v];
}
rt[v] = v;
for (int i = u, j = pos[v]; i != v; i = a[i]) pos[i] = --j;
}
}
vis[u] = 2;
}
void dfs2(int u, int d) {
if (pos[u] == -1)
for (auto &&[m, i] : queries[u])
if (d + m < int(cnt.size())) ans[i] -= cnt[d + m];
if (d >= int(cnt.size())) cnt.resize(d + 1);
++cnt[d];
for (int v : e[u])
if (pos[v] == -1) dfs2(v, d + 1);
if (pos[u] == -1)
for (auto &&[m, i] : queries[u])
if (d + m < int(cnt.size())) ans[i] += cnt[d + m];
}
void dfs3(int u, int d) {
if (d >= int(cnt.size())) cnt.resize(d + 1);
++cnt[d];
for (int v : e[u])
if (rt[v] != v) dfs3(v, d + 1);
}
void dfs4(int u, int d) {
if (pos[u] != -1)
for (auto &&[m, i] : queries[u])
if (d + m < int(cnt.size())) ans[i] -= cnt[d + m];
if (d >= int(cnt.size())) cnt.resize(d + 1);
++cnt[d];
for (int v : e[u])
if (rt[v] != v) dfs4(v, d + 1);
if (pos[u] != -1)
for (auto &&[m, i] : queries[u])
if (d + m < int(cnt.size())) ans[i] += cnt[d + m];
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cin >> n;
a.resize(n);
pos.assign(n, -1);
e.resize(n);
queries.resize(n);
vis.resize(n);
rt.assign(n, -1);
for (int i = 0; i < n; ++i) {
std::cin >> a[i];
--a[i];
e[a[i]].push_back(i);
}
for (int i = 0; i < n; ++i)
if (vis[i] == 0) dfs1(i);
std::cin >> q;
ans.resize(q);
for (int i = 0; i < q; ++i) {
long long m;
int u;
std::cin >> m >> u;
--u;
queries[u].emplace_back(m, i);
}
for (int i = 0; i < n; ++i) {
if (pos[i] != -1) {
cnt.clear();
dfs2(i, 0);
}
}
for (int i = 0; i < n; ++i) {
if (rt[i] == i) {
cnt.clear();
dfs3(i, 0);
sum = cnt;
for (int j = pos[i]; j < int(sum.size()); ++j) sum[j] += sum[j - pos[i]];
int j = i;
do {
for (auto &&[m, k] : queries[j]) {
long long t = m + (i == j ? 0 : pos[j]);
if (t >= int(cnt.size())) {
t %= pos[i];
t += (cnt.size() - t - 1) / pos[i] * pos[i];
} else {
ans[k] -= cnt[t];
}
ans[k] += sum[t];
}
j = a[j];
} while (j != i);
cnt.clear();
dfs4(i, 0);
}
}
for (int i = 0; i < q; ++i) std::cout << ans[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Nmax = 2e5 + 5;
int A[Nmax], start[Nmax];
long long cnt[Nmax];
bool cycle[Nmax];
int go[Nmax], where[Nmax], visited[Nmax];
vector<int> active[Nmax], when[Nmax];
int zz[Nmax], ans[Nmax];
int nrcomp, n, q, Nr;
vector<int> cyc[Nmax];
vector<int> query1[Nmax], query2[Nmax], to[Nmax];
int level[Nmax], L[Nmax], R[Nmax], Size[Nmax];
vector<int> cc[Nmax];
class AIB {
int a[Nmax];
int ub(int x) { return (x & (-x)); }
int query(int pos) {
int ans = 0;
for (; pos; pos -= ub(pos)) ans += a[pos];
return ans;
}
public:
void upd(int pos, int add) {
for (; pos <= Nr; pos += ub(pos)) a[pos] += add;
}
int query(int L, int R) {
assert(1 <= L && L <= R && R <= Nr);
return query(R) - query(L - 1);
}
} aib;
void dfs0(int node) {
visited[node] = 3;
where[node] = nrcomp;
cc[nrcomp].push_back(node);
L[node] = ++Nr;
for (auto it : to[node])
if (!cycle[it]) {
go[it] = go[node];
level[it] = level[node] + 1;
dfs0(it);
}
R[node] = Nr;
}
void find_comp(int root) {
int node = root;
vector<int> nodes;
while (!visited[node]) {
visited[node] = 1;
nodes.push_back(node);
node = A[node];
}
bool ww = 0;
for (auto it : nodes) {
if (it == node) ww = 1;
if (ww) ++Size[nrcomp], cycle[it] = 1;
}
for (auto it : nodes)
if (cycle[it]) cyc[nrcomp].push_back(it);
int i;
for (i = 0; i < cyc[nrcomp].size(); ++i) {
level[cyc[nrcomp][i]] = 0;
go[cyc[nrcomp][i]] = i;
dfs0(cyc[nrcomp][i]);
}
}
void find_graph() {
int i;
for (i = 1; i <= n; ++i)
if (!visited[i]) {
++nrcomp;
find_comp(i);
}
}
void solve1(int id) {
for (auto node : cc[id]) active[level[node]].push_back(go[node]);
sort(query1[id].begin(), query1[id].end(),
[](int x, int y) { return cnt[x] < cnt[y]; });
if (id == 2) {
}
int i;
int j = 0, k;
for (i = 0; i < query1[id].size(); ++i) {
while (j < cc[id].size() && j <= cnt[query1[id][i]]) {
for (auto it : active[j]) {
int md = ((it - j) % Size[id] + Size[id]) % Size[id];
zz[md]++;
}
++j;
}
int tmp =
(((long long)go[start[query1[id][i]]] - cnt[query1[id][i]]) % Size[id] +
Size[id]) %
Size[id];
ans[query1[id][i]] = zz[tmp];
}
for (i = 0; i < cc[id].size(); ++i) zz[i] = 0, active[i].clear();
}
void solve2(int id) {
for (auto it : query2[id])
if (level[start[it]] + cnt[it] < (long long)cc[id].size())
when[level[start[it]] + cnt[it]].push_back(it);
for (auto it : cc[id]) active[level[it]].push_back(L[it]);
int i;
for (i = 0; i < cc[id].size(); ++i) {
for (auto it : active[i]) aib.upd(it, 1);
for (auto it : when[i]) ans[it] = aib.query(L[start[it]], R[start[it]]);
for (auto it : active[i]) aib.upd(it, -1);
}
for (i = 0; i < cc[id].size(); ++i) active[i].clear(), when[i].clear();
}
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
int i;
cin >> n;
for (i = 1; i <= n; ++i) cin >> A[i], to[A[i]].push_back(i);
cin >> q;
for (i = 1; i <= q; ++i) cin >> cnt[i] >> start[i];
find_graph();
for (i = 1; i <= q; ++i)
if (cycle[start[i]])
query1[where[start[i]]].push_back(i);
else
query2[where[start[i]]].push_back(i);
for (i = 1; i <= nrcomp; ++i) solve1(i);
for (i = 1; i <= nrcomp; ++i) solve2(i);
for (i = 1; i <= q; ++i) cout << ans[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mn = 2e5 + 5;
const int mod = 1e9 + 7;
int n, q;
int a[mn];
bool is_cycle[mn];
int cycc[mn];
vector<int> cycle[mn];
int cycnt;
int cyid[mn];
int to[mn];
int dist[mn];
vector<int> rg[mn];
int vis[mn];
vector<int> st;
void dfs(int x) {
if (vis[x] == -1) {
int u = ((int)st.size()) - 1;
++cycnt;
while (st[u] != x) {
is_cycle[st[u]] = 1;
cycc[st[u]] = cycnt;
cyid[st[u]] = cycle[cycnt].size();
cycle[cycnt].push_back(st[u]);
u--;
}
is_cycle[st[u]] = 1;
cycc[st[u]] = cycnt;
cyid[st[u]] = cycle[cycnt].size();
cycle[cycnt].push_back(st[u]);
return;
}
vis[x] = -1;
st.push_back(x);
if (vis[a[x]] != 1) {
dfs(a[x]);
}
if (vis[a[x]] == 1 && cycc[a[x]] && !cycc[x]) {
cycc[x] = cycc[a[x]];
}
vis[x] = 1;
st.pop_back();
}
struct node {
int id, dist, from;
};
vector<int> vv[mn];
void bfs() {
queue<node> q;
for (int i = 1; i <= n; i++) {
if (is_cycle[i]) q.push({i, 0, i});
}
while (!q.empty()) {
node u = q.front();
q.pop();
for (auto &p : rg[u.id]) {
if (is_cycle[p]) continue;
q.push({p, u.dist + 1, u.from});
to[p] = u.from;
dist[p] = u.dist + 1;
vv[u.from].push_back(u.dist + 1);
}
}
}
struct query {
long long m;
int y, id, cyclecnt;
bool operator<(const query &p) const { return cyclecnt < p.cyclecnt; }
} Q[mn];
int ans[mn];
vector<int> cyclemod[mn];
int dfsc;
int pc[mn], pe[mn];
int dep[mn];
int maxid;
vector<int> v[mn];
void dfs2(int x, int banned, int depth, int cyclesize) {
pc[x] = ++dfsc;
dep[x] = depth;
maxid = max(depth, maxid);
v[depth].push_back(pc[x]);
if (!is_cycle[x]) cyclemod[depth % cyclesize].push_back(depth - dep[to[x]]);
for (auto &i : rg[x]) {
if (i != banned) {
dfs2(i, banned, depth + 1, cyclesize);
}
}
pe[x] = dfsc;
}
void build(int cnt) {
int cysize = cycle[cnt].size();
for (int i = 0; i < ((int)cycle[cnt].size()); i++) {
cyclemod[i].clear();
}
for (int i = 0; i <= maxid; i++) v[i].clear();
maxid = 0;
for (auto &i : cycle[cnt]) {
if (is_cycle[i]) {
dfs2(i, i, 0, ((int)cycle[cnt].size()));
break;
}
}
for (int j = 0; j < ((int)cycle[cnt].size()); j++) {
sort(cyclemod[j].begin(), cyclemod[j].end());
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
rg[a[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) dfs(i);
}
bfs();
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%lld%d", &Q[i].m, &Q[i].y);
Q[i].id = i;
Q[i].cyclecnt = cycc[Q[i].y];
}
sort(Q + 1, Q + q + 1);
int lastqcy = 0;
for (int i = 1; i <= q; i++) {
if (lastqcy != Q[i].cyclecnt) {
build(Q[i].cyclecnt);
lastqcy = Q[i].cyclecnt;
}
if (!is_cycle[Q[i].y]) {
Q[i].m = min(Q[i].m, (long long)1e6);
int di = dep[Q[i].y] + Q[i].m;
ans[Q[i].id] = upper_bound(v[di].begin(), v[di].end(), pe[Q[i].y]) -
lower_bound(v[di].begin(), v[di].end(), pc[Q[i].y]);
} else {
int idx = (cyid[Q[i].y] + Q[i].m) % ((int)cycle[lastqcy].size());
ans[Q[i].id] =
upper_bound(cyclemod[idx].begin(), cyclemod[idx].end(), Q[i].m) -
begin(cyclemod[idx]) + 1;
}
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200000;
struct edge {
edge *nxt;
int to;
} edges[MAXN + 5], *adj[MAXN + 5], *ecnt = edges;
void addedge(int u, int v) {
edge *p = (++ecnt);
p->to = v, p->nxt = adj[u], adj[u] = p;
}
bool tag[MAXN + 5];
int fa[MAXN + 5];
int find(int x) { return fa[x] = (fa[x] == x ? x : find(fa[x])); }
bool unite(int x, int y) {
int fx = find(x), fy = find(y);
if (fx == fy)
return false;
else {
fa[fx] = fy;
return true;
}
}
vector<int> cir[MAXN + 5];
int cnt;
bool dfs1(int x, const int &y) {
if (x == y) {
tag[x] = true, cir[cnt].push_back(x);
return true;
}
for (edge *p = adj[x]; p; p = p->nxt)
if (dfs1(p->to, y)) {
tag[x] = true, cir[cnt].push_back(x);
return true;
}
return false;
}
struct query {
int type, id;
long long m;
query(int _t = 0, int _i = 0, long long _m = 0) : type(_t), id(_i), m(_m) {}
friend bool operator<(query a, query b) {
return (a.m == b.m ? a.type > b.type : a.m > b.m);
}
};
int ans[MAXN + 5];
vector<query> qry[MAXN + 5];
int tot[MAXN + 5], mxdep, s;
priority_queue<query> que;
int nxt(int x) { return x == s - 1 ? 0 : x + 1; }
void dfs2(int x, int dep, const int &id, int ps) {
que.push(query(-1, cir[id][ps], dep));
mxdep = max(mxdep, dep);
if (!tag[x]) {
for (int i = 0; i < qry[x].size(); i++)
if (dep + qry[x][i].m <= MAXN)
ans[qry[x][i].id] -= tot[dep + qry[x][i].m];
}
tot[dep]++;
for (edge *p = adj[x]; p; p = p->nxt)
if (!tag[p->to]) dfs2(p->to, dep + 1, id, nxt(ps));
if (!tag[x]) {
for (int i = 0; i < qry[x].size(); i++)
if (dep + qry[x][i].m <= MAXN)
ans[qry[x][i].id] += tot[dep + qry[x][i].m];
}
}
int res[MAXN + 5];
int main() {
int N, M;
scanf("%d", &N);
for (int i = 1; i <= N; i++) fa[i] = i;
for (int i = 1; i <= N; i++) {
int x;
scanf("%d", &x);
if (!unite(x, i))
cnt++, dfs1(i, x), reverse(cir[cnt].begin(), cir[cnt].end());
addedge(x, i);
}
scanf("%d", &M);
for (int i = 1; i <= M; i++) {
long long m;
int y;
scanf("%lld%d", &m, &y);
qry[y].push_back(query(0, i, m));
}
for (int i = 1; i <= cnt; i++) {
s = (int)cir[i].size();
for (int j = 0; j < s; j++) {
int x = cir[i][j];
mxdep = 0, dfs2(x, 0, i, j);
for (int k = 0; k <= mxdep; k++) tot[k] = 0;
for (int k = 0; k < qry[x].size(); k++) {
int y = cir[i][(j + qry[x][k].m) % s];
que.push(query(qry[x][k].id, y, qry[x][k].m));
}
}
while (!que.empty()) {
query t = que.top();
que.pop();
if (t.type == -1)
res[t.id]++;
else
ans[t.type] = res[t.id];
}
}
for (int i = 1; i <= M; i++) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, M = 998244353, INF = 0x3f3f3f3f;
void Main();
bool fastio = 0;
void print() { cout << '\n'; }
template <typename T, typename... U>
void print(const T& x, const U&... y) {
((sizeof...(y) == 0) ? (cout << x) : (cout << x << ' '));
print(y...);
}
template <typename T>
void print(const T& a, int l, int r, char c) {
for (int i = l; i <= r; ++i) {
cout << a[i];
if (i == r)
cout << '\n';
else
cout << c;
}
}
void input() {}
template <typename T, typename... U>
void input(T& x, U&... y) {
cin >> x;
input(y...);
}
template <typename T>
void input(T& a, int l, int r, bool f) {
for (int i = l; i <= r; ++i) cin >> a[i];
}
template <typename T>
void Max(T& a, T b) {
a < b ? a = b : 1;
}
template <typename T>
void Min(T& a, T b) {
a > b ? a = b : 1;
}
template <typename T>
void Add(T& a, T b) {
a += b, a > M ? a -= M : 1;
}
int main(int argc, char** argv) {
ios::sync_with_stdio(0), cin.tie(0);
cout << setprecision(10) << fixed;
Main();
}
int fa[N], deg[N], ans[N];
vector<pair<long long, int>> Q[N];
vector<int> dp[N];
void merge(vector<int>& a, vector<int>& b) {
if (a.size() < b.size()) swap(a, b);
for (int i = 0; i < (int)b.size(); ++i)
a[a.size() - 1 - i] += b[b.size() - 1 - i];
}
void Main() {
int n, q;
input(n);
for (int i = 1; i <= n; ++i) {
input(fa[i]);
++deg[fa[i]];
}
queue<int> leaves;
input(q);
for (long long i = 1, y, m; i <= q; ++i)
input(m, y), Q[y].push_back(make_pair(m, (int)i));
for (int i = 1; i <= n; ++i) {
if (deg[i] == 0) leaves.push(i);
dp[i].push_back(1);
}
while (!leaves.empty()) {
int v = leaves.front();
leaves.pop();
for (auto x : Q[v])
if (x.first < (long long)dp[v].size())
ans[x.second] = dp[v][dp[v].size() - 1 - x.first];
dp[v].push_back(0);
merge(dp[fa[v]], dp[v]);
if (--deg[fa[v]] == 0) leaves.push(fa[v]);
}
for (int i = 1; i <= n; ++i)
if (deg[i] != 0) {
vector<int> v;
int j = i, sz = 0;
do {
deg[j] = 0;
auto x = dp[j];
merge(v, x);
v.push_back(0);
j = fa[j];
++sz;
} while (j != i);
for (int k = 0; k + sz < (int)v.size(); ++k)
v[v.size() - 1 - k - sz] += v[v.size() - 1 - k];
do {
merge(v, dp[j]);
for (auto x : Q[j]) {
if (x.first < (long long)v.size()) {
ans[x.second] = v[v.size() - 1 - x.first];
} else {
ans[x.second] =
v[(((long long)v.size() - 1 - x.first) % sz + sz) % sz];
}
}
j = fa[j];
v.push_back(0);
} while (j != i);
}
print(ans, 1, q, '\n');
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T, class T1>
int chkmin(T &x, const T1 &y) {
return x > y ? x = y, 1 : 0;
}
template <class T, class T1>
int chkmax(T &x, const T1 &y) {
return x < y ? x = y, 1 : 0;
}
const int MAXN = (1 << 20);
int n;
int a[MAXN];
int answer[MAXN];
vector<pair<int64_t, int> > que[MAXN];
void read() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
}
int vis[MAXN], used[MAXN];
vector<vector<int> > c;
struct mydeque {
vector<int> vec;
int &operator[](const unsigned &pos) { return vec[vec.size() - pos - 1]; }
unsigned size() { return vec.size(); }
void push_front(int x) { vec.push_back(x); }
};
int q;
int d[MAXN], deg[MAXN];
mydeque dp[MAXN];
void merge(mydeque &a, mydeque &b) {
if (((int)a.size()) < ((int)b.size())) swap(a, b);
for (int i = 0; i < ((int)b.size()); i++) {
a[i] += b[i];
}
}
int idx(int len, int64_t m, int s) {
int rem = m % s;
int ans = (len / s) * s + rem;
if (ans >= len) ans -= s;
return ans;
}
void solve() {
cin >> q;
for (int i = 0; i < q; i++) {
int64_t m;
int u;
cin >> m >> u;
que[u].push_back({m, i});
}
int TM = 42;
for (int i = 1; i <= n; i++) {
if (!used[i]) {
int x = i;
TM++;
while (!used[x]) {
used[x] = TM;
x = a[x];
}
if (!vis[x] && used[x] == TM) {
vector<int> vec;
while (!vis[x]) {
vis[x] = 1;
vec.push_back(x);
x = a[x];
}
c.push_back(vec);
}
}
}
queue<int> q;
for (int i = 1; i <= n; i++) {
dp[i].vec = {1};
deg[a[i]]++;
}
for (int i = 1; i <= n; i++) {
if (deg[i] == 0) q.push(i);
}
while (!q.empty()) {
int i = q.front();
q.pop();
for (auto it : que[i]) {
if (((int)dp[i].size()) <= it.first)
answer[it.second] = 0;
else
answer[it.second] = dp[i][it.first];
}
dp[i].push_front(0);
merge(dp[a[i]], dp[i]);
deg[a[i]]--;
if (deg[a[i]] == 0) {
q.push(a[i]);
}
}
for (auto cyc : c) {
mydeque tmp;
int m = ((int)cyc.size());
for (int i : cyc) {
auto cp = dp[i];
tmp.push_front(0);
merge(tmp, cp);
}
for (int j = 0; j < ((int)tmp.size()); j++) {
if (j + m < ((int)tmp.size())) tmp[j + m] += tmp[j];
}
for (int i : cyc) {
tmp.push_front(0);
merge(tmp, dp[i]);
for (auto it : que[i]) {
if (((int)tmp.size()) <= it.first)
answer[it.second] = tmp[idx(((int)tmp.size()), it.first, m)];
else
answer[it.second] = tmp[it.first];
}
}
}
for (int i = 0; i < ::q; i++) {
cout << answer[i] << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
read();
solve();
return 0;
}
|
#include <bits/stdc++.h>
const int N = 2e5 + 5;
std::vector<int> g[N];
int n, Q, a[N];
std::vector<int> tour[N], block[N];
struct Query {
long long m;
int x, id;
bool operator<(const Query &b) const { return m < b.m; }
};
std::vector<Query> q[N], qt[N];
bool inTour[N];
int blg[N], x[N], y[N], cnt, f[N];
int stk[N], top;
int vis[N];
void dfs(int u) {
stk[top++] = u;
vis[u] = 1;
int v = a[u];
if (vis[v] == 2)
;
else if (vis[v] == 1) {
++cnt;
int p = -1;
for (int j = 0; j < top; j++)
if (stk[j] == v) {
p = j;
break;
}
for (int j = p; j < top; j++) {
tour[cnt].push_back(stk[j]);
inTour[stk[j]] = true;
blg[stk[j]] = cnt;
x[stk[j]] = 0;
y[stk[j]] = j - p;
}
} else
dfs(v);
--top;
vis[u] = 2;
}
void dfs2(int u, int dep, int belong, int id) {
blg[u] = belong;
x[u] = dep;
y[u] = id;
for (int v : g[u])
if (!inTour[v]) dfs2(v, dep + 1, belong, id);
}
int ans[N], num[N];
void solve(int u) {
for (Query &c : q[u])
if (x[u] + c.m < N) {
ans[c.id] -= num[x[u] + c.m];
}
num[x[u]]++;
for (int v : g[u])
if (!inTour[v]) solve(v);
for (Query &c : q[u])
if (x[u] + c.m < N) {
ans[c.id] += num[x[u] + c.m];
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
g[a[i]].push_back(i);
}
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs(i);
for (int i = 1; i <= cnt; i++) {
for (int j = 0; j < tour[i].size(); j++) {
dfs2(tour[i][j], 0, i, j);
f[tour[i][j]] = j;
}
}
for (int i = 1; i <= n; i++) block[blg[i]].push_back(i);
scanf("%d", &Q);
for (int i = 1; i <= Q; i++) {
long long m;
int d;
scanf("%lld%d", &m, &d);
if (!inTour[d])
q[d].push_back({m, 0, i});
else
qt[blg[d]].push_back({m, f[d], i});
}
for (int i = 1; i <= cnt; i++)
if (qt[i].size()) {
int p = 0;
std::sort(block[i].begin(), block[i].end(),
[](int a, int b) { return x[a] < x[b]; });
std::sort(qt[i].begin(), qt[i].end());
int mod = tour[i].size();
for (int j = 0; j < mod; j++) num[j] = 0;
for (Query &c : qt[i]) {
while (p < block[i].size() && x[block[i][p]] <= c.m) {
int v = block[i][p++];
num[(y[v] - x[v] % mod + mod) % mod]++;
}
int t = (c.x - c.m) % mod;
t = (t + mod) % mod;
ans[c.id] = num[t];
}
for (int v : tour[i]) solve(v);
}
for (int i = 1; i <= Q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200200;
int n, m, ans[N], g[N];
int deg[N], q[N], top, id[N];
vector<int> G[N], a[N], pre[N];
vector<pair<long long, int> > Q[N];
vector<pair<int, int> > b[N];
void SolveTree(int v) {
int big = -1, siz = G[v].size();
for (int i = 0; i < siz; i++) {
int u = G[v][i];
if (big == -1 || a[id[u]].size() > a[id[big]].size()) big = u;
}
if (big == -1)
id[v] = v;
else
id[v] = id[big];
int sz = a[id[v]].size();
for (int i = 0; i < siz; i++) {
int u = G[v][i];
if (u == big) continue;
int z = id[u];
reverse(a[z].begin(), a[z].end());
for (int i = 0; i < (int)a[z].size(); i++) a[id[v]][sz - 1 - i] += a[z][i];
}
a[id[v]].push_back(1);
siz = Q[v].size();
for (int i = 0; i < siz; i++) {
pair<long long, int> t = Q[v][i];
long long x = t.first;
if (x <= sz) ans[t.second] = a[id[v]][sz - x];
}
int u = g[v];
G[u].push_back(v);
deg[u]--;
if (!deg[u]) q[++top] = u;
}
void SolveCycle(vector<int> cycle) {
reverse(cycle.begin(), cycle.end());
int k = cycle.size();
for (int i = 0; i < k; i++) {
b[i].clear();
pre[i].clear();
}
for (int t = 0; t < k; t++) {
int v = cycle[t];
int big = -1, siz = G[v].size();
for (int i = 0; i < siz; i++) {
int u = G[v][i];
if (big == -1 || a[id[u]].size() > a[id[big]].size()) big = u;
}
if (big == -1)
id[v] = v;
else
id[v] = id[big];
int sz = a[id[v]].size();
for (int i = 0; i < siz; i++) {
int u = G[v][i];
if (u == big) continue;
int z = id[u];
reverse(a[z].begin(), a[z].end());
for (int i = 0; i < (int)a[z].size(); i++)
a[id[v]][sz - 1 - i] += a[z][i];
}
a[id[v]].push_back(1);
reverse(a[id[v]].begin(), a[id[v]].end());
for (int i = 0; i <= sz; i++) {
int p = (t + i) % k;
b[p].push_back(make_pair(i, a[id[v]][i]));
}
}
for (int i = 0; i < k; i++) {
sort(b[i].begin(), b[i].end());
pre[i].push_back(0);
int siz = b[i].size();
for (int s = 0; s < siz; s++) {
pair<int, int> t = b[i][s];
pre[i].push_back(pre[i].back() + t.second);
}
}
for (int t = 0; t < k; t++) {
int v = cycle[t];
int siz = Q[v].size();
for (int i = 0; i < siz; i++) {
pair<long long, int> z = Q[v][i];
long long x = z.first;
int xx;
if (x > (long long)1e7)
xx = x - ((x - (long long)1e7) / k) * k;
else
xx = x;
int p = (xx + t) % k;
int pos = lower_bound(b[p].begin(), b[p].end(), make_pair(xx, N)) -
b[p].begin();
ans[z.second] = pre[p][pos];
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &g[i]);
deg[g[i]]++;
}
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
long long x;
int v;
scanf("%lld%d", &x, &v);
Q[v].push_back(make_pair(x, i));
}
for (int i = 1; i <= n; i++)
if (!deg[i]) q[++top] = i;
for (int i = 1; i <= top; i++) {
int v = q[i];
SolveTree(v);
}
for (int v = 1; v <= n; v++) {
if (!deg[v]) continue;
vector<int> all;
int u = v;
do {
all.push_back(u);
u = g[u];
} while (u != v);
SolveCycle(all);
int siz = all.size();
for (int i = 0; i < siz; i++) deg[all[i]] = 0;
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 200000;
const int MAXQ = 100000;
int n;
int nxt[MAXN];
int nq;
long long qsteps[MAXQ];
int qidx[MAXQ];
int qans[MAXQ];
vector<vector<int>> cycs;
bool incyc[MAXN];
int state[MAXN];
vector<int> ch[MAXN];
vector<int> q[MAXN];
vector<int> res[MAXN];
int merge(int a, int b) {
if (((int)(res[a]).size()) < ((int)(res[b]).size())) swap(a, b);
for (int i = (0); i < (((int)(res[b]).size())); ++i) {
int k = ((int)(res[b]).size()) - i - 1;
res[a][((int)(res[a]).size()) - k - 1] += res[b][i];
}
res[b] = vector<int>();
return a;
}
int dfstree(int at) {
int ret = at;
res[ret].clear();
for (int i = (0); i < (((int)(ch[at]).size())); ++i) {
int to = ch[at][i];
int sub = dfstree(to);
ret = merge(ret, sub);
}
res[ret].push_back(1);
if (!incyc[at])
for (int i = (0); i < (((int)(q[at]).size())); ++i) {
int id = q[at][i];
qans[id] = qsteps[id] < ((int)(res[ret]).size())
? res[ret][((int)(res[ret]).size()) - qsteps[id] - 1]
: 0;
}
return ret;
}
void dfsadd(int at, int dep, vector<int> &lst) {
while (dep >= ((int)(lst).size())) lst.push_back(0);
++lst[dep];
for (int i = (0); i < (((int)(ch[at]).size())); ++i) {
int to = ch[at][i];
dfsadd(to, dep + 1, lst);
}
}
void solve() {
cycs.clear();
for (int i = (0); i < (n); ++i) state[i] = 0;
for (int i = (0); i < (n); ++i)
if (state[i] == 0) {
int at = i;
while (state[at] == 0) {
state[at] = 1;
at = nxt[at];
}
if (state[at] == 1) {
vector<int> cyc;
while (state[at] == 1) {
state[at] = 2;
cyc.push_back(at);
at = nxt[at];
}
cycs.push_back(cyc);
}
at = i;
while (state[at] == 1) {
state[at] = 2;
at = nxt[at];
}
}
for (int i = (0); i < (n); ++i) incyc[i] = false;
for (int i = (0); i < (((int)(cycs).size())); ++i)
for (int j = (0); j < (((int)(cycs[i]).size())); ++j)
incyc[cycs[i][j]] = true;
for (int i = (0); i < (n); ++i) q[i].clear();
for (int i = (0); i < (nq); ++i) q[qidx[i]].push_back(i);
for (int i = (0); i < (nq); ++i) qans[i] = -1;
for (int i = (0); i < (n); ++i) ch[i].clear();
for (int i = (0); i < (n); ++i)
if (!incyc[i]) ch[nxt[i]].push_back(i);
for (int i = (0); i < (n); ++i) res[i].clear();
for (int i = (0); i < (n); ++i)
if (incyc[i]) {
int sub = dfstree(i);
res[sub] = vector<int>();
}
for (int i = (0); i < (((int)(cycs).size())); ++i) {
vector<int> cyc = cycs[i];
vector<int> cnt;
for (int j = (0); j < (((int)(cyc).size())); ++j) {
int at = cyc[j];
dfsadd(at, ((int)(cyc).size()) - j, cnt);
for (int k = (0); k < (((int)(q[at]).size())); ++k) {
int id = q[at][k];
long long need = qsteps[id] + ((int)(cyc).size()) - j;
qans[id] = need < ((int)(cnt).size()) ? cnt[need] : 0;
}
}
for (int k = (((int)(cyc).size())); k < (((int)(cnt).size())); ++k)
cnt[k] += cnt[k - ((int)(cyc).size())];
for (int j = (0); j < (((int)(cyc).size())); ++j) {
int at = cyc[j];
for (int k = (0); k < (((int)(q[at]).size())); ++k) {
int id = q[at][k];
long long need = qsteps[id] - j;
if (need >= ((int)(cnt).size()))
need -= (need - ((int)(cnt).size()) + ((int)(cyc).size())) /
((int)(cyc).size()) * ((int)(cyc).size());
if (need >= 0) qans[id] += cnt[need];
}
}
}
}
void run() {
scanf("%d", &n);
for (int i = (0); i < (n); ++i) scanf("%d", &nxt[i]), --nxt[i];
scanf("%d", &nq);
for (int i = (0); i < (nq); ++i)
scanf("%lld%d", &qsteps[i], &qidx[i]), --qidx[i];
solve();
for (int i = (0); i < (nq); ++i) printf("%d\n", qans[i]);
}
int main() {
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
int n;
vector<int> a;
vector<vector<pair<long long, int> > > qs;
vector<int> res;
vector<int> used;
vector<vector<int> > gr;
vector<int> dfs(int v) {
vector<int> mas(1, 1);
for (int u : gr[v]) {
auto upd = dfs(u);
upd.push_back(0);
if (upd.size() > mas.size()) swap(upd, mas);
for (int i = 0; i < (int)upd.size(); i++) {
mas[(int)mas.size() - 1 - i] += upd[(int)upd.size() - 1 - i];
}
}
if (used[v] == 1) {
for (auto t : qs[v]) {
long long first = t.first;
if (first >= (int)mas.size()) {
res[t.second] = 0;
} else {
res[t.second] = mas[(int)mas.size() - 1 - first];
}
}
}
return mas;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
a.resize(n);
gr.resize(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i]--;
}
vector<vector<int> > cycles;
vector<int> pos(n, -1), num(n, -1);
used.resize(n, 0);
for (int i = 0; i < n; i++) {
if (used[i]) continue;
vector<int> mas;
int v = i;
while (!used[v]) {
used[v] = 1;
mas.push_back(v);
v = a[v];
}
vector<int> cycle;
while (mas.size() && mas.back() != v) {
cycle.push_back(mas.back());
mas.pop_back();
}
if (!mas.size()) {
continue;
}
cycle.push_back(mas.back());
reverse(cycle.begin(), cycle.end());
cycles.push_back(cycle);
for (int t = 0; t < (int)cycle.size(); t++) {
int v = cycle[t];
used[v] = 2;
num[v] = cycles.size() - 1;
pos[v] = t;
}
}
int q;
cin >> q;
res.resize(q);
qs.resize(n);
for (int i = 0; i < q; i++) {
long long m;
cin >> m;
int v;
cin >> v;
v--;
if (used[v] == 1) {
qs[v].push_back({m, i});
} else {
auto &cycle = cycles[num[v]];
int post = pos[v];
int sz = cycle.size();
int now_sh = m % sz;
int pos = (post - now_sh + sz) % sz;
int nxt = cycle[pos];
qs[nxt].push_back({m, i});
}
}
for (int i = 0; i < n; i++) {
if (used[i] == 1) {
gr[a[i]].push_back(i);
}
}
vector<vector<pair<int, int> > > cnts(n);
for (int i = 0; i < n; i++) {
if (used[i] == 2) {
auto t = dfs(i);
auto &cycle = cycles[num[i]];
int post = pos[i];
int sz = cycle.size();
for (int dist = 0; dist < (int)t.size(); dist++) {
int cnt = t[(int)t.size() - 1 - dist];
int now_sh = dist % sz;
int pos = (post - now_sh + sz) % sz;
int nxt = cycle[pos];
int now_dist = dist - dist % sz;
if (dist % sz) {
now_dist += sz;
}
cnts[nxt].push_back({dist, cnt});
}
}
}
for (int i = 0; i < n; i++) {
if (used[i] == 2) {
sort(cnts[i].begin(), cnts[i].end());
auto pref = cnts[i];
for (int i = 1; i < (int)pref.size(); i++) {
pref[i].second += pref[i - 1].second;
}
for (auto qt : qs[i]) {
long long first = qt.first, id = qt.second;
int pos =
lower_bound(pref.begin(), pref.end(),
make_pair((first > INF ? INF : (int)first), INF)) -
pref.begin();
res[id] = pref[pos - 1].second;
}
}
}
for (int i = 0; i < q; i++) {
cout << res[i] << "\n";
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
template <class T>
inline bool setmin(T &a, T b) {
if (a > b) return a = b, 1;
return 0;
}
template <class T>
inline bool setmax(T &a, T b) {
if (a < b) return a = b, 1;
return 0;
}
template <class T>
inline T fast(T a, T b, T mod) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
template <class T>
inline T russian(T a, T b, T mod) {
long long res = 0;
while (b) {
if (b & 1) res = (res + a) % mod;
a = (a + a) % mod;
b >>= 1;
}
return res;
}
template <class T>
istream &operator>>(istream &os, vector<T> &container) {
for (auto &u : container) os >> u;
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &container) {
for (auto &u : container) os << u << " ";
return os;
}
template <typename T>
inline T gcd(T a, T b) {
while (b) swap(a %= b, b);
return a;
}
const long long T = 1 << 20;
const long long INF = 1e9 + 7;
const long long mod = 998244353;
const long long BIG_INF = 1e18 + 7;
const long long N = 2e5 + 7;
const long long LOG = 19;
long long n, m, k, q;
vector<vector<long long>> G(N);
vector<vector<long long>> G2(N);
vector<vector<long long>> vec(N);
long long skoki[N][LOG];
long long ruch[N];
long long dist[N];
long long licznik_drzew = 1;
long long na_c[N];
long long dl_c[N];
long long przodek[N];
long long odw[N];
long long gl_w_drz;
vector<vector<long long>> drzewo[N];
long long pre;
long long numer[N];
long long gl_d[N];
long long pre_d[N];
long long post_d[N];
long long reszta(long long b, long long a) {
long long gl = gl_d[a] + b - 1;
if (gl >= (long long)(drzewo[numer[a]]).size()) return 0;
return (upper_bound((drzewo[numer[a]][gl]).begin(),
(drzewo[numer[a]][gl]).end(), post_d[a]) -
upper_bound((drzewo[numer[a]][gl]).begin(),
(drzewo[numer[a]][gl]).end(), pre_d[a])) /
2;
}
void rob_drzewo(long long st, long long cnt, long long gl = 1) {
if ((long long)(drzewo[cnt]).size() < gl)
drzewo[cnt].resize(drzewo[cnt].size() + 1);
numer[st] = cnt;
gl_d[st] = gl;
pre_d[st] = pre;
drzewo[cnt][gl - 1].push_back(pre++);
for (auto &u : G2[st]) {
if (na_c[u]) continue;
rob_drzewo(u, cnt, gl + 1);
}
post_d[st] = pre;
drzewo[cnt][gl - 1].push_back(pre++);
}
void bfs(long long st) {
queue<long long> kol;
pre = 1;
rob_drzewo(st, licznik_drzew++);
long long akt = st;
kol.push(st);
long long max_dist = 1;
dist[st] = 1;
while ((long long)(kol).size()) {
auto x = kol.front();
kol.pop();
if (dist[x] > max_dist) {
max_dist++;
akt = przodek[akt];
}
if (x != st) {
vec[akt].push_back(dist[x] - 1);
}
for (auto &u : G2[x]) {
if (na_c[u]) continue;
dist[u] = dist[x] + 1;
kol.push(u);
}
}
}
void rob_vec() {
for (long long i = 1; i <= n; i++)
if (na_c[i]) bfs(i);
for (long long i = 1; i <= n; i++) sort((vec[i]).begin(), (vec[i]).end());
}
long long znajdz_przodka(long long st, long long dl) {
long long dl2 = dl % dl_c[st];
long long pom = st;
for (long long i = 0; i < LOG; i++)
if (dl2 & (1 << i)) pom = skoki[pom][i];
return pom;
}
long long odp_cykl(long long dis, long long st) {
long long p = znajdz_przodka(st, dis);
return 1 +
(upper_bound((vec[p]).begin(), (vec[p]).end(), dis) - vec[p].begin());
}
void rob_skoki() {
for (long long i = 1; i <= n; i++) skoki[i][0] = przodek[i];
for (long long i = 1; i < LOG; i++)
for (long long j = 1; j <= n; j++)
skoki[j][i] = skoki[skoki[j][i - 1]][i - 1];
}
void oznacz_cykl(long long st) {
long long dl = 1;
long long pom = ruch[st];
while (pom != st) {
dl++;
pom = ruch[pom];
}
pom = ruch[st];
dl_c[st] = dl;
na_c[st] = true;
while (pom != st) {
dl_c[pom] = dl;
na_c[pom] = true;
pom = ruch[pom];
}
}
void dfs(long long st) {
odw[st] = 1;
if (odw[ruch[st]] == 1) {
przodek[ruch[st]] = st;
oznacz_cykl(ruch[st]);
} else if (odw[ruch[st]] == 2) {
} else {
przodek[ruch[st]] = st;
dfs(ruch[st]);
}
odw[st] = 2;
}
void policz_cykle() {
for (long long i = 1; i <= n; i++)
if (!odw[i]) dfs(i);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> ruch[i];
G[i].push_back(ruch[i]);
G2[ruch[i]].push_back(i);
}
policz_cykle();
rob_skoki();
rob_vec();
cin >> q;
while (q--) {
long long a, b;
cin >> a >> b;
if (na_c[b])
cout << odp_cykl(a, b) << '\n';
else
cout << reszta(a, b) << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
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 << 3) + (x << 1) + c - '0';
c = getchar();
}
return x * F;
}
int n, m, fa[200000 + 5], du[200000 + 5], ans[200000 + 5];
vector<pair<long long, int> > qry[200000 + 5];
vector<int> cnt[200000 + 5];
queue<int> Q;
void merge(vector<int> &A, vector<int> &B) {
if (A.size() < B.size()) swap(A, B);
for (int i = 1; i <= B.size(); i++) A[A.size() - i] += B[B.size() - i];
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
fa[i] = read();
du[fa[i]]++;
}
m = read();
for (int i = 1; i <= m; i++) {
long long x = read();
int y = read();
qry[y].push_back(pair<long long, int>(x, i));
}
for (int i = 1; i <= n; i++) {
if (!du[i]) Q.push(i);
cnt[i].push_back(1);
}
while (!Q.empty()) {
int x = Q.front();
Q.pop();
for (int i = 0; i < qry[x].size(); i++) {
long long t = qry[x][i].first;
int pos = qry[x][i].second;
if (t >= cnt[x].size())
ans[pos] = 0;
else
ans[pos] = cnt[x][cnt[x].size() - t - 1];
}
cnt[x].push_back(0);
merge(cnt[fa[x]], cnt[x]);
du[fa[x]]--;
if (!du[fa[x]]) Q.push(fa[x]);
}
for (int j = 1; j <= n; j++)
if (du[j]) {
int p = j, siz = 0;
vector<int> cyc, tmp;
do {
du[p] = 0;
tmp = cnt[p];
merge(cyc, tmp);
siz++;
cyc.push_back(0);
p = fa[p];
} while (p != j);
for (int i = 1; i + siz <= cyc.size(); i++)
cyc[cyc.size() - i - siz] += cyc[cyc.size() - i];
do {
merge(cyc, cnt[p]);
for (int i = 0; i < qry[p].size(); i++) {
long long t = cyc.size() - qry[p][i].first - 1;
int pos = qry[p][i].second;
if (t < 0) t = (t % siz + siz) % siz;
ans[pos] = cyc[t];
}
p = fa[p];
cyc.push_back(0);
} while (p != j);
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
int oo[1 + 200000 - 1], oj[1 + 200000 - 1];
int link(int o, int j) {
static int _ = 1;
oo[_] = o, oj[_] = j;
return _++;
}
int ae[200000], ca[200000], cb[200000], dd[200000], ta[200000], tb[200000], n,
n_;
void dfs(int i, int d) {
static int time;
int o;
ta[i] = time++;
for (o = ae[i]; o; o = oo[o]) {
int j = oj[o];
dfs(j, d + 1);
}
tb[i] = time;
}
int compare1(const void *a, const void *b) {
int i = *(int *)a;
int j = *(int *)b;
return dd[i] != dd[j] ? dd[i] - dd[j] : ta[i] - ta[j];
}
int compare2(const void *a, const void *b) {
int i = *(int *)a;
int j = *(int *)b;
return ca[i] != ca[j] ? ca[i] - ca[j]
: (cb[i] != cb[j] ? cb[i] - cb[j] : dd[i] - dd[j]);
}
int ii[200000], jj[200000];
int search1(long long d, int a) {
int lower = -1, upper = n;
while (upper - lower > 1) {
int h = (lower + upper) / 2, i = ii[h];
if (dd[i] < d || dd[i] == d && ta[i] <= a)
lower = h;
else
upper = h;
}
return lower + 1;
}
int search2(int a, int b, long long d) {
int lower = -1, upper = n_;
while (upper - lower > 1) {
int h = (lower + upper) / 2, j = jj[h];
if (ca[j] < a || ca[j] == a && (cb[j] < b || cb[j] == b && dd[j] <= d))
lower = h;
else
upper = h;
}
return lower + 1;
}
int main() {
static int aa[200000], ll[200000 + 1];
static char cycle[200000];
int m, q, i, d;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &aa[i]), aa[i]--;
scanf("%d", &q);
m = 0;
for (i = 0; i < n; i++) {
int j, a, b, l;
if (ca[i]) continue;
j = i, d = 0;
while (!ca[j]) {
ca[j] = -1;
j = aa[j], d++;
}
if (ca[j] == -1) {
a = ++m;
l = 0;
while (ca[j] == -1) {
ca[j] = -2;
l++;
cycle[j] = 1;
j = aa[j];
}
ll[a] = l, b = 0;
d -= l;
} else {
a = ca[j], l = ll[a], b = (cb[j] - d) % l;
if (b < 0) b += l;
d += dd[j];
}
j = i;
while (ca[j] < 0) {
ca[j] = a, cb[j] = b++ % l, dd[j] = cycle[j] ? 0 : d--;
j = aa[j];
}
}
for (i = 0; i < n; i++)
if (!cycle[i]) ae[aa[i]] = link(ae[aa[i]], i);
for (i = 0; i < n; i++)
if (cycle[i]) dfs(i, 0);
for (i = 0; i < n; i++) ii[i] = i;
qsort(ii, n, sizeof *ii, compare1);
for (i = 0; i < n; i++)
if (!cycle[i]) jj[n_++] = i;
qsort(jj, n_, sizeof *jj, compare2);
while (q--) {
long long k;
scanf("%lld%d", &k, &i), i--;
if (!cycle[i])
printf("%d\n",
search1(dd[i] + k, tb[i] - 1) - search1(dd[i] + k, ta[i] - 1));
else {
int a = ca[i], b = (cb[i] - k) % ll[a];
if (b < 0) b += ll[a];
printf("%d\n", 1 + search2(a, b, dd[i] + k) - search2(a, b, -1));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 6e5 + 7;
int Stack[N], vis[N], flag[N], ans[N], n, f[N], to[N], top = 0, dep[N];
vector<pair<long long, int> > g[N];
vector<int> p[N];
void dfs(int x) {
vis[x] = 1;
Stack[++top] = x;
if (vis[to[x]] == 1) {
for (int i = top; Stack[i] != to[x]; i--) flag[Stack[i]] = true;
flag[Stack[to[x]]] = true;
} else if (!vis[to[x]])
dfs(to[x]);
vis[x] = 2;
}
void dfs(int x, map<int, int> &m, int r) {
dep[x] = r;
for (int v : p[x])
if (!flag[v]) {
map<int, int> mm;
dfs(v, mm, r + 1);
if (mm.size() > m.size()) swap(mm, m);
for (auto u : mm) m[u.first] += u.second;
}
m[dep[x]]++;
if (flag[x]) return;
for (auto v : g[x]) {
if (v.first <= N) {
ans[v.second] = m[v.first + dep[x]];
} else
ans[v.second] = 0;
}
}
int lowbit(int x) { return x & -x; }
void add(int x, int r, int y, int len) {
if (r < len) f[r] += y, r += len;
for (int i = r / len; i * len + r % len <= n * 3; i += lowbit(i)) {
f[i * len + r % len] += y;
}
for (int v : p[x])
if (!flag[v]) add(v, r + 1, y, len);
}
int get(int r, int len) {
int y = f[r % len];
for (int i = r / len; i > 0; i -= lowbit(i)) y += f[i * len + r % len];
return y;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &to[i]);
p[to[i]].push_back(i);
}
int q;
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int u;
long long len;
scanf("%lld%d", &len, &u);
g[u].push_back({len, i});
}
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs(i);
for (int i = 1; i <= n; i++)
if (flag[i]) {
map<int, int> m;
dfs(i, m, 1);
}
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++)
if (!vis[i] && flag[i]) {
int len = 1, base = n;
for (int j = to[i]; j != i; j = to[j], len++)
;
add(i, 0 + base, 1, len);
vis[i] = true;
for (int j = to[i], k = 1; j != i; j = to[j], k++)
add(j, len - k + base, 1, len);
for (auto v : g[i]) {
int tmp;
if (v.first > n)
tmp = (v.first - n) % len + n;
else
tmp = v.first;
ans[v.second] = get(tmp + base, len);
}
for (int j = to[i], k = 1; j != i; j = to[j], k++) {
add(j, len - k + base, -1, len);
add(j, -k + base, 1, len);
vis[j] = true;
for (auto v : g[j]) {
int tmp;
if (v.first > n)
tmp = (v.first - n) % len + n;
else
tmp = v.first;
ans[v.second] = get(tmp - k + base, len);
}
}
add(i, 0 + base, -1, len);
for (int j = to[i], k = 1; j != i; j = to[j], k++)
add(j, -k + base, -1, len);
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
template <typename T>
void no(T s) {
cout << s;
exit(0);
}
void no() {
cout << "NO";
exit(0);
}
constexpr int maxn = 240000;
bool vis[maxn], inc[maxn], ins[maxn];
int A[maxn], ans[maxn], st[maxn], cn;
vector<int> c[maxn], G[maxn];
vector<pair<LL, int>> q[maxn];
vector<int> dn[maxn];
void DFS(int rt, int u, int d) {
if (d >= (int)dn[rt].size()) dn[rt].resize(d + 1);
dn[rt][d] += 1;
if (u != rt)
for (auto p : q[u])
if (d + p.first < (int)dn[rt].size())
ans[p.second] -= dn[rt][d + p.first];
for (int v : G[u])
if (not inc[v]) DFS(rt, v, d + 1);
if (u != rt)
for (auto p : q[u])
if (d + p.first < (int)dn[rt].size())
ans[p.second] += dn[rt][d + p.first];
}
vector<int> BIT[maxn];
void add(vector<int> &v, LL p, int x) {
for (; p < (int)v.size(); p += p & -p) v[p] += x;
}
int sum(vector<int> &v, LL p) {
int res = 0;
for (p = min(p, (LL)v.size() - 1); p; p -= p & -p) res += v[p];
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout << fixed << setprecision(20);
int n;
cin >> n;
for (int i = 1; i <= n; i += 1) {
cin >> A[i];
G[A[i]].push_back(i);
}
int Q;
cin >> Q;
for (int i = 1, y; i <= Q; i += 1) {
LL m;
cin >> m >> y;
q[y].push_back({m, i});
}
for (int i = 1; i <= n; i += 1)
if (not vis[i]) {
int stn = 0;
for (int p = i; not vis[p]; p = A[p]) {
st[stn += 1] = p;
ins[p] = true;
vis[p] = true;
if (ins[A[p]]) {
cn += 1;
for (int j = 1, ok = 0; j <= stn; j += 1) {
if (st[j] == A[p]) ok = 1;
if (ok) {
c[cn].push_back(st[j]);
inc[st[j]] = true;
}
}
break;
}
}
for (int i = 1; i <= stn; i += 1) ins[st[i]] = false;
}
for (int i = 1; i <= n; i += 1)
if (inc[i]) DFS(i, i, 0);
for (int i = 1; i <= cn; i += 1) {
int sz = 0, B = c[i].size();
for (int u : c[i]) sz = max(sz, (int)dn[u].size());
sz = sz / c[i].size() + 5;
for (int j = 0; j < (int)c[i].size(); j += 1) {
BIT[j].resize(sz);
fill(BIT[j].begin(), BIT[j].end(), 0);
}
for (int u : c[i]) {
for (int j = 0; j < (int)dn[u].size(); j += 1)
add(BIT[(B + j) % c[i].size()], (B + j) / c[i].size() + 1, dn[u][j]);
for (auto p : q[u])
ans[p.second] += sum(BIT[(B + p.first) % c[i].size()],
(B + p.first) / c[i].size() + 1);
B -= 1;
}
for (int j = 0; j < (int)c[i].size(); j += 1)
fill(BIT[j].begin(), BIT[j].end(), 0);
B = 1;
for (int x = c[i].size() - 1; ~x; x -= 1) {
int u = c[i][x];
for (auto p : q[u])
ans[p.second] += sum(BIT[(B + p.first) % c[i].size()],
(B + p.first) / c[i].size() + 1);
for (int j = 0; j < (int)dn[u].size(); j += 1)
add(BIT[(B + j) % c[i].size()], (B + j) / c[i].size() + 2, dn[u][j]);
B += 1;
}
}
for (int i = 1; i <= Q; i += 1) cout << ans[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
vector<int> tree[N];
int d[N];
int root[N];
vector<int> heiV[N];
vector<int> impV[N];
vector<int> cir[N];
int n, test;
int deg[N];
int gr[N];
int pos[N];
int a[N];
long long qu[N][2];
int quP[N];
int lab[N][2];
void initTree(int u, int st) {
static int n1 = 0;
lab[u][0] = ++n1;
root[u] = st;
for (auto v : tree[u]) {
d[v] = d[u] + 1;
initTree(v, st);
}
lab[u][1] = n1;
}
void BFS(int root) {
gr[root] = root;
cir[root].push_back(root);
pos[root] = 0;
while (1) {
int u = a[cir[root].back()];
if (u == root) break;
gr[u] = root;
pos[u] = cir[root].size();
cir[root].push_back(u);
}
}
int f[N];
int solveTree(long long x, int u) {
if (x + d[u] > N) return 0;
int layer = x + d[u];
auto iteR = upper_bound(heiV[layer].begin(), heiV[layer].end(), lab[u][1]);
auto iteL = lower_bound(heiV[layer].begin(), heiV[layer].end(), lab[u][0]);
return iteR - iteL;
}
int solveCir(long long x, int u) {
int grU = gr[u];
int n1 = cir[grU].size();
int pU = (pos[u] - x % n1 + n1) % n1;
return f[cir[grU][pU]];
}
int ans[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
cin >> test;
for (int i = 1; i <= test; i++) {
cin >> qu[i][0] >> qu[i][1];
}
for (int i = 1; i <= test; i++) quP[i] = i;
sort(quP + 1, quP + test + 1,
[&](int x, int y) { return qu[x][0] < qu[y][0]; });
for (int i = 1; i <= n; i++) deg[a[i]]++;
queue<int> q;
for (int i = 1; i <= n; i++)
if (deg[i] == 0) {
q.push(i);
}
while (!q.empty()) {
int u = q.front();
q.pop();
tree[a[u]].push_back(u);
deg[a[u]]--;
if (!deg[a[u]]) q.push(a[u]);
}
for (int i = 1; i <= n; i++)
if (deg[i] > 0) {
initTree(i, i);
}
for (int i = 1; i <= n; i++) {
heiV[d[i]].push_back(lab[i][0]);
impV[d[i]].push_back(i);
}
for (int i = 0; i < N; i++) {
sort(heiV[i].begin(), heiV[i].end());
}
memset(gr, -1, sizeof(gr));
memset(pos, -1, sizeof(pos));
for (int i = 1; i <= n; i++)
if (deg[i] > 0 && gr[i] == -1) {
BFS(i);
}
int depth = 0;
for (int i = 1; i <= test; i++) {
int curQ = quP[i];
while (depth <= min(1LL * N - 1, qu[curQ][0])) {
for (auto u : impV[depth]) {
int tarU = root[u];
int grU = gr[tarU];
int pU = pos[tarU];
long long n1 = cir[grU].size();
int upgrX = cir[grU][(pU - depth % n1 + n1) % n1];
f[upgrX]++;
}
depth++;
}
if (deg[qu[curQ][1]] == 0) {
ans[curQ] = solveTree(qu[curQ][0], qu[curQ][1]);
} else {
ans[curQ] = solveCir(qu[curQ][0], qu[curQ][1]);
}
}
for (int i = 1; i <= test; i++) cout << ans[i] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 2e5;
struct DSU {
int fa[Maxn + 5];
void init(int n) {
for (int i = 1; i <= n; i++) fa[i] = i;
}
int find(int u) { return u == fa[u] ? u : fa[u] = find(fa[u]); }
bool unite(int u, int v) {
u = find(u), v = find(v);
if (u == v) return false;
fa[u] = v;
return true;
}
};
struct Query {
int id, typ;
long long m;
Query() {}
Query(int _typ, int _id, long long _m) { typ = _typ, id = _id, m = _m; }
bool operator<(const Query &rhs) const {
return m == rhs.m ? typ > rhs.typ : m > rhs.m;
}
};
struct Edge {
int to;
Edge *nxt;
};
int N, A[Maxn + 5];
DSU s;
Edge pool[Maxn * 2 + 5];
Edge *G[Maxn + 5], *ecnt = &pool[0];
inline void addedge(int u, int v) {
Edge *p = ++ecnt;
p->to = v, p->nxt = G[u];
G[u] = p;
}
vector<int> circles[Maxn + 5];
int cnt_circle;
bool on_circle[Maxn + 5];
bool DFS(int u, int tp) {
if (u == tp) {
on_circle[u] = true;
circles[cnt_circle].push_back(u);
return true;
}
for (Edge *p = G[u]; p != NULL; p = p->nxt) {
int v = p->to;
if (!DFS(v, tp)) continue;
on_circle[u] = true, circles[cnt_circle].push_back(u);
return true;
}
return false;
}
vector<Query> Q[Maxn + 5];
int len, cnt[Maxn + 5];
priority_queue<Query> q;
int mxdep;
int ans[Maxn + 5], res[Maxn + 5];
inline int nxt(int x) { return x == len - 1 ? 0 : x + 1; }
void DFS(int u, int dep, int cirid, int pos) {
q.push(Query(-1, circles[cirid][pos], dep));
mxdep = max(mxdep, dep);
if (!on_circle[u])
for (int i = 0; i < (int)Q[u].size(); i++)
if (dep + Q[u][i].m <= Maxn) ans[Q[u][i].id] -= cnt[dep + Q[u][i].m];
cnt[dep]++;
for (Edge *p = G[u]; p != NULL; p = p->nxt) {
int v = p->to;
if (on_circle[v]) continue;
DFS(v, dep + 1, cirid, nxt(pos));
}
if (!on_circle[u])
for (int i = 0; i < (int)Q[u].size(); i++)
if (dep + Q[u][i].m <= Maxn) ans[Q[u][i].id] += cnt[dep + Q[u][i].m];
}
int main() {
scanf("%d", &N);
s.init(N);
for (int i = 1; i <= N; i++) {
scanf("%d", &A[i]);
if (!s.unite(A[i], i)) {
cnt_circle++, DFS(i, A[i]);
reverse(circles[cnt_circle].begin(), circles[cnt_circle].end());
}
addedge(A[i], i);
}
int _;
scanf("%d", &_);
for (int i = 1; i <= _; i++) {
long long m;
int y;
scanf("%lld %d", &m, &y);
Q[y].push_back(Query(0, i, m));
}
for (int i = 1; i <= cnt_circle; i++) {
len = (int)circles[i].size();
for (int j = 0; j < len; j++) {
int u = circles[i][j];
mxdep = 0;
DFS(u, 0, i, j);
for (int k = 0; k <= mxdep; k++) cnt[k] = 0;
for (int k = 0; k < (int)Q[u].size(); k++) {
int v = circles[i][(j + Q[u][k].m) % len];
q.push(Query(Q[u][k].id, v, Q[u][k].m));
}
}
while (!q.empty()) {
Query tmp = q.top();
q.pop();
if (tmp.typ == -1)
res[tmp.id]++;
else
ans[tmp.typ] = res[tmp.id];
}
}
for (int i = 1; i <= _; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Vi = vector<int>;
using Pii = pair<int, int>;
template <class t, class u, class... w>
auto operator<<(t& o, u a) -> decltype(a.print(), o) {
o << "{";
a.print();
o << "}";
return o;
};
template <class t, class u, class... w>
auto operator<<(t& o, u a) -> decltype(a.second, o) {
o << "(" << a.first << ", " << a.second << ")";
return o;
};
template <class t, class u, class... w>
auto operator<<(t& o, u a) -> decltype((a).begin(), (a).end(), o) {
o << "[";
auto d = "";
for (auto i : a) (o << d << i, d = ", ");
o << "]";
return o;
};
void DD(...) {}
template <class t, class u, class... w>
void DD(t s, u a, w... k) {
int b = 44;
while (*s && *s != b) {
b += (*s == 40 ? 50 : *s == 41 ? -50 : 0);
cerr << *s++;
}
cerr << ": " << a << *s++;
DD(s, k...);
}
template <class t, class u, class... w>
vector<t> span(const t* a, u n) {
return {a, a + n};
}
struct Fenwick {
Vi s;
Fenwick(int n = 0) : s(n, 0) {}
void modify(int i, int v) {
for (; i < int((s).size()); i |= i + 1) s[i] += v;
}
int query(int i) {
int v = 0;
for (; i > 0; i &= i - 1) v += s[i - 1];
return v;
}
};
vector<Vi> G;
Vi nxt, seen, ans;
vector<vector<pair<ll, int>>> queries;
int tot;
vector<Fenwick> rests;
int add;
Vi kek;
void upd(int i, int k) {
i -= add;
int r = i % int((rests).size());
int d = i / int((rests).size());
rests[r].modify(d, k);
}
int query(int dist) {
dist -= add;
int r = dist % int((rests).size());
int d = dist / int((rests).size());
return rests[r].query(d + 1);
}
void dfs(int v, int d) {
if (seen[v] != 2) {
for (auto& q : (queries[v])) {
ll s = q.first + d;
if (s < int((kek).size())) ans[q.second] -= kek[s];
}
}
kek[d]++;
tot++;
for (auto& e : (G[v])) {
if (seen[e] == 2) continue;
seen[e] = 3;
dfs(e, d + 1);
}
if (seen[v] != 2) {
for (auto& q : (queries[v])) {
ll s = q.first + d;
if (s < int((kek).size())) ans[q.second] += kek[s];
}
}
}
void dfsCount(int v, int d, int m) {
upd(d, m);
for (auto& e : (G[v])) {
if (seen[e] == 2) continue;
dfsCount(e, d + 1, m);
}
}
void process(int root) {
Vi cycle;
while (seen[root] != 2) {
cycle.push_back(root);
seen[root] = 2;
root = nxt[root];
}
tot = 0;
for (auto& v : (cycle)) {
dfs(v, 0);
}
int lim = tot * 3 + 3;
lim = lim / int((cycle).size()) + 2;
add = 0;
rests.resize(int((cycle).size()));
reverse((cycle).begin(), (cycle).end());
for (auto& r : (rests)) {
r = {lim};
}
for (int i = (0); i < (int((cycle).size())); i++) {
dfsCount(cycle[i], i, 1);
}
for (int i = (0); i < (int((cycle).size())); i++) {
for (auto& q : (queries[cycle[i]])) {
ll tmp = q.first;
if (tmp > tot * 2) {
tmp = (tmp - tot * 2) % int((cycle).size()) + tot * 2;
}
ans[q.second] = query(int(tmp));
}
dfsCount(cycle[i], 0, -1);
add--;
dfsCount(cycle[i], int((cycle).size()) - 1, 1);
}
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(18);
int n;
cin >> n;
nxt.resize(n);
G.resize(n);
queries.resize(n);
kek.resize(n + 5);
for (int i = (0); i < (n); i++) {
cin >> nxt[i];
nxt[i]--;
G[nxt[i]].push_back(i);
}
int q;
cin >> q;
for (int i = (0); i < (q); i++) {
ll m;
int second;
cin >> m >> second;
second--;
queries[second].push_back({m, i});
}
seen.resize(n);
ans.resize(q);
for (int i = (0); i < (n); i++) {
if (seen[i]) continue;
int v = i;
while (!seen[v]) {
seen[v] = 1;
v = nxt[v];
}
process(v);
}
for (auto& a : (ans)) {
cout << a << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 2 * (int)1e5;
const int Q = 1e5;
vector<pair<ll, int>> ques[N];
vector<int> deps[N];
int ins[N];
int res[Q];
void combine(vector<int>& a, vector<int>& b) {
if (a.size() < b.size()) swap(a, b);
for (int j = 1; j <= b.size(); ++j) {
a[a.size() - j] += b[b.size() - j];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> as(n);
for (int i = 0; i < n; ++i) {
cin >> as[i];
--as[i];
++ins[as[i]];
}
int q;
cin >> q;
for (int j = 0; j < q; ++j) {
ll m;
int y;
cin >> m >> y;
ques[y - 1].emplace_back(m, j);
}
vector<int> que;
for (int i = 0; i < n; ++i) {
deps[i] = {1};
if (ins[i] == 0) que.push_back(i);
}
for (int j = 0; j < que.size(); ++j) {
int i = que[j];
for (auto pr : ques[i]) {
ll m = pr.first;
if (deps[i].size() <= m)
res[pr.second] = 0;
else
res[pr.second] = deps[i][deps[i].size() - (m + 1)];
}
deps[i].push_back(0);
combine(deps[as[i]], deps[i]);
--ins[as[i]];
if (ins[as[i]] == 0) que.push_back(as[i]);
deps[i].clear();
deps[i].shrink_to_fit();
}
for (int i = 0; i < n; ++i) {
if (ins[i] == 0) continue;
int len = 0;
vector<int> cur;
for (int j = i;;) {
ins[j] = 0;
++len;
vector<int> bu = deps[j];
combine(cur, bu);
cur.push_back(0);
j = as[j];
if (j == i) break;
}
for (int t = 1; t + len <= cur.size(); ++t) {
cur[cur.size() - t - len] += cur[cur.size() - t];
}
for (int j = i;;) {
combine(cur, deps[j]);
for (auto pr : ques[j]) {
ll ind = (ll)cur.size() - (pr.first + 1);
if (ind < 0) {
ind %= len;
if (ind < 0) ind += len;
}
res[pr.second] = cur[ind];
}
cur.push_back(0);
j = as[j];
if (j == i) break;
}
}
for (int i = 0; i < q; ++i) cout << res[i] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
int n, m;
int fa[N + 3], deg[N + 3], ans[N + 3];
vector<pair<long long, int> > qry[N + 3];
vector<int> cnt[N + 3];
inline long long QRead() {
long long resu = 0;
char c = (char)getchar();
while ('0' > c || c > '9') c = (char)getchar();
while ('0' <= c && c <= '9')
resu = (resu << 1) + (resu << 3) + c - '0', c = (char)getchar();
return resu;
}
void Merge(vector<int> &A, vector<int> &B) {
if (A.size() < B.size()) swap(A, B);
for (int i = 1; i <= B.size(); i++) A[A.size() - i] += B[B.size() - i];
}
int main() {
n = (int)QRead();
for (int i = 1; i <= n; i++) {
fa[i] = (int)QRead();
deg[fa[i]]++;
}
m = (int)QRead();
for (int i = 1; i <= m; i++) {
long long x = QRead();
int y = (int)QRead();
qry[y].push_back(make_pair(x, i));
}
queue<int> lev;
for (int i = 1; i <= n; i++) {
if (!deg[i]) lev.push(i);
cnt[i].push_back(1);
}
while (!lev.empty()) {
int u = lev.front();
lev.pop();
for (int i = 0; i < (int)qry[u].size(); i++) {
pair<long long, int> now = qry[u][i];
if (now.first >= (int)cnt[u].size())
ans[now.second] = 0;
else
ans[now.second] = cnt[u][cnt[u].size() - 1 - now.first];
}
cnt[u].push_back(0);
Merge(cnt[fa[u]], cnt[u]);
deg[fa[u]]--;
if (!deg[fa[u]]) lev.push(fa[u]);
}
for (int u = 1; u <= n; u++)
if (deg[u]) {
int cop = u, siz = 0;
vector<int> cir;
do {
deg[cop] = 0;
vector<int> cpy = cnt[cop];
Merge(cir, cpy);
siz++;
cir.push_back(0);
cop = fa[cop];
} while (cop != u);
for (int i = 1; i + siz <= cir.size(); i++)
cir[cir.size() - i - siz] += cir[cir.size() - i];
do {
Merge(cir, cnt[cop]);
for (int i = 0; i < qry[cop].size(); i++) {
long long qm = qry[cop][i].first;
int id = qry[cop][i].second;
qm = cir.size() - 1 - qm;
if (qm < 0) qm = (qm % siz + siz) % siz;
ans[id] = cir[qm];
}
cop = fa[cop];
cir.push_back(0);
} while (cop != u);
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
int n, m;
int fa[N + 3], deg[N + 3], ans[N + 3];
vector<pair<long long, int> > G[N + 3];
vector<int> cnt[N + 3];
void Merge(vector<int> &A, vector<int> &B) {
if (A.size() < B.size()) swap(A, B);
for (int i = 1; i <= B.size(); i++) A[A.size() - i] += B[B.size() - i];
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &fa[i]);
deg[fa[i]]++;
}
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
long long x;
int y;
scanf("%lld%d", &x, &y);
G[y].push_back(make_pair(x, i));
}
queue<int> Q;
for (int i = 1; i <= n; i++) {
if (!deg[i]) Q.push(i);
cnt[i].push_back(1);
}
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (int i = 0; i < (int)G[u].size(); i++) {
pair<long long, int> now = G[u][i];
if (now.first >= (int)cnt[u].size())
ans[now.second] = 0;
else
ans[now.second] = cnt[u][cnt[u].size() - 1 - now.first];
}
cnt[u].push_back(0);
Merge(cnt[fa[u]], cnt[u]);
deg[fa[u]]--;
if (!deg[fa[u]]) Q.push(fa[u]);
}
for (int u = 1; u <= n; u++)
if (deg[u]) {
int cop = u, siz = 0;
vector<int> cir;
do {
deg[cop] = 0;
vector<int> cpy = cnt[cop];
Merge(cir, cpy);
siz++;
cir.push_back(0);
cop = fa[cop];
} while (cop != u);
for (int i = 1; i + siz <= cir.size(); i++)
cir[cir.size() - i - siz] += cir[cir.size() - i];
do {
Merge(cir, cnt[cop]);
for (int i = 0; i < G[cop].size(); i++) {
long long qm = G[cop][i].first;
int id = G[cop][i].second;
qm = cir.size() - 1 - qm;
if (qm < 0) qm = (qm % siz + siz) % siz;
ans[id] = cir[qm];
}
cop = fa[cop];
cir.push_back(0);
} while (cop != u);
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using lint = long long;
using pii = pair<int, int>;
const int N = 200005;
int n, q, a[N], ind[N], ps[N], pe[N], pc, dep[N], cyc[N], cn[N], csz[N], cc;
vector<int> e[N], dv[N];
vector<vector<vector<int>>> cv;
queue<int> qq;
void f(int first, int second, int z, int u, int v, int w) {
dep[first] = z;
ps[first] = ++pc;
dv[dep[first]].push_back(pc);
cv[u][(v + dep[first]) % w].push_back(dep[first]);
for (int i : e[first])
if (i != first) f(i, first, z + 1, u, v, w);
pe[first] = pc;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
ind[a[i]]++;
}
for (int i = 1; i <= n; i++)
if (!ind[i]) qq.push(i);
while (!qq.empty()) {
int first = qq.front();
qq.pop();
e[a[first]].push_back(first);
if (--ind[a[first]] == 0) qq.push(a[first]);
}
cv.push_back(vector<vector<int>>());
for (int i = 1; i <= n; i++)
if (ind[i]) {
if (!cyc[i]) {
cyc[i] = ++cc;
cv.push_back(vector<vector<int>>());
cv[cc].push_back(vector<int>());
int zz = 1;
for (int j = a[i]; j != i; j = a[j], zz++) {
cyc[j] = cc;
cv[cc].push_back(vector<int>());
}
int z = zz;
csz[i] = zz;
cn[i] = --z;
for (int j = a[i]; j != i; j = a[j]) {
csz[j] = zz;
cn[j] = --z;
}
}
f(i, 0, 0, cyc[i], cn[i], csz[i]);
}
for (auto &i : cv)
for (auto &j : i) sort(j.begin(), j.end());
cin >> q;
for (; q--;) {
ll m;
int second;
cin >> m >> second;
if (cyc[second]) {
int idx = (cn[second] + m) % csz[second];
m = min(m, ll(1e6));
auto &cur = cv[cyc[second]][idx];
cout << int(upper_bound(cur.begin(), cur.end(), m) - cur.begin()) << '\n';
} else {
ll t = dep[second] + m;
if (t >= N)
cout << "0\n";
else
cout << int(upper_bound(dv[t].begin(), dv[t].end(), pe[second]) -
lower_bound(dv[t].begin(), dv[t].end(), ps[second]))
<< '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int add(int _a, int _b) {
_a = (_a + 1000000007) % 1000000007;
_b = (_b + 1000000007) % 1000000007;
return (_a + _b) % 1000000007;
}
int mul(int _a, int _b) {
_a = (_a + 1000000007) % 1000000007;
_b = (_b + 1000000007) % 1000000007;
return ((long long int)((long long int)_a * (long long int)_b)) % 1000000007;
}
int n, ara[2 * 100010], sccCnt = 0, sccRoot[2 * 100010], sccNo[2 * 100010],
rootNo[2 * 100010], sbtr[2 * 100010], ht[2 * 100010], q,
global[2 * 100010], position[2 * 100010],
sol[2 * 100010];
const int thresh = 200005;
bool inCycle[2 * 100010];
vector<int> adj[2 * 100010], rev[2 * 100010], scc[2 * 100010], cum[2 * 100010];
vector<int> topo, treeRoot, qlist[2 * 100010], vrtx;
pair<long long int, int> query[2 * 100010];
bool vis[2 * 100010];
void input() {
int i, j;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &ara[i]);
if (ara[i] == i) {
inCycle[ara[i]] = true;
}
adj[ara[i]].push_back(i);
rev[i].push_back(ara[i]);
}
}
void dfs0(int src) {
int i, j;
vis[src] = true;
for (i = 0; i < adj[src].size(); i++) {
int u = adj[src][i];
if (!vis[u]) {
dfs0(u);
}
}
topo.push_back(src);
}
void dfs1(int src) {
int i, j;
vis[src] = true;
scc[sccCnt].push_back(src);
sccNo[src] = sccCnt;
for (i = 0; i < rev[src].size(); i++) {
int u = rev[src][i];
if (!vis[u]) {
dfs1(u);
}
}
}
void dfs2(int src, int rt) {
int i, j;
vis[src] = true;
sbtr[src] = 1;
rootNo[src] = rt;
vrtx.push_back(src);
for (i = 0; i < adj[src].size(); i++) {
int u = adj[src][i];
if (!vis[u]) {
dfs2(u, rt), sbtr[src] += sbtr[u];
}
}
}
void dfs3(int src, int rt, int d, int len, int idx) {
int i, j;
vis[src] = true;
ht[src] = d;
cum[idx][ht[src]]++;
for (i = 0; i < adj[src].size(); i++) {
int u = adj[src][i];
if (!vis[u]) {
if (inCycle[u]) {
dfs3(u, u, d + 1, len, idx);
} else {
dfs3(u, rt, d + 1, len, idx);
}
}
}
}
void dsu(int src, int par, bool keep) {
int i, j, u, bg = -1, mx = -1, v;
long long int d;
for (i = 0; i < adj[src].size(); i++) {
u = adj[src][i];
if (u != par && u != rootNo[src]) {
if (sbtr[u] > mx) {
mx = sbtr[u], bg = u;
}
}
}
for (i = 0; i < adj[src].size(); i++) {
u = adj[src][i];
if (u != par && u != rootNo[src] && u != bg) {
dsu(u, src, false);
}
}
if (mx != -1) {
dsu(bg, src, true);
}
global[ht[src]]++;
for (i = 0; i < adj[src].size(); i++) {
u = adj[src][i];
if (u != par && u != rootNo[src] && u != bg) {
for (j = position[u]; j <= position[u] + sbtr[u] - 1; j++) {
v = vrtx[j];
global[ht[v]]++;
}
}
}
for (i = 0; i < qlist[src].size(); i++) {
int idx = qlist[src][i];
d = query[idx].first;
if ((long long int)ht[src] + d <= (long long int)thresh) {
sol[idx] += global[(long long int)ht[src] + d];
}
}
if (!keep) {
for (j = position[src]; j <= position[src] + sbtr[src] - 1; j++) {
v = vrtx[j];
global[ht[v]]--;
}
}
}
void solve() {
int i, j, u, len, r, dis, sz;
long long int d;
for (i = 1; i <= n; i++) {
if (!vis[i]) {
dfs0(i);
}
}
reverse(topo.begin(), topo.end());
for (i = 1; i <= n; i++) {
vis[i] = false;
}
for (i = 0, sccCnt = 0; i < topo.size(); i++) {
if (!vis[topo[i]]) {
dfs1(topo[i]);
sccRoot[sccCnt] = topo[i];
sccCnt++;
}
}
for (i = 0; i < sccCnt; i++) {
if (scc[i].size() >= 2) {
for (j = 0; j < scc[i].size(); j++) {
inCycle[scc[i][j]] = true;
}
}
}
for (i = 1; i <= n; i++) {
vis[i] = false;
}
for (i = 0; i < sccCnt; i++) {
if (scc[i].size() >= 2 || (scc[i].size() == 1 && inCycle[scc[i][0]])) {
treeRoot.push_back(sccRoot[i]);
dfs2(sccRoot[i], sccRoot[i]);
} else if (scc[i].size() == 1 && rev[scc[i][0]].size() == 0) {
treeRoot.push_back(scc[i][0]);
dfs2(scc[i][0], scc[i][0]);
}
}
for (i = 0; i < vrtx.size(); i++) {
u = vrtx[i], position[u] = i;
}
for (i = 1; i <= n; i++) {
vis[i] = false;
}
for (i = 0; i < treeRoot.size(); i++) {
u = treeRoot[i];
if (inCycle[u]) {
cum[u].resize(sbtr[u] + 1);
len = scc[sccNo[u]].size();
dfs3(u, u, 0, len, u);
for (j = 0; j < cum[u].size(); j++) {
cum[u][j] = j - len < 0 ? cum[u][j] : cum[u][j] + cum[u][j - len];
}
}
}
scanf("%d", &q);
for (i = 0; i < q; i++) {
scanf("%lld %d", &query[i].first, &query[i].second);
qlist[query[i].second].push_back(i);
u = query[i].second;
d = query[i].first;
if (inCycle[u]) {
r = rootNo[u];
len = scc[sccNo[r]].size();
dis = len - ht[u];
d -= (long long int)dis;
sz = cum[r].size();
if (d >= sz) {
d = d - ((d - (long long int)sz + (long long int)len) /
(long long int)len) *
(long long int)len;
}
if (d < 0) {
continue;
}
sol[i] += cum[r][d];
}
}
for (i = 0; i < treeRoot.size(); i++) {
u = treeRoot[i];
dsu(u, -1, false);
}
for (i = 0; i < q; i++) {
printf("%d", sol[i]);
puts("");
}
}
int main() {
input();
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<vector<int>> f[200001];
int l[200001], cc;
bool vis[200001];
int g[200001], h[200001], c[200001], p[200001];
bool dfs_cyc(int u, int d) {
if (vis[u]) {
if (!c[u]) {
c[u] = ++cc;
l[c[u]] = d - p[u];
h[u] = 0;
p[u] = 0;
return true;
} else
return false;
} else {
p[u] = d;
vis[u] = 1;
bool flg = dfs_cyc(g[u], d + 1);
c[u] = c[g[u]];
p[u] = p[g[u]] ? p[g[u]] - 1 : l[c[u]] - 1;
if (!flg)
h[u] = h[g[u]] + 1;
else
h[u] = 0;
if (!h[u])
return p[u];
else
return false;
}
}
int ls[200001 * 20], rs[200001 * 20], st[200001 * 20], rt[200001], nc;
int cp(int q) {
int p = ++nc;
ls[p] = ls[q];
rs[p] = rs[q];
st[p] = st[q];
return p;
}
void modify(int x, int v, int p, int lb, int rb) {
st[p] += v;
if (lb + 1 == rb)
return;
else {
int mid = (lb + rb) >> 1;
if (x < mid)
modify(x, v, ls[p] = cp(ls[p]), lb, mid);
else
modify(x, v, rs[p] = cp(rs[p]), mid, rb);
}
}
int query(int x, int lp, int rp, int lb, int rb) {
if (x >= rb) return 0;
if (lb + 1 == rb)
return st[rp] - st[lp];
else {
int mid = (lb + rb) >> 1;
if (x < mid)
return query(x, ls[lp], ls[rp], lb, mid);
else
return query(x, rs[lp], rs[rp], mid, rb);
}
}
vector<int> gt[200001];
int dlb[200001], drb[200001], dfc;
void dfs_dfn(int u) {
dlb[u] = ++dfc;
modify(h[u], 1, rt[dfc] = cp(rt[dfc - 1]), 0, n);
for (int v : gt[u]) dfs_dfn(v);
drb[u] = dfc;
}
int main(void) {
scanf("%d", &n);
for (int u = 1; u <= n; ++u) scanf("%d", g + u);
for (int u = 1; u <= n; ++u) dfs_cyc(u, 1);
for (int w = 1; w <= cc; ++w) f[w].resize(l[w]);
for (int u = 1; u <= n; ++u) {
f[c[u]][p[u]].push_back(h[u]);
if (h[u]) gt[g[u]].push_back(u);
}
for (int w = 1; w <= cc; ++w)
for (int p = 0; p != l[w]; ++p) sort(f[w][p].begin(), f[w][p].end());
for (int u = 1; u <= n; ++u)
if (!h[u]) dfs_dfn(u);
int q;
scanf("%d", &q);
while (q--) {
long long m;
int u;
scanf("%lld%d", &m, &u);
int w = c[u], ans;
if (!h[u]) {
int t = (p[u] - (m % l[w]) + l[w]) % l[w];
int d = m % l[w];
ans = upper_bound(f[w][t].begin(), f[w][t].end(), m) - f[w][t].begin();
} else {
ans = query(m + h[u], rt[dlb[u] - 1], rt[drb[u]], 0, n);
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, M = 998244353, INF = 0x3f3f3f3f;
void Main();
bool fastio = 0;
void print() { cout << '\n'; }
template <typename T, typename... U>
void print(const T& x, const U&... y) {
((sizeof...(y) == 0) ? (cout << x) : (cout << x << ' '));
print(y...);
}
template <typename T>
void print(const T& a, int l, int r, char c) {
for (int i = l; i <= r; ++i) {
cout << a[i];
if (i == r)
cout << '\n';
else
cout << c;
}
}
void input() {}
template <typename T, typename... U>
void input(T& x, U&... y) {
cin >> x;
input(y...);
}
template <typename T>
void input(T& a, int l, int r, bool f) {
for (int i = l; i <= r; ++i) cin >> a[i];
}
template <typename T>
void Max(T& a, T b) {
a < b ? a = b : 1;
}
template <typename T>
void Min(T& a, T b) {
a > b ? a = b : 1;
}
template <typename T>
void Add(T& a, T b) {
a += b, a > M ? a -= M : 1;
}
int main(int argc, char** argv) {
ios::sync_with_stdio(0), cin.tie(0);
cout << setprecision(10) << fixed;
Main();
}
int fa[N], deg[N], ans[N];
vector<pair<long long, int>> Q[N];
vector<int> dp[N];
void merge(vector<int>& a, vector<int>& b) {
if (a.size() < b.size()) swap(a, b);
for (int i = 0; i < (int)b.size(); ++i)
a[a.size() - 1 - i] += b[b.size() - 1 - i];
}
void Main() {
int n, q;
input(n);
for (int i = 1; i <= n; ++i) {
input(fa[i]);
++deg[fa[i]];
}
queue<int> leaves;
input(q);
for (long long i = 1, y, m; i <= q; ++i)
input(m, y), Q[y].push_back(make_pair(m, (int)i));
for (int i = 1; i <= n; ++i) {
if (deg[i] == 0) leaves.push(i);
dp[i].push_back(1);
}
while (!leaves.empty()) {
int v = leaves.front();
leaves.pop();
for (auto x : Q[v])
if (x.first < (long long)dp[v].size())
ans[x.second] = dp[v][dp[v].size() - 1 - x.first];
dp[v].push_back(0);
merge(dp[fa[v]], dp[v]);
if (--deg[fa[v]] == 0) leaves.push(fa[v]);
}
for (int i = 1; i <= n; ++i)
if (deg[i] != 0) {
vector<int> v;
int j = i, sz = 0;
do {
deg[j] = 0;
auto x = dp[j];
merge(v, x);
v.push_back(0);
j = fa[j];
++sz;
} while (j != i);
for (int k = 0; k + sz < (int)v.size(); ++k)
v[v.size() - 1 - k - sz] += v[v.size() - 1 - k];
do {
merge(v, dp[j]);
for (auto x : Q[j]) {
x.first = (long long)v.size() - x.first - 1;
if (x.first < 0) {
x.first %= sz;
if (x.first) {
x.first += sz;
}
}
ans[x.second] = v[x.first];
}
j = fa[j];
v.push_back(0);
} while (j != i);
}
print(ans, 1, q, '\n');
}
|
#include <bits/stdc++.h>
const int N = 200005;
using std::vector;
vector<vector<int>> dis[N];
vector<int> dis2[N], e[N];
int deep[N], in[N], out[N], siz[N], c[N], d[N], a[N], idn, cnt, n, x, id[N], Q;
long long m;
std::queue<int> q;
void dfs(int col, int x, int dep, int cn) {
in[x] = ++idn;
deep[x] = dep;
dis2[dep].push_back(idn);
dis[col][(dep + cn) % siz[col]].push_back(dep);
for (auto u : e[x]) dfs(col, u, dep + 1, cn);
out[x] = idn;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
d[a[i]]++;
}
for (int i = 1; i <= n; i++)
if (!d[i]) q.push(i);
while (!q.empty()) {
int x = q.front();
q.pop();
e[a[x]].push_back(x);
if (!(--d[a[x]])) q.push(a[x]);
}
for (int i = 1; i <= n; i++)
if (d[i]) {
if (!c[i]) {
c[i] = ++cnt;
siz[cnt] = 1;
for (int x = a[i]; x != i; x = a[x]) ++siz[cnt], c[x] = cnt;
int tt = siz[cnt];
for (int x = a[i]; x != i; x = a[x]) id[x] = --tt;
dis[cnt].resize(siz[cnt] + 1);
}
dfs(c[i], i, 0, id[i]);
}
scanf("%d", &Q);
for (int i = 1; i <= cnt; i++)
for (int j = 0; j < siz[i]; j++)
std::sort(dis[i][j].begin(), dis[i][j].end());
while (Q--) {
scanf("%lld%d", &m, &x);
if (d[x]) {
int col = c[x], t = (id[x] + m) % siz[col];
m = (int)std::min(m, (long long)n);
int p = std::upper_bound(dis[col][t].begin(), dis[col][t].end(), m) -
dis[col][t].begin();
printf("%d\n", p);
} else {
if (deep[x] + m > n) {
puts("0");
continue;
}
int t = deep[x] + m;
int pl = std::lower_bound(dis2[t].begin(), dis2[t].end(), in[x]) -
dis2[t].begin();
int pr = std::upper_bound(dis2[t].begin(), dis2[t].end(), out[x]) -
dis2[t].begin();
printf("%d\n", pr - pl);
}
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using ld = long double;
using vi = vector<int>;
int n;
vi a;
vector<vi> g;
vector<vi> cycles;
vi color;
vector<bool> on_cycle;
vi roots;
vi d_root;
vi what_cycle;
vector<vector<vi>> dists_by_rem;
vi ans;
vector<vector<pair<int, ll>>> to_ask;
vector<vi> keko;
vector<vi*> lnk;
vector<vector<pair<int, ll>>> to_ask2;
vector<vi> subtree;
vector<map<int, int>> cnt;
void dfs_subtree(int v, int p, int root) {
subtree[root].push_back(v);
for (int to : g[v]) {
if (to != p && !on_cycle[to]) {
dfs_subtree(to, v, root);
}
}
}
void dfs_dist(int v, int cycle) {
what_cycle[v] = cycle;
for (int to : g[v]) {
if (d_root[to] == -1) {
d_root[to] = d_root[v] + 1;
dfs_dist(to, cycle);
}
}
}
void dfs(int v, int p, int dep) {
int kid = -1;
for (int to : g[v]) {
if (to != p && !on_cycle[to]) {
dfs(to, v, dep + 1);
if (kid == -1 || lnk[to]->size() > lnk[kid]->size()) {
kid = to;
}
}
}
if (kid == -1) {
lnk[v] = &keko[v];
} else {
lnk[v] = lnk[kid];
}
for (int to : g[v]) {
if (to != p && !on_cycle[to] && to != kid) {
for (int i = 0; i < lnk[to]->size(); i++) {
(*lnk[v])[lnk[v]->size() - 1 - (lnk[to]->size() - i - 1)] +=
(*lnk[to])[i];
}
vi().swap(*lnk[to]);
}
}
lnk[v]->push_back(1);
for (auto query : to_ask[v]) {
if (query.second < lnk[v]->size()) {
ans[query.first] += (*lnk[v])[lnk[v]->size() - 1 - query.second];
}
}
}
int32_t main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
a.resize(n);
g.resize(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
--a[i];
g[a[i]].push_back(i);
}
color.resize(n, -1);
on_cycle.resize(n, false);
for (int start = 0; start < n; start++) {
if (color[start] != -1) continue;
int u = start;
vi path;
while (color[u] == -1) {
path.push_back(u);
color[u] = start;
u = a[u];
}
if (color[u] == start) {
reverse((path).begin(), (path).end());
while (path.back() != u) {
path.pop_back();
}
cycles.emplace_back(path);
for (auto v : path) {
on_cycle[v] = true;
}
}
}
subtree.resize(n);
for (int u = 0; u < n; u++) {
if (on_cycle[u]) {
dfs_subtree(u, -1, u);
}
}
d_root.resize(n, -1);
roots.resize((int)((cycles).size()));
what_cycle.resize(n);
for (int i = 0; i < (int)((cycles).size()); i++) {
roots[i] = cycles[i][0];
d_root[roots[i]] = 0;
dfs_dist(roots[i], i);
}
dists_by_rem.resize((int)((cycles).size()));
for (int i = 0; i < (int)((cycles).size()); i++) {
dists_by_rem[i].resize((int)((cycles[i]).size()));
}
for (int u = 0; u < n; u++) {
dists_by_rem[what_cycle[u]]
[d_root[u] % (int)((cycles[what_cycle[u]]).size())]
.push_back(d_root[u]);
}
for (int i = 0; i < (int)((cycles).size()); i++) {
for (auto& v : dists_by_rem[i]) {
sort((v).begin(), (v).end());
}
}
int q;
cin >> q;
ans.resize(q, 0);
to_ask.resize(n);
to_ask2.resize(n);
for (int i = 0; i < q; i++) {
ll m;
int y;
cin >> m >> y;
--y;
if (on_cycle[y]) {
int cyc = what_cycle[y];
int len = (int)((cycles[cyc]).size());
int rem = (m + d_root[y]) % len;
ans[i] = upper_bound((dists_by_rem[cyc][rem]).begin(),
(dists_by_rem[cyc][rem]).end(),
m - (len - d_root[y]) % len) -
dists_by_rem[cyc][rem].begin();
if (d_root[y] > 0) {
to_ask2[y].emplace_back(i, m + d_root[y]);
}
} else {
to_ask[y].emplace_back(i, m);
}
}
cnt.resize((int)((cycles).size()));
for (int i = 0; i < (int)((cycles).size()); i++) {
reverse((cycles[i]).begin(), (cycles[i]).end());
for (int j = 0; j < (int)((cycles[i]).size()) - 1; j++) {
for (int u : subtree[cycles[i][j]]) {
cnt[i][d_root[u]]++;
}
for (auto query : to_ask2[cycles[i][j]]) {
ans[query.first] += cnt[i][query.second];
}
}
}
keko.resize(n);
lnk.resize(n);
for (int i = 0; i < n; i++) {
if (on_cycle[i]) {
dfs(i, -1, 0);
}
}
for (auto x : ans) cout << x << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[200005], q, ans[200005], root[200005], len[200005];
int cidx[200005], hang[200005];
long long m[200005];
basic_string<int> inv[200005], qry[200005];
basic_string<int> root_inv[200005], occ[200005], hang_inv[200005];
bool st[200005], cyc[200005];
void dfs1(int x) {
int y = a[x];
st[x] = 1;
if (root[y]) {
root[x] = root[y];
} else if (st[y]) {
root[x] = x;
} else {
dfs1(y);
root[x] = root[y];
}
st[x] = 0;
}
int el[200005], er[200005], et, dub[200005];
void dfs2(int x, int h) {
el[x] = et++;
hang[x] = h;
hang_inv[h] += x;
for (int y : inv[x]) {
if (!cyc[y]) {
dub[y] = dub[x] + 1;
dfs2(y, h);
}
}
er[x] = et;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
inv[a[i]] += i;
}
cin >> q;
for (int i = 0; i < q; i++) {
int y;
cin >> m[i] >> y;
qry[y] += i;
}
for (int i = 1; i <= n; i++)
if (!root[i]) dfs1(i);
for (int i = 1; i <= n; i++) root_inv[root[i]] += i;
for (int i = 1; i <= n; i++) {
if (i == root[i]) {
int l = 1;
cyc[i] = 1;
for (int j = a[i]; j != i; j = a[j]) {
cidx[j] = l;
l++;
cyc[j] = 1;
}
len[i] = l;
}
}
for (int i = 1; i <= n; i++) {
if (cyc[i]) {
dfs2(i, i);
}
}
for (int i = 1; i <= n; i++) {
occ[dub[i]] += el[i];
}
for (int i = 0; i <= n; i++) sort(occ[i].begin(), occ[i].end());
for (int x = 1; x <= n; x++) {
if (!cyc[x]) {
for (int i : qry[x]) {
int d = min(200001ll, m[i] + dub[x]);
auto it1 = lower_bound(occ[d].begin(), occ[d].end(), el[x]);
auto it2 = lower_bound(occ[d].begin(), occ[d].end(), er[x]);
ans[i] = it2 - it1;
}
}
}
for (int x = 1; x <= n; x++) {
if (x == root[x]) {
int sz = root_inv[x].size(), l = len[x];
deque<int> w(sz);
for (int y : root_inv[x]) {
int h = hang[y];
w[dub[y] + (cidx[h] == 0 ? 0 : l - cidx[h])]++;
}
for (int i = l; i < sz; i++) w[i] += w[i - l];
for (int _i = 0, y = x; _i < l; _i++) {
for (int i : qry[y]) {
ans[i] = w[m[i] >= sz ? m[i] - (m[i] - sz) / l * l - l : m[i]];
}
y = a[y];
w.push_front(0);
for (int z : hang_inv[y]) w[dub[z]]++;
w.pop_back();
}
}
}
for (int i = 0; i < q; i++) cout << ans[i] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static const long long L = 233333;
static char sxd[L], *sss = sxd, *ttt = sxd;
if (sss == ttt) {
ttt = (sss = sxd) + fread(sxd, 1, L, stdin);
if (sss == ttt) {
return EOF;
}
}
return *sss++;
}
inline char readalpha() {
char c = gc();
for (; !isalpha(c); c = gc())
;
return c;
}
inline char readchar() {
char c = gc();
for (; c == ' '; c = gc())
;
return c;
}
template <class T>
inline bool read(T &x) {
bool flg = false;
char c = gc();
x = 0;
for (; !isdigit(c); c = gc()) {
if (c == '-') {
flg = true;
} else if (c == EOF) {
return false;
}
}
for (; isdigit(c); c = gc()) {
x = (x << 1) + (x << 3) + (c ^ 48);
}
if (flg) {
x = -x;
}
return true;
}
template <class T>
inline void write(T x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x < 10) {
putchar(x | 48);
return;
}
write(x / 10);
putchar((x % 10) | 48);
}
const int mod = 1000000009;
const int sqrt5 = 383008016;
const int inv2 = 500000005;
const int isqrt5 = 276601605;
const int phi1 = 691504013;
const int phi2 = 308495997;
inline int ksm(int a, int b) {
long long ans = 1;
for (; b; b >>= 1, a = (long long)a * a % mod) {
if (b & 1) {
ans = (long long)ans * a % mod;
}
}
return ans;
}
inline void merge(vector<int> &a, vector<int> &b) {
if (a.size() < b.size()) {
swap(a, b);
}
for (unsigned i = 1; i <= b.size(); ++i) {
a[a.size() - i] += b[b.size() - i];
}
}
const int maxn = 200005;
int n, q;
int fa[maxn];
int rd[maxn];
int ans[maxn];
vector<pair<long long, int> > que[maxn];
vector<int> dp[maxn];
int main() {
read(n);
for (int i = 1; i <= n; ++i) {
read(fa[i]);
rd[fa[i]]++;
}
read(q);
for (int i = 1; i <= q; ++i) {
long long x;
int y;
read(x), read(y);
que[y].emplace_back(x, i);
}
queue<int> leaves;
for (int i = 1; i <= n; ++i) {
if (!rd[i]) {
leaves.push(i);
}
dp[i].push_back(1);
}
while (!leaves.empty()) {
int now = leaves.front();
leaves.pop();
for (auto qq : que[now]) {
if (qq.first >= (int)dp[now].size()) {
ans[qq.second] = 0;
} else {
ans[qq.second] = dp[now][dp[now].size() - qq.first - 1];
}
}
dp[now].push_back(0);
merge(dp[fa[now]], dp[now]);
rd[fa[now]]--;
if (!rd[fa[now]]) {
leaves.push(fa[now]);
}
}
for (int now = 1; now <= n; ++now) {
if (rd[now]) {
int noww = now;
int len = 0;
vector<int> yuan;
do {
auto bak = dp[noww];
merge(yuan, bak);
len++;
yuan.push_back(0);
noww = fa[noww];
rd[noww] = 0;
} while (noww != now);
for (unsigned i = 1; i + len <= yuan.size(); ++i) {
yuan[yuan.size() - i - len] += yuan[yuan.size() - i];
}
do {
merge(yuan, dp[noww]);
for (auto qq : que[noww]) {
qq.first = (long long)yuan.size() - qq.first - 1;
if (qq.first < 0) {
qq.first %= len;
if (qq.first) {
qq.first += len;
}
}
ans[qq.second] = yuan[qq.first];
}
noww = fa[noww];
yuan.push_back(0);
} while (noww != now);
}
}
for (int i = 1; i <= q; ++i) {
printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int mod1 = 998244353;
const long long inf = 5e18;
long long n, p, w, d;
void solve() {
cin >> n >> p >> w >> d;
for (long long draw = 0; draw < w; draw++) {
long long score = draw * d;
long long win = (p - score) / w;
if (win >= 0 && score >= 0 && score + win * w == p && win + draw <= n) {
cout << win << " " << draw << " " << n - win - draw;
return;
}
}
cout << -1;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, p;
int w, d;
cin >> n >> p >> w >> d;
for (long long i = 0; i < w; i++) {
long long x = p - i * d;
if (x % w == 0 && x >= 0 && x / w + i <= n) {
cout << x / w << " " << i << " " << n - x / w - i;
return 0;
}
}
cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, t, q, n, p, w, d, x, y, z, a, b, c;
cin >> n >> p >> w >> d;
a = p / w;
x = a;
y = (p - (a * w)) / d;
if ((a * w + y * d) == p) {
z = n - a - y;
if (x >= 0 && y >= 0 && z >= 0)
cout << x << " " << y << " " << z;
else
cout << "-1";
} else {
for (i = 0; i < 10e6 + 1; i++) {
if ((p - (d * i)) % w == 0) {
x = (p - (d * i)) / w;
y = i;
z = n - x - y;
break;
}
}
if (i == 10e6 + 1) {
cout << "-1";
} else {
if (x >= 0 && y >= 0 && z >= 0)
cout << x << " " << y << " " << z;
else
cout << "-1";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int n) {
long long int res = 1;
while (n > 0) {
if (n % 2 == 1) res = res * x;
x = x * x;
n = n / 2;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n, p, w, d, x, y, z, i;
cin >> n >> p >> w >> d;
if (p / w > n) {
cout << -1;
return 0;
} else {
if (p % w == 0) {
cout << p / w << " 0 " << n - p / w;
} else {
x = p / w;
y = p % w;
if (y % d == 0) {
if (x + y / d > n) {
cout << -1;
return 0;
} else {
cout << x << " " << y / d << " " << n - x - y / d;
}
} else {
long long int k = w - d;
z = y % d;
y = y / d;
long long int q = 0;
for (i = 1; i < d; i++) {
if ((i * k + z) % d == 0) {
q = i;
break;
}
}
if (q != 0) {
x = x - q;
y = y + q + (i * k + z) / d;
if (x >= 0 && (x + y) <= n) {
cout << x << " " << y << " " << n - x - y;
} else
cout << -1;
} else
cout << -1;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, p, w, d;
long long x, y;
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long r = exgcd(b, a % b, y, x);
y -= x * (a / b);
return r;
}
signed main() {
cin >> n >> p >> w >> d;
long long temp = exgcd(w, d, x, y);
if (p % temp != 0) {
printf("-1");
return 0;
}
long long t1 = p / temp;
long long m = w / temp;
t1 %= w;
y *= t1;
if (y < 0) y -= (y / m) * m;
y = (y + m) % m;
x = (p - (y * d)) / w;
if (x < 0 || x + y > n)
printf("-1");
else
printf("%lld %lld %lld", x, y, n - x - y);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n, p, w, d;
cin >> n >> p >> w >> d;
for (long long j = 0; j <= w; j++) {
if ((p - d * j) % w == 0 && (j + (p - d * j) / w <= n) &&
(p - d * j) >= 0) {
cout << (p - d * j) / w << " " << j << " " << n - (j) - ((p - d * j) / w);
return 0;
}
}
cout << -1;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, p, w, d;
long long exgcd(long long a, long long b, long long &x, long long &y) {
long long res;
if (b) {
res = exgcd(b, a % b, y, x), y -= a / b * x;
return res;
} else {
x = 1, y = 0;
return a;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int i, j, flag = 0;
cin >> n >> p >> w >> d;
if (w > d) {
flag = 1;
swap(w, d);
}
long long x, y;
long long g = exgcd(w, d, x, y);
if (p % g != 0)
cout << -1 << endl;
else {
long long s = d / g, t = w / g;
x = (s + (p / g) % s * (x % s) % s) % s;
y = (p - x * w) / d;
if (x >= 0 && y >= 0 && x + y <= n) {
if (flag)
cout << y << ' ' << x << ' ' << n - x - y << endl;
else
cout << x << ' ' << y << ' ' << n - x - y << endl;
} else
cout << -1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, p, d, w, k, x, y, z;
int main() {
cin >> n >> p >> w >> d;
for (y = 0; y < w; y++) {
x = p - d * y;
if (x >= 0 && x % w == 0) {
x = x / w;
if (x + y <= n) {
cout << x << " " << y << " " << n - x - y;
return 0;
}
}
}
cout << -1;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, p, w, d;
cin >> n >> p >> w >> d;
assert(w > d);
for (int i = 0; i < w; i++) {
long long left = p - d * i;
if (left < 0) break;
if (left % w == 0) {
long long wins = left / w;
if (wins + i <= n) {
cout << wins << ' ' << i << ' ' << n - wins - i << '\n';
return 0;
}
}
}
cout << "-1\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 1e18;
const long long int MAX = 1e5 + 5;
int32_t main() {
long long int n, p, w, d;
cin >> n >> p >> w >> d;
long long int x, y, z;
for (long long int i = 0; i <= MAX; i++) {
x = p - i * d;
if (x % w == 0 && x / w + i <= n && x >= 0) {
cout << x / w << " " << i << " " << n - x / w - i << "\n";
return 0;
;
}
}
cout << -1 << "\n";
return 0;
;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, p, w, d, ax, ay = -1;
scanf("%lld %lld %lld %lld", &n, &p, &w, &d);
while (++ay <= w) {
if (p == ay * d)
goto done;
else if ((p - ay * d) >= 0 && (p - ay * d) % w == 0 &&
(p - ay * d) / w + ay <= n) {
goto done;
}
}
goto notdone;
done:
printf("%lld %lld %lld\n", (p - ay * d) / w, ay, n - (p - ay * d) / w - ay);
return 0;
notdone:
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << "{" << p.first << "," << p.second << "}";
return os;
}
const long long N = 3e5 + 5;
const long long oo = 1e9 + 7;
long long gcd(long long a, long long b, long long &x, long long &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long x1, y1;
long long d = gcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
long long mulmod(long long a, long long b, long long c) {
return ((a % c) * (b % c)) % c;
}
bool find_any_solution(long long a, long long b, long long c, long long &x0,
long long &y0, long long &g) {
g = gcd(abs(a), abs(b), x0, y0);
if (c % g) {
return false;
}
long long dx = c / a;
c -= dx * a;
long long dy = c / b;
c -= dy * b;
x0 = dx + mulmod(x0, c / g, b);
y0 = dy + mulmod(y0, c / g, a);
return true;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long n, p, w, d;
cin >> n >> p >> w >> d;
long long x, y, g;
if (find_any_solution(w, d, p, x, y, g)) {
long long wg = w / g;
long long dg = d / g;
long long xk = ceill(-1.0 * x / dg);
long long yk = floorl(1.0 * y / wg);
if (xk > yk)
cout << "-1\n";
else {
long long k;
if (d >= w) {
long long xyk = ceill((-1.0 * (x + y)) / (dg - wg));
k = min(max(xk, xyk), yk);
} else {
long long xyk = floorl((-1.0 * (x + y)) / (dg - wg));
k = max(xk, min(yk, xyk));
}
x = x + k * dg;
y = y - k * wg;
assert(x >= 0);
assert(y >= 0);
assert(x * w + y * d == p);
if (x + y <= n)
cout << x << " " << y << " " << n - x - y << "\n";
else
cout << "-1\n";
}
} else
cout << "-1\n";
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, w, d, p, t1, t, T;
char ch[10005];
long long gets() {
long long v = 0;
char ch;
bool f = 0;
while (!isdigit(ch = getchar()))
if (ch == '-') f = 1;
v = ch - 48;
while (isdigit(ch = getchar())) v = (v << 1) + (v << 3) + ch - 48;
return f ? -v : v;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
void test() {
n = gets(), p = gets(), w = gets(), d = gets();
t1 = gcd(gcd(w, d), p);
w /= t1, d /= t1, p /= t1;
if (w * n < p) {
puts("-1");
return;
}
for (long long i = 0; i <= w - 1; i++) {
t = p - d * i;
if (t < 0) break;
if (t % w == 0) {
if (t / w + i > n)
;
else {
printf("%lld %lld %lld\n", t / w, i, n - t / w - i);
return;
}
}
}
puts("-1");
}
int main() {
test();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, p, w, d;
cin >> n >> p >> w >> d;
long long int i, x, y, z;
for (i = 0; i < w; i++) {
if ((p - i * d) >= 0 && ((p - i * d) % w == 0) &&
((p - i * d) / w) + i <= n)
break;
}
if (i == w)
cout << "-1\n";
else {
x = ((p - i * d) / w);
y = i;
z = n - x - y;
cout << x << " " << y << " " << z << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long double eps = 1e-12;
long long dx[] = {0, 0, 1, -1};
long long dy[] = {1, -1, 0, 0};
long long n, res = 0, k = 0, h, ans = 0, m, level = 0;
;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long x, long long y) { return (x * y) / gcd(x, y); }
string s2, ch = "", s, s1 = "", t;
vector<pair<string, long long> > vm;
vector<pair<pair<long long, long long>, long long> > vvvl, vvvr;
vector<pair<long long, long long> > vv, vv2;
vector<long long> v[300005], vnode;
map<pair<long long, long long>, long long> mp;
long long a[500005], vis[500005], dp[4100][4100];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long i = 0, x = 0, z = 0, y = 0, j = 0, q, mx = 0, mm, idx = 0, ok = 0,
l = 0, r = 0, negatif = 0, positif = 0, l1, r1, g = 0, d;
set<pair<long long, long long> >::iterator it, it2;
set<long long>::iterator it1;
long long w, p;
cin >> n >> p >> w >> d;
x = 0;
y = 0;
z = 0;
for (x = 0; x <= 1e7; x++) {
long long cur = p;
cur -= x * w;
if (cur < 0) continue;
if (cur % d != 0) continue;
y = cur / d;
if ((x + y) > n) continue;
z = n - (x + y);
return cout << x << " " << y << " "
<< " " << z,
0;
}
for (y = 0; y <= 1e7; y++) {
long long cur = p;
cur -= y * d;
if (cur < 0) continue;
if (cur % w != 0) continue;
x = cur / w;
if ((x + y) > n) continue;
z = n - (x + y);
return cout << x << " " << y << " "
<< " " << z,
0;
}
return cout << "-1", 0;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, p, w, d;
cin >> n >> p >> w >> d;
if (p % w == 0 && n >= p / w) {
cout << p / w << " " << 0 << " " << n - p / w;
return 0;
}
if (p % d == 0 && n >= p / d) {
cout << 0 << " " << p / d << " " << n - p / d;
return 0;
}
if (p / w + p % w / d <= n && p / w * w + p % w / d * d == p) {
cout << p / w << " " << p % w / d << " " << n - p / w - p % w / d;
return 0;
}
for (long long i = 1; i <= min(p / d, n); i++) {
long long now = p - i * d;
if (now < 0) break;
if (now > 0 && now % w == 0 && n - now / w - i >= 0) {
cout << now / w << " " << i << " " << n - now / w - i;
return 0;
}
if (i == 10000000) break;
}
cout << -1;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n, p, w, d;
cin >> n >> p >> w >> d;
long long int l = 0, r = n, mid, ans = -1;
long long int x, y, z, p1 = -1;
for (y = 0; y <= 1000001; y++) {
x = (p - y * d) / w;
z = n - x - y;
if ((x + y + z) == n && (x * w + y * d) == p && x >= 0 && y >= 0 &&
z >= 0) {
p1 = 1;
break;
}
}
if (p1 == 1) {
cout << x << " " << y << " " << z;
} else {
cout << -1;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, p, w, d, y = 0, i = 1;
cin >> n >> p >> w >> d;
if (w % d == 0 || d % w == 0) {
int k = w > d ? d : w;
if (p % k != 0) {
cout << "-1";
return 0;
}
}
if ((p > w * n || (p < w && p < d)) && p) {
cout << "-1";
return 0;
}
while ((p - y * d) % w != 0 && y * d <= p && p) {
y++;
}
long long int x = (p - y * d) / w;
long long int z = n - y - x;
cout << x << " " << y << " " << z;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, p, w, d, y = 1e18;
int main() {
cin >> n >> p >> w >> d;
for (int i = 0; i < w; i++)
if ((i * d) % w == p % w) {
y = i;
break;
}
long long x = (p - y * d) / w;
if (x + y > n || x < 0 || y == 1e18)
cout << -1;
else
cout << x << " " << y << " " << n - y - x;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios_base::sync_with_stdio(false);
long long int n, p, w, d;
cin >> n >> p >> w >> d;
long long int y = 0;
for (y = 0; y < w; y++) {
if (p - y * d >= 0 && (p - y * d) % w == 0 && y + (p - y * d) / w <= n) {
cout << (p - y * d) / w << " " << y << " " << n - (p - y * d) / w - y;
return 0;
}
}
cout << "-1";
return 0;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, p, w, d;
cin >> n >> p >> w >> d;
long long above = n * w - p;
if (p == 0) {
cout << "0 0 " << n << endl;
} else if (above < 0 || d > p) {
cout << -1 << endl;
} else {
long long xx = p / w;
for (long long k = 0; k <= 1e5; k++) {
long long x = xx - k;
if (x < 0) break;
long long sheng = p - x * w;
if (sheng % d != 0) continue;
long long y = sheng / d;
if (x + y > n) continue;
cout << x << " " << y << " " << n - x - y << endl;
return 0;
}
cout << -1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << '\n';
err(++it, args...);
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
string lts(long long int x) {
stringstream second;
second << x;
return second.str();
}
long long int stl(string x) {
stringstream second(x);
long long int temp;
second >> temp;
return temp;
}
const int MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long int n, p, w, d;
cin >> n >> p >> w >> d;
for (long long int y = (0); y <= (long long int)(w - 1); ++y) {
if ((p - y * d) % w == 0) {
long long int x = (p - y * d) / w;
long long int z = n - x - y;
if (z >= 0 && x >= 0 && y >= 0) {
cout << x << ' ' << y << ' ' << z;
return 0;
}
}
}
cout << -1;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
long long n, p, w, d;
scanf("%lld%lld%lld%lld", &n, &p, &w, &d);
long long m = p / w, l;
for (int i = 0; i <= min(m, 100000ll); i++) {
if ((p - (m - i) * w) % d == 0) {
l = (p - (m - i) * w) / d;
if (m - i + l <= n) {
printf("%lld %lld %lld\n", m - i, l, n - m + i - l);
return 0;
}
}
}
puts("-1");
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, p, w, d;
int main() {
cin >> n >> p >> w >> d;
for (long long i = 0; i < w; i++) {
if ((p - i * d) % w == 0) {
long long x = (p - i * d) / w;
if (x >= 0 && x + i <= n) {
printf("%lld %lld %lld\n", x, i, n - x - i);
return 0;
}
}
}
cout << "-1" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace io {
const int __SIZE = (1 << 21) + 1;
char ibuf[__SIZE], *iS, *iT, obuf[__SIZE], *oS = obuf, *oT = oS + __SIZE - 1,
__c, qu[55];
int __f, qr, _eof;
inline void flush() { fwrite(obuf, 1, oS - obuf, stdout), oS = obuf; }
inline void gc(char &x) {
x = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
}
inline void pc(char x) {
*oS++ = x;
if (oS == oT) flush();
}
inline void pstr(const char *s) {
int __len = strlen(s);
for (__f = 0; __f < __len; ++__f) pc(s[__f]);
}
inline void gstr(char *s) {
for (__c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
__c < 32 || __c > 126 || __c == ' ';)
__c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
for (; __c > 31 && __c < 127 && __c != ' ';
++s, __c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
*s = __c;
*s = 0;
}
template <class I>
inline bool gi(I &x) {
_eof = 0;
for (__f = 1,
__c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
(__c < '0' || __c > '9') && !_eof;
__c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) {
if (__c == '-') __f = -1;
_eof |= __c == EOF;
}
for (x = 0; __c <= '9' && __c >= '0' && !_eof;
__c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
x = x * 10 + (__c & 15), _eof |= __c == EOF;
x *= __f;
return !_eof;
}
template <class I>
inline void print(I x) {
if (!x) pc('0');
if (x < 0) pc('-'), x = -x;
while (x) qu[++qr] = x % 10 + '0', x /= 10;
while (qr) pc(qu[qr--]);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher_;
} // namespace io
using io::gc;
using io::gi;
using io::gstr;
using io::pc;
using io::print;
using io::pstr;
template <typename T>
inline void chkmax(T &a, T b) {
a = a > b ? a : b;
}
template <typename T>
inline void chkmin(T &a, T b) {
a = a < b ? a : b;
}
template <typename T>
inline T gcd(T &a, T b) {
return !b ? a : gcd(b, a % b);
}
const int mod = 1000000007;
template <typename T>
const T Mod(T x) {
return x >= mod * 2 ? x % mod : (x >= mod ? x - mod : x);
}
template <typename T>
const void Add(T &a, T b) {
a = Mod(a + b);
}
const int MAXN = 100100;
int main() {
long long n, p, d, w, x, y;
gi(n), gi(p), gi(w), gi(d);
x = p / w, y = 0;
while (x >= (p / w) - d && x >= 0) {
long long tmp = p - w * x;
if (tmp % d == 0) {
y = tmp / d;
if (x + y > n) {
pstr("-1\n");
return 0;
} else {
print(x), pc(' '), print(y), pc(' '), print(n - x - y), pc('\n');
return 0;
}
}
--x;
}
pstr("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
;
int64_t n, p, w, d;
cin >> n >> p >> w >> d;
int64_t x, y, z, xx;
for (y = 0; y < w; ++y) {
xx = (p - (y * d)) % w;
if (xx == 0) {
x = (p - (y * d)) / w;
z = n - x - y;
break;
}
}
if (x < 0 or y < 0 or z < 0)
cout << "-1\n";
else
cout << x << " " << y << " " << z << "\n";
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("2,Ofast,inline")
const long long N = 1e5 + 10;
const long long mod = 1e9 + 7;
const long long inf = 0x3f3f3f;
const double eps = 1e-9;
using namespace std;
template <typename tp>
inline void read(tp &x) {
x = 0;
char c = getchar();
bool f = 0;
for (; c < '0' || c > '9'; f |= (c == '-'), c = getchar())
;
for (; c >= '0' && c <= '9'; x = (x << 3) + (x << 1) + c - '0', c = getchar())
;
if (f) x = -x;
}
long long n, p, w, d, x, y, gcdd;
long long exgcd(long long a, long long b, long long &x, long long &y) {
long long ret;
if (!b) {
ret = a;
x = 1, y = 0;
} else {
ret = exgcd(b, a % b, x, y);
long long tmp = x;
x = y;
y = tmp - (a / b) * y;
}
return ret;
}
void solve() {
long long flaga = w / gcdd, flagb = d / gcdd;
x = x % flagb * ((p / gcdd) % flagb);
x = (x % flagb + flagb) % flagb;
y = (p - w * x) / d;
if (n >= x + y && x >= 0 && y >= 0) {
printf("%lld %lld %lld\n", x, y, n - x - y);
exit(0);
}
y = (y % flaga + flaga) % flaga;
x = (p - d * y) / w;
if (n >= x + y && x >= 0 && y >= 0) {
printf("%lld %lld %lld\n", x, y, n - x - y);
exit(0);
}
}
int main() {
read(n), read(p), read(w), read(d);
gcdd = exgcd(w, d, x, y);
if (p % gcdd) return 0 * printf("-1\n");
solve();
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b, long long int &x,
long long int &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long int x1, y1;
long long int d = gcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
bool find_any_solution(long long int a, long long int b, long long int c,
long long int &x0, long long int &y0, long long int &g) {
cout << a << " " << b << " " << c << endl;
g = gcd(abs(a), abs(b), x0, y0);
if (c % g) {
return false;
}
long long int aux1 = c / g;
x0 = x0 * aux1;
y0 = y0 * aux1;
if (a < 0) x0 = -x0;
if (b < 0) y0 = -y0;
return true;
}
int main() {
long long int n, p, w, d, x, y, k1, k2, k3, g;
cin >> n >> p >> w >> d;
for (int y = 0; y < w; y++) {
if ((p - y * d) >= 0 && (p - y * d) % w == 0 &&
((p - y * d) / w + y) <= n) {
cout << (p - y * d) / w << " " << y << " " << n - y - (p - y * d) / w
<< endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
vector<long long> g;
vector<bool> used;
long long depth = 0;
bool dfs(long long v) {
if (used[v])
return false;
else if (v == 0)
return true;
else {
depth++;
used[v] = true;
return dfs(g[v]);
}
}
long long cycle(long long v) {
if (used[v])
return v;
else {
depth++;
used[v] = true;
return cycle(g[v]);
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, p, d, w;
cin >> n >> p >> w >> d;
long long mod = w - d;
g.resize(mod);
used = vector<bool>(mod, false);
long long av = mod;
while (av < d) {
av += mod;
}
for (long long i = 0; i < mod; i++) {
g[i] = (av + i - d) % mod;
}
if (dfs(p % mod)) {
used = vector<bool>(mod, false);
long long sh = depth;
depth = 0;
long long v = cycle(0);
long long x = (p - d * depth) / mod;
long long y = depth - x;
long long z = n - x - y;
if (x >= 0 && y >= 0 && z >= 0 && y * d + x * w == p)
cout << x << ' ' << y << ' ' << z;
else if (v == 0) {
long long pr = depth;
long long k = (p - sh * w) / (w * pr) - 1;
long long cnt = 4;
while (cnt--) {
long long a = k * pr + sh;
x = (p - d * a) / mod;
y = a - x;
z = n - x - y;
if (x >= 0 && y >= 0 && z >= 0 && y * d + x * w == p) {
cout << x << ' ' << y << ' ' << z;
return 0;
}
k++;
}
cout << -1;
} else {
cout << -1;
}
} else {
cout << -1;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int64_t mult(int64_t a, int64_t b, int64_t mod) { return a * b % mod; }
int64_t deg(int64_t a, int64_t b, int64_t mod) {
if (mod == 1) return 0;
int64_t res = 1;
int64_t deg = a;
while (b) {
if (b & 1) res = mult(res, deg, mod);
deg = mult(deg, deg, mod);
b /= 2;
}
return res;
}
int64_t gcd(int64_t a, int64_t b) { return b ? gcd(b, a % b) : a; }
int main() {
int64_t n, p, w, d;
cin >> n >> p >> w >> d;
if (p % gcd(w, d) != 0) {
cout << -1 << endl;
return 0;
}
int64_t allgcd = gcd(w, d);
w /= allgcd;
p /= allgcd;
d /= allgcd;
int64_t wm = w % d;
int64_t pm = p % d;
int64_t x0 = -1;
for (int64_t i = 0; i < d; ++i) {
if (i * wm % d == pm) {
x0 = i;
break;
}
}
if (x0 == -1) {
cout << -1 << endl;
return 0;
}
assert((p - w * x0) % d == 0);
int64_t y0 = (p - w * x0) / d;
int64_t t;
if (y0 < 0) {
t = -((-y0) / w + ((-y0) % w != 0));
} else {
t = y0 / w;
}
int64_t resx = x0 + t * d;
int64_t resy = y0 - w * t;
if (resx + resy > n || resx < 0) {
cout << -1 << endl;
return 0;
}
assert(y0 >= 0);
cout << resx << ' ' << resy << ' ' << n - resx - resy << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
long long n, p, d, w;
cin >> n >> p >> w >> d;
for (register int y = (0); y <= (w); ++y) {
long long x = (p - y * d) / w;
if (x < 0) continue;
if (x * w + y * d != p) continue;
if (x + y <= n) {
cout << x << ' ' << y << ' ' << n - x - y << '\n';
return 0;
}
}
cout << -1 << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
const int inf = 1000 * 1000 * 1000;
const int mod = 1000 * 1000 * 1000 + 7;
long long n, p, w, d;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
mt19937 myrand(chrono::steady_clock::now().time_since_epoch().count());
cin >> n >> p >> w >> d;
long long mul = (w * d) / gcd(w, d);
for (int i = 0; i * d <= mul; i++) {
if ((p - i * d) % w == 0) {
long long j = (p - i * d) / w;
if (j >= 0 && i + j <= n) {
cout << j << " " << i << " " << n - i - j << endl;
return 0;
}
}
}
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
ifstream fin("input");
void init() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
}
void solve() {
long long n, p, w, d;
cin >> n >> p >> w >> d;
for (long long y = 0; y < w; y++) {
if (p - y * d >= 0 && (p - y * d) % w == 0) {
long long x = (p - y * d) / w;
if (x + y <= n) {
cout << x << " " << y << " " << n - x - y << endl;
return;
}
}
}
cout << -1;
}
int main() {
init();
solve();
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.