#include <bits/stdc++.h>

using i64 = long long;

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int N, K;
    std::cin >> N >> K;
    
    std::vector<std::vector<int>> adj(N);
    for (int i = 1; i < N; i++) {
        int u, v;
        std::cin >> u >> v;
        u--, v--;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }
    
    std::vector<int> p(N);
    for (int i = 0; i < N; i++) {
        std::cin >> p[i];
    }
    
    std::vector<int> path;
    i64 ans = 0;
    if (K == 1) {
        std::vector<i64> sum(N);
        std::vector<int> par(N);
        par[0] = -1;
        auto dfs = [&](auto self, int x) -> void {
            if (par[x] != -1) {
                adj[x].erase(std::find(adj[x].begin(), adj[x].end(), par[x]));
            }
            sum[x] += p[x];
            for (auto y : adj[x]) {
                par[y] = x;
                sum[y] = sum[x];
                self(self, y);
            }
        };
        dfs(dfs, 0);
        
        int x = std::max_element(sum.begin(), sum.end()) - sum.begin();
        ans = sum[x];
        
        for (int i = x; i != -1; i = par[i]) {
            path.push_back(i);
        }
        std::reverse(path.begin(), path.end());
    } else if (K == 2) {
        std::vector<i64> dp1(N), dp2(N), dp3(N);
        
        std::vector<int> par(N);
        par[0] = -1;
        auto dfs = [&](auto self, int x, int option) -> void {
            if (option == 0) {
                if (par[x] != -1) {
                    adj[x].erase(std::find(adj[x].begin(), adj[x].end(), par[x]));
                }
                for (auto y : adj[x]) {
                    par[y] = x;
                    self(self, y, 0);
                }
            }
            i64 sum = 0;
            std::pair<i64, int> mx1[2] {{0, -1}, {0, -2}};
            std::pair<i64, int> mx2[2] {{0, -3}, {0, -4}};
            std::pair<i64, int> mx3[2] {{0, -5}, {0, -6}};
            for (auto y : adj[x]) {
                sum += p[y];
                std::pair<i64, int> v {dp1[y] - p[y], y};
                for (int i = 0; i < 2; i++) {
                    if (v > mx1[i]) {
                        std::swap(v, mx1[i]);
                    }
                }
                v = {dp2[y] - p[y], y};
                for (int i = 0; i < 2; i++) {
                    if (v > mx2[i]) {
                        std::swap(v, mx2[i]);
                    }
                }
                v = {dp3[y] - p[y], y};
                for (int i = 0; i < 2; i++) {
                    if (v > mx3[i]) {
                        std::swap(v, mx3[i]);
                    }
                }
            }
            if (option == 0) {
                for (int i = 0; i < 2; i++) {
                    for (int j = 0; j < 2; j++) {
                        if (mx1[i].second != mx2[j].second) {
                            dp1[x] = std::max(dp1[x], sum + mx1[i].first + mx2[j].first + p[x]);
                        }
                    }
                }
                dp2[x] = std::max(dp2[x], sum + mx3[0].first + p[x]);
                dp3[x] = std::max(dp3[x], sum + mx2[0].first + p[x]);
            } else if (option == 1) {
                path.push_back(x);
                for (int i = 0; i < 2; i++) {
                    for (int j = 0; j < 2; j++) {
                        if (mx1[i].second != mx2[j].second) {
                            if (dp1[x] == sum + mx1[i].first + mx2[j].first + p[x]) {
                                if (mx2[j].second >= 0) {
                                    self(self, mx2[j].second, 2);
                                }
                                for (auto y : adj[x]) {
                                    if (y != mx1[i].second && y != mx2[j].second) {
                                        path.push_back(y);
                                    }
                                }
                                if (mx1[i].second >= 0) {
                                    self(self, mx1[i].second, 1);
                                }
                                return;
                            }
                        }
                    }
                }
            } else if (option == 2) {
                for (auto y : adj[x]) {
                    if (y != mx3[0].second) {
                        path.push_back(y);
                    }
                }
                if (mx3[0].second >= 0) {
                    self(self, mx3[0].second, 3);
                }
                path.push_back(x);
            } else if (option == 3) {
                path.push_back(x);
                if (mx2[0].second >= 0) {
                    self(self, mx2[0].second, 2);
                }
                for (auto y : adj[x]) {
                    if (y != mx2[0].second) {
                        path.push_back(y);
                    }
                }
            }
        };
        dfs(dfs, 0, 0);
        
        ans = dp1[0];
        
        dfs(dfs, 0, 1);
    } else {
        
    }
    
    std::cout << ans << "\n";
    std::cout << path.size() << "\n";
    for (auto x : path) {
        std::cout << x + 1 << " \n"[x == path.back()];
    }
    
    return 0;
}