动态规划和贪婪算法

如果是求一个问题的最优解（通常是求最大值或者最小值），而且该问题能够分解成若干个子问题，并且子问题之间还有重叠的更小的子问题，就可以用动态规划来解决这个问题。在应用动态规划之前要分析能否把大问题分解成小问题，分解后的每个小问题也存在最优解。如果把小问题的最优解组合起来能够得到整个问题的最优解，那么就可以使用动态规划来解决这个问题。

贪婪算法和动态规划不一样，当我们应用贪婪算法解决问题的时候，每一步都可以做出一个贪婪的选择，基于这个选择，我们确定能够得到最优解。

问题：一根长度为n的绳子，把绳子剪成m段（m，n都是整数，n>1并且m>1）,每段绳子的长度记为k[0],k[1],...,k[m]。请问k[0]xk[1]x...k[m]可能的最大乘积是多少？例如绳子长度是8时，把它剪成长度分别为2，3，3的三段，此时得到的最大乘积是18。

解题思路：动态规划需要O(n平方)的时间复杂度和O(n)空间复杂度。可以定义f(n)为把长度为n的绳子剪成若干段后各段长度乘积的最大值。在剪第一下时，有n-1种可能的选择，也就是剪出来的第一段绳子的长度可能为1，2，...，n-1。因此f(n)=max(f(i)xf(n-i))，其中0<i<n。这是一个从上往下的递归公式。由于递归会出现很多重复的子问题，从而有大量不必要的重复计算。一个更好的办法是按照从下而上的顺序计算，也就是说先得到f(2)，f(3)，再得到f(4)，f(5)，知道得到f(n)。当绳子长度为2时，只能剪成长度都为1的两段，因此f(2)=1，当绳子的长度为3时，可能把绳子剪成长度分别为1和2的两段或者长度都为1的三段，因此，f(3)=2。一次类推。

int maxProduct(int len)
{
    if(len < 2)
        return 0;
    if(len == 2)
        return 1;
    if(len == 3)
        return 2;

    int *product = new int[len + 1];
    product[0] = 0;
    product[1] = 1;
    product[2] = 2;
    product[3] = 3;

    int max = 0;
    for(int i = 4; i <= len; i++)
    {
        max = 0;    
        for(int j = 1; j <= i/2; j++)
        {
            int prod = product[j] * product[i-j];
            if(max < prod)
                max = prod;

            product[i] = max;
        }
    }

    max = product[len];
    delete[] product;

    return max;
}

贪婪算法解题思路：如果按照如下方法剪绳子，则得到的各段绳子的长度的乘积将最大：当n>=5时，尽可能多的剪长度为3的绳子，当剩下的绳子长度为4时，把绳子剪成长度为2的绳子。

int maxProduct(int len)
{
    if(len < 2)
        return 0;
    if(len == 2)
        return 1;
    if(len == 3)   
        return 2;

    int count3 = len/3;//尽可能多的剪长度为3的绳子
    //当绳子最后剩下的长度为4时，把绳子剪成长度为2的两段，因为2x2>1x3
    if(len - count3 * 3 == 1)
        count3 -= 1;

    int count2 = (len-count3 * 3)/2;

    return (int)(pow(3,count3))*(int)(pow(2,count2));
}