往上找第五级上级，为什么可以只跳两次？

"""Static rooted tree with parent-before-child numbering, zero-based vertices."""
from itertools import product


def require(condition, message):
    if not condition:
        raise AssertionError(message)


class Ancestors:
    def __init__(self, parents):
        if not isinstance(parents, (list, tuple)) or not parents:
            raise ValueError("a nonempty parent list or tuple is required")
        if type(parents[0]) is not int or parents[0] != -1:
            raise ValueError("vertex zero is the root, with parent -1")
        for vertex, parent in enumerate(parents[1:], 1):
            if type(parent) is not int or not 0 <= parent < vertex:
                raise ValueError("each parent must have a smaller vertex number")
        self.parents = tuple(parents)
        self.depth = [0] * len(parents)
        for vertex in range(1, len(parents)):
            self.depth[vertex] = self.depth[parents[vertex]] + 1
        self.up = [list(parents)]
        for _ in range(1, len(parents).bit_length()):
            previous = self.up[-1]
            self.up.append([-1 if middle == -1 else previous[middle]
                            for middle in previous])

    def kth(self, vertex, distance, trace=False):
        if type(vertex) is not int or not 0 <= vertex < len(self.parents):
            raise ValueError("invalid vertex")
        if type(distance) is not int or distance < 0:
            raise ValueError("distance must be a nonnegative integer")
        if distance > self.depth[vertex]:
            return -1, []
        events, level = [], 0
        while distance:
            if distance & 1:
                following = self.up[level][vertex]
                if trace:
                    events.append((1 << level, vertex, following))
                vertex = following
            distance >>= 1
            level += 1
        return vertex, events


def oracle(parents, vertex, distance):
    for _ in range(distance):
        if vertex == -1:
            break
        vertex = parents[vertex]
    return vertex


def main():
    parents = [-1, 0, 1, 2, 3, 4, 5, 2]
    tree = Ancestors(parents)
    print(f"parents={parents}")
    print(f"depth={tree.depth}")
    for level, row in enumerate(tree.up):
        print(f"jump={1 << level}: {row}")
    answer, trace = tree.kth(6, 5, trace=True)
    require(answer == 1, "binary jumps")
    print(f"query(6,5)={answer}; jumps={trace}")
    for vertex, distance in [(6, 0), (6, 6), (6, 7), (0, 1), (7, 2), (7, 10**12)]:
        result, _ = tree.kth(vertex, distance)
        if distance < 100:
            require(result == oracle(parents, vertex, distance), "boundary")
        else:
            require(result == -1, "huge distance")
        print(f"query({vertex},{distance})={result}")
    rejected = 0
    for invalid in [[], [0], [-1, 1], [-1, 2, 1], [-1, -1], [-1, True]]:
        try:
            Ancestors(invalid)
        except ValueError:
            rejected += 1
        else:
            raise AssertionError("invalid parent input accepted")
    for vertex, distance in [(-1, 1), (8, 0), (0, -1), (0, True)]:
        try:
            tree.kth(vertex, distance)
        except ValueError:
            rejected += 1
        else:
            raise AssertionError("invalid query accepted")
    trees = queries = 0
    for size in range(1, 8):
        for choices in product(*(range(vertex) for vertex in range(1, size))):
            data = [-1, *choices]
            current = Ancestors(data)
            for vertex in range(size):
                for distance in range(size + 3):
                    actual, _ = current.kth(vertex, distance)
                    require(actual == oracle(data, vertex, distance), (data, vertex, distance))
                    queries += 1
            trees += 1
    print(f"oracle_trees={trees}; oracle_queries={queries}; rejected_inputs={rejected}")
    print("PASS")


if __name__ == "__main__":
    main()