如何以特定方式在 c++ STL 中查找？

Question

map< pair<int,int> , int > m ;

这里pair.first 和pair.second 是正数，pair.second >= pair.first。

我想在映射m 中找到所有迭代器，这样对于给定的键。键是一个整数，位于对之间，例如键是 2，对是 [2,5] 和 [1,2] 等。
例如m[1,3] = 10 , m[3,5] = 6 , m[1,8] = 9 , m[7,8] = 15 然后当我搜索 m.find(3) 时，它会返回 m[1,3] 、 m[1,8] 、 m[3,5] 的迭代器。如果没有密钥，它将返回 m.end()。

Answer 1

我不确定为什么你想这样做，但是现在 Boost Interval Container 库非常有能力。

假设您可能想要跟踪特定点的映射值的 total（总和），您可以简单地将拆分 Combining Style 应用于您的输入数据和利润：

Live On Coliru

#include <boost/icl/split_interval_map.hpp>
#include <boost/range/iterator_range.hpp>
#include <iostream>

namespace icl = boost::icl;

int main() {
    using Map  = icl::split_interval_map<int, int>;
    using Ival = Map::interval_type;
    Map m;
    m.add({Ival::closed(1,3), 10});
    m.add({Ival::closed(3,5), 6});
    m.add({Ival::closed(1,8), 9});
    m.add({Ival::closed(7,8), 15});

    for (auto e : m) std::cout << e.first << " -> " << e.second << "\n";

    std::cout << "------------------------------\n";

    for (auto e : boost::make_iterator_range(m.equal_range(Ival::closed(3,3))))
        std::cout << e.first << " -> " << e.second << "\n";
}

这会告诉我们：

[1,3) -> 19
[3,3] -> 25
(3,5] -> 15
(5,7) -> 9
[7,8] -> 24
------------------------------
[3,3] -> 25

注意如何

• 合并非常准确地反映了点 [3,3] 是唯一同时与输入数据中的[1,3] 和[3,5] 重合的点，因此，我们得到组合集中的半开区间（[1,3)、[3,3] 和 (3,5]）。
• 还要注意对这一点的查询如何正确返回您感兴趣的所有三个区间的10+6+9 的总和。

这有什么用？

所以，你看我把问题的焦点从“如何？”转移了。到“什么？”。它通常有助于说明代码的目标而不是特定的机制。

当然，如果您对平均值、最小值或最大值感兴趣，而不是总和，您可能会发现自己正在编写一些自定义组合策略。

奖励如果您愿意，您至少可以使用 Boost Icl 编写 OP 中提出的问题的解决方案：Live On Coliru。虽然它不是特别有效，但它直截了当且健壮。

Answer 2

如果您只需要在映射中找到的下一个值的迭代器，您可以使用 std::find_if 算法，如下所示：

int key=2;
map<pair<int,int>, int>::iterator it =std::find_if(m.begin(),m.end(),
                         [key](pair<pair<int,int>,int> entry)
                         {
                           return (entry.first.first <= key) 
                                  && (entry.first.second >= key);
                         }
                         );

cout << "the next value is: [" << it->first.first << "/";
cout << it->first.second << "] " << it->second << endl;

Answer 3

没有办法避免从地图开始进行线性搜索，因为如果第一个元素是 {0,INT_MAX} 则它匹配并且您想要的元素不一定在连续范围内，例如如果您有 {1,3},{2,2}{3,5} 当键为 3 时，您只需要第一个和最后一个元素。

当您到达first 大于键的元素时，您可以停止搜索。

类似这样的东西（未经测试）：

typedef map< pair<int,int> , int > Map;

std::vector<Map::iterator>
find(int key, const Map& m)
{
  std::vector<Map::iterator> matches;
  for (Map::iterator it = m.begin(), end = m.end(); it != end && key <= it->first; ++it)
  {
    if (it.first >= key && key <= it.second)
      matches.push_back(it);
  }
  return matches;
}

你可以把它变成一个仿函数并使用find_if，但我不确定它是否值得。

如果您只想每次调用返回一个迭代器：

typedef map< pair<int,int> , int > Map;

Map::iterator
find(int key, const Map& m, Map::iterator it)
{
  for (Map::iterator end = m.end(); it != end && key <= it->first; ++it)
  {
    if (it.first >= key && key <= it.second)
      return it;
  }
  return m.end();
}

Map::iterator
find(int key, const Map& m)
{ return find(key, m, m.begin()); }

Answer 4

我认为您可以存储（和使用）地图的相应键，而不是迭代器。如果是这样，那么代码可能看起来像

#include <iostream>
#include <map>
#include <algorithm>
#include <vector>
#include <utility>

int main() 
{
    std::map<std::pair<int, int>, int> m;
    m[{ 1, 3}] = 10; 
    m[{ 3, 5}] = 6;
    m[{ 7, 8}] = 15;

    typedef std::map<std::pair<int, int>, int>::value_type value_type;
    typedef std::map<std::pair<int, int>, int>::key_type key_type;

    int search;

    auto in_range = [&search]( const value_type &value )
    {
        return value.first.first <= search && search <= value.first.second; 
    };

    search = 3;

    std::vector<key_type> v;
    v.reserve( std::count_if( m.begin(), m.end(), in_range ) );

    for ( const auto &p : m )
    {
        if ( in_range( p ) ) v.push_back( p.first );
    }

    for ( const auto &p : v ) 
    {
        std::cout << "[ " << p.first << ", " << p.second << " ]" << std::endl;
    }

    return 0;
}

输出是

[ 1, 3 ]
[ 3, 5 ]

考虑到假设 key.first 小于或等于 key.second ，其中 key 是映射的键。