Leetcode 题 '3Sum' 算法超过时限，寻求改进

Question

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

class Solution:
    def threeSum(self, nums):

        data = []
        i = j = k =0
        length = len(nums)
        for i in range(length):
            for j in range(length):
                if j == i:
                    continue
                for k in range(length):
                    if k == j or k == i:
                        continue
                    sorted_num = sorted([nums[i],nums[j],nums[k]])
                    if nums[i]+nums[j]+nums[k] == 0 and sorted_num not in data:
                        data.append(sorted_num)

        return data

My soulution is working well but it appears that it may be too slow. Is there a way to improve my codes without changing it significantly?

Answer 1

This is a O(n^2) solution with some optimization tricks:

import itertools

class Solution:
    def findsum(self, lookup: dict, target: int):
        for u in lookup:
            v = target - u
            # reduce duplication, we may enforce v <= u
            try:
                m = lookup[v]
                if u != v or m > 1:
                    yield u, v
            except KeyError:
                pass

    def threeSum(self, nums: List[int]) -> List[List[int]]:
        lookup = {}
        triplets = set()
        for x in nums:
            for y, z in self.findsum(lookup, -x):
                triplets.add(tuple(sorted([x, y, z])))
            lookup[x] = lookup.get(x, 0) + 1
        return [list(triplet) for triplet in triplets]

First, you need a hash lookup to reduce your O(n^3) algorithm to O(n^2). This is the whole idea, and the rest are micro-optimizations:

• the lookup table is build along with the scan on the array, so it is one-pass
• the lookup table index on the unique items that seen before, so it handles duplicates efficiently, and by using that, we keep the iteration count of the second-level loop to the minimal

Answer 2

I'd suggest:

for j in range(i+1, length):

This will save you len(nums)^2/2 steps and first if statement becomes redundant.

sorted_num = sorted([nums[i],nums[j],nums[k]])
    if nums[i]+nums[j]+nums[k] == 0 and sorted_num not in data:
        sorted_num = sorted([nums[i],nums[j],nums[k]])
        data.append(sorted_num)

To avoid unneeded calls to sorted in the innermost loop.

Answer 3

This is an optimized version, will pass through:

from typing import List

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        unique_triplets = []
        nums.sort()
        for i in range(len(nums) - 2):
            if i > 0 and nums[i] == nums[i - 1]:
                continue
            lo = i + 1
            hi = len(nums) - 1
            while lo < hi:
                target_sum = nums[i] + nums[lo] + nums[hi]
                if target_sum < 0:
                    lo += 1
                if target_sum > 0:
                    hi -= 1
                if target_sum == 0:
                    unique_triplets.append((nums[i], nums[lo], nums[hi]))
                    while lo < hi and nums[lo] == nums[lo + 1]:
                        lo += 1
                    while lo < hi and nums[hi] == nums[hi - 1]:
                        hi -= 1
                    lo += 1
                    hi -= 1
        return unique_triplets

The TLE is most likely for those instances that fall into these two whiles:

• while lo < hi and nums[lo] == nums[lo + 1]:

• while lo < hi and nums[lo] == nums[lo + 1]:

---

References

• For additional details, please see the Discussion Board where you can find plenty of well-explained accepted solutions with a variety of languages including low-complexity algorithms and asymptotic runtime / memory analysis ^{1 , 2} .

Answer 4

Your solution is the brute force one, and the slowest one. Better solutions can be:

Assume you start from an element from array. Consider using a Set for finding next two numbers from remaining array.

There is a 3rd better solution as well. See https://www.gyanblog.com/gyan/coding-interview/leetcode-three-sum/