dijkstra算法

①先取一点v[0]作为起始点，初始化dis[i],d[i]的值为v[0]到其余点v[i]的距离w[0][i]，如果直接相邻初始化为权值，否则初始化为无限大；

②将v[0]标记，vis[0] = 1(vis一开始初始化为0)；

③找寻与v[0]相邻的最近点v[k]，将v[k]点记录下来，v[k]与v[0]的距离记为min；

④把v[k]标记，vis[k]=1；

⑤查询并比较，让dis[j]与min+w[k][j]进行比较，判断是直接v[0]连接v[j]短，还是经过v[k]连接v[j]更短，即dis[j]=MIN(dis[j],min+w[k][j])；

⑥继续重复步骤③与步骤⑤，知道找出所有点为止。

题目

http://cogs.pro/cogs/problem/problem.php?pid=415

/****************************************************************************************************

                                        最短路—dijkstra算法(邻接表)
                        将边权替换为概率，相加改为相乘，最短距离改为最大概率
                        

********************************************************************************************************/
#include<cstdio>
#include<vector>
#define MaxInt 99999999
#define MaxN 10005
#define eps 1e-8
using namespace std;
struct Edge{
    int next,to;
    double power;
}e[6*MaxN]; 
bool s[MaxN];// 判断是否已存入该点到S集合中
double dis[MaxN];
int n,m,ed[MaxN];
void in(){
    scanf("%d%d",&n,&m);
    int x;
    for(int i=1;i<=m;i++){
        int j=i<<1;
        scanf("%d%d%lf",&x,&e[j].to,&e[j].power);
        e[j].power/=100;
        e[j].next=ed[x],ed[x]=j;
        if(x==1)dis[e[j].to]=e[j].power;
        j++;
        e[j].to=x;x=e[j-1].to,e[j].power=e[j-1].power;
        e[j].next=ed[x],ed[x]=j;
        if(x==1)dis[e[j].to]=e[j].power;
    }
}
void dijkstra(int v0){//v0为源点 
    s[v0]=1;dis[v0]=1;
    for(int i=1;i<n;i++){
        double min1=0;int u=v0;
        for(int j=1;j<=n;j++){// 找出当前未使用的点j的dis[j]最小值
            if(!s[j]&&dis[j]>min1+eps){
                u=j;min1=dis[j];// u保存当前邻接点中距离最小(概率最大)的点的号码
            }
        }
        s[u]=1;
        int x=ed[u];
        while(x){//在通过新加入的u点路径找到离v0点更短的路径
            if(dis[e[x].to]<dis[u]*e[x].power-eps)dis[e[x].to]=dis[u]*e[x].power;//更新dis
            x=e[x].next;
        }
    }
}
int perseverance(){
    freopen("toura.in","r",stdin);
    freopen("toura.out","w",stdout);
    in();
    dijkstra(1);
    printf("%.6lf",dis[n]*100);
}
int come_on=perseverance();
int main(){
    return 0;
}

 堆优化

/****************************************************************************************************

                                        最短路—dijkstra算法堆优化(邻接表)
                        将边权替换为概率，相加改为相乘，最短距离改为最大概率
                        

********************************************************************************************************/
#include<cstdio>
#include<queue>
#define MaxInt 99999999
#define MaxN 10005
#define eps 1e-8
using namespace std;
struct Edge{
    int next,to;
    double power;
}e[6*MaxN]; 
bool s[MaxN];// 判断是否已存入该点到S集合中
priority_queue<pair<double,int> > q;
double dis[MaxN];
int n,m,ed[MaxN];
void in(){
    scanf("%d%d",&n,&m);
    int x;
    for(int i=1;i<=m;i++){
        int j=i<<1;
        scanf("%d%d%lf",&x,&e[j].to,&e[j].power);
        e[j].power/=100;
        e[j].next=ed[x],ed[x]=j;
        //if(x==1)dis[e[j].to]=e[j].power;
        j++;
        e[j].to=x;x=e[j-1].to,e[j].power=e[j-1].power;
        e[j].next=ed[x],ed[x]=j;
        //if(x==1)dis[e[j].to]=e[j].power;
    }
}
void dijkstra(int v0){//v0为源点 
    dis[v0]=1;
    q.push(make_pair( 1,v0));
    while(!q.empty()){
        pair<double,int>w=q.top();q.pop();// 找出当前未使用的点j的dis[j]最小值
        int u=w.second;
        if(u==n)return;
        if(s[u])continue;//使用过了 
        s[u]=1;
        int x=ed[u];
        while(x){//在通过新加入的u点路径找到离v0点更短的路径
            if(dis[e[x].to]<dis[u]*e[x].power-eps){
                dis[e[x].to]=dis[u]*e[x].power;//更新dis
                q.push(make_pair(dis[e[x].to],e[x].to)); 
            }
            x=e[x].next;
        }
    }
}
int perseverance(){
    freopen("toura.in","r",stdin);
    freopen("toura.out","w",stdout);
    in();
    dijkstra(1);
    printf("%.6lf",dis[n]*100);
}
int come_on=perseverance();
int main(){
    return 0;
}

 允许内部修改的堆优化（不用掌握）

#include<iostream>
using namespace std;
struct MinBinaryHeap{
       struct node{
            int key;           
            int value;
            inline bool operator<(const node &t)const{
                 return value < t.value;   
            }          
       }*array;
       int *location,heap_size;
       MinBinaryHeap(int size){
            heap_size=0;
                array=new node[size+1];
                location=new int[size];
       }       
       ~MinBinaryHeap(){
                delete[] array;    
                delete[] location;
       }
       inline void update(int loc,const node& x){ //put x into array[loc]
            array[loc]=x;
            location[x.key]=loc;  
       }
       void per_down(int hole){
            node tem=array[hole];     
               while(1){    
                int child=hole<<1;     
                if(child > heap_size)
                   break;
                if(child!=heap_size && array[child+1] < array[child])
                   child++;
                if(array[child] < tem){
                   update(hole,array[child]);
                   hole=child;        
                }else break;
            }
            update(hole,tem);
       }       
       void per_up(int hole){
            node tem=array[hole];    
               while(hole > 1){
                if(tem < array[hole>>1]){
                   update(hole,array[hole>>1]);
                   hole>>=1;
               }else break;
            }
            update(hole,tem);
       }
       void build_heap(int *values, int n){
               heap_size=n;
               for(int i=1;i<=n;i++){
                array[i].key=i-1;
                array[i].value=*(values++);     
                location[array[i].key]=i;
            }
            for(int i=heap_size>>1;i>=1;i--)
                per_down(i);            
       }
       pair<int,int> pop(){
               pair<int,int> res=make_pair(array[1].key,array[1].value);       
                array[1]=array[heap_size--];
                per_down(1);
            return res;;
       }
       void decrease_to(int key,int value){
               array[location[key]].value=value;    
            per_up(location[key]);    
       }
};
const int maxn=100000,INF=0x11111111;;
struct graph{
       int node_num,allop_pt;
       struct edge{
                 int j,w;
                 edge *next;
       }*g[maxn],*pool;
       graph(int node_num,int edge_num):node_num(node_num){
                  memset(g,0,sizeof(g));
                  pool=new edge[2*edge_num];
               allop_pt=0;
       }
       ~graph(){
               delete[] pool;            
       }
       inline edge* new_edge(int j,int w,edge* next){
                pool[allop_pt].j=j;
                pool[allop_pt].w=w;
                pool[allop_pt].next=next;
                return &pool[allop_pt++];
       }
       inline void add_edge(int i,int j,int w){
                  g[i]=new_edge(j,w,g[i]);
                  g[j]=new_edge(i,w,g[j]);
       }       
};
void dijkstra(graph& g,int source, int dis[]){
     bool known[maxn]={0};
     for(int i=0;i<g.node_num;i++)dis[i]=INF;
     dis[source]=0;
     MinBinaryHeap heap(g.node_num);
     heap.build_heap(dis,g.node_num);
     for(int k=0;k<g.node_num;k++){
         pair<int,int> tem=heap.pop();        
         int i=tem.first;
         known[i]=true;
         for(graph::edge* e=g.g[i];e;e=e->next){
                  if(!known[e->j] && dis[e->j] > dis[i]+e->w){  
                     dis[e->j]=dis[i]+e->w;
                     heap.decrease_to(e->j,dis[e->j]);
                 }
         }
     }
}