// #define _GLIBCXX_DEBUG

#include <bits/stdc++.h>

using namespace std;

#define int long long
#define ll long long
#define flt double
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()

mt19937 rnd(234);
const ll inf = 1e18;

int n, k;
vector<ll> a;
vector<vector<int>> g;
vector<int> prnt;
vector<int> ans;
vector<int> szs;
vector<ll> dp, dp_ret, dp_aboba;

void build_szs(int v) {
    szs[v] = 1;
    int mx_sz = -1;
    int mx_sz_pos = -1;
    for (int i = 0; i < (int)g[v].size(); i += 1) {
        int to = g[v][i];
        build_szs(to);
        szs[v] += szs[to];
        if (szs[to] > mx_sz) {
            mx_sz = szs[to];
            mx_sz_pos = i;
        }
    }
    if (mx_sz_pos != -1) {
        swap(g[v][0], g[v][mx_sz_pos]);
    }
}

void dfs0(int v, int p) {
    prnt[v] = p;
    auto it = find(all(g[v]), p);
    if (it != g[v].end()) {
        g[v].erase(it);
    }
    for (auto to : g[v]) {
        dfs0(to, v);
    }
}

void dfs1(int v, ll sm, pair<ll, int> &rs) {
    sm += a[v];
    rs = max(rs, make_pair(sm, v));
    for (auto to : g[v]) {
        dfs1(to, sm, rs);
    }
}

void dfs2(int v) {
    if(g[v].empty()){
        dp[v] = a[v];
        dp_ret[v] = a[v];
        return;
    }
    ll sm = 0;
    for (auto to : g[v]) {
        dfs2(to);
        sm += a[to];
    }
    int sns = g[v].size();
    vector<pair<ll, int>> srtd_dp(sns), srtd_dp_ret(sns), srtd_dp_aboba(sns);
    for(int i = 0; i < sns; i += 1){
        int to = g[v][i];
        srtd_dp[i] = make_pair(dp[to], i);
        srtd_dp_ret[i] = make_pair(dp_ret[to], i);
        srtd_dp_aboba[i] = make_pair(dp_aboba[to], i);
    }
    sort(rall(srtd_dp));
    sort(rall(srtd_dp_ret));
    sort(rall(srtd_dp_aboba));
    dp_ret[v] = max(dp_ret[v], a[v] + srtd_dp_ret[0].first + sm - a[g[v][srtd_dp_ret[0].second]]);
    dp_aboba[v] = max(dp_aboba[v], srtd_dp[0].first + sm - a[g[v][srtd_dp[0].second]]);
    dp[v] = max(dp[v], a[v] + srtd_dp[0].first + sm - a[g[v][srtd_dp[0].second]]);
    for(int i = 0; i < sns && i < 4; i += 1){
        for(int j = 0; j < sns && j < 4; j += 1){
            if(srtd_dp_ret[i].second != srtd_dp[j].second){
                dp_aboba[v] = max(dp_aboba[v], a[v] + srtd_dp_ret[i].first + srtd_dp[j].first + sm - a[g[v][srtd_dp_ret[i].second]] - a[g[v][srtd_dp[j].second]]);
                dp[v] = max(dp[v], a[v] + srtd_dp_ret[i].first + srtd_dp[j].first + sm - a[g[v][srtd_dp_ret[i].second]] - a[g[v][srtd_dp[j].second]]);
            }
            if(srtd_dp_ret[i].second == srtd_dp_ret[j].second){
                continue;
            }
            for(int k = 0; k < sns && k < 4; k += 1){
                if(srtd_dp_ret[i].second == srtd_dp[k].second || srtd_dp_ret[j].second == srtd_dp[k].second){
                    continue;
                }
                dp_aboba[v] = max(dp_aboba[v], a[v] + srtd_dp_ret[i].first + srtd_dp_ret[j].first + srtd_dp[k].first + sm - a[g[v][srtd_dp_ret[i].second]] - a[g[v][srtd_dp_ret[j].second]] - a[g[v][srtd_dp[k].second]]);
            }
        }
    }
}

list<int>::iterator dfs3(int v, list<int> &rs, list<int>::iterator it, bool rvrsd) {
    auto ret_val = it;
    if (!rvrsd) {
        ret_val = rs.insert(it, v);
    } else {
        it = rs.insert(it, v);
    }
    for (int i = 0; i < (int)g[v].size(); i += 1) {
        int to = g[v][i];
        if (!rvrsd) {
            dfs3(to, rs, it, !rvrsd);
        } else {
            it = dfs3(to, rs, it, !rvrsd);
        }
    }
    return ret_val;
}

ll solve() {
    ans.clear();
    if (k == 1) {
        pair<ll, int> rs = {-1, -1};
        dfs1(0, 0, rs);
        vector<int> way;
        int v = rs.second;
        while (v != -1) {
            way.push_back(v);
            v = prnt[v];
        }
        reverse(all(way));
        ans = way;
        return rs.first;
    }
    if (k == 2) {
        dp.assign(n, -1);
        dp_ret.assign(n, -1);
        dp_aboba.assign(n, -1);
        dfs2(0);
        
        return -1;
    }
    if (k == 3) {
        szs.resize(n);
        build_szs(0);
        list<int> rs;
        dfs3(0, rs, rs.begin(), false);
        for (auto x : rs) {
            ans.push_back(x);
        }
        ll sm = 0;
        for (int i = 0; i < n; i += 1) {
            sm += a[i];
        }
        return sm;
    }
    assert(0);
    return -1;
}

int32_t main() {
    if (1) {
        ios::sync_with_stdio(0);
        cin.tie(0);
        cout.tie(0);
    }
    cin >> n >> k;
    g.assign(n, vector<int>());
    for (int i = 0; i < n - 1; i += 1) {
        int u, v;
        cin >> u >> v;
        --u;
        --v;
        g[u].push_back(v);
        g[v].push_back(u);
    }
    a.resize(n);
    for (int i = 0; i < n; i += 1) {
        cin >> a[i];
    }
    prnt.resize(n);
    dfs0(0, -1);
    ll rs = solve();
    cout << rs << "\n";
    cout << (int)ans.size() << "\n";
    for (auto t : ans) {
        cout << t + 1 << " ";
    }
    cout << "\n";
    return 0;
}

/*
10 3
1 2
2 3
2 4
2 5
5 6
1 7
7 8
7 9
8 10
1 1 1 1 1 1 1 1 1 1

*/