LeetCode 343. Integer Break

问题描述

• Given a positive integer n, break it into the sum of at least two positive integers and maximize the product of those integers. Return the maximum product you can get.
• For example, given n = 2, return 1 (2 = 1 + 1); given n = 10, return 36 (10 = 3 + 3 + 4).
• Note: You may assume that n is not less than 2 and not larger than 58.
• 地址

问题分析

• 将一个正数，分成至少两个部分，求各部分的乘积最大是多少？
• 该题有多种解法，可以用动态规划，也可以找规律来求解。
• 动态规划：O(N^2)
  因为该题是求最优化的问题，所以可以用动态规划。
  最优子结构： 通过求子问题的最优解，可以获得原问题的最优解。
  
  但要注意的是，不要遗漏分割成两部分的情况，例如 2 * (n-2)
• O(N)的方法：
• O(logN)的方法：链接

代码实现

• 递归（TLE）

    //递归
    public int integerBreak(int n) {
        if (n <= 0) {
            return 0;
        }
        return getMaxProduct(n);
    }

    public int getMaxProduct(int n) {
        if (n == 1) {
            return 1;
        }
        int maxProduct = 0;
        for (int val = 1; val <= n - 1; ++val) {
            maxProduct = Math.max(Math.max(maxProduct, val * (n - val)), val * getMaxProduct(n - val));
        }
        return maxProduct;
    }

• 记忆化搜索

    //记忆化搜索
    public int[] res;
    public int integerBreak(int n) {
        if (n <= 0) {
            return 0;
        }
        res = new int[n + 1];
        return getMaxProduct(n);
    }

    public int getMaxProduct(int n) {
        if (n == 1) {
            return 1;
        }
        if (res[n] != 0) {
            return res[n];
        }
        int maxProduct = 0;
        for (int val = 1; val <= n - 1; ++val) {
            maxProduct = Math.max(Math.max(maxProduct, val * (n - val)), val * getMaxProduct(n - val));
        }
        res[n] = maxProduct;
        return maxProduct;
    }

• 动态规划

    public int integerBreak(int n) {
        if (n <= 0) {
            return 0;
        }
        int[] dp = new int[n + 1];
        dp[1] = 1;
        for (int i = 2; i <= n; ++i) {
            for (int val = 1; val < i; ++val) {
                dp[i] = Math.max(Math.max(dp[i], val * (i - val)), val * dp[i - val]);
                //dp[i] = Math.max(dp[i], val * Math.max(i - val, dp[i - val]));
            }
        }
        return dp[n];
    }

• O(N)

    public int integerBreak(int n) {
        if (n <= 2) return 1;
        if (n == 3) return 2;
        if (n == 4) return 4;
        int[] p = new int[n+1];
        p[2] = 2;
        p[3] = 3;
        p[4] = 4;
        for (int i = 5; i <= n; ++i) {
            p[i] = 3 * p[i-3];
        }
        return p[n];
    }

• O(logN)

    public int integerBreak(int n) {
        if (n <= 2) return 1;
        if (n == 3) return 2;
        if (n % 3 == 0) return (int)Math.pow(3, (n/3));
        else if (n % 3 == 1) return 4 * (int)Math.pow(3, (n-4)/3);
        else return 2 * (int)Math.pow(3, (n-2)/3);
    }