#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <cmath>
#include <vector>
#include <stack>
#include <queue>
#include <algorithm>
using namespace std;

int campWithRanger[501];
int campDist[501][501];

int bestDist[501];

int bestTotDist[501];

int maxDist;

int min(int path1, int path2)
{
	if(path1 > path2){ return path2; }
	else { return path1; }
}

void FloydWarshall(int numCam)
{
	int i, j, k;

	for(k = 1; k <= numCam; k++){
		for(i = 1; i <= numCam; i++){
			for(j = 1; j <= numCam; j++){
				campDist[i][j] = min(campDist[i][j], campDist[i][k] + campDist[k][j]);
			}
		}
	}
}

/*void Dijkstra(int camNum, int numCam)
{
	int i, j;
	vector<int> Q;
	int u, v;
	int minDist, altDist;

	for(i = 1; i <= numCam; i++){
		dist[i] = maxDist;
	}

	dist[camNum] = 0;

	for(i = 1; i <= numCam; i++){
		Q.push_back(i);
	}

	for(j = 0; j < Q.size()-1; j++){
		minDist = maxDist;
		u = 0;
		for(i = 0; i < Q.size(); i++){
			if(dist[Q[i]] < minDist && Q[i] != -1){
				minDist = dist[Q[i]];
				u = i;
			}
		}

		if(dist[Q[u]] == maxDist){ break; }

		Q[u] = -1;
		
		for(i = 1; i <= numCam; i++){
			if(campDist[Q[u]][i] != maxDist){
				altDist = dist[Q[u]] + campDist[Q[u]][i];
				if(altDist < dist[Q[i]]){
					dist[Q[i]] = altDist;
				}
			}
		}
	}

	for(i = 0; i < numCam; i++){
		cout << dist[i] << " ";
	}
	cout << endl;
}*/

void Dijkstra(int numCam)
{
	int i, j;
	int tempDist;

	for(i = 1; i <= numCam; i++){
		tempDist = maxDist;
		for(j = 1; j <= numCam; j++){
			if(campWithRanger[j] == 1 && campDist[i][j] < tempDist){
				tempDist = campDist[i][j];
			}
		}
		bestDist[i] = tempDist;
	}
}

int main()
{
	int numRan, numCam, numPat;
	int camNum, cam1, cam2, dist;
	int bestRang, bestDistance;

	int i, j;

	while(1)
	{
		cin >> numRan >> numCam >> numPat;
		if(cin.eof()){ break; }

		for(j = 0; j <= numCam; j++){
			for(i = 0; i <= numCam; i++){
				if(i != j){
					campDist[i][j] = -1;
				}
			}
		}

		for(i = 0; i < numRan; i++)
		{
			cin >> camNum;
			campWithRanger[camNum] = 1;
		}

		for(i = 0; i < numPat; i++)
		{
			cin >> cam1 >> cam2 >> dist;
			campDist[cam1][cam2] = dist;
			campDist[cam2][cam1] = dist;
			maxDist += dist;
		}

		for(j = 0; j <= numCam; j++){
			for(i = 0; i <= numCam; i++){
				if(campDist[i][j] == -1){
					campDist[i][j] = maxDist;
				}
			}
			bestTotDist[j] = -1;
			bestDist[j] = maxDist;
		}

		FloydWarshall(numCam);

		//newCam = 1;
		for(i = 1; i <= numCam; i++){
			if(campWithRanger[i] != 1){
				//newCam = i;
				campWithRanger[i] = 1;
				Dijkstra(numCam);
				campWithRanger[i] = 0;
			}

			for(j = 1; j <= numCam; j++){
				bestTotDist[i] = bestTotDist[i] + bestDist[j];
				bestDist[j] = maxDist;
			}
		}

		bestRang = 0;
		bestDistance = maxDist;
		for(i = 1; i <= numCam; i++){
			//cout << bestTotDist[i] << " ";
			if(bestTotDist[i] < bestDistance && bestTotDist[i] != -1){
				bestDistance = bestTotDist[i];
				bestRang = i;
			}
		}
		//cout << endl;

		cout << bestRang << endl;

		for(i = 1; i <= numCam; i++)
		{
			campWithRanger[i] = 0;
		}

		/*for(j = 1; j <= numCam; j++)
		{
			for(i = 1; i <= numCam; i++)
			{
				cout << campDist[i][j] << " ";
			}
			cout << endl;
		}

		cout << endl;*/
	}

	return 0;
}