剑指Offer——剪绳子

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

思路一：动态规划；

自底向上以此求出绳子为1,2,3,4.....最大的乘积，保存在一个数组中；计算后面乘积的时候使用前面的乘积；

思路二：贪婪算法;

由题目得出当绳子超过5的时候，每次都乘三得到的乘积比较大；

代码：

public class MaxProduct {
    /**
     * 利用贪婪算法
     * 1、当len>=5的时候,尽可能多的剪长度为3的绳子；
     * 2、当剩下的绳子长度为4的时候，剪成长度为2的两个
     * @param len
     * @return
     */
    public 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));
    }

    /**
     * 利用动态规划
     * @param len
     * @return
     */
    public static int  MaxProduct2(int len) {
        int [] sum=new int[len+1];
        sum[1]=1;
        sum[2]=2;
        sum[3]=3;
        for(int i=4;i<=len;i++){
               sum[i]=max(sum,i);
            }
        return sum[len];
    }
    public static int max(int []sum,int len){
        int max=0;
        for(int i=1;i<=len/2;i++){
            int newmax=sum[i]*sum[len-i];
            if(max<newmax){
                max=newmax;
            }
        }
        return max;
    }

    public static void main(String [] args){
        int s=6;
        int a=MaxProduct2(s);
        System.out.println(a);
    }
}