python code: it's work
IntuitionApproachComplexity
Time complexity:

Space complexity:
Code
# Intuition
<!-- Describe your first thoughts on how to solve this problem. -->

# Approach
<!-- Describe your approach to solving the problem. -->

# Complexity
- Time complexity: 
<!-- Add your time complexity here, e.g. $$O(n)$$ -->

- Space complexity:
<!-- Add your space complexity here, e.g. $$O(n)$$ -->

# Code
```python3 []
class Solution:
    def numberOfComponents(self, properties: List[List[int]], k: int) -> int:
        n = len(properties)

        adjlist = defaultdict(list)
        
        for i in range(n):
            for j in range(n):
                if i != j:
                    if self.intersect(i, j, properties) >= k:
                        adjlist[i].append(j)
                        adjlist[j].append(i)


        count_component = 0

        visited = [False] * n
        for i in range(n):
            if not visited[i]:
                self.bfs(i, visited, adjlist)
                count_component += 1

        return count_component
        
    def intersect(self, i, j, properties):

        mp1 = {}
        for val in properties[i]:
            mp1[val] = True

        mp2 = {}
        for val in properties[j]:
            if val in mp1 and val not in mp2: 
                mp2[val] = True
                
        return len(mp2)


    def bfs(self, src, visited, adjlist):
        q = deque()
        q.append(src)
        visited[src] = True

        while q:
            front = q.popleft()

            for neighbor in adjlist[front]:
                if not visited[neighbor]:
                    q.append(neighbor)
                    visited[neighbor] = True
```
['Hash Table', 'Breadth-First Search', 'Python3']