Javascript 基于bacctracking的子集和

我尝试使用回溯解决以下问题：

假设给你一个数字N，你必须找到 用不同的方法把它写成1，3和4的和

以下是我的尝试：

const backtrack = (array, index, result = [], sum) => {
  if (index >= array.length || sum < 0) {
    return 0;
  }
  if (sum === 0) {
    console.log(result);
    return 1;
  }

  return (
    backtrack(array, index, result.concat(array[index]), sum - array[index]) +
    backtrack(array, index + 1, result, sum)
  );
};

输出

[ 1, 1, 1, 1, 1 ]
[ 1, 1, 3 ]
[ 1, 4 ]
3

正如您所看到的，输出中只有一半的组合数

缺少的组合是：

[ 1, 3, 1 ]
[ 3,1,1]
[ 4, 1 ]

我可以解释为什么会出现这种情况，因为调用我的右子树时使用了

回溯（数组、索引+1、结果、和）

它查找索引大于当前索引的元素。有没有人能给我一些提示，说明我需要做哪些更改才能获得所需的输出？

试试以下方法：

backtrack = (array, index, result = [], remainig) => {
  if (index >= array.length || remainig < 0) {
    return 0;
  }
  if (remainig === 0) {
    console.log(result);
    return 1;
  }
  var sum = 0;
  for (var ind = 0; ind < array.length; ind++) {
    const curr = array[ind];
    sum += backtrack(array, 0, result.concat(curr), remainig - curr);
  }
  return sum;
};

backtrack=（数组、索引、结果=[]，剩余）=>{
如果（索引>=array.length | | remaining<0）{
返回0；
}
如果（剩余值===0）{
控制台日志（结果）；
返回1；
}
var总和=0；
对于（var ind=0；ind

定义结果列表的第一个元素时，必须遍历整个数组

backtrack = (array, index, result = [], remainig) => {
  if (index >= array.length || remainig < 0) {
    return 0;
  }
  if (remainig === 0) {
    console.log(result);
    return 1;
  }
  var sum = 0;
  for (var ind = 0; ind < array.length; ind++) {
    const curr = array[ind];
    sum += backtrack(array, 0, result.concat(curr), remainig - curr);
  }
  return sum;
};