7-janghw0126

[janghw0126]

🔗 문제 링크

프로그래머스 | 양과 늑대

✔️ 소요된 시간

1시간

✨ 수도 코드

이번 문제는 DFS을 이용하여 탐색을 수행하고, 양의 수를 최대로 유지하면서 탐색을 진행하는 문제였습니다. 이 문제의 핵심은 현재 위치에서 양과 늑대의 수를 추적하며, 조건에 따라 탐색을 중단하거나 계속하는 것입니다!

🧐 문제 접근 방법

1. 문제 분석:

• 문제 지문에서는 늑대의 수가 양의 수와 같거나 더 많아지면, 더 이상 탐색을 진행할 수 없다. 라고 명시되어 있어, 늑대의 수가 양의 수를 초과하는 경로는 탐색하지 않는 것이 중요하다고 생각했습니다. 그래서 DFS를 사용해 모든 경로를 탐색하되, 늑대의 수가 양의 수보다 많아지는 순간 탐색을 중단하는 아이디어를 이용했습니다.
• 또한, 루트 노드부터 출발하여 가능한 모든 경로를 탐색하면서 양의 수를 최대로 만들 수 있는 방법을 찾아야 한다. 라는 지문을 통해, 모든 경로를 탐색해야 하는 문제라는 점에서 DFS가 적합하다고 판단했습니다.

2. DFS 탐색:

• DFS를 통해서 트리의 깊이를 우선으로 탐색하며, 현재 경로에서 양과 늑대의 수를 추적합니다. 탐색 도중 늑대의 수가 양의 수 이상이 되면 그 경로는 더 이상 탐색할 필요가 없으므로 중단합니다.
• 양의 수가 최대가 될 때까지 모든 가능한 경로를 탐색하고, 그중에서 양의 수가 가장 많은 경우를 기록합니다.

✅ 문제 로직

1. 초기화:

• 각 노드의 자식 노드들을 저장하기 위해 child 리스트를 초기화합니다.
• edges를 순회하여 부모-자식 관계를 child 리스트에 저장합니다.

2. DFS 재귀 함수 정의:

• 현재 노드의 번호, 양의 수(sheep), 늑대의 수(wolf), 다음에 탐색할 수 있는 노드들의 리스트(next_nodes)를 선언합니다.
• 현재 양의 수가 늑대보다 많을 때만 탐색을 계속 진행합니다.
• 현재 양의 수가 최대일 경우 max_count를 갱신합니다.
• 다음 탐색 가능한 노드들을 반복적으로 탐색합니다.

3. 탐색 시작:

• 루트 노드인 0번 노드에서 탐색을 시작하며, 처음에는 양 1마리가 주어집니다.
• child[0]을 탐색할 수 있는 초기 노드로 설정하고, DFS를 시작합니다.

4. 최종 결과 반환:

• 모든 탐색이 끝난 후, max_count에 저장된 최대 양의 수를 반환합니다.

💥 트러블 슈팅

늑대 수와 양 수 비교 부분에서 이슈가 있었습니다. 처음에는 wolf > sheep 조건에서 탐색을 중단했으나, 테스트 과정에서 늑대의 수가 양과 같은 경우에도 탐색이 잘못되는 경우가 발생했습니다. 그래서 문제의 조건에 맞추어 wolf >= sheep으로 조건을 수정함으로써, 정확한 결과를 얻을 수 있었습니다.

👩‍💻 최종 코드

# 전역 변수로 최대 양의 수를 저장
max_count = 0

def solution(info, edges):
    # 각 노드의 자식 노드를 저장할 리스트 초기화
    child = [[] for _ in range(len(info))]

    # edges에 따라 부모-자식 관계를 설정
    for p, c in edges:
        child[p].append(c)

    # 깊이 우선 탐색(DFS)을 수행하는 재귀 함수 정의
    def dfs(node, sheep, wolf, next_nodes):
        global max_count

        # 늑대 수가 양 수보다 많아지면 탐색 중지
        if wolf >= sheep:
            return

        # 최대 양의 수를 갱신
        max_count = max(max_count, sheep)

        # 현재 노드의 자식 노드들을 탐색 가능 노드 리스트에 추가
        next_nodes.extend(child[node])

        # 다음으로 이동할 수 있는 노드들을 순회
        for next_node in next_nodes:
            # 다음 노드가 현재 위치가 아닌 경우에만 이동
            new_next_nodes = [n for n in next_nodes if n != next_node]
            # 다음 노드에 늑대가 있는 경우
            if info[next_node]:
                dfs(next_node, sheep, wolf + 1, new_next_nodes)
            # 다음 노드에 양이 있는 경우
            else:
                dfs(next_node, sheep + 1, wolf, new_next_nodes)

    # 루트 노드(0번)에서 DFS 시작 (처음에 양 1마리가 있음)
    dfs(0, 1, 0, child[0])

    return max_count

📚 새롭게 알게된 내용

이번 PR에서는 경로를 탐색하는 도중에 조건을 추가하여 불필요한 경로를 미리 차단함으로써 효율성을 높이는 것이 중요하다는 것을 깨달았습니다.

[9kyo-hwang]

이 문제는 원칙적으로 백트래킹/완전탐색으로 풀 수 없는데, 카카오에서 제시한 테스트케이스가 빈약해서 통과가 됩니다. 혜원님이 올려주신 코드도 일종의 완전탐색인데, 아래와 같은 테스트 케이스에 대해 시간초과가 발생합니다.

info = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
edges = [[0, 1], [0, 2], [1, 3], [1, 4], [2, 5], [2, 6], [3, 7], [3, 8], [4, 9], [4, 10], [5, 11], [5, 12], [6, 13], [6, 14], [7, 15], [7, 16]]
Return = 17

자세한 설명은 양과 늑대 풀이 블로그를 확인해보시면 됩니다 :)
요약하자면, 정해는 [비트마스킹을 사용해 확장된 상태 공간에서의 flood fill]입니다.

def solution(info, edges):
    n = len(info)
    
    visited = [False] * (1 << n)
    graph = [[] for _ in range(n)]
    
    for p, c in edges:
        graph[p].append(c)
    
    answer = 0
    def dfs(mask: int = 1):
        nonlocal answer
        
        if visited[mask]:
            return
        
        visited[mask] = True
        sheep, wolf = 0, 0
        
        for node in range(n):
            if mask & (1 << node):
                sheep += (info[node] == 0)
                wolf += (info[node] == 1)
        
        if sheep <= wolf:
            return
        
        answer = max(answer, sheep)
        
        for parent in range(n):
            if not mask & (1 << parent):
                continue

            for child in graph[parent]:
                dfs(mask | (1 << child))
    
    dfs(1)
    
    return answer

[jung0115]

리뷰가 늦어서 죄송합니다 🥲

사소한 부분이지만 혜원 님 코드 중에 max_count를 전역 변수로 선언한 부분이 있어서 전역 변수를 사용하지 않고 풀이하는 코드를 작성해봤습니다!! 혜원 님 코드를 일부 수정했습니당

def solution(info, edges):
    # 각 노드의 자식 노드를 저장할 리스트 초기화
    child = [[] for _ in range(len(info))]

    # edges에 따라 부모-자식 관계를 설정
    for p, c in edges:
        child[p].append(c)

    # 깊이 우선 탐색(DFS)을 수행하는 재귀 함수 정의
    def dfs(node, sheep, wolf, next_nodes):
        # 늑대 수가 양 수보다 많아지면 탐색 중지
        if wolf >= sheep:
            return sheep - 1  # 현재 양의 수에서 1을 뺀 값을 반환

        # 현재 노드의 자식 노드들을 탐색 가능 노드 리스트에 추가
        next_nodes.extend(child[node])

        max_sheep = sheep  # 현재까지의 최대 양의 수

        # 다음으로 이동할 수 있는 노드들을 순회
        for next_node in next_nodes:
            # 다음 노드가 현재 위치가 아닌 경우에만 이동
            new_next_nodes = [n for n in next_nodes if n != next_node]
            # 다음 노드에 늑대가 있는 경우
            if info[next_node]:
                max_sheep = max(max_sheep, dfs(next_node, sheep, wolf + 1, new_next_nodes))
            # 다음 노드에 양이 있는 경우
            else:
                max_sheep = max(max_sheep, dfs(next_node, sheep + 1, wolf, new_next_nodes))

        return max_sheep  # 탐색된 양의 최대 수를 반환

    # 루트 노드(0번)에서 DFS 시작 (처음에 양 1마리가 있음)
    return dfs(0, 1, 0, child[0])