[leetcode]2326. Spiral Matrix IV

https://leetcode.com/problems/spiral-matrix-iv/description/

You are given two integers m and n, which represent the dimensions of a matrix.

You are also given the head of a linked list of integers.

Generate an m x n matrix that contains the integers in the linked list presented in spiral order (clockwise), starting from the top-left of the matrix. If there are remaining empty spaces, fill them with -1.

Return the generated matrix.

Example 1:

Input: m = 3, n = 5, head = [3,0,2,6,8,1,7,9,4,2,5,5,0]

Output: [[3,0,2,6,8],[5,0,-1,-1,1],[5,2,4,9,7]]

Explanation: The diagram above shows how the values are printed in the matrix.

Note that the remaining spaces in the matrix are filled with -1.

Example 2:

Input: m = 1, n = 4, head = [0,1,2]

Output: [[0,1,2,-1]]

Explanation: The diagram above shows how the values are printed from left to right in the matrix.

The last space in the matrix is set to -1.

Constraints:

• 1 <= m, n <= 105

• 1 <= m * n <= 105

• The number of nodes in the list is in the range [1, m * n].

• 0 <= Node.val <= 1000

思路参考：https://blog.csdn.net/xiaocong1990/article/details/72723535?ops_request_misc=&request_id=79cf4509942d453c88e8be61258a6d85&biz_id=&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~koosearch~default-4-72723535-null-null.268^v1^control&utm_term=Spiral%20Matrix&spm=1018.2226.3001.4450

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> spiralMatrix(int n, int m, ListNode* head) 
    {
        // Create a matrix of n x m with values filled with -1.
        vector<vector<int>> spiral(n, vector<int>(m, -1));
        int u = 0, d = n - 1, l = 0, r = m - 1;

        while (head != NULL)
        {
            // up
            for (int col = l; col <= r && head!= NULL && spiral[u][col] == -1; col++) {
                spiral[u][col] = head->val;
                head = head->next;
            }
            if (head == NULL || ++u > d)
                break;
     
            // right
            for (int row = u; row <= d && head!= NULL && spiral[row][r] == -1; row++) {
                spiral[row][r] = head->val;
                head = head->next;
            }
            if (head == NULL || --r < l) 
                break;

            // down
            for (int col = r; col >= l && head!= NULL && spiral[d][col] == -1; col--) {
                spiral[d][col] = head->val;
                head = head->next;
            }
            if (head == NULL || --d < u) 
                break;

            // left
            for (int row = d; row >= u && head!= NULL && spiral[row][l] == -1; row--) {
                spiral[row][l] = head->val;
                head = head->next;
            }
            if (head == NULL || ++l > r) 
                break;

        }
        // Rest values are itself -1.
        return spiral;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */

class Solution {
public:
    vector<vector<int>> spiralMatrix(int n, int m, ListNode* head) 
    {
        // Create a matrix of n x m with values filled with -1.
        vector<vector<int>> spiral(n, vector<int>(m, -1));
        int i = 0, j = 0;
        // Traverse the matrix in spiral form, and update with the values present in the head list.
        // If head reacher NULL pointer break out from the loop, and return the spiral matrix.
        while (head != NULL)
        {
            if (j < m)
            {
                while (head != NULL && j < m && spiral[i][j] == -1)
                {
                    spiral[i][j] = head->val;
                    head = head->next;
                    j++;
                }
                if (head == NULL)
                    break;
                i++;
                j--;
            }
            if (i < n)
            {
                while (head != NULL && i < n && spiral[i][j] == -1)
                {
                    spiral[i][j] = head->val;
                    head = head->next;
                    i++;
                }
                if (head == NULL)
                    break;
                i--;
                j--;
            }
            if (j >= 0)
            {
                while (head != NULL && j >= 0 && spiral[i][j] == -1)
                {
                    spiral[i][j] = head->val;
                    head = head->next;
                    j--;
                }
                if (head == NULL)
                    break;
                j++;
                i--;
            }
            if (i >= 0)
            {
                while (head != NULL && i >= 0 && spiral[i][j] == -1)
                {
                    spiral[i][j] = head->val;
                    head = head->next;
                    i--;
                }
                if (head == NULL)
                    break;
                i++;
                j++;
            }
            n--;
            m++;
        }
        // Rest values are itself -1.
        return spiral;
    }
};