[프로그래머스] 외벽점검 :: 재귀, 메모이제이션, 코드, 결과

외벽 점검

문제

https://programmers.co.kr/learn/courses/30/lessons/60062#

문제 설명

레스토랑을 운영하고 있는 스카피는 레스토랑 내부가 너무 낡아 친구들과 함께 직접 리모델링 하기로 했습니다. 레스토랑이 있는 곳은 스노우타운으로 매우 추운 지역이어서 내부 공사를 하는 도중에 주기적으로 외벽의 상태를 점검해야 할 필요가 있습니다.

레스토랑의 구조는 완전히 동그란 모양이고 외벽의 총 둘레는 n미터이며, 외벽의 몇몇 지점은 추위가 심할 경우 손상될 수도 있는 취약한 지점들이 있습니다. 따라서 내부 공사 도중에도 외벽의 취약 지점들이 손상되지 않았는 지, 주기적으로 친구들을 보내서 점검을 하기로 했습니다. 다만, 빠른 공사 진행을 위해 점검 시간을 1시간으로 제한했습니다. 친구들이 1시간 동안 이동할 수 있는 거리는 제각각이기 때문에, 최소한의 친구들을 투입해 취약 지점을 점검하고 나머지 친구들은 내부 공사를 돕도록 하려고 합니다. 편의 상 레스토랑의 정북 방향 지점을 0으로 나타내며, 취약 지점의 위치는 정북 방향 지점으로부터 시계 방향으로 떨어진 거리로 나타냅니다. 또, 친구들은 출발 지점부터 시계, 혹은 반시계 방향으로 외벽을 따라서만 이동합니다.

외벽의 길이 n, 취약 지점의 위치가 담긴 배열 weak, 각 친구가 1시간 동안 이동할 수 있는 거리가 담긴 배열 dist가 매개변수로 주어질 때, 취약 지점을 점검하기 위해 보내야 하는 친구 수의 최소값을 return 하도록 solution 함수를 완성해주세요.

제한사항

• n은 1 이상 200 이하인 자연수입니다.
• weak의 길이는 1 이상 15 이하입니다.
  • 서로 다른 두 취약점의 위치가 같은 경우는 주어지지 않습니다.
  • 취약 지점의 위치는 오름차순으로 정렬되어 주어집니다.
  • weak의 원소는 0 이상 n - 1 이하인 정수입니다.
• dist의 길이는 1 이상 8 이하입니다.
  • dist의 원소는 1 이상 100 이하인 자연수입니다.
• 친구들을 모두 투입해도 취약 지점을 전부 점검할 수 없는 경우에는 -1을 return 해주세요.

---

입출력 예

n	weak	dist	result
12	[1, 5, 6, 10]	[1, 2, 3, 4]	2
12	[1, 3, 4, 9, 10]	[3, 5, 7]	1

입출력 예에 대한 설명

입출력 예 #1

원형 레스토랑에서 외벽의 취약 지점의 위치는 다음과 같습니다.

친구들을 투입하는 예시 중 하나는 다음과 같습니다.

• 4m를 이동할 수 있는 친구는 10m 지점에서 출발해 시계방향으로 돌아 1m 위치에 있는 취약 지점에서 외벽 점검을 마칩니다.
• 2m를 이동할 수 있는 친구는 4.5m 지점에서 출발해 6.5m 지점에서 외벽 점검을 마칩니다.

그 외에 여러 방법들이 있지만, 두 명보다 적은 친구를 투입하는 방법은 없습니다. 따라서 친구를 최소 두 명 투입해야 합니다.

입출력 예 #2

원형 레스토랑에서 외벽의 취약 지점의 위치는 다음과 같습니다.

7m를 이동할 수 있는 친구가 4m 지점에서 출발해 반시계 방향으로 점검을 돌면 모든 취약 지점을 점검할 수 있습니다. 따라서 친구를 최소 한 명 투입하면 됩니다.

---

코드

#include <string>
#include <vector>
#include <algorithm>
#include <map>

using namespace std;

unordered_map<string, int> memo;

string makeKeyString(vector<int>& weak, vector<int>& dist){
    // 메모이제이션을 위한 key 생성 함수
    string s;
    for(int i=0; i<weak.size(); i++){
        s += to_string(weak[i]);
        s += "/"; // 구분자
    }
    s+=":"; // 구분자
    for(int i=0; i<dist.size(); i++){
        s += to_string(dist[i]);
        s += "/"; // 구분자
    }
    return s;
}

int memoReturn(string s){
    // 메모이제이션 결과 return
    if(memo.find(s)!=memo.end())
        return memo[s];
    else
        return -1;
}

int module(int n, vector<int>& weak, vector<int> dist) {
    // 현재 weak와 dist에서 최소로 수리할 수 있는 인원수를 return 하는 함수

    if (weak.size() == 0) // weak가 더이상 없으면 0
        return 0;
    if (dist.size() == 0) // weak가 있는데 dist가 없으면 불가능 (최대값 return)
        return 1e9;
    if (weak.size() == 1) // dist가 있는데 weak가 1개 남았으면 바로 해결 가능
        return 1;

    int biggest = dist[dist.size() - 1]; // 가장 큰 dist를 받아옴
    dist.pop_back();
    int mod = n;
    int min = 1e8; // 1 더해주는 것 때문에 1e9로 처리하면 overflow => ㅠㅠ

    for (int i = 0; i<weak.size(); i++) {
        int start = weak[i];
        int end = weak[i] + biggest; end %= mod; // end가 n보다 커지는 것 방지

        vector<int> tmpWeak(weak);
        bool over = false;
        if (start > end) {
            over = true;
        }
        for (int i = tmpWeak.size()-1; i >= 0; i--) { // 갈 수 있는 범위 내의 weak 없애기
            if (over) {
                if (start <= tmpWeak[i] || end >= tmpWeak[i])
                    tmpWeak.erase(tmpWeak.begin() + i);
            }
            else {
                if (start <= tmpWeak[i] && end >= tmpWeak[i])
                    tmpWeak.erase(tmpWeak.begin() + i);
            }
        }

        int tmp;
        string s_tmp = makeKeyString(tmpWeak, dist); // 키 생성
        int tmpMemo = memoReturn(s_tmp); // memo에 있는지 확인
        if(tmpMemo!=-1)
            tmp = tmpMemo; // 있으면 사용
        else{
            tmp = module(n, tmpWeak, dist);
            memo[s_tmp] = tmp; // 없으면 계산 후 memo에 저장
        }
        if (min>tmp)
            min = tmp;
    }
    return min+1; // 처음 dist 사용한 것 고려해서 1 더해주기
}

int solution(int n, vector<int> weak, vector<int> dist) {
    sort(dist.begin(), dist.end());
    int answer = module(n, weak, dist);

    if(answer>=1e8) // 만약 불가능하면
        answer = -1;

    return answer;
}

풀이

처음에 input 값이 적은 걸 생각하지 못하고, 조건에 맞춰 풀다가 된통 당했다 ㅎㅎㅎ input 값이 적고 조건이 너무 많아서 고려하기 힘들면 완전탐색 + 속도개선방법(DP, 메모이제이션, 재귀 조건)를 생각해보자.

재귀를 이용하여, 현재 dist로부터 weak를 제거하기 위해 필요한 최소 인원수를 return 하는 식으로 동작시키면 된다.

1. 완전 탐색으로 dist를 최대 값부터 사용한다.
2. 해당 dist로 갈 수 있는 범위를 각 weak 지점에 대해서 살펴본다.
3. 해당 범위에 있는 weak 지점들을 제거한다.
4. 남은 weak와 dist를 재귀로 넘겨 1번부터 다시 적용한다.

이렇게 재귀 단계를 따라가봤을 때, 다음 단계로 가는 경우의 수는 갈 수 있는 weak의 수이다. 방향은 시계, 반시계 방향을 선택할 수 있지만 한 방향으로 고정하면 모든 경우의 수를 체크할 수 있으므로 시계방향으로 고정한다. weak의 수는 입력값에서 주어졌듯 최대 15이므로 한 단계에서 뻗어나오는 가지의 수는 최대 15개이다.

더해서 weak가 한 단계에 최소 하나씩 사라진다고 최악으로 가정하면 최대 15 깊이가 나오므로, 15^15라는 시간복잡도가 나온다.

이는 너무 큰 시간복잡도 이므로 재귀에서 겹치는 부분을 줄이는 방식으로 시간복잡도를 낮춰야하는데, '메모이제이션'을 사용하였다. 해당 문제에서 겹치는 부분을 판단하는 기준은 dist와 weak이다.

dist와 weak가 같은 module function은 반복할 필요없이 이전 값과 동일한 결과를 내므로 dist와 weak를 사용하여 메모이제이션을 처리하면 된다.

둘 다 vector<int>의 구조이기 때문에 메모이제이션에 용이하도록 구분자를 이용하여 string으로 만들어준 후에 map으로 메모이제이션을 구현해주었다.

채점결과

다른 사람의 풀이

• 순열을 이용해서 푸는 것이 더 빠르다.