Merge branch 'neetcode-gh:main' into main

Author: faithandlogic

.gitignore

@@ -0,0 +1 @@
+.DS_Store

200-Number-of-Islands.py

@@ -4,7 +4,6 @@ def numIslands(self, grid: List[List[str]]) -> int:
             return 0
 
         islands = 0
-        q = collections.deque()
         visit = set()
         rows, cols = len(grid), len(grid[0])
 

212-Word-Search-II.py

@@ -2,14 +2,25 @@ class TrieNode:
     def __init__(self):
         self.children = {}
         self.isWord = False
+        self.refs = 0
 
     def addWord(self, word):
         cur = self
+        cur.refs += 1
         for c in word:
             if c not in cur.children:
                 cur.children[c] = TrieNode()
             cur = cur.children[c]
+            cur.refs += 1
         cur.isWord = True
+        
+    def removeWord(self, word):
+        cur = self
+        cur.refs -= 1
+        for c in word:
+            if c in cur.children:
+                cur = cur.children[c]
+                cur.refs -= 1
 
 
 class Solution:
@@ -24,14 +35,18 @@ def findWords(self, board: List[List[str]], words: List[str]) -> List[str]:
         def dfs(r, c, node, word):
             if (r < 0 or c < 0 or 
                 r == ROWS or c == COLS or
-                board[r][c] not in node.children or (r, c) in visit):
+                board[r][c] not in node.children or
+                node.children[board[r][c]].refs < 1 or
+                (r, c) in visit):
                 return
 
             visit.add((r, c))
             node = node.children[board[r][c]]
             word += board[r][c]
             if node.isWord:
+                node.isWord = False
                 res.add(word)
+                root.removeWord(word)
 
             dfs(r + 1, c, node, word)
             dfs(r - 1, c, node, word)

26-Remove-Duplicates-from-Sorted Array.py

@@ -0,0 +1,16 @@
+class Solution(object):
+    def removeDuplicates(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        k = 0
+        i = 0
+        while i < len(nums):
+            val = nums[i]
+            while i + 1 < len(nums) and nums[i+1] == val:
+                nums.remove(val)
+                k += 1
+            i += 1
+        return len(nums)
+                

27-Remove-Element.py

@@ -0,0 +1,10 @@
+class Solution(object):
+    def removeElement(self, nums, val):
+        """
+        :type nums: List[int]
+        :type val: int
+        :rtype: int
+        """
+        for i in range(nums.count(val)): # loop how many val is in the list
+            nums.remove(val)  # remove each val one by one
+        return len(nums) # return len of nums

286-Walls-and-Gates.py

@@ -14,7 +14,13 @@ def addRooms(r, c):
                 return
             visit.add((r, c))
             q.append([r, c])
-        
+
+        for r in range(ROWS):
+            for c in range(COLS):
+                if rooms[r][c] == 0:
+                    q.append([r, c])
+                    visit.add((r, c))
+
         dist = 0
         while q:
             for i in range(len(q)):

323-Number-of-Connected-Components-in-an-Undirected-Graph.py

@@ -0,0 +1,19 @@
+class UnionFind:
+    def __init__(self):
+        self.f = {}
+    
+    def findParent(self,x):
+        y = self.f.get(x,x)
+        if x!=y:
+            y = self.f[x] = self.findParent(y) 
+        return y
+    
+    def union(self,x,y):
+        self.f[self.findParent(x)] = self.findParent(y)
+
+class Solution:
+    def countComponents(self, n: int, edges: List[List[int]]) -> int:
+        dsu = UnionFind()
+        for a,b in edges:
+            dsu.union(a,b)
+        return len(set(dsu.findParent(x) for x in range(n)))

416-Partition-Equal-Subset-Sum.py

@@ -15,4 +15,4 @@ def canPartition(self, nums: List[int]) -> bool:
                 nextDP.add(t + nums[i])
                 nextDP.add(t)
             dp = nextDP
-        return True if target in dp else False
+        return False

43-Number_of_Connected_Components_in_an_Undirected_Graph.py

@@ -0,0 +1,31 @@
+
+class Solution:
+    def count_components(self, n: int, edges: List[List[int]]) -> int:
+        parent = [i for i in range(n)]
+        rank = [1] * n
+
+        def find_union(node: int) -> None:
+            result = node
+            while result != parent[result]:
+                parent[result] = parent[parent[result]] # path compression
+                result = parent[result]
+            return result
+
+        def union(node_1: int, node_2: int):
+            parent_1 = find_union(node_1)
+            parent_2 = find_union(node_2)
+            if parent_1 == parent_2:
+                return 0
+            if rank[parent_2] < rank[parent_1]:
+                parent[parent_1] = parent_2
+                rank[parent_2] += rank[parent_1]
+            else:
+                parent[parent_2] = parent_1
+                rank[parent_1] += rank[parent_2]
+            return 1
+        
+        result = n
+        for node_1, node_2 in edges:
+            result -= union(node_1, node_2)
+        return result
+