對 c++ 向量的交集

Question

我有以下向量：

 vector<unsigned> A,B1;
 vector<pair<unsigned,unsigned> > B2;

我想執行(A,B1)的交集，然后是(A,B2)的交集。 然后我想執行兩個交集結果的並集。 向量A和B1包含排序的無符號整數，向量B2包含(start,end)值對。 示例向量A和B2 ，以及它們的交集向量如下所示：

   vector<unsigned> A(2,4,6,8,9,10,34,74,79,81,89,91,95);
   vector<pair<unsigned,unsigned> > B2={ {2, 3}, {29, 40}, {60, 85} };
   vector<unsigned> intersection; //result of intersection of A and B2 -> Procedure of performing intersection is explained below
   //intersection=(2,34,74,79,81);

2在交集，因為2在{2,3} 。 類似地， 34處於交集，因為34位於{29,40}之間。 類似地， 74 、 79 、 81處於交集，因為它們位於B2的最后一個元素{60,85}的范圍內。

是否有一些有效的方法可以讓我獲得與以下相同的結果：

(1). 交叉點A和B1 ； (2). A和B2交點； (3). 步驟 1 和 2 中執行的兩個交集的並集（即交集(A,B1)和(A,B2) ）

Answer 1

更新：

重新閱讀問題后，我意識到您可能希望將所有三個操作合二為一。

我們可以通過將三個函數合二為一並返回一個元組來將外循環的迭代次數減少到一次並刪除一個內循環：

#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
#include <tuple>


std::tuple<std::vector<unsigned>, std::vector<unsigned>, std::vector<unsigned>>
find_everything(const std::vector<unsigned>& a,
                const std::vector<std::pair<unsigned,unsigned> >& b1,
                const std::vector<std::pair<unsigned,unsigned> >& b2)
{
    std::vector<unsigned> r1, r2, both;

    for (auto x : a)
    {
        auto either = false;
        auto i = std::find_if(std::begin(b1),
                              std::end(b1),
                              [x](const auto& range)
                              { return x >= range.first && x < range.second; });
        if (i != std::end(b1)) {
            either = true;
            r1.push_back(x);
        }

        i = std::find_if(std::begin(b2),
                              std::end(b2),
                              [x](const auto& range)
                              { return x >= range.first && x < range.second; });
        if (i != std::end(b2)) {
            either = true;
            r2.push_back(x);
        }

        if (either) {
            both.push_back(x);
        }
    }
    return std::make_tuple(std::move(r1), std::move(r2), std::move(both));
}



int main()
{

    using namespace std;

    vector<unsigned> A { 2,4,6,8,9,10,34,74,79,81,89,91,95 };
    vector<pair<unsigned,unsigned> > B1={ {4, 5}, {8, 10}, {90, 99} };
    vector<pair<unsigned,unsigned> > B2={ {2, 3}, {29, 40}, {60, 85} };

    auto results = find_everything(A, B1, B2);
    const auto& r1 = std::get<0>(results);
    const auto& r2 = std::get<1>(results);
    const auto& both = std::get<2>(results);
    copy(begin(r1), end(r1), ostream_iterator<unsigned>(cout, ", "));
    cout << endl;

    copy(begin(r2), end(r2), ostream_iterator<unsigned>(cout, ", "));
    cout << endl;

    copy(begin(both), end(both), ostream_iterator<unsigned>(cout, ", "));
    cout << endl;

    return 0;
}

預期成績：

4, 8, 9, 91, 95,
2, 34, 74, 79, 81,
2, 4, 8, 9, 34, 74, 79, 81, 91, 95,

進一步的工作：

如果數據集很大，我們可以立即做出兩個明顯的改進：

1. 由於 A、B1 和 B2 已排序，我們可以跟蹤“當前”匹配迭代器，減少每個匹配或不匹配的搜索空間（這開始爭論std::lower_bound ）

2. 或者如果 A 明顯大於 B1 和 B2，我們可以並行搜索。

玩得開心 ：）