Question

我手头有一个有趣的问题。我想解决从加权图的源顶点开始的问题，并找出导致它的所有可能路径。

例如：考虑上面的有向图： enter image description here

预期输出如果我从Source = A开始：

1）A - ＆gt; C - ＆gt; D - ＆gt; B-＆GT;甲

2）A - ＆gt; B - ＆gt;甲

3）A - ＆gt; D - ＆gt; B - ＆gt;甲

注意：

a）图表将被加权，我在遍历时找到边的总和（不一定是最小和）。

b）计划使用矩阵表示图形，图形在某些地方可能是循环的。

b）哪个是最有效的代码才能解决这个问题？我知道BFS和DFS，但他们不计算往返行程！

当前的DFS代码:(邻接图）

void dfs(int cost[][20],int v[],int n, int j)
{
int i;
v[j]=1;
printf("Vistiing %d\n",j);
for(i=0;i<n;i++)
if(cost[j][i]==1 && v[i]==0)
dfs(cost,v,n,i
);
}

Answer 1

这可以通过修改DFS（或BFS）来解决。

考虑DFS。

访问节点后，将其标记为已访问。从中返回后，将其标记为未访问，以便可以识别其他路径。

你的例子：

Start from A.
Choose a path.
A->B->A.
Return to B. No other paths.
Return to A. Mark B unvisited. Choose another path.
A->D->B->A.
Return to B. No other paths.
Return to D. Mark B unvisited. No other paths.
Return to A. Mark D unvisited. Choose another path.
A->C->D->B->A.

注意：这里重要的是标记未访问的节点。

Answer 2

这听起来像是Backtracking的一个很好的应用案例：

从所需节点开始
如果您是第二次到达开始节点，请返回结果
否则：对于每个邻居
- 将邻居添加到当前路径
- 进行递归
- 从当前路径中删除邻居

这是作为一个例子在这里实现的。当然，这个（特别是图表数据结构）只是一个快速草图，以表明这个想法是可行的，在MCVE中：

import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;


public class GraphRoundTrips
{
    static class Vertex
    {
        String name;
        Vertex(String name)
        {
            this.name = name;
        }
        @Override
        public String toString()
        {
            return name;
        }
    }

    static class Edge
    {
        Vertex v0;
        Vertex v1;
        Edge(Vertex v0, Vertex v1)
        {
            this.v0 = v0;
            this.v1 = v1;
        }
        @Override
        public String toString()
        {
            return "("+v0+","+v1+")";
        }
    }

    static class Graph
    {
        List<Vertex> vertices = new ArrayList<Vertex>();
        List<Edge> edges = new ArrayList<Edge>();

        void addVertex(Vertex v)
        {
            vertices.add(v);
        }
        void addEdge(Edge e)
        {
            edges.add(e);
        }

        List<Vertex> getOutNeighbors(Vertex v)
        {
            List<Vertex> result = new ArrayList<Vertex>();
            for (Edge e : edges)
            {
                if (e.v0.equals(v))
                {
                    result.add(e.v1);
                }
            }
            return result;
        }
    }

    public static void main(String[] args)
    {
        Vertex A = new Vertex("A");
        Vertex B = new Vertex("B");
        Vertex C = new Vertex("C");
        Vertex D = new Vertex("D");

        Graph graph = new Graph();
        graph.addVertex(A);
        graph.addVertex(B);
        graph.addVertex(C);
        graph.addVertex(D);

        graph.addEdge(new Edge(A,C));
        graph.addEdge(new Edge(A,D));
        graph.addEdge(new Edge(A,B));
        graph.addEdge(new Edge(B,A));
        graph.addEdge(new Edge(C,D));
        graph.addEdge(new Edge(D,B));

        compute(graph, A, null, new LinkedHashSet<Vertex>());

    }

    private static void compute(Graph g, Vertex startVertex, 
        Vertex currentVertex, Set<Vertex> currentPath)
    {
        if (startVertex.equals(currentVertex))
        {
            List<Vertex> path = new ArrayList<Vertex>();
            path.add(startVertex);
            path.addAll(currentPath);
            System.out.println("Result "+path);
        }
        if (currentVertex == null)
        {
            currentVertex = startVertex;
        }
        List<Vertex> neighbors = g.getOutNeighbors(currentVertex);
        for (Vertex neighbor : neighbors)
        {
            if (!currentPath.contains(neighbor))
            {
                currentPath.add(neighbor);
                compute(g, startVertex, neighbor, currentPath);
                currentPath.remove(neighbor);
            }
        }
    }



}

遍历图形，一个顶点，所有可能的往返

2 个答案: