基础图论问题算法总结
这里介绍了图论中常见算法的原理和实现，所有代码已打包，此处可以下载。
一、邻接表存图
用邻接矩阵表示稀疏图会浪费大量内存空间。而在邻接表中是通过把类似于“从顶点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;
- }