๋ค์ด๊ฐ๊ธฐ ์ ์, ๋ฌธ์ ์์ ์ฃผ์ด์ง '์ ๋ ฌํ ๋์์ ๊ฐฏ์'๊ฐ ์ปค์ง๋ฉด ์ ๋ ฌ์ด ์ด๋ ต๋ค. ๊ทธ๊ฒ์ ๋ํ ํด๊ฒฐ์ฑ ์? ๋ถํ ์ ๋ณต ๊ธฐ๋ฒ(Divide-and-Conquer) STEP 1. ์๋ ๋ฌธ์ ๋ฅผ ๋ ๋ฆฝ์ ์ผ๋ก ํ ์ ์๋ ์์ ๋ฌธ์ ๋ก ๋๋(Divide) STEP 2. ๊ฐ๊ฐ์ ๋ฌธ์ ๋ฅผ ํ(Delegate) STEP 3. ๊ฐ๊ฐ์ ๋ฌธ์ ์ ๋ต์ ์ด์ฉํด ์๋ ๋ฌธ์ ์ ๋ต์ ๋ง๋ ๋ค.(Combine) ์ ๋ ฌ์ ์ํ ๋ถํ ์ ๋ณต ๊ธฐ๋ฒ์ ๋ํ์ ์ผ๋ก ๋ ๊ฐ์ง๊ฐ ์๋ค. 1. ๋ณํฉ ์ ๋ ฌ(Merge sort) 2. ํต ์ ๋ ฌ(Quick sort) ๋ณธ๊ฒฉ์ ์ผ๋ก ๋ณํฉ ์ ๋ ฌ์ ๋ํด ์์๋ณด์. ์๊ณ ๋ฆฌ์ฆ์ ๊ธฐ๋ณธ ์์ด๋์ด Divide - ์ ๋ ฌํ ๋ฆฌ์คํธ๋ฅผ ์ ์ชฝ ๋ฐ, ๋ค์ชฝ ๋ฐ์ผ๋ก ๋๋๋ค. Half Delegate(Front) - ์ ์ชฝ ๋ฐ์ ์ ๋ ฌํ๋ค. Half De..
์ฝ์ ์ ๋ ฌ - ์ด๋ฏธ ์ ๋ ฌ๋ ๋ถ๋ถ์ ํญ์ ์ ๋ ฌ๋์ด ์๋ค. - ์ฒ์์๋ ์ ๋ ฌ๋ ๋ถ๋ถ์ ์์๊ฐ 1๊ฐ - ๋งค๋ฒ, ์ ๋ ฌํ ๋ถ๋ถ์ ์์ 1๊ฐ๋ฅผ ์ด๋ฏธ ์ ๋ ฌ๋ ๋ถ๋ถ์ผ๋ก ์ฎ๊ธด๋ค. ์๊ฐ ๋ณต์ก๋ Θ(n^2) - ๊ฐ์ฅ ์ข์ ๋: ์ด๋ฏธ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ๋์ด ์์ ๋ -> ์ด n-1 ๋ฒ = Θ(n) - ์ต์ ์ ๊ฒฝ์ฐ: ์ญ์์ผ๋ก ์ ๋ ฌ๋์ด ์์ ๋ i๋ฒ์งธ ์์น์ ์์๋ฅผ ์ ๋ ฌ๋ ๋ถ๋ถ์ ์ถ๊ฐํ ๋, i-1 ๊ฐ์ ์์์ ๋ชจ๋ ๋น๊ตํด์ผํ๋ค. i = 2,3, ..., n์ผ ๋ ๊ฐ๊ฐ ๋น๊ตํด์ผํ ๊ฐ์๋ 1+ 2+ ... + n-1 = n(n-1)/2 = Θ(n^2) ์ฝ์ ์ ๋ ฌ Python ์ฝ๋ def insertionSort(): nums = list(map(int, input().split(' '))) for i in range(1, len(n..
๋ฒ๋ธ ์ ๋ ฌ: ๋งจ ์ผ์ชฝ ์์๋ถํฐ ๋ฐ๋ก ์ด์ํ ์์์ ๋น๊ตํด ๊ฐ๋ฉด์, ํฐ ์๊ฐ ์ค๋ฅธ์ชฝ์ผ๋ก ๊ฐ๋๋ก ๊ตํํจ. ๋งจ ๋๊น์ง ๊ฐ๋ฉด ๊ฐ์ฅ ํฐ ์์๋ฅผ ์ฐพ์ ๊ฒ์ด๋ฏ๋ก, ์ด ๊ณผ์ ์ ๋ค์ ๋๋จธ์ง n-1๊ฐ ์์ ๋ํด์ ๋ฐ๋ณต. ์๊ฐ๋ณต์ก๋: O(n^2) ๋ฒ๋ธ์ ๋ ฌ Python ์ฝ๋ def bubbleSort(): numbers = list(map(int, input().split(' '))) for i in range(0, len(numbers) - 1): for j in range(i+1, len(numbers)): if(numbers[i] > numbers[j]): tmp = numbers[j] numbers[j] = numbers[i] numbers[i] = tmp print(numbers) ์ ๋ ฅ ๋ฐ ์ถ๋ ฅ
BFS๋ ํ๋ฅผ ์ด์ฉํ ๋ฐ๋ณต ๊ตฌ์กฐ๋ก ๊ตฌํํ๋ค. ๋จผ์ ํ๋ฅผ ์ด์ฉํ BFS Pseudo code๋ฅผ ๋ณด๋ฉด์ ์ด๋ป๊ฒ ๊ตฌํํด์ผํ ์ง ์๊ฐํด๋ณด์. 1) ํ๋ฅผ ์ด์ฉํ BFS Pseudo code BFS(G, start_v) let Q be a queue label start_v as discovered Q.enqueue(start_v) while Q is not empty do v := Q.dequeue() if v is the goal then return v for all edges from v to w in G.adjacentEdges(v) do if w is not labeled as discovered then label w as discovered w.parent := v Q.enqueue(w) 2) ํ๋ฅผ ์ด..
1) ์ฌ๊ท๋ฅผ ์ด์ฉํ DFS ๊ตฌํ Pseudo code G๋ ๊ทธ๋ํ, v๋ ์ ์ (vertex)์ผ ๋, DFS(G,v) lable v as discovered for all directed edges from v to w that are in G.adjacentEdges(v) do if vertex w is not labeled as discovered then recursively call DFS(G,w) ์ฌ๊ท๋ฅผ ์ด์ฉํ DFS ๊ตฌํ Python code def recursive_dfs(v, discovered=[]): discovered.append(v) for w in graph[v]: if w not in discovered: discovered = recusrive_dfs(w, discovered) ..
- Total
- Today
- Yesterday
- DOM
- React Query
- ๋ฐ์ดํฐ๋ฒ ์ด์ค
- JavaScript
- leetcode
- ์๋ฐ์คํฌ๋ฆฝํธ
- DB
- state
- useState
- react
- mdn
- ์๋ฌ
- ์๋ฃ๊ตฌ์กฐ
- Browser
- github
- ์๊ณ ๋ฆฌ์ฆ
- ์ ๋ ฌ
- ๋ธ๋ผ์ฐ์
- CSS
- Context API
- error
- BOJ
- git
- ํ์ด์ฌ
- Python
- ๋ฆฌ์กํธ
- ํจ์
- Component
- ๊ทธ๋ํ
- zustand
์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | 3 | 4 | |||
5 | 6 | 7 | 8 | 9 | 10 | 11 |
12 | 13 | 14 | 15 | 16 | 17 | 18 |
19 | 20 | 21 | 22 | 23 | 24 | 25 |
26 | 27 | 28 | 29 | 30 | 31 |