离散数学实验二

最新推荐文章于 2023-06-03 21:17:26 发布
最新推荐文章于 2023-06-03 21:17:26 发布
阅读量3.1k 收藏 32
点赞数 4
分类专栏： 离散数学 文章标签： 图论 算法 矩阵 离散数学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huzimu_/article/details/122900744
版权

实验题目：生成树、环路空间、断集空间的求解

实验目的：

1、掌握无向连通图生成树的求解方法；
2、掌握基本回路系统和环路空间的求解方法；
3、掌握基本割集系统和断集空间的求解方法；
4、了解生成树、环路空间和断集空间的实际应用。

实验要求：

1、给定一无向简单连通图的相邻矩阵（例如：）。
例如

2、输出此图的关联矩阵M。
3、求此图所有生成树的个数。
4、输出其中任意一颗生成树的相邻矩阵（默认第i行对应顶点vi）和关联矩阵（默认第i行对应顶点vi，第j列对应边ej）。
5、求此生成树对应的基本回路系统（输出形式如：{e1e4e3,e2e5e3}）。
6、求此生成树对应的基本割集系统（输出形式如：{{e1,e4},{e2,e5},{e3,e4,e5}}）。
*加分题：
7、求此生成树对应的环路空间（输出形式如：{,e1e4e3,e2e5e3,e1e4e5e2}）。
8、求此生成树对应的断集空间（输出形式如：{,{e1,e4},{e2,e5},{e3,e4,e5},{e1,e2,e4,e5},{e1,e3,e5},{e2,e3,e4},{e1,e2,e3}}）。

相关思路

  1. 求生成树的个数：这里借助关联矩阵M先得到 n - 1 阶行列式，然后根据该行列式是否满秩，若满秩，则相应的边构成生成树；
  2. 基本回路系统：对于一个特定的生成树，每一个弦都对应一个基本回路，取一个弦加入树枝集合，然后在这个集合中找出对应的回路集合；
  3. 基本割集系统：对于一个特定的生成树，每个树枝都对应一个基本割集，取一个树枝加入弦集合，去掉这个集合中所有的边之后的图必然是不连通的，但是，割集需要满足极小性，所以还需要根据弦添加后图是否连通去除冗余的弦，如果加入这个弦之后图仍不连通，说明这个弦就是冗余的；
  4. 环路空间：环路系统中的回路彼此环合得到，包括空集，对于两两环合和三个回路的情况比较容易处理，若回路数量多于3个，先将要进行环合的回路序列选出，然后将环合结果加入空间；
  5. 断集空间：割集系统中的割集彼此环合得到，包括空集，处理方式同上；

模拟代码

//    1、给定一无向简单连通图的相邻矩阵（例如：）。
//    2、输出此图的关联矩阵M。
//    3、求此图所有生成树的个数。
//    4、输出其中任意一颗生成树的相邻矩阵（默认第i行对应顶点vi）和关联矩阵（默认第i行对应顶点vi，第j列对应边ej）。
//    5、求此生成树对应的基本回路系统（输出形式如：{e1e4e3,e2e5e3}）。
//    基本回路必然包含加入的那个弦
//    所以，从弦的一个顶点出发，经过生成树上的边，如果能够回到另一个顶点
//    这条路径就是基本回路
//    因为输出要求用边表示回路，这里每次每次存储一条边，如果最后能回到出发的边，就把这条回路加入基本回路系统
//    如果不能，就回退，这里每个弦只可能对应一个回路，所以一旦找到就返回。
//    DfS函数的设想：
//    参数：
//    边路径栈，记录每一条边
//    压缩版的关联矩阵（因为输出的边的序号是初始关联矩阵中的序号，所以这里的压缩关联矩阵也是初始矩阵的）
//    初始起点（即终点）
//    当前起点
//    边是否经过的数组
//    存储基本回路系统的数组，找到回路后就把路径存入
//    树枝集合
//    返回值：为bool型，如果找到了，就返回TRUE
//    每次遍历树枝集合，寻找没有经过的边，如果没有找到，说明上一次走错了，回退
//    如果找到了，判断是否已经构成回路，如果没有，继续递归，如果找到了，返回
//    6、求此生成树对应的基本割集系统（输出形式如：{{e1,e4},{e2,e5},{e3,e4,e5}}）。
//    *加分题：
//    7、求此生成树对应的环路空间（输出形式如：{,e1e4e3,e2e5e3,e1e4e5e2}）。
//    8、求此生成树对应的断集空间（输出形式如：{,{e1,e4},{e2,e5},{e3,e4,e5},{e1,e2,e4,e5},{e1,e3,e5},{e2,e3,e4},{e1,e2,e3}}）。
//    对于环路空间和断集空间，关键是实现环合运算，这里不再考虑环路中边的顺序问题，把每个环路当成一个集合即可
#include <bits/stdc++.h>

using namespace std;

int n = 0; // 顶点数
int m = 0; // 边数

// 传入的参数为行列式的阶数和行列式数组，返回值为矩阵的秩
int rankOfDeterminant(int n, vector<vector<int> > matrix)
{
    // 求二进制矩阵的秩，即消元，最后看斜对角线上有几个1
    int row = 0;
    for(int col=0; col < n && row < n; col++, row++)  // 从每一列开始，将每一列消到只有 1 个 1 或者全 0
    {
        int i = 0;
        for(i = row; i < n; ++i)  // 寻找这一列第一个非 0 的行
        {
            if(matrix[i][col] != 0)
                break;
        }
        if(n == i)
            --row;
        else
        {
            swap(matrix[row], matrix[i]);
            for(int k = i+1; k < n; k++)
            {
                if(0 != matrix[k][col])
                {
                    for(int j = col; j < n; j++)
                    {
                        matrix[k][j] ^= matrix[row][j];// 用第 r 行的 1 消除这一列上其余全部行的 1
                    }
                }
            }
        }
    }
    return row;
}

// 传入的参数依次为待选序列的起始值j，还要选取的序列数，所有序列数组，当前序列数组，可供选择的数目m
// 类似m选n的所有序列问题
void selectSequence(int j, int num, vector<vector<int> >& sequences, vector<int> sequence, int tm)
{
    if (num == 0)   // 选好一个序列
    {
        sequences.push_back(sequence);
        return;
    }
    else if (j + num > tm)   // 已经不能选取一个 n - 1 序列了
    {
        return;
    }
    else
    {
        // 选择j
        sequence.push_back(j); // 这里的j是边的序号
        selectSequence(j + 1, num - 1, sequences, sequence, tm);
        // 不选j
        sequence.pop_back();
        selectSequence(j + 1, num, sequences, sequence, tm);
    }
}

// 根据相邻矩阵得到关联矩阵
void getIncidenceMatrix(vector<vector<int> > &A, vector<vector<int> > &M)
{
    // 先算出边数，然后给边编号，因为是简单图，所以每两个顶点之间只有一个边，遍历下三角即可
    // 行列式的是通过 m 列选 n - 1列生成的
    int t = 0;
    for (int i = 1; i < n; ++i)
    {
        for (int j = 0; j < i; ++j)
        {
            if (A[i][j] == 1)
            {
                M[i][t] = 1;
                M[j][t] = 1;
                t++;
            }
        }
    }
}

void printMatrix(vector<vector<int> > &M)
{
    for (int i = 0; i < int(M.size()); ++i)
    {
        printf("%d", M[i][0]);
        for (int j = 1; j < int(M[0].size()); ++j)
        {
            printf(" %d", M[i][j]);
        }
        printf("\n");
    }
}

int numOfSpanningTree(vector<vector<int> > & M, vector<vector<int> > &sequences, unordered_set<int>& store)
{
    // 去掉关联矩阵第一行，依次排查所有的 n - 1 阶子方阵，行列式非零的即为生成树
    int ret = 0;
    for (int t = 0; t < int(sequences.size()); ++t)
    {
        vector<vector<int> > a(n - 1, vector<int>(n - 1, 0));
        for (int i = 1; i < n; ++i)
        {
            for (int j = 0; j < n - 1; ++j)
            {
                a[i - 1][j] = M[i][sequences[t][j]];
            }
        }
        if (rankOfDeterminant(n - 1, a) == n - 1)
        {
            ret++;
            store.insert(t); // 记录对应生成树的n - 1阶行列式所在索引号
        }
    }
    return ret;
}

void branchSet(vector<int>& sequence, unordered_set<int>& branches)
{
    // 求树枝的集合
    for (int i = 0; i < int(sequence.size()); ++i)
    {
        branches.insert(sequence[i]);
    }
}

void stringSet(unordered_set<int> &strings, unordered_set<int>& branches)
{
    // 求弦的集合
    for (int i = 0; i < m; ++i)
    {
        if (branches.count(i) == 0)
        {
            strings.insert(i);
        }
    }
}

void basicCutSet(vector<unordered_set<int> >& cutSystem, unordered_set<int>& branches, unordered_set<int>& strings)
{
    // 基本割集系统
    for (auto it = branches.begin(); it != branches.end(); ++it)
    {
        unordered_set<int> temp(strings);
        temp.insert(*it);
        cutSystem.push_back(temp);
    }
}

void endpointsOfEdge(unordered_map<int, vector<int> > &endpoints, vector<vector<int> >& M)
{
    // 边和顶点绑定
    for (int j = 0; j < m; ++j)
    {
        for (int i = 0; i < n; ++i)
        {
            if (M[i][j] == 1)
            {
                endpoints[j].push_back(i);
            }
        }
    }
}

bool dfs(int initS, int newS, vector<int> &usedEdge, stack<int> &edgePath,unordered_map<int, vector<int> > &endpoints, vector<unordered_set<int> >& loopSystem, unordered_set<int>& branches)
{
    if (newS == initS)   // 当前起点为初始起点时，说明已经走出了一条回路
    {
        unordered_set<int> temp;
        while (!edgePath.empty())
        {
            int t = edgePath.top();
            edgePath.pop();
            temp.insert(t);
        }
        loopSystem.push_back(temp);
        return true;
    }
    bool flag = false; // 是否能走通
    for (auto it = branches.begin(); it != branches.end(); ++it)
    {
        if (usedEdge[*it] == 0)   // 未用过的边
        {
            int tnewS = newS;
            if (endpoints[*it][0] == newS)   // 可以走通
            {
                tnewS = endpoints[*it][1]; // 更新当前起点
            }
            else if (endpoints[*it][1] == newS)
            {
                tnewS = endpoints[*it][0];
            }
            else
            {
                continue;
            }
            usedEdge[*it] = 1;
            edgePath.push(*it);
            flag = true;
            if (dfs(initS, tnewS, usedEdge, edgePath, endpoints, loopSystem,branches))   // 找到了返回
            {
                return true;
            }
            else
            {
                flag = false;
                usedEdge[*it] = 0;
                edgePath.pop();
            }
        }
    }
    return flag;
}

void basicCircuitSet(vector<unordered_set<int> >& loopSystem, unordered_set<int>& branches, unordered_set<int>& strings, unordered_map<int, vector<int> > &endpoints)
{
    for (auto it = strings.begin(); it != strings.end(); ++it)
    {
        int initS = endpoints[*it][0];
        int newS = endpoints[*it][1];
        vector<int> usedEdge(m, 0);
        usedEdge[*it] = 1;
        stack<int> edgePath;
        edgePath.push(*it);
        if (dfs(initS, newS, usedEdge, edgePath, endpoints, loopSystem, branches))
        {

        }
        else
        {
            cout << "dfs不可能找不到的，哪里出错了呢？" << endl;
        }
    }
}

// 传入的参数分别是边集数组，输出设置选项，choice为0输出的事基本断集系统
// 为1输出的为基本回路系统，为2输出的为回路空间，为3输出的为断集空间
void printEdgeSet(vector<unordered_set<int> > &edgeSet, int choice)
{
    if (edgeSet.size() == 0)
    {
        if (choice == 0 || choice == 1)
        {
            printf("null set\n");
        }
        else
        {
            printf("{null set}\n");
        }
    }
    else if (choice == 0 || choice == 3)   // 基本断集系统或断集空间
    {
        printf("{");
        if (choice == 3)  // 断集空间还要输出一个空集
        {
            printf("null set,");
        }
        for (int i = 0; i < int(edgeSet.size()); ++i)
        {
            printf("{");
            auto it = edgeSet[i].begin();
            printf("e%d",*it + 1);
            ++it;
            while(it != edgeSet[i].end())
            {
                printf(",e%d", *it + 1);
                ++it;
            }
            printf("}");

            if (i != int(edgeSet.size()) - 1)
            {
                printf(",");
            }
        }
        printf("}\n");
    }
    else   // 基本回路系统或环路空间
    {
        printf("{");
        if (choice == 2)  // 环路空间还要输出空集
        {
            printf("null set,");
        }
        for (int i = 0; i < int(edgeSet.size()); ++i)
        {
            auto it = edgeSet[i].begin();
            printf("e%d",*it + 1);
            ++it;
            while(it != edgeSet[i].end())
            {
                printf("e%d", *it + 1);
                ++it;
            }
            if (i != int(edgeSet.size()) - 1)
            {
                printf(",");
            }
        }
        printf("}\n");
    }

}

void cyclization(unordered_set<int>& a, unordered_set<int> &b, unordered_set<int>& temp)
{
    for (auto it = a.begin(); it != a.end(); ++it)
    {
        if (b.count(*it) == 0)
        {
            temp.insert(*it);
        }
    }
    for (auto it = b.begin(); it != b.end(); ++it)
    {
        if (a.count(*it) == 0)
        {
            temp.insert(*it);
        }
    }
}

// dfs遍历二位数组中所有的点
void dfs(int t, vector<vector<int>> &tP, vector<int>& visited)
{
    for (int i = 0; i < n; ++i)
    {
        if (visited[i] == 0 && tP[t][i] == 1)   // i没有访问过，顶点t和i之间有边
        {
            visited[i] = 1;
            dfs(i, tP, visited);
        }
    }
}

// 根据邻接矩阵判断是否是连通图
bool isConnected(vector<vector<int>> &tP, vector<int>& visited)
{
    // 先排除有孤立点的
    if (n == 1)
    {
        return false;
    }
    // 从v1开始搜索
    visited[0] = 1;
    dfs(0, tP, visited);
    for (int i = 0; i < n; ++i)
    {
        if (visited[i] == 0) // 有顶点没有访问到
        {
            return false;
        }
    }
    return true;
}


int main()
{
    // 输入相邻矩阵
    cout << "输入顶点数：" << endl;
    cin >> n;
    vector<vector<int> > A(n, vector<int>(n, 0)); // 相邻矩阵
    cout << "输入相邻矩阵：" << endl;
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<n; j++)
        {
            cin >> A[i][j];
            if (A[i][j] != 0)
            {
                m++;
            }
        }
    }
    m /= 2; // 这里用握手定理求边数
    vector<vector<int> > M(n, vector<int>(m, 0)); // 关联矩阵
    getIncidenceMatrix(A, M);
    cout << "输出关联矩阵：" << endl;
    printMatrix(M);
    vector<vector<int> > sequences; // 记录 n - 1阶行列式的序列集
    vector<int> sequence; // 记录n - 1 阶行列式
    selectSequence(0, n - 1, sequences, sequence, m);
//    cout << "sequences大小" << sequences.size() << endl;
    cout << "生成树的数量：" << endl;
    unordered_set<int> store; // 存储所有生成树的n - 1阶行列式的位置
    printf("%d\n", numOfSpanningTree(M, sequences, store));

    int t = *store.begin(); // 这里选取其中一个生成树对应的n - 1阶行列式
    vector<vector<int> > tA(n, vector<int>(n, 0)); // 该树的相邻矩阵
    vector<vector<int> > tM(n, vector<int>(n - 1, 0)); // 其中一个生成树的关联矩阵

    for (int i = 0; i < n; ++i) // i是顶点序号
    {
        for (int j = 0; j < n - 1; ++j)
        {
            sequence.push_back(sequences[t][j]);  // sequences[t][j]是边序号
            tM[i][j] = M[i][sequences[t][j]]; // 这里对生成树中的 n - 1 条边进行了重新编号
        }
    }

    printf("任意一个生成树的关联矩阵：\n");
    printMatrix(tM);
    for (int j = 0; j < n - 1; ++j) // 遍历边
    {
        int x = -1;
        int y = -1;
        for (int i = 0; i < n; ++i) // 遍历顶点
        {
            if (tM[i][j] == 1)
            {
                if (x == -1)
                {
                    x = i;
                }
                else
                {
                    y = i;
                }
            }
        }
        tA[x][y] = 1;
        tA[y][x] = 1;
    }
    printf("任意一个生成树的相邻矩阵：\n");
    printMatrix(tA);

    unordered_set<int> strings; // 存储弦序号
    unordered_set<int> branches; // 存储树枝序号
    vector<unordered_set<int> > cutSystem; // 存储该生成树的基本断集系统
    vector<unordered_set<int> > loopSystem; // 存储该生成树的基本回路系统
    unordered_map<int, vector<int> > endpoints; // 压缩版的关联矩阵，值是端点序号
    endpointsOfEdge(endpoints, M);
    branchSet(sequence, branches);
    stringSet(strings, branches);
    printf("branches:%d\n", branches.size());
    printf("strings:%d\n", strings.size());
    // 基本割集系统：先把一个树枝和所有弦放入一个假割集，
    // 再对邻接矩阵操作，去掉所有弦和一个树枝，再尝试添加弦，如果添加后仍然是不连通的，就添加这条弦
    // 然后，在假割集中去掉添加的弦，最终得到真的割集
    unordered_set<int> temp;
    vector<vector<int> > P(A); // 复制邻接矩阵
    for (auto it = strings.begin(); it != strings.end(); ++it)
    {
        temp.insert(*it);
//      对邻接矩阵进行操作，去掉所有弦
        int v1 = endpoints[*it][0];
        int v2 = endpoints[*it][1];
        P[v1][v2] = 0;
        P[v2][v1] = 0;
    }

    for (auto it = branches.begin(); it != branches.end(); ++it)
    {
        unordered_set<int> fSet(temp);
        vector<vector<int>> tP(P);
        vector<int> visited(n, 0);
//      对邻接矩阵操作，去掉一个树枝，这时的邻接矩阵应该是不连通的，否则报错
        fSet.insert(*it); // 加入一个树枝的序号
        int v1 = endpoints[*it][0];
        int v2 = endpoints[*it][1];
        tP[v1][v2] = 0;
        tP[v2][v1] = 0;
        if (isConnected(tP, visited))
        {
            cout << "出错了，去除所有的弦和一个树枝后不可能是连通的！" << endl;
            exit(1);
        }
        for (auto p = strings.begin(); p != strings.end(); ++p)
        {
//      判断加上这个弦后的邻接矩阵是否连通，仍不连通则在假割集中将其删除，连通了就再在邻接矩阵中将其去掉
            int v1 = endpoints[*p][0];
            int v2 = endpoints[*p][1];
            tP[v1][v2] = 1;
            tP[v2][v1] = 1;
            for (int i = 0; i < n; ++i)
                visited[i] = 0;
            if (!isConnected(tP, visited))   // 仍不连通，在假割集中将这条弦去掉
            {
                fSet.erase(*p);
            }
            else   // 连通了说明这条弦是真割集的一部分
            {
                tP[v1][v2] = 0;
                tP[v2][v1] = 0;
            }
        }
        cutSystem.push_back(fSet);
    }
    printf("基本割集系统：\n");
    printEdgeSet(cutSystem, 0);

    // 基本回路系统
    basicCircuitSet(loopSystem, branches, strings, endpoints);
    printf("基本回路系统：\n");
    printEdgeSet(loopSystem, 1);
    vector<unordered_set<int> > loopSpace;
    vector<unordered_set<int> > cutSpace;
// 求环路空间，环合运算并不是两两环合，0个就是空集，1个就是本身，
// 所以仍然有一个n选m的过程，即哪些基本回路之间进行环合运算，这些基本回路两两环合得到最终的边集
    for (auto i = loopSystem.begin(); i != loopSystem.end(); ++i)
    {
        loopSpace.push_back(*i); // 一个环合
        for (auto j = i + 1; j != loopSystem.end(); ++j) // 两两环合
        {
            unordered_set<int> temp;
            cyclization(*i, *j, temp);
            loopSpace.push_back(temp);
        }
    }
    if (loopSystem.size() == 3)   // 三个环合
    {
        auto t1 = loopSystem.begin();
        auto t2 = t1 + 1;
        unordered_set<int> temp1;
        cyclization(*t1, *t2, temp1);
        unordered_set<int> temp2;
        t2++;
        cyclization(temp1, *t2, temp2);
        loopSpace.push_back(temp2);
    }
    else if (loopSpace.size() > 3)
    {
        int num = loopSystem.size();
        for (int i = 3; i <= int(loopSpace.size()); ++i)   // i代表参与环合的环路数量
        {
            // 先从num个环路中选出i个环路，然后对这i个环路进行环合运算
            vector<vector<int>> sets;
            vector<int> temp;
            selectSequence(0, i, sets, temp, num);
            for (int ti = 0; ti < int(sets.size()); ++ti)   // sets[ti][tj]是loopSystem中环路的序号
            {
                auto t1 = loopSystem[sets[ti][0]];
                unordered_set<int> t;
                for (int tj = 1; tj < i; ++tj)
                {
                    auto t2 = loopSystem[sets[ti][tj]];
                    cyclization(t1, t2, t);
                    t1 = t; // 当前的部分环合赋值给t1
                    t.clear();
                }
                loopSpace.push_back(t1); // 其中一个i环合结果，一共有sets.size()个
            }
        }
    }
    printf("该生成树对应的环路空间：\n");
    printEdgeSet(loopSpace, 2);
//    // 求断集空间
    for (auto i = cutSystem.begin(); i != cutSystem.end(); ++i)
    {
        cutSpace.push_back(*i); // 一个断集
        for (auto j = i + 1; j != cutSystem.end(); ++j) // 两两环合
        {
            unordered_set<int> temp;
            cyclization(*i, *j, temp);
            cutSpace.push_back(temp);
        }
    }
    if (cutSystem.size() == 3)   // 三个环合
    {
        auto t1 = cutSystem.begin();
        auto t2 = t1 + 1;
        unordered_set<int> temp1;
        cyclization(*t1, *t2, temp1);
        unordered_set<int> temp2;
        t2++;
        cyclization(temp1, *t2, temp2);
        cutSpace.push_back(temp2);
    }
    else if (cutSpace.size() > 3)
    {
        int num = cutSystem.size();
        for (int i = 3; i <= int(cutSpace.size()); ++i)   // i代表参与环合的断集数量
        {
            // 先从num个断集中选出i个断集，然后对这i个断集进行环合运算
            vector<vector<int>> sets;
            vector<int> temp;
            selectSequence(0, i, sets, temp, num);
            for (int ti = 0; ti < int(sets.size()); ++ti)   // sets[ti][tj]是cutSystem中环路的序号
            {
                auto t1 = cutSystem[sets[ti][0]];
                unordered_set<int> t;
                for (int tj = 1; tj < i; ++tj)
                {
                    auto t2 = cutSystem[sets[ti][tj]];
                    cyclization(t1, t2, t);
                    t1 = t; // 当前的部分环合赋值给t1
                    t.clear();
                }
                cutSpace.push_back(t1); // 其中一个i环合结果，一共有sets.size()个
            }
        }
    }
    printf("该生成树对应的断集空间：\n");
    printEdgeSet(cutSpace, 3);
    return 0;
}

测试结果

测试用例一：

输入顶点数：
4
输入相邻矩阵：
0 1 1 1
1 0 0 1
1 0 0 1
1 1 1 0
输出关联矩阵：
1 1 1 0 0
1 0 0 1 0
0 1 0 0 1
0 0 1 1 1
sequences大小10
生成树的数量：
8
任意一个生成树的关联矩阵：
1 0 0
0 1 0
0 0 1
1 1 1
任意一个生成树的相邻矩阵：
0 0 0 1
0 0 0 1
0 0 0 1
1 1 1 0
branches:3
strings:2
基本割集系统：
{{e5,e2},{e4,e1},{e3,e2,e1}}
基本回路系统：
{e2e5e3,e1e4e3}
该生成树对应的环路空间：
{null set,e2e5e3,e4e1e5e2,e1e4e3}
该生成树对应的断集空间：
{null set,{e5,e2,e1},{e4,e5},{e3,e5},{e4,e2,e1},{e3,e4},{e3,e2,e1}}

测试用例二

输入顶点数：
4
输入相邻矩阵：
0 1 1 1
1 0 1 1
1 1 0 1
1 1 1 0
输出关联矩阵：
1 1 0 1 0 0
1 0 1 0 1 0
0 1 1 0 0 1
0 0 0 1 1 1
生成树的数量：
16
任意一个生成树的关联矩阵：
1 0 0
0 1 0
0 0 1
1 1 1
任意一个生成树的相邻矩阵：
0 0 0 1
0 0 0 1
0 0 0 1
1 1 1 0
branches:3
strings:3
基本割集系统：
{{e6,e2,e3},{e5,e1,e3},{e4,e1,e2}}
基本回路系统：
{e3e6e5,e2e6e4,e1e5e4}
该生成树对应的环路空间：
{null set,e3e6e5,e4e2e5e3,e4e1e6e3,e2e6e4,e5e1e6e2,e1e5e4,e1e3e2}
该生成树对应的断集空间：
{null set,{e6,e2,e3},{e5,e2,e1,e6},{e4,e3,e1,e6},{e5,e1,e3},{e2,e4,e3,e5},{e4,e1,e2},{e4,e6,e5}}

测试用例三

输入顶点数：
2
输入相邻矩阵：
0 1
1 0
输出关联矩阵：
1
1
生成树的数量：
1
任意一个生成树的关联矩阵：
1
1
任意一个生成树的相邻矩阵：
0 1
1 0
branches:1
strings:0
基本割集系统：
{{e1}}
基本回路系统：
null set
该生成树对应的环路空间：
{null set}
该生成树对应的断集空间：
{null set,{e1}}

测试用例四

输入顶点数：
5
输入相邻矩阵：
0 1 1 0 0
1 0 0 1 0
1 0 0 1 0
0 1 1 0 1
0 0 0 1 0
输出关联矩阵：
1 1 0 0 0
1 0 1 0 0
0 1 0 1 0
0 0 1 1 1
0 0 0 0 1
生成树的数量：
4
任意一个生成树的关联矩阵：
1 0 0 0
0 1 0 0
1 0 1 0
0 1 1 1
0 0 0 1
任意一个生成树的相邻矩阵：
0 0 1 0 0
0 0 0 1 0
1 0 0 1 0
0 1 1 0 1
0 0 0 1 0
branches:4
strings:1
基本割集系统：
{{e5},{e4,e1},{e3,e1},{e2,e1}}
基本回路系统：
{e1e3e4e2}
该生成树对应的环路空间：
{null set,e1e3e4e2}
该生成树对应的断集空间：
{null set,{e5},{e1,e4,e5},{e1,e3,e5},{e1,e2,e5},{e4,e1},{e3,e4},{e2,e4},{e3,e1},{e2,e3},{e2,e1},{e3,e5,e4},{e2,e5,e4},{e2,e5,e3},{e1,e2,e4,e3},{e1,e3,e5,e4,e2}}

huzimu_
关注
  • 4
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
离散数学实验
m0_50997138的博客
06-06 9039
实验一 真值计算及真值表 一、实验目的 （1）熟悉五个常用联结词合取、析取、条件和双条件的概念，掌握真值表技术。 （2）熟悉五个真值表，掌握真值表技术； 二、实验内容 定义1 设P表示一个命题，由命题联结词┐和命题P连接成┐P，称┐P为P的否定式复合命题， ┐P读“非P”。称┐为否定联结词。┐P是真，当且仅当P为假；┐P是假，当且仅当P为真。 定义2 设P和Q为两个命题，由命题联结词∧将P和Q连接成P∧Q，称P∧Q为命题P和Q的合取式复合命题，P∧Q读做“P与Q”，或“P且Q”。称∧为合取联结词。当且仅当P
离散数学实验报告
12-09
实验一 联结词的运算 实验二 集合的运算 实验三 二元关系的性质判定 实验四 图的矩阵运算
OUC离散数学II实验三(Python)
安小白的博客
12-31 455
平面图判定及对偶图的求解
离散数学实验三则（关系元算，集合运算与操作，最短路）
m0_61126523的博客
05-06 2059
前言 前段时间才做了离散实验的实验报告，为防止在本地遗失，所以上传到CSDN上一份，欢迎大家一起学习 实验1 关系元算 实验报告内容 一、实验目的 熟悉掌握命题逻辑中的联结词、真值表、主范式等，进一步能用他们来解决实际问题。 二、实验内容 1、从键盘输入两个命题变元P和Q的真值，求它们的合取、析取、条件和双条件的真值。（A） 2、求任意一个命题公式的真值表（B，并根据真值表求主范式（C）） 三、实验环境 C或C++语言编程环境实现。 DEVC++ 5.4.0 MinGW GCC 4.7
南京邮电大学离散数学实验一（求主析取和主合取范式）
亦是远方的小地方
05-16 4702
南京邮电大学离散数学实验一（求主析取和主合取范式）
大学离散数学实验集合运算.zip
01-06
（2）二个集合的交运算：把数组A中元素逐一与数组B中的元素进行比较，将相同的元素放在数组C中，数组C便是集合A和集合B的交。 （3）二个集合的并运算：把数组A中各个元素先保存在数组C中。将数组B中的元素逐一与数组...
南京邮电大学离散数学实验.zip
最新发布
05-15
南京邮电大学离散数学实验 lab1: 输入任意公式, 打印出该公式的真值表、主合取范式和主析取范式. lab2: 输入可以是具体的二元关系，也可以给定一个具体的集合，随机生成一个二元关系，根据二元关系性质及对应的判定...
大学离散数学实验二元关系及其性质.zip
01-06
（2）若R对角线上的元素都是1，则R具有自反性。 （3）若R是对称矩阵，则R具有对称性。对称矩阵的判断方法是： 。 （4）关系的传递性判断方法：对任意i，j，k，若 。 （5）求商集的方法：商集是由等价类组成的集合...
离散数学实验二：集合上二元关系性质判定的实现.doc
10-29
离散数学实验报告
离散实践二，easyx版
06-20
利用幂函数f(x)=xr对自己拍摄的数字图像R\G\B通道的像素值进行变换。f(x)是每个像素R\G\B通道的变换函数：x是变换前某像素某个通道的值，f(x)是变换后对应像素相应通道的值，编程并观察当r=0.1\0.4\0.6\0.8\1.0\1.2\1.5\1.8\2.0\2.5\5.0\10.0等值时(r值可结合自己的实验现象更改调整，以效果明显的参数为宜)，幂函数对数字图像的处理效果。对比彩色图像转换前后的效果图，分析r大于1时的取值、r小于1时的取值和r等于1时的取值对结果的影响，统一在报告中进行分析说明。 使用vs2019开发，需要安装easyx图形库
离散数学实验一
热门推荐
huzimu_的博客
02-12 1万+
实验题目：可简单图化、连通图、欧拉图和哈密顿图的判断 实验目的： 掌握可简单图化的定义及判断方法； 掌握连通图、欧拉图的判断方法； 掌握欧拉回路的搜索方法； 了解欧拉图的实际应用。 实验要求： 给定一非负整数序列（例如：(4,2,2,2,2)）。 判断此非负整数序列是否是可图化的，是否是可简单图化的。 如果是可简单图化的，根据Havel定理过程求出对应的简单图，并输出此图。 判断此简单图是否是连通的。 如果是连通图，判断此图是否是欧拉图。如果是欧拉图，请输出一条欧拉回路（输出形式如：v2->v1
数据结构 -- 树（附C++代码实现，前序，后序，中序遍历，树的深度，包括递归和非递归遍历 附完整C++代码）
m0_56350559的博客
06-03 637
二叉树是一种特殊的树结构，每个节点最多有两个子节点，分别称为左子节点和右子节点。结点的度：左右节点各为一个度叶子结点或者终端结点：度为0的结点树的度：结点的最大分支数树的深度(高度)---层数二叉树形态： 空树，根节点，根节点+左子树 根结点+右子树 根+左+右根据树的结点和树的形状，分为几个形态：斜树，满二叉树和完全二叉树。
【离散数学实验报告】关系性质和闭包运算
Yaoyao2024的博客
05-24 2087
本次实验通过矩阵运算的方法，实现了关系性质的判断以及关系闭包运算的方法。实验中，我们分别编写了程序来判断关系的自反性、反自反性、对称性、反对称性和传递性，以及计算关系的自反闭包、对称闭包和传递闭包。此外，我们还使用Warshall算法实现了关系的传递闭包计算。通过本次实验，我们进一步掌握了关系的性质和闭包运算的方法，提高了逻辑思维能力和算法设计思想。同时，我们学习了C++语言程序设计的基本方法和各种调试手段，为以后的学习和工作打下了坚实的基础。
C语言---离散数学实验--图的基本概念及其应用
海绵宝宝de派小星的博客
05-13 2269
C语言--离散数学实验--图的基本概念及其应用（附带源码下载）
南京邮电大学离散数学实验二（二元关系的性质判定）
亦是远方的小地方
05-16 3405
南京邮电大学离散数学实验二（二元关系的性质判定）
离散数学实验三
huzimu_的博客
02-15 1773
实验题目：平面图对偶图的求解 实验目的： 1、掌握平面图的定义； 2、掌握平面图对偶图的求解方法； 3、掌握平面图与其对偶图之间顶点数、边数和面数的关系。 实验要求： 1、给定一平面图的面矩阵R和连通分支数p 2、输出此平面图的顶点数n、边数m和面数r。 3、输出此平面图的对偶图的顶点数n*、边数m和面数r。 4、输出此平面图的对偶图的相邻矩阵（注意：面Ri中放置顶点vi，相邻矩阵第i行对应顶点vi，）。 知识回顾 1、平面图的欧拉定理：n - m + r = 1 + p; 其中n、m、r、p分别是顶点数
离散数学期末复习-基本回路系统和基本割集系统
博客地址 www.sec0nd.top
07-01 1万+
基本回路与基本回路系统 定义 设T是连通图G的一颗生成树，对每一条弦e，存在唯一的由弦e和T的树枝构成的初级回路Ce，称Ce为对应于弦e的基本回路。称所有基本回路的集合为对应生成树T的基本回路系统。 求基本回路的算法 设弦e=(u,v)，先求T中u到v的路径，再加上弦e。 例如 基本割集与基本割集系统 定义 设T是连通图G的一颗生成树，对T的每一条树枝a，存在唯一的由树枝a，其余的边都是弦的割集Sa，称Sa为对应树枝a的基本割集，称所有基本割集的集合为对应生成树T的基本割集系统。 求基本割集的算法 设a为
离散数学实验C语言欧拉图
06-11
2. 统计每个节点的度数，如果存在度数为奇数的节点，则一定不是欧拉图。 3. 如果每个节点的度数都是偶数，则该图是欧拉图。 以下是基于邻接矩阵存储的无向图的判断欧拉图的 C 语言代码： ```c #include #include ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值