Dijkstra算法

吐槽一句，这个东西好难拼

迪杰斯特拉算法是由荷兰计算机科学家狄克斯特拉于1959 
年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法，解决的是有向图中最短路径问题。迪杰斯特拉算法主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。——百度百科

 

Dijkstra算法就是用来算在一个有向带权图中，一个点到其他各点的最短距离

其思路是： 
1.给起始点权值标成0，其他点标成无限大。从出发点开始 
2.向该点向能通向的点走，算出到各点的总距离，并标记在相应点上。 
3.给该点标记上访问标志，以后不再访问该点，然后从所有点中选出权值最小的点，重复步骤2 
4.当所有点均被标记后，各点权值即为到该点最短距离

 

代码 
我觉得我写的好冗杂，不过注释应该能看懂的，理会意思即可

  1 #include <iostream>
  2 #include <set>
  3 #include <vector>
  4 #include <queue>
  5 using namespace std;
  6 
  7 
  8 class Dijkstra{
  9     private:
 10         const int INF=100000;
 11         struct Edge{//边
 12             int to,weight;
 13         };
 14         struct Weight{//用于优先队列的比较
 15             int weight,n;
 16             bool operator < (const Weight& rhs)const{
 17                 return weight>rhs.weight;//权值越大，优先度越小
 18             }
 19         };
 20 
 21         struct Tree{//树
 22             vector<vector<Edge> > node;
 23             vector<int> d;//到各个节点的最小值
 24             int N;//节点数目
 25 
 26             void init(int NodeNumber){//初始化
 27                 node.resize(NodeNumber);
 28                 d.resize(NodeNumber);
 29                 N=NodeNumber;
 30             }
 31 
 32             void Add(int from,int to,int weight){//添加边
 33                 node[from].push_back((Edge){to,weight});
 34             }
 35         };
 36         Tree T;
 37 
 38     public:
 39         void Add(int from,int to,int weight){
 40             T.Add(from,to,weight);
 41         }
 42         void init(int NodeNumber){
 43             T.init(NodeNumber);
 44         }
 45         void dijkstra(int v){//Dijkstra主算法
 46             vector<int>done;//访问标记
 47             done.resize(T.N);
 48             for(int i=0;i<T.d.size();i++){
 49                 T.d[i]=INF;
 50                 done[i]=0;
 51             }
 52             priority_queue <Weight> Q;//优先队列
 53             Q.push((Weight){0,v});//从第一个点开始
 54             T.d[v]=0;
 55 
 56             //BFS
 57             while(!Q.empty()){//只要队列不空就走下去
 58                 int u=Q.top().n;//获得优先度最高的节点
 59                 Q.pop();
 60                 if(done[u])continue;//如果已经访问过就跳过
 61                 done[u]=1;//访问标记
 62                 for(int i=0;i<T.node[u].size();i++){//该节点可以访问的节点
 63                     Edge& next=T.node[u][i];
 64                     if(T.d[u]+next.weight<T.d[next.to]){//如果距离更短，则更新
 65                         T.d[next.to]=T.d[u]+next.weight;
 66                         Q.push((Weight){next.weight,next.to});
 67                         //可以在这里加上一个vector，用来记录路径
 68                     }
 69                 }
 70             }
 71         }
 72         int get(int n){//返回到达指定节点的最短距离
 73             return T.d[n];
 74         }
 75 };
 76 
 77 int main(){
 78    Dijkstra D;
 79    D.init(6);
 80    D.Add(0,1,7);
 81    D.Add(0,2,9);
 82    D.Add(0,5,14);
 83    D.Add(1,0,7);
 84    D.Add(1,2,10);
 85    D.Add(1,3,15);
 86    D.Add(2,0,9);
 87    D.Add(2,1,10);
 88    D.Add(2,3,11);
 89    D.Add(2,5,2);
 90    D.Add(3,1,15);
 91    D.Add(3,2,11);
 92    D.Add(3,4,6);
 93    D.Add(4,3,6);
 94    D.Add(4,5,9);
 95    D.Add(5,0,14);
 96    D.Add(5,0,14);
 97    D.Add(5,4,9);
 98    D.dijkstra(0);
 99 
100    for(int i=0;i<6;i++){
101         cout<<D.get(i)<<endl;
102    }
103 
104 }

这个程序实现了如图所示图的最短距离的求得