- ๋ณธ Repository์๋ ์ทจ์ ์ค๋น๋ฅผ ํ๋ฉด์ ๊ณต๋ถํ ์๋ฃ๊ตฌ์กฐ/์๊ณ ๋ฆฌ์ฆ์ ๊ฐ๋ ๋ฐ ์ค์ต, ์ฝ๋ฉํ ์คํธ ํ์ด ๋ฑ์ ๋ด์์ต๋๋ค. ์๋ ๋งํฌ ๋ฐ ๋ด์ฉ์ ์ง์์ ์ ๋ฐ์ดํธ ์์ ์ ๋๋ค.
- ์ ๋ ฅ๊ฐ์ ๋ฐ๋ฅธ ์ฐ์ฐ์ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ ๋ณ์์ ๋ฐ๋ผ ํ๊ธฐ
- ๊ฐ๋จํ ์ธ๋ฑ์ฑ
function O_1_algorithm(arr, index) {
return arr[index];
}
let arr = [1, 2, 3, 4, 5];
let index = 1;
let result = O_1_algorithm(arr, index);
console.log(result); // 2
- ์๊ฐ๋ณต์ก๋๊ฐ linearํ๊ฒ ์ฆ๊ฐ
- range ๊ธธ์ด๊ฐ n๊ฐ์ธ for๋ฌธ์ด ๋ํ์
- ์ ๋ค์ด ๊ฒ์์ ์๊ฐ
- BFS ์๊ณ ๋ฆฌ์ฆ์ด ๋ํ์
- ์ด์ค for๋ฌธ
- ์ฌ๊ทํจ์๊ฐ ๋ํ์ (ํผ๋ณด๋์ฐ)
function fibonacci(n) {
if (n <= 1) {
return 1;
}
return fibonacci(n - 1) + fibonacci(n - 2);
}
ํ๋์ ๋ฃจํ๋ฅผ ์ฌ์ฉํ์ฌ ๋จ์ผ ์์ ์งํฉ์ ๋ฐ๋ณต ํ๋ ๊ฒฝ์ฐ : O (n) ์ปฌ๋ ์ ์ ์ ๋ฐ ์ด์ ์ ๋ฐ๋ณต ํ๋ ๊ฒฝ์ฐ : O (n / 2) -> O (n) ๋ ๊ฐ์ ๋ค๋ฅธ ๋ฃจํ๋ฅผ ์ฌ์ฉํ์ฌ ๋ ๊ฐ์ ๊ฐ๋ณ ์ฝ๋ ์ ์ ๋ฐ๋ณต ํ ๊ฒฝ์ฐ : O (n + m) -> O (n) ๋ ๊ฐ์ ์ค์ฒฉ ๋ฃจํ๋ฅผ ์ฌ์ฉํ์ฌ ๋จ์ผ ์ปฌ๋ ์ ์ ๋ฐ๋ณตํ๋ ๊ฒฝ์ฐ : O (nยฒ) ๋ ๊ฐ์ ์ค์ฒฉ ๋ฃจํ๋ฅผ ์ฌ์ฉํ์ฌ ๋ ๊ฐ์ ๋ค๋ฅธ ์ฝ๋ ์ ์ ๋ฐ๋ณต ํ ๊ฒฝ์ฐ : O (n * m) -> O (nยฒ) ์ปฌ๋ ์ ์ ๋ ฌ์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ : O(n*log(n))
[https://blog.chulgil.me/algorithm/]

- key ๊ฐ๋ค์ด hash table์ ๊ฐ ๊ฐ์ mapping ๋จ
- ์ด๋ฌํ mapping์
hash function์ ์ํจ - hash table์ ๊ฐ ์นธ๋ค์ hash bucket์ด๋ผ๊ณ ํจ
[https://medium.com/@songjaeyoung92/%EC%9E%90%EB%A3%8C%EA%B5%AC%EC%A1%B0-javascript-hash-table-%EC%9D%B4%EB%9E%80-5f5345623dab]
- ๊ฐ์ value(hash bucket)์ mapping๋ ๊ฒฝ์ฐ, ์ด๋ฅผ collision(์ถฉ๋)์ด๋ผ๊ณ ํจ. ํ๋์ ๊ฒฝ์ฐ bucket์ ์ฐ๋ฌ์ ์ ์ฅํ๋ ๋ฐฉ๋ฒ์ด ์์
๊ตฌํ ๋ฐ ์ฝ๋ฉ?๐ค
- python์ dictionary ์๋ฃํ์ ์ด์ฉํ๋ฉด ๊ฐ key์ value๊ฐ์ ์์์๊ฐ(O(n))์ ์ ๊ทผ ๊ฐ๋ฅ
- value์ ์๋ฃํ์ ๋ฐ๋ผ defaultdict๋ฅผ ํ์ฉํ๋ฉด ์ง๊ด์ ์ธ(์งง์)์ฝ๋ฉ ๊ฐ๋ฅ
- value ์ป์ ๋ indexing
[index]๋ณด๋ค๋dict.get๋ฉ์๋๋ฅผ ์ฐ๋๊ฒ์ด ์๋ฌ๋ฅผ ๋ฐฉ์ง (์์ธ์ฒ๋ฆฌ ์ฉ์ด)
- binary tree ๋ฅผ ๊ฐ์
- ์ต์ํ ๋๋ ์ต๋ํ์ด ์๊ณ , ์๋ ์์๋ ์ต์ํ์ ๊ฐ์ ํ๊ณ ๋ ์์
- ์๊ฐ๋ณต์ก๋๊ฐ log(n) ์ผ๋ก ์ฐ์ ์์ ํ์ ๊ฐ์ ์๋ฃ๊ตฌ์กฐ๋ณด๋ค ํจ์จ์ ์ธ ์๊ณ ๋ฆฌ์ฆ ๊ตฌํ ๊ฐ๋ฅ
- ๊ณ ๋ ค๋ํ๊ต ๋์์๋ถ์์ฐ๊ตฌ์ค ๊ต์ก์๋ฃ ์ฐธ๊ณ .
import heapq as hp
x=[3,2,1,4,5]
hp.heapify(x) # heap์ผ๋ก ๋ง๋ฆ
print(x)
>> [1, 2, 3, 4, 5]
hp.heappush(x,3) # item ์ฝ์
print(x)
>> [1, 2, 3, 4, 5, 3] # binary tree์ ๋ง์ง๋ง ๋
ธ๋์ ์ถ๊ฐ๋จ
hp.heappop(x) # ์ต์๊ฐ ์ญ์ delete_min
print(x)
>> [2, 3, 3, 4, 5]
hp.heappushpop(x,1) # item ์ฝ์
ํ delete_min ์ํ
print(x)
>> [2, 3, 3, 4, 5] # 1์ด ์ต์์๊ธฐ์ ๊ทธ๋ญ ํ์ด๋์์
hp.heapreplace(x,1) #delete ๋จผ์ ํ๋ค์ item ์ฝ์
print(x)
>> [1, 3, 3, 4, 5] # 1๋ก ๋์ฒด๋์๋ค (replace)-
$$V$$ : Vertices( or Nodes) -
$$E$$ : edges (connect vertex and vertex)
์์ ๊ฐ์ด

- edge๋ vertice์ ์์ผ๋ก ํํ๋จ (a,b)
- edge๋ ๋ฐฉํฅ ๋๋ weight๋ฅผ ๊ฐ์ง ์ ์์
- degree ๋ vertice์ ๊ฐ์
๋ edge์ ์๋ฅผ ํํ
- loop : ๊ฐ์ vertice์ ์ฐ๊ฒฐ๋ edge
- ๊ทธ๋ํ๊ฐ edge๊ด๊ณ๋ฅผ ํ๋ ฌ๋ก ๋ํ๋ธ ๊ฒ
- ๋ฐฉํฅ์ด ์๋ ๊ทธ๋ํ์์๋ ๋์นญํ๋ ฌ์ ๊ผด์ ๋ณด์
- ๋๋น์ฐ์ ํ์
- queue์ ์๋ฃ๊ตฌ์กฐ ํ์ฉ
- ๋ฐฉ๋ฌธํ ๋ ธ๋๋ค์ ์ฐจ๋ก๋ก ์ ์ฅํ ํ ๊บผ๋ผ ์ ์๋ ์๋ฃ ๊ตฌ์กฐ์ธ ํ(Queue)๋ฅผ ์ฌ์ฉํจ
- ์ฆ ์ ์ ์ ์ถ(FIFO) ์์น์ผ๋ก ํ์
- ์ต๋จ๊ฒฝ๋ก ๋ฌธ์ ์ ์ ํฉ
- ๊น์ด ์ฐ์ ํ์
- stack ์๋ฃ๊ตฌ์กฐ ๋๋ Recursive algorithm์ผ๋ก ๊ตฌํ
- ๊ฒฝ๋ก์ ํน์ง์ ์ ์ฅํด๋ฌ์ผ ํ๋ ๋ฌธ์ ์ ์ ํฉ
- ๊ทธ๋ํ์ ๋ชจ๋ ์ ์ ์ ๋ฐฉ๋ฌธํ๋ ๊ฒ์ด ์ฃผ์ํ ๋ฌธ์ ๋ผ๋ฉด ์ด๋ ๊ฒ์ ์ฐ๋ ๋ ธ์๊ด
- ๊ฒ์ ๋์ ๊ทธ๋ํ๊ฐ ์ ๋ง ํฌ๋ค๋ฉด DFS๋ฅผ ๊ณ ๋ ค
- ๊ฒ์๋์์ ๊ท๋ชจ๊ฐ ํฌ์ง ์๊ณ , ๊ฒ์ ์์ ์ง์ ์ผ๋ก๋ถํฐ ์ํ๋ ๋์์ด ๋ณ๋ก ๋ฉ์ง ์๋ค๋ฉด BFS
- sorting1 - bubble sort, selection sort, insertion sort (๊ฐ๋ ๋ฐpython ์ค์ต)
- sorting2 - mergesort, quicksort, heapsort (๊ฐ๋ ๋ฐ python ์ค์ต)
- sorting3 - counting, radix, topological
- ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ ์๊ฐ๋ณต์ก๋ ๋น๊ต
์ ๋ ํ ์ ๐ ์ต์๊ฐ์ ๊ตฌํ๋ ค๋ฉด ๋งจ ์ฒ์์๋ ์ต๋ ๊ฐ์ ๊ณจ๋ผ์ ์ค์ ํด์ฃผ๊ณ ๋น๊ตํด๋๊ฐ๋ฉด์ ์ค์ ํด์ฃผ๋ ๋ฐฉ์์ด ์ข๋ค. dp ๋ฆฌ์คํธ๋ฅผ ์ ์ํ ๋ index ๊ฐ์ ๋งคํ๋๋ ๊ทธ ๊ฐ๋ถํฐ ์ ๋๋ก ์ ์ํ๋๊ฒ ํต์ฌ์ด๋ค. ๊ทธ๋ฌ๊ณ ๋๋ฉด ๋ฌธ์ ์ ์ค๋ง๋ฆฌ๊ฐ ๋ณด์ธ๋ค.
- ํจ์ ํธ์ถ์ด ๋๋ฌด ๋ง๋ค
- ๋์ผํ parameter๋ฅผ ๊ฐ๋ ํจ์ ํธ์ถ์ด ์ค๋ณต๋์ด ๋นํจ์จ์
- ์ ๋ณด๋ฅผ ๋ฏธ๋ฆฌ ์ ์ฅํด๋๊ณ ์์ ๋ฌธ์ ๋ถํฐ ํ๋ํ๋์ฉ ํด๊ฒฐํด๊ฐ๋ฉด ์ด๋จ๊น?
2๋ฅผ 8๋ฒ ๋ํ๋ฉด 16์ด๋ค. -> 2๋ฅผ 9๋ฒ ๋ํ ๋๋ ๋ค์ ๋ํ์ง ๋ง๊ณ 2๋ฅผ 8๋ฒ ๋ํ ๊ฒ์ 2๋ฅผ ๋ํ๋ฉด ๋ผ!

- Recursion : top-down์ผ๋ก task์ ๋งจ ์๋ถํฐ ํธ์ถ
- DP : sub instance์ธ F(0)๋ถํฐ ๊ทธ ๊ฒฐ๊ณผ๋ฅผ memoization์ ์ ์ฅ (bottom-up)
์ ๊ทธ๋ฆผ์ ์ฝ๋๋ก ๊ตฌํํด ๋ด ์๋ค.
#recursive
def fibonacci(x):
if x==0:
return 0
if x==1:
return 1
return fibonacci(x-1)+fibonacci(x-2)
fibonacci(8)
>>> 21
#dp
def fibonacci_dp(x):
dic = {}
dic[0] = 0
dic[1] = 1
for itr in range(2, x+1):
dic[itr] = dic[itr-2] + dic[itr-1]
return dic[x]
fibonacci_dp(8)
>>> 21
- dp๋ฅผ ์ฌ์ฉํ๋ฉด recursion๊ณผ ๋ฌ๋ฆฌ ๋งค 0,1 ๊ฒฐ๊ณผ๊ฐ์ผ๋ก ๊ทธ ๋ค์ ์คํ ๊ฐ์ ๊ณ์ ์ ์ฅํ๋ค.
- ์ฌ๊ธฐ์๋ memoization table๋ก dictionary ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ๋ค.
- ๋จ๊ณ๋ณ๋ก ํ ์ํฉ์์์ ์ต์ ํด๋ฅผ ์ ํ.
์ธ์ ์ ์ฉํด์ผ ํ๋?
- ์ต์ข ํด์ ์ต์ ์ฑ์ ์ํฅ์ ๋ฏธ์น์ง ์๋๋ค๋ ํ์ ์ด ์์ด์ผ ํจ.
- ๊ณตํต์ ์ผ๋ก ๊ฒฝ๋ก ์ฐพ๊ธฐ ๋ฌธ์ ์ ์ ํฉ.
- BFS : queue๋ก ๊ตฌํ
- ์ต๋จ๊ฒฝ๋ก์ ์ ํฉ
- DFS : ์ฌ๊ท๋ stack์ผ๋ก ๊ตฌํ
- ๊ฒฝ๋ก์ ํน์ง์ ์ ์ฅํด๋ ๋ ์ ํฉ












