Codeforces Round #596 (Div. 2, based on Technocup 2020 Elimination Round 2) F. Tree Factory 構造題

F. Tree Factory

Bytelandian Tree Factory produces trees for all kinds of industrial applications. You have been tasked with optimizing the production of a certain type of tree for an especially large and important order.

The tree in question is a rooted tree with n vertices labelled with distinct integers from 0 to n−1. The vertex labelled 0 is the root of the tree, and for any non-root vertex v the label of its parent p(v) is less than the label of v.

All trees at the factory are made from bamboo blanks. A bamboo is a rooted tree such that each vertex has exactly one child, except for a single leaf vertex with no children. The vertices of a bamboo blank can be labelled arbitrarily before its processing is started.

To process a bamboo into another tree a single type of operation can be made: choose an arbitrary non-root vertex v such that its parent p(v) is not a root either. The operation consists of changing the parent of v to its parent's parent p(p(v)). Note that parents of all other vertices remain unchanged, in particular, the subtree of v does not change.

Efficiency is crucial, hence you have to minimize the number of operations to make the desired tree from a bamboo blank. Construct any optimal sequence of operations to produce the desired tree.

Note that the labelling of the resulting tree has to coincide with the labelling of the desired tree. Formally, the labels of the roots have to be equal, and for non-root vertices with the same label the labels of their parents should be the same.

It is guaranteed that for any test present in this problem an answer exists, and further, an optimal sequence contains at most 106 operations. Note that any hack that does not meet these conditions will be invalid.

Input

The first line contains a single integer n — the number of vertices in the tree (2≤n≤105).

The second line contains n−1 integers p(1),…,p(n−1) — indices of parent vertices of 1,…,n−1 respectively (0≤p(i)<i).

Output

In the first line, print n distinct integers id1,…,idn — the initial labelling of the bamboo blank starting from the root vertex (0≤idi<n).

In the second line, print a single integer k — the number of operations in your sequence (0≤k≤106).

In the third line print k integers v1,…,vk describing operations in order. The i-th operation consists of changing p(vi) to p(p(vi)). Each operation should be valid, i.e. neither vi nor p(vi) can be the root of the tree at the moment.

Examples

input
5
0 0 1 1

output
0 2 1 4 3
2
1 3

input
4
0 1 2

output
0 1 2 3
0

題意

如今有一個鏈，而後每次操做能夠使得fa[x]=fa[fa[x]]，就是使得本身的爺爺變成本身的父親。而後操做若干次，就會變成一顆樹。

如今題目給你一個根爲0的樹，說這個是由一條鏈操做獲得的，讓你還原這條鏈的樣子，並輸出方案，要求操做次數最少。

題解

咱們把操做轉換一下，其實就是使得一個子樹的父親，變成本身的兄弟。

咱們手動模擬一下，能夠發現，樹鏈的長度是必定的，咱們若是讓深度大於等於他的子樹插進去的話，那麼深度確定會+1的，因而咱們就每次插入深度大於等於他的就行了。

代碼

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+7;
int fa[maxn],mx[maxn],n;
vector<int>son[maxn];
vector<int>order;
bool cmp(int x,int y){
    return mx[x]<mx[y];
}
void dfs1(int x){
    for(int i=0;i<son[x].size();i++){
        dfs1(son[x][i]);
        mx[x]=max(mx[x],mx[son[x][i]]+1);
    }
    sort(son[x].begin(),son[x].end(),cmp);
}
void dfs2(int x){
    cout<<x<<" ";
    for(int i=0;i<son[x].size();i++){
        dfs2(son[x][i]);
        if(i==0)continue;
        for(int j=0;j<=mx[son[x][i-1]];j++){
            order.push_back(son[x][i]);
        }
    }
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<n;i++){
        scanf("%d",&fa[i]);
        son[fa[i]].push_back(i);
    }
    dfs1(0);
    dfs2(0);
    cout<<endl;
    cout<<order.size()<<endl;
    for(int i=0;i<order.size();i++){
        cout<<order[i]<<" ";
    }
    cout<<endl;
}