排列与组合生成类

// Copyright (c) 

// All rights reserved.

//

//Describe : Premutation And Combination generater

//Author   : Qing

//Date     : 2015-01-19



#ifndef __PREMUTATION_COMBINATION_H__

#define __PREMUTATION_COMBINATION_H__



#include <bitset>

#include <vector>

#include <algorithm>



namespace Qing

{

    template<typename T, unsigned int ElementCount>

    class PermutationCombination

    {

    public:



        PermutationCombination(void) {}

        ~PermutationCombination(void){}



        bool GetCombination(const std::vector<T> &SourceVector, int CombinationElementCount, std::vector<std::vector<T> > &ResultVector);

        bool GetPermutation(const std::vector<T> &SourceVector, int PermutationElementCount, std::vector<std::vector<T> > &ResultVector);



    private:



        bool AdjustPosition(std::bitset<ElementCount> &FlagArray, unsigned int SourceVectorElementCount);

    };



    template<typename T, unsigned int ElementCount>

    bool PermutationCombination<T,ElementCount>::GetCombination(const std::vector<T> &SourceVector, int CombinationElementCount, std::vector<std::vector<T> >& ResultVector)

    {

        if(SourceVector.size() <= 0 || CombinationElementCount <= 0 || CombinationElementCount > static_cast<int>(SourceVector.size()))

        {

            return false;

        }



        std::bitset<ElementCount> FlagArray;

        for(int Index = 0; Index < CombinationElementCount; Index++)

        {

            FlagArray.set(Index);

        }



        do

        {

            ResultVector.push_back(std::vector<T>(CombinationElementCount, T()));

            std::vector<T> &TempArray = ResultVector[ResultVector.size()-1];



            std::vector<T>::size_type TempIndex = 0;

            for(std::size_t BitSetIndex = 0; BitSetIndex < FlagArray.size(); BitSetIndex++)

            {

                if(FlagArray[BitSetIndex])

                {

                    TempArray[TempIndex] = SourceVector[BitSetIndex];

                    if(++TempIndex == CombinationElementCount)

                    {

                        break;

                    }

                }

            }

        }

        while(AdjustPosition(FlagArray, SourceVector.size()));



        return true;

    }



    template<typename T, unsigned int ElementCount>

    bool PermutationCombination<T,ElementCount>::GetPermutation(const std::vector<T> &SourceVector, int PermutationElementCount, std::vector<std::vector<T> >& ResultVector)

    {

        if(SourceVector.size() <= 0 || PermutationElementCount <= 0 || PermutationElementCount > static_cast<int>(SourceVector.size()))

        {

            return false;

        }



        std::bitset<ElementCount> FlagArray;

        for(int Index = 0; Index < PermutationElementCount; Index++)

        {

            FlagArray.set(Index);

        }



        std::vector<T> TempArray(PermutationElementCount,T());



        do

        {

            std::vector<T>::size_type TempIndex = 0;

            for(std::size_t BitSetIndex = 0; BitSetIndex < FlagArray.size(); BitSetIndex++)

            {

                if(FlagArray[BitSetIndex])

                {

                    TempArray[TempIndex] = SourceVector[BitSetIndex];

                    if(++TempIndex == PermutationElementCount)

                    {

                        do

                        {

                            ResultVector.push_back(TempArray);

                        }

                        while (next_permutation(TempArray.begin(), TempArray.end()));



                        break;

                    }

                }

            }

        }

        while(AdjustPosition(FlagArray, SourceVector.size()));



        return true;

    }



    //*********************** 0-1 exchange algorithm ************************

    //  example : C(5,3)

    //      1   1   1   0   0

    //      1   1   0   1   0

    //      1   0   1   1   0

    //      0   1   1   1   0

    //      1   1   0   0   1

    //      1   0   1   0   1

    //      0   1   1   0   1

    //      1   0   0   1   1

    //      0   1   0   1   1

    //      0   0   1   1   1

    //*********************** 0-1 exchange algorithm ************************

    template<typename T, unsigned int ElementCount>

    bool PermutationCombination<T,ElementCount>::AdjustPosition(std::bitset<ElementCount> &FlagArray, unsigned int SourceVectorElementCount)

    {

        SourceVectorElementCount -= 1;

        for(unsigned int i = 0; i < SourceVectorElementCount; i++)

        {

            if(FlagArray[i] && !FlagArray[i+1])

            {

                FlagArray.reset(i);

                FlagArray.set(i + 1);



                if(!FlagArray[0] && i != 0)

                {

                    int TrueCount = 0;

                    for(unsigned int j = 0; j < i; j++)

                    {

                        if(FlagArray[j])

                        {

                            ++TrueCount;

                        }



                        FlagArray.reset(j);

                    }



                    for(int k = 0; k < TrueCount; k++)

                    {

                        FlagArray.set(k);

                    }

                }



                return true;

            }

        }



        return false;

    }

}



#endif