30-Dolchae

[Dolchae]

🔗 문제 링크

2644 촌수계산

✔️ 소요된 시간

1시간

✨ 수도 코드

문제

주어진 두 사람의 촌수를 계산하는 문제이다.

• 부모와 자식 사이가 1촌으로 정의되므로 나와 할아버지는 2촌, 아버지 형제들과 할아버지는 1촌, 나와 아버지 형제들은 3촌이 된다.
  입력
• 첫째 줄에 전체 사람 수, 둘째 줄에 촌수를 계산해야 하는 두 사람의 번호(a,b), 셋째 줄에 관계의 수 m, 넷째 줄부터는 부모 자식 간의 관계 두 번호 x,y가 나온다.
  • 이때 x가 y의 부모가 된다.
    출력
• a,b의 촌수를 계산해 출력하면 되는데, 친척 관계가 전혀 없을 경우에는 -1을 출력한다.

예제 1)

코드

n = int(input())
a,b = map(int, input().split())
node_num = int(input())
graph = [[] for _ in range(n+1)]
visited = [False] * (n+1)
result = []

• 첫째 줄에 전체 사람 수(n), 둘째 줄에 촌수를 계산해야 하는 두 사람의 번호(a,b), 셋째 줄에 관계의 수(node_num)를 입력받는다.
• 관계들을 저장할 graph 2차원 배열과 방문 여부를 확인할 visited, 결과를 저장할 result 리스트를 선언한다.

for _ in range(node_num):
  x, y = map(int, input().split())
  graph[x].append(y)
  graph[y].append(x)

• 관계의 수만큼 for문을 반복하며 x와 y를 입력받으며 연결정보를 graph에 저장한다.

def dfs(v, num):
  num += 1
  visited[v] = True

  if v == b:
    result.append(num)

  for i in graph[v]:
    if not visited[i]:
      dfs(i, num)

a에서 b로 가는 dfs를 수행한다.

• 현재 노드 v와 현재까지의 거리 num을 받는다.
• 방문 노드를 체크하고 만약 b에 도달했다면 해당 경로의 길이 num을 추가한다.
• 방문하지 않은 노드들을 계속 재귀적으로 탐색한다.

dfs(a, 0)
if len(result) == 0:
  print(-1)
else:
  print(result[0]-1)

• 만약 result가 비어있다면 a와 b 두 사람의 친척 관계가 없다는 뜻이므로 -1을 출력한다.
• 그렇지 않다면 최초의 경로의 길이에서 (출발 노드를 제외하기 위해) 1을 뺀 값을 출력한다.

전체 코드

n = int(input())
a,b = map(int, input().split())
node_num = int(input())
graph = [[] for _ in range(n+1)]
visited = [False] * (n+1)
result = []

for _ in range(node_num):
  x, y = map(int, input().split())
  graph[x].append(y)
  graph[y].append(x)

def dfs(v, num):
  num += 1
  visited[v] = True

  if v == b:
    result.append(num)

  for i in graph[v]:
    if not visited[i]:
      dfs(i, num)

dfs(a, 0)
if len(result) == 0:
  print(-1)
else:
  print(result[0]-1)

📚 새롭게 알게된 내용

구교황 선배님이 추천해주신 백트래킹 문제를 풀어보려 했는데 찾아보니 백트래킹에 DFS가 쓰인다길래 DFS 문제를 먼저 도전해보았다. 그런데 오랜만에 푸니 더더욱 모르겠어서 애먹다가 결국 블로그 참고했다..


코드 참고 블로그

[xxubin04]

DFS로 푸니까 간결하게 코드가 짜지는군요...😂
저는 BFS로 도전했는데 코드가 1000B가 넘었네요...하하
깔끔하게 잘 푸셔서 제 코드만 남기고 가겠습니다!

BFS 코드

from collections import deque
input = open(0).readline

people_num = int(input())
A, B = map(int, input().split())
relationship = [[0] for _ in range(people_num + 1)]

for i in range(relation_num := int(input())):
    a, b = map(int, input().split())
    if relationship[a] == [0]:
        relationship[a] = [b]
    else:
        relationship[a].append(b)
    
    if relationship[b] == [0]:
        relationship[b] = [a]
    else:
        relationship[b].append(a)

visited = [0 for _ in range(people_num + 1)]

def chon(r, c, p):
    global ans, check
    q = deque()
    q.append((r, c, p))
    while q:
        relation, cnt, person = q.popleft()
        if visited[person] == 0:
            visited[person] = 1
            cnt += 1
            for j in relation[person]:
                if j == A:
                    ans.append(cnt)
                    return ans
                q.append((relation, cnt, j))

ans = []       
cnt = 0
answer = chon(relationship, cnt, B)
print(min(answer) if answer else -1)

[9kyo-hwang]

저는 아예 모든 노드에 대한 거리 정보를 기록하는 리스트를 하나 만들어서, 그 값을 계속 바꿔주는 식으로 짜봤네요.

input = open(0).readline

n = int(input())
a, b = map(int, input().split())
m = int(input())

tree = [[] for _ in range(n + 1)]
dists = [-1] * (n + 1)  # 초기값은 -1
dists[a] = 0  # 시작 노드인 a는 거리 0으로 설정

for _ in range(m):
    x, y = map(int, input().split())
    tree[x].append(y)
    tree[y].append(x)
    

def dfs(src: int = a):
    for dst in tree[src]:  # src와 연결된 인접 노드에 대해
        if dists[dst] == -1:  # 초기값(-1) 그대로라면 방문한 적 없음
            dists[dst] = dists[src] + 1  # src 노드까지의 거리 + 1로 재설정
            dfs(dst)  # 재귀 호출
        
dfs()
print(dists[b])  # 최종적으로 b에 대한 거리값을 출력하면 됨. 도달했으면 거리값이, 도달못했으면 초기 -1값이 그대로 담겨져있음

그리고 반드시 재귀로 할 필요도 없겠죠? stack을 이용한 dfs도 가능하답니다.

input = open(0).readline

n = int(input())
a, b = map(int, input().split())
m = int(input())

tree = [[] for _ in range(n + 1)]
dists = [-1] * (n + 1)
dists[a] = 0

for _ in range(m):
    x, y = map(int, input().split())
    tree[x].append(y)
    tree[y].append(x)
    

stack = [a]
while stack:
    src = stack.pop()
    if src == b:
        break
        
    for dst in tree[src]:
        if dists[dst] == -1:
            dists[dst] = dists[src] + 1
            stack.append(dst)


print(dists[b])

마치 queue를 쓴 bfs랑 코드가 비슷하죠? 아래가 bfs 코드입니다.

from collections import deque
input = open(0).readline

n = int(input())
a, b = map(int, input().split())
m = int(input())

tree = [[] for _ in range(n + 1)]
dists = [-1] * (n + 1)
dists[a] = 0

for _ in range(m):
    x, y = map(int, input().split())
    tree[x].append(y)
    tree[y].append(x)


q = deque([a])
while q:
    src = q.popleft()
    if src == b:
        break
    
    for dst in tree[src]:
        if dists[dst] == -1:
            dists[dst] = dists[src] + 1
            q.append(dst)


print(dists[b])

특이하게 이 문제는 bfs가 속도가 제일 느리네요

맨 밑이 재귀호출, 가운데가 stack dfs, 맨 위가 queue bfs 코드입니다.

[9kyo-hwang]

거리값(촌 수)을 num이 기억하고 있으니, 이를 반환하는 식으로 코드를 짜면 좀 더 직관적일 것 같네요.

def dfs(src: int = a, dist: int = 0):  # 디폴트 파라미터로 노드 a, 거리 0을 지정함
    if visited[src]:  # 방문했던 정점이라면
        return -1  # 찾는 대상이 아니므로 -1 리턴
    elif src == b:  # 현재 검사하는 노드가 찾는 대상(b)이라면
        return dist  # 현재까지의 거리값을 반환
    else: 
        visited[src] = True  # 방문처리
        ans = -1
        for dst in tree[src]:  # 인접한 노드들에 대해
            ans = max(ans, dfs(dst, dist + 1))  # 재귀 호출에 대한 결과 중 큰 값을 취함
        return ans  # 큰 값은 실제 거리일 거고, 아니라면 못찾았다는 의미의 -1이 담겨있음

이런 식으로 작성하면, dfs 함수를 호출했을 때 실제 거리 값 이 반환되거나 못찾았다는 뜻에서 -1 이 반환되겠죠?
그거를 바로 출력해주면 됩니다.

print(dfs())  # dfs 함수에 디폴트 파라미터를 지정해놔서 인자를 넘겨주지 않아도 됩니다.