一种有效的袜子配对算法

前提条件

堆里必须至少有一只袜子桌子必须足够大，以容纳N/2袜子（最坏情况），其中N是总数袜子。

算法

Try:

挑选第一只袜子把它放在桌子上选择下一只袜子，然后看看它（可能会把“不再有袜子”扔到袜子堆里）现在扫描桌子上的袜子（如果桌子上没有袜子，则抛出异常）有匹配的吗？a） 是=>从桌子上取下匹配的袜子b） no=>将袜子放在桌子上（可能会抛出“桌子不够大”异常）

除了：

桌子不够大：小心地将所有未配对的袜子混合在一起，然后继续操作//此操作将导致一个新的堆和一个空表桌子上没有袜子：扔（最后一只不受欢迎的袜子）堆里没有袜子：出口洗衣房

最后：

如果袜子堆里还有袜子：转到3

已知问题

如果或周围没有表，算法将进入无限循环桌子上没有足够的地方容纳至少一只袜子。

可能的改进

根据要分拣的袜子数量，吞吐量可能是通过整理桌子上的袜子来增加空间

为了使其工作，需要一个具有唯一每双袜子的价值。这样的属性很容易根据袜子的视觉财产合成。

按所述属性对桌上的袜子进行排序。让我们调用该属性“颜色”。将袜子排成一排，并将深色袜子放在右侧（即push_back（）），左侧（即。.push_front（））

对于大量的袜子，尤其是以前看不见的袜子，属性合成可能需要很长时间，因此吞吐量将明显下降。但是，这些属性可以保存在内存中并重用。

需要进行一些研究来评估这种可能性的效率改善出现以下问题：

上述袜子的最佳搭配数量是多少改善对于给定数量的袜子，之前需要多少次迭代吞吐量增加？a） 用于最后一次迭代b） 对于所有迭代

符合MCVE指南的PoC：

#include <iostream>
#include <vector>
#include <string>
#include <time.h>

using namespace std;

struct pileOfsocks {
    pileOfsocks(int pairCount = 42) :
        elemCount(pairCount<<1) {
        srand(time(NULL));
        socks.resize(elemCount);

        vector<int> used_colors;
        vector<int> used_indices;

        auto getOne = [](vector<int>& v, int c) {
            int r;
            do {
                r = rand() % c;
            } while (find(v.begin(), v.end(), r) != v.end());
            v.push_back(r);
            return r;
        };

        for (auto i = 0; i < pairCount; i++) {
            auto sock_color = getOne(used_colors, INT_MAX);
            socks[getOne(used_indices, elemCount)] = sock_color;
            socks[getOne(used_indices, elemCount)] = sock_color;
        }
    }

    void show(const string& prompt) {
        cout << prompt << ":" << endl;
        for (auto i = 0; i < socks.size(); i++){
            cout << socks[i] << " ";
        }
        cout << endl;
    }

    void pair() {
        for (auto i = 0; i < socks.size(); i++) {
            std::vector<int>::iterator it = find(unpaired_socks.begin(), unpaired_socks.end(), socks[i]);
            if (it != unpaired_socks.end()) {
                unpaired_socks.erase(it);
                paired_socks.push_back(socks[i]);
                paired_socks.push_back(socks[i]);
            }
            else
                unpaired_socks.push_back(socks[i]);
        }

        socks = paired_socks;
        paired_socks.clear();
    }

private:
    int elemCount;
    vector<int> socks;
    vector<int> unpaired_socks;
    vector<int> paired_socks;
};

int main() {
    pileOfsocks socks;

    socks.show("unpaired socks");
    socks.pair();
    socks.show("paired socks");

    system("pause");
    return 0;
}

这是问错了问题。正确的问题是，我为什么要花时间整理袜子？如果你选择X个货币单位来计算你的空闲时间，那么每年的花费是多少？

通常情况下，这不仅仅是任何空闲时间，这是早晨的空闲时间，你可以躺在床上，或者喝咖啡，或者早点离开，不被交通堵塞。

退一步想办法解决问题通常是好的。

还有一个办法！

找一只你喜欢的袜子。考虑所有相关特征：不同照明条件下的颜色、整体质量和耐久性、不同气候条件下的舒适性以及气味吸收。同样重要的是，它们在储存过程中不应失去弹性，所以天然织物是好的，它们应该可以用塑料包装。

如果左脚和右脚的袜子没有区别，那就更好了，但这并不重要。如果袜子是左右对称的，找到一双袜子是O（1）运算，而对袜子进行排序是近似的O（M）运算，其中M是你家里扔袜子的地方的数量，理想情况下是一个小常数。

如果你选择了一双左右袜子不同的奇装异服，对左脚和右脚的桶进行全桶排序，取O（N+M），其中N是袜子的数量，M与上述相同。其他人可以给出找到第一双袜子的平均迭代次数的公式，但通过盲搜索找到一双袜子的最坏情况是N/2+1，对于合理的N来说，这在天文学上是不太可能的。当用Mk1 Eyeball扫描一堆未分类的袜子时，使用先进的图像识别算法和启发式方法可以加快速度。

因此，实现O（1）袜子配对效率的算法（假设对称袜子）为：

你需要估计你的余生需要多少双袜子，或者直到你退休并搬到更温暖的气候，不再需要穿袜子。如果你还年轻，你还可以估计我们需要多长时间才能在家里拥有袜子分拣机器人，而整个问题变得无关紧要。您需要了解如何批量订购您选择的袜子，以及它的价格，以及它们的送货方式。订购袜子！扔掉你的旧袜子。

另一个步骤3将包括比较几年来一次购买几双同样数量的可能更便宜的袜子的成本，并加上整理袜子的成本。但我要保证：批量购买更便宜！此外，库存袜子的价值会随着股价的上涨而增加，这比你在很多投资中得到的要多。此外，还有存储成本，但袜子确实不会占用壁橱顶部货架上的空间。

问题已解决。所以，只要买一双新袜子，扔掉/捐赠你的旧袜子，在知道你的余生每天都在节省金钱和时间之后，就可以幸福地生活下去。

案例1：所有袜子都是一样的（顺便说一句，这是我在现实生活中所做的）。

选择其中的任意两个组成一对。恒定时间。

案例2：有固定数量的组合（所有权、颜色、大小、纹理等）。

使用基数排序。这只是线性时间，因为不需要比较。

情况3：组合的数量事先未知（一般情况）。

我们必须进行比较，以检查两只袜子是否成对。选择基于O（n log n）比较的排序算法之一。

然而，在现实生活中，当袜子的数量相对较少（恒定）时，这些理论上的优化算法将无法很好地工作。这可能比顺序搜索花费更多的时间，理论上需要二次时间。

如果你可以将一双袜子抽象为密钥本身，将另一双袜子作为值，那么我们可以使用哈希来发挥作用。

在你身后的地板上做两个假想的部分，一个给你，另一个给配偶。从袜子堆里取一只。现在，按照以下规则将袜子一只一只地放在地板上。确定袜子是你的还是她的，并查看地板上的相关部分。如果你能在地板上找到这双鞋，就把它捡起来，把它们系起来，或者把它们夹起来，或者在找到一双鞋后做任何你想做的事情，然后把它放在篮子里（把它从地板上取下来）。将其放在相关章节中。重复3次，直到所有袜子都从袜子堆上取下。

说明：

哈希和抽象

抽象是一个非常强大的概念，已用于改善用户体验（UX）。现实生活中与计算机交互的抽象示例包括：

用于在GUI（图形用户界面）中导航以访问地址的文件夹图标，而不是键入实际地址以导航到某个位置。GUI滑块用于控制不同级别的音量、文档滚动位置等。。

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

我相信提问者正在考虑使用哈希，这样在放置袜子之前，应该知道袜子的位置。

这就是为什么我建议将放在地板上的一只袜子抽象为哈希键本身（因此不需要复制袜子）。

如何定义哈希键？

如果有不止一双类似的袜子，下面的密钥定义也适用。也就是说，假设有两双黑色男士袜子PairA和PairB，每双袜子都被命名为PairA-L、PairA-R、PairB-L和PairB-R。因此，PairA-L可以与PairB-R配对，但PairA-L和PairB-L不能配对。

假设任何袜子都可以通过以下方式唯一标识，

属性[性别]+属性[颜色]+属性（材质）+属性[类型1]+属性[类别2]+属性[左_右]

这是我们的第一个哈希函数。让我们对这个h1（G_C_M_T1_T2_LR）使用一个简短的符号。h1（x）不是我们的位置键。

消除Left_or_Right属性的另一个哈希函数是h2（G_C_M_T1_T2）。第二个函数h2（x）是我们的位置键！（你身后地板上的空间）。

要定位插槽，请使用h2（G_C_M_T1_T2）。一旦找到了槽，就使用h1（x）来检查它们的哈希值。如果它们不匹配，你就有一对。否则，把袜子扔到同一个槽里。

注意：由于我们在找到一个插槽时删除了一个插槽，因此可以安全地假设最多只有一个插槽具有唯一的h2（x）或h1（x）值。

如果我们每只袜子正好有一对匹配的袜子，那么使用h2（x）来查找位置，如果没有袜子，则需要进行检查，因为可以安全地假设它们是一对。

为什么把袜子放在地板上很重要

让我们考虑一个场景，袜子堆在一起（最坏的情况）。这意味着我们别无选择，只能进行线性搜索来找到一对。

将它们铺在地板上可以提高可见度，从而提高发现匹配袜子（匹配哈希键）的机会。当第三步把袜子放在地板上时，我们的大脑已经下意识地记录了位置。-因此，如果这个位置在我们的内存中可用，我们可以直接找到匹配的配对。-如果没有记住位置，不要担心，然后我们可以一直返回到线性搜索。

为什么从地板上取下这对鞋很重要？

短期人类记忆在需要记忆的项目较少时效果最好。因此，增加了我们使用哈希来识别这对的概率。当使用线性搜索对时，它还将减少要搜索的项目的数量。

分析

情况1：最坏的情况是，Derpina无法记住或直接使用哈希技术在地板上发现袜子。Derp对地板上的物品进行线性搜索。这并不比遍历堆以找到对更糟。比较上限：O（n^2）。比较下限：（n/2）。（当Derpina每捡一只袜子都是上一只的时候）。案例2：德普记得他放在地板上的每一只袜子的位置，每只袜子正好有一双。比较上限：O（n/2）。比较下限：O（n/2）。

我说的是比较操作，从袜子堆里挑选袜子必然是n次操作。因此，实际的下限是n次迭代，n/2次比较。

加快进度

为了获得完美的分数，使Derp获得O（n/2）比较，我建议Derpina，

花更多时间穿袜子来熟悉它。是的，这意味着也要花更多时间穿着德普的袜子。玩记忆游戏，如在网格中找出对，可以提高短期记忆性能，这是非常有益的。

这是否等同于元素清晰度问题？

我建议的方法是用于解决元素区分问题的方法之一，将它们放在哈希表中并进行比较。

考虑到您的特殊情况，即只有一个精确的对，它已经变得非常等价于元素区别问题。因为我们甚至可以对袜子进行分类，并检查相邻袜子是否成对（EDP的另一种解决方案）。

然而，如果给定袜子可能存在不止一双，那么它就偏离了EDP。

为了说明从一堆袜子中配对有多有效，我们必须首先定义机器，因为配对不是通过图灵或随机存取机器完成的，而随机存取机器通常用作算法分析的基础。

机器

机器是被称为人类的现实世界元素的抽象。它能够通过一双眼睛从环境中阅读。我们的机器模型能够通过使用两个手臂来操纵环境。逻辑和算术运算是用我们的大脑计算的（希望是；-）。

我们还必须考虑可以使用这些仪器执行的原子操作的内在运行时间。由于物理限制，由手臂或眼睛执行的操作具有非恒定的时间复杂性。这是因为我们不能用手臂移动一大堆无穷无尽的袜子，也不能用眼睛看到一大堆袜子上的袜子。

然而，机械物理学也给了我们一些好处。我们不限于用手臂移动最多一只袜子。我们可以一次移动两个。

因此，根据之前的分析，应按降序使用以下操作：

逻辑和算术运算环境读数环境改造

我们还可以利用这样一个事实，即人们只有非常有限的袜子。因此，环境改造可能涉及到所有袜子。

算法

我的建议是：

把袜子堆里的袜子都铺在地板上。通过看地板上的袜子找到一双。从2开始重复，直到无法配对。从1开始重复，直到地板上没有袜子。

操作4是必要的，因为当将袜子铺在地板上时，一些袜子可能会隐藏其他袜子。算法分析如下：

分析

该算法以高概率终止。这是由于在第二步中找不到袜子。

对于以下对n双袜子配对的运行时分析，我们假设在步骤1之后，至少有一半的2n双袜子没有隐藏。所以在平均情况下，我们可以找到n/2对。这意味着步骤4的循环执行了O（logn）次。步骤2执行O（n^2）次。因此，我们可以得出结论：

该算法涉及O（lnn+n）环境修改（步骤1 O（lnn）加上从地板上挑选每双袜子）该算法涉及步骤2中的O（n^2）个环境读数该算法包括O（n^2）个逻辑和算术运算，用于在步骤2中比较袜子和另一袜子

因此，我们的总运行时复杂度为O（r*n^2+w*（lnn+n）），其中r和w分别是合理数量袜子的环境读取和环境写入操作的因素。省略了逻辑运算和算术运算的成本，因为我们假设需要恒定数量的逻辑运算和算数运算来决定2只袜子是否属于同一对。这可能在每种情况下都不可行。

我在攻读计算机科学博士期间经常思考这个问题。我提出了多种解决方案，这取决于区分袜子的能力，从而尽可能快地找到正确的袜子。

假设看袜子和记住它们独特图案的成本可以忽略不计（ε）。那么最好的解决办法就是把所有的袜子都扔到桌子上。这包括以下步骤：

将所有袜子放在一张桌子上（1），并创建一个hashmap｛pattern:position｝（ε）当有剩余袜子时（n/2）：随机挑选一只袜子（1）查找相应袜子的位置（ε）取回袜子（1）并存放

这确实是最快的可能性，并且以n+1＝O（n）复杂度执行。但它假设你完全记得所有的模式。。。在实践中，情况并非如此，我个人的经验是，你有时在第一次尝试时找不到匹配的一对：

把所有袜子扔在桌子上（1）当有剩余袜子时（n/2）：随机挑选一只袜子（1）当未配对时（1/P）：找到具有相似图案的袜子拿袜子，比较两者（1）如果可以，存储配对

这现在取决于我们找到匹配对的能力。如果你的深色/灰色双鞋或白色运动袜经常有非常相似的图案，这一点尤其正确！让我们承认你有概率找到相应的袜子。在找到相应的袜子以形成一双袜子之前，平均需要1/P的尝试。总体复杂度为1+（n/2）*（1+1/P）=O（n）。

两者在袜子数量上都是线性的，并且是非常相似的解决方案。让我们稍微修改一下这个问题，承认你有多双类似的袜子，并且很容易在一次移动中存储多双袜子（1+ε）。对于K个不同的模式，您可以实现：

对于每只袜子（n）：随机挑选一只袜子（1）将其放到其模式的集群中对于每个集群（K）：取簇并储存袜子（1+ε）

总体复杂度变为n+K=O（n）。它仍然是线性的，但选择正确的算法现在可能很大程度上取决于P和K的值！但人们可能会再次反对，因为您可能很难找到（或创建）每只袜子的集群。

此外，你也可以在网站上查找最佳算法，并提出自己的解决方案，从而节省时间：）