SPFA模板

最新推荐文章于 2020-01-21 09:58:41 发布

原创最新推荐文章于 2020-01-21 09:58:41 发布 · 317 阅读

1 ·

CC 4.0 BY-SA版权

模板专栏收录该内容

55 篇文章

订阅专栏

本文介绍了一种基于队列实现的最短路径快速算法（SPFA），该算法用于解决带负权边的单源最短路径问题。通过使用队列来记录待处理节点，并通过迭代更新节点距离值，SPFA能够有效地寻找从起点到各节点的最短路径。本文提供了完整的代码实现，并解释了如何检测是否存在负权回路。

int used[Maxn],outqueue[Maxn],head[Maxn],low[Maxn],n,m;
struct Edge
{
       int to,w,next;
}edge[Maxm];
bool SPFA (int start)
{
     queue a;
     used[start] = 1;
     low[start] = 0;
     a.push(start);
     while (!a.empty())
     {
           int top = a.front();
           a.pop();
           outqueue[top]++;
           if (outqueue[top] > n) return false;
           for (int k = head[top]; k!= -1; k = edge[k].next)
           {
               if (low[edge[k].to] > low[top] + edge[k].w)
                  low[edge[k].to] = low[top] + edge[k].w;
               if (!used[edge[k].to])
               {
                   used[edge[k].to] = 1;
                   a.push(edge[k].to);
               }
           }
     }
     return true;
}

int main()
{
    while (scanf ("%d%d", &n ,&m) != EOF)
    {
          memset (used, 0 ,sizeof(used));
          memset (head, -1 ,sizeof(head));
          memset (outqueue, 0 ,sizeof(outqueue));
          memset (low, Max, sizeof(low));
          int k = 0;
          while (m--)
          {
                int a,b,w;
                scanf ("%d%d%d", &a, &b, &w);
                edge[k].to = b;
                edge[k].w = w;
                edge[k].next = head[a];
                head[a] = k++;
          }
          if (SPFA(1))
             printf ("%d\n", low[n]);
          else
             printf ("不存在最短\n");
    }
}