最短路SPFA

SPFA算法是对Bellman-ford算法的优化，

优化的思想：Bellman-ford算法是遍历所有边，对边进行松弛操作，但是如果前一个边的距离没有变化，那么后一个边的距离也不会变化。通过这个特性，我们可以将变化距离的点存在队列中，只对这些点的后继点进行松弛操作。

SPFA算法的时间复杂度为O(m)-O(nm)，m为边数，n为点数，最坏情况与Bellman-ford算法相同。

acwing851. spfa求最短路

给定一个n个点m条边的有向图，图中可能存在重边和自环， 边权可能为负数。

请你求出1号点到n号点的最短距离，如果无法从1号点走到n号点，则输出impossible。

数据保证不存在负权回路。

输入格式：

第一行包含整数n和m。

接下来m行每行包含三个整数x，y，z，表示存在一条从点x到点y的有向边，边长为z。

输出格式：

输出一个整数，表示1号点到n号点的最短距离。

如果路径不存在，则输出”impossible”。

数据范围：

1≤n,m≤1e5

图中涉及边长绝对值均不超过10000。

输入样例：

3 3
1 2 5
2 3 -3
1 3 4

输出样例：

2

模板代码：

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
typedef pair<int,int>pii;
const int N=1e5+10;
int n,m;
int d[N];
int f[N];
vector<pii>v[N];
int spfa()
{
    memset(d,0x3f,sizeof d);
    d[1]=0;
    queue<int>q;
    q.push(1);
    f[1]=1;
    while(!q.empty())
    {
        int t=q.front();
        q.pop();
        f[t]=0;
        for(int i=0;i<v[t].size();i++)
        {
            pii y=v[t][i];
            if(d[y.first]>y.second+d[t])
            {
                d[y.first]=y.second+d[t];
                if(!f[y.first])
                {
                    f[y.first]=1;
                    q.push(y.first);
                }
            }
        }
    }
    if(d[n]>0x3f3f3f3f/2) return -1;//存在负权边
    return d[n];
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=0;i<m;i++)
    {
        int x,y,w;
        scanf("%d%d%d",&x,&y,&w);
        v[x].push_back({y,w});
    }
    int k=spfa();
    if(k==-1) printf("impossible\n");
    else printf("%d\n",k);
    
    return 0;
}

acwing852. spfa判断负环

给定一个n个点m条边的有向图，图中可能存在重边和自环， 边权可能为负数。

请你判断图中是否存在负权回路。

输入格式

第一行包含整数n和m。

接下来m行每行包含三个整数x，y，z，表示存在一条从点x到点y的有向边，边长为z。

输出格式

如果图中存在负权回路，则输出“Yes”，否则输出“No”。

数据范围

1≤n≤2000

1≤m≤10000,
图中涉及边长绝对值均不超过10000。

输入样例：

3 3
1 2 -1
2 3 4
3 1 -4

输出样例：

Yes

分析：引入cnt数组，记录每个点到点1所需要的边数，当某个点的cnt边数大于等于n时，说明，在求1到这个点的路径上出现了负环。

代码：

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
const int M=1e4+10,N=2e3+10;
typedef pair<int,int>pii;
int n,m;
vector<pii>v[N];
int d[N];
bool f[N];
int cnt[N];
int spfa()
{
    queue<int>q;
    for(int i=1;i<=n;i++)
    {
        d[i]=0x3f3f3f3f;
        f[i]=1;
        q.push(i);
    }
    while(!q.empty())
    {
        int t=q.front();
        q.pop();
        f[t]=0;
        for(int i=0;i<v[t].size();i++)
        {
            pii y=v[t][i];
            if(d[y.first]>y.second+d[t])
            {
                d[y.first]=y.second+d[t];
                cnt[y.first]=cnt[t]+1;
                if(cnt[y.first]>=n) return true;
                if(!f[y.second])
                {
                    q.push(y.first);
                    f[y.first]=1;
                }
            }
        }
    }
    return false;
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=0;i<m;i++)
    {
        int x,y,w;
        scanf("%d%d%d",&x,&y,&w);
        v[x].push_back({y,w});
    }
    int k=spfa();
    if(k) printf("Yes\n");
    else printf("No\n");
    return 0;
}