Question

我一直试图找出这个问题，但无济于事。我有两个输入数组：a [n]和b [n-1]。我想要做的是输出数组的排列＆＃34; a＆＃34;这样，部分和不等于数组中的任何元素＆＃34; b＆＃34;。我试着通过一个例子说明这一点：

a = {1,3,7}

b = {4,8}

因此，在这种情况下，排列{1,3,7}不会起作用，因为我们有部分总和：

1,1 + 3 = 4（这是阵列b的一部分），1 + 3 + 7 = 11.

一个好的排列将是{3,7,1}，因为我们有部分总和：

3,3 + 7 = 10,3 + 7 + 1 = 11（结果不在数组b中）。

我尝试过一种动态编程方法（主要是子集求和问题），但在这种情况下似乎没有用。有没有人知道如何处理这个问题？

Answer 1

我建议的算法是递归的，我也有一个可能有用的代码示例。我们的想法是反过来：

首先看看数组a的总和是否没有出现在数组b中（如果是，我们就在那里停止）。

一旦我们清除了总和检查，我们需要确定元素的顺序。我们从最后开始，为最后一个位置选择候选i，看看我们是否可以为n-1数组a重复此过程，我们从数组中删除了候选者。如果我们这样做，我们将候选i添加到返回数组的结束位置 - 并返回该数组。

递归步骤是：

给定一个数组，检查它是否只包含一个元素。如果是，检查元素是否存在于禁用和数组中，如果是，则返回null。如果不是，则按原样返回具有单个元素的数组。 （结束案例）
给定具有多个元素的数组：

2.1。检查其对禁止的sum数组的总和。如果它存在，则返回null。如果没有，则迭代数组，并为每个元素i递归调用该方法，不带候选i的数组。

2.2。如果递归调用带回null - 继续迭代。

2.3。如果它带回一个数组，将元素i附加到数组的末尾并返回它。

下面的代码显示了Java中的算法。我试着保持简单。

public static boolean contains(int[] arr, int val) {

    for (int i : arr) {
      if (i == val) {
        return true;
      }
    }
    return false;
  }

  public static int sum(int[] arr) {

    int sum = 0;
    for (int i : arr) {
      sum += i;
    }
    return sum;
  }

  public static int[] removeElem(int index, int[] arr) {

    int[] retArr = new int[arr.length - 1];
    for (int i = 0; i < index; i++) {
      retArr[i] = arr[i];
    }
    for (int i = index + 1; i < arr.length; i++) {
      retArr[i - 1] = arr[i];
    }
    return retArr;
  }

  public static int[] getArr(int[] arr, int[] forbidden) {

    if (arr.length == 1) {
      if (!contains(forbidden, arr[0]))
        return arr;
      else
        return null;
    }
    else {
      if (contains(forbidden, sum(arr))) {
        return null;
      }
      else {
        for (int i = 0; i < arr.length; i++) {
          int[] retArr = getArr(removeElem(i, arr), forbidden);
          if (retArr != null) {
            int[] newArr = new int[arr.length];
            for (int j = 0; j < retArr.length; j++) {
              newArr[j] = retArr[j];
            }
            newArr[newArr.length - 1] = arr[i];
            return newArr;
          }
        }
      }
    }
    return null;
  }

  public static void main(String[] args) throws IOException {

    int[] a = { 1, 3, 7, 9 };
    int[] b = { 4, 19, 16 };

    System.out.println("input array a: " + Arrays.toString(a));
    System.out.println("forbidden sum array b: " + Arrays.toString(b));
    System.out.println(Arrays.toString(getArr(a, b)));
  }

输出：

input array a: [1, 3, 7, 9]
forbidden sum array b: [4, 19, 16]
[9, 1, 7, 3]

更多例子：

input array a: [1, 3, 7, 9]
forbidden sum array b: [4, 19, 8]
[9, 7, 1, 3]

input array a: [1, 3, 7, 9]
forbidden sum array b: [4, 10, 8]
[9, 7, 3, 1]

input array a: [1, 3, 7, 9]
forbidden sum array b: [4, 10, 20]
null 
(for impossible forbidden sum)

部分和永远不会达到给定值的整数序列的置换

1 个答案: