#include <iostream>
#include<string>
#include <vector>
#include <queue>
#include <stack>
#include <iomanip>
#include <stdio.h>
#include <math.h>

using namespace std;

class treeNode{
public:
    int id;
    int depth;
    int parent;
    vector<int> connect;
    vector<int> children;
    int color;
    int nextChildIndex;
    bool isGood;

    treeNode(){
        id = 0;
        depth = -1;
        parent = -1;
        color = 0;
        nextChildIndex = 0;
        isGood = false;
    }

    int getNextChild(){
        int result;
        if(children.size() > nextChildIndex){
            result = children[nextChildIndex];
            nextChildIndex++;
        } else {
            result = -1;
        }
        return result;
    }
};

int main()
{

    int n;
    cin >> n;
    int a;
    int b;
    vector<treeNode> tn(n); // tn: tree node
    stack<int> nodeStack;

    for (int i = 0; i < n; i++)
    {
        cin >> tn[i].color;
    }

    for (int i = 0; i < n-1; i++)
    {
        cin >> a >> b;
        tn[a-1].connect.push_back(b-1);
        tn[b-1].connect.push_back(a-1);
    }

    tn[0].depth = 0;
    nodeStack.push(0);
    while(nodeStack.size() > 0){ // SoA か AoS か、実行時間に差はない
        int origin = nodeStack.top();
        nodeStack.pop();
        int nodes = tn[origin].connect.size();
        for (int i = 0; i < nodes; i++)
        {
            int target = tn[origin].connect[i];
            if(tn[target].depth<0){
                tn[target].parent = origin;
                tn[origin].children.push_back(target);
                tn[target].depth = tn[origin].depth + 1;
                nodeStack.push(target);
            }
        }
    }
    // ここからアルゴリズムのメイン
    tn[0].isGood = true;
    int currentNode = 0;
    vector<int> colorAccum(100010, 0);
    colorAccum[tn[0].color]++;
    while(currentNode >=  0){
        int nextNode = tn[currentNode].getNextChild();
        if(nextNode >= 0){ // 子ノードに進む場合
            if(colorAccum[tn[nextNode].color] == 0){
                tn[nextNode].isGood = true;
            }
            colorAccum[tn[nextNode].color]++;
        } else { // 親ノードに戻る場合
            nextNode = tn[currentNode].parent;
            colorAccum[tn[currentNode].color]--;
        }
        currentNode = nextNode;
    }

    for (int i = 0; i < n; i++)
    {
        if(tn[i].isGood){
            cout << (i+1) << endl;
        }
    }

    return 0;
}