邻接矩阵：有向无权图的判定

nameofworld

已于 2024-04-27 18:54:12 修改

阅读量983

点赞数

分类专栏：我的dhu记录数据结构与算法学习文章标签：大数据 c++ 数据结构图论算法

于 2022-07-02 16:27:03 首次发布

本文链接：https://blog.csdn.net/nameofworld/article/details/125574333

版权

我的dhu记录同时被 2 个专栏收录

90 篇文章 8 订阅

订阅专栏

数据结构与算法学习

29 篇文章 0 订阅

订阅专栏

邻接矩阵：有向无环图（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

这道题像是前面构造邻接矩阵和前一道题邻接表：BFS实现拓扑排序的结合版，只需要在上一道题基础上Graph结构体里面加上一个用来存邻接矩阵的二维数组，然后输出时把输出邻接表改成输出输出邻接矩阵，然后在TopoSort函数里把原来输出拓扑排序的句子去掉就可以了。

AC代码如下：

#include<iostream>
#include<queue>
#include<algorithm>
#include<cstring>
#include<vector>
using namespace std;
int flag = 0,flag2=0,x=0;
int cun[1000][3] = {0};
int am,teshu=0;
template<class TypeOfEdge>
struct Edge
{
    int vex;
    TypeOfEdge weight;
    struct Edge* next=NULL;

};
template<class TypeOfVer,class TypeOfEdge>
struct Ver
{
    string ver;
    Edge<TypeOfEdge>* next=NULL;
} ;
template<class TypeOfVer,class TypeOfEdge>
struct Graph
{
    Ver<TypeOfVer,TypeOfEdge> AdjList[100];
    int vnum;
    int edge[100][100];
    int bnum;
    void ADDUDN(Graph<TypeOfVer,TypeOfEdge> &G);
    void creatUDN(Graph<TypeOfVer,TypeOfEdge> &G);
    void creatDG(Graph<TypeOfVer,TypeOfEdge> &G);
    //void creatDN(Graph<TypeOfVer,TypeOfEdge> &G);
    //void creatUDG(Graph<TypeOfVer,TypeOfEdge> &G);
    int findvex(Graph<TypeOfVer,TypeOfEdge> *G,string v);
    void changeDG(Graph<TypeOfVer,TypeOfEdge> &G,int am);
    void changeUDG(Graph<TypeOfVer,TypeOfEdge> &G,int am);
    int TopoSort(Graph<TypeOfVer,TypeOfEdge> &G,int topo[]);
    void findindegree(Graph<TypeOfVer,TypeOfEdge> &G,int indegree[]);
} ;
template<class TypeOfVer,class TypeOfEdge>
void Graph<TypeOfVer,TypeOfEdge>:: ADDUDN(Graph& G)
{
    for (int j = 0; j < G.bnum; j++)
    {
        int temp = 0;
        cin >> temp;
        int qian= cun[j][0];
        int hou = cun[j][1];
        Edge<TypeOfEdge> * pa;
        Edge<TypeOfEdge>* ph;
        pa = G.AdjList[qian].next;
        ph = G.AdjList[hou].next;
        while (pa)
        {
            if (pa->vex == hou)
            {
                pa->weight = temp;
            }
            pa = pa->next;
        }
        while (ph)
        {
            if (ph->vex == qian)
            {
                ph->weight = temp;
            }
            ph = ph->next;
        }
    }
}
template<class TypeOfVer,class TypeOfEdge>
void Graph<TypeOfVer,TypeOfEdge>::creatUDN(Graph &G)
{
    cin >>G.vnum ;
    for (int i = 0; i <G.vnum; i++)
    {
        cin >> G.AdjList[i].ver;
    }
    cin >> G.bnum;
    for (int i = 0; i < G.bnum; i++)
    {
        int x1;
        int x2;
        cin >> x1 >> x2;
        cun[i][0] = x1;
        cun[i][1] = x2;
        Edge<TypeOfEdge>* pa = new Edge<TypeOfEdge>;
        pa->vex = x2;
        pa->next= G.AdjList[x1].next ;
        G.AdjList[x1].next = pa;
        Edge<TypeOfEdge>* pb = new Edge<TypeOfEdge>;
        pb->vex = x1;
        pb->next= G.AdjList[x2].next ;
        G.AdjList[x2].next = pb;
    }
    //ADDUDN(G);
}
template<class TypeOfVer,class TypeOfEdge>
void Graph<TypeOfVer,TypeOfEdge>::creatDG(Graph &G)
{
    cin >> G.vnum;
    for (int i = 0; i < G.vnum; i++)
    {
        cin >> G.AdjList[i].ver;
    }
    cin >> G.bnum;
    for(int i=0;i<G.vnum;i++)
    {
        for(int j=0;j<G.vnum;j++)
        {
            G.edge[i][j]=0;
        }
    }
    for (int i = 0; i < G.bnum; i++)
    {
        int x1;
        int x2;
        cin >> x1 >> x2;
        G.edge[x1][x2]=1;
        cun[i][0] = x1;
        cun[i][1] = x2;
        Edge<TypeOfEdge>* pa = new Edge<TypeOfEdge>;
        pa->vex = x2;
        pa->next=G.AdjList[x1].next;
        G.AdjList[x1].next = pa;
    }
}
template<class TypeOfVer,class TypeOfEdge>
int Graph<TypeOfVer,TypeOfEdge>::findvex(Graph *G,string v)
{
    int i;
    for(i=0; i<G->vnum; i++)
    {
        if(v==G->AdjList[i].ver)
        {
            return i;
        }
    }
    return -1;
}
template<class TypeOfVer,class TypeOfEdge>
void Graph<TypeOfVer,TypeOfEdge>::findindegree(Graph &G,int indegree[])
{
    Edge<TypeOfEdge> *p;
    for(int i=0; i<G.vnum; i++)
    {
        p=G.AdjList[i].next;
        while(p!=NULL)
        {
            indegree[p->vex]++;
            p=p->next;
        }
    }
}
template<class TypeOfVer,class TypeOfEdge>
class SqQueue
{
private:
    TypeOfVer *elem;   // 存储空间基址
    int front;   // 队头指针
    int rear;   // 队尾指针
    //int maxSize;        // 允许的最大存储容量(以sizeof(ElemType)为单位
public:
    //初始化顺序队列
    SqQueue()
    {
        elem=new TypeOfVer[100];
        front=rear=0;
    }
    int jindui(SqQueue<TypeOfVer,TypeOfEdge>&Q,TypeOfVer e)
    {
        Q.elem[Q.rear]=e;
        Q.rear=(Q.rear+1)%100;
        return 1;
    }
    TypeOfVer chudui(SqQueue &Q,TypeOfEdge &e)
    {
        e=Q.elem[Q.front];
        Q.front=(Q.front+1)%100;
        return e;
    }
    TypeOfVer GetTop(SqQueue &Q)
    {
        return Q.elem[Q.front];
    }
    bool empty(SqQueue Q)
    {
        if(Q.front!=Q.rear)return 0;
        else return 1;
    }
};
template<class TypeOfVer,class TypeOfEdge>
int Graph<TypeOfVer,TypeOfEdge>::TopoSort(Graph &G,int hb[])
{
    x=0;
    int indegree[100]= {0};
    findindegree(G,indegree);
    SqQueue<char,int>Q;
    int i;
    for( i=0; i<G.vnum; i++)
    {
        if(!indegree[i])Q.jindui(Q,i);
    }
    int dd=0;
    while(!Q.empty(Q))
    {
        Q.chudui(Q,i);
        hb[dd]=i;
        dd++;
        Edge<TypeOfEdge> *p;
        p=G.AdjList[i].next;
        while(p!=NULL)
        {
            int k=p->vex;
            indegree[k]--;
            if(indegree[k]==0)Q.jindui(Q,k);
            p=p->next;
        }
    }
    /*for(int j=0; j<dd; j++)
    {
        if(x)cout<<"->";
        x=1;
        cout<<G.AdjList[hb[j]].ver;
        if(j==dd-1)cout<<endl;
    }*/
    if(dd<G.vnum)return 0;
    else  return 1;
}
int main()
{
    string kind;
    cin >> kind;
    int hb[100];
    Graph<char,int> G;
    if (kind == "DG")//
    {
        G.creatDG(G);
        for (int w = 0; w < G.vnum; w++)
        {
            if (flag == 1)
            {
                cout << " ";
            }
            flag = 1;
            cout << G.AdjList[w].ver;
        }
        cout << endl<<endl;
        for (int m = 0; m < G.vnum; m++)
        {
            for(int n=0;n<G.vnum;n++)
            {
                cout<<G.edge[m][n]<<" ";
            }
            cout<<endl;
        }
        cout<<endl;
        if(G.TopoSort(G,hb))
        {
            cout<<"true";
        }
        else cout<<"false";
    }

    else if (kind == "UDG")//
    {
        G.creatUDN(G);
        for (int w = 0; w < G.vnum; w++)
        {
            if (flag == 1)
            {
                cout << " ";
            }
            flag = 1;
            cout << G.AdjList[w].ver;
        }
        cout << endl;
        for (int m = 0; m < G.vnum; m++)
        {
            for(int n=0;n<G.vnum;n++)
            {
                cout<<G.edge[m][n]<<" ";
            }
            cout<<endl;
        }
        cout<<endl;
        if(G.TopoSort(G,hb))
        {
            cout<<"true";
        }
        else cout<<"false";
    }
    return 0;
}

nameofworld

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
邻接矩阵：有向无权图的判定

邻接矩阵：有向无环图（DAG）的判断作者:冯向阳时间限制:1S章节:DS:图这道题像是前面构造邻接矩阵和前一道题邻接表：BFS实现拓扑排序的结合版，只需要在上一道题基础上Graph结构体里面加上一个用来存邻接矩阵的二维数组，然后输出时把输出邻接表改成输出输出邻接矩阵，然后在TopoSort函数里把原来输出拓扑排序的句子去掉就可以了。AC代码...
复制链接

扫一扫