Properties Graph

Properties Graph - Problem

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

You are given a 2D integer array properties having dimensions n x m and an integer k.

Define a function intersect(a, b) that returns the number of distinct integers common to both arrays a and b.

Construct an undirected graph where each index i corresponds to properties[i]. There is an edge between node i and node j if and only if intersect(properties[i], properties[j]) >= k, where i and j are in the range [0, n - 1] and i != j.

Return the number of connected components in the resulting graph.

Input & Output

Example 1 — Basic Graph Formation

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

› Output: 1

💡 Note: Intersections: properties[0] ∩ properties[1] = {1,3} (size 2 ≥ k), properties[0] ∩ properties[2] = {2,3} (size 2 ≥ k), properties[1] ∩ properties[2] = {3} (size 1 < k). Edges: 0-1, 0-2. Since node 0 connects to both nodes 1 and 2, all three nodes form one connected component.

Example 2 — No Connections

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

› Output: 3

💡 Note: No two arrays have 2 or more common elements, so no edges exist. Each node forms its own component: 3 components total.

Example 3 — All Connected

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

› Output: 1

💡 Note: All pairs have at least 2 common elements: (0,1) share {1,2}, (0,2) share {2,3}, (1,2) share {2}. Wait, (1,2) only share {2}, which is size 1 < k=2. So edges are 0-1 and 0-2, making one component {0,1,2}.

Constraints

1 ≤ properties.length ≤ 10³
1 ≤ properties[i].length ≤ 10³
1 ≤ properties[i][j] ≤ 10⁵
1 ≤ k ≤ 10³

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 f Facebook 18

The key insight is to model this as a graph connectivity problem where nodes are property arrays and edges exist when intersection size ≥ k. Best approach uses hash sets for O(1) intersection counting and Union-Find for efficient component tracking. Time: O(n²×m), Space: O(n×m)

Common Approaches

✓ Brute Force with DFS

⏱️ Time: O(n² × m) Space: O(n + E)

For each pair of nodes, count common elements by nested loops. Build an adjacency list for edges where intersection >= k. Use DFS to traverse and count connected components.

Optimized with Hash Sets

⏱️ Time: O(n² × m + n × m) Space: O(n × m)

Convert each property array to a hash set for constant-time lookups. Count intersections by iterating through smaller set and checking membership in larger set. Then use Union-Find for efficient component counting.

Brute Force with DFS — Algorithm Steps

Compare all pairs O(n²) to count intersections
Build adjacency list for valid edges
Use DFS to find connected components

Visualization

Tap to expand

Step-by-Step Walkthrough

Compare Pairs

Count common elements between all pairs of property arrays

Build Graph

Create edges for pairs with intersection >= k

Count Components

Use DFS to find connected components

Code -

solution.c — C

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

void dfs(int** graph, int* graph_sizes, bool* visited, int node) {
    visited[node] = true;
    for (int i = 0; i < graph_sizes[node]; i++) {
        int neighbor = graph[node][i];
        if (!visited[neighbor]) {
            dfs(graph, graph_sizes, visited, neighbor);
        }
    }
}

int solution(int** properties, int* propertySizes, int propertiesSize, int k) {
    int n = propertiesSize;
    if (n == 0) return 0;
    
    // Build adjacency list
    int** graph = (int**)malloc(n * sizeof(int*));
    int* graph_sizes = (int*)calloc(n, sizeof(int));
    int* graph_capacity = (int*)malloc(n * sizeof(int));
    
    for (int i = 0; i < n; i++) {
        graph[i] = (int*)malloc(10 * sizeof(int));
        graph_capacity[i] = 10;
    }
    
    // Compare all pairs to find edges
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            // Count intersection between properties[i] and properties[j]
            int intersection = 0;
            for (int x = 0; x < propertySizes[i]; x++) {
                for (int y = 0; y < propertySizes[j]; y++) {
                    if (properties[i][x] == properties[j][y]) {
                        intersection++;
                        break;  // Count each distinct value once
                    }
                }
            }
            
            if (intersection >= k) {
                // Add edge i-j
                if (graph_sizes[i] >= graph_capacity[i]) {
                    graph_capacity[i] *= 2;
                    graph[i] = (int*)realloc(graph[i], graph_capacity[i] * sizeof(int));
                }
                graph[i][graph_sizes[i]++] = j;
                
                // Add edge j-i
                if (graph_sizes[j] >= graph_capacity[j]) {
                    graph_capacity[j] *= 2;
                    graph[j] = (int*)realloc(graph[j], graph_capacity[j] * sizeof(int));
                }
                graph[j][graph_sizes[j]++] = i;
            }
        }
    }
    
    // Count connected components using DFS
    bool* visited = (bool*)calloc(n, sizeof(bool));
    int components = 0;
    
    for (int i = 0; i < n; i++) {
        if (!visited[i]) {
            dfs(graph, graph_sizes, visited, i);
            components++;
        }
    }
    
    // Cleanup
    for (int i = 0; i < n; i++) {
        free(graph[i]);
    }
    free(graph);
    free(graph_sizes);
    free(graph_capacity);
    free(visited);
    
    return components;
}

int main() {
    char buffer[10000];
    char line[5000];
    
    // Read first line (properties array)
    if (fgets(line, sizeof(line), stdin) == NULL) return 1;
    
    // Parse properties array
    int** properties = (int**)malloc(1000 * sizeof(int*));
    int* propertySizes = (int*)malloc(1000 * sizeof(int));
    int n = 0;
    
    char* p = line;
    // Skip first '['
    while (*p && *p != '[') p++;
    if (*p) p++;
    
    while (*p && *p != ']') {
        // Find inner '['
        while (*p && *p != '[') p++;
        if (*p != '[') break;
        p++; // Skip '['
        
        // Parse numbers in this inner array
        properties[n] = (int*)malloc(100 * sizeof(int));
        int count = 0;
        
        while (*p && *p != ']') {
            if (*p >= '0' && *p <= '9') {
                int num = 0;
                while (*p >= '0' && *p <= '9') {
                    num = num * 10 + (*p - '0');
                    p++;
                }
                properties[n][count++] = num;
            } else {
                p++;
            }
        }
        
        propertySizes[n] = count;
        n++;
        
        if (*p == ']') p++; // Skip ']'
    }
    
    // Read second line (k)
    if (fgets(line, sizeof(line), stdin) == NULL) return 1;
    int k = 0;
    char* p2 = line;
    while (*p2 >= '0' && *p2 <= '9') {
        k = k * 10 + (*p2 - '0');
        p2++;
    }
    
    int result = solution(properties, propertySizes, n, k);
    printf("%d\n", result);
    
    // Cleanup
    for (int i = 0; i < n; i++) {
        free(properties[i]);
    }
    free(properties);
    free(propertySizes);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × m)

Compare all n² pairs, each intersection takes O(m) time

⚠ Quadratic Growth

Space Complexity

O(n + E)

Adjacency list storage plus DFS recursion stack

⚡ Linearithmic Space

12.0K Views

Medium Frequency

~25 min Avg. Time

245 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

Brute Force with DFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler