Merge pull request #1484 from taurus09318976/main

[taurus09318976] WEEK 07 Solutions

Author: taurus09318976

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

@@ -0,0 +1,49 @@
+'''
+해결 방법 : 
+1) 슬라이딩 윈도우 기법을 사용해 중복 없는 가장 긴 부분 문자열을 찾음
+2) char_index 딕셔너리로 각 문자의 마지막 등장 위치를 추적함
+3) 중복 문자를 발견하면 start를 중복 문자의 다음 위치로 이동시킴
+
+시간 복잡도: O(n) 
+    문자열을 한 번씩 순회
+공간 복잡도: O(min(m, n)) 
+    (m=문자 집합 크기, 보통 O(1)로 간주)
+
+Example 1.의 경우 s = "abcabcbb"
+
+단계	end	문자	start	char_index	                max_length
+0	    0	a	    0	    {'a':0}	                    1   
+1	    1	b	    0	    {'a':0, 'b':1}	            2
+2	    2	c	    0	    {'a':0, 'b':1, 'c':2}	    3
+3	    3	a	    1	    {'a':3, ...}	            3
+4	    4	b	    2	    {'b':4, ...}	            3
+5	    5	c	    3	    {'c':5, ...}	            3
+6	    6	b	    5	    {'b':6, ...}	            3
+7	    7	b	    7	    {'b':7, ...}	            3
+
+'''
+
+class Solution:
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        char_index = {}  # 각 문자의 최근 위치 저장
+        start = 0         # 현재 윈도우 시작 인덱스
+        max_length = 0    # 최대 길이
+        
+        # 문자열 끝까지 순회
+        for end in range(len(s)):
+            # 중복 문자 확인 -> start 갱신 & 현재 문자 위치 기록          
+            if s[end] in char_index and char_index[s[end]] >= start:
+                # 중복 문자 발견: 시작점을 중복 문자 다음으로 이동
+                start = char_index[s[end]] + 1
+            # 현재 문자의 위치 갱신
+            char_index[s[end]] = end
+            # 현재 윈도우 길이 계산
+            current_length = end - start + 1
+            if current_length > max_length:
+                # max_length 갱신
+                max_length = current_length
+        
+        return max_length
+
+
+  

number-of-islands/taurus09318976.py

@@ -0,0 +1,55 @@
+'''
+문제 의도: 
+2차원 grid에서 '1'로 연결된 부분의 개수를 세는 문제임
+'1'이 상하좌우로 연결되어 있으면 같은 섬임
+'0'은 바다임
+
+해결 방법: 
+모든 칸을 하나씩 확인하면서, '1'을 만나면 섬 개수를 1 증가시키고,
+그 섬에 속한 모든 '1'을 '0'으로 바꿔줌(방문 표시).
+이때 DFS(깊이 우선 탐색)로 연결된 섬을 모두 방문함.
+
+시간 복잡도: O(m × n)
+    모든 칸을 한 번씩만 방문함
+공간 복잡도: O(m × n) (최악의 경우 재귀 호출 스택)
+    땅이 모두 연결되어 있으면 재귀 깊이가 m×n까지 갈 수 있음
+'''
+class Solution:
+    def numIslands(self, grid: List[List[str]]) -> int:
+        # grid가 비어있으면 섬이 없으니 0 반환
+        if not grid:
+            return 0
+
+        # 행과 열의 개수 저장
+        rows = len(grid)
+        cols = len(grid[0])
+
+        # 섬의 개수 세는 변수
+        count = 0
+
+        # (x,y) 위치에서 상하좌우로 연결된 모든 섬을 방문하는 함수
+        def dfs(x, y):
+            # 범위를 벗어나거나, 이미 방문했거나, 바다면 함수 종료
+            if x < 0 or x >= rows or y < 0 or y >= cols or grid[x][y] == "0":
+                return
+            grid[x][y] = "0"  # 방문 표시(섬을 물로 바꿔서 중복 방문 방지)
+            
+            # 상하좌우로 이동하며 연결된 섬을 모두 방문
+            dfs(x+1, y)
+            dfs(x-1, y)
+            dfs(x, y+1)
+            dfs(x, y-1)
+
+        # 모든 칸을 하나씩 확인 
+        for i in range(rows):
+            for j in range(cols):
+
+                # 새로운 섬 발견하면 count 1 증가, 깊이우선탐색으로 연결된 섬 모두 방문
+                if grid[i][j] == "1":  
+                    count += 1
+                    dfs(i, j)  
+        # 섬의 개수 반환
+        return count
+
+
+

reverse-linked-list/taurus09318976.py

@@ -0,0 +1,45 @@
+'''
+문제 의도 : linked list가 주어졌을 때, 이 리스트를 순서를 반대로 해서 반환하는 문제임
+해결 방법 : 리스트를 처음부터 끝까지 한번씩 돌면서 각 노드의 다음 노드를 이전 노드로 바꿔주면 됨
+
+시간 복잡도: O(n)
+    리스트의 모든 노드를 한 번씩만 방문하므로
+공간 복잡도: O(1)
+    추가로 사용하는 변수는 prev, curr, next_temp 세 개뿐임
+
+Example 1.의 경우
+
+단계	prev	curr	next_temp	리스트 상태
+1	   None	    1	    2	        1 → None, 2 → 3 → 4 → 5
+2	    1	    2	    3	        2 → 1 → None, 3 → 4 → 5
+3	    2	    3	    4	        3 → 2 → 1 → None, 4 → 5
+4	    3	    4	    5	        4 → 3 → 2 → 1 → None, 5
+5	    4	    5	    None	    5 → 4 → 3 → 2 → 1 → None
+
+'''
+
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+
+class Solution:
+    def reverseList(self, head: Optional[ListNode]):
+        prev = None           # 이전 노드를 저장할 변수. 맨 처음엔 아무것도 없으므로 None으로 시작
+        curr = head           # 현재 작업할 노드를 head(리스트의 첫번째 노드)로 시작함
+
+        # 현재 노드가 None이 아닐 때(= 끝까지 가지 않았을 때) 반복함
+        while curr:           
+            # 현재 노드의 다음 노드를 임시로 저장함(다음 줄에서 연결을 바꿔버리기 때문).
+            next_temp = curr.next   
+            # 현재 노드의 next를 이전 노드로 바꿔줌(=화살표 방향을 뒤집는 역할)
+            curr.next = prev        
+            # prev를 현재 노드로 이동
+            prev = curr             
+            # curr를 다음 노드로 이동시킴
+            curr = next_temp        
+        # 반복이 끝나면 prev가 역순으로 바뀐 리스트의 첫 번째 노드(새로운 head)가 됨
+        return prev           
+
+
+

set-matrix-zeroes/taurus09318976.py

@@ -0,0 +1,41 @@
+'''
+문제의도 : m x n 크디의 2차원 행렬에서 어떤 칸에 0이 있으면 그 칸이 속한 행과 열 전체를 0으로 바꿔야 함
+조건 : 새로운 배열을 만들지 않고 원래 matrix에서 직접 바꿔야 함
+
+해결방법 : 
+1) 먼저 0이 있는 행과 열을 따로 기록해둠
+2) 그 다음, 기록된 행과 열을 모두 0으로 만듬
+
+시간 복잡도: O(m × n)
+    행렬의 모든 칸을 한 번씩 확인하므로
+공간 복잡도: O(m + n)
+    0이 있는 행과 열 번호를 저장하는 데 최대 (행 개수 + 열 개수)만큼 공간이 필요하므로
+
+'''
+
+class Solution:
+    def setZeroes(self, matrix: List[List[int]]):
+        rows = len(matrix)  # 행렬의 행 개수를 구함
+        cols = len(matrix[0]) # 행렬의 열 개수를 구함
+        zero_rows = set()  # 0이 있는 행 번호를 저장할 집함
+        zero_cols = set()  # 0이 있는 열 번호를 저장할 집합
+
+        # 모든 행과 열을 돌면서 0이 있으면 해당 행과 열 번호를 기록함
+        for i in range(rows):
+            for j in range(cols):
+                if matrix[i][j] == 0:
+                    zero_rows.add(i)
+                    zero_cols.add(j)
+
+        # 0이 있는 행을 모두 0으로 바꿈
+        for i in zero_rows:
+            for j in range(cols):
+                matrix[i][j] = 0
+
+        # 0이 있는 열을 모두 0으로 바꿈
+        for j in zero_cols:
+            for i in range(rows):
+                matrix[i][j] = 0
+
+
+                

unique-paths/taurus09318976.py

@@ -0,0 +1,24 @@
+'''
+조건 : 로봇은 오른쪽 또는 아래로만 이동 가능
+경로 수 = 위쪽에서 내려온 경로 + 왼쪽에서 온 경로
+dp[j] = 현재 행의 j열까지 도달하는 경로 수
+
+시간 복잡도: O(m×n)
+    모든 셀을 한 번씩 계산하므로
+공간 복잡도: O(n) 
+    1차원 배열만 사용하므로
+'''
+
+class Solution:
+    def uniquePaths(self, m: int, n: int):
+        dp = [1] * n  # 첫 번째 행은 모든 열에 도달하는 경로가 1개(오른쪽으로만 이동하므로)
+        
+        for i in range(1, m):      # 2번째 행부터 마지막 행까지 순회
+            for j in range(1, n):  # 2번째 열부터 마지막 열까지 순회
+                dp[j] += dp[j-1]   # 왼쪽 셀값(왼쪽방향 경로) + 현재 값(위쪽 방향 경로)
+        
+        return dp[-1]  # 마지막 셀 값이 총 경로 수
+
+
+
+