spfa() 先辈们好给力啊！orz...... come on!

最新推荐文章于 2018-05-20 22:13:00 发布
最新推荐文章于 2018-05-20 22:13:00 发布
阅读量627 收藏
点赞数
分类专栏： 最短路

适用范围：给定的图存在负权边，这时类似Dijkstra等算法便没有了用武之地，而Bellman-Ford算法的复杂度又过高，SPFA算法便派上用场了。 我们约定有向加权图G不存在负权回路，即最短路径一定存在。当然，我们可以在执行该算法前做一次拓扑排序，以判断是否存在负权回路，但这不是我们讨论的重点。

算法思想：我们用数组d记录每个结点的最短路径估计值，用邻接表来存储图G。我们采取的方法是动态逼近法：设立一个先进先出的队列用来保存待优化的结点，优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作，直至队列空为止

期望的时间复杂度O(ke)， 其中k为所有顶点进队的平均次数，可以证明k一般小于等于2。

实现方法：

　　建立一个队列，初始时队列里只有起始点，再建立一个表格记录起始点到所有点的最短路径（该表格的初始值要赋为极大值，该点到他本身的路径赋为0）。然后执行松弛操作，用队列里有的点作为起始点去刷新到所有点的最短路，如果刷新成功且被刷新点不在队列中则把该点加入到队列最后。重复执行直到队列为空。

判断有无负环：
　　如果某个点进入队列的次数超过N次则存在负环（SPFA无法处理带负环的图）


首先建立起始点a到其余各点的
最短路径表格

首先源点a入队，当队列非空时：
　１、队首元素（a）出队，对以a为起始点的所有边的终点依次进行松弛操作（此处有b,c,d三个点），此时路径表格状态为：

在松弛时三个点的最短路径估值变小了，而这些点队列中都没有出现，这些点
需要入队，此时，队列中新入队了三个结点b,c,d

队首元素b点出队，对以b为起始点的所有边的终点依次进行松弛操作（此处只有e点），此时路径表格状态为：

在最短路径表中，e的最短路径估值也变小了，e在队列中不存在，因此e也要
入队，此时队列中的元素为c，d，e

队首元素c点出队，对以c为起始点的所有边的终点依次进行松弛操作（此处有e,f两个点），此时路径表格状态为：

在最短路径表中，e，f的最短路径估值变小了，e在队列中存在，f不存在。因此
e不用入队了，f要入队，此时队列中的元素为d，e，f

队首元素d点出队，对以d为起始点的所有边的终点依次进行松弛操作（此处只有g这个点），此时路径表格状态为：

在最短路径表中，g的最短路径估值没有变小（松弛不成功），没有新结点入队，队列中元素为f，g

队首元素f点出队，对以f为起始点的所有边的终点依次进行松弛操作（此处有d，e，g三个点），此时路径表格状态为：


在最短路径表中，e，g的最短路径估值又变小，队列中无e点，e入队，队列中存在g这个点，g不用入队，此时队列中元素为g，e

队首元素g点出队，对以g为起始点的所有边的终点依次进行松弛操作（此处只有b点），此时路径表格状态为：

在最短路径表中，b的最短路径估值又变小，队列中无b点，b入队，此时队列中元素为e，b
队首元素e点出队，对以e为起始点的所有边的终点依次进行松弛操作（此处只有g这个点），此时路径表格状态为：

在最短路径表中，g的最短路径估值没变化（松弛不成功），此时队列中元素为b

队首元素b点出队，对以b为起始点的所有边的终点依次进行松弛操作（此处只有e这个点），此时路径表格状态为：

在最短路径表中，e的最短路径估值没变化（松弛不成功），此时队列为空了

最终a到g的最短路径为１４

program：

#include<cstdio>
using namespace std;
struct node
{int x;
int value;
int next;
};
node e[60000];
int visited[1505],dis[1505],st[1505],queue[1000];
int main()
{
int n,m,u,v,w,start,h,r,cur;
freopen("c.in","r",stdin);
freopen("c.out","w",stdout);
while(scanf("%d%d",&n,&m)!=EOF)
{
for(int i=1;i<=1500;i++)
{visited[i]=0;
dis[i]=-1;
st[i]=-1; //这个初始化给下边那个while循环带来影响
}

for(int i=1;i<=m;i++)
{
scanf("%d%d%d\n",&u,&v,&w);
e[i].x=v; //记录后继节点 相当于链表中的创建一个节点，并使得数据域先记录
e[i].value=w;
e[i].next=st[u]; //记录顶点节点的某一个边表节点的下标，相当于在链表中吧该边表节点的next指针先指向他的后继边表节点
st[u]=i; //把该顶点的指针指向边表节点，相当于链表中的插入中，头结点的指针改变
}
start=1;
visited[start]=1;
dis[start]=0;
h=0;
r=1;
queue[r]=start;
while(h!=r)
{

h=(h+1)%1000;
cur=queue[h];
int tmp=st[cur];
visited[cur]=0;

while(tmp!=-1)
{
if (dis[e[tmp].x]<dis[cur]+e[tmp].value) //改成大于号才对
{
dis[e[tmp].x]=dis[cur]+e[tmp].value;
if(visited[e[tmp].x]==0)
{

visited[e[tmp].x]=1;
r=(r+1)%1000;
queue[r]=e[tmp].x;
}
}
tmp=e[tmp].next;
}
}
printf("%d\n",dis[n]);
}
return 0;
}


(没有质量，就出数量) 下面一文转载出处：http://blog.csdn.net/morgan_xww/article/details/6279596

  1. /*
  2. SPFA(Shortest Path Faster Algorithm) [图的存储方式为邻接表]
  3. 是Bellman-Ford算法的一种队列实现，减少了不必要的冗余计算。
  4. 算法大致流程是用一个队列来进行维护。 初始时将源加入队列。 每次从队列中取出一个元素，
  5. 并对所有与他相邻的点进行松弛，若某个相邻的点松弛成功，则将其入队。 直到队列为空时算法结束。
  6. 它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短路径，可以处理负边。
  8. SPFA 在形式上和BFS非常类似，不同的是BFS中一个点出了队列就不可能重新进入队列，但是SPFA中
  9. 一个点可能在出队列之后再次被放入队列，也就是一个点改进过其它的点之后，过了一段时间可能本
  10. 身被改进，于是再次用来改进其它的点，这样反复迭代下去。
  12. 判断有无负环：如果某个点进入队列的次数超过V次则存在负环（SPFA无法处理带负环的图）。
  14. SPFA算法有两个优化算法 SLF 和 LLL：
  15. SLF：Small Label First 策略，设要加入的节点是j，队首元素为i，若dist(j)<dist(i)，则将j插入队首，
  16. 否则插入队尾。
  17. LLL：Large Label Last 策略，设队首元素为i，队列中所有dist值的平均值为x，若dist(i)>x则将i插入
  18. 到队尾，查找下一元素，直到找到某一i使得dist(i)<=x，则将i出对进行松弛操作。
  19. 引用网上资料，SLF 可使速度提高 15 ~ 20%；SLF + LLL 可提高约 50%。
  20. 在实际的应用中SPFA的算法时间效率不是很稳定，为了避免最坏情况的出现，通常使用效率更加稳定的Dijkstra算法。
  21. */
  23. //用数组实现邻接表存储，pnt[i,0]表示与i相邻的结点个数，pnt[i,1...k]存储与i相邻的点
  24. int pnt[MAXN][MAXN];
  25. int map[MAXN][MAXN]; //map[i,j]为初始输入的i到j的距离，并且map[i,i]=0;未知的map[i,j]=INF;
  26. int dis[MAXN];
  27. char vst[MAXN];
  29. int SPFA(int n,int s)
  30. {
  31. int i, pri, end, p, t;
  32. memset(vst, 0, sizeof(vst));
  33. for (i=1; i<=n; i++)
  34. dis[i] = INF;
  35. dis[s] = 0;
  36. vst[s] = 1;
  37. Q[0] = s; pri = 0; end = 1;
  38. while (pri < end)
  39. {
  40. p = Q[pri];
  41. for (i=1; i<=pnt[p][0]; i++)
  42. {
  43. t = pnt[p][i];
  44. //先释放，释放成功后再判断是否要加入队列
  45. if (dis[p]+map[p][t] < dis[t])
  46. {
  47. dis[t] = dis[p]+map[p][t];
  48. if (!vst[t])
  49. {
  50. Q[end++] = t;
  51. vst[t] = 1;
  52. }
  53. }
  54. }
  55. vst[p] = 0;
  56. pri++;
  57. }
  58. return 1;
  59. }
  1. /*
  2. SPFA(Shortest Path Faster Algorithm) [图的存储方式为邻接表]
  3. 是Bellman-Ford算法的一种队列实现，减少了不必要的冗余计算。
  4. 算法大致流程是用一个队列来进行维护。 初始时将源加入队列。 每次从队列中取出一个元素，
  5. 并对所有与他相邻的点进行松弛，若某个相邻的点松弛成功，则将其入队。 直到队列为空时算法结束。
  6. 它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短路径，可以处理负边。
  8. SPFA 在形式上和BFS非常类似，不同的是BFS中一个点出了队列就不可能重新进入队列，但是SPFA中
  9. 一个点可能在出队列之后再次被放入队列，也就是一个点改进过其它的点之后，过了一段时间可能本
  10. 身被改进，于是再次用来改进其它的点，这样反复迭代下去。
  12. 判断有无负环：如果某个点进入队列的次数超过V次则存在负环（SPFA无法处理带负环的图）。
  14. SPFA算法有两个优化算法 SLF 和 LLL：
  15. SLF：Small Label First 策略，设要加入的节点是j，队首元素为i，若dist(j)<dist(i)，则将j插入队首，
  16. 否则插入队尾。
  17. LLL：Large Label Last 策略，设队首元素为i，队列中所有dist值的平均值为x，若dist(i)>x则将i插入
  18. 到队尾，查找下一元素，直到找到某一i使得dist(i)<=x，则将i出对进行松弛操作。
  19. 引用网上资料，SLF 可使速度提高 15 ~ 20%；SLF + LLL 可提高约 50%。
  20. 在实际的应用中SPFA的算法时间效率不是很稳定，为了避免最坏情况的出现，通常使用效率更加稳定的Dijkstra算法。
  21. */
  23. //用数组实现邻接表存储，pnt[i,0]表示与i相邻的结点个数，pnt[i,1...k]存储与i相邻的点
  24. int pnt[MAXN][MAXN];
  25. int map[MAXN][MAXN]; //map[i,j]为初始输入的i到j的距离，并且map[i,i]=0;未知的map[i,j]=INF;
  26. int dis[MAXN];
  27. char vst[MAXN];
  29. int SPFA(int n, int s)
  30. {
  31. int i, pri, end, p, t;
  32. memset(vst, 0, sizeof(vst));
  33. for (i=1; i<=n; i++)
  34. dis[i] = INF;
  35. dis[s] = 0;
  36. vst[s] = 1;
  37. Q[0] = s; pri = 0; end = 1;
  38. while (pri < end)
  39. {
  40. p = Q[pri];
  41. for (i=1; i<=pnt[p][0]; i++)
  42. {
  43. t = pnt[p][i];
  44. //先释放，释放成功后再判断是否要加入队列
  45. if (dis[p]+map[p][t] < dis[t])
  46. {
  47. dis[t] = dis[p]+map[p][t];
  48. if (!vst[t])
  49. {
  50. Q[end++] = t;
  51. vst[t] = 1;
  52. }
  53. }
  54. }
  55. vst[p] = 0;
  56. pri++;
  57. }
  58. return 1;
  59. } 
/*
SPFA(Shortest Path Faster Algorithm) [图的存储方式为邻接表]
是Bellman-Ford算法的一种队列实现，减少了不必要的冗余计算。
算法大致流程是用一个队列来进行维护。 初始时将源加入队列。 每次从队列中取出一个元素，
并对所有与他相邻的点进行松弛，若某个相邻的点松弛成功，则将其入队。 直到队列为空时算法结束。
它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短路径，可以处理负边。

SPFA 在形式上和BFS非常类似，不同的是BFS中一个点出了队列就不可能重新进入队列，但是SPFA中
一个点可能在出队列之后再次被放入队列，也就是一个点改进过其它的点之后，过了一段时间可能本
身被改进，于是再次用来改进其它的点，这样反复迭代下去。

判断有无负环：如果某个点进入队列的次数超过V次则存在负环（SPFA无法处理带负环的图）。

SPFA算法有两个优化算法 SLF 和 LLL：
SLF：Small Label First 策略，设要加入的节点是j，队首元素为i，若dist(j)<dist(i)，则将j插入队首，
否则插入队尾。
LLL：Large Label Last 策略，设队首元素为i，队列中所有dist值的平均值为x，若dist(i)>x则将i插入
到队尾，查找下一元素，直到找到某一i使得dist(i)<=x，则将i出对进行松弛操作。
引用网上资料，SLF 可使速度提高 15 ~ 20%；SLF + LLL 可提高约 50%。
在实际的应用中SPFA的算法时间效率不是很稳定，为了避免最坏情况的出现，通常使用效率更加稳定的Dijkstra算法。
*/

//用数组实现邻接表存储，pnt[i,0]表示与i相邻的结点个数，pnt[i,1...k]存储与i相邻的点
int  pnt[MAXN][MAXN];
int  map[MAXN][MAXN]; //map[i,j]为初始输入的i到j的距离，并且map[i,i]=0;未知的map[i,j]=INF;
int  dis[MAXN];
char vst[MAXN];

int SPFA(int n, int s)
{
    int i, pri, end, p, t;
    memset(vst, 0, sizeof(vst));
    for (i=1; i<=n; i++)
        dis[i] = INF;
    dis[s] = 0;
    vst[s] = 1;
    Q[0] = s; pri = 0; end = 1;
    while (pri < end)
    {
        p = Q[pri];
        for (i=1; i<=pnt[p][0]; i++)
        {
            t = pnt[p][i];
            //先释放，释放成功后再判断是否要加入队列
            if (dis[p]+map[p][t] < dis[t])
            {
                dis[t] = dis[p]+map[p][t];
                if (!vst[t])
                {
                    Q[end++] = t;
                    vst[t] = 1;
                }
            }
        }
        vst[p] = 0;
        pri++;
    }
    return 1;
}
  1. 正规邻接表存储：
  2. /* ------- 邻接表存储 ----------- */
  3. struct Edge
  4. {
  5. int e; //终点
  6. int v; //边权
  7. struct Edge *nxt;
  8. };
  9. struct
  10. {
  11. struct Edge *head, *last;
  12. } node[MAXN];
  13. /* -------------------------------- */
  15. /* 添加有向边<起点,终点,边权> */
  16. void add(int s,int e,int v)
  17. {
  18. struct Edge *p;
  19. p = (struct Edge*)malloc(sizeof(struct Edge));
  20. p->e = e;
  21. p->v = v;
  22. p->nxt = NULL;
  23. if (node[s].head == NULL)
  24. {
  25. node[s].head = p;
  26. node[s].last = p;
  27. }
  28. else
  29. {
  30. node[s].last->nxt = p;
  31. node[s].last = p;
  32. }
  33. }
  35. /* 松弛，成功返回1，否则0 */
  36. int relax(int s,int e,int v)
  37. {
  38. if (dis[s]+v < dis[e])
  39. {
  40. dis[e] = dis[s]+v;
  41. return 1;
  42. }
  43. return 0;
  44. }
  46. /* SPFA有负权回路返回0,否则返回1并且最短路径保存在dis[] */
  47. int n;
  48. int vst[MAXN], cnt[MAXN];
  49. int Q[MAXN*MAXN];
  50. int SPFA(int s0)
  51. {
  52. int i, p, q;
  53. struct Edge *pp;
  55. memset(vst, 0, sizeof(vst));
  56. memset(cnt, 0, sizeof(cnt));
  57. for (i=0; i<=n; i++)
  58. dis[i] = INF;
  59. dis[s0] = 0;
  61. Q[0] = s0; p = 0; q = 1;
  62. vst[s0] = 1;
  63. cnt[s0]++;
  64. while (p < q)
  65. {
  66. pp = node[Q[p]].head;
  67. while (pp)
  68. {
  69. if (relax(Q[p], pp->e, pp->v) && !vst[pp->e])
  70. {
  71. Q[q++] = pp->e;
  72. vst[pp->e] = 1;
  73. cnt[pp->e]++;
  74. if (cnt[pp->e] > n) //有负权回路
  75. return 0;
  76. }
  77. pp = pp->nxt;
  78. }
  79. vst[Q[p]] = 0;
  80. p++;
  81. }
  82. return 1;
  83. }
  1. 正规邻接表存储：
  2. /* ------- 邻接表存储 ----------- */
  3. struct Edge
  4. {
  5. int e; //终点
  6. int v; //边权
  7. struct Edge *nxt;
  8. };
  9. struct
  10. {
  11. struct Edge *head, *last;
  12. } node[MAXN];
  13. /* -------------------------------- */
  15. /* 添加有向边<起点,终点,边权> */
  16. void add(int s, int e, int v)
  17. {
  18. struct Edge *p;
  19. p = (struct Edge*)malloc(sizeof(struct Edge));
  20. p->e = e;
  21. p->v = v;
  22. p->nxt = NULL;
  23. if (node[s].head == NULL)
  24. {
  25. node[s].head = p;
  26. node[s].last = p;
  27. }
  28. else
  29. {
  30. node[s].last->nxt = p;
  31. node[s].last = p;
  32. }
  33. }
  35. /* 松弛，成功返回1，否则0 */
  36. int relax(int s, int e, int v)
  37. {
  38. if (dis[s]+v < dis[e])
  39. {
  40. dis[e] = dis[s]+v;
  41. return 1;
  42. }
  43. return 0;
  44. }
  46. /* SPFA有负权回路返回0,否则返回1并且最短路径保存在dis[] */
  47. int n;
  48. int vst[MAXN], cnt[MAXN];
  49. int Q[MAXN*MAXN];
  50. int SPFA(int s0)
  51. {
  52. int i, p, q;
  53. struct Edge *pp;
  55. memset(vst, 0, sizeof(vst));
  56. memset(cnt, 0, sizeof(cnt));
  57. for (i=0; i<=n; i++)
  58. dis[i] = INF;
  59. dis[s0] = 0;
  61. Q[0] = s0; p = 0; q = 1;
  62. vst[s0] = 1;
  63. cnt[s0]++;
  64. while (p < q)
  65. {
  66. pp = node[Q[p]].head;
  67. while (pp)
  68. {
  69. if (relax(Q[p], pp->e, pp->v) && !vst[pp->e])
  70. {
  71. Q[q++] = pp->e;
  72. vst[pp->e] = 1;
  73. cnt[pp->e]++;
  74. if (cnt[pp->e] > n) //有负权回路
  75. return 0;
  76. }
  77. pp = pp->nxt;
  78. }
  79. vst[Q[p]] = 0;
  80. p++;
  81. }
  82. return 1;
  83. } 
正规邻接表存储：
/* ------- 邻接表存储 ----------- */
struct Edge
{
    int e;  //终点
    int v;  //边权
    struct Edge *nxt;
};
struct
{
    struct Edge *head, *last;
} node[MAXN];
/* -------------------------------- */

/*  添加有向边<起点,终点,边权>  */
void add(int s, int e, int v)
{
    struct Edge *p;
    p = (struct Edge*)malloc(sizeof(struct Edge));
    p->e = e;
    p->v = v;
    p->nxt = NULL;
    if (node[s].head == NULL)
    {
        node[s].head = p;
        node[s].last = p;
    }
    else
    {
        node[s].last->nxt = p;
        node[s].last = p;
    }
}

/*  松弛，成功返回1，否则0  */
int relax(int s, int e, int v)
{
    if (dis[s]+v < dis[e])
    {
        dis[e] = dis[s]+v;
        return 1;
    }
    return 0;
}

/*  SPFA有负权回路返回0,否则返回1并且最短路径保存在dis[]  */
int n;
int vst[MAXN], cnt[MAXN];
int Q[MAXN*MAXN];
int SPFA(int s0)
{
    int i, p, q;
    struct Edge *pp;

    memset(vst, 0, sizeof(vst));
    memset(cnt, 0, sizeof(cnt));
    for (i=0; i<=n; i++)
        dis[i] = INF;
    dis[s0] = 0;

    Q[0] = s0; p = 0; q = 1;
    vst[s0] = 1;
    cnt[s0]++;
    while (p < q)
    {
        pp = node[Q[p]].head;
        while (pp)
        {
            if (relax(Q[p], pp->e, pp->v) && !vst[pp->e])
            {
                Q[q++] = pp->e;
                vst[pp->e] = 1;
                cnt[pp->e]++;
                if (cnt[pp->e] > n) //有负权回路
                    return 0;
            }
            pp = pp->nxt;
        }
        vst[Q[p]] = 0;
        p++;
    }
    return 1;
}
  1. /**通过poj 3159 证明：还是用数组来实现邻接表比用链表来实现邻接表效率高， **/
  3. #define MAX_node 10000
  4. #define MAX_edge 100000
  6. struct Edge
  7. {
  8. int e, v;
  9. } edge[MAX_edge];
  11. int neg; //number of edge
  12. int node[MAX_node]; //注意node要用memset初始化全部为-1
  13. int next[MAX_edge];
  15. void add(int s,int e,int v)
  16. {
  17. edge[neg].e = e;
  18. edge[neg].v = v;
  19. next[neg] = node[s];
  20. node[s] = neg++;
  21. }
  22. /* 该题还证明用栈来实现SPFA比用队列来实现效率高，还节约空间 */
  23. int SPFA(int s0)//栈实现
  24. {
  25. int i, t, p, top;
  27. memset(vst, 0, sizeof(vst));
  28. for (i=1; i<=n; i++)
  29. dis[i] = INF;
  30. dis[s0] = 0;
  32. Q[0] = s0;
  33. top = 1;
  34. vst[s0] = 1;
  35. while (top)
  36. {
  37. t = Q[--top];
  38. vst[t] = 0;
  39. p = node[t];
  40. while (p != -1)
  41. {
  42. if (relax(t, edge[p].e, edge[p].v) && !vst[edge[p].e])
  43. {
  44. Q[top++] = edge[p].e;
  45. vst[edge[p].e] = 1;
  46. }
  47. p = next[p];
  48. }
  49. }
  50. return 1;
  51. }
南山小翁
关注
专栏目录
单源最短路——热浪
行走天涯的豆沙包的博客
01-18 442
热浪 德克萨斯纯朴的民众们这个夏天正在遭受巨大的热浪！！！ 他们的德克萨斯长角牛吃起来不错，可是它们并不是很擅长生产富含奶油的乳制品。 农夫John此时身先士卒地承担起向德克萨斯运送大量的营养冰凉的牛奶的重任，以减轻德克萨斯人忍受酷暑的痛苦。 John已经研究过可以把牛奶从威斯康星运送到德克萨斯州的路线。 这些路线包括起始点和终点一共有 T 个城镇，为了方便标号为 1 到 T。 除了起点和终点外的...
SPFA[知乎：叶枝黎曼].py
10-14
SPFA[知乎：叶枝黎曼].py
SPFA 算法详解( 强大图解，不会都难！)
热门推荐
muxi@Achilles的专栏
08-22 4万+
适用范围：给定的图存在负权边，这时类似Dijkstra等算法便没有了用武之地，而Bellman-Ford算法的复杂度又过高，SPFA算法便派上用场了。 我们约定有向加权图G不存在负权回路，即最短路径一定存在。当然，我们可以在执行该算法前做一次拓扑排序，以判断是否存在负权回路，但这不是我们讨论的重点。 算法思想：我们用数组d记录每个结点的最短路径估计值，用邻接表来存储图G。我们采取的方法是动态
spfa算法详解
weixin_33736832的博客
05-20 286
spfa的算法思想（动态逼近法）： 设立一个先进先出的队列q用来保存待优化的结点，优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作，直至队列空为止。 松弛操作的原理是著...
SPFA算法——最短路径
weixin_34277853的博客
11-18 779
  粗略讲讲SPFA算法的原理，SPFA算法是1994年西安交通大学段凡丁提出 是一种求单源最短路的算法 算法中需要用到的主要变量 int n;  //表示n个点，从1到n标号 int s,t;  //s为源点，t为终点 int d[N];  //d[i]表示源点s到点i的最短路 int p[N];  //记录路径（或者说记录前驱） queue &lt;int&gt; q;  //...
SPFA算法
weixin_30511039的博客
09-14 1355
SPFA算法 一.算法简介 SPFA(Shortest Path Faster Algorithm)算法是求单源最短路径的一种算法，它是Bellman-ford的队列优化，它是一种十分高效的最短路算法。 很多时候，给定的图存在负权边，这时类似Dijkstra等算法便没有了用武之地，而Bellman-Ford算法的复杂度又过高，SPFA算法便派上用场了。SPFA的复杂度大约是O(kE),...
SPFA算法模版+邻接表实现.docx
05-06
SPFA（Shortest Path Faster Algorithm）算法是一种求解图中单源最短路径问题的算法，它是贝尔曼-福特算法（Bellman-Ford Algorithm）的一种优化版本。SPFA算法主要适用于边稀疏的图，其平均时间复杂度为O(E)，其中E...
SPFA.zip_SPFA
09-24
SPFA（Shortest Path Faster Algorithm，最短路径更快算法）是一种用于解决图论中的单源最短路径问题的算法，由李振国于2001年提出。它与Dijkstra算法类似，但解决了Dijkstra算法在处理负权边时可能出现的问题。SPFA...
spfa算法
Crazy_Bear
09-23 393
spfa算法：最短路径算法，适用于求解带有负权的图的最短路径，是BellmanFord的一种优化 时间复杂度：O（kE），k为每个节点进入队列的次数，一般 局限性：适用于稀疏图，同时不能输出负环(仅能检测负环，如果需要输出负环可使用BellmanFord算法)，算法不稳定 本质：宽度优先搜索+剪枝（将一个节点压入队列之前需要先判断这个节点是否已经在队列中） 代码： int hea
SPFA 算法
zcube的技术博客
09-05 1469
/** SPFA: Shortest Path Faster Algorithm 看到名字不禁为之一颤，SPFA算法是西南交通大学段凡丁于1994年发表的。 SPFA 也是竞赛中最常见的算法之一，不仅仅用来解决带负权的单源最短路 而且是求解差分约束问题的专用算法，也常用它和最大流合作解决最小费问题 可以说SPFA 是 dijkstra 和 bellman 的
最短路径问题---SPEA算法详解
路途遥远，初心难忘，道阻且长，愿君走出半生，归来仍是少年
02-22 3328
1、最短路径问题介绍问题解释： 从图中的某个顶点出发到达另外一个顶点的所经过的边的权重和最小的一条路径，称为最短路径解决问题的算法：迪杰斯特拉算法（Dijkstra算法）弗洛伊德算法（Floyd算法）SPFA算法之前已经对Dijkstra算法和Floyd算法做了介绍（不懂的可以看这篇博客：Dijkstra算法详解、Floyd算法详解），所以这篇博客打算对SPFA算法做详细的的介绍。2、SPFA算法...
使用Dijkstra算法解决最短路径问题
在给出的代码中，定义了一个名为`SPFA`的类，用于实现Dijkstra算法。`SPFA`类包含了以下几个成员变量： 1. `n`: 表示图中的节点数量。 2. `path[MAX][MAX]`: 二维数组，存储图的邻接矩阵，表示各个节点之间的距离或...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值