蛇形填充阶梯方阵 | 豆包MarsCode AI刷题

蛇形填充阶梯方阵 | 豆包MarsCode AI刷题

蛇形填充n阶方阵 - MarsCode

简单题，控制边界进行循环填充就可以了

问题描述

小L面临一个有趣的任务：在一个 $n \times n$ 的方阵中填入 $1$ 到 $n \times n$ 这些数字，并要求按照蛇形顺序从右上角开始，沿着方阵的边界顺时针填充。

例如，当 $n = 4$ 时，方阵应如下所示：

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

目标是编写程序输出填充完成的方阵，确保格式正确。

---

测试样例

样例 1

• 输入：n = 4
• 输出：[[10, 11, 12, 1], [9, 16, 13, 2], [8, 15, 14, 3], [7, 6, 5, 4]]

样例 2

• 输入：n = 5
• 输出：[[13, 14, 15, 16, 1], [12, 23, 24, 17, 2], [11, 22, 25, 18, 3], [10, 21, 20, 19, 4], [9, 8, 7, 6, 5]]

样例 3

• 输入：n = 3
• 输出：[[7, 8, 1], [6, 9, 2], [5, 4, 3]]

---

算法分析

1. 蛇形填充的逻辑

蛇形填充矩阵要求按照以下顺序进行：

1. 从右上角开始向下填充列。
2. 到达底部后，向左填充行。
3. 到达左侧后，向上填充列。
4. 到达顶部后，向右填充行。

在每次填充后，调整矩阵的边界（上下左右四条边），继续按顺序填充。

2. 矩阵边界

• 定义边界：
  • 维护四个边界：上（top）、下（bottom）、左（left）、右（right）。
  • 初始时 top = 0，bottom = n - 1，left = 0，right = n - 1。

在每次填充完成后，更新相应边界以缩小填充范围。

3.停止条件：

• 当 top > bottom 或 left > right 时，填充结束。

4. 时间复杂度

该算法对矩阵中的每个元素访问一次，因此时间复杂度为 $O(n^2)$。

---

算法实现

Python实现

def solution(n: int) -> list:
    """
    构建一个 n x n 的矩阵，以蛇形顺序填充数字。
    """
    # 初始化矩阵
    matrix = [[0] * n for _ in range(n)]

    # 初始化边界
    top, bottom, left, right = 0, n - 1, 0, n - 1
    num = 1

    # 按照蛇形顺序填充矩阵
    while num <= n * n:
        # 从上到下填充右侧列
        for i in range(top, bottom + 1):
            matrix[i][right] = num
            num += 1
        right -= 1  # 收缩右侧边界

        # 从右到左填充底部行
        for i in range(right, left - 1, -1):
            matrix[bottom][i] = num
            num += 1
        bottom -= 1  # 收缩底部边界

        # 从下到上填充左侧列
        if left <= right:
            for i in range(bottom, top - 1, -1):
                matrix[i][left] = num
                num += 1
            left += 1  # 收缩左侧边界

        # 从左到右填充顶部行
        if top <= bottom:
            for i in range(left, right + 1):
                matrix[top][i] = num
                num += 1
            top += 1  # 收缩顶部边界

    return matrix


if __name__ == "__main__":
    # 测试用例
    print(solution(4) == [[10, 11, 12, 1], [9, 16, 13, 2], [8, 15, 14, 3], [7, 6, 5, 4]])  # 应输出 True
    print(solution(5) == [[13, 14, 15, 16, 1], [12, 23, 24, 17, 2], [11, 22, 25, 18, 3], [10, 21, 20, 19, 4], [9, 8, 7, 6, 5]])  # 应输出 True
    print(solution(3) == [[7, 8, 1], [6, 9, 2], [5, 4, 3]])  # 应输出 True

---

Go实现

package main

import (
	"fmt"
	"reflect"
)

func solution(n int) [][]int {
	// 初始化矩阵
	matrix := make([][]int, n)
	for i := range matrix {
		matrix[i] = make([]int, n)
	}

	// 初始化边界
	top, bottom, left, right := 0, n-1, 0, n-1
	num := 1

	// 蛇形填充，按题目顺序
	for num <= n*n {
		// 从上到下填充右侧列
		for i := top; i <= bottom; i++ {
			matrix[i][right] = num
			num++
		}
		right-- // 收缩右侧边界

		// 从右到左填充底部行
		for i := right; i >= left; i-- {
			matrix[bottom][i] = num
			num++
		}
		bottom-- // 收缩底部边界

		// 从下到上填充左侧列
		if left <= right {
			for i := bottom; i >= top; i-- {
				matrix[i][left] = num
				num++
			}
			left++ // 收缩左侧边界
		}

		// 从左到右填充顶部行
		if top <= bottom {
			for i := left; i <= right; i++ {
				matrix[top][i] = num
				num++
			}
			top++ // 收缩顶部边界
		}
	}

	return matrix
}

func main() {
	fmt.Println(reflect.DeepEqual(solution(4), [][]int{{10, 11, 12, 1}, {9, 16, 13, 2}, {8, 15, 14, 3}, {7, 6, 5, 4}}))
	fmt.Println(reflect.DeepEqual(solution(5), [][]int{{13, 14, 15, 16, 1}, {12, 23, 24, 17, 2}, {11, 22, 25, 18, 3}, {10, 21, 20, 19, 4}, {9, 8, 7, 6, 5}}))
	fmt.Println(reflect.DeepEqual(solution(3), [][]int{{7, 8, 1}, {6, 9, 2}, {5, 4, 3}}))
}

---