矩阵变换

1、给定一个正整数 n，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        if n == 0: return []
        row = col = n
        ans = [[False] * row for _ in range(col)]
        dr = [0, 1, 0, -1]
        dc = [1, 0, -1, 0]
        r = c = di = 0

        for v in range(1, row * col + 1):
            ans[r][c] = v
            cr, cc = r + dr[di], c + dc[di]
            if 0 <= cr < row and 0 <= cc < col and not ans[cr][cc]:
                r = cr
                c = cc
            else:
                di = (di + 1) % 4
                r, c = r + dr[di], c + dc[di]
        
        return ans
    def generate(self,n):
        list0=[j for j in range(1,n**2+1)]
        x=y=0
        dx=[0,1,0,-1]
        dy=[1,0,-1,0]
        di=0
        visited=set()
        list1=[[None]*n for _ in range(n)]
        for i in range(n**2):
            list1[x][y]=i 
            visited.add((x,y))
            nx,ny=x+dx[di],y+dy[di]
            if 0<=nx<m and 0<=ny<n and (nx,ny) not in visited:
                x,y=nx,ny 
            else:
                di=(di+1)%4 
                x,y=x+dx[di],y+dy[di]
        return list1

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

class Solution:
    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
        if not matrix:return []

        x=y=0 
        res = [] 
        dx = [ 0, 1, 0,-1]                        
        dy = [ 1, 0,-1, 0]                        
        di = 0                                    
        visited = set()                           
        m,n = len(matrix),len(matrix[0])          
                
        for i in range(m*n):                                     
            res.append(matrix[x][y])                             
            visited.add((x,y))                                   
            tx,ty = x+dx[di],y+dy[di]                            
            if 0<=tx<m and 0<=ty<n and (tx,ty) not in visited:   
                x,y = tx,ty                                       
            else:                                                
                di = (di+1)%4                                    
                x,y = x + dx[di],y+dy[di]                        
        return res

    #def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
        #res = []
        #while matrix:
            #res += matrix.pop(0)
            #matrix = list(map(list, zip(*matrix)))[::-1]
        #return res

3、给你一幅由 N × N 矩阵表示的图像，其中每个像素的大小为 4 字节。请你设计一种算法，将图像旋转 90 度。

不占用额外内存空间能否做到？

class Solution:
    def rotate(self,matrix):
        length=len(matrix)
        matrix[:]=matrix[::-1]
        #for i in range(length//2):
            #for j in range(length):
                #tmp=matrix[i][j]
                #matrix[i][j]=matrix[length-i-i][j]
                #matrix[length-1-i][j]=tmp
        for i in range(length):
            for j in range(i):
                matrix[j][i],matrix[i][j]=matrix[i][j],matrix[j][i]
        #matrix[:]=matrix[::-1] 逆时针旋转

4、给定一个正整数 n，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        list0 = [j for j in range(1,n**2 + 1)]                         
        x = y = 0
        dx = [0,1,0,-1]                                                
        dy = [1,0,-1,0]
        di = 0
        visited = set()                                                 
        list1 = [[None for k in range(n)] for k in range(n)]            
        for i in range(n**2):
            list1[x][y] = list0[i]                                      
            visited.add((x,y))
            nx,ny = x + dx[di],y+dy[di]                                 
            if 0<=nx<n and 0<=ny<n and (nx,ny) not in visited:          
                x,y = nx,ny
            else:
                di = (di+1)%4
                x,y= x+dx[di],y+dy[di]
        return list1