Question

我正在尝试创建一个代码，在子集中添加所有整数，看看它们是否加起来为零。这是我到目前为止所得到的

  /**
   * Solve the subset sum problem for a set of integer values.
   * 
   * @param t
   *          a set of integer values
   * @return <code>true</code> if there exists a non-empty subset of
   *         <code>t</code> whose elements sum to zero.
   */
  public static boolean subsetSum(Set<Integer> t) {
    return subsetSum(new ArrayList<Integer>(t), null);
  }

  /**
   * Computes the sum of two Integers where one or both references are null. If
   * both references are null then the result is null; otherwise the result is
   * an integer equal to <code>a + b</code> where null references are treated as
   * being equal to zero.
   * 
   * @param a
   * @param b
   * @return the sum of <code>a</code> and <code>b</code>
   */
  private static Integer add(Integer a, Integer b) {
    if (a == null && b == null) {
      return null;
    } else if (a == null) {
      return b;
    } else if (b == null) {
      return a;
    }
    return a + b;
  }

  /**
   * Recursive solution for the subset sum problem.
   * 
   * <p>
   * <code>currentSum</code> holds the value of the subset under consideration;
   * it should be <code>null</code> if the current subset is empty.
   * 
   * @param t
   *          a list containing unique integer values (a set of integers)
   * @param currentSum
   *          the current subset sum so far
   * @return <code>true</code> if there exists a subset of <code>t</code> such
   *         that the sum of the elements in the subset and
   *         <code>currentSum</code> equals zero.
   */

******** THIS IS THE PART I HAD TO EDIT *************
  private static boolean subsetSum(List<Integer> t, Integer currentSum) {
      currentSum = 0;
      for (int i = 0; i < t.size(); i++) {
          currentSum = currentSum + (Integer)(t.get(i));
      }
      if (Lab9W.add(currentSum, t.get(0)) == 0) {
          return true;
      }
      else if (Lab9W.add(currentSum, t.get(1)) == 0) {
          return true;
      } else if (Lab9W.add(-t.get(0),t.get(0)) == 0) {
          return true;
      }
      else {
          return false;
      }

  }

}

这里有关于制作此代码的提示：

首先考虑集合的第一个元素是否有一个子集和第一个和其余部分为零？是否有一个零子集没有第一个和其余的一组？如果2或3中的任何一个为真然后返回true，否则返回false

任何帮助请我整天都在努力，我无法让它在我的生活中工作，在递归中我无法弄清楚如何调用该方法。

所以我的问题是如何在递归中编写此方法？整个方法应该添加子集的总和，看它们是否等于零。

Answer 1

好的，你可以为递归

做这样的事情

 private static boolean subsetSum(List<Integer> t, Integer sizeOfArray,Integer currentSum){

      if(sizeOfArray == -1)
      {
        if (Lab9W.add(currentSum, t.get(0)) == 0)
        {
            return true;
        }
        else if (Lab9W.add(currentSum, t.get(1)) == 0)
        {
            return true;
        }
        else if (Lab9W.add(-t.get(0),t.get(0)) == 0) 
        {
            return true;
        }
        else
        {
            return false;
        }

       return subsetSum(t,sizeOfArray - 1,currentSum + t.get(sizeOfArray));
 }

我输入它没有检查，但那是一些概念。以这个想法玩耍

第一个电话应该是这样的

subsetSum(array,array.size()-1,0); // i dont know if its array.size()-1 // it is...

// 好的，你也可以这样做......

    // return sum of array
    public Integer subsetSum(List<Integer> t, Integer sizeOfArray) 
    {
        if(sizeOfArray == 0)
            return t.get(0);
        return subsetSum(t, sizeOfArray - 1) + t.get(sizeOfArray);
    }

//现在你可以做到这一点

     public boolean check(List<Integer> t)
{
        Integer currentSum = subsetSum(t,t.size()-1); 

        if (Lab9W.add(currentSum, t.get(0)) == 0)
            {
                return true;
            }
            else if (Lab9W.add(currentSum, t.get(1)) == 0)
            {
                return true;
            }
            else if (Lab9W.add(-t.get(0),t.get(0)) == 0) 
            {
                return true;
            }
            else
            {
                return false;
            }
}

Answer 2

// return sum of array
    public Integer subsetSum(List<Integer> t, Integer sizeOfArray) 
    {
        if(sizeOfArray == 0)
            return t.get(0);
        return subsetSum(t, sizeOfArray - 1) + t.get(sizeOfArray);
    }
//now you can do this somewere

     public boolean check(List<Integer> t)
{
        Integer currentSum = subsetSum(t,t.size()-1); 

        if (Lab9W.add(currentSum, t.get(0)) == 0) // do something with these if statements
            {
                return true;
            }
            else if (Lab9W.add(currentSum, t.get(1)) == 0)
            {
                return true;
            }
            else if (Lab9W.add(-t.get(0),t.get(0)) == 0) 
            {
                return true;
            }
            else
            {
                return false;
            }
}

Answer 3

它与这个问题相似吗？你怎么解决它？

给定一组整块重量宝石，可以将它们分成两组重量完全相等。写一个递归函数

public static boolean canSplit（int [] stones，int left，int right）

其中，给定一组权重宝石意味着功能可分为两组）左对 - （这样整个团队都值得。如有必要，请使用函数subArray。培训：查看第一块石头并递归确定哪个组与之相关联。

为子集和应用递归

3 个答案: