Most Stones Removed with Same Row or Column

Most Stones Removed with Same Row or Column - Problem

Imagine you're playing a strategic stone removal game on an infinite 2D grid! You have n stones placed at various integer coordinates, with at most one stone per position.

The Rule: You can remove a stone if and only if there's at least one other stone that shares the same row OR the same column with it.

Your Goal: Remove as many stones as possible following this rule!

Given an array stones where stones[i] = [x_i, y_i] represents the coordinates of the i-th stone, return the maximum number of stones you can remove.

Key Insight: This isn't just about counting - it's about understanding connected components! Stones that can "reach" each other through shared rows/columns form groups, and from each group, you can remove all but one stone.

Input & Output

example_1.py — Basic Connected Groups

$ Input: stones = [[0,0],[0,1],[1,0],[1,2],[2,1],[2,2]]

› Output: 5

💡 Note: All stones are connected through shared rows/columns forming one component. We can remove 5 stones, leaving 1.

example_2.py — Multiple Components

$ Input: stones = [[0,0],[0,2],[1,1],[2,0],[2,2]]

› Output: 3

💡 Note: Two connected components: {[0,0],[2,0],[0,2],[2,2]} and {[1,1]}. Remove 3 from first group, 0 from second.

example_3.py — Single Stone

$ Input: stones = [[0,0]]

› Output: 0

💡 Note: Cannot remove the only stone as there's no other stone sharing its row or column.

Constraints

1 ≤ stones.length ≤ 1000
0 ≤ x_i, y_i ≤ 10⁴
No two stones are at the same coordinate point
All coordinates are integers

Visualization

Tap to expand

Understanding the Visualization

Identify Connections

Two stones are connected if they share the same row OR column

Find Components

Group all connected stones into separate components

Apply Strategy

From each component of size k, we can remove k-1 stones

Calculate Result

Sum up all removals: total_stones - number_of_components

Key Takeaway

🎯 Key Insight: Transform the problem into finding connected components. The answer is always total_stones - number_of_components, because from each component we must keep exactly one stone.

Asked in

G Google 42 f Facebook 28 a Amazon 31 ⊞ Microsoft 19

The key insight is that this is a connected components problem. Stones that share rows or columns form connected groups, and from each group we can remove all but one stone. The optimal Union-Find approach maps coordinates to unique IDs and efficiently finds components in O(n⋅α(n)) time.

Common Approaches

Approach	Time	Space	Notes
✓ Union-Find (Optimal)	O(n * α(n))	O(n)	Use Union-Find to efficiently group connected stones by rows and columns
Brute Force DFS	O(n²)	O(n)	Use DFS to find all connected components by checking every stone pair

Union-Find (Optimal) — Algorithm Steps

Create Union-Find data structure
Map row coordinates to unique IDs (0 to max_row)
Map column coordinates to unique IDs (max_row+1 to max_row+max_col+1)
For each stone, union its row_id and column_id
Count distinct root parents in Union-Find
Return total stones minus number of components

Visualization

Tap to expand

Step-by-Step Walkthrough

Map Coordinates

Assign unique IDs to rows and columns

Union Operations

Connect row and column IDs for each stone

Find Components

Count distinct root parents

Calculate Answer

Total stones minus components

Code -

solution.c — C

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

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

UnionFind* createUF(int n) {
    UnionFind* uf = malloc(sizeof(UnionFind));
    uf->parent = malloc(n * sizeof(int));
    uf->rank = calloc(n, sizeof(int));
    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]);
    }
    return uf->parent[x];
}

void unite(UnionFind* uf, int x, int y) {
    int px = find(uf, x), py = find(uf, y);
    if (px == py) return;
    
    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]++;
    }
}

int removeStones(int stones[][2], int stonesSize) {
    UnionFind* uf = createUF(20002);
    
    for (int i = 0; i < stonesSize; i++) {
        unite(uf, stones[i][0], stones[i][1] + 10001);
    }
    
    // Count unique roots - simplified for C
    int roots[10001] = {0};
    int count = 0;
    for (int i = 0; i < stonesSize; i++) {
        int root = find(uf, stones[i][0]);
        if (roots[root] == 0) {
            roots[root] = 1;
            count++;
        }
    }
    
    free(uf->parent);
    free(uf->rank);
    free(uf);
    
    return stonesSize - count;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * α(n))

Union-Find operations with path compression, where α is inverse Ackermann function (practically constant)

✓ Linear Growth

Space Complexity

O(n)

Union-Find parent array size proportional to coordinate range

⚡ Linearithmic Space

48.0K Views

Medium Frequency

~25 min Avg. Time

2.1K 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