leetcode——2-4数之和

相关习题

1. 两数之和
2. 三数之和
3. 统计特殊四元组
4. 四数之和

两数之和（着重哈希表）

从数组中找出两个数，之和等于给定的target。
这个题其实双重遍历就能解决问题，但是我们不能就这样结束，不然后面的题就不好受了。

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        dic = {}
        for index in range(len(nums)):
            if nums[index] in dic:
                return [index, dic[nums[index]]]
            else:
                dic[target-nums[index]] = index

字典存储的是key=当前元素和target差值，value=当前元素下标
我们每次遇到一个元素，先看看在不在字典中，在就说明另一半已经遇到了，直接返回，没有就将这个加入字典。

三数之和——双指针

这次换成a+b+c=0了。
这题的数据量一看就是不能直接三重循环的情况，另外再加上要求的结果不可以重复，就烦的一批。

这里丢一个新的套路，一会解释。

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        nums = sorted(nums)
        ret = set()
        for i in range(2, len(nums)):
            a, b = 0, i-1
            while a < b:
                if nums[a]+nums[b]+nums[i] >= 0:
                    if not nums[a]+nums[b]+nums[i]:
                        ret.add((nums[a], nums[b], nums[i]))
                    b -= 1
                else:
                    a += 1
        return [list(i) for i in list(ret)]

这里我们遍历第一个数据，a、b作为另外两个数据的指针，分别从两端开始查找。
如果当前的一对a、b成立，或者是和大于零，我们就可以看看前面的值；
如果小了，就将a往后走。

这里可能要问了，这样已经走过的b，会不会没有被统计啊？
这是一个升序序列，你当前的a都嫌弃b数据大，后面的a也一定嫌弃啊

另外，采用元组实在是没办法，主要是他哈希表我不能塞列表进去（列表是可变类型，哈希表的内容一定是不可变的）。
其实这样也就是防止有多个一样的b排在一起，其他的情况也防止不了，想修改一下的，但是没找到太合适的思路，过了得了。

统计特殊四元组（哈希表）

这个是9/5的周赛，还没有官方解释，我看数据量不太大，直接暴力遍历，现在一起分析一下。

首先，这个数据量暴力循环是没问题的，四层罢了；
并且这道题只是统计数量，不限制相同的，所以还好做一些。

但是，三数之和的方式不能用了，因为这个题离谱就在于他的顺序性。（竞赛没看到，直接提交挂了一次，当场心态爆炸）

这里分享两个看到的不错的思路，一个是讨论区，一个是leetcode的排名中。

排名中的一个字典

这段是一行注释没有，找了宿舍的dl，也是看了一段时间才明白。

from collections import Counter
class Solution:
    def countQuadruplets(self, nums: List[int]) -> int:
        n = len(nums)
        value = Counter()
        for c in range(1, n - 1):
            for d in range(c + 1, n):
                value[nums[d]-nums[c]] += 1
        res = 0
        for b in range(1, n - 2):
            for d in range(b + 1, n):
                value[nums[d]-nums[b]] -= 1
            for a in range(b):
                res += value[nums[a]+nums[b]]
        return res

算法的核心也就是将整个分为两部分，一边找a+b，一边匹配d-c。
但是按照上面的方式，我们发现其实添加的内容是有问题的。
容我先画一个图：（d-c的图，数字为下标）

c=1	c=2	……	c=(n-2)
2-1	3-2	……	(n-1)-(n-2)
3-1	4-2	……
……	……
n-1

这些就是第一个for循环添加的内容。
然后，我们观察一下a和b的下标，最开始b取值为1，那么a范围就是[0,1），然后此时很明显，第一列的内容是不可取的，所以我们需要先删掉，然后再考虑字典中哪些是合适的。
下一轮，b=2，第二列不合适，删去，从剩下的取符合条件的。

这样说下来，其实最开始感觉第一列没必要加，其实他就是没必要 ，但是为了保证整体的可读性，所以才有的。

（多嘴一句，其实有一些算法，你硬看是真看不出来，如果在脑子里面或者是编译器上跑一下，打印一些东西，选一个合适的角度，他到底想干什么就一清二楚了）

讨论区中的三字典法

这个来自leetcode吴自华大佬的，只提到了算法，斗胆进行一个合理性的分析。
截图：

代码：

def countQuadruplets(nums: list[int]):
    single = Counter()
    double = Counter()
    triple = Counter()
    ans = 0
    for num in nums:
        ans += triple[num]
        for d in double:
            triple[d + num] += double[d]
        for s in single:
            double[s + num] += single[s]
        single[num] += 1
    return ans

当时看到这个，第一反应就是他是不断维护单个元素值、两个元素和以及三个元素和的字典，每一个字典都是key=和，value=个数，不过巧就在他是一次遍历，说实话我好奇是后期整合的还是一次性想到。

不过我当时没理解的就是为什么是先加，然后3、2、1的顺序整合，直到我跑了一个案例。

输入[1,1,1,3,5]，我们模拟一下：
按照之前的顺序，第一轮single添加1，第二轮single再多一个1，第三轮triple才出现内容，
而如果我们将三个字典的处理顺序反过来，会变成：
第一轮，single多一个1，然后double检测到single的内容，和当前值加，变成{2:1}，很明显是有问题的。

同理，添加的位置也要在最上面，这样其实顺序也就不怎么能修改了。

四数之和

这题读完了，满脑子都是三数之和，那么就在之前的基础上补充一些：

class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        nums = sorted(nums)
        ret = set()
        for i in range(2, len(nums)-1):
            for j in range(i+1, len(nums)):
                a, b = 0, i-1
                while a < b:
                    if nums[a]+nums[b]+nums[i]+nums[j] >= target:
                        if nums[a]+nums[b]+nums[i]+nums[j] == target:
                            ret.add((nums[a], nums[b], nums[i], nums[j]))
                        b -= 1
                    else:
                        a += 1
        return [list(i) for i in list(ret)]

在上面说过，哈希表其实是为了防止两个相同的b，官方大大给出了一个不错的想法，不过也很麻烦，就是比较i、j的值。