#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll INF = 1e18;

struct Edge { int v; int w; };

vector<ll> dijkstra(int n, int src, const vector<vector<Edge>>& g) {
    vector<ll> dist(n + 1, INF);
    dist[src] = 0;
    using pli = pair<ll, int>;
    priority_queue<pli, vector<pli>, greater<pli>> pq;
    pq.push({0, src});
    while (!pq.empty()) {
        auto [d, u] = pq.top(); pq.pop();
        if (d != dist[u]) continue;
        for (auto &e : g[u]) {
            ll nd = d + e.w;
            if (nd < dist[e.v]) {
                dist[e.v] = nd;
                pq.push({nd, e.v});
            }
        }
    }
    return dist;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n, m, k;
    if (!(cin >> n >> m >> k)) return 0;
    int A, B;
    cin >> A >> B;
    vector<ll> price(n + 1, -1);
    for (int i = 0; i < k; ++i) {
        int idx; ll p;
        cin >> idx >> p;
        price[idx] = p;
    }
    vector<vector<Edge>> g(n + 1);
    for (int i = 0; i < m; ++i) {
        int u, v, w;
        cin >> u >> v >> w;
        g[u].push_back({v, w});
        g[v].push_back({u, w});
    }

    vector<ll> distA = dijkstra(n, A, g);
    vector<ll> distB = dijkstra(n, B, g);

    ll minTotal = INF;
    int bestCity = -1;
    ll bestPrice = -1;

    for (int i = 1; i <= n; ++i) {
        if (price[i] != -1) {
            if (distA[i] == INF || distB[i] == INF) continue;
            ll total = distA[i] + distB[i] + price[i];
            if (total < minTotal) {
                minTotal = total;
                bestCity = i;
                bestPrice = price[i];
            } else if (total == minTotal) {
                if (price[i] > bestPrice) {
                    bestCity = i;
                    bestPrice = price[i];
                } else if (price[i] == bestPrice) {
                    if (i < bestCity) {
                        bestCity = i;
                    }
                }
            }
        }
    }

    cout << minTotal << " " << bestCity << "\n";
    return 0;
}

// Pseudocode / Core Logic
// Sử dụng Dijkstra với priority queue lưu {cost, u, bought}
// bought = 0: chưa mua tiền, bought = 1: đã mua tiền
// dist[u][0]: chi phí nhỏ nhất để đến u mà chưa mua tiền
// dist[u][1]: chi phí nhỏ nhất để đến u mà đã mua tiền

void solve() {
    // Khởi tạo dist[][] = INF
    // dist[A][0] = 0
    // Nếu A có bán tiền, dist[A][1] = price[A]
    // PQ push({0, A, 0})
    // Nếu A có bán tiền, push({price[A], A, 1})

    // while (!PQ.empty()) {
    //   pop node {d, u, state}
    //   if (d > dist[u][state]) continue;
    //   
    //   for (edge u-v weight w) {
    //     // Case 1: Chưa mua tiền
    //     if (state == 0) {
    //       // Đi tiếp mà vẫn chưa mua
    //       if (d + w < dist[v][0]) update(dist[v][0], d+w);
    //       
    //       // Nếu v có bán tiền, quyết định mua ở đây
    //       if (price[v] != -1) {
    //         if (d + w + price[v] < dist[v][1]) update(dist[v][1], d+w+price[v]);
    //       }
    //     }
    //     // Case 2: Đã mua tiền
    //     else {
    //       // Đi tiếp, chỉ cộng chi phí đường
    //       if (d + w < dist[v][1]) update(dist[v][1], d+w);
    //     }
    //   }
    // }

    // // Kết quả là dist[B][1]
    // // Lưu ý: Cách này chỉ tìm được chi phí nhỏ nhất, không直接 tìm được thành phố mua tiền.
    // // Để tìm thành phố, ta cần truy vết (backtracking) hoặc kết hợp với cách 1.
}

// Ý tưởng:
// 1. Tìm tất cả đường đi từ A đến B.
// 2. Với mỗi đường đi, kiểm tra xem có thành phố nào bán tiền không.
// 3. Tính chi phí.
// Độ phức tạp: Quá lớn, không khả thi với n <= 5000.