#include <bits/stdc++.h>

int32_t main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int n, k;
    std::cin >> n >> k;
    std::vector<std::vector<int>> gr(n);
    for (int i = 0; i < n - 1; i++) {
        int u, v;
        std::cin >> u >> v;
        u--;
        v--;
        gr[u].push_back(v);
        gr[v].push_back(u);
    }

    std::vector<int> p(n);
    for (int& i : p) {
        std::cin >> i;
    }
    p.push_back(0);
    {
        auto dfs = [&](auto dfs, int v, int f) -> void {
            auto it = std::find(gr[v].begin(), gr[v].end(), f);
            if (it != gr[v].end()) {
                gr[v].erase(it);
            }
            for (int& t : gr[v]) {
                dfs(dfs, t, v);
            }
        };
        dfs(dfs, 0, -1);
    }
    if (k == 1) {
        std::vector<int64_t> dist(n, 0);
        std::vector<int> prv(n, -1);
        auto dfs = [&](auto dfs, int v, int f, int64_t d) -> void {
            prv[v] = f;
            dist[v] = d;
            for (int t : gr[v]) {
                dfs(dfs, t, v, d + p[t]);
            }
        };
        dfs(dfs, 0, -1, p[0]);
        int it = std::max_element(dist.begin(), dist.end()) - dist.begin();
        int v = it;
        std::vector<int> ans;
        while (v != -1) {
            ans.push_back(v);
            v = prv[v];
        }
        std::reverse(ans.begin(), ans.end());
        std::cout << dist[it] << "\n";
        std::cout << ans.size() << "\n";
        for (int i = 0; i < ans.size(); i++) {
            std::cout << ans[i] + 1 << " \n"[i == ans.size() - 1];
        }
        return 0;
    }
    if (k == 3) {
        std::vector<int> tin(n), tout(n), depth(n);
        int e = 0;
        auto dfs = [&](auto dfs, int v, int d) -> void {
            tin[v] = e++;
            depth[v] = d;
            for (int t : gr[v]) {
                dfs(dfs, t, d + 1);
            }
            tout[v] = e++;
        };
        dfs(dfs, 0, 0);

        int64_t ans_val = std::accumulate(p.begin(), p.end(), 0ll);
        std::vector<int> ans(n);
        std::iota(ans.begin(), ans.end(), 0);
        std::sort(ans.begin(), ans.end(), [&](int a, int b) {
            auto get = [&](int i) {
                if (depth[i] % 2) {
                    return tout[i];
                }
                return tin[i];
            };
            return get(a) < get(b);
        });

        std::cout << ans_val << "\n";
        std::cout << ans.size() << "\n";
        for (int i = 0; i < ans.size(); i++) {
            std::cout << ans[i] + 1 << " \n"[i == ans.size() - 1];
        }
        return 0;
    }

    if (k == 2) {
        std::vector<std::pair<int64_t, int>> dp(n + 1);
        std::vector<std::pair<int64_t, std::pair<int, int>>> dp2(n + 1);
        auto dfs = [&](auto dfs, int v) -> void {
            int64_t sum = 0;
            for (int t : gr[v]) {
                sum += p[t];
                dfs(dfs, t);
            }
            if (gr[v].empty()) {
                dp[v] = {p[v], n};
                dp2[v] = {p[v], {n, n}};
                return;
            }
            for (int t : gr[v]) {
                dp[v] = std::max(dp[v], {p[v] + sum - p[t] + dp[t].first, t});
            }
            std::array<int, 3> cum1, cum2;
            cum1.fill(n);
            cum2.fill(n);
            for (int t : gr[v]) {
                cum1[2] = t;
                std::sort(cum1.begin(), cum1.end(), [&](int a, int b) { return dp[a] > dp[b]; });
                cum2[2] = t;
                std::sort(cum2.begin(), cum2.end(), [&](int a, int b) { return dp2[a] > dp2[b]; });
            }
            for (int a = 0; a < 2; a++) {
                for (int b = 0; b < 2; b++) {
                    if (cum1[a] != cum2[b]) {
                        dp2[v] = std::max(dp2[v], {p[v] + sum - p[cum1[a]] - p[cum2[b]] + dp[cum1[a]].first + dp2[cum2[b]].first, {cum1[a], cum2[b]}});
                    }
                }
            }
        };
        dfs(dfs, 0);

        auto get_cum = [&](int v) {
            std::deque<int> res;
            bool rev = false;

            auto add = [&](bool back, int val) {
                assert(res.size() < 1e6);
                if (back != rev) {
                    res.push_back(val);
                } else {
                    res.push_front(val);
                }
            };
            auto f = [&](auto f, int v) -> void {
                if (v == n) {
                    return;
                }
                int nxt = dp[v].second;
                f(f, nxt);

                rev = !rev;
                for (int t : gr[v]) {
                    if (t != nxt) {
                        add(0, t);
                    }
                }
                add(0, v);
            };
            f(f, v);

            if (rev) {
                std::reverse(res.begin(), res.end());
            }
            return std::vector<int>(res.begin(), res.end());
        };

        int v = 0;
        std::vector<int> ans;
        while (v != n) {
            auto [val, pp] = dp2[v];
            auto [a, b] = pp;
            ans.push_back(v);
            for (int t : gr[v]) {
                if (t != a && t != b) {
                    ans.push_back(t);
                }
            }
            auto vc = get_cum(a);
            ans.insert(ans.end(), vc.begin(), vc.end());
            v = b;
            assert(ans.size() < 1e6);
        }

        std::cout << dp2[0].first << "\n";
        std::cout << ans.size() << "\n";
        for (int i = 0; i < ans.size(); i++) {
            std::cout << ans[i] + 1 << " \n"[i == ans.size() - 1];
        }
        return 0;
    }

    return 0;
}