最短路总结4 SPFA及应用

最短路系列链接
最短路总结1 最短路问题概述与朴素dijkstra
最短路总结2 堆优化dijkstra
最短路总结3 BellmanFord
最短路总结4 SPFA及应用
最短路总结5 floyd

1.spfa算法

1. 本质是利用宽搜优化bellman-ford算法
2. 功能强大，绝大多数情况下比bellman-ford算法要强~~（只要不限制最短路经过的边数或者存在负权回路）~~ ，也可以代替dijkstra算法。
3. 由于算法中是更新点v的所有出边，因此用vector实现的邻接表比较好用

2.算法流程

1. 源点入队
2. while queue不空
3. 取出队首元素t，队首弹出
4. 用t松弛更新t的所有出边
5. 若更新b成功，且当前b不在队列queue中，则b入队

值得注意的是：
1.queue中装的是用来更新其他点的点
2.用一个bool数组维护标识1-n点，此时是否在队列中

3. 模板

int n;      // 总点数
int h[N], w[N], e[N], ne[N], idx;       // 邻接表存储所有边
int dist[N];        // 存储每个点到1号点的最短距离
bool st[N];     // 存储每个点是否在队列中

// 求1号点到n号点的最短路距离，如果从1号点无法走到n号点则返回-1
int spfa()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    queue<int> q;
    q.push(1);
    st[1] = true;

    while (q.size())
    {
        auto 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])     // 如果队列中已存在j，则不需要将j重复插入
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }

    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

作者：yxc
链接：https://www.acwing.com/blog/content/405/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

4.应用1：spfa求最短路

给定一个n个点m条边的有向图，图中可能存在重边和自环， 边权可能为负数。
请你求出1号点到n号点的最短距离，如果无法从1号点走到n号点，则输出impossible。
数据保证不存在负权回路。
输入格式
第一行包含整数n和m。
接下来m行每行包含三个整数x，y，z，表示存在一条从点x到点y的有向边，边长为z。
输出格式
输出一个整数，表示1号点到n号点的最短距离。
如果路径不存在，则输出”impossible”。
数据范围
1≤n,m≤
10
5
1≤n,m≤105
,
图中涉及边长绝对值均不超过10000。
输入样例：
3 3
1 2 5
2 3 -3
1 3 4
输出样例：
2

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

using namespace std;

typedef pair<int,int> pa;
const int inf=0x3f3f3f3f,N=100010;

int n,m;
int dist[N];
vector<int> ne[N];
vector<int> ww[N];
queue<pa> q;

int spfa () {
    memset(dist,inf,sizeof(dist));
    dist[1]=0;
    
    q.push({1,0});
    while(q.size()) {
        pa t=q.front();
        q.pop();
        int k=t.first,x=t.second;
        for(int i=0;i<ne[k].size();i++) {
            int v=ne[k][i];
            int w=ww[k][i];
            if(dist[v]>x+w) {
                dist[v]=x+w;
                q.push({v,dist[v]});
            }
        }
    }
    
    if(dist[n]>=1000000000) return -1;
    else return dist[n];
}

int main()
{
    cin >> n >> m;
    while(m --) {
        int x,y,z;
        cin >> x >> y >> z;
        if(x!=y) {
            ne[x].push_back(y);
            ww[x].push_back(z);
        }
    }
    int t=spfa();
    if(t==-1) puts("impossible");
    else cout << t;
    
    return 0;
}

5.应用2：spfa判断负环

1. 维护数组cnt[N],表示从源点到i节点的最短路径经过了cnt[i]条边。
2. 判断存在负环的依据：cnt[i]>=n，当某个节点的最短路径经过超过n-1个节点时，由于n个节点无环最多经过n-1条边，因此必存在一个环，且，当且仅当环路为负时，才有可能是最短路（环路>=0不会被更新），因此这个环路必是负环。

模板：

int n;      // 总点数
int h[N], w[N], e[N], ne[N], idx;       // 邻接表存储所有边
int dist[N], cnt[N];        // dist[x]存储1号点到x的最短距离，cnt[x]存储1到x的最短路中经过的点数
bool st[N];     // 存储每个点是否在队列中

// 如果存在负环，则返回true，否则返回false。
bool spfa()
{
    // 不需要初始化dist数组
    // 原理：如果某条最短路径上有n个点（除了自己），那么加上自己之后一共有n+1个点，由抽屉原理一定有两个点相同，所以存在环。

    queue<int> q;
    for (int i = 1; i <= n; i ++ )
    {
        q.push(i);
        st[i] = true;
    }

    while (q.size())
    {
        auto 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;       // 如果从1号点到x的最短路中包含至少n个点（不包括自己），则说明存在环
                if (!st[j])
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }

    return false;
}

作者：yxc
链接：https://www.acwing.com/blog/content/405/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

板子题：

给定一个n个点m条边的有向图，图中可能存在重边和自环， 边权可能为负数。
请你判断图中是否存在负权回路。
输入格式
第一行包含整数n和m。
接下来m行每行包含三个整数x，y，z，表示存在一条从点x到点y的有向边，边长为z。
输出格式
如果图中存在负权回路，则输出“Yes”，否则输出“No”。
数据范围
1≤n≤2000
1≤n≤2000
,
1≤m≤10000
1≤m≤10000
,
图中涉及边长绝对值均不超过10000。
输入样例：
3 3
1 2 -1
2 3 4
3 1 -4
输出样例：
Yes

//值得注意的是，这道题问的是是否存在负环，而非是否存在从源点开始的负环，因此，在初始化的时候，要将所有点入队而非仅仅入队源点
#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>

using namespace std;

const int N=2010,inf=0x3f3f3f3f;
int n,m;
vector<int> ne[N];
vector<int> ww[N];
int dist[N];
int cnt[N];
bool st[N];
queue<int> q;

bool spfa() {
// 	memset(dist,inf,sizeof(dist));
// 	dist[1]=0;
	for(int i=1;i<=n;i++) {
		q.push(i);
		st[i]=1;
	}
	
	while(q.size()) {
		int v=q.front();
		q.pop();
		st[v]=false;
		
		for(int i=0;i<ne[v].size();i++) {
			int k=ne[v][i];
			int w=ww[v][i];
			if(dist[k]>dist[v]+w) {
				dist[k]=dist[v]+w;
				cnt[k]=cnt[v]+1;
				if(cnt[k]>=n) return true;
				if(!st[k]) {
					q.push(k);
					st[k]=1;
				}
			}
		}
	
	}
	
	return false;
}

int main()
{
	cin >> n >> m;
	while(m --) {
		int x,y,z;
		cin >> x >> y >> z;
		if(x!=y) {
			ne[x].push_back(y);
			ww[x].push_back(z);
		}
	}
	bool is=spfa();
	if(is) puts("Yes");
	else puts("No");
	
	return 0;
}