9-fnzksxl

[fnzksxl]

🔗 문제 링크

순위

✔️ 소요된 시간

약 1시간.?

✨ 수도 코드

처음에 문제 중

하지만 몇몇 경기 결과를 분실하여 정확하게 순위를 매길 수 없습니다.
이 부분을 넘겨 짚어 읽어서(사실상 안 읽고 넘어간)
제가 생각해내지 못한 그리디한 방법이나 수학적 지식이 있는 줄 알았습니다.. 하아

처음에 아이디어가 잘 안 떠올라서 한 번 그냥 그림판으로 흐름을 무작정 따라가봤습니다. 마우스라서 글씨가 더럽군요

아하! 깨달았습니다. 이 녀석.. 나머지 모든 노드들과 연결되어 있다면 순위를 알 수 있군요?

이어진 간선들을 유향간선이라 간주했을 때 이어진 노드
이 간선들을 뒤집었을 때 이어진 노드

위 두 노드들의 합집합이 본인을 제외한 노드들이라면(사실상 n-1개의 노드라면) 순위를 알 수 있는 노드입니다.

여기까지 알아내고 아, 플로이드-워셜 알고리즘을 쓰는 문제인가?까지 유추해냈는데..
오랜만에 들어보는 이름들이라 어떻게 구현하는지 까먹어버렸지 뭐에요.
그래서 제 마음대로 일단 구현해봤습니다. 코드가 더러워보이는 이유도 다 그것 때문이에요.

간단하게 제가 구현한 방식을 설명해보겠습니다.

1. 데이터를 토대로 그래프를 만든다.
2. 간선을 뒤집어서 그래프를 하나 더 만든다.
3. 처음부터 끝까지 노드를 순회하면서

• 뒤집지 않은 그래프에서 내가 갈 수 있는 노드를 기억
• 뒤집은 그래프에서 내가 갈 수 있는 노드를 기억

4. 기억하고 있는 노드의 합 == n-1 이라면 개수 +1

from collections import deque

def func(n, graph, degree):
    for i in range(1, n+1):
        q = deque()
        q.append(i)
        
        while q:
            node = q.popleft()
            
            for next_node in graph[node]:
                _before = len(degree[i])
                degree[i].add(next_node)
                
                if _before == len(degree[i]):
                    continue
                
                q.append(next_node)
                
def solution(n, results):
    answer = 0
    graph = [[] for _ in range(n+1)]
    reversed_graph = [[] for _ in range(n+1)]
    in_degree = [set() for _ in range(n+1)]
    out_degree = [set() for _ in range(n+1)]
    
    for win, defeat in results:
        graph[win].append(defeat)
        reversed_graph[defeat].append(win)
    
    func(n, graph, out_degree)
    func(n, reversed_graph, in_degree)
    
    
    for i in range(1, n+1):
        if len(out_degree[i])+len(in_degree[i]) == n-1:
            answer += 1
    
    return answer

📚 새롭게 알게된 내용

문제를 꼼꼼히 읽자.

[9kyo-hwang]

문제 설명만 보면 도저히 그래프 문제로 안보이는데, 알고보니 플로이드-워셜 문제란 말이죠... 저도 이거 처음풀 때 그래프 카테고리라고 표기 안해줬으면 갈피도 못잡았을 것 같아요.

전 정석적인 플로이드-워셜 풀이로 접근했습니다. 대신 여기서는 최단 거리를 구하는 것이 아닌, "�i가 k를 이겼고 k가 j를 이겼으면 i는 j를 이긴 거다!"와 같이 관계 를 확장해가는 개념이니 이 부분만 살짝 다르겠네요.

def solution(n, results):
    graph = [[float('inf')] * (n + 1) for _ in range(n + 1)]
    for i in range(1, n + 1):
        graph[i][i] = 0
        
    for A, B in results:
        graph[A][B] = 1  # A는 B를 이겼으므로 1
        graph[B][A] = -1  # B는 A에게 졌으므로 -1
        
    for k in range(1, n + 1):
        for i in range(1, n + 1):
            for j in range(1, n + 1):
                if graph[i][k] == 1 and graph[k][j] == 1:  # i가 k를 이겼고, k가 j를 이겼다면
                    graph[i][j] = 1  # i는 j를 이긴거다.
                elif graph[i][k] == -1 and graph[k][j] == -1:  # 반대 경우
                    graph[i][j] = -1
                    
    answer = 0
    for i in range(1, n + 1):  # 매 i번째 사람마다
        if float('inf') not in graph[i][1:]:  # 관계를 알 수 없는(inf) 경우가 없다면
            answer += 1  # 카운트 + 1
    return answer

---

허허 dictionary를 써서 훨씬 간단하게 푼 사람이 있네요... update란 함수가 있어서 얘가 다 해주네...

from collections import defaultdict

def solution(n, results):
    win, lose = defaultdict(set), defaultdict(set)
    for A, B in results:
        win[A].add(B)
        lose[B].add(A)

    for i in range(1, n + 1):
        for winner in lose[i]:  # i번 선수에게 이긴 선수들
            win[winner].update(win[i])
        for loser in win[i]:  # i번 선수에게 진 선수들
            lose[loser].update(lose[i])

    answer = 0
    for i in range(1, n + 1):
        if len(win[i]) + len(lose[i]) == n - 1:
            answer += 1
        
    return answer

[fnzksxl]

@9kyo-hwang 저처럼 set을 써서 푸신 분이네용 defaultdict로 set 자료형을 빈 상태로 초기화해서 쓰신 풀이 같습니다. 저도 update로 한 번에 없애줄까라고 생각은 해봤는데 저 풀이 되게 깔끔하군요.. 그런데 졌을 때를 -1로 다르게 표기하신 이유가 있을까요?

[9kyo-hwang]

@9kyo-hwang 저처럼 set을 써서 푸신 분이네용 defaultdict로 set 자료형을 빈 상태로 초기화해서 쓰신 풀이 같습니다. 저도 update로 한 번에 없애줄까라고 생각은 해봤는데 저 풀이 되게 깔끔하군요.. 그런데 졌을 때를 -1로 다르게 표기하신 이유가 있을까요?

ㅓ 이긴 거랑 진 거를 구분할려고 한 건데, 생각해보니 그럴 필요가 없었군요?
관계가 있다는 사실 자체가 중요한 거였네요...

[fnzksxl]

@9kyo-hwang 교황님이라 어떤 큰 뜻이 숨어있는 줄 알았습니다 ㅎㅋㅋㅋㅋㅋ

[SeongHoonC]

플로이드 워셜 기억이 안나서 교황이꺼 보고 풀었네요..ㅋㅋ
상기해서 좋았습니다 굿..
이기고 이겼을 때 업뎃, 지고 졌을 때 업뎃 이걸 생각 못했네요

const val INFF = 100_000_000

class Solution {
    fun solution(n: Int, results: Array<IntArray>): Int {
        val graph = Array(n + 1) { i ->
            Array(n + 1) { j -> if (i == j) 0 else INFF }
        }

        results.forEach {
            graph[it[0]][it[1]] = 1
            graph[it[1]][it[0]] = -1
        }

        for (k in 1..n) {
            for (a in 1..n) {
                for (b in 1..n) {
                    if (graph[a][k] == 1 && graph[k][b] == 1) {
                        graph[a][b] = 1
                    } else if (graph[a][k] == -1 && graph[k][b] == -1) {
                        graph[a][b] = -1
                    }
                }
            }
        }

        val answer = mutableListOf<Int>()
        for (i in 1..n) {
            var isNotINFF = true
            for (j in 1..n) {
                if (graph[i][j] != INFF) {
                    continue
                }
                isNotINFF = false
                break
            }
            if (isNotINFF) {
                answer.add(i)
            }
        }
        return answer.count()
    }
}

[tgyuuAn]

AlgoLeadMe/AlgoLeadMe-1#88

이 문제에 대해서 PR이 이전에 올라왔었는데,

저는 플로이드 워셜인지도 몰랐어요..

저는 약간 다르게 풀어서 풀이 공유해봅니다!!

[alstjr7437]

저는 따로 이기고 지는 관계를 생각해서 풀었습니다!!

1. 이기고 진애들 그래프를 따로 만들어서 저장해둔다.
2. i(2) 한테 진애들(5) -> i(2)를 이긴 애들(1,3,4)에게도 짐
3. i(2) 한테 이긴애들(1,3,4) -> i(2)한테 진 애들(5)에게도 이김

위와 같이 계산해서 중복을 제거하고 두 그래프의 합이 n-1인만큼 부분까지 생각했는데 구현에서 막혀서 인터넷을 참고했습니다 ㅠ

적고보니 교황님이 작성하신 부분이네요

def solution(n, results):
    answer = 0
    win_graph = {}    # 이긴 애들
    lose_graph = {}   # 진 애들
    
    for i in range(1, n+1):
        win_graph[i] = set()
        lose_graph[i] = set()

    for winner, loser in results:   # 그래프 만들기
        if winner not in win_graph:
            win_graph[loser] = set()
        if loser not in lose_graph:
            lose_graph[winner] = set()
        win_graph[loser].add(winner)
        lose_graph[winner].add(loser)

    for i in range(1, n+1):         
        for winner in win_graph[i]:  # i한테 진 애들 -> i를 이긴 애들한테도 짐
            if i in lose_graph:
                lose_graph[winner].update(lose_graph[i])
        for loser in lose_graph[i]:  # i한테 이긴 애들 -> i한테 진 애들한테도 이김
            if i in win_graph:
                win_graph[loser].update(win_graph[i])
    
    for i in range(1, n+1):
        if len(win_graph[i]) + len(lose_graph[i]) == n-1:  # i한테 이기고 진 애들 합쳐서 n-1이면 순위가 결정된 것
            answer += 1

    return answer

[wkdghdwns199]

def bfs (_dict, player,n) :

    queue = [player]
    checker = [0 for _ in range(0,n+1)]
    count_node = 0
    while queue :
        current_player = queue.pop(0)
        
        for checking_player in _dict[current_player] :
            
            if checker[checking_player] == 0 :
                checker[checking_player] = 1
                queue.extend(_dict[current_player])
                count_node += 1
                
    return count_node

def solution(n, results):
    answer = 0
    
    win_dict = {index+1 : [] for index in range(len(results))}
    lose_dict = {index+1 : [] for index in range(len(results))}
    
    for result in results :
        win, lose = result[0], result[1]
        win_dict[win].append(lose)
        lose_dict[lose].append(win)
    
    for player in range(1,n+1) :
        if bfs(win_dict, player,n) + bfs(lose_dict, player,n) == n-1 :
            answer +=1
    print(answer)
    return answer

이렇게 했는데

이렇게 떠서 화가 나네요 뭐가 틀렸을까요?

[tgyuuAn]

@wkdghdwns199

재귀 함수가 너무 깊어져서 그런 것 같은데,

코드 맨 위에

import sys

sys.setrecursionlimit(1000000)

넣어보시겠어요?

---

제가 직접 해보니까 아직 그래도 에러가 나네요..

인덱스 관련 에러인가...

[wkdghdwns199]

@tgyuuAn 아 아쉽네요.. ㅜㅜ 한 번 다시 해봐야겠슴다