主要介紹圖論的基礎、圖的兩種表示、圖的遍歷（深度和廣度）、一個點到另一點的路徑和最短路徑等。
原文訪問我的技術部落格番茄技術小棧-圖論
圖論基礎
圖論並不是研究圖畫。而是研究由節點和邊所構成的數學模型
圖論抽象模型
-
萬事開頭難，雖然看上去很複雜，但是慢慢學習深入之後會體會到他的魅力
-
很多資訊之間的聯絡都可以使用圖來表示。資料視覺化
圖可以表示的關係
- 交通運輸（每個節點是城市，邊是道路。點是航站樓，邊是航線）
- 社交網路（人 & 好友關係 電影 & 電影相似程度）
- 網際網路（域名 域名跳轉）
- 工作安排（先後程度）
- 腦區活動
- 程式狀態執行（自動機）
圖的分類：
- 無向圖（Undirected Graph）人和人認識就是邊，沒有方向
- 有向圖（Directed Graph）自動機轉移有方向
-
無向圖是一種特殊的有向圖
-
無權圖（邊:認識不認識：好友度）
-
有權圖（邊帶值：電影相似程度 & 路長）
圖的連通性：
三圖或者一圖
- 可以看做是三張圖。也可以視為一個。
- 圖不是完全連通的。
簡單圖（simple Graph）：
- 考慮最小生成樹，連通性，這兩種邊意義不大
- 簡單圖：不包含。
圖的表示
- 對於邊的表示採用什麼樣的資料結構：
鄰接矩陣
n個節點 就是一個n行n列的矩陣，無向圖對角線對稱：1表示連通。0表示沒通
有向圖的矩陣表示：
鄰接表：
對於每個頂點只表達與這個頂點相連線的資訊
- 每一行都是一個連結串列，存放了對這一行而言相連的節點。
- 也可以表示有向圖
優點：儲存空間小
具體問題具體分析
-
鄰接表適合表示稀疏圖 (Sparse Graph) 多少
-
鄰接矩陣適合表示稠密圖 (Dense Graph)邊多
- 每個電影和其他所有電影之間的相似度。不管相似大小都是連線的邊。所有的點之間都有邊。
-
稠密：邊的個數與能擁有的最大邊的個數對比。
-
如下圖就是一個稀疏圖：
- 稠密圖完全圖
程式碼實現
鄰接矩陣程式碼實現
// 稠密圖 - 鄰接矩陣
class DenseGraph{
private:
int n, m; // 節點數和邊數
bool directed; // 是否為有向圖
vector<vector<bool>> g; // 圖的具體資料
public:
// 建構函式
DenseGraph( int n , bool directed ){
assert( n >= 0 );
this->n = n;
this->m = 0; // 初始化沒有任何邊
this->directed = directed;
// g初始化為n*n的布林矩陣, 每一個g[i][j]均為false, 表示沒有任和邊
//g = vector<vector<bool>>(n, vector<bool>(n, false));
for (int i = 0; i < n; ++i) {
g.push_back(vector<bool>(n, false));
}
}
~DenseGraph(){ }
int V(){ return n;} // 返回節點個數
int E(){ return m;} // 返回邊的個數
// 向圖中新增一個邊，v和w表示一個頂點
void addEdge( int v , int w ){
assert( v >= 0 && v < n );
assert( w >= 0 && w < n );
if( hasEdge( v , w ) )
return;
g[v][w] = true;
if( !directed )
g[w][v] = true;
m ++;
}
// 驗證圖中是否有從v到w的邊
bool hasEdge( int v , int w ){
assert( v >= 0 && v < n );
assert( w >= 0 && w < n );
return g[v][w];
}
};
複製程式碼注意：
- addedge的時候已經去除了平行邊的概念。因為如果有邊之間return
- O(1)來判斷是否有邊
稀疏圖程式碼實現
// 稀疏圖 - 鄰接表
class SparseGraph{
private:
int n, m; // 節點數和邊數
bool directed; // 是否為有向圖
vector<vector<int>> g; // 圖的具體資料
public:
// 建構函式
SparseGraph( int n , bool directed ){
assert( n >= 0 );
this->n = n;
this->m = 0; // 初始化沒有任何邊
this->directed = directed;
// g初始化為n個空的vector, 表示每一個g[i]都為空, 即沒有任和邊
//g = vector<vector<int>>(n, vector<int>());
for (int i = 0; i < n; ++i) {
g.push_back(vector<int>());
}
}
~SparseGraph(){ }
int V(){ return n;} // 返回節點個數
int E(){ return m;} // 返回邊的個數
// 向圖中新增一個邊
void addEdge( int v, int w ){
assert( v >= 0 && v < n );
assert( w >= 0 && w < n );
g[v].push_back(w);
//處理自環邊
if( v != w && !directed )
g[w].push_back(v);
m ++;
}
// 驗證圖中是否有從v到w的邊
bool hasEdge( int v , int w ){
assert( v >= 0 && v < n );
assert( w >= 0 && w < n );
//使用鄰接表在判斷解決平行邊複雜度高
for( int i = 0 ; i < g[v].size() ; i ++ )
if( g[v][i] == w )
return true;
return false;
}
};
複製程式碼鄰接表取消平行邊複雜度度過大。
鄰接表的優勢
- 遍歷鄰邊 - 圖演算法中最常見的操作
- 遍歷鄰邊，鄰接表有優勢
相鄰點迭代器
稀疏圖的迭代器程式碼實現
// 鄰邊迭代器, 傳入一個圖和一個頂點,
// 迭代在這個圖中和這個頂點向連的所有頂點
class adjIterator{
private:
SparseGraph &G; // 圖G的引用
int v;
int index;
public:
// 建構函式
adjIterator(SparseGraph &graph, int v): G(graph){
this->v = v;
this->index = 0;
}
~adjIterator(){}
// 返回圖G中與頂點v相連線的第一個頂點
int begin(){
index = 0;
if( G.g[v].size() )
return G.g[v][index];
// 若沒有頂點和v相連線, 則返回-1
return -1;
}
// 返回圖G中與頂點v相連線的下一個頂點
int next(){
index ++;
if( index < G.g[v].size() )
return G.g[v][index];
// 若沒有頂點和v相連線, 則返回-1
return -1;
}
// 檢視是否已經迭代完了圖G中與頂點v相連線的所有頂點
bool end(){
return index >= G.g[v].size();
}
};
複製程式碼稠密圖的程式碼實現
// 鄰邊迭代器, 傳入一個圖和一個頂點,
// 迭代在這個圖中和這個頂點向連的所有頂點
class adjIterator{
private:
DenseGraph &G; // 圖G的引用
int v;
int index;
public:
// 建構函式
adjIterator(DenseGraph &graph, int v): G(graph){
assert( v >= 0 && v < G.n );
this->v = v;
this->index = -1; // 索引從-1開始, 因為每次遍歷都需要呼叫一次next()
}
~adjIterator(){}
// 返回圖G中與頂點v相連線的第一個頂點
int begin(){
// 索引從-1開始, 因為每次遍歷都需要呼叫一次next()
index = -1;
return next();
}
// 返回圖G中與頂點v相連線的下一個頂點
int next(){
// 從當前index開始向後搜尋, 直到找到一個g[v][index]為true
for( index += 1 ; index < G.V() ; index ++ )
if( G.g[v][index] )
return index;
// 若沒有頂點和v相連線, 則返回-1
return -1;
}
// 檢視是否已經迭代完了圖G中與頂點v相連線的所有頂點
bool end(){
return index >= G.V();
}
};
複製程式碼測試
#include <iostream>
#include "SparseGraph.h"
#include "DenseGraph.h"
using namespace std;
int main() {
int N = 20;
int M = 100;
srand( time(NULL) );
// Sparse Graph
SparseGraph g1(N , false);
for( int i = 0 ; i < M ; i ++ ){
int a = rand()%N;
int b = rand()%N;
g1.addEdge( a , b );
}
// O(E)
for( int v = 0 ; v < N ; v ++ ){
cout<<v<<" : ";
SparseGraph::adjIterator adj( g1 , v );
for( int w = adj.begin() ; !adj.end() ; w = adj.next() )
cout<<w<<" ";
cout<<endl;
}
cout<<endl;
// Dense Graph
DenseGraph g2(N , false);
for( int i = 0 ; i < M ; i ++ ){
int a = rand()%N;
int b = rand()%N;
g2.addEdge( a , b );
}
// O(V^2)
for( int v = 0 ; v < N ; v ++ ){
cout<<v<<" : ";
DenseGraph::adjIterator adj( g2 , v );
for( int w = adj.begin() ; !adj.end() ; w = adj.next() )
cout<<w<<" ";
cout<<endl;
}
return 0;
}
複製程式碼執行結果：
0 : 0 7 17 18 4 2 17 17 7 9 8
1 : 15 12 19 8 5 11 3 4 16 4
2 : 19 6 2 17 3 9 6 19 4 6 17 7 6 0
3 : 2 4 19 16 8 10 19 11 1 7 5 16 17
4 : 10 15 3 2 14 0 17 1 16 1
5 : 11 14 7 1 14 15 6 3 15
6 : 8 2 16 8 11 19 10 2 6 2 11 14 5 9 2 12 17
7 : 9 9 17 19 5 0 14 2 3 0 10
8 : 9 6 6 9 14 14 1 16 3 17 0
9 : 7 15 8 19 7 8 12 2 13 6 0
10 : 4 10 6 3 19 18 7
11 : 6 5 6 1 3
12 : 1 9 6
13 : 16 9 18
14 : 18 5 8 8 4 7 16 5 6 17
15 : 9 1 15 4 5 15 18 5
16 : 6 13 8 3 14 4 3 18 1
17 : 19 7 2 0 2 4 8 0 0 14 3 6
18 : 14 13 0 15 10 16 19 18
19 : 2 17 9 1 6 7 3 2 10 3 18
0 : 2 3 7 8 13 14 19
1 : 5 10 12 16 19
2 : 0 3 5 6 7 9 10 11 12 18
3 : 0 2 6 8 10 14 15 17 18 19
4 : 4 6 7 8 14 17 18 19
5 : 1 2 7 10 14 15 17 19
6 : 2 3 4 8 9 11 12 14
7 : 0 2 4 5 7 8 9 13 15 16 19
8 : 0 3 4 6 7 17 18 19
9 : 2 6 7 15 16
10 : 1 2 3 5 13 18
11 : 2 6 11 13 15 16 18 19
12 : 1 2 6
13 : 0 7 10 11 15 17 19
14 : 0 3 4 5 6
15 : 3 5 7 9 11 13 16
16 : 1 7 9 11 15 16 17
17 : 3 4 5 8 13 16 17
18 : 2 3 4 8 10 11 19
19 : 0 1 3 4 5 7 8 11 13 18
複製程式碼生成稠密圖和稀疏圖類封裝
template <typename Graph>
class ReadGraph{
public:
// 從檔案filename中讀取圖的資訊, 儲存進圖graph中
ReadGraph(Graph &graph, const string &filename){
ifstream file(filename);
string line;
int V, E;
assert( file.is_open() );
// 第一行讀取圖中的節點個數和邊的個數
assert( getline(file, line) );
stringstream ss(line);
ss>>V>>E;
assert( V == graph.V() );
// 讀取每一條邊的資訊
for( int i = 0 ; i < E ; i ++ ){
assert( getline(file, line) );
stringstream ss(line);
int a,b;
ss>>a>>b;
assert( a >= 0 && a < V );
assert( b >= 0 && b < V );
graph.addEdge( a , b );
}
}
};
複製程式碼深度優先遍歷和聯通分量
- 深度優先遍歷
- 廣度優先遍歷
思想：一個點往下試，記錄是否遍歷過（因為存在環）。
0-1-2-5-3-4-6
圖示為3個聯通分量
深度優先遍歷程式碼實現
遍歷完成後看沒遍歷過的點
// 求無權圖的聯通分量
template <typename Graph>
class Component{
private:
Graph &G; // 圖的引用
bool *visited; // 記錄dfs的過程中節點是否被訪問
int ccount; // 記錄聯通分量個數
int *id; // 每個節點所對應的聯通分量標記
// 圖的深度優先遍歷(遞迴方式)
void dfs( int v ){
visited[v] = true;
id[v] = ccount;
typename Graph::adjIterator adj(G, v);
for( int i = adj.begin() ; !adj.end() ; i = adj.next() ){
if( !visited[i] )
dfs(i);
}
}
public:
// 建構函式, 求出無權圖的聯通分量
Component(Graph &graph): G(graph){
// 演算法初始化
visited = new bool[G.V()];
id = new int[G.V()];
ccount = 0;
for( int i = 0 ; i < G.V() ; i ++ ){
visited[i] = false;
id[i] = -1;
}
// 求圖的聯通分量
for( int i = 0 ; i < G.V() ; i ++ )
if( !visited[i] ){
dfs(i);
ccount ++;
}
}
// 解構函式
~Component(){
delete[] visited;
delete[] id;
}
// 返回圖的聯通分量個數
int count(){
return ccount;
}
// 查詢點v和點w是否聯通
bool isConnected( int v , int w ){
assert( v >= 0 && v < G.V() );
assert( w >= 0 && w < G.V() );
return id[v] == id[w];
}
};
複製程式碼main.cpp
// 測試圖的聯通分量演算法
int main() {
// TestG1.txt
string filename1 = "testG1.txt";
SparseGraph g1 = SparseGraph(13, false);
ReadGraph<SparseGraph> readGraph1(g1, filename1);
Component<SparseGraph> component1(g1);
cout<<"TestG1.txt, Component Count: "<<component1.count()<<endl;
cout<<endl;
// TestG2.txt
string filename2 = "testG2.txt";
SparseGraph g2 = SparseGraph(7, false);
ReadGraph<SparseGraph> readGraph2(g2, filename2);
Component<SparseGraph> component2(g2);
cout<<"TestG2.txt, Component Count: "<<component2.count()<<endl;
return 0;
}
複製程式碼結果
TestG1.txt, Component Count: 3
TestG2.txt, Component Count: 1
複製程式碼** 注意**
- 求出連通分量，可以求出兩個結點是否相連
- 新增id來記錄。
int *id; // 每個節點所對應的聯通分量標記
複製程式碼- 並查集只能讓我們知道兩個結點是否相連。而路徑需要圖論來解決
尋路
深度優先獲得一條路徑。遍歷的同時儲存是從哪遍歷過來的。
int * from; // 記錄路徑, from[i]表示查詢的路徑上i的上一個節點
// 路徑查詢
template <typename Graph>
class Path{
private:
Graph &G; // 圖的引用
int s; // 起始點
bool* visited; // 記錄dfs的過程中節點是否被訪問
int * from; // 記錄路徑, from[i]表示查詢的路徑上i的上一個節點
// 圖的深度優先遍歷
void dfs( int v ){
visited[v] = true;
typename Graph::adjIterator adj(G, v);
for( int i = adj.begin() ; !adj.end() ; i = adj.next() ){
if( !visited[i] ){
from[i] = v;
dfs(i);
}
}
}
public:
// 建構函式, 尋路演算法, 尋找圖graph從s點到其他點的路徑
Path(Graph &graph, int s):G(graph){
// 演算法初始化
assert( s >= 0 && s < G.V() );
visited = new bool[G.V()];
from = new int[G.V()];
for( int i = 0 ; i < G.V() ; i ++ ){
visited[i] = false;
from[i] = -1;
}
this->s = s;
// 尋路演算法
dfs(s);
}
// 解構函式
~Path(){
delete [] visited;
delete [] from;
}
// 查詢從s點到w點是否有路徑
bool hasPath(int w){
assert( w >= 0 && w < G.V() );
return visited[w];
}
// 查詢從s點到w點的路徑, 存放在vec中
void path(int w, vector<int> &vec){
assert( hasPath(w) );
stack<int> s;
// 通過from陣列逆向查詢到從s到w的路徑, 存放到棧中
int p = w;
while( p != -1 ){
s.push(p);
p = from[p];
}
// 從棧中依次取出元素, 獲得順序的從s到w的路徑
vec.clear();
while( !s.empty() ){
vec.push_back( s.top() );
s.pop();
}
}
// 列印出從s點到w點的路徑
void showPath(int w){
assert( hasPath(w) );
vector<int> vec;
path( w , vec );
for( int i = 0 ; i < vec.size() ; i ++ ){
cout<<vec[i];
if( i == vec.size() - 1 )
cout<<endl;
else
cout<<" -> ";
}
}
};
複製程式碼main.cpp:
// 測試尋路演算法
int main() {
string filename = "testG.txt";
SparseGraph g = SparseGraph(7, false);
ReadGraph<SparseGraph> readGraph(g, filename);
g.show();
cout<<endl;
Path<SparseGraph> path(g,0);
cout<<"Path from 0 to 6 : " << endl;
path.showPath(6);
return 0;
}
複製程式碼執行結果：
vertex 0: 1 2 5 6
vertex 1: 0
vertex 2: 0
vertex 3: 4 5
vertex 4: 3 5 6
vertex 5: 0 3 4
vertex 6: 0 4
DFS : 0 -> 5 -> 3 -> 4 -> 6
[Finished in 1.2s]
複製程式碼複雜度：
- 稀疏圖（鄰接表）： O( V + E ), 想獲得一個節點的所有相鄰節點的時候，我們要將圖中所有節點掃一遍
- 稠密圖（鄰接矩陣）：O( V^2 )
注意:
- 深度優先遍歷演算法對有向圖依然有效
- 深度優先遍歷也可以用於判斷圖中是否有環。
圖的廣度優先遍歷
一般需要使用佇列使用佇列。
- 佇列為空表示遍歷完成
- 距離0節點的距離排序，先遍歷的節點距離<=後遍歷的節點距離
- 記錄距離並且用from陣列記錄來源節點可以求出最短路徑。
- 廣度優先遍歷：求出了無權圖的最短路徑。
程式碼實現：
// 尋找無權圖的最短路徑
template <typename Graph>
class ShortestPath{
private:
Graph &G; // 圖的引用
int s; // 起始點
bool *visited; // 記錄dfs的過程中節點是否被訪問
int *from; // 記錄路徑, from[i]表示查詢的路徑上i的上一個節點
int *ord; // 記錄路徑中節點的次序。ord[i]表示i節點在路徑中的次序；記錄最短路徑
public:
// 建構函式, 尋找無權圖graph從s點到其他點的最短路徑
ShortestPath(Graph &graph, int s):G(graph){
// 演算法初始化
assert( s >= 0 && s < graph.V() );
visited = new bool[graph.V()];
from = new int[graph.V()];
ord = new int[graph.V()];
for( int i = 0 ; i < graph.V() ; i ++ ){
visited[i] = false;
from[i] = -1;
ord[i] = -1;
}
this->s = s;
// 無向圖最短路徑演算法, 從s開始廣度優先遍歷整張圖
queue<int> q;
q.push( s );
visited[s] = true;
ord[s] = 0;
while( !q.empty() ){
int v = q.front();
q.pop();
typename Graph::adjIterator adj(G, v);
for( int i = adj.begin() ; !adj.end() ; i = adj.next() )
if( !visited[i] ){
q.push(i);
visited[i] = true;
from[i] = v;
ord[i] = ord[v] + 1;
}
}
}
// 解構函式
~ShortestPath(){
delete [] visited;
delete [] from;
delete [] ord;
}
// 查詢從s點到w點是否有路徑
bool hasPath(int w){
assert( w >= 0 && w < G.V() );
return visited[w];
}
// 查詢從s點到w點的路徑, 存放在vec中
void path(int w, vector<int> &vec){
assert( w >= 0 && w < G.V() );
stack<int> s;
// 通過from陣列逆向查詢到從s到w的路徑, 存放到棧中
int p = w;
while( p != -1 ){
s.push(p);
p = from[p];
}
// 從棧中依次取出元素, 獲得順序的從s到w的路徑
vec.clear();
while( !s.empty() ){
vec.push_back( s.top() );
s.pop();
}
}
// 列印出從s點到w點的路徑
void showPath(int w){
assert( w >= 0 && w < G.V() );
vector<int> vec;
path(w, vec);
for( int i = 0 ; i < vec.size() ; i ++ ){
cout<<vec[i];
if( i == vec.size()-1 )
cout<<endl;
else
cout<<" -> ";
}
}
// 檢視從s點到w點的最短路徑長度
int length(int w){
assert( w >= 0 && w < G.V() );
return ord[w];
}
};
複製程式碼main.cpp:
// 測試無權圖最短路徑演算法
int main() {
string filename = "testG.txt";
SparseGraph g = SparseGraph(7, false);
ReadGraph<SparseGraph> readGraph(g, filename);
g.show();
cout<<endl;
// 比較使用深度優先遍歷和廣度優先遍歷獲得路徑的不同
// 廣度優先遍歷獲得的是無權圖的最短路徑
Path<SparseGraph> dfs(g,0);
cout<<"DFS : ";
dfs.showPath(6);
ShortestPath<SparseGraph> bfs(g,0);
cout<<"BFS : ";
bfs.showPath(6);
return 0;
}
複製程式碼執行結果：
vertex 0: 1 2 5 6
vertex 1: 0
vertex 2: 0
vertex 3: 4 5
vertex 4: 3 5 6
vertex 5: 0 3 4
vertex 6: 0 4
DFS : 0 -> 5 -> 3 -> 4 -> 6
BFS : 0 -> 6
複製程式碼注意：
- 廣度優先一定可以找到最短無權路徑
- 廣度優先一定可以找到最短無權路徑並可能找到多條，深度也有可能找到。
- 多條最短路徑。跟遍歷順序有關。
-------------------------華麗的分割線--------------------
看完的朋友可以點個喜歡/關注，您的支援是對我最大的鼓勵。
想了解更多，歡迎關注我的微信公眾號：番茄技術小棧
