20、邻接矩阵：BFS实现拓扑排序

问题描述 :

目的：使用C++模板设计并逐步完善图的邻接矩阵抽象数据类型（ADT）。

内容：（1）请参照图的邻接矩阵模板类原型，设计并逐步完善图的邻接矩阵ADT。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。）

（2）设计并实现一个算法，基于广度优先搜索的思想，对于给定的有向图（网），实现拓扑排序。如排序成功，返回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;
    }

};
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.TopologicalSort();
    if (flag)
        cout << "true" << endl;
    else
        cout << "false" << endl;
    return 0;
}