๋ฌธ์ ์์ฝ๋์ฐ์ด๋ ์บ ํผ์ค์์ ๋ง๋ ์ ์๋ ์น๊ตฌ์ ์๋ฅผ ์๊ณ ์ถ์ดํ๋ค. ์บ ํผ์ค๋ ( N \times M ) ํฌ๊ธฐ์ด๋ฉฐ, ๋์ฐ์ด๋ ๋น ๊ณต๊ฐ('O')๊ณผ ์ฌ๋('P')์ด ์๋ ๊ณณ์ผ๋ก ์ด๋ํ ์ ์๋ค. ๋ฒฝ('X')์ ์ด๋ํ ์ ์๋ค. ๋์ฐ์ด๊ฐ ์์ํ๋ ์์น๋ 'I'๋ก ์ฃผ์ด์ง๋ค. ๋์ฐ์ด๊ฐ ๋ง๋ ์ ์๋ ์ฌ๋์ ์๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ๋ ๋ฌธ์ ์ด๋ค.์
๋ ฅ์ฒซ ๋ฒ์งธ ์ค์ ์บ ํผ์ค์ ํฌ๊ธฐ๋ฅผ ๋ํ๋ด๋ ๋ ์ ์ ( N )๊ณผ ( M )์ด ์ฃผ์ด์ง๋ค.๋ค์ ( N )๊ฐ์ ์ค์ ์บ ํผ์ค์ ์ ๋ณด๊ฐ ์ฃผ์ด์ง๋ค. 'O'๋ ๋น ๊ณต๊ฐ, 'X'๋ ๋ฒฝ, 'I'๋ ๋์ฐ์ด์ ์์ ์์น, 'P'๋ ์ฌ๋์ด๋ค.์ถ๋ ฅ๋์ฐ์ด๊ฐ ๋ง๋ ์ ์๋ ์ฌ๋์ ์๋ฅผ ์ถ๋ ฅํ๋ค. ๋ง์ฝ ์๋ฌด๋ ๋ง๋์ง ๋ชปํ ๊ฒฝ์ฐ "TT"๋ฅผ ์ถ๋ ฅํ๋ค. ํ์ด ์ค๋ช
์ด ๋ฌธ์ ๋ BFS(๋๋น ์ฐ์ ํ์)๋ฅผ..
BFS
๋ฌธ์ ์์ฝ์ง๋์์ ๊ฐ ์ง์ ์ ๋ํด ๋ชฉํ ์ง์ (๊ฐ์ด 2์ธ ์ง์ )๊น์ง์ ๊ฑฐ๋ฆฌ๋ฅผ ๊ตฌํ๋ ๋ฌธ์ ์ด๋ค. ์ง๋๋ ๊ฐ๋ก์ ์ธ๋ก๋ก๋ง ์์ง์ผ ์ ์์ผ๋ฉฐ, 0์ ๊ฐ ์ ์๋ ๋
, 1์ ๊ฐ ์ ์๋ ๋
, 2๋ ๋ชฉํ ์ง์ ์ ์๋ฏธํ๋ค. ํ์ด ์ค๋ช
์ด ๋ฌธ์ ๋ ๋๋น ์ฐ์ ํ์(BFS)๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ ์ง์ ์์ ๋ชฉํ ์ง์ ๊น์ง์ ์ต๋จ ๊ฑฐ๋ฆฌ๋ฅผ ๊ตฌํ๋ ๋ฌธ์ ์ด๋ค.BFS๋ ์ต๋จ ๊ฑฐ๋ฆฌ๋ฅผ ๊ตฌํ๋ ๋ฐ ์ ํฉํ ์๊ณ ๋ฆฌ์ฆ์ด๋ค. from collections import dequeimport sysinput = sys.stdin.readlinen, m = map(int, input().split())graph = [list(map(int, input().split())) for _ in range(n)]def bfs(graph, n, m): distan..
๋ฌธ์ ์์ฝ๋ณด๋ ๊ฒ์์์ ํ๋ ์ด์ด๋ ์ฃผ์ฌ์๋ฅผ ๊ตด๋ ค 1๋ฒ ์นธ์์ 100๋ฒ ์นธ๊น์ง ์ด๋ํด์ผ ํ๋ค.์ฌ๋ค๋ฆฌ๋ ๋์ฐฉํ๋ฉด ๋ ๋์ ๋ฒํธ๋ก ์ด๋ํ๊ณ , ๋ฑ์ ๋ ๋ฎ์ ๋ฒํธ๋ก ์ด๋ํ๊ฒ ํ๋ค.100๋ฒ ์นธ์ ๋์ฐฉํ๊ธฐ ์ํด ์ฃผ์ฌ์๋ฅผ ์ต์ ๋ช ๋ฒ ๊ตด๋ ค์ผ ํ๋์ง ๊ตฌํ๋ค. ํ์ดfrom collections import dequeimport sysinput = sys.stdin.readlinedef snakes_and_ladders(N, M, ladders, snakes): board = list(range(101)) # ๋ณด๋์ ๊ฐ ์นธ ์ด๊ธฐํ for start, end in ladders.items(): board[start] = end # ์ฌ๋ค๋ฆฌ ์ค์ for start, end in snakes.it..

๋ฌธ์ ์์ฝ๋ค ๊ฐ์ ๋ช
๋ น์ด D, S, L, R ๊ฐ ์๋ ๊ณ์ฐ๊ธฐ๋ ์ ์ A, B๊ฐ ์ฃผ์ด์ก์ ๋, A๋ฅผ B๋ก ๋ฐ๊พธ๋ ์ต์ํ์ ๋ช
๋ น์ด ์์ฑ-> BFSBFS๋ผ๋ ๊ฑด ์ด๋ ต์ง ์๊ฒ ์๊ฐํด๋ผ ์ ์์๋๋ฐ.. ์ด ๋ฌธ์ ์์ ๊ฐ์ฅ ์ด๋ ค์ ๋ ์ ์ ์๊ฐ ์ด๊ณผ์๋ค. ์๊ฐ ์ด๊ณผ ํ์ดfrom collections import dequedef D(n): return (2 * n) % 10000def S(n): return n - 1 if n != 0 else 9999def L(n): n = f"{n:04}" # ๋ค ์๋ฆฟ์๋ก ๋ง์ถ๊ธฐ return int(n[1:] + n[0])def R(n): n = f"{n:04}" # ๋ค ์๋ฆฟ์๋ก ๋ง์ถ๊ธฐ return int(n[-1] + n[:-1])def bfs(..

ํ์ด 1: ํ๋ก์ด๋-์์
ํ๋ก์ด๋-์์
: ๋ชจ๋ ์ ์ ์ ์ต๋จ ๊ฑฐ๋ฆฌ ๊ณ์ฐ์๊ฐ ๋ณต์ก๋๋ O(N^3) - ์ด ๋ฌธ์ ๋ N ์ต๋๊ฐ 100์ด๋ฏ๋ก ์ด ๋ฌธ์ ์์ ์ฌ์ฉํ ์ ์๋ค.import sysinput = sys.stdin.readlineN, M = map(int, input().split())# ๊ฑฐ๋ฆฌ ๋ฐฐ์ด ์ด๊ธฐํINF = sys.maxsizedist = [[INF] * (N+1) for _ in range(N+1)]# ์์ ๊ณผ์ ๊ฑฐ๋ฆฌ๋ 0์ผ๋กfor i in range(1, N+1): dist[i][i] = 0# ์น๊ตฌ ๊ด๊ณ ์
๋ ฅfor _ in range(M): A, B = map(int, input().split()) dist[A][B] = 1 dist[B][A] = 1# ํ๋ก์ด๋-์์
for k ..
๋ฐฉํฅ ์๋ ๊ทธ๋ํ ์ฃผ์ด์ง -> ์ฐ๊ฒฐ ์์(connected component) ๊ฐ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ ์์ด๋์ด๊ทธ๋ํ ํ์ (DFS/BFS)๋ฐฉ๋ฌธ ๋ชปํ ๋
ธ๋ ํ๋๋ผ๋ ์๋ค๋ฉด ์นด์ดํธ ์ฆ๊ฐํ๊ณ ๊ทธ ๋ฐฉ๋ฌธ ๋ชปํ ๋
ธ๋ (false ๋
ธ๋)์์ ์์ํด์ ๋ค์ ๊ทธ๋ํ ํ์false ๋
ธ๋ ์์ ๋๊น์ง ๊ทธ๋ํ ํ์ ๋ฐ๋ณต ํ์ด - DFS ์ฌ์ฉimport sysinput = sys.stdin.readlineN, M = map(int, input().split())graph = [[] for _ in range(N+1)]for _ in range(M): u, v = map(int, input().split()) graph[u].append(v) graph[v].append(u)visited = [False] * (N+..
๋ฌธ์ ์์ฝ์๋น ํ์ฌ ์์น N, ๋์ ํ์ฌ ์์น K, 0๋ถํฐ 100,000 ๊น์ง์ ์ ์์๋น์ด๊ฐ ๋์์ ์ฐพ์ ์ ์๋ ๊ฐ์ฅ ๋น ๋ฅธ ์๊ฐ ๊ตฌํ๊ธฐ.์๋น์ด๊ฐ ์ด๋ํ ์ ์๋ ๊ฑด 3๊ฐ์ง : X-1, X+1, 2*X ํ์ด์์ ๋
ธ๋์ ์ฐ๊ฒฐ๋ ๋
ธ๋๋ 3๊ฐ, ๊ฐ ๋
ธ๋์์ 1์ด๊ฐ ์ง๋ ๋๋ง๋ค ํ๋์ฉ ์ด๋ํ๋ค๊ฐ,๋ชฉํ ๋
ธ๋์ ๋์ฐฉํ๋ฉด ๊ฑธ๋ฆฐ ์๊ฐ ๋ฆฌํด-> BFS๋ก ํ์ดํ ์ ์๋ค def bfs(n, k): if n == k: # ๊ฐ๋ค๋ฉด ๊ฑธ๋ฆฐ ์๊ฐ 0 return 0 visited = [False] * 100001 # ์
๋ ฅ ๊ฐ ๋ฒ์๋ณด๋ค ํฌ๊ฒ queue = deque([(n, 0)]) # n์๋ ํ์ฌ ๋
ธ๋ ์์น, 0์๋ ๊ฑธ๋ฆฐ ์๊ฐ ์ ์ฅ while queue: cur, time = queu..
๋ฌธ์ ์์ฝn * m ์ฌ์ด์ฆ ํ ๋งํ ๋ณด๊ด ์์์ต์ ํ ๋งํ ์ธ์ ํ ๊ณณ์ ์๋ ๊ฑด ์ํฅ ๋ฐ์ ์ต๊ฒ ๋จ.์ฐฝ๊ณ ์ ๋ณด๊ดํ ํ ๋งํ ๋ค์ด ์ต์ ๋ฉฐ์น ์ง๋๋ฉด ๋ค ์ต๊ฒ ๋๋์ง!๋จ, ์์์ ์ผ๋ถ ์นธ์๋ ํ ๋งํ ๊ฐ ๋ค์ด์์ง ์์ ์๋ ์๋ค. M,N์ 2๋ถํฐ 10001์ ์ต์ ํ ๋งํ , 0์ ์ ์ต์ ํ ๋งํ , -1์ ํ ๋งํ ์์ํ ๋งํ ๋ ์ต์ ํ๋ ์๋ค๊ณ ํ๋ค. ๋ชจ๋ ์ต์ ๋๊น์ง์ ์ต์ ๋ ์ง๋ฅผ ์ถ๋ ฅํ๋,๋ชจ๋ ํ ๋งํ ๊ฐ ์ต์ด์๋ค๋ฉด 0 ์ถ๋ ฅ, ๋ชจ๋ ์ต์ง ๋ชปํ๋ ์ํฉ์ด๋ผ๋ฉด -1์ ์ถ๋ ฅํ๋ค. ํ์ด์ด ๋ฌธ์ ๋ BFS๋ก ํ์ด์ผ ํ๋ ๋ฌธ์ ๋ค. ํ๋ฃจ๊ฐ ์ง๋ ๋๋ง๋ค ์ํฅ์ ๋ฐ์ ์ต๊ฒ ๋๊ธฐ ๋๋ฌธ. from collections import dequem, n = map(int, input().split()) # ๊ฐ๋ก, ์ธ๋กgraph = []for i in..
ํ์ด 1: DFS, ์ฌ๊ท์ด์ฉ - RecursionErrordef dfs(x, y): visited[x][y] = True for dx, dy in [(1,0), (-1,0), (0,1), (0,-1)]: nx, ny = x + dx, y + dy if 0 ์ฒซ๋ฒ์งธ ํ์ด์ด๋ค. DFS์ ์ฌ๊ท๋ฅผ ์ฌ์ฉํ์ฌ ํ์๋๋ Recursion Error๊ฐ ๋ฌ๋ค.Recursion Error: ์ฌ๊ท์ ๊ด๋ จ๋ ์๋ฌ. ์ฃผ๋ก Python์ด ์ ํ ์ต๋ ์ฌ๊ท ๊น์ด๋ณด๋ค ๋ ๊น์ด์ง ๋.์ด ๊ฒฝ์ฐ, ์ฌ๊ท๋ฅผ ์ฌ์ฉํ์ง ์๋๋ก ๋ฐ๊พธ์ด์ผ ํ๋ค.BFS๋ฅผ ์ฌ์ฉํด์ ํ๊ฑฐ๋, ์ฌ๊ท ์์ด DFS๋ฅผ ๊ตฌํํด์ผ ํ๋ค. ์ฐธ๊ณ ๋งํฌ : https://yesolz.tistory.com/entry/Python-%EB%B0%B1%EC%A..
1. n, m, v ์
๋ ฅ ๋ฐ๊ธฐ (๋์ด์ฐ๊ธฐ ์
๋ ฅ)n, m, v = map(int, input().split())N(์ ์ ์), M(๊ฐ์ ์), V(ํ์ ์์ํ ์ ์ ๋ฒํธ) 2. ๊ทธ๋ํ ์
๋ ฅ ๋ฐ๊ธฐ (๋
ธ๋ ์ฐ๊ฒฐ ์ ๋ณด) - ์ธ์ ํ๋ ฌgraph = [[0] * (n+1) for _ in range(n+1)]for i in range(m): a, b = map(int, input().split()) graph[a][b] = graph[b][a] = 1 ์ ์ ๋ฒํธ์ ์ธ๋ฑ์ค ์ผ์น์ํค๊ธฐ ์ํด n+1๋ก ์ด๊ธฐํ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ์ด๋ฏ๋ก graph[a][b] = graph[b][a] = 1 ** ๊ทธ๋ํ ์ถ๋ ฅํ๊ธฐdef print_graph(graph): for row in graph[1:]: # 0๋ฒ์งธ ํ๊ณผ ์ด์ ์ฌ์ฉํ..