#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int MAXN = 2e5 + 5;
const ll linf = 0x3f3f3f3f3f3f3f3f;

inline void chk_max(ll &a,ll b){ if(a<b) a=b;}

int n,d;
int p[MAXN];
vector<int> g[MAXN];

namespace P1
{
	ll h[MAXN];
	int son[MAXN];
	void dfs_h(int u,int fa)
	{
		for(int v: g[u]) if(v != fa)
		{
			dfs_h(v,u);
			if(h[v] > h[son[u]])
				son[u] = v;
		}
		h[u] = h[son[u]] + p[u];
	}
	
	void solve(void)
	{
		dfs_h(1,0);
		
		vector<int> vec;
		for(int u=1; u; u=son[u])
			vec.emplace_back(u);
		
		printf("%lld\n",h[1]);
		printf("%d\n",(int)vec.size());
		for(auto t: vec)
			printf("%d ",t);
	}
}

namespace P2
{
	struct Data
	{
		ll val;
		array<int,3> a;
		Data(void){ val = -linf; a.fill(0);}
		Data(ll k,int u){ val = k; a.fill(0); a[0] = u;}
		void chk(const Data &oth,int i,int u,ll k)
		{
			if(val >= oth.val + k) return;
			val = oth.val + k;
			a = oth.a;
			if(i != -1) a[i] = u;
		}
		void chk(const Data &oth)
		{
			if(val < oth.val) *this = oth;
		}
	};
	
	vector<int> save_ch[MAXN];
	ll c[MAXN], fin[MAXN], sp[MAXN];
	int use_c[MAXN];
	Data fin1[MAXN], fin2[MAXN], sp1[MAXN], sp2[MAXN];
	
	void dfs_dp(int u,int fa)
	{
		vector<int> ch;
		for(int v: g[u]) if(v != fa)
		{
			dfs_dp(v,u);
			ch.emplace_back(v);
		}
		save_ch[u] = ch;
		
		c[u] = sp[u] = fin[u] = -linf;
		
		{
			vector<Data> tmp(8), nxt(8);
			for(int i=0; i<8; ++i)
				tmp[i].val = p[u];
			for(int v: ch)
			{
				fill(nxt.begin(), nxt.end(), Data());
				for(int mask=0; mask<8; ++mask)
				{
					nxt[mask].chk(tmp[mask], -1, v, p[v]);
					if((mask & 1) == 0) nxt[mask | 1].chk(tmp[mask], 0, v, c[v]);
					if((mask & 2) == 0) nxt[mask | 2].chk(tmp[mask], 1, v, c[v]);
					if((mask & 4) == 0) nxt[mask | 4].chk(tmp[mask], 2, v, fin[v]);
				}
				tmp.swap(nxt);
			}
			
			c[u] = tmp[1].val; use_c[u] = tmp[1].a[0];
			fin1[u] = tmp[6];
			sp1[u] = tmp[7];
		}
		
		{
			vector<Data> tmp(4), nxt(4);
			for(int i=0; i<4; ++i)
				tmp[i].val = p[u];
			for(int v: ch)
			{
				fill(nxt.begin(), nxt.end(), Data());
				for(int mask=0; mask<4; ++mask)
				{
					nxt[mask].chk(tmp[mask], -1, v, p[v]);
					if((mask & 1) == 0) nxt[mask | 1].chk(tmp[mask], 0, v, c[v]);
					if((mask & 2) == 0) nxt[mask | 2].chk(tmp[mask], 1, v, sp[v]);
				}
				tmp.swap(nxt);
			}
			
			fin2[u] = tmp[2];
			sp2[u] = tmp[3];
		}
		
		fin[u] = max(fin1[u].val, fin2[u].val);
		sp[u] = max(sp1[u].val, sp2[u].val);
	}
	
	vector<int> ans;
	
	void push(int u)
	{
		ans.emplace_back(u);
	}
	
	void print_c(int,int);
	void print_sp(int);
	void print_fin(int);
	
	void print_c(int u,int type)
	{
		int x = use_c[u];
		auto ch = save_ch[u];
		if(type == 0)
		{
			push(u);
			if(x) print_c(x, type ^ 1);
			for(int v: ch) if(v != x)
				push(v);
		}
		else
		{
			for(int v: ch) if(v != x)
				push(v);
			if(x) print_c(x, type ^ 1);
			push(u);
		}
	}
	
	void print_fin1(int u)
	{
		auto t = fin1[u].a;
		auto ch = save_ch[u];
		push(u);
		if(t[0]) print_c(t[0], 1);
		for(auto v: ch)
			if(v != t[0] && v != t[1])
				push(v);
		if(t[1]) print_fin(t[1]);
	}
	void print_fin2(int u)
	{
		auto t = fin2[u].a;
		push(u);
		if(t[0]) print_sp(t[0]);
	}
	void print_fin(int u)
	{
		if(fin1[u].val >= fin2[u].val)
			print_fin1(u);
		else
			print_fin2(u);
	}
	
	void print_sp1(int u)
	{
		auto t = sp1[u].a;
		auto ch = save_ch[u];
		
		if(t[0]) print_c(t[0], 0);
		push(u);
		if(t[1]) print_c(t[1], 1);
		for(auto v: ch)
			if(v != t[0] && v != t[1] && v != t[2])
				push(v);
		if(t[2]) print_fin(t[2]);
	}
	void print_sp2(int u)
	{
		auto t = sp2[u].a;
		auto ch = save_ch[u];
		
		for(auto v: ch)
			if(v != t[0] && v != t[1] && v != t[2])
				push(v);
		if(t[0]) print_c(t[0], 0);
		push(u);
		if(t[1]) print_sp(t[1]);
	}
	void print_sp(int u)
	{
		if(sp1[u].val >= sp2[u].val)
			print_sp1(u);
		else
			print_sp2(u);
	}
	
	void solve(void)
	{
		dfs_dp(1,0);
		print_fin(1);
		
		printf("%lld\n",fin[1]);
		printf("%d\n",(int)ans.size());
		for(auto t: ans)
			printf("%d ",t);
	}
}

namespace P3
{
	void dfs(int u,int fa,int type)
	{
		if(type == 0) printf("%d ",u);
		for(auto v: g[u]) if(v != fa)
			dfs(v, u, type ^ 1);
		if(type == 1) printf("%d ",u);
	}
	
	void solve(void)
	{
		ll ans = accumulate(p+1, p+n+1, 0ll);
		printf("%lld\n",ans);
		printf("%d\n",n);
		dfs(1,0,0);
	}
}

int main(void)
{
//	freopen("a.in","r",stdin);
	
	scanf("%d%d",&n,&d);
	for(int i=1; i<n; ++i)
	{
		int u,v;
		scanf("%d%d",&u,&v);
		g[u].emplace_back(v);
		g[v].emplace_back(u);
	}
	for(int i=1; i<=n; ++i)
		scanf("%d",&p[i]);
	
	if(d == 1) P1 :: solve();
	else if(d == 2) P2 :: solve();
	else if(d == 3) P3 :: solve();
	return 0;
}