动态规划的几个实例

１.算一个数组中的每一项目等于其它项的乘积:

//Don't forget to free the result.
int* MutilArray(int nInput[], int nCount)
{
    int nMutilAll = 1;
    int *PResult = NULL;

    PResult = (int*)malloc(sizeof(int) * nCount);
    if (!PResult)
       return NULL;

    for (int i=0; i < nCount; i++)
    {
        nMutilAll *= nInput[i];
    }

    for (int i=0; i< nCount; i++)
    {
        PResult[i]  = nMutilAll/nInput[i];
    }

    return PResult;
}

2.如果我们有面值为1元、3元和5元的硬币若干枚，如何用最少的硬币凑够11(X)元？ 

int nConisArray[] = {1, 3, 5};

bool HaveThisCoin(int nCoin)
{
    if (nCoin == 1 || nCoin == 3 || nCoin == 5)
    {
        return true;
    }
    return false;
}

//dp
int dp(int nFindMondy)
{
    int nLen = 1;
    if (HaveThisCoin(nFindMondy))
    {
        nLen = 1;
    }
    else
    {
        if (nFindMondy >= 5)
        {
            nLen = dp(nFindMondy - 5) + 1;
        }
        else if(nFindMondy >= 3)
        {
            nLen = dp(nFindMondy - 3) + 1;
        }
        else
        {
            nLen = dp(nFindMondy - 1) + 1;
        }
    }
    return nLen;
}

２.一个序列有N个数：A[1],A[2],…,A[N]，求出最长非降子序列的长度。

int LIS(int nArray[], int nCnt)
{
    int *pArray = new int[nCnt];
    int  nLen = 1;

    for (int i=0; i < nCnt; i++)
    {
        pArray[i] = 1;
        for (int j = 0; j < i; j++)
        {
            if (nArray[j] > nArray[i] && pArray[j] + 1 > pArray[i])
                pArray[i] = pArray[j] + 1;
        }

        if (pArray[i] > nLen)
           nLen = pArray[i];
    }

    delete[] pArray;
    return nLen;
}

３.平面上有N*M个格子，每个格子中放着一定数量的苹果。你从左上角的格子开始， 每一步只能向下走或是向右走，每次走到一个格子上就把格子里的苹果收集起来， 这样下去，你最多能收集到多少个苹果。

#define ROWS
#define COLUMNS

int max(int a, int b)
{
    return a > b ? a : b;
}

int Demon(int i, int j)
{
    int nCount = 0;

    if (i == ROWS - 1 && j == COLUMNS -1)
    {
        return nApples[ROWS - 1][COLUMNS - 1];
    }

    else if ( i == ROWS - 1 && j < COLUMNS - 1)
    {
        nCount = nApples[i][j] + Demon(i, j + 1);
    }
    else if (j == COLUMNS - 1 && i < ROWS - 1)
    {
        nCount = nApples[i][j] + Demon(i + 1, j);
    }

    if (i < COLUMNS - 1 && j < COLUMNS - 1)
    {
         nCount = nApples[i][j] + max(Demon(i + 1, j), Demon(i, j + 1));
    }
    return nCount;
}