#include <bits/stdc++.h>

#define f first
#define s second
#define pb push_back
#define mp make_pair

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<long long, long long> pll;

const int N = 300500, inf = 1e9, mod = 998244353;
const ll INF = 1e18;

int sum(int a, int b) {
    a += b;
    if (a >= mod)
        a -= mod;
    return a;
}

int sub(int a, int b) {
    a -= b;
    if (a < 0)
        a += mod;
    return a;
}

int mult(int a, int b) {
    return 1ll * a * b % mod;
}

int bp(int a, int b) {
    int res = 1;
    while (b) {
        if (b & 1)
            res = mult(res, a);
        a = mult(a, a);
        b >>= 1;
    }
    return res;
}

int inv(int x) {
    return bp(x, mod - 2);
}

int n, k, a[N];
vector<int> g[N];

void pre_dfs(int v, int p) {
    for (int i = 0; i < g[v].size(); i++) {
        if (g[v][i] == p) {
            swap(g[v][i], g[v][g[v].size() - 1]);
            g[v].pop_back();
        }
    }
    for (auto to: g[v])
        pre_dfs(to, v);
}

namespace K1 {
    ll d[N];
    int pr[N];

    void dfs(int v) {
        for (auto to: g[v]) {
            d[to] = d[v] + a[to];
            pr[to] = v;
            dfs(to);
        }
    }

    void solve() {
        d[0] = a[0], pr[0] = -1;
        dfs(0);
        int v = max_element(d, d + n) - d;

        cout << d[v] << "\n";

        vector<int> ans;
        while (v != -1) {
            ans.pb(v);
            v = pr[v];
        }
        reverse(ans.begin(), ans.end());

        cout << ans.size() << "\n";
        for (auto x: ans)
            cout << x + 1 << " ";
        cout << "\n";
    }
}


namespace K3 {
    void dfs(int v, int f) {
        if (f)
            cout << v + 1 << " ";
        for (auto to: g[v])
            dfs(to, f ^ 1);
        if (!f)
            cout << v + 1 << " ";
    }

    void solve() {
        ll s = 0;
        for (int i = 0; i < n; i++)
            s += a[i];
        cout << s << "\n";
        cout << n << "\n";
        dfs(0, 1);
        cout << "\n";
    }
}


namespace K2 {
    ll dp[N][2][3];

    vector<int> ans;

    void dfs(int v) {
        for (auto to: g[v])
            dfs(to);
        {
            ll res = a[v];
            dp[v][0][0] = res;
        }
        {
            ll res = 0;
            ll s = 0;
            for (auto to: g[v])
                s += dp[to][0][0];
            for (auto to: g[v])
                res = max(res, s - dp[to][0][0] + dp[to][1][0]);
            dp[v][0][1] = res + a[v];
        }
        {
            ll res = 0;
            ll s = 0;
            for (auto to: g[v])
                s += dp[to][0][0];
            for (auto to1: g[v])
                for (auto to2: g[v])
                    if (to1 != to2)
                        res = max(res, s - dp[to1][0][0] - dp[to2][0][0] + dp[to1][1][0] + dp[to2][0][2]);
            for (auto to: g[v])
                res = max(res, s - dp[to][0][0] + dp[to][0][2]);
            for (auto to: g[v])
                res = max(res, s - dp[to][0][0] + dp[to][1][0]);
            for (auto to: g[v])
                res = max(res, dp[to][1][2]);
            dp[v][0][2] = res + a[v];
        }
        {
            ll res = 0;
            ll s = 0;
            for (auto to: g[v])
                s += dp[to][0][0];
            for (auto to: g[v])
                res = max(res, s - dp[to][0][0] + dp[to][0][1]);
            dp[v][1][0] = res + a[v];
        }
        {
            ll res = 0;
            dp[v][1][1] = -INF;
        }
        {
            ll res = dp[v][1][0];
            res = max(res, dp[v][0][2]);
            ll s = 0;
            for (auto to: g[v])
                s += dp[to][0][0];
            for (auto to1: g[v])
                for (auto to2: g[v])
                    if (to1 != to2)
                        res = max(res, s - dp[to1][0][0] - dp[to2][0][0] + dp[to1][0][1] + dp[to2][1][2] + a[v]);
            for (auto to1: g[v])
                for (auto to2: g[v])
                    for (auto to3: g[v])
                        if (to1 != to2 && to1 != to3 && to2 != to3)
                            res = max(res,
                                      s - dp[to1][0][0] - dp[to2][0][0] - dp[to3][0][0] + dp[to1][0][1] +
                                      dp[to2][1][0] +
                                      dp[to3][0][2] + a[v]);
            dp[v][1][2] = res;
        }
        assert(dp[v][0][1] == dp[v][1][0]);
    }

    void flex(int v, int i, int j) {
        if(dp[v][i][j] == a[v]) {
            ans.pb(v);
            return;
        }

        if (i == 0 && j == 1) {
            int u;
            ll s = 0;
            for (auto to: g[v])
                s += dp[to][0][0];
            for (auto to: g[v])
                if (s - dp[to][0][0] + dp[to][1][0] == dp[v][i][j] - a[v])
                    u = to;
            ans.pb(v);
            flex(u, 1, 0);
            for (auto to: g[v])
                if (to != u)
                    flex(to, 0, 0);
            return;
        }

        if (i == 0 && j == 2) {
            ll s = 0;
            for (auto to: g[v])
                s += dp[to][0][0];


            for (auto to: g[v]) {
                if (dp[to][1][2] == dp[v][i][j] - a[v]) {
                    ans.pb(v);
                    flex(to, 1, 2);
                    return;
                }
                if (s - dp[to][0][0] + dp[to][0][2] == dp[v][i][j] - a[v]) {
                    ans.pb(v);
                    for (auto u: g[v])
                        if (u != to)
                            flex(u, 0, 0);
                    flex(to, 0, 2);
                    return;
                }
            }
            for (auto to1: g[v])
                for (auto to2: g[v])
                    if (to1 != to2 &&
                        s - dp[to1][0][0] - dp[to2][0][0] + dp[to1][1][0] + dp[to2][0][2] == dp[v][i][j] - a[v]) {
                        ans.pb(v);
                        flex(to1, 1, 0);
                        for (auto u: g[v])
                            if (u != to1 && u != to2)
                                flex(u, 0, 0);
                        flex(to2, 0, 2);
                        return;
                    }
            if(dp[v][i][j] == a[v]) {
                ans.pb(v);
                return;
            }
        }
        if (i == 1 && j == 0) {
            ll s = 0;
            for (auto to: g[v])
                s += dp[to][0][0];
            for (auto to: g[v])
                if (s - dp[to][0][0] + dp[to][0][1] == dp[v][i][j] - a[v]) {
                    for (auto u: g[v])
                        if (u != to)
                            flex(u, 0, 0);
                    flex(to, 0, 1);
                    ans.pb(v);
                    return;
                }
        }
        if (i == 1 && j == 1) {

        }
        if (i == 1 && j == 2) {
            if (dp[v][0][2] == dp[v][i][j]) {
                flex(v, 0, 2);
                return;
            }

            ll s = 0;
            for (auto to: g[v])
                s += dp[to][0][0];
            for (auto to1: g[v])
                for (auto to2: g[v])
                    if (to1 != to2 &&
                        s - dp[to1][0][0] - dp[to2][0][0] + dp[to1][0][1] + dp[to2][1][2] + a[v] == dp[v][i][j]) {
                        for (auto u: g[v])
                            if (u != to1 && u != to2)
                                flex(u, 0, 0);
                        flex(to1, 0, 1);
                        ans.pb(v);
                        flex(to2, 1, 2);
                        return;
                    }

            for (auto to1: g[v])
                for (auto to2: g[v])
                    for (auto to3: g[v])
                        if (to1 != to2 && to1 != to3 && to2 != to3 &&
                            s - dp[to1][0][0] - dp[to2][0][0] - dp[to3][0][0] + dp[to1][0][1] +
                            dp[to2][1][0] +
                            dp[to3][0][2] + a[v] == dp[v][i][j]) {

                            flex(to1, 0, 1);
                            ans.pb(v);
                            flex(to2, 1, 0);
                            for (auto u: g[v])
                                if (u != to1 && u != to2 && u != to3)
                                    flex(u, 0, 0);
                            flex(to3, 0, 2);
                            return;
                        }
        }
        assert(0);
    }

    void solve() {
        dfs(0);
        flex(0, 0, 2);
        cout << dp[0][0][2] << "\n";
        cout << ans.size() << "\n";
        for (auto x: ans)
            cout << x + 1 << " ";
        cout << "\n";
    }

}

void solve() {
    cin >> n >> k;
    for (int i = 0; i < n - 1; i++) {
        int v, u;
        cin >> v >> u;
        v--, u--;
        g[v].pb(u);
        g[u].pb(v);
    }
    for (int i = 0; i < n; i++)
        cin >> a[i];
    pre_dfs(0, -1);
    if (k == 1)K1::solve();
    if (k == 2)K2::solve();
    if (k == 3)K3::solve();
}

int main() {
#ifdef DEBUG
    freopen("input.txt", "r", stdin);
#endif
    ios_base::sync_with_stdio(false);
    int t = 1;
//    cin >> t;
    for (int i = 1; i <= t; i++) {
//        cout << "Case #" << i << endl;
        solve();
    }
}