Question

我正在努力应对《代码大战》中的“最佳旅行”

https://www.codewars.com/kata/best-travel

总的来说，我对如何解决问题有一个策略，但是我确实在努力解决一个具体挑战...

这是要访问的城镇k的可能组合。

我有一个策略来计算他们可能选择的所有可能的城镇，它是一个深至K的嵌套数组。因此，如果他们计划访问3个城镇，则这是三个嵌套的循环... 4个城镇，4个嵌套循环等...

为了确保通用概念起作用，我对三个嵌套循环和一个对四个嵌套for循环进行了硬编码。

那些工作...

但是我的问题是如何超越硬编码的嵌套循环进入具有k个嵌套4个循环的动态函数。

我以前从未想过递归嵌套循环的概念，因此在这里可以读到它。

Trying to convert nested loop to recursive function

我认为这是一种策略的总体思路，但是我所有配置这种递归嵌套循环的尝试都是徒劳的，似乎远远超出了我目前的理解。

您能想到一种实现此目标的方法吗？

如果您有替代策略而不是递归嵌套循环，可以解释一下这个概念吗？除此之外，我想不出任何合适的主意。

非常感谢您

function rdc(arr: number[]) {
  return arr.reduce((acc, cur) => {
    return acc + cur;
  })
}
function fourLayersDeep(arr: number[]) {
  let output: any[] = [];
  for (let i = 0; i <= arr.length - 4; i++) {
    for (let j = i + 1; j <= arr.length - 3; j++) {
      for (let k = j +1; k <= arr.length -2; k ++) {
        for (let l = k + 1; l <= arr.length -1; l ++){
          let temp = [arr[i], arr[j], arr[k], arr[l]];
          output.push(temp);
        }
      }
    }
  }
  return output;
}
function threeLayersDeep(arr: number[]) {
  let output: number[][] = [];
  for (let i = 0; i <= arr.length - 3; i++) {
    for (let j = i + 1; j <= arr.length - 2; j++) {
      for (let k = j + 1; k <= arr.length - 1; k++) {
        let temp = [arr[i], arr[j], arr[k]];
        output.push(temp);
      }
    }
  }
  return output;
}

function chooseBestSum(t: number, k: number, ls: number[]): number | null {
  let townCombos;
  if (k === 4){
    townCombos = fourLayersDeep(ls);
  }
  else {
    townCombos = threeLayersDeep(ls);
  }

  let townComboSorted = townCombos.sort((a, b) => rdc(b) - rdc(a));
  for (let candidate of townComboSorted) {
    //@ts-ignore
    if (rdc(candidate) <= t) {
      return rdc(candidate);
    }
  }
  return null;
}
console.log(chooseBestSum(331, 4,[ 91, 74, 73, 85, 73, 81, 87 ]))

努力解决递归嵌套循环解决方案

0 个答案: