问题描述 :
目的:使用C++模板设计并逐步完善图的邻接矩阵抽象数据类型(ADT)。
内容:
(1)请参照图的邻接矩阵模板类原型,设计并逐步完善图的邻接矩阵ADT。(由于该环境目前仅支持单文件的编译,故将所有内容都集中在一个源文件内。在实际的设计中,推荐将抽象类及对应的派生类分别放在单独的头文件中。)
(2)设计并实现一个算法,对于给定的有向图(网),判断其是否是有向无环图(DAG)。如是(不存在回路),返回true;否则返回false。图的存储结构采用邻接矩阵。将其加入到ADT中。
注意:DG(有向图), DN(有向网), UDG(无向图), UDN(无向网)
提示:检测回路(有向环)的一种方法是对有向图构造它的拓扑有序序列。如果通过拓扑排序能将该图的所有顶点都排入一个拓扑有序的序列中, 则该图中必定不会出现回路(有向环)。
解题代码:
#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; //边数
//存放邻接矩阵(TypeOfEdge表示顶点关系类型。对于无权图,用1或0,表示相邻否;对于带权图,则为权值类型)
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;
//DFS遍历(递归部分)
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()
{
;
}
//全自动输入 true is need 无边标记
bool Auto_input(bool need_emp)//true is need 无边标记
{
//DG(有向图), DN(有向网), UDG(无向图), UDN(无向网)
/*第一行:图的类型 DN UDN
第二行:结点数
第三行:结点集
第四行:无边标记
第五行:边数
第六行:边集
第七行:权集*/
/*第一行:图的类型 DG UDG
第二行:结点数
第三行:结点集
第四行:边数
第五行:边集*/
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")//DG(有向图)
have_dir = true, have_w = false;
if (GraphKind == "DN")//DN(有向网)
have_dir = true, have_w = true;
if (GraphKind == "UDG")//UDG(无向图)
have_dir = false, have_w = false;
if (GraphKind == "UDN")//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;
}
//往G中添加一个顶点
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;
}
//返回G中指定顶点的位置
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;
}
//取得G中指定顶点的入度
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;
}
//取得G中指定顶点的出度
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;
}
//拓扑排序并判断有无回路 0 有 1 无
bool TopologicalSort(void)
{
if (Edges == 0)
return 0;
int i, j;
//将各个顶点的入度存在indegree
vector<int> indegree;
indegree.clear();
//------
for (i = 0; i < Vers; i++)
indegree.push_back(search_PointIn(i));
//------
//入度为0,进栈。
queue<int> S;
//------
for (i = 0; i < indegree.size(); i++)
if (indegree[i] == 0)
S.push(i);
//------
vector<int> sort_list;//the way of sort
//BFS
while (!S.empty())
{
int now;
now = S.front();
S.pop();
sort_list.push_back(now);
int next_p;
next_p = Look_firstPoint(now);//获取now的第一个相邻的点
while (next_p != -1)
{
--indegree[next_p];
if (indegree[next_p] == 0)
S.push(next_p);
/*if (indegree[next_p] == -1)
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;
}
//判断有无DAG 1 yes 0 no
bool Check_DAG(void)
{
if (Edges == 0)
return 0;
int i, j;
//将各个顶点的入度存在indegree
vector<int> indegree;
indegree.clear();
//------
for (i = 0; i < Vers; i++)
indegree.push_back(search_PointIn(i));
//------
//入度为0,进栈。
queue<int> S;
//------
for (i = 0; i < indegree.size(); i++)
if (indegree[i] == 0)
S.push(i);
//------
vector<int> sort_list;//the way of sort
//BFS
while (!S.empty())
{
int now;
now = S.front();
S.pop();
sort_list.push_back(now);
int next_p;
next_p = Look_firstPoint(now);//获取now的第一个相邻的点
while (next_p != -1)
{
--indegree[next_p];
if (indegree[next_p] == 0)
S.push(next_p);
/*if (indegree[next_p] == -1)
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;
adjmatrix_graph<string, int> a;
a.Auto_input(0);
//cout << a.GetGraphKind() << endl;//输出类型
//输出顶点集----------------------
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;
}