利用spfa算法求最短路与判断负权回路

利用spfa算法求最短路与判断负权回路

spfa算法是对dijkstra算法的优化，大致内容与dijkstra算法相似，但是在更新距离前会判断，距离是否缩小。如果距离缩小，则更新并将该点加入队列，反之则不更新也不加入队列。

一、求最短路

先看看dijkstra算法的写法：

void dijkstra()
{
    memset(dist,0x3f,sizeof dist);
    dist[1] = 0;
    
    proirity_queue<PII,vector<PII>,greater<PII>>q;
    q.push({0,1});
    
    while(q.size())
    {
        PII t = q.top();
        q.pop();
        
        int p = t.second;
        if(vis[p])continue;
        vis[p] = 1;
        
        for(int i = h[p];i != -1;i = ne[i])
        {
            int j = e[i];
            if(dist[j] < dist[t] + d[i])
            {
                dist[j] = dist[t] + d[i];
                q.push({dist[j],j});
            }
        }
    }
}

如果不了解dijkstra算法的话可以看看：Dijkstra求最短路_Kicamon的博客-CSDN博客

而spfa算法则会判断该点距离是否缩短，缩短了才会加入队列，并且会判断该点是否在队列中，不会将冗余数值加入其中。

代码如下：

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

二、判断是否存在负权回路

已知存在n个点，那么从一点到另一点经过的最多边数就是n - 1条，那么当一个点的边数不小于n时，就意味着路径上存在负权回路。由于负权回路可能存在于任意一条路径中，那么就要已所有边为起点开始搜。并开一个数组cnt用于存储每个点的边数。

bool dfs()
{
    queue<int>q;
    for(int i =1;i <= n;i++)
    {
        q.push(i);
        vis[i] = 1;
    }
    
    while(q.size())
    {
        int t = q.front();
        q.pop();
        vis[t] = 0;
        
        for(int i = h[t];i != -1;i = ne[i])
        {
            if(dist[j] > dist[t] + d[i])
            {
                dist[j] = dist[t] + d[i];
                
                cnt[j] = cnt[t] + 1;
                if(cnt[j] >= n)return 1;
                
                if(!vis[j])
                {
                    q.push(j);
                    vis[j] = 1;
                }
            }
        } 
    }
    
    return 0;
}