Efficient way of finding the number of equivalence classes in C++ - c++

Question

Suppose we're given an array of integers. A[n], for instance
A[11]={10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}
and a list of prime numbers, B[k], for instance
B[2]={3, 5}
For each element, b_i in B[k], we find the elements in A[n] that are divisible by it and combine them into an equivalence class, and if an element in A[n] is not divisible by any element in B[k], then it's an equivalence class consisting of a single element. For instance, in the above example, the equivalence classes would be
{12, 15, 18}
{10, 15, 20}
{11}
{13}
{14}
{16}
{17}
{19}
(15 was repeated as it's divisible by both 3 and 5), where first equivalence class consists of numbers in A[n] divisible by 3, and second are the ones divisible by 5, and the rest are elements that are co-prime to 3 and 5. Basically, given A[n] and B[k], I want to calculate how many equivalence sets can be created, and in the above example, it would be 8.
and what I came up with is the following:
for(j=0; j<n; j++){
check[j]=true;
}
for(i=0; i<k; i++){
helper=0;
for(j=0; j<n; j++){
if(check[j]==true){
if(A[j]%B[i]==0){
check[j]==false;
helper++;
}
}
}
if(helper>0){
count++;
}
}
for(j=0; j<n; j++){
if(check[j]==true){
count++;
}
}
check is the array of boolean that returns false if it already belongs to some equivalence class and true if it does not belong to an equivalence class yet.
this calculates the number of equivalence sets divisible by elements in B[k], but now, I'm not sure what to do with singleton sets as check array members are all re-set to true after the loop.
(I tried
for(j=0; j<n; j++){
if(check[j]==true){
count++;
}
}
after the above loop, but it only adds n to the count)
Can someone help me on this? Is there a more efficient way of doing it? Also, what should I do with the singleton sets?
Thanks.
PS. Since 15 is repeated in 2 sets, it's not technically an equivalence class. Sorry about it.

Answer 1

Same code sample rewritten using standard containers:
#include <iostream>
#include <map>
#include <set>
using namespace std;
int A[]= { 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 };
int B[]= { 3, 5 };
typedef set<int> row;
int
main()
{
map<int, row> results;
// Fill
for (auto i = begin(A); i != end(A); ++i)
for (auto j = begin(B); j != end(B); j++)
{
if (*i % *j)
results[*i] = row();
else
{
if (results.find(*j) == results.end())
results[*j] = row();
results[*j].insert(*i);
}
}
// Cleanup
for (auto j = begin(B); j != end(B); j++)
for (auto i : results[*j])
results.erase(i);
// Dump
for (auto i : results)
{
cout << "{ ";
if (i.second.size())
for (auto j = i.second.begin(), nocomma = --i.second.end(); j != i.second.end(); ++j)
cout << *j << (j == nocomma ? " " : ", ");
else
cout << i.first << " ";
cout << "}" << endl;
}
return 0;
}
The output:
{ 12, 15, 18 }
{ 10, 15, 20 }
{ 11 }
{ 13 }
{ 14 }
{ 16 }
{ 17 }
{ 19 }