DAA | 顶点覆盖问题

顶点覆盖问题是图论中的经典问题之一，它要求在一个无向图中找出一组顶点，使这组顶点覆盖了图中的所有边。

DAA 是 Dynamic Array Approach 的缩写，是一种动态规划算法。在这个算法中，我们使用了二叉树的思想，将问题划分成子问题，并且动态更新问题的解。这种算法能够有效地解决顶点覆盖问题，时间复杂度为 O(n log n)。

动态规划

动态规划是一种通过将问题分解成子问题来求解更复杂的问题的算法。与分治算法类似，动态规划也是递归的，但是动态规划会记忆中间的结果，以便避免重复计算。

DAA 算法就是一种动态规划算法，它的核心思想是：

• 将原问题划分成更小的子问题。
• 用一个二叉树结构存储子问题的解。
• 动态更新子问题的解，直到得到原问题的解。

算法步骤

DAA 算法可以被分为以下四个步骤：

1. 创建一个大小为 n 的结构体数组，其中每个结构体表示一个图中的节点，并且结构体中包含一个大小为 2 的指针数组，用于按照节点的邻居列表链接到其他节点。

2. 创建一棵二叉树，其中每个节点表示当前图的一个子集。根据以下标准来组织这颗树：

   • 设根节点为 T。
   • 如果节点 v 表示子集 S，则其左子节点表示子集 S-v，右子节点表示子集 S-v’.

   节点 v 的状态可以用一个长度为 n 的二进制数组表示，其中对应于节点 i 的二进制位为 1，当且仅当节点 i 在 S 中。

3. 在每个节点 v 上，计算覆盖子集 S 的最小节点数（即覆盖 S 中所有边所需节点数的最小值）。

   • 如果节点 v 是叶子节点，则该节点的值为 0。
   • 否则，该节点的值为 min{1 + T.left.child[v] + T.right.value, T.left.value + 1 + T.right.child[v]}，其中 T.left.value 和 T.right.value 分别是 T.left 和 T.right 的值，T.left.child[v] 和 T.right.child[v] 分别表示在左子树或右子树中寻找终止条件的最小长度。

4. 最终的答案是在根节点 T 上，即 T.value。

代码实现

以下是 DAA 算法的 Python 实现代码：

class Node:
    def __init__(self, idx, adj_list):
        self.idx = idx
        self.adj_list = adj_list
        self.cover = 0 # coverage number

def daa(node_list):
    n = len(node_list)
    mask = (1 << n) - 1
    tree = [None] * (mask + 1) 
    root = Node(0, [])
    root.right = root.left = root
    
    for i in range(n):
        tree[1 << i] = Node(i, node_list[i])
        root.right = root.left = tree[1 << i]
    
    for i in range(1, mask + 1):
        if not tree[i]: continue

        for j in range(n): 
            if (i & (1 << j)) != 0:
                continue
            k = i | (1 << j)
            if tree[k] is None:
                tree[k] = Node(k, [])

            if j in tree[i].adj_list:
                tree[k].cover = min(tree[k].cover, tree[i].cover)
            else:
                tree[k].cover = min(tree[k].cover, 1 + tree[i].cover)

        if tree[i].cover is None:
            tree[i].cover = float('inf')

    def dfs(node):
        if node.left == node.right:
            node.cover = 0
        else:
            dfs(node.left)
            dfs(node.right)

            node.cover = min(1 + node.left.cover + node.right.cover, node.left.cover + 1 + node.right.cover)

    dfs(root)
    return root.cover

总结

DAA 算法是一种动态规划算法，能够有效地解决顶点覆盖问题。这种算法利用了二叉树的结构，将问题分解成子问题，并且重复利用分解后的问题的解，避免了重复计算。DAA 算法的时间复杂度为 O(n log n)，是一种比较高效的算法。