Java 将一个正整数分解为至少两个正整数之和，并返回最大乘积

这是最近的一个访谈问题，给定一个正整数n，将其分解为至少两个正整数的和，并使这些整数的乘积最大化。返回您可以获得的最大产品

例如，给定n=2，返回1（2=1+1）；给定n=10，返回 36（10=3+3+4）

我试图递归地解决它，方法是 首先将数字分成两半，找到最大乘积，然后继续将每一半分开，直到得到最大值

这是我的密码

private int integerBreak(int n, int maxProduct){

        int index = 0;
        for(int i=0; i<n; i++){
            if((i * (n-i)) >maxProduct) {
                maxProduct = i*(n-i);
                index = i;
            }
        }
        return integerBreak(index, index) * integerBreak(n - index, n-index);
    }
    public int integerBreak(int n) {

        int maxProduct = 0;
        return integerBreak(n, maxProduct);

    }

private int integerBreak（int n，int maxProduct）{
int指数=0；
对于（int i=0；imaxProduct）{
maxProduct=i*（n-i）；
指数=i；
}
}
返回integerBreak（索引，索引）*integerBreak（n-索引，n-索引）；
}
公共整数整数破解（整数n）{
int-maxProduct=0；
返回整数break（n，最大乘积）；
}

---

现在我对如何终止递归的基本条件有点不知所措。如果有人能帮我解决问题，而不是提出完全不同的解决方案，我会很感激。

< P>如果你试图找到一个循环，那么就会变得复杂而效率不高（数字越大，最长的时候你就会发现它，你需要考虑索引等）

最好、最快的算法是中点算法，即将给定的数字除以2，如果数字为奇数，则计算偏差，最后计算乘积

例子：

---

将正确获得结果…

我编写了一个简单的Java应用程序来计算数字2到20的整数之和的最大乘积。第一个数字是总和。中间的数字是总和的因子。最后的数字是这些因素的乘积。以下是结果

2   [1, 1]   1
3   [2, 1]   2
4   [2, 2]   4
5   [3, 2]   6
6   [3, 3]   9
7   [4, 3]   12
8   [3, 3, 2]   18
9   [3, 3, 3]   27
10   [4, 3, 3]   36
11   [3, 3, 3, 2]   54
12   [3, 3, 3, 3]   81
13   [4, 3, 3, 3]   108
14   [3, 3, 3, 3, 2]   162
15   [3, 3, 3, 3, 3]   243
16   [4, 3, 3, 3, 3]   324
17   [3, 3, 3, 3, 3, 2]   486
18   [3, 3, 3, 3, 3, 3]   729
19   [4, 3, 3, 3, 3, 3]   972
20   [3, 3, 3, 3, 3, 3, 2]   1458

calculateMaximumFactors方法使用最大乘积计算因子。因子法生成总和的因子。乘积法计算各因素的乘积。代码如下：

package com.ggl.testing;

import java.util.Arrays;

public class MaximumProduct {

    public static void main(String[] args) {
        for (int sum = 2; sum <= 20; sum++) {
            System.out.print(sum + "   ");
            System.out.println(calculateMaximumFactors(sum));
        }
    }

    private static String calculateMaximumFactors(int sum) {
        int[] previousFactors = new int[0];
        int maxProduct = 0;

        for (int i = 2; i <= sum; i++) {
            int[] factors = factor(sum, i);
            int product = product(factors);
            if (product > maxProduct) {
                maxProduct = product;
                previousFactors = Arrays.copyOf(factors, factors.length);
            }
        }

        return Arrays.toString(previousFactors) + "   " + maxProduct;
    }

    private static int[] factor(int sum, int divisor) {
        if (sum < divisor) {
            return new int[0];
        }

        int num = sum / divisor;
        int remainder = sum % divisor;
        int[] result = new int[divisor];
        for (int i = 0; i < divisor; i++) {
            result[i] = num;
            if (remainder > 0) {
                result[i]++;
                remainder--;
            }
        }

        return result;
    }

    private static int product(int[] factors) {
        int product = 1;

        for (int i = 0; i < factors.length; i++) {
            product *= factors[i];
        }

        return product;
    }

}

package com.ggl.testing；
导入java.util.array；
公共类最大乘积{
公共静态void main（字符串[]args）{
对于（整数和=2；和0）{
结果[i]++；
余数--；
}
}
返回结果；
}
私有静态int乘积（int[]因子）{
int乘积=1；
对于（int i=0；i

以下是我对这个问题的解决方案：（想法：最好将整数分解为3的倍数）

---

这是简单的O（N）解。希望这对别人有帮助

这个想法是把数字分成2或3的倍数。如果你写一些数字，比如7到10，你就应该知道了。假设最大值为60，则有一个简单的动态解决方案：

int dp[60];
public:
int integerBreak(int n)
{
  dp[1]=1,dp[2]=1,dp[3]=2,dp[4]=4,dp[5]=6,dp[6]=9;
  for(int i=7;i<=n;i++)
     dp[i]=max(dp[i-3]*3,dp[i-2]*2);
  return dp[n];
}

int-dp[60]；
公众：
整数破解（整数n）
{
dp[1]=1，dp[2]=1，dp[3]=2，dp[4]=4，dp[5]=6，dp[6]=9；
对于（int i=7；i“将一个正整数分解为…”否，n是正的。降低您的参数？可能会有帮助“方法是首先将数字拆分为两半，然后找到最大乘积，并继续拆分每一半，直到得到最大值。”不。将数字分成两半、三分之一、四分之一、五分之一等等，直到我们计算出最大值。谢谢@RC。这很有帮助，但我的方法的全部要点是在没有数学证明的情况下找到一个解决方案。如果你在函数中传递10，你会得到25，这是不正确的。你应该得到36。正是我的观点。没有guar安泰除以2将得到最大乘积。他希望得到最大乘积所需的数量，只要它们加起来等于传入的数字。@ΦXoce웃Пepeúpa也许您可以用提供的示例再次阅读问题陈述。
package com.ggl.testing;

import java.util.Arrays;

public class MaximumProduct {

    public static void main(String[] args) {
        for (int sum = 2; sum <= 20; sum++) {
            System.out.print(sum + "   ");
            System.out.println(calculateMaximumFactors(sum));
        }
    }

    private static String calculateMaximumFactors(int sum) {
        int[] previousFactors = new int[0];
        int maxProduct = 0;

        for (int i = 2; i <= sum; i++) {
            int[] factors = factor(sum, i);
            int product = product(factors);
            if (product > maxProduct) {
                maxProduct = product;
                previousFactors = Arrays.copyOf(factors, factors.length);
            }
        }

        return Arrays.toString(previousFactors) + "   " + maxProduct;
    }

    private static int[] factor(int sum, int divisor) {
        if (sum < divisor) {
            return new int[0];
        }

        int num = sum / divisor;
        int remainder = sum % divisor;
        int[] result = new int[divisor];
        for (int i = 0; i < divisor; i++) {
            result[i] = num;
            if (remainder > 0) {
                result[i]++;
                remainder--;
            }
        }

        return result;
    }

    private static int product(int[] factors) {
        int product = 1;

        for (int i = 0; i < factors.length; i++) {
            product *= factors[i];
        }

        return product;
    }

}

public int integerBreak(int n) {

    // base case : 
    if (n == 2 || n == 3){ 
       return (n-1);
    }

    int maxProduct = 1;
    while (n > 4){
        n -= 3;
        maxProduct *= 3; // Keep multiplying 3.
    }
    return (n * maxProduct); // multiply with left over n.

}

int dp[60];
public:
int integerBreak(int n)
{
  dp[1]=1,dp[2]=1,dp[3]=2,dp[4]=4,dp[5]=6,dp[6]=9;
  for(int i=7;i<=n;i++)
     dp[i]=max(dp[i-3]*3,dp[i-2]*2);
  return dp[n];
}