LeetCode HuaWei 机试可能题目 python

以下题目来源LeetCode

递归：LeetCode 70、112、509
70. 爬楼梯
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

class Solution:
    def climbStairs(self, n: int) -> int:
        f1=1
        f2=2
        if n==1:
            return 1
        if n==2:
            return 2
        for i in range(3,n+1):
            f=f1+f2
            f1=f2
            f2=f
        return f

112 路径总和

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        path_sum=[]
        def dfs(node,sum_):
            if node==None:
                return 
            if node.left==None and node.right==None:
                sum_=sum_+node.val
                path_sum.append(sum_)
                return
            sum_=sum_+node.val
            dfs(node.left,sum_)
            dfs(node.right,sum_)
            sum_=sum_-node.val
        sum_=0
        dfs(root,sum_)
        # print(path_sum)
        if targetSum in path_sum:
            return True
        else:
            return False

509. 斐波那契数
斐波那契数 （通常用 F(n) 表示）形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：

F(0) = 0，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1
给定 n ，请计算 F(n) 。

class Solution:
    def fib(self, n: int) -> int:
        f0=1
        f1=1
        if n==0:
            return 0
        if n<3:
            return  1
        for i in range(3,n+1):
            f=f0+f1
            f0=f1
            f1=f
        return f

分治 LeetCode 23 169 240
23. 合并 K 个升序链表
给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
        if len(lists)==0:
            return None
        head=[]
        for list_node in lists:
            while(list_node):
                head.append(list_node.val)
                list_node=list_node.next
        head=sorted(head)

        start_node=ListNode()
        res_node=start_node
        for i in range(0,len(head)):
            curr=ListNode(head[i])
            res_node.next=curr
            res_node=res_node.next
        return start_node.next
#可以考虑利用分治思想，先两两有序数组进行合并，一直循环下去，只能只剩一个

240. 搜索二维矩阵 II
编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target 。该矩阵具有以下特性：

每行的元素从左到右升序排列。
每列的元素从上到下升序排列。
169. 多数元素
给定一个大小为 n 的数组 nums ，返回其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
你可以假设数组是非空的，并且给定的数组总是存在多数元素。

class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        count={}
        for i in nums:
            if i not in count:
                count[i]=1
            else:
                count[i]=count[i]+1
        
        count=sorted(count.items(), key=lambda x:x[1], reverse=True)
        # if count[0][1]>int(len(nums)/2):
        return count[0][0]

直接按序排序，下标为n/2一定是众数
class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        nums.sort()
        return nums[len(nums) // 2]
**可以利用分治思想**
使用经典的分治算法递归求解，直到所有的子问题都是长度为 1 的数组。长度为 1 的子数组中唯一的数显然是众数，直接返回即可。如果回溯后某区间的长度大于 1，我们必须将左右子区间的值合并。如果它们的众数相同，那么显然这一段区间的众数是它们相同的值。否则，我们需要比较两个众数在整个区间内出现的次数来决定该区间的众数。

class Solution:
    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
        hang=len(matrix)
        lie=len(matrix[0])
        cur=matrix[0][lie-1]
        cur_hang=0
        cur_lie=lie-1
        while(cur_hang<hang and cur_lie>=0):
            cur=matrix[cur_hang][cur_lie]
            if target==cur:
                return True
            elif target<cur:
                cur_lie=cur_lie-1
            elif target>cur:
                cur_hang=cur_hang+1
        if cur==target:
            return True
        else:
            return False

单调栈
LeetCode 84 85 739 503

84. 柱状图中最大的矩形
给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。
求在该柱状图中，能够勾勒出来的矩形的最大面积。

明天再写吧