Problem: We have a graph with N vertices and M edges, and there are two people on the graph: Takahashi and Aoki.  The i-th edge connects Vertex U_i and Vertex V_i. The time it takes to traverse this edge is D_i minutes, regardless of direction and who traverses the edge (Takahashi or Aoki).  Takahashi departs Vertex S and Aoki departs Vertex T at the same time. Takahashi travels to Vertex T and Aoki travels to Vertex S, both in the shortest time possible. Find the number of the pairs of ways for Takahashi and Aoki to choose their shortest paths such that they never meet (at a vertex or on an edge) during the travel, modulo 10^9 + 7.

Submission attempts (in order):
from collections import defaultdict
from heapq import heappop, heappush


def get_patterns_func(s, ancestors):
    cache = {s: 1}

    def get_patterns(v):
        if v in cache:
            return cache[v]
        return sum(get_patterns(a) for a in ancestors[v])

    return get_patterns


def solve(s, t, links):
    MOD = 1000000007
    q = [(0, s, -1, 0), (0, t, -1, 1)]
    visited = [{}, {}]
    ancestors = [defaultdict(set), defaultdict(set)]
    limit = float('inf')
    collision_pair = set()
    while q:
        cost, v, a, is_bwd = heappop(q)
        if cost > limit:
            break
        visited_self = visited[is_bwd]
        # print(is_bwd, cost, v, a, visited_self)
        if v in visited_self and visited_self[v] < cost:
            continue

        visited_self[v] = cost
        ancestors[is_bwd][v].add(a)

        visited_opp = visited[is_bwd ^ 1]
        if v in visited_opp:
            cost_opp = visited_opp[v]
            if limit < cost + cost_opp:
                continue
            limit = cost + cost_opp
            if cost == cost_opp:
                # print('add', v)
                collision_pair.add((v, v))
            else:
                # print('add', v, a)
                collision_pair.add((v, a) if is_bwd else (a, v))
            continue

        for du, u in links[v]:
            nc = cost + du
            if u in visited_self and visited_self[u] < nc:
                continue
            heappush(q, (nc, u, v, is_bwd))

    get_patterns_fwd = get_patterns_func(s, ancestors[0])
    get_patterns_bwd = get_patterns_func(t, ancestors[1])
    shortest_count = 0
    collision_count = 0

    for u, v in collision_pair:
        r1, r2 = get_patterns_fwd(u), get_patterns_bwd(v)
        shortest_count += r1 * r2
        shortest_count %= MOD
        collision_count += pow(r1 * r2, 2, MOD)
        collision_count %= MOD
    # print(limit)
    # print(visited)
    # print(ancestors)
    
    

    return (pow(shortest_count, 2, MOD) - collision_count) % MOD


n, m = map(int, input().split())
s, t = map(int, input().split())
s -= 1
t -= 1
links = [set() for _ in range(n)]
for _ in range(m):
    u, v, d = map(int, input().split())
    u -= 1
    v -= 1
    links[u].add((d, v))
    links[v].add((d, u))
print(solve(s, t, links))


from bisect import bisect
from heapq import heappop, heappush


def solve(s, t, links):
    MOD, INF = 1000000007, float('inf')
    q = [(0, s, -1, 0), (0, t, -1, 1)]
    visited_fwd, visited_bwd = [float('inf')] * n, [float('inf')] * n
    pattern_fwd, pattern_bwd = [0] * n, [0] * n
    limit = float('inf')
    collision_nodes = set()
    collision_pairs = set()
    while q:
        cost, v, a, is_bwd = heappop(q)
        if is_bwd:
            visited_self = visited_bwd
            visited_opp = visited_fwd
            pattern_self = pattern_bwd
        else:
            visited_self = visited_fwd
            visited_opp = visited_bwd
            pattern_self = pattern_fwd
        if visited_self[v] < cost:
            continue
        visited_self[v] = cost
        pattern_self[v] += 1

        cost_opp = visited_opp[v]
        if cost_opp < INF:
            limit = cost + cost_opp
            if cost == cost_opp:
                collision_nodes.add(v)
            else:
                collision_pairs.add((v, a) if is_bwd else (a, v))
            break

        for du, u in links[v]:
            nc = cost + du
            if visited_self[u] < nc:
                continue
            heappush(q, (nc, u, v, is_bwd))

    q.sort()
    for cost, v, a, is_bwd in q[:bisect(q, (limit, n))]:
        if is_bwd:
            visited_self = visited_bwd
            visited_opp = visited_fwd
            pattern_self = pattern_bwd
        else:
            visited_self = visited_fwd
            visited_opp = visited_bwd
            pattern_self = pattern_fwd

        if visited_self[v] < cost:
            continue
        cost_opp = visited_opp[v]
        if cost_opp == INF:
            continue

        visited_self[v] = cost
        pattern_self[v] += 1

        if limit < cost + cost_opp or a in collision_nodes:
            continue
        if cost == cost_opp:
            collision_nodes.add(v)
        else:
            collision_pairs.add((v, a) if is_bwd else (a, v))

    shortest_count = 0
    collision_count = 0

    for v in collision_nodes:
        r1, r2 = pattern_fwd[v], pattern_bwd[v]
        shortest_count += r1 * r2
        shortest_count %= MOD
        collision_count += pow(r1 * r2, 2, MOD)
    collision_count %= MOD
    for u, v in collision_pairs:
        r1, r2 = pattern_fwd[u], pattern_bwd[v]
        shortest_count += r1 * r2
        shortest_count %= MOD
        collision_count += pow(r1 * r2, 2, MOD)

    return (pow(shortest_count, 2, MOD) - collision_count) % MOD


n, m = map(int, input().split())
s, t = map(int, input().split())
s -= 1
t -= 1
links = [set() for _ in range(n)]
for _ in range(m):
    u, v, d = map(int, input().split())
    u -= 1
    v -= 1
    links[u].add((d, v))
    links[v].add((d, u))
print(solve(s, t, links))


from bisect import bisect
from heapq import heappop, heappush


def solve(s, t, links):
    MOD, INF = 1000000007, float('inf')
    q = [(0, s, -1, 0), (0, t, -1, 1)]
    visited_fwd, visited_bwd = [float('inf')] * n, [float('inf')] * n
    pattern_fwd, pattern_bwd = [0] * n, [0] * n
    limit = float('inf')
    collision_nodes = set()
    collision_pairs = set()
    while q:
        cost, v, a, is_bwd = heappop(q)
        if is_bwd:
            visited_self = visited_bwd
            visited_opp = visited_fwd
            pattern_self = pattern_bwd
        else:
            visited_self = visited_fwd
            visited_opp = visited_bwd
            pattern_self = pattern_fwd
        if visited_self[v] < cost:
            continue
        visited_self[v] = cost
        pattern_self[v] += 1

        cost_opp = visited_opp[v]
        if cost_opp < INF:
            limit = cost + cost_opp
            if cost == cost_opp:
                collision_nodes.add(v)
            else:
                collision_pairs.add((v, a) if is_bwd else (a, v))
            break

        for du, u in links[v]:
            nc = cost + du
            if visited_self[u] < nc:
                continue
            heappush(q, (nc, u, v, is_bwd))

    q.sort()
    for cost, v, a, is_bwd in q[:bisect(q, (limit, n))]:
        print('loop', cost, v, a, is_bwd)
        if is_bwd:
            visited_self = visited_bwd
            visited_opp = visited_fwd
            pattern_self = pattern_bwd
        else:
            visited_self = visited_fwd
            visited_opp = visited_bwd
            pattern_self = pattern_fwd

        if visited_self[v] < cost:
            continue
        visited_self[v] = cost
        pattern_self[v] += 1

        cost_opp = visited_opp[v]
        if cost_opp < INF:
            if limit < cost + cost_opp or a in collision_nodes:
                continue
            if cost == cost_opp:
                collision_nodes.add(v)
            else:
                collision_pairs.add((v, a) if is_bwd else (a, v))

    shortest_count = 0
    collision_count = 0

    for v in collision_nodes:
        r1, r2 = pattern_fwd[v], pattern_bwd[v]
        shortest_count += r1 * r2
        shortest_count %= MOD
        collision_count += pow(r1 * r2, 2, MOD)
    collision_count %= MOD
    for u, v in collision_pairs:
        r1, r2 = pattern_fwd[u], pattern_bwd[v]
        shortest_count += r1 * r2
        shortest_count %= MOD
        collision_count += pow(r1 * r2, 2, MOD)

    return (pow(shortest_count, 2, MOD) - collision_count) % MOD


n, m = map(int, input().split())
s, t = map(int, input().split())
s -= 1
t -= 1
links = [set() for _ in range(n)]
for _ in range(m):
    u, v, d = map(int, input().split())
    u -= 1
    v -= 1
    links[u].add((d, v))
    links[v].add((d, u))
print(solve(s, t, links))


from heapq import heappop, heappush
import sys

MOD, INF = 1000000007, float('inf')


def solve(s, t, links):
    q = [(0, 0, s, -1, 0), (0, 0, t, -1, 1)]
    visited_fwd, visited_bwd = [INF] * n, [INF] * n
    patterns_fwd, patterns_bwd = [0] * n, [0] * n
    collision_nodes, collision_links = set(), set()
    limit = 0
    while q:
        cost, cost_a, v, a, is_bwd = heappop(q)
        if is_bwd:
            visited_self = visited_bwd
            visited_opp = visited_fwd
            patterns_self = patterns_bwd
        else:
            visited_self = visited_fwd
            visited_opp = visited_bwd
            patterns_self = patterns_fwd

        relax_flag = False
        cost_preceding = visited_self[v]
        if cost_preceding == INF:
            visited_self[v] = cost
            relax_flag = True
        elif cost > cost_preceding:
            continue

        patterns_self[v] += patterns_self[a]

        cost_opp = visited_opp[v]
        if cost_opp != INF:
            limit = cost + cost_opp
            if cost == cost_opp:
                collision_nodes.add(v)
            else:
                collision_links.add((v, a) if is_bwd else (a, v))
            break

        if relax_flag:
            for u, du in links[v].items():
                nc = cost + du
                if visited_self[u] < nc:
                    continue
                heappush(q, (nc, cost, u, v, is_bwd))

    collision_time = limit / 2
    while q:
        cost, cost_a, v, a, is_bwd = heappop(q)
        if cost > limit:
            break
        visited_self = visited_bwd if is_bwd else visited_fwd
        if visited_self[v] == INF:
            visited_self[v] = cost
        if is_bwd:
            if cost == collision_time:
                patterns_bwd[v] += patterns_bwd[a]
            continue
        if cost_a == collision_time:
            collision_nodes.add(a)
        elif cost == collision_time:
            collision_nodes.add(v)
            patterns_fwd[v] += patterns_fwd[a]
        else:
            collision_links.add((a, v))

    shortest_count = 0
    collision_count = 0

    for v in collision_nodes:
        if visited_fwd[v] == visited_bwd[v]:
            r = patterns_fwd[v] * patterns_bwd[v]
            shortest_count += r
            shortest_count %= MOD
            collision_count += r * r
            collision_count %= MOD

    for u, v in collision_links:
        if visited_fwd[u] + visited_bwd[v] + links[u][v] == limit:
            r = patterns_fwd[u] * patterns_bwd[v]
            shortest_count += r
            shortest_count %= MOD
            collision_count += r * r
            collision_count %= MOD

    return (shortest_count ** 2 - collision_count) % MOD


n, m = map(int, input().split())
s, t = map(int, input().split())
s -= 1
t -= 1
links = [{} for _ in range(n)]
for uvd in sys.stdin.readlines():
    u, v, d = map(int, uvd.split())
    # for _ in range(m):
    #     u, v, d = map(int, input().split())
    u -= 1
    v -= 1
    links[u][v] = d
    links[v][u] = d
print(solve(s, t, links))


from heapq import heappop, heappush
import sys

MOD, INF = 1000000007, float('inf')


def solve(s, t, links):
    q = [(0, 0, s, -1, 0), (0, 0, t, -1, 1)]
    visited_fwd, visited_bwd = [INF] * n, [INF] * n
    patterns_fwd, patterns_bwd = [0] * (n + 1), [0] * (n + 1)
    patterns_fwd[-1] = patterns_bwd[-1] = 1
    collision_nodes, collision_links = set(), set()
    limit = 0
    while q:
        cost, cost_a, v, a, is_bwd = heappop(q)
        if is_bwd:
            visited_self = visited_bwd
            visited_opp = visited_fwd
            patterns_self = patterns_bwd
        else:
            visited_self = visited_fwd
            visited_opp = visited_bwd
            patterns_self = patterns_fwd

        relax_flag = False
        cost_preceding = visited_self[v]
        if cost_preceding == INF:
            visited_self[v] = cost
            relax_flag = True
        elif cost > cost_preceding:
            continue

        patterns_self[v] += patterns_self[a]

        cost_opp = visited_opp[v]
        if cost_opp != INF:
            limit = cost + cost_opp
            if cost == cost_opp:
                collision_nodes.add(v)
            else:
                collision_links.add((v, a) if is_bwd else (a, v))
            break

        if relax_flag:
            for u, du in links[v].items():
                nc = cost + du
                if visited_self[u] < nc:
                    continue
                heappush(q, (nc, cost, u, v, is_bwd))

    collision_time = limit / 2
    while q:
        cost, cost_a, v, a, is_bwd = heappop(q)
        if cost > limit:
            break
        visited_self = visited_bwd if is_bwd else visited_fwd
        if visited_self[v] == INF:
            visited_self[v] = cost
        if is_bwd:
            if cost == collision_time:
                patterns_bwd[v] += patterns_bwd[a]
            continue
        if cost_a == collision_time:
            collision_nodes.add(a)
        elif cost == collision_time:
            collision_nodes.add(v)
            patterns_fwd[v] += patterns_fwd[a]
        else:
            collision_links.add((a, v))

    shortest_count = 0
    collision_count = 0

    for v in collision_nodes:
        if visited_fwd[v] == visited_bwd[v]:
            r = patterns_fwd[v] * patterns_bwd[v]
            shortest_count += r
            shortest_count %= MOD
            collision_count += r * r
            collision_count %= MOD

    for u, v in collision_links:
        if visited_fwd[u] + visited_bwd[v] + links[u][v] == limit:
            r = patterns_fwd[u] * patterns_bwd[v]
            shortest_count += r
            shortest_count %= MOD
            collision_count += r * r
            collision_count %= MOD

    return (shortest_count ** 2 - collision_count) % MOD


n, m = map(int, input().split())
s, t = map(int, input().split())
s -= 1
t -= 1
links = [{} for _ in range(n)]
for uvd in sys.stdin.readlines():
    u, v, d = map(int, uvd.split())
    # for _ in range(m):
    #     u, v, d = map(int, input().split())
    u -= 1
    v -= 1
    links[u][v] = d
    links[v][u] = d
print(solve(s, t, links))


Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

Accepted