Leetcode 学习计划之21天算法 (六）

第6天 滑动窗口

集合的操作：set.add() set.remove() 字典的操作：dict.setdefault()

如果涉及到不重复考虑集合，涉及到排列、计数可考虑字典

不倒退的移动可考虑双指针、滑动窗口（左移一位、右移一位）

3、无重复字符的最长字串

1、暴力法：内外两层循环，外层循环len次，内层循环做窗口，如果下一个字符不在之前的窗口内的字符串里，就+1；如果重复就break，看看这个窗口内的长度是否比max大，大的话就替换成当前值。

时O(n^2)  空(1)

2、用队列做。如果当前字符s[i]不在队列里就入队；在的话就出队直到和s[i]相等的值出队，s[i]再入队。然后每次循环都判断队长，return最长的队长。

时O(n) 空O(k)（最长子串）

3、用集合set+双指针做。left指向不重复的第一个字符，right指向不重复的最后一个字符。当下一个字符不重复时，加入集合。重复时移除重复值之前的所有值，left右移。无论是否重复right都要右移。return 最长的set长度。

时O(n) 空O(k)

class Solution(object):
    def lengthOfLongestSubstring(self, s):
        """
        :type s: str
        :rtype: int
        """
        l = len(s)
        if l == 0:
            return 0
        max = ans = 1
        for i in range(0,l):
            ans = 1
            for j in range(i+1,l):
                if s[j] not in s[i:j]:
                    ans += 1
                else:
                    break
            if max < ans:
                max = ans
        return max

class Solution(object):
    def lengthOfLongestSubstring(self, s):
        """
        :type s: str
        :rtype: int
        """
        l = len(s)
        max = ans = 0
        queue = []
        for i in range(l):
            if s[i] not in queue:
                queue.append(s[i])
            else:
                while(queue[0]!=s[i]):
                    queue.pop(0)
                queue.pop(0)
                queue.append(s[i])
            ans = len(queue)
            if ans>max:
                max = ans
        if len(queue) == l:
            return l
        return max

class Solution(object):
    def lengthOfLongestSubstring(self, s):
        """
        :type s: str
        :rtype: int
        """
        set1 = set()
        l = len(s)
        left = 0
        right = ans = 0
        while right < l:          
            if s[right] not in set1: #如果下一个字符不与之前的重复 那就加入 右指针右移
                set1.add(s[right]) 
                right +=1
                ans = max(right-left, ans)   #算加入后的长度            
            else:             #如果下一个字符与之前的重复，那就把重复之前的都移除 左指针右移 
                              #因为s[right]的值与之前的重复值一样，所以就不把重复值移除了，因为先移除再移入效果一样。
                while(s[left]!=s[right]):
                    set1.remove(s[left])
                    left += 1  
                left +=1     #这里还要再右移一位，因为之前只移到了重复值那里
                right +=1                          
        return ans

567、字符串的排列

1、暴力法：先把s1放入字典中，然后再再按照s1的长度对s2进行循环交叠的切片，放入字典中，看看有没有和s1的字典一样的 ，有的话就是True，否则为false.

2、双指针滑动窗口：right指向下一个可能符合题意的字符，left指向当前满足题意得第一个字符。

普通滑动窗口双指针：

（每次两个指针同时右移，更新字典，不重新建立字典，只把left的移除，right的移入。）

优化双指针： 

right逐渐右移，如果right所在字符不在s1字符的字典里，那说明之前看的全白搭，重新初始化s2的字典。如果right所在字符在s1字符的字典里，那就加入，然后看加入的这个字符数是不是大于s1中的数量，如果大于那就把之前的字符都从字典中移除去，直到left指向与当前字符相等的那个字符的下一位。然后判断左右指针间的间距，如果等于s1长的话，return True。

"adc" "dcda" 注意这种情况

class Solution(object):
    def checkInclusion(self, s1, s2):
        """
        :type s1: str
        :type s2: str
        :rtype: bool
        """
        d1 = {}
        for i in s1:
            if i not in d1:
                d1[i] = 1
            else:
                d1[i] +=1
        flag = False
        l2 = len(s2)
        l = len(s1)
        for j in range(l2):
            s = s2[j:j+l]
            d2 = {}
            for i in s:
                if i not in d2:
                    d2[i] = 1
                else:
                    d2[i] +=1 
            if d1 == d2:
                flag = True
        return flag          

class Solution(object):
    def checkInclusion(self, s1, s2):
        """
        :type s1: str
        :type s2: str
        :rtype: bool
        """
        d1 = {}
        for i in s1:
            d1.setdefault(i,0)
            d1[i] += 1

        l1 = len(s1)    
        l2 = len(s2)
        left = right = 0
        d2 = {}
        while right < l2:
            if s2[right] not in d1:
                d2 = {}
                left = right + 1
            else:     
                d2.setdefault(s2[right],0)
                d2[s2[right]] += 1    
                if d2[s2[right]] > d1[s2[right]]:
                    while s2[left]!= s2[right]:
                        d2[s2[left]] -= 1  #要先做字典-1再做左指针右移
                        left +=1                        
                    d2[s2[left]] -= 1    #while循环之后还要重复一次，把与right所在字符一致的字符移除，left指向下一位符合题意的字符
                    left += 1
                if right -left == l1 -1:
                    if d1 == d2:
                        return True 
            right += 1
        return False