最短路 模板

堆优化的Dijkstra NlogN 邻接表

#include <utility>
#include <queue>
typedef std::pair<int, int> P;   //first为点的编号, second为边的权值
const int N = 100005;
int dis[N];
vector<P>e[N];  //first为点的编号, second为边的权值
std::priority_queue<P, vector<P>, greater<P> >q;
void dij(int s)
{
    for (int i = 1; i <= N; ++i)    dis[i] = 0xffffff;
    dis[s] = 0;
    while (!q.empty())  q.pop();
    q.push(P(s, 0));
    while (!q.empty())
    {
        P c = q.top(); q.pop();
        int u = c.first;
        int uw = c.second;
        if (dis[u] < uw)
            continue;
        for (int i = 0; i < e[u].size(); ++i)
        {
            int v = e[u][i].first;
            int w = e[u][i].second;
            if (dis[v] > uw + w)
            {
                dis[v] = uw + w;
                q.push(P(v, dis[v]));
            }
        }
    }
}

堆优化Dijkstra 链式前向星

const int N = 100005;
const int M = 200005;
int cnt, head[N];
struct Edge
{
	int v, next, w;
}e[M];
//head初始化为-1
void add(int u, int v, int w)
{
	e[cnt] = { v, head[u], w };
	head[u] = cnt++;
}
int n, m;
int dis[N];
struct heap {
	int d, u;
	bool operator < (const heap& x)const { return d > x.d; }
};
void dij(int s)
{
	priority_queue<heap> q;
	memset(dis, 127, sizeof(dis));
	dis[s] = 0;
	q.push({ 0, s });
	while (!q.empty())
	{
		heap uu = q.top(); q.pop();
		int u = uu.u;
		if (dis[u] < uu.d)	continue;
		for (int i = head[u]; ~i; i = e[i].next)
		{
			int v = e[i].v;
			if (dis[v] > dis[u] + e[i].w)
			{
				dis[v] = dis[u] + e[i].w;
				q.push({ dis[v],v });
			}
		}
	}
}

普通Dijkstra N^2

const int N = 5005;
bool vis[N];	//vis要初始化为false
int dis[N];
int e[N][N];    //e最开始要初始化为0xffffff, e[i][i]设为0
void dij(int s)
{
    vis[s] = true;
    for (int i = 1; i <= N; ++i)
        dis[i] = e[s][i];
    for (int i = 1; i < N; i++)
    {
        int u, min = 0xffffff;
        for (int j = 1; j <= n; j++)
            if (!vis[j] && min > dis[j])
            {
                min = dis[j];
                u = j;
            }
        vis[u] = true;
        for (int v = 1; v <= n; v++)
            if (e[u][v] != 0xffffff && dis[v] > dis[u] + e[u][v])
                dis[v] = dis[u] + e[u][v];
    }
}

SPFA

const int M = 250005;
const int N = 100005;
struct edge
{
    int to, next, w;
}e[M << 1];
int cnt, head[N]
bool vis[N];
void spfa(int s, long long d[])
{
    for (int i = 0; i < n; ++i) d[i] = 0xfffffff;
    memset(vis, false, sizeof(vis));
    queue<int>q;
    d[s] = 0;
    vis[s] = true;
    q.push(s);
    while (!q.empty())
    {
        int u = q.front(); q.pop();
        vis[u] = false;
        for (int i = head[u]; i; i = e[i].next)
        {
            int v = e[i].to;
            int w = e[i].w;
            if (d[v] <= d[u] + w)   continue;
            d[v] = d[u] + w;
            if (!vis[v])
            {
                vis[v] = true;
                q.push(v);
            }
        }
    }
}