Leetcode 腾讯50题 day7

Leetcode 腾讯50题 day7

No.54 螺旋矩阵

题目描述

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

输入:
[
  [1, 2, 3, 4],
  [5, 6, 7, 8],
  [9,10,11,12]
]
输出: [1,2,3,4,8,12,11,10,9,5,6,7]

我的思路

这是一道模拟题，就是按照题目给出的思路实现就可解出的题。我这里的主要思路是定义好前进的方向与是否访问过该元素的矩阵，因为整个矩阵的遍历是顺时针的，因此总是按照右、下、左、上的顺序在循环，因此用一个数组保存方向，只要当前方向的下一个值可以访问，就到下一个值，否则就切换到下一个方向继续尝试，当所有方向的下一个值都没法访问时遍历结束。我的方法空间复杂度是O(n²)，leetcode题解中有O(1)的方法，更巧妙一些。

主要有两点比较常用我觉得值得分享：

1. 处理类似迷宫、矩阵的某个方向的值这种类似的题，可以定义好一个方向列表，如[[0,1], [1,0], [0,-1], [-1,0]]，这样用原来的坐标加上这个列表的值就是下一个点的坐标
2. for…else语句: python里的for语句和c++/java不同的地方是，for可以和else搭配使用，表示for里的结果都执行完之后如果没被break则跳入else，是比较实用的一个方法

代码

class Solution:
    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
        if len(matrix)==0:
            return []
        res = []
        m, n = len(matrix), len(matrix[0])
        x, y = 0, 0
        d = [[0,1], [1,0], [0,-1], [-1,0]]
        flag = [[0 for i in range(n)] for j in range(m)]
        direction = 0
        while True:
            res.append(matrix[x][y])
            flag[x][y] = 1
            for i in range(4):
                xx, yy = x+d[(direction+i)%4][0], y+d[(direction+i)%4][1]
                if 0<=xx<m and 0<=yy<n and flag[xx][yy]==0:
                    x, y = xx, yy
                    direction = (direction+i) % 4
                    break
            else:
                break
        return res

No.59 螺旋矩阵II

题目描述

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

输入: 3
输出:
[
 [ 1, 2, 3 ],
 [ 8, 9, 4 ],
 [ 7, 6, 5 ]
]

我的思路

这还是一道模拟题，与上题很类似我都用了方向的方法来处理，由于本题是方阵，在纸上自己画的时候发现在给每个格子赋值的时候有一种规律，就是除了第一行以外，剩余的行，每两次变换方向，就减少一个赋值长度，如下图所示

上图以6x6的方阵为例，第一行要填充6个值，接下来的两个方向是向下和向左，各填充5个值，继续按照顺时针的下两个方向，即向上和向右，再填充4个值…循环到填充到n²个值为止，图中相同颜色标注的是填充值相同的两段，颜色越深填充值越少。

代码

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        d = [[0,1], [1,0], [0,-1], [-1,0]]
        if n==0:
            return []
        res = [[0 for i in range(n)] for i in range(n)]
        #先填充第一行
        for i in range(n):
            res[0][i] = i+1
        t = n+1
        direction = 1 #接下来的方向是向下的
        counter = 2
        total = n**2
        fill_nums = n-1
        x, y = 0, n-1
        #按顺时针方向填充值，每两次方向变换减少一个填充值的数量
        while t<=total:
            for i in range(fill_nums):
                x = x + d[direction][0]
                y = y + d[direction][1]
                res[x][y] = t
                t += 1
            counter -= 1
            direction = (direction+1) % 4
            if counter==0:
                fill_nums -= 1
                counter = 2
        return res

No.61 旋转链表

题目描述

给定一个链表，旋转链表，将链表每个节点向右移动 k 个位置，其中 k 是非负数。

输入: 1->2->3->4->5->NULL, k = 2
输出: 4->5->1->2->3->NULL
解释:
向右旋转 1 步: 5->1->2->3->4->NULL
向右旋转 2 步: 4->5->1->2->3->NULL

我的思路

链表的算法中最常涉及的是先行指针，即使用不同的指针依次访问链表，每个指针的快慢不同，或者出发时间不同，以此来达到处理链表中多个结点。

在本题中，由题意可以知道其实只需改动两个结点就可以达成目的，一个是原链表中最后一个结点，需要将其下一个结点改为原链表的头结点；另一个要改动的是在旋转之后成为最后一个结点的那个结点，在原链表中需要将其下一个结点改成空，并注意将该节点的下一个结点赋值成目标链表的头结点，这里实现时要稍稍注意一下赋值的先后顺序。

因此找到这两个要改动的结点就可以解决问题，因此可以想到先行指针，让一个指针先移动k对总长度的取模，然后两个指针再同时移动，当右边的指针到结尾时，左边的指针便是目标链表的结尾。

代码

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def rotateRight(self, head: ListNode, k: int) -> ListNode:
        if head == None:
            return None
        p = head
        cnt = 1
        while p.next != None:
            p = p.next
            cnt += 1
        k = k % cnt
        left, right = head, head
        for i in range(k):
            right = right.next
        while right.next != None:
            left = left.next
            right = right.next
        right.next = head
        head = left.next
        left.next = None
        return head