Question

我正在寻找工会。我想根据其中一个索引是否与另一对索引共享一个数字来对数字对进行分组。所以：

我有一对像这样的对：

pairs: [[1,3], [6,8], [3,8], [2,7]]

最好的方法是将它们分组在这样的工会中：

[ [ 1, 3, 8, 6 ], [ 2, 7 ] ]

（[1,3]和[3,8]一起去，因为他们共享3.该组与[6,8]结合，因为他们共享8.什么是最好的方式在javascript中执行此操作？

以下是其他例子：

pairs: [[8,5], [10,8], [4,18], [20,12], [5,2], [17,2], [13,25],[29,12], [22,2], [17,11]]

into [ [ 8, 5, 10, 2, 17, 22, 11 ],[ 4, 18 ],[ 20, 12, 29 ],[ 13, 25 ] ]

修改这是我目前正在使用的方法：

findUnions = function(pairs, unions){
   if (!unions){
       unions = [pairs[0]];
       pairs.shift();
   }else{
       if(pairs.length){
           unions.push(pairs[0])
           pairs.shift()
       }
   }

    if (!pairs.length){
        return unions
    }
    unite = true
    while (unite && pairs.length){
        unite = false
        loop1:
        for (i in unions){
            loop2:
            var length = pairs.length;
            for (j=0;j<length;j++){
                if (unions[i].includes(pairs[j][0])){
                    if (!unions[i].includes(pairs[j][1])){
                        unions[i].push(pairs[j][1])
                        pairs.splice(j, 1)
                        j-=1;
                        length-=1
                        unite = true
                    }else{
                        pairs.splice(j, 1)
                        j-=1
                        length-=1
                    }
                }else if (unions[i].includes(pairs[j][1])){
                     unions[i].push(pairs[j][0])
                     pairs.splice(j, 1)
                     unite = true
                    j-=1
                    length-=1
                }
            }
        }
    }
    return findUnions(pairs, unions)
}

Answer 1

方法：

finalArray = [], positions = {};    
for i to Array.length
   for j=i+1 to Array.length
       find match between arr[i] and arr[j]
       if match found
          pos = postion mapped to either i or j in positions
          add elements of arr[i] or arr[j] or both depending on pos.
return finalArray

在方法中我们保持存储数组的位置，我们在位置对象中添加到finalArray，然后我们可以使用这个对象找到一个合适的位置来在finalArray中添加匹配数组的元素。

＆＃13;

function mergeArrays(finalArray, pos, subArray) {
for (var k = 0; k < subArray.length; k++) {
    if (finalArray[pos].indexOf(subArray[k]) < 0)
        finalArray[pos].push(subArray[k]);
}

}

function unionArrays(arr) {
var finalArray = [arr[0]],
    positions = {
        0: 0
    };
for (var i = 0; i < arr.length; i++) {
    for (var j = i + 1; j < arr.length; j++) {
        for (var k = 0; k < arr[i].length; k++) {
            if (arr[j].indexOf(arr[i][k]) >= 0) {
                if (i in positions) {
                    mergeArrays(finalArray, positions[i], arr[j]);
                    positions[j] = positions[i];
                } else if (j in positions) {
                    mergeArrays(finalArray, positions[j], arr[i]);
                    positions[i] = positions[j];
                } else {
                    var pos = finalArray.length;
                    finalArray.push([]);
                    mergeArrays(finalArray, pos, arr[i]);
                    mergeArrays(finalArray, pos, arr[j]);
                    positions[i] = positions[j] = pos;
                }
                break;
            }

        }
    }
    if (!(i in positions)) {
        finalArray.push(arr[i]);
        positions[i] = finalArray.length - 1;
    }
}
return finalArray;
}
console.log(unionArrays([[1,3], [6,8], [3,8], [2,7]]));
console.log(unionArrays([[8,5], [10,8], [4,18], [20,12], [5,2], [17,2], [13,25],[29,12], [22,2], [17,11]]));

＆＃13;

Answer 2

阿。您正在寻找的算法是dfs林。 Wikipedia在树木和森林上有一些好东西。

dfs林只是一个dfs（深度优先搜索），直到没有未访问的节点为止。结果是连接和隔离的子图（＆＃34;树＆＃34;）的图形（＆＃34;森林＆＃34;）。这些是＆＃34;工会＆＃34;你指的是。

当每个节点映射到它所连接的节点时，深度优先搜索更容易（也更快）。所以不是这个数据：

[[1,3], [6,8], [3,8], [2,7]]

你想要：

{1: [3], 2: [7], 3: [1, 8], 6: [8], 7: [2], 8: [6, 3]}

转换数据非常简单（而且速度快）：

function mapNodes(edges) {
    let nodeMap = {}

    edges.forEach(edge => {
        let node1 = edge[0]
        let node2 = edge[1]

        if (!nodeMap[node1]) nodeMap[node1] = [node2]
        else nodeMap[node1].push(node2)

        if (!nodeMap[node2]) nodeMap[node2] = [node1]
        else nodeMap[node2].push(node1)
    })
    return nodeMap
}

然后dfs本身是一个简单的递归算法，dfs林只是一直运行它，直到没有更多未访问的节点。这是一个[编辑：不是那么]粗略的例子：

function dfsForest(nodeMap) {
    let forest = []
    let nodes = Object.keys(nodeMap)

    while (true) {
        let root = +nodes.find(node => !nodeMap[node].visited)
        if (isNaN(root)) break // all nodes visited

        forest.push(dfs(root, nodeMap))
    }
    return forest
}

function dfs(root, nodeMap, tree = []) {
    if (tree.includes(root)) return tree // base case

    tree.push(root)
    nodeMap[root].visited = true

    let connectedNodes = nodeMap[root]
    for (let i = 0; i < connectedNodes.length; i++) {
        let connectedNode = connectedNodes[i]
        dfs(connectedNode, nodeMap, tree)
    }
    return tree
}

这里有JSFiddle所有这些。

编辑：

嗯，我说它很粗糙。我编辑了代码和小提琴，删除了额外的visitedNodes数组和它创建的n平方算法。它应该像人类现在发现的那样快速。

在我的测试中，重新格式化数据需要大约350毫秒，并在5000个非最佳对上运行dfs林。在最佳情况下，它需要大约50毫秒。它的退化很好。例如，将总边数加倍会使执行时间从1.5到2.5倍增加，具体取决于对的最佳位置。

事实上，这里有JSFiddle，答案是@Dij。你会看到你的边数是否翻倍，执行时间是四倍（yikes）。他的算法确实有一个有趣的特征，因为没有最优/非最优的情况;一切都需要相同的时间。但是，即使在最不理想的情况下，dfs森林仍然比平率更快。

Answer 3

为满足第一个要求，您可以迭代数组，在迭代过程中从包含所有相邻索引的新数组中排除当前数组。检查相邻数组是否包含当前数组的一个或多个元素，如果为true则将元素推送到新数组。

过滤原始数组，查找不包含先前过滤数组元素的元素。

使用Set从数组中删除重复的条目。

const arr = [[1,3], [6,8], [3,8], [2,7]];

let res = [];

for (const[key, [a, b]] of Object.entries(arr)) {
  const adjacent = arr.filter((el, index) => index !== +key);

const has = adjacent.filter(el => el.includes(a) || el.includes(b));
  res = [...res, ...has.filter(prop => !res.includes(prop))];
}

let not = new Set(...arr.filter(([a, b]) => !res.some(([c, d]) => 
            a === c || b === d || a === d || b === c)));

let set = new Set();

for (const [a, b] of res) {
  if (!set.has(a)) set.add(a);
  if (!set.has(b)) set.add(b);
}

res = [[...set], [...not]];

console.log(res);

Javascript Union Pairs Union Find

3 个答案: