Merge pull request #487 from kjb512/main

[kayden] Week 07 Solutions

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

@@ -0,0 +1,20 @@
+class Solution:
+    # 시간복잡도: O(N)
+    # 공간복잡도: O(N)
+    # set에서 제외하는 로직을 없애기 위해, map을 사용해서 idx값을 저장후, start와 비교해서 start보다 작은 idx를 가진 경우에는 중복이 아니라고 판단했습니다.
+    def lengthOfLongestSubstring(self, s: str) -> int:
+
+        last_idx = {}
+        answer = 0
+        start = 0
+
+        for idx, ch in enumerate(s):
+            # 중복 조회시 idx값과 start 값 비교를 통해, 삭제하는 로직을 없이 중복을 확인했습니다.
+            if ch in last_idx and last_idx[ch] >= start:
+                start = last_idx[ch] + 1
+                last_idx[ch] = idx
+            else:
+                answer = max(answer, idx - start + 1)
+                last_idx[ch] = idx
+
+        return answer

number-of-islands/kayden.py

@@ -0,0 +1,36 @@
+# 시간복잡도: O(M*N)
+# 공간복잡도: O(M*N)
+
+from collections import deque
+
+
+class Solution:
+    def numIslands(self, grid: List[List[str]]) -> int:
+        dx = [0, 0, -1, 1]
+        dy = [-1, 1, 0, 0]
+        m = len(grid)
+        n = len(grid[0])
+        q = deque()
+
+        def bfs(a, b):
+            q.append((a, b))
+            while q:
+                x, y = q.popleft()
+
+                for i in range(4):
+                    nx = x + dx[i]
+                    ny = y + dy[i]
+                    if not (0 <= nx < m and 0 <= ny < n): continue
+
+                    if grid[nx][ny] == '1':
+                        grid[nx][ny] = '0'
+                        q.append((nx, ny))
+
+        count = 0
+        for i in range(m):
+            for j in range(n):
+                if grid[i][j] == '1':
+                    count += 1
+                    bfs(i, j)
+
+        return count

reverse-linked-list/kayden.java

@@ -0,0 +1,26 @@
+/**
+* Definition for singly-linked list.
+* public class ListNode {
+*     int val;
+*     ListNode next;
+*     ListNode() {}
+*     ListNode(int val) { this.val = val; }
+*     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+* }
+*/
+// 시간복잡도: O(N)
+// 공간복잡도: O(1)
+class Solution {
+    public ListNode reverseList(ListNode head) {
+        ListNode prev = null;
+
+        while (head != null){
+            ListNode next = head.next;
+            head.next = prev;
+            prev = head;
+            head = next;
+        }
+
+        return prev;
+    }
+}

set-matrix-zeroes/kayden.py

@@ -0,0 +1,23 @@
+# 시간복잡도: O(m*n)
+# 공간복잡도: O(m+n)
+class Solution:
+    def setZeroes(self, matrix: List[List[int]]) -> None:
+        m = len(matrix)
+        n = len(matrix[0])
+
+        rows = set()
+        cols = set()
+
+        for i in range(m):
+            for j in range(n):
+                if matrix[i][j] == 0:
+                    rows.add(i)
+                    cols.add(j)
+
+        for row in rows:
+            for j in range(n):
+                matrix[row][j] = 0
+
+        for col in cols:
+            for i in range(m):
+                matrix[i][col] = 0

unique-paths/kayden.py

@@ -0,0 +1,17 @@
+from math import comb
+class Solution:
+    # 시간복잡도: O(m+n)
+    # 공간복잡도: O(1)
+    def uniquePaths(self, m: int, n: int) -> int:
+        return comb(m+n-2, n-1) # m+n-2Cn-1
+
+    # 시간복잡도: O(m*n)
+    # 공간복잡도: O(n)
+    def uniquePaths2(self, m: int, n: int) -> int:
+        dp = [1] * n
+
+        for _ in range(1, m):
+            for j in range(1, n):
+                dp[j] = dp[j-1] + dp[j]
+
+        return dp[n-1]