29-9kyo-hwang

[9kyo-hwang]

🔗 문제 링크

2022 KAKAO BLIND RECRUITMENT 파괴되지 않은 건물

✔️ 소요된 시간

20분 + 해설보고 1시간 40분

✨ 수도 코드

0. 카카오는 신인가?

처음 문제를 딱 봤을 땐 "? 그냥 반복문으로 값 바꾸면 끝나는 거 아닌가?" 했지만 난이도가 Lv.3인 것을 보고 뭔가 잘못됨을 깨달았다.

일단 그냥 무식하게 순회하는 코드라도 내보자 해서 제출해봤지만 역시 효율성은 싹 다 날려먹었다. 암만 짱구를 굴려봐도 "내가 알고 있는 지식으로 속도를 빠르게 할 수 있나?"에 대한 답이 나오지 않았다.

"이건 내가 모르는 영역인가...?" 싶어서 궁금증을 참지 못하고 카카오 공식 해설글을 봤는데, 역시 전혀 상상도 못한 방법이었다.

효율성 통과한 비율이 1%대인 걸 보니, 나만 그런 건 아니구나 싶어서 안도의 한숨을 쉬었다.

1. 문제 파악

건물의 내구도를 나타내는 2차원 정수 배열 board와 적의 공격 혹은 아군의 회복 스킬을 나타내는 2차원 정수 배열 skill이 매개변수로 주어진다.
적의 공격 혹은 아군의 회복 스킬이 모두 끝난 뒤 파괴되지 않은 건물의 개수를 return하는 solution 함수를 완성하라.

예를 들어, 아래와 같이 크기가 4 x 5인 맵에 내구도가 5인 건물들이 있는 상태를 가정해보자.

적이 맵의 (0,0)부터 (3,4)까지 공격하여 4만큼 건물의 내구도를 낮췄다. 맵은 다음과 같이 변화한다.

적이 맵의 (2,0)부터 (2,3)까지 공격하여 2만큼 건물의 내구도를 낮추면 아래와 같이 4개의 건물이 파괴된다.

아군이 맵의 (1,0)부터 (3,1)까지 회복하여 2만큼 건물의 내구도를 높이면 아래와 같이 2개의 건물이 파괴되었다가 복구되고 2개의 건물만 파괴되어있는 상태로 변한다.

적이 맵의 (0,1)부터 (3,3)까지 공격하여 1만큼 건물의 내구도를 낮추면 아래와 같이 8개의 건물이 더 파괴되어 총 10개의 건물이 파괴된 상태가 된다. 이 때 내구도가 0 이하가 된 이미 파괴된 건물도, 공격을 받으면 계속해서 내구도가 하락한다.

최종적으로 총 10개의 건물이 파괴되지 않았다.

2. 풀이

결국 2차원 배열에서 구간의 변화를 어떻게 효율적으로 처리할 지가 관건이다. 위에서 얘기한 것처럼 brute-force로 풀 경우 정확성 테스트 케이스는 모두 맞출 수 있지만, 시간 복잡도가 $O(N * M * K)$ (K: 스킬 개수)가 되어 효율성 테케에서 시간 초과가 발생했다.

2차원 배열에 앞서, 우선은 1차원 배열에 대한 구간 변화를 효율적으로 처리하는 방법을 보겠다.
[1, 2, 4, 8, 9] 라는 리스트가 주어졌을 때, 0번 원소부터 3번 원소까지 2만큼 빼서 [-1, 0, 2, 6, 9]라는 리스트로 만들고자 한다. 가장 단순한 방법은 반복문을 이용한 방법이지만, 이는 $O(M)$ 시간복잡도가 걸린다.

$O(M)$ 을 $O(1)$ 로 줄이는 방법은 누적 합을 이용하는 것이다.

• 위 예시의 경우, 0번 원소부터 3번 원소까지 2씩 감소시키는 것이므로 [-2, 0, 0, 0, 2]라는 새로운 리스트를 생성한다.
• 이 리스트를 앞에서부터 누적합 시키면 [-2, -2, -2, -2, 0]이 된다.
• 누적합시킨 리스트를 원본 리스트 [1, 2, 4, 8, 9]와 더하면 [-1, 0, 2, 6, 9]를 얻을 수 있다.

즉 a번째 원소부터 b번째 원소까지 c만큼 변화를 주고 싶으면, 새로운 리스트의 a번째 원소에 c를 더하고 b + 1번째 원소에 c를 빼면 된다.

이제 이 내용을 2차원으로 확장해보자. 한 번 (0, 0)부터 (2, 2)까지 n만큼 변화를 준다고 가정해보자.

1차원 배열에서 하는 방법처럼, 각 행마다 따로 누적합을 적용시키면 다음과 같다.

n 0 0 -n
n 0 0 -n
n 0 0 -n

이거를 열 방향에 대해 확인해보자.

n
n
n

이는 결국

 n
 0
 0
-n

과 같다. 또한

-n
-n
-n

이는 결국

-n
 0
 0
 n

과 같다. 결국

n 0 0 -n
n 0 0 -n
n 0 0 -n

이를 다시 표현해보면

 n 0 0 -n
 0 0 0  0
 0 0 0  0 
-n 0 0  n

과 같다. 이를 행과 열에 대해 각각 누적합 시키면

n n n 0
n n n 0
n n n 0
0 0 0 0

임을 알 수 있다. 우리가 원하는 (0, 0)부터 (2, 2)까지 n만큼 변화를 주는 리스트가 완성되었다.

이러한 방법을 통해 skill의 한 원소를 $O(1)$ 만에 처리할 수 있다. 이를 K개의 skill에 대해 모두 적용하므로 $O(K)$ 시간복잡도가 걸린다. 또한 해당 배열을 누적합 배열로 과정이 필요한데, 이때 각각 행 방향과 열 방향에 대해 수행하므로 $O(N * M)$ 시간복잡도가 걸린다. 최종적으로 $O(K + N * M)$ 시간복잡도가 걸리면서, 문제를 해결할 수 있다.

2번 테스트 케이스에 한 번 적용해보자.

1. (1, 1)부터 (2, 2)까지 -4만큼 변화를 줘야 한다. 따라서 (1, 1)과 (3, 3)엔 -4, (1, 3)과 (3, 1)엔 4만큼 변화를 준다.

0  0  0  0
0 -4  0  4
0  0  0  0
0  4  0 -4

2. (0, 0)부터 (1, 1)까지 -2만큼 변화를 줘야 한다. 따라서 (0, 0)과 (2, 2)엔 -2, (0, 2)와 (2, 0)엔 2만큼 변화를 준다.

-2  0  2  0
 0 -4  0  4
 2  0 -2  0
 0  4  0 -4

3. (2, 0)부터 (2, 0)까지 +100만큼 변화를 줘야 한다. 따라서 (2, 0)과 (3, 1)엔 100, (2, 1)과 (3, 0)엔 -100만큼 변화를 준다.

  -2    0  2  0
   0   -4  0  4
 102 -100 -2  0
-100  104  0 -4

이제 이 배열을 먼저 가로 방향으로 누적합한다.

  -2 -2  0 0
   0 -4 -4 0
 102  2  0 0
-100  4  4 0

다음으로 세로 방향으로 누적합한다.

 -2 -2  0 0
 -2 -6 -4 0
100 -4 -4 0
  0  0  0 0

마지막으로 이 리스트를 원본과 합쳐준다.

1 2 3     -2 -2  0     -1  0 3
4 5 6  +  -2 -6 -4  =   2 -1 2
7 8 9    100 -4 -4    107  4 5

따라서 0보다 큰 정수의 개수는 6개이다.

3. 코드 확인

int solution(vector<vector<int>> Board, vector<vector<int>> Skills) 
{
    const int N = Board.size(), M = Board[0].size();
    vector<vector<int>> WeightMatrix = GetWeightMatrix(N, M, Skills);
    
    for(int i = 0; i < N; ++i)
    {
        for(int j = 0; j < M; ++j)
        {
            Board[i][j] += WeightMatrix[i][j];
        }
    }
    
    int Answer = 0;
    for(const vector<int>& Row : Board)
    {
        for(const int& Col : Row)
        {
            Answer += (Col > 0);
        }
    }
    
    return Answer;
}

매개변수로 주어진 board 정보와 skill 정보를 가지고, GetWeightMatrix()를 호출해 누적합 리스트를 만들어 반환받는다.
이를 원본 board 정보와 합친 뒤, 0보다 큰 개수를 카운팅해서 반환한다.

vector<vector<int>> GetWeightMatrix(const int N, const int M, const vector<vector<int>>& InSkills)
{
    vector WeightMatrix(N + 1, vector(M + 1, 0));
    for(const vector<int>& InSkill : InSkills)
    {
        FSkill Skill(InSkill);
        if(Skill.Type == static_cast<int>(ESkillType::ATTACK))
        {
            WeightMatrix[Skill.R1][Skill.C1] -= Skill.Degree;
            WeightMatrix[Skill.R2 + 1][Skill.C2 + 1] -= Skill.Degree;
            
            WeightMatrix[Skill.R1][Skill.C2 + 1] += Skill.Degree;
            WeightMatrix[Skill.R2 + 1][Skill.C1] += Skill.Degree;
        }
        else if(Skill.Type == static_cast<int>(ESkillType::HEAL))
        {
            WeightMatrix[Skill.R1][Skill.C1] += Skill.Degree;
            WeightMatrix[Skill.R2 + 1][Skill.C2 + 1] += Skill.Degree;
            
            WeightMatrix[Skill.R1][Skill.C2 + 1] -= Skill.Degree;
            WeightMatrix[Skill.R2 + 1][Skill.C1] -= Skill.Degree;
        }
    }

    ...
}

누적합 리스트는 원리에 따라 N과 M보다 한 칸씩 더 크게 공간을 잡아준다.
그리고 각각의 스킬을 하나씩 확인한다.

• 만약 해당 스킬이 적의 공격이라면 Degree만큼 (r1, c1)과 (r2 + 1, c2 + 1)는 빼줘야 하고 (r1, c2 + 1)과 (r2 + 1, c1)에는 더해줘야 한다.
• 반대로 아군의 회복이라면 Degree만큼 (r1, c1)과 (r2 + 1, c2 + 1)는 더해줘야 하고 (r1, c2 + 1)과 (r2 + 1, c1)에는 빼줘야 한다.

vector<vector<int>> GetWeightMatrix(const int N, const int M, const vector<vector<int>>& InSkills)
{
    ...
    for(int i = 0; i <= N; ++i)
    {
        for(int j = 0; j < M; ++j)
        {
            WeightMatrix[i][j + 1] += WeightMatrix[i][j];
        }
    }
    
    for(int j = 0; j <= M; ++j)
    {
        for(int i = 0; i < N; ++i)
        {
            WeightMatrix[i + 1][j] += WeightMatrix[i][j];
        }
    }
       
    return WeightMatrix;
}

이제 모든 스킬에 대해 정보 기록을 완료했다면, 마지막으로 가로 방향과 세로 방향으로 각각 누적합을 진행해준다.
누적합이 완료되면 이를 반환해준다.

4. 전체 코드

#include <string>
#include <vector>

using namespace std;

struct FSkill
{
    int Type, R1, C1, R2, C2, Degree;
    
    FSkill(const vector<int>& InSkill) : Type(InSkill[0]), R1(InSkill[1]), C1(InSkill[2]), R2(InSkill[3]), C2(InSkill[4]), Degree(InSkill[5]) { }
};

enum class ESkillType
{
    NONE,
    ATTACK,
    HEAL,
};

vector<vector<int>> GetWeightMatrix(const int N, const int M, const vector<vector<int>>& InSkills)
{
    vector WeightMatrix(N + 1, vector(M + 1, 0));
    for(const vector<int>& InSkill : InSkills)
    {
        FSkill Skill(InSkill);
        if(Skill.Type == static_cast<int>(ESkillType::ATTACK))
        {
            WeightMatrix[Skill.R1][Skill.C1] -= Skill.Degree;
            WeightMatrix[Skill.R2 + 1][Skill.C2 + 1] -= Skill.Degree;
            
            WeightMatrix[Skill.R1][Skill.C2 + 1] += Skill.Degree;
            WeightMatrix[Skill.R2 + 1][Skill.C1] += Skill.Degree;
        }
        else if(Skill.Type == static_cast<int>(ESkillType::HEAL))
        {
            WeightMatrix[Skill.R1][Skill.C1] += Skill.Degree;
            WeightMatrix[Skill.R2 + 1][Skill.C2 + 1] += Skill.Degree;
            
            WeightMatrix[Skill.R1][Skill.C2 + 1] -= Skill.Degree;
            WeightMatrix[Skill.R2 + 1][Skill.C1] -= Skill.Degree;
        }
    }
    
    for(int i = 0; i <= N; ++i)
    {
        for(int j = 0; j < M; ++j)
        {
            WeightMatrix[i][j + 1] += WeightMatrix[i][j];
        }
    }
    
    for(int j = 0; j <= M; ++j)
    {
        for(int i = 0; i < N; ++i)
        {
            WeightMatrix[i + 1][j] += WeightMatrix[i][j];
        }
    }
       
    return WeightMatrix;
}

int solution(vector<vector<int>> Board, vector<vector<int>> Skills) 
{
    const int N = Board.size(), M = Board[0].size();
    vector<vector<int>> WeightMatrix = GetWeightMatrix(N, M, Skills);
    
    for(int i = 0; i < N; ++i)
    {
        for(int j = 0; j < M; ++j)
        {
            Board[i][j] += WeightMatrix[i][j];
        }
    }
    
    int Answer = 0;
    for(const vector<int>& Row : Board)
    {
        for(const int& Col : Row)
        {
            Answer += (Col > 0);
        }
    }
    
    return Answer;
}

📚 새롭게 알게된 내용

카카오에는 천재들만 존재하는 것인가...? 누적합을 이렇게 응용한다는 걸 상상조차 못했다.
허허... 벽이 좀 느껴진다.

[Dolchae]

난이도가 높은 문제일 수록 이렇게 효율을 따져서 최적화하는 과정이 더 중요해지는 것 같네요.. 그리고 느껴지셨다는 그 벽, 저는 선배님한테 느끼고 갑니다😄😂 이번 문제도 대단히 수고하셨습니다🔥😊

[xxubin04]

저도 문제 설명을 보고 '브루트포스로 푸는 건가?' 싶었는데 효율성 테케도 통과해야 하는군요...
저에겐 그냥 벽이 아니고 거인들의 벽이네요...😂
선배님도 저에겐 엄청난 벽이랍니다.👍
수고 많으셨습니다!!