#include <bits/stdc++.h>
#define DMAX 5010
#define LMAX 20

using namespace std;

ifstream fin("radiatie.in");
ofstream fout("radiatie.out");

struct nume{
    int x,c;
};
struct nume2{
    int y,x,c;
};

vector <nume> V[DMAX];
vector <int> arb[DMAX];
priority_queue <nume2> heap;

int dp[DMAX];
bool uz[DMAX];

int M[2*DMAX][LMAX];
int ind[DMAX];
int euler[2*DMAX];
int h[DMAX];
int level[2*DMAX];
int dist[DMAX][DMAX];

int n,m,k,cate;

inline bool operator<(nume2 x,nume2 y){
    return x.c>y.c;
}
inline int maxim(int x,int y){
    if(x>y)
       return x;
    return y;
}

void citire();
void prim();
void dfs(int node);
void dfs2(int node,int rad);
void constr();

int main(){
    int i,x,y,node,a,b,aux,kk;
    citire();
    prim();
    memset(uz,0,sizeof(uz));
    dfs(1);
    constr();
    for(i=1;i<=n;i++)
        dfs2(i,i);
    while(k--)
        {fin>>a>>b;
         x=ind[a];
         y=ind[b];
         if(x<y)
            {aux=y;
             y=x;
             x=aux;
            }
         kk=log2(x-y+1);
         if(level[M[y][kk]] < level[M[x-(1<<kk)+1][kk]])
            node=euler[M[y][kk]];
            else
            node=euler[M[x-(1<<kk)+1][kk]];
         fout<<maxim(dist[node][a],dist[node][b])<<'\n';
        }

    return 0;
}
void citire(){
    int i,x,y,cost;
    fin>>n>>m>>k;
    for(i=1;i<=m;i++)
        {fin>>x>>y>>cost;
         V[x].push_back({y,cost});
         V[y].push_back({x,cost});
        }
}
void prim(){
    int i,j;
    nume2 var;
    uz[1]=true;
    for(i=0;i<V[1].size();i++)
        heap.push({1,V[1][i].x,V[1][i].c});
    for(i=2;i<=n;i++)
        {while(uz[heap.top().x])
               heap.pop();
         var=heap.top();
         dp[var.x]=var.c;
         uz[var.x]=true;
         arb[var.y].push_back(var.x);
         for(j=0;j<V[var.x].size();j++)
             if(!uz[V[var.x][j].x])
                heap.push({var.x,V[var.x][j].x,V[var.x][j].c});
        }
}
void dfs(int node){
    int i;

    cate++;
    euler[cate]=node;
    level[cate]=h[node];

    uz[node]=true;

    if(!ind[node])
       ind[node]=cate;

    for(i=0;i<arb[node].size();i++)
        if(!uz[arb[node][i]])
           {h[arb[node][i]]=h[node]+1;
            dfs(arb[node][i]);

            cate++;
            euler[cate]=node;
            level[cate]=h[node];
           }
}
void constr(){
    int i,j;
    for(i=1;i<=2*n-1;i++)
        M[i][0]=i;
    for(j=1; (1<<j)<=2*n-1; j++)
        for(i=1;i+(1<<j)-1<=2*n-1;i++)
            if(level[M[i][j-1]] < level[M[i+(1<<(j-1))][j-1]])
                M[i][j]=M[i][j-1];
                else
                M[i][j]=M[i+(1<<(j-1))][j-1];
}
void dfs2(int node,int rad){
    int i;
    for(i=0;i<arb[node].size();i++)
        {dist[rad][arb[node][i]]=maxim(dist[rad][node],dp[arb[node][i]]);
         dfs2(arb[node][i],rad);
        }
}