#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <sstream>
#include <complex>
#include <ctime>
#include <cassert>
#include <functional>

using namespace std;

typedef long long ll;
typedef vector<int> VI;
typedef pair<int,int> PII;

#define REP(i,s,t) for(int i=(s);i<(t);i++)
#define FILL(x,v) memset(x,v,sizeof(x))

const int INF = (int)1E9;
#define MAXN 5005
#define MAXL 3720

int n, L, ans, lcms[MAXL], mapping[MAXN * 2];
int dp[MAXN][MAXL], val[MAXN];
VI adj[MAXN], factors[MAXL];
void dfs(int x, int p) {
  VI chdp(L,0);
  for (auto &y: adj[x]) {
    if (y == p) continue;
    dfs(y, x);
    REP(i,0,L) chdp[i] = dp[y][i] == INF ? INF : chdp[i] + dp[y][i];
  }
  REP(i,0,L) dp[x][i] = INF;
  REP(i,0,L) {
    int v = lcms[i], sol = chdp[i] + (v == val[x] ? 0 : v);
    if (sol <= 2 * n) {
      for (auto &f: factors[i])
        dp[x][mapping[f]] = min(dp[x][mapping[f]], sol);
    }
  }
  REP(i,0,L) {
    if (dp[x][i] == INF) continue;
    int v = lcms[i];
    for (int m = 1; m * v <= lcms[L - 1]; m++) {
      int mvi = mapping[m * v];
      dp[x][mvi] = min(dp[x][mvi], dp[x][i]);
    }
  }
}
int main() {
  for (int i = 2; i <= 10000; i++) {
    int x = i;
    bool bad = false;
    VI facs;
    for (int d = 2; d * d <= x; d++) {
      if (x % d) continue;
      if (d > 100) {
        bad = true;
        break;
      }
      facs.push_back(d);
      while (x % d == 0) x /= d;
    }
    if (x < 100 && !bad) {
      if (x > 1) facs.push_back(x);
      lcms[L] = i;
      factors[L++] = facs;
    }
  }
  FILL(mapping, -1);
  REP(i,0,L) mapping[lcms[i]] = i;
  cin >> n;
  REP(i,0,n) cin >> val[i];
  REP(i,0,n-1) {
    int a, b;
    cin >> a >> b; a--; b--;
    adj[a].push_back(b);
    adj[b].push_back(a);
  }
  dfs(0, -1);
  cout << *min_element(dp[0], dp[0] + L) << endl;
  return 0;
}