图论专题小结：最短路算法

1.Dijkstra算法（适用于边权为正的图）

（1）概述：该算法可以计算正权图的单源最短路，即从一个单个源点出发，到所有结点的最短路。伪代码如下：

         清除所有点的标号

         设d[0]=0,其他d[i]=INF

         循环n次

        {

             在所有未标号的结点中，选出d值最小的结点x

             给结点x标记

             对于从x出发的所有边(x,y)，更新d[y]=min{d[y],d[x]+w(x,y)}

        }

下面给出优化到O(M*logN)的代码

#define N 10000
#define INF 1000000
struct Edge
{
	int from,to,dist;
	Edge(int u, int v, int d) :from(u), to(v), dist(d){}
};
struct HeapNode//将d值，编号捆绑为一个结构体
{
	int d, u;
	HeapNode(int dd, int uu) :d(dd), u(uu){};
	bool operator <(const HeapNode&rhs)const
	{
		return d>rhs.d;
	}
};
struct Dijkstra
{
	int n, m;
	vector<Edge>edges;
	vector<int>G[N];
	bool done[N];//是否已经永久标记
	int d[N]; //s到各个点的距离
	int p[N]; //最短路中的上一条边

	void init()//初始化
	{
		this->n = n;
		for (int i = 0; i < n; i++)
			G[i].clear();
		edges.clear();
	}
	void AddEdge(int from, int to, int dist)//添加两个端点，距离
	{
		edges.push_back(Edge(from, to, dist));
		m = edges.size();
		G[from].push_back(m - 1);//这条边的序号是m-1
	}
	void dijkstra(int s)//s是源点，注意s表示的是边序号
	{
		priority_queue<HeapNode>Q;
		for (int i = 0; i < n; i++)
			d[i] = INF;
		d[s] = 0;//源点的d值为0
		memset(done, 0, sizeof(done));
		Q.push(HeapNode(0,s));
		while (!Q.empty())//利用BFS的思路
		{
			HeapNode x = Q.top(); Q.pop();
			int u = x.u;//边的u端点
			if (done[u])continue;//已经取过，扔掉
			done[u] = true;
			for (int i = 0; i < G[u].size(); i++)//考虑从u出发的所有边
			{
				Edge& e = edges[G[u][i]];//e是第i条和u相连的边
				if (d[e.to]>d[u] + e.dist)//松弛操作
				{
					d[e.to] = d[u] + e.dist;
					p[e.to] = G[u][i];//记录e.to这个端点的父边
					Q.push(HeapNode(d[e.to], e.to));
				}
			}
		}
	}
};

2.Bellman-Ford算法（适用于边权可正可负的图）

（1）概述：当负权存在时，最短路不一定存在。但有这样一个事实：如果最短路存在，一定存在一个不含环的最短路。（分零环，正环，负环三种讨论即可证明）。

既然如此，那么最短路最多只经过（起点不算）n-1个结点，可以通过n-1次松弛操作得到。下面利用了FIFO队列代替这n-1次循环检查。因为这样一个结点可以多次进入队列。这样的好处是最坏情况下时间复杂度才是O(N*M)。

#define N 10000
#define INF 1000000
struct Edge
{
	int from, to, dist;//dist可正可负
	Edge(int u, int v, int d) :from(u), to(v), dist(d){}
};
struct HeapNode//将d值，编号捆绑为一个结构体
{
	int d, u;
	HeapNode(int dd, int uu) :d(dd), u(uu){};
	bool operator <(const HeapNode&rhs)const
	{
		return d>rhs.d;
	}
};
struct Bellman_Ford
{
	int n, m;
	vector<Edge>edges;
	vector<int>G[N];
	bool done[N];//是否已经永久标记
	int d[N]; //s到各个点的距离
	int p[N]; //最短路中的上一条边
	int inq[N],cnt[N];

	void init()//初始化
	{
		this->n = n;
		for (int i = 0; i < n; i++)
			G[i].clear();
		edges.clear();
	}
	void AddEdge(int from, int to, int dist)//添加两个端点，距离
	{
		edges.push_back(Edge(from, to, dist));
		m = edges.size();
		G[from].push_back(m - 1);//这条边的序号是m-1
	}

	bool bellman_ford(int s)
	{
		queue<int>Q;
		memset(inq, 0, sizeof(inq));//inq数组标记是否进入队列
		memset(cnt, 0, sizeof(cnt));//cnt数组标记到结点入队列的次数
		for (int i = 0; i < n; i++)
			d[i] = INF;
		d[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++)
			{
				Edge&e = edges[G[u][i]];
				if (d[u]<INF&&d[e.to]>d[u] + e.dist)//松弛操作
				{
					d[e.to] = d[u] + e.dist;
					p[e.to] = G[u][i];
					if (!inq[e.to])
					{
						Q.push(e.to);
						inq[e.to] = true;
						if (++cnt[e.to] > n)//入队列次数超过n次，说明有负圈存在，及时退出
							return false;
					}
				}
			}
		}
		return true;
	}
};

（2）简易版本的Bellman-Ford算法（只适用于不含负圈的图）

#define N 1000
#define INF 100000000
struct Edge{ int from, to, cost; };
Edge es[N];
int d[N];    //最短距离
int V, E;
void shortest_path(int s)
{
	for (int i = 0; i < V; i++)//初始化为无穷大
		d[i] = INF;
	d[s] = 0;
	while (1)//循环次数不超过V-1次
	{
		bool update = false;
		for (int i = 0; i < E; i++)//考察每一条边
		{
			Edge e = es[i];
			if (d[e.from] != INF&&d[e.to]>d[e.from] + e.cost)
			{
				d[e.to] = d[e.from] + e.cost;
				update = true;
			}
		}
		if (!update)break;//只要不含有负圈，更新的次数就是有限的
	}
}

3.Floyd算法（适用于快速求解每两个点之间的最短路）

（1）概述：如果需要求每两个点之间的最短路（权值可正可负），可以用下面的Floyd-Warshall算法。

(i)适用于带权图

#define N 1000
#define INF 10000001 //预先估计一下最短路上限
int d[N][N];//记录u,v之间的权值
int n;

void Floyd()//带权图
{
	for (int k = 0; k < n;k++)
	for (int i = 0; i < n;i++)
	for (int j = 0; j < n; j++)
		d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}

(ii)适用于有向无权图（DAG）

#define N 1000
int d[N][N];//记录u,v之间的权值
int n;

void Floyd()//适用于DAG，只判断是否连通
{
	for (int k = 0; k < n; k++)
	for (int i = 0; i < n; i++)
	for (int j = 0; j < n; j++)
		d[i][j] = d[i][j] || (d[i][k] && d[k][j]);
}