#include <iostream>
#include <vector>
#include <queue>
#include <fstream>
#include <algorithm>
#include <limits.h>

using namespace std;

struct Edge {
    int to, length;
};

vector<vector<Edge>> adj;
vector<pair<int, int>> queries;

bool canReach(int N, int maxLength, int start, int end) {
    vector<bool> visited(N + 1, false);
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
    
    pq.push({0, start});
    
    while (!pq.empty()) {
        auto [dist, node] = pq.top();
        pq.pop();
        
        if (node == end) return true;
        if (visited[node]) continue;
        
        visited[node] = true;
        
        for (auto& edge : adj[node]) {
            if (edge.length <= maxLength && !visited[edge.to]) {
                pq.push({dist + edge.length, edge.to});
            }
        }
    }
    
    return false;
}

int findMinMaxEdgeLength(int N, int start, int end) {
    int left = 1, right = 1e9;
    int answer = right;
    
    while (left <= right) {
        int mid = (left + right) / 2;
        if (canReach(N, mid, start, end)) {
            answer = mid;
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    
    return answer;
}

int main() {
    ifstream fin("radiatie.in");
    ofstream fout("radiatie.out");
    
    int N, M, K;
    fin >> N >> M >> K;
    
    adj.resize(N + 1);
    
    for (int i = 0; i < M; ++i) {
        int a, b, c;
        fin >> a >> b >> c;
        adj[a].push_back({b, c});
        adj[b].push_back({a, c});
    }
    
    queries.resize(K);
    for (int i = 0; i < K; ++i) {
        int x, y;
        fin >> x >> y;
        queries[i] = {x, y};
    }
    
    for (const auto& [x, y] : queries) {
        int result = findMinMaxEdgeLength(N, x, y);
        fout << result << "\n";
    }
    
    fin.close();
    fout.close();
    
    return 0;
}