每日一练 — 2021.12.02

---

一、跳跃游戏

1、程序简介

• 给定一个非负整数数组，你最初位于数组的第一个位置。
• 数组中的每个元素代表你在该位置可以跳跃的最大长度。
• 你的目标是使用最少的跳跃次数到达数组的最后一个位置。

示例:

输入:

[2,3,1,1,4]

输出:

2
解释: 跳到最后一个位置的最小跳跃数是 2。从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。

说明:

假设你总是可以到达数组的最后一个位置。

2、程序代码

# -*- coding: utf-8 -*-
"""
Created on Thu Dec  2 07:38:28 2021
Function:
@author: 小梁aixj
"""
class Solution:
    def jump(self, nums):
        if len(nums) <= 1:
            return 0
        end = 0 + nums[0]
        start = 0
        step = 1
        maxDis = 0 + nums[0]
        while end < len(nums) - 1:
            for i in range(start + 1, end + 1):
                maxDis = max(maxDis, nums[i] + i)
            start = end
            end = maxDis
            step  += 1
        return step
    
#%%
s = Solution()
print(s.jump(nums = [2,3,0,1,4]))

3、运行结果

二、无重复字符的最长子串

1、程序简介

给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

• 输入: s = “abcabcbb”
• 输出: 3
• 解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。

示例 2:

• 输入: s = “bbbbb”
• 输出: 1
• 解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。

示例 3:

• 输入: s = “pwwkew”
• 输出: 3
• 解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。
• 请注意，你的答案必须是 子串 的长度，“pwke” 是一个子序列，不是子串。

示例 4:

• 输入: s = “”
• 输出: 0

提示：

• 0 <= s.length <= 5 * 104
• s 由英文字母、数字、符号和空格组成

2、程序代码

# -*- coding: utf-8 -*-
"""
Created on Thu Dec  2 07:42:29 2021
Function:
@author: 小梁aixj
"""
class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        i = 0
        j = 0
        m = 0
        hset = {}
        while j < len(s):
            char = s[j]
            index = hset.get(char)
            if index is not None and index>i:
                i=index
            m=m if m >j-i+1 else j-i+1
            hset[char] = j+1
            j+=1
        return m
#%%
s=Solution()
print(s.lengthOfLongestSubstring('abcabcbb'))
print(s.lengthOfLongestSubstring('bbbbb'))
print(s.lengthOfLongestSubstring('pwwkew'))
print(s.lengthOfLongestSubstring(''))

3、运行结果

三、二叉树的中序遍历

1、程序简介

给定一个二叉树的根节点 root ，返回它的 中序 遍历。

示例 1：

• 输入：root = [1,null,2,3]
• 输出：[1,3,2]

示例 2：

• 输入：root = []
• 输出：[]

示例 3：

• 输入：root = [1]
• 输出：[1]

示例 4：

• 输入：root = [1,2]
• 输出：[2,1]

示例 5：

• 输入：root = [1,null,2]

• 输出：[1,2]

提示：

• 树中节点数目在范围 [0, 100] 内

• -100 <= Node.val <= 100

• 进阶: 递归算法很简单，你可以通过迭代算法完成吗？

2、程序代码

# -*- coding: utf-8 -*-
"""
Created on Thu Dec  2 07:42:55 2021
Function:
@author: 小梁aixj
"""
class TreeNode(object):
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
class List2Tree(object):
    def __init__(self, nums: list):
        self.nums = nums
        self.queue = []
        if len(nums) == 1:
            self.root = TreeNode(self.nums.pop(0))
        else:
            a=self.nums.pop(0)
            b=self.nums.pop(0)
            c=self.nums.pop(0)
            self.root=TreeNode(a)
            if b is not None:
                self.root.left=TreeNode(b)
            else:
                self.root.left=b
            if c is not None:
                self.root.right=TreeNode(c)
            else:
                self.root.right = c
            self.queue.append(self.root.left)
            self.queue.append(self.root.right)
    def convert(self):
        while len(self.nums) > 0 and len(self.queue) > 0:
            node = self.queue.pop(0)
            if node is not None:
                num = self.nums.pop(0)
                if num is not None:
                    node.left = TreeNode(num)
                else:
                    node.left = num
                if len(self.nums) > 0:
                    num = self.nums.pop(0)
                else:
                    num = None
                if num is not None:
                    node.right = TreeNode(num)
                else:
                    node.right = num
                self.queue.append(node.left)
                self.queue.append(node.right)
        return self.root
class Solution(object):
    def inorderTraversal(self, root):
        if root is None:
            return []
        root = List2Tree(root).convert()
        res = []
        stack=[root]
        while len(stack) > 0:
            curr=stack.pop()
            if not isinstance(curr, TreeNode):
                res.append(curr)
                continue
            if curr.right is not None:
                stack.append(curr.right)
            stack.append(curr.val)
            if curr.left is not None:
                stack.append(curr.left)
        return res
#%%
s = Solution()
print(s.inorderTraversal(root = [1,None,2,3]))
print(s.inorderTraversal(root = [1,None,2]))

3、运行结果