概率論是統計分析的基礎，而統計分析在很多領域比如人工智慧，生物資訊學中作為理論基礎，具有廣泛的應用場景。組合數在概率論中常用，本文就對組合數的數值計算給出一個C++求解的演算法。通過實現該演算法，對數值計算上的某些方法加深的認識。
首先，來看一下組合數的公式：

通過該公式，首先會想到使用暴力求解法來計算。但階乘的計算，很容易就會造成數值的溢位，因此暴力求解法在數值稍大的情況下就無法適用。
緊接著，想到常用的處理溢位的方法，利用轉換成對數進行運算，使用該種方法可將連乘轉換成連加，溢位問題是解決了，但精度上卻又不能滿足要求。
於是，需要探索其他的方法來解決這一問題。考慮到分子分母均為階乘，如果對分子分母分別分解質因數，然後對共同的質因數進行約分，最終剩下的質因數的乘積就是我們最終要求的結果。使用這一方法的好處，還在於我們可以通過記錄質因數及質因數存在的次數來記錄最終的結果，而不必直接記錄最終的結果，這樣就可以同時解決溢位問題和精度問題。

在本文最後，我附上了具體的C++實現的程式碼。在看程式碼之前，我們先將其中的核心部分進行一下解讀與分析。
1.初始化素數動態陣列（C++的動態陣列可以用STL中的向量來實現）。在判斷某個數是否素數時，我們只需要輪循到該數的平方根即可，這將大大減少內層迴圈的演算法複雜度。

2.n的階乘裡面含有素數的次數。因為n!表示n(n-1)(n-2)…1，因此如果n>=x（素數）,則必然至少存在n/x次素數x，並且這n/x個數除以素數x之後得到的新的排列中，又會又(n/x)/x次素數x。換句話說，素數x的所有次數，均會包含在第一次迴圈能夠整除x的這些數中，而這些數中有的可能包括多次的素數x。因此，通過getPrimePow方法，則得到了n!裡面含有素數x的所有次數，記為pow返回。

具體的演算法如下：

#ifndef _COMBINE_CALCULATOR_H_
#define _COMBINE_CALCULATOR_H_
#include <vector>
#include <map>
#include <iostream>
 

using namespace std;

class CombineCalculator
{
public:
    CombineCalculator();
    ~CombineCalculator();
    //計算組合數，C(n,m)
    bool calculateCombine(int n, int m);
    //列印結果
    void printResult();
private:
    //計算n!中含有素數x的次數
    int getPrimePow(int n, int x);
    //生成素數
    void generatePrime();
    //存放素數動態陣列
    vector<int> primeVec;
    //結果Map,key為素數，value為該素數的次數
    map<int, int> resultMap;
    const int MAXN = 1000;
    const int MAXPRIME = 1000;
};

#endif

#include "CombineCalculator.h"

CombineCalculator::CombineCalculator()
{
    generatePrime();
}

CombineCalculator::~CombineCalculator()
{

}

void CombineCalculator::generatePrime()
{
    for (int i = 2; i < MAXPRIME; i++)
    {
        bool isPrime = true;
        int s = sqrt(i);
        for (int j = 2; j <= s; j++)
        {
            if (i%j == 0)
            {
                isPrime = false;
                break;
            }
        }
        if (isPrime)
        {
            primeVec.push_back(i);
        }
    }
    return;
}


int CombineCalculator::getPrimePow(int n, int x)
{
    int pow = 0;
    while (n >= x)
    {
        int temp = n / x;
        pow += temp;
        n = temp;
    }
    return pow;
}


bool CombineCalculator::calculateCombine(int n, int m)
{
    bool result = true;
    if (n > MAXN)
    {
        result = false;

    }
    else
    {
        for (int i = 0; i < primeVec.size(); i++)
        {
            int pow = getPrimePow(n, primeVec[i]) - getPrimePow(m, primeVec[i]) - getPrimePow(n - m, primeVec[i]);
            if (pow != 0)
                resultMap.insert(std::pair<int,int>(primeVec[i], pow));
        }
    }
    return result;
}

void CombineCalculator::printResult()
{
    map<int, int>::const_iterator iter;
    for (iter = resultMap.begin(); iter != resultMap.end(); iter++)
    {
        cout << "Key:" << iter->first << "Value:" << iter->second << endl;
    }
}