#include <bits/stdc++.h>
#define ll long long
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pl3 tuple<ll, ll, ll>
#define pdd pair<double, double>
#define F first
#define S second
#define all(x) x.begin(), x.end()

using namespace std;

// len[u][v]: we go from u to v, taking only lowercase characters, what is the shortest and the second shortest?
// dp[u][v][0/1][0/1]: we produce two indistunguishable, where they are 0: not yet or 1: already different, what is the smallest sum of length?

// at most 50 * 50 * 100, 1e6 suffices
const int INF = 1000'000;

int N, P, M, out[55][27], dp[55][55][4], ans = INF;
vector<int> E[55];
vector<int> len[55][55];

signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);
    cin >> N >> P >> M;
    for (int i = 1; i <= P; i++)
    {
        int j;
        cin >> j;
        out[j][26] = N + 1;
    }
    for (int i = 1; i <= M; i++)
    {
        int u, v;
        char c;
        cin >> u >> c >> v;
        if (islower(c))
            E[u].emplace_back(v);
        else
            out[u][c - 'A'] = v;
    }
    for (int i = 1; i <= N; i++)
    {
        len[i][i].emplace_back(0);
        queue<pii> q;
        q.emplace(i, 0);
        while (!q.empty())
        {
            auto [j, d] = q.front();
            q.pop();
            for (auto k : E[j])
                if (len[i][k].size() < 2)
                {
                    len[i][k].emplace_back(d + 1);
                    q.emplace(k, d + 1);
                }
        }
        for (int j = 1; j <= N; j++)
            len[i][j].resize(2, INF);
    }
    priority_queue<array<int, 4>, vector<array<int, 4>>, greater<array<int, 4>>> pq;

    for (int i = 1; i <= N + 1; i++)
        for (int j = 1; j <= N + 1; j++)
            for (int k = 0; k < 4; k++)
                dp[i][j][k] = INF;

    auto update = [&](int i, int j, int k, int d)
    {
        if (d < dp[i][j][k])
            dp[i][j][k] = d, pq.push({dp[i][j][k], i, j, k});
    };

    update(1, 1, 0, 0);

    while (!pq.empty())
    {
        auto [d, i, j, k] = pq.top();
        pq.pop();
        if (dp[i][j][k] < d || i > N || j > N)
            continue;

        // walk lowercase
        if ((k & 1) == 0)
            for (int x = 1; x <= N; x++)
                for (int y = 1; y <= N; y++)
                {
                    int inc = len[i][x][0] + len[j][y][0]; // possibly same
                    update(x, y, k ^ 1, d + inc);

                    inc = len[i][x][0] + len[j][y][i == j && x == y]; // guaranteed different
                    update(x, y, (k | 2) ^ 1, d + inc);
                }
        // walk uppercase
        if ((k & 1) == 1)
            for (int c = 0; c <= 26; c++)
                if (out[i][c] && out[j][c])
                {
                    int x = out[i][c], y = out[j][c];
                    update(x, y, k ^ 1, d + 2);
                }
    }
    // AdydFAd
    // FAF
    if (dp[N + 1][N + 1][2] >= INF)
        cout << -1 << '\n';
    else
        cout << dp[N + 1][N + 1][2] - 2 << '\n';
}