34 邻接矩阵：有向无环图（DAG）的判断
作者: 冯向阳时间限制: 1S章节: DS:图
截止日期: 2022-06-30 23:55:00
问题描述 :
目的：使用C++模板设计并逐步完善图的邻接矩阵抽象数据类型（ADT）。
内容：（1）请参照图的邻接矩阵模板类原型，设计并逐步完善图的邻接矩阵ADT。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。）
（2）设计并实现一个算法，对于给定的有向图（网），判断其是否是有向无环图（DAG）。如是（不存在回路），返回true；否则返回false。图的存储结构采用邻接矩阵。将其加入到ADT中。
注意：DG（有向图）, DN（有向网）, UDG（无向图）, UDN（无向网）
提示：检测回路（有向环）的一种方法是对有向图构造它的拓扑有序序列。如果通过拓扑排序能将该图的所有顶点都排入一个拓扑有序的序列中, 则该图中必定不会出现回路（有向环）。
参考函数原型：
//有向图判断回路
template<class TypeOfVer, class TypeOfEdge>
bool adjmatrix_graph<TypeOfVer, TypeOfEdge>::isDAG();
图的邻接矩阵模板类原型参考如下：
template <class TypeOfVer, class TypeOfEdge>
class adjmatrix_graph{
private:
int Vers; //顶点数
int Edges; //边数
TypeOfEdge **edge; //存放邻接矩阵（TypeOfEdge表示顶点关系类型。对于无权图，用1或0，表示相邻否；对于带权图，则为权值类型）
TypeOfVer *ver; //存放结点值
TypeOfEdge noEdge; //邻接矩阵中的∞的表示值
string GraphKind; //图的种类标志
bool DFS(int u, int &num, int visited[]); //DFS遍历（递归部分）
bool CheckRoute(int u, int v, int visited[]); //检查两个结点之间是否有路径存在（递归部分）
public:
adjmatrix_graph( const string &kd, int vSize, const TypeOfVer d[], const TypeOfEdge noEdgeFlag); //构造函数构造一个只有结点没有边的图。4个参数的含义：图的类型、结点数、结点值和邻接矩阵中表示结点间没有边的标记（无权图：0，有权图：输入参数定）
adjmatrix_graph( const string &kd, int vSize, int eSize, const TypeOfVer d[], int **e); //构造函数构造一个无权图。5个参数的含义：图的类型、结点数、边数、结点集和边集
adjmatrix_graph( const string &kd, int vSize, int eSize, const TypeOfEdge noEdgeFlag, const TypeOfVer d[], int **e, const TypeOfEdge w[]); //构造函数构造一个有权图。7个参数的含义：图的类型、结点数、边数、无边标记、结点集、边集、权集
bool GraphisEmpty() { return Vers == 0; } //判断图空否
string GetGraphKind(){ return GraphKind; }
bool GetVer(int u, TypeOfVer &data); //取得G中指定顶点的值
int GetFirstAdjVex(int u, int &v); //返回G中指定顶点u的第一个邻接顶点的位序（顶点集）。若顶点在G中没有邻接顶点，则返回-1
int GetNextAdjVex(int u, int v, int &w); //返回G中指定顶点u的下一个邻接顶点（相对于v）的位序（顶点集）。若顶点在G中没有邻接顶点，则返回-1
bool PutVer(int u, TypeOfVer data); //对G中指定顶点赋值
bool InsertVer(const TypeOfVer &data); //往G中添加一个顶点
int LocateVer(TypeOfVer data); //返回G中指定顶点的位置
bool ExistEdge(int u, int v); //检查指定2个顶点是否是邻接顶点
bool PrintMatrix(); //输出邻接矩阵
int GetVerNum(){ return Vers;} //取得当前顶点数
int GetEdgeNum(){ return Edges;} //取得当前边数
int Get_Degree(int u); //求指定顶点的（出）度（无向图/网：度； 有向图/网：出度 ）
int Get_InDegree(int u); //求有向图指定顶点的入度
bool Insert_Edge(int u, int v); //无权图插入一条边
bool Insert_Edge(int u, int v, TypeOfEdge w); //有权图插入一条边
bool DeleteVer(const TypeOfVer &data); //往G中删除一个顶点
bool Delete_Edge(int u, int v); //无权图删除一条边
bool Delete_Edge(int u, int v, TypeOfEdge w); //有权图删除一条边
void DFS_Traverse(int u); //DFS遍历（外壳部分）
void BFS_Traverse(int u); //BFS遍历
bool CheckRoute(int u, int v); //检查两个结点之间是否有路径存在（外壳部分）
bool TopSort(); //拓扑排序（不带输出）
bool TopSort(int &num, int topsort[]); //拓扑排序（带输出）
bool isDAG(); //有向图判断回路
~adjmatrix_graph(); //析构函数
};
输入说明 :
建图的输入数据格式参见建图的算法说明。（以有向图为例）
第一行：图的类型
第二行：结点数
第三行：结点集
第四行：边数
第五行：边集
输出说明 :
第一行：顶点集
空行
第二行：邻接矩阵
空行
第三行：true（是DAG）/false（不是DAG）
输入范例 :
DG
4
A B C D
4
0 1
0 2
2 3
3 1
----------------
A B C D
0 1 1 0
0 0 0 0
0 0 0 1
0 1 0 0
true
------------------------
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string>
#include <vector>
#include <queue>
#include <sstream>
#include <stack>
#include <map>
#include <ctime>
#include <array>
#include <set>
using namespace std;
template <class TypeOfVer, class TypeOfEdge>
class adjmatrix_graph {
private:
int Vers;
int Edges;
vector<vector<TypeOfEdge> >edge;
TypeOfEdge noEdge;
vector<TypeOfVer> ver;
string GraphKind;
bool have_dir = false, have_w = false;
vector<TypeOfVer> dfs_lis;
vector<bool> vis_lis;
bool DFS(int t)
{
int i, j;
vis_lis[t] = true;
dfs_lis.push_back(ver[t]);
for (i = 0; i < Vers; i++)
if (edge[t][i] != noEdge)
if (vis_lis[i] == false)
DFS(i);
return 1;
}
public:
adjmatrix_graph()
{
Vers = 0;
Edges = 0;
edge.clear();
ver.clear();
noEdge = 0;
}
~adjmatrix_graph()
{
;
}
bool Auto_input(bool need_emp)
{
cin >> GraphKind;
cin >> Vers;
ver.resize(Vers);
for (int i = 0; i < Vers; i++)
cin >> ver[i];
if (need_emp || GraphKind == "DN")
cin >> noEdge;
vector<TypeOfEdge> line;
for (int j = 0; j < Vers; j++)
{
for (int i = 0; i < Vers; i++)
line.push_back(noEdge);
edge.push_back(line);
}
cin >> Edges;
vector<int> x_p, y_p, w_p;
for (int i = 0; i < Edges; i++)
{
int c_x, c_y;
cin >> c_x >> c_y;
x_p.push_back(c_x);
y_p.push_back(c_y);
}
if (GraphKind == "DG")
have_dir = true, have_w = false;
if (GraphKind == "DN")
have_dir = true, have_w = true;
if (GraphKind == "UDG")
have_dir = false, have_w = false;
if (GraphKind == "UDN")
have_dir = false, have_w = true;
if (have_w)
for (int i = 0; i < Edges; i++)
{
int c_w;
cin >> c_w;
w_p.push_back(c_w);
}
for (int i = 0; i < Edges; i++)
{
if (have_dir == false)
{
if (have_w == true)
edge[x_p[i]][y_p[i]] = edge[y_p[i]][x_p[i]] = w_p[i];
else
edge[x_p[i]][y_p[i]] = edge[y_p[i]][x_p[i]] = 1;
}
else
{
if (have_w == true)
edge[x_p[i]][y_p[i]] = w_p[i];
else
edge[x_p[i]][y_p[i]] = 1;
}
}
return 1;
}
bool PrintMatrix()
{
int i, j;
for (i = 0; i < Vers; i++)
{
for (j = 0; j < Vers - 1; j++)
cout << edge[i][j] << " ";
cout << edge[i][j] << " ";
cout << endl;
}
return 1;
}
bool GraphisEmpty(void)
{
return Vers == 0;
}
string GetGraphKind(void)
{
return GraphKind;
}
vector<TypeOfVer> GetGraph_Point(void)
{
return ver;
}
bool InsertVer(const TypeOfVer& data)
{
ver.push_back(data);
vector<TypeOfEdge> line;
for (int j = 0; j < Vers; j++)
{
edge[j].push_back(noEdge);
}
for (int j = 0; j <= Vers; j++)
{
line.push_back(noEdge);
}
edge.push_back(line);
Vers++;
return 1;
}
int LocateVer(TypeOfVer data)
{
int i = 0;
for (i = 0; i < ver.size(); i++)
if (ver[i] == data)
return i;
return -1;
}
bool Delete_Point(const TypeOfVer& data)
{
int i, j;
for (i = 0; i < Vers; i++)
if (ver[i] == data)
{
ver.erase(ver.begin() + i);
break;
}
if (i == Vers)
return 0;
Vers--;
edge.erase(edge.begin() + i);
for (j = 0; j < Vers; j++)
edge[j].erase(edge[j].begin() + i);
return 1;
}
int GetEdgeNum(void)
{
return Edges;
}
int GetVerNum()
{
return Vers;
}
bool Delete_Edge(int u, int v)
{
if (have_dir == true)
if (edge[u][v] != noEdge)
{
edge[u][v] = noEdge;
Edges--;
return true;
}
else
return false;
else
{
if (edge[u][v] != noEdge && edge[v][u] != noEdge)
{
edge[u][v] = noEdge;
edge[v][u] = noEdge;
Edges--;
return true;
}
else
return false;
}
return false;
}
int search_PointIn(int p)
{
if (have_dir == false)
return -1;
if (p < 0 || p >= Vers)
return -1;
int i, ans = 0;
for (i = 0; i < Vers; i++)
if (edge[i][p] != noEdge)
ans++;
return ans;
}
int search_PointOut(int p)
{
if (p < 0 || p >= Vers)
return -1;
int i, ans = 0;
for (i = 0; i < Vers; i++)
if (edge[p][i] != noEdge)
ans++;
return ans;
}
bool Look_adjacent(int u, int v)
{
if (u < 0 || u >= Vers)
return false;
if (v < 0 || v >= Vers)
return false;
if (u == v)
return false;
if (edge[u][v] != noEdge)
return true;
else
return false;
}
int Look_firstPoint(int p)
{
if (p < 0 || p >= Vers)
return -1;
for (int i = 0; i < Vers; i++)
if (edge[p][i] != noEdge)
return i;
return -1;
}
int Look_nextPoint(int u, int v)
{
if (u < 0 || u >= Vers)
return -1;
if (v < 0 || v >= Vers)
return -1;
for (int i = v + 1; i < Vers; i++)
if (edge[u][i] != noEdge)
return i;
return -1;
}
vector<TypeOfVer> DFS_Traverse(int star)
{
dfs_lis.clear();
vis_lis.clear();
for (int i = 0; i < Vers; i++)
vis_lis.push_back(false);
DFS(star);
return dfs_lis;
}
vector<TypeOfVer> BFS_Traverse(int star)
{
vector<TypeOfVer> bfs_lis;
bfs_lis.clear();
vis_lis.clear();
for (int i = 0; i < Vers; i++)
vis_lis.push_back(false);
queue<int> Q;
Q.push(star);
vis_lis[star] = true;
bfs_lis.push_back(ver[star]);
int now;
while (!Q.empty())
{
now = Q.front();
Q.pop();
for (int i = 0; i < Vers; i++)
if (edge[now][i] != noEdge)
if (vis_lis[i] == false)
{
bfs_lis.push_back(ver[i]);
vis_lis[i] = true;
Q.push(i);
}
}
return bfs_lis;
}
bool search_way(int star, int v)
{
vis_lis.clear();
for (int i = 0; i < Vers; i++)
vis_lis.push_back(false);
queue<int> Q;
Q.push(star);
vis_lis[star] = true;
int now;
while (!Q.empty())
{
now = Q.front();
Q.pop();
if (now == v)
return true;
for (int i = 0; i < Vers; i++)
if (edge[now][i] != noEdge)
if (vis_lis[i] == false)
{
vis_lis[i] = true;
Q.push(i);
}
}
return false;
}
bool TopologicalSort(void)
{
if (Edges == 0)
return 0;
int i, j;
vector<int> indegree;
indegree.clear();
//------
for (i = 0; i < Vers; i++)
indegree.push_back(search_PointIn(i));
queue<int> S;
for (i = 0; i < indegree.size(); i++)
if (indegree[i] == 0)
S.push(i);
vector<int> sort_list;
while (!S.empty())
{
int now;
now = S.front();
S.pop();
sort_list.push_back(now);
int next_p;
next_p = Look_firstPoint(now);
while (next_p != -1)
{
--indegree[next_p];
if (indegree[next_p] == 0)
S.push(next_p);
next_p = Look_nextPoint(now, next_p);
}
}
if (sort_list.size() == 0)
return 0;
//------
for (i = 0; i < sort_list.size() - 1; i++)
cout << ver[sort_list[i]] << "->";
cout << ver[sort_list[i]] << endl;
//------
if (sort_list.size() < Vers)
return 0;
return 1;
}
bool Check_DAG(void)
{
if (Edges == 0)
return 0;
int i, j;
vector<int> indegree;
indegree.clear();
for (i = 0; i < Vers; i++)
indegree.push_back(search_PointIn(i));
queue<int> S;
for (i = 0; i < indegree.size(); i++)
if (indegree[i] == 0)
S.push(i);
//------
vector<int> sort_list;
while (!S.empty())
{
int now;
now = S.front();
S.pop();
sort_list.push_back(now);
int next_p;
next_p = Look_firstPoint(now);
while (next_p != -1)
{
--indegree[next_p];
if (indegree[next_p] == 0)
S.push(next_p);
next_p = Look_nextPoint(now, next_p);
}
}
if (sort_list.size() < Vers)
return 0;
return 1;
}
};
int main()
{
int i;
string s;
for (int m = 0; m < 100; m++)
{
int ii;
ii++;
ii--;
int e = 0;
e++;
e = e + ii;
ii = e - ii;
}
adjmatrix_graph<string, int> a;
a.Auto_input(0);
vector<string> ans;
ans = a.GetGraph_Point();
for (i = 0; i < ans.size() - 1; i++)
cout << ans[i] << " ";
cout << ans[i] << endl;
//-------------------------------
cout << endl;
a.PrintMatrix();
cout << endl;
bool flag = a.Check_DAG();
if (flag)
cout << "true" << endl;
else
cout << "false" << endl;
return 0;
}
4004
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
