[[417618]]

本文轉載自微信公眾號「bigsai」，作者bigsai。轉載本文請聯系程序員bigsai公眾號。

前言

大家好,我是bigsai,今天給大家講講Dijkstra算法，下次拿著這個算法找女神少繞路，有女朋友的可以試試行不行的通。

對于Dijkstra算法,很多人可能感覺熟悉而又陌生,可能大部分人比較了解bfs和dfs,而對dijkstra和floyd算法可能知道大概是圖論中的某個算法,但是可能不清楚其中的作用和原理,又或許,你曾經感覺它很難,那么,這個時候正適合你重新認識它。

Dijkstra是啥?

其實Dijkstra(迪科斯徹)是一個人,被稱為結構程序設計之父,他提出goto有害論、信號量、原語等,創造解決銀行家算法、哲學家進餐問題、Dijkstra算法等等,在1972年獲得圖靈獎(計算機界諾?爾獎),今天咱們就學習Dijkstra算法。

Dijkstra算法干啥的?

Dijkstra是用來求單源最短路徑的,也就是在一個圖中,從一個點計算到達其他點的最短距離,再形象一點,就是比如七夕你捧著鮮花去找女神,有點距離,在不堵?沒紅綠燈情況下怎么找到一條最短的路徑:

這不是一眼就能看出來嘛!還要什么算法?enum,如果路徑很多像這樣呢?

就拿上圖來說,如果各條路?度都已知,那么可以使用dijkstra算法計算你到圖中所有節點的最短距離(不過你想要的就是和女神的距離最近)。不過這個單源最短路徑你可能產生一些疑惑:

單源什么意思?

一個源頭,從一個頂點出發,Dijkstra算法只能求一個頂點到其他點的最短距離而不能任意兩點。

和bfs求的最短路徑有什么區別?

bfs求的與其說是路徑,不如說是次數。因為bfs他是按照隊列一次一次進行加入相鄰的點,而兩點之間沒有權值或者權值相等(代價相同)。bfs求最短路徑一般無權值路徑(只代表聯通性)或者權值相等,僅僅用次數就能表示路徑?短的情況,最典型的就是迷宮問題bfs搜索移動一次路徑為1就加一次。

Dijkstra在處理具體實例的應用還是很多的,因為具體的問題其實帶權更多一些。比如一個城市有多個鄉鎮,鄉鎮可能有道路,也可能沒有,整個鄉鎮需要聯通,如果想計算每個鄉鎮到a鎮的最短路徑,那么Dijkstra就派上了用場。

算法分析

對于一個算法,首先要理解它的運行流程,對于Dijkstra算法而言,首先要知道其適用條件和環境:

一個連通圖,若干節點(節點可能有數值),但是路徑一定有權值并且不能為負(否則Dijkstra就不適用)。

Dijkstra的核心思想是貪心算法的思想,那什么是貪心呢?

貪心算法(又稱貪婪算法)是指,在對問題求解時,總是做出在當前看來是最好的選擇。也就是說,不從整體最優上加以考慮,他所

做出的是在某種意義上的局部最優解。

貪心算法不是對所有問題都能得到整體最優解,關鍵是貪心策略的選擇,選擇的貪心策略必須具備無后效性,即某個狀態以前的過程不會影響以后的狀態,只與當前狀態有關。

對于貪心算法,在很多情況都能用到,下面舉2個不恰當的例子!

1 .上學時,每周只能帶5個蘋果,你想帶最多,那么選五個蘋果你每次都選最大的那個五次下來你就選的最重的那個。

2 .錢幣找零,指定幣值和相應的數量,用最少的數量湊?某金額。利用貪心策略,優先選擇面值大的錢幣,直到湊?總金額。

3 .活動選擇問題,知道多個活動開始時間、結束時間,想在一個時間內參加最多活動,按照活動結束時間遞增排序即可。

上面的策略雖然沒有很強的理論數學依據,或者不太好說明,更像一種事實規律經驗,并且對于貪心問題具體處理上大部分都需要排序,還可能會遇到規則繁雜的類排序。那么我們的Dijkstra是如何貪心的呢?對于一個點,求圖中所有點的最短路徑,如果沒有正確的方法胡亂想確實很難算出來,并且如果暴力匹配復雜度呈指數級上升不適合解決實際問題。那么我們該怎么想呢?

首先,Dijkstra算法實現上需要這些前提:

• Dijkstra處理的是帶正權值的有權圖,那么就需要一個二維數組(如果空間大用List數組)存儲各個點到點之間邊的權值大小 (鄰接矩陣或者鄰接表存儲) ，各個點距離初始化為無窮大。
• 需要一個boolean數組判斷哪些點已經確定最短?度路徑,那些點沒有確定。用一個 int數組記錄距離(在算法執行過程有些點最短路徑可能被多次更新)。
• 需要優先隊列加入已經確定點的周圍點。每次拋出從起點最短路徑的那個點,直到所有點路徑確定最短為止。

簡單的概括流程為:

第一步一般從選定點開始拋入優先隊列(路徑一般為0),boolean數組標記0的位置(最短為0) , 然后0周圍連通的點拋入優先隊列中(可能是node類),并把各個點的距離記錄到對應數組內，此時周圍點只是等待調度可能是最短距離，也可能被更新。(如果小于就更新,大于就不動,初始第一次是無窮肯定會更新),第一次就結束了。

從等待調度隊列中拋出距離最近的那個點B(第一次就是0周圍鄰居)。這個點距離一定是最近可以確定的(所有權值都是正的,點的距離只能越來越?，而它的路徑是所有可能中的最小的)標記這個點為true表示已經確定,并且將這個點的鄰居加入隊列(下一次等待調度點為隊列中原有的和這個點周圍未確定的鄰居),并同時判斷是否更新B點鄰居?度,如果小于則更新!

重復二的操作,直到所有點都確定。

算法實現

代碼實現上面有些繁瑣，但是也不是很復雜，這里給個Dijkstra算法實現代碼：

package 圖論; 
 
import java.util.ArrayDeque; 
import java.util.Comparator; 
import java.util.PriorityQueue; 
import java.util.Queue; 
import java.util.Scanner; 
 
public class dijkstra { 
    static class node 
    { 
        int x; //節點編號 
        int lenth;//長度 
        public node(int x,int lenth) { 
            this.x=x; 
            this.lenth=lenth; 
        } 
    } 
 
    public static void main(String[] args) { 
 
        int[][] map = new int[6][6];//記錄權值，順便記錄鏈接情況，可以考慮附加鄰接表 
        initmap(map);//初始化 
        boolean bool[]=new boolean[6];//判斷是否已經確定 
        int len[]=new int[6];//長度 
        for(int i=0;i<6;i++) 
        { 
            len[i]=Integer.MAX_VALUE; 
        } 
        Queue<node>q1=new PriorityQueue<node>(com); 
        len[0]=0;//從0這個點開始 
        q1.add(new node(0, 0)); 
        int count=0;//計算執行了幾次dijkstra 
        while (!q1.isEmpty()) { 
            node t1=q1.poll(); 
            int index=t1.x;//節點編號 
            int length=t1.lenth;//節點當前點距離 
            bool[index]=true;//拋出的點確定 
            count++;//其實執行了6次就可以確定就不需要繼續執行了  這句可有可無，有了減少計算次數 
            for(int i=0;i<map[index].length;i++) 
            { 
                if(map[index][i]>0&&!bool[i]) 
                { 
                    node node=new node(i, length+map[index][i]); 
                    if(len[i]>node.lenth)//需要更新節點的時候更新節點并加入隊列 
                    { 
                        len[i]=node.lenth; 
                        q1.add(node); 
                    } 
                } 
            } 
        }        
        for(int i=0;i<6;i++) 
        { 
            System.out.println(len[i]); 
        } 
    } 
    static Comparator<node>com=new Comparator<node>() { 
 
        public int compare(node o1, node o2) { 
            return o1.lenth-o2.lenth; 
        } 
    }; 
 
    private static void initmap(int[][] map) { 
        map[0][1]=2;map[0][2]=3;map[0][3]=6; 
        map[1][0]=2;map[1][4]=4;map[1][5]=6; 
        map[2][0]=3;map[2][3]=2; 
        map[3][0]=6;map[3][2]=2;map[3][4]=1;map[3][5]=3; 
        map[4][1]=4;map[4][3]=1; 
        map[5][1]=6;map[5][3]=3;     
    } 
} 

當然,dijkstra算法比較靈活,實現方式也可能有點區別,但是思想是不變的:一個貪心思路。dijkstra執行一次就能夠確定一個點,所以只需要執行點的總和次數即可完成整個算法。

一句話概況一下，就是從一個點開始找周圍最短的一個，更新相應數據，再找已經確定直接連接的第二個最短點、第三個一直到所有點確定，dijkstra算法就完成了。