Easy C++ solution✅| comments added for explanation✅
Code


# Code
```cpp []
// standard dsu template
class disjoint{
    //for 0 based indexing
    vector<int> rank;
    vector<int> parent;
    vector<int> size;
       public:
    disjoint(int n){
        rank.resize(n,0);
        size.resize(n,1);
        parent.resize(n,0);
        for (int i=0;i<n;i++){
            parent[i]=i;
        }
    }
    void reset(int node){
        parent[node]=node;
    }
    bool connected(int u,int v){
        return (findParent(u)==findParent(v));
    }
    int findParent(int u){
        if (u==parent[u]){
            return u;
        }
        return parent[u]=findParent(parent[u]);
    }
    void unionrank(int u,int v){
        int pu=findParent(u);
        int pv=findParent(v);
        if (pu==pv){
            return;
        }
        if (rank[pu]==rank[pv]){
            parent[pv]=pu;
            rank[pu]++;
        }
        else if(rank[pu]<rank[pv]){
            parent[pu]=pv;
        }
        else{
            parent[pv]=pu;
        }
    }
    void unionsize(int u,int v){
         int pu=findParent(u);
        int pv=findParent(v);
        if (pu==pv){
            return;
        }
        if (size[pu] < size[pv]) {
            parent[pu] = pv;
            size[pv] += size[pu];
        }
        else {
            parent[pv] = pu;
            size[pu] += size[pv];
        }
    }
};

class Solution {
public:
int numberOfComponents(vector<vector<int>>& properties, int k) {
        int n = properties.size();
        // Initialize disjoint set for n nodes.
        disjoint d(n);
    
        // Create a 2D vector 'v' of size n x 101 (because properties values are in range [0, 100])
        // and mark the occurrence of each integer in properties[i].
        vector<vector<int>> v(n, vector<int>(101, 0));
        for (int i = 0; i < n; i++) {
            for (auto j : properties[i])
                v[i][j] = 1;  // Mark that integer j is present in properties[i].
        }
    
        // Compare each pair of properties.
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                int cnt = 0;  // Counter for common distinct integers.
                // Iterate over all possible values from 0 to 100.
                for (int q = 0; q <= 100; q++) {
                    // If integer 'q' is present in both properties[i] and properties[j], increment counter.
                    if (v[i][q] == 1 && v[j][q] == 1)
                        cnt++;
                }
                // If the number of common distinct integers is at least k, union the two nodes.
                if (cnt >= k)
                    d.unionrank(i, j);
            }
        }
    
        // Use a set to collect unique representative parents of each component.
        set<int> ans;
        for (int i = 0; i < n; i++) {
            ans.insert(d.findParent(i));
        }
        // The number of connected components is the size of the set.
        return ans.size();
    }
};
```
['C++']