java奇数魔方阵算法 奇数阶魔方阵 c语言

一、什么是魔方阵？

魔方矩阵，又称幻方，是具有相同的行数和列数，并在每行每列、对角线上的和都相等的矩阵。

\(N\) 阶幻方，即将自然数 \(1\) 到 \(N^2\) 排成 \(N\) 行 \(N\) 列的方阵，使每行、每列及两条主对角线上的 \(N\)

二、魔方阵的分类

对于魔方阵的构造，可分为一下三种类型：

• 奇数阶（\(N\)为奇数 [\(2n+1\)的形式] ）
• 单偶数阶（\(N\)为\(4\)的倍数 [\(4n\)的形式] ）
• 双偶数阶（\(N\)为其他偶数 [\(4n+2\)的形式] ）

三、魔方阵及代码实现

1、奇数阶魔方阵（\(n\)为奇数）

一般解法：

1. 将 \(1\)
2. 从 \(2\) 开始到 \(n^{2}\) 为止，每个数字的排放规律为：每一个数字排放的行比前一个数字的行数减 \(1\)，每个数字排放的列比前一个数字的列数加\(1\)；
3. 行的特殊情况：如果前一个数字的行数为 \(1\)，那么该数字排在第 \(n\)
4. 列的特殊情况：如果前一个数字的列数为 \(n\)，那么该数字排在第 \(1\)
5. 其他情况：如果按照上面规律确定的位置上已经有数字，则把要排的数字放在上一个数字的下面。

下面为 \(5\)

17	24	1	8	15
23	5	7	14	16
4	6	13	20	22
10	12	19	21	3
11	18	25	2	9

代码实现：

//奇数阶魔方阵
void odd_number(int n)
{
    int i;
    int row,line,row_0,line_0;//row为列坐标，line为行坐标，row_0记录行坐标，line_0记录列坐标
    line=0;row=(n+1)/2-1;//初始化行、列坐标
    a[line][row]=1;
    for(i=2;i<=n*n;i++)
    {
        line_0=line;row_0=row;//记录上一次循环行、列坐标
        if(line==0&&row==n-1)//第1行第n列的情况
        {
            line=n-1;//行坐标转到第n行
            row=0;//列坐标转到第1行
        }
        else if(line==0)//第1行非第n列的情况
        {
            line=n-1;//行坐标转到第n行
            row++;//列坐标+1
        }
        else if(row==n-1)//第n列非第1行的情况
        {
            row=0;//列坐标转到第1列
            line--;//行坐标-1
        }
        else//普通情况
        {
            line--;//行坐标-1
            row++;//列坐标+1
        }
        if(a[line][row]!=0)//判断该位置是否有数字
        {
            line=line_0+1;//（基于本次for循环开始的坐标）行坐标-1，转跳到下一行
            row=row_0;//（基于本次for循环开始的坐标）列坐标不变
        }
        a[line][row]=i;//赋值
    }
}

2、单偶数阶魔方阵（ \(n\) 为偶数，且不能被 \(4\)

一般解法（以 \(10\)

1. 首先把魔方阵均分为四个象限（形成四个奇数阶魔方阵），用奇数阶魔方阵填充的方法依次填充四个象限（顺序为 \(A\) → \(D\) → \(B\) → \(C\)

A	B
C	D

17	24	1	8	15	67	74	51	58	65
23	5	7	14	16	73	55	57	64	66
4	6	13	20	22	54	56	63	70	72
10	12	19	21	3	60	62	69	71	53
11	18	25	2	9	61	68	75	52	59
92	99	76	83	90	42	49	26	33	40
98	80	82	89	91	48	30	32	39	41
79	81	88	95	97	29	31	38	45	47
85	87	94	96	78	35	37	44	46	28
86	93	100	77	84	36	43	50	27	34

1. 对于 \(A\) 象限的中间行，从中间格开始，自左至右标出 \(k\) 格；对于 \(A\) 象限的其他行，标出最左边 \(k\) 格（其中，\(k\) 满足表达式 \(n=4k+2\)

17	24	1	8	15	67	74	51	58	65
23	5	7	14	16	73	55	57	64	66
4	6	13	20	22	54	56	63	70	72
10	12	19	21	3	60	62	69	71	53
11	18	25	2	9	61	68	75	52	59
92	99	76	83	90	42	49	26	33	40
98	80	82	89	91	48	30	32	39	41
79	81	88	95	97	29	31	38	45	47
85	87	94	96	78	35	37	44	46	28
86	93	100	77	84	36	43	50	27	34

1. 将 \(A\) 象限标出的数字与 \(C\)

92	99	1	8	15	67	74	51	58	65
98	80	7	14	16	73	55	57	64	66
4	6	88	95	22	54	56	63	70	72
85	87	19	21	3	60	62	69	71	53
86	93	25	2	9	61	68	75	52	59
17	24	76	83	90	42	49	26	33	40
23	5	82	89	91	48	30	32	39	41
79	81	13	20	97	29	31	38	45	47
10	12	94	96	78	35	37	44	46	28
11	18	100	77	84	36	43	50	27	34

1. 对于 \(B\) 象限的所有行的中格，自左向右标出 \(k-1\) 格，并将其与 \(D\)

92	99	1	8	15	67	74	51	58	65
98	80	7	14	16	73	55	57	64	66
4	6	88	95	22	54	56	63	70	72
85	87	19	21	3	60	62	69	71	53
86	93	25	2	9	61	68	75	52	59
17	24	76	83	90	42	49	26	33	40
23	5	82	89	91	48	30	32	39	41
79	81	13	20	97	29	31	38	45	47
10	12	94	96	78	35	37	44	46	28
11	18	100	77	84	36	43	50	27	34

92	99	1	8	15	67	74	26	58	65
98	80	7	14	16	73	55	32	64	66
4	6	88	95	22	54	56	38	70	72
85	87	19	21	3	60	62	44	71	53
86	93	25	2	9	61	68	50	52	59
17	24	76	83	90	42	49	51	33	40
23	5	82	89	91	48	30	57	39	41
79	81	13	20	97	29	31	63	45	47
10	12	94	96	78	35	37	69	46	28
11	18	100	77	84	36	43	75	27	34

代码实现：

void single_even_number(int n)
{
    int i,j;
    int k,line,row,line_0,row_0;//k是与n相关的参数，line为行坐标，row为列坐标,line_0记录行坐标，row_0记录列坐标
    k=(n-2)/4;
    //A象限
    line=0;row=k;//初始化A象限行列坐标
    a[line][row]=1;
    for(i=2;i<=(2*k+1)*(2*k+1);i++)//A象限的数字范围为1~(2*k+1)*(2*k+1)
    {
        line_0=line;row_0=row;//记录该次循环的初始行列坐标
        if(line==0&&row==2*k)//第0行第2*k列的情况
        {
            line=2*k;//行坐标转为2*k
            row=0;//列坐标转为0
        }
        else if(line==0)//第0行非第2*k列的情况
        {
            line=2*k;//行坐标转为2*k
            row++;//列坐标+1
        }
        else if(row==2*k)//第2*k列非第0行的情况
        {
            row=0;//列坐标转为0
            line--;//行坐标-1
        }
        else//普通情况
        {
            line--;//行坐标-1
            row++;//列坐标+1
        }
        if(a[line][row]!=0)//判断是否遇到该位置有数字的情况
        {
            line=line_0+1;
            row=row_0;
        }
        a[line][row]=i;//赋值
    }
    //D象限
    line=2*k+1;row=3*k+1;//初始化D象限行列坐标
    a[2*k+1][3*k+1]=(2*k+1)*(2*k+1)+1;
    for(i=(2*k+1)*(2*k+1)+2;i<=2*(2*k+1)*(2*k+1);i++)//D象限数字范围(2*k+1)*(2*k+1)+1~2*(2*k+1)*(2*k+1)
	{
		line_0=line;row_0=row;//记录该次循环的初始行列坐标
		if((line==2*k+1)&&(row==4*k+1))//第(2*k+1)行第(4*k+1)列的情况
		{
			line=4*k+1;//行坐标转为4*k+1
			row=2*k+1;//列坐标转为2*k+1
		}
		else if(line==2*k+1)//第(2*k+1)行非第(4*k+1)列的情况
		{
			line=4*k+1;//行坐标转为4*k+1
			row++;//列坐标+1
		}
		else if(row==4*k+1)//第(4*k+1)列非第(2*k+1)行的情况
		{
			row=2*k+1;//列坐标转为2*k+1
			line--;//行坐标-1
		}
		else//普通情况
		{
			line--;//行坐标-1
			row++;//列坐标+1
		}
		if(a[line][row]!=0)//判断是否遇到该位置有数字的情况
		{
			line=line_0+1;
			row=row_0;
		}
		a[line][row]=i;//赋值
	}
    //B象限
    line=0;row=3*k+1;//初始化B象限行列坐标
    a[line][row]=2*(2*k+1)*(2*k+1)+1;
    for(i=2*(2*k+1)*(2*k+1)+2;i<=3*(2*k+1)*(2*k+1);i++)//B象限数字范围2*(2*k+1)*(2*k+1)+1~3*(2*k+1)*(2*k+1)
	{
		line_0=line;row_0=row;//记录该次循环的初始行列坐标
		if((line==0)&&(row==4*k+1))//第0行第(4*k+1)列的情况
		{
			line=2*k;//行坐标转为2*k
			row=2*k+1;//列坐标转为2*k+1
		}
		else if(line==0)//第0行非第(4*k+1)列的情况
		{
			line=2*k;//行坐标转为2*k
			row++;//列坐标+1
		}
		else if(row==4*k+1)//第(4*k+1)列非第0行的情况
		{
			row=2*k+1;//列坐标转为2*k+1
			line--;//行坐标-1
		}
		else//普通情况
		{
			line--;//行坐标-1
			row++;//列坐标+1
		}
		if(a[line][row]!=0)//判断是否遇到该位置有数字的情况
		{
			line=line_0+1;
			row=row_0;
		}
		a[line][row]=i;//赋值
	}
    //C象限
    line=2*k+1;row=k;//初始化C象限行列坐标
    a[line][row]=3*(2*k+1)*(2*k+1)+1;
    for(i=3*(2*k+1)*(2*k+1)+2;i<=4*(2*k+1)*(2*k+1);i++)//C象限数字范围3*(2*k+1)*(2*k+1)+1~4*(2*k+1)*(2*k+1)
	{
		line_0=line;row_0=row;//记录该次循环的初始行列坐标
		if((line==2*k+1)&&(row==2*k))//第(2*k+1)行第2*k列的情况
		{
			line=4*k+1;//行坐标转为4*k+1
			row=0;//列坐标转为0
		}
		else if(line==2*k+1)//第(2*k+1)行非第2*k列的情况
		{
			line=4*k+1;//行坐标转为4*k+1
			row++;//列坐标+1
		}
		else if(row==2*k)//第2*k列非第(2*k+1)行的情况
		{
			row=0;//列坐标转为0
			line--;//行坐标-1
		}
		else//普通情况
		{
			line--;//行坐标-1
			row++;//列坐标+1
		}
		if(a[line][row]!=0)//判断是否遇到该位置有数字的情况
		{
			line=line_0+1;
			row=row_0;
		}
		a[line][row]=i;//赋值
	}
    //换A、C象限相关数字的位置
    for(i=0;i<2*k+1;i++)//对于A、C象限
	{
        int j_0,f=0;//j_0记录循环次数，f=0为标志位
        for(j=0,j_0=0;j_0<k;j_0++,j++)//进行k次交换
		{
			if(i==k&&f==0)//判断是否为中间行
			{
				j+=k;
				f=1;
			}	
			x=a[i][j];
			a[i][j]=a[i+2*k+1][j];
			a[i+2*k+1][j]=x;
		} 
    }
	//换B、D象限相关数字的位置
	if(k>=2)
		for(i=0;i<k-1;i++)//每行交换k-1个数
			for(j=0;j<2*k+1;j++)//从第0行到第2*k行交换
			{
				x=a[j][3*k+1+i];
				a[j][3*k+1+i]=a[2*k+1+j][3*k+1+i];
				a[2*k+1+j][3*k+1+i]=x;
			}
}

3、双偶数阶魔方阵（n为偶数，且能被4整除）

一般规律：

1. 用横线和竖线将 \(n\) 阶魔方阵均分为 \(m\) 个 \(4*4\)
2. 将 \(n*n\) 个数从小到大，从左到右，从上到下，依次填入方阵中，遇到 \(4*4\)
3. 将 \(n*n\) 个数从小到大，从右到左，从下到上，依次填入方阵\(4*4\)的小方阵的对角线上，其他位置不填（注：此位置不填的数不作为下一个位置填的数)
4. 将2、3两步得到的魔方阵合并为一个魔方阵，双偶数阶魔方阵排列完成。

64	2	3	61	60	6	7	57
9	55	54	12	13	51	50	16
17	47	46	20	21	43	42	24
40	26	27	37	36	30	31	33
32	34	35	29	28	38	39	25
41	23	22	44	45	19	18	48
49	15	14	52	53	11	10	56
8	58	59	5	4	62	63	1

解决双偶数阶魔方阵的关键是要准确计算对角线。

从左上到右下的对角线满足 \(line \div 4 == row \div 4\)

从右上到左下的对角线满足 \(( line + row ) \div 4 == 3\)

	0	1	2	3	4	5	6	7
0	0			3	4			7
1		2	3			6	7
2		3	4			7	8
3	3			6	7			10
4	4			7	8			11
5		6	7			10	11
6		7	8			11	12
7	7			10	11			14

代码实现：

void double_even_number(int n)
{
    int line,row;
	int t_1=1,t_2=n*n;//t_1为正向，t_2为逆向
	for(line=0;line<n;line++)
	{
		for(row=0;row<n;row++)
		{
			if(line%4==row%4||(line+row)%4==3)//判断是否为对角线
				a[line][row]=t_2;
			else
				a[line][row]=t_1;
			t_1++;
			t_2--;
		}
	}
}

主函数如下：

#include<stdio.h>
#include<math.h> 
int a[100][100]={0};//将数组a中所有元素赋值为0
int main()
{
	int n,i,j;
	void odd_number(int n);
	void single_even_number(int n);
	void double_even_number(int n);
	printf("请输入“魔方阵 ”的参数n=");
	scanf("%d",&n);
	if(n%2==1)
		odd_number(n);
	else if(n%4==2)
		single_even_number(n); 
	else if(n%4==0)
		double_even_number(n);
	printf("该“魔方阵”如下:\n");
	for(i=0;i<n;i++)
	{
		for(j=0;j<n;j++)
			printf("%4d",a[i][j]);
		printf("\n");
	}
	return 0;
 }