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 (Clang 3.8.0) (judge verdict: Wrong Answer)

#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
#include <ctype.h>
#include <stdint.h>
#include <string.h>
#include <wchar.h>
#include <math.h>

#define N_MAX (100)
#define P_MAX (100)
#define DP_ARRAY_SIZE (N_MAX * P_MAX / 32 + 1)

#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define ABS(a) ((a) < 0 ? -(a) : (a))
#define ABSS(a, b) ((a) > (b) ? (a) - (b) : (b) - (a))

int compare_sz_asc(const void* a, const void* b) {
    return *((size_t*)a) < * ((size_t*)b) ? -1 : 1;
}

int compare_sz_desc(const void* a, const void* b) {
    return *((size_t*)a) > * ((size_t*)b) ? -1 : 1;
}

int compare_f(const void* a, const void* b) {
    return *((int64_t*)a) < *((int64_t*)b) ? -1 : 1;
}

int compare_f2(const void* a, const void* b) {
    return *((uint64_t*)a) > * ((uint64_t*)b) ? -1 : 1;
}

static size_t comb(const size_t n, const size_t r) {
    size_t result = 1;

    for (size_t i = 0; i < r; i++) {
        result *= n - i;
        result /= i + 1;
    }

    return result;
}

static uint64_t combU64(const uint64_t n, const uint64_t r) {
    uint64_t result = 1;

    for (uint64_t i = 0; i < r; i++) {
        result *= n - i;
        result /= i + 1;
    }

    return result;
}

static uint64_t gcdU64(uint64_t m, uint64_t n)
{
    uint64_t temp;

    while (m % n != 0) {
        temp = n;
        n = m % n;
        m = temp;
    }

    return n;
}

static size_t gcdZu(size_t m, size_t n) {
    size_t temp;

    while (m % n != 0) {
        temp = n;
        n = m % n;
        m = temp;
    }

    return n;
}

typedef struct {
    size_t idx;
    size_t edgeCount;
    size_t num;
} _pInfo;

static _pInfo pInfo[10000];

static size_t a[10000];
static size_t b[10000];
static size_t c[10000];

static int compare_p(const void* a, const void* b) {
    const _pInfo* aP = (_pInfo*)a;
    const _pInfo* bP = (_pInfo*)b;

    return aP->edgeCount < bP->edgeCount ? -1 : 1;
}

static int compare_po(const void* a, const void* b) {
    const _pInfo* aP = (_pInfo*)a;
    const _pInfo* bP = (_pInfo*)b;

    return aP->idx < bP->idx ? -1 : 1;
}

int main(void) {
    size_t N;

    scanf("%zu\n", &N);
    for (size_t i = 0; i < N; i++) {
        pInfo[i].idx = i;
        pInfo[i].edgeCount = 0;
    }
    for (size_t i = 0; i < N-1; i++) {
        scanf("%zu %zu", &(a[i]), &(b[i]));
        a[i]--;
        b[i]--;
        pInfo[a[i]].edgeCount++;
        pInfo[b[i]].edgeCount++;
    }
    for (size_t i = 0; i < N; i++) {
        scanf("%zu", &(c[i]));
        if (i < N - 1) {
            scanf(" ");
        }

    }

    qsort(c, N, sizeof(size_t), compare_sz_asc);
    qsort(pInfo, N, sizeof(_pInfo), compare_p);

    for (size_t i = 0; i < N; i++) {
        pInfo[i].num = c[i];
    }

    qsort(pInfo, N, sizeof(_pInfo), compare_po);

    size_t sum = 0;

    for (size_t i = 0; i < N - 1; i++) {
        sum += MIN(pInfo[a[i]].num, pInfo[b[i]].num);
    }

    printf("%zu\n", sum);
    for (size_t i = 0; i < N; i++) {
        printf("%zu", pInfo[i].num);
        if (i < N - 1) {
            putchar(' ');
        }
    }

    return 0;
}