我有这个问题我希望人们可以指出我正确的方向，因为我甚至不知道从哪里开始。
这是设置，我在SQL Server中有两个表，表A是一个汇总表，表B是一个详细信息表，所以像这样：
Table A
ParentID Total Amount
1 100
2 587
Table B
ParentID ChildID Amount
1 1 8
1 2 7
1 3 18
1 4 93
2 5 500
2 6 82
2 7 5
2 8 10
因此，对于每个ParentID，我需要提出其子金额等于父母总金额的子组合。
因此，对于ParentID 1（100），它将是ChildIDs 2和4（7 + 93），我将忽略ChildID 1和3。
对于ParentID 2，它将是5,6,7的孩子，我会忽略8。
子组合没有固定的大小，可以组合成父级。
所以做一些研究，似乎我需要为每个父母获得所有孩子的权力集。然后从那里我可以总结他们的总金额，看看他们中的任何一个是否等于父母。但是，如果我错了，请纠正我，但如果集合中有N个项目，则电源组将包含2 ^ N个组合。
其中一些父母有750多个孩子，2 ^ 750是非常非常大的一个。我主要是一个.NET / SQL Server人员，但我愿意尝试任何人们认为适合这项工作的技术。
所以有几个问题。
1）我是否应该沿着试图找出每个父母的力量集的道路走下去，还是我吵着错误的树？ 2）这是一个已经被弄清楚的算法吗？我只是在Google上找到一个糟糕的工作？ 3）假设可以做到这一点，解决问题的正确方法是什么？
答案 0 :(得分：1)
问题可以减少到子集问题，这可以简化为简单的背包问题。 有一个动态编程解决方案来解决这个问题： -
W = knapsack capacity = Total Amount of parent.
item weight = item cost = child amount.
maximize profit and if W = profit then there exists a subset else not.
使用kanpsack的DP解决方案解决此问题并通过回溯获得结果。
这是JAVA中的解决方案，也许你可以转换为C＃： -
public class SubSetSum {
static int[][] costs;
public static void calSets(int target,int[] arr) {
costs = new int[arr.length][target+1];
for(int j=0;j<=target;j++) {
if(arr[0]<=j) {
costs[0][j] = arr[0];
}
}
for(int i=1;i<arr.length;i++) {
for(int j=0;j<=target;j++) {
costs[i][j] = costs[i-1][j];
if(arr[i]<=j) {
costs[i][j] = Math.max(costs[i][j],costs[i-1][j-arr[i]]+arr[i]);
}
}
}
System.out.println("total amount: "+costs[arr.length-1][target]);
if(costs[arr.length-1][target]==target) {
System.out.println("Sets :");
printSets(arr,arr.length-1,target,"");
}
else System.out.println("No such Set found");
}
public static void printSets(int[] arr,int n,int w,String result) {
if(w==0) {
System.out.println(result);
return;
}
if(n==0) {
System.out.println(result+","+0);
return;
}
if(costs[n-1][w]==costs[n][w]) {
printSets(arr,n-1,w,new String(result));
}
if(arr[n]<=w&&(costs[n-1][w-arr[n]]+arr[n])==costs[n][w]) {
printSets(arr,n-1,w-arr[n],result+","+n);
}
}
public static void main(String[] args) {
int[] arr = {1,2,3,8,9,7};
calSets(10,arr);
}
}
注意： -
在某些情况下，蛮力比DP更可行，因为DP = O(ParentAmount*totalchildren)的空间和时间复杂度，而蛮力的时间复杂度 = {{ 1}}和空间复杂度 = O(2^n)。您可以根据问题选择。
答案 1 :(得分：0)
一些研究告诉我你可以在N * 2 ^ P中解决这个问题，其中N是孩子的数量，P是存储最大数量所需的比特数。看，比方说，这里： http://en.wikipedia.org/wiki/Subset_sum_problem#Polynomial_time_approximate_algorithm
=============================================
只要每个父母的孩子数量很少，那么编制powerset很好，但请注意N个孩子的powerset是2 ^ n，它增长得非常快。 2 ^ 750绝对大，大约10 ^ 225。
有很多功能可以找到powerset，我主要使用Java工作，我知道Guava中有一个，我认为Apache Commoms Math中也有一个。构建一个powerset并不困难，直观地你可以认为它是一个深度为N的二叉树，其中每个级别都是“我是否包含这个元素是/否”。
我不用c＃编写，而是用伪代码编写
Set<Set<Object>> Powerset(Set<Set<Object>> powerset, Object newItem){
Set<Set<Object>> newSet = powerset.clone();
for (Set<Object> set : newSet){
set.add(newItem)
}
return newSet.addAll(powerset)
}
因此，这需要N个元素的powerset，并返回N + 1个元素的幂集。所以你可以反复调用它来构建从空集开始的powerset。
对于更多的孩子，而不是构建powerset，使用相同的功能，但删除总和超过目标的任何集合。 （显然它是单调增加的，所以一旦超过目标就不能继续。例如，假设Object.hasValue（）返回一个数字，然后执行：
Set<Set<Object>> Powerset(Set<Set<Object>> powerset, Object newItem, int target){
Set<Set<Object>> newSet = powerset.clone();
for (Set<Object> set : newSet){
set.add(newItem)
}
Set<Set<Object>> result = new Set<Set<Object>>();
for(Set<Object> set : newSet){
int sum = 0;
for(Object o : set){
sum += o.hasvalue();
}
if(sum <= target){
result.add(set)
}
}
return result.addAll(powerset);
}
可以进行各种优化（例如，您应该首先添加最大的数字，如果您尽早排除数字，则最快数字。（如果数字大于目标，则只需要将其添加到一组中）如果你先做，那就做2 ^ n-1套。）你也可以这样做，使Set直接携带其组件的总和，从而消除sum循环，你可以通过存储来提高空间复杂度它作为一个树，其元素指向其父元素，并执行DFS，因此您一次只在内存中有一个树分支，并且只保留成功的分支。
答案 2 :(得分：0)
如果有些父母有750个孩子，那么你的时间就会用完。如果你想在太阳烧毁之前得到答案，你应该研究某种并行云计算解决方案。
2^750 = 5922386521
532855740161817506647119
732883018558947359509044
845726112560091729648156
474603305162988578607512
400425457279991804428268
870599332596921062626576
000993556884845161077691
136496092218188572933193
945756793025561702170624
现在，让我们假设我们真的很幸运，就像赢得彩票一样幸运，并且很早就能找到正确的组合。
现在，让我们假设我们拥有可以计算十亿秒的快速计算机。
它会采取像
这样的东西6.332987 * 10^135 years
找到答案。现在，这仍然是一段难以想象的漫长时期。您可以将其视为，
4.52356 * 10^125 ages of the universe.
或更具表现力的是，宇宙的年龄乘以宇宙中的原子数量的时间越长。那是很长一段时间。
这是一些猜想，但我怀疑宇宙中没有足够的材料来制造足够的计算机来平行计算，足以在太阳耗尽燃料之前完成它。 （在现有技术的范围内。）
我建议应该放弃强力集合方法。计算机速度很快，但速度并不快。
答案 3 :(得分：0)
实际上，您的情况并不像2 ^ 750分析所暗示的那样可怕。放弃电源设置解决方案并转而使用动态编程。一个选项可能如下：
public static IEnumerable<int> FindSet(IEnumerable<int> amounts, int target)
{
var results = new Dictionary<int, List<int>>();
results[0] = new List<int>();
foreach(var amount in amounts)
{
for(int i = 0; i <= target; i++)
{
if(!results.ContainsKey(i) || results[i].Contains(amount))
continue;
var combination = new List<int>(results[i]);
combination.Add(amount);
if (i + amount == target)
return combination;
results[i + amount] = combination;
}
}
return null;
}
前提是我们开始说我们知道如何使用空集来达到0的总和。然后，对于我们经历的每个可用金额，并说如果我们知道如何在不使用n的情况下达到amount的总和，那么我们现在也知道如何达到n+amount的总和 - 获取上一个结果并向其添加amount。
从循环中可以看出，它按O（NK）的顺序运行，其中N是集合中的值的数量，K是目标总和。比O（2 ^ N）好多了。
这只是为了给出算法的草图。可能还有足够的性能调整空间。特别是这些列表可以替换为某种节点＆＃34;节点＆＃34;支持树结构的类。
关于Node类的含义草图，如：
public class Node
{
public int Value;
public Node Parent;
public List<int> ToList()
{
if(Parent == null)
{
return new List<int> { Value };
}
var result = Parent.ToList();
result.Add(Value);
return result;
}
}
然后你不必继续复制列表