我有一对矢量（V1，V2）的矢量，称为以下形式的pairV1V2：
(1,2,3),(938,462,4837) -> (V1,V2)
(3,9,13),(938,0472,944)
(81,84,93),(938,84,845)
然后我需要保留以下内容：
(1,2,3),(938,462,4837) -> (V1,V2)
(3,9,13),(938,0472,944)
(81,84,93),(84,845)
我需要从头开始扫描pairV1V2，并且在任何两个V1不相等的地方，我需要删除V2中的交叉元素。我写了以下代码来做同样的事情。然而，我的代码结果非常低效，因为我的矢量对V1V2很大，它在V2中有很多元素（大约10亿）。
int main(int argc, char** argv) {
std::vector<std::pair<std::vector<unsigned>, std::vector<unsigned> > > pairV1V2;
std::vector<std::pair <std::vector<unsigned>,std::vector<unsigned> > >::iterator itm2,lm2=pairV1V2.end();
for(std::vector<std::pair <std::vector<unsigned>,std::vector<unsigned> > >::iterator itm=pairV1V2.begin(), lm=pairV1V2.end(); itm!=lm; ++itm)
{
//Outer values
vector<unsigned> outerV1=(*itm).first;
vector<unsigned> outerV2=(*itm).second;
sort(outerV2.begin(), outerV2.end());
itm2=itm;
itm2++;
for(itm2;itm2!=lm2;++itm2)
{
vector<unsigned> innerV1=(*itm2).first;
vector<unsigned> innerV2=(*itm2).second;
vector<unsigned> setDiffV1;
std::set_difference(innerV1.begin(), innerV1.end(), outerV1.begin(), outerV1.end(),
std::inserter(setDiffV1, setDiffV1.end()));
if(setDiffV1.size()==0) //check whether any two V1's are different
{
sort(innerV2.begin(), innerV2.end());
if((itm->second.size()!=0)&&(itm2->second.size()!=0)){
std::vector<unsigned> delIntersectingElem;
std::set_intersection(outerV2.begin(),outerV2.end(),innerV2.begin(), innerV2.end(),
std::back_inserter(delIntersectingElem));
if(delIntersectingElem.size()!=0) //if there are intersecting V2's
{
for(std::vector<unsigned>::iterator its=(itm2->second).begin(),ls=(itm2->second).end();its!=ls;)
{
//if *its is present in delIntersectingElem then delete it.
if(!(std::find(delIntersectingElem.begin(), delIntersectingElem.end(), (*its)) == delIntersectingElem.end()))
{
(itm2->second).erase(its); //delete intersecting elements from inner v2
ls--;
}else{
++its;
}
}
}
}
}
}
}
return 0;
}
有人可以帮助我改进现有的代码吗 - 它给出了正确的答案（在示例中，我可能为了简洁而错过了一些案例 - 但代码处理了所有这些代码）但是非常慢（因为对角化）通过perf）。如果我目前的代码中有改进建议，我将不胜感激。但是，如果两个代码的逻辑相同，那么新算法也是可以接受的
答案 0 :(得分：4)
从向量中删除元素的最有效方法是反向交换技巧，但这仅适用于您不关心订单的情况。
#include <vector>
#include <iostream>
int main()
{
std::vector<int> v { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
auto it = v.begin() + 5;
// replace the current element with the back of the vector,
// then shrink the size of the vector by 1.
*it = std::move(v.back());
v.pop_back();
for (auto n : v) {
std::cout << n << " ";
}
std::cout << "\n";
}
如果你知道会有很多删除或非常大的向量，你可以通过使用这个技巧来保持效率，记住在删除后不要使用++当前的迭代器，并std::sort()向量当你到达终点时。
---编辑---
#include <algorithm>
#include <iostream>
#include <vector>
//! Efficiently remove an element from a vector without
//! preserving order. If the element is not the last element
//! in the vector, transfer the last element into its position
//! using a move if possible.
//! Regardless, we then shrink the size of the vector deleting
//! the element at the end, which will either be destructed or
//! the element we were deleting.
//! @note: Effectively invalidates the current iterator.
template<class ValueType>
bool unstable_remove(
typename std::vector<ValueType>& container,
typename std::vector<ValueType>::iterator it
)
{
// Leave in-situ if we are already the tail element.
auto lastEl = container.end() - 1;
if (it != lastEl) {
// overwrite this element with what is in the last,
// which should have the same effect as deleting this.
*it = std::move(*lastEl);
}
// release the last cell of the vector, because it should
// now either be destructed or contain the value we were
// deleting.
container.pop_back();
}
int main()
{
std::vector<int> ints { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
auto it = ints.begin();
while (it != ints.end()) {
if ((*it % 3) == 0) {
unstable_remove(ints, it);
// do not pass go / ++it
continue;
}
++it;
}
std::cout << "after removes:\n";
for (auto val : ints)
std::cout << val << " ";
std::cout << "\n";
std::sort(ints.begin(), ints.end());
std::cout << "after sort:\n";
for (auto val : ints)
std::cout << val << " ";
std::cout << "\n";
}
after removes:
1 2 10 4 5 8
after sort:
1 2 4 5 8 10
---编辑2 ---
为了便于阅读，我们清理了您的代码，我也放弃了您的结束捕获，因为......您正在删除元素。
#include <vector>
#include <cstdint>
using vec_t = std::vector<uint32_t>;
using vecpair_t = std::pair<vec_t, vec_t>;
using pairvec_t = std::vector<vecpair_t>;
int main(int argc, char** argv) {
pairvec_t pairV1V2;
for(auto itm = pairV1V2.begin(); itm != pairV1V2.end(); ++itm)
{
//Outer values
auto& outerV1 = itm->first; // NOTE '&' - reference not copy!
auto& outerV2 = itm->second;
sort(outerV2.begin(), outerV2.end());
for(auto itm2 = itm + 1; itm2 != pairV1V2.end(); ++itm2)
{
auto& innerV1 = itm2->first;
auto& innerV2 = itm2->second;
vec_t setDiffV1;
至于优化此方法的另一种方法 - 因为您的列表已排序 - 同时在两个列表中比较值。
template<typename ValueType>
void dedupe_vectors(
typename std::vector<ValueType>& lhs,
typename std::vector<ValueType>& rhs
)
{
auto lit = lhs.begin();
auto rit = rhs.begin();
while (rit != rhs.end) {
while (lit != lhs.end() && *lit < *rit)
++lit;
if (lit == lhs.end())
break;
if (*lit == *rit) {
v2.erase(rit);
continue;
}
++rit;
}
}
我知道 - 我们两次测试lit vs lhs.end。看一下编译器使用-O3生成的代码，看看它是否自己检测不到。如果是这样，那么您可以担心优化它。
答案 1 :(得分：4)
有一个名为remove_if的未充分利用的STL算法，它允许您有效地（O（n））从容器中删除与谓词匹配的所有元素。如果你有一个vector或deque，它是最有用的，因为它们对元素＆＃34;在中间＆＃34;有一个昂贵的（O（n））擦除操作。但是，您需要注意remove_if实际上没有删除任何元素，它只会将 not 匹配谓词的所有元素移动到您指定范围的前面。做＆＃34; erase_if＆＃34;的规范方式因此（在这个例子中，所有奇数整数都将被删除）：
std::vector ints = …;
ints.erase(std::remove_if(begin(ints), end(ints), [](int i) { return i%2 != 0; }), end(ints));
说明：remove_if将与谓词匹配的所有整数 not （即本例中的偶数整数）移到前面，并返回一个超过最后一个元素的迭代器。然后，我们实际上使用vector<int>::erase的范围重载将从这一个开始的所有元素擦除到向量的末尾。
例如，假设我们有ints == {5,7,4,10,9,16,20,6}。 remove_if会将ints变为{4,10,16,20,6,UNSPEC,UNSPEC,UNSPEC}，我使用UNSPEC来表示任何未指定的值，并且它还会返回指向第一个UNSPEC元素的迭代器。然后，我们删除具有未指定值的所有元素，并获得所需结果{4,10,16,20,6}。
更新：关于上一个答案，我想指出remove_if是稳定的，即它不会改变其余元素的顺序。