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);
}