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

class Solution {
    func spiralMatrix(_ m: Int, _ n: Int, _ head: ListNode?) -> [[Int]] {
        let r = Array(repeating:-1, count:n)
        var result = Array(repeating:r, count:m)
       
        var row = 0
        var col = 0
        var head = head
        var padding = 0 // 0 top, 1: right, 2: bottom, 3: left
        var idx = 0

        var maxCol = 0
        var minCol = 0
        var maxRow = 0
        var minRow = 0
        func calBorder() {
            maxCol = n - idx - 1
            maxRow = m - idx - 1
            minCol = idx
            minRow = 1 + idx
        }
        calBorder()

        while head != nil {
            result[row][col] = head!.val
            head = head!.next
           
            if padding == 0 {
                col += 1
                if col > maxCol {
                    col = maxCol
                    row += 1
                    padding = 1
                }
            } else if padding == 1 {
                row += 1
                if row > maxRow {
                    row = maxRow
                    col -= 1
                    padding = 2
                }
            } else if padding == 2 {
                col -= 1
                if col < minCol {
                    col = minCol
                    row -= 1
                    padding = 3
                }
            } else {
                row -= 1
                if row < minRow {
                    row = minRow
                    col += 1
                    padding = 0
                    idx += 1
                    calBorder()
                }
            }
           
        }

        return result
    }
}

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    int[][] res;
    ListNode head;
    public int[][] spiralMatrix(int m, int n, ListNode head) {
        this.res = new int[m][n];
        this.head = head;
        for (int[] r : res) {
            Arrays.fill(r, -1);
        }
        for (int i = 0; i < (m - 1) / 2 + 1; i++) {
            if (head == null) {
                return res;
            }
            buildMatrix(i, i, m - 1 - i, n - 1 - i);
        }
        return res;
    }

    private void buildMatrix(int y, int x, int row, int col) {
        if (col < x) {
            return;
        }
        for (int i = x; i <= col; i++) {
            if (head != null) {
                res[y][i] = head.val;
                head = head.next;
            } else {
                return;
            }
        }

        for (int i = y + 1; i <= row - 1; i++) {
            if (head != null) {
                res[i][col] = head.val;
                head = head.next;
            } else {
                return;
            }
        }

        if (y == row) {
            return;
        }

        for (int i = col; i >= x; i--) {
            if (head != null) {
                res[row][i] = head.val;
                head = head.next;
            } else {
                return;
            }
        }

        if (x == col) {
            return;
        }

        for (int i = row - 1; i >= y + 1; i--) {
            if (head != null) {
                res[i][x] = head.val;
                head = head.next;
            } else {
                return;
            }
        }
    }
}

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def spiralMatrix(self, m: int, n: int, head: Optional[ListNode]) -> List[List[int]]:
        grid = [[-1 for _ in range(n)] for _ in range(m)]
        curr = head
        # go_right
        col = 0
        col_end = n
        row = 0
        row_end = m
        while curr:
            # go right
            for i in range(col, col_end, 1):
                if not curr:
                    return grid
                grid[row][i] = curr.val
                curr = curr.next
            row += 1
            # go down
            for i in range(row, row_end, 1):
                if not curr:
                    return grid
                grid[i][col_end - 1] = curr.val
                curr = curr.next
            col_end -= 1    
            # go left
            
            for i in range(col_end - 1, col - 1, -1):
                if not curr:
                    return grid
                grid[row_end - 1][i] = curr.val
                curr = curr.next
            row_end -= 1
            
            # go up
            for i in range(row_end - 1, row - 1, -1):
                if not curr:
                    return grid
                grid[i][col] = curr.val
                curr = curr.next
            col += 1

        return grid

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

        auto next_step = [&](int r, int c) -> bool {
            if (r < 0 || r >= m || c < 0 || c >= n) return true;
            if (ans[r][c] != -1) return true;
            return false;
        };

        int current_step = 0, r = 0, c = 0;
        ListNode* node = head;
        while (node != nullptr) {
            auto step = steps[current_step];
            if (next_step(r + step.first, c + step.second)) {
                current_step = (current_step + 1) % steps.size();
                step = steps[current_step];
            }
            ans[r][c] = node->val;
            r += step.first;
            c += step.second;
            node = node->next;
        }

        return ans;
    }
};

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def spiralMatrix(self, m: int, n: int, head: Optional[ListNode]) -> List[List[int]]:

        arr = [[-1 for _ in range(n)] for _ in range(m)]

        left, right = 0, n
        top, bottom = 0, m

        while left < right and top < bottom:
            for i in range (left, right):
                if head is not None:
                    arr[top][i] = head.val
                    head = head.next
                
            top += 1

            for i in range (top, bottom):
                if head is not None:
                    arr[i][right - 1] = head.val
                    head = head.next
                
            right -= 1

            for i in range (right - 1, left - 1, -1):
                if head is not None:
                    arr[bottom - 1][i] = head.val
                    head = head.next
                
            bottom -= 1

            for i in range (bottom - 1, top - 1, -1):
                if head is not None:
                    arr[i][left] = head.val
                    head = head.next
                
            left += 1


        return arr

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def spiralMatrix(self, m: int, n: int, head: Optional[ListNode]) -> List[List[int]]:
        res = [[-1 for _ in range(n)] for _ in range(m)]
        l , r , t , b = 0 , n - 1 , 0 , m - 1
        while head:
            # left
            for i in range(l , r + 1):
                if not head: break
                res[t][i] = head.val
                head = head.next
            t += 1
            #down
            for i in range(t , b + 1):
                if not head: break
                res[i][r] = head.val
                head = head.next
            r -= 1
            #right
            for i in range(r , l - 1 , -1):
                if not head: break
                res[b][i] = head.val
                head = head.next
            b -= 1
            # up
            for i in range(b , t - 1 , -1):
                if not head: break
                res[i][l] = head.val
                head = head.next
            l += 1
            
        return res

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def spiralMatrix(self, m: int, n: int, head: Optional[ListNode]) -> List[List[int]]:
        res = [[-1 for _ in range(n)] for _ in range(m)]
        direction = [[0 , 1] , [1 , 0], [0 , -1] , [-1 , 0]]
        i , j , k = 0 , 0 , 0
        while head:
            res[i][j] = head.val
            x = i + direction[k][0]
            y = j + direction[k][1]
            if x < 0 or y < 0 or x >= m  or y >= n or res[x][y] != -1: k = (k + 1) % 4 #move
            i += direction[k][0]
            j += direction[k][1]
            head = head.next
            
        return res

function spiralMatrix(m: number, n: number, head: ListNode | null): number[][] {
    const res = new Array(m).fill(null).map(item => Array(n).fill(-1));
    let i = 0, j = 0, idx = 0;
    const dirs = [[0,1], [1, 0], [0, -1], [-1, 0]];
    while(head) {
        res[i][j] = head.val;
        const ii = i + dirs[idx][0], jj = j + dirs[idx][1];
        if (ii < 0 || jj < 0 || ii >=m || jj >=n || res[ii][jj] !== -1) idx = (idx + 1) % 4;
        i+= dirs[idx][0], j+= dirs[idx][1]
        head = head.next
    }
    return res;
};

impl Solution {
    pub fn spiral_matrix(m: i32, n: i32, mut head: Option<Box<ListNode>>) -> Vec<Vec<i32>> {
        let (mut i, mut j) = (0, 0);

        // [up, right, down, left];
        let deltas = [(-1, 0), (0, 1), (1, 0), (0, -1)];
        let mut cur_dir = 1;

        let mut result = vec![vec![-1; n as usize]; m as usize];

        while let Some(mut node) = head {
            result[i as usize][j as usize] = node.val;

            let (di, dj) = deltas[cur_dir];
            let (next_i, next_j) = (i + di, j + dj);

            if !(0 <= next_i && next_i < m && 0 <= next_j && next_j < n) || result[next_i as usize][next_j as usize] != -1 {
                cur_dir = (cur_dir + 1) % 4;
                let (di, dj) = deltas[cur_dir];
                (i, j) = (i + di, j + dj);
            } else {
                (i, j) = (next_i, next_j);
            }

            head = node.next.take();
        }

        result
    }
}