2023秋招算法题每日学习（5）

DAY 5

1.AcWing 851. spfa求最短路

考察点：spfa算法

spfa算法是bellman_ford的队列优化版本, bfs实现
优化的是dist[b] = min(dist[b], dist[a]+w)
因为只有dist[a]更新之后变小, dist[b]更新之后才有可能变小
需要st[i]数组，保证队列里面只有一个i;

 由上图可得：如果dist[a]没有发生变化，则不需要更新dist[b]，这就是spfa算法的优化之处。

用通俗的话来说，spfa的核心思想其实就是只有更新过的点才可以用来更新别人，可以更新别人的点放入到队列当中，如果队列不空，则持续更新队列。

总结：（对比最近学习的搜索与图论的算法）/*下面总结转载自ACWING 作者：orzorz*/

1) st数组的作用：判断当前的点是否已经加入到队列当中了；已经加入队列的结点就不需要反复的把该点加入到队列中了，就算此次还是会更新到源点的距离，那只用更新一下数值而不用加入到队列当中。
即便不使用st数组最终也没有什么关系，但是使用的好处在于可以提升效率。
2) SPFA算法看上去和Dijstra算法长得有一些像但是其中的意义还是相差甚远的:

1] Dijkstra算法中的st数组保存的是当前确定了到源点距离最小的点，且一旦确定了最小那么就不可逆了(不可标记为true后改变为false)；SPFA算法中的st数组仅仅只是表示的当前发生过更新的点，且spfa中的st数组可逆(可以在标记为true之后又标记为false)。顺带一提的是BFS中的st数组记录的是当前已经被遍历过的点。
2] Dijkstra算法里使用的是优先队列保存的是当前未确定最小距离的点，目的是快速的取出当前到源点距离最小的点；SPFA算法中使用的是队列(你也可以使用别的数据结构),目的只是记录一下当前发生过更新的点。

3) Bellman_ford算法里最后return-1的判断条件写的是dist[n]>0x3f3f3f3f/2;而spfa算法写的是dist[n]==0x3f3f3f3f;其原因在于Bellman_ford算法会遍历所有的边，因此不管是不是和源点连通的边它都会得到更新；但是SPFA算法不一样，它相当于采用了BFS，因此遍历到的结点都是与源点连通的，因此如果你要求的n和源点不连通，它不会得到更新，还是保持的0x3f3f3f3f。

4)  Bellman_ford算法可以存在负权回路，是因为其循环的次数是有限制的因此最终不会发生死循环；但是SPFA算法不可以，由于用了队列来存储，只要发生了更新就会不断的入队，因此假如有负权回路请你不要用SPFA否则会死循环，SPFA可以处理负权边，但是不能处理有负权回路的图。

5) 由于SPFA算法是由Bellman_ford算法优化而来，在最坏的情况下时间复杂度和它一样即时间复杂度为 O(nm)O(nm) ，假如题目时间允许可以直接用SPFA算法去解Dijkstra算法的题目。

6) 求负环一般使用SPFA算法，方法是用一个cnt数组记录每个点到源点的边数，一个点被更新一次就+1，一旦有点的边数达到了n那就证明存在了负环。

#include<cstring>
#include<iostream>
#include<queue>
#include<algorithm>

using namespace std;

const int N = 100010;

int n,m;
int h[N],e[N],w[N],ne[N],idx;
int dist[N];
int st[N];

void add(int a,int b,int c)//邻接表存储
{
    e[idx] = b,w[idx] = c,ne[idx] = h[a],h[a] = idx++;
}

int spfa()
{
    memset(dist,0x3f,sizeof dist);
    dist[1] = 0;
    queue<int>q;
    q.push(1);
    st[1] = true;
    
    while(q.size())
    {
        int 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;
                }
            }
             
        }
    }
    return dist[n];
    
}

int main()
{
    scanf("%d%d",&n,&m);
    memset(h,-1,sizeof h);
    while(m--)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c);
    }
    int t = spfa();
    if(t == 0x3f3f3f3f) puts("impossible");//相当于采用了BFS，因此遍历到的结点都是与源点连通的，因此如果你要求的n和源点不连通，它不会得到更新，还是保持的0x3f3f3f3f。
    else printf("%d\n",t);
    return 0;
}

2.AcWing 852. spfa判断负环

spfa判断负环的方法：简单来说就是利用抽屉原理，我们通过记录走过的边数cnt[n]，如果经过了n条边或者更多，说明其点肯定大于n，说明存在环，再由于前面的判断条件可以得到，这个环必定是负环。

 

 

#include<cstring>
#include<iostream>
#include<queue>
#include<algorithm>

using namespace std;

const int N = 100010;

int n,m;
int h[N],e[N],w[N],ne[N],idx;
int dist[N], cnt[N];//cnt用来记录经过的边数
bool st[N];

void add(int a,int b,int c)//邻接表存储
{
    e[idx] = b,w[idx] = c,ne[idx] = h[a],h[a] = idx++;
}

bool spfa()
{
   //spfa判断是否有负环不需要初始化
    queue<int>q;
    for(int i = 1;i<=n;i++)
   {
       q.push(i);//因为寻找负环不一定是从结点1进入，所以需要将所有结点压入队列
       st[i] = true;
   }
   
    while(q.size())
    {
        int 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];
                cnt[j] = cnt[t]+1;
                if(cnt[j]>=n) return true;
                if (!st[j])//防止将重复的数据压入队列
                {
                    q.push(j);
                    st[j] = true;
                }
            }
             
        }
    }
    return false;
    
}

int main()
{
    scanf("%d%d",&n,&m);
    memset(h,-1,sizeof h);
    while(m--)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c);
    }
    if(spfa()) puts("Yes");
    else puts("No");
    return 0;
}