剪绳子问题(多解法)

剑指offer之剪绳子问题(多解法)

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

递归法：

由于递归是最接近于自然智慧的，所以对于一道题往往递归的解法更加容易想出来，都是递归也有其先天的不足，就是在递归过程中会进行大量的重复运算。所以从时间复杂度的角度上考虑不推荐用递归。

思路：首先定义函数f(n)为长度为n的绳子剪成若干段之后各段长度乘积的最大值，对于一个绳子长为n的绳子可以先将其分成两段，设一段为长度为i，则另一段绳子长度则为n-i，则为题则转化为f(n)=max(f(n-i)*f(i))，根据该表达式写递归代码如下：

 public static int ProductAfterCutting_solution(int length,int begin)//length表示剩余的绳子的长度，而begin则表示绳子的初始长度,如果初始的长度小于等于3则该段绳子还需要分割(把绳子剪成m段(m,n都是整数，n>1并且m>1)),如果原始长度是>3的则说明该绳子至少被分割为了2段满足题设中的条件，直接将剩余绳长返回即是最大的。
    {
        if(length<=3)
        {
            if(begin<=3)
            {
                return length<2?0:length-1;
            }else{
                return length;
            }
        }


        int max=0;
        for(int i=2;i<=length/2;i++)
        {
            int value=ProductAfterCutting_solution(length-i,begin)*ProductAfterCutting_solution(i,begin);
            if(value>max)
            {
                max=value;
            }
        }
        return max;
    }

记忆化搜索：

为了改进递归算法的先天不足，可以在递归中加入一个数组来缓存已经运算过的数据，对于已经在递归中运算过的数据可以直接在数组中取出，无需再调用递归，解决了递归中大量重复计算的问题。思路上和递归算法一致。

实现代码如下：

public static int RecordProductAfterCutting_solution(int length,int begin,int[] arr)
    {
        if(length<=3)
        {
            if(begin<=3)
            {
                return length<2?0:length-1;
            }else{
                arr[length]=length;
                return length;
            }
        }
        int max=0;
        for(int i=2;i<=length/2;i++)
        {
            if(arr[length-i]==0) arr[length-i]= ProductAfterCutting_solution(length-i,begin);
            if(arr[i]==0) arr[i]=ProductAfterCutting_solution(i,begin);
            int value=arr[i]*arr[length-i];
            if(value>max)
            {
                max=value;
            }
        }
        arr[length]=max;
        return max;

    }

动态规划

代码如下：

public static int GreedyProductAfterCutting_solution(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-=1;
        int timesOf2=(length-timesOf3*3)/2;
        return (int)(Math.pow(3,timesOf3))*(int)(Math.pow(2,timesOf2));
    }

贪心算法

思路：如果我们按照如下的策略剪绳子，则得到的各段绳子的长度乘积最大：当n>=5时，我们尽可能多地剪长度为3的绳子；将剩下的绳子尽可能全部剪为长度为2的绳子。接下来对该策略的正确性进行证明。当n>=5时可以证明2(n-2)>n，并且3(n-3)>n。即当绳子剩余长度>=5时，我们尽量将绳子剪为长度为3或者为2的绳子段。另外，当n>=5时，3(n-3)>=2(n-2)，因此我们可以把绳子尽可能的剪为3的绳子段。

代码实现如下:

public static int GreedyProductAfterCutting_solution(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-=1;
        int timesOf2=(length-timesOf3*3)/2;
        return (int)(Math.pow(3,timesOf3))*(int)(Math.pow(2,timesOf2));
    }