代码随想录算法训练营Day7|LeetCode

Q383 array as hash table

[Q383]

# Way1: use array as hash table
def canConstruct(self, ransomNote: str, magazine: str) -> bool:
  arr = [0]*26
  for x in magazine: # 记录 magazine里各个字符出现次数
    arr[ord(x) - ord('a')] += 1
  for x in ransomNote: # 在arr里对应的字符个数做--操作
    if arr[ord(x) - ord('a')] == 0: # 如果没有出现过直接返回
      return False
    else:
      arr[ord(x) - ord('a')] -= 1
  return True

# Way2: defaultdict
def canConstruct(self, ransomNote: str, magazine: str) -> bool:
  from collections impory defaultdict
  hashmap = defaultdict(int)
  for x in magazine:
    hashmap[x] += 1
  for x in ransomNote:
    value = hashmap.get(x)
    if value is None or value == 0:
      return False
    else:
      hashmap[x] -= 1
   return True

# Way3
class Solution(object):
    def canConstruct(self, ransomNote, magazine):
        """
        :type ransomNote: str
        :type magazine: str
        :rtype: bool
        """
        # use a dict to store the number of letter occurance in ransomNote
        hashmap = dict()
        for s in ransomNote:
            if s in hashmap:
                hashmap[s] += 1
            else:
                hashmap[s] = 1
        
        # check if the letter we need can be found in magazine
        for l in magazine:
            if l in hashmap:
                hashmap[l] -= 1
        
        for key in hashmap:
            if hashmap[key] > 0:
                return False
        return True

# Way4: Counter
class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        c1 = collections.Counter(ransomNote)
        c2 = collections.Counter(magazine)
        x = c1 - c2
        #x只保留值大于0的符号，当c1里面的符号个数小于c2时，不会被保留
        #所以x只保留下了，magazine不能表达的
        if(len(x)==0):
            return True
        else:
            return False

Q454 map as hash table

[Q454]

def fourSumCount(self, nums1, nums2, nums2, nums4):
  # use a dict to store the elements in nums1 & nums2 and their sum
  hashmap = dict()
  for n1 in nums1:
    for n2 in nums2:
      if n1+n2 in hashmap:
        hashmap[n1+n2] += 1
      else:
        hashmap[n1+n2] = 1
  # if the -(a+b) exists in nums3 & nums4, we shall add the count
  count = 0
  for n3 in nums3:
    for n4 in nums4:
      if key in hashmap:
        count += hashmap[key]
  return count

Q15 双指针

[Q15]

class Solution:
    def threeSum(self, nums):
        ans = []
        n = len(nums)
        nums.sort()
    # 找出a + b + c = 0
        # a = nums[i], b = nums[left], c = nums[right]
        for i in range(n):
            left = i + 1
            right = n - 1
        # 排序之后如果第一个元素已经大于零，那么无论如何组合都不可能凑成三元组，直接返回结果就可以了
            if nums[i] > 0: 
                break
            if i >= 1 and nums[i] == nums[i - 1]: # 去重a
                continue
            while left < right:
                total = nums[i] + nums[left] + nums[right]
                if total > 0:
                    right -= 1
                elif total < 0:
                    left += 1
                else:
                    ans.append([nums[i], nums[left], nums[right]])
            # 去重逻辑应该放在找到一个三元组之后，对b 和 c去重
                    while left != right and nums[left] == nums[left + 1]: left += 1
                    while left != right and nums[right] == nums[right - 1]: right -= 1
                    left += 1
                    right -= 1
        return ans

Q18 双指针+哈希表

[Q18]

# 双指针法
class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        
        nums.sort()
        n = len(nums)
        res = []
        for i in range(n):   
            if i > 0 and nums[i] == nums[i - 1]: continue  # 对nums[i]去重
            for k in range(i+1, n):
                if k > i + 1 and nums[k] == nums[k-1]: continue  # 对nums[k]去重
                p = k + 1
                q = n - 1

                while p < q:
                    if nums[i] + nums[k] + nums[p] + nums[q] > target: q -= 1
                    elif nums[i] + nums[k] + nums[p] + nums[q] < target: p += 1
                    else:
                        res.append([nums[i], nums[k], nums[p], nums[q]])
            # 对nums[p]和nums[q]去重
                        while p < q and nums[p] == nums[p + 1]: p += 1
                        while p < q and nums[q] == nums[q - 1]: q -= 1
                        p += 1
                        q -= 1
        return res

# 哈希表法
class Solution(object):
    def fourSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[List[int]]
        """
        # use a dict to store value:showtimes
        hashmap = dict()
        for n in nums:
            if n in hashmap:
                hashmap[n] += 1
            else: 
                hashmap[n] = 1
        
        # good thing about using python is you can use set to drop duplicates.
        ans = set()
        # ans = []  # save results by list()
        for i in range(len(nums)):
            for j in range(i + 1, len(nums)):
                for k in range(j + 1, len(nums)):
                    val = target - (nums[i] + nums[j] + nums[k])
                    if val in hashmap:
                        # make sure no duplicates.
                        count = (nums[i] == val) + (nums[j] == val) + (nums[k] == val)
                        if hashmap[val] > count:
                          ans_tmp = tuple(sorted([nums[i], nums[j], nums[k], val]))
                          ans.add(ans_tmp)
                          # Avoiding duplication in list manner but it cause time complexity increases
                          # if ans_tmp not in ans:  
                          #     ans.append(ans_tmp)
                        else:
                            continue
        return list(ans) 
        # if used list() to save results, just 
        # return ans

Reference from: https://programmercarl.com/