深度优先算法（DFS）遍历有向无环图计算最优路径

遍历有向无环图，寻找最优路径：

1、假设我们从A点走到B点，可以经过不同的地方，分别用1,2,3,4,5,6表示，A用0表示，B用7表示，从一个地方到另一个地方，中间的路好走的程度用w表示，w越大表示越好走，因此我们可以建立数学模型如下图1所示：

图1

2、根据数学模型，我们判断这是一个有向无环图遍历问题，有向无环图遍历有两种方法，（1）、广度优先（BFS）、（2）、深度优先（DFS）而我们需要的结果是从A到B那个路径的w值最大，即输出结果是路径：0->1->3->7，权值1+3+7=11。最后我们只需要选出权值和最大的路径即可，DFS正好适合这种输出结果，而且时间复杂度为O（V+E）。java代码实现如下：

3、创建有向无环图节点

package answer.graph.model;

 

import java.util.ArrayList;

import java.util.List;

 

/**

 * 节点

 * @author willWang

 * @Date 2017-11-23

 */

public class GraphNode {

 

    public List<GraphEdge> edgeList = null;

   

    private String label = "";

   

    public GraphNode(String label) {

       this.label = label;

       if (edgeList == null) {

           edgeList = new ArrayList<GraphEdge>();

       }

    }

   

    /**

     * 给节点添加边

     * @author willWang

     * @date 2017-11-23

     * @param edge

     */

    public void addEdgeList(GraphEdge edge) {

       edgeList.add(edge);

    }

   

    /**

     * 获取节点标签

     * @author willWang

     * @date 2017-11-23

     * @return

     */

    public String getLabel() {

       return label;

    }

}

         4、创建有向无环图的边

package answer.graph.model;

 

/**

 * 创建有向无环图边

 * @author willWang

 *

 */

public class GraphEdge {

 

    //左侧节点

    private GraphNode nodeLeft;

    //右侧节点

    private GraphNode nodeRight;

    //权重

    private int weight;

 

    /**

     * 初始化边

     * @author wwy

     * @date 2017-11-23

     * @param nodeLeft

     * @param nodeRight

     * @param weight

     */

    public GraphEdge(GraphNode nodeLeft, GraphNode nodeRight, int weight) {

       this.nodeLeft = nodeLeft;

       this.nodeRight = nodeRight;

       this.weight = weight;

    }

 

    public GraphNode getNodeLeft() {

       return nodeLeft;

    }

 

    public GraphNode getNodeRight() {

       return nodeRight;

    }

   

    public int getWeight() {

       return weight;

    }

}

    5、根据设计初始化有向无环图

package answer.graph.model;

 

import java.util.ArrayList;

import java.util.List;

 

/**

 * 按照设计图构造有向无环图

 * @author willWang

 * @Date 2017-11-23

 */

public class MyGraph {

 

    private List<GraphNode> nodes = null;

   

    public void initGraph(int n) {

       if (nodes == null) {

           nodes = new ArrayList<GraphNode>();

       }

      

       GraphNode node = null;

       for (int i = 0; i < n; i++) {

           node = new GraphNode(String.valueOf(i));

           nodes.add(node);

       }

    }

   

    public void initGraph(int n, boolean b) {

       initGraph(n);

       GraphEdge edge01 = new GraphEdge(nodes.get(0), nodes.get(1), 1);

       GraphEdge edge02 = new GraphEdge(nodes.get(0), nodes.get(2), 2);

       GraphEdge edge13 = new GraphEdge(nodes.get(1), nodes.get(3), 3);

       GraphEdge edge14 = new GraphEdge(nodes.get(1), nodes.get(4), 4);

       GraphEdge edge25 = new GraphEdge(nodes.get(2), nodes.get(5), 5);

       GraphEdge edge26 = new GraphEdge(nodes.get(2), nodes.get(6), 6);

       GraphEdge edge37 = new GraphEdge(nodes.get(3), nodes.get(7), 7);

       GraphEdge edge47 = new GraphEdge(nodes.get(4), nodes.get(7), 8);

       GraphEdge edge57 = new GraphEdge(nodes.get(5), nodes.get(7), 9);

       GraphEdge edge67 = new GraphEdge(nodes.get(6), nodes.get(7), 10);

      

      

       nodes.get(0).addEdgeList(edge01);

       nodes.get(0).addEdgeList(edge02);

       nodes.get(1).addEdgeList(edge13);

       nodes.get(1).addEdgeList(edge14);

       nodes.get(2).addEdgeList(edge25);

       nodes.get(2).addEdgeList(edge26);

       nodes.get(3).addEdgeList(edge37);

       nodes.get(4).addEdgeList(edge47);

       nodes.get(5).addEdgeList(edge57);

       nodes.get(6).addEdgeList(edge67);

    }

   

    public void initGraph() {

       initGraph(8, false);

    }

   

    public List<GraphNode> getGraphNodes() {

       return nodes;

    }

}

         6、重点来了，根据深度优先算法遍历有向无环图，并计算出最优路径

package answer.graph.traversing;

 

import java.util.List;

 

import answer.graph.model.GraphEdge;

import answer.graph.model.GraphNode;

 

/**

 * 采用深度优先算法获取最佳路径

 * @author wwy

 * @Date 2017-11-23

 */

public class DFSGetBestPath {

   

    private int tempWeight = 0;

    int maxWeight = 0;

    String result = "";

    private StringBuffer wsb = new StringBuffer();

    private StringBuffer lsb = new StringBuffer();

   

    public String getResult() {

       return result;

    }

 

    /**

     * 采用深度优先算法递归遍历有向无环图

     * @param node

     * @param visited

     * @return

     */

    public GraphNode searchTraversing(GraphNode node,List<GraphNode> visited) {

       // 如果已经查看过该节点，返回该节点

       if (visited.contains(node)) {

           return node;

       }

      

       visited.add(node);

       //添加节点示例

       if(lsb.length() > 0){

           lsb.append("->");

       }

       lsb.append(node.getLabel());

//     System.out.println("节点：" + node.getLabel());

       if(node.edgeList.size() > 0){

           for (int i = 0; i < node.edgeList.size(); i++) {

              GraphEdge gEdge = node.edgeList.get(i);

              int weight = gEdge.getWeight();

              //计算当前路径权重

              tempWeight += weight;

              //添加权重示例

              if(wsb.length() > 0){

                  wsb.append("+");

              }

              wsb.append(weight);

             

              GraphNode nextNode = searchTraversing(gEdge.getNodeRight(), visited);

              if(nextNode.getLabel() != null && nextNode.getLabel() != ""){

                  //减去退出路径的权重

                  tempWeight -= weight;

                  //删除退出路径的权重示例

                  if(wsb.length() <= 1){

                     wsb.delete(wsb.length()-1, wsb.length());

                  }else{

                     wsb.delete(wsb.length()-2, wsb.length());

                  }

                  //删除退出路径的节点示例

                  if(lsb.length() <= 1){

                     lsb.delete(lsb.length()-1, lsb.length());

                  }else{

                     lsb.delete(lsb.length()-3, lsb.length());

                  }

              }

              //删除当前节点，为遍历其他路径上的节点做准备

              visited.remove(nextNode);

           }

       }else{

           if(maxWeight < tempWeight){

              maxWeight = tempWeight;//更细最大权重

              //更新最有路径结果

              result = maxWeight+"（最优路径是："+lsb.toString()+"权重之和是："+wsb.toString()+"="+maxWeight+"）";

           }

       }

       return node;

    }

}

    7、测试代码

public class Main {

 

    private static MyGraph graph = null;

   

    /**

     * 初始化有向无环图

     * @author willWang

     * @date 2017-11-23

     */

    private static void initGraph() {

       if (graph == null) {

           graph = new MyGraph();

       }

      

       graph.initGraph();

    }

   

    public static void main(String[] args) {

       //初始化有向无环图

       initGraph();

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

      

       System.out.println("深度优先算法");

graph.getGraphNodes().get(0)

       DFSGetBestPath mdfs = new DFSGetBestPath();

       GraphNode result = mdfs.searchTraversing(graph.getGraphNodes().get(0), visited);

       System.out.println(mdfs.getResult());

}

}

         8、输出结果：

起点：

0

输出：18（最优路径是：0->2->6->7权重之和是：2+6+10=18）

源码下载地址：http://download.csdn.net/download/wwy1219787539/10135173