44-9kyo-hwang

[9kyo-hwang]

🔗 문제 링크

6987 월드컵

✔️ 소요된 시간

1시간 + 못참고 블로그

✨ 수도 코드

하 왜 이게 안떠올랐을까...

1. 문제

6개국으로 구성된 각 조별로 동일한 조에 소속된 국가들과 한 번씩, 각 국가별로 총 5번의 경기를 치른 결과가 주어진다. 각 나라의 승, 무승부, 패의 수가 가능한 결과인지를 판별하라.

예를 들어, 아래 2개의 결과는 가능하나

나라	승	무	패
A	5	0	0
B	3	0	2
C	2	0	3
D	0	0	5
E	4	0	1
F	1	0	4

나라	승	무	패
A	4	1	0
B	3	0	2
C	4	1	0
D	1	1	3
E	0	0	5
F	1	1	3

아래 2개의 결과는 불가능하다.

나라	승	무	패
A	5	0	0
B	4	0	1
C	2	2	1
D	2	0	3
E	1	0	4
F	0	0	5

나라	승	무	패
A	5	0	0
B	3	1	1
C	2	1	1
D	2	0	3
E	0	0	5
F	1	0	4

2. 풀이

A, B, C, D, E, F 6개의 팀이 각 팀들과 한 번씩 치르는 경우는 다음과 같이 총 15가지다.

• A, B
• A, C
• A, D
• A, E
• A, F
• B, C
• B, D
• B, E
• B, F
• C, D
• C, E
• C, F
• D, E
• D, F
• E, F

각 매치마다 가질 수 있는 결과는 다음과 같이 총 3가지다

• 팀 1 승리
• 팀 2 승리
• 무승부

따라서 모든 경우의 수를 다 돌아보면 $3^{15} = 14,348,907$ 번의 연산이 발생한다. 충분히 시간 안에 가능하므로 "백트래킹"을 이용해 풀어본다.

for _ in range(4):
    scores = list(map(int, input().split()))
    scores = [scores[i:i+3] for i in range(0, 18, 3)]
    print(1 if backtracking() else 0, end=' ')

4개의 테스트 케이스가 주어진다. 각 테스트 케이스마다 결과 정보가 주어지면 (1 x 18) 형태로 주어지므로 (6 x 3)으로 재배치한다.
이후 backtracking 함수를 호출해 True면 1, False면 0을 반환한다. True면 주어진 scores가 가능한 결과란 뜻이고, False면 불가능한 결과란 뜻이다.

matches = list(combinations(range(6), 2))

def backtracking(game: int = 0) -> bool:
    if game == len(matches):
        for score in scores:
            if score.count(0) != 3:
                return False
                
        return True
    ...

backtracking 함수에서 base case에 해당하는 부분이다.
game 변수는 15개의 매치에서 몇 번째 매치인 지 나타낸다. matches에는 위에서 말한 (A,B), (A, C), ...가 숫자로 표현된 (0, 1), (0, 2), ... 이런 값들이 저장돼있다.
즉 game 변수 값이 15에 도달하면 모든 경기를 다 수행해봤다는 뜻이므로 scores 리스트를 확인해본다.
아래 코드를 보면 알겠지만, [1팀 승 - 2팀 패], [1팀 무 - 2팀 무], [1팀 패 - 2팀 승] 3가지 경우를 확인해보기 위해 scores 리스트에 저장된 값을 "1씩 줄여본다"

예를 들어

나라	승	무	패
A	5	0	0
B	3	0	2

이 두 팀에 대해서 경우를 검사한다 할 때

1. A 승, B 패 -> Scores[A][Win] -= 1, Scores[B][Lose] -= 1
2. A 무, B 무 -> Scores[A][Tie] -= 1, Scores[B][Tie] -= 1
3. A 패, B 승 -> Scores[A][Lose] -= 1, Scores[B][Win] -= 1

이런 식으로 한다는 의미이다.

15가지 매치를 모두 완료하면 Score 리스트를 다시 확인해보는데, 만약 모든 팀의 스코어가 "0 0 0"으로 되어있다면 만들어질 수 있는 스코어 약 1400만 가지 중 하나의 케이스에 부합했다는 의미이므로 True를 반환한다. 그게 아니라면 False를 반환한다.

result_indices = ((0, 2), (1, 1), (2, 0))

t1, t2 = matches[game]

for i, j in result_indices:
    if scores[t1][i] <= 0 or scores[t2][j] <= 0:
        continue
    
    scores[t1][i] -= 1
    scores[t2][j] -= 1
    
    if backtracking(game + 1):
        return True
    
    scores[t1][i] += 1
    scores[t2][j] += 1

return False

backtracking 함수의 recursive case이다. 현재 매치(game)에 해당하는 팀 1, 2를 matches에서 꺼낸다.
그리고 result_indices에서 값을 하나씩 꺼내 경우의 수를 확인한다. 각 숫자 0, 1, 2는 다음을 의미한다.

• scores[team][0]: 이긴 횟수
• scores[team][1]: 비긴 횟수
• scores[team][2]: 진 횟수

즉

• (0, 2): 팀 t1은 이기고, 팀 t2는 짐
• (1, 1): 팀 t1, t2가 비김
• (2, 0): 팀 t1은 지고, 팀 t2는 이김

들어있는 수를 1씩 깎으면서 각 경우의 수를 확인해보고, backtracking한 결과가 True를 반환하는 식이다.
만약 False라면 해당 경우는 불가능한 경우이므로 다시 원복시킨 뒤 다음 경우를 확인한다.
이 때 어느 한 팀의 점수가 이미 0 이하라면 해당 경우는 확인하지 않는다. 0 밑으로 내려가는 건 불가능한 경우이기 때문이다.

저렇게 result_indices를 모두 확인했는데도 중간에 True가 반환되지 않았다면, 애초에 현재 상태 자체가 불가능하므로 False로 빠져나간다.

전체 코드

from itertools import combinations
input = open(0).readline

matches = list(combinations(range(6), 2))
result_indices = ((0, 2), (1, 1), (2, 0))

def backtracking(game: int = 0) -> bool:
    if game == len(matches):
        for score in scores:
            if score.count(0) != 3:
                return False
                
        return True
    
    t1, t2 = matches[game]
    
    for i, j in result_indices:
        if scores[t1][i] <= 0 or scores[t2][j] <= 0:
            continue
        
        scores[t1][i] -= 1
        scores[t2][j] -= 1
        
        if backtracking(game + 1):
            return True
        
        scores[t1][i] += 1
        scores[t2][j] += 1
    
    return False

for _ in range(4):
    scores = list(map(int, input().split()))
    scores = [scores[i:i+3] for i in range(0, 18, 3)]
    print(1 if backtracking() else 0, end=' ')

• C++

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

const vector<pair<int, int>> TeamMatches
{
    {0, 1}, {0, 2}, {0, 3}, {0, 4}, {0, 5}, 
    {1, 2}, {1, 3}, {1, 4}, {1, 5},
    {2, 3}, {2, 4}, {2, 5},
    {3, 4}, {3, 5},
    {4, 5},
};

const vector<pair<int, int>> MatchResultIndices
{// 1 win,   tie,   2 win
    {0, 2}, {1, 1}, {2, 0}
};

vector<vector<int>> MatchScore;

bool Backtracking(int Match = 0)
{
    if(Match == TeamMatches.size())
    {
        for(const auto& Team : MatchScore)
        {
            if(count(Team.begin(), Team.end(), 0) != 3)
            {
                return false;
            }
        }
        
        return true;
    }
    
    const auto& [Team1, Team2] = TeamMatches[Match];
    for(const auto& [i, j] : MatchResultIndices)
    {
        if(MatchScore[Team1][i] <= 0 || MatchScore[Team2][j] <= 0)
        {
            continue;
        }
        
        --MatchScore[Team1][i];
        --MatchScore[Team2][j];
        
        if(Backtracking(Match + 1))
        {
            return true;
        }
        
        ++MatchScore[Team1][i];
        ++MatchScore[Team2][j];
    }
    
    return false;
}

int main()
{
    cin.tie(nullptr)->sync_with_stdio(false);
    
    for(int T = 1; T <= 4; ++T)
    {
        MatchScore.assign(6, vector(3, 0));
        for(auto& Team : MatchScore)
        {
            for(auto& Score : Team)
            {
                cin >> Score;
            }
        }
        cout << Backtracking() << " ";
    }

    return 0;
}

📚 새롭게 알게된 내용

허 왜 이게 안보였을까... 주어진 팀 개수가 극도로 적어서 완탐때리면 될 것 같다란 생각이 들긴 했는데 "어떻게 구현해야 하는 지" 감이 안잡혀서 삽질 거하게 했다.
큰일났네...

[xxubin04]

리뷰 늦어서 매우 죄송합니다..🧎🏻‍♀️
한 일주일 전에 도전해봤다가 안되어서 오늘 다시 도전해봤는데 역시 틀리는군요..🤯
PR과 블로그 참고해서 풀어봐도 테케는 통과하지만 틀리네요?? 허허..
저는 일일이 (0, 2), (1, 1), (2, 0)으로 나누어서 코드를 짰는데 확실히 result_indices = ((0, 2), (1, 1), (2, 0)) 이렇게 묶어서 for문으로 푸니 가독성이 좋은 것 같습니다.👍👍

[gjsk132]

여차저차 백트레킹까지는 생각했던 것 같은데, 코드 짜는 과정에서 포기합니다.

4번의 경기 값을 기억해두고, 각 경기들의 결과를 구해서, 그게 주어진 경기 결과와 같은 값이 있으면 True로 바꾸려고 했는데...

Recursive 코드를 작성하는게 아직 연습이 많이 필요한 것 같습니다. 🥲

( 뭔가 경기 결과만으로 할 수 있을 것 같았는데... 안되네요 )