Question

我正在改变/改进这个递归函数。我的目的是添加一个全局类变量nrOfFails来存储搜索不成功的所有迭代。

我按如下方式调用该函数：

{
    ArrayList<Integer> solutions = new ArrayList<>();
    int[] money1= {2,2,2,5,10,10,20}
    int targe1 = 24
    System.out.print(solutions(money1,target1,solutions))
}

 /**
   * Returns the number of ways of creating specified target value as a sum of money starting with c
   * @param money the set of coins
   * @param c Index of the array
   * @param target the amount to give back
   * @return number of ways
   */
  private static int solutions(int[] money, int c, int target, ArrayList<Integer> s)
  {
    assert money!=null : "array should be initialized";
    assert c>=0&&c<=money.length;
    nrOfFails = 0;

    if(target==0)
    {
      showSolution(s);
      return 1;
    }
    if(target<0)
      return 0;
    if(c>=money.length)
      return 0;
    else
    {
      s.add(money[c]);
      int with = solutions(money, c + 1, target - money[c], s);
      s.remove(s.size()-1);
      int without = solutions(money, c + 1, target,s);
      return with + without;
    }
  }

  private static void showSolution(ArrayList<Integer> s)
  {
    System.out.print(s);
  }

我提出了一种原始的方法来“计算”不成功的迭代，但我想使用递归来解决这个问题。

至于原始解决方案。我试图检查在任何迭代中钱[]的内容是否有一个不包含目标数量的倍数的值，然后我们徒劳地搜索。使用for和counter来检查是否有共同的倍数，如果没有，那么我们搜索是徒劳的。

Answer 1

让我们考虑搜索失败的＆＃34;迭代＆＃34;你想要数。

其中一种情况是，您将负target传递给递归调用（这意味着target - money[c] < 0递归调用中的solutions(money, c + 1, target - money[c], s)。

另一种情况是在达到目标总和之前用完数组元素（即c >= money.length时）。

因此，在这两种情况下，您应该增加nrOfFails计数器。我将它们统一到一个条件中，以缩短代码：

static int nrOfFails = 0;
private static int solutions(int[] money, int c, int target, ArrayList<Integer> s)
{
    assert money != null : "array should be initialized";
    assert c >= 0 && c <= money.length;

    if (target == 0) {
        showSolution(s);
        return 1;
    } else if (target < 0 || c >= money.length) {
        nrOfFails++;
        return 0;
    } else {
        s.add(money[c]);
        int with = solutions(money, c + 1, target - money[c], s);
        s.remove(s.size() - 1);
        int without = solutions(money, c + 1, target, s);
        return with + without;
    }
}

在第一次调用0之前，您必须将静态变量重置为solutions。

请注意，在初始调用递归方法时忘记了c参数。我在这里添加了它。我还添加了nrOfFails的重置和打印：

nrOfFails = 0;
ArrayList<Integer> solutions = new ArrayList<>();
int[] money1= {2,2,2,5,10,10,20};
int target = 24;
System.out.println(solutions(money1,0,target,solutions));
System.out.println ("number of fails = " + nrOfFails);

这会产生以下输出：

[2, 2, 10, 10]
[2, 2, 20]
[2, 2, 10, 10]
[2, 2, 20]
[2, 2, 10, 10]
[2, 2, 20]
6
number of fails = 110

理解这个递归函数

1 个答案: