[프로그래머스] 외벽 점검

문제

---

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

레스토랑의 구조는 완전히 동그란 모양이고 외벽의 총 둘레는 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 해주세요.

 

 

 

 

풀이

---

원형이기 때문에 문제를 풀 때 어려움이 있다. 이를 해결하기위해 선형으로 배치하는 것이 필요하다.

 

weak[] 배열을 2배로 선언하고 n 만큼을 더해서 선형으로 두배시켜 한바퀴 돌았을 때를 표현해준다.

예를들면,

n = 12, weak[] = [1, 5, 6, 10] 일 때, weak[] = [1, 5, 6, 10, 13, 17, 18, 22] 형태로 바꿔준다.

 

이렇게하면 원형인 형태를 선형으로 표현할 수 있다.

 

그리고 dist 배열을 순열로 배치 해준다.

항상 같은 형태로 대입하면 같은 답만 발생한다. 하지만, 1번에서 외벽점검을 하는 사람을 바꿔주면 모든 경우의 수를 따질 수 있다.

 

이렇게 2가지 방식을 지켜서 완전탐색을 하면 된다.

 

아래코드는 dist 배열의 순열의 모든 경우의 수를 구하는 코드다.

static void Permutation(List<Integer> dist, List<Integer> result, int r, int size){
    if(r == size){
        List<Integer> P_dist = new ArrayList<Integer>();
        for(int d : result){
            P_dist.add(d);
        }

        list.add(P_dist);
        return;
    } 


    for(int i = 0 ; i < dist.size() ; i++){
        result.add(dist.remove(i));
        Permutation(dist, result, r + 1, size);
        dist.add(i, result.remove(result.size() - 1));
    }
}

이렇게 구해진 순서를 weak 배열의 0 번째 부터 순찰한 결과 1 번째 부터 순찰한 결과 ...  weak.length번째까지 순찰한 결과중 가장 최솟값을 구하면 된다. 아래 코드가 이를 의미한다.

for(int start = 0 ; start < weak.length ; start++){

    int weakIndex = start;
    int time = weak_double[weakIndex];
    int i = 0;
    for(i = 0 ; i < distList.size() ; i++){
        if(distList.get(i) == 0){
            continue;
        }
        time += distList.get(i);

        while( weakIndex < start + weak.length && time >= weak_double[weakIndex]){
            weakIndex++;
        }

        if(weakIndex < start + weak.length){
            time = weak_double[weakIndex];
        }
        else{ 
            break;
        }
    }

    if(i < dist.length){
        answer = Math.min(answer, i + 1);
    }   

time 의 수가 weak_double 에 저장 된 수보다 크면 weakIndex를 늘려준다. 이때 마지막 까지 다 순찰하였는데 i 가 dist.length 보다 작으면 모두 순찰가능한 경우이므로 이때의 결과를 answer와 비교해 준다.

 

 

<전체코드>

import java.util.*;

class Solution {
    
    static List<List<Integer>> list;
    public int solution(int n, int[] weak, int[] dist){
        int answer = dist.length + 1;
        
        int[] weak_double = new int[weak.length * 2];
        for(int i = 0 ; i < weak.length * 2 ; i++){
            if(i < weak.length){
                weak_double[i] = weak[i];
            }
            else{
                weak_double[i] = weak[i - weak.length] + n;
            }
        }
        
        list = new ArrayList<>();
        List<Integer> dist_List = new ArrayList<Integer>();
        for(int d : dist){
            dist_List.add(d);
        }
        Permutation(dist_List, new ArrayList<Integer>(), 0, dist_List.size());
        
        for(List<Integer> distList : list){
            
            for(int start = 0 ; start < weak.length ; start++){

                int weakIndex = start;
                int time = weak_double[weakIndex];
                int i = 0;
                for(i = 0 ; i < distList.size() ; i++){
                    if(distList.get(i) == 0){
                        continue;
                    }
                    time += distList.get(i);

                    while( weakIndex < start + weak.length && time >= weak_double[weakIndex]){
                        weakIndex++;
                    }

                    if(weakIndex < start + weak.length){
                        time = weak_double[weakIndex];
                    }
                    else{ 
                        break;
                    }
                }

                if(i < dist.length){
                    answer = Math.min(answer, i + 1);
                }   
}
        }        
        
        if(answer == dist.length +1){
            answer = -1;
        }
        
        return answer;
    }
    
    static void Permutation(List<Integer> dist, List<Integer> result, int r, int size){
        if(r == size){
            List<Integer> P_dist = new ArrayList<Integer>();
            for(int d : result){
                P_dist.add(d);
            }

            list.add(P_dist);
            return;
        } 


        for(int i = 0 ; i < dist.size() ; i++){
            result.add(dist.remove(i));
            Permutation(dist, result, r + 1, size);
            dist.add(i, result.remove(result.size() - 1));
        }
    }
}