小白试水——leetcode腾讯题库-54.螺旋矩阵（Python解答）

题目54：螺旋矩阵

给定一个包含 m x n 个元素的矩阵（m 行, n 列），请按照顺时针螺旋顺序，返回矩阵中的所有元素。

示例 1:

输入:
[
 [ 1, 2, 3 ],
 [ 4, 5, 6 ],
 [ 7, 8, 9 ]
]

输出: [1,2,3,6,9,8,7,4,5]

示例 2:

输入:
[
  [1, 2, 3, 4],
  [5, 6, 7, 8],
  [9,10,11,12]
]

输出: [1,2,3,4,8,12,11,10,9,5,6,7]

思路一: 模拟过程

通过控制行的上下边界,列的左右边界

class Solution(object):
    def spiralOrder(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: List[int]
        """
        if not matrix:
            return []
        res = []
        u_i = 0
        d_i = len(matrix)-1
        l_j = 0
        r_j = len(matrix[0])-1
        while u_i <= d_i and l_j <= r_j:
            # 从左到右
            for i in range(l_j,r_j+1):
                res.append(matrix[u_i][i])
            u_i += 1
            if u_i > d_i:
                break
            # 从上到下
            for i in range(u_i,d_i+1):
                res.append(matrix[i][r_j])
            r_j -= 1
            if l_j > r_j:
                break
            # 从右到左
            for i in range(r_j,l_j-1,-1):
                res.append(matrix[d_i][i])
            d_i -= 1
            # 从下到上
            for i in range(d_i,u_i-1,-1):
                res.append(matrix[i][l_j])
            l_j += 1
        return res 

思路二: 旋转（类似吃蛋卷）

直接举例子,

把弹出输出即可.

class Solution(object):
    def spiralOrder(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: List[int]
        """
        if not matrix:
            return []
        res = []
        while matrix:
            res.extend(matrix.pop(0))
            next_matrix = []
            if matrix == []:
                break
            # print(matrix)
            for i in zip(*matrix):
                next_matrix.append((i))
            # print(next_matrix)
            matrix = next_matrix[::-1]
        return res

思路三：模拟

直觉

绘制螺旋轨迹路径，我们发现当路径超出界限或者进入之前访问过的单元格时，会顺时针旋转方向。

算法

假设数组有 R 行 C 列，seen[r][c] 表示第 r 行第 c 列的单元格之前已经被访问过了。当前所在位置为 (r, c)，前进方向是 di。我们希望访问所有 C 个单元格。

当我们遍历整个矩阵，下一步候选移动位置是 (cr, cc)。如果这个候选位置在矩阵范围内并且没有被访问过，那么它将会变成下一步移动的位置；否则，我们将前进方向顺时针旋转之后再计算下一步的移动位置。

class Solution(object):
    def spiralOrder(self, matrix):
        if not matrix:
        	return []
        R, C = len(matrix), len(matrix[0])
        seen = [[False] * C for _ in matrix]
        ans = []
        dr = [0, 1, 0, -1]
        dc = [1, 0, -1, 0]
        r = c = di = 0
        for _ in range(R * C):
            ans.append(matrix[r][c])
            seen[r][c] = True
            cr, cc = r + dr[di], c + dc[di]
            if 0 <= cr < R and 0 <= cc < C and not seen[cr][cc]:
                r, c = cr, cc
            else:
                di = (di + 1) % 4
                r, c = r + dr[di], c + dc[di]
        return ans

复杂度分析

时间复杂度： O(N)，其中 N 是输入矩阵所有元素的个数。因为我们将矩阵中的每个元素都添加进答案里。
空间复杂度： O(N)，需要两个矩阵 seen 和 ans 存储所需信息。

思路四：按层模拟

直觉

答案是最外层所有元素按照顺时针顺序输出，其次是次外层，以此类推。

算法

我们定义矩阵的第 k 层是到最近边界距离为 k 的所有顶点。例如，下图矩阵最外层元素都是第 1 层，次外层元素都是第 2 层，然后是第 3 层的。

[[1, 1, 1, 1, 1, 1, 1],
 [1, 2, 2, 2, 2, 2, 1],
 [1, 2, 3, 3, 3, 2, 1],
 [1, 2, 2, 2, 2, 2, 1],
 [1, 1, 1, 1, 1, 1, 1]]

对于每层，我们从左上方开始以顺时针的顺序遍历所有元素，假设当前层左上角坐标是 (r1, c1)，右下角坐标是 (r2, c2)。

首先，遍历上方的所有元素 (r1, c)，按照 c = c1,…,c2 的顺序。然后遍历右侧的所有元素 (r, c2)，按照 r = r1+1,…,r2 的顺序。如果这一层有四条边（也就是 r1 < r2 并且 c1 < c2 ），我们以下图所示的方式遍历下方的元素和左侧的元素。

class Solution(object):
    def spiralOrder(self, matrix):
        def spiral_coords(r1, c1, r2, c2):
            for c in range(c1, c2 + 1):
                yield r1, c
            for r in range(r1 + 1, r2 + 1):
                yield r, c2
            if r1 < r2 and c1 < c2:
                for c in range(c2 - 1, c1, -1):
                    yield r2, c
                for r in range(r2, r1, -1):
                    yield r, c1

        if not matrix: return []
        ans = []
        r1, r2 = 0, len(matrix) - 1
        c1, c2 = 0, len(matrix[0]) - 1
        while r1 <= r2 and c1 <= c2:
            for r, c in spiral_coords(r1, c1, r2, c2):
                ans.append(matrix[r][c])
            r1 += 1; r2 -= 1
            c1 += 1; c2 -= 1
        return ans

复杂度分析

时间复杂度： O(N)，其中 N 是输入矩阵所有元素的个数。因为我们将矩阵中的每个元素都添加进答案里。
空间复杂度： O(N)，需要矩阵 ans 存储信息。

一行代码

class Solution:
    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
        return matrix and [*matrix.pop(0)] + self.spiralOrder([*zip(*matrix)][::-1])