Introduction

In this blog post, we will explore how to solve the LeetCode problem "947" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like Chatmagic, we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

Problem Statement

On a 2D plane, we place n stones at some integer coordinate points. Each coordinate point may have at most one stone. A stone can be removed if it shares either the same row or the same column as another stone that has not been removed. Given an array stones of length n where stones[i] = [xi, yi] represents the location of the ith stone, return the largest possible number of stones that can be removed. Example 1: Input: stones = [[0,0],[0,1],[1,0],[1,2],[2,1],[2,2]] Output: 5 Explanation: One way to remove 5 stones is as follows: 1. Remove stone [2,2] because it shares the same row as [2,1]. 2. Remove stone [2,1] because it shares the same column as [0,1]. 3. Remove stone [1,2] because it shares the same row as [1,0]. 4. Remove stone [1,0] because it shares the same column as [0,0]. 5. Remove stone [0,1] because it shares the same row as [0,0]. Stone [0,0] cannot be removed since it does not share a row/column with another stone still on the plane. Example 2: Input: stones = [[0,0],[0,2],[1,1],[2,0],[2,2]] Output: 3 Explanation: One way to make 3 moves is as follows: 1. Remove stone [2,2] because it shares the same row as [2,0]. 2. Remove stone [2,0] because it shares the same column as [0,0]. 3. Remove stone [0,2] because it shares the same row as [0,0]. Stones [0,0] and [1,1] cannot be removed since they do not share a row/column with another stone still on the plane. Example 3: Input: stones = [[0,0]] Output: 0 Explanation: [0,0] is the only stone on the plane, so you cannot remove it. Constraints: 1 <= stones.length <= 1000 0 <= xi, yi <= 104 No two stones are at the same coordinate point.

Explanation

Here's the solution to the problem:

• Key Idea: The problem can be modeled as finding connected components in a graph. Each stone is a node, and two stones are connected if they share the same row or column. The maximum number of removable stones is the total number of stones minus the number of connected components.

• Union-Find: We use the Union-Find (Disjoint Set Union) data structure to efficiently find connected components.

• Iterate and Union: Iterate through the stones. For each stone, union it with other stones that share the same row or column using the Union-Find data structure.

• Complexity:

  • Runtime: O(n), where n is the number of stones, assuming near-constant time for union and find operations due to path compression and rank optimization in Union-Find. In theory, it's closer to O(n * α(n)), where α(n) is the inverse Ackermann function, which grows extremely slowly and can be considered near-constant for practical input sizes.
  • Storage: O(n) to store the parent array in the Union-Find data structure.

Code

    class UnionFind:
    def __init__(self, n):
        self.parent = list(range(n))
        self.rank = [0] * n

    def find(self, x):
        if self.parent[x] != x:
            self.parent[x] = self.find(self.parent[x])  # Path compression
        return self.parent[x]

    def union(self, x, y):
        root_x = self.find(x)
        root_y = self.find(y)
        if root_x != root_y:
            if self.rank[root_x] < self.rank[root_y]:
                self.parent[root_x] = root_y
            elif self.rank[root_x] > self.rank[root_y]:
                self.parent[root_y] = root_x
            else:
                self.parent[root_y] = root_x
                self.rank[root_x] += 1
            return True  # Union happened
        return False   # Already in the same set


def removeStones(stones):
    n = len(stones)
    uf = UnionFind(n)
    removed_count = 0
    for i in range(n):
        for j in range(i + 1, n):
            if stones[i][0] == stones[j][0] or stones[i][1] == stones[j][1]:
                if uf.union(i, j):
                    removed_count += 1

    return removed_count