《Leetcode of November》字母异位词总结

 

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        if not s and not t:
            return True
        if not s or not t or len(s)!=len(t):
            return False
        

        #hash表法
        #先构建一个字典
        dic = {}
        for char in s:
    
            dic[char] = dic.get(char,0)+1

        #然后再该字典中查找元素，找到一个删掉一个，如果value出现负数那就说明没有俩不是字母异位词
        for char in t:
            dic[char] = dic.get(char,0)-1
            if dic[char]<0:
                return False
        return  True



        #简单粗暴,直接排序
        s = list(s)
        t = list(t) 
        s.sort()
        t.sort()
        return s==t

• 异位指的就是位置不一样，但是所含的字母都是一模一样的
• 暴力法就是直接将字符串转为列表，然后排序列表
• 比较两个列表是不是相同即可

class Solution:
    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
        dic = {}
        res = []
        for char in strs:
            tmp = char[:]
            List = list(tmp)
            List.sort()
            seq = ''.join(List)
            if  seq not in dic:
                dic[seq]=[char,]
            else:
                dic[seq].append(char)
        for k,v in dic.items():
            res.append(v)
        
        return res

• 使用hash表去存异位词，然后再遍历hash表，将异位词的结合添加到结果集中去

 

 

class Solution:
    def findAnagrams(self, s: str, p: str) -> List[int]:
        
        target = {}  #将要匹配的target
        window = {}  #将要判断的字符串
        res = []
        left,right = 0,0  #左右两个指针
        size = len(s)    
        target_size=len(p)
        #声明一个target的字典
        for i in p:
            target[i] = target.get(i,0)+1
        
        while right<size:
            char = s[right]
            #如果当前的字符不再target，清空window的窗口，并且两个指针回到同一个起跑线
            if char not in target:
                window.clear()
                left=right=right+1
            #如果当前字符在target
            else:
                #将目标字符hash化
                window[char] = window.get(char,0)+1
                #如果左右指针之差等于目标的size，那就看window是不是等于target
                #如果等于添加left的索引，并且将之前left对应的值减1，然后再移动左右指针
                if right-left+1==target_size:
                    if window==target:
                        res.append(left)
                    window[s[left]]-=1
                    left+=1
                right+=1

        return res


        

        #暴力法:测试不通过
        source_size = len(s)
        target_size = len(p)
        #如果字符串长度是小于p的话那就返回空
        if source_size<target_size or not s:
            return []
        res = []
        start = 0
        target = sorted(list(p))
        index = []
        for i in range(source_size):
            if s[i] in target:
                index.append(i)
        for start in index:
            if start+target_size>source_size:
                break
            temp = s[start:start+target_size]
            if sorted(list(temp))==target:
                res.append(start)
            
        
        return res

• 暴力法
  • 暴力法就是依次遍历逐个位置，然后和target比较，但是就是超时了
• 滑动窗口法
  • 将目标字符串hash化
  • 声明两个双指针
  • 去维护一个window窗口，然后比较window窗口和目标字符串hash化的target

总结：hash表很重要，双指针+hash表更重要。