顺时针生成数组

给定一个n，生成一个数组，要求：
1、中间位置为1，从1开始顺时针生成2，3，4.
如下例所示：

'''
n=1时，
生成[1]

n=2时，
生成
[[1, 2], 
 [4, 3]]
 
n=3时，
生成
[[7, 8, 9], 
 [6, 1, 2], 
 [5, 4, 3]]

n=4时，
生成
[[7, 8, 9, 10], 
 [6, 1, 2, 11], 
 [5, 4, 3, 12], 
 [16, 15, 14, 13]]


n=5时，
生成
[[21, 22, 23, 24, 25], 
 [20, 7, 8, 9, 10], 
 [19, 6, 1, 2, 11], 
 [18, 5, 4, 3, 12], 
 [17, 16, 15, 14, 13]]
'''

'''
解题思路：先找到1所在的位置，也就是中间位置，然后按规则生成更改数组中对应的元素。
'''
class Solution():
    def get_res(self, n):
        if n == 1:
            return [1]
        dp = [[0]*n for _ in range(n)]
        #中心
        index_i = (n-1)//2
        num = 1
        dp[index_i][index_i] = 1
        self.backtrack(dp, index_i, index_i+1, num+1, next_step="down")
        return dp
    
    def backtrack(self, dp, i, j, num, next_step):
        if i<0 or i >= len(dp) or j <0 or j >=len(dp):
            return
        dp[i][j] = num
        num += 1
        # 判断下一侧是否是0
        if next_step == "right":
            cur_j = j+1
            if i+1 == len(dp):
                return
            while cur_j < len(dp) and dp[i+1][cur_j] != 0:
                dp[i][cur_j] = num
                cur_j += 1
                num += 1
            self.backtrack(dp, i, cur_j, num, next_step="down")

        if next_step == "down":
            cur_i = i+1
            if j-1 == -1:
                return
            while cur_i < len(dp) and dp[cur_i][j-1] != 0:
                dp[cur_i][j] = num
                cur_i += 1
                num += 1
            self.backtrack(dp, cur_i, j, num, next_step="left")
        
        if next_step == "left":
            cur_j = j-1
            if i-1 == -1:
                return
            while cur_j >=0 and dp[i-1][cur_j] != 0:
                dp[i][cur_j] = num
                cur_j -= 1
                num += 1
            self.backtrack(dp, i, cur_j, num, next_step="up")
        
        if next_step == "up":
            cur_i = i-1
            if j+1 == len(dp):
                return
            while cur_i >=0 and dp[cur_i][j+1] != 0:
                dp[cur_i][j] = num
                cur_i -= 1
                num += 1
            self.backtrack(dp, cur_i, j, num, next_step="right")
        
        return
        
solu = Solution()
res = solu.get_res(5)
print(res)