【剑指offer-67】20190911/03 剪绳子

【剑指offer-67】剪绳子

• 考点：贪心
• 时间限制：1秒
• 空间限制：32768K
• 题目描述
  给你一根长度为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

---

思路：

动态规划求解问题的四个特征：
①求一个问题的最优解；
②整体的问题的最优解是依赖于各个子问题的最优解；
③小问题之间还有相互重叠的更小的子问题；
④从上往下分析问题，从下往上求解问题；
贪婪解法： 当n大于等于5时，我们尽可能多的剪长度为3的绳子；当剩下的绳子长度为4时，把绳子剪成两段长度为2的绳子。 为什么选2，3为最小的子问题？因为2，3包含于各个问题中，如果再往下剪得话，乘积就会变小。 为什么选长度为3？因为当n≥5时，3(n−3)≥2(n−2)

动态规划:长度为i的可得最大乘积:dp[i]=dp[j]*dp[i-j]的最大值

代码：

public class Solution {
    public int cutRope(int target) {
        if (target < 2) {
            return 0;
        }
        if (target == 2) {
            return 1;
        }
        if (target == 3) {
            return 2;
        }
        
        int[] dp = new int [target + 1];
         /****长度为1、2、3、4的绳子的最大积********/
        dp[0] = 0;
        dp[1] = 0;
        dp[2] = 2;
        dp[3] = 3;
        
        int max = 0, i = 0, j = 0;
        for (i = 4; i <= target; i++) {
            max = 0;
            for (j = 1; j <= i / 2; j++) {
                int product = dp[j] * dp[i - j];
                if (max < product) {
                    max = product;
                }
              dp[i] = max;
            }
        }
        return dp[target];
    }
}

贪心法

public class Solution {
    public int cutRope(int target) {
    //贪心法，尽量剪出长度3，若最后剩长度4，就剪2*2
        if (target < 2) {
            return 0;
        }
        if (target == 2) {
            return 1;
        }
        if (target == 3) {
            return 2;
        }
        
        // 可以剪出3的次数
        int timeOf3 = target / 3;
        
        //判断最后剩下的一段长度是不是4
        if (target % 3 == 1) {
            timeOf3--;
        }
        
        // 剪完3后 剩下剪2 可以剪2的个数
        int timeOf2 = (target - timeOf3 * 3) / 2;
        
        // 计算最终只
        return (int)(Math.pow(3, timeOf3)) * (int)(Math.pow(2, timeOf2));
    }
}

我的问题：

1. 注意i和j的下标值都是小于等于某个数值

---

其他思路1：

• 题目分析：
• 先举几个例子，可以看出规律来。
• 4 ： 2*2
• 5 ： 2*3
• 6 ： 3*3
• 7 ： 2*2*3 或者4*3
• 8 ： 2*3*3
• 9 ： 3*3*3
• 10：2*2*3*3 或者4*3*3
• 11：2*3*3*3
• 12：3*3*3*3
• 13：2*2*3*3*3 或者4*3*3*3
• 下面是分析：
• 首先判断k[0]到k[m]可能有哪些数字，实际上只可能是2或者3。
• 当然也可能有4，但是4=2*2，我们就简单些不考虑了。
• 5<2*3,6<3*\3,比6更大的数字我们就更不用考虑了，肯定要继续分。
• 其次看2和3的数量，2的数量肯定小于3个，为什么呢？因为2*2*2<3*3，那么题目就简单了。
• 直接用n除以3，根据得到的余数判断是一个2还是两个2还是没有2就行了。
• 由于题目规定m>1，所以2只能是1*1，3只能是2*1，这两个特殊情况直接返回就行了。
• 乘方运算的复杂度为：O(log n)，用动态规划来做会耗时比较多。

public class Solution {
    public int cutRope(int target) {
        return n_max_3(target);
    }
    public int n_max_3(int n) {
        if (n == 2) {
            return 1;
        }
        if (n == 3) {
            return 2;
        }
        int x = n % 3;
        int y = n / 3;
        if (x == 0) {
            // 正好被3整除，y就是有多少个3
            return (int)Math.pow(3, y);
        } else if (x == 1) {
            return 2 * 2 * (int)Math.pow(3, y - 1);
        } else {
            return 2 * (int)Math.pow(3, y);
        }
    }
}

---