【笔记】最短路——SPFA算法

##算法功能

　　找最短路（最长路？）

##算法思想

　　用一个节点k更新节点i到节点j的最短路

##邻接链表存储

　　基础而高效的图的存储方式

　　存的是单向边（无向边可以看成两条有向边）

##实现

　　维护节点i到源点s的最小值d[i]

　　用队列实现

　　　　维护队列z,

　　　　　　用visit[]记录一个点是否在队列

　　　　从源点开始进队列，每次弹出队头元素x，(标记visit[x]=0)

　　　　用它的最短路d[x]将与它相连的节点y的最短路d[y]更新

　　　　如果y不在队列（visit[y]==0），让y入队，记录（visit[y]=1）

　　　　直到队列为空，所有节点的d[]都已维护好

##判断负环

　　若图中存在负环，则更新时一定不断地让负环上的节点入队，负环上的点一定会无数次入队，最终死循环

　　所以我们记录一个点入队的次数sum[],sum[i]在每次i入队时++，如果sum[i]贼大，贼大，证明有负环

　　　　贼大到多大呢？贼大到2*m(m是边数)就肯定死循环了

　　　　反正就是不能比2*m大（一共m条边，假设都与节点i相连，则i最多入队m次（当然不可能所有边都让i走一遍）(老师让sum[i]和m*2比较，不知道为啥那么大

 #include <iostream>
 #include <algorithm>
 #include <cstdio>
 #include <string>
 #include <cstring>
 #include <cmath>
 #include <queue>
 #define N 100010
 #define M 100010
 //复杂度上限m*n
 //n个点，每个如m次 

 //正常nlogn

 //网格图贼慢
 using namespace std;

 queue <int> z;
 int d[N],len,visit[N],n,m;

 //采用结构体存图
 struct edge
 {
     int x,y,k,next;
 }a[M];
 // 邻接链表存储
 int first[M];
 void ins(int x,int y,int k)
 {
     len++;
     a[len].x=x;
     a[len].y=y;
     a[len].k=k;
     a[len].next=first[x];
     first[x]=len;
 }
 int sum[N];

 int main()
 {
     cin>>n>>m;
     memset(d,,sizeof(d));//63是billion（十亿）级别的10 6110 9567
     int x,y,k;
     for(int i=;i<=m;i++)
     {
         cin>>x>>y>>k;
         ins(x,y,k);
         ins(y,x,k);
     }
     int s;
     cin>>s;//源点
     z.push(s);
     visit[s]=;
     d[s]=;

     //******主体代码
     while(!z.empty())
     {
         x=z.front();
         for(int k=first[x];k;k=a[k].next)
         {
             y=a[k].y;
             if(d[x]+a[k].k < d[y])
             {
                 d[y]=d[x]+a[k].k;
                 if(!visit[y])
                 {
 //                    sum[y]++;
                     z.push(y);//这是一个迭代的过程（老师说的，其实我不知道啥是迭代）
                     visit[y]=;
                 }
             }
         }
         z.pop();
         sum[x]++;
         /*if(sum[x] > 2*m)//判断负环 有时会用到
         {
             printf("NO");
             break;
         }*/
         visit[x]=;
     }
     //**********
     for(int i=;i<=n;i++)    cout<<d[i]<<" ";//得到所有节点到源点的最短路
     return ;
 }