Medium
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:
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:
Remove stone [2,2] because it shares the same row as [2,0].
Remove stone [2,0] because it shares the same column as [0,0].
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
class Solution {
private val roots = IntArray(20002)
fun removeStones(stones: Array<IntArray>): Int {
for (stone in stones) {
init(stone[0] + 1, roots)
init(stone[1] + 10000, roots)
union(stone[0] + 1, stone[1] + 10000)
}
val set: HashSet<Int> = HashSet()
for (n in roots) {
if (n == 0) {
continue
}
set.add(find(n))
}
return stones.size - set.size
}
private fun init(i: Int, roots: IntArray) {
if (roots[i] != 0) {
return
}
roots[i] = i
}
private fun union(i: Int, j: Int) {
val ri = find(i)
val rj = find(j)
if (ri == rj) {
return
}
roots[ri] = rj
}
private fun find(i: Int): Int {
var cur = i
while (cur != roots[cur]) {
cur = roots[roots[cur]]
}
return cur
}
}