import java.io.*;
import java.util.*;
public class dining {
	static int V;
    static int minDist(int dist[], boolean[] set1)  { 
        int min = Integer.MAX_VALUE, min_index=-1; // Computers are too stupid to understand infinite
        for (int v = 0; v < V; v++) 
            if (set1[v] == false && dist[v] <= min) { 
                min = dist[v]; 
                min_index = v; 
            } 
        return min_index; 
    } 
    static final int OFFSET  = -1; // Offset by 1 for adjancey matirix because index begins at 0
    public static int[] root;
    public static int status = -1;
    public static int[] arr;
    public static int[] pasture;
    private static int[] dijkstra(int[][] graph1, int startVertex) {
    	status = 0;
        int N = graph1.length;
        int[] dists = new int[N];
        boolean[] added = new boolean[N];
        for (int vertexIndex = 0; vertexIndex < N; vertexIndex++) {
            dists[vertexIndex] = Integer.MAX_VALUE;
            added[vertexIndex] = false;
        }
        dists[startVertex] = 0;
        int[] parents = new int[N];
        parents[startVertex] = -1;
        for (int i = 1; i < N; i++) {
            int nearestVertex = -1;
            int shortestDistance = Integer.MAX_VALUE;
            for (int vertexIndex = 0; vertexIndex < N; vertexIndex++) {
                if (!added[vertexIndex] && dists[vertexIndex] < shortestDistance) {
                    nearestVertex = vertexIndex;
                    shortestDistance = dists[vertexIndex];
                }
            }
            added[nearestVertex] = true;
            for (int vertexIndex = 0; vertexIndex < N; vertexIndex++) {
            	
                int edgeDistance = graph1[nearestVertex][vertexIndex];
                // Used to be    >
                if (edgeDistance != 0 && ((shortestDistance + edgeDistance) < dists[vertexIndex])) {
                    parents[vertexIndex] = nearestVertex;
                    dists[vertexIndex] = shortestDistance +
                        edgeDistance;
                   
                }
                if(edgeDistance<0) {
                	System.out.println("Info: "+nearestVertex+" "+vertexIndex);
                	arr[nearestVertex-1] = 1;
                	arr[vertexIndex-1] = 1;
                	/*
                	if(pasture[nearestVertex] > 0) {
                	for(int j = 0; j < N; j++) {
        				
        					graph1[nearestVertex][j] = 0;
                        	graph1[j][nearestVertex] = 0;
        				
        			}
                	}
                	if(pasture[vertexIndex] > 0) {
                    	for(int j = 0; j < N; j++) {
            				
            					graph1[j][vertexIndex] = 0;
                            	graph1[vertexIndex][j] = 0;
            				
            			}
                    	}
                    */
                	graph1[nearestVertex][vertexIndex] = 0;
                	graph1[vertexIndex][nearestVertex] = 0;
                }
            }
        }
        root = parents;
        return dists;
    }
	public static void main(String[] args) throws IOException{
		BufferedReader f = new BufferedReader(new FileReader("dining.in"));
		StringTokenizer st = new StringTokenizer(f.readLine());
		int N = Integer.parseInt(st.nextToken());
		int M = Integer.parseInt(st.nextToken());
		int K = Integer.parseInt(st.nextToken());
		int[][] matrix = new int[N][N];
		arr = new int[N-1];
		pasture = new int[N];
		for(int i = 0; i < N; i++){
		//Arrays.fill(matrix[i], Integer.MAX_VALUE);
		}
		for(int i = 0; i < M; i ++) {
			st = new StringTokenizer(f.readLine());
			int x = Integer.parseInt(st.nextToken()),y = Integer.parseInt(st.nextToken()),z = Integer.parseInt(st.nextToken());
			matrix[x + OFFSET][y + OFFSET] = z;
			matrix[y + OFFSET][x + OFFSET] = z;
		}
		//System.out.println(Arrays.deepToString(matrix).replaceAll("],*", "],\n"));
		// Dijkstra Modification begins here
		for(int i = 0; i < K; i++) {
			st = new StringTokenizer(f.readLine());
			int x = Integer.parseInt(st.nextToken());
			int y = Integer.parseInt(st.nextToken());
			pasture[x-1] = y;
			x = x + OFFSET;
			for(int j = 0; j < N; j++) {
				if(matrix[j][x] != 0) {
					//System.out.println("Override 1   "+j+" "+x+" "+y);
				matrix[j][x] = matrix[j][x] - y;
				}
				if(matrix[x][j] != 0) {
					//System.out.println("Override 2   "+x+" "+j+" "+y);
				matrix[x][j] = matrix[x][j] - y;
				}
			}
		}
		// End modification
		//System.out.println("Modifacation Complete");
		//System.out.println(Arrays.deepToString(matrix).replaceAll("],*", "],\n"));
		int[] out = dijkstra(matrix, N-1);
		
		//System.out.println(Arrays.toString(root));
		//System.out.println(Arrays.toString(out));
		PrintWriter pw = new PrintWriter(new FileWriter("dining.out"));
		for(int k:arr) {
			pw.println(k);
		}
		pw.close();
		
	}
}