magic.cpp

这是一个代码,可以实现任意阶的幻方的计算(6除外)

#include "Magic.h"


MagicSquare::MagicSquare()
{
	m_nType = 1;

}
MagicSquare::~MagicSquare()
{

}

bool MagicSquare::Check(	)
{
	int		res;
	int		right= m_nN *(m_nN * m_nN + 1)/2;
	int		temp= m_nN + 1;
	int		i;
	int		j;
	/*
		for(i=1;i<=m_nN;i++)
		{
			for(j=1;j<=m_nN;j++)
				cout<<Array[i][j]<<' ';
			cout<<endl;
		}
		cout<<endl;
	*/
	
	//行
	for( i = 1; i<=m_nN ;i++)
	{
		res=0;
		for(j = 1;j<=m_nN ;j++)
		{
			res+=Array[i][j];

		}
//		cout<<res<<endl;
		if (res != right) 
			return false;
	}
	//列
	for( j = 1; j<=m_nN ;j++)
	{
		res=0;
		for(i = 1;i<=m_nN ;i++)
		{
			res+=Array[i][j];

		}
//		cout<<res<<endl;
		if (res != right) 
			return false;
	}
	//正对角线
	res=0;
	for( i =1 ;i<=m_nN ;i++)
	{
		res+=Array[i][i];

	}
//	cout<<res<<endl;
	if (res != right)
		return false;
	//反对角线
	res=0;
	for( i =1 ;i<=m_nN ;i++)
	{
		res+=Array[i][temp-i];

	}
//	cout<<res<<endl;
	if (res != right)
		return false;


	return true;
}


bool MagicSquare::ReChange()
{
	int		i;
	if (m_nType==1)
	{
		for(i=1 ; i<=m_nN; i++)
		{
			Array[i][m_nB]		= ArrayInit[i][m_nV - i];
			Array[i][m_nV - i]	= ArrayInit[i][m_nB];
			Array[m_nB][i]		= ArrayInit[i][i];
			Array[i][i]			= ArrayInit[m_nB][i];

		}

	}
	else
	{
		for(i =0; i<=m_nN -1;i++)
		{
			Array[m_nN -i][m_nB]	=m_nN+(m_nN-1)*i;
			Array[m_nB][m_nN -i]	=1+m_nV*i;
			Array[m_nN-i][1+i]		=m_nV/2+m_nN*i;
			Array[m_nN-i][m_nN-i]	=(m_nN-1)*m_nN/2+i+1;

		}
	}

	return true;
}

void MagicSquare::Init(int n)
{

	m_nA= n / 2 ;
	m_nB= m_nA+1;
	m_nW= n % 4;
	m_nV= n +1;
	m_nM= n/4;
	m_nN= n;

	
}

void MagicSquare::MainChange()
{
	int		k;
	int		i;
	int		j;
	int		bk;
	for( k= 1; k<=2; k++)
	{
		bk=m_nType==1? 3-k:k;
		for( i=k ; i<=m_nA ;i+=2)
		{
			for (j= bk;j<= m_nA;j+=2)
			{
				Array[i][j]=ArrayInit[m_nV -i][m_nV -j];
				Array[m_nV -i][m_nV -j]=ArrayInit[i][j];
				Array[i][m_nV-j]=ArrayInit[m_nV-i][j];
				Array[m_nV-i][j]=ArrayInit[i][m_nV-j];
			}
		}
	}

}

void MagicSquare::StartChange()
{
	int		i;
	int		j;

	for( i=1 ; i<=m_nN ;i++)
	{
		for( j=1; j<= m_nN ;j++)
		{
			ArrayInit[i][j]= (i-1)*m_nN +j;
//			cout<<ArrayInit[i][j]<<' ';
		}
//		cout<<endl;
	}

	for( i=1 ; i<=m_nN ;i++)
	{
		for( j=1; j<= m_nN ;j++)
		{
			Array[i][j]=ArrayInit[i][j];
		}
	}
	MainChange();
	if( m_nN %2 == 0)
	{
		if(m_nW == 2)
		{
			for( i =2 ; i<= m_nA -1;i++)
			{
				Reverse( Array[i][m_nA],Array[m_nV - i][m_nA]);
				Reverse( Array[m_nB][i],Array[m_nB][m_nV - i]);
			}
			Reverse(Array[1][m_nA],Array[1][m_nB]);
			Reverse(Array[m_nA][1],Array[m_nB][1]);
			Reverse(Array[1][3],Array[m_nN][3]);
			Reverse(Array[3][m_nN],Array[3][1]);

		}
	}
	else
	{
		ReChange();
		if ( m_nW ==3) 
		{
			for(i = 1; i<=m_nA -1; i++)
			{
				Reverse(Array[m_nA][i],Array[m_nA][m_nV-i]);
				Reverse(Array[i][m_nA],Array[m_nV-i][m_nA]);
			}
			Reverse(Array[m_nA][m_nA],Array[m_nV-m_nA][m_nV-m_nA]);
			Reverse(Array[m_nA][m_nB],Array[m_nV-m_nA][m_nB]);
		}
	}
	

}

void MagicSquare::Reverse(int &a, int &b)
{
	int		n;
	n=a;
	a=b;
	b=n;

}

void MagicSquare::SetType(int i)
{
	m_nType=i;
}

bool MagicSquare::SaveToFile(char  *szPath)
{
    ofstream ofn;
    ofn.open(szPath);
    if( ofn.fail())
    	return false;
    for( int i=1; i<=m_nN ; i++)
    {
	for( int j=1; j<=m_nN ; j++)
	{
	    ofn<<Array[i][j]<<'\t';
	}
	ofn<<endl;
    }
    return true;

}