最短路问题四种算法

1 迪杰斯特拉算法

特点：效率高，不能处理负边

int dijstra()
{
    priority_queue<PII,vector<PII>,greater<PII>>q;
    memset(dist,0x3f,sizeof(dist));
    dist[1]=0;//求s到t的最短路的话dist[s]=0；
    q.push({0,1});
    while(q.size())
    {
        auto t=q.top();    
        q.pop();
        int ver=t.second,dis=t.first;
        if(st[ver])continue;
        st[ver]=true;
        for(int i=h[ver];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(dist[j]>dist[ver]+w[i])
            {
                dist[j]=dist[ver]+w[i];
                q.push({dist[j],j});
            }
        }
    }
    if(dist[n]==0x3f3f3f3f)return -1;
    return dist[n];//dist[t]=0；
}

2 floyd算法

特点：可以处理多源最短路，基于动态规划效率低（时间复杂度O（N3））

//Floyd算法图的初始化
for(int i=1;i<=n;i++)
{
    {
        for(int j=1;j<=n;j++)
        {
            if(i==j)mp[i][j]=0;
            else mp[i][j]=INF;
        }
    }
}
//Floyd核心代码
void floyd()
{
    for(int k=1;k<=n;k++)
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
               mp[i][j]=min(mp[i][j],mp[i][k]+mp[k][j]);
}

3 bellman_ford算法

特点：可以处理负权边，处理有边数限制的最短路问题 

void bellman_ford()
{
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    for(int i=0;i<k;i++)
    {
        memcpy(backup,dist,sizeof dist);
        for(int j=0;j<m;j++)
        {
            int a=e[j].a,b=e[j].b,w=e[j].w;
            dist[b]=min(dist[b],backup[a]+w);
        }
    }
}

4.spfa算法

特点:是对bellman_ford算法的优化，可处理负权边

void spfa()
{
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    queue<int>q;
    q.push(1);
    st[1]=true;
    while(q.size())
    {
        auto t=q.front();
        q.pop();
        st[t]=false;
        for(int i=h[t];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(dist[j]>dist[t]+w[i])
            {
                dist[j]=dist[t]+w[i];
                if(!st[j])
                {
                    q.push(j);
                    st[j]=true;
                }
            }
        }
    }
}