from collections import deque
class UnionFind:
    """
        n : 要素数
        root : 親ノード
        size : グループのサイズ
    """
    
    def __init__(self, n):
        self.n = n
        self.root = [-1]*(n+1)
        self.size = [1]*(n+1)
    
    """ノードxのrootノードを見つける"""
    def Find_Root(self, x):
        if self.root[x] < 0:
            return x
        else:
            self.root[x] = self.Find_Root(self.root[x])
            return self.root[x]
    
    """木の合併"""
    def Union(self, x, y):
        #入力ノードの親を探索
        x = self.Find_Root(x)
        y = self.Find_Root(y)
        
        #既に同じ木に所属する場合
        if x==y:
            return 
        
        #異なる木に所属する場合 -> sizeが小さい方から大きい方に合併する
        elif self.size[x] > self.size[y]:
            self.size[x] += self.size[y]
            self.root[y] = x
        
        else:
            self.size[y] += self.size[x]
            self.root[x] = y

n = int(input())
uf = UnionFind(n)
G = [[] for _ in range(n+1)]
for _ in range(n-1):
    a,b = map(int,input().split())
    uf.Union(a,b)
    G[a].append(b)
    G[b].append(a)
rt = uf.root.index(-1)
for idx in range(1, n+1):
    if uf.root[idx] == -1:
        rt = idx-1
        break

c = list(map(int,input().split()))
c.sort(reverse=True)
c = [0] + c
ans = [0]*(n+1)
que = deque([rt])
idx = 1

while que:
    node = que.popleft()
    if ans[node]!=0:
        continue
    else:
        ans[node] = c[idx]
        idx += 1
        for g in G[node]:
            que.append(g)
print(sum(c)-max(c))
print(*ans[1:]) from collections import deque class UnionFind:
    """
        n : 要素数
        root : 親ノード
        size : グループのサイズ
    """
    
    def __init__(self, n):
        self.n = n
        self.root = [-1]*(n+1)
        self.size = [1]*(n+1)
    
    """ノードxのrootノードを見つける"""
    def Find_Root(self, x):
        if self.root[x] < 0:
            return x
        else:
            self.root[x] = self.Find_Root(self.root[x])
            return self.root[x]
    
    """木の合併"""
    def Union(self, x, y):
        #入力ノードの親を探索
        x = self.Find_Root(x)
        y = self.Find_Root(y)
        
        #既に同じ木に所属する場合
        if x==y:
            return 
        
        #異なる木に所属する場合 -> sizeが小さい方から大きい方に合併する
        elif self.size[x] > self.size[y]:
            self.size[x] += self.size[y]
            self.root[y] = x
        
        else:
            self.size[y] += self.size[x]
            self.root[x] = y UnionFind """
        n : 要素数
        root : 親ノード
        size : グループのサイズ
    """ def __init__(self, n):
        self.n = n
        self.root = [-1]*(n+1)
        self.size = [1]*(n+1)
    
     __init__ self.n = n self.n self n n self.root = [-1]*(n+1) self.root self root [-1]*(n+1) [-1] -1 n+1 n 1 self.size = [1]*(n+1) self.size self size [1]*(n+1) [1] 1 n+1 n 1 self self n n """ノードxのrootノードを見つける""" def Find_Root(self, x):
        if self.root[x] < 0:
            return x
        else:
            self.root[x] = self.Find_Root(self.root[x])
            return self.root[x]
    
     Find_Root if self.root[x] < 0:
            return x
        else:
            self.root[x] = self.Find_Root(self.root[x])
            return self.root[x]
    
     self.root[x] < 0 self.root[x] self.root self root x 0 return x x self.root[x] = self.Find_Root(self.root[x]) self.root[x] self.root self root x self.Find_Root(self.root[x]) self.Find_Root self Find_Root self.root[x] self.root self root x return self.root[x] self.root[x] self.root self root x self self x x """木の合併""" def Union(self, x, y):
        #入力ノードの親を探索
        x = self.Find_Root(x)
        y = self.Find_Root(y)
        
        #既に同じ木に所属する場合
        if x==y:
            return 
        
        #異なる木に所属する場合 -> sizeが小さい方から大きい方に合併する
        elif self.size[x] > self.size[y]:
            self.size[x] += self.size[y]
            self.root[y] = x
        
        else:
            self.size[y] += self.size[x]
            self.root[x] = y Union x = self.Find_Root(x) x self.Find_Root(x) self.Find_Root self Find_Root x y = self.Find_Root(y) y self.Find_Root(y) self.Find_Root self Find_Root y if x==y:
            return 
        
        #異なる木に所属する場合 -> sizeが小さい方から大きい方に合併する
        elif self.size[x] > self.size[y]:
            self.size[x] += self.size[y]
            self.root[y] = x
        
        else:
            self.size[y] += self.size[x]
            self.root[x] = y x==y x y return elif self.size[x] > self.size[y]:
            self.size[x] += self.size[y]
            self.root[y] = x
        
         self.size[x] > self.size[y] self.size[x] self.size self size x self.size[y] self.size self size y self.size[x] += self.size[y] self.size[x] self.size self size x self.size[y] self.size self size y self.root[y] = x self.root[y] self.root self root y x self.size[y] += self.size[x] self.size[y] self.size self size y self.size[x] self.size self size x self.root[x] = y self.root[x] self.root self root x y self self x x y y n = int(input()) n int(input()) int input() input uf = UnionFind(n) uf UnionFind(n) UnionFind n [] for _ in range(n+1) for _ in range(n+1) _ range(n+1) range n+1 n 1 for _ in range(n+1) [] G = [[] for _ in range(n+1)] G [[] for _ in range(n+1)] for _ in range(n-1):
    a,b = map(int,input().split())
    uf.Union(a,b)
    G[a].append(b)
    G[b].append(a) _ range(n-1) range n-1 n 1 a,b = map(int,input().split()) a map(int,input().split()) map int input().split() ().split () input split b uf.Union(a,b) uf.Union uf Union a b G[a].append(b) [a].append [a] G a append b G[b].append(a) [b].append [b] G b append a rt = uf.root.index(-1) rt uf.root.index(-1) uf.root.index uf.root uf root index -1 for idx in range(1, n+1):
    if uf.root[idx] == -1:
        rt = idx-1
        break idx range(1, n+1) range 1 n+1 n 1 if uf.root[idx] == -1:
        rt = idx-1
        break uf.root[idx] == -1 uf.root[idx] uf.root uf root idx -1 rt = idx-1 rt idx-1 idx 1 break c = list(map(int,input().split())) c list(map(int,input().split())) list map(int,input().split()) map int input().split() ().split () input split c.sort(reverse=True) c.sort c sort reverse=True reverse True c = [0] + c c [0] + c [0] 0 c ans = [0]*(n+1) ans [0]*(n+1) [0] 0 n+1 n 1 que = deque([rt]) que deque([rt]) deque [rt] rt idx = 1 idx 1 while que:
    node = que.popleft()
    if ans[node]!=0:
        continue
    else:
        ans[node] = c[idx]
        idx += 1
        for g in G[node]:
            que.append(g) que node = que.popleft() node que.popleft() que.popleft que popleft if ans[node]!=0:
        continue
    else:
        ans[node] = c[idx]
        idx += 1
        for g in G[node]:
            que.append(g) ans[node]!=0 ans[node] ans node 0 continue ans[node] = c[idx] ans[node] ans node c[idx] c idx idx += 1 idx 1 for g in G[node]:
            que.append(g) g G[node] G node que.append(g) que.append que append g print(sum(c)-max(c)) print sum(c)-max(c) sum(c) sum c max(c) max c print(*ans[1:]) print *ans[1:] ans[1:] ans 1: 1 G = [[] for _ in range(n+1)] [[] for _ in range(n+1)] G node = que.popleft() que.popleft() node class UnionFind:
    """
        n : 要素数
        root : 親ノード
        size : グループのサイズ
    """
    
    def __init__(self, n):
        self.n = n
        self.root = [-1]*(n+1)
        self.size = [1]*(n+1)
    
    """ノードxのrootノードを見つける"""
    def Find_Root(self, x):
        if self.root[x] < 0:
            return x
        else:
            self.root[x] = self.Find_Root(self.root[x])
            return self.root[x]
    
    """木の合併"""
    def Union(self, x, y):
        #入力ノードの親を探索
        x = self.Find_Root(x)
        y = self.Find_Root(y)
        
        #既に同じ木に所属する場合
        if x==y:
            return 
        
        #異なる木に所属する場合 -> sizeが小さい方から大きい方に合併する
        elif self.size[x] > self.size[y]:
            self.size[x] += self.size[y]
            self.root[y] = x
        
        else:
            self.size[y] += self.size[x]
            self.root[x] = y class UnionFind:
    """
        n : 要素数
        root : 親ノード
        size : グループのサイズ
    """
    
    def __init__(self, n):
        self.n = n
        self.root = [-1]*(n+1)
        self.size = [1]*(n+1)
    
    """ノードxのrootノードを見つける"""
    def Find_Root(self, x):
        if self.root[x] < 0:
            return x
        else:
            self.root[x] = self.Find_Root(self.root[x])
            return self.root[x]
    
    """木の合併"""
    def Union(self, x, y):
        #入力ノードの親を探索
        x = self.Find_Root(x)
        y = self.Find_Root(y)
        
        #既に同じ木に所属する場合
        if x==y:
            return 
        
        #異なる木に所属する場合 -> sizeが小さい方から大きい方に合併する
        elif self.size[x] > self.size[y]:
            self.size[x] += self.size[y]
            self.root[y] = x
        
        else:
            self.size[y] += self.size[x]
            self.root[x] = y UnionFind ans = [0]*(n+1) [0]*(n+1) ans que = deque([rt]) deque([rt]) que a,b = map(int,input().split()) map(int,input().split()) a rt = uf.root.index(-1) uf.root.index(-1) rt uf = UnionFind(n) UnionFind(n) uf rt = idx-1 idx-1 rt b = map(int,input().split()) map(int,input().split()) b c = [0] + c [0] + c c c = list(map(int,input().split())) list(map(int,input().split())) c idx += 1 1 idx n = int(input()) int(input()) n idx = 1 1 idx
from collections import deque
class UnionFind:
    """
        n : 要素数
        root : 親ノード
        size : グループのサイズ
    """
    
    def __init__(self, n):
        self.n = n
        self.root = [-1]*(n+1)
        self.size = [1]*(n+1)
    
    """ノードxのrootノードを見つける"""
    def Find_Root(self, x):
        if self.root[x] < 0:
            return x
        else:
            self.root[x] = self.Find_Root(self.root[x])
            return self.root[x]
    
    """木の合併"""
    def Union(self, x, y):
        #入力ノードの親を探索
        x = self.Find_Root(x)
        y = self.Find_Root(y)
        
        #既に同じ木に所属する場合
        if x==y:
            return 
        
        #異なる木に所属する場合 -> sizeが小さい方から大きい方に合併する
        elif self.size[x] > self.size[y]:
            self.size[x] += self.size[y]
            self.root[y] = x
        
        else:
            self.size[y] += self.size[x]
            self.root[x] = y

n = int(input())
uf = UnionFind(n)
G = [[] for _ in range(n+1)]
for _ in range(n-1):
    a,b = map(int,input().split())
    uf.Union(a,b)
    G[a].append(b)
    G[b].append(a)
rt = uf.root.index(-1)
for idx in range(1, n+1):
    if uf.root[idx] == -1:
        rt = idx-1
        break

c = list(map(int,input().split()))
c.sort(reverse=True)
c = [0] + c
ans = [0]*(n+1)
que = deque([rt])
idx = 1

while que:
    node = que.popleft()
    if ans[node]!=0:
        continue
    else:
        ans[node] = c[idx]
        idx += 1
        for g in G[node]:
            que.append(g)
print(sum(c)-max(c))
print(*ans[1:])