Merge pull request #937 from Chaedie/main

[Chaedie] Week 7

longest-substring-without-repeating-characters/Chaedie.py

@@ -0,0 +1,22 @@
+"""
+Solution: 
+    1) for iteration 을 도는 동안 hash set 을 이용해 처음 발견한 원소들을 window set에 넣는다.
+    2) 중복되는 원소를 발견할 경우 해당 원소의 중복이 사라질때까지 left side 의 원소들을 하나씩 제거한다.
+
+Time: O(n^2) = O(n) (for iteration) * O(n) 최악의 경우 n만큼의 중복제거 
+Space: O(n) (모든 원소가 set에 들어갈 경우)
+"""
+
+
+class Solution:
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        window = set()
+        max_len = 0
+        l = 0
+        for r in range(len(s)):
+            while s[r] in window:
+                window.remove(s[l])
+                l += 1
+            window.add(s[r])
+            max_len = max(max_len, len(window))
+        return max_len

number-of-islands/Chaedie.py

@@ -0,0 +1,31 @@
+"""
+Solution: 
+    1) for 문을 돌면서 섬(1)인 경우 result 에 1을 더하고 dfs를 돌린다.
+    2) dfs 를 통해 섬 전체를 순회하며 0으로 만들어준다.
+    3) 섬의 갯수 result 를 return 한다.
+
+육지의 갯수 n
+Time: O(n) n회의 dfs 함수 실행 될 수 있음
+Space: O(n) n의 호출스택이 사용 될 수 있음
+"""
+
+
+class Solution:
+    def numIslands(self, grid: List[List[str]]) -> int:
+        ROWS, COLS = len(grid), len(grid[0])
+        result = 0
+
+        def dfs(i, j):
+            if i < 0 or i >= ROWS or j < 0 or j >= COLS or grid[i][j] == "0":
+                return
+            grid[i][j] = "0"
+            for dx, dy in [(0, 1), (0, -1), (-1, 0), (1, 0)]:
+                dfs(i + dx, j + dy)
+
+        for i in range(ROWS):
+            for j in range(COLS):
+                if grid[i][j] == "1":
+                    dfs(i, j)
+                    result += 1
+
+        return result

reverse-linked-list/Chaedie.py

@@ -0,0 +1,21 @@
+"""
+Solution:
+    1) next node를 저장합니다.
+    2) cur node 를 prev node 로 연결시킵니다.
+    3) cur node 가 prev node 가 됩니다.
+    4) cur node 는 next node 가 됩니다.
+Time: O(n)
+Space: O(1)
+"""
+
+
+class Solution:
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        prev = None
+        cur = head
+        while cur:
+            next = cur.next
+            cur.next = prev
+            prev = cur
+            cur = next
+        return prev

set-matrix-zeroes/Chaedie.py

@@ -0,0 +1,31 @@
+"""
+Solution: 
+    1) matrix를 순회하면서 0을 찾는다. 
+    2) 0일 경우 rows, cols set에 각 인덱스를 넣는다.
+    3) rows, cols 를 순회하면서 해당하는 row, col을 0으로 만들어준다.
+Time: O(nm) = O(nm) (순회) + 최대 O(nm) + 최대 O(nm)
+Space: O(n + m)
+"""
+
+
+class Solution:
+    def setZeroes(self, matrix: List[List[int]]) -> None:
+        """
+        Do not return anything, modify matrix in-place instead.
+        """
+        ROWS, COLS = len(matrix), len(matrix[0])
+        rows = set()
+        cols = set()
+        for i in range(ROWS):
+            for j in range(COLS):
+                if matrix[i][j] == 0:
+                    rows.add(i)
+                    cols.add(j)
+
+        for i in rows:
+            for j in range(COLS):
+                matrix[i][j] = 0
+
+        for j in cols:
+            for i in range(ROWS):
+                matrix[i][j] = 0

unique-paths/Chaedie.py

@@ -0,0 +1,33 @@
+"""
+1 0 0 0 0 0 0
+0 0 0 0 0 0 0
+0 0 0 0 0 0 0
+
+Solution: 
+    1) grid에서 0,0을 제외하곤 도달할 수 있는 방법이 left way + upper way 갯수밖에 없다고 생각했다.
+    2) 따라서 grid를 순회하며 grid index의 경계를 넘어가지 않을 경우 left way + upper way 갯수를 더해주었다.
+    3) 마지막 grid의 우하단의 값을 return 해주었습니다.
+Time: O(mn) (원소의 갯수)
+Space: O(mn) (원소의 갯수)
+"""
+
+
+class Solution:
+    def uniquePaths(self, m: int, n: int) -> int:
+        dp = []
+        for i in range(m):
+            dp.append([0] * n)
+        print(dp)
+
+        for i in range(m):
+            for j in range(n):
+                if i == 0 and j == 0:
+                    dp[i][j] = 1
+                    continue
+
+                up_value = 0 if i - 1 < 0 or i - 1 >= m else dp[i - 1][j]
+                left_value = 0 if j - 1 < 0 or j - 1 >= n else dp[i][j - 1]
+
+                dp[i][j] = up_value + left_value
+
+        return dp[m - 1][n - 1]