By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
432,474 Members | 939 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 432,474 IT Pros & Developers. It's quick & easy.

STL and combinations question

P: n/a
Thank you for reading my plea for help.

What I'm trying to achieve is to get the subsets from a given set using the
Standard Template Library.

Say, for example, I have created an empty set and then have inserted 3
numbers into that set (1, 2, 3). Next, I would like to get all of the subset
pairs (1, 2), (1, 3) and (2, 3) for processing.

A Google search has given me a lot to think about but nothing specific for
my needs. I have played with next_permutation and read about
next_combination which sounded more promising, since combinations are what
I'm looking for, but next_combination doesn't appear to be part of STL (572:
error: 'next_combination' was not declared in this scope).

Can someone please put me on the right track? Perhaps a simple example might
help.

--
Regards,
Phil.
Dec 29 '06 #1
Share this Question
Share on Google+
5 Replies


P: n/a
"Phil" <ph*****@telstra.comwrote in message
news:Tm****************@news-server.bigpond.net.au
Thank you for reading my plea for help.

What I'm trying to achieve is to get the subsets from a given set
using the Standard Template Library.

Say, for example, I have created an empty set and then have inserted 3
numbers into that set (1, 2, 3). Next, I would like to get all of the
subset pairs (1, 2), (1, 3) and (2, 3) for processing.

A Google search has given me a lot to think about but nothing
specific for my needs. I have played with next_permutation and read
about next_combination which sounded more promising, since
combinations are what I'm looking for, but next_combination doesn't
appear to be part of STL (572: error: 'next_combination' was not
declared in this scope).
Can someone please put me on the right track? Perhaps a simple
example might help.

Algorithms for finding all subsets are not trivial and have nothing
specifically to do with the C++ language. Try

comp.programming

--
John Carson
Dec 29 '06 #2

P: n/a
On 2006-12-29 03:49, Phil wrote:
Thank you for reading my plea for help.

What I'm trying to achieve is to get the subsets from a given set using the
Standard Template Library.

Say, for example, I have created an empty set and then have inserted 3
numbers into that set (1, 2, 3). Next, I would like to get all of the subset
pairs (1, 2), (1, 3) and (2, 3) for processing.
This can probably be done using any container but I find a vector
particularly useful in this case:

#include <vector>
#include <utils>

std::vector<intset;
std::vector<std::pair<int, int pairs;

// initialize the set somehow

for (size_t i = 0; i < set.size(); ++i)
for (size_t j = i + 1; j < set.size(); ++k)
pairs.push_back(std::make_pair(i, j));

This will run in about O((n^2) / 2).

--
Erik Wikström
Dec 30 '06 #3

P: n/a
Erik Wikström wrote:
On 2006-12-29 03:49, Phil wrote:
>Thank you for reading my plea for help.

What I'm trying to achieve is to get the subsets from a given set
using the Standard Template Library.

Say, for example, I have created an empty set and then have inserted 3
numbers into that set (1, 2, 3). Next, I would like to get all of the
subset pairs (1, 2), (1, 3) and (2, 3) for processing.

This can probably be done using any container but I find a vector
particularly useful in this case:

#include <vector>
#include <utils>

std::vector<intset;
std::vector<std::pair<int, int pairs;

// initialize the set somehow

for (size_t i = 0; i < set.size(); ++i)
for (size_t j = i + 1; j < set.size(); ++k)
pairs.push_back(std::make_pair(i, j));

This will run in about O((n^2) / 2).

Would boost's "next_combination" work ?

see this:
http://www.bxmy.org/code/combination.hpp
Dec 30 '06 #4

P: n/a
On 2006-12-30 23:06, Gianni Mariani wrote:
Erik Wikström wrote:
>On 2006-12-29 03:49, Phil wrote:
>>Thank you for reading my plea for help.

What I'm trying to achieve is to get the subsets from a given set
using the Standard Template Library.

Say, for example, I have created an empty set and then have inserted 3
numbers into that set (1, 2, 3). Next, I would like to get all of the
subset pairs (1, 2), (1, 3) and (2, 3) for processing.

This can probably be done using any container but I find a vector
particularly useful in this case:

#include <vector>
#include <utils>

std::vector<intset;
std::vector<std::pair<int, int pairs;

// initialize the set somehow

for (size_t i = 0; i < set.size(); ++i)
for (size_t j = i + 1; j < set.size(); ++k)
pairs.push_back(std::make_pair(i, j));

This will run in about O((n^2) / 2).


Would boost's "next_combination" work ?

see this:
http://www.bxmy.org/code/combination.hpp
The link does not lead to code that is part of boost, and from the code
I saw it looked unnecessarily complicated, but it might work. Best way
to find out is to test it. You might also be interested in the
following: http://www.codeproject.com/cpp/CombC.asp

--
Erik Wikström
Dec 31 '06 #5

P: n/a
In article <Tm****************@news-server.bigpond.net.au>,
"Phil" <ph*****@telstra.comwrote:
Thank you for reading my plea for help.

What I'm trying to achieve is to get the subsets from a given set using the
Standard Template Library.

Say, for example, I have created an empty set and then have inserted 3
numbers into that set (1, 2, 3). Next, I would like to get all of the subset
pairs (1, 2), (1, 3) and (2, 3) for processing.

A Google search has given me a lot to think about but nothing specific for
my needs. I have played with next_permutation and read about
next_combination which sounded more promising, since combinations are what
I'm looking for, but next_combination doesn't appear to be part of STL (572:
error: 'next_combination' was not declared in this scope).

Can someone please put me on the right track? Perhaps a simple example might
help.
This question comes up often enough that I believe C++ should have a
standard solution. I do not find a need for this functionality often.
But I do need it sometimes. And when I need it, I really need it badly.
And it is very non-trivial to get right.

I most recently used the below-linked code to semi-automate the
generation of test cases for the rvalue reference work. I needed to
test all combinations of function calls involving lvalue and rvalue
arguments to overload sets containing const and/or volatile lvalue and
rvalue references (here's a link to those tests for the curious
http://home.twcny.rr.com/hinnant/cpp...lue_ref_test/).

Anyway, I've decided to make the fundamental combination (and
permutation) algorithms public. They can be found here, including a
couple of demoes:

http://home.twcny.rr.com/hinnant/cpp...binations.html

The second demo (involving clusters of cities) is perhaps the most
interesting. It demonstrates the ability to perform a combination
calculation that itself involves computing over combinations.
Admittedly the demo could be coded more efficiently. But hasn't been
for the purpose of demonstrating this nested combination computation
capability.

This set of algorithms is not necessarily a complete set. But I do not
have the time to extend it for now. I currently have:

template<class BidirectionalIterator, class Function, class Size>
Function
for_each_permutation(BidirectionalIterator first,
BidirectionalIterator last,
Size k, Function f);
template<class BidirectionalIterator, class Function, class Size>
Function
for_each_circular_permutation(BidirectionalIterato r first,
BidirectionalIterator last,
Size k, Function f);

template<class BidirectionalIterator, class Function, class Size>
Function
for_each_combination(BidirectionalIterator first,
BidirectionalIterator last,
Size k, Function f);

I wouldn't mind having "reversible permutation" versions. I.e. when you
consider a permutation and its reverse to be the same set, there's no
need to compute characteristics of both (e.g. if you're computing the
sum of distances between a sequence of locations, the distance is the
same whether the locations are traversed forwards or backwards). This
could cut the expense of the above permutation functions in half, but I
have not succeeded in coding those algorithms at this point.

Hth.

-Howard
Jan 2 '07 #6

This discussion thread is closed

Replies have been disabled for this discussion.