Problem:
Score : 500 points

Problem Statement

You are given a tree with N vertices 1,2,\ldots,N, and positive integers c_1,c_2,\ldots,c_N.
The i-th edge in the tree (1 \leq i \leq N-1) connects Vertex a_i and Vertex b_i.

We will write a positive integer on each vertex in T and calculate our score as follows:

On each edge, write the smaller of the integers written on the two endpoints.

Let our score be the sum of the integers written on all the edges.

Find the maximum possible score when we write each of c_1,c_2,\ldots,c_N on one vertex in T, and show one way to achieve it. If an integer occurs multiple times in c_1,c_2,\ldots,c_N, we must use it that number of times.

Constraints

1 \leq N \leq 10000

1 \leq a_i,b_i \leq N

1 \leq c_i \leq 10^5

The given graph is a tree.

Input

Input is given from Standard Input in the following format:

N
a_1 b_1
:
a_{N-1} b_{N-1}
c_1 \ldots c_N

Output

Use the following format:

M
d_1 \ldots d_N

where M is the maximum possible score, and d_i is the integer to write on Vertex i.
d_1,d_2,\ldots,d_N must be a permutation of c_1,c_2,\ldots,c_N.
If there are multiple ways to achieve the maximum score, any of them will be accepted.

Sample Input 1

5
1 2
2 3
3 4
4 5
1 2 3 4 5

Sample Output 1

10
1 2 3 4 5

If we write 1,2,3,4,5 on Vertex 1,2,3,4,5, respectively, the integers written on the four edges will be 1,2,3,4, for the score of 10. This is the maximum possible score.

Sample Input 2

5
1 2
1 3
1 4
1 5
3141 59 26 53 59

Sample Output 2

197
59 26 3141 59 53

c_1,c_2,\ldots,c_N may not be pairwise distinct.

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

#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;
}