【离散数学】阿贝尔群和循环群编程题

1：模n加法循环群的生成元

输入循环群的阶数n，输出该群的生成元。

例如：

输入：24

输出：1 5 7 11 13 17 19 23

注：生成元用空格分隔，（23后面也有一个空格）

#include <iostream>
#include <malloc.h>
using namespace std;

int main(){
    int n;
    cin>>n;
    int *element=(int*)malloc(sizeof(int)*n);
    int *ret=(int*)malloc(sizeof(int)*n);
    int cnt1=0,cnt2=0,i,j;
    
    for(i=1;i<n;i++){
        if(i!=1 && n%i==0){
            element[cnt1++]=i;
        }
    }
    
    for(i=1;i<n;i++){
        if(i==1){
            ret[cnt2++]=i;
        }
        else{
            bool flag=1;
            for (j=0;j<cnt1;j++){
                if(i%element[j]==0){
                    flag=0;
                    break;
                }
            }
            if(flag){
                ret[cnt2++]=i;
            }
        }
    }
    
    for(i=0;i<cnt2;i++){
        cout<<ret[i]<<" ";
    }
    return 0;
} 

2：构造一个剩余类乘法群U(m)

对于输入的正整数m，构造剩余类乘法群，输出该群的所有元素，并判断是否是循环群，如果是循环群，输出所有的生成元（升序排序）。

输入输出样例1：

输入：

5

输出：

1 2 3 4 （空格分隔 剩余类群的元素 ，不用加[ ]）

Y (表示是循环群)

2 3 (空格分隔循环群的生成元)

输入输出样例2：

输入：

9

输出：

1 2 4 5 7 8 （空格分隔 剩余类群的元素 ，不用加[ ]）

Y (表示是循环群)

2 5 (空格分隔循环群的生成元)

输入输出样例3：

输入：

20

输出：

1 3 7 9 11 13 17 19 （空格分隔 剩余类群的元素 ，不用加[ ]）

N (表示不是循环群)

#include <iostream>
#include <malloc.h>
#include <stdlib.h>
using namespace std;

//对于输入的正整数m，构造剩余类乘法群，输出该群的所有元素，
//并判断是否是循环群，如果是循环群，输出所有的生成元（升序排序）

int cmp(const void *a,const void *b){
    return (*(int*)a-*(int*)b);
}

int main(){
    int m;
    cin>>m;
    int *element=(int*)malloc(sizeof(int)*m);
    int *factor=(int*)malloc(sizeof(int)*m);
    int i=0,j=0,cnt1=0,cnt2=0;
    
    for(i=1;i<m;i++){
        if(i!=1 && m%i==0){
            factor[cnt1++]=i;
        }
    }
    
    for(i=1;i<m;i++){
        if(i==1){
            element[cnt2++]=i;
        }
        else{
            bool flag=1;
            for (j=0;j<cnt1;j++){
                if(i%factor[j]==0){
                    flag=0;
                    break;
                }
            }
            if(flag){
                element[cnt2++]=i;
            }
        }
    }
    
    //output 1
    for(i=0;i<cnt2;i++){
        cout<<element[i]<<" ";
    }
    cout<<endl;
    
    int *ret=(int*)malloc(sizeof(int)*cnt2);
    //生成元集合 
    int cntret=0;
    for(i=0;i<cnt2;i++){
        //int cnt[cnt2]={0},
        int *cnt=(int*)malloc(sizeof(int)*cnt2);
        int count=0,temp=element[i];
        //判断是否为生成元
        for(j=0;j<cnt2;j++){
            cnt[count++]=temp*element[i]%m;
            temp=cnt[count-1];
        }
        //qsort(nums,numsSize,sizeof(int),cmp);
        qsort(cnt,count,sizeof(int),cmp);
        //把当前元素的所有幂的结果排序 
        int test=1;
        for(j=0;j<cnt2;j++){
            if(cnt[j]!=element[j]){
                test=0;
                break;
            }
        }
        if(test==1){
            ret[cntret++]=element[i];
        }
    }
    
    //output 2
    if(cntret!=0){
        cout<<"Y"<<endl;
    }
    else{
        cout<<"N"<<endl;
    }
    
    //output 3
    qsort(ret,cntret,sizeof(int),cmp);
    for(i=0;i<cntret;i++){
        cout<<ret[i]<<" ";
    }
    
    return 0;
}