Day2:剑指offer

最新推荐文章于 2023-03-13 15:26:56 发布

try_trying_try

最新推荐文章于 2023-03-13 15:26:56 发布

阅读量137

点赞数

分类专栏：刷题

本文链接：https://blog.csdn.net/u012114900/article/details/105398469

版权

刷题专栏收录该内容

14 篇文章 1 订阅

订阅专栏

6.二叉树的下一个结点
给定一个二叉树和其中的一个结点，请找出中序遍历 [左，根，右] 顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。
如果给定的节点是中序遍历序列的最后一个，则返回空节点;
二叉树一定不为空，且给定的节点一定不是空节点；(这句没懂)

思路：遇到这种’第一感觉’复杂的题，画出二叉树的结构图，via具体的例子找出中序遍历下一个节点的规律
#解析:
#1.当此节点有右子树，下一个节点就是右子树中最左侧的节点。
#2.当此节点没有右子树时，
#2.1 若它是它父节点的左节点，那么下一个节点就是它的父节点
#2.2 若不是，就沿着父指针向上遍历，直到找到一个是它父节点的左节点，这个父节点就是我们要找的下一个节点。

# class TreeLinkNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#         self.next = None
class Solution:
    def GetNext(self, pNode):
        if not pNode: return
        if pNode.right:     #节点有右子树，则下一个节点就是它右子树的最左节点
            pRight = pNode.right   #移动节点可以不用初始化，一直在移动，而不是头指针(need初始化 LikeNode(0))
            while pRight.left:
                pRight = pRight.left
            return pRight

        while pNode.next:  #节点没有右子树，沿着父节点，直到找到是它父节点的左节点
            parent = pNode.next
            if parent.left == pNode:
                return parent
            pNode = parent
        return

用两个栈实现队列，支持如下四种操作：
push(x) – 将元素x插到队尾；
pop() – 将队首的元素弹出，并返回该元素；
peek() – 返回队首元素；
empty() – 返回队列是否为空；

知识：栈 (空间)由操作系统自动分配释放 [一级缓存]通常是被调用时处于存储空间中，调用完立即释放
栈操作系统会给每个线程创建一个栈用来存储函数调用时各个函数的参数、返回地址及临时变量等
队列前端(队头指针) 删除操作后端(队尾指针) 插入操作

 #[法一]在**出队**时保证队先进先出的特性
 #push(x)：直接将x插入栈1中，时间复杂度O(1)
#pop()：队列是先进先出，栈是先进后出，所以将栈1所有的元素放入栈2中，
#此时最先进入的元素在栈2的顶部，弹出即可。下次若栈2不为空，直接弹出栈顶元素即可。时间复杂度O(n)

#栈可以有.append操作
class Solution:
    def __init__(self):  #need自己定义两个stack:s1  s2
        self.s1 = []
        self.s2 = []
    def push(self, node):
        self.s1.append(node)
    def pop(self):
    # return xx
        if self.s2:
            return self.s2.pop()  # 递归
        #else:                     #有无else都OK  
        while self.s1:        
            self.s2.append(self.s1.pop()) #s2.append一定是从s1.pop(),才能保证s1清空
        return self.s2.pop() 
    def peek(self)->int:
        if self.s2:
            return self.s2[-1]   #栈位置上的last[-1] 是队首元素 [后进先出]
        while self.s1:
            self.s2.append(self.s1.pop())
        return self.s2[-1]
    def empty(self)->bool:
        if self.s1 or self.s2:
            return False
        else:   #else也可不要
            return True

 #[法二]在**入队**时就保证队先进先出的特性
class Solution:
    def push(self, node:int):
        while self.s1:
            self.s2.append(self.s1.pop())
        self.s1.append(node)
        while self.s2:
            self.s1.append(self.s2.pop())

    def pop(self):
    # return xx
        return self.s1.pop()

7.1 用两个队列实现一个栈使用队列实现栈的下列操作：(给的都是将要实现栈函数的描述)
push(x) – 元素 x 入栈
pop() – 移除栈顶元素
top() – 获取栈顶元素
empty() – 返回栈是否为空

 #[法二]在**入栈**时就保证队先进先出的特性
class Solution:
    def __init__(self):  #定义两个deque[队列要导入模块，栈noneed]
        from collections import deque
        self.q1 = deque()
        self.q2 = deque()
    def push(self, node:int)->None:
        while self.q1:
            self.q2.append(self.q1.popleft())  #.popleft()是'配合一致'队列的'先进先出'
        self.q1.append(node)
        while self.q2:
            self.q1.append(self.q2.popleft())
    def pop(self)->int:
        return self.q1.popleft()
        
    def top(self)->int:
        return self.q1[0]  #只需获取一个元素，can't use .popleft()
    def empty(self)->bool:
        if self.q1 or self.q2:
            return False
        return True

8.斐波那契数列
该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。
F(0) = 0, F(1) = 1
F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
给定 N，计算 F(N)。

摘录：如果 interviewer没有特别的要求，则可以尽量多采用递归的方法编程。简洁（如不可，可考虑用栈模拟递归的过程）

#自己写空间复杂度O(n)，等价于空间换时间
class Solution:
    def Fibonacci(self, n):
        # write code here
        if n<2: return n
        f = [0]*(n+1)     #小注意点:长度为n+1
        f[0],f[1] = 0,1
        for i in range(2,n+1):
            f[i]= f[i-1] + f[i-2]
        return f[n]

#题解
class Solution: """递归+滚动变量(节约空间复杂度) 对by self code Improve"""
    def Fibonacci(self, n):
        if n<2: return n
        f0,f1,fn = 0,1,0  #must要有fn
        for _ in range(2,n+1):
            fn = f0+f1
            f0,f1 = f1,fn
        return fn

#or
def Fibonacci(self, n):
        if n<2: return n
        f0,f1,fn = 0,1,0  #must要有fn
        i = 2
        while i<=n:
            f[i]= f[i-1] + f[i-2]
            i +=1
        return f[n]

class Solution: """递归+滚动变量(节约空间复杂度) 对by self code Improve"""
    def Fibonacci(self, n):
        if n<2: return n
        f0,f1,fn = 0,1,0  #must要有fn
        for _ in range(2,n+1):
            fn = f0+f1
            f0,f1 = f1,fn
        return fn

class Solution: """（仅学习思想）递归最精髓解释，时间复杂度O(2^n);运行时间太长不通过"""
    def Fibonacci(self, n):
        if n<2: return n
        return self.Fibonacci(n-1)+self.Fibonacci(n-2)

小技巧

def mul(a,b): # 首先定义二阶矩阵乘法运算
    c = [[0,0],[0,0]]
    for i in range(2):
        for j in range(2):
            for k in range(2):
                c[i][j] +=a[i][k] * b[k][j]
    return c
    
def multiply(A,n):
    res = [[1, 0],
           [0, 1]]  # 单位矩阵，等价于1，作为base
    while n:                     #停止条件 n == 1
        if n&1: res = mul(res,A) #位运算(二进制运算) 等价于 奇数&1返回1，偶数&1返回0
        A = mul(A,A)
        n = n>>1  #位运算(二进制运算) 等价于 除以2且向下取整
    return res[0][1]

8.1青蛙跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

 class Solution:
    def jumpFloor(self, number):
        if number<3: return number
        f1,f2,fn = 1,2,0
        for _ in range(3, number+1):
            fn = f1+f2
            f1,f2 = f2,fn
        return fn

8.2 青蛙变态跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法

每个台阶都有跳与不跳两种情况（除了最后一个台阶），最后一个台阶必须跳。.

class Solution:
    def jumpFloorII(self, number):
        return 2**(number-1)

8.3 矩形覆盖问题
可以用2x1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2x1的小矩形无重叠地覆盖一个2xn的大矩形，总共有多少种方法？

#完全同8.2
 class Solution:
    def rectCover(self, n):
        if n<3: return n
        f1,f2,fn = 1,2,0
        for _ in range(3,n+1):
            fn = f1+f2
            f1,f2  = f2,fn
        return fn

旋转数组的最小数字
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

class Solution:
    def minNumberInRotateArray(self, rotateArray):
        rotateArray.sort()  #.sort()同.reverse() 该方法没有返回值，但是会对列表的对象进行排序 改变变量值
        return rotateArray[0]

#题解：'二分法'类似
class Solution:
    def minNumberInRotateArray(self, nums: list[int]) -> int:
        if not nums: return
        n = len(nums)-1 #起码有两个元素
        if n == 1 or nums[0]< nums[n]:return nums[0]  #特殊测试的考虑
        while n>0 and nums[0] == nums[n]:  # 找到第一个小于nums[0]的数
            n -=1
        l,r = 0, n    
        while l<r:
            mid = 1+r >>1  #运算符优先级：乘除-加减-左移/右移
            if nums[mid]>=nums[l]:
                l = mid
            else:
                r = mid
        return nums[r]

矩阵中的最长递增路径
Leecode 329. DFS深度优先搜索
给定一个整数矩阵，找出*最长递增路径的长度*。
对于每个单元格，你可以往上，下，左，右四个方向移动。你不能在对角线方向上移动或移动到边界外（即不允许环绕）。

方法一：代码清晰
方法二：效率最高
方法三：代码简洁

#先搭建框架，再填细节
class Solution:
    def longestIncreasingPath(self, matrix: list[list[int]]) -> int:
        if not matrix or not matrix[0]: return 0

        row, col = len(matrix),len(matrix[0])
        lookup = [[0]*col for _ in range(row)]  #ultima长度记录
        def dfs(i,j):
            if lookup[i][j]!=0:         #要标记，已走过的不再去
                return lookup[i][j]
            res=1  #temp长度记录
            for x,y in [[-1,0],[1,0],[0,1],[0,-1]]:  #往下一步
                temp_i, temp_j=x+i, y+j   #自由性：all可移动点
                if 0<=temp_i<row and 0<=temp_j<col and matrix[temp_i][temp_j]>matrix[i][j]:                    #有效性：不能出边界
                    res = max(res,1+dfs(temp_i,temp_j))  #*
            lookup[i][j] = max(res, lookup[i][j]) #不懂为啥要用max#
            return lookup[i][j]
        return max(dfs(i,j) for i in range(row) for j in range(col))

        # 方法二
        def dfs(i, j):
            if lookup[i][j]!=0:         #要标记，已走过的不再去
                return lookup[i][j]
            lookup[i][j]= 1+max(
                dfs(i+1,j) if 0<=i+1<row and 0<=j<col and matrix[i+1][j]>matrix[i][j] else 0,
                dfs(i-1,j), ...
                dfs(i,j+1), ...
                dfs(i,j-1),...,
            )
            return lookup[i][j]
#格式：max(dfs() if ... else 0)

        # 方法三
        #(方法二的code简化)
        def dfs(i, j):
            if lookup[i][j] != 0:  # 要标记，已走过的不再去
                return lookup[i][j]
            lookup[i][j] = 1 + max(
                [dfs(i + x, y + j) for x, y in [[-1, 0], [1, 0], [0, 1], [0, -1]] \
                 if 0 <= (i + x) < row and 0 <= (j + y) < col and matrix[i + x][j + y] > matrix[i][j]] or [0]
            )   
            return lookup[i][j]
#格式：max([dfs() for _ in [] if ... ] or [0])

#方法一(res = max(res,1+dfs(temp_i,temp_j))#*) 递归code从外往里'剥'算[从后往前算]；实质求结果，从里(最初)往外get solution 
#用#*算dfs(i,j)隐含lookup[i][j]==0，其实是路径(temp_i,temp_j)->(i,j),故res=1+dfs(temp_i,temp_j)；
#再与(其它不通过(temp_i,temp_j))->(i,j)路径长度相比res;
#最终，res = max(res,1+dfs(temp_i,temp_j))

扩展：
一个3*n矩阵a,将a中每列的三个数字中取出一个按顺序组成一个长度为n的数组b,即 $b_i$ 可以是 $a_{1,i}, a_{2,i}, a_{3,i}$ 其中任意一个。问 $\Sigma_{i=1}^{n-1}|b_i-b_{i+1}|$ 的最小值是多少？
在这里插入图片描述

n = int(input())
arr=[]
for i in range(3):
    arr.append( list(map(int,input().split())) )

col = len(arr[0])
dp = [[0]*col for _ in range(3)]  #min记录 每个位置
for j in range(1,col):
    dp[0][j] = min( abs(arr[0][j-1]-arr[0][j])+dp[0][j-1],abs(arr[1][j-1]-arr[0][j])+dp[1][j-1],abs(arr[2][j-1]-arr[0][j])+dp[2][j-1] )
    dp[1][j] = min( abs(arr[0][j-1]-arr[1][j])+dp[0][j-1],abs(arr[1][j-1]-arr[1][j])+dp[1][j-1],abs(arr[2][j-1]-arr[1][j])+dp[2][j-1])
    dp[2][j] = min( abs(arr[0][j-1]-arr[2][j])+dp[0][j-1],abs(arr[1][j-1]-arr[2][j])+dp[1][j-1],abs(arr[2][j-1]-arr[2][j])+dp[2][j-1] )
print( min(dp[0][col-1], dp[1][col-1], dp[2][col-1]) )

 总结：太长可以分开想了再写
 dp[0][j] = min( abs(arr[0][j-1]-arr[0][j])+dp[0][j-1],abs(arr[1][j-1]-arr[0][j])+dp[1][j-1],abs(arr[2][j-1]-arr[0][j])+dp[2][j-1] )
#A = abs(arr[0][j-1]-arr[0][j])
#B0 = abs(arr[0][j-1]-arr[0][j])+dp[0][j-1]
#B1
#B2
#dp[0][j] = min(B0, B1, B2 )

try_trying_try

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Day2:剑指offer

6.二叉树的下一个结点给定一个二叉树和其中的一个结点，请找出中序遍历 [左，根，右] 顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。如果给定的节点是中序遍历序列的最后一个，则返回空节点;二叉树一定不为空，且给定的节点一定不是空节点；(这句没懂)思路：遇到这种’第一感觉’复杂的题，画出二叉树的结构图，via具体的例子找出中序遍历下一个节点的规律#...
复制链接

扫一扫