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 Ruby (2.3.3) (judge verdict: Accepted)


class PriorityQueue
  class Node
    include Comparable
    attr_reader :id
    attr_accessor :priority, :value
    @@next_id=0
    def initialize(priority,value=nil)
      @id=@@next_id
      @@next_id+=1
      @priority=priority
      @value=value
    end
    def <=>(other)
      return @priority<=>other.priority
    end
    def reset
      @@next_id=0
    end
  end

  def initialize
    @nodes = [nil]
    @id2index = {}
  end

  def <<(new_node)
    @nodes << new_node
    @id2index[new_node.id]=@nodes.size - 1
    bubble_up(@nodes.size - 1)
  end

  def pop
    return nil if empty?
    exchange(1, @nodes.size - 1)
    max = @nodes.pop
    @id2index.delete(max.id)
    bubble_down(1)
    max
  end

  def push(new_node)
    self << new_node
  end

  def empty?
    return @nodes.size==1
  end

  def change_priority(id, new_priority)
    index=@id2index[id]
    return false if index.nil?
    @nodes[index].priority=new_priority
    bubble_up(index)
    bubble_down(index)
    return true
  end

  def bubble_up(index)
    parent_index = index/2
    return if index <= 1
    return if @nodes[parent_index] >= @nodes[index]

    exchange(index, parent_index)
    bubble_up(parent_index)
  end
  def bubble_down(index)
    child_index = (index * 2)
    return if child_index > @nodes.size - 1
    child_index += 1 if child_index<@nodes.size-1 && @nodes[child_index+1]>@nodes[child_index]
    return if @nodes[index] > @nodes[child_index]
    
    exchange(index, child_index)
    bubble_down(child_index)
  end
  
  def exchange(source, target)
    @id2index[@nodes[source].id], @id2index[@nodes[target].id] = @id2index[@nodes[target].id], @id2index[@nodes[source].id]
    @nodes[source], @nodes[target] = @nodes[target], @nodes[source]
  end
end














N=gets.to_i
pq=PriorityQueue.new()

tree=Array.new(N){Array.new}
(N-1).times do
  a,b=gets.split.map(&:to_i)
  tree[a-1] << b-1
  tree[b-1] << a-1
end
C=gets.split.map(&:to_i)
C.sort_by!{|i| -i}
nodes=[]
N.times do |i|
  node=PriorityQueue::Node.new(-tree[i].size)
  nodes << node
  pq << node
end

ret=[]
N.times do |i|
  node=pq.pop
  from=node.id
  ret[from]=C.pop
  tree[from].each do |to|
    if nodes[to].priority<0
      pq.change_priority(to,nodes[to].priority+1)
    end
  end
end

sum=0
N.times do |from|
  tree[from].each do |to|
    sum+=[ret[from],ret[to]].min
  end
end

puts sum/2
puts ret.join(" ")