TopCoder[TCO2016 Round 1A]:EllysTree(1000)

Problem Statement

Elly has a graph with N+1 vertices, conveniently numbered from 0 to N. The graph is actually a rooted tree, with the root being the vertex with number zero.

Elly can move between the vertices of her tree by jumping from one vertex to another. Not all jumps are allowed. Elly may jump from vertex A to vertex B if and only if one of A and B is a (direct or indirect) descendant of the other.

Elly is currently standing in the root of the tree: vertex 0. She would like to make a sequence of N jumps that visits each of the other N vertices exactly once. Note that Elly is allowed to jump over previously visited vertices. For example, if A is an ancestor of B and B is an ancestor of C, Elly can jump from A to C or from C to A even if B has been already visited.

You are given the description of the tree: a vector <int> parent with N elements. For each i between 0 and N-1, inclusive, the vertex parent[i] is the parent of the vertex (i+1). If it is possible for Elly to visit each of the vertices 1 through N exactly once, return a vector <int> with N elements: the numbers of the vertices in the order in which she should visit them. If there is more than one possible answer, return the lexicographically smallest one. If there is no way to achieve her goal, return an empty vector <int> instead.

Definition

Class:	EllysTree
Method:	getMoves
Parameters:	vector <int>
Returns:	vector <int>
Method signature:	vector <int> getMoves(vector <int> parent)
(be sure your method is public)

Limits

Time limit (s):	2.000
Memory limit (MB):	256

Notes

A tree is a connected graph with N+1 vertices and N edges. A rooted tree is a tree in which one vertex is labeled as the root.

In a rooted tree, the parent of vertex X is the first vertex on the path from X to the root. The root has no parent.

In a rooted tree, vertex X is a descendant of vertex Y if Y lies on the path from X to the root.

Given two equally long but different sequences of integers A and B, A is said to be lexicographically smaller than B if A contains a smaller number on the first position where they differ.

Constraints

parent will contain between 1 and 100 elements, inclusive.

Each element of parent will be between 0 and |parent|, inclusive, where "|parent|" denotes the number of elements in parent (i.e. N).

It is guaranteed, that the given graph will be a valid rooted tree.

Examples

{9, 13, 7, 9, 8, 14, 14, 0, 6, 9, 2, 2, 5, 5, 7}

Returns: {1, 5, 2, 11, 13, 12, 8, 3, 7, 15, 14, 4, 6, 9, 10 }

The nodes Elly can jump to from node 6 are: {0, 8, 5, 14, 9, 10, 1, 4}.

{3, 4, 5, 0, 2}

Returns: {1, 2, 3, 4, 5 }

There are no branches in this tree, thus Elly can traverse it in any order.

{0, 0}

Returns: { }

The root has two children. No matter which of them Elly chooses first, she will not be able to get to the other, since the girl has to go back to the root, which is already visited.

{0, 6, 6, 2, 6, 1, 3, 5}

Returns: {2, 4, 1, 3, 7, 6, 5, 8 }

题意：给定一棵有根数，标号为0~n，你可以从根（0号点）开始，在这棵树上跳。你只能在子孙与祖先跳跃。要求跳跃n次后访问每个点各一次，并使访问序列字典序最小。

题解：

首先想到的是如何构造出一个可行的方案。我们把跳跃分为向上跳（深度减少）和向下跳（深度增加）两种。显然，叶节点只可以通过向下跳来访问，访问后也只能向上跳。对于一个非根的非叶节点，其叶节点一定会被访问，我们可以使所有的非根的非叶节点都通过向上跳来访问。

这样，构造一个可行序列的方法就是：先从根跳到一个叶节点上，在逐渐向上跳，直到跳到一个子树没有都被访问的节点。然后再跳到其子树上的一个未被访问的叶节点（一定存在），重复操作。

这样的过程可以看做是用非叶节点去消掉其下方的叶节点，可以用DP处理。

因为答案要求字典序最小，我们可以每次枚举跳到哪个点上，再DP验证之后是否存在可行方案。注意DP时应忽略被访问过的点，对于当前位于的点要特殊考虑。

步数复杂度为n，枚举复杂度为n，DP复杂度为n，总复杂度O(n^3)。

代码：

 int a[],b[],c[],dp[],v[],dp2[],dep[],siz[],now,n;

 void qq(int x,int fa)

 {

     dep[x]=dep[fa]+;

     for(int i=c[x];i;i=b[i])qq(i,x);

 }

 bool gcd(int x,int y)

 {

     if(dep[x]>dep[y])swap(x,y);

     while(dep[x]<dep[y])y=a[y];

     return x!=y;

 }

 void ss(int x)

 {

     dp[x]=; dp2[x]=; siz[x]=;

     for(int i=c[x];i;i=b[i])

     {

         ss(i); dp[x]=dp[x]+dp[i]; dp2[x]=max(dp2[x],dp2[i]); siz[x]=siz[x]+siz[i];

     }

     if((v[x]==)and(siz[x]==))dp[x]++; if(now==x)dp2[x]=;

     if((dp[x]>)and(siz[x]!=)and((v[x]==)or(now==x)))

     {

         if(dp2[x]==)dp[x]=max(dp[x]-,);else dp[x]=max(dp[x]-,);

     }

     if((v[x]==)or(x==now))siz[x]++;

 }

 class EllysTree

 {

     public:

     vector <int> getMoves(vector <int> parent)

     {

         //$CARETPOSITION$

         vector <int> ans; n=parent.size();

         for(int i=;i<n;i++)a[i+]=parent[i];

         for(int i=;i<=n;i++){ b[i]=c[a[i]]; c[a[i]]=i; }

         qq(,);

         now=; v[]=; ss(); if(dp[]>)return ans;

         for(int ii=;ii<=n;ii++)

         {

             for(int i=;i<=n;i++)

             if(v[i]==)

             {

                 if(gcd(now,i))continue;

                 int tnow=now; now=i; v[i]=; ss(); if(dp[]==){ ans.push_back(i); break; }

                 now=tnow; v[i]=;

             }

         }

         return ans;

     }

 };