在螺旋矩阵中找到指定索引处的元素

什么是螺旋矩阵？

螺旋矩阵是指一个矩阵，其中的元素以螺旋形状排列。

下图是一个4 × 4的螺旋矩阵：

1  2  3  4
12 13 14 5
11 16 15 6
10 9  8  7

问题描述

给定一个正整数n和一个二维数组matrix，其中$matrix$是一个n x n的矩阵，同时定义它的“螺旋顺序”为矩阵中元素按照正方形外围循环顺序遍历形成的一维数组。例如，上面的4 × 4矩阵的螺旋顺序就是：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

现在，给定一个整数$x$，请你返回矩阵中第$x$个元素（$1 \leq x \leq n^2$）。

解法

方法一：按层模拟

我们可以发现，每次螺旋遍历都是从外层到内层，而每一层的长度是$2 \times (n-1) + 2 \times (n-3) + ...$。我们可以计算出$x$位于哪一层的范围内，然后在这一层中进行查找。

具体步骤如下：

1. 计算出$x$所在层的范围[start, end]，其中start表示此层第一个元素的下标，end表示此层最后一个元素的下标。
2. 计算出$x$在此层中的偏移量offset，简单来说，就是$x$在此层中的位置与此层第一个元素的位置之差。
3. 根据start和offset计算出$x$在矩阵中的坐标(row, col)，其中row表示行，col表示列。

代码如下：

class Solution:
    def findElement(self, matrix: List[List[int]], x: int) -> int:
        n = len(matrix) # 矩阵的大小
        start = 0 # 当前层的第一个元素的下标
        offset = x - 1 # 当前层中x的偏移量
        while offset >= 0:
            # 计算出当前层的范围
            end = start + 2 * (n - 1)
            if n <= 2:
                end = start + n - 1

            # 计算出x在当前层中的位置
            if offset <= end - start:
                row, col = self.convert(start, end, offset, n)
                return matrix[row][col]

            # 继续在下一层中查找
            start = start + 2
            n = n - 4
            offset = offset - (end - start + 1)

    def convert(self, start, end, offset, n):
        """
        将一维下标转换为二维下标
        """
        # 计算出矩阵中第一个元素的行、列
        row, col = start, start
        # direction表示方向，0表示向右，1表示向下，2表示向左，3表示向上
        direction = 0
        for i in range(offset):
            if direction == 0:
                if col < end:
                    col = col + 1
                else:
                    row = row + 1
                    direction = 1
            elif direction == 1:
                if row < end:
                    row = row + 1
                else:
                    col = col - 1
                    direction = 2
            elif direction == 2:
                if col > start:
                    col = col - 1
                else:
                    row = row - 1
                    direction = 3
            else:
                if row > start:
                    row = row - 1
                else:
                    col = col + 1
                    direction = 0
        return row, col

代码的时间复杂度为$O(n)$，空间复杂度为$O(1)$。

方法二：按圈数计算

第二种方法是按照圈数计算$x$的位置。我们可以先遍历外层圈数，将外围圈数上的元素遍历完，然后再遍历内层圈数。

具体步骤如下：

1. 计算出$x$所在层的圈数k，其中圈数从外向内依次为0, 1, 2, ...，每一圈包含$2 \times (n-1) + 2 \times (n-3) + ...$个元素。
2. 计算出$x$在此层中的偏移量offset，简单来说，就是$x$在此层中的位置与此层第一个元素的位置之差。
3. 根据k和offset计算出$x$在矩阵中的坐标(row, col)。

具体实现可以参考下面的代码：

class Solution:
    def findElement(self, matrix: List[List[int]], x: int) -> int:
        n = len(matrix) # 矩阵的大小
        k = 0 # 当前的圈数
        while 2 * k < n:
            # 计算出当前层的范围
            start = k
            end = n - k - 1

            # 计算出此层的元素个数
            count = 2 * (n - 2 * k) + 2 * (n - 2 * k - 2)

            # 计算出x在当前层中的偏移量
            offset = (x - 1) % count

            # 计算出x在当前层中的行和列
            row, col = self.convert(start, end, offset, n)

            # 计算出x的值
            x = matrix[row][col]

            # 更新圈数
            k = k + 1

        return x

    def convert(self, start, end, offset, n):
        """
        将一维下标转换为二维下标
        """
        # 计算出矩阵中第一个元素的行、列
        row, col = start, start
        # direction表示方向，0表示向右，1表示向下，2表示向左，3表示向上
        direction = 0
        for i in range(offset):
            if direction == 0:
                if col < end:
                    col = col + 1
                else:
                    row = row + 1
                    direction = 1
            elif direction == 1:
                if row < end:
                    row = row + 1
                else:
                    col = col - 1
                    direction = 2
            elif direction == 2:
                if col > start:
                    col = col - 1
                else:
                    row = row - 1
                    direction = 3
            else:
                if row > start:
                    row = row - 1
                else:
                    col = col + 1
                    direction = 0
        return row, col

代码的时间复杂度为$O(n)$，空间复杂度为$O(1)$。

总结

本题的核心思路是确定$x$在矩阵中的坐标，然后返回相应的值。我们可以按层模拟或按圈数计算。具体实现时，需要注意细节问题。