【最短路算法模板】

bfs可以求无权的图，DP可以求有向无环图的最短路。

【下面是两种dijkstra】求没有负权图(可以有环)

【O(n^2)】

/*dp[ed]就是终点最短路，dp[ed] == INF时无路径*/
void dijkstra(int st)
{
	memset(dp,0x3f,sizeof(dp));
	memset(vis,0,sizeof(vis));
	dp[st] = 0;
	for(int i = 0; i < n; i++)
	{
		int x, minn = INF;
		for(int j = 0; j < n; j++) if(!vis[j] && dp[j] <= minn) minn = dp[x=j];
		if(INF == minn) return;//小优化
		vis[x] = true;
		for(int j = 0; j < n; j++) dp[j] = min(dp[j], dp[x]+cost[x][j]);
	}
}

 

【O(mlogn)】m是边数，n是点数

struct NODE{
	int dis, u;
	NODE(int a = 0, int b = 0){ dis = a, u = b;}
	bool operator <(const NODE& a) const {return dis > a.dis;}
};
struct E{
	int from, to, cost;
	E(int a = 0, int b = 0, int c = 0){ from = a, to = b, cost = c;}
};
vector<E> edge;//记录所有边
vector<int> g[MAXN];//每个点出发的所有边的编号

void add(int a, int b, int v)//加一条有向边
{
	edge.push_back(E(a,b,v));
	int buf = edge.size();
	g[a].push_back(buf-1);
}
void dijkstra(int st)
{
	priority_queue<NODE> q;
	memset(dp,0x3f,sizeof(dp));
	memset(vis,0,sizeof(vis));
	dp[st] = 0;
	q.push(NODE(0,st));
	while(!q.empty())
	{
		NODE buf = q.top();
		q.pop();
		if(vis[buf.u]) continue;
		vis[buf.u] = true;
		for(int i = 0; i < g[buf.u].size(); i++)
		{
			E& e = edge[g[buf.u][i]];
			if(dp[e.to] > dp[buf.u]+e.cost)
			{
				dp[e.to] = dp[buf.u]+e.cost;
				q.push(NODE(dp[e.to],e.to));
			}
		}
	}
}

 【下面是SPFA(就是bellman_ford改进的)  o(k*m，k是常数)】可以求有负环的图

这样写一般情况下远小于 O（n*m）

struct E{
	int from, to, cost;
	E(int a = 0, int b = 0, int c = 0){from = a, to = b, cost = c;}
};
vector<E> edge;
vector<int>g[MAXN];

void add(int a, int b, int c)
{
	edge.push_back(E(a,b,c));
	g[a].push_back(edge.size()-1);
}
bool bellman_ford(int s)
{
	queue<int> q;
	memset(dp,0x3f,sizeof(dp));
	memset(inq,0,sizeof(inq));
	memset(cnt,0,sizeof(cnt));
	dp[s] = 0;
	inq[s] = true;
	q.push(s);
	while(!q.empty())
	{
		int u = q.front();q.pop();
		inq[u] = false;
		for(int i = 0; i < g[u].size(); i++)
		{
			E& e = edge[g[u][i]];
			if(dp[u] < INF && dp[e.to] > dp[u]+e.cost)
			{
				dp[e.to] = dp[u]+e.cost;
				if(!inq[e.to])
				{
					q.push(e.to);
					inq[e.to] = true;
					if(++cnt[e.to] > n) return false;//发现负圈退出
				}
			}
		}
	}
	return true;
}

 

【下面是floyd O(n^3)】用来求任意两点之间的最短路，上面的都是求单源最短路

【求最短路】

void floyd(int s)
{
	for(int i = 0; i < n; i++) dp[i][i] = 0;
	for (int k = 0; k < n; k++)
	{
		for (int i = 0; i < n; i++)
		{
			for (int j = 0; j < n; j++)
			{
				dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j]);
			}
		}
	}
}

【求有向图的传递闭包】就是两点之间有无通路

void floyd(int s)
{
	for(int i = 0; i < n; i++) dp[i][i] = 1;
	for (int k = 0; k < n; k++)
	{
		for (int i = 0; i < n; i++)
		{
			for (int j = 0; j < n; j++)
			{
				dp[i][j] = dp[i][j] || (dp[i][k]&&dp[k][j]);
			}
		}
	}
}