我正在研究子集求和问题,需要打印最接近该值的子集和,如果相等则只打印该值。只有正整数
如果存在多个与该值同等接近的子集和,则
value = 10,subsetSum1 = 9,subsetSum2 = 11
打印小于该值的总和。
因此,控制台应用程序可以完美地找到相等的子集和,但是如何打印出最接近该值的子集和。
class Program
{
static int[] elements;
static int value;
static bool solution = false;
static void Main()
{
value = 10000;
Console.WriteLine("How many numbers ?");
int elementsQty = int.Parse(Console.ReadLine());
elements = new int[elementsQty];
for (int i = 0; i < elementsQty; i++)
{
elements[i] = int.Parse(Console.ReadLine());
}
Console.WriteLine("\nOutput:");
List<int> subset = new List<int>();
GetSubset(0, subset);
if (!solution)
Console.WriteLine("No match");
Console.ReadLine();
}
static void GetSubset(int index, List<int> myElements)
{
if (myElements.Sum() == value && myElements.Count > 0)
{
Console.WriteLine(" {0} = {1}", string.Join(" + ", myElements), value);
solution = true;
}
for (int i = index; i < elements.Length; i++)
{
myElements.Add(elements[i]);
GetSubset(i + 1, myElements);
myElements.RemoveAt(myElements.Count - 1);
}
}
}
答案 0 :(得分:3)
您当前的解决方案使用回溯。这种方法的问题在于时间复杂度呈指数级增长。哪个不好:从您输入合理数量的元素(如100+)开始,您的程序就注定了。
鉴于您的整数列表都是(严格)正数,更好的方法是使用动态编程。
我们的想法是,如果您搜索总和 K ,则定义最多 2 K + 1 列表元素的内存 。最初所有内存元素都是无效的null
,除了元素索引0
,您存储空集合。
所以最初的记忆看起来像是:
7 -> _
6 -> _
5 -> _
4 -> _
3 -> _
2 -> _
1 -> _
0 -> []
如果b=8
(我们将在此答案的其余部分使用b=8
,但它当然只是一个示例)。
_
没有(null
指针),[]
是一个空集合(无论是什么类型的集合)。
现在,对于给定数字集中的每个元素,执行以下任务。你迭代在内存中的所有有效(不是null
)集合。对于每个集合,您“升级”该集合:进行复制,将元素添加到集合中,并使用新总和将其存储到索引中。如果已经存在具有该总和的集合,则您不做任何事情。这种迭代可以如下实现:
for(int s = b-xi-1; s >= 0; s--) {
if(cols[s+xi] == null && cols[s] != null) {
List<int> cln = new List<int>(cols[s]);
cln.Add(xi);
cols[s+xi] = cln;
}
}
xi
我们希望添加的元素。因此,if
语句检查具有总和s
的集合是否有效(不是null
)以及我们是否必须创建新集合:具有结果总和的集合是否尚不存在。 for
循环设置边界:将集合升级为边界是没有用的:因此s+xi
和s
都必须是有效边界。这意味着s
的范围从0
(包含)到b-xi-1
(包含)。我们必须向后迭代,因为否则我们可能会再次添加元素xi
。
的确,以第一个元素为2
为例,现在我们开始从0
到8-2-1=5
进行迭代(错误)。现在这意味着如果s=0
,我们“升级”空集合,所以现在内存看起来像:
7 -> _
6 -> _
5 -> _
4 -> _
3 -> _
2 -> [2]
1 -> _
0 -> []
([2]
是一个2
)的集合,for
循环的下一次迭代s=1
,我们看不到存在第一个的集合,所以我们继续,但现在s=2
我们刚刚构建了这样的集合。关键是我们的算法没有做任何书签,因此会再加2次导致:
7 -> _
6 -> _
5 -> _
4 -> [2,2]
3 -> _
2 -> [2]
1 -> _
0 -> []
现在可以做两件事:为迭代构建哪些集合做书签,但这需要额外的工作,或者可以从高到低迭代。由于所有整数xi
都保证是正数,因此我们知道我们无法“升级”向下集合中的集合。如果我们以正确的方式执行整个迭代,之后内存看起来像:
7 -> _
6 -> _
5 -> _
4 -> _
3 -> _
2 -> [2]
1 -> _
0 -> []
如果下一个元素是1
,则内存如下:
7 -> _
6 -> _
5 -> _
4 -> _
3 -> [2,1]
2 -> [2]
1 -> [1]
0 -> []
现在给定下一个元素是3
,我们终于看到了动态编程的强大功能:
7 -> _
6 -> [2,1,3]
5 -> [2,3]
4 -> [1,3]
3 -> [2,1]
2 -> [2]
1 -> [1]
0 -> []
您注意到我们没有为3
构建[3]
的集合,因为已经存在此类集合。这可能看起来不那么令人印象深刻。但是,所有源自[2,1]
的集合现在都不会与[3]
重复,如果使用回溯算法就会出现这种情况。
对每个元素执行此操作后,每个索引的内存要么是创建具有与索引对应的总和的子集的方式,要么是null
如果不能构造此类子集。现在,您只需查看构造的集合,然后选择最接近 K 的集合。我们知道这样的集合最多不同于 K ,因为空集合的总和为零,因此不同 K 。
可以使用此算法讲述整个故事:
static List<int> GetSubset(int value, IEnumerable<int> xs) {
int b = 2*value;
List<int>[] cols = new List<int>[b];
cols[0] = new List<int>();
foreach(int xi in xs) {
for(int s = b-xi-1; s >= 0; s--) {
if(cols[s+xi] == null && cols[s] != null) {
List<int> cln = new List<int>(cols[s]);
cln.Add(xi);
cols[s+xi] = cln;
}
}
}
for(int d = 0; d < value; d++) {
if(cols[value-d] != null) {
return cols[value-d];
} else if(cols[value+d] != null) {
return cols[value+d];
}
}
return cols[0];
}
List<T>
方法不是最有效的方法:您可以使用 head-tail 列表方法(但遗憾的是,.NET库似乎缺少此方法)。
演示(使用csharp
交互式shell):
$ csharp
Mono C# Shell, type "help;" for help
Enter statements below.
csharp> public class Foo {
>
> public static List<int> GetSubset(int value, IEnumerable<int> xs) {
> int b = 2*value;
> List<int>[] cols = new List<int>[b];
> cols[0] = new List<int>();
> foreach(int xi in xs) {
> for(int s = b-xi-1; s >= 0; s--) {
> if(cols[s+xi] == null && cols[s] != null) {
> List<int> cln = new List<int>(cols[s]);
> cln.Add(xi);
> cols[s+xi] = cln;
> }
> }
> }
> for(int d = 0; d < value; d++) {
> if(cols[value-d] != null) {
> return cols[value-d];
> } else if(cols[value+d] != null) {
> return cols[value+d];
> }
> }
> return cols[0];
> }
> }
csharp>
csharp> int[] items = new int[] {2,3,5,7};
csharp> Foo.GetSubset(8,items);
{ 3, 5 }
csharp> Foo.GetSubset(7,items);
{ 2, 5 }
csharp> Foo.GetSubset(9,items);
{ 2, 7 }
csharp> Foo.GetSubset(6,items);
{ 2, 3 }
csharp> Foo.GetSubset(10,items);
{ 2, 3, 5 }
csharp> Foo.GetSubset(11,items);
{ 2, 3, 5 }
正如您所看到的,6
无法使用这些整数形成,但可以提出一个总计为5
的集合。
这种方法的一个优点是你只需要进行一次搜索:你可以多次调用你的方法,首先搜索值 K ,然后 K + 1 ,然后 K-1 等。但问题是这会导致计算成本高昂的方法。