#include <iostream>
#include <vector>
#include <map>

//triangulacja == przykro mi

using namespace std;

typedef long long LL;

struct vertex
{
    vector<int> neighbours;
    int cost;
    vector<LL> results = { -1, -1 };
};

void input(vector<vertex>& g)
{
    int n;
    cin >> n;

    g.assign(n + 1, vertex());

    for (int i = 1; i < n + 1; i++)
    {
        int x;
        cin >> x;

        g[i].cost = x;
    }

    for (int i = 0; i < n - 1; i++)
    {
        int x, y;
        cin >> x >> y;

        g[x].neighbours.push_back(y);
        g[y].neighbours.push_back(x);
    }
}

LL dfs(vector<vertex>& g, int v, int a, bool gr) //a - ancestor, gr - guarded
{
    if (g[v].results[gr] != -1)
        return g[v].results[gr];

    LL x = 0;

    if (gr)
        x += g[v].cost;

    if (!gr)
    {
        for (auto i = g[v].neighbours.begin(); i != g[v].neighbours.end(); i++)
        {
            if (*i == a)
                continue;

            x += dfs(g, *i, v, !gr);
        }
    }
    else
    {
        for (auto i = g[v].neighbours.begin(); i != g[v].neighbours.end(); i++)
        {
            if (*i == a)
                continue;

            LL a = dfs(g, *i, v, !gr);
            LL b = dfs(g, *i, v, gr);

            a < b ? x += a : x += b;
        }
    }

    return g[v].results[gr] = x;
}

void guards(vector<vertex>& g, vector<bool>& iG, int v, int a, bool gr)
{
    iG[v] = gr;

    if (gr)
    {
        for (int i = 0; i < g[v].neighbours.size(); i++)
        {
            if (i == a)
                continue;

            if (g[(i)].results[0] < g[(i)].results[1])
                guards(g, iG, i, a, false);
            else
                guards(g, iG, i, a, true);
        }
    }
    else
    {
        for (int i = 0; i < g[v].neighbours.size(); i++)
        {
            if (i == a)
                continue;

            guards(g, iG, i, a, true);
        }
    }
}

void output(vector<bool>& g, LL r, int size)
{
    cout << r << endl;

    for (int i = 1; i < size; i++)
        cout << g[i];

    cout << endl;
}

int main()
{
    int z;
    cin >> z;

    while (z--)
    {
        vector<vertex> graph;
        vector<bool> ifGuarded1, ifGuarded2;
        LL result1, result2;

        input(graph);

        ifGuarded1.assign(graph.size(), false);
        ifGuarded2.assign(graph.size(), false);

        result1 = dfs(graph, 1, 0, true);
        guards(graph, ifGuarded1, 1, 0, true);
        result2 = dfs(graph, 1, 0, false);
        guards(graph, ifGuarded2, 1, 0, false);

        if (result1 < result2)
            output(ifGuarded1, result1, graph.size());
        else
            output(ifGuarded2, result2, graph.size());
    }

    return 0;
}