五大基本算法思想之动态规划和贪心算法

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接： https://blog.csdn.net/qq_29857681/article/details/95775170

使用场景： 一个大问题可以拆分成多个小问题，每个小问题有最优解（最值） ，则大问题有最优解。

把一根绳子剪成多段，并且使得每段的长度乘积最大。

我们先考虑能否把大问题分解成小问题，分解后的小问题也存在最优解，如果把小问题的最优解组合起来能否是整个问题的最优解，这就是动态规划求解

贪心算法注意是找合适的值(本例中的3和2) 并用数学归纳法证明。

public class JianShengZi {

    public static void main(String[] args) {
        System.out.println(TanXin(18));
    }

    /**
     * 动态规划
     * @param length
     * @return
     */
    static int maxlength(int length) {
        if (length < 2)
            return 0;
        if (length == 2)
            return 1;
        if (length == 3)
            return 2;
        int[] maxVal = new int[length + 1];
        //当剩下的绳长分别是0/1/2/3的时候，最大乘积就是本身的长度，不需要再去剪,因为一刀没有不剪的乘积大
        maxVal[1] = 1;
        maxVal[2] = 2;
        maxVal[3] = 3;
        for (int i = 4; i <= length; i++) {
            int j = 1;
            while (j <= i / 2) {
                if (maxVal[j] * maxVal[i - j] > maxVal[i])
                    maxVal[i] = maxVal[j] * maxVal[i - j];
                j++;
            }
        }

        return maxVal[length];
    }

    /**
     * 贪心算法
     * @param length
     * @return
     */
    static int TanXin(int length) {
        if (length < 2) return 0;
        if (length == 2) return 1;
        if (length == 3) return 2;

        int timesOf3 = length / 3;
        if ((length - timesOf3 * 3) == 1) timesOf3--;
        int timesOf2 = (length - timesOf3 * 3) / 2;
        return (int) (Math.pow(3, timesOf3) * Math.pow(2, timesOf2));
    }
}