#include <iostream>
#include <vector>

typedef long long ll;
typedef double lf;

// #define DEBUG 1
struct IO
{
    #define MAXSIZE (1 << 20)
    #define isdigit(x) (x >= '0' && x <= '9')
    char buf[MAXSIZE], *p1, *p2;
    char pbuf[MAXSIZE], *pp;
    #if DEBUG
    #else
    IO() : p1(buf), p2(buf), pp(pbuf) {}
    ~IO() {fwrite(pbuf, 1, pp - pbuf, stdout);}
    #endif
    #define gc() (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, MAXSIZE, stdin), p1 == p2) ? ' ' : *p1++)
    #define blank(x) (x == ' ' || x == '\n' || x == '\r' || x == '\t')

    template <typename T>
    void Read(T &x)
    {
        #if DEBUG
        std::cin >> x;
        #else
        bool sign = 0; char ch = gc(); x = 0;
        for (; !isdigit(ch); ch = gc())
            if (ch == '-') sign = 1;
        for (; isdigit(ch); ch = gc()) x = x * 10 + (ch ^ 48);
        if (sign) x = -x;
        #endif
    }
    void Read(char *s)
    {
        #if DEBUG
        std::cin >> s;
        #else
        char ch = gc();
        for (; blank(ch); ch = gc());
        for (; !blank(ch); ch = gc()) *s++ = ch;
        *s = 0;
        #endif
    }
    void Read(char &c) {for (c = gc(); blank(c); c = gc());}

    void Push(const char &c)
    {
        #if DEBUG
        putchar(c);
        #else
        if (pp - pbuf == MAXSIZE) fwrite(pbuf, 1, MAXSIZE, stdout), pp = pbuf;
        *pp++ = c;
        #endif
    }
    template <typename T>
    void Write(T x)
    {
        if (x < 0) x = -x, Push('-');
        static T sta[35];
        int top = 0;
        do sta[top++] = x % 10, x /= 10; while (x);
        while (top) Push(sta[--top] ^ 48);
    }
    template <typename T>
    void Write(T x, char lst) {Write(x), Push(lst);}
} IO;
#define Read(x) IO.Read(x)
#define Write(x, y) IO.Write(x, y)
#define Put(x) IO.Push(x)

using namespace std;

const int MAXN = 2e5 + 10;

int n, K, a[MAXN];
vector <int> ans;

vector <int> e[MAXN];
int fa[MAXN];

namespace Solution1
{
    ll dis[MAXN];
    void DFS(int u, int t)
    {
        dis[u] += dis[t] + a[u], fa[u] = t;
        for (auto v : e[u])
            if (v != t) DFS(v, u);
    }
    inline void Solve()
    {
        DFS(1, 0);
        int p = 1;
        for (int i = 2; i <= n; i++)
            if (dis[i] > dis[p]) p = i;
        cout << dis[p] << "\n";
        while (p) ans.push_back(p), p = fa[p];
        cout << ans.size() << "\n";
        for (int i = ans.size() - 1; i >= 0; i--) cout << ans[i] << " ";
        cout << "\n";
    }
}

namespace Solution2
{
    ll f[MAXN][3]; int type[MAXN][3];
    int nxt[MAXN][3][3];
    void DFS(int u, int t)
    {
        ll sum = 0;
        int mx0[3] = {0}, mx1[3] = {0}, mx2[2] = {0};
        for (auto v : e[u])
            if (v != t)
            {
                DFS(v, u);
                sum += a[v];
                if (!mx0[0] || f[mx0[0]][0] - a[mx0[0]] < f[v][0] - a[v])
                    mx0[2] = mx0[1], mx0[1] = mx0[0], mx0[0] = v;
                else if (!mx0[1] || f[mx0[1]][0] - a[mx0[1]] < f[v][0] - a[v])
                    mx0[2] = mx0[1], mx0[1] = v;
                else if (!mx0[2] || f[mx0[2]][0] - a[mx0[2]] < f[v][0] - a[v])
                    mx0[2] = v;
                if (!mx1[0] || f[mx1[0]][1] - a[mx1[0]] < f[v][1] - a[v])
                    mx1[2] = mx1[1], mx1[1] = mx1[0], mx1[0] = v;
                else if (!mx1[1] || f[mx1[1]][1] - a[mx1[1]] < f[v][1] - a[v])
                    mx1[2] = mx1[1], mx1[1] = v;
                else if (!mx1[2] || f[mx1[2]][1] - a[mx1[2]] < f[v][1] - a[v])
                    mx1[2] = v;
                if (!mx2[0] || f[mx2[0]][2] - a[mx2[0]] < f[v][2] - a[v])
                    mx2[1] = mx2[0], mx2[0] = v;
                else if (!mx2[1] || f[mx2[1]][2] - a[mx2[1]] < f[v][2] - a[v])
                    mx2[1] = v;
                if (f[u][0] < f[v][2] + a[u]) f[u][0] = f[v][2] + a[u], nxt[u][0][0] = v, type[u][0] = 2;
            }
        if (e[u].size() - (u != 1) == 0)
        {
            f[u][0] = f[u][1] = f[u][2] = a[u];
            return;
        }
        // cout << "DFS " << u << ":\n";
        // for (int i = 0; i < 3; i++) cout << mx0[i] << " "; cout << "\n";
        // for (int i = 0; i < 3; i++) cout << mx1[i] << " "; cout << "\n";
        // cout << mx2 << "\n";
        int p = 0, p2; ll trs;
        while (mx0[0] == mx1[p]) p++; trs = sum + a[u] + f[mx0[0]][0] - a[mx0[0]] + f[mx1[p]][1] - a[mx1[p]];
        // cout << trs << " " << mx0[0] << " " << mx1[p] << "\n";
        // cout << type[u][0] << "\n";
        if (f[u][0] < trs) f[u][0] = trs, nxt[u][0][0] = mx1[p], nxt[u][0][1] = mx0[0], type[u][0] = 1;
        p = 0;
        while (mx1[0] == mx0[p]) p++; trs = sum + a[u] + f[mx0[p]][0] - a[mx0[p]] + f[mx1[0]][1] - a[mx1[0]];
        // cout << trs << " " << mx0[p] << " " << mx1[0] << "\n";
        if (f[u][0] < trs) f[u][0] = trs, nxt[u][0][0] = mx1[0], nxt[u][0][1] = mx0[p], type[u][0] = 1;
        // cout << f[u][0] << " " << nxt[u][0][0] << " " << nxt[u][0][1] << " " << type[u][0] << "\n";
        f[u][1] = sum + a[u] + f[mx1[0]][1] - a[mx1[0]], nxt[u][1][0] = mx1[0];
        p = 0; while (mx2[0] == mx1[p]) p++;
        f[u][2] = sum + a[u] + f[mx1[p]][1] - a[mx1[p]] + f[mx2[0]][2] - a[mx2[0]], nxt[u][2][0] = mx1[p], nxt[u][2][1] = mx2[0], type[u][2] = 4;
        p = 0; while (mx1[0] == mx2[p]) p++; trs = sum + a[u] + f[mx1[0]][1] - a[mx1[0]] + f[mx2[p]][2] - a[mx2[p]];
        if (f[u][2] < trs) f[u][2] = trs, nxt[u][2][0] = mx1[0], nxt[u][2][1] = mx2[p], type[u][2] = 4;
        p = 0; while (mx0[0] == mx1[p]) p++; p2 = p + 1; while (mx0[0] == mx1[p2]) p2++;
        trs = sum + a[u] + f[mx0[0]][0] - a[mx0[0]] + f[mx1[p]][1] - a[mx1[p]] + f[mx1[p2]][1] - a[mx1[p2]];
        if (f[u][2] < trs)
            f[u][2] = trs, nxt[u][2][0] = mx1[p], nxt[u][2][1] = mx1[p2], nxt[u][2][2] = mx0[0], type[u][2] = 5;
        // if (mx0[1] == 0) return;
        p = 0; while (mx0[1] && mx0[1] == mx1[p]) p++; p2 = p + 1; while (mx0[1] && mx0[1] == mx1[p2]) p2++;
        trs = sum + a[u] + f[mx0[1]][0] - a[mx0[1]] + f[mx1[p]][1] - a[mx1[p]] + f[mx1[p2]][1] - a[mx1[p2]];
        if (f[u][2] < trs)
            f[u][2] = trs, nxt[u][2][0] = mx1[p], nxt[u][2][1] = mx1[p2], nxt[u][2][2] = mx0[1], type[u][2] = 5;
        // if (mx0[2] == 0) return;
        p = 0; while (mx0[2] && mx0[2] == mx1[p]) p++; p2 = p + 1; while (mx0[2] && mx0[2] == mx1[p2]) p2++;
        trs = sum + a[u] + f[mx0[2]][0] - a[mx0[2]] + f[mx1[p]][1] - a[mx1[p]] + f[mx1[p2]][1] - a[mx1[p2]];
        if (f[u][2] < trs)
            f[u][2] = trs, nxt[u][2][0] = mx1[p], nxt[u][2][1] = mx1[p2], nxt[u][2][2] = mx0[2], type[u][2] = 5;
        // cout << f[u][2] << " " << nxt[u][2][0] << " " << nxt[u][2][1] << " " << nxt[u][2][2] << " " << type[u][2] << "\n";
        // cout << f[u][0] << " " << f[u][1] << "\n";
    }
    void Print(int u, int t, int x)
    {
        if (!u) return;
        // cout << u << " " << x << "\n";
        if (e[u].size() - (u != 1) == 0) return ans.push_back(u), void();
        if (x == 1)
        {
            ans.push_back(u), Print(nxt[u][1][0], u, -x);
            for (auto v : e[u])
                if (v != t && v != nxt[u][1][0]) ans.push_back(v);
            return;
        }
        if (x == -1)
        {
            for (auto v : e[u])
                if (v != t && v != nxt[u][1][0]) ans.push_back(v);
            Print(nxt[u][1][0], u, -x), ans.push_back(u);
            return;
        }
        if (x == 0)
        {
            if (type[u][0] == 2) ans.push_back(u), Print(nxt[u][0][0], u, 2);
            else
            {
                // cout << "x=0: " << u << " " << nxt[u][0][0] << " " << nxt[u][0][1] << "\n";
                ans.push_back(u), Print(nxt[u][0][0], u, -1);
                for (auto v : e[u])
                    if (v != t && v != nxt[u][0][0] && v != nxt[u][0][1]) ans.push_back(v);
                Print(nxt[u][0][1], u, 0);
            }
            return;
        }
        if (type[u][2] == 4)
        {
            for (auto v : e[u])
                if (v != t && v != nxt[u][2][0] && v != nxt[u][2][1]) ans.push_back(v);
            Print(nxt[u][2][0], u, 1), ans.push_back(u), Print(nxt[u][2][1], u, 2);
            return;
        }
        Print(nxt[u][2][0], u, 1), ans.push_back(u), Print(nxt[u][2][1], u, -1);
        for (auto v : e[u])
            if (v != t && v != nxt[u][2][0] && v != nxt[u][2][1] && v != nxt[u][2][2]) ans.push_back(v);
        Print(nxt[u][2][2], u, 0);
    }
    inline void Solve()
    {
        DFS(1, 0), Print(1, 0, 0);
        // cout << f[1][0] << "\n";
        cout << f[1][0] << "\n" << ans.size() << "\n";
        for (auto x : ans) cout << x << " ";
        cout << "\n";
        // for (int i = 1; i <= n; i++) cout << f[i][0] << " " << f[i][1] << " " << f[i][2] << "\n";
    }
}

namespace Solution3
{
    void DFS(int u, int t, bool tp)
    {
        if (tp) cout << u << " ";
        for (auto v : e[u])
            if (v != t) DFS(v, u, !tp);
        if (!tp) cout << u << " ";
    }
    inline void Solve()
    {
        ll ans = 0;
        for (int i = 1; i <= n; i++) ans += a[i];
        cout << ans << "\n" << n << "\n";
        DFS(1, 0, 1);
    }
}

int main()
{
    // freopen("B.in", "r", stdin);
    // freopen("B.out", "w", stdout);
    #if DEBUG
    #else
    ios::sync_with_stdio(0), cin.tie(0);
    #endif
    Read(n), Read(K);
    for (int i = 1, u, v; i < n; i++) Read(u), Read(v), e[u].push_back(v), e[v].push_back(u);
    for (int i = 1; i <= n; i++) Read(a[i]);
    if (K == 1) Solution1::Solve();
    else if (K == 2) Solution2::Solve();
    else Solution3::Solve();
    return 0;
}