试题:集合的划分问题

输入集合{ 1, 2, 3 }

输出结果:

{ {1}, {2}, {3} }

{ {1}, {2, 3} }

{ {1, 3}, {2} }

{ {1, 2, 3} }

试编写相应算法:

#include <cassert>
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;

template <typename T>
void set(const vector<T> & element, const vector<int> & total_index,
         vector<vector<int> *> & v_index)
{
    for (int i = 1; i <= total_index.size(); ++i) {
        vector<int> index;
        index.reserve(i);

        for (int j = 0; j < i; ++j) {
            index.push_back(j);
        }

        while (true) {
            while (0 == index[0] && index[i - 1] <= total_index.size() - 1) {
                vector<int> * pused_index = new vector<int>;
                pused_index->reserve(index.size());

				vector<int> unuse_index(total_index.begin(), total_index.end());
                for (int j = 0; j < i; ++j) {
                    int e_index = total_index[index[j]];
                    pused_index->push_back(e_index);
                    unuse_index.erase(
                        remove(unuse_index.begin(), unuse_index.end(), e_index)
                    );
                }

                v_index.push_back(pused_index);

                if (0 == unuse_index.size()) {
                    cout << '\t' << "{ ";
                    vector<vector<int> *>::iterator v_iter = v_index.begin();
                    while (true) {
                        vector<int> * p_index = *v_iter;
                        cout << "{ ";
                        vector<int>::iterator i_iter = p_index->begin();
                        cout << element[*i_iter];
                        ++i_iter;
                        while (p_index->end() != i_iter) {
                            cout << ", " << element[*i_iter];
							++i_iter;
                        }
                        cout << " }";
                        ++v_iter;
                        if (v_index.end() != v_iter) {
                            cout << ", ";
                        }
                        else {
                            break;
                        }
                    }
                    cout << " }" << endl;
                }
                else {
                    set(element, unuse_index, v_index);
                }

                vector<int> * p_index = v_index.back();
                assert(p_index == pused_index);
                v_index.pop_back();
                delete pused_index;

                ++index[i - 1];
            }

            int index_bound = total_index.size();
            int carry_index = i - 2;
            while (carry_index >= 0) {
                ++index[carry_index];
                --index_bound;
                if (index[carry_index] < index_bound) {
                    break;
                }
                else {
                    assert(index[carry_index] == index_bound);
                    --carry_index;
                }
            }
            if (carry_index >= 0) {
                for (int j = carry_index + 1; j < i; ++j) {
                    index[j] = index[j - 1] + 1;
                }
            }
			else {
				break;
			}
        }
    }
}

template <typename U, typename V>
void set(U begin, U end, V * pfirst)
{
    vector<V> element(begin, end);
    vector<int> total_index;
    total_index.reserve(element.size());
    for (int i = 0; i < element.size(); ++i) {
        total_index.push_back(i);
    }
    vector<vector<int> *> v_index;
    set(element, total_index, v_index);
}

template <typename T>
void set(T begin, T end)
{
    set(begin, end, &*begin);
}

int main()
{
    int data[] = { 1, 2, 3, 4, 5, 6 };
    set(data, *(&data + 1));

    return 0;
}