Problem Statement

There is a tree with N vertices, numbered 1 through N. The i-th of the N−1 edges connects vertices ai and bi.

Currently, there are Ai stones placed on vertex i. Takahashi and Aoki will play a game using this tree.

First, Takahashi will select a vertex and place a piece on it. Then, starting from Takahashi, they will alternately perform the following operation:

• Remove one stone from the vertex currently occupied by the piece.
• Then, move the piece to a vertex that is adjacent to the currently occupied vertex.

The player who is left with no stone on the vertex occupied by the piece and thus cannot perform the operation, loses the game. Find all the vertices v such that Takahashi can place the piece on v at the beginning and win the game.

Constraints

• 2≦N≦3000
• 1≦ai,bi≦N
• 0≦Ai≦109
• The given graph is a tree.

---

Input

The input is given from Standard Input in the following format:

N
A1 A2 … AN
a1 b1
:
aN−1 bN−1

Output

Print the indices of the vertices v such that Takahashi can place the piece on v at the beginning and win the game, in a line, in ascending order.

---

Sample Input 1

Copy

3
1 2 3
1 2
2 3

Sample Output 1

Copy

2

The following is one possible progress of the game when Takahashi places the piece on vertex 2:

• Takahashi moves the piece to vertex 1. The number of the stones on each vertex is now: (1,1,3).
• Aoki moves the piece to vertex 2. The number of the stones on each vertex is now: (0,1,3).
• Takahashi moves the piece to vertex 1. The number of the stones on each vertex is now: (0,0,3).
• Aoki cannot take a stone from the vertex, and thus Takahashi wins.

---

Sample Input 2

Copy

5
5 4 1 2 3
1 2
1 3
2 4
2 5

Sample Output 2

Copy

1 2

---

Sample Input 3

Copy

3
1 1 1
1 2
2 3

Sample Output 3

Copy

Note that the correct output may be an empty line.

好妙的博弈啊！让我这个不会博弈的蒟蒻都感觉挺有趣的。

先摘一段题意：

给出一棵N个节点的树，每个节点有Ai个石头

Takahashi先选择一个节点v放置一个棋子，然后Takahashi和Aoki轮流操作（Takahashi先）

.从棋子所在节点移走一个石头

.将棋子移到与当前节点相邻的节点

不能进行操作者输（当棋子所在节点没有石头的时候不能进行操作），求所有能够使Takahashi赢的节点v

好的，现在我们都清楚了题目的意思。

那么，我们可以来口糊一个结论——从权值小的节点走到权值大的节点相当于没有走。

对于先手来说，从权值相等的点走到权值相等的点都相当于没有走。

那么，我们只需要考虑从权值大的点走向权值小的点。

设win[u]表示先手在以u为根的子树中游戏是否有必胜策略。在u有必胜策略当且仅当win[u]=1。

则考虑它的子节点。

win[u]=1当u的众多子节点里，存在一个点v，使得a[u]>a[v]&&win[v]=0。

win[u]=0当u没有子节点，或者对于u的所有子节点，都有a[u]<=a[v]||(a[u]>a[v]&&win[v]=1)。

这样我们就可以对于每一个节点，以它为根，dfs一遍，就可以求出可行点了。

还有一个问题需要探究——

就是在确定win[]时，为什么不需要考虑父节点？

来证明一发：

对于当前树的根节点，无父节点，不需考虑父节点情况；

对于每一个非根节点x，它被访问到当且仅当a[fa[x]]>a[x]，根据上面所述，x不会往fa[x]走。

所以只需要一直向下递归更新就行了。

code：

 #include<bits/stdc++.h>
 using namespace std;
 ;
 ],nxt[N<<]; bool win[N];
 void add(int x,int y) {
     nxt[++tot]=lnk[x],lnk[x]=tot,son[tot]=y;
 }
 void dfs(int x,int p) {
     win[x]=;
     for (int j=lnk[x]; j; j=nxt[j]) {
         if (son[j]==p) continue;
         if (a[x]>a[son[j]]) {
             dfs(son[j],x);
             ;
         }
     }
 }
 int main() {
     scanf("%d",&n);
     ; i<=n; i++) scanf("%d",&a[i]);
     ,x,y; i<n; i++) {
         scanf("%d%d",&x,&y);
         add(x,y),add(y,x);
     }
     ; i<=n; i++) {
         dfs(i,);
         if (win[i]) printf("%d ",i);
     }
     ;
 }

---

upd：

事实上，上述过程相当于一个dp，事实上在dp里面可以记忆化。

这显然是正确的，因为如果扫一遍扫到了它，那它是胜态还是负态就是确定的了。

所以复杂度相当于是O(n)的。