基础图论问题算法总结

这里介绍了图论中常见算法的原理和实现，所有代码已打包，此处可以下载。

一、邻接表存图

用邻接矩阵表示稀疏图会浪费大量内存空间。而在邻接表中是通过把类似于“从顶点0出发有到顶点1、2、3、4的边”这样的信息保存在链表中来表示图的。这样只需要O(|V| + |E|)的内存空间。

#include <cstdio>
#include <vector>
std::vector<int> g[max_v];
/**
*边上有属性的情况
*sturct edge{
* int to, cost;
*};
*std::vector<edge> g[max_v];
*/
int main(void)
{
int v, e;
scanf("%d%d", &v, &e);
for(int i = 0; i != e; ++i){
int s, t;
scanf("%d%d", &s, &t);
g[s].push_back(t);
//g[t].push_back(s);//无向图的情况
}
return 0;
}

二、最短路问题

1.Bellman-Ford求单源最短路

记从起点s出发到顶点i的最短距离为d[i]，则有d[i] = min{d[j] + (从j到i的边的权值) | e = (j ,i) ∈ E}。对于图中有圈的情况，设d[s] = 0, d[i] = INF则可以在有限次数内算出新的d。只要不存在从s可达到的负圈，最多在|V| - 1次循环后for(;;)就会break，因此复杂度是O(|V| × |E|)。也就是说，若存在负圈，在第|V|次循环也会更新d值，可以利用这个性质检查是否存在负圈。

struct edge{
int from;
int to;
int cost;
};
edge es[max_e];
int d[max_v];
int v, e;
//从顶点s出发的单源最短路
void bellman_ford(int s)
{
for(int i = 0; i != v; ++i)
d[i] = INF;//无限大
d[s] = 0;
for(;;){
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;
}
}
//检查负圈，返回真为有
bool find_negative_loop(void)
{
memset(d, 0, sizeof(d));
for(int i = 0; i != v; ++i){
for(int j = 0; j != e; ++j){
edge e = es[j];
if(d[e.to] > d[e.from] + e.cost){
d[e.to] = d[e.from] + e.cost;
//第n次仍更新则存在负圈
if(i == v - 1)
return true;
}
}
}
return false;
}

2.Dijkstra求无负边的单源最短路

描述：①找到最短距离已经确定的顶点，从它出发更新相邻顶点的最短距离，此后不需要再关心“最短距离已经确定的顶点”。如何得到“最短距离已经确定的顶点”呢？在开始时，只有到起点的最短距离是确定的。在尚未使用过的顶点中，距离d[i]最小的顶点就是最短距离已经确定的顶点。下面给出时间复杂度为O(|V|²)使用邻接矩阵实现的Dijkstra算法。

template <typename t>
inline t min(t a, t b)
{
return a < b ? a : b;
}
int cost[max_v][max_v];//存权值的邻接矩阵
int d[max_v];//最短距离
bool used[max_v];//已经使用过的图
int v;//顶点数量
void Dijkstra(int s)
{
for(int i = 0; i != v; ++i)
d[i] = INF;
for(int i = 0; i != v; ++i)
used[i] = false;
d[s] = 0;
for(;;){
int v = -1;
//从未使用过的顶点中找出一个距离最小的顶点
for(int u = 0; u != v; ++u)
if(!used[u] && (v == -1 || d[u] < d[v]))
v = u;
if(-1 == v)
break;
for(int u = 0; u != v; ++u)
d[u] = min(d[u], d[v] + cost[v][u]);
}
}

当使用邻接表时，更新最短距离只需要访问每条边1次，因此这部分的复杂度是O(|E|)，但是查找顶点需要都枚举一次，最终复杂度还是平方级的。可以使用C++ STL的优先队列priority_queue来实现。在每次更新时往堆里插入当前最短距离和顶点的值对，当取出的最小值不是最短距离的话，就丢弃它。这样算法的复杂度优化到了O(|E|log|V|)。Dijkstra较Bellman-Ford效率更高，但无法应用于存在负边的图。

#include <queue>
#include <vector>
#include <utility>
struct edge{
int to;
int cost;
};
typedef std::pair<int, int> P;//first 最短距离, second 顶点编号
int v;
std::vector<edge> g[max_v];
int d[max_v];
void Dijkstra(int s)
{
std::priority_queue<P, std::vector<P>, std::greater<P> > que;
for(int i = 0; i != v; ++i)
d[i] = INF;
d[s] = 0;
que.push(P(0, s));
while(!que.empty()){
P p = que.top();
que.pop();
int v = p.second;
if(d[v] < p.first)
continue;
for(unsigned int i = 0; i != g[v].size(); ++i){
edge e = g[v][i];
if(d[e.to] > d[v] + e.cost){
d[e.to] = d[v] + e.cost;
que.push(P(d[e.to], e.to));
}
}
}
}

3.适用于在各种图中求任意两点间距离的Floyd-Warshall

代码极短，十分有效，不解释原理。同样可用于判断是否存在负圈：检查是否存在d[i][i]是负数。复杂度：O(|V|^3)。

template <typename t>
inline t min(t a, t b)
{
return a < b ? a : b;
}
int d[max_v][max_v];
int v;
void Floyd_Warshall(void)
{
for(int k = 0; k != v; ++k)
for(int i = 0; i != v; ++i)
for(int j = 0; j != v; ++j)
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}

三、最小生成树问题

1.用于邻接矩阵的Prim

假设有一颗只包含一个顶点v的树T，贪心地选取T和其他顶点之间相连的最小权值的边并把它加入到T中。不断进行这个操作就可以得到生成树了。下面给出的算法时间复杂度是O(|V|²)。

template <typename t>
inline t min(t a, t b)
{
return a < b ? a : b;
}
int cost[max_v][max_v];
int mincost[max_v];//从集合X出发的边到每个顶点的最小权
bool used[max_v] ;//顶点i是否包含在集合X中
int v;
int Prim(void)
{
for(int i = 0; i != v; ++i){
mincost[i] = INF;
used[i] = false;
}
mincost[0] = 0;
int res = 0;
for(;;){
int v = -1;
//从不属于集合X的顶点中选取从X到其权值最小的顶点
for(int u = 0; u != v; ++u)
if(!used[u] && (v == -1 || mincost[u] < mincost[v]))
v = u;
if(-1 == v)
break;
used[v] = true;//把顶点v加入集合X
res += mincost[v];//把边的长度加入结果
for(int u = 0; u != v; ++u)
mincost[u] = min(mincost[u], cost[v][u]);
}
return res;
}

2.用于邻接表的Kruskal

按照边的权值的顺序从小到大查看一遍（需要排序），若不产生圈或重边，就把这条边加入到生成树中。

如何判断是否产生圈：若要把连接u和v的边e加入到生成树中，只要加入之前u和v不在同一个连通分量里，加入e就不会产生圈，若在就一定会产生圈。引入并查集就可以做到，并查集的实现包含在代码包里。Kruskal最耗时的操作是对边的排序，时间复杂度：O(|E|log|V|)。

#include <algorithm>
#include "Union_Find.cpp"
struct edge{
int u, v, cost;
};
bool comp(const edge &a, const edge &b)
{
return a.cost < b.cost;
}
edge es[max_e];
int v, e;
int Kruskal(void)
{
std::sort(es, es + e, comp);
init(v);//初始化并查集
int res = 0;
for(int i = 0; i != e; ++i){
edge e = es[i];
if(!same(e.u, e.v)){
unite(e.u, e.v);
res += e.cost;
}
}
return res;
}