python每日一题【剑指 Offer 38. 字符串的排列】【剑指 Offer 55 - II. 平衡二叉树】

day35-2022.12.01

题目信息来源

作者：Krahets

链接：https://leetcode.cn/leetbook/read/illustration-of-algorithm

来源：力扣（LeetCode）

剑指 Offer 38. 字符串的排列

输入一个字符串，打印出该字符串中字符的所有排列。

你可以以任意顺序返回这个字符串数组，但里面不能有重复元素。

输入：s = "abc"
输出：["abc","acb","bac","bca","cab","cba"]

题解：个人题解

好像是要用递归解，我就这样做了，但看起来和遍历似乎没啥区别，速度很慢，超时边缘，除了代码比较短？看看官方题解怎么做吧还是。

思路上没有问题，但是字符串反复创建，修改很费时。

class Solution:
    def permutation(self, s: str) -> str:
        def issue(pre, now):
            if len(pre)==len(s) and pre not in result:
                result.append(pre)
                return
            for i in range(len(now)):
                issue(pre + now[i], now[0:i]+now[i+1:])
        
        result = []
        issue('', s)
        return result

题解：官方题解

思路虽然和我的一样，但是在处理的时候用了技巧，即通过直接交换列表里元素的顺序来查找组合，这样处理的速度就会很快，之后再通过回溯的方式，这个题应该是递归和回溯用的比较综合的题，但很显然我没有做到。

class Solution:
    def permutation(self, s: str) -> List[str]:
        def issue(idx):
            if idx==len(s)-1:
                result.append(''.join(s))
                return
            dic = set()
            for i in range(idx, len(s)):
                if s[i] in dic:continue
                dic.add(s[i])
                s[i], s[idx] = s[idx], s[i]
                issue(idx+1)
                s[i], s[idx] = s[idx], s[i]

        s = list(s)
        result = []
        issue(0)
        return result

day36-2022.12.02

题目信息来源

作者：Krahets

链接：https://leetcode.cn/leetbook/read/illustration-of-algorithm

来源：力扣（LeetCode）

剑指 Offer 55 - II. 平衡二叉树

输入一棵二叉树的根节点，判断该树是不是平衡二叉树。如果某二叉树中任意节点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。

给定二叉树 [3,9,20,null,null,15,7]

    3
   / \
  9  20
    /  \
   15   7

返回 true 。

给定二叉树 [1,2,2,3,3,null,null,4,4]

       1
      / \
     2   2
    / \
   3   3
  / \
 4   4

返回 false 。

题解：个人题解 DFS

本来留到倒数的几道递归和回溯题，想不到比想得要简单，也是一次就能做出来的程度。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def isBalanced(self, root: TreeNode) -> bool:
        def deepLength(node):
            if not node:return 0
            left = deepLength(node.left)
            right = deepLength(node.right)
            if abs(left-right)>1:
                self.result = False
            return max(left, right)+1
        
        self.result = True
        deepLength(root)
        return self.result

题解：官方题解DFS

官方题解还用到了剪枝（因为结果已经可以判断还提前返回）。确实会减少一部分递归操作。但似乎我的方法速度快一点？

class Solution:
    def isBalanced(self, root: TreeNode) -> bool:
        def deepLength(node):
            if not node:return 0
            left = deepLength(node.left)
            if left==-1:return -1
            right = deepLength(node.right)
            if right==-1:return -1
            return max(left, right)+1 if abs(left-right)<=1 else -1
        
        return deepLength(root)!=-1