#
# Complete the 'minimalCost' function below.
#
# The function is expected to return an INTEGER.
# The function accepts following parameters:
#  1. INTEGER n
#  2. INTEGER start_city
#  3. INTEGER end_city
#  4. 2D_INTEGER_ARRAY roads
#  5. 2D_INTEGER_ARRAY flights
#
import heapq
def assert_range(x, a, b):
    assert a <= x and x <= b

def assert_input(n, start_city, end_city, roads, flights):
    N_M_K_RANGE = 1, 10**5
    LEN_RANGE = 1, 10**4
    assert_range(n , *N_M_K_RANGE)
    CITIES_RANGE = 1, n
    assert_range(len(roads) , *N_M_K_RANGE)
    assert_range(len(flights) , *N_M_K_RANGE)
    assert_range(start_city , *CITIES_RANGE)
    assert_range(end_city , *CITIES_RANGE)
    for i in range (len(roads)):
        assert len(roads[i]) == 3
        assert_range(roads[i][0] , *CITIES_RANGE)
        assert_range(roads[i][1] , *CITIES_RANGE)
        assert_range(roads[i][2] , *LEN_RANGE)
    for i in range (len(flights)):
        assert len(flights[i]) == 3
        assert_range(flights[i][0] , *CITIES_RANGE)
        assert_range(flights[i][1] , *CITIES_RANGE)
        assert_range(flights[i][2] , *LEN_RANGE)

def dijkstra(n, start, roads):
    start -= 1
    INF = 10**9+47
    g = [[] for _ in range(n)]
    for i in range (len(roads)):
        u = roads[i][0]
        v = roads[i][1]
        d = roads[i][2]
        u -= 1
        v -= 1
        g[v].append((u, d))
        g[u].append((v, d))

    dist = [INF for _ in range(n)]
    q = []
    q.append((0, start))
    dist[start] = 0
    while q:
        d, v = heapq.heappop(q)
        if d > dist[v]:
            continue
        for u, w in g[v]:
            new_d = d + w
            if new_d < dist[u]:
                dist[u] = new_d
                heapq.heappush(q , (dist[u] , u))
    return dist

def minimalCost(n, start_city, end_city, roads, flights):
    assert_input(n, start_city, end_city, roads, flights)
    f = dijkstra(n, start_city, roads)
    g = dijkstra(n, end_city, flights)
    INF = 10**9+47
    ans = INF
    for i in range (n):
        print(str(f[i]) + "  " + str(g[i]))
        if f[i] == INF or g[i] == INF:
            continue
        ans = min(ans , f[i] + g[i])
    if ans == INF:
        ans = -1
    return ans