Code-CSDN-C++-圖
轉自
版權宣告：本文為博主原創文章，遵循 CC 4.0 BY-SA 版權協議，轉載請附上原文出處連結和本宣告。
本文連結：https://blog.csdn.net/weixin_62684026/article/details/128358023
Code
資料結構
鄰接表
namespace link_table
{
//建立邊的結構
template<class W>
struct Edge
{
//int _srci;這裡我們暫且不存源點的下標
int _dsti; // 目標點的下標
W _w; // 權值
Edge<W>* _next;//鄰接表的連結指標
Edge(int dsti, const W& w)
:_dsti(dsti)
, _w(w)
, _next(nullptr)
{}
};
template<class V, class W, bool Direction = false>
class Graph
{
typedef Edge<W> Edge;
public:
Graph(const V* a, size_t n)
{
_vertexs.reserve(n);
for (size_t i = 0; i < n; ++i)
{
_vertexs.push_back(a[i]);
_indexMap[a[i]] = i;
}
_tables.resize(n, nullptr);
}
size_t GetVertexIndex(const V& v)
{
auto it = _indexMap.find(v);
if (it != _indexMap.end())
{
return it->second;
}
else
{
//assert(false);
throw invalid_argument("頂點不存在");
return -1;
}
}
void AddEdge(const V& src, const V& dst, const W& w)
{
size_t srci = GetVertexIndex(src);
size_t dsti = GetVertexIndex(dst);
// 1->2
Edge* eg = new Edge(dsti, w);
//頭插法
eg->_next = _tables[srci];
_tables[srci] = eg;
// 2->1
// 如果是無向圖的話，新增反向的路徑
if (Direction == false)
{
Edge* eg = new Edge(srci, w);
eg->_next = _tables[dsti];
_tables[dsti] = eg;
}
}
void Print()
{
// 頂點
for (size_t i = 0; i < _vertexs.size(); ++i)
{
cout << "[" << i << "]" << "->" << _vertexs[i] << endl;
}
cout << endl;
for (size_t i = 0; i < _tables.size(); ++i)
{
cout << _vertexs[i] << "[" << i << "]->";
Edge* cur = _tables[i];
while (cur)
{
cout <<"["<<_vertexs[cur->_dsti] << ":" << cur->_dsti << ":"<<cur->_w<<"]->";
cur = cur->_next;
}
cout <<"[nullptr]"<<endl;
}
}
private:
vector<V> _vertexs; // 頂點集合
map<V, int> _indexMap; // 頂點對映下標
vector<Edge*> _tables; // 鄰接表
};
void TestGraph1()
{
/*Graph<char, int, true> g("0123", 4);
g.AddEdge('0', '1', 1);
g.AddEdge('0', '3', 4);
g.AddEdge('1', '3', 2);
g.AddEdge('1', '2', 9);
g.AddEdge('2', '3', 8);
g.AddEdge('2', '1', 5);
g.AddEdge('2', '0', 3);
g.AddEdge('3', '2', 6);
g.Print();*/
string a[] = { "張三", "李四", "王五", "趙六" };
Graph<string, int, true> g1(a, 4);
g1.AddEdge("張三", "李四", 100);
g1.AddEdge("張三", "王五", 200);
g1.AddEdge("王五", "趙六", 30);
g1.Print();
}
}
鄰接矩陣
#pragma once
#include <vector>
#include <map>
//V表示的事我們點中的資料型別
// weight代表權重
//Direction表示是有向圖還是無向圖
namespace matrix
{
//我們這裡預設是無向圖
template<class V,class W ,W MAX_W=INT_MAX, bool Direction =false>
class Graph
{
public:
//圖的建立
//1、IO輸入 --不方便測試,oj中更適合
//2、圖結構關係樣例寫到檔案裡，讀取檔案
//3.手動新增邊（首先我們建立頂點，手動新增邊）
Graph(const V*a,size_t n)
{
_vertex.reserve(n);
for(size_t i=0;i<n;++i)
{
_vertex.push_back(a[i]);
//透過頂點找下標
_indexmap[a[i]]=i;
}
_matrix.resize(n);
for(size_t i=0;i<_matrix.size();++i) {
//開闢n個大小，然後初始化每一個值都是MAX_W
_matrix[i].resize(n, MAX_W);
}
}
//確定頂點的下標
size_t GetVertexIndex(const V& v)
{
auto it=_indexmap.find(v);
//如果查詢到了就返回下標
if( it!=_indexmap.end())
{
return it->second;
}else
{
// assert(false);
throw invalid_argument("頂點不存在");
//防止編譯器檢查
return -1;
}
}
void AddEdge(const V& src,const V&dst,const W& w)
{
size_t srci= GetVertexIndex(src);
size_t dsti= GetVertexIndex(dst);
_matrix[srci][dsti]=w;
//如果是無向圖的話，我們需要新增雙向的
if(Direction== false)
{
_matrix[dsti][srci]=w;
}
}
void Print()
{
//將頂點列印出來
for(size_t i=0;i<_vertex.size();++i)
{
cout<<"["<<i<<"]"<<"->"<<_vertex[i]<<endl;
}
cout<<endl;
//矩陣
//將橫向的下標列印出來
cout<<" ";
for(size_t i=0;i<_vertex.size();++i)
{
cout<<i<<" ";
}
cout<<endl;
for(size_t i=0;i<_matrix.size();++i)
{
cout<<i<<" ";//將豎向的下標列印出來
for(size_t j=0;j<_matrix[i].size();++j)
{
// cout<<_matrix[i][j]<<" ";
if(_matrix[i][j]==MAX_W)
{
cout<<"* ";
}
else{
cout<<_matrix[i][j]<<" ";
}
}
cout<<endl;
}
}
private:
vector<V> _vertex;//頂點集合
map<V,int> _indexmap;//頂點對映下標
vector<vector<W>> _matrix; //鄰接矩陣
};
void TestGraph() {
Graph<char, int, INT_MAX, true> g("0123", 4);
g.AddEdge('0', '1', 1);
g.AddEdge('0', '3', 4);
g.AddEdge('1', '3', 2);
g.AddEdge('1', '2', 9);
g.AddEdge('2', '3', 8);
g.AddEdge('2', '1', 5);
g.AddEdge('2', '0', 3);
g.AddEdge('3', '2', 6);
g.Print();
}
}
遍歷
深度優先遍歷
void _DFS(size_t srci, vector<bool>& visited)
{
//訪問一個點，標記一個點
cout << srci << ":" << _vertex[srci] << endl;
visited[srci] = true;
// 找一個srci相鄰的沒有訪問過的點，去往深度遍歷
for (size_t i = 0; i < _vertex.size(); ++i)
{
if (_matrix[srci][i] != MAX_W && visited[i] == false)
{
_DFS(i, visited);
}
}
}
void DFS(const V& src)
{
//獲取傳入的源點的下標
size_t srci = GetVertexIndex(src);
//建立標記陣列
vector<bool> visited(_vertex.size(), false);
_DFS(srci, visited);
}
廣度優先遍歷
//傳入起點`
void BFS(const V& src)
{
//計算起點的下標
size_t srci = GetVertexIndex(src);
// 佇列和標記陣列
queue<int> q;
//建立一個標記陣列
vector<bool> visited(_vertex.size(), false);
//將起點加入佇列中
q.push(srci);
//標記起點
//只要入佇列了，我們就將其標記
visited[srci] = true;
size_t n = _vertex.size();
while (!q.empty())
{
//出隊頭的資料
int front = q.front();
q.pop();
cout << front <<":"<<_vertex[front] << endl;
// 把front頂點的鄰接頂點入佇列
for (size_t i = 0; i < n; ++i)
{
if (_matrix[front][i] != MAX_W)
{
//如果沒有被標記過，我們就將其入隊
if (visited[i] == false)
{
q.push(i);
visited[i] = true;
}
}
}
}
cout << endl;
}
最小生成樹
Kruskal演算法（克魯斯卡爾演算法）
//邊的定義，源點，目標點，權值
struct Edge
{
size_t _srci;
size_t _dsti;
W _w;
Edge(size_t srci, size_t dsti, const W& w)
:_srci(srci)
, _dsti(dsti)
, _w(w)
{}
bool operator>(const Edge& e) const
{
//比較權值的大小，過載我們的>運算子
return _w > e._w;
}
};
void AddEdge(const V& src, const V& dst, const W& w)
{
size_t srci = GetVertexIndex(src);
size_t dsti = GetVertexIndex(dst);
_AddEdge(srci, dsti, w);
}
void _AddEdge(size_t srci, size_t dsti, const W& w)
{
_matrix[srci][dsti] = w;
// 無向圖
if (Direction == false)
{
_matrix[dsti][srci] = w;
}
}
W Kruskal(Self& minTree)
{
size_t n = _vertex.size();
//建立我們的最小生成樹
minTree._vertex = _vertex;
minTree._indexmap = _indexmap;
//初始化我們最小生成樹的矩陣
minTree._matrix.resize(n);
for (size_t i = 0; i < n; ++i)
{
minTree._matrix[i].resize(n, MAX_W);
}
//用優先順序佇列，這裡我們需要讓小的優先順序高，也就是我們需要傳入greater
priority_queue<Edge, vector<Edge>, greater<Edge>> minque;
for (size_t i = 0; i < n; ++i)
{
for (size_t j = 0; j < n; ++j)
{
//將所有的邊都放入優先順序佇列中
//i<j是為了避免重複新增
if (i < j && _matrix[i][j] != MAX_W)
{
minque.push(Edge(i, j, _matrix[i][j]));
}
}
}
// 選出n-1條邊
int size = 0;
//總的權值
W totalW = W();
//建立一個並查集，並查集程式碼參考我們上面的部落格連結
UnionFindSet ufs(n);
while (!minque.empty())
{
Edge min = minque.top();
minque.pop();
//如果當前新增的邊的兩個頂點不在同一個集合中，也就是不相連的話，我們就可以新增這條邊
if (!ufs.InSet(min._srci, min._dsti))
{
cout << _vertex[min._srci] << "->" << _vertex[min._dsti] <<":"<<min._w << endl;
//往我們的最小生成樹中新增這條邊
minTree._AddEdge(min._srci, min._dsti, min._w);
//將這條邊新增到我們的並查集當中
ufs.Union(min._srci, min._dsti);
++size;
totalW += min._w;
}
else
{
cout << "構成環：";
cout << _vertex[min._srci] << "->" << _vertex[min._dsti] << ":" << min._w << endl;
}
}
//找到了最小生成樹
if (size == n - 1)
{
return totalW;
}
//如果沒有找到就返回權值
else
{
return W();
}
}
測試程式碼
void TestGraphMinTree()
{
const char* str = "abcdefghi";
Graph<char, int> g(str, strlen(str));
g.AddEdge('a', 'b', 4);
g.AddEdge('a', 'h', 8);
//g.AddEdge('a', 'h', 9);
g.AddEdge('b', 'c', 8);
g.AddEdge('b', 'h', 11);
g.AddEdge('c', 'i', 2);
g.AddEdge('c', 'f', 4);
g.AddEdge('c', 'd', 7);
g.AddEdge('d', 'f', 14);
g.AddEdge('d', 'e', 9);
g.AddEdge('e', 'f', 10);
g.AddEdge('f', 'g', 2);
g.AddEdge('g', 'h', 1);
g.AddEdge('g', 'i', 6);
g.AddEdge('h', 'i', 7);
Graph<char, int> kminTree;
cout << "Kruskal:" << g.Kruskal(kminTree) << endl;
kminTree.Print();
}
Prim演算法
//我們要選擇一個起點
W Prim(Self& minTree, const W& src)
{
//獲取這個起點的下標
size_t srci = GetVertexIndex(src);
size_t n = _vertex.size();
minTree._vertex = _vertex;
minTree._indexmap = _indexmap;
minTree._matrix.resize(n);
for (size_t i = 0; i < n; ++i)
{
minTree._matrix[i].resize(n, MAX_W);
}
//同兩個陣列，分別表示已經被最小生成樹選中的結點和沒有被最小生成樹選中的結點
vector<bool> X(n, false);
vector<bool> Y(n, true);
X[srci] = true;
Y[srci] = false;
// 從X->Y集合中連線的邊裡面選出最小的邊
priority_queue<Edge, vector<Edge>, greater<Edge>> minq;
// 先把srci連線的邊新增到佇列中
for (size_t i = 0; i < n; ++i)
{
if (_matrix[srci][i] != MAX_W)
{
//分別將起始點，指向的最終點和權值構成的邊放入佇列中
minq.push(Edge(srci, i, _matrix[srci][i]));
}
}
size_t size = 0;
W totalW = W();
while (!minq.empty())
{
Edge min = minq.top();
minq.pop();
// 最小邊的目標點也在X集合，則構成環
if (X[min._dsti])
{
//cout << "構成環:";
//cout << _vertexs[min._srci] << "->" << _vertexs[min._dsti] << ":" << min._w << endl;
}
else
{
//將這條邊新增到我們的最小生成樹當中
minTree._AddEdge(min._srci, min._dsti, min._w);
//cout << _vertexs[min._srci] << "->" << _vertexs[min._dsti] << ":" << min._w << endl;
//X中對應的點將其標記成true代表已經加入了x集合
X[min._dsti]= true;
//Y代表的是還沒有被連線的點，所以我們將我們這個已經被連線的點的位置標記成false
Y[min._dsti] = false;
++size;
totalW += min._w;
//如果選出了了n-1條邊，那麼我們選邊就已經結束了
if (size == n - 1)
break;
for (size_t i = 0; i < n; ++i)
{
//將當前邊的終點作為我們挑選下一條邊的起點，並且這條起點的終點不能在我們的X集合中
//然後將這些點重新放入我們的佇列中
if (_matrix[min._dsti][i] != MAX_W && Y[i])
{
minq.push(Edge(min._dsti, i, _matrix[min._dsti][i]));
}
}
}
}
//選到了n-1條邊就返回總的權重
if (size == n - 1)
{
return totalW;
}
else
{
return W();
}
}
測試程式碼
void TestGraphMinTree2()
{
const char* str = "abcdefghi";
Graph<char, int> g(str, strlen(str));
g.AddEdge('a', 'b', 4);
g.AddEdge('a', 'h', 8);
//g.AddEdge('a', 'h', 9);
g.AddEdge('b', 'c', 8);
g.AddEdge('b', 'h', 11);
g.AddEdge('c', 'i', 2);
g.AddEdge('c', 'f', 4);
g.AddEdge('c', 'd', 7);
g.AddEdge('d', 'f', 14);
g.AddEdge('d', 'e', 9);
g.AddEdge('e', 'f', 10);
g.AddEdge('f', 'g', 2);
g.AddEdge('g', 'h', 1);
g.AddEdge('g', 'i', 6);
g.AddEdge('h', 'i', 7);
Graph<char, int> pminTree;
cout << "Prim:" << g.Prim(pminTree, 'a') << endl;
pminTree.Print();
cout << endl;
}
最短路徑
Dijkstra演算法
//列印最短路徑
void PrintShortPath(const V& src, const vector<W>& dist, const vector<int>& pPath)
{
//獲取目標點的對應的索引
size_t srci = GetVertexIndex(src);
//獲取一共的點的個數
size_t n = _vertex.size();
for (size_t i = 0; i < n; ++i)
{
//如果i不是我們當前的源點，也就是需要排除自己走到自己的情況
if (i != srci)
{
// 找出i頂點的路徑
vector<int> path;
size_t parenti = i;
//如果父節點不是我們的源，我們就不斷向前查詢，並且將我們的路徑記錄到我們的path當中
while (parenti != srci)
{
path.push_back(parenti);
parenti = pPath[parenti];
}
path.push_back(srci);
//由於我們是從後向前尋找的，所以我們需要將我們的vector逆置一下
reverse(path.begin(), path.end());
for (auto index : path)
{
cout << _vertex[index] << "->";
}
cout << dist[i] << endl;
}
}
}
//傳入源點，
// 傳入儲存源點到其他各個點的最短路徑的權值和容器（例：點s到syzx的路徑）
//傳入每個節點的父路徑，也就是從我們的源節點到我們每一個節點的最短路徑的前一個節點的下標
void Dijkstra(const V& src, vector<W>& dist, vector<int>& pPath)
{
//源點的下標
size_t srci = GetVertexIndex(src);
//節點的數量
size_t n = _vertex.size();
//將所有的路徑初始化為無窮大
dist.resize(n, MAX_W);
//將路徑全部都初始化成-1，也就是沒有前一個結點（我們結點的下標從0開始）
pPath.resize(n, -1);
//自己結點到自己的距離就是0
dist[srci] = 0;
//自己到自己的最短路徑的前一個節點就是自己，所以前一個節點的下標也是自己
pPath[srci] = srci;
// 標記已經確定最短路徑的頂點集合，初始全部都是false，也就是全部都沒有被確定下來
vector<bool> S(n, false);
for (size_t j = 0; j < n; ++j)
{
// 選最短路徑頂點且不在S更新其他路徑
//最小的點為u，初始化為0
int u = 0;
//記錄到最小的點的權值
W min = MAX_W;
for (size_t i = 0; i < n; ++i)
{
//這個點沒有被選過，並且到這個點的權值比我們當前的最小值更小，我們就進行更新
if (S[i] == false && dist[i] < min)
{
//用u記錄這個最近的點的編號
u = i;
min = dist[i];
}
}
//標記當前點已經被選中了
S[u] = true;
// 鬆弛更新u連線頂點v srci->u + u->v < srci->v 更新
//確定u連結出去的所有點
for (size_t v = 0; v < n; ++v)
{
//如果v這個點沒有被標記過，也就是我們這個點還沒有被確定最短距離，並且從我們當前點u走到v的路徑是存在的
//並且從u走到v的總權值的和比之前源點到v的權值更小，我們就更新我們從源點到我們的v的最小權值
if (S[v] == false && _matrix[u][v] != MAX_W
&& dist[u] + _matrix[u][v] < dist[v])
{
//更新從源點到v的最小權值
dist[v] = dist[u] + _matrix[u][v];
//標記我們從源點到v的最小路徑要走到v這一步的前一個節點需要走u
pPath[v] = u;
}
}
}
}
測試程式碼
void TestGraphDijkstra()
{
const char* str = "syztx";
Graph<char, int, INT_MAX, true> g(str, strlen(str));
g.AddEdge('s', 't', 10);
g.AddEdge('s', 'y', 5);
g.AddEdge('y', 't', 3);
g.AddEdge('y', 'x', 9);
g.AddEdge('y', 'z', 2);
g.AddEdge('z', 's', 7);
g.AddEdge('z', 'x', 6);
g.AddEdge('t', 'y', 2);
g.AddEdge('t', 'x', 1);
g.AddEdge('x', 'z', 4);
vector<int> dist;
vector<int> parentPath;
g.Dijkstra('s', dist, parentPath);
g.PrintShortPath('s', dist, parentPath);
}
Bellman-Ford演算法（貝爾曼福特演算法）
// 時間複雜度：O(N^3) 空間複雜度：O（N）
bool BellmanFord(const V& src, vector<W>& dist, vector<int>& pPath)
{
//獲取我們點的總和數
size_t n = _vertex.size();
//獲取我們源點的索引
size_t srci = GetVertexIndex(src);
// vector<W> dist,記錄srci-其他頂點最短路徑權值陣列
dist.resize(n, MAX_W);
// vector<int> pPath 記錄srci-其他頂點最短路徑父頂點陣列
pPath.resize(n, -1);
// 先更新srci->srci為預設值
dist[srci] = W();
//cout << "更新邊：i->j" << endl;
// 總體最多更新n輪
//從s->t最多經過n條邊，否則就會變成迴路。
//每一條路徑的更新都可能會影響別的路徑
for (size_t k = 0; k < n; ++k)
{
// i->j 更新鬆弛
bool update = false;
cout << "更新第:" << k << "輪" << endl;
for (size_t i = 0; i < n; ++i)
{
for (size_t j = 0; j < n; ++j)
{
// srci -> i + i ->j
//如果i->j邊存在的話，並且srci -> i + i ->j比原來的距離更小，就更新該路徑
if (_matrix[i][j] != MAX_W && dist[i] + _matrix[i][j] < dist[j])
{
//這一輪有發生更新
update = true;
cout << _vertex[i] << "->" << _vertex[j] << ":" << _matrix[i][j] << endl;
dist[j] = dist[i] + _matrix[i][j];
//記錄當前點的前一個節點
pPath[j] = i;
}
}
}
// 如果這個輪次中沒有更新出更短路徑，那麼後續輪次就不需要再走了
if (update == false)
{
break;
}
}
// 還能更新就是帶負權迴路，具體的例子在下面
for (size_t i = 0; i < n; ++i)
{
for (size_t j = 0; j < n; ++j)
{
// srci -> i + i ->j
if (_matrix[i][j] != MAX_W && dist[i] + _matrix[i][j] < dist[j])
{
return false;
}
}
}
return true;
}
測試程式碼
void TestGraphBellmanFord()
{
const char* str = "syztx";
Graph<char, int, INT_MAX, true> g(str, strlen(str));
g.AddEdge('s', 't', 6);
g.AddEdge('s', 'y', 7);
g.AddEdge('y', 'z', 9);
g.AddEdge('y', 'x', -3);
g.AddEdge('z', 's', 2);
g.AddEdge('z', 'x', 7);
g.AddEdge('t', 'x', 5);
g.AddEdge('t', 'y', 8);
g.AddEdge('t', 'z', -4);
g.AddEdge('x', 't', -2);
vector<int> dist;
vector<int> parentPath;
g.BellmanFord('s', dist, parentPath);
g.PrintShortPath('s', dist, parentPath);
Floyd-Warshall演算法（弗洛伊德演算法）
void FloydWarshall(vector<vector<W>>& vvDist, vector<vector<int>>& vvpPath)
{
//獲取一共有多少個點
size_t n = _vertex.size();
vvDist.resize(n);
vvpPath.resize(n);
// 初始化權值和路徑矩陣
for (size_t i = 0; i < n; ++i)
{
//設定成最大值，表示不相通
vvDist[i].resize(n, MAX_W);
//設定成-1表示沒有父路徑
vvpPath[i].resize(n, -1);
}
// 直接相連的邊更新一下
for (size_t i = 0; i < n; ++i)
{
for (size_t j = 0; j < n; ++j)
{
if (_matrix[i][j] != MAX_W)
{
vvDist[i][j] = _matrix[i][j];
//連線的上一個點
vvpPath[i][j] = i;
}
//自己跟自己相連的話，就更新成0
if (i == j)
{
vvDist[i][j] = W();
}
}
}
//所有點都有可能成為別的路徑的中間點
// abcdef a {} f || b {} c
// 最短路徑的更新i-> {其他頂點} ->j
//這裡的k就是遍歷所有的點，假設i到j的路徑經過k這個點會不會比不經過k更短。
for (size_t k = 0; k < n; ++k)
{
for (size_t i = 0; i < n; ++i)
{
for (size_t j = 0; j < n; ++j)
{
// k 作為的中間點嘗試去更新i->j的路徑
if (vvDist[i][k] != MAX_W && vvDist[k][j] != MAX_W
//如果經過k點我們的路徑會變得更短
&& vvDist[i][k] + vvDist[k][j] < vvDist[i][j])
{
//更新i,j
vvDist[i][j] = vvDist[i][k] + vvDist[k][j];
// 找跟j相連的上一個鄰接頂點
// 如果k->j 直接相連，上一個點就是k，vvpPath[k][j]存就是k
// 如果k->j 沒有直接相連，比如說中間還經過了別的點 k->...->x->j，vvpPath[k][j]存就是x
//vvpPath[i][j]= vvpPath[k][j]代表想要走到j這個點之前還要先想辦法走到k這個點
vvpPath[i][j] = vvpPath[k][j];
}
}
}
// 列印權值和路徑矩陣觀察資料
for (size_t i = 0; i < n; ++i)
{
for (size_t j = 0; j < n; ++j)
{
if (vvDist[i][j] == MAX_W)
{
//cout << "*" << " ";
printf("%3c", '*');
}
else
{
//cout << vvDist[i][j] << " ";
printf("%3d", vvDist[i][j]);
}
}
cout << endl;
}
cout << endl;
for (size_t i = 0; i < n; ++i)
{
for (size_t j = 0; j < n; ++j)
{
//cout << vvParentPath[i][j] << " ";
printf("%3d", vvpPath[i][j]);
}
cout << endl;
}
cout << "=================================" << endl;
}
}
測試程式碼
void TestFloydWarShall()
{
const char* str = "12345";
Graph<char, int, INT_MAX, true> g(str, strlen(str));
g.AddEdge('1', '2', 3);
g.AddEdge('1', '3', 8);
g.AddEdge('1', '5', -4);
g.AddEdge('2', '4', 1);
g.AddEdge('2', '5', 7);
g.AddEdge('3', '2', 4);
g.AddEdge('4', '1', 2);
g.AddEdge('4', '3', -5);
g.AddEdge('5', '4', 6);
vector<vector<int>> vvDist;
vector<vector<int>> vvParentPath;
g.FloydWarshall(vvDist, vvParentPath);
// 列印任意兩點之間的最短路徑
for (size_t i = 0; i < strlen(str); ++i)
{
g.PrintShortPath(str[i], vvDist[i], vvParentPath[i]);
cout << endl;
}
}