群的判定C++代码

群的判定

/**
实验题目：群的判定

实验内容：输入代数系统<A，*>的集合A和*运算的运算表，判定<A，*>是否是群。

实验要求：1、提供输入接口；

                 2、提供输出结果；

                 3、元素集合中的元素至少有3个；

                 4、上传程序源代码文件和运行效果截图。
 */
#define max_int 100
#include<iostream>
using std::cin;
using std::cout;
using std::endl;
//封闭性检验
bool Closed(int a[], int b[][max_int],int n) {
    
    

    for (int i = 0; i < n; i++)
    {
    
    
        for (int j = 0; j < n; j++)
        {
    
    
            int flag = 0;
            for (int k = 0; k < n; k++)
            {
    
    
                if (a[k] == b[i][j])
                    flag = 1;
            }
            if (flag == 0)
            {
    
    
                return false;//该群不满足封闭性返回
            }
        }
    }
    return true;
}

//返回元素所在的位置
int position(int a, int b[],int n) {
    
    
    for (int i = 0; i < n; i++) {
    
    
        if (a == b[i]) {
    
    
            return i;
        }
    }
    return -1;
}

//返回表里指定位置的元素
int element(int a, int b, int D[][max_int],int x[],int n) {
    
    
    return D[position(a, x, n)][position(b, x, n)];
}

//判断两个结果是否相等，相等则满足结合律，不相等，则不满足解和律
bool judge(int a, int b, int c,int D[][max_int],int n,int x[]) {
    
    
    int an_x, an_y;
    an_x = element(a, b, D, x, n);
    an_y = element(b, c, D, x, n);
    if (element(an_x, c, D, x, n) == element(a, an_y, D, x, n)) {
    
    
        return true;
    }
    else {
    
    
        return false;
    }
}

//判断幺元,幺元只能是第一个元素
bool Unitary(int D[][max_int], int n, int x[]) {
    
    
    int judge_left = 0, judge_right = 0;
    for (int i = 0; i < n; i++)
    {
    
    
        int flag = 0;
        for (int j = 0, k = 0; j < n, k < n; j++, k++)
        {
    
    
            if (D[i][j] != x[k]) {
    
    
                break;
            }
            else {
    
    
                flag++;
            }
        }
        if (flag == n)
        {
    
    
            judge_left = 1;
        }
    }
    for (int i = 0; i < n; i++)
    {
    
    
        int flag = 0;
        for (int j = 0, k = 0; j < n, k < n; j++, k++)
        {
    
    
            if (D[j][i] != x[k]) {
    
    
                break;
            }
            else {
    
    
                flag++;
            }
        }
        if (flag == n)
        {
    
    
            judge_right = 1;
        }
    }
    if (judge_left == 1 && judge_right == 1) {
    
    
        return true;
    }
    else {
    
    
        return false;
    }
}

//判断每个元素的逆元是否存在
bool judgeAll(int D[][max_int], int n, int x[]) {
    
    
    int flag = 0;
    for (int i = 1; i < n; i++)//第i行
    {
    
    
        for (int j = 0; j < n; j++)//第j列
        {
    
    
            if (D[i][j] == x[0])
                flag++;
        }
    }
    if (flag == n - 1)
        return true;
    else
        return false;
}
int main() {
    
    
    int a[max_int], D[max_int][max_int];//集合A和*运算的运算表
    int n;//集合里面元素的数量
    int flag = 0;//定义一个flag值作为信号量来判断
    //数据输入
    cin >> n;
    for (int i = 0; i < n; i++)
    {
    
    
        cin >> a[i];
    }
    for (int j = 0; j < n; j++)
    {
    
    
        for (int k = 0; k < n; k++)
        {
    
    
            cin >> D[j][k];
        }
    }
    //对其运算表进行判断，并将flag值增加
    if (Closed(a, D, n)) {
    
    
        cout << "满足封闭性" << endl;
        flag++;
    }
    if (judge(a[0], a[1], a[2], D, n, a))
    {
    
    
        cout << "满足结合律" << endl;
        flag++;
    }

    if (Unitary(D, n, a)) {
    
    
        cout << "存在幺元" << endl;
        flag++;
    }

    if (judgeAll(D, n, a)) {
    
    
        cout << "每个元素都存在它的逆元" << endl;
        flag++;
    }
    //当信号量为4即是四个条件都满足即是群
    if (flag == 4) {
    
    
        cout << "是群" << endl;
    }
    else {
    
    
        cout << "不是群" << endl;
    }
    return 0;
}