leetcode笔记1—— “N数之和”类题

leetcode笔记1—— “N数之和”类题

相关题目

#1 两数之和
#15 三数之和
#18 四数之和

以三数之和为例：
给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。
示例：

例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为：
[
  [-1, 0, 1],
  [-1, -1, 2]
]

两数之和

参见官方题解，主要有两种方法

• 暴力法：两层循环 时间复杂度O(n^2)，空间复杂度O(1)
• 哈希法：先建立哈希映射表，再顺序查表判断 时空复杂度均为O(n)
  还有一种是排序遍历法，即先排序再用首尾双指针遍历，比暴力法要快

三数之和

方法一：循环嵌套法

在两数之和的排序遍历法基础上再套一层循环：先排序，再顺序遍历嵌套首尾双指针遍历（遍历时可通过去重进一步优化）

python3实现

    def threeSum(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
         nums.sort()
        res = []
        for i in range(len(nums)):
            if i!=0 and nums[i]==nums[i-1]: # 去重
                continue 
            l = i+1
            r = len(nums)-1
            while l<r:
                s = nums[i] + nums[l] + nums[r]
                if s==0:
                    res.append([nums[i], nums[l], nums[r]])
                    l += 1
                    r -= 1
                    while l<r and nums[l]==nums[l-1]:
                        l += 1
                    while r>l and nums[r]==nums[r+1]:
                        r -= 1
                elif s<0:
                    l += 1
                else:
                    r -= 1
        return res

C++实现

    vector<vector<int>> threeSum(vector<int> &nums)
    {
        sort(nums.begin(),nums.end());
        int len=nums.size();
        vector<vector<int>> result;
        if(len < 3)
            return result;
        for(int i=0; i<len; ++i)
        {
            if(i==0 || nums[i]>nums[i-1])
            {
                int l = i+1;
                int r = len-1;
                while(l < r)
                {
                    int sum = nums[i]+nums[l]+nums[r];
                    if(sum == 0)
                    {
                        result.push_back({nums[i], nums[l], nums[r]});
                        ++l;
                        --r;
                        while(l<r && nums[l]==nums[l-1])
                            ++l;
                        while(r>l && nums[r]==nums[r+1])
                            --r;
                    }
                    else if(sum < 0)
                        ++l;
                    else    
                        --r;
                }
            }
        }
        return result;
    }

复杂度分析

• 时间复杂度：排序O(nlogn)，外循环O(n)，双指针遍历O(n)，总共应不超过O(n^2)
• 空间复杂度：O(1)

方法二：递归法

将两数之和的排序遍历法作为递归基，将N数之和问题通过递归最终转化为两数之和问题
python3实现

    def fourSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[List[int]]
        """
        nums.sort()
        res = []
        self.nSum(nums, target, 4, [], res)
        return res
    
       def nSum(self, nums, target, N, temp, res):
        # 通过递归将n数之和转化为2数之和
        if len(nums)<N or N<2:
            return
        # 2-sum
        if N==2:
            left = 0
            right = len(nums)-1
            while left<right:
                s = nums[left]+nums[right]
                if s==target:
                    res.append(temp+[nums[left], nums[right]])
                    left += 1
                    right -= 1
                    while left<right and nums[left] == nums[left-1]:
                        left += 1
                    while left<right and nums[right] == nums[right+1]:
                        right -= 1
                elif s<target:
                    left += 1
                else:
                    right -= 1
        else:
            for i in range(len(nums)-N+1): # 因为已排序，N数之和的首个数只要遍历到len(nums)-N即可
                if target<nums[0]*N or target>nums[-1]*N:
                    break # 目标值比最小数的N倍还小或比最大数的N倍还大必定不合条件
                if i!=0 and nums[i]==nums[i-1]: # 去重
                    continue
                self.nSum(nums[i+1:], target-nums[i], N-1, temp+[nums[i]], res)
        return

C++版本暂未实现，欢迎大神补充
复杂度分析
与循环嵌套法应该相同，但更具扩展性

总结

1. 相似问题要善于借助其中基础问题的解决思路去解决更复杂问题
2. 有时间的话解决问题后多想一步，能否推而广之（如递归法）
3. 可借助leetcode通过题的分布情况学习高效解法的思路