关于从2D数组创建排名路径列表，我需要了解什么？

Question

假设我有一个设备矩阵和它们的统计信息。 帽子，衬衫，裤子，靴子。 每个内部数组的大小都可以变化，但是总是会有一定数量的内部数组-在这种情况下为4。

var array = [
  [1,9,2,8,3],        // hat
  [2,8,3,6],          // shirt
  [1,3],              // pants
  [9,3,2,6,8,2,1,5,2] // boots
]

我想找到通过矩阵的最佳路径，然后以使确定的下一条路线（因而是该路线的总和）是第一条路线中的第二条最佳路线的方式删除项目。 在此示例中， [9, 8, 3, 9]最好，对吗？ 因此，我们可以在[0]中删除9以达到8从而仅减少1。

我可以汇总所有可能的路线并从那里确定，但是内部数组的大小可能比所示的大得多。

我花了一些时间思考它，并进行了研究。 我唯一能看到的是匈牙利算法，但它现在已经超出了我的数学/综合知识。 在这种情况下，那将是最适用的知识吗？ 它似乎可以满足一条路线的最低“成本”，但我需要相反的选择。

我的想法，至少作为一个想法：

1. 在每个内部数组中提取最高编号，从中创建新数组。 对此排名[0]。
2. 比较每个内部阵列中的最高编号与第二最低的编号。 订购每个之间的差异。
3. 从内部数组中删除编号为2的最低差的最高编号。
4. 重复＃1至＃3。

在上面的示例中，我期望以下内容。

[9, 8, 3, 9]
[8, 8, 3, 9]
[8, 8, 3, 8]
[8, 6, 3, 8]
[8, 6, 3, 6]
[8, 6, 3, 5]

编辑：我想我已经解释了这个问题，让我修复一下。

EDIT2：从本质上讲，是最小损失的集合，仅从一个内部数组中除去一项。

Answer 1

更新 ：我最初误解了您的问题。 您随后澄清了这个问题，在此我提供了一个全新的解决方案。

我使用的策略是将所有子数组中的所有元素展平为单个数组，但是这样做要记住它们来自哪个原始子数组。 然后，我对展平的数组进行排序，首先按值降序排序，然后按子数组编号升序排序。 例如，排序的展平数组的前3个元素将是[[9,0]，[9,3]，[8,0]，...]，表示子数组0中的值9，然后是值9从子数组3开始，然后从子数组0开始，取值为8，依此类推。然后，我遍历该列表，并根据需要获取尽可能多的值，直到达到n，但为尚未使用的任何子数组留出空间选择一个值。

请注意，此解决方案适用于任意数量的子数组，每个子数组具有任意数量的元素。

 const array = [ [1,9,2,8,3], // hat [2,8,3,6], // shirt [1,3], // pants [9,3,2,6,8,2,1,5,2] // boots ]; for (let n = 0; n < 17; n += 1) { const valuesChosen = getTopNBest(array, n); console.log(`n = ${n}: ${JSON.stringify(valuesChosen)}`); } function getTopNBest(array, n) { const numTypes = array.length; const allElmtsRanked = []; array.forEach((sub, typeNum) => { sub.forEach(elmt => {allElmtsRanked.push([elmt, typeNum]);}); }); allElmtsRanked.sort((a,b) => b[0] - a[0] !== 0 ? b[0] - a[0] : a[1] - b[1]); const valuesChosen = array.map(() => null); let totalNumValuesExamined = 0; let numSecondaryValuesChosen = 0; let numUnrepresentedTypes = numTypes; let currPair, currValue, currTypeNum; while (numUnrepresentedTypes !== 0 || numSecondaryValuesChosen < n) { currPair = allElmtsRanked[totalNumValuesExamined]; currValue = currPair[0]; currTypeNum = currPair[1]; totalNumValuesExamined += 1; if (valuesChosen[currTypeNum] === null) { valuesChosen[currTypeNum] = currValue; numUnrepresentedTypes -= 1; } else if (numSecondaryValuesChosen < n) { numSecondaryValuesChosen += 1; valuesChosen[currTypeNum] = currValue; } } return valuesChosen; } 

随后，您问为什么我先按值然后按子数组号排序。 比较以下两种情况：

var array = [
  [8],
  [9,9,9,9,9],
  [8],
  [8]
]

...与...

var array = [
  [9,8],
  [9,9],
  [9,8],
  [9,8]
]

如果仅对这些扁平化的数组进行扁平化，而又不保留有关值来自哪个子数组的任何信息，则在两种情况下，最终都会得到相同的扁平化数组，即

var sortedFlattenedArray = [9,9,9,9,9,8,8,8]

假设您想要最好/最理想的途径。 现在，无论哪种情况，您都将得到[9,9,9,9] ，而第一种情况下，您确实需要[8,9,8,8] 。 仅在记住子数组/类型编号后才能获取此信息，例如：

var sortedFlattenedArray = [[9,1],[9,1],[9,1],[9,1],[9,1],[8,0],[8,2],[8,3]]

因此，当您不再需要任何类型的更多次优值，但仍在寻找特定值的最大可能值时，实际策略可以让您忽略已采样类型的合理高但次优值类型。

这是另一种查看方式。 这里的策略使您可以对所有原始数组进行展平和排序， 但要记住每个元素的来源 。 反过来，这可以让您在选择路径时保持选择性，说：“啊，下一个值很高，这很好，但是请耐心等待，因为它是一顶帽子（您只能通过读取它的关联子项来知道-阵列/型号），我已经取回我的“次优值”配额，所以我会忽略这个帽子值，但是，我会继续通过分拣扁平阵列迁移到找到一个最高的剩余价值衬衫（同样，您只能通过读取其关联的子数组/类型编号来发现它），但我仍没有找到任何价值。”