动态规划7-正整数分组

将一堆正整数分为2组,要求2组的和相差最小。
例如:1 2 3 4 5,将1 2 4分为1组,3 5分为1组,两组和相差1,是所有方案中相差最少的。 整数个数n<=100,所有整数的和<=10000

初看题目,第一想到贪心。怎么贪?排序,每次把数放到“最有利”的一边,最有利指的是每次都把数放到使得结果差值尽可能小的那边。这样的方法显然前两个数只能分到不同的组了,这是不对的。比如{1,2,3},这种贪心会把1和2分开,显然得不到最优解。 最优解是{1,2}在一起,3自己在一组。

是不是如果找到一个数和其他几个数的和相等,就一定先把这个数和另外那几个数分开放?因为这样放差值仍然是0。 不是的,看看{1,2,3,7},我们不能把{1,2}和3分开。而是应该{1,2,3}一起放到一组才最优。

没招了。万能的枚举啊,我们把每个数要么放第一组,要么放第二组,所以一共2^n种情况,取一种差值最小的就好了。这种方法固然可以,但是实际复杂度太高了。

继续枚举的思路,我们为什么要尝试那么多情况呢?因为我们在决定第i个数放到哪组的时候,前面的所有2^i-1种情况可能产生的两组数可能有不同的差值。对!关键因素不在于前面的2^i-1种情况,而在于差值的情况。

那么,我们用bool f(i,j)表示前i个数分成两组,差值是j的情况是否可能出现。

考虑一下f(i,j)的含义我们把第i个数放到了某一组,差值变成了j (j >= 0)
第i个数放入哪个组有两种可能:

(1) 第i个数放入原来和比较大的组,那么放入第i个数的时候差值变成了j,拉大了差值,所以原来的差值是j - ai  (j >=ai),那么如果f(i-1, j - ai)是true,则f(i,j)也为true
(2) 第i个数放入原来和比较小的组,那么放入第i个数的时候又有两种情况:
(2.1) 原来相差很大了,已经是j + ai了,加入ai缩小了差距,于是意味着如果f(i- 1, j + ai) = true,则f(i,j)是true。
(2.2) 原来相差不大, 加入ai之后,和较小的组变成了和较大的组。那么原来大的比小的和大ai – j (ai >=j), 于是意味着如果f(i – 1, ai – j)是true,则f(i,j)为true。
(1)和(2.2)可以统一成若 f(i-1, |j - ai|) = true,则f(i,j) = true

总结前面说的

f(i,j) = f(i – 1, |j - ai|) || f(i – 1, j + ai)

这里我们巧妙地运用绝对值和逻辑或运算。

继续考虑,初值是什么? f(0,0) = true。没有数的时候,差值只能是0,其余f(0,x > 0) = false。
第二维有多大? 第二维大小可以达到所有数的所以时间复杂度是O(n * sum),空间复杂度也是 O(n * sum),这里sum是所有数的总和。

最终答案是什么?

根据定义,最终答案是min{x| f(n,x) = true}
空间优化?  f(i, *)只与f(i – 1, *)有关,所以两行,达到递推的目的。
上面的解法看起来不是动态规划,因为动态规划的式子看起来应该是个“优化”问题,也就是应该有max或者min的样子,而不是一个bool值。

那么我们有别的方法么?
考虑最后分组情况,如果所有数的和为sum, 较小和的那组数一定不超过 [sum / 2]。我们的目标是使得和较小组的总和尽可能大。

我们的目标是从这n个数中选出一些数,这些数的总和不超过[sum / 2]且总和尽可能大。

那我们重新定义int f(i,j)表示从前i个数中选出的数,总和不超过j的时候能得到的最大的和。

则如果不选择ai    f(i-1,j) = f(i,j)
如果选择ai,则f(i,j) = f(i, j - ai)    j >=  ai

第二维大小是[sum / 2]
初值是f(0, x) = 0  注意含义是总和“不超过”x的时候的最大值。
递推式是

那么最终答案是什么? 根据定义,应该是f(n, [sum / 2])。

时间复杂度和空间复杂度依然是O(n * [sum / 2]) ,同样可以优化掉一维的空间复杂度。

综上所述,两种方法的时间复杂度都是O(n * sum)级别的,通常sum不是很大,比如说本题sum不超过10000,所以从实际角度上讲,这个复杂度比O(2n)强多了。

再顺带说一下如果要求出一组最优解的具体分配方案,怎么做?

别忘了,动态规划问题,求具体方案的惯用方法就是记录当前f(i,j)是由之前哪个状态得到的,然后一步一步小心谨慎地回退到起点,就像我们在搜索问题中记录之前地节点恢复出路径一样。

最后,我们来提供输入输出数据,由你来写一段程序,实现这个算法,只有写出了正确的程序,才能继续后面的课程。

输入

第1行:一个数N,N为正整数的数量。
第2 - N+1行,N个正整数。
(N <= 100, 所有正整数的和 <= 10000)

输出

输出这个最小差

输入示例

5
1
2
3
4
5

输出示例

1
 1 #正整数分组
 2 n=int(input())
 3 a=[0]
 4 f=[0]
 5 sum=0
 6 for i in range(n):
 7     x=int(input())
 8     a.append(x)
 9     f.append(0)
10     sum+=x
11 k=int(sum / 2)
12 for i in range(k):
13     f.append(0)
14 for i in range(1,n+1):
15     for j in range(k,a[i]-1,-1):
16         f[j]=max(f[j],f[j-a[i]]+a[i])
17 print(sum-2*f[k])        
时间: 2024-10-24 19:11:27

动态规划7-正整数分组的相关文章

动态规划&amp;数塔取数&amp;矩阵取数&amp;背包问题&amp;最大子段和&amp;正整数分组

动态规划(dynamic programming)是运筹学的一个分支,是求解决策过程(decision process)最优化的数学方法.在面试笔试中动态规划也是经常作为考题出现,其中较为简单的DP题目我们应该有百分之百的把握顺利解决才可以. 一.动态规划定义动态规划实际上是一类题目的总称,并不是指某个固定的算法.动态规划的意义就是通过采用递推(或者分而治之)的策略,通过解决大问题的子问题从而解决整体的做法.动态规划的核心思想是巧妙地将问题拆分成多个子问题,通过计算子问题而得到整体问题的解.而子

【动态规划】数字分组I

[动态规划]数字分组I 时间限制: 1 Sec  内存限制: 64 MB提交: 10  解决: 6[提交][状态][讨论版] 题目描述 给出一堆魔法石的重量,问如何分成两堆,使得它们质量和之差最小,求出这个最小值. 输入 第一行一个数n (n ≤30). 接下来n行,每行一个正整数.(每个数≤100000) 输出 一个整数表示两组数字和的最小差. 样例输入 5 1 2 3 4 5 样例输出 1 将问题转化为求背包容量为所有数总和一半的背包问题 #include <iostream> #incl

1007 正整数分组 1010 只包含因子2 3 5的数 1014 X^2 Mod P 1024 矩阵中不重复的元素 1031 骨牌覆盖

1007 正整数分组 将一堆正整数分为2组,要求2组的和相差最小. 例如:1 2 3 4 5,将1 2 4分为1组,3 5分为1组,两组和相差1,是所有方案中相差最少的. Input 第1行:一个数N,N为正整数的数量. 第2 - N+1行,N个正整数. (N <= 100, 所有正整数的和 <= 10000) Output 输出这个最小差 Input示例 5 1 2 3 4 5 Output示例 1这题不就是小李打怪兽吗,不知道谁模仿谁,呵呵,刚还是我编的题里的,dp,证明一下(要证明什么自

51 Nod 1007 正整数分组【类01背包】

1007 正整数分组 基准时间限制:1 秒 空间限制:131072 KB 分值: 10 难度:2级算法题 将一堆正整数分为2组,要求2组的和相差最小. 例如:1 2 3 4 5,将1 2 4分为1组,3 5分为1组,两组和相差1,是所有方案中相差最少的. Input 第1行:一个数N,N为正整数的数量. 第2 - N+1行,N个正整数. (N <= 100, 所有正整数的和 <= 10000) Output 输出这个最小差 Input示例 5 1 2 3 4 5 Output示例 1 题目链接

正整数分组(动态规划,但我用的是枚举)

个人心得:这题其实是一个运用动态规划的题目,将n个整数放在俩个背包里,平均下来就是sum/2,此时找到放在背包中最大的就可以了, 此时相减必然是最小的差.而我根据动态规划一步一步得到最优解的思想,从第一个开始枚举,到第n个数会有2^n个数据太大了,n可取100, 听说n=32,就能买下整个拉斯维加斯了.所以我用了stack和set就排重,本来以为会超时,但没想到过了. 题目: 将一堆正整数分为2组,要求2组的和相差最小. 例如:1 2 3 4 5,将1 2 4分为1组,3 5分为1组,两组和相差

动规讲解基础讲解八——正整数分组

将一堆正整数分为2组,要求2组的和相差最小.例如:1 2 3 4 5,将1 2 4分为1组,3 5分为1组,两组和相差1,是所有方案中相差最少的. 整数个数n<=100,所有整数的和<=10000 初看题目,第一想到贪心.怎么贪?排序,每次把数放到“最有利”的一边,最有利指的是每次都把数放到使得结果差值尽可能小的那边.这样的方法显然前两个数只能分到不同的组了,这是不对的.比如{1,2,3},这种贪心会把1和2分开,显然得不到最优解. 最优解是{1,2}在一起,3自己在一组. 是不是如果找到一个

(DP)51NOD 1007正整数分组

将一堆正整数分为2组,要求2组的和相差最小. 例如:1 2 3 4 5,将1 2 4分为1组,3 5分为1组,两组和相差1,是所有方案中相差最少的. 输入 第1行:一个数N,N为正整数的数量. 第2 - N+1行,N个正整数. (N <= 100, 所有正整数的和 <= 10000) 输出 输出这个最小差 输入样例 5 1 2 3 4 5 输出样例 1解: 1 #include <stdio.h> 2 #include<string.h> 3 int dp[10005]

1007 正整数分组

0_1背包问题的变形,这是第一次的错解:DP时把每个物品体积设置为1,导致漏了一些结果. #include<iostream> #include<algorithm> #include<cstdio> #include<iomanip> #include<cmath> #include<vector> #include<string> using namespace std; typedef long long LL; #

正整数分组

1 #include <iostream> 2 #include <cstring> 3 #include <algorithm> 4 #include <cmath> 5 #include <cstdio> 6 #define _xx ios_base::sync_with_stdio(0);cin.tie(0); 7 using namespace std; 8 typedef long long ll; 9 int dp[10005], a