顺时针循环增长的数组

问题描述：

/*

*input n, print the cube.

*in the example, n = 5

*1 2 3 4 5

*16 17 18 19 6

*15 24 25 20 7

*14 23 22 21 8

*13 12 11 10 9

*/

最容易想到思路的就是，创建一个数组，然后顺时针螺旋递增，下面是该思路实现的代码。

#include <iostream.h>
#include <stdio.h>

#define N 10 

int M[N][N];

void main()
{
int n,i,j;

cin>>n;

for(i=0;i<n;i++)
for(j=0;j<n;j++)
M[i][j] = 0;

for(i=0;i<(n+1)/2;i++)
{
if(i==0)
M[0][0] = 1;
else
M[i][i] = M[i][i-1]+1;
for(j=i+1;j<n-i;j++)
M[i][j] = M[i][j-1] + 1;
for(j=i+1;j<n-i;j++)
M[j][n-i-1] = M[j-1][n-i-1] + 1;
for(j=n-i-2;j>=i;j--)
M[n-i-1][j] = M[n-i-1][j+1] + 1;
for(j=n-i-2;j>i;j--)
M[j][i] = M[j+1][i] + 1;
}

for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
printf("%-5d",M[i][j]);
cout<<endl;
}
cout<<endl;

}

还有效率更高的解吗？能不能直接根据元素的坐标计算它的值呢？答案是可以的。

其实，每一层螺旋都重复了同样的规律，只是内层螺旋都加上了外层螺旋的终值。如果能推导出每层螺旋终值的通项，那么也就能根据当前元素的位置计算其值。

把最外层螺旋记为第0层，往内推进一层，层数加1，元素(i,j)的层数layer是(i,j,n-i-1,n-j-1)中的最小值。

第layer层螺旋的路径长度为4*(n-layer*2)-4，那么该层的螺旋终值就是所有层数不大于layer的螺旋路径长度之和，根据等差数列求和公式，每层螺旋终值的通项为(4*n-4*layer-4)*(layer+1）。

在计算第layer层元素的值时，我们需要第layer-1层的螺旋终值作为初始值，记为init。那么init=(4*n-4*layer)*layer。接下来根据元素所处螺旋层的位置（上边，右边，下边，左边）来计算元素的值，记得加上外层螺旋的终值就行了。

下面是代码实现。

#include <stdio.h>
#include <iostream.h>

#define min(a,b)  (((a)>(b))?(b):(a))

void main()
{
int i,j,layer,n,init,res;

cin>>n;

init = 0;
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
layer = min(min(i,n-i-1),min(j,n-j-1));
init = (4*n-4*layer)*layer;
if(layer==i)
{
res = init + j - layer + 1;
}
else if(layer==n-j-1)
{
res = init + n - 2*layer + i - layer;
}
else if(layer==n-i-1)
{
res = init + 2*(n - layer*2) - 1 + n - layer - 1 - j;
}
else if(layer==j)
{
res = init + 3*(n - layer*2) - 2 + n - layer - 1 - i;
}
printf("%-5d",res);
}
cout<<endl;
}
cout<<endl;
}