如何查找两个给定顶点JAVA之间是否存在路径

Question

我正在尝试编写一种方法来查找在邻接矩阵中表示的无向图中的顶点之间是否存在路径。

这是我拥有的邻接矩阵：

int[][] adj_matrix ={{0,1,0,0},
                     {1,0,1,0},
                     {0,1,0,1},
                     {0,0,0,0}};

这是我迄今为止尝试过的：

public boolean isPath(int vorigin, int vdestiny)
{
    
    boolean result = false;
    ArrayList path = new ArrayList<Integer>();
    for (int i = 0; i < adj_matrix.length; i++) {
        for (int j = 0; j < adj_matrix.length; j++) {
            if(adj_matrix[vorigin][j]>0){
                path.add(vorigin);
            }
            if(adj_matrix[vdestiny][j]>0){
                path.add(vdestiny);
                break;
            }
        }
    }
    if(path.contains(vorigin) && path.contains(vdestiny)){
        System.out.println("There is a path");
    }
    
    return result;
}

如您所见，我的方法只检查每个顶点所在的行，因此它不会真正起作用。我不知道如何在这里进行。我真的不知道如何检查确实会成为路径一部分的顶点。

我已经对此进行了大量研究，但是我能够找到的大多数方法都实现了邻接列表，这是我不想在这种情况下使用的东西。还有一些其他方法使用递归，这是一个很好的选择，但我想以迭代的方式来做。提前致谢。

Answer 1

这里是查找 2 个给定节点之间是否存在路径的 Java 程序的源代码。 Java程序成功编译并在Windows系统上运行。程序输出也如下所示。

public class Path_Between_Nodes
{
    private Map<String, LinkedHashSet<String>> map = new HashMap();
 
    public void addEdge(String node1, String node2)
    {
        LinkedHashSet<String> adjacent = map.get(node1);
        if (adjacent == null)
        {
            adjacent = new LinkedHashSet();
            map.put(node1, adjacent);
        }
        adjacent.add(node2);
    }
 
    public void addTwoWayVertex(String node1, String node2)
    {
        addEdge(node1, node2);
        addEdge(node2, node1);
    }
 
    public boolean isConnected(String node1, String node2)
    {
        Set adjacent = map.get(node1);
        if (adjacent == null)
        {
            return false;
        }
        return adjacent.contains(node2);
    }
 
    public LinkedList<String> adjacentNodes(String last)
    {
        LinkedHashSet<String> adjacent = map.get(last);
        if (adjacent == null)
        {
            return new LinkedList();
        }
        return new LinkedList<String>(adjacent);
    }
 
    private static String  START;
    private static String  END;
    private static boolean flag;
 
    public static void main(String[] args)
    {
        // this graph is directional
        Path_Between_Nodes graph = new Path_Between_Nodes();
        // graph.addEdge("A", "B");
        graph.addEdge("A", "C");
        graph.addEdge("B", "A");
        graph.addEdge("B", "D");
        graph.addEdge("B", "E"); 
        graph.addEdge("B", "F");
        graph.addEdge("C", "A");
        graph.addEdge("C", "E");
        graph.addEdge("C", "F");
        graph.addEdge("D", "B");
        graph.addEdge("E", "C");
        graph.addEdge("E", "F");
        // graph.addEdge("F", "B");
        graph.addEdge("F", "C");
        graph.addEdge("F", "E");
        LinkedList<String> visited = new LinkedList();
        System.out.println("Enter the source node:");
        Scanner sc = new Scanner(System.in);
        START = sc.next();
        System.out.println("Enter the destination node:");
        END = sc.next();
 
        visited.add(START);
        new Path_Between_Nodes().breadthFirst(graph, visited);
        sc.close();
    }
 
    private void breadthFirst(Path_Between_Nodes graph,
            LinkedList<String> visited)
    {
        LinkedList<String> nodes = graph.adjacentNodes(visited.getLast());
 
        for (String node : nodes)
        {
            if (visited.contains(node))
            {
                continue;
            }
            if (node.equals(END))
            {
                visited.add(node);
                printPath(visited);
                flag = true;
                visited.removeLast();
                break;
            }
        }
 
        for (String node : nodes)
        {
            if (visited.contains(node) || node.equals(END))
            {
                continue;
            }
            visited.addLast(node);
            breadthFirst(graph, visited);
            visited.removeLast();
        }
        if (flag == false)
        {
            System.out.println("No path Exists between " + START + " and "
                    + END);
            flag = true;
        }
 
    }
 
    private void printPath(LinkedList<String> visited)
    {
        if (flag == false)
            System.out.println("Yes there exists a path between " + START
                    + " and " + END);
 
        for (String node : visited)
        {
            System.out.print(node);
            System.out.print(" ");
        }
        System.out.println();
    }
}

输出：

$ javac Path_Between_Nodes.java
$ java Path_Between_Nodes
 
Enter the source node:
E
Enter the destination node:
B
No path Exists between E and B
 
Enter the source node:
A
Enter the destination node:
E
Yes there exists a path between A and E
A C E 
A C F E