import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.stream.IntStream;
import java.util.Arrays;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.OptionalInt;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.BufferedReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author lewin
 */
public class gcd_harmony_lewin {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader2 in = new InputReader2(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        GCDHarmony solver = new GCDHarmony();
        solver.solve(1, in, out);
        out.close();
    }

    static class GCDHarmony {
        int MAX = 10000;
        int INF = 1 << 29;
        int[] val;
        List<Integer>[] tree;

        public void solve(int testNumber, InputReader2 in, OutputWriter out) {
            int n = in.nextInt();
            val = in.readIntArray(n);
            tree = LUtils.genArrayList(n);
            for (int i = 0; i < n - 1; i++) {
                int a = in.nextInt() - 1, b = in.nextInt() - 1;
                tree[a].add(b);
                tree[b].add(a);
            }
            out.println(AUtils.min(solve(0, -1)));
        }

        int[] solve(int node, int par) {
            int[] ans = new int[MAX];
            for (int i = 0; i < MAX; i++) {
                ans[i] = i == val[node] ? 0 : i;
            }
            for (int child : tree[node]) {
                if (child == par) continue;
                int[] tmp = solve(child, node);
                int[] mn = new int[MAX];
                Arrays.fill(mn, INF);
                for (int d = 2; d < MAX; d++) {
                    for (int a = d; a < MAX; a += d) {
                        mn[d] = Math.min(mn[d], tmp[a]);
                    }
                }
                int[] add = new int[MAX];
                Arrays.fill(add, INF);
                for (int d = 2; d < MAX; d++) {
                    for (int a = d; a < MAX; a += d) {
                        add[a] = Math.min(add[a], mn[d]);
                    }
                }
                for (int i = 0; i < MAX; i++) {
                    ans[i] += add[i];
                    if (ans[i] >= INF) ans[i] = INF;
                }
            }
            return ans;
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void close() {
            writer.close();
        }

        public void println(int i) {
            writer.println(i);
        }

    }

    static class LUtils {
        public static <E> List<E>[] genArrayList(int size) {
            List<E>[] r = new ArrayList[size];
            for (int i = 0; i < size; i++) r[i] = new ArrayList<>();
            return r;
        }

    }

    static class AUtils {
        public static int min(int[] arr) {
            return Arrays.stream(arr).min().getAsInt();
        }

    }

    static class InputReader2 {
        private BufferedReader in;
        private StringTokenizer st;

        public InputReader2(InputStream stream) {
            in = new BufferedReader(new InputStreamReader(stream));
            st = null;
        }

        public int[] readIntArray(int tokens) {
            int[] ret = new int[tokens];
            for (int i = 0; i < tokens; i++) {
                ret[i] = nextInt();
            }
            return ret;
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public String next() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(in.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

    }
}