Java 编写一个程序，确定两组数字的和是否相等

例如：

输入：3,6,3 输出：真（因为3+3=6）

输入：3,2,6,4 输出：False（因为任何组合都不会导致相等）

输入：4,7,3,6 输出：真（因为4+6=7+3）

你们能告诉我怎么编码吗？

---

我已经开始编写代码了，但我对如何添加数字并比较它们感到困惑

我将解释一个人如何在不知道神奇词汇（如“划分问题”、“动态规划”等）的情况下处理这些问题，并用它们查阅一些大的答案书（如维基百科）

如果从输入中选取一个尚未使用的最大数字的实例，并将其分配给两个组中的一个组，则您已将问题简化为同一问题的较小实例（广义版本）

一般化的问题是，你能把输入的数字分成两组，这样两组的和之间的差就是一个特殊的非负整数吗

假设我们的输入数字是4,3,2,1，我们需要分成两组，这样两组的总和之差为0

我们将4分配给其中一个组，在这种特殊情况下，哪个组无关紧要

现在我们剩下的输入数字是3，2，1，忽略我们已经处理过的4，我们需要将这三个数字分成两组，这样组和之间的差值是4。（这将平衡我们通过将4分配给其中一个组而创建的两个组之间的差异。）正如所承诺的，这是原始类型问题的一个较小实例

困难在于，有时候，比如5，5，4，3，3（维基百科“分区问题”中的例子），下一个数字需要进入哪个组并不明显。如果你一直跟踪你所做的事情，那么当你发现你最近的尝试不起作用时，你可以回来（“回溯”）尝试另一种方法

5, 5, 4, 3, 3 {} {}
   5, 4, 3, 3 {5} {}
      4, 3, 3 {5} {5}
         3, 3 {5, 4} {5}
            3 {5, 4} {5, 3}
              {5, 4} {5, 3, 3} NO - backtrack
              {5, 4, 3} {5, 3} NO - backtrack
            3 {5, 4, 3} {5}
              {5, 4, 3} {5, 3} NO - already tried - backtrack
              {5, 4, 3, 3} {3} NO - backtrack
         3, 3 {5} {5, 4} NO - symmetric to what we already tried - backtrack
      4, 3, 3 {5, 5} {}
         3, 3 {5, 5} {4}
            3 {5, 5} {4, 3}
              {5, 5} {4, 3, 3} YES

---

我们能很快得到答案吗？好吧，这不是被问到的问题，但是考虑到回溯的复杂性，问这个问题是很自然的。答案是，不，即使我们有史以来最聪明的人为我们工作也不行。没有人能找到一种方法，无论我们给出这种问题的什么实例，它都能保证快速执行。也许我们可以很好地处理这些问题的许多实例，但一般来说，一个做这类事情的程序注定会很慢。

我将解释一个人如何在不知道神奇的词汇（如“划分问题”、“动态规划”等）的情况下处理这类问题，并用这些词汇查阅一些答案的大书（比如维基百科）

如果从输入中选取一个尚未使用的最大数字的实例，并将其分配给两个组中的一个组，则您已将问题简化为同一问题的较小实例（广义版本）

一般化的问题是，你能把输入的数字分成两组，这样两组的和之间的差就是一个特殊的非负整数吗

假设我们的输入数字是4,3,2,1，我们需要分成两组，这样两组的总和之差为0

我们将4分配给其中一个组，在这种特殊情况下，哪个组无关紧要

现在我们剩下的输入数字是3，2，1，忽略我们已经处理过的4，我们需要将这三个数字分成两组，这样组和之间的差值是4。（这将平衡我们通过将4分配给其中一个组而创建的两个组之间的差值。）正如所承诺的，这是原始类型问题的一个较小实例

困难在于，有时，例如5、5、4、3、3（维基百科“分区问题”中的例子），不清楚下一个数字需要进入哪个组。如果你跟踪你所做的事情，那么当你发现你最近的尝试不起作用时，你可以回来（“回溯”）并尝试另一种方法

5, 5, 4, 3, 3 {} {}
   5, 4, 3, 3 {5} {}
      4, 3, 3 {5} {5}
         3, 3 {5, 4} {5}
            3 {5, 4} {5, 3}
              {5, 4} {5, 3, 3} NO - backtrack
              {5, 4, 3} {5, 3} NO - backtrack
            3 {5, 4, 3} {5}
              {5, 4, 3} {5, 3} NO - already tried - backtrack
              {5, 4, 3, 3} {3} NO - backtrack
         3, 3 {5} {5, 4} NO - symmetric to what we already tried - backtrack
      4, 3, 3 {5, 5} {}
         3, 3 {5, 5} {4}
            3 {5, 5} {4, 3}
              {5, 5} {4, 3, 3} YES

---

我们能很快得到答案吗？好吧，这不是被问到的问题，但考虑到回溯的复杂性，问是很自然的。答案是，不，即使我们有史以来最聪明的人为我们工作，也不会。没有人找到一种能保证快速执行的方法无论我们给出这类问题的哪一个实例。也许我们可以很好地处理这些问题的许多实例，但是一般来说，一个做这类事情的程序注定会很慢。

这是划分问题，它是NP完全的。尽管如此，你可以使用一个动态规划解决方案。See维基百科的文章

---

这是一个划分问题，它是NP完全问题。尽管如此，还是有一个动态编程解决方案可以使用。请参阅Wikipedia文章

公共级Weirdie{
专用布尔计算（int[]数组）{
布尔匹配=假；
列表=新的ArrayList（）；
int length=array.length；
对于（int i=0；i
公共类Weirdie{
专用布尔计算（int[]数组）{
布尔匹配=假；
列表=新的ArrayList（）；
int length=array.length；
对于（int i=0；i来确定一个数组可以分成两个相等的求和数组，我们还可以找到一个子集，它有整个数组的一半和

例如：输入：4、7、3、6

我们应该找到一个子集，它的和=10，这是一个简单的DP prob

公共静态布尔IsubSet（int[]a，int-sum，int-n）{

if（总和=0）
返回true；
如果（n确定一个数组可以分成两个相等和的数组，我们还可以找到一个子集，它有整个数组和的一半

例如：输入：4、7、3、6

我们应该找一个
  if(sum == 0)
    return true;
  if(n<0)
    return false;
 return isSubset(a, sum-a[n], n-1) || isSubset(a, sum, n-1);
}

int[] numbersArray = new int[10];
int sum = 0;

for(int j = 0; j < numbersArray.lenght;j++) // sum
   sum += numbersArray[j];



for(int i = 0; i < numbersArray.lenght;i++)
{
   int numChecking =  numbersArray[i]; // right half .. 

   if((sum-numChecking) == numChecking)
     return true;

}
return false;