c++ 离散数学 群的相关判断及求解

采用C/C++/其它语言编程，构造一个n阶群<G={a,b,c,…},*>，G的阶|G|满足：3<=|G|<=6

1、判断该群是否是循环群，若是，输出该群的某个生成元。

2、给出每一个元素的阶和逆元

#include<iostream>

using namespace std;
//返回元素下标
//n为集合元素个数，set[]为存放元素集合，s为要求下标的元素
int sub(int n, char set[], char s)
{
    for (int i = 0; i < n; i++)
    {
        if (set[i] == s)
            return i;
    }
}

//判断群是不是循环群
//n为群的阶数，，set[]为存放集合元素的数组，ele[6][6]为存放群运算表的二维数组
int Iscyc(int n, char set[], char ele[][6])
{
    int x, count;
    int cnt;
    for (int i = 0; i < n; i++)
    {
        count = 0;//计量---集合中的元素是否由set[i]的幂组成

        for (int j = 0; j < n; j++)
        {
            x = i;
            cnt = 2;//防止死循环
            if (set[j] == set[i])
                count++;
            if (set[j] == ele[x][i])
                count++;

            while (set[j] != ele[x][i] && cnt < n)
            {
                x = sub(n, set, ele[x][i]);
                cnt++;
                if (set[j] == ele[x][i])
                    count++;
            }


        }
        if (count == n)
            return 1;
    }
    return 0;

}

//输出循环群的生成元
//n为群的阶数，，set[]为存放集合元素的数组，ele[6][6]为存放群运算表的二维数组
void gen(int n, char set[], char ele[][6])
{
    int x, count;
    int cnt;
    for (int i = 0; i < n; i++)
    {
        count = 0;
        for (int j = 0; j < n; j++)
        {
            x = i;
            cnt = 2;
            if (set[j] == set[i])
                count++;
            if (set[j] == ele[x][i])
                count++;
            while (set[j] != ele[x][i] && cnt < n)
            {
                x = sub(n, set, ele[x][i]);
                cnt++;
                if (set[j] == ele[x][i])
                    count++;
            }
        }
        if (count == n)
            cout << "循环群的生成元是：" << set[i] << endl;
    }
}

//给出群中每个元素的阶
//n为群的阶数，，set[]为存放集合元素的数组，ele[6][6]为存放群运算表的二维数组,ie为幺元
void order(int n, char set[], char ele[][6], char ie)
{
    int  x, cnt;
    for (int i = 0; i < n; i++)
    {
        if (set[i] != ie)
        {
            x = i;
            cnt = 2;
            if (ele[x][i] == ie)
                cout << set[i] << "的阶是" << cnt << endl;
            while (ele[x][i] != ie)
            {
                x = sub(n, set, ele[x][i]);
                cnt++;
                if (ele[x][i] == ie)
                {
                    cout << set[i] << "的阶是" << cnt << endl;
                    break;
                }
            }
        }
        else
            cout << set[i] << "的阶是1" << endl;
    }


}

//输出群中每个元素的逆元
//n为群的阶数，，set[]为存放集合元素的数组，ele[6][6]为存放群运算表的二维数组
//ie为幺元
void inver(int n, char set[], char ele[][6], char ie)
{

    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
        {
            if (ele[i][j] == ie)
            {
                cout << set[i] << "的逆元是" << set[j] << endl;
                break;
            }
        }


}


int main()
{
    cout << "请输入元素的个数(要求3到6之间)" << endl;
    int inputnum;
    cin >> inputnum;
    cout << "请输入元素" << endl;
    char Y[4];
    for (int i = 0; i < inputnum; i++)
    {
        cin >> Y[i];
    }
    cout << "请输入群的幺元" << endl;
    char e;
    cin >> e;
    char outputform[7][7];
    char out1[6][6];
    outputform[0][0] = '*';
    for (int i = 1; i <= inputnum; i++)
    {
        outputform[0][i] = Y[i - 1];
        outputform[i][0] = Y[i - 1];
    }
    int m;
    for (int i = 0; i < inputnum; i++)
    {
        if (Y[i] == e)
        {
            m = i;
            break;
        }
    }
    int n = m;
    int r = m;
    for (int i = 0; i < inputnum; i++)
    {
        out1[n%inputnum][m] = Y[n%inputnum];
        n = n + 1;
    }
    int q;
    for (int i = 0; i < inputnum; i++)
    {
        q = 0;
        for (int y = 0; y < inputnum; y++)
        {
            if (out1[i][m] == Y[y])
            {
                q = y;
                break;
            }
        }
        for (int j = m; j < inputnum + m; j++)
        {
            out1[i][j%inputnum] = Y[q%inputnum];
            q++;
        }
    }
    for (int i = 1; i <= inputnum; i++)
    {
        for (int j = 1; j <= inputnum; j++)
        {
            outputform[i][j] = out1[i - 1][j - 1];
        }
    }
    for (int i = 0; i <= inputnum; i++)
    {
        for (int j = 0; j <= inputnum; j++)
        {
            cout << outputform[i][j] << ' ';
        }
        cout << endl;
    }


    cout << "---------------------------" << endl;
    if (Iscyc(inputnum, Y, out1))
    {
        cout << "<G,*>是循环群" << endl;
        gen(inputnum, Y, out1);
    }
    else
        cout << "<G,*>不是循环群" << endl;
    cout << "---------------------------" << endl;
    order(inputnum, Y, out1, e);
    cout << "---------------------------" << endl;
    inver(inputnum, Y, out1, e);


    return 0;
}