PAT (Basic Level) Practise （中文）1050. 螺旋矩阵(25)

1. 螺旋矩阵(25)

时间限制
150 ms
内存限制
65536 kB
代码长度限制
8000 B
判题程序
Standard
作者
CHEN, Yue
本题要求将给定的N个正整数按非递增的顺序，填入“螺旋矩阵”。所谓“螺旋矩阵”，是指从左上角第1个格子开始，按顺时针螺旋方向填充。要求矩阵的规模为m行n列，满足条件：m*n等于N；m>=n；且m-n取所有可能值中的最小值。

输入格式：

输入在第1行中给出一个正整数N，第2行给出N个待填充的正整数。所有数字不超过104，相邻数字以空格分隔。

输出格式：

输出螺旋矩阵。每行n个数字，共m行。相邻数字以1个空格分隔，行末不得有多余空格。

输入样例：
12
37 76 20 98 76 42 53 95 60 81 58 93
输出样例：
98 95 93
42 37 81
53 20 76
58 60 76

思路：对于每一个插入的数，顺序都是先往右边插入，再往下边插入，再往左边插入，最后往上插入，设置一个flag，标记当前插入的方向，若遇到边界则换下一个方向。

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>

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

int main()
{
    int N;
    int m = 0, n = 0;
    scanf("%d", &N);
    int i,j,k;
    int *buf = (int *)malloc(sizeof(int) * N);

    for(i = 0; i < N; i++)
    {
        scanf("%d", &buf[i]);
    }
    qsort(buf, N, sizeof(int), cmp);


    //求出m, n 
    m = N;
    n = 1;
    for(i = N; i > 0; i--)
    {
        if(N % i == 0)
        {
            if(i - N / i < 0)
                break;
            if(i - N / i < m -n)
            {
                m = i;
                n = N / i;
            }
        }
    }

    //动态分配二维数组
    int **p = (int **)malloc(sizeof(int *) * m);
    for(i = 0; i < m; i++)
    {
        p[i] = (int *)malloc(sizeof(int) * n);
    }
    for(i = 0; i < m; i++)
    {
        for(j = 0; j < n; j++)
        {
            p[i][j] = 0;
        }
    }


    i = 0;
    j = 0;
    k = 0;
    int flag = 0;
    for(k = 0; k < N; k++)
    {
        /*判断时，先判断是否到达数组边界，再判断那个位上是否已经有数字，因为先访问数组会出现访问越界的情况*/
        if(flag == 0) //向右插入
        {
            if(j < n && p[i][j] == 0) //可以插入
            {
                p[i][j] = buf[k];
                j++;
                continue;
            }
            else //向下插入
            {
                flag = 1;
                p[++i][--j] = buf[k];
                i++; 
                continue;

            }
        }
        if(flag == 1) //向下插入
        {
            if(i < m && p[i][j] == 0) //可以插入
            {
                p[i][j] = buf[k];
                i++;
                continue;
            }
            else //向左插入
            {
                flag = 2;
                p[--i][--j] = buf[k];
                j--;
                continue;
            }
        }
        if(flag == 2) //向左插入
        {
            if(j >=0 && p[i][j] == 0)
            {
                p[i][j] = buf[k];
                j--;
                continue;
            }
            else //向上插入
            {
                flag = 3;
                p[--i][++j] = buf[k];
                i--;
                continue;
            }
        }
        if(flag == 3) // 向上插入
        {
            if(i >= 0 && p[i][j] == 0)
            {
                p[i][j] = buf[k];
                i--;
                continue;
            }
            else //向右
            {
                flag = 0;
                p[++i][++j] = buf[k];
                j++;
                continue;
            }
        }
    }

    for(i = 0; i < m; i++)
    {
        for(j = 0; j < n; j++)
        {
            if(j != n - 1)
            {
                printf("%d ", p[i][j]);
            }
            else 
                printf("%d", p[i][j]);
        }
        printf("\n");
    }

    return 0;
}