class UnionFind:
    def __init__(self, size):
        self.parent = list(range(size))
        self.rank = [1] * size
    
    def find(self, u):
        if self.parent[u] != u:
            self.parent[u] = self.find(self.parent[u])  # Path compression
        return self.parent[u]
    
    def union(self, u, v):
        root_u = self.find(u)
        root_v = self.find(v)
        
        if root_u != root_v:
            # Union by rank
            if self.rank[root_u] > self.rank[root_v]:
                self.parent[root_v] = root_u
            elif self.rank[root_u] < self.rank[root_v]:
                self.parent[root_u] = root_v
            else:
                self.parent[root_v] = root_u
                self.rank[root_u] += 1

def find_visible_profiles(connection_nodes, connection_edges, connection_from, connection_to, queries):
    # Initialize Union-Find structure
    uf = UnionFind(connection_nodes + 1)  # Assuming nodes are 1-indexed
    
    # Union the connections
    for u, v in zip(connection_from, connection_to):
        uf.union(u, v)
    
    # Count the size of each connected component
     comp * (connection_nodes + 1)
    for node in range(1, connection_nodes + 1):
        root = uf.find(node)
        component_size[root] += 1
    
    # Prepare results for queries
    result = []
    for query in queries:
        root = uf.find(query)
        result.append(component_size[root] if component_size[root] > 0 else 1)
    
    return result