离散数学实验2 关联矩阵、相邻矩阵、生成树、环路空间、断集空间的求解 C++

已于 2022-09-29 19:24:31 修改
阅读量2.2k 收藏 31
点赞数 3
分类专栏： 离散数学图论 文章标签： c++ 矩阵 图论
于 2022-06-04 16:54:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51502608/article/details/125123209
版权

离散数学实验报告2

文章目录

一、实验题目

实验题目：关联矩阵、相邻矩阵、生成树、环路空间、断集空间的求解

实验时间: 2021.12.16

二、实验目的

  1. 掌握无向连通图生成树的求解方法；

  2. 掌握基本回路系统和环路空间的求解方法；

  3. 掌握基本割集系统和断集空间的求解方法；

  4. 了解生成树、环路空间和断集空间的实际应用。

三、实验要求

  1. 给定无向简单连通图的相邻矩阵 例如:[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MPyNdYqm-1654332805884)(/Users/a26012/Desktop/截屏2021-12-23 15.02.35.png)]。
  2. 输出此图的关联矩阵M。
  3. 求此图所有生成树个数。
  4. 输出其中任意一颗生成树的相邻矩阵（默认第i行对应顶点vi）和关联矩阵（默认第i行对应顶点vi，第j列对应边ej）。
  5. 求此生成树对应的基本回路系统（输出形式如：{e1e4e3,e2e5e3}）。
  6. 求此生成树对应的环路空间（输出形式如：{Φ,e1e4e3,e2e5e3,e1e4e5e2})。
  7. 求此生成树对应的基本割集系统（输出形式如：{{e1,e4},{e2,e5},{e3,e4,e5}})。
  8. 求此生成树对应的断集空间（输出形式如：{Φ, {e1,e4}, {e2,e5}, {e3,e4,e5}, {e1,e2,e4,e5}, {e1,e3,e5}, {e2,e3,e4}, {e1,e2,e3}})。

四、实验步骤和内容

需求分析：

给定相邻矩阵，求关联矩阵，生成树个数，输出其中任意一颗生成树的相邻矩阵和关联矩阵。

求此生成树对应的基本回路系统，环路空间

求此生成树对应的基本割集系统，断集空间

输入形式与输入范围

预设输入点范围 : 0 < n < 999 0<n<999 0<n<999

邻接矩阵的边数： 0 < m < 99 9 2 0<m<999^2 0<m<9992

输入形式: 相邻矩阵 如：

0 1 1 0 1
1 0 1 0 1
1 1 0 1 0
0 0 1 0 1
1 1 0 1 0

输出：

示例：

0 1 1 0 1
1 0 1 0 1
1 1 0 1 0
0 0 1 0 1
1 1 0 1 0

  e1 e2 e3 e4 e5 e6 e7 
v1 1  1  1  0  0  0  0  
v2 1  0  0  1  1  0  0  
v3 0  1  0  1  0  1  0  
v4 0  0  0  0  0  1  1  
v5 0  0  1  0  1  0  1  

生成树的个数为：24

它的一棵树为：
   V1 V2 V3 V4 V5 
V1  0  1  1  0  1 
V2  1  0  0  0  0 
V3  1  0  0  1  0 
V4  0  0  1  0  0 
V5  1  0  0  0  0 

  e1 e2 e3 e4 
v1 1  1  1  0  
v2 1  0  0  0  
v3 0  1  0  1  
v4 0  0  0  1  
v5 0  0  1  0  

基本回路系统:{e4e2e1, e5e3e1, e7e3e2e6, }
环路空间:{ Φ,e1e2e4,e1e3e5,e2e3e6e7,e2e3e4e5,e1e3e4e6e7,e1e2e5e6e7,e4e5e6e7,}

基本割集系统:{e4e5e1,e4e5e7e2,e4e5e7e3,e4e5e7e6,}
断集空间{ Φ,e1e4e5,e2e4e5e7,e3e4e5e7,e4e5e6e7,e1e2e7,e1e3e7,e1e6e7,e2e3,e2e6,e3e6,e1e2e3e4e5,e1e2e4e5e6,e1e3e4e5e6,e2e3e4e5e6e7,e1e2e3e6e7,}

概要设计：

使用的数据结构与算法：

关联矩阵、相邻矩阵、广度优先遍历、深度优先遍历、矩阵树定理(Matrix-Tree 定理)求生成树个数、分治思想

程序流程：
  1. 读入相邻矩阵
  2. 根据相邻矩阵，求出邻接矩阵sq2，基尔霍夫矩阵K。
  3. 输出邻接矩阵
  4. 根据基尔霍夫矩阵和矩阵树定理求出生成树个数gauss( )。
  5. printTree( )函数中用广度优先遍历求出生成树，xl为树的相邻矩阵 ，gl为树的邻接矩阵
  6. 求基本回路系统和环路空间printSystem()。求基本回路系统方法：枚举每一条弦，如果把它加到树中，就会有且只有一条回路，该回路就是一条基本回路。求环路空间方法，深度优先搜索，枚举所有情况，进行对称差运算。
  7. 求基本割集系统，断集空间printSystem2()。求基本割集系统：枚举每一条树枝，找到该树枝对应的边割集，该割集就是一个基本割集。求断集空间方法，同上，深度优先搜索，枚举所有情况，进行对称差运算。

详细代码

#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <sstream>
#include <vector>
#include <queue>
using namespace std;
int sq[1000][1000];    //相邻矩阵
int sq2[1000][10000],edx=0,eedx=0;   //邻接矩阵
int edge[1000][1000];    //边编号
int c[1000][1000];
int xl[1000][1000];    //树的相邻矩阵
int gl[1000][1000];   //树的邻接矩阵
bool st[1000];     //是否遍历到
int wsz[1000];  //方便计算对称差
int K[1000][1000];  //生成树个数
vector<vector<int>> baseC;   //基本回路系统
vector<vector<int>> baseG;   //基本割集系统
int sz=0;
const int MOD = 0x3f3f3f3f;
int gauss(int n) {//求矩阵K的n-1阶顺序主子式
    int res = 1;
    for (int i = 1; i <= n - 1; i++) {//枚举主对角线上第i个元素
        for (int j = i + 1; j <= n - 1; j++) {//枚举剩下的行
            while (K[j][i]) {//辗转相除
                int t = K[i][i] / K[j][i];
                for (int k = i; k <= n - 1; k++)//转为倒三角
                    K[i][k] = (K[i][k] - t * K[j][k] + MOD) % MOD;
                swap(K[i], K[j]);//交换i、j两行
                res = -res;//取负
            }
        }
        res = (res * K[i][i]) % MOD;
    }
    return (res + MOD) % MOD;
}


void print_sq(){
    cout<<"  ";
    for(int i=1;i<=edx;i++){
        cout<<"e"<<i<<" ";
    }
    cout<<endl;
    for(int i=1;i<=sz;i++){
        cout<<"v"<<i<<" ";
        for(int j=1;j<=edx;j++){
            if(sq2[i][j]) cout<<1;
            else cout<<0;
            cout<<"  ";
        }
        cout<<endl;
    }
}

void printTree(){
    bool st[1000];

    memset(xl,0,sizeof xl);
    memset(st,0,sizeof st);
    memset(gl,0,sizeof gl);
    queue<int> Q;
    Q.push(1);
    st[1]= true;
    while(!Q.empty()){
        int nw=Q.front();
        Q.pop();
        for(int i=1;i<=sz;i++){
            if(!st[i]&&sq[nw][i]){
                xl[nw][i]=xl[i][nw]=1;
                Q.push(i);
                st[i]= true;
            }
        }
    }

    cout<<"\n它的一棵树为：\n";
    printf("   ");
    for(int i=1;i<=sz;i++){
        printf("V%d ",i);
    }
    cout<<endl;
    for(int i=1;i<=sz;i++){
        printf("V%d ",i);
        for(int j=1;j<=sz;j++){
            printf(" %d ",xl[i][j]);
        }
        cout<<endl;
    }
    cout<<endl;
    edx=0;
    for(int i=1;i<=sz;i++){
        for(int j=i+1;j<=sz;j++){
            if(xl[i][j]){
                ++edx;
                gl[i][edx]=gl[j][edx]=1;
            }
        }
    }
    cout<<"  ";
    for(int i=1;i<=edx;i++){
        cout<<"e"<<i<<" ";
    }
    cout<<endl;
    for(int i=1;i<=sz;i++){
        cout<<"v"<<i<<" ";
        for(int j=1;j<=edx;j++){
            if(gl[i][j]) cout<<1;
            else cout<<0;
            cout<<"  ";
        }
        cout<<endl;
    }
}
void bfs(int x,int y){
    queue<int> Q;
    vector<int> tmp;
    bool st[1000];
    int fa[1000];
    memset(fa,0,sizeof fa);
    memset(st,0,sizeof st);

    Q.push(x);
    st[x]= true;
    fa[x]=-1;
    tmp.push_back(edge[x][y]);
    while(!Q.empty()){
        int nw=Q.front();
        Q.pop();
        for(int i=1;i<=sz;i++){
            if(!st[i]&&xl[nw][i]){
                xl[nw][i]=xl[i][nw]=1;
                Q.push(i);
                fa[i]=nw;
                st[i]= true;
            }
        }
        if(st[y]) break;
    }

    int nw=y;
    while(nw!=x){
        tmp.push_back(edge[nw][fa[nw]]);
        cout<<"e"<<edge[nw][fa[nw]];
        nw=fa[nw];
    }
    baseC.push_back(tmp);
}
void dfs(int nub,int idx,int type){      //枚举对称差
    if(nub==0){
        for(int i=1;i<=eedx;i++){
            if(wsz[i]%2)
                cout<<"e"<<i;
        }
        cout<<",";
        return;
    }
    if(idx==baseC.size()&&type==1) return;
    if(idx==baseG.size()&&type!=1) return;
    if(type==1){
        for(int j=0;j< baseC[idx].size() ;j++)  wsz[ baseC[idx][j] ]++;
        dfs(nub-1,idx+1,1);    //选第idx个基本回路
        for(int j=0;j<baseC[idx].size();j++)  wsz[baseC[idx][j]]--;

        dfs(nub,idx+1,1);
    }else{
        for(int j=0;j<baseG[idx].size();j++)  wsz[baseG[idx][j]]++;
        dfs(nub-1,idx+1,2);
        for(int j=0;j<baseG[idx].size();j++)  wsz[baseG[idx][j]]--;
        dfs(nub,idx+1,2);
    }
}
void printSystem(){
    int base=0;

    cout<<"\n基本回路系统:{";
    for(int i=1;i<=sz;i++){
        for(int j=i+1;j<=sz;j++){
            if(sq[i][j]&&!xl[i][j]){
                cout<<"e"<<edge[i][j];

                bfs(i,j); //2 4 / 3 4
                cout<<", ";
                base++;
            }
        }
    }
    memset(wsz,0,sizeof wsz);
    cout<<"}\n环路空间:{ Φ,";
    for(int i=1;i<=baseC.size();i++){
        dfs(i,0,1);
    }
    cout<<"}\n";
}
void gogo(int x){
    if(st[x]) return;
    st[x]= true;
    for(int i=1;i<=sz;i++){
        if(sq[x][i]) gogo(i);
    }
}
vector<int> tmp;
bool wzy(int n){
    if(n==0){
        for(int i=0;i<=sz;i++) st[i]=0;
        gogo(1);
        for(int i=1;i<=sz;i++)
            if(!st[i]){
                baseG.push_back(tmp);
                return true;
            }
        return false;
    }
    for(int i=1;i<=sz;i++){
        for(int j=i+1;j<=sz;j++){
            if(sq[i][j]&&!xl[i][j]){
                sq[i][j]=sq[j][i]=0;
                tmp.push_back(edge[i][j]);
                bool rt=wzy(n-1);
                tmp.pop_back();
                sq[i][j]=sq[j][i]=1;
                return rt;
            }
        }
    }
}
void printSystem2(){
    int base=0;
    cout<<"\n基本割集系统:{";
    for(int i=1;i<=sz;i++){
        for(int j=i+1;j<=sz;j++){
            if(xl[i][j]){
                sq[j][i]=sq[i][j]=0;
                tmp.clear();
                for(int k=1;;k++){
                    if(wzy(k)){
                        break;
                    }
                }
                baseG[baseG.size()-1].push_back(edge[i][j]);
                sq[j][i]=sq[i][j]=1;
            }
        }
    }
    for(int i=0;i<baseG.size();i++){
        for(int j=0;j<baseG[i].size();j++){
            cout<<"e"<<baseG[i][j];
        }
        cout<<",";
    }
    cout<<"}\n断集空间{ Φ,";
    memset(wsz,0,sizeof wsz);
    for(int i=1;i<=baseG.size();i++){
        dfs(i,0,2);
    }
    cout<<"}\n";
}
int main() {

    string str;
    getline(cin,str);
    while(str!="\0"){
        stringstream ss(str);
        sz++;
        for(int j=1;!ss.eof();j++){
            ss>>sq[sz][j];
        }
        getline(cin,str);
    }
    for(int i=1;i<=sz;i++){
        for(int j=i+1;j<=sz;j++){
            if(sq[i][j]){
                ++edx;
                ++eedx;
                edge[i][j]=edge[j][i]=edx;
                sq2[i][edx]=sq2[j][edx]=1;
                K[i][i]++;
                K[j][j]++;
                K[i][j]--;
                K[j][i]--;
            }
        }
    }
    print_sq();
    cout<<endl<<"生成树的个数为："<<gauss(sz)<<endl;
    if(!gauss(sz)) return 0;
    printTree();
    printSystem();
    printSystem2();
    return 0;
}

调试分析

调试过程中所遇到的问题及解决方法

一切正常

算法的时空分析

求邻接矩阵，基尔霍夫矩阵，求生成树 O ( n 2 ) O(n^2) O(n2)

Matrix-Tree 定理(求矩阵行列式) O ( n 4 ) O(n^4) O(n4)

基本回路系统 O ( n 3 ) O(n^3) O(n3)

基本割集系统 O ( n 4 ) O(n^4) O(n4)

求断集空间，环路空间 O ( 2 n ) O(2^n) O(2n)

五、实验结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Q7ioy7pe-1654332805884)(/Users/a26012/Desktop/截屏2021-12-23 15.34.55.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-X0JRu0BA-1654332805885)(/Users/a26012/Desktop/截屏2021-12-23 15.35.15.png)]

六、实验总结

心得体会：

  • 对无向连通图生成树的求解方法，基本回路系统和环路空间的求解方法，基本割集系统和断集空间的求解方法有了更深的理解，了解生成树、环路空间和断集空间的实际应用。很好的锻炼了代码能力，吸收了许多教训，学到了编程中的许多知识，非常有用。
  • 可能是因为这个实验比较难，有一些同学借鉴了我的代码。
-meteor-
关注
  • 3
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构实验：用邻接矩阵存储，并按Prim算法求最小生成树
10-10
根据书P262习题3给定的无向带权图，用邻接矩阵作为存储结构，用prim算法构造其最小生成树。 对图G(V,E)设置集合S，存放已访问的顶点，然后每次从集合V-S中选择与集合S的最短距离最小的一个顶点(记为u)，访问并加入...
离散数学·图的矩阵表示、平面图
qq_61786525的博客
11-04 5044
内含练习，可供复习
离散数学Ⅱ-生成树、环路空间、断集空间的求解
zzf_521的博客
12-22 2491
实验目的： 掌握无向连通图生成树的求解方法； 掌握基本回路系统和环路空间的求解方法； 掌握基本割集系统和断集空间的求解方法； 了解生成树、环路空间和断集空间的实际应用。 实验要求 1.给定一无向简单连通图的相邻矩阵 2.输出此图的关联矩阵M。 3.求此图所有生成树的个数。 4.输出其中任意一颗生成树的相邻矩阵（默认第i行对应顶点vi）和关联矩阵（默认第i行对应顶点vi，第j列对应边ej）。 5.求此生成树对应的基本回路系统（输出形式如：{e1e4e3,e2e5e3}）。 .
图 网络 关联矩阵
正在格式化……
10-10 5422
下面就是一个简单的图（在离散数学中称之为“图”），图有两个元素：结点(nodes)，边(edges)。 在实际应用中，可以给边加上箭头来表示电流的流向，这就是一个有向图： 然后我们可以定义一个关联矩阵(Incidence Matrices)，这个矩阵的描述如下：列代表结点，行代表边。如果从结点a到结点b有一条边（箭尾是a，箭头是b），那么就把a置为-1，把b置为1,。根据这个准
图的一些基本知识：关联矩阵、拉普拉斯矩阵
luzaijiaoxia0618的博客
03-08 3万+
目录前言关联矩阵（Incidence Matrix）拉普拉斯矩阵（Laplacian）参考文献 前言       本文介绍了一些图论的基础知识，包括图的关联矩阵、拉普拉斯矩阵，本文中某些图片或者知识的参考/来源已列于本文最后。 关联矩阵（Incidence Matrix）       关联矩阵是n×m的矩阵，n为顶点数量，m为边数量。 &...
离散数学·环路空间、断集空间、根树
qq_61786525的博客
10-20 1116
内含习题，可供练习
离散数学实验报告——根据矩阵的乘法求复合关系
07-31
将二元关系用关系矩阵表示。通过两个关系矩阵对应行列元素先进行逻辑乘，后进行逻辑加生成新的关系矩阵中的每一个元素。新的关系矩阵所对应的二元关系就是两个二元关系复合形成的，编程实现这一复合过程。
空间权重矩阵（地级市、省级四种空间权重矩阵）
05-16
空间权重矩阵（地级市、省级四种空间权重矩阵），31个省市的邻接矩阵、经济地理矩阵、非对称经济地理矩阵（八类矩阵）
离散数学实验报告——图的可达矩阵实现
07-31
将图形中的边表达成二元关系，计算该二元关系的传递闭包，并将传递闭包表达成关系矩阵。该关系矩阵就是图形的可达矩阵，编程实现求可达矩阵的过程。
SY20143080378 蔡永翔 第二次作业_关联矩阵_一个树_
09-28
计算机编程实现：自动生成给定某一线性时不变（不含受控源）的关联矩阵A，一个树
12图、网络、关联矩阵
m0_56898461的博客
01-14 2855
图、网络、关联矩阵
蓝桥杯算法训练—关联矩阵
brilliantZC的博客
01-20 1401
　　这题首先要明白关联矩阵是怎么一回事。关联矩阵是用结点与支路的关系描述有向图的拓扑性质。一条支路连接某两个结点，则称该支路与这两个结点相关联。支路与结点的关联性质可以用关联矩阵描述。设有向图的结点数为 n,支路数为 b,且所有结点与支路均加以编号。于是，该有向图的关联矩阵为一个（n*b）阶的矩阵，用Aij 表示。它的每一行对应一个结点，每一列对应一条支路，它的任一元素 aij定义如下： a...
邻接矩阵、可达性矩阵、完全关联矩阵、可达性矩阵的计算
最新发布
qq_51216031的博客
01-10 1601
注意：对于无向图来说，只需要考虑边和点之间有没有关系，有关系即为1，没有关系即为0；但是对于有向图来说，点与边之间的关系还有起点和终点之分。起点为1，终点为-1.完全关联矩阵：描述点与边的关系，如果该点和该边有关系为1，没有关系就为0，非常简单。邻接矩阵：很简单，就是两个点有关系就是1，没有关系就是0。可达性矩阵：非常简单，两点之间有路为1，没有路为0。
OUC离散数学II实验二（Python+Cpp）
安小白的博客
12-21 2282
OUC离散数学II实验二，有Python和Cpp两个版本
【集合论】关系表示 ( 关系矩阵 | 关系矩阵示例 | 关系矩阵性质 | 关系矩阵运算 | 关系图 | 关系图示例 | 关系表示相关性质 )
热门推荐
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
10-03 3万+
一、关系矩阵 、 二、关系矩阵示例 、 三、关系矩阵性质 、 四、关系矩阵运算 、 五、关系图 、 六、关系图示例 、 七、关系表示相关性质 、
离散数学——环路空间&断集空间（超详细！！超简单！！）
m0_74028782的博客
12-25 683
推论2：m-n+1得到的是G的断集。（2）G的两个回路环和以后==>得到的是G的环路。
离散数学-图论-图的矩阵表示（12.1）
weixin_57038791的博客
01-19 1970
定义：设无向图G=,V={$v_1,v_2,···,v_n$},E={$e_1,e_2,···,e_m$},令$m_{ij}$为顶点$v_i$与边$e_j$的关联次数，则称$(m_{ij})_{n×m}$为G的关联矩阵，记作M(G)。 例如： 无向图的关联矩阵为
关联矩阵
weixin_44076848的博客
01-31 8400
flag 蓝桥杯第26天 题目介绍 问题描述 　　有一个n个结点m条边的有向图，请输出他的关联矩阵。 输入格式 　　第一行两个整数n、m，表示图中结点和边的数目。n<=100,m<=1000。 　　接下来m行，每行两个整数a、b，表示图中有(a,b)边。 　　注意图中可能含有重边，但不会有自环。 输出格式 　　输出该图的关联矩阵，注意请勿改变边和结点的顺序。 样例输入 5 9 1 2 ...
离散数学之矩阵关系运算
Soul__man的博客
04-07 7823
矩阵关系运算前提: (1)第一个矩阵的列数等于第二个矩阵的行数。 (2)两个矩阵的元素均是0或1。 例如:A关系运算B得到C 原理：C11=(A11∧B11)∨(A12∧B21) C12=(A11∧B12)∨(A12∧B22)...... 就是把矩阵乘法中各个元素的乘法变成合取，原来乘法之后进行的相加改为合取后的析取。 #include<iostream> using namespace std; const int N=105; int A[N][N],B[N][N].
2.动态规划法求解矩阵链式相乘问题c++语言
09-22
具体而言，我们可以使用一个循环来遍历矩阵链的长度，从2到n，其中n表示矩阵链的长度。在每个循环中，我们再使用一个循环来遍历所有可能的起点，从1到n-length+1。 在每个起点位置，我们可以将矩阵链分成两部分，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值