Question

我正在实施DFS搜索以在邻接矩阵中运行。有了这个，我想解决de euler路径问题。

我已经运行DFS没有任何问题，但现在我想修改它，以便每当它尝试访问已经访问过的边时它将执行回溯。这是我目前的代码：

public class Graph {

private int numVertex;
private int numEdges;
private boolean[][] adj;

public Graph(int numVertex, int numEdges) {
    this.numVertex = numVertex;
    this.numEdges = numEdges;
    this.adj = new boolean[numVertex+1][numVertex+1];
}

public void addEdge(int start, int end){
    adj[start][end] = true;
    adj[end][start] = true;
}

List<Integer> visited = new ArrayList<Integer>();

public Integer DFS(Graph G, int startVertex){
    int i=0;
    pilha.push(startVertex);
    for(i=0; i<G.numVertex; i++){

        if(G.adj[i][startVertex] != false){
            System.out.println("i: " + i);
            G.adj[i][startVertex] = false;
            G.adj[startVertex][i] = false;

            DFS(G, i);
            pilha.push(i);

            G.adj[i][startVertex] = true;
            G.adj[startVertex][i] = true;
        }

/*          else{
            pilha.pop();
        }*/

        if(!pilha.isEmpty()){
        int c = pilha.pop();

        visited.add(c);
        System.out.println("visited: " + visited);
        }

    }
    return -1;
}

Stack<Integer> pilha = new Stack();

public static void main(String[] args) {

    Scanner input = new Scanner(System.in);

    int numVertices = input.nextInt();
    int numLinks = input.nextInt();
    int startNode = input.nextInt();

    Graph g = new Graph(numVertices, numLinks);

    for(int i = 0; i<numLinks; i++){
        g.addEdge(input.nextInt(),input.nextInt());
    }

    g.DFS(g, startNode);
}
}

问题是，每当我尝试运行被注释的pop时，我都会得到一个EmptyStackException。关于如何修改我的代码的任何想法，以便它在尝试访问已访问的边缘时将回溯。

提前谢谢。

Answer 1

如果startvertex与某个顶点i不相邻，那么你的其他人也会被执行。只有当startvertex不与任何顶点i相邻时，它才能真正得到它。

我会做类似的事情：

bool hasAdjacent = False;
for(i=0; i<G.numVertex; i++){
    if(G.adj[i][startVertex] != false){
        hasAdjacent = True;
        ...

    }
}
if (!hasAdjacent) {
    int c = pilha.pop();
    visited.add(c);
}

我没有给你一个完整的解决方案，但我认为这解决了你的主要逻辑问题。

Java DFS在邻接矩阵中回溯

1 个答案: