assets/train/leetcode_dataset_train/leetcode_train_array-nesting/solution.py

from __future__ import annotations

import collections
import functools
import math
import random
import string
from bisect import *
from collections import *
from functools import *
from heapq import *
from itertools import *
from math import *
from operator import *
from string import *
from typing import *


class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next


class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right


class Node:
    def __init__(self, val=0, children=None, next=None, random=None):
        self.val = val
        self.children = children
        self.next = next
        self.random = random


def list_node(values):
    if not values:
        return None
    dummy = ListNode()
    current = dummy
    for value in values:
        current.next = ListNode(value)
        current = current.next
    return dummy.next


def list_values(node):
    values = []
    steps = 0
    while node is not None:
        values.append(node.val)
        node = node.next
        steps += 1
        if steps > 10000:
            raise AssertionError("linked list appears to contain a cycle")
    return values


def is_same_list(left, right):
    return list_values(left) == list_values(right)


def tree_node(values):
    if not values:
        return None
    nodes = [None if value is None else TreeNode(value) for value in values]
    children = nodes[::-1]
    root = children.pop()
    for node in nodes:
        if node is None:
            continue
        if children:
            node.left = children.pop()
        if children:
            node.right = children.pop()
    return root


def tree_values(root):
    if root is None:
        return []
    values = []
    queue = deque([root])
    while queue:
        node = queue.popleft()
        if node is None:
            values.append(None)
            continue
        values.append(node.val)
        queue.append(node.left)
        queue.append(node.right)
    while values and values[-1] is None:
        values.pop()
    return values


def is_same_tree(left, right):
    return tree_values(left) == tree_values(right)


class Solution:
    def arrayNesting(self, nums: List[int]) -> int: