C++ 在向量向量中查找向量的最快方法

我的代码是：

struct TileIdx { int mRow; int mCol; };

typedef std::vector<TileIdx> TileChain;

bool IsChainInChains(const TileChain& chain, const std::vector<TileChain>& chainArray);

struct TileIdx{int mRow；int mCol；}；
typedef std：：向量TileChain；
bool-ischainin链（const-TileChain和chain，const-std:：vector和chainArray）；

分析器显示，

IsChainInChains

是我代码的瓶颈。
我需要最快的方法来实现此功能。
我们可以假设，

chainArray

已经排序（哪种方式？由您决定）。
我们还可以假设mRow和mCol不超过100（即

mRow*100+mCol

是有效的

int

，用于排序）。

---

我并不是故意将当前的实现包括在内，以便社区不仅分析我的代码，而且提出新的解决方案

如果没有太多有用的信息，我建议使用二进制搜索。为此，请使用标准库函数

其中

comp

是用于排序

chainArray

的谓词，是严格的弱排序

---

请注意，

std:：vector

有一个

操作符您真的需要向量向量吗？如果对数据的其他操作速度较慢，那么最好使用一组向量。看看这个小例子：

#include <set>
#include <vector>

struct TileIdx { int mRow; int mCol; };

typedef std::vector<TileIdx> TileChain;

bool operator < (const TileChain& t1, const TileChain& t2)
{
  if(t1.size() < t2.size())
    return true;
  if(t1.size() > t2.size())
    return false;
  for(unsigned long int i = 0; i < t1.size(); ++i)
  {
    if(t1[i].mRow < t2[i].mRow)
      return true;
    if(t1[i].mRow > t2[i].mRow)
      return false;
  }
  return false;
}

bool IsChainInChains(const TileChain& chain, const std::set<TileChain>& chains)
{
  return chains.count(chain) > 0;
}

#包括
#包括
结构TileIdx{int mRow；int mCol；}；
typedef std：：向量TileChain；
布尔运算符<（常数TileChain和t1，常数TileChain和t2）
{
如果（t1.size（）t2.size（））
返回false；
for（无符号长整数i=0；it2[i].mRow）
返回false；
}
返回false；
}
bool IsChainInChains（常量TileChain&chain，常量标准：：集合与链）
{
返回链。计数（链）>0；
}

然后，您必须根据您的目标选择您的容器。供您参考，这些行动所需的时间为：


在链中插入一个新链，对于
set
，取O（log（n）），对于
vector
在链中查找链需要O（log（n））表示
set
，O（n）表示
vector
已在
集合中对链中的链进行排序
，对于
向量

然后，如您所见，如果您不经常修改链，但经常检查链，
std:：set
是一个很好的解决方案。
请指定问题中缺少哪些有用的信息。@deko我们不知道您是否在使用二进制搜索。我们不知道您是否已经在使用
std:：loser\u-bound
。无法知道您的实现为何“缓慢”。也许没有办法加快速度，我明白你的意思。我不使用
std:：lower_bound
。我试试你的办法！塔克斯！因无正当理由未能提供当前解决方案而减1。“这让你的问题更糟。”雅克我解释了我的理由。我不希望我的代码被分析，而是希望搜索不同的方法。这样，这个问题就更为普遍，因此对未来的社区更为有用。
bool operator<(TileIdx rhs, TileIdx lhs) { .... }

std::sort(begin(chainArray), end(chainArray));

....

auto it = std::lower_bound(begin(chainArray), end(chainArray), chain);

#include <set>
#include <vector>

struct TileIdx { int mRow; int mCol; };

typedef std::vector<TileIdx> TileChain;

bool operator < (const TileChain& t1, const TileChain& t2)
{
  if(t1.size() < t2.size())
    return true;
  if(t1.size() > t2.size())
    return false;
  for(unsigned long int i = 0; i < t1.size(); ++i)
  {
    if(t1[i].mRow < t2[i].mRow)
      return true;
    if(t1[i].mRow > t2[i].mRow)
      return false;
  }
  return false;
}

bool IsChainInChains(const TileChain& chain, const std::set<TileChain>& chains)
{
  return chains.count(chain) > 0;
}