UGC NET CS 2018 年 12 月 – II | 问题 22

这是一道关于程序设计的题目，要求考生在考试中解答该问题。这个问题需要使用编程技能和程序设计的知识来回答。

题目

一个无向图 $G$ 具有 $n$ 个顶点和 $m$ 条边。$G$ 的所有边没有相同的权重。将 $G$ 的边排序并标号，始终保持边权相同顺序。已知 $G$ 是连通图。用 $\pi(i)$ 表示编号为 $i$ 的边的两个顶点中较靠左的顶点的编号。下面是一个例子：

     5     3
A---------B---------C
| \     / |     /   |
|   \ D   |   /     |
|     \   | /       |
E---------F---------G
     6     1

如上图所示，共有七条边，编号为 1-7，编号 2-6 的边权最小，即 $w(2) < w(1) < w(7) < w(6) < w(4) < w(3) < w(5)$。如果采用如下方式将边编号：

$e_1 = 2, e_2 = 1, e_3 = 7, e_4 = 6, e_5 = 4, e_6 = 3, e_7 = 5$

则 $\pi(1)=2,\pi(2)=2,\pi(3)=5,\pi(4)=2,\pi(5)=1,\pi(6)=2,\pi(7)=1$。

现在需要设计一个时间复杂度为 $O(m)$ 的算法，将边按上述方式编号。

解答

该问题是一个排序问题。一种解决方案是基于快速排序算法，并且每次只需要将两个簇内的边进行比较。该算法的时间复杂度为 $O(m\log m)$。

但是我们需要设计一个时间复杂度为 $O(m)$ 的算法。我们可以使用桶排序算法，该算法可以通过空间换时间来降低时间复杂度。我们按照在整个图中每个节点的 $\pi(i)$ 进行桶排序，然后再按照边的权重进行排序。

假设 $v$ 是编号最小的那个 $\pi(i)$ 值，那么我们可以在 $\Theta(m)$ 的时间内确定编号为 $e_1$ 的边，然后我们将 $v$ 的所有出边按照边的权重进行桶排序。然后，我们递归将剩余的边进行排序。

下面是该算法的伪代码：

1. 扫描整个图，为每个 $\pi(i)$ 分配一个桶
2. 扫描每条边，找到编号最小的 $\pi(i)$ 值 $v$。标记 $e_1$ 为权重最小的 $v$ 边（如果存在权重相等的情况，则按照编号排序）
3. 对于桶 $v$ 中的每个边 $e$，递归将边进行排序，并更新编号
4. 递归将剩余的边进行排序

下面是该算法的Python实现：

def pi(i):
    # i 的 pi(i) 值
    pass

def sort_edges(G):
    n, m = G.size, G.edges
    bucket = [[] for i in range(n)]
    for i in range(m):
        b = pi(i)
        bucket[b].append(i)
    
    # 找到 pi(i) 最小的边
    for i in range(n):
        if bucket[i]:
            elist = bucket[i]
            # 找到最小的边
            e = min(elist, key=G.weight)
            # 将边 e 标记为编号 1 的边
            G.sort_id[e] = 1
            elist.remove(e)
            # 递归将 pi(e) 相等的边进行排序
            for j in range(n):
                if bucket[j]:
                    elist = [e for e in bucket[j] if pi(e) == pi(i)]
                    if elist:
                        sublist = sort_edges(G, elist)
                        for e in sublist:
                            G.sort_id[e] = n + 1
                            n += 1
                        
            # 递归将剩余的边进行排序
            sublist = sort_edges(G, elist)
            for e in sublist:
                G.sort_id[e] = n + 1
                n += 1
            break
    return sublist

def bucket_sort(G):
    # 对边进行桶排序
    sort_edges(G)
    # 更新所有边的编号
    for i in range(m):
        G.edges[i].sort_id = G.sort_id[i]

其中，pi(i) 函数表示边 $i$ 的 $\pi(i)$ 值，sort_edges(G, v) 函数是对 $\pi(e) = v$ 的边进行排序并返回排序后的边列表，bucket_sort(G) 函数则根据 $\pi(i)$ 和边权对边进行排序并更新编号。

我们可以看到，该算法的时间复杂度为 $O(m)$，因为桶排序的时间复杂度是 $O(m)$，而递归调用 sort_edges() 的时间复杂度也是 $O(m)$。