#include <fstream>
using namespace std;

#define in "radiatie.in"
#define out "radiatie.out"
#define NMAX 15010
#define MMAX 30001
#define _INF_ 2000000000

typedef long int INT;
typedef struct nod {
        int vf;
        INT cost;
        nod*next;
} *PNOD, NOD;

      
PNOD L[NMAX];

int d[NMAX];
int tata[NMAX];
int s[NMAX];
int n, m, k, ok;
INT maxim, minim, val;

void Read();
void Dijkstra(int);
void Kap(int);
void Solve( int,int);
void Add( int i, int j, INT cost );
void Write();
void A( int i, int j, INT cost );

FILE *fout = fopen ( out, "w" );

int main()
{
    Read();

    fclose ( fout );
    return 0;
}

void Read()
{
     FILE *fin = fopen( in, "r" );
     fscanf( fin, "%d%d%d", &n, &m, &k );
     int i, x, y;
     INT c;
     for ( i = 1; i <= m; ++i )
     {
         fscanf( fin, "%d%d%ld", &x, &y, &c );
         Add( x, y, c );
         Add( y, x, c );
         d[x] = d[y] = _INF_;
     }
     for ( i = 1; i <= k; ++i )
     {
         fscanf( fin, "%d%d", &x, &y );
         Solve( x, y );
         //break;
     }
     fclose( fin );
}

void Add( int i, int j, INT cost )
{
     PNOD p = new NOD;
     p->vf = j;
     p->cost = cost;
     p->next = L[i];
     L[i] = p;
}

void Solve( int v1, int v2 )
{
     int i;
     maxim = val = 0;
     Dijkstra( v1 );
     
     for ( i = v2; tata[i] != 0; i = tata[i] )
     {
         INT prov = 0;
         prov = d[i] - d[tata[i]];
         if ( prov > maxim ) maxim = prov;
     }
     
     int n1 = v2;
     int n2 = tata[v2];
     for ( PNOD p = L[n1]; p; p = p->next )
     {
         if ( p->vf == n2 ) p->vf == 0;
     }
     for ( PNOD p = L[n2]; p; p = p->next )
     {
         if ( p->vf == n1 ) p->vf == 0;
     }
     //am calculat prima varianta
     //initializam pentru ce-a de doua
     for ( i = 1; i <= n; ++i )
     {
            d[i] = _INF_;
            tata[i] = s[i] = 0;
     }
     Kap( v1 );
     for ( i = v2; tata[i] != 0; i = tata[i] )
     {
         INT prov = 0;
         prov = d[i] - d[tata[i]];
         if ( prov > val ) val = prov;
     }
     INT sol = ( maxim < val ? maxim : val );
     fprintf( fout, "%ld\n", sol );
}

void Dijkstra( int sursa )
{
     for ( PNOD p = L[sursa]; p; p = p->next )
     {
         d[p->vf] = p->cost;
         tata[p->vf] = sursa;
     }
     d[sursa] = 0;
     tata[sursa] = 0;
     s[sursa] = 1;
     int tur, i;
     for ( tur = 1; tur <= n - 1; ++tur )
     {
         minim = _INF_;
         for ( i = 1; i <= n; ++i )
         {
               if ( !s[i] && d[i] < minim )
               {
                    minim = d[i];
                    ok = i;
               }
         }
         s[ok] = 1;
         for ( PNOD p = L[ok]; p; p = p->next )
         {
             if ( !s[p->vf] && d[p->vf] > d[ok] + p->cost )
             {
                  d[p->vf] = d[ok] + p->cost;
                  tata[p->vf] = ok;
             }
         }
     }
}

void Kap( int sursa )
{
     int tur, i, n1,n2;
     for ( PNOD p = L[sursa]; p && p > 0 ; p = p->next )
     {
         d[p->vf] = p->cost;
         tata[p->vf] = sursa;
     }
     d[sursa] = 0;
     tata[sursa] = 0;
     s[sursa] = 1;
     
     for ( tur = 1; tur <= n - 1; ++tur )
     {
         minim = _INF_;
         for ( i = 1; i <= n; ++i )
         {
               if ( !s[i] && d[i] < minim )
               {
                    minim = d[i];
                    ok = i;
               }
         }
         s[ok] = 1;
         for ( PNOD p = L[ok]; p && p > 0; p = p->next )
         {
             if ( !s[p->vf] && d[p->vf] > d[ok] + p->cost )
             {
                  d[p->vf] = d[ok] + p->cost;
                  tata[p->vf] = ok;
             }
         }
     }
}