查找无向图的 k 核

什么是 k 核？

在图论中，k 核是指一个最大的子图，其中每个节点至少有 k 条边与其相连。换句话说，如果一个节点在这个子图中，则至少有 k 条边与它相连。

如何查找 k 核？

下面介绍两种查找无向图的 k 核的算法。

算法一：BM算法

BM算法是一种基于并查集的算法，复杂度为 O(m * alpha(m))，其中 alpha(m) 为自然对数的反函数。

首先我们需要构建一个初始的并查集，将每个节点看作一个单元素集合。接下来按照度从小到大排序，遍历每个节点，对于每个节点 u，先将 u 和其所有邻居 v 合并到同一个集合中，然后检查合并后的集合大小是否满足要求，如果不满足要求，则将 u 从合并后的集合中删除。

代码实现如下：

def k_core_bm_algorithm(graph, k):
    # 初始化并查集
    uf = UnionFind(len(graph))
    for u in range(len(graph)):
        for v in graph[u]:
            uf.union(u, v)

    # 按度从小到大排序
    degree = [len(graph[u]) for u in range(len(graph))]
    nodes = sorted(range(len(graph)), key=lambda x: degree[x])

    # 遍历所有节点
    for u in nodes:
        # 将 u 和其所有邻居合并到同一个集合中
        for v in graph[u]:
            uf.union(u, v)

        # 检查集合大小是否满足要求
        if uf.get_size(u) < k:
            # 删除 u
            for v in graph[u]:
                uf.remove_edge(u, v)

    # 返回 k 核
    k_core = {u: set(graph[u]) for u in range(len(graph)) if len(graph[u]) >= k}

    return k_core

算法二：DFS算法

DFS算法是一种递归算法，复杂度为 O(n + m)。

算法的主要思想是：从度最小的节点开始进行深度优先搜索，每次遍历到一个节点时，将其度数减去 k，并将其所有邻居的度数减去 k。如果某个节点度数小于 k，则说明该节点不属于 k 核，将其从图中删除。

代码实现如下：

def k_core_dfs_algorithm(graph, k):
    # 按度从小到大排序
    degree = [len(graph[u]) for u in range(len(graph))]
    nodes = sorted(range(len(graph)), key=lambda x: degree[x])

    # 初始化节点访问状态和度数
    visited = [False] * len(graph)
    deg = degree.copy()

    # 从度最小的节点开始进行深度优先搜索
    for u in nodes:
        if not visited[u]:
            _dfs(u, graph, visited, deg, k)

    # 返回 k 核
    k_core = {u: set(graph[u]) for u in range(len(graph)) if len(graph[u]) >= k}

    return k_core

def _dfs(u, graph, visited, deg, k):
    visited[u] = True
    for v in graph[u]:
        if not visited[v]:
            # 将 v 的度数减去 k
            deg[v] -= k
            # 如果 v 的度数小于 k，则反向删除 v -> u 的边
            if deg[v] < k:
                graph[v].remove(u)
                graph[u].remove(v)
            else:
                _dfs(v, graph, visited, deg, k)

总结

以上就是两种查找无向图的 k 核的算法。BM算法的时间复杂度较高，但实现简单；DFS算法的时间复杂度较低，但实现稍微复杂一些。根据实际情况选择合适的算法即可。