Oh really So much to do.
IntuitionFirst divide the part and then understand the concept.ApproachSo  first make the function which return count of commman number and thenalso make dfs fu
# Intuition
First divide the part and then understand the concept.
# Approach
So  first make the function which return count of commman number and thenalso make dfs function then sort the prop arrays and make them unique and thenmake the call for the common count then make the adjancent list. and then return the connected component  
# Complexity
- Time complexity: $$O(n^2)$$

- Space complexity: $$O(n)$$

# Code
```cpp []
class Solution {
public:

    int comman(vector<int>&a,vector<int>&b){
        int i=0,j=0,cnt=0;
        while(i<a.size() and j<b.size()){
            if(a[i]==b[j]){
                cnt++,i++,j++;
                }
                else if(a[i]<b[j]){
                    i++;
                }
                else{
                    j++;
                }
        }
        return cnt;
    }

    void dfs(int a , vector<int>&vis,vector<vector<int>>&adj){
        vis[a]=1;
        for(auto v : adj[a]){
            if(vis[v])continue;
            dfs(v,vis,adj);
        }
    }
    int numberOfComponents(vector<vector<int>>& properties, int k) {
        for(int i=0;i<properties.size();i++){
            sort(properties[i].begin(),properties[i].end());
            properties[i].resize(unique(properties[i].begin(),properties[i].end())-properties[i].begin());
        }
            vector<vector<int>> adj(properties.size());
        for(int i=0;i<properties.size();i++){
            for(int j=i+1;j<properties.size();j++){
                int cnt=comman(properties[i],properties[j]);
                if(cnt>=k){
                    adj[i].push_back(j);
                    adj[j].push_back(i);
                }
            }
        }
        int ans=0;
        vector<int>vis(properties.size(),0);
        for(int i=0;i<properties.size();i++){
            if(vis[i])continue;
            dfs(i,vis,adj);
            ans++;
        }
        return ans;
    }
};
```
['Depth-First Search', 'Counting Sort', 'C++']