交通信号

import sys
import copy
from collections import deque
import heapq

input = lambda: sys.stdin.readline().rstrip("\r\n")
printf = lambda d: sys.stdout.write(str(d) + "\n")

INF = int(1e20)


# sys.setrecursionlimit(10000)


def mul_input():
    return map(int, input().split())


class Edge:
    g = 0
    r = 0
    v = 0
    w = 0
    ne = 0
    dir = 0


def add(a, b, g, r, w, dir):
    global idx
    e[idx].v = b
    e[idx].w = w
    e[idx].g = g
    e[idx].r = r
    e[idx].dir = dir
    e[idx].ne = h[a]
    h[a] = idx
    idx += 1


def dijkstra(s):
    vis = [False] * (n + 1)
    dis = [INF] * (n + 1)
    dis[0] = dis[s] = 0
    vis[0] = True

    q = []

    heapq.heappush(q, [0, s])

    while q:
        _, u = heapq.heappop(q)

        if vis[u]:
            continue

        vis[u] = True

        i = h[u]
        while i != -1:
            v = e[i].v
            g = e[i].g
            w = e[i].w
            r = e[i].r
            dir = e[i].dir
            i = e[i].ne

            temp = dis[u] % (g + w + r)

            if dir == 1:
                if 0 <= temp < g:
                    minm = dis[u] + w
                else:
                    minm = dis[u] + w + g + w + r - temp

            if dir == 2:
                if g+w <= temp < g+r+w:
                    minm = dis[u] + w
                else:
                    minm = dis[u] + w + g + w - temp

            if dis[v] > minm:
                dis[v] = minm
                if not vis[v]:
                    heapq.heappush(q, [minm, v])

    return dis


n, m, s, t = mul_input()
idx = 0
h = [-1] * (n + 1)
e = [Edge() for _ in range(2 * m + 1)]

for _ in range(m):
    u, v, g, r, d = mul_input()
    add(u, v, g, r, d, 1)
    add(v, u, g, r, d, 2)

ans = dijkstra(s)

if ans[t] == INF:
    print(-1)
else:
    print(ans[t])

个人思路是存无向图跑dijkstra，取余判断是否可以通行，不可以通行就加上需要等待的时间。