使用 std::map 对键进行部分匹配

【问题标题】：Partial matching of a key using a std::map使用 std::map 对键进行部分匹配
【发布时间】：2023-03-29 10:48:01
【问题描述】：

当您在该结构的两个不同成员之间进行匹配时，我有一个关于如何使用 std::map 对象对结构键进行部分匹配的问题。

让我们从一个简单的场景开始。假设我想对一个键进行部分匹配，只涉及结构的一个成员。我有以下地图和钥匙：

std::map<SimpleIdentifier, Contents>

SimpleIdentifier 如下所述。

/**
 * \class SimpleIdentifier
 * \brief Used to identify and sort data in the map
 */
class SimpleIdentifier
{
public:
    SimpleIdentifier():
        idA(-1),
        idB(-1),
        partialMatch1(false) {}

    SimpleIdentifier(const long long int& a, const long long int& b):
        idA(a),
        idB(b),
        partialMatch1(false) {}

    void setPartialMatch1() { partialMatch1 = true; }

    bool operator==(const Identifier& rhs) const
    {
        return (idA == rhs.idA) && (idB == rhs.idB);
    }

    bool operator<(const Identifier& rhs) const
    {
        if (partialMatch1 || rhs.partialMatch1)
        {
            // Match A to A
            if(rhs.partialMatch1)
            {
                if(idA < rhs.idA)
                {
                    return true;
                }
            }
            else if(partialMatch1)
            {
                if(idA < rhs.idA)
                {
                    return true;
                }
            }

            return false;
        }
        else
        {
            if(idA < rhs.idA)
            {
                return true;
            }
            else if (idA == rhs.idA)
            {
                if(idB < rhs.idB)
                {
                    return true;
                }
            }

        }

        return false;
    }

private:
    long long int idA;
    long long int idB;

    bool partialMatch1;
};

这让我可以按 A 排序，如果 A 相等，则按 B 排序。因此，如果我有以下数据

dataMap:

Key: [ 0, 0 ] Value: []
Key: [ 0, 1 ] Value: []
Key: [ 0, 2 ] Value: []
Key: [ 3, 1 ] Value: []
Key: [ 3, 2 ] Value: []
Key: [ 3, 3 ] Value: []
Key: [ 5, 3 ] Value: []
Key: [ 5, 7 ] Value: []

我可以找到[ 3, 2 ]对应的键值对

Identifier perfectMatchID(3, 2);
std::map<SimpleIdentifier, Contents>::iterator it = dataMap.begin();
it = dataMap.find(perfectMatchID);

我也可以找到对应于[ 3, * ]的部分匹配

Identifier partialMatchID(3, 2);
partialMatchID.setPartialMatch1();
std::map<SimpleIdentifier, Contents>::iterator it = dataMap.begin();
it = dataMap.find(partialMatchID);

这很好，因为我可以在 while 循环中遍历每个迭代器以找到每个匹配的键值对并对其进行处理。

我现在想将它扩展为能够匹配匹配 3 的键的任一成员，因此包括 [ 3, * ] 或 [ *, 3 ]。 SimpleIdentifier 已扩展为一个名为 Identifier 的新对象。 

/**
 * \class Identifier
 * \brief Used to identify and sort data in the map
 */
class Identifier
{
public:
    Identifier():
        idA(-1),
        idB(-1),
        partialMatch(false),
        partialMatch1(false),
        partialMatch2(false),
        partialMatch3(false),
        partialMatch4(false) {}

    Identifier(const long long int& a, const long long int& b):
        idA(a),
        idB(b),
        partialMatch(false),
        partialMatch1(false),
        partialMatch2(false),
        partialMatch3(false),
        partialMatch4(false) {}

    void setPartialMatch() { partialMatch = true; }
    void setPartialMatch1() { partialMatch1 = true; }
    void setPartialMatch2() { partialMatch2 = true; }
    void setPartialMatch3() { partialMatch3 = true; }
    void setPartialMatch4() { partialMatch4 = true; }

    bool operator==(const Identifier& rhs) const
    {
        return (idA == rhs.idA) && (idB == rhs.idB);
    }

    bool operator<(const Identifier& rhs) const
    {
        if (partialMatch || rhs.partialMatch)
        {
            // In order to match, only 1 should be false, the other 3 may or may not be false
            //
            // Note: The issue here is that the check that validates for the rhs.partialMatch should be identical
            //       to the check that validates for partialMatch. Since this is const that may not be possible
            if(rhs.partialMatch)
            {
                unsigned int check1 = (idA < rhs.idA) ? 1 : 0; // Match A to A
                unsigned int check2 = (idB < rhs.idB) ? 1 : 0; // Match B to B
                unsigned int check3 = (idA < rhs.idB) ? 1 : 0; // Match A to B
                unsigned int check4 = (idB < rhs.idA) ? 1 : 0; // Match B to A

                if( (check1 + check2 + check3 + check4) > 0 )
                {
                    return true;
                }
            }
            else if(partialMatch)
            {
                unsigned int check1 = (idA < rhs.idA) ? 1 : 0; // Match A to A
                unsigned int check2 = (idB < rhs.idB) ? 1 : 0; // Match B to B
                unsigned int check3 = (idB < rhs.idA) ? 1 : 0; // Match B to A
                unsigned int check4 = (idA < rhs.idB) ? 1 : 0; // Match A to B

                if( (check1 + check2 + check3 + check4) > 0 )
                {
                    return true;
                }
            }

            return false;
        }
        else if (partialMatch1 || rhs.partialMatch1)
        {
            // Match A to A
            if(rhs.partialMatch1)
            {
                if(idA < rhs.idA)
                {
                    return true;
                }
            }
            else if(partialMatch1)
            {
                if(idA < rhs.idA)
                {
                    return true;
                }
            }

            return false;
        }
        else if (partialMatch2 || rhs.partialMatch2)
        {
            // Match B to B
            if(rhs.partialMatch2)
            {
                if(idB < rhs.idB)
                {
                    return true;
                }
            }
            else if(partialMatch2)
            {
                if(idB < rhs.idB)
                {
                    return true;
                }
            }

            return false;
        }
        else if (partialMatch3 || rhs.partialMatch3)
        {
            // Match A to B
            if(rhs.partialMatch3)
            {
                if(idA < rhs.idB)
                {
                    return true;
                }
            }
            else if(partialMatch3)
            {
                if(idB < rhs.idA)
                {
                    return true;
                }
            }

            return false;
        }
        else if (partialMatch4 || rhs.partialMatch4)
        {
            // Match B to A
            if(rhs.partialMatch4)
            {
                if(idB < rhs.idA)
                {
                    return true;
                }
            }
            else if(partialMatch4)
            {
                if(idA < rhs.idB)
                {
                    return true;
                }
            }

            return false;
        }
        else
        {
            if(idA < rhs.idA)
            {
                return true;
            }
            else if (idA == rhs.idA)
            {
                if(idB < rhs.idB)
                {
                    return true;
                }
            }

        }

        return false;
    }

private:
    long long int idA;
    long long int idB;

    bool partialMatch;
    bool partialMatch1;
    bool partialMatch2;
    bool partialMatch3;
    bool partialMatch4;
};

标识符让我进行部分匹配，使用查询键查找四种场景。它寻找四种场景（不是实际代码）

queryKey.idA == idA
queryKey.idB == idB
queryKey.idA == idB
queryKey.idB == idA

但是，在实践中，我需要在每个场景上执行一个 while 循环，一次只设置一个部分匹配项（1 到 4）。 

setPartialMatch1(); // a-rhs.a
setPartialMatch2(); // b-rhs.b
setPartialMatch3(); // a-rhs.b
setPartialMatch4(); // b-rhs.a

我希望能够对其进行增强，以便在单个块中识别部分匹配的键。

setPartialMatch(); // magic

我设计了下面的单元测试。使用匹配 1 到匹配 4 的所有部分匹配都可以正常工作。但是，进行部分匹配以使我不需要每个匹配项都行不通。你会发现使用 setPartialMatch(); 运行这个单元测试对于所有测试都会失败

任何关于如何使其工作的想法或建议，或替代方案都会很棒。

完整的单元测试如下：

/**
 * \file PartialMatchUnitTest.cpp
 *
 * \brief Unit testing for partial matching in std::map
 *
 * \author Otto Nahmee
 */

#define BOOST_TEST_DYN_LINK
#define BOOST_TEST_MODULE PartialMatchingUnitTest

#include <boost/test/unit_test.hpp>

#include <iostream>
#include <map>

/*****************************************************************************/

BOOST_AUTO_TEST_SUITE(TestSuite)

/**
 * \class Identifier
 * \brief Used to identify and sort data in the map
 */
class Identifier
{
public:
    Identifier():
        idA(-1),
        idB(-1),
        partialMatch(false),
        partialMatch1(false),
        partialMatch2(false),
        partialMatch3(false),
        partialMatch4(false) {}

    Identifier(const long long int& a, const long long int& b):
        idA(a),
        idB(b),
        partialMatch(false),
        partialMatch1(false),
        partialMatch2(false),
        partialMatch3(false),
        partialMatch4(false) {}

    void setPartialMatch() { partialMatch = true; }
    void setPartialMatch1() { partialMatch1 = true; }
    void setPartialMatch2() { partialMatch2 = true; }
    void setPartialMatch3() { partialMatch3 = true; }
    void setPartialMatch4() { partialMatch4 = true; }

    bool operator==(const Identifier& rhs) const
    {
        return (idA == rhs.idA) && (idB == rhs.idB);
    }

    bool operator<(const Identifier& rhs) const
    {
        if (partialMatch || rhs.partialMatch)
        {
            // In order to match, only 1 should be false, the other 3 may or may not be false
            //
            // Note: The issue here is that the check that validates for the rhs.partialMatch should be identical
            //       to the check that validates for partialMatch. Since this is const that may not be possible
            if(rhs.partialMatch)
            {
                unsigned int check1 = (idA < rhs.idA) ? 1 : 0; // Match A to A
                unsigned int check2 = (idB < rhs.idB) ? 1 : 0; // Match B to B
                unsigned int check3 = (idA < rhs.idB) ? 1 : 0; // Match A to B
                unsigned int check4 = (idB < rhs.idA) ? 1 : 0; // Match B to A

                if( (check1 + check2 + check3 + check4) > 0 )
                {
                    return true;
                }
            }
            else if(partialMatch)
            {
                unsigned int check1 = (idA < rhs.idA) ? 1 : 0; // Match A to A
                unsigned int check2 = (idB < rhs.idB) ? 1 : 0; // Match B to B
                unsigned int check3 = (idB < rhs.idA) ? 1 : 0; // Match B to A
                unsigned int check4 = (idA < rhs.idB) ? 1 : 0; // Match A to B

                if( (check1 + check2 + check3 + check4) > 0 )
                {
                    return true;
                }
            }

            return false;
        }
        else if (partialMatch1 || rhs.partialMatch1)
        {
            // Match A to A
            if(rhs.partialMatch1)
            {
                if(idA < rhs.idA)
                {
                    return true;
                }
            }
            else if(partialMatch1)
            {
                if(idA < rhs.idA)
                {
                    return true;
                }
            }

            return false;
        }
        else if (partialMatch2 || rhs.partialMatch2)
        {
            // Match B to B
            if(rhs.partialMatch2)
            {
                if(idB < rhs.idB)
                {
                    return true;
                }
            }
            else if(partialMatch2)
            {
                if(idB < rhs.idB)
                {
                    return true;
                }
            }

            return false;
        }
        else if (partialMatch3 || rhs.partialMatch3)
        {
            // Match A to B
            if(rhs.partialMatch3)
            {
                if(idA < rhs.idB)
                {
                    return true;
                }
            }
            else if(partialMatch3)
            {
                if(idB < rhs.idA)
                {
                    return true;
                }
            }

            return false;
        }
        else if (partialMatch4 || rhs.partialMatch4)
        {
            // Match B to A
            if(rhs.partialMatch4)
            {
                if(idB < rhs.idA)
                {
                    return true;
                }
            }
            else if(partialMatch4)
            {
                if(idA < rhs.idB)
                {
                    return true;
                }
            }

            return false;
        }
        else
        {
            if(idA < rhs.idA)
            {
                return true;
            }
            else if (idA == rhs.idA)
            {
                if(idB < rhs.idB)
                {
                    return true;
                }
            }

        }

        return false;
    }

private:
    long long int idA;
    long long int idB;

    bool partialMatch;
    bool partialMatch1;
    bool partialMatch2;
    bool partialMatch3;
    bool partialMatch4;
};

/**
 * \class Contents
 * \brief Contents to get merged in
 */
struct Contents
{
public:
    Contents():
        num1(0),
        num2(0),
        num3(0),
        num4(0)
    {}

    Contents(const long long int& n1, const long long int& n2, const long long int& n3, const long long int& n4):
        num1(n1),
        num2(n2),
        num3(n3),
        num4(n4)
    {}

    long long int num1;
    long long int num2;
    long long int num3;
    long long int num4;
};

typedef std::pair<Identifier, Contents> DataPair;
typedef std::map<Identifier, Contents> DataMap;



/**
 * \brief Testing Partial matching
 */
BOOST_AUTO_TEST_CASE(PartialMatch)
{
    DataMap dataMap;

    Identifier ID0(8, 9);
    dataMap[ID0] = Contents(1,2,3,4);

    Identifier ID1(10, 11);
    dataMap[ID1] = Contents(1,2,3,4);

    Identifier ID2(12, 14);
    dataMap[ID2] = Contents(1,2,3,4);

    Identifier ID3(15, 17);
    dataMap[ID3] = Contents(1,2,3,4);

    Identifier ID4(14, 22);
    dataMap[ID4] = Contents(1,2,3,4);

    Identifier ID5(23, 25);
    dataMap[ID5] = Contents(1,2,3,4);


    // Test perfect matching
    {
        Identifier perfectMatchID1(10, 11);

        DataMap::iterator it1 = dataMap.begin();
        it1 = dataMap.find(perfectMatchID1);
        BOOST_CHECK(it1 != dataMap.end());
        BOOST_CHECK(it1->first == ID1);


        Identifier perfectMatchID3(15, 17);

        DataMap::iterator it3 = dataMap.begin();
        it3 = dataMap.find(perfectMatchID3);
        BOOST_CHECK(it3 != dataMap.end());
        BOOST_CHECK(it3->first == ID3);
    }

    // Test partial matching
    // Try to match ID1 (10, 11);
    {
        Identifier partialMatchID1(10, 100);
        Identifier partialMatchID2(110, 11);
        Identifier partialMatchID3(110, 10);
        Identifier partialMatchID4(11, 100);

        Identifier partialMatchID5(10, 0);
        Identifier partialMatchID6(0, 11);
        Identifier partialMatchID7(0, 10);
        Identifier partialMatchID8(11, 0);

        Identifier partialMatchID9(10, 11);

        partialMatchID1.setPartialMatch1(); // a-rhs.a
        partialMatchID2.setPartialMatch2(); // b-rhs.b
        partialMatchID3.setPartialMatch3(); // a-rhs.b
        partialMatchID4.setPartialMatch4(); // b-rhs.a

        partialMatchID5.setPartialMatch1(); // a-rhs.a
        partialMatchID6.setPartialMatch2(); // b-rhs.b
        partialMatchID7.setPartialMatch3(); // a-rhs.b
        partialMatchID8.setPartialMatch4(); // b-rhs.a

        partialMatchID9.setPartialMatch1();

        DataMap::iterator it1 = dataMap.begin();
        it1 = dataMap.find(partialMatchID1);
        BOOST_CHECK(it1 != dataMap.end());
        BOOST_CHECK(it1->first == ID1);

        DataMap::iterator it2 = dataMap.begin();
        it2 = dataMap.find(partialMatchID2);
        BOOST_CHECK(it2 != dataMap.end());
        BOOST_CHECK(it2->first == ID1);

        DataMap::iterator it3 = dataMap.begin();
        it3 = dataMap.find(partialMatchID3);
        BOOST_CHECK(it3 != dataMap.end());
        BOOST_CHECK(it3->first == ID1);

        DataMap::iterator it4 = dataMap.begin();
        it4 = dataMap.find(partialMatchID4);
        BOOST_CHECK(it4 != dataMap.end());
        BOOST_CHECK(it4->first == ID1);

        DataMap::iterator it5 = dataMap.begin();
        it5 = dataMap.find(partialMatchID5);
        BOOST_CHECK(it5 != dataMap.end());
        BOOST_CHECK(it5->first == ID1);

        DataMap::iterator it6 = dataMap.begin();
        it6 = dataMap.find(partialMatchID6);
        BOOST_CHECK(it6 != dataMap.end());
        BOOST_CHECK(it6->first == ID1);

        DataMap::iterator it7 = dataMap.begin();
        it7 = dataMap.find(partialMatchID7);
        BOOST_CHECK(it7 != dataMap.end());
        BOOST_CHECK(it7->first == ID1);

        DataMap::iterator it8 = dataMap.begin();
        it8 = dataMap.find(partialMatchID8);
        BOOST_CHECK(it8 != dataMap.end());
        BOOST_CHECK(it8->first == ID1);

        DataMap::iterator it9 = dataMap.begin();
        it9 = dataMap.find(partialMatchID9);
        BOOST_CHECK(it9 != dataMap.end());
        BOOST_CHECK(it9->first == ID1);
    }

    // Try to match ID1 (10, 11);
    {
        Identifier partialMatchID1(10, 100);
        Identifier partialMatchID2(110, 11);
        Identifier partialMatchID3(11, 100);
        Identifier partialMatchID4(110, 10);

        Identifier partialMatchID5(10, 0);
        Identifier partialMatchID6(0, 11);
        Identifier partialMatchID7(11, 0);
        Identifier partialMatchID8(0, 10);

        Identifier partialMatchID9(10, 11);

        partialMatchID1.setPartialMatch();
        partialMatchID2.setPartialMatch();
        partialMatchID3.setPartialMatch();
        partialMatchID4.setPartialMatch();

        partialMatchID5.setPartialMatch();
        partialMatchID6.setPartialMatch();
        partialMatchID7.setPartialMatch();
        partialMatchID8.setPartialMatch();

        partialMatchID9.setPartialMatch();

        DataMap::iterator it1 = dataMap.begin();
        it1 = dataMap.find(partialMatchID1);
        BOOST_CHECK(it1 != dataMap.end());
        BOOST_CHECK(it1->first == ID1);

        DataMap::iterator it2 = dataMap.begin();
        it2 = dataMap.find(partialMatchID2);
        BOOST_CHECK(it2 != dataMap.end());
        BOOST_CHECK(it2->first == ID1);

        DataMap::iterator it3 = dataMap.begin();
        it3 = dataMap.find(partialMatchID3);
        BOOST_CHECK(it3 != dataMap.end());
        BOOST_CHECK(it3->first == ID1);

        DataMap::iterator it4 = dataMap.begin();
        it4 = dataMap.find(partialMatchID4);
        BOOST_CHECK(it4 != dataMap.end());
        BOOST_CHECK(it4->first == ID1);

        DataMap::iterator it5 = dataMap.begin();
        it5 = dataMap.find(partialMatchID5);
        BOOST_CHECK(it5 != dataMap.end());
        BOOST_CHECK(it5->first == ID1);

        DataMap::iterator it6 = dataMap.begin();
        it6 = dataMap.find(partialMatchID6);
        BOOST_CHECK(it6 != dataMap.end());
        BOOST_CHECK(it6->first == ID1);

        DataMap::iterator it7 = dataMap.begin();
        it7 = dataMap.find(partialMatchID7);
        BOOST_CHECK(it7 != dataMap.end());
        BOOST_CHECK(it7->first == ID1);

        DataMap::iterator it8 = dataMap.begin();
        it8 = dataMap.find(partialMatchID8);
        BOOST_CHECK(it8 != dataMap.end());
        BOOST_CHECK(it8->first == ID1);

        DataMap::iterator it9 = dataMap.begin();
        it9 = dataMap.find(partialMatchID9);
        BOOST_CHECK(it9 != dataMap.end());
        BOOST_CHECK(it9->first == ID1);
    }


    // Try to match ID3 (15, 17);
    {
        Identifier partialMatchID1(15, 100);
        Identifier partialMatchID2(110, 17);
        Identifier partialMatchID3(17, 100);
        Identifier partialMatchID4(110, 15);

        Identifier partialMatchID5(15, 0);
        Identifier partialMatchID6(0, 17);
        Identifier partialMatchID7(17, 0);
        Identifier partialMatchID8(0, 15);

        Identifier partialMatchID9(15, 17);

        partialMatchID1.setPartialMatch();
        partialMatchID2.setPartialMatch();
        partialMatchID3.setPartialMatch();
        partialMatchID4.setPartialMatch();

        partialMatchID5.setPartialMatch();
        partialMatchID6.setPartialMatch();
        partialMatchID7.setPartialMatch();
        partialMatchID8.setPartialMatch();

        partialMatchID9.setPartialMatch();


        DataMap::iterator it1 = dataMap.begin();
        it1 = dataMap.find(partialMatchID1);
        BOOST_CHECK(it1 != dataMap.end());
        BOOST_CHECK(it1->first == ID3);

        DataMap::iterator it2 = dataMap.begin();
        it2 = dataMap.find(partialMatchID2);
        BOOST_CHECK(it2 != dataMap.end());
        BOOST_CHECK(it2->first == ID3);

        DataMap::iterator it3 = dataMap.begin();
        it3 = dataMap.find(partialMatchID3);
        BOOST_CHECK(it3 != dataMap.end());
        BOOST_CHECK(it3->first == ID3);

        DataMap::iterator it4 = dataMap.begin();
        it4 = dataMap.find(partialMatchID4);
        BOOST_CHECK(it4 != dataMap.end());
        BOOST_CHECK(it4->first == ID3);

        DataMap::iterator it5 = dataMap.begin();
        it5 = dataMap.find(partialMatchID5);
        BOOST_CHECK(it5 != dataMap.end());
        BOOST_CHECK(it5->first == ID3);

        DataMap::iterator it6 = dataMap.begin();
        it6 = dataMap.find(partialMatchID6);
        BOOST_CHECK(it6 != dataMap.end());
        BOOST_CHECK(it6->first == ID3);

        DataMap::iterator it7 = dataMap.begin();
        it7 = dataMap.find(partialMatchID7);
        BOOST_CHECK(it7 != dataMap.end());
        BOOST_CHECK(it7->first == ID3);

        DataMap::iterator it8 = dataMap.begin();
        it8 = dataMap.find(partialMatchID8);
        BOOST_CHECK(it8 != dataMap.end());
        BOOST_CHECK(it8->first == ID3);

        DataMap::iterator it9 = dataMap.begin();
        it9 = dataMap.find(partialMatchID9);
        BOOST_CHECK(it9 != dataMap.end());
        BOOST_CHECK(it9->first == ID3);
    }


}

BOOST_AUTO_TEST_SUITE_END()

/*****************************************************************************/

【问题讨论】：

    标签： c++ stdmap


    【解决方案1】：

    您不能使用std::map。它回答strict-weak-ordering 异常发生在地图的比较器中：

    {   // test if _Pred(_Left, _Right) and _Pred is strict weak ordering
return (!_Pred(_Left, _Right)
    ? false
    : _Pred(_Right, _Left)
        ? (_DEBUG_ERROR2("invalid comparator", _File, _Line), true)
        : true);

    以及我不确定你在这里做什么：

    Identifier partialMatchID(3, 2);
partialMatchID.setPartialMatch1();
std::map<SimpleIdentifier, Contents>::iterator it = dataMap.begin();
it = dataMap.find(partialMatchID);

    这很好，因为我可以通过 while 循环中的每个迭代器以查找每个匹配的键值对 并用它做点什么。

    map.find 将只返回一个唯一匹配项。如果您正在“迭代”，则它必须超出map.find。你不能用std::map做你想做的事，至少据我所知。

    因为你想匹配不同的排序，我看不到任何方法，只能使用另一个索引容器，或者 boost::multi_index，或者，只是对“其他”排序进行线性搜索。

    【讨论】：

    • "map.find 将只返回一个唯一匹配项。如果您正在“迭代”，它必须超出 map.find" - 它只返回一个唯一匹配项。如果我将 std::find 放在一个 while 循环中，那么我可以找到所有匹配的键值对，直到不再匹配为止。
    猜你喜欢
    • 2012-03-10
    • 2013-10-07
    • 1970-01-01
    • 2022-08-05
    • 1970-01-01
    • 2011-09-23
    • 1970-01-01
    • 1970-01-01
    • 2018-09-05
    相关资源
    最近更新 更多
    热门标签
    Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode