我怎样才能有效地从一堆袜子里穿袜子？

昨天，我在洗衣服时把袜子配对，结果发现我这样做效率不高。我在做一个天真的搜索——挑选一只袜子，然后“反复”寻找那一双袜子。这需要平均在n/2*n/4=n2/8袜子上迭代。

作为一名计算机科学家，我在想我能做什么？排序（根据大小/颜色/…）当然是为了实现O（NlogN）解决方案。

哈希或其他不到位的解决方案是不可选择的，因为我无法复制我的袜子（如果可以的话，这可能很好）。

因此，问题基本上是：

给定一堆n双袜子，其中包含2n个元素（假设每只袜子正好有一对匹配的袜子），用对数的额外空间高效地将它们配对的最佳方式是什么？（如果需要的话，我相信我可以记住这些信息。）

我将感谢回答以下方面的问题：

大量袜子的一般理论解。袜子的实际数量没有那么多，我不相信我的配偶和我有超过30双。（而且很容易区分我的袜子和她的袜子；这也可以用吗？）它是否等同于元素清晰度问题？

当前回答

这是基于比较的模型中的Omega（n log n）下限。（唯一有效的操作是比较两只袜子。）

假设你知道你的2n只袜子是这样排列的：

p1 p2 p3。。。pn pf（1）pf（2）。。。功率因数（n）

其中f是集合{1,2，…，n}的未知排列。知道这一点不会使问题变得更难。有n个！可能的输出（上半部分和下半部分之间的匹配），这意味着您需要log（n！）=Omega（n log n）比较。这可通过分类获得。

由于您对元素区别性问题的连接感兴趣：证明元素区别性的Omega（n log n）界限比较困难，因为输出是二进制的yes/no。这里，输出必须是匹配的，并且可能输出的数量足以获得一个合适的界限。然而，有一个变量与元素的区别有关。假设你有2n只袜子，想知道它们是否可以唯一配对。您可以通过将（a1，a2，…，an）发送到（a1，a1，a2、a2，…、an，an）来获得ED的缩减。（附带地，通过拓扑结构，ED的硬度证明非常有趣。）

我认为，如果只允许等式测试，那么原始问题应该有一个Omega（n2）边界。我的直觉是：考虑一个测试后添加边的图形，并认为如果图形不密集，则输出不是唯一确定的。

2013-01-20 20:18:42

其他回答

我所做的就是拿起第一只袜子，把它放下（比如，放在洗衣碗的边缘）。然后我拿起另一只袜子，检查它是否与第一只袜子相同。如果是，我会把它们都去掉。如果不是，我把它放在第一只袜子旁边。然后我拿起第三只袜子，将其与前两只袜子进行比较（如果它们还在的话）。等

这种方法可以很容易地在阵列中实现，假设“移除”袜子是一个选项。实际上，你甚至不需要“脱掉”袜子。如果您不需要对袜子进行排序（见下文），那么您只需移动它们，就可以得到一个数组，该数组中所有袜子都成对排列。

假设袜子的唯一操作是比较相等，这个算法基本上仍然是n2算法，尽管我不知道平均情况（从未学会计算）。

当然，分类可以提高效率，尤其是在现实生活中，你可以很容易地将袜子“插入”在另外两个袜子之间。在计算中，树也可以做到这一点，但这是额外的空间。当然，我们又回到了NlogN（或者更多，如果有几只袜子按排序标准是相同的，但不是来自同一双）。

除此之外，我想不出什么，但这种方法在现实生活中似乎非常有效

2013-01-19 15:49:31

List<Sock> UnSearchedSocks = getAllSocks();
List<Sock> UnMatchedSocks = new list<Sock>();
List<PairOfSocks> PairedSocks = new list<PairOfSocks>();

foreach (Sock newSock in UnsearchedSocks)
{
  Sock MatchedSock = null;
  foreach(Sock UnmatchedSock in UnmatchedSocks)
  {
    if (UnmatchedSock.isPairOf(newSock))
    {
      MatchedSock = UnmatchedSock;
      break;
    }
  }
  if (MatchedSock != null)
  {
    UnmatchedSocks.remove(MatchedSock);
    PairedSocks.Add(new PairOfSocks(MatchedSock, NewSock));
  }
  else
  {
    UnmatchedSocks.Add(NewSock);
  }
}

2013-01-22 16:32:11

我提出的解决方案假设所有袜子在细节上都是相同的，除了颜色。如果袜子之间有更多的细节需要延迟，这些细节可以用来定义不同类型的袜子，而不是我的例子中的颜色。。

假设我们有一堆袜子，袜子可以有三种颜色：蓝色、红色或绿色。

然后，我们可以为每种颜色创建一个并行工作程序；它有自己的列表来填充相应的颜色。

At time i:

Blue  read  Pile[i]    : If Blue  then Blue.Count++  ; B=TRUE  ; sync

Red   read  Pile[i+1]  : If Red   then Red.Count++   ; R=TRUE  ; sync

Green read  Pile [i+2] : If Green then Green.Count++ ; G=TRUE  ; sync

同步过程：

Sync i:

i++

If R is TRUE:
    i++
    If G is TRUE:
        i++

这需要初始化：

Init:

If Pile[0] != Blue:
    If      Pile[0] = Red   : Red.Count++
    Else if Pile[0] = Green : Green.Count++

If Pile[1] != Red:
    If Pile[0] = Green : Green.Count++

哪里

Best Case: B, R, G, B, R, G, .., B, R, G

Worst Case: B, B, B, .., B

Time(Worst-Case) = C * n ~ O(n)

Time(Best-Case) = C * (n/k) ~ O(n/k)

n: number of sock pairs
k: number of colors
C: sync overhead

2014-05-25 09:46:20

非算法答案，但当我这样做时“高效”：

步骤1）丢弃所有现有袜子第2步）去沃尔玛买10-n包的白色和m包黑色。日常无需其他颜色生活

然而，有时，我不得不再次这样做（丢失的袜子、损坏的袜子等），我讨厌太频繁地丢弃完美的袜子（我希望他们继续出售相同的袜子参考！），所以我最近采取了不同的方法。

算法答案：

考虑一下，如果你只为第二叠袜子画一只袜子，就像你正在做的那样，你在天真的搜索中找到匹配袜子的几率很低。

所以，随机挑选其中五个，记住它们的形状或长度。

为什么是五？通常情况下，人类在工作记忆中记住五到七个不同的元素是很好的——有点像RPN堆栈的人类等价物——五个是安全的默认值。

从2n-5的堆栈中选择一个。现在，在你画的五个图案中寻找一个匹配（视觉模式匹配-人类擅长用一个小堆栈），如果你没有找到一个，那么把它添加到你的五个。继续从袜子堆中随机挑选袜子，并与你的5+1袜子进行比较。随着堆栈的增长，它会降低性能，但会提高赔率。快得多。

请随意写下公式，以计算50%的匹配几率需要抽取多少样本。IIRC这是一个超几何定律。

我每天早上都会这样做，很少需要三次以上的平局——但我有n双类似的m形白袜子（大约10双，不分输赢）。现在你可以估计我的股票堆的大小：-）

顺便说一句，我发现，每次我需要一双袜子时，整理所有袜子的交易成本之和远远少于一次整理和装订袜子。准时制的效果更好，因为这样你就不必绑袜子了，而且边际回报也在减少（也就是说，当你在洗衣店的某个地方时，你一直在寻找那两到三只袜子，而你需要完成袜子的搭配，而你却在这上面浪费了时间）。