The Algorithm on Combinations

In combinatorial mathematics, a combination is an un-ordered collection of distinct elements, usually of a prescribed size and taken from a given set. (An ordered collection of distinct elements would sometimes be called a permutation, but that term is ambiguous; it can also mean "reordering of all terms", among other related notions.) Given such a set S, a combination of elements of S is just a subset of S, where, as always for (sub)sets the order of the elements is not taken into account (two lists with the same elements in different orders are considered to be the same combination). Also, as always for (sub)sets, no elements can be repeated more than once in a combination; this is often referred to as a "collection without repetition". For instance, {1,1,2} is not a combination of three digits; as a set this is the same as {1,2,1} or {2,1,1} or even {1,2}. (From WiKi) 

 

---

Some "recursive algorithm" ways to calculate the combination.

 

[1] The process of this algorithm could be illustrated as Fig.1 as below.

#include <iostream> using namespace std; void Combin(int n,int m,int a); int count=0; int main() { int n,m; n=4; m=2; Combin(n,m,0); printf("C(%d,%d)=%d/n",n,m,count); return 0; } void Combin(int n,int m,int a) { if(n == m) { if(a>0) { printf("%d",a); } while(m > 0) { printf("%d",m--); } ++count; printf("/n"); return; } else if(0 == m) { printf("%d ",a); ++count; return; } Combin(n-1,m-1,a*10+n); Combin(n-1,m,a); }

 

[2] Another way makes use of the equation "C(n,m)=C(n-1,m-1)+C(n-1,m)" .

#include <iostream> using namespace std; int C(int _n,int _m) { if(_n==_m || _n==1 || _m==0) { return 1; } else { return C(_n-1,_m-1)+C(_n-1,_m); } } int main() { int n,m; while (1) { cout<<"enter n and m:"; cin>>n>>m; if (n>0 && m<=n) { cout<<"C("<<n<<","<<m<<")="<<C(n,m)<<endl; } else { cout<<"error: n>0 && m<=n"<<endl; } } return 0; }   

[3] From the definition of combination, since as we all know, C(n,m) is equvivalent to n!/(m!*(n-m)!).

#include <iostream> using namespace std; long fac(int); long C(int,int); int main() { int n,k; long s; cout<<"n="; cin>>n; cout<<"k="; cin>>k; s = C(n,k); printf("C(%d,%d)=%d/n",n,k,s); return 0; } long C(int _n,int _k) { int nRe; nRe=fac(_n)/(fac(_n-_k)*fac(_k)); return nRe; } long fac(int i) { long lRe; if (i==1 || i==0) { return 1; } else { lRe=i*fac(i-1); } return lRe; }   

As the ways mentioned above, you may easily find that these ways just only can be used for solving the little number, like C(4,2). But if need to solve C(100000,2), even more C(100000,200), these ways cannot work! 

In the beginning, the solution I thought is to reduce a fraction to make the result little, the ways like following:

#include <iostream> using namespace std; long fac(int); double C(int,int); int main() { while (1) { int n,k; double s; cout<<"n="; cin>>n; cout<<"k="; cin>>k; s = C(n,k); printf("C(%d,%d)=%lf/n",n,k,s); } return 0; } double C(int _n,int _k) { int up=_n,down=_k; double dRe=1.0; for (int i=0; i!=_k; ++i) { dRe*=((double)up--/(double)down--); } return dRe; }   

In fact, this ways  can reduce the results in some extents(the loss of accuracy), if for C(100000,200), it still connot work!