70-9kyo-hwang

[9kyo-hwang]

🔗 문제 링크

2021 KAKAO BLIND RECRUITMENT 매출 하락 최소화

"카카오상사"는 다음과 같은 조직 구성도를 갖는다.

원 안에 적힌 두 개의 숫자는 직원의 정보를 의미한다. 왼쪽 숫자는 직원번호이며 직원을 식별할 수 있도록 1번부터 순서대로 발급되는 일련번호이며, 오른쪽 숫자는 해당 직원의 하루평균 매출액을 나타낸다. 위 그림에서 1번 직원은 14원을, 9번 직원은 28원의 하루평균 매출액을 기록하고 있다.

화살표가 시작되는 쪽의 직원은 팀장, 화살표를 받는 쪽의 직원은 팀원을 의미한다.

• 직원번호 1번은 회사의 CEO로 고정되어 있으며, CEO는 항상 팀장이고 팀원일 수 없어 화살표를 받는 쪽이 될 수 없다.
• CEO를 제외한 나머지 모든 직원들은 다른 누군가로부터 정확히 1개의 화살표를 받는다.

한 직원은 최대 2개의 팀에 소속될 수 있지만, 팀장을 겸임하거나 두 개의 팀에서 팀원이 될 수는 없다.

• 10번 직원은 D팀의 팀장이면서 동시에 5번 직원이 팀장으로 있는 C팀에 속한 팀원이다.
• 5번, 9번, 10번 직원은 받는 쪽의 화살표와 시작하는 화살표가 모두 있으므로 팀장인 동시에 팀원이다.
• 2번, 3번, 4번, 6번, 7번, 8번 직원은 시작하는 화살표가 없고 받는 쪽의 화살표만 있으므로 팀장이 아니며 오직 팀원이다.
• 1번 직원인 CEO는 받는 쪽의 화살표가 없고 시작하는 화살표만 있으며 항상 팀원이 아닌 팀장이다.

그림의 조직도에는 A, B, C, D 총 4개의 팀이 존재하며, 각각 1번, 9번, 5번, 10번 직원이 팀장 직위를 담당한다.

이러한 구성에서, 하루 일정으로 워크숍을 계획하고 있다. 단, 모든 직원을 참석시킬 수 없어 아래와 같은 기준으로 워크숍에 참석할 직원들을 선발하려고 한다.

1. 워크숍에서 교육받은 내용은 전 직원들에게 공유되어야 하므로 모든 팀은 최소 1명 이상의 직원을 워크숍에 참석시켜야 한다.
2. 워크숍 기간 동안, 회사의 매출 손실을 최소화하는 것이 중요하므로 워크숍에 참석하는 직원들의 하루평균 매출액의 합이 최소가 되어야 한다.

위 조직도에서는 회색으로 칠해진 1, 7, 10번 직원을 워크숍에 참석시키면 모든 팀에서 최소 한 명 이상의 직원을 참석시킨 것이 되며, 해당 직원들의 하루평균 매출액의 합은 44(14+13+17)원이다. 10번 직원은 C팀과 D팀 모두에 속해 있으므로, 두 팀에서 모두 참석한 것으로 인정된다.

모든 팀에서 최소 한 명 이상 워크숍에 참석하면서, 참석하는 직원들의 하루평균 매출액의 합을 최소로 하려고 할 때, 최소화된 매출액의 합을 구해서 return 하도록 solution 함수를 완성하라.

✔️ 소요된 시간

2시간 하고 GG쳐서 해설 봄...

✨ 수도 코드

조직도 그림을 보면 알 수 있듯, 트리 형태로 관계를 표현할 수 있다. CEO, 즉 1번 노드가 Head로 존재하고 팀원들이 서브 트리로 표현된다.

vector<vector<int>> Tree;
int solution(vector<int> InSales, vector<vector<int>> InLinks) 
{
    Tree.resize(InSales.size() + 1);  // Sales 배열 길이가 직원 수(N), 1번부터 시작하므로 N + 1
    for(const vector<int>& Link : InLinks)
    {
        int a = Link[0], b = Link[1];
        Tree[a].emplace_back(b);
    }

    ...
}

우리의 목표는 모든 팀에서 최소 한 명의 팀원을 워크숍에 참석시키되, "매출 손해를 최소로" 만들어야 한다. 다만 매출 손해가 최소가 되는 팀원 조합이 바로 알 수 있는 방법은 없으므로, 모든 경우를 확인해봐야 한다.
다만 직원이 최대 300,000명까지 존재할 수 있기 때문에 단순히 모든 경우를 확인하기에는 시간이 너무 오래 걸린다. 그렇기에 각 경우에 따른 매출 손실을 캐싱해두는 등 별도의 조치가 필요하다. 이 점을 기억하자.

우선 각 팀원이 워크숍에 참석하냐, 참석 안하냐에 따른 매출 손실을 나타내보자.

• 팀장이 아닌 팀원, 즉 Leaf Node들은 참석 안하면 손실이 없고 참석 하면 본인의 매출만큼 손실이 발생한다.
• 팀장 입장에서는 아래 조직에서 계산된 최선의 결과 + 나의 참석 유무에 따른 추가 손실로 경우가 나뉜다.

위와 같은 계산 방식을 생각해보면, DFS를 사용하여 말단 직원에서 시작해 최종적으로 CEO에 도달해서 최선의 결과를 얻어내는 식으로 계산하는 방식이 합리적이다.

pair<int, int> DFS(const vector<int>& InLosses, const int Head = 1);

DFS 함수를 위와 같이 정의한다. 2개의 int 값을 반환하는데, (Head 직원이 참석 안했을 때의 최소 매출 손실, Head 직원이 참석했을 때의 최소 매출 손실)을 반환한다. 인자는 손실, 즉 각 팀원의 매출 배열과 현재 팀원(팀장) 번호를 의미한다. 최초 시작은 CEO이다.

if(Tree[Head].empty())
{
    return {0, LossIfHeadParticipation};
}

현재 Head 팀원의 하부 조직이 없을 경우, 즉 Leaf Node인 경우 위에서 얘기한 것처럼 (참석 안하면 손실 0, 참석하면 본인 매출만큼 손실)을 반환한다.

int TotalLosses = 0, MinLossDifference = 1e9;
bool bMemberParticipation = false;
for(const int Member : Tree[Head])
{
    const auto& [LossIfNotParticipation, LossIfParticipation] = DFS(InLosses, Member);
    TotalLosses += min(LossIfNotParticipation, LossIfParticipation);
    ...
}

Leaf Node가 아니라면 자기 밑으로 팀원들이 존재할 테니 각각을 순회하며 DFS를 재귀 호출해 (참석 안했을 때의 손실, 참석 했을 때의 손실)을 각각 반환받는다. 그리고 둘 중 손실이 적은 쪽의 값으로 전체 손실을 기록한다.

for(const int Member : Tree[Head])
{
    ...
    if(LossIfNotParticipation >= LossIfParticipation)
    {
        bMemberParticipation = true;
    }

    MinLossDifference = min(MinLossDifference, LossIfParticipation - LossIfNotParticipation);
}

이 부분을 주의해야 한다. 일반적으로 생각하면 "참석을 안하면 안 할 수록 매출 손실은 적어진다"가 맞지만, 일부 경우는 참석을 안하는 게 더 큰 매출 손실이 일어날 수 있다. 그럴 경우 팀원을 반드시 참석시켜야 한다. MinLossDifference는 아래에서 설명한다.

if(bMemberParticipation)
{
    return {TotalLosses, LossIfHeadParticipation + TotalLosses};
}
...

하위 팀원들의 결과를 모두 확인했다면 최종적으로 팀장의 참석 유무에 따른 비용을 추가로 계산해 최종 손실을 반환해주면 된다.
만약 위 for문에서 "참석시켜야 매출 손실이 덜 한" 팀원이 발견됐을 경우, 그 팀은 최소 1명 참석이 보장되므로 반환하는 매출 손실도 딱 팀장의 매출 만큼 더해진다. 즉 (팀장이 참석 안하면 팀원들의 손실, 팀장이 참석하면 팀원들의 손실 + 팀장 매출)이 반환된다.

반면 "모든 팀원이 워크숍에 참석하지 않는 것이 매출 손실이 덜 발생한다"라고 하면 고려해야 할 사항이 늘어난다.

• 팀장이 워크숍에 참석한다면 해당 팀에 최소 1명 참석이 보장되는 것이므로 밑에서 계산된 손실 + 팀장 매출을 반환하면 된다.
• 팀장조차 참석을 안하는 경우는 "팀원 중 한 명을 강제로 참석"시켜야 하는데, 이 경우 어떤 팀원을 참석시켜야 하는 지에 대해 고민해야 한다.

모든 팀원이 참석 안하는 게 손실이 가장 적고, 팀장마저 참석을 안한다면 손실을 감수하고 팀원 1명을 강제로 참여시켜야 한다. 이 때 어떤 팀원을 참석시켜야 하는 지가 문제인데, 여기서 MinLossDifference를 다시 확인한다.

MinLossDifference = min(MinLossDifference, LossIfParticipation - LossIfNotParticipation);

말 그대로 참석 했을 때의 손실과 참석 안 했을 때의 손실의 차 중 가장 작은 값을 기록한다. 이 값이 여기서 사용되는데, 어쩔 수 없이 팀원 한 명을 참석시켜야 한다면 "참석 하든 안 하든 매출 손실 차이가 별로 없는" 직원을 참석시키는 것이 가장 좋기 때문이다.
정확히는, "참석 안 했을 때의 손실을 빼고 참석 했을 때의 손실을 더했을 때 그 값이 가장 작은 팀원"을 찾는 것이다.

• 현재 TotalLosses에는 min(LossIfNotParticipation, LossIfParticipation) 값이 누적되고 있는데, 우리가 확인하는 경우는 LossIfNotParticipation 값만 누적된 경우이다.
• 즉 1명을 참석시켜야 한다면 TotalLosses에서 해당 팀원의 LossIfNotParticipation 값이 빠지고 LossIfParticipation 값이 더해져야 한다.
• 다시 말해 TotalLosses - LossIfNotParticipation + LossIfParticipation 과정이 발생하는 것이므로, 더해지는 LossIfParticipation 값이 가장 작은 팀원을 찾아야 하는 것이다.
• 그러므로 LossIfParticipation - LossIfNotParticipation이 가장 작은 팀원을 찾아 MinLossDifference로 기록하는 것이다.

참석시킬 팀원을 찾았다면, 팀장이 참석하지 않았을 때의 반환값으로 TotalLosses + MinLossDifference를 반환한다.

...
else
{
    return {TotalLosses + MinLossDifference, LossIfHeadParticipation + TotalLosses};
}

최종적으로 solution 함수에서 최초로 DFS 함수를 호출할 때의 반환값은 [CEO가 참석하지 않았을 때의 최소 손실, CEO가 참석했을 때의 최소 손실]이 된다. 이 둘 중 작은 값을 반환하면 된다.

const auto& [LossIfNotParticipation, LossIfParticipation] = DFS(InSales);
return min(LossIfNotParticipation, LossIfParticipation);

전체 코드

#include <string>
#include <vector>

using namespace std;

vector<vector<int>> Tree;
pair<int, int> DFS(const vector<int>& InLosses, const int Head = 1)
{
    const int LossIfHeadParticipation = InLosses[Head - 1];
    
    if(Tree[Head].empty())
    {
        return {0, LossIfHeadParticipation};
    }

    int TotalLosses = 0, MinLossDifference = 1e9;
    bool bMemberParticipation = false;
    
    for(const int Member : Tree[Head])
    {
        const auto& [LossIfNotParticipation, LossIfParticipation] = DFS(InLosses, Member);
        TotalLosses += min(LossIfNotParticipation, LossIfParticipation);

        if(LossIfNotParticipation >= LossIfParticipation)
        {
            bMemberParticipation = true;
        }

        MinLossDifference = min(MinLossDifference, LossIfParticipation - LossIfNotParticipation);
    }

    if(bMemberParticipation)
    {
        return {TotalLosses, LossIfHeadParticipation + TotalLosses};
    }
    else
    {
        return {TotalLosses + MinLossDifference, LossIfHeadParticipation + TotalLosses};
    }
}

int solution(vector<int> InSales, vector<vector<int>> InLinks) 
{
    Tree.resize(InSales.size() + 1);
    for(const vector<int>& Link : InLinks)
    {
        int a = Link[0], b = Link[1];
        Tree[a].emplace_back(b);
    }

    const auto& [LossIfNotParticipation, LossIfParticipation] = DFS(InSales);
    return min(LossIfNotParticipation, LossIfParticipation);
}

📚 새롭게 알게된 내용

줄 글로만 적다보니 설명이 너무 길어진 것 같다.
프로그래머스 AI가 문제 추천해주길래 트라이 했다가 시원하게 패배해버렸는데, Level 4 문제였네... ㅋㅋ

[gjsk132]

될듯 말듯 됐다가 안됐다가...

어찌저찌 재귀를 써서 하는게 적절한건 알았는데...
결국 실패했습니다🥲

반환값을 팀장이 있냐 없냐 2개로 넘겨주는걸 보니까 뭔가 어떻게 하면 해결하면 되는지 빡 이해했습니다.