์์์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ -ํ๋ฅผ ์ด์ฉ 1. ์ง์ ์ฐจ์๊ฐ 0์ธ ๋ชจ๋ ๋ ธ๋๋ฅผ ํ์ ๋ฃ๋๋ค. 2. ํ๊ฐ ๋น ๋๊น์ง ๋ค์์ ๊ณผ์ ์ ๋ฐ๋ณตํ๋ค. 1) ํ์์ ์์๋ฅผ ๊บผ๋ด ํด๋น ๋ ธ๋์์ ๋๊ฐ๋ ๊ฐ์ ์ ๊ทธ๋ํ์์ ์ ๊ฑฐํ๋ค. 2) ์๋กญ๊ฒ ์ง์ ์ฐจ์๊ฐ 0์ด ๋ ๋ ธ๋๋ฅผ ํ์ ๋ฃ๋๋ค. --> ๊ฒฐ๊ณผ์ ์ผ๋ก ๊ฐ ๋ ธ๋๊ฐ ํ์ ๋ค์ด์จ ์์๊ฐ ์์ ์ ๋ ฌ์ ์ํํ ๊ฒฐ๊ณผ์ ๊ฐ๋ค. (ํน์ง) - ์ฌ์ดํด์ด ์๋ ๋ฐฉํฅ๊ทธ๋ํ(DAG)์ฌ์ผ ํ๋ค. - ํ ๋จ๊ณ์์ ํ์ ์๋กญ๊ฒ ๋ค์ด๊ฐ๋ ์์๊ฐ 2๊ฐ ์ด์์ธ ๊ฒฝ์ฐ๊ฐ ์๋ค๋ฉด ์ฌ๋ฌ๊ฐ์ง ๋ต ์กด์ฌ. - ๋ชจ๋ ์์๋ฅผ ๋ฐฉ๋ฌธํ๊ธฐ ์ ์ ํ๊ฐ ๋น๋ค๋ฉด ์ฌ์ดํด์ด ์กด์ฌํ๋ค๊ณ ํ๋จํ ์ ์์ (์๊ฐ๋ณต์ก๋) - ์ฐจ๋ก๋๋ก ๋ชจ๋ ๋ ธ๋๋ฅผ ํ์ธํ๋ฉฐ ๊ฐ ๋ ธ๋์์ ๋๊ฐ๋ ๊ฐ์ ์ ์ฐจ๋ก๋๋ก ์ ๊ฑฐํ๋ฏ๋ก ์๊ฐ๋ณต์ก๋๋ O(V+E)์ด๋ค. ์์์ ๋ ฌ ์ฝ๋ from ..
์ต์ ์คํจ๋ ํธ๋ฆฌ๋ ์คํจ๋ ํธ๋ฆฌ์ค ๋ชจ๋ ๊ฐ์ค์น์ ํฉ์ด ์ต์์ธ ํธ๋ฆฌ์ด๋ค. (ํ๋ฆผ, ํฌ๋ฃจ์ค์นผ) 1. ํฌ๋ฃจ์ค์นผ ์๊ณ ๋ฆฌ์ฆ - ๊ฐ์ค์น๊ฐ ์ต์์ธ ๊ฐ์ ์ ํ๋์ฉ ์ ํํด ๋๊ฐ๋ ๊ฐ์ ๊ธฐ๋ฐ ์๊ณ ๋ฆฌ์ฆ์ด๋ค. ์ฌ์ดํด์ด ๋ฐ์ํ๋ ๊ฒฝ์ฐ์ ๋ํด์๋ ์์ธ ์ฒ๋ฆฌ๊ฐ ํ์ํ๋ค. def find_parent(a): # ๋ถ๋ชจ์ฐพ๊ธฐ if parent[a] == a: return a else: parent[a] = find_parent(parent[a]) return parent[a] def merge(a, b): x = find_parent(a) y = find_parent(b) if x != y: parent[x] = y return True return False v, e = map(int, input().split()) parent = d..
1. BFS def depth(tree,root): queue = deque() queue.append((root,1)) visit = [] count = 1 while queue: #while๋ฌธ์ ๋๋ฆฌ๋ ๋งํผ ๊น์ด ์ฆ๊ฐ v, count= queue.popleft() visit.append(v) for node in tree[v]: if node != '.' and node not in visit: queue.append((node,count+1)) return count ๊ฐ ๋ ธ๋์์์ count๋ฅผ ๊ณ์ ๋๋ ค์ฃผ๊ณ while๋ฌธ์ ๋น ์ ธ๋์์ ๋ ๋ง์ง๋ง count๋ฅผ ๋ฆฌํดํ๋ฉด ์ต๋ ๊น์ด๋ฅผ ๊ตฌํ ์ ์๋ค. 2. ์ฌ๊ท def depth(tree,root): if root =='.': return 0 left = d..
๋ง๊ทธ๋๋ก ๋ฏธ๋กํ์ ๋ฌธ์ ์๋ค. 1,1์์ n,m๊น์ง ์ด๋ํ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ์ฐพ์ผ๋ฉด ๋๋ค. ์ต์์ ์นธ ์๋ฅผ ์ถ๋ ฅํด์ผ ํ๊ธฐ ๋๋ฌธ์ BFS๋ฅผ ์ฌ์ฉํ์๋ค. from collections import deque def bfs(v): queue.append((0, 0)) dx = [0, 0, 1, -1] dy = [1, -1, 0, 0] while queue: x, y = queue.popleft() for i in range(4): # ์์๋ ธ๋ ํ์ ์ถ๊ฐํ๊ธฐ ์ํจ nx, ny = x + dx[i], y + dy[i] if 0
์์ ์์ ๋ฅผ 2์ฐจ์ ๋ฐฐ์ด๋ก ํํํ๋ฉด ์ด๋ ๊ฒ ๋๋ค. (์๋ฐฉํฅ์ด๋ฏ๋ก) matrix[i][j]๋ผ๋ฉด i์์ j๋ฅผ ๊ฐ ์ ์์ผ๋ฉด 1, ์๋๋ฉด 0์ด๋ค. def dfs(v): # v๊ฐ ์์์ print(v, end=' ') visit[v] = 1 # ๋ฐฉ๋ฌธํ ์ 1๋ก for i in range(1, n + 1): if visit[i] == 0 and matrix[v][i] == 1: # ๋ฐฉ๋ฌธ์ ์์ง ์ํ๊ณ v์์ i๋ก ๊ฐ์์๋ค๋ฉด dfs(i) # i๋ฅผ ๋ค์ v๋ก ํ๋ฉด์ dfs ๋ก ํ์ def bfs(v): queue = [v] # ๋ค๋ ค์ผ ํ ์ ์ ์ฅ visit[v] = 0 # ๋ฐฉ๋ฌธํ ์ 0์ผ๋ก( dfs๋ก ์ธํด 1๋ก ๋ฐ๋์ด ์์ผ๋ฏ๋ก) while queue: # ํ๊ฐ ๋น ๋๊น์ง v = queue.pop(0) print(v,..
์ ๊ตญ์ฌ์ฌ๋ฅผ ๋ฐ์์ผ ํ๋ n๋ช ์ ์ฌ๋์ด ์์ ๋ ์ฌ์ฌ๊ด๋ค์ ์ฌ์ฌํ ๋ ๊ฐ๊ฐ ์ฃผ์ด์ง times์ ๊ฐ์ ์๊ฐ์ด ์์๋๋ค. ์ด n๋ช ์ ์ฌ๋์ด ์ ๋ถ ๊ฒ์ฌ๋ฅผ ๋ฐ๋๋ฐ ๊ฑธ๋ฆฌ๋ ์ต์์ ์๊ฐ์ ๊ตฌํ๋ ๋ฌธ์ ์๋ค. ์ผ๋จ n๋ช ์ ์ฌ๋์ด ๊ฒ์ฌ๋ฐ๋๋ฐ ๊ฑธ๋ฆฌ๋ ์ต์ ์ ์๊ฐ์ ๊ฐ์ฅ ์ค๋ ์๊ฐ์ด ์์๋๋ ์ฌ์ฌ๊ด์๊ฒ ๋ชจ๋ ์ฌ๋์ด ๊ฒ์ฌ๋ฅผ ๋ฐ๋ ๊ฒฝ์ฐ์ด๋ค. ์ด์ง ํ์์ ์ด์ฉํด left = 0 right= ์ต์ ์ ์๊ฐ์ผ๋ก ํ์ฌ ๊ฐ์ฅ ์ต์๋ก ๊ฑธ๋ฆฌ๋ ์๊ฐ์ ์ฐพ๋๋ค. left = 0 right = max(time_list) * n # ๋ชจ๋ ์ฌ๋์ด ๋ค ๋ฐ์ ๋ ๋๋๋ ์๊ฐ์ ์ต์ ์ ๊ฒฝ์ฐ while left = n: answer = mid right = mid - 1 elif people < n: left = mid + 1 print(answer) ๋๋ ์ด์ง..
๋๋ ๋ธ๋ฃจํธํฌ์ค ๋ฐฉ์์ ์ด์ฉํด์ ๋ฌธ์ ๋ฅผ ํ์๋ค. ๊ทธ๊ฑฐ๋ฐ์ ์๊ฐ์ด ๋์ง ์์๋ค. ๋ชจ๋ ๊ฒฝ์ฐ๋ฅผ ํ์ํด๋ด์ผ ํ๋๋ฐ ๊ทธ ๋ฐฉ๋ฒ์ ์ฐพ๋ ๊ฒ๋ ์๊ณ ๋ฆฌ์ฆ ์ด๋ณด์ธ ๋์๊ฒ๋ ๋๋ฌด ์ด๋ ค์ ๋ค. ๋ชจ๋ ์์ด์ ํ์ํด์ผํ๋๋ฐ ์ด ๋ฐฉ๋ฒ์ ์ฐพ์๋ณด์๋ค. w[i][j]๊ฐ ๋์ i์์ j๋ก ๊ฐ๋ ๋น์ฉ์ด๋ผ๊ณ ํ์๊ธฐ ๋๋ฌธ์ w[i][i+1]๊ณผ ๊ฐ์ ๋ฐฉ์์ผ๋ก ๊ฑฐ๋ฆฌ๋น์ฉ์ ์ธ์ผ์ง ๋ชจ๋ ๋์๋ฅผ ๊ฒฝ์ ํ ์ ์๋ค. permutation์ ์ด์ฉํ์ฌ 0๋ถํฐ n-1๊น์ง์ ์๋ฅผ ์์ด๋ก ์ง๊ณ ๊ทธ ๊ฒฝ์ฐ์ ์๋ง๋ค์ ๋น์ฉ์ ๊ตฌํ๋ค. ์๋ฅผ ๋ค์ด ๋์๋ฅผ 0,1,2,3์ด ์๋ค๊ณ ํ ๋ perm = [3 1 2 0]์ด๋ผ๋ฉด 3->1 1->2 1->0์ผ๋ก ๊ฐ๋ ๋น์ฉ์ด๋ค. ๊ทธ๋ ๊ฒ ๋ชจ๋ ๊ฒฝ์ฐ๋ฅผ ๋ค ํ์ํด๋ณธ ํ ์ต์ ๋น์ฉ์ ๊ตฌํ๋ฉด ๋๋ค. import itertools n = int(..
์ฒ์์๋ ๋ฌธ์ ๊ฐ ์ดํด๊ฐ ์๊ฐ๋๋ฐ ๊ทธ๋ฅ A์ A๋ฅผ ์ง์ง๊ณ B์ B๋ฅผ ์ง์ง์์ ๋ ๊ฒน์น๋ ์ ์ด ์๊ณ ๋จ๋ ๋ฌธ์๊ฐ ์์ผ๋ฉด ์ข์ ๋ฌธ์๋ก ์ธ์ด์ฃผ๋ ๊ฒ์ด์๋ค. ์ด ๋ฌธ์ ๋ฅผ ํธ๋ ์๊ณ ๋ฆฌ์ฆ์ 1. ์คํ์ ๊ฐ์ ๋ฌธ์๊ฐ ๋ค์ด์ค๋ฉด pop 2. ์คํ์ ๋ค๋ฅธ ๋ฌธ์๊ฐ ๋ค์ด์ค๋ฉด push ํ๋ ๊ฒ์ด๋ค. ํ์ด์ฌ์ผ๋ก ์๊ณ ๋ฆฌ์ฆ์ ์ง๊ธฐ ์์ํ์ง ์ผ๋ง ๋์ง ์์ ๋ฆฌ์คํธ๊ฐ ๋น์ด์์ ๊ฒฝ์ฐ์ ๋ํ ์กฐ๊ฑด๋ฌธ์ ๋ง๋ค๋ ์๋์ ๊ฐ์ ์ฝ๋๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด len(stack)์ ์ฌ์ฉํ๋ ๊ฒ๋ณด๋ค ํจ์ฌ ๋์ ์ฝ๋๋ผ๋ ๊ฒ๋ ์๊ฒ ๋์๋ค. if not stack: ๊ทธ๋ฆฌ๊ณ ๋ฆฌ์คํธ์ ๋ง์ง๋ง ์์์ ์ ๊ทผํ ๋ stack[-1]์ฒ๋ผ ์ฌ์ฉํ๋ค๋ ๊ฒ์ ์๊ฒ ๋์๋ค. def main(): n = int(input()) word_list = [] stack=[] count = 0..
์ด ๋ฌธ์ ๋ ์๊ฐํ ๊ฒ ๋ณด๋ค ์ด๋ ค์ ๋ค. DP๋ก ํ์ด์ผ๊ฒ ๋ค๊ณ ์๊ฐ์ ํ๊ณ ์งฐ๋๋ฐ ๋ฐฐ์ด 1์์๋ถํฐ ์์ํ๋ ๋ ์ง ๊ณ์ฐ์ ์ด๋ป๊ฒ ํด์ผํ ์ง ๊ฐ์ด ์์๋ค. ๊ทธ๋์ ์๋ด์ก๋ ์์๋ฅผ ๋ง์ง๋ง๋ ์์๋ถํฐ ์์ํ์๋ค. ์ผ๋จ ์๋ด์ ์ก์์ ์๋ ๋ ๊ณผ ์๋ด์ ์ก์ ์ ์๋ ๋ ๋ก ์กฐ๊ฑด์ ๋๋๋ค. 1. ์๋ด์ ์ก์ผ๋ฉด ํด์ฌ์ผ์ ๋๊ธฐ๋ ๊ฒฝ์ฐ DP[i] = DP[i+1] ์ ๋ ์ ์ก์ ์๋ด ๊ฐ๊ฒฉ ๋์ 2. ์๋ด ์ก์ ์ ์๋ ๊ฒฝ์ฐ max(DP[i+1], DP[i+time[i]]+Price[i]) ์ ๋ ์ ์ก์ ์๋ด๊ฐ๊ฒฉ๊ณผ (์ค๋์๋ด๊ฐ๊ฒฉ+์๋ด์ผ์ง๋ํ์ ์๋ด๊ฐ๊ฒฉ) ์ค ํฐ ๊ฐ def main(): n = int(input()) max_price_list = [0 for _ in range(n + 2)] time_list = [0 for _ in ..
์ฒ์์๋ ๊ทธ๋ฅ ์กฐ๊ฑด๋ฌธ์ ๋ง๋ค์ด ๊ทธ๋ฆฌ๋์๊ณ ๋ฆฌ์ฆ ๋ฐฉ์์ผ๋ก ๊ณ์ ๊ทธ๋๊ทธ๋ ์์์๋ฅผ ๋ง๋ค๋ฉด์ ์ง๋ฉด ๋ ์ค ์์๋ค. ํ์ง๋ง 10์ ์ ๋ ฅ์ผ๋ก ๋ฃ์์ ๋ ์์ธ๊ฐ ๋ฐ์ํ์๊ณ ์ฐ์ ์์๋ฅผ ์ ํด๋๊ณ ์ง๋ ๋ฐฉ์์ผ๋ก๋ ํ๋ฉด ์๋๊ฒ ๋ค๋ ์๊ฐ์ด ๋ค์๋ค. ์์ ๋ฌธ์ ์์ ์๋ํ ํ์ด๋ฒ์ DP ์๊ณ ๋ฆฌ์ฆ์ ์ด์ฉํ๋ ๋ฐฉ์์ผ๋ก ์ ํ์์ ์ด์ฉํ๋ ๊ฒ์ด ๊ฐ์ฅ ์ข๋ค. DP(๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ)๋ ํฐ ๋ฌธ์ ๋ฅผ ์์ ๋ฌธ์ ๋ก ๋๋์ด ํธ๋ ๋ฐฉ๋ฒ์ด๋ค. ์ด ์์ ๋ฌธ์ ๋ค์ ์ด๋๊ฐ์ ์ ์ฅํด๋๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ด ์์ ๋ฌธ์ ๋ค์ ์ด์ฉํด์ ๋ต์ ๋์ถํด๋ธ๋ค. f(n/2)+1 f(n/3)+1 f(n-1)+1 ์ค ์ต์๊ฐ์ด f(n)์ ๊ฐ์ด ๋๋ค. ๋ถํ์ํ ์ฐ์ฐ์ ์ฌ๋ฌ๋ฒ ํ๋ ๊ฒ์ ๋ง๊ธฐ ์ํด ๋ฆฌ์คํธ์ ์ฐ์ฐํ์๋ฅผ ์ ์ฅํด๋๋๋ค. ์๋ฅผ ๋ค์ด 10์ ์ ๋ ฅํ์ ๊ฒฝ์ฐ ๋ฐฐ์ด ์ธ๋ฑ์ค 1๋ถํฐ 1..