一.問題描述

Given an array S of n integers, are there elements a, b, c in S such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.

Note: The solution set must not contain duplicate triplets.

For example, given array S = [-1, 0, 1, 2, -1, -4],

A solution set is:
[
  [-1, 0, 1],
  [-1, -1, 2]
]

二.演算法設計&優化

尋找三個數使其總和為0，暴力解法複雜度為O(N^3)。因此考慮通過排序（O(NlogN)）來優化演算法。我們知道對於有序的序列的TwoSum演算法複雜度是O(N)，而3Sum不過就是固定一個數的TwoSum。因此解法為一次固定陣列中的一個數，求剩下陣列的TwoSum使其和加上固定的數之和為零。顯而易見，該演算法時間複雜度為O(N^2)。

我最初在設計3Sum這個演算法的時候只是排了序，然後固定一個數，再求TwoSum的時候只是簡單地判定不存在的情況就跳過，程式碼如下：

class Solution(object):
    def threeSum(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        n = len(nums)
        outputlist = []
        nums.sort()
        for i in range(n-1):
            if i>0 and nums[i] == nums[i-1]:
                continue
            for j in range(n-1,i,-1):
                if j<n-1 and nums[j] == nums[j+1]:
                    continue
                jj = j-1
                while jj>i:
                    if nums[i]+nums[jj]>nums[jj]:
                        break
                    elif nums[i]+nums[j]+nums[jj]==0:
                        outputlist.append([nums[i],nums[jj],nums[j]])
                        break
                    jj = jj-1
        return outputlist
                

顯然該演算法複雜度是高於O(N^2)的。

我根據上上述演算法優化後所寫的時間複雜度為O(N^2)的演算法如下：

#？原理很簡單不想寫了？(^人^) #

三.問題擴充套件

3Sum的問題可以通過固定一個數轉化成TwoSum的問題，那麼顯然KSum的問題不斷地轉化最後變成TwoSum的問題。我們知道KSum的問題暴力解法的時間複雜度會達到O(N^k)，而通過一步步退化成TwoSum，其時間複雜度可以降低到O(N^(k-1))，這個貌似是最好的界了。KSum演算法可以通過遞迴來實現。附上我寫的4Sum的程式碼：

class Solution(object):
    def fourSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[List[int]]
        """
        len_nums = len(nums)
        if len_nums < 4:
            return []
        re_list = []
        # sort
        nums.sort()
        for i in range(len_nums):
            # need the unique one
            if i > 0 and nums[i] == nums[i - 1]:
                continue
            for j in range(i + 1, len_nums - 2):
                # need the unique one
                if j-1!= i and nums[j] == nums[j - 1]:
                    continue
                target1 = target - nums[i] - nums[j]
                m = j + 1
                n = len_nums - 1
                while m < n:
                    if nums[m] + nums[n] > target1:
                        n = n - 1
                    elif nums[m] + nums[n] < target1:
                        m = m + 1
                    else:
                        re_list.append([nums[i], nums[j], nums[m], nums[n]])
                        while m + 1 < len_nums and nums[m + 1] == nums[m]:
                            m = m + 1
                        while n - 1 > j + 1 and nums[n - 1] == nums[n]:
                            n = n - 1
                        m = m + 1
                        n = n - 1
        return re_list