如果仅当节点为绿色时才允许旅行，则从节点 1 到达 N 的最短时间

给定一个N 个节点和M 个边的无向连通图。每个节点都有一个灯，但有时它可以是绿色或红色。最初，所有节点都是绿色的。每隔T秒，光的颜色就会从绿色变为红色，反之亦然。只有当节点 U 的颜色是绿色时，才有可能从节点 U 移动到节点 V。通过任何边缘所需的时间是C秒。求从节点 1 到节点 N 所需的最短时间。

例子：

Input: N = 5, M = 5, T = 3, C = 5
           Edges[] = {{1, 2}, {1, 3}, {1, 4}, {2, 4}, {2, 5}}
Output: 11
Explanation: At 0sec, the color of node 1 is green, so travel from node 1 to node 2 in 5sec.
Now at 5sec, the color of node 2 is red so wait 1sec to change into green.
Now at 6sec, the color of node 2 is green, so travel from node 2 to node 5 in 5sec.
Total time = 5(from node 1 to node 2) + 1(wait at node 2) + 5(from node 2 to node 5) = 11 sec.

方法：给定的问题可以通过使用广度优先搜索和 Dijkstra 算法来解决，因为该问题类似于最短路径问题。请按照以下步骤解决问题：

• 初始化一个队列，比如Q ，它存储要遍历的节点以及到达该节点所需的时间。
• 创建一个布尔数组，比如V ，它存储当前节点是否被访问。
• 将节点 1 和时间 0 作为一对推送到队列Q 中。
• 考虑到总是有绿灯并且穿过边缘需要 1 秒，然后只需运行 BFS 并找到从节点 1 到达节点 N 所需的最短时间并将其存储在一个变量中，比如time 。
• 创建一个函数findTime ，如果通过边缘移动需要C秒并且光颜色在T秒后通过执行以下步骤发生变化，它会找到时间：
  • 将变量ans初始化为 0，该变量将存储从节点 1 到达节点 N 所需的最短时间。
  • 使用变量i在范围[0, time] 中迭代并执行以下步骤：
    • 如果(ans/T) %2 = 1 ，则将ans的值修改为(ans/T + 1)* T + C 。
    • 否则，将C添加到变量ans 。
• 打印ANS作为回答。

下面是上述方法的实现：

Python3

# Python program for the above approach
  
# Import library for Queue
from queue import Queue
  
# Function to find min edge
def minEdge():
  
    # Initialize queue and push [1, 0]
    Q = Queue()
    Q.put([1, 0])
  
    # Create visited array to keep the
    # track if node is visited or not
    V = [False for _ in range(N + 1)]
  
    # Run infinite loop
    while 1:
        crnt, c = Q.get()
  
        # If node is N, terminate loop
        if crnt == N:
            break
  
        # Travel adjacent nodes of crnt
        for _ in X[crnt]:
            # Check wheather we visited previously or not
            if not V[_]:
                
                # Push into queue and make as true
                Q.put([_, c + 1])
                V[_] = True
  
    return c
  
# Function to Find time required to reach 1 to N
def findTime(c):
    ans = 0
    for _ in range(c):
  
        # Check color of node is red or green
        if (ans//T) % 2:
            
            # Add C sec from next green color time
            ans = (ans//T + 1)*T + C
        else:
            # Add C
            ans += C
      
    # Return the answer
    return ans
  
# Driver Code
if __name__ == "__main__":
  
    # Given Input
    N = 5
    M = 5
    T = 3
    C = 5
    X = [[], [2, 3, 4], [4, 5], [1], [1, 2], [2]]
  
    # Function Call
    c = minEdge()
    ans = findTime(c)
  
    # Print total time
    print(ans)

输出

11

时间复杂度： O(N + M)
空间复杂度： O(N + M)

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。