leetcode343

 public class Solution
     {
         public int IntegerBreak(int n)
         {
             if (n == )
             {
                 return ;
             }
             else if (n == )
             {
                 return ;
             }
             var max = int.MinValue;
             for (int i = ; i <= n / ; i++)
             {
                 var div = n / i;
                 var mod = n % i;
                 var cur = ;
                 if (mod == )
                 {
                     cur = Convert.ToInt32(Math.Pow(i, div));
                 }
                 else
                 {
                     var cur1 = Convert.ToInt32(Math.Pow(i, div - ) * (i + mod));
                     var cur2 = Convert.ToInt32(Math.Pow(i, div)) * mod;
                     cur = Math.Max(cur1, cur2);
                 }
                 if (cur > max)
                 {
                     max = cur;
                 }
                 else
                 {
                     break;
                 }
             }
             return max;
         }
     }

https://leetcode.com/problems/integer-break/#/description

这道题的解题思路是，从2到n/2每个值依次进行尝试，对于每一个值，计算这种情况下的因子乘积，

如果是可以被整除，则计算当前值的“倍数的次方”；如果不能被整除，则分两种情况分别计算。

第一种是：将某一个因子与余数合并为一个因子。

第二种是：剩余的余数做一个单独的因子。

每种情况都计算出其因子的乘积，然后找最大值。

举例来说，输入参数n=12，

i=2，执行21行，cur=2^6=64，更新max=64

i=3，执行21行，cur=3^4=81，更新max=81

i=4，执行21行，cur=4^3=64，保持max=81

i=5，执行25～27，cur1=5^(2-1) * (5+2)=5*7=35，cur2=5^2 * 2=5*5*2=50，cur=50，保持max=81

i=6，执行21行，cur=6^2=36，保持max=81

执行完毕，最终结果为81。

补充一个使用dp的解决方案：

 public class Solution
     {
         public int IntegerBreak(int n)
         {
             int[] dp = new int[n + ];
             dp[] = ;
             for (int i = ; i <= n; i++)
             {
                 for (int j = i-; j >=; j--)
                 {
                     var premax = dp[i - j];
                     var distance = i - j;
                     var cur = Math.Max(premax, distance) * j;
                     dp[i] = Math.Max(dp[i], cur);
                 }
             }
             return dp[n];
         }
     }