单元最短路径算法模板汇总(Dijkstra, BF,SPFA)，附链式前向星模板

//求其它点到源点s的最短路径，用优先级队列优化

int road[maxn][maxn];//road[i][j]表示i与j的距离(这里指进过该条路的时间)
int dis[maxn];//dis[i]表示i点到源点s的最短路径大小
int vis[maxn];//vis[i]=1表示节点i已经求过到源点的单源最短路径
vector<int> link[maxn];//link[i]表示i与哪些点连接
int n,m;

struct Node{
    int u,dis;  //u:节点  dis:到源点s的距离

    bool operator<(const Node tmp) const{
        return dis>tmp.dis;  //优先级序列默认的是最先取出的是“最大的”。所以这里要从大到小排序
    }
};

void dijkstra() {
    priority_queue<Node> q;
    Node tmp,a;
    for(int i=0;i<maxn;i++)
        dis[i]=INF;
    memset(vis,0,sizeof(vis));
    dis[s]=0;
    a.dis=0;
    a.u=s;
    q.push(a);
    while(!q.empty()) {
        tmp=q.top();
        q.pop();
        int idx=tmp.u;
        vis[idx]=1;
        for(int k=0; k<link[idx].size(); k++) {
            int v=link[idx][k];
            if(!vis[v]) {
                if(dis[idx]+road[idx][v]<dis[v]) {
                    dis[v]=dis[idx]+road[idx][v];
                    a.dis=dis[v];
                    a.u=v;
                    q.push(a);
                }
            }
        }
    }
}

//求源点s到各节点的最短路
bool Bellman_Ford(int s){
    //初始化
    for(int i=0;i<n;i++){
        dist[i]=INF;   //i到源点s的距离
        pre[i]=-1;     //i的前驱节点，用于输出路径
    }
    dist[s]=0;
    for(int i=1;i<n;i++){   //进行n-1次迭代
        for(each(u,v)∈E){     //对所有边松弛一次
            if(dist[u]+w[u][v]<dist[v]){
                dist[v]=dist[u]+w[u][v];
                pre[v]=u;
            }
        }
    }
    //若进行n-1次迭代后，仍然存在可以更新的路径，表明有负权回路，返回false
    for(each(u,v)∈E){
        if(dist[u]+w[u][v]<dist[v]){
            return false;
        }
    }
    return true;
}

int vis[i]://用来标记点i是否在队列中
//计算源点s至各节点的最短路长，这里遍历采用邻接链表——链式前向星
void SPFA(int s){
    queue<int> q;
    int u,v;
    dist[s]=0;  
    q.push(s);
    vis[s]=1;
    while(!q.empty()){
        u=q.front();
        q.pop();
        vis[u]=0;
        //对u的所有出边的端点进行松弛操作，如果可以经过u使得源点到v的路径变短，则更新
        for(int k=head[u];k!=-1;k=edge[k].next){
            v=edge[k].to;
            if(dist[u]+w[u][v]<dist[v]){
                dist[v]=dist[u]+w[u][v];
                //若点v不在队列里，则加入到队列中
                if(!vis[v]){
                    q.push(v);
                    vis[v]=1;
                }
            }
        }
    }
}

//邻接链表存储——链式前向星
//head[i]：表示父亲节点i的所有指向子节点的最后一次与i连接的边的序号
//edge[k].next：表示编号为k的边的相邻的一条边的编号，这两条边是同一节点引出的
//edge[k].to：表示编号为k的边所指向的节点编号
//int head[n],tot;
//n为顶点数，m为边数

struct edge
{
int next,to;
}edge[m]

void add(int x,int y)
{
    edge[tot].next =head[x];
    edge[tot].to = y;
    head[x] = tot++;
}
//初始化
void init()
{
    memset(head,-1,sizeof(head))
    tot = 0;
}

//遍历与x相邻的所有点v
for(int k = head[x];k!=-1;k=edge[k].next)
{
    int v = edge[k].to;
    //...
}