์๋ ๊ฐ๋ฅ์ฑ์ด ๋์ผ๋ 15๊ธฐ ์ํํธ์จ์ด ๋ง์์คํธ๋ก์ ์ง์ํ์ต๋๋ค. ๋ญ๋ ๋์ ํด๋ณด๋๊ฒ ์ค์ํ๋๊น์.
๋ฐ๋ผ์ ํ๋ DP ์ ์ ๋ฏธ๋ค๋๊ณ ์๋ง ๊ธฐ์ถ ํธ๋๊ฑฐ์ ์ง์คํ๋ ค ํฉ๋๋ค. ๊ธฐ์ถ์ DP๋ ํฌํจ๋์ด ์์ผ๋ ๊ฒธ์ฌ๊ฒธ์ฌ ๊ณต๋ถํ๊ฒ ์ต๋๋ค.
1012 - ์ ๊ธฐ๋ ๋ฐฐ์ถ
BFS๋ก 1์ด ๋ญ์ณ์๋ ๊ตฌ์ญ ๊ฐฏ์๋ฅผ ํ์ ํ๋ ๋ฌธ์ ์ ๋๋ค.
T = int(input())
que = deque([])
ans = []
ํ ์คํธ์ผ์,ํ,๋ต์ ์ถ๋ ฅํ ans๋ฅผ ์ ์ธํ๊ฒ ์ต๋๋ค.
for _ in range(T):
M,N,K = map(int,input().split())
graph = [[0]*M for _ in range(N)]
visited = [[0]*M for _ in range(N)]
ํ ์คํธ์ผ์ด์ค๋งํผ ๋ฃจํ๋ฅผ ๋๋ ค์ฃผ๊ณ , ๊ฐ๋ก,์ธ๋ก,๋ฐฐ์ถ๊ฐ ์ฌ์ด์ ธ ์๋ ์์น๋ฅผ ๋ฐ์์
for _ in range(K):
a,b = map(int,input().split())
graph[b][a] = 1
๊ทธ๋ํ์ ํ๊ธฐํด์ค๋๋ค. ์ฃผ์ํ ์ ์ ์ด๊ณณ ๊ทธ๋ํ์ ํ๊ธฐ ๋ฐฉ์์ ์ด๊ณผ ํ์ด ๋ฐ๋๋ผ์ a์ b๋ฅผ ๊ฑฐ๊พธ๋ก ์ ๋ ฅ๋ฐ์์ผ ์ ์์ ์ผ๋ก ์ถ๋ ฅ๋ฉ๋๋ค.
cnt = 0
for i in range(N):
for j in range(M):
if not visited[i][j] and graph[i][j] == 1:
bfs(i,j)
cnt += 1
๋ค์์ผ๋ก cnt๋ณ์๋ฅผ ์ ์ธํ๊ณ ๊ทธ๋ํ๋ฅผ ์ํํ๋ ๋์ ๋ฐฉ๋ฌธํ์ง ์์ ์ง์ญ์ด๊ณ ํด๋น ์ง์ญ์ด 1์ด๋ผ๋ฉด BFS ํ์์ผ๋ก ๋์์ค๋๋ค. ํ์ ํ์๋ cnt๋ณ์๋ฅผ 1 ์ฌ๋ ค์ค๋๋ค.
ans.append(cnt)
for values in ans:
print(values)
cnt๋ณ์๋ฅผ ans์ ์ถ๊ฐํ๊ณ values๋ก์จ ์ถ๋ ฅํ๋ฉด ๋ต์ด ์ถ๋ ฅ๋ฉ๋๋ค.
from collections import deque
dx = [-1,1,0,0]
dy = [0,0,1,-1]
BFS๋ ํญ์ ๋จน๋ ๊ทธ ๋ง์ ๋๋ค. dx,dy๋ก ์ํ์ข์ฐ ํ์ ์ค์ ํ๊ณ
def bfs(x,y):
que.append([x,y])
visited[x][y] = 1
ํ์์ ๋ค์ด์์ผ๋ฉด ํด๋น ์์น๋ ๋ฐฉ๋ฌธ์ฌ๋ถ O๋ก ํ๊ธฐ ํด์ค๋๋ค.
while que:
x,y = que.popleft()
for i in range(4):
nx = dx[i] + x
ny = dy[i] + y
if nx<0 or ny<0 or nx>=N or ny>=M:
continue
4๋ฐฉํฅ ํ์์ ์ค์ํ๋๋์ ๊ทธ๋ํ ๋ฐ์ ๋ฒ์ด๋๋ คํ๋ฉด continue๋ก ๋ง์์ฃผ๊ณ
if not visited[nx][ny] and graph[nx][ny] == 1:
visited[nx][ny] = 1
que.append([nx,ny])
๋ง์ฝ์ ํ์ํ๋ค๊ฐ ๋ฐฉ๋ฌธ์ ์ํ๊ณ ํด๋น ์ง์ญ์ด 1์ด๋ผ๋ฉด ํ์ ํ๋ณด์ง์ ๋ฃ์ด์ฃผ๊ณ ๋ฐฉ๋ฌธ์ฌ๋ถ O๋ก ํ๊ธฐํด์ฃผ๋ฉด ๋ฉ๋๋ค.
9461๋ฒ - ํ๋๋ฐ ์์ด
๊ทธ๋ฆผ๊ณผ ๊ฐ์ ์ผ๊ฐํ์ด ๋์ ๋ชจ์์ผ๋ก ๋์ฌ์ ์๊ณ P(N)์ N๋ฒ์งธ ์ผ๊ฐํ ๋ณ์ ๊ธธ์ด๋ผ ํ ๋, P(N)์ ๊ตฌํ์์ค.
๋ผ๋ DP๋ฌธ์ ์ ๋๋ค.
๋จผ์ ์ ๋ P(4)์์ ์ ํ์์ ๋์ถํ๋ ค๊ณ ๋ดค๋๋
P(4) = P(3)+P(1) ๊ทธ๋ฆฌ๊ณ P(4) = P(3)+P(2) ๋ผ๋ ์์ด ๋๊ฐ๊ฐ ๋์ถ๋์ด ์ ํ์์ ์ธ์ฐ๋๊ฒ ํ๋ค์์ต๋๋ค.
๊ทธ๋์ ํ์คํ ๊ตฌ๋ถ๋๋ ์ง์ ์ ๋ดค๋๋ P(11)์ ์ดํด๋ณด๋ฉด P(11) = P(10) + P(6)์ธ๋ฐ P(10)๊ณผ P(6)์ ๊ฐ๊ฐ 9์ 3์ธ ์์ด์ ํ๋๋ฐ์ ์๋ ๊ณ ์ ์๋ผ P(11)์ ์ฐ์ฐ์ด ๊ฐ๋ฅํ ๊ฒฝ์ฐ๋ ์ ๊ฒ๋ฐ์ ์์์ต๋๋ค.
๋ฐ๋ผ์ ๋ณธ ๋ฌธ์ ์์ P(n)์ P(n-1)+P(n-5)๋ผ๋ ์ ํ์ ๋์ถ์ด ๊ฐ๋ฅํฉ๋๋ค.
T = int(input())
for _ in range(T):
n = int(input())
print(dp(n-1))
๋จผ์ ํ
์คํธ์ผ์ด์ค๋ฅผ ๋ฐ๊ณ ๋ฐ์๋งํผ dpํจ์๋ฅผ ์ฌ๊ท๋ก์จ ๋๋ ค์ค๋๋ค.
n-1๋ก ๋ณ์์ ๋ฃ์ ์ด์ ๋ ๋ฌธ์ ๋ P(1)๋ถํฐ ์์ํ์ง๋ง ์ ๋ P(0)๋ถํฐ ์์ํ๊ธฐ ๋๋ฌธ์
๋๋ค.
memo = [0]*101
def dp(N):
if N == 0 : return 1
if N == 1 : return 1
if N == 2 : return 1
if N == 3 : return 2
if N == 4 : return 2
๋ฉ๋ชจ์ด์ ์ด์ ์ ํ๋ ๋ง๋ค์ด์ฃผ๊ณ 0,1,2 ์ฒซ ์ธ ์ผ๊ฐํ์ 1๋ก ์ด๊ธฐํ, 3,4 ๋๊ฐ์ ์ผ๊ฐํ์ 3,4๋ก ์ด๊ธฐํ๋ฅผ ์งํํด์ค๋๋ค. 3,4๋ฅผ ๊ตณ์ด ๋ฃ์ด์ฃผ๋ ์ด์ ๋ ์๋ฅผ ๋ค์ด ์ด๊ธฐํ ์ ์์ด ์ ํ์ P(4)๋ฅผ ์๋ํ๊ฒ ๋๋ฉด P(3) + P(-1)์ด๋ผ๋ ์์๋ฅผ ๋ถ๋ฌ์ค๋ ์ฌํ๊ฐ ๋ฐ์ํ๋ฏ๋ก ์ด๋ฅผ ๋ฐฉ์งํ๊ธฐ ์ํจ์ ๋๋ค.
if memo[N]:
return memo[N]
memo[N] = dp(N-1) + dp(N-5)
return memo[N]
๋ฉ๋ชจ์ด์ ์ด์ ์ ์์ผ๋ฉด ํด๋น ๊ฐ์ผ๋ก return ํ๊ณ ์๋๋ผ๋ฉด ํ์ฌ ํ์์ค์ธ N๊ฐ์ ๋ฉ๋ชจ์ด์ ์ด์ ์ ๋ฃ๊ณ ํด๋น ๊ฐ์ผ๋ก return ํ๋ฉด ๋ฉ๋๋ค.