给定一个整数N，它表示所连接城市的数量(从1到N )，以及一个二维数组arr [] [] ，该数组由通过双向桥相互连接的对组成。任务是找到从城市1到达城市N所需的最少桥梁数量。
例子：
Input: N = 3, M = 2, arr[][] = {{1, 2}, {2, 3}}
Output: 2
Explanation:
To reach Node 2 from Node 1, 1 bridge is required to be crossed.
To reach Node 3 from Node 2, 1 bridge is required to be crossed.
Hence, 2 bridges are required to be connected.
Input: N = 4, M = 3, arr[][] = {{1, 2}, {2, 3}, {2, 4}}
Output: 2
方法：请按照以下步骤解决问题：
- 初始化邻接表以构建和存储Graph节点。
- 初始化一个数组，例如vis [] ，大小为N，以标记访问的节点，并初始化另一个数组，例如dist [] ，大小为N ，以存储距城市1的最小距离。
- 执行BFS并使用“单一源最短路径”的概念遍历图形并存储从城市1到达每个城市所需的最少桥梁数量。
- 将dist [N]的值打印为从城市1到达城市N的最小距离。
下面是上述方法的实现：
C++
// C++ program for the above approach
#include
using namespace std;
// Adjacency list to store graph
vector g[10001];
// Stores info about visited nodes
int vis[10001];
// Stores distance of nodes
// from the source node
int dist[10001];
// Function for BFS traversal
void BFS(int src)
{
// Stores the nodes
queue q;
// Push the source node
q.push(src);
// Mark the pushed node visited
vis[src] = 1;
// Source node is always at dist 0
dist[src] = 0;
// Iterate until queue is not empty
while (!q.empty()) {
// Update the current node
int curr = q.front();
// Pop the node after
// update by curr
q.pop();
// Traverse every node of
// the adjacency list
for (auto child : g[curr]) {
if (vis[child] == 0) {
// Push the child node
// if its not visited
q.push(child);
// Update the distance of next level
// nodes as it can be accessed by the
// previous node in BFS
dist[child] = dist[curr] + 1;
// Mark the child node as visited
vis[child] = 1;
}
}
}
}
// Funtion to build the graph
void buildGraph(int M, int arr[][2])
{
for (int i = 0; i < M; i++) {
g[arr[i][0]].push_back(arr[i][1]);
g[arr[i][1]].push_back(arr[i][0]);
}
}
// Function to print the distance between from
// city 1 to city N
void shortestDistance(int N, int M, int arr[][2])
{
// Build graph
buildGraph(M, arr);
// Perform BFS traversal
BFS(1);
// Print the shortest distance
cout << dist[N];
}
// Driver Code
int main()
{
// Given number of Nodes & Edges
int N = 3, M = 2;
// Given pairs of edges
int arr[][2] = { { 1, 2 }, { 2, 3 } };
// Function Call
shortestDistance(N, M, arr);
} Java
// Java program for the above approach
import java.util.*;
class GFG
{
// Adjacency list to store graph
static Vector []g = new Vector[10001];
// Stores info about visited nodes
static int []vis = new int[10001];
// Stores distance of nodes
// from the source node
static int []dist = new int[10001];
static {
for(int i = 0; i < g.length; i++)
{
g[i] = new Vector<>();
}
}
// Function for BFS traversal
static void BFS(int src)
{
// Stores the nodes
Queue q = new LinkedList<>();
// Push the source node
q.add(src);
// Mark the pushed node visited
vis[src] = 1;
// Source node is always at dist 0
dist[src] = 0;
// Iterate until queue is not empty
while (!q.isEmpty()) {
// Update the current node
int curr = q.peek();
// Pop the node after
// update by curr
q.remove();
// Traverse every node of
// the adjacency list
for (int child : g[curr]) {
if (vis[child] == 0) {
// Push the child node
// if its not visited
q.add(child);
// Update the distance of next level
// nodes as it can be accessed by the
// previous node in BFS
dist[child] = dist[curr] + 1;
// Mark the child node as visited
vis[child] = 1;
}
}
}
}
// Funtion to build the graph
static void buildGraph(int M, int arr[][])
{
for (int i = 0; i < M; i++) {
g[arr[i][0]].add(arr[i][1]);
g[arr[i][1]].add(arr[i][0]);
}
}
// Function to print the distance between from
// city 1 to city N
static void shortestDistance(int N, int M, int arr[][])
{
// Build graph
buildGraph(M, arr);
// Perform BFS traversal
BFS(1);
// Print the shortest distance
System.out.print(dist[N]);
}
// Driver Code
public static void main(String[] args)
{
// Given number of Nodes & Edges
int N = 3, M = 2;
// Given pairs of edges
int arr[][] = { { 1, 2 }, { 2, 3 } };
// Function Call
shortestDistance(N, M, arr);
}
}
// This code is contributed by shikhasingrajput. Python3
# Python 3 program for the above approach
# Adjacency list to store graph
g = [[] for i in range(10001)]
# Stores info about visited nodes
vis = [0 for i in range(10001)]
# Stores distance of nodes
# from the source node
dist = [0 for i in range(10001)]
# Function for BFS traversal
def BFS(src):
global vis
global dist
global g
# Stores the nodes
q = []
# Push the source node
q.append(src)
# Mark the pushed node visited
vis[src] = 1
# Source node is always at dist 0
dist[src] = 0
# Iterate until queue is not empty
while (len(q)):
# Update the current node
curr = q[0]
# Pop the node after
# update by curr
q.remove(q[0])
# Traverse every node of
# the adjacency list
for child in g[curr]:
if (vis[child] == 0):
# Push the child node
# if its not visited
q.append(child)
# Update the distance of next level
# nodes as it can be accessed by the
# previous node in BFS
dist[child] = dist[curr] + 1
# Mark the child node as visited
vis[child] = 1
# Funtion to build the graph
def buildGraph(M, arr):
global g
for i in range(M):
g[arr[i][0]].append(arr[i][1])
g[arr[i][1]].append(arr[i][0])
# Function to print the distance between from
# city 1 to city N
def shortestDistance(N, M, arr):
# Build graph
buildGraph(M, arr)
# Perform BFS traversal
BFS(1)
# Print the shortest distance
print(dist[N])
# Driver Code
if __name__ == '__main__':
# Given number of Nodes & Edges
N = 3
M = 2
# Given pairs of edges
arr = [[1, 2], [2, 3]]
# Function Call
shortestDistance(N, M, arr)
# This code is contributed by SURENDRA_GANGWAR.C#
// C# program for the above approach
using System;
using System.Collections.Generic;
public class GFG
{
// Adjacency list to store graph
static List []g = new List[10001];
// Stores info about visited nodes
static int []vis = new int[10001];
// Stores distance of nodes
// from the source node
static int []dist = new int[10001];
// Function for BFS traversal
static void BFS(int src)
{
// Stores the nodes
Queue q = new Queue();
// Push the source node
q.Enqueue(src);
// Mark the pushed node visited
vis[src] = 1;
// Source node is always at dist 0
dist[src] = 0;
// Iterate until queue is not empty
while (q.Count!=0) {
// Update the current node
int curr = q.Peek();
// Pop the node after
// update by curr
q.Dequeue();
// Traverse every node of
// the adjacency list
foreach (int child in g[curr]) {
if (vis[child] == 0) {
// Push the child node
// if its not visited
q.Enqueue(child);
// Update the distance of next level
// nodes as it can be accessed by the
// previous node in BFS
dist[child] = dist[curr] + 1;
// Mark the child node as visited
vis[child] = 1;
}
}
}
}
// Funtion to build the graph
static void buildGraph(int M, int [,]arr)
{
for (int i = 0; i < M; i++) {
g[arr[i,0]].Add(arr[i,1]);
g[arr[i,1]].Add(arr[i,0]);
}
}
// Function to print the distance between from
// city 1 to city N
static void shortestDistance(int N, int M, int [,]arr)
{
// Build graph
buildGraph(M, arr);
// Perform BFS traversal
BFS(1);
// Print the shortest distance
Console.Write(dist[N]);
}
// Driver Code
public static void Main(String[] args)
{
// Given number of Nodes & Edges
int N = 3, M = 2;
// Given pairs of edges
int [,]arr = { { 1, 2 }, { 2, 3 } };
for(int i = 0; i < g.Length; i++)
{
g[i] = new List();
}
// Function Call
shortestDistance(N, M, arr);
}
}
// This code is contributed by shikhasingrajput 输出：
2时间复杂度： O(N)
辅助空间： O(N)