想躺平又躺不平的day05

---

四数相加 II

四个整数数组 nums1、nums2、nums3 和 nums4，数组长度都是 n，计算有多少个元组 (i, j, k, l) 能满足：

• 0 <= i, j, k, l < n
• nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

提示：这道题只需要返回有多少组元组即可，那么也就是说可以将四数相加转换为两数相加问题。

  遍历其中两个数组得到两两之间的和存进map哈希结构，key为和，value为key对应出现的次数。接着，同样遍历另外两个数组,并求两两之间的和s判断(0-s)是否在哈希表中并返回对应的value值为当前符合条件的元组数，累加得到最终的元组数。

class Solution(object):
    def fourSumCount(self, nums1, nums2, nums3, nums4):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :type nums3: List[int]
        :type nums4: List[int]
        :rtype: int
        """
        hash_table = {}
        for n1 in nums1:  # 前两个数组和
            for n2 in nums2:
                hash_table[n1+n2] = hash_table.get(n1+n2,0) + 1
        count = 0
        for n3 in nums3: # 后两个数组和
            for n4 in nums4:
                s = n3 + n4
                k = -s   # 判断条件(0-s)
                if k in hash_table:
                    count += hash_table[k]
        return count

赎金信

两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine里面的字符构成。如果可以，返回 true ；否则返回 false 。magazine 中的每个字符只能在 ransomNote 中使用一次。

  这道题与【字母异位词】解题思想一致：以字母的ASCII码特性将不同字母与‘a’的ASCII码差值得到索引值，存入哈希表数组对应的索引下。要判断ransomNote字符串是否由Magazine字符串构成，即判断ransomNote中字母出现的次数是否小于等于Magazine字符串中字母出现的次数。

class Solution(object):
    def canConstruct(self, ransomNote, magazine):
        """
        :type ransomNote: str
        :type magazine: str
        :rtype: bool
        """
        hash_table = [0] * 26
        for i in range(len(ransomNote)):  # 统计ransomNote中字母出现的次数
            hash_table[ord(ransomNote[i])-ord('a')] += 1
        for j in range(len(magazine)):    # 在ransomNote基础上减去magazine字母出现的次数
            hash_table[ord(magazine[j])-ord('a')] -= 1
        for h in hash_table:  # 哈希表中元素需全都小于等于0
            if h > 0:  
                return False
        return True

三数之和

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请返回所有和为 0 且不重复的三元组。
**注意：**答案中不可以包含重复的三元组。

  拿到这道题下意识地就想着用哈希表解决，但是发现，首先同一索引的元素不能取多次，然后得到的三个数字的组合要去重。我直接一整个呆住。经过一番折腾去看了题解(实在是尽力了)。。。。。。
  这道题的解题思路是先将数组排序，然后第一个元素取值为整个数组。索引表示为i，剩下的两个元素只能取第一元素后面的元素即[i+1，len(nums)-1]。利用双指针，左指针指向i+1，右指针指向len(nums)-1。这样，就能保证同一索引的值不会取多次。
  然后，由于一开始我们已经对数组进行排序，此时将三个索引对应的值相加判断是否等于target，小于target其他两个值不动，将左指针往右加一；大于target则将右指针往左减一。如果等于target则记录下来。

  划重点：去重的逻辑主要考虑三个数的去重，保证三个元素对应的位置不会再次取到相同的元素(比如说第一个位置取了某个值n，双指针根据遍历条件得到符合条件的元素[a,b]，那么第一个位置的数往后遍历则不能再取n了，会得到重复的结果)，但是三个元素的值可以相同(来源于不同索引的相同值)。

• 在第一位置的元素去重的条件为nums[i-1] == nums[i]，即不能取与之前取值相同的元素(因为已经排过序，所以只用比上一个索引对应的值而不用与之前所有的值进行对比)。同时，由于要比较上一索引，所以还需加一个条件i>0。
• 同理，双指针对应的两个元素也不能重复取已经取过的元素，所以在当两个指针当前值和下一个值相等时，将两个指针分别往右和往左移动一个位置，直到不相等为止。此时的左右指针指向的为重复元素的最后一个。这样，达到了对第二、第三个元素去重的目的。

class Solution(object):
    def threeSum(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        nums.sort()
        result = []
        for i in range(len(nums)):
            if nums[i] > 0:  # 剪枝(如果第一个数为正数，那么加上后面两个数之和不可能等于0)
                return result
            if i > 0 and nums[i-1] == nums[i]:  # 第一个元素的去重
                continue
            left = i + 1
            right = len(nums) - 1
            while left < right:
                s = nums[i] + nums[left] + nums[right]
                if s > 0:
                    right -= 1
                elif s < 0:
                    left += 1
                else:
                    result.append([nums[i],nums[left],nums[right]])
                    while left < right and nums[left] == nums[left+1]: # 第二个元素的去重
                        left += 1
                    while left < right and nums[right] == nums[right-1]: # 第三个元素的去重
                        right -= 1
                    right -= 1
                    left += 1
        return result

四数之和

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组[nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

• 0 <= a, b, c, d < n
• a、b、c 和 d 互不相同
• nums[a] + nums[b] + nums[c] + nums[d] == target 可以按 任意顺序 返回答案 。

  根据上述三数之和的思想，四数之和即在三数之和的基础上再套一层循环：第一个数字遍历整个数组，第二个数字遍历从第一个数字取值的后一位到数组最后一位，然后剩下两个数字由左、右双指针进行判断。
  这道题还需要注意的地方就是target并不是大于等于0的，因此剪枝的时候不能直接像上述三数之和那样剪枝，而是需要加一个target>=0的约束条件进行剪枝。

class Solution(object):
    def fourSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[List[int]]
        """
        nums.sort()
        result = []
        n = len(nums)
        for i in range(n):
            if nums[i] > target and target >= 0: # 剪枝(如果第一个数大于target，那么加上后面两个数之和(此时一定为正数)不可能等于target(需保证target>=0))
                return result  #此时剪枝后就无需再往后遍历了，直接返回结果
            if i > 0 and nums[i] == nums[i-1]:  # 第一个元素的去重
                continue
            for j in range(i+1,n):
                if nums[i]+nums[j] > target and target >= 0: # 剪枝(与上述思想一致，但是比较对象编程前两个数之和)
                    break  #此时剪枝后对于j就无需再往后遍历了，但是i仍然需要往后遍历，所以break而不是return result
                if j > i+1 and nums[j] == nums[j-1]:
                    continue
                left = j+1
                right = len(nums)-1
                while left < right:
                    s = nums[i] + nums[j] + nums[left] + nums[right]
                    if s == target:
                        result.append([nums[i], nums[j], nums[left], nums[right]])
                        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
                    elif s < target:
                        left += 1
                    else:
                        right -= 1
        return result

  我自己在写这个代码的时候，就发现老是有一部分样例通不过，但是又对比代码感觉没什么差别。后来一看，才发现在剪枝处理的时候，最外层元素的剪枝可以直接返回result，但是里层的剪枝却不能直接返回result，而是应该用break。因为，对于里层的遍历进行剪枝了，但是外层的遍历还要往后遍历。