识别节点位于另外两个节点之间

Question

给出了树。边信息以邻接表格式给出。

节点编号在 1, 2, 3, ....N.

树的根总是 1。

现在，给出了两个索引。问题是上述两个中的任何一个索引是否位于从根（1）到其他索引的路径上。

约束

1. 节点数为 10^5。
2. 可以触发的最大查询数，10^5。
3. 父 ID 始终小于子 ID。

示例：-

给定的边缘：-

1 2
2 5
1 3
3 7
1 4
4 8
8 9

问题 -

2 3  ( Answer - Not possible, from 1 to 2, 3 never comes in between and from 1 to 3, 2 never comes in between.)
8 9  ( Answer - Possible, 8 lies in between 1 and 9)

下一个例子：-

1 2
2 4
2 5
1 3
3 6
3 7
3 8

Answer 1

算法如下：-

1. 从根目录开始，记下每个节点的IN TIME和OUT TIME。正如你所说，给出了邻接列表。您可以通过在时间复杂度 O(Total number of nodes ) 中使用 DFS 轻松完成。

2. 一个节点“B”是另一个节点“A”的后代，仅在一种情况下。

   IN_TIME(A)

这样，Query 将在 O(1) 时间内处理。

Answer 2

假设父节点的ID（更靠近根的那个）总是大于子节点的ID，就像你的例子中的情况一样，你可以很容易地从任何边缘看到它是否引向根部或远离根部。因此，基本算法将是：

given nodes n and m
find edge (x, n) or (n, x) such that x < n
repeat with node x until x is m or x is root

我认为没有更快的方法来确定一个节点是否位于根节点和另一个节点之间。当然，您可以通过使用适当的数据结构来提高性能，例如，首先将每个节点映射到哈希集中的父节点。下面是一个 Python 示例：

ROOT = 1
edges = ((1, 2), (2, 4), (2, 5), (1, 3), (3, 6), (3, 7), (3, 8))

parents = {}
for edge in edges:
    parent, child = min(edge), max(edge)
    parents[child] = parent

def is_anchestor_of(p, c):
    while c > p:
        if parents[c] == p:
            return True
        c = parents[c]
    return False

创建哈希映射的时间和空间复杂度在节点或边的数量上为 O(n)（在树中几乎相同），is_anchestor_of 的平均案例复杂度为 O (logn)，但在最坏的情况下（极度不平衡的树或链）会恶化到 O(n)。

您可以通过将每个节点映射到它的所有锚点来提高查找复杂性。创建这个哈希映射的复杂性是 O(n log n)，除非我在时间和空间上都弄错了，但在最坏的情况下可能会上升到 O(n^2)。无论如何，使用这种结构，is_anchestor_of 的复杂度是 O(1)，因为它只是在哈希映射中查找，然后在哈希集中查找。

anchestors = {}
for node in parents:
    anchestors[node] = set([ ROOT ])
    p = parents[node]
    while p != ROOT:
        anchestors[node].add(p)
        p = parents[p]

def is_anchestor_of(p, c):
    return p in anchestors[c]

在这两种情况下，只需检查一个是否是另一个的锚。

def on_one_path(x, y):
    return is_anchestor_of(x, y) if x < y else is_anchestor_of(y, x)
print on_one_path(3, 8)

---

更新：似乎有更有效的方法；请参阅@Loha 的 答案。

Answer 3

对于每个节点，在树中构造它上面的节点的排序列表：

1 {}
2 {1}
3 {1}
4 {1}
5 {1, 2}
7 {1, 3}
8 {1, 4}
9 {1, 4, 8}

然后，当给出查询时，搜索列表中属于另一个的每个节点（O(logN)）：

2 3: 2 is not in {1}, and 3 is not in {1}, so the answer is no.
8 9: 9 is not in {1, 4}, but 8 is in {1, 4, 8}, so the answer is yes.

编辑：

正如 tobias_k 所指出的，还有其他结构，例如哈希表，可以使搜索O(1)。构建表格是 O(n)，很简单 - 只需遍历边列表并将它们放入。