棘手的链表问题

发布于 2024-10-25 06:03:39 字数 179 浏览 2 评论 0原文

给定三个列表:A、B 和 C,每个列表的长度为 n。如果任意 3 个数字(每个列表中 1 个),总和为零返回 true。我想用 o(n) 复杂度解决这个问题。我已经对列表进行了排序,我可以考虑创建一个总和为 2 的哈希映射链接列表或比较 3 个列表[o(n*n*n)]。建议一些即兴创作方法以降低复杂性的方法。我想不出任何方法...谢谢 adv

Given three lists: A, B and C of length n each. if any 3 three numbers (1 from each list), sum up to zero return true.I want to solve this with o(n)complexity.I have sorted the lists and I can think of creating either a hash map with sum of 2 linked lists or comparing 3 lists together[o(n*n*n)].Suggest some ways to improvise the methods to reduce complexity..I can't think of any...Thanks in adv

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(3

动听の歌 2024-11-01 06:03:40

列表已排序,对吗?在 O(n) 时间内从 C 构建一个排序数组 C'

对于 A × B 中的每一个 n² 对 xy,使用二分查找检查 -(x + y) 是否在 C' 中。总时间复杂度为 O(n² lg n),空间复杂度为 O(n)。

C构建哈希表可以将时间复杂度进一步降低到O(n²),但代价是对O(1)哈希表的信任。

The lists are sorted, right? Build a sorted array C' out of C in O(n) time.

For each of the n² pairs x, y in A × B, check if -(x + y) is in C' with binary search. Total time complexity is O(n² lg n), space complexity is O(n).

Building a hash table out of C brings the time complexity down further to O(n²), at the expense of belief in O(1) hash tables.

橘亓 2024-11-01 06:03:40

我认为在 o(n²) 中不可能(即确实比 更好),但可以在 中完成O(n²)(即)如下:

首先,反转列表B以获得B' (需要 O(n) 时间),其项目按降序排序的列表。首先,我们考虑在列表 AB' 中查找两个元素的总和为任意给定数字的问题:

我们可以像下面这样执行此操作(Python 代码):

def getIndicesFromTwoArrays(A,B,t):
    a,b=0,0
    while(A[a]+B[b]!=t):
        b=b+1
        if b==len(B):
            return (-1,-1)
        if A[a]+B[b]<t:
            a=a+1
            b=b-1
            if a==len(A):
                return (-1,-1)
    return (a,b)

上述的运行时间是O(n)。所需的额外空间是O(1),因为我们只需要存储两个指针。请注意,上面的内容可以很容易地进行转换,以便它可以与双向链表一起使用。

然后,总的来说,我们只需执行以下操作:

def test(A,B,C):
    B.reverse()
    for c in C:
        if getIndicesFromTwoArrays(A, B, c) != (-1,-1):
            return True
    return False

这会导致运行时间 O(n²) 和额外的空间 O(1)

I do not think it is possible in o(n²) (i.e. really better than ), but it can be done in O(n²) (i.e. sth. like ) as follows:

First of all, reverse list B to obtain B' (takes O(n) time), a list whose items are sorted in descending order. First, we consider the problem of finding two elements in the lists A and B' that sum to any given number:

We can do this like the following (Python code):

def getIndicesFromTwoArrays(A,B,t):
    a,b=0,0
    while(A[a]+B[b]!=t):
        b=b+1
        if b==len(B):
            return (-1,-1)
        if A[a]+B[b]<t:
            a=a+1
            b=b-1
            if a==len(A):
                return (-1,-1)
    return (a,b)

Run time of the above is O(n). Additional space required is O(1) since we only have to store two pointers. Note that the above can be easily transformed such that it works with doubly linked lists.

Then, overall we just have to do the following:

def test(A,B,C):
    B.reverse()
    for c in C:
        if getIndicesFromTwoArrays(A, B, c) != (-1,-1):
            return True
    return False

That results in running time O(n²) and additional space O(1).

猫腻 2024-11-01 06:03:40

你不能用 O(n) 的复杂度来做到这一点,因为它是 NP 完全问题(除非 P=NP)。请查看有关子集和问题的 Wiki 页面以获取可能的解决方案。

You can't do this with O(n) complexity since it's NP-complete problem (unless P=NP). Check out Wiki page about Subset Sum problem for possible solutions.

~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文