#include <cstdio>
#include <algorithm>
#include <vector>
#include <map>
#include <set>
#include <queue>

//#define DBG

using namespace std;

int n, m;

struct Stacja {
  bool krajowa;
  int r;
  vector<int> drogi;
  bool ok;  // czy jeszcze ją brać pod uwagę (zagraniczne w ogóle nie biorą udziału)
  int ile;  // ile stacji sąsiaduje (w pierwszej fazie chodzi o zagraniczne, a w drugiej o nieprzeanalizowane krajowe)
  map<int, int> *Z; // zależność kosztu grupy od rozstawu w tej stacji (rozstaw, zmiana gradientu kosztu)
  int opt;          // optymalny rozstaw w stacji dla grupy (ewentualnie kolejny z Z też jeszcze jest optymalny)
  int g;            // gradient w poprzednim przedziale przed opt
};

Stacja *s;

//////////////////////////////////////////////////////////////////////////////////////
#ifdef DBG
void pisz() {
  printf("n=%d, m=%d\n", n, m);
  for (int i = m; i < n; ++i) if (s[i].ok) {
    printf("  %d. ile=%d [", i, s[i].ile);
    vector<int> &drogi = s[i].drogi;
    for (int j = 0; j < drogi.size(); ++j) if (s[drogi[j]].ok) printf("%d ", drogi[j]);
    printf("] [");
    for (int j = 0; j < drogi.size(); ++j)
      if (!s[drogi[j]].krajowa) printf("%d ", drogi[j]);
    printf("]\n");
  }
}
void piszZ(int i)
{
  printf("  size=%d [", s[i].Z->size());
  map<int, int>::iterator xx = s[i].Z->begin();
  while (xx != s[i].Z->end()) {
    printf("(%d, %d) ", xx->first, xx->second);
    xx++;
  }
  printf("]\n");
}

#endif // DBG

//////////////////////////////////////////////////////////////////////////////////////
// wyznacza górną granicę zakresu optymalnego dla stacji i
inline int opt_max(int i)
{
  int opt2 = s[i].opt; // na początek można ustawić dolną granicę
  map<int, int>::iterator it = s[i].Z->find(opt2); // musi być
  if (s[i].g + it->second == 0) { // jest gradient zerowy do kolejnego punktu
    it++;
    if (it == s[i].Z->end())
      opt2 = 500000;
    else
      opt2 = it->first;
  }
  return opt2;
}


//////////////////////////////////////////////////////////////////////////////////////

inline void dodaj(map<int, int> *Z, int r, int d, int stary_opt = -1)
{
  map<int, int>::iterator it = Z->find(r);
  if (it == Z->end()) {
    Z->insert(pair<int, int>(r, d));   // jeśli nie ma to dodaj
  }
  else { // jeśli jest to zmodyfikuj wartość
    d += it->second;
    Z->erase(it);
    // nie dodawaj jeśli wyjdzie zero chyba, że to stary opt, który zachowujemy
    if (d != 0 || r == stary_opt) Z->insert(pair<int, int>(r, d));
  }
}

long long licz()
{
  /*
    Informacja o zależności kosztu grupy od rozstawu na skrajnej stacji będzie pamiętana w formie:
      map<int, int> - (rozstaw, zmiana gradientu w stosunku do poprzedniego przedziału)
      int - optymalny rozstaw
            ostatni z mapy, dla którego suma narastająco dla poprzednich wartości jest < 0
      int - ten ujemny gradient
    Znajdź te stacje, które łączą się z zagranicznymi.
      Zainicjuj dla nich informację o zależności:
        wrzuć (0, -n) oraz (ri, 2) dla każdej stacji zagranicznej i=1..n
        przejdź po mapie i znajdź optymalny
    Dla pozostałych zainicjuj na pusto.
    Na PQ wrzuć wszystkie nieprzeanalizowane stacje z kluczem w postaci liczby nieprzeanalizowanych
    krajowych którymi się łączą i wybieraj kolejno stacje A (aż zostanie jedna):
      Usuń z PQ.
      Znajdź jedyną nieprzeanalizowaną sasiadującą B.
      Dołącz informacje o zależności A do B.
      Jeśli ta B nie ma swojej zależności to tylko bierze zakres opt z A.
      Oznacz A jako przeanalizowaną i popraw liczbę nieprzeanalizowanych sąsiednich dla B (w PQ).
    Jak w PQ jest jedna stacja to od niej zaczynamy obliczanie kosztu:
      Ustaw jej rozstaw na wartość optymalną (jak jest przedział to obojętnie).
      Przejdź od niej BSF wszystkie krajowe:
        Wchodząc na stację krajową (tzn. wychodząc do niej z już policzonej)
          Ustaw jej rozstaw na optymalny, a jeśli przedzial wybierz wartość bliższą
          rozstawowi na stacji, z której wychodzimy.
          Dolicz koszt połączenia do wyniku.
  */

  set<pair<int, int> > PQ;   // kolejka priorytetowa  (liczba nieprzeanalizowanych sąsiednich, numer stacji)
  int i, j;

  // obliczenie zależności kosztu od rozstawu dla pojedynczych stacji (uwzględniając tylko zagraniczne)
  for (i = m; i < n; ++i) if (s[i].ok) {
    #ifdef DBG
    printf("obliczam zaleznosci i=%d\n", i);
    #endif // DBG
    vector<int> &drogi = s[i].drogi;
    s[i].Z = new map<int, int>();
    if (s[i].ile > 0) { // ma zagraniczne (UWAGA: nie każda musi mieć)
      dodaj(s[i].Z, 0, -s[i].ile);
      for(j = 0; j < drogi.size(); ++j)
        if (!s[drogi[j]].krajowa) dodaj(s[i].Z, s[drogi[j]].r, 2);
      #ifdef DBG
      piszZ(i);
      #endif // DBG
      map<int, int>::iterator it = s[i].Z->begin();
      s[i].opt = 0;
      s[i].g = 0;
      int g = it->second; // gradient w kolejnym przedziale (teraz w pierwszym od 0)
      #ifdef DBG
      printf("  g=%d\n", g);
      #endif // DBG
      it++; // patrzymy od następnego rozstawu
      for(; g < 0 && it != s[i].Z->end(); it++) {
        s[i].opt = it->first;
        s[i].g = g;
        g += it->second;
      }
      // zatrzymujemy się na g >= 0 czyli poprzedni zapamiętamy był ostatnim z g < 0
      #ifdef DBG
      printf("  opt=%d, g=%d\n", s[i].opt, s[i].g);
      #endif // DBG
    }
    else {  // oznaczenie, że nie miała zagranicznych
      s[i].opt = -1;
      s[i].g = 0;
    }

    s[i].ile = 0; // teraz liczymy sąsiednie krajowe
    for (j = 0; j < drogi.size(); ++j) if (s[drogi[j]].ok && s[drogi[j]].krajowa) s[i].ile++;
    PQ.insert(pair<int, int>(s[i].ile, i));
    #ifdef DBG
    printf("  wstawiam ile=%d, stacja=%d\n", s[i].ile, i);
    #endif // DBG
  }
  #ifdef DBG
  printf("PQ.size()=%d\n", PQ.size());
  {
    set<pair<int, int> >::iterator xx = PQ.begin();
    printf("%d\n", xx->first);
  }
  #endif // DBG

  // łączenie grup stacji - dołączamy zawsze taką co ma tylko jedną drogę do nieprzeanalizowanej
  while (PQ.size() > 1) {   // aż zostanie tylko jedna grupa
    set<pair<int, int> >::iterator it = PQ.begin();
    int A = it->second; // numer stacji dołączanej
    PQ.erase(it);
    // znajdź nieprzeanalizowaną sąsiednią krajową (musi być)
    for (i = 0; !s[s[A].drogi[i]].ok; ++i);
    int B = s[A].drogi[i]; // numer stacji do której dołączamy
    #ifdef DBG
    printf("dolacz A=%d B=%d\n", A, B);
    piszZ(A);
    piszZ(B);
    #endif // DBG

    // wyznaczyć dla A zakres minimalny i dodać zmiany gradientu
    int g0 = s[B].g;  // poprzedni gradient przed punktem optymalnym
    int Amin = s[A].opt;
    int Amax = opt_max(A);
    int t3[3] = {0, Amin, Amax};
    int d3[3] = {-1, 1, 1};
    int B_stary_opt = s[B].opt;

    if (B_stary_opt == -1) {  // stacja bez zagranicznych
      for (i = 0; i < 3; ++i) {
        dodaj(s[B].Z, t3[i], d3[i]);
      }
      s[B].opt = Amin;
      s[B].g = -1;
    }
    else {
      map<int, int>::iterator it_opt = s[B].Z->find(B_stary_opt);
      int g2 = g0 + it_opt->second; // gradient w przedziale za dolną granicą zakresu optymalnego (poprzedni = przed aktualizacją)
      #ifdef DBG
      printf("  g0=%d, g2=%d, Amin=%d, Amax=%d, Bopt=%d\n", g0, g2, Amin, Amax, B_stary_opt);
      #endif // DBG
      for (i = 0; i < 3; ++i) {
        dodaj(s[B].Z, t3[i], d3[i], B_stary_opt); // nie usuwaj starej granicy zakres u optymalnego bo potrzebne
        if (t3[i] <  B_stary_opt) g0 += d3[i];
        if (t3[i] <= B_stary_opt) g2 += d3[i];
      }
      #ifdef DBG
      printf("  g0=%d, g2=%d\n", g0, g2);
      #endif // DBG
      // teraz trzeba zaktualizować dolną granicę przedziału optymalnego oraz gradient dla B
      it_opt = s[B].Z->find(B_stary_opt); // znaleźć na nowo po zmianach w strukturze
      // sprawdzamy czy zmiana gradientu w starym opt nie wyszła zerowa bo jeśli tak to on do usunięcia
      bool usun_stary_opt = (it_opt->second == 0);
      if (g0 == 0) {
        // I. gradient przed poprzednim optymalnym był < 0, ale mógł się wyzerować i trzeba się cofnąć
        it_opt--;
        s[B].opt = it_opt->first;
        s[B].g = - it_opt->second;
      }
      else if (g2 < 0) {
        // II. gradient za tym punktem był >= 0, ale mógł spaść < 0 i trzeba się przesunąć do przodu
        it_opt++;
        s[B].opt = it_opt->first;
        s[B].g = g2;
      }
      else {
        // nic się nie przesunęło, ale trzeba zaktualizować gradient
        s[B].g = g0;
      }
      if (usun_stary_opt) {
        #ifdef DBG
        if (s[B].opt == B_stary_opt) {
          printf ("  !!! usuwamy opt!\n");
          exit(0);
        }
        #endif // DBG
        s[B].Z->erase(B_stary_opt);
      }
      #ifdef DBG
      {
        piszZ(B);
        int opt2 = opt_max(B);
        if (opt2 > s[B].opt)
          printf("  opt=(%d, %d) g=%d\n", s[B].opt, opt2, s[B].g);
        else
          printf("  opt=%d, g=%d\n", s[B].opt, s[B].g);

        // sprawdzenie "na piechotę"
        map<int, int>::iterator spr_it = s[B].Z->begin();
        int spr_opt = 0;
        int spr_g = 0;
        int g = spr_it->second; // gradient w kolejnym przedziale (teraz w pierwszym od 0)
        spr_it++; // patrzymy od następnego rozstawu
        for(; g < 0 && spr_it != s[B].Z->end(); spr_it++) { // zatrzymujemy się na wartości >= 0
          spr_opt = spr_it->first;                          // czyli poprzedni zapamiętamy był ostatnim < 0
          spr_g = g;
          g += spr_it->second;
          //printf("    r=%d, g=%d, gnar=%d\n", spr_opt, spr_it->second, g);
        }
        if (spr_opt != s[B].opt || spr_g != s[B].g) {
          printf("  !!!! ma byc: opt=%d g=%d\n", spr_opt, spr_g);
          exit(0);
        }
      }
      #endif // DBG
    }

    s[A].ok = false; // już przeanalizowana
    // aktualizować liczbę połączeń z B do nieprzeanalizowanych i poprawić w PQ
    PQ.erase(pair<int, int>(s[B].ile, B));
    s[B].ile--;
    PQ.insert(pair<int, int>(s[B].ile, B));
  }

  // teraz już tylko ustalenie optymalnych rozstawów i policzenie kosztu
  int A = PQ.begin()->second; // ostatnia stacja od której zaczynamy teraz ustawianie rozstawów
  s[A].r = s[A].opt; // ustawiamy w stacji rozstaw optymalny dla całej grupy
  long long wyn = 0;
  queue<int> q;
  q.push(A);
  while (q.size()) {
    A = q.front(); // kolejna odwiedzana stacja
    q.pop();
    vector<int> &drogi = s[A].drogi;
    for (i = 0; i < drogi.size(); ++i) {
      int B = drogi[i]; // sąsiednia
      if (s[B].r == -1) { // odwiedź sąsiednie (krajowe) co nie mają r
        if (s[A].r <= s[B].opt)
          s[B].r = s[B].opt; // weź dolną granicę zakresu optymalnego dla B
        else { // s[B].opt < s[A].r
          // jak się da to weź to samo co w A a jak nie to górna granica będzie lepsza niż dolna
          s[B].r = min(s[A].r, opt_max(B));
        }
        q.push(B);
        wyn += abs(s[A].r - s[B].r); // dolicz koszt
      }
      else if (!s[B].krajowa)
        wyn += abs(s[A].r - s[B].r); // dolicz koszt do zagranicznej
      #ifdef DBG
      else
        continue;
      printf("BAZRK(%d, %d) = %d\n", A, B, abs(s[A].r - s[B].r));
      #endif // DBG
    }
  }
  #ifdef DBG
  long long spr_wyn = 0;
  for (i = m; i < n; ++i) if (s[i].r <= 500000) {
    printf("r[%d] = %d\n", i, s[i].r);
    vector<int> &drogi = s[i].drogi;
    for (int j = 0; j < drogi.size(); ++j) {
      int cel = drogi[j];
      if (cel < i  &&  s[cel].r <= 500000)
        spr_wyn += abs(s[i].r - s[cel].r);
    }
  }
  printf("spr_wyn=%I64d\n", spr_wyn);
  #endif // DBG
  return wyn;
}

//////////////////////////////////////////////////////////////////////////////////////
void czytaj()
{
  int i;
  scanf("%d%d", &n, &m);
  s = new Stacja[n];
  for (i = 0; i < n; ++i) {
    s[i].ok = s[i].krajowa = (i >= m);
    s[i].drogi = vector<int>();
    s[i].ile = 0;
    s[i].Z = NULL;
    s[i].r = -1; // niepoliczona
  }
  for (i = 0; i < n - 1; ++i) {
    int a, b;
    scanf("%d%d", &a, &b);
    a--; b--;
    s[a].drogi.push_back(b);
    s[b].drogi.push_back(a);
    if (!s[a].krajowa) s[b].ile++;
    if (!s[b].krajowa) s[a].ile++;
  }
  for (i = 0; i < m; ++i) scanf("%d", &s[i].r);
  #ifdef DBG
  pisz();
  #endif // DBG
}

int main()
{
  czytaj();
  if (n == 2 && m == 2) {  // uff
    printf("%d\n", abs(s[0].r - s[1].r));
    return 0;
  }
  //redukuj();  -- trudno będzie bez redukcji bo coś zwaliłem
  long long wyn = licz();
  printf("%lld\n", wyn);
  return 0;
}