力扣刷题笔记螺旋矩阵 IV

前言

本文是为了记录思路，便于日后进行题目分析。

正文

首先为了模仿整个链表转换为二维数组的形式，写了好几个循环来表示其迭代的过程，将其变化的结果输出了出来，发现head的输出方法可以外加上一个变量来进行记录，同时由于只是一个变量又不会说是增加太多空间复杂度，为了便于思路继续下去，所以添加一个变量，未添加前容易因为写这个过程比较麻烦而搞混，导致Track Error，不利于代码思路进行下去：

m = 3
n = 5
head = [3,0,2,6,8,1,7,9,4,2,5,5,0]
mat=list()
for i in range(m):
    mat.append([0]*n)
print(mat)
# 0~n-1
for i in range(n):
    mat[0][i]=head[i]
    print(mat)
# n~n+m-1
for j in range(m):
    mat[j][-1]=head[n+j]
    print(mat)
# n+m~
for i in range(n):
    mat[-1][n-1-i]=head[n+m+i-1]
    print(mat)
for j in range(m-1):
    mat[m-j-1][0]=head[n+m+n-2+j]
    print(mat)
    '''
未报错前的结果：
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
[[3, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
[[3, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
[[3, 0, 2, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
[[3, 0, 2, 6, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
[[3, 0, 2, 6, 8], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
[[3, 0, 2, 6, 1], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
[[3, 0, 2, 6, 1], [0, 0, 0, 0, 7], [0, 0, 0, 0, 0]]
[[3, 0, 2, 6, 1], [0, 0, 0, 0, 7], [0, 0, 0, 0, 9]]
[[3, 0, 2, 6, 1], [0, 0, 0, 0, 7], [0, 0, 0, 0, 9]]
[[3, 0, 2, 6, 1], [0, 0, 0, 0, 7], [0, 0, 0, 4, 9]]
[[3, 0, 2, 6, 1], [0, 0, 0, 0, 7], [0, 0, 2, 4, 9]]
[[3, 0, 2, 6, 1], [0, 0, 0, 0, 7], [0, 5, 2, 4, 9]]
[[3, 0, 2, 6, 1], [0, 0, 0, 0, 7], [5, 5, 2, 4, 9]]
[[3, 0, 2, 6, 1], [0, 0, 0, 0, 7], [5, 5, 2, 4, 9]]
[[3, 0, 2, 6, 1], [0, 0, 0, 0, 7], [5, 5, 2, 4, 9]]
'''

在添加完变量idx表示对应的head里的元素下标后，又对原本的head遍历方法进行了优化，具体优化算法为：设置一个边界，用这个边界来区分填充的元素，具体方法如下：

def add_new():
    bond=len(head)    
    if idx>=bond:        
        return -1
    else:
        return head[idx]
    
m = 3
n = 5
head = [3,0,2,6,8,1,7,9,4,2,5,5,0]
mat=list()
idx=-1

for i in range(m):
    mat.append([0]*n)
print(mat)

for i in range(n):
    idx+=1
    mat[0][i]=add_new()
    print(mat)

for j in range(1,m):
    idx+=1
    mat[j][-1]=add_new()
    print(mat)

for i in range(n-2,-1,-1):
    idx+=1
    mat[-1][i]=add_new()
    print(mat)

for j in range(m-2,0,-1):
    idx+=1
    mat[j][0]=add_new()
    print(mat)

for i in range(1,n-1):
    idx+=1
    mat[1][i]=add_new()
    print(mat)
'''
迭代过程如下：
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
[[3, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
[[3, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
[[3, 0, 2, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
[[3, 0, 2, 6, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
[[3, 0, 2, 6, 8], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
[[3, 0, 2, 6, 8], [0, 0, 0, 0, 1], [0, 0, 0, 0, 0]]
[[3, 0, 2, 6, 8], [0, 0, 0, 0, 1], [0, 0, 0, 0, 7]]
[[3, 0, 2, 6, 8], [0, 0, 0, 0, 1], [0, 0, 0, 9, 7]]
[[3, 0, 2, 6, 8], [0, 0, 0, 0, 1], [0, 0, 4, 9, 7]]
[[3, 0, 2, 6, 8], [0, 0, 0, 0, 1], [0, 2, 4, 9, 7]]
[[3, 0, 2, 6, 8], [0, 0, 0, 0, 1], [5, 2, 4, 9, 7]]
[[3, 0, 2, 6, 8], [5, 0, 0, 0, 1], [5, 2, 4, 9, 7]]
[[3, 0, 2, 6, 8], [5, 0, 0, 0, 1], [5, 2, 4, 9, 7]]
[[3, 0, 2, 6, 8], [5, 0, -1, 0, 1], [5, 2, 4, 9, 7]]
[[3, 0, 2, 6, 8], [5, 0, -1, -1, 1], [5, 2, 4, 9, 7]]
'''

利用idx还有一个好处，就是可以判断是否迭代完成整个矩阵，即是否填满了整个螺旋矩阵，当idx=m*n-1时，说明迭代完成。旋转四次为一个循环，之后只需要用while写一个循环即可实现整个的迭代过程，由此理论，对代码进行优化：

def add_new():
    if idx>=len(head):        
        return -1
    else:
        return head[idx]
    
m = 3
n = 5
head = [3,0,2,6,8,1,7,9,4,2,5,5,0]
mat=list()
idx=-1
m_head=0
n_head=0

for i in range(m):
    mat.append([0]*n)
print(mat)
print(m*n-1)
while True:
    for i in range(n_head,n-n_head):
        idx+=1
        mat[0+m_head][i]=add_new()
        print(mat)
    bond=m*n-1
    if idx>=bond:
        break

    for j in range(1+m_head,m-m_head):
        idx+=1
        mat[j][-1+n_head]=add_new()
        print(mat)
    bond=m*n-1
    if idx>=bond:
        break

    for i in range(n-2-n_head,-1+n_head,-1):
        idx+=1
        mat[-1-m_head][i]=add_new()
        print(mat)
    bond=m*n-1
    if idx>=bond:
        break

    for j in range(m-2-m_head,0+m_head,-1):
        idx+=1
        mat[j][0+n_head]=add_new()
        print(mat)
    bond=m*n-1
    if idx>=bond:
        break

    n_head+=1
    m_head+=1
'''
输出的结果与第一次结果完全一致：
[[3, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
[[3, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
[[3, 0, 2, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
[[3, 0, 2, 6, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
[[3, 0, 2, 6, 8], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
[[3, 0, 2, 6, 8], [0, 0, 0, 0, 1], [0, 0, 0, 0, 0]]
[[3, 0, 2, 6, 8], [0, 0, 0, 0, 1], [0, 0, 0, 0, 7]]
[[3, 0, 2, 6, 8], [0, 0, 0, 0, 1], [0, 0, 0, 9, 7]]
[[3, 0, 2, 6, 8], [0, 0, 0, 0, 1], [0, 0, 4, 9, 7]]
[[3, 0, 2, 6, 8], [0, 0, 0, 0, 1], [0, 2, 4, 9, 7]]
[[3, 0, 2, 6, 8], [0, 0, 0, 0, 1], [5, 2, 4, 9, 7]]
[[3, 0, 2, 6, 8], [5, 0, 0, 0, 1], [5, 2, 4, 9, 7]]
[[3, 0, 2, 6, 8], [5, 0, 0, 0, 1], [5, 2, 4, 9, 7]]
[[3, 0, 2, 6, 8], [5, 0, -1, 0, 1], [5, 2, 4, 9, 7]]
[[3, 0, 2, 6, 8], [5, 0, -1, -1, 1], [5, 2, 4, 9, 7]]
'''

与我们这里写的不同的是，力扣中考察的是我们对于链表的基础知识的掌握，所以我们需要对于链表有个清晰的认知，val代表的是其数值，next表示下一个的地址，在这个理论基础上，我们可以对已有的代码改造，将loop写为leetcode中可以使用的代码：

# 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]]:    
        def add_new():
            if head==None:        
                return -1
            else:
                return head.val
        mat=list()
        idx=-1
        m_head=0
        n_head=0

        for i in range(m):
            mat.append([0]*n)

        while True:
            for i in range(n_head,n-n_head):
                idx+=1
                if i!=0:
                    try:
                        head=head.next
                    except:
                        pass
                mat[0+m_head][i]=add_new()
                print(mat)
            bond=m*n-1
            if idx>=bond:
                break

            for j in range(1+m_head,m-m_head):
                idx+=1
                try:
                    head=head.next
                except:
                    pass
                mat[j][-1+n_head]=add_new()
                print(mat)
            bond=m*n-1
            if idx>=bond:
                break

            for i in range(n-2-n_head,-1+n_head,-1):
                idx+=1
                try:
                    head=head.next
                except:
                    pass
                mat[-1-m_head][i]=add_new()
                print(mat)
            bond=m*n-1
            if idx>=bond:
                break

            for j in range(m-2-m_head,0+m_head,-1):
                idx+=1
                try:
                    head=head.next
                except:
                    pass
                mat[j][0+n_head]=add_new()
                print(mat)
            bond=m*n-1
            if idx>=bond:
                break

            n_head+=1
            m_head+=1
        return mat

在修改好之后，一部分可以正常输出，但是有的也不能正常输出，检查原因得出有一部分应该是-1的元素，我添加之后变为了0：

再次检查代码发现，是一个loop中的变化出错，检查的时候由于输出的矩阵实在是过大，所以不得不显示为矩阵的形式来进行阅读：

可以看出其变化没有按照其应该的方式变换，因此说明代码出现问题：

在修改之后，更改leetcode中代码，发现输出溢出：

将print的东西关闭后，提交成功：

不过由于用了太多的循环之类的导致了时间复杂度很高，时间上用的时间很久，但是由于多余的参数就只有一个变量idx以及两个迭代的参数，所以空间上还可以，总之可以进步的空间还很大，之后可以进行相关优化。