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;
}