節點介數

下面是求節點介數的代碼，介數就是指經過一個點的最短路徑的比例，在計算復雜網絡中節點重要性的時候會用到。

/**
 * 用來計算介數
 * 要計算所有的最短路徑，用DIJ計算最短路徑的時候我們可以發現一個規律：最后生成的結果是最小生成樹，而一棵樹是可以用一個一維數組表示的。
 * 所以本代碼在計算介數的時候具有和DIJ相同的時間復雜度。
 */
public class Betweeness {
    private double[][]     dis;
    private int            N;
    Betweeness(double[][] dis)
    {
        this.dis = dis;
        this.N = dis.length;
    }
    /**
     * 根據返回的樹來計算經過每個節點的最短路徑的數目
     * @return
     */
    public double[] getBetweeness()
    {
        double[] b = new double[N];
        for(int start = 0; start < N; start++)
        {
            int[] path = getPath(start);    // 保存樹的結構
            int[] num = new int[N];            // 一個節點的路徑的數目
            int[] used = new int[N];        // 0：初始-->1：有子節點  0--->2:把沒有子節點的處理
            
            // 每次處理的時候找到沒有子節點的點，然后將它的個數加到它的父節點中
            for(int i = 0; i < N; i++)
            {
                for(int j = 0; j < N; j++)
                {
                    if(path[j] != -1 && used[path[j]] == 0)
                    {
                        used[path[j]] = 1;
                    }
                }
                for(int j = 0; j < N; j++)
                {
                    if(used[j] == 0 && path[j] >= 0)
                    {
                        num[path[j]] += 1 + num[j];
                        used[j] = 2;
                    }
                }
                for(int j = 0; j < N; j++)
                {
                    if(used[j] == 1)
                    {
                        used[j] = 0;
                    }
                }
            }
            for(int i = 0; i < N; i++)
            {
                b[i] += num[i];
            }
        }

        double sum = N*N - N;
        for(int i = 0; i < N; i++)
        {
            b[i] /= sum;
        }        
        return b;
    }
    /**
     * 計算從start出發到各個節點的最短路徑，返回這棵最小生成樹
     * @param start
     * @return
     */
    public int[] getPath(int start)
    {
        int[] path = new int[N];
        boolean[] used = new boolean[N];
        double[] minDis = new double[N];
        for(int i = 0; i < N; i++)
        {
            path[i] = -1;
            minDis[i] = -1.0;
        }
        used[start] = true;
        minDis[start] = 0.0;
        
        for(int i = 1; i < N; i++)
        {
            for(int j = 0; j < N; j++)
            {
                if(used[j] == true || dis[start][j] < 0){
                    continue;
                }
                if(dis[start][j] >= 0.0 && (minDis[j] < 0.0 || minDis[j] > minDis[start] + dis[start][j]))
                {
                    path[j] = start;
                    minDis[j] = minDis[start] + dis[start][j];
                }
            }
            start = -1;
            for(int j = 0; j < N; j++)
            {
                if(minDis[j] < 0.0 || used[j] == true)
                {
                    continue;
                }
                if(start == -1 || minDis[start] > minDis[j])
                {
                    start = j;
                    used[start] = true;
                }
            }
            if(start == -1)
            {
                break;
            }
        }
        return path;
    }
    /////////////////////////////////////////////////////////////////////
    public static void main(String[] main){
        double[][] dis = {{0, 1, 5, 2},
                          {1, 0, 4, 6},
                          {5, 4, 0, 3},
                          {2, 6, 3, 0}};
        
        
        double[] b = new Betweeness(dis).getBetweeness();
        for(int i = 0; i < b.length; i++)
        {
            System.out.println(b[i]);
        }
    }
}