#include<bits/stdc++.h>

#define int long long
#define pb push_back
#define fi first
#define se second
using namespace std;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int maxN = 5e5 + 5;
const int mod = 1e9 + 7;
const ll oo = 1e18;

struct ForbiddenPath {
    int x, y;
};

struct RealVertex {
    int u, w;

    bool operator<(const RealVertex &other) const {
        return (u == other.u)? w > other.w : u > other.u;
    }
};

struct CheckVertex {
    int pre, cur;

    bool operator<(const CheckVertex &other) const {
        return (pre == other.pre)? cur < other.cur : pre < other.pre;
    }
};

struct Vertex {
    int pre, cur, w;

    bool operator<(const Vertex &other) const {
        return w > other.w;
    }
};

int n, m, k;
int source, target;
map<CheckVertex, int> f;
map<RealVertex, int> forbid;
vector<RealVertex> adj[maxN];
priority_queue<Vertex> pq;

void ReadInput()
{
    cin >> m >> n >> k;
    cin >> source >> target;
    for(int i = 1; i <= m; i++) {
        int u, v, w; cin >> u >> v >> w;
        adj[u].pb({v, w});
    }
    for(int i = 1; i <= k; i++) {
        int x, y, z; cin >> x >> y >> z;
        forbid[{x, y}] = z;
    }
}

void Dijkstra() {
    pq.push({-1, source, 0});
    f[{-1, source}] = 0;
    while(!pq.empty()) {
        Vertex u = pq.top();
        pq.pop();
        auto &fu = f[{u.pre, u.cur}];
        if(u.w != fu) continue;
        for(auto v: adj[u.cur]) {
            auto it = forbid.find({u.pre, u.cur});
            //cerr << u.pre << ' ' << u.cur << ' ' << v.u << ' ' << (it != forbid.end()) << '\n';
            if(it != forbid.end() && it->second == v.u) continue;
            //cerr << u.pre << ' ' << u.cur << ' ' << v.u << '\n';
            if(f.find({u.cur, v.u}) == f.end()) {
                auto &fv = f[{u.cur, v.u}];
                fv = fu + v.w;
                pq.push({u.cur, v.u, fv});
                //cerr << u.cur << ' ' << v.u << ' ' << fu << ' ' << v.w << ' ' << fv << '\n';
                continue;
            }
            auto &fv = f[{u.cur, v.u}];
            if(fv > fu + v.w) {
                fv = fu + v.w;
                pq.push({u.cur, v.u, fv});
                continue;
            }
        }
    }
}

void Solve()
{
    if(source == target) {
        cout << 0 << '\n';
        return;
    }
    int res = oo;
    for(int u = 0; u < n; u++) {
        //cerr << u << '\n';
        for(auto v: adj[u]) {
            //cerr << u << ' ' << v.u << ' ' << res << '\n';
            if(v.u == target) {
                if(f.find({u, v.u}) == f.end()) continue;
                res = min(res, f[{u, v.u}]);
                //cerr << u << ' ' << v.u << ' ' << res << '\n';
            }
        }
    }
    if(res == oo) cout << -1 << '\n';
    else cout << res << '\n';
}
#define taskname "sol"
int32_t main()
{
    if (fopen(taskname ".inp", "r"))
    {
        freopen(taskname ".inp", "r", stdin);
        freopen(taskname ".out", "w", stdout);
    }
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    int T = 1;
    //cin >> T;
    for(int itest=1; itest<=T; itest++)
    {
        ReadInput();
        Dijkstra();
        Solve();
    }
}