劍指Offer 之 剪繩子

動態規劃 & 貪心策略 解法：

public class RopeCutting{
 
/**
     * 分析：由於m， target > 1,說明繩子至少必須cut一次
     * 對於
     * target = 2， max = 1 < target
     * target = 3， max = 2 < target
     * target = 4， max = 2 * 2 = 4 >= target
     * target = 5， max = 2 * 3 = 6 >= target
     * 。。。
     * 考慮到 target < 3時， max multiple value < target
     * 而一旦target > 3時，則必須考慮截斷繩子，因爲截斷比不截斷繩子獲得更大的max value
     * 此時動態規劃中從底向上推導的最簡單情形爲pro[0] = 0, pro[1] = 1, pro[2] = 2, pro[3] = 3,
     * 從target = 4開始進行遍歷，基於最簡單的情形進行計算
     *
     * 因此這三種情況單獨考慮
     *
     * @param target
     * @return
     */
    public int ropeCut(int target){
        if(target < 2)
            return 0;
        else if(target == 2)
            return 1;
        else if(target == 3)
            return 2;

        int[] pro = new int[target + 1];
        pro[0] = 0;
        pro[1] = 1;
        pro[2] = 2;
        pro[3] = 3;

        int max = 0; // i增加，max總會擴大，一次第一層循環內不需要max歸零
        int tmp;
        for (int i = 4; i <= target ; i++) {
            for (int j = 1; j <= i / 2 ; j++) {
                   tmp = pro[j] * pro[i - j];
                   max = max < tmp ? tmp : max;
            }
            pro[i] = max;
        }

        return pro[target];
    }


   /**
     *  此題貌似greedy算法更簡單，因爲只要是大於3的繩子長度就應該被截斷爲
     *  2， 3的片段組成，截斷爲3的越多，乘積的值越大，所謂greedy strategy.
     *  關鍵是考慮最後的情況，最後剩下4時，應該取2 * 2可以獲得最大值。
     * @param target
     * @return
     */
    public int greedyRopeCut(int target){
        int threeLen = target / 3;
        int leftLen = target % 3;

        // 餘數的情況分爲三種0， 1， 2
        if(0 == leftLen)
            return (int)Math.pow(3, threeLen);
        else if(2 == leftLen)
            return (int)Math.pow(3, threeLen) * 2;
        else
            return (int)Math.pow(3, threeLen - 1) * 2;
    }



    public static void main(String[] args) {
        System.out.println("Dynamic result ==> " + new RopeCutting().ropeCut(100));
        System.out.println("Greedy result ==> " + new RopeCutting().ropeCut(100));
    }
}