Question

我正在尝试解决LeetCode上的3Sum问题。我提出以下解决方案：

import collections


class Solution:
    def threeSum(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        d = collections.defaultdict(dict)
        for i in range(len(nums)):
            for j in range(i + 1, len(nums)):
                d[-nums[i]-nums[j]].update(
                    {tuple(sorted([nums[i], nums[j]])): (i, j)})

        triplets = set()
        for index, num in enumerate(nums):
            if num in d:
                for doublet, indices in d[num].items():
                    if index not in indices:
                        triplet = tuple(sorted([num, *doublet]))
                        if triplet not in triplets:
                            triplets.add(triplet)
                            break

        return [list(triplet) for triplet in triplets]

具有以下测试套件：

def set_equals(a, b):
    # Auxiliary method for testing
    return set(tuple(x) for x in a) == set(tuple(y) for y in b)


def test_unique():
    assert Solution().threeSum([0, 0]) == []


def test_1():
    nums = [-1, 0, 1, 2, -1, 4]
    assert set_equals(
        Solution().threeSum(nums),
        [
          [-1, 0, 1],
          [-1, -1, 2]
        ])


def test_with_duplicates():
    nums = [-1, 0, -1, 0, 1]
    assert set_equals(
        Solution().threeSum(nums),
        [[-1, 0, 1]])


def test_same_number():
    assert Solution().threeSum([0, 0, 0]) == [[0, 0, 0]]


def test_3():
    assert set_equals(Solution().threeSum(
        [-4, -2, -2, -2, 0, 1, 2, 2, 2, 3, 3, 4, 4, 6, 6]),
        [
            [-4, -2, 6],
            [-4, 0, 4],
            [-4, 1, 3],
            [-4, 2, 2],
            [-2, -2, 4],
            [-2, 0, 2]])


def test_4():
    assert set_equals(Solution().threeSum(
        [-4, -2, 1, -5, -4, -4, 4, -2, 0, 4, 0, -2, 3, 1, -5, 0]),
        [
            [-5, 1, 4],
            [-4, 0, 4],
            [-4, 1, 3],
            [-2, -2, 4],
            [-2, 1, 1],
            [0, 0, 0]])


def test_6():
    assert set_equals(
        Solution().threeSum([0, 3, 0, 1, 1, -1, -5, -5, 3, -3, -3, 0]),
        [[-3, 0, 3], [-1, 0, 1], [0, 0, 0]])

所有测试均在本地通过：

$ pytest 3sum.py -s
============================= test session starts ==============================
platform darwin -- Python 3.6.6, pytest-3.8.1, py-1.6.0, pluggy-0.7.1
rootdir: /Users/kurtpeek/GoogleDrive/LeetCode, inifile:
collected 7 items                                                              

3sum.py .......

=========================== 7 passed in 0.04 seconds ===========================

但是，如果我通过LeetCode提交解决方案，则会收到“错误答案”结果：

但是请注意，这与我的本地测试套件中的test_6是相同的测试用例！

实际上，如果我在ipython shell中运行此输入（在将文件重命名为threesum.py以避免导入错误之后），我将获得预期的三个结果，尽管顺序不同：

$ ipython
Python 3.6.6 (v3.6.6:4cf1f54eb7, Jun 26 2018, 19:50:54) 
Type 'copyright', 'credits' or 'license' for more information
IPython 6.5.0 -- An enhanced Interactive Python. Type '?' for help.

In [1]: from threesum import *

In [2]: Solution().threeSum([0, 3, 0, 1, 1, -1, -5, -5, 3, -3, -3, 0])
Out[2]: [[-1, 0, 1], [0, 0, 0], [-3, 0, 3]]

似乎，LeetCode的“输出”与我的输出不同。知道如何让解决方案被接受吗？

Answer 1

我对发生的事情进行了许多测试。

这与以下事实有关：字典项键，值对的出现顺序与它们被推入字典的顺序不同。

例如，您的词典可能有d = {1:'a', 2:'b', 3:'c'} 但是当通过字典进行迭代时：

for key, value in d.items():
    print(key, value)

不能保证您得到此打印件：

1, 'a'
2, 'b'
3, 'c'

因为本来就应该对字典进行排序。

关于为什么它在您的计算机上甚至在我的计算机上都起作用的原因是，我敢冒险猜测我们有Python 3.5+（我确定可以）保存字典的输入顺序。

Leetcode运行Python3。不是3.5 +。

因此，当您遍历字典

for doublet, indices in d[num].items():

根据doublet, indices出现的顺序（没有任何特定顺序的保证），您不能保证循环执行是相同的！

你能做什么？我说要学会使用OrderedDict。这样可以保留将键，值对放入字典的顺序。

我不是OrderedDict的专家，所以我无济于事。

但是一个简单的打印语句：

for doublet, indices in d[num].items():
    print(doublet, indices)

在您自己的本地计算机和Leetcode输出中都会显示我的意思。打印doublet, indices会使它们在Leetcode输出和本地计算机输出中以不同的顺序显示。

Answer 2

问题的核心是break语句，该语句引入了Abhishek所解释的“顺序依赖”。如果我注释掉break语句，则会收到另一个错误，Time Limit Exceeded：

显然，我的O（N ^ 2）解太慢了，但至少现在给出了正确的答案。

在Python中解决LeetCode 3sum问题

2 个答案: