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 = ; i < n; i++)
     {
         if (set[i] == s)
             return i;
     }
 }

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

         for (int j = ; j < n; j++)
         {
             x = i;
             cnt = ;//防止死循环
             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 ;
     }
     return ;

 }

 //输出循环群的生成元
 //n为群的阶数，，set[]为存放集合元素的数组，ele[6][6]为存放群运算表的二维数组
 void gen(int n, char set[], char ele[][])
 {
     int x, count;
     int cnt;
     for (int i = ; i < n; i++)
     {
         count = ;
         for (int j = ; j < n; j++)
         {
             x = i;
             cnt = ;
             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[][], char ie)
 {
     int  x, cnt;
     for (int i = ; i < n; i++)
     {
         if (set[i] != ie)
         {
             x = i;
             cnt = ;
             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[][], char ie)
 {

     for (int i = ; i < n; i++)
         for (int j = ; 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[];
     for (int i = ; i < inputnum; i++)
     {
         cin >> Y[i];
     }
     cout << "请输入群的幺元" << endl;
     char e;
     cin >> e;
     char outputform[][];
     char out1[][];
     outputform[][] = '*';
     for (int i = ; i <= inputnum; i++)
     {
         outputform[][i] = Y[i - ];
         outputform[i][] = Y[i - ];
     }
     int m;
     for (int i = ; i < inputnum; i++)
     {
         if (Y[i] == e)
         {
             m = i;
             break;
         }
     }
     int n = m;
     int r = m;
     for (int i = ; i < inputnum; i++)
     {
         out1[n%inputnum][m] = Y[n%inputnum];
         n = n + ;
     }
     int q;
     for (int i = ; i < inputnum; i++)
     {
         q = ;
         for (int y = ; 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 = ; i <= inputnum; i++)
     {
         for (int j = ; j <= inputnum; j++)
         {
             outputform[i][j] = out1[i - ][j - ];
         }
     }
     for (int i = ; i <= inputnum; i++)
     {
         for (int j = ; 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 ;
 }