Question

有很多图问题需要对 BFS 算法进行一些修改。我刚遇到这个问题。我想到了这个问题，只是对标准 BFS 算法进行了扩展。问题指出：

给定一个国家，有 N 个城市和 M 条双向道路。每个城市都有一个红绿灯，只有两种颜色，即绿色和红色。每 T 秒后，所有交通灯的颜色都会从绿色变为红色，反之亦然。只有红绿灯时我们才能穿过城市。最初，所有交通灯都是绿色的。在任何城市，如果交通灯是红色的，那么我们必须等待它的灯变绿。走任何一条路所花费的时间都是 C。我们必须找到从 1 到 N 市的最短时间。

注意：图不包含自环或多条边。

例如：

N=5,M=5,T=3,C=5

边缘是：

1 2,

1 3,

2 4,

1 4,

2 5.

这里从 1 到 5 的最短时间是 11 通过路径 1 2 5.我们可以在 5 秒内到达城市 2。然后等待 1 秒让灯变绿，然后等待 5 秒转至 5。

谁能分享他解决这个问题的方法？是 BFS 问题还是其他一些图算法也需要？最好理解伪代码是否与算法一起存在？

Answer 1

因为所有城市的初始状态都相同，开关灯的频率相同，并且所有道路的持续时间相同，所以交通灯对所有路线的延迟都是相同的。

由于所有道路的持续时间相同，这意味着 BFS 将是解决问题的有效方法。对标准算法的唯一调整是调整每个节点的时间，以解决由于交通灯引起的任何延迟。

（如果道路的持续时间不同，或者灯不规则地切换，则需要更高级的算法，例如 Dijkstra。）

Answer 2

我假设所有的边权重都是整数秒。

注意交通灯的周期是2T。取你的原始图 G 并复制它的节点 2T 次：G₀, G₁, . .., G_{2T - 1}。如果原始图中从节点 a 到 b 的边 G 中存在权重为 w 的边，则添加一个从G_t中的每个节点a到b中b的具有权重的边w em>G_{(t + w) mod 2T} 对于每个 t，其中 a 中的光是绿色的。在G_t、G_{(t+1) mod 2T}中的每个节点之间添加权重为1的边，表示等待的可能性一座城市。

最后，将 G 的节点的另一个副本添加到您的图表中，D，它将用于目标节点。将 G_t 中每个节点的边添加到 D 中的相应节点，权重为 0。

那么G₀中的节点s和D中的t之间的最短路径em> 完全符合您的问题。

Answer 3

Auth::user()->hasRole(['admin', 'client']);

Answer 4

这个问题是在我参加过的一家公司的编码回合中提出的，我可以想出一个时间复杂度为 O(n) 的 BFS 解决方案。

（编码回合现已结束。这是我的解决方案）-已编辑

我的解决方案（Python 3）：

def getPresentTrafficColorAndWaitTime(curr_color,traffic,cost_travel):
    #color
    val = (cost_travel//traffic)%2
    if val == 1:
        curr_color = 0 if curr_color==1 else 1

    #waitTime
    waitTime = traffic - (cost_travel%traffic)

    return curr_color,waitTime


def bfs(adj,visited,curr,final,traffic,cost_travel):
    queue = []
    queue.append(1)
    visited[1] = 1
    dist = 0
    # Red: 1 , Green: 0
    curr_color = 0
    temp_cost_travel = cost_travel
    while queue:
        length = len(queue)
        for _ in range(length):
            curr = queue[0]
            queue.pop(0)
            for i in adj[curr]:
                if i == final:
                    return dist+cost_travel
                elif visited[i] == 0:
                    visited[i] = 1
                    queue.append(i)
        curr_color,waitTime = getPresentTrafficColorAndWaitTime(curr_color,traffic,temp_cost_travel)
        if curr_color == 1:
            add_dist = waitTime
            temp_cost_travel = cost_travel
            curr_color = 0
        else:
            add_dist = 0
            temp_cost_travel += cost_travel
        dist += cost_travel + add_dist
    return -1


# Taking Input and creating Adjacency-list using defaultdict
n,m,t,c = map(int,input().split())
adj_list = defaultdict(list)
for _ in range(m):
    u,v = map(int,input().split())
    adj_list[u] = adj_list.get(u,[]) + [v]
    adj_list[v] = adj_list.get(v,[]) + [u]

visited = [0]*(n+1)

answer = bfs(adj_list,visited,1,n,t,c)
print(answer)

从城市 1 到城市 N 的最短时间

4 个答案: