查找有向图中两个顶点之间是否存在路径| 2套

给定一个有向图和其中的两个顶点，检查是否存在从第一个给定顶点到第二个顶点的路径。

例子：

Consider the following Graph: 
 

Input : (u, v) = (1, 3) 
Output: Yes 
Explanation: 
There is a path from 1 to 3, 1 -> 2 -> 3

Input : (u, v) = (3, 6) 
Output: No 
Explanation: 
There is no path from 3 to 6  

此处讨论了此问题的基于 BFS 或 DFS 的解决方案。
方法：这里我们将讨论使用 Floyd Warshall 算法的基于动态规划的解决方案。

• 创建一个布尔 2D 矩阵mat ，如果存在从顶点i到j的路径，则mat[i][j]将为真。
• 对于每个起始顶点i和结束顶点j遍历所有中间顶点k并检查是否存在从i到j到k的路径，然后将mat[i][j]标记为 true。
• 最后，检查mat[u][v]是否为真，然后返回真，否则返回假。

下面是上述方法的实现：

C++

// C++ program to find if there is a
// path between two vertices in a
// directed graph using Dynamic Programming
 
#include 
using namespace std;
#define X 6
#define Z 2
 
// function to find if there is a
// path between two vertices in a
// directed graph
bool existPath(int V, int edges[X][Z],
               int u, int v)
{
    // dp matrix
    bool mat[V][V];
    memset(mat, false, sizeof(mat));
 
    // set dp[i][j]=true if there is
    // edge between i to j
    for (int i = 0; i < X; i++)
        mat[edges[i][0]][edges[i][1]] = true;
 
    // check for all intermediate vertex
    for (int k = 0; k < V; k++) {
        for (int i = 0; i < V; i++) {
            for (int j = 0; j < V; j++) {
 
                mat[i][j] = mat[i][j]
                            || mat[i][k]
                                   && mat[k][j];
            }
        }
    }
 
    // if vertex is invalid
    if (u >= V || v >= V) {
        return false;
    }
 
    // if there is a path
    if (mat[u][v])
        return true;
    return false;
}
 
// Driver function
int main()
{
    int V = 4;
    int edges[X][Z]
        = { { 0, 2 }, { 0, 1 },
            { 1, 2 }, { 2, 3 },
            { 2, 0 }, { 3, 3 } };
    int u = 1, v = 3;
 
    if (existPath(V, edges, u, v))
        cout << "Yes\n";
    else
        cout << "No\n";
    return 0;
}

Java

// Java program to find if there is a path
// between two vertices in a directed graph
// using Dynamic Programming
import java.util.*;
 
class GFG{
     
static final int X = 6;
static final int Z = 2;
 
// Function to find if there is a
// path between two vertices in a
// directed graph
static boolean existPath(int V, int edges[][],
                         int u, int v)
{
     
    // mat matrix
    boolean [][]mat = new boolean[V][V];
 
    // set mat[i][j]=true if there is
    // edge between i to j
    for (int i = 0; i < X; i++)
        mat[edges[i][0]][edges[i][1]] = true;
 
    // Check for all intermediate vertex
    for(int k = 0; k < V; k++)
    {
        for(int i = 0; i < V; i++)
        {
            for(int j = 0; j < V; j++)
            {
                mat[i][j] = mat[i][j] ||
                            mat[i][k] &&
                            mat[k][j];
            }
        }
    }
 
    // If vertex is invalid
    if (u >= V || v >= V)
    {
        return false;
    }
 
    // If there is a path
    if (mat[u][v])
        return true;
    return false;
}
 
// Driver code
public static void main(String[] args)
{
    int V = 4;
    int edges[][] = { { 0, 2 }, { 0, 1 },
                      { 1, 2 }, { 2, 3 },
                      { 2, 0 }, { 3, 3 } };
    int u = 1, v = 3;
 
    if (existPath(V, edges, u, v))
        System.out.print("Yes\n");
    else
        System.out.print("No\n");
}
}
 
// This code is contributed by Princi Singh

Python3

# Python3 program to find if there
# is a path between two vertices in a
# directed graph using Dynamic Programming
X = 6
Z = 2
  
# Function to find if there is a
# path between two vertices in a
# directed graph
def existPath(V, edges, u, v):
     
    # dp matrix
    mat = [[False for i in range(V)]
                  for j in range(V)]
  
    # Set dp[i][j]=true if there is
    # edge between i to j
    for i in range(X):
        mat[edges[i][0]][edges[i][1]] = True
  
    # Check for all intermediate vertex
    for k in range(V):
        for i in range(V):
            for j in range(V):
                mat[i][j] = (mat[i][j] or
                             mat[i][k] and
                             mat[k][j])
  
    # If vertex is invalid
    if (u >= V or v >= V):
        return False
  
    # If there is a path
    if (mat[u][v]):
        return True
         
    return False
 
# Driver code
V = 4
edges = [ [ 0, 2 ], [ 0, 1 ],
          [ 1, 2 ], [ 2, 3 ],
          [ 2, 0 ], [ 3, 3 ] ]
         
u, v = 1, 3
 
if (existPath(V, edges, u, v)):
    print("Yes")
else:
    print("No")
 
# This code is contributed by divyeshrabadiya07

C#

// C# program to find if there is a path
// between two vertices in a directed graph
// using Dynamic Programming
using System;
class GFG{
     
static readonly int X = 6;
static readonly int Z = 2;
 
// Function to find if there is a
// path between two vertices in a
// directed graph
static bool existPath(int V, int [,]edges,
                      int u, int v)
{
     
    // mat matrix
    bool [,]mat = new bool[V, V];
 
    // set mat[i,j]=true if there is
    // edge between i to j
    for (int i = 0; i < X; i++)
        mat[edges[i, 0], edges[i, 1]] = true;
 
    // Check for all intermediate vertex
    for(int k = 0; k < V; k++)
    {
        for(int i = 0; i < V; i++)
        {
            for(int j = 0; j < V; j++)
            {
                mat[i, j] = mat[i, j] ||
                            mat[i, k] &&
                            mat[k, j];
            }
        }
    }
 
    // If vertex is invalid
    if (u >= V || v >= V)
    {
        return false;
    }
 
    // If there is a path
    if (mat[u, v])
        return true;
    return false;
}
 
// Driver code
public static void Main(String[] args)
{
    int V = 4;
    int [,]edges = { { 0, 2 }, { 0, 1 },
                     { 1, 2 }, { 2, 3 },
                     { 2, 0 }, { 3, 3 } };
    int u = 1, v = 3;
 
    if (existPath(V, edges, u, v))
        Console.Write("Yes\n");
    else
        Console.Write("No\n");
}
}
 
// This code is contributed by sapnasingh4991

Javascript

 
// Javascript program to find if there is a path
// between two vertices in a directed graph
// using Dynamic Programming
     
var X = 6;
var Z = 2;
 
// Function to find if there is a
// path between two vertices in a
// directed graph
function existPath(V, edges, u, v)
{
     
    // mat matrix
    var mat = Array.from(Array(V), ()=>Array(V));
 
    // set mat[i,j]=true if there is
    // edge between i to j
    for (var i = 0; i < X; i++)
        mat[edges[i][0]][edges[i][1]] = true;
 
    // Check for all intermediate vertex
    for(var k = 0; k < V; k++)
    {
        for(var i = 0; i < V; i++)
        {
            for(var j = 0; j < V; j++)
            {
                mat[i][j] = mat[i][j] ||
                            mat[i][k] &&
                            mat[k][j];
            }
        }
    }
 
    // If vertex is invalid
    if (u >= V || v >= V)
    {
        return false;
    }
 
    // If there is a path
    if (mat[u][v])
        return true;
    return false;
}
 
// Driver code
var V = 4;
var edges = [ [ 0, 2 ], [ 0, 1 ],
                 [ 1, 2 ], [ 2, 3 ],
                 [ 2, 0 ], [ 3, 3 ] ];
var u = 1, v = 3;
if (existPath(V, edges, u, v))
    document.write("Yes<br>");
else
    document.write("No<br>");
 

输出：

Yes

时间复杂度： O ( V ³ )
辅助空间： O (V ² )

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