链表两个节点都写着7，能说明它们在同一位置吗？

"""Identity-based cycle entry and length for a finite, unchanged next chain."""
from itertools import product


class Node:
    __slots__ = ("value", "next")

    def __init__(self, value):
        self.value = value
        self.next = None


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


def next_node(node):
    if node is None:
        return None
    if type(node) is not Node:
        raise TypeError("head and next must be Node or None")
    successor = node.next
    if successor is not None and type(successor) is not Node:
        raise TypeError("head and next must be Node or None")
    return successor


def floyd_cycle(head, emit=None):
    """Return (entry_node, cycle_length), or (None, 0). Do not mutate nodes.

    With emit=None the core stores only a fixed number of references/counters.
    A callback may observe states but must not change nodes or links.
    """
    slow = fast = head
    while True:
        # Move before comparing: both pointers initially equal head.
        slow = next_node(slow)
        fast = next_node(next_node(fast))
        if emit is not None:
            emit("search", slow, fast)
        if slow is None or fast is None:
            return None, 0
        if slow is fast:  # Identity, never slow.value == fast.value.
            break

    entry = head
    if emit is not None:
        emit("reset", entry, slow)
    while entry is not slow:
        entry = next_node(entry)
        slow = next_node(slow)
        if emit is not None:
            emit("entry", entry, slow)

    length = 1
    cursor = next_node(entry)
    if emit is not None:
        emit("length", entry, cursor)
    while cursor is not entry:
        cursor = next_node(cursor)
        length += 1
        if emit is not None:
            emit("length", entry, cursor)
    return entry, length


def visited_oracle(head):
    """Independent small-test reference: store each visited identity's step."""
    seen = {}
    current = head
    step = 0
    while current is not None:
        identity = id(current)
        if identity in seen:
            return current, step - seen[identity]
        seen[identity] = step
        step += 1
        current = current.next
    return None, 0


def make_graph(successors):
    # Equal payloads deliberately do not identify these separate objects.
    nodes = [Node(7) for _ in successors]
    for node, index in zip(nodes, successors):
        node.next = None if index == -1 else nodes[index]
    return nodes


def compare(head):
    entry, length = floyd_cycle(head)
    wanted, wanted_length = visited_oracle(head)
    require(entry is wanted and length == wanted_length, "entry/length mismatch")


def main():
    nodes = make_graph([1, 2, 3, 4, 5, 2])
    labels = {id(node): i for i, node in enumerate(nodes)}
    events = []

    def show(phase, first, second):
        a = None if first is None else labels[id(first)]
        b = None if second is None else labels[id(second)]
        events.append((phase, a, b))

    entry, length = floyd_cycle(nodes[0], show)
    require(entry is nodes[2] and length == 4, "known entry/length")
    meeting = [a for phase, a, b in events if phase == "search" and a == b][0]
    require(meeting == 4, "first meeting is not the entry here")
    print("all_node_values=[7, 7, 7, 7, 7, 7]")
    print("next_indices=[1, 2, 3, 4, 5, 2]")
    for phase, a, b in events:
        print(f"{phase}: first={a}; second={b}")
    print(f"meeting_index={meeting}; entry_index={labels[id(entry)]}; cycle_length={length}")

    chain = make_graph([1, 2, 3, -1])
    require(chain[1].value == chain[2].value and chain[1] is not chain[2], "value vs identity")
    require(floyd_cycle(chain[0]) == (None, 0), "equal values must not create a cycle")
    require(floyd_cycle(None) == (None, 0), "empty chain")
    single = make_graph([-1])
    require(floyd_cycle(single[0]) == (None, 0), "single noncycle")
    self_loop = make_graph([0])
    found, size = floyd_cycle(self_loop[0])
    require(found is self_loop[0] and size == 1, "head self-loop")
    head_cycle = make_graph([1, 0])
    found, size = floyd_cycle(head_cycle[0])
    require(found is head_cycle[0] and size == 2, "cycle begins at head")
    print("same_values_without_cycle=None; empty=None; single=None; head_self_loop=1; head_cycle=2")

    graphs = starts = 0
    for n in range(6):
        # Every node independently points to None or one of n nodes.
        for successors in product(range(-1, n), repeat=n):
            graph = make_graph(successors)
            before = [node.next for node in graph]
            for head in [None] + graph:
                compare(head)
                starts += 1
            require(all(node.next is old for node, old in zip(graph, before)), "links mutated")
            graphs += 1
    require(graphs == 8477 and starts == 50069, "enumeration coverage")

    # Long prefix and long cycle are separate from the small graph enumeration.
    long_graph = make_graph(list(range(1, 1000)) + [997])
    compare(long_graph[0])
    found, size = floyd_cycle(long_graph[0])
    require(found is long_graph[997] and size == 3, "long prefix")
    long_cycle = make_graph(list(range(1, 1000)) + [0])
    compare(long_cycle[0])
    require(floyd_cycle(long_cycle[0])[1] == 1000, "long cycle")

    malformed = Node(7)
    malformed.next = 42
    invalid = [42, "node", object(), malformed]
    rejected = 0
    for head in invalid:
        try:
            floyd_cycle(head)
        except TypeError:
            rejected += 1
        else:
            raise AssertionError("invalid link accepted")
    print(f"enumerated_graphs={graphs}; enumerated_starts={starts}; long_cases=2; rejected_inputs={rejected}")
    print("PASS: identity/entry/length match visited oracle; core does not mutate links")


if __name__ == "__main__":
    main()