有向无环带权图的最短路径及长度

package graphics.dag.topologicalsort;

/**
 * 获取一个拓扑序列
 * @author zhangxinren
 *
 */
public class TopologicalSort {
    // 每条边的入度
    private static int[] inDegree;// 邻接表元素个变化，inDegree初始长度也变化
    // 当前可以走的边（入度为0的边）
    private static LinkedNode next;

    public static int[] topologicalSort(int[][] edges) {
        int m = 0;
        int[] result = new int[edges.length];
        inDegree = new int[edges.length];

        for (int i = 0; i < inDegree.length; i++) {
            inDegree[i] = 0;
        }

        for (int i = 0; i < edges.length; i++) {
            for (int j = 0; j < edges[i].length; j++) {
                inDegree[edges[i][j]]++;
            }
        }

        for (int i = 0; i < inDegree.length; i++) {
            if (inDegree[i] == 0) {
                if(next == null){
                    next = new LinkedNode(i);
                }
                else
                {
                    LinkedNode tempNode = new LinkedNode(i);
                    tempNode.next = next.next;
                    next.next = tempNode;
                }
            }
        }
                
        while (next != null) {// 没有入度为零的顶点时结束
            LinkedNode temp = next.next;// 取出一个入度为零的顶点
            if(temp != null){
                next.next = temp.next;
            }
            else{
                temp = next;
                next = null;
            }
            
            result[m++] = temp.number;
            
            int[] tempDegree = edges[temp.number];
            
            for(int i = 0; i < tempDegree.length; i++){// 更新顶点入度和入度为0的点
                inDegree[tempDegree[i]]--;
                if(inDegree[tempDegree[i]] == 0){
                    LinkedNode tempNode = new LinkedNode(tempDegree[i]);
                    if(null != next){
                        tempNode.next = next.next;
                        next.next = tempNode;
                    }
                    else
                    {
                        next = tempNode;
                    }
                }
            }
        }
        
        return result;
    }
}

package graphics.dag.topologicalsort;

public class LinkedNode {
    int number;
    LinkedNode next;
    public LinkedNode(int number) {
        super();
        this.number = number;
    }
}

package graphics.dag.topologicalsort;

/**
 * 有向无环带权图最短路径
 * @author zhangxinren
 *
 */
public class ShortestPathLength {
    // 到顶点的最短路径数组
    private static int[] shortest;
    // 前一个结点到当前结点路径最短时的前一个结点
    private static int[] pred;
    // 顶点邻接表
    private static int[][] edges = {
            {1,2,3},{4},{4,5},{5},{6},{6},{}
    };
    // 边权值的邻接矩阵
    private static int[][] weight = {
            {Integer.MAX_VALUE, 1, 5, 6, Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE},
            {Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, 7, Integer.MAX_VALUE, Integer.MAX_VALUE},
            {Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, 2, 5, Integer.MAX_VALUE},
            {Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, 8, Integer.MAX_VALUE},
            {Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, 4},
            {Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, 3},
            {Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE}
    };
    
    public static int shortestPathLength(int[][] edges, int[][] weight){
        int n = edges.length;
        shortest = new int[n];
        pred = new int[n];
        
        // 初始化：认为除起点0的最短路径为0外其它都为无穷大，当前顶点的最短路径的前一个顶点为无（-1）
        for(int i = 0; i < n; i++){
            shortest[i] = Integer.MAX_VALUE;
            pred[i] = -1;
        }
        
        shortest[0] = 0;
        
        // 获取一个拓扑序列
        int[] sequence = TopologicalSort.topologicalSort(edges);
        
        // 处理拓扑序列中的每一个顶点
        for(int i = 0; i < sequence.length; i++){
            int temp = sequence[i];
            // 获取当前顶点为出来边的顶点
            int[] tempDegree = edges[temp];
            
            // 更新这些顶点的最短距离
            for(int j = 0; j < tempDegree.length; j++){
                int end = tempDegree[j];
                relax(temp, end);
            }
        }
        
        return shortest[sequence[sequence.length - 1]];
    }
    
    /**
     * start顶点到它的下一个顶点end，看是否需要更新shortest[end]
     * 在到start顶点最短距离加上start与end的距离小于到end顶点最短距离时，更新最短距离
     * @param start
     * @param end
     * @return
     */
    public static boolean relax(int start, int end){
        if(shortest[start] != Integer.MAX_VALUE && shortest[end] > shortest[start] + weight[start][end]){
            shortest[end] = shortest[start] + weight[start][end];
            pred[end] = start;
            return true;
        }
        
        return false;
    }
    
    public static void main(String[] args) {
        // 获取最短路径长度
        int result = shortestPathLength(edges, weight);
        
        int[] sequence = TopologicalSort.topologicalSort(edges);
        System.out.print("sequence： ");
        for(int i = 0; i < sequence.length; i++){
            System.out.print(sequence[i] + " ");
        }
        System.out.println();
        int end = sequence[sequence.length - 1];
        System.out.println("result: " + result);

        StringBuilder sb = new StringBuilder(end + " ");
        int pre = pred[end];
        while(pre != -1){
            sb.append(pre + " ");
            pre = pred[pre];
        }
        sb.setLength(sb.length() - 1);
        sb.reverse();
        
        // 打印出最短路径
        System.out.println(sb.toString());
        
        // 打印出到所有点的最短路径长度
        System.out.println("从0开始的最短路径");
        for(int i = 0; i < edges.length; i++){
            System.out.println(i + ": " + shortest[i]);
        }
    }
}

sequence： 0 3 2 5 1 4 6 
result: 11
0 2 4 6
从0开始的最短路径
0: 0
1: 1
2: 5
3: 6
4: 7
5: 10
6: 11