#ifdef LOCAL
#include <cstdio>
#include <vector>
#include <algorithm>
#include <iostream>
#include <cstring>
#include <map>
#else
#include <bits/stdc++.h>
#endif
using namespace std ;

typedef long long ll ;
typedef unsigned long long ull ;
#define rep(i , n ) for ( int i =0; i < n ; i++)
#define rrep(i , n) for ( int i = n-1; i >=0 ; i--)

#define _sort(arg) sort(begin(arg), end(arg))
#define MOD 1000000007
#define pb push_back
#define DEBUG(x) cout << #x << ": " << x << endl;

class UnionFind {
private:
	ull size_; 
	std::vector<ull> par, rank, count;

public:
	UnionFind() : size_(0), par(std::vector<ull>()), rank(std::vector<ull>()), count(std::vector<ull>()) {};
	UnionFind(ull size__) : size_(size__) {
		par.resize(size_); rank.resize(size_); count.resize(size__);
		for (ull i = 0; i < size_; i++) par[i] = i, rank[i] = 0, count[i] = 1;
	}
	ull size() { return size_; }
	// ull root(ull x) { return par[x] == x ? x : par[x] = root(par[x]); }
	
	ull root(ull x)
	{
		while(par[x] != x)
		{
			par[x] = par[par[x]];
			x = par[x];
		}
		return x;
	}
	
	bool same(ull x, ull y) { return root(x) == root(y); }

	void unite(ull x, ull y) {
		x = root(x), y = root(y);
		if (x == y) return;
		if (rank[x] < rank[y]) par[x] = y, count[y]+=count[x], count[x]=0;
		else if (rank[x] == rank[y]) par[y] = x, rank[x]++, count[x]+=count[y], count[y]=0;
		else par[y] = x, count[x] += count[y], count[y] = 0;
	}

	ull size__(ull x)
	{
		return count[root(x)];
	}

	bool operator==(const UnionFind &u) { return par == u.par; }
	bool operator!=(const UnionFind &u) { return par != u.par; }
};
/*
maybe sth wrong 
got wa in one problem
*/
ll modpow(ll a, ll b)
{
	if (b == 0)
	{
		return 1;
	}

	if (b % 2)
	{
		return a * modpow(a, b-1) % MOD;
	}
	else
	{
		ll halfB = b / 2;
		ll half = modpow(a, halfB);
		return half * half % MOD;
	}
}

ll calcComb(ll n, ll m)
{
	if (m > n-m)
	{
		return calcComb(n, n-m);
	}

	ll ansMul = 1;
	ll ansDiv = 1;

	rep(i, m)
	{
		ansMul *= (n-i);
		ansDiv *= (i+1);
		ansMul %= MOD;
		ansDiv %= MOD;
	}

	return ansMul * modpow(ansDiv, MOD - 2) % MOD;
}

__attribute__((constructor))
void initial()
{
	cin.tie(NULL);
	ios::sync_with_stdio(false);
}

struct Edge
{
	int to;
	int nxt;
}e[200005];
int n,m,edgenum,head[100005],c[100005],ans[100005],pa[100005];
void add(int u,int v)
{
	e[++edgenum].to=v;
	e[edgenum].nxt=head[u];
	head[u]=edgenum;
}
int ind=0;
void dfs(int node)
{
	//ans[node]=c[++ind];
	ans[node]=c[ind++];
	for(int hd=head[node];hd;hd=e[hd].nxt)
	{
		int to=e[hd].to;
		if(to==pa[node])continue;
		pa[to]=node;
		dfs(to);
	}
}
bool cmp(int a,int b)
{
	return a>b;
}

int main()
{
	int N;
	
	cin >> N;
	/*
	map<int, vector<int> > m;
	bool visited[N];
	rep(i, N)
	{
		visited[i] = false;
	}
	
	rep(i, N-1)
	{
		int a, b;
		cin >> a >> b;
		a--;
		b--;
		if (m.count(a))
		{
			m[a].pb(b);
		}
		else
		{
			vector<int> edges;
			edges.pb(b);
			m[a] = edges;
		}
		
		if (m.count(b))
		{
			m[b].pb(a);
		}
		else
		{
			vector<int> edges;
			edges.pb(a);
			m[b] = edges;
		}
	}

	int c[N];
	int max_ = 0;
	int total = 0;
	rep(i, N)
	{
		cin >> c[i];
		total += c[i];
		max_ = max(max_, c[i]);
	}

	total -= max_;
	sort(c, c+N, greater<int>());
	int i = 0;
	int d[N];
	//cout << "h" << endl;
	for(map<int, vector<int> >::iterator it = m.begin(); it != m.end(); ++it)
	{
		//cout << it->first << endl;
		if ((i == 0) || (!visited[it->first]))
		{
			d[it->first] = c[i];
			i++;
			visited[it->first] = true;		
		}
		vector<int> tmp = it->second;
		for(int j = 0; j < tmp.size(); j++)
		{
			//cout << "[b]tmpj = " << tmp[j] << endl;
			if (visited[tmp[j]])
			{
				continue;
			}
			d[tmp[j]] = c[i];
			i++;
			visited[tmp[j]] = true;
			//cout << "[a]tmpj = " << tmp[j] << endl;
		}
	}
	*/
/*
	vector<pair<int, int> > edges;
	rep(i, N-1)
	{
		int a, b;
		cin >> a >> b;
		a--; b--;
		edges.pb(make_pair(a,b));
	}

	int c[N];
	int max_ = 0;
	int total = 0;
	rep(i, N)
	{
		cin >> c[i];
		total += c[i];
		max_ = max(max_, c[i]);
	}

	total -= max_;
	sort(c, c+N, greater<int>());
	int d[N];
	memset(d, -1, sizeof(d));
	int j = 0;
	rep(i, N-1)
	{
		pair<int,int> edge = edges[i];
		if (d[edge.first] < 0)
		{
			d[edge.first] = c[j++];
		}
		if (d[edge.second] < 0)
		{
			d[edge.second] = c[j++];
		}
	}
	*/

	rep(i, N-1)
	{
		int a, b;
		cin >> a >> b;
		a--; b--;
		add(a,b);
		add(b,a);
	}

	//int c[N];
	int max_ = 0;
	int total = 0;
	rep(i, N)
	{
		cin >> c[i];
		total += c[i];
		max_ = max(max_, c[i]);
	}

	total -= max_;
	sort(c, c+N, greater<int>());
	
	dfs(0);

	cout << total << endl;
	for(int i = 0; i < N; i++)
	{
		cout << ans[i] << " ";
	}
	cout << endl;

	
	return 0;
}


Measured memory_bytes: 896