动态规划与贪婪算法

动态规划问题特点

• 求一个问题的最优解
• 整体问题的最优解依赖各子问题的最优解
• 大问题分解为若干个小问题，小问题之间有互相重叠的更小的子问题。
• 因为子问题在分解大问题的过程中重复出现，为避免重复求解，从下往上的顺序计算小问题并存储。从上往下分析问题，从下往上求解问题。

贪婪算法问题特点

• 每一步都做出贪婪的选择，基于该选择，可以确定得到最优解
• 需要用数学方式证明贪婪选择的正确性

剪绳子

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

输入描述:

输入一个数n，意义见题面。（2 <= n <= 60）

输出描述:

输出答案。

示例1 输入

8

输出

18

动态规划

存储前一步计算出的f(4), f(5), f(n-i)的最优结果。

class Solution {
public:
    int cutRope(int number) {
        if(number<2) return 0;
        if(number==2) return 1;
        if(number==3) return 2;
        
        int *results = new int[number+1];
        results[0] = 0;
        results[1] = 1;
        results[2] = 2; //2的长度
        results[3] = 3; //3的长度
        for(int i=4; i<=number; ++i)
        {
            int max = 0;
            for(int cj=1; cj<=i/2; ++cj)
            {
                if(results[cj]*results[i-cj]>max)
                    max = results[cj]*results[number-cj];
            }
            results[i] = max;
        }
                
        int res = results[number];
        delete[] results;
        return res;
    }
};

贪婪算法

尽量剪3的，余数为0或1或2，因为余数为1，实际最后一次减3时，余4，此时，对半剪更好。

class Solution {
public:
    int cutRope(int number) {
        if(number<2) return 0;
        if(number==2) return 1;
        if(number==3) return 2;
        
        int timesof3 = number/3;
        int remainder = number%3;
        if(remainder==1)
            --timesof3;
        int timesof2 = (number-3*timesof3)/2;
        return pow(3, timesof3)* pow(2, timesof2);
    }
};