๐ฅ CS/Algorithm
[Algorithm] ํ | ์ต๋ ํ, ์ต์ ํ
heap์ด๋? : ์ฐ์ ์์ ํ(priority queue)๋ฅผ ๊ตฌํํ๊ธฐ ์ํด ์ฌ์ฉํ๋ ์๋ฃ๊ตฌ์กฐ ์ค ํ๋๋ก, ์์ ์ด์งํธ๋ฆฌ๋ฅผ base๋ก ํ ์๋ฃ๊ตฌ์กฐ. ์ฐ์ ์์ ํ๋ ์ฐ์ ์์๊ฐ ๊ฐ์ฅ ๋์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ฅ ๋จผ์ ์ญ์ ํ๋ ์ ์ด ํน์ง ์ต์ ํ: ๋ถ๋ชจ ๋ ธ๋์ ํค ๊ฐ์ด ์์ ๋ ธ๋์ ํค ๊ฐ๋ณด๋ค ํญ์ ์์ ํ ์ต๋ ํ: ๋ถ๋ชจ ๋ ธ๋์ ํค ๊ฐ์ด ์์ ๋ ธ๋์ ํค ๊ฐ๋ณด๋ค ํญ์ ํฐ ํ ์๋ฃ๊ตฌ์กฐ ์ถ์ถ๋๋ ๋ฐ์ดํฐ ์คํ(stack) ๊ฐ์ฅ ๋์ค์ ์ฝ์ ๋ ๋ฐ์ดํฐ ํ(queue) ๊ฐ์ฅ ๋จผ์ ์ฝ์ ๋ ๋ฐ์ดํฐ ์ฐ์ ์์ ํ(priority queue) ๊ฐ์ฅ ์ฐ์ ์์๊ฐ ๋์ ๋ฐ์ดํฐ ์ต์ ํ (min heap) : ๊ฐ์ด ๊ฐ์ฅ ๋ฎ์ ๋ฐ์ดํฐ๊ฐ ๋จผ์ ์ญ์ import heapq heap = [] heapq.heappush(heap, 5) heapq.heap..
[Algorithm] DFS & BFS | ๊ทธ๋ํ ํ์
โปํ์: ๋ง์ ๋ฐ์ดํฐ์์ ์ํ๋ ๋ฐ์ดํฐ๋ฅผ ์ฐพ๋ ๊ณผ์ ๊ทธ๋ํ ํ์์ ์ํ ์๋ฃ๊ตฌ์กฐ (1) ์คํ (2) ํ (3) ์ฌ๊ทํจ์ (4) ๊ทธ๋ํ DFS | ๊น์ด ์ฐ์ ํ์ : ๊น์ ๋ถ๋ถ์ ์ฐ์ ์ ์ผ๋ก ํ์ ๐ ํน์ ๊ฒฝ๋ก๋ก ํ์ํ๋ค๊ฐ ํน์ ์ํฉ์์ ์ต๋ํ ๊น์์ด ๋ค์ด๊ฐ์ ๋ ธ๋ ๋ฐฉ๋ฌธ ํ ๋ค์ ๋์๊ฐ ๋ค๋ฅธ ๋ ธ๋ ๋ฐฉ๋ฌธ (1) ํ์ ์์ ๋ ธ๋๋ฅผ ์คํ์ ์ฝ์ ํ๊ณ ๋ฐฉ๋ฌธ์ฒ๋ฆฌ โป ๋ฐฉ๋ฌธ์ฒ๋ฆฌ: ์คํ์ ํ๋ฒ ์ฝ์ ๋์ด ์ฒ๋ฆฌ๋ ๋ ธ๋๊ฐ ๋ค์ ์ฝ์ ๋์ง ์๊ฒ check (2) ์คํ์ ์ต์๋จ ๋ ธ๋์ ๋ฐฉ๋ฌธํ์ง ์์ ๋ ธ๋๊ฐ ์๋ค๋ฉด ๊ทธ ์ธ์ ๋ ธ๋๋ฅผ ์คํ์ pushํ๊ณ ๋ค์ ๋์๊ฐ ๋ค๋ฅธ ๋ ธ๋๋ฅผ ๋ฐฉ๋ฌธํ๋ค. (3) (2) ๊ณผ์ ์ ๋ฐ๋ณต ์ํํ๋ค. ๊ฒฐ๊ณผ์ ์ผ๋ก ๋ ธ๋์ ํ์ ์์๋ ์คํ์ ๋ค์ด๊ฐ ์์์ ๊ฐ๋ค. 1 → 2 → 5 →6 → 3 → 7 → 4 → 8 ์ฒซ ..
[Algorithm] ์๋ผํ ์คํ ๋ค์ค์ ์ฒด | ์์ ์ฐพ๊ธฐ
์์๋ฅผ ์ฐพ๋ ๋ฐฉ๋ฒ ์ค ํ๋์ธ ์๋ผํ ์คํ ๋ค์ค์ ์ฒด์ ๋ํด ์์๋ณด์ ์๋ฆฌ๋ ๋ค์๊ณผ ๊ฐ๋ค. ๐ก 0๋ถํฐ ๊ตฌํ๊ณ ์ํ๋ ์(n)๊น์ง True๋ก ์ฑ์ด ๋ฆฌ์คํธ๋ฅผ ์์ฑํ๋ค. ๐ก 2๋ฅผ ์ ์ธํ 2์ ๋ฐฐ์๋ฅผ False๋ก ๋ฐ๊พผ๋ค. ๐ก 3์ ์ ์ธํ 3์ ๋ฐฐ์๋ฅผ False๋ก ๋ฐ๊พผ๋ค. ๐ก 5๋ฅผ ์ ์ธํ 5์ ๋ฐฐ์๋ฅผ False๋ก ๋ฐ๊พผ๋ค. . . . ๐กn์ ์ต๋ ์ฝ์๋ sqrt(n) ์ดํ์ด๋ฏ๋ก sqrt(n)์ ๋ฐฐ์๋ฅผ ๋ชจ๋ False๋ก ๋ฐ๊พผ๋ค. ๐ก2~n๊น์ง์ ์ซ์ ์ค True์ธ ์ซ์๋ค์ด ์์๊ฐ ๋๋ค. ์ด๋ฅผ ์ฝ๋๋ก ๊ตฌํํ๋ฉด ๋ค์๊ณผ ๊ฐ๋ค. def isPrime(n): sieve = [True] * n # n์ ์ต๋ ์ฝ์๋ sqrt(n) ์ดํ m = int(n ** 0.5) for i in range(2, m+1): if sieve[i] == ..
[Algorithm] ์ด์ง ํ์ | Binary Search
1. ์์ฐจ ํ์ : ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ํ์ ๋ฐฉ๋ฒ - ๋ฆฌ์คํธ ์์ ์๋ ํน์ ๋ฐ์ดํฐ๋ฅผ ์ฐพ๊ธฐ ์ํด ์์์๋ถํฐ ํ๋์ฉ ํ์ธ - ์ ๋ ฌ๋์ง ์์ ๋ฆฌ์คํธ์์ ๋ฐ์ดํฐ๋ฅผ ์ฐพ์ ๋ ์ฌ์ฉ - ํ์ด์ฌ์ count() ๋ฉ์๋ ๋ด๋ถ์์ ์์ฐจ ํ์์ด ์ฌ์ฉ๋๋ค. ๐ ์๊ฐ ๋ณต์ก๋: O(n) # target = ์ฐพ๊ณ ์ํ๋ ์์ def search(n, target, array): for i in range(n): # ํ์ฌ์ ์์๊ฐ target๊ณผ ๋์ผํ๋ฉด if array[i] == target: return i # ํ์ฌ์ ์์น ์ธ๋ฑ์ค ๋ฐํ 2. ์ด์ง ํ์(์ด๋ถ ํ์) : ๋ฒ์๋ฅผ ์ ๋ฐ์ฉ ๋๋๋ฉฐ ํ์ํ๋ ๋ฐฉ๋ฒ - ๋ฐฐ์ด ๋ด๋ถ ๋ฐ์ดํฐ๊ฐ ์ ๋ ฌ๋์ด ์์ด์ผ ์ฌ์ฉ์ด ๊ฐ๋ฅ - ๋ณ์ 3๊ฐ ํ์: ์์์ , ๋์ , ์ค๊ฐ์ - ์ค๊ฐ์ ์ด ์ค์ ์ผ ๋๋ ์์์ ์ดํ..
[Algorithm] ์ ๋ ฌ | ์ ํ ์ ๋ ฌ, ์ฝ์ ์ ๋ ฌ, ํต ์ ๋ ฌ, ๊ณ์ ์ ๋ ฌ
์ ๋ ฌ์ด๋ ์ฃผ์ด์ง ๋ฐ์ดํฐ๋ฅผ ํน์ ๊ธฐ์ค์ ๋ฐ๋ผ ์์๋๋ก ๋์ดํ์ฌ ์ฌ๋ฐฐ์นํ๋ ๊ฒ์ ๋งํ๋ค. ์ ๋ ฌ๋ ๋ฐฐ์ด์์ ์ํ๋ ๊ฐ์ ํ์ํ๋ ์ด์ง ํ์(Binary Search)๋ฅผ ์ํด์๋ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ ์ ์์๋์ด์ผ ํ๋ค. 1. ์ ํ ์ ๋ ฌ ๐ ๊ฐ์ฅ ์์ ๋ฐ์ดํฐ๋ฅผ ์ ํํด ๋งจ ์์ ์๋ ๋ฐ์ดํฐ์ ๊ตํํ๋ ๊ณผ์ ์ ๋ฐ๋ณต swap(๋ฆฌ์คํธ์์ ๋ ์์์ ์์น๋ฅผ ๋ณ๊ฒฝํ๋ ์์ )์ ์ด์ฉํ๋ฉด ์ ํ์ ๋ ฌ์ ์ฝ๊ฒ ๊ตฌํํ ์ ์๋ค. arr = [4,3,1,7,2,8,6,5] for i in range(len(arr)): min_index = i # ์ฐ์ ๊ฐ์ฅ ์์ ์์์ ์ธ๋ฑ์ค๋ก ๋งจ ์์ ์์๋ฅผ ์ง์ for j in range(i+1, len(arr)): # ๋งจ ์ ์์ ์ ์ธ if arr[min_index] > arr[j]: # ๊ฐ์ฅ ์์ ..
[Algorithm] ๋์ ํ๋ก๊ทธ๋๋ฐ | Dynamic Programming (DP)
ํฐ ๋ฌธ์ ๋ฅผ ์๊ฒ ๋๋๊ณ , ๊ฐ์ ๋ฌธ์ ๋ผ๋ฉด ํ ๋ฒ์ฉ๋ง ํ์ด ๋ฌธ์ ๋ฅผ ํจ์จ์ ์ผ๋ก ํด๊ฒฐํ๋ ์๊ณ ๋ฆฌ์ฆ ๊ธฐ๋ฒ ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ์ ์ฌ์ฉํ๋ ์ด์ 1. ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ๋ ์ฌ์ฉํ๋๋ผ๋, ์ฐ์ฐ ์๋๋ฅผ ์ฆ๊ฐ์ํค๊ธฐ ์ํด 2. ์ค๋ณต๋๋ ์ฐ์ฐ์ ์ค์ด๊ธฐ ์ํด ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ์ ์ฌ์ฉ ์กฐ๊ฑด 1. ์ต์ ๋ถ๋ถ ๊ตฌ์กฐ (Optimal Substructure) - ํฐ ๋ฌธ์ ๋ฅผ ์์ ๋ฌธ์ ๋ก ๋๋ ์ ์์ผ๋ฉฐ ์์ ๋ฌธ์ ์ ๋ต์ ๋ชจ์์ ํฐ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์์ ๋ 2. ์ค๋ณต๋๋ ๋ถ๋ถ ๋ฌธ์ - ๋์ผํ ์์ ๋ฌธ์ ๋ฅผ ๋ฐ๋ณต์ ์ผ๋ก ํด๊ฒฐํ ์ ์์ ๋ ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ ๋ฌธ์ ์ ๊ทผ ๋ฐฉ๋ฒ - ๊ทธ๋ฆฌ๋, ๊ตฌํ, ์์ ํ์ ๋ฑ์ผ๋ก ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์๋ ์ง ๊ฒํ ํ ํ ๋ ์ค๋ฅด์ง ์๋๋ค๋ฉด ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ์ ๊ณ ๋ คํด๋ณธ๋ค. - ์ฌ๊ท ํจ์๋ก ์์ฑํด๋ณธ ํ, ์์ ๋ฌธ์ ์์ ..