
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(" ")