def specialBinaryTree(arr):
    from collections import Counter
    freq = Counter(arr)
    min_val, max_val = min(arr), max(arr)
    count = 0
    
    for root in range(min_val, max_val + 1):
        l, r = min_val, max_val
        while l <= r:
            s = l + r
            if s == 2 * root:
                count += freq[l] * freq[r] if l != r else freq[l] * (freq[l] - 1) // 2
                l += 1
                r -= 1
            elif s < 2 * root:
                l += 1
            else:
                r -= 1

    return count

 import math
from collections import defaultdict, deque

def connectedSum(graph_nodes, graph_from, graph_to):
    graph = defaultdict(list)
    for u, v in zip(graph_from, graph_to):
        graph[u].append(v)
        graph[v].append(u)
    
    visited = set()

    def bfs(node):
        queue = deque([node])
        visited.add(node)
        component_size = 0
        while queue:
            current = queue.popleft()
            component_size += 1
            for neighbor in graph[current]:
                if neighbor not in visited:
                    visited.add(neighbor)
                    queue.append(neighbor)
        return component_size
    
    total_sum = 0
    for node in range(1, graph_nodes + 1):
        if node not in visited:
            component_size = bfs(node)
            total_sum += math.ceil(math.sqrt(component_size))
    
    return total_sum                                                                                                                             

def maxTickets(tickets):
    tickets.sort()
    max_len = 1
    curr_len = 1
    for i in range(1, len(tickets)):
        if abs(tickets[i] - tickets[i - 1]) <= 1:
            curr_len += 1
        else:
            max_len = max(max_len, curr_len)
            curr_len = 1
    return max(max_len, curr_len)

from collections import deque
def photoAlbum(index, identity):
    album = deque()
    for i in range(len(index)):
        album.insert(index[i], identity[i])
    return list(album)