thảo luận Leetcode mỗi ngày

class Solution {
    public int[][] spiralMatrix(int m, int n, ListNode head) {
        int[][] matrix = new int[m][n];
        int[][] direction = new int[][]{{0,1},{1,0},{0,-1},{-1,0}};
        int[] size = new int[]{n,m-1};
        int x = 0;
        int y = -1;
        int index = 0;
        for(int[] mat:matrix)
            Arrays.fill(mat,-1);
        ListNode node = head;
        while(node!=null){
            for(int[] d:direction){
                int k = size[index];
                for(int i = 0;i<k && node!=null;i++){
                    x+=d[0];
                    y+=d[1];   
                    matrix[x][y] = node.val;                               
                    node = node.next;
                }
                size[index]--;
                index = (index+1)%2;
            }           
        }
        return matrix;
    }
}

class Solution {
public:
    vector<vector<int>> spiralMatrix(int m, int n, ListNode* head) {
        vector<vector<int>> ret(m, vector<int>(n, -1));
        array<pair<int, int>, 4> adj = {make_pair(0,1), make_pair(1,0), make_pair(0,-1), make_pair(-1,0) };
        for (int i = 0, j = 0, x = 0, y = 1, dir = 0; head != nullptr; i += x, j += y, head = head->next) {
            ret[i][j] = head->val;
            int next_x = i + x, next_y = j + y;
            if (next_x < 0 || next_x >= m || next_y < 0 || next_y >= n || ret[next_x][next_y] != -1) {
                dir = (dir + 1)%4;
                std::tie(x, y) = adj[dir];
            }
        }
        return ret;
    }
};

class Solution {
public:
    vector<vector<int>> spiralMatrix(int m, int n, ListNode* head) {
        
        vector<vector<int>> ans(m, vector<int>(n, -1));
        vector<vector<int>> directions = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
        int mode = 0;

        int col = 0, row = 0;

        while (head) {
            ans[row][col] = head->val;
            head = head->next;

            int nextRow = row + directions[mode][0];
            int nextCol = col + directions[mode][1];

            if (nextRow >= m || nextRow < 0 || nextCol >= n || nextCol < 0 || ans[nextRow][nextCol] != -1) {
                mode = (mode + 1) % 4;
                nextRow = row + directions[mode][0];
                nextCol = col + directions[mode][1];
            }

            row = nextRow;
            col = nextCol;
        }

        return ans;
    }
};

public class Solution
{
    public int[][] SpiralMatrix(int m, int n, ListNode head)
    {
        int[][] result = new int[m][];
        for (int row = 0; row < m; row++)
        {
            result[row] = new int[n];
            for (int col = 0; col < n; col++)
            {
                result[row][col] = -1;
            }
        }

        int[][] dirs = { [0, 1], [1, 0], [0, -1], [-1, 0] };
        
        int dirIndex = 0;
        int[] coord = [0, -1];

        int remain = m * n;
        bool horTravel = true;
        m--;
        while (true)
        {
            int count = horTravel ? n : m;
            int[] dir = dirs[dirIndex];
            for (int i = 0; i < count; i++)
            {
                coord[0] += dir[0];
                coord[1] += dir[1];
                result[coord[0]][coord[1]] = head == null ? -1 : head.val;
                remain--;
                head = head.next;
                if (remain == 0 || head == null)
                {
                    goto Result;
                }
            }
            if (horTravel)
                n--;
            else
                m--;
            horTravel = !horTravel;
            dirIndex = (dirIndex + 1) % 4;
        }

        Result:
        return result;
    }
}