=(search)
Search ํ์#
[](YOUR URL HERE)
- vs ์ต๋จ๊ฒฝ๋ก, ์ต์๋น์ฉ ๋ฌธ์
ํ์ ๋ฌธ์ ๋ ๊ทธ๋ํ์์ ๊ฒฝ๋ก๋ฅผ ์ฐพ๋ ๊ฒ์ด ์ฃผ๋ ๋ชฉํ๋ค. ๊ฒฝ๋ก๋ฅผ ์ฐพ๊ธฐ๋ง ํ๋ฉด ๋๋ ๊ฒ์ด๊ณ , ๊ฒฝ๋ก๊ฐ ๊ฐ์ค์น๊ฐ ์์ผ๋ฉด(๋น์ฉ์ด๋ผ๋๊ฐ, ๊ฑฐ๋ฆฌ๋ผ๋๊ฐ) ์ต๋จ ๊ฒฝ๋ก ํน์ ์ต์ ๋น์ฉ์ ๊ฒฝ๋ก๋ฅผ ์ฐพ๋ ๋ฌธ์ ๊ฐ ๋๋ค. ์ด๊ฒ(๋ค์ต์คํธ๋ผ, ๋ฒจ๋ง ํฌ๋)๋ค์ ๋ํ ๊ฒ์ ๋ฐ๋ก ํ๊ณ , ๊ฒฝ๋ก๋ฅผ ์ฐพ๋ ๋ฌธ์ ์ ๋ํด์๋ง ๋ค๋ฃจ๊ฒ ๋ค.
- vs Greedy
๋ณดํต ๋ ๊ฐ์ง๋ก ๋๋๋ค. (1) ๋ชจ๋ ๊ฒฝ๋ก ์ฐพ๊ธฐ, (2) ํน์ ๊ฒฝ๋ก ์ฐพ๊ธฐ. ๋ ๋ค ๋ชจ๋ ๊ฒฝ๋ก๋ฅผ ์ดํด๋ณด๋ ๊ฒ์ด ํ์ ๋ฌธ์ ์ ๋ณธ์ง์ด๋ผ๊ณ ํ ์ ์๋ค. Greedy๋์ ๋ค๋ฅด๋ค. Greedy๋ ๊ทธ๋๊ทธ๋ ์ต์ ์ ์ ํ์ ํ๋ ๊ฒ์ด๊ณ , ํด๋น ์ ํ์ ๋ชจ๋ ๊ฒฝ๋ก ์ค์ ์ต์ ์ ๊ฒฝ๋ก๋ฅผ ๋ณด์ฅํ ๋ ์ฌ์ฉํ ์ ์๋ค. ํ์ง๋ง ํ์์ ๋ชจ๋ ๊ฒฝ์ฐ๋ฅผ ์ดํด๋ด์ผ๋ง ํ๋ ๊ฒฝ์ฐ์ ์ฌ์ฉํ๋ค.
- When?
(๊ฐ์ค์น ์์ผ๋ฉด์) ๋ชจ๋ ๊ฒฝ์ฐ ๊ตฌํ ๋ DFS
๊ฒ์ ๋์ ๊ทธ๋ํ๊ฐ ๋๋ฌด ํฌ๋ฉด DFS
(๊ฐ์ค์น ์์ผ๋ฉด์) ์ต๋จ๊ฑฐ๋ฆฌ๋ฅผ ๊ตฌํด์ผํ ๋๋ BFS
๊ฒ์ ๋์์ด ๊ท๋ชจ๊ฐ ์๊ณ , ์์ ์ง์ ๋ถํฐ ๋ฉ์ง ์๋ค๋ฉด BFS
Breadth First Search#
๋๋น ์ฐ์ ํ์ ์ ์ ๋ค๊ณผ ๊ฐ์ ๋ ๋ฒจ์ ์๋ ๋ ธ๋๋ค(ํ์ ๋ ธ๋)์ ๋จผ์ ํ์ํ๋ ๋ฐฉ์ ๋ณดํต queue๋ฅผ ์ด์ฉํ์ฌ ๊ตฌํํ๋ค. ์ด๋ฅผ ์ํด deque๋ฅผ ์ฌ์ฉํ๋ค.
๊ทธ๋ ๋ค๋ฉด ์ด๊ฑธ ์ด๋ป๊ฒ ํด์ผํ ๊น?
from collections import deque
def bfs(graph, start, visited):
queue = deque([start])
visited[start] = True
while queue:
v = queue.popleft()
for i in graph[v]:
if not visited[i]:
queue.append(i)
visited[i] = True
visited = [False]*9
bfs(graph, 1, visited)
Depth First Search#
๊น์ด ์ฐ์ ํ์
backtracking#
P : root node
C : child node
void CheckNode(node P)
{
node C;
if (promising(P)) {
if (there is a solution of P),
then writhe the solution
else {
for (each child node C of P) {
checkNodeยฉ
}
}
}\
else
backtrack to parent node P
}\