有效地获得排序列表的排序总和

Question

你有一个数字的升序列表，你能想到的最有效的算法是什么来获得该列表中每两个数字的和的升序列表。 结果列表中的重复项无关紧要，如果您愿意，可以删除它们或避免它们。

需要明确的是，我对算法感兴趣。 随意以您喜欢的任何语言和范式发布代码。

Answer 1

2018 年编辑：您可能应该停止阅读本文。 （但我不能删除它，因为它被接受了。）

如果你写出这样的总和：

1 4  5  6  8  9
---------------
2 5  6  7  9 10
  8  9 10 12 13
    10 11 13 14
       12 14 15
          16 17
             18

您会注意到，由于 M[i,j] <= M[i,j+1] 和 M[i,j] <= M[i+1,j]，那么您只需要检查左上角“角”并选择最低的一个。

例如

• 只有 1 个左上角，选择 2
• 只有1个，选5个
• 6 或 8，选 6
• 7 或 8，选 7
• 9 或 8，选 8
• 9 或 9，两者都选 :)
• 10 或 10 或 10，全选
• 12 或 11，选 11
• 12 或 12，两者都选
• 13 或 13，两者都选
• 14 或 14，两者都选
• 15 或 16，选 15
• 只选1个，选16个
• 只选1个，选17个
• 只选1个，选18个

当然，当你有很多左上角时，这个解决方案就会转移。

我很确定这个问题是 Ω(n²)，因为你必须计算每个 M[i,j] 的总和——除非有人有更好的求和算法:)

Answer 2

我想我会分步对它进行伪编码并解释我的逻辑，而不是编码它，以便更好的程序员可以在必要时在我的逻辑中戳洞。

第一步，我们从一个长度为 n 的数字列表开始。 对于每个数字，我们需要创建一个长度为 n-1 的列表，因为我们不会向其自身添加数字。 最后，我们有一个在 O(n^2) 时间内生成的大约 n 个排序列表的列表。

step 1 (startinglist) 
for each number num1 in startinglist
   for each number num2 in startinglist
      add num1 plus num2 into templist
   add templist to sumlist
return sumlist 

在第 2 步中，因为列表是按设计排序的（向排序列表中的每个元素添加一个数字，列表仍将被排序）我们可以通过将每个列表合并在一起而不是对整个列表进行合并排序来简单地进行归并排序。 最后，这应该花费 O(n^2) 时间。

step 2 (sumlist) 
create an empty list mergedlist
for each list templist in sumlist
   set mergelist equal to: merge(mergedlist,templist)
return mergedlist

合并方法将是正常的合并步骤，并进行检查以确保没有重复的总和。 我不会写出来，因为任何人都可以查找归并排序。

所以这是我的解决方案。 整个算法是 O(n^2) 时间。 随时指出任何错误或改进。

Answer 3

你可以在 python 中用两行来做到这一点

allSums = set(a+b for a in X for b in X)
allSums = sorted(allSums)

迭代的成本是n^2 （可能是集合的额外对数因子？），排序的成本是 s * log(s)，其中 s 是集合的大小。

集合的大小可能与n*(n-1)/2 ，例如，如果X = [1,2,4,...,2^n] 。 所以如果你想生成这个列表，在最坏的情况下至少需要n^2/2 ，因为这是输出的大小。

但是，如果您想选择结果的前 k 个元素，您可以使用 Frederickson 和 Johnson 的排序X+Y矩阵的选择算法在 O(kn) 中执行此操作（有关详细信息，请参见此处） 。 虽然这可能会被修改为通过重用计算在线生成它们，并为这个集合获得一个高效的生成器。

@deuseldorf，Peter 关于(n!)有些困惑，我严重怀疑 deuseldorf 的意思是“n 阶乘”，而只是“n，（非常兴奋）！”

Answer 4

这个问题已经困扰我大约一天了。 惊人的。

无论如何，您无法轻松摆脱它的 n^2 性质，但是您可以通过合并做得更好，因为您可以绑定范围以插入每个元素。

如果您查看生成的所有列表，它们具有以下形式：

(a[i], a[j]) | j>=i

如果你把它翻转 90 度，你会得到：

(a[i], a[j]) | i<=j

现在，合并过程应该采用两个列表i和i+1 （对应于第一个成员始终a[i]和a[i+1] ），您可以将范围绑定到插入元素(a[i + 1], a[j])通过(a[i], a[j])的位置和(a[i + 1], a[j + 1])的位置进入列表i 。

这意味着您应该在j方面反向合并。 我不知道（还）您是否也可以在j利用它，但这似乎是可能的。

Answer 5

在 SQL 中：

create table numbers(n int not null)
insert into numbers(n) values(1),(1), (2), (2), (3), (4)


select distinct num1.n+num2.n sum2n
from numbers num1
inner join numbers num2 
    on num1.n<>num2.n
order by sum2n

C# LINQ：

List<int> num = new List<int>{ 1, 1, 2, 2, 3, 4};
var uNum = num.Distinct().ToList();
var sums=(from num1 in uNum
        from num2 in uNum 
        where num1!=num2
        select num1+num2).Distinct();
foreach (var s in sums)
{
    Console.WriteLine(s);
}

Answer 6

我能想到的最好方法是生成每对总和的矩阵，然后将行合并在一起，即合并排序。 我觉得我缺少一些简单的见解，可以揭示更有效的解决方案。

我的算法，在 Haskell 中：

matrixOfSums list = [[a+b | b <- list, b >= a] | a <- list]

sortedSums = foldl merge [] matrixOfSums

--A normal merge, save that we remove duplicates
merge xs [] = xs
merge [] ys = ys
merge (x:xs) (y:ys) = case compare x y of
    LT -> x:(merge xs (y:ys))
    EQ -> x:(merge xs (dropWhile (==x) ys))
    GT -> y:(merge (x:xs) ys)

我发现了一个小改进，它更适合基于惰性流的编码。 一次合并所有列，而不是成对合并列。 优点是您可以立即开始获取列表元素。

-- wide-merge does a standard merge (ala merge-sort) across an arbitrary number of lists
-- wideNubMerge does this while eliminating duplicates
wideNubMerge :: Ord a => [[a]] -> [a]
wideNubMerge ls = wideNubMerge1 $ filter (/= []) ls
wideNubMerge1 [] = []
wideNubMerge1 ls = mini:(wideNubMerge rest)
    where mini = minimum $ map head ls
          rest = map (dropWhile (== mini)) ls

betterSortedSums = wideNubMerge matrixOfSums

但是，如果您知道将使用所有总和，并且提前获得其中一些没有任何好处，请使用“ foldl merge [] ”，因为它更快。

Answer 7

无论你做什么，如果不对输入值施加额外的约束，你都不能做得比 O(n^2) 更好，因为你必须遍历所有的数字对。 迭代将主导排序（您可以在 O(n log n) 或更快的时间内完成）。

Answer 8

如果您正在寻找一种真正的语言不可知解决方案，那么在我看来，您会非常失望，因为您将被 for 循环和一些条件所困。 但是，如果您将其打开为函数式语言或函数式语言特性（我正在寻找 LINQ），那么我这里的同事可以用 Ruby、Lisp、Erlang 和其他语言的优雅示例填充此页面。