947_Most_Stones_Removed_with_Same_Row_or_Column

Author: Partho Biswas

README.md

@@ -498,6 +498,7 @@ BFS, DFS, Dijkstra, Floyd–Warshall, Bellman-Ford, Kruskal, Prim's, Minimum Spa
 |26| **[752. Open the Lock](https://tinyurl.com/yxpwjn7r)** | [Python](https://tinyurl.com/wu6rdaw/752_Open_the_Lock.py)| **[Art 1](https://tinyurl.com/s3oskv8)**, **[Art 2](https://tinyurl.com/rsr4tz9)** | Medium |📌 **TODO: CHECK again. Very important  and interesting problem. Loved it** |
 |27| **[489. Robot Room Cleaner](https://tinyurl.com/yxpwjn7r)** | [Python](https://tinyurl.com/wu6rdaw/489_Robot_Room_Cleaner.py), [Swift](https://tinyurl.com/wuja3c4/489_Robot_Room_Cleaner.swift) | **[Vid 1](https://tinyurl.com/vahalvm)**, **[Vid 2](https://tinyurl.com/qpumkro)**, **[Art 1](https://tinyurl.com/rnu8679)** | Hard |📌 **TODO: CHECK again. Very important  and interesting problem. I fucking loved it** |
 |28| **[1136. Parallel Courses](https://tinyurl.com/yxpwjn7r)** | [Python](https://tinyurl.com/wu6rdaw/11136_Parallel_Courses.py), [Swift](https://tinyurl.com/wuja3c4/11136_Parallel_Courses.swift) | --- | Hard |📌 Topological sort. |
+|29| **[947. Most Stones Removed with Same Row or Column](https://tinyurl.com/rrm6w2a)** | [Python](https://tinyurl.com/wu6rdaw/947_Most_Stones_Removed_with_Same_Row_or_Column.py), [Swift](https://tinyurl.com/wuja3c4/947_Most_Stones_Removed_with_Same_Row_or_Column.swift) | [Vid 1](https://tinyurl.com/sc2g6eg), [Art 1](https://tinyurl.com/sxyzxkr), [Vid 2](https://tinyurl.com/wocnrhn), [Art 2](https://tinyurl.com/sogsj74), [Art 3](https://tinyurl.com/w4pk463) | Medium |📌 DFS and Union FInd |
 
 
 </p>

leetcode.com/python/200_Number_of_Islands.py

@@ -7,6 +7,7 @@ class Solution(object):
     # Class to represent
     # Disjoint Set Data structure
     class DisjointUnionSets(object):
+
         def __init__(self, n):
             self.rank = [0] * n
             self.parent = [0] * n
@@ -20,9 +21,7 @@ def makeSet(self):
             for i in range(self.n):
                 self.parent[i] = i
 
-                # Finds the representative of the set that x
-
-        # is an element of
+        # Finds the representative of the set that x is an element of
         def find(self, x):
             if (self.parent[x] != x):
                 # if x is not the parent of itself,
@@ -34,9 +33,7 @@ def find(self, x):
                 return self.find(self.parent[x])
             return x
 
-            # Unites the set that includes x and
-
-        # the set that includes y
+        # Unites the set that includes x and the set that includes y
         def Union(self, x, y):
 
             # Find the representatives(or the root nodes)
@@ -60,7 +57,6 @@ def Union(self, x, y):
             # remains less
             elif self.rank[yRoot] < self.rank[xRoot]:
                 self.parent[yRoot] = xRoot
-
             else:
 
                 # Else if their ranks are the same
@@ -72,6 +68,7 @@ def Union(self, x, y):
                 # rank by 1
                 self.rank[xRoot] = self.rank[xRoot] + 1
 
+
     # Returns number of islands in a[][]
     def numIslands(self, grid):
         """
@@ -134,56 +131,56 @@ def numIslands(self, grid):
 
 
 
-# # Approach 2: Using DFS - Accepted
-# class Solution(object):
-#     def numIslands(self, grid):
-#         """
-#         :type grid: List[List[str]]
-#         :rtype: int
-#         """
-#         sizes = []
-#         visited = [[False for value in row] for row in grid]
-#         for i in range(len(grid)):
-#             for j in range(len(grid[i])):
-#                 if visited[i][j]:
-#                     continue
-#                 else:
-#                     self.traverseNode(i, j, grid, visited, sizes)
-#         return len(sizes)
-#
-#
-#     def traverseNode(self, i, j, grid, visited, sizes):
-#         currentRiverSize = 0
-#         nodesToExplore = [[i, j]]
-#         while len(nodesToExplore):
-#             currentNode = nodesToExplore.pop()
-#             i = currentNode[0]
-#             j = currentNode[1]
-#             if visited[i][j]:
-#                 continue
-#             visited[i][j] = True
-#             if grid[i][j] == "0":
-#                 continue
-#             currentRiverSize += 1
-#             unvisitedNeighbours = self.getUnvisitedNeighbour(i, j, grid, visited)
-#             for neighbour in unvisitedNeighbours:
-#                 nodesToExplore.append(neighbour)
-#         if currentRiverSize > 0:
-#             sizes.append(currentRiverSize)
-#
-#
-#
-#     def getUnvisitedNeighbour(self, i, j, grid, visited):
-#         unvisitedNeighbours = []
-#         if i > 0 and not visited[i - 1][j]:
-#             unvisitedNeighbours.append([i - 1, j])
-#         if i < len(grid) - 1 and not visited[i + 1][j]:
-#             unvisitedNeighbours.append([i + 1, j])
-#         if j > 0 and not visited[i][j - 1]:
-#             unvisitedNeighbours.append([i, j - 1])
-#         if j < len(grid[0]) - 1 and not visited[i][j + 1]:
-#             unvisitedNeighbours.append([i, j + 1])
-#         return unvisitedNeighbours
+# Approach 2: Using DFS - Accepted
+class Solution(object):
+    def numIslands(self, grid):
+        """
+        :type grid: List[List[str]]
+        :rtype: int
+        """
+        sizes = []
+        visited = [[False for value in row] for row in grid]
+        for i in range(len(grid)):
+            for j in range(len(grid[i])):
+                if visited[i][j]:
+                    continue
+                else:
+                    self.traverseNode(i, j, grid, visited, sizes)
+        return len(sizes)
+
+
+    def traverseNode(self, i, j, grid, visited, sizes):
+        currentRiverSize = 0
+        nodesToExplore = [[i, j]]
+        while len(nodesToExplore):
+            currentNode = nodesToExplore.pop()
+            i = currentNode[0]
+            j = currentNode[1]
+            if visited[i][j]:
+                continue
+            visited[i][j] = True
+            if grid[i][j] == "0":
+                continue
+            currentRiverSize += 1
+            unvisitedNeighbours = self.getUnvisitedNeighbour(i, j, grid, visited)
+            for neighbour in unvisitedNeighbours:
+                nodesToExplore.append(neighbour)
+        if currentRiverSize > 0:
+            sizes.append(currentRiverSize)
+
+
+
+    def getUnvisitedNeighbour(self, i, j, grid, visited):
+        unvisitedNeighbours = []
+        if i > 0 and not visited[i - 1][j]:
+            unvisitedNeighbours.append([i - 1, j])
+        if i < len(grid) - 1 and not visited[i + 1][j]:
+            unvisitedNeighbours.append([i + 1, j])
+        if j > 0 and not visited[i][j - 1]:
+            unvisitedNeighbours.append([i, j - 1])
+        if j < len(grid[0]) - 1 and not visited[i][j + 1]:
+            unvisitedNeighbours.append([i, j + 1])
+        return unvisitedNeighbours
 
 
 

leetcode.com/python/305_Number_of_Islands_II.py

@@ -8,6 +8,7 @@ class Solution(object):
     # Class to represent
     # Disjoint Set Data structure
     class DisjointUnionSets(object):
+
         def __init__(self, n):
             self.rank = [0] * n
             self.parent = [0] * n
@@ -21,9 +22,7 @@ def makeSet(self):
             for i in range(self.n):
                 self.parent[i] = i
 
-                # Finds the representative of the set that x
-
-        # is an element of
+        # Finds the representative of the set that x is an element of
         def find(self, x):
             if (self.parent[x] != x):
                 # if x is not the parent of itself,
@@ -35,9 +34,7 @@ def find(self, x):
                 return self.find(self.parent[x])
             return x
 
-            # Unites the set that includes x and
-
-        # the set that includes y
+        # Unites the set that includes x and the set that includes y
         def Union(self, x, y):
 
             # Find the representatives(or the root nodes)
@@ -61,7 +58,6 @@ def Union(self, x, y):
             # remains less
             elif self.rank[yRoot] < self.rank[xRoot]:
                 self.parent[yRoot] = xRoot
-
             else:
 
                 # Else if their ranks are the same
@@ -118,7 +114,6 @@ def numIslands2(self, m, n, positions):
 
 
 # SOURCE:   https://tinyurl.com/qohtl3m
-
 class UnionFind(object):
     def __init__(self):
         self.parents = {}

leetcode.com/python/947_Most_Stones_Removed_with_Same_Row_or_Column.py

@@ -0,0 +1,69 @@
+# Source: https://tinyurl.com/sxyzxkr
+# Approach 1: DFS
+class Solution(object):
+    def removeStones(self, stones):
+        """
+        :type stones: List[List[int]]
+        :rtype: int
+        """
+        if len(stones) < 2:
+            return 0
+        disJointSetCount, visited = 0, set()
+        for x, y in stones:
+            if (x, y) not in visited:
+                self.DFS(stones, visited, x, y)
+                disJointSetCount += 1
+        return len(stones) - disJointSetCount
+
+    def DFS(self, stones, visited, x, y):
+        if (x, y) not in visited:
+            visited.add((x, y))
+            for nextX, nextY in stones:
+                if x == nextX:
+                    self.DFS(stones, visited, x, nextY)
+                if y == nextY:
+                    self.DFS(stones, visited, nextX, y)
+
+
+
+
+# Approach 2: Union Find
+class Solution(object):
+
+    class DisjointUnionSets(object):
+        def __init__(self, numberOfSets):
+            self.rank = [0 for _ in range(numberOfSets)]
+            self.parent = [i for i in range(numberOfSets)]
+            self.numberOfSets = numberOfSets
+
+        def find(self, setElement):
+            parentOfSetElement = self.parent[setElement]
+            if parentOfSetElement != setElement:
+                return self.find(parentOfSetElement)
+            return parentOfSetElement
+
+        def union(self, elementA, elementB):
+            parentA, parentB = self.find(elementA), self.find(elementB)
+            if parentA == parentB:
+                return
+            if self.rank[parentA] >= self.rank[parentB]:
+                self.parent[parentB] = parentA
+                self.rank[parentA] += self.rank[parentB]
+            else:
+                self.parent[parentA] = parentB
+                self.parent[parentB] += self[parentA]
+            self.numberOfSets -= 1
+
+    def removeStones(self, stones):
+        """
+        :type stones: List[List[int]]
+        :rtype: int
+        """
+        numberOfStones = len(stones)
+        disjointSet = self.DisjointUnionSets(numberOfStones)
+        for i in range(len(numberOfStones)):
+            for j in range(i + 1, numberOfStones):
+                if (stones[i][1] == stones[j][1]) or (stones[i][0] == stones[j][0]):
+                    disjointSet.union(i, j)
+
+        return numberOfStones - disjointSet.numberOfSets