Properties Graph - Practice Coding Problems

Properties Graph - Problem

Array Hash Table Depth-First Search Breadth-First Search Union Find Graph Medium

Imagine you're a social network analyst tasked with finding communities based on shared interests! You have a collection of user profiles, where each profile contains a list of properties (interests, skills, hobbies, etc.).

Given a 2D integer array properties of dimensions n × m and an integer k, your goal is to:

Build an undirected graph where each user (row) is a node
Connect two users with an edge if they share at least k common properties
Count the number of connected components (separate communities)

The intersect(a, b) function returns the number of distinct integers common to both arrays. There's an edge between node i and node j if and only if intersect(properties[i], properties[j]) >= k.

Goal: Return the total number of connected components in the resulting graph.

Input & Output

example_1.py — Basic Case

$ Input: properties = [[1,2,3], [1,2], [2,3], [4,5]] k = 2

› Output: 2

💡 Note: Node 0 and 1 share [1,2] (2 elements >= k=2), so they're connected. Node 0 and 2 share [2,3] (2 elements >= k=2), so they're connected. This creates component {0,1,2}. Node 3 has properties [4,5] which don't intersect with others by ≥2 elements, forming a separate component {3}. Total: 2 components.

example_2.py — No Connections

$ Input: properties = [[1], [2], [3]] k = 2

› Output: 3

💡 Note: No two nodes share 2 or more common properties (each has only 1 property, all different). Each node forms its own component: {0}, {1}, {2}. Total: 3 components.

example_3.py — All Connected

$ Input: properties = [[1,2,3,4], [1,2,5,6], [2,3,7,8]] k = 2

› Output: 1

💡 Note: Node 0 and 1 share [1,2] (2 elements >= k=2). Node 0 and 2 share [2,3] (2 elements >= k=2). Through transitivity, all nodes are in one connected component {0,1,2}. Total: 1 component.

Constraints

1 ≤ n ≤ 10³
1 ≤ m ≤ 100
1 ≤ k ≤ m
1 ≤ properties[i][j] ≤ 10⁴
Each properties[i] contains distinct integers

Visualization

Tap to expand

Understanding the Visualization

User Profiles

Each user has a list of interests/properties

Find Common Interests

Compare each pair to find shared interests

Create Friendships

Connect users with k+ common interests

Count Communities

Count separate friend groups using Union-Find

Key Takeaway

🎯 Key Insight: Union-Find efficiently merges communities without building the full graph, using path compression and union by rank for optimal performance.

Asked in

f Facebook 35 G Google 28 in LinkedIn 22 a Amazon 18

The optimal approach uses Union-Find data structure to efficiently merge components. For each pair of nodes, compute their property intersection and union them if intersection ≥ k. The Union-Find structure handles path compression and union by rank for nearly O(1) operations, making it more efficient than explicit graph construction with DFS.

Common Approaches

Approach	Time	Space	Notes
✓ Union-Find (Optimal)	O(n² × m × α(n))	O(n)	Use Union-Find to efficiently merge components as we discover edges
Brute Force + DFS	O(n² × m)	O(n² + n)	Build adjacency list by checking all pairs, then use DFS to count components

Union-Find (Optimal) — Algorithm Steps

Initialize Union-Find with each node as its own parent
For each pair of nodes, compute intersection of their properties
If intersection >= k, union the two nodes in the same component
After processing all pairs, count number of unique root parents
Each unique root represents one connected component

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Each node points to itself as parent

Find Intersection

Check if two nodes share enough properties

Union Components

Merge the two nodes' components using union by rank

Count Final

Count nodes that are their own parent

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int* parent;
    int* rank;
    int components;
    int size;
} UnionFind;

UnionFind* createUnionFind(int n) {
    UnionFind* uf = malloc(sizeof(UnionFind));
    uf->parent = malloc(n * sizeof(int));
    uf->rank = calloc(n, sizeof(int));
    uf->components = n;
    uf->size = n;
    
    for (int i = 0; i < n; i++) {
        uf->parent[i] = i;
    }
    
    return uf;
}

int find(UnionFind* uf, int x) {
    if (uf->parent[x] != x) {
        uf->parent[x] = find(uf, uf->parent[x]); // Path compression
    }
    return uf->parent[x];
}

int unionSets(UnionFind* uf, int x, int y) {
    int px = find(uf, x);
    int py = find(uf, y);
    
    if (px == py) return 0;
    
    // Union by rank
    if (uf->rank[px] < uf->rank[py]) {
        uf->parent[px] = py;
    } else if (uf->rank[px] > uf->rank[py]) {
        uf->parent[py] = px;
    } else {
        uf->parent[py] = px;
        uf->rank[px]++;
    }
    
    uf->components--;
    return 1;
}

int intersect(int* a, int sizeA, int* b, int sizeB) {
    int count = 0;
    for (int i = 0; i < sizeA; i++) {
        for (int j = 0; j < sizeB; j++) {
            if (a[i] == b[j]) {
                count++;
                break;
            }
        }
    }
    return count;
}

int countConnectedComponents(int** properties, int* propertySizes, int n, int k) {
    UnionFind* uf = createUnionFind(n);
    
    // Check all pairs and union if intersection >= k
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (intersect(properties[i], propertySizes[i], properties[j], propertySizes[j]) >= k) {
                unionSets(uf, i, j);
            }
        }
    }
    
    int result = uf->components;
    
    // Cleanup
    free(uf->parent);
    free(uf->rank);
    free(uf);
    
    return result;
}

int main() {
    // Input parsing and solution call
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × m × α(n))

O(n²) pairs to check, O(m) intersection computation, O(α(n)) for Union-Find operations where α is inverse Ackermann

⚠ Quadratic Growth

Space Complexity

O(n)

O(n) space for Union-Find parent and rank arrays

⚡ Linearithmic Space

62.5K Views

Medium-High Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Union-Find (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler