Update element stl list of lists - c++

Question

I am working with a list of a list of vector of ints (std::list<std::list<std::vector<int>>> z(nlevel)).
I might have something like:
{ {1} {2} {3} }
{ {1 2} {2 1} {1 3} }
{ {1 2 3} {2 1 3} {1 2 4} }
I need to remove the non-unique combination of integers, so e.g., the second element of the list above should become
{ { 1 2 } {1 3} }
This is a large object, so I'm trying to update each element of the outermost list by reference. I've tried something like:
lit = z.begin();
for (i = 0; i < nlevel; i++) {
distinct_z(*lit, primes);
lit++;
}
where distinct_z is a function to find the unique vector combinations by reference, but this doesn't seem to affect the list z. Note: distinct_z does work fine in another part of my code where I am already working with the ith element of the list. I've provided distinct_z below. It includes some unique data types from the Rcpp package in R, but is hopefully understandable. Essentially, I use the log sum of prime numbers to identify non-unique combinations of integers because the order of the integers does not matter. To reiterate, distinct_z does work in another part of my code where I pass it an actual list of vectors of ints. The problem seems to be that I'm trying to pass something using an iterator.
void distinct_lz(std::list<std::vector<int>> &lz,
const IntegerVector &primes) {
int i, j, npids = lz.size();
NumericVector pids(npids);
std::list<std::vector<int>>::iterator lit = lz.begin();
int z_size = lit -> size();
for(i = 0; i < npids; i++) {
for (j = 0; j < z_size; j++) {
// cprime = primes[lit -> at(j)];
// pids[i] += log(cprime);
// cprime = primes[lit -> at(j)];
pids[i] += log(primes[lit -> at(j)]);
}
lit++;
}
LogicalVector dup = duplicated(round(pids, 8));
lit = lz.begin();
for(i = 0; i < npids; i++) {
if(dup(i) == 1) {
lz.erase(lit);
}
lit++;
}
}
What is the best approach for doing what I want?
Background: The data structure probably seems unnecessarily complicated, but I'm enumerating all connected subgraphs starting at a vertex using a breadth-first approach. So given a current subgraph, I see what other vertices are connected to create a set of new subgraphs and repeat. I initially did this using a list of vectors of ints, but removing repeats was ridiculously slow due to the fact that I had to copy the current object if I removed part of the vector. This approach is much faster even though the structure is more complicated.
Edit: Here is a solution that mostly does what I want, though it results in some undesired copying. I updated distinct_z to return a copy of the object instead of modifying the reference, and then replaced the element at lit.
lit = z.begin();
for (i = 0; i < nlevel; i++) {
(*lit) = distinct_z(*lit, primes);
lit++;
}

Answer 1

In C++ there is a well known idiom known as the erase-remove idiom for removing elements from an STL container. It basically involves shuffling unwanted items to the end of the container and then erasing the unwanted tail.
We can use a predicate function (e.g. lambda) to select the items we want to erase and use functions from <algorithm>. In your case we use a set of set of ints (std::<set<int>>) to store unique combinations. Convert each vector in the list to a set of ints and delete it if hasn't been seen before.
#include <set>
#include <list>
#include <vector>
#include <algorithm>
#include <iostream>
void distinct_lz(std::list<std::vector<int>>& lz)
{
std::set<std::set<int>> unqiueNums;
lz.erase(std::remove_if(lz.begin(), lz.end(),
[&unqiueNums](std::vector<int>& v) {
std::set<int> s{ v.cbegin(), v.cend() };
if (unqiueNums.find(s) != unqiueNums.end())
return true;
else
{
unqiueNums.insert(s);
return false;
}
}), lz.end());
}
int main()
{
std::list<std::vector<int>> lv = { {1, 2}, {2, 1}, {1, 3}, {3,4} };
distinct_lz(lv);
for (auto &v: lv)
{
for( auto n: v)
{
std::cout << n << " ";
}
std::cout << "\n";
}
}
Output:
1 2
1 3
3 4
Working version here.