最短路模版

SPFA

bool SPFA()
{
	memset(inq, false, sizeof(inq));
	for(int i = 0; i <= n; i++)
		d[i] = INF;
	d[0] = 0;
	queue <int> Q;
	Q.push(0);
	inq[0] = true;
	while(!Q.empty())
	{
		int u = Q.front(); Q.pop();
		inq[u] = false;
		for(int i = 0; i < G[u].size(); i++)
		{
			int v = G[u][i].v;
			int w = G[u][i].w;
			if(d[v] < d[u] + w)
			{
				d[v] = d[u] + w;
				if(!inq[v])
				{
					inq[v] = true;
					Q.push(v);
				}	
			}
		}
	}
}

 

Dijkstra

 

const int INF = 999999999;
const int maxn = 510;
struct edge
{
	int u, v, w;
	edge(){}
	edge(int u, int v, int w) : u(u), v(v), w(w) {}
	
}a[16010];
int n, m, num;
struct HeapNode
{
	int u, d;
	bool operator < (const HeapNode& rhs) const
	{
		return d > rhs.d;
	}
	HeapNode(){}
	HeapNode(int u, int d) : u(u), d(d) {}
};
vector <edge> edges;
vector <int> G[maxn];
int d[maxn];
bool vis[maxn];
void Dijkstra(int s)
{
	for(int i = 0; i <= n; i++)
		d[i] = INF;
	d[s] = 0;
	memset(vis, false, sizeof(vis));
	priority_queue <HeapNode> Q;
	Q.push(HeapNode(s, 0));
	while(!Q.empty())
	{
		HeapNode x = Q.top();Q.pop();
		int u = x.u;
		if(vis[u])
			continue;
		vis[u] = true;
		for(int i = 0; i < G[u].size(); i++)
		{
			edge e = edges[G[u][i]];
			int v = e.v;
			if(d[v] > max(x.d, e.w))
			{
				d[v] = max(x.d, e.w);
				Q.push(HeapNode(v, d[v]));
			}
		}
	}
}
void AddEdge(int u, int v, int w)
{
	edges.push_back(edge(u, v, w));
	edges.push_back(edge(v, u, w));
	num = edges.size();
	G[u].push_back(num-2);
	G[v].push_back(num-1);
}