图论->最短路->SPFA && Dijkstra

SPFA:

优点：

1、可以处理负值边

2、比较好写

缺点：

1、容易被卡时间

特点：

1、队列

模板：

 

//dis[]->最短路; sp->SPFA的队列;
//flag[]->是否在队列中
//u->当前点; v->下一点; d->边的权值
void SPFA(){
    for(int i=1;i<=n;i++)
    dis[i] = maxx;                                  //最短路初始化
    dis[s] = 0;                                     //起点操作1
    sp.push(s);                                     //起点操作2
    while(!sp.empty()){                             //SPFA循环
        int u = sp.front();                         //出队列
        sp.pop();
        flag[u] = 0;                                  
        for(int i = head[u];i;i = que[i].next){      //枚举边
            int v = que[i].v, d = que[i].d;
            if(dis[v] > dis[u] + d){                 //松弛操作
                dis[v] = dis[u] + d;
                if(!flag[v]){                        //不在队列中则入队列
                    flag[v] = 1;
                    sp.push(v);
                }
            }
        }
    }
} 

 Dijkstra:

优点：

1、不容易被卡

缺点：

1、不能处理负权值边

2、可能不怎么容易好写

特点：

1、小根堆 || 优先队列(priority_queue)

2、贪心算法

模板：

 

void dij(){
    for(int i=1;i<=n;i++)
    dis[i] = maxx;                                        //初始化
    dis[s] = 0; 
    di.push(heapnode(s,dis[s]));                          //起点入堆
    heapnode it;                                          //当前堆
    while(!di.empty()){                                   //dij循环
        it = di.top();
        int u = it.s;
        di.pop();                                         //出堆
        if(dis[u] != it.d) continue;                      //不是符合当前的值
        int p = head[u];                                  //当前边
        do{                                               //枚举边
            int v = que[p].v,d = que[p].d;
            if(dis[v] > dis[u] + d){                      //松弛操作
                dis[v] = dis[u] + d;
                di.push(heapnode(v,dis[v]));
            }
            p = que[p].next;
        }while(p != 0);
    }
}