#include <fstream>

#include <iomanip>
#include <vector>
#include <set>
#include <iterator>

using namespace std;


typedef struct Drum{
       int x, y;
};
typedef struct Nod{
       int vf;
       bool c;
};

vector<int> d, t;
vector<bool> sel;
vector<Drum> p;
vector<vector<Nod> > L;
int n, m, k, maxim1;

struct Functor {
	
	bool operator () (int i, int j)
	{
		return d[i] < d[j];
	}
};

multiset<int, Functor> Q;

void Read();
void Path(int nod);
void Mc();
void Df(int nod);
void Dijkstra(int source);

ofstream fout("radiatie.out");

int main()
{
	Read();
	int maxim = 0;
	int poz = 0;
    for(int i = 1; i <= k; i++)
    {
            maxim = 0;
            for(int j = 1; j <= p[i].y; j++)
            {
                    if(L[p[i].x][j].vf > maxim && L[p[i].x][j].c == false)
                    {
                                       maxim = L[p[i].x][j].vf;
                                       poz = j;
                    }
            }
            L[p[i].x][poz].vf = 0;
           
    }
    for(int i = 1; i <= n; i++) 
           for(int j = 1; j <= n; j++)
                   if(L[i][j].vf != 0 && L[j][i].vf == 0) L[j][i].vf = L[i][j].vf;
    for(int i = 1; i <= n; i++) 
           for(int j = 1; j <= n; j++)
                   if(L[i][j].vf == 0) L[i][j].vf = 1000000001;
    int ant = 0;
    for(int i = 1; i <= k; i++)
    {
            if(p[i].x != ant)
            {
                      Dijkstra(p[i].x);
                      Path(p[i].y);
                      fout << maxim1 << "\n";   
                      maxim1 = 0;
            }
            if(p[i].x == ant)
            {
                      fout << maxim1 << "\n";
            }
    }
    
    fout.close();
	return 0;
}

void Dijkstra(int source)
{
	for(int i = 1 ; i <= n; i++)   
	        d[i] = 1000000001;
    sel.assign(n+1, false);
	d[source] = 0;
	t[source] = 0;
	Q.insert(source);
	sel[source] = true;
	int k;
	while ( !Q.empty() )
	{
		k = *Q.begin();
		Q.erase(Q.begin());  
		sel[k] = false;
		for (int i = 1; i <= n; i++)
			if (d[i] > d[k] + L[k][i].vf )
			{			
				if ( sel[i] == true ) 
					Q.erase(i);
				else 
					sel[i] = true;
			
				d[i] = d[k] + L[k][i].vf;
				t[i] = k;
				Q.insert(i);
			}
	}
}

void Read()
{
     ifstream fin("radiatie.in");
     fin >> n >> m >> k;
     int i, v1, v2, c;
     p.resize(n+1);
     sel.resize(n+1);
     d.resize(n+1);
     L.resize(n+1);
     for(i = 1; i <= n; i++)
           L[i].resize(n+1);
     for(i = 1; i <= m; i++)
     {
           fin >> v1 >> v2 >> c;
           L[v1][v2].vf = c;
           //L[v2][v1].vf = c;
           //fout << v1 << " " << v2 << " " << c << "\n";
     }
     Mc();
     vector<Drum>().swap(p);
     p.resize(k+1);
     for(i = 1; i <= k; i++)
     {
           fin >> v1 >> v2;
           p[i].x = v1;
           p[i].y = v2;
     }
     t.resize(n+1);
     fin.close();
}

void Mc()
{
     for(int i = 1; i <= n; i++)
             if(sel[i] == false)
             {
                       p[i].y = 1;
                       Df(i);
             }
}

void Df(int nod)
{
     sel[nod] = true;
     p[nod].x = p[nod].y;
     for(int i = 1; i <= n; i++)
     {
             if(L[nod][i].vf != 0 && sel[i] == false)             
             {
                          p[i].y = p[nod].y + 1;
                          d[i] = nod;
                          Df(i);
                          if(p[nod].x > p[i].x) p[nod].x = p[i].x;
                          if(p[i].x < p[nod].y) 
                          {
                                    L[nod][i].c = true;
                          }
             }
             else
             {
                 if(i != d[nod] && p[nod].x > p[i].y) p[nod].x = p[i].y;
             }
     }
}
        
void Path(int nod)
{
     if(!t[nod]) return;
     Path(t[nod]);
     if(L[nod][t[nod]].vf > maxim1) maxim1 = L[nod][t[nod]].vf;
}