ICPC2023南京站题解（A C D F G I L M）
本场金牌线为7题前一半。做出8题可稳金牌，这里是难度前8题的题解。
ICPC2023南京站
I:
签到题。
#include <bits/stdc++.h>
#define ll long long
#define QWQ cout<<"QwQ"<<endl;
#define FOR() ll le=e[u].size();for(ll i=0;i<le;i++)
using namespace std;
const ll N=501010;
inline ll read() {
ll sum = 0, ff = 1; char c = getchar();
while(c<'0' || c>'9') { if(c=='-') ff = -1; c = getchar(); }
while(c>='0'&&c<='9') { sum = sum * 10 + c - '0'; c = getchar(); }
return sum * ff;
}
int T;
int n,m;
struct E{
int wei,zhi;
}a[N];
inline bool cmp(E A,E B) { return A.wei<B.wei; }
int main() {
T = read();
while(T--) {
bool flag = 1;
n = read(); m = read();
for(int i=1;i<=m;i++) {
a[i].wei = read(); a[i].zhi = read();
}
sort(a+1,a+m+1,cmp);
for(int i=1;i<=m;i++) {
if(a[i].wei-a[i-1].wei==a[i].zhi-a[i-1].zhi) continue;
if(a[i].zhi<a[i].wei-a[i-1].wei) continue;
flag = 0;
break;
}
if(flag) cout<<"Yes\n";
else cout<<"No\n";
}
return 0;
}
F:
等价重写，可以轻松地想到本题和图论有关，每个操作修改的数字是独一无二的，因此每个覆盖事件都可以产生一个先后关系，我们可以将某个位置先写入的数字连向后写入的数字，在拓扑排序中就可以表示先写入较早的数字。
我WA了一发哈哈，因为没考虑完整，连边只需要连向每个位置最后覆盖的数字就行，之前谁把谁覆盖没有关系。
#include <bits/stdc++.h>
#define ll long long
#define QWQ cout<<"QwQ"<<endl;
#define FOR() ll le=e[u].size();for(ll i=0;i<le;i++)
using namespace std;
const ll N=501010;
inline ll read() {
ll sum = 0, ff = 1; char c = getchar();
while(c<'0' || c>'9') { if(c=='-') ff = -1; c = getchar(); }
while(c>='0'&&c<='9') { sum = sum * 10 + c - '0'; c = getchar(); }
return sum * ff;
}
int T;
int n,m;
int a[N];
int ru[N];
vector <int> e[N];
int ans[N],cnt;
priority_queue <int> q;
vector <int> g[N];
void chushihua() {
for(ll i=1;i<=n;i++) ru[i] = 0, e[i].clear();
for(ll i=1;i<=m;i++) g[i].clear();
cnt = 0;
}
int main() {
int x,y;
T = read();
while(T--) {
chushihua();
n = read(); m = read();
for(int i=1;i<=n;i++) {
x = read();
while(x--) {
y = read();
g[y].push_back(i);
}
}
for(int i=1;i<=m;i++) {
if(g[i].size()==0) continue;
int hou = g[i].back();
for(auto v : g[i]) if(v != hou) e[v].push_back(hou), ru[hou]++;
}
for(int i=1;i<=n;i++) if(!ru[i]) q.push(i);
while(!q.empty()) {
int u = q.top(); q.pop();
ans[++cnt] = u;
FOR() {
int v = e[u][i];
ru[v]--;
if(ru[v]==0) q.push(v);
}
}
bool tong = 1;
for(int i=1;i<=cnt;i++) if(i!=ans[i]) tong = 0;
if(tong) {
cout<<"No\n";
continue;
}
cout<<"Yes\n";
for(int i=1;i<=n;i++) cout<<ans[i]<<" \n"[i==n];
}
return 0;
}
C:
官方题解中给出了两种解法，都有思考价值。
解法一：
异或运算满足不等式：\(a-b\leq a\oplus b \leq a+b\)，那么我们把题目中的 g 写出来：\(g=(kP+1)\oplus(P-1)\)，它也满足不等式：\((k-1)P+2\leq (kP+1)\oplus(P-1)\leq (k+1)P\)。
这个不等式能告诉我们什么？虽然我们的 \((kP+1)\) 异或上了 \((P-1)\) 使得结果 g 的具体值不确定，但是 g 是有取值范围的，这个范围的大小不超过2P，随着 \(k\) 的增长，g 的取值范围左右各增加一个 P，也就是说，g 的取值范围接近上限 m 时，k 的取值就在 \(\lfloor\frac mP\rfloor\) 左右，小于这个值时，g 一定比 m 小，大于这个值时 g 一定比 m 大，在 \(\lfloor\frac mP\rfloor\) 左右时特判即可。
解法二：
这个做法是比较无脑且科技的，比较推荐：
将 [l,r] 这个区间的所有整数异或上一个值 X ，可以得到 log 段连续的区间。[0,m] 这个区间异或上 (P-1)，每一段判断有多少 (kP+1) 即可。
#include <bits/stdc++.h>
#define ll long long
using namespace std;
const ll N=101010;
inline ll read() {
ll sum = 0, ff = 1; char c = getchar();
while(c<'0' || c>'9') { if(c=='-') ff = -1; c = getchar(); }
while(c>='0'&&c<='9') { sum = sum * 10 + c - '0'; c = getchar(); }
return sum * ff;
}
ll T;
ll m,P;
struct D{
ll l,r;
}d[N];
inline bool cmp(D A,D B) { return A.l < B.l; }
ll cnt;
void get_fen(ll R,ll X) {
ll da = 1ll << 60ll;
d[cnt=1] = {0,R};
for(ll i=60;i>=0;i--,da>>=1) {
if(d[1].l+da<=d[1].r) {
if((X>>i)&1) {
d[++cnt] = {d[1].l+da,d[1].l+2*da-1};
d[1].r -= da;
}
else {
d[++cnt] = {d[1].l,d[1].l+da-1};
d[1].l += da;
}
}
else if((X>>i)&1) d[1].l += da, d[1].r += da;
}
sort(d+1,d+cnt+1,cmp);
// for(ll i=1;i<=cnt;i++) cout<<d[i].l<<" "<<d[i].r<<"\n";
}
inline ll ask(ll R) {
if(R<=0) return 0;
return (R-1)/P+1;
}
int main() {
T = read();
while(T--) {
P = read(); m = read();
get_fen(m,P-1);
ll ans = 0;
for(ll i=1;i<=cnt;i++) {
ans += ask(d[i].r);
ans -= ask(d[i].l-1);
}
cout<<ans<<"\n";
}
return 0;
}
G:
可以免费选物品的背包，总感觉哪里做过。
假如从珠宝店出来，你拿着一些物品，把这些物品分为两类，一类是你买的，一类是你免费选的，那么可以肯定的是，你免费选的那些物品，一定是价格比较高的，这样省钱。
所以这两类物品是存在一个分界线的，是按价格排序的分界线。
枚举一个价格，设免费选的都高于这个价格，买来的都低于这个价格，那就高于这个价格的优先选价值高的，低于这个价格的用背包。
前者优先队列，后者朴素背包。
#include <bits/stdc++.h>
#define ll long long
#define QWQ cout<<"QwQ"<<endl;
#define FOR() ll le=e[u].size();for(ll i=0;i<le;i++)
using namespace std;
const ll N=501010;
inline ll read() {
ll sum = 0, ff = 1; char c = getchar();
while(c<'0' || c>'9') { if(c=='-') ff = -1; c = getchar(); }
while(c>='0'&&c<='9') { sum = sum * 10 + c - '0'; c = getchar(); }
return sum * ff;
}
ll n,W,K;
struct E{
ll w,v;
}a[N];
inline bool cmp(E A,E B) { return A.w > B.w; }
priority_queue <ll, vector<ll>, greater<ll> > q;
ll qian[N];
ll f[N];
int main() {
n = read(); W = read(); K = read();
for(ll i=1;i<=n;i++) {
a[i].w = read(); a[i].v = read();
}
sort(a+1,a+n+1,cmp);
ll now = 0;
for(ll i=1;i<=n;i++) {
now += a[i].v;
q.push(a[i].v);
if(i>K) now -= q.top(), q.pop();
qian[i] = now;
}
ll ans = 0;
for(ll i=n;i>=1;i--) {
ll da = 0;
for(ll j=W;j>=a[i].w;j--) {
f[j] = max(f[j], f[j-a[i].w] + a[i].v);
da = max(f[j], da);
}
ans = max(ans,da+qian[i-1]);
}
cout<<ans;
return 0;
}
A:
南京站四次重现，还挺酷的。
题目比较吓人，但是稍微想想会发现，如果我是袋鼠，我会把我能走到的地方都走一遍，如果还没有赢，那我就赢不了了。
我能走的区域就是四连通块，如果场内有能够包含我这个连通块的其他连通块，那我就成为不了赢家，反之肯定能赢，且我连通块内的其他袋鼠也一定能赢（这个很关键）。
枚举所有的连通块，扫一遍全图，每个位置判断需要花费我连通块大小的时间，设每个连通块大小为 \(siz_i\) ，总复杂度为 \(\sum siz_i*nm=(nm)^2\) ，因为题目中 \(n*m\) 是 1000，所以平方可过。
#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N=1010;
const int inf=0x3f3f3f3f;
inline ll read() {
ll sum = 0, ff = 1; char c = getchar();
while(c<'0' || c>'9') { if(c=='-') ff = -1; c = getchar(); }
while(c>='0'&&c<='9') { sum = sum * 10 + c - '0'; c = getchar(); }
return sum * ff;
}
ll T;
int n,m;
char s[N];
int ff[] = {1,-1,0,0};
int gg[] = {0,0,1,-1};
int a[N][N];
int shang, xia, zuo, you;
int vis[N][N];
struct D { int x,y; }st[N];
int cnt;
int ans;
void chushihua() {
for(int i=0;i<=n+1;i++) for(int j=0;j<=m+1;j++) vis[i][j] = a[i][j] = 0;
ans = 0;
}
void DFS(int x,int y) {
st[++cnt] = {x,y};
vis[x][y] = 1;
shang = min(shang,x);
zuo = min(zuo,y);
xia = max(xia,x);
you = max(you,y);
for(int k=0;k<4;k++) {
int xx = ff[k] + x;
int yy = gg[k] + y;
if(vis[xx][yy] || !a[xx][yy]) continue;
DFS(xx,yy);
}
}
int main() {
T = read();
while(T--) {
chushihua();
n = read(); m = read();
for(int i=1;i<=n;i++) {
scanf("%s",s+1);
for(int j=1;j<=m;j++) {
if(s[j]=='.') a[i][j] = 1;
else a[i][j] = 0;
}
}
for(int i=1;i<=n;i++) {
for(int j=1;j<=m;j++) {
if(a[i][j] && !vis[i][j]) {
cnt = 0;
shang = zuo = inf;
xia = you = 0;
DFS(i,j);
int shu = xia-shang+1;
int heng = you-zuo+1;
bool you = 0;
for(int I=1;I<=n;I++) {
if(I+shu-1>n) break;
for(int J=1;J<=m;J++) {
if(J+heng-1>m) break;
if(I==shang && J==zuo) continue;
bool can = 1;
for(int k=1;k<=cnt;k++) {
if(!a[ I+st[k].x-shang ][ J+st[k].y-zuo ]) { can = 0; break; }
}
if(can) {you = 1; break;}
}
if(you==1) break;
}
if(!you) ans += cnt;
}
}
}
cout<<ans<<endl;
}
return 0;
}
L：
这题思考难度是签到，但是难写程度甚至导致成为了银牌题。
电梯运包裹，因为包裹大小只有 1 和 2，且贪心满足要求，所以是可以排完序后直接模拟的，直接模拟的话可能会有些卡手，因为想使用两个set分别存 1 和 2 的包裹的话，来回选还是比较难写的。
我的做法把所有包裹放在一起按楼层排序，如何寻找最高的大小为 1 的包裹呢，想必大家都听说过树状数组二分这个东西吧？支持单点减（某个1包裹被运完），查询第k个数的值（查询楼层最大的1包裹的位置）。
但是我觉得麻烦没用树状数组，我是直接二分的，在前缀和上二分，找楼层最大的1包裹，因为答案是单调的，所以某个包裹被运完之后，我可以把二分的右区间改成这个楼层，这样就保证答案一定还没运完。
题解提供了避免区分 1 和 2 包裹的转化做法。因为保证电梯大小是偶数，这就诱使选手去思考下更简单的转化：如果我电梯只剩下1的空间，我挑选一个1包裹，和我把下一个2包裹拆成两个1，效果是一样的，都不影响最终答案。证明不难，也比较妙。最终结论就是，2包裹全拆成1包裹就行了，不用讨论了。
但是我想练练码力所以没转化。
#include <bits/stdc++.h>
#define ll long long
using namespace std;
const ll N=101010;
inline ll read() {
ll sum = 0, ff = 1; char c = getchar();
while(c<'0' || c>'9') { if(c=='-') ff = -1; c = getchar(); }
while(c>='0'&&c<='9') { sum = sum * 10 + c - '0'; c = getchar(); }
return sum * ff;
}
ll T;
ll n,K;
struct E{
ll num,fl,cl;
}a[N];
inline bool cmp(E A,E B) { return A.fl < B.fl; }
ll sum[N];
ll R;
void chushihua() {
R = 0;
}
int main() {
T = read();
while(T--) {
chushihua();
n = read(); K = read();
for(ll i=1;i<=n;i++) {
a[i].num = read(); a[i].cl = read(); a[i].fl = read();
}
sort(a+1,a+n+1,cmp);
for(ll i=1;i<=n;i++) {
sum[i] = sum[i-1] + (a[i].cl==1);
if(a[i].cl==1) R = i;
}
ll ans = 0;
for(ll i=n;i>=1;i--) {
// for(ll j=1;j<=n;j++) cout<<a[j].fl<<","<<a[j].cl<<","<<a[j].num<<" ";
// cout<<"ans = "<<ans<<endl;
if(a[i].cl * a[i].num >= K) ans += a[i].fl * ((a[i].cl * a[i].num) / K), a[i].num %= K / a[i].cl;
if(!a[i].num) continue;
ll now = K;
ll j = i;
ans += a[i].fl;
while(1) {
if(a[j].cl * a[j].num < now) now -= a[j].cl * a[j].num, a[j].num = 0;
else { a[j].num -= now / a[j].cl; now %= a[j].cl; break; }
j--;
if(j==0) break;
}
if(j==0) break;
R = min(j,R);
if(sum[R]==0 || now==0) continue;
ll l = 1, r = R, mid, res;
while(l<=r) {
mid = l+r >> 1;
if(sum[mid]==sum[j]) res = mid, r = mid-1;
else l = mid+1;
}
R = res;
a[R].num--;
if(!a[R].num) R--;
}
cout<<ans<<"\n";
}
return 0;
}
M:
好经典的题意，上一次见降雨存水的题好像是一道防AK几何。
好心的出题人怕大家做不出来，温馨地给了一个“更正式地”，其实是个关键的题意转化：\(ans = \sum\limits_{i=1}^n (min(f_i,g_i)-a_i)\)，\(f_i,g_i\) 分别表示前缀最大值和后缀最大值。这个转化是在枚举每一个位置上有多高的水柱。
更新 \(a_i\) 时，单独更新每一个位置的 \(f_i,g_i\) 是比较好更新的，可是它俩的 min 值就不是很方便更新，能不能进一步转化？
我们发现，\(f_i,g_i\)本来就是左右的最大值，这俩已经包括了全局所有的数，那么对它们取个min，是不是跟全局次大值有关呢。
只要能想到这一点，不难转化成下式：\(min(f_i,g_i) = f_i+g_i-max(f_i,g_i)=f_i+g_i-max_i\)，\(max_i\) 表示全局最大值。\(ans = \sum\limits_{i=1}^nf_i+g_i-max_i-a_i\)。
因为 \(a_i\) 的修改只有增加，这就方便了我们对这三个值的维护，比如 \(f_i\) 是单增的，就可以用 set 维护，相同的数值只需在 set 中记录第一个位置。
#include <bits/stdc++.h>
#define ll long long
using namespace std;
const ll N=501010;
const ll inf=0x3f3f3f3f3f3f3f3f;
inline ll read() {
ll sum = 0, ff = 1; char c = getchar();
while(c<'0' || c>'9') { if(c=='-') ff = -1; c = getchar(); }
while(c>='0'&&c<='9') { sum = sum * 10 + c - '0'; c = getchar(); }
return sum * ff;
}
ll T;
ll n,Q;
struct E{
ll wei,zhi;
};
inline bool operator < (E A,E B) { if(A.wei!=B.wei) return A.wei < B.wei; return A.zhi > B.zhi; }
set <E> s;
ll a[N],b[N];
ll X[N],Y[N];
ll ans[N];
ll tot,ma,F,G;
void chushihua() {
tot = ma = F = G = 0;
for(ll i=1;i<=Q;i++) ans[i] = 0;
s.clear();
}
void outing() {
cout<<"G = "<<G<<endl;
for(auto v : s) {
cout<<v.wei<<","<<v.zhi<<" ";
}
cout<<endl;
}
int main() {
T = read();
while(T--) {
chushihua();
n = read();
for(ll i=1;i<=n;i++) b[i] = a[i] = read(), tot += a[i], ma = max(a[i],ma);
Q = read();
for(ll i=1;i<=Q;i++) {
X[i] = read(); Y[i] = read();
a[X[i]] += Y[i]; ma = max(ma,a[X[i]]);
tot += Y[i];
ans[i] -= tot + ma * n;
// cout<<"i = "<<i<<" tot = "<<tot<<" ma = "<<ma<<endl;
}
a[n+1] = a[0] = inf;
for(ll i=1;i<=n;i++) a[i] = b[i];
ll now = 0;
s.insert({0,0});
for(ll i=1;i<=n+1;i++) {
if(a[i]>now) {
now = a[i];
E lst = *(--s.end());
F += (i - lst.wei) * lst.zhi;
s.insert({i,a[i]});
}
}
for(ll i=1;i<=Q;i++) {
a[X[i]] += Y[i];
E wo = {X[i], a[X[i]]};
auto it = --s.lower_bound(wo);
if((*it).zhi < a[X[i]]) {
ll shang = (*it).zhi;
s.insert(wo);
it = ++s.find(wo);
F -= shang * (it->wei - wo.wei);
while(it->zhi <= wo.zhi) {
auto nxt = ++it; it--;
F -= (nxt->wei - it->wei) * it->zhi;
s.erase(it);
it = nxt;
}
F += (it->wei - wo.wei) * wo.zhi;
}
ans[i] += F;
}
s.clear();
for(ll i=1;i<=n;i++) a[i] = b[i];
now = 0;
s.insert({-n-1,0});
for(ll i=n;i>=0;i--) {
if(a[i]>now) {
now = a[i];
E lst = *(--s.end());
G += (-i - lst.wei) * lst.zhi;
s.insert({-i, a[i]});
}
}
for(ll i=1;i<=Q;i++) {
a[X[i]] += Y[i];
E wo = {-X[i], a[X[i]]};
auto it = --s.lower_bound(wo);
if((*it).zhi < a[X[i]]) {
ll shang = (*it).zhi;
s.insert(wo);
it = ++s.find(wo);
G -= shang * (it->wei - wo.wei);
while(it->zhi <= wo.zhi) {
auto nxt = ++it; it--;
G -= (nxt->wei - it->wei) * it->zhi;
s.erase(it);
it = nxt;
}
G += (it->wei - wo.wei) * wo.zhi;
}
ans[i] += G;
}
for(ll i=1;i<=Q;i++) cout<<ans[i]<<"\n";
}
return 0;
}
D:
凸优化的树上DP。
设 \(f[u][i]\) 表示 u 这棵子树所有分支都有 i 个黑点的最小修改量，\(g[u][0/1]\) 表示把 u 这个点改成红点/黑点的代价。
有如下转化：\(f[u][i] = min(g[u][1]+\sum f[v][i-1],g[u][0]+\sum f[v][i])\) 。
i 的取值是 u 子树中最短的分支，也就是说复杂度就是所有子树中最短分支的长度和，但显然当数据是链状结构时会卡死。
喜欢拿金牌的选手们会发现，这是个可以凸优化的DP，由于 DP 转移式子是将两个序列进行 (min,+) 卷积，满足闵可夫斯基和的形式，也就是两个凸包相加融合（这个在几何题中也比较常见），两个凸序列卷完还是凸序列，g 因为只有两个值所以一定是凸的，f 通过归纳自然也能证明是凸序列。
那么凸序列有什么好处呢？我们可以用 “差分序列加首项” 来维护一个凸序列，如果凸序列存在最小值，那么差分数列是单增的。回想几何中的闵可夫斯基和，我们将两个凸包上的每一条线段合在一起按斜率进行排序，序列上的 (min,+) 卷积也是如此，将首项相加，再将两个差分数列的每一个数合在一起排序，生成新的差分数列，即为卷积后 \(f[u]\) 的序列。
回到这题的做法，我们每次求 \(f[u]\) 序列，需要先将 \(f[v]\) 直接相加，再和 \(g[u]\) 做卷积，\(f[v]\) 直接相加只需要保留最短分支的长度即可（下面的代码中用 \(sho[u]\) 表示）。
这个做法最大的好处是，我们不会被链之类的数据卡掉，当我们只有一个儿子时，直接继承它的 \(f[v]\) 数列即可。
然后是和 \(g[u]\) 做卷积，分为两种：当 u 是红点时，往差分数列加入一个1；当 u 是黑点时，首项加1，再往差分数列加入一个-1。
最终答案，也就是 \(f[1]\) 的最小值，等于首项加上差分数列最小前缀（所有负数相加）。为了避免使用平衡树维护，我们观察发现加入的数字只有1和-1，我们换个简单的写法，用三个vector来记录差分数列，一个从小到大记录负数，一个记录0，一个从大到小记录正数，加入1和-1只需在vector尾部插入即可。
思路可能比较经典，但是思考和实现难度都是妥妥的金牌题。
#include <bits/stdc++.h>
#define ll long long
#define QWQ cout<<"QwQ"<<endl;
#define FOR() ll le=e[u].size();for(ll i=0;i<le;i++)
using namespace std;
const ll N=501010;
inline ll read() {
ll sum = 0, ff = 1; char c = getchar();
while(c<'0' || c>'9') { if(c=='-') ff = -1; c = getchar(); }
while(c>='0'&&c<='9') { sum = sum * 10 + c - '0'; c = getchar(); }
return sum * ff;
}
struct E{
ll a0,he;
vector <ll> fu;
vector <ll> li;
vector <ll> zh;
}f[N],ling;
E *F[N]; // F[u] 指针指向儿子的f数列，便于直接继承。
ll T;
ll n;
char s[N];
ll cl[N];
vector <ll> e[N];
ll len[N],sho[N];
ll ans[N];
ll a[N];
void chushihua() {
for(ll i=1;i<=n;i++) len[i] = sho[i] = 0, e[i].clear();
for(ll i=1;i<=n;i++) f[i] = ling;
}
void DFS(ll u) {
len[u] = 1;
FOR() {
ll v = e[u][i];
DFS(v);
len[u] = max(len[u],len[v]+1);
F[u] = F[v];
if(!sho[u] || sho[v]+1 < sho[u]) sho[u] = sho[v]+1;
}
}
void TREE(ll u) {
FOR() TREE(e[u][i]);
if(e[u].size()>=2) {
for(ll i=0;i<=sho[u];i++) a[i] = 0;
for(ll v : e[u]) {
a[0] += (*F[v]).a0;
ll now = 1;
for(ll w : (*F[v]).fu) {
a[now] += w;
now++;
if(now>sho[u]) break;
}
if(now>sho[u]) continue;
for(ll w : (*F[v]).li) {
now++;
if(now>sho[u]) break;
}
if(now>sho[u]) continue;
for(ll i=(*F[v]).zh.size()-1;i>=0;i--) {
ll w = (*F[v]).zh[i];
a[now] += w;
now++;
if(now>sho[u]) break;
}
}
*F[u] = ling;
(*F[u]).a0 = a[0];
for(ll i=1;i<=sho[u];i++) {
if(a[i]<0) (*F[u]).fu.push_back(a[i]), (*F[u]).he += a[i];
else if(a[i]==0) (*F[u]).li.push_back(0);
}
for(ll i=sho[u];i>=1;i--) {
if(a[i]>0) (*F[u]).zh.push_back(a[i]);
else break;
}
}
if(cl[u]) (*F[u]).a0++, (*F[u]).fu.push_back(-1), (*F[u]).he--;
else (*F[u]).zh.push_back(1);
ans[u] = (*F[u]).a0 + (*F[u]).he;
}
int main() {
T = read();
while(T--) {
chushihua();
n = read();
scanf("%s",s+1);
for(ll i=1;i<=n;i++) cl[i] = s[i] - '0', F[i] = &f[i];
for(ll i=2;i<=n;i++) e[read()].push_back(i);
DFS(1);
TREE(1);
for(ll i=1;i<=n;i++) cout<<ans[i]<<" \n"[i==n];
}
return 0;
}
