#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;

// For every pair of nodes, find shortest path using only small characters, and a distinct shortest path using only small characters
// For every pair of nodes, find shortest path to the goal such that both have the same large letters on the path, and sum of small letter count is minimised.
// 	Then, do the same, but this time guarantee that the strings produced by the walks are distinct.
// To do this, loop next node for first, loop next node for second, and loop large character they take from there
// -> Complexity O(n^2 * n^2)

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template<class T>
T rand(T a, T b) {
	return uniform_int_distribution<T>(a, b)(rng);
}
template<class T>
T rand() {
	return uniform_int_distribution<T>()(rng);
}

// Struct for priority queue operations on index set [0, n-1]
// push(i, v) overwrites value at position i if one already exists
// decKey is faster but requires that the new key is smaller than the old one
struct Prique {
	const ll INF = 4 * (ll)1e18;
	vector<pair<ll, int>> data;
	const int n;

	Prique(int siz) : n(siz), data(2*siz, {INF, -1}) { data[0] = {-INF, -1}; }
	bool empty() const { return data[1].second >= INF; }
	pair<ll, int> top() const { return data[1]; }

	void push(int i, ll v) {
		data[i+n] = {v, (v >= INF ? -1 : i)};
		for (i += n; i > 1; i >>= 1) data[i>>1] = min(data[i], data[i^1]);
	}
	void decKey(int i, ll v) {
		for (int j = i+n; data[j].first > v; j >>= 1) data[j] = {v, i};
	}
	pair<ll, int> pop() {
		auto res = data[1];
		push(res.second, INF);
		return res;
	}
};

const ull MOD = (ull)4e9 + 7;
const ull MULT = rand(2ull, MOD - 2);
const int INF = 1e9 + 7;
const int N = 50;
const int C = 26;
vector<pair<int, int>> big_in[N];
pair<int, ull> opt[N][N][2]; // Two distinct shortest paths using only small characters from a to b
int dp[N][N][4];
int nxt[N][C];
bool goal[N];

pair<int, ull> extend(pair<int, ull> cur, int c) {
	return {cur.first + 1, (cur.second * MULT + c) % MOD};
}

int main() {
	ios_base::sync_with_stdio(false);
	cin.tie(0);

	// "What is the maximum k, such that exists i < n - k, such that str[i, i + k) = str[n - k, n)
	// -> reverse string. Need to find suffix occurring after i, with maximum LCA with i
	
	int n, k, m;
	cin >> n >> k >> m;
	for (int i = 0; i < k; ++i) {
		int t;
		cin >> t;
		goal[t - 1] = 1;
	}
	for (int i = 0; i < n; ++i) {
		for (int c = 0; c < C; ++c) nxt[i][c] = -1;
	}
	for (int j = 0; j < m; ++j) {
		int a, b;
		char c;
		cin >> a >> c >> b;
		--a; --b;

		if ('a' <= c && c <= 'z') {
			nxt[a][c - 'a'] = b;
		} else {
			big_in[b].emplace_back(c - 'A', a);
		}
	}
	for (int s = 0; s < n; ++s) {
		for (int t = 0; t < n; ++t) {
			opt[s][t][0] = {INF, 0ull};
			opt[s][t][1] = {INF, 0ull};
		}
		opt[s][s][0] = {0, 0ull};
		
		vector<pair<int, int>> que = {{s, 0}};
		for (int ind = 0; ind < que.size(); ++ind) {
			int i = que[ind].first;
			auto cur = opt[s][i][que[ind].second];
			for (int c = 0; c < C; ++c) {
				int t = nxt[i][c];
				if (t == -1) continue;

				auto off = extend(cur, c);
				if (off.first < opt[s][t][0].first) {
					opt[s][t][0] = off;
					que.emplace_back(t, 0);
				} else if (off != opt[s][t][0] && off.first < opt[s][t][1].first) {
					opt[s][t][1] = off;
					que.emplace_back(t, 1);
				}
			}
		}
		// for (int t = 0; t < n; ++t) cerr << s << ' ' << t << ": " << opt[s][t][0].first << ' ' << opt[s][t][1].first << '\n';
	}

	Prique pq(4*n*n);
	for (int a = 0; a < n; ++a) {
		for (int b = a; b < n; ++b) {
			for (int j = 0; j < 4; ++j) dp[a][b][j] = INF;
			if (goal[a] && goal[b]) {
				dp[a][b][0] = 0;
				pq.decKey(a + n*b, 0);
			}
		}
	}
	while(pq.top().second != -1) {
		auto pr = pq.pop();
		int ind = pr.second;
		int a = ind % n;
		int b = (ind / n) % n;
		int s = ind / (n * n) % 2;
		int r = ind / (2 * n * n);
		int base = dp[a][b][s + 2*r];
		// cerr << a << ' ' << b << ' ' << s << ' ' << r << ": " << base << '\n';
	
		if (s == 0) {
			for (int x = 0; x < n; ++x) {
				if (opt[x][a][0].first >= INF) continue;
				for (int y = 0; y < n; ++y) {
					if (opt[y][b][0].first >= INF) continue;

					int off = base + opt[x][a][0].first + opt[y][b][0].first;
					int off2 = base + min(opt[x][a][0].first + opt[y][b][1].first, opt[x][a][1].first + opt[y][b][0].first);
					if (r == 1 || opt[x][a][0] != opt[y][b][0]) off2 = off;
					
					int pa = min(x, y);
					int pb = max(x, y);
					if (dp[pa][pb][1] > off) {
						dp[pa][pb][1] = off;
						pq.decKey(pa + n*pb + n*n, off);
					}
					if (dp[pa][pb][3] > off2) {
						dp[pa][pb][3] = off2;
						pq.decKey(pa + n*pb + 3*n*n, off2);
					}
				}
			}
		} else {
			for (auto pr : big_in[a]) {
				for (auto pr2 : big_in[b]) {
					if (pr.first != pr2.first) continue;

					int x = pr.second;
					int y = pr2.second;
					int pa = min(x, y);
					int pb = max(x, y);

					int off = base + 2;
					if (dp[pa][pb][2*r] > off) {
						dp[pa][pb][2*r] = off;
						pq.decKey(pa + n*pb + 2*r * n*n, off);
					}
				}
			}
		}
	}

	int res = min(dp[0][0][2], dp[0][0][3]);
	if (res < INF) {
		cout << res << '\n';
	} else {
		cout << -1 << '\n';
	}
	
}