七. 前缀树/前缀和

​​560. 和为 K 的子数组​​

​​剑指 Offer II 010. 和为 k 的子数组​​

class Solution:
    def subarraySum(self, nums, k):
        res = pre_sum = 0
        pre_dict = {0:1}
        for num in nums:
            pre_sum += num
            # 将当前累加和减去整数K的结果，在哈希表中查找是否存在。如果存在该key值，证明以数组某一点为起点到当前位置满足题意，res加等于将该key值对应的value
            res += pre_dict.get(pre_sum - k, 0)
            # 判断当前的累加和是否在哈希表中，若存在value+1，若不存在value=1
            pre_dict[pre_sum] = pre_dict.get(pre_sum, 0) + 1
        return res

​​208. 实现 Trie (前缀树)​​

class Trie:
    def __init__(self):
        self.children = [None] * 26
        self.isEnd = False
    
    def searchPrefix(self, prefix: str) -> "Trie":
        node = self
        for ch in prefix:
            ch = ord(ch) - ord("a")
            if not node.children[ch]:
                return None
            node = node.children[ch]
        return node

    def insert(self, word: str) -> None:
        node = self
        for ch in word:
            ch = ord(ch) - ord("a")
            if not node.children[ch]:
                node.children[ch] = Trie()
            node = node.children[ch]
        node.isEnd = True

    def search(self, word: str) -> bool:
        node = self.searchPrefix(word)
        return node is not None and node.isEnd

    def startsWith(self, prefix: str) -> bool:
        return self.searchPrefix(prefix) is not None



# Your Trie object will be instantiated and called as such:
# obj = Trie()
# obj.insert(word)
# param_2 = obj.search(word)
# param_3 = obj.startsWith(prefix)

​​剑指 Offer II 011. 0 和 1 个数相同的子数组​​

class Solution:
    def findMaxLength(self, nums: List[int]) -> int:
        n = len(nums)
        preSum = [0 for _ in range(n + 1)]
        hashmap = defaultdict()    
        hashmap[0] = 0    
        ans = 0
        for i in range(1, n + 1):
            temp = - 1 if nums[i - 1] == 0 else 1
            preSum[i] = preSum[i - 1] + temp
            if preSum[i] in hashmap:
                ans = max(ans, i - hashmap[preSum[i]])
            else:
                hashmap[preSum[i]] = i
        return ans

​​剑指 Offer II 012. 左右两边子数组的和相等​​

class Solution:
    def pivotIndex(self, nums: List[int]) -> int:
        total = sum(nums)
        pre_sum = 0 
        for i in range(len(nums)):
            if pre_sum*2 + nums[i] == total:
                return i
            pre_sum += nums[i]
        return -1

​​剑指 Offer II 071. 按权重生成随机数​​

class Solution:

    def __init__(self, w: List[int]):
        self.pre = list(accumulate(w))
        self.total = sum(w)

    def pickIndex(self) -> int:
        x = random.randint(1, self.total)
        return bisect_left(self.pre, x)

# Your Solution object will be instantiated and called as such:
# obj = Solution(w)
# param_1 = obj.pickIndex()

​​面试题 17.05. 字母与数字​​

class Solution:
    def findLongestSubarray(self, array: List[str]) -> List[str]:

        if not array:
            return []
        
        dp = [0] * len(array)
        dp[0] = 1 if 'A' <= array[0] <= "Z" or 'a'<=array[0]<='z' else -1  ###字母减去数字

        for i in range(1, len(array)):          
            dp[i] = dp[i - 1] + 1 if 'A' <= array[i] <= "Z" or 'a'<=array[i]<='z' else  dp[i - 1] - 1
              
        dic = {}
        dic[0] = -1        
        for i in range(len(dp)):
            dic[dp[i]] = dic.get(dp[i],i)
           
        max_length = 0
        left = 0
        right = 0
    
        for i in range(len(dp)):
            if i - dic[dp[i]]>max_length:
                left = dic[dp[i]]
                right = i+1
                max_length = right -left

        return array[left+1:right]