腳本在陣列中推送元素就像追趕尾巴一樣

[0,1, 5, 29]
[0,2,6,29]
[0,3,7, 8, 29]
[0,4,10]
[0,4,11]
[0,4,12, 18, 29]
[0,4,13,19,29]

生成器是可迭代的，因此你可以使用Array.from將所有結果收集在一個陣列中 -

const all = Array. from(solver(input, 0)
console.log(all)

[
  [0,1,5,29] 。
  [0,2,6,29] 。
  [0,3,7,8,29] 。
  [0,4,10] 。
  [0,4,11] 。
  [0,4,12,18,29] 。
  [0,4,13,19,29] 。
]

將生成器與優化的輸入型別相結合，以獲得更好的結果。

uj5u.com熱心網友回復：

根據我對你的輸出的理解，你想要的有點像一個多米諾骨牌鏈。你用陣列開始的第一個元素包含0作為輸出的種子，例如[0,1]和[0,2]...，然后你根據陣列中的最后一項和下一個條目中的第一項，找到下一個陣列加入鏈中。

這個程序在本質上是遞回的，因為你從種子開始，不知道你需要加入多遠/多深。為了分解這一點，我們可以這樣做：

1. 分離你的
   






將你的輸入分離成種子和非種子（節點）。
2. 從種子開始
。
3. 遍歷種子并呼叫一個函式，它將遞回地將節點添加到你的種子中。訣竅在于，當可以找到多個路徑時，你要復制種子陣列
。

這個函式應該遞回地呼叫自己，這里有一個快速的邏輯：

這個函式應該遞回地呼叫自己。

/**。
 * @method[/span
 * @params arr 種子陣列（它的長度會增長）。
 * @params nodes 非種子的集合。
 */
function chain（arr, nodes） {
  //我們首先找到任何剩下的節點，我們可以支配鏈到當前種子。
  const nextNodes = nodes.filter(node => node[0] == arr[arr. length - 1] ）。)

  //如果沒有找到，回傳陣列。
  if (!nextNodes.length) return [arr];

  //否則，我們將瀏覽所有的下一個節點并創建一個當前種子的副本。
  //然后將下一個節點附加到它上面。
  return nextNodes.map(nextNode =>  {
    return chain([...arr, nextNode[1] ], nodes)。
  }）.flat（）。

請看下面的概念驗證：

const input = [
  [0, 1] 。
  [0, 2] 。
  [0, 3]。
  [0, 4]。
  [1, 5]。
  [2, 6]。
  [3, 7] 。
  [4, 10] 。
  [4, 11]。
  [4, 12]。
  [4, 13]。
  [5, 29]。
  [6, 29]。
  [7, 8]。
  [8, 29]。
  [9, 29]。
  [12, 18]。
  [13, 19]。
  [17, 29]。
  [18, 29]。
  [19, 29]。
  [21, 29]。
  [24, 29]。
  [26, 29]。
  [28, 29].
];

const seeds = input. filter(entry => entry[0] ==0) 。
const nodes = input. filter(entry => entry[0] !==0) 。

function chain(arr, nodes) {
  const nextNodes = nodes.filter(span class="hljs-params">node => node[0] == arr[arr. length - 1] ）。)

  if (!nextNodes.length) return [arr] 。

  return nextNodes.map(nextNode => {
    return chain([...arr, nextNode[1]], nodes)。
  }）.flat（）。
}

const output = seeds.map(seed =>  {
  return chain（seed, nodes）。
}）.flat（）。

console.log（output）;

uj5u.com熱心網友回復：

我將把問題分成兩部分：

下面是該方法的一個實作：

const input = 
  [
    [0, 1 ], [ 0, 2 ], [ 0, 3 ],
    [0, 4 ], [ 1, 5 ], [ 2, 6 ],
    [3, 7], [ 4, 10 ], [ 4, 11 ],
    [4, 12], [ 4, 13 ], [ 5, 29 ],
    [6, 29], [ 7, 8], [8, 29]。
    [9, 29], [ 12, 18 ], [ 13, 19 ],
    [17, 29], [ 18, 29 ], [ 19, 29 ],
    [21, 29], [ 24, 29 ], [ 26, 29 ],
    [28, 29 ].
  ];
  
  
  
const nodes = {};

//存盤節點之間的所有路徑。
for (const [ start, end ] of input) {
  nodes[end] = nodes[end] || { id: end, children: [] };
  nodes[start] = nodes[start] || { id: start, children: [] };
  
  nodes[start].children.push（nodes[end]）。
}

//查找從0開始的所有路徑。
const getPaths = ({ children, id }) => children.length === 0 ?
  ? [[ id ]] : children.0 ?
  : children.flatMap(
      n => getPaths（n）。 map(p => [ id, ...p ])
    )

console.log(getPaths(nodes[0] );

uj5u.com熱心網友回復：

你也可以用一個單一的回圈來做，并遵循你的規則：

如果edge以0開始（start），就把它推到result。

let input = [[0, 1]。[0, 2], [0, 3], [0, 4], [1, 5] 。[2, 6], [3, 7], [4, 10], [4, 11] 。
            [4, 12], [4, 13] 。[5, 29], [6, 29] 。[7, 8], [8, 29] 。[9, 29], [12, 18] 。
            [13, 19], [17, 29], [18, 29], [19, 29], [21, 29] 。[24, 29], [26, 29] 。
            [28, 29] ]。

let result = [];
for (let edge of input) {
  let start = edge[0] 。
  if (start ==0) { // <-- 1. (0 => push for sure) 
    result.push（edge）。
  } else {
    for (let path of result) {
      let position = path.indexOf（start）。
      if (position > 0) { // <-- 2. (不能是0，但>=也行)
        if (position !== path.length - 1) { // <--- 4. (need a copy).
          path = path.slice(0, position   1) 。
          result.push（path）。
        }
        path.push(edge[1]); // <-- 3. 4.（無論路徑是什么）
        break。
      }
    }
  }
}
console.log(JSON.stringify（result）);

（JSON.stringify()只是用于格式化）

標籤：

上一篇：不在遞回中迭代

下一篇：解釋一下這個JavaScript遞回