// Java solution for problem E
// Author: Grzegorz Guspiel

import java.io.*;
import java.util.*;

public class e {
void out(String s) { System.out.print(s); }

final long INF = 1100100100100100100L;

class IntReader {
    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer tokenizer = new StringTokenizer("");

    int next() throws IOException {
        while (!tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(reader.readLine());
        }
        return Integer.parseInt(tokenizer.nextToken());
    }
}

int sgn(long a) {
    if (a < 0) return -1;
    else if (a == 0) return 0;
    else return 1;
}

long globalUid = 0;
class Asset implements Comparable<Asset> {
    final long required;
    final long gain;
    final long uid = globalUid++;

    Asset(long required, long gain) {
        this.required = required;
        this.gain = gain;
    }

    @Override
    public int compareTo(Asset rhs) {
        int s = sgn(required - rhs.required);
        if (s == 0) return sgn(uid - rhs.uid);
        else return s;
    }
}

class Node {
    int id;
    long value;
    ArrayList<Node> adj = new ArrayList<Node>();

    void join(TreeSet<Asset> main, TreeSet<Asset> other) {
        for (Asset asset : other) {
            main.add(new Asset(asset.required, asset.gain));
        }
    }

    TreeSet<Asset> dfs(Node parent) {
        ArrayList<TreeSet<Asset>> sets = new ArrayList<TreeSet<Asset>>();
        for (Node node : adj) if (node != parent) {
            sets.add(node.dfs(this));
        }

        TreeSet<Asset> main = new TreeSet<Asset>();
        for (TreeSet<Asset> set : sets) {
            if (main.size() < set.size()) {
                main = set;
            }
        }

        for (TreeSet<Asset> set : sets) if (set != main) {
            join(main, set);
        }
        sets = null;

        if (value > 0) {
            main.add(new Asset(0, value));
        } else {
            long required = -value;
            long gain = value;

            while (main.size() > 0 && (gain <= 0 || required >= main.first().required)) {
                required = Math.max(required, -gain + main.first().required);
                gain += main.first().gain;
                main.remove(main.first());
            }
            
            if (gain > 0) {
                main.add(new Asset(required, gain));
            }
        }

        return main;
    }
}

void solve() throws IOException {
    IntReader reader = new IntReader();
    int z = reader.next();
    for (int zz = 0; zz < z; zz++) {
        int n = reader.next();
        Node[] nodes = new Node[n + 1];

        for (int i = 0; i <= n; i++) {
            nodes[i] = new Node();
            nodes[i].id = i;
        }

        int destination = reader.next();

        for (int i = 1; i <= n; i++) nodes[i].value = reader.next();
        nodes[0].value = INF;
        nodes[0].adj.add(nodes[destination]);
        nodes[destination].adj.add(nodes[0]);

        for (int i = 0; i < n - 1; i++) {
            int a = reader.next();
            int b = reader.next();
            nodes[a].adj.add(nodes[b]);
            nodes[b].adj.add(nodes[a]);
        }

        TreeSet<Asset> finalAssets = nodes[1].dfs(null);
        long have = 0;
        while (finalAssets.size() > 0 && finalAssets.first().required <= have) {
            have += finalAssets.first().gain;
            finalAssets.remove(finalAssets.first());
        }

        if (have >= INF) out("escaped\n");
        else out("trapped\n");
    }

}

public static void main(String[] args) throws IOException {
    new e().solve();
}

} // class e