/*
	Keep It Simple!
*/

#include<iostream>
#include<fstream>
#include<list>
#include<vector>

#define MaxN 36005
#define inf 1<<30

using namespace std;

int N, M, K;

vector< pair<int, int> > G[MaxN];

int Distances[MaxN],Heap[MaxN],InHeapPosition[MaxN],Catun[MaxN];
bool viz[MaxN];
int Number_Of_Heap_Elements;

void swap(int v[],int a,int b)
{
    int aux = v[a];
    v[a] = v[b];
    v[b] = aux;
}

void GoUp(int x)
{
	while( x/2 >= 1 && Distances[Heap[x]] < Distances[Heap[x/2]] )
	{
		int aux = Heap[x];
		Heap[x] = Heap[x/2];
		Heap[x/2] = aux;
		
		InHeapPosition[Heap[x]] = x;
		InHeapPosition[Heap[x/2]] = x/2;
		
		x = x/2;
	}
}

void Heap_push_back(int idx)
{
	Heap[++Number_Of_Heap_Elements] = idx;
	InHeapPosition[idx] = Number_Of_Heap_Elements;
	GoUp(Number_Of_Heap_Elements);
}

void GoDown(int x)
{
	int y = x;
	do
	{
	    x = y;
		y = x;
		if( 2*x <= Number_Of_Heap_Elements && Distances[Heap[2*x]] < Distances[Heap[y]] ) y = 2*x;
	    if( 2*x+1 <= Number_Of_Heap_Elements && Distances[Heap[2*x+1]] < Distances[Heap[y]] ) y = 2*x+1;

		if(x != y)
		{
			int aux = Heap[x];
			Heap[x] = Heap[y];
			Heap[y] = aux;
			
			InHeapPosition[Heap[x]] = x;
			InHeapPosition[Heap[y]] = y;
		}
	}while(x != y);
}


void RemoveFirstElement()
{
	Heap[1] = Heap[Number_Of_Heap_Elements--];
	InHeapPosition[Heap[1]] = 1;
	GoDown(1);
}

void Dijkstra()
{
	while(Number_Of_Heap_Elements)
	{
		int node = Heap[1];
		RemoveFirstElement();
		viz[node] = 1;
		for(size_t i = 0; i < G[node].size(); i++)
		{
			int vecin = G[node][i].first;
			int cost = G[node][i].second;
			
			if(!viz[vecin] && Distances[vecin] > Distances[node] + cost)
			{
				Distances[vecin] = Distances[node]+cost;
				Catun[vecin] = Catun[node];
				GoUp(InHeapPosition[vecin]);
			}
			else if( Distances[vecin] == Distances[node] + cost )
			{
				if(Catun[vecin] > Catun[node] ) Catun[vecin] = Catun[node];
			}
		}
	}
}

int main()
{
	ifstream f("catun.in");
	ofstream g("catun.out");
	
	f >> N >> M >> K;
	
	int x,y,c;
	
	for(int i=1;i<=N;i++){ Distances[i] = inf; 
		Heap_push_back(i); }
	
	for(int i=1;i<=K;i++)
	{
		f >> x;
		Distances[x] = 0;
		Catun[x] = x;
		GoUp(InHeapPosition[x]);
	}

	
	for(int i=1;i<=M;i++)
	{
		f >> x >> y >> c;
		G[x].push_back( make_pair(y,c) );
		G[y].push_back( make_pair(x,c) );
	}
		
	Dijkstra();
	
	for(int i=1;i<=N;i++)
	{
		if(Catun[i] == i)
			g << "0 ";
		else
		    g << Catun[i] << " ";
	}
	
	f.close();
	g.close();
	return 0;
}