最短路径SPFA和Bellman-Ford算法

参考模板：

#include<bits/stdc++.h>
using namespace std;
#define INF 0x3f3f3f3f
typedef long long ll;

struct node {
	int v, dis;
	node(int v, int dis) {
		this->v = v, this->dis = dis;
	}
};
vector<node> adj[1005];
int n, d[1005], num[1005];
bool inq[1005];

bool SPFA(int s)
{
	fill(d, d + 1005, INF);
	priority_queue<int> q;  //priority_queue只能用top取元素，因为其实质是个堆
	q.push(s);
	inq[s] = true;
	num[s]++;
	d[s] = 0;
	
	while (!q.empty())
	{
		int u = q.top();
		q.pop();
		inq[u] = false;
		for (int i = 0; i < adj[u].size();i++)
		{
			int v = adj[u][i].v;
			int dis = adj[u][i].dis;
			if (d[u] + dis < d[v])
			{
				d[v] = d[u] + dis;
				if (!inq[v])
				{
					q.push(v);
					inq[v] = true;
					num[v]++;
					if (num[v] >= n) return false;  //若有负权环，入队次数一定超过n
				}
			}
		}
	}
	return true;
}

bool bellman(int s)
{
	fill(d, d + 1005, INF);
	for (int i = 0; i < n - 1; i++)
	{
		for (int j = 0; j < n; j++)
		{
			for (int k = 0; k < adj[j].size(); j++)
			{
				int v = adj[j][k].v;
				int dis = adj[j][k].dis;
				if (d[j] + dis < d[v])
				{
					d[v] = d[j] + dis;
				}
			}
		}
	}

	for (int j = 0; j < n; j++)
	{
		for (int k = 0; k < adj[j].size(); j++)
		{
			int v = adj[j][k].v;
			int dis = adj[j][k].dis;
			if (d[j] + dis < d[v]) return false;
		}
	}
	return true;
}

int main()
{
	//主函数按需补充
	return 0;
}