Решение

import java.util.Scanner;
import java.util.Arrays;
import java.io.PrintWriter;
import java.io.IOException;

public class Solution {
    static int n, k, nr;
    static int[][][] m = new int[401][401][2];
    static int[][] l = new int[401][401];
    static int[] r = new int[401];
    static int[] a = new int[20001];
    static int[] b = new int[20001];

    static boolean[] u = new boolean[401];
    static int[] o = new int[1000001];

    static boolean[][] s = new boolean[401][401];

    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);

        n = sc.nextInt();
        for (int i = 1; i <= 400; i++) {
            for (int j = 1; j <= 400; j++) {
                m[i][j][0] = m[i][j][1] = 1000_000;
            }
        }
        k = sc.nextInt();
        for (int i = 1; i <= n; i++) {
            m[i][i][0] = 0;
        }
        for (int i = 1; i <= k; i++) {
            a[i] = sc.nextInt();
            b[i] = sc.nextInt();
            s[a[i]][b[i]] = true;
            s[b[i]][a[i]] = true;
        }

        for (int i = 1; i <= n; i++) {
            l[i][0] = 0;
            for (int j = 1; j <= n; j++) {
                if (s[i][j]) {
                    ++l[i][0];
                    l[i][l[i][0]] = j;
                }
            }
        }

        nr = sc.nextInt();
        for (int i = 1; i <= nr; i++) {
            r[i] = sc.nextInt();
        }

        for (int i = 1; i <= nr; i++) {
            bfs(r[i]);
        }

        int an = 1000000;
        for (int i = 1; i <= k; i++) {
            int c = 0;
            for (int j = 1; j <= nr; j++) {
                c = Math.max(c, Math.min(Math.min(m[r[j]][a[i]][0], m[r[j]][a[i]][1]),
                        Math.min(m[r[j]][b[i]][0], m[r[j]][b[i]][1])) + 1);
            }
            an = Math.min(an, c);
        }
        for (int i = 1; i <= n; i++) {
            int lc = 0;
            int ln = 0;
            for (int j = 1; j <= nr; j++) {
                lc = Math.max(lc, m[r[j]][i][0]);
                ln = Math.max(ln, m[r[j]][i][1]);
            }
            an = Math.min(an, Math.min(lc, ln));
        }

        if (an < 100000) {
            double minTimeForAllRobots = (double) an / 2.0;
            double reminder = minTimeForAllRobots % 1;
            if (reminder == 0.0) {
                System.out.println((int) minTimeForAllRobots);
            } else {
                System.out.println(minTimeForAllRobots);
            }
        } else {
            out.println("-1");
        }

        sc.close();
        out.close();
    }

    static void bfs(int v) {
        Arrays.fill(u, false);
        int p1 = 1;
        int p2 = 1;
        o[p1] = v;
        u[v] = true;
        while (p1 <= p2) {
            int cv = o[p1++];
            u[cv] = false;
            for (int i = 1; i <= l[cv][0]; i++) {
                if (m[v][l[cv][i]][0] > m[v][cv][1] + 2) {
                    m[v][l[cv][i]][0] = m[v][cv][1] + 2;
                    if (!u[l[cv][i]]) {
                        u[l[cv][i]] = true;
                        o[++p2] = l[cv][i];
                    }
                }
                if (m[v][l[cv][i]][1] > m[v][cv][0] + 2) {
                    m[v][l[cv][i]][1] = m[v][cv][0] + 2;
                    if (!u[l[cv][i]]) {
                        u[l[cv][i]] = true;
                        o[++p2] = l[cv][i];
                    }
                }
            }
        }
    }
}