用go语言，一个数字n，一定要分成k份，
得到的乘积尽量大是多少？
数字n和k，可能非常大，到达10^12规模。
结果可能更大，所以返回结果对1000000007取模。
大体过程如下：
算法1：暴力递归
1.首先判断k是否为0或者n是否小于k，若是则返回-1。
2.调用递归函数process1，传入参数n和k。
3.在递归函数中，若k为1，则返回n。
4.使用循环从1到rest（即剩余数字n）遍历cur，cur为当前需要划分的数字。
5.将cur与process1(rest-cur, j-1)相乘，得到当前划分下的乘积curAns。
6.若curAns大于ans，则更新ans为curAns。
7.返回ans作为结果。
算法2：贪心的解
1.首先判断k是否为0或者n是否小于k，若是则返回-1。
2.计算每份应得数字a，为n除以k的商。
3.计算有多少份应该升级成a+1，并将结果保存到变量b中。
4.初始化ans为1。
5.使用循环从0到b遍历i，将a+1乘以ans，更新ans的值。
6.使用循环从0到k-b遍历i，将a乘以ans，更新ans的值。
7.返回ans作为结果。
算法3：贪心的解（最优解）
1.首先判断k是否为0或者n是否小于k，若是则返回-1。
2.初始化变量mod为1000000007。
3.计算每份应得数字a，为n除以k的商。
4.计算有多少份应该升级成a+1，并将结果保存到变量b中。
5.调用函数power(a+1, b, mod)计算part1，表示a+1的b次方的结果对mod取模。
6.调用函数power(a, k-b, mod)计算part2，表示a的k-b次方的结果对mod取模。
7.返回(part1 * part2) % mod作为结果。
总的时间复杂度：
算法1：暴力递归的时间复杂度可以用递归树来表示，假设n和k的差值为m（即n-k=m），则递归树的高度为m，每个节点需要进行O(m)的计算，所以总的时间复杂度为O(m^m)。
算法2和算法3的时间复杂度为O(1)，因为只有常数次的运算。
总的空间复杂度：
算法1：暴力递归的空间复杂度为O(m)，递归树的高度为m，所以递归所需的栈空间为O(m)。
算法2和算法3的空间复杂度为O(1)，只需要常数个变量进行计算。
go完整代码如下：
package main
import "fmt"
// 暴力递归
// 一定能得到最优解
func maxValue1(n int, k int) int {
if k == 0 || n < k {
return -1
}
return process1(n, k)
}
// 剩余的数字rest，一定要拆成j份，返回最大乘积
func process1(rest int, j int) int {
if j == 1 {
return rest
}
// 10 , 3份
// 1 * f(9,2)
// 2 * f(8,2)
// 3 * f(7,2)
// ...
ans := -1 << 31
for cur := 1; cur <= rest && (rest-cur) >= (j-1); cur++ {
curAns := cur * process1(rest-cur, j-1)
if curAns > ans {
ans = curAns
}
}
return ans
}
// 贪心的解
// 这不是最优解，只是展示贪心思路
func maxValue2(n int, k int) int {
if k == 0 || n < k {
return -1
}
// 数字n，一定要分k份
// 每份先得多少，n/k
a := n / k
// 有多少份可以升级成a+1
b := n % k
ans := 1
for i := 0; i < b; i++ {
ans *= a + 1
}
for i := 0; i < k-b; i++ {
ans *= a
}
return ans
}
// 贪心的解
// 这是最优解
// 但是如果结果很大，让求余数...
func maxValue3(n int64, k int64) int {
if k == 0 || n < k {
return -1
}
mod := 1000000007
a := n / k
b := n % k
part1 := power(a+1, b, mod)
part2 := power(a, k-b, mod)
return int((part1 * part2) % int64(mod))
}
// 返回a的n次方，%mod的结果
func power(a int64, n int64, mod int) int64 {
ans := int64(1)
tmp := a
for n != 0 {
if (n & 1) != 0 {
ans = (ans * tmp) % int64(mod)
}
n >>= 1
tmp = (tmp * tmp) % int64(mod)
}
return ans
}
func main() {
// 可以自己来用参数实验
n := 20
k := 4
fmt.Println(maxValue1(n, k))
fmt.Println(maxValue2(n, k))
// fmt.Println(maxValue3(n, k))
}
rust完整代码如下：
fn max_value1(n: i32, k: i32) -> i32 {
if k == 0 || n < k {
return -1;
}
process1(n, k)
}
fn process1(rest: i32, j: i32) -> i32 {
if j == 1 {
return rest;
}
let mut ans = i32::MIN;
for cur in 1..=rest {
if (rest - cur) >= (j - 1) {
let cur_ans = cur * process1(rest - cur, j - 1);
ans = ans.max(cur_ans);
}
}
ans
}
fn max_value2(n: i32, k: i32) -> i32 {
if k == 0 || n < k {
return -1;
}
let a = n / k;
let b = n % k;
let mut ans = 1;
for _ in 0..b {
ans *= a + 1;
}
for _ in 0..(k - b) {
ans *= a;
}
ans
}
fn max_value3(n: i64, k: i64) -> i32 {
if k == 0 || n < k {
return -1;
}
let mod_val = 1000000007;
let a = n / k;
let b = n % k;
let part1 = power(a + 1, b, mod_val);
let part2 = power(a, k - b, mod_val);
(part1 * part2 % mod_val) as i32
}
fn power(a: i64, n: i64, mod_val: i64) -> i64 {
let mut ans = 1;
let mut tmp = a;
let mut n = n;
while n != 0 {
if n & 1 != 0 {
ans = ans * tmp % mod_val;
}
n >>= 1;
tmp = tmp * tmp % mod_val;
}
ans
}
fn main() {
let n = 20;
let k = 4;
println!("{}", max_value1(n, k));
println!("{}", max_value2(n, k));
println!("{}", max_value3(n as i64, k as i64));
}
c++完整代码如下：
#include <iostream>
using namespace std;
int process1(int rest, int j)
{
if (j == 1)
{
return rest;
}
int ans = INT_MIN;
for (int cur = 1; cur <= rest && (rest - cur) >= (j - 1); cur++)
{
int curAns = cur * process1(rest - cur, j - 1);
ans = max(ans, curAns);
}
return ans;
}
int maxValue1(int n, int k)
{
if (k == 0 || n < k)
{
return -1;
}
return process1(n, k);
}
int maxValue2(int n, int k)
{
if (k == 0 || n < k)
{
return -1;
}
int a = n / k;
int b = n % k;
int ans = 1;
for (int i = 0; i < b; i++)
{
ans *= a + 1;
}
for (int i = 0; i < k - b; i++)
{
ans *= a;
}
return ans;
}
int power(long long a, long long n, int mod)
{
long long ans = 1;
long long tmp = a;
while (n != 0) {
if ((n & 1) != 0)
{
ans = (ans * tmp) % mod;
}
n >>= 1;
tmp = (tmp * tmp) % mod;
}
return ans;
}
int maxValue3(long long n, long long k)
{
if (k == 0 || n < k)
{
return -1;
}
int mod = 1000000007;
long long a = n / k;
long long b = n % k;
long long part1 = power(a + 1, b, mod);
long long part2 = power(a, k - b, mod);
return (part1 * part2) % mod;
}
int main() {
int n = 20;
int k = 4;
cout << maxValue1(n, k) << endl;
cout << maxValue2(n, k) << endl;
cout << maxValue3(n, k) << endl;
return 0;
}
c完整代码如下：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 暴力递归
// 一定能得到最优解
int maxValue1(int n, int k) {
if (k == 0 || n < k) {
return -1;
}
return process1(n, k);
}
// 剩余的数字rest，一定要拆成j份，返回最大乘积
int process1(int rest, int j) {
if (j == 1) {
return rest;
}
// 10 , 3份
// 1 * f(9,2)
// 2 * f(8,2)
// 3 * f(7,2)
// ...
int ans = -INT_MAX;
for (int cur = 1; cur <= rest && (rest - cur) >= (j - 1); cur++) {
int curAns = cur * process1(rest - cur, j - 1);
if (curAns > ans) {
ans = curAns;
}
}
return ans;
}
// 贪心的解
// 这不是最优解，只是展示贪心思路
int maxValue2(int n, int k) {
if (k == 0 || n < k) {
return -1;
}
// 数字n，一定要分k份
// 每份先得多少，n/k
int a = n / k;
// 有多少份可以升级成a+1
int b = n % k;
int ans = 1;
for (int i = 0; i < b; i++) {
ans *= a + 1;
}
for (int i = 0; i < k - b; i++) {
ans *= a;
}
return ans;
}
long long power(long long a, long long n, int mod);
// 贪心的解
// 这是最优解
// 但是如果结果很大，让求余数...
int maxValue3(long long n, long long k) {
if (k == 0 || n < k) {
return -1;
}
int mod = 1000000007;
long long a = n / k;
long long b = n % k;
long long part1 = power(a + 1, b, mod);
long long part2 = power(a, k - b, mod);
return (int)((part1 * part2) % mod);
}
// 返回a的n次方，%mod的结果
long long power(long long a, long long n, int mod) {
long long ans = 1;
long long tmp = a;
while (n != 0) {
if ((n & 1) != 0) {
ans = (ans * tmp) % mod;
}
n >>= 1;
tmp = (tmp * tmp) % mod;
}
return ans;
}
int main() {
// 可以自己来用参数实验
int n = 20;
int k = 4;
printf("%d\n", maxValue1(n, k));
printf("%d\n", maxValue2(n, k));
//printf("%d\n", maxValue3(n, k));
return 0;
}
