题目描述
给你一根长度为n的绳子,请把绳子剪成
m
m
m段 (
m
m
m和
n
n
n都是整数,
n
>
1
n>1
n>1并且
m
>
1
m>1
m>1),每段绳子的长度记为
k
[
0
]
,
k
[
1
]
,
.
.
.
,
k
[
m
]
k[0],k[1],...,k[m]
k[0],k[1],...,k[m]。
请问
k
[
0
]
∗
k
[
1
]
∗
.
.
.
∗
k
[
m
]
k[0]*k[1]*...*k[m]
k[0]∗k[1]∗...∗k[m]可能的最大乘积是多少?
例如,当绳子的长度为8时,我们把它剪成长度分别为2,3,3的三段,此时得到的最大乘积是18。
思路一:动态规划
首先定义函数
f
(
n
)
f(n)
f(n)为把长度为
n
n
n的绳子剪成若干段后各段长度乘积的最大值。在剪第一刀时,我们有
n
−
1
n-1
n−1种选择,也就是说第一段绳子的可能长度分别为
1
,
2
,
3.....
,
n
−
1
1,2,3.....,n-1
1,2,3.....,n−1。因此
f
(
n
)
=
m
a
x
(
f
(
i
)
∗
f
(
n
−
i
)
)
f(n)=max(f(i)*f(n-i))
f(n)=max(f(i)∗f(n−i)),其中
0
<
i
<
n
0<i<n
0<i<n。这是一个自上而下的递归公式。由于递归会有大量的不必要的重复计算。一个更好的办法是按照从下而上的顺序计算,也就是说我们先得到
f
(
2
)
,
f
(
3
)
f(2), f(3)
f(2),f(3),再得到
f
(
4
)
,
f
(
5
)
f(4), f(5)
f(4),f(5),直到得到
f
(
n
)
f(n)
f(n)。
当绳子的长度为2的时候,只能剪成长度为1的两段,所以
f
(
2
)
=
1
f(2) = 1
f(2)=1,当
n
=
3
n = 3
n=3时,易得
f
(
3
)
=
2
f(3) = 2
f(3)=2。
class Solution {
public:
int maxProductAfterCutting(int length) {
if(length < 2)
return 0;
if(length == 2)
return 1;
if(length == 3)
return 2;
vector<int> dp(length+1);
dp[0] = 0;
dp[1] = 1;
dp[2] = 2;
dp[3] = 3;
for(int i = 4; i <= length; ++i){
for(int j = 1; j <= i / 2; ++j){
dp[i] = max(dp[i], dp[j] * dp[i-j]);
}
}
return dp[length];
}
};
思路二 贪心
按照以下策略来剪绳子:当
n
≥
5
n≥5
n≥5时,尽可能多剪长度为3的绳子;当剩下的绳子长度为4时,把绳子剪成两段长度为2的绳子。
思路的正确性:首先,当
n
>
5
n>5
n>5时,可以证明
2
(
n
−
2
)
>
n
2(n-2) > n
2(n−2)>n并且
3
(
n
−
3
)
>
n
3(n-3) > n
3(n−3)>n。就是说,当绳子剩下的长度大于或者等于5的时候,就把绳子剪成长度为3或者2的绳子段。
另外,当
n
≥
5
n≥5
n≥5时,
3
(
n
−
3
)
≥
2
(
n
−
2
)
3(n-3) ≥ 2(n-2)
3(n−3)≥2(n−2),因此应尽可能地多剪长度为3的绳子段。当绳子长度为4时,
2
∗
2
>
3
∗
1
2*2 > 3*1
2∗2>3∗1。
class Solution {
public:
int maxProductAfterCutting(int length){
if(length < 2)
return 0;
if(length == 2)
return 1;
if(length == 3)
return 2;
//尽可能多地减去长度为3的绳子段
int timesOfThree = length / 3;
//当绳子剩下的长度为4,应该剪为两个2,因为2*2 > 3*1
if(length - timesOfThree * 3 == 1)
timesOfThree -= 1;
int timesOfTwo = (length - timesOfThree * 3) / 2;
return (int)(pow(3, timesOfThree)) * (int)(pow(2, timesOfTwo));
}
};