2020-5-21

5-21


  1. py3的整数
    py2 ‘/’ 会将结果自动转为整数
    py3 则会变成浮点数,具体参见 这里
    py3 ‘//’ 代表整除取整

  1. 双精度 单精度 半精度
    依次为
double float 半精度
64bits 32bits 16bits

  1. python 操作符
    其中[] 操作符标准模式为[i:j:s][i:j) 表示起始位和终止位,s表示步长;
    如果s<0i默认为-1,j默认-(len()-1),所以[::-1]代表反转,具体

  1. py3 函数返回类型
    ->指定函数返回类型,List不同于list,List存在于typing包里,使用from typing import List 语句调用

  1. lc 面试题08.08
def permutation( S: str) -> List[str]:
    ans=[]
    rec={}
    rec=rec.fromkeys(S,1)
    
    def helper(S,str,r):
        if not S:
           ans.append(str)
        for i in range(0,len(S)):
            if r[S[i]]:
               r[S[i]]=0
               helper(S[0:i]+S[i+1:],str+S[i],rec.fromkeys(S,1))
    helper(S,"",rec.fromkeys(S,1))
    return list(ans)

我的做法是给每个节点一张表用于登记子节点,如果某个子节点已经登记过了,就跳过,不再生成树。
lc题解里的解法:

def permutation(self, S: str) -> List[str]:
    res = []
    track = ''
    used = [False for _ in range(len(S))]
    S = sorted(S)
    def backtrack(s, track):
        if len(s) == len(track):
           res.append(track)
           return
        for i in range(len(s)):
            if not used[i]:
               if i > 0 and s[i] == s[i-1] and not used[i-1]:
                  continue
               used[i] = True
               backtrack(s, track + s[i])
               used[i] = False
              
     backtrack(S, track)
     return res

先sort,用s[i]==s[i-1]这条跳过重复子节点,不去生成树
同时used数组用来标志哪些节点已在track中,不去选择,因为他选择了一种从字符串头检索的方式,这个常量时间其实可以做优化。
二者时间复杂度一致O(n2),常量时间题解的更快,应该是我的算法每个节点都要生成表导致的。


  1. 内部函数引用外部函数内的变量
    py3之后的解决办法:nonlocal关键字
    py3之前的解决办法:外部函数变量设置成list[0]

你可能感兴趣的:(2020-5-21)