有一堆石头,每块石头的重量都是正整数。
每一回合,从中选出任意两块石头,然后将它们一起粉碎。假设石头的重量分别为 x 和 y,且 x <= y。那么粉碎的可能结果如下:
如果 x == y,那么两块石头都会被完全粉碎;
如果 x != y,那么重量为 x 的石头将会完全粉碎,而重量为 y 的石头新重量为 y-x。
最后,最多只会剩下一块石头。返回此石头最小的可能重量。如果没有石头剩下,就返回 0。
示例:
输入:[2,7,4,1,8,1]
输出:1
解释:
组合 2 和 4,得到 2,所以数组转化为 [2,7,1,8,1],
组合 7 和 8,得到 1,所以数组转化为 [2,1,1,1],
组合 2 和 1,得到 1,所以数组转化为 [1,1,1],
组合 1 和 1,得到 0,所以数组转化为 [1],这就是最优值。
提示:
1 <= stones.length <= 30
1 <= stones[i] <= 1000
基本思路:本题可以换种角度思考问题,假设stones={a,b,c},那么碰撞的结果只有,a-b-c,a-c-b,b-a-c,b-c-a,c-a-b,c-b-a,假设再添加一个元素d,仅仅对于a-b-c这种形式,有a+d-b-c,a-b-c-d,d+b+c-a等等形式,不难发现,最后的结果实际上是对每个数组上的元素进行加减法得到的,共有2^(n)中结果,直接计算结果有点大,可以采用bitset来做。
- 根据1的位置,确定结果。以bound=40000为界限,1的范围为[10000,70000],左移k位代表加k,右移k位代表减去k,|代表的是把这两种结果都保存下来,又因为加减具有对称性和要求正结果,故只需要找到bound=40000以后第一个1的位置即可。
对于上述结果,其实可以进一步发现,如果把加法算为一堆,令其结果为x,减法算为一堆,令其结果为y,那么最终结果为abs(x-y),这代表,其实我们可以把问题转换成,把石头分为两堆,使其大小尽量相等,即target=sum/2,问题直接转换成0-1背包问题。
const int capacity = 60002;
const int bound = 30001;
int lastStoneWeightII(vector<int>& stones) {
bitset<60002> rec;
rec[bound] = 1;
for (auto &stone : stones) {
rec = (rec << stone | rec >> stone); //左移k位代表加k,右移k位代表减去k
}
for (int i = 0; i < bound; i++) {
if (rec[bound + i])
return i;
}
return -1;
}
基本思路:动态规划,既可以用上面的思路,也可以采用下面的思路思考问题,以上面的例子[2,7,4,1,8,1]为例:
- 组合2,4:[<4-2>,7,1,81]
- 组合7,8:[<4-2>,<8-7>,1,1]
- 组合2,1: [<4-2-1>,<8-7>,1]
- 组合1,2:[<4-2-1-1>,<8-7>] <===> [<8-7-(4-2-1-1)>] <===> [<(8+2+1+1)-(7+4)>] <===>[<12-11>] <===>[<sum-(sum/2)*2>]
- 上述问题可以转化为分成两堆,8,2,1,1一堆,7和4一堆,结果为两堆结果差的绝对值
总结:对于上述任何问题都可以最终表达为f=x1-x2-x3……-xk=x1-(x2+x3+……+xk)=(s1+s2+……+sr)-(t1+t2+……+tp),注意这里每一个xi都可能是一个复数表达(即有多个石头变换得到),而si和ti都是单个的石头,等价于将其分为两堆,使其尽量平均,g=min(f)=min(sum(s)-sum(t)),等价于求最接近sum/2的堆的大小,故我们可以令target=sum/2,使用0-1背包的思路解决问题。
int lastStoneWeightII(vector<int>& stones) {
int sum=0;
for(auto &it:stones){
sum+=it;
}
int target=sum>>1;
vector<int> dp(target+1,0);
for(auto &it:stones){
for(int j=target;j>=it;j--){
dp[j]=max(dp[j],dp[j-it]+it);
}
}
return sum-2*dp[target];
}