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

문제 링크

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

문제 설명

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

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

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

제한사항

알고리즘: 브루트 포스

풀이

이 문제는 취약 지점을 점검하기 위해 보내야 하는 친구 수의 최소값을 구하는 문제다.

먼저, 취약 지점을 점검하는 순서를 구해야 한다. 취약 지점이 [1, 5, 6, 10]일 때
1. 1 -> 5 -> 6 -> 10
2. 5 -> 6 -> 10 -> 1
3. 6 -> 10 -> 1 -> 5
4. 10 -> 1 -> 5 -> 6
총 4가지 존재한다.
여기서 시계 방향만 따지는 이유는 반시계 방향으로도 움직일 수 있지만, 각 지점 간의 차이는 같기 때문에 한 방향만 선택하면 모든 경우의 수를 구할 수 있다.
ex)
1 -> 5 -> 6 -> 10은 시계 방향
10 -> 6 -> 5 -> 1은 반시계 방향
두 순서는 거리가 같다. (중복임) 그렇기 때문에 한 방향만 따져주면 된다.

취약 지점을 점검하는 순서를 구했으면, 이제 친구들을 투입하는 모든 경우의 수를 구하면 된다. -> 여기서 순열을 이용

그리고 취약 지점을 점검하는 모든 순서에 친구들을 투입하는 모든 순서로 답을 찾아내면 된다. -> 반복문으로 간단하게 구현 가능

모든 경우의 수를 따졌을 때
weak는 15 이하이기 때문에 취약 지점을 점거하는 모든 순서는 15개가 최대다.
dist는 8 이하이고 순열이기 때문에 모든 순서는 8!이다.
계산하면 총 경우의 수는 604800이다.

소스 코드

import java.util.*;
class Solution {
    static ArrayList<ArrayList<Integer>> weakOrder_list = new ArrayList<>();
    static ArrayList<Integer> result = new ArrayList<>();
    static int answer = Integer.MAX_VALUE;
    static boolean[] visited;
    public int solution(int n, int[] weak, int[] dist) {
        visited = new boolean[dist.length];
        for(int i=0; i<weak.length; i++) {
            ArrayList<Integer> weak_list = new ArrayList<>();
            for(int j=i; j < i + weak.length; j++) {
                if(j < weak.length) weak_list.add(weak[j]); 
                else weak_list.add(weak[j - weak.length] + n);
            }
            weakOrder_list.add(weak_list);
        }
        DFS(dist);
        return answer == Integer.MAX_VALUE ? -1 : answer;
    }
    
    static void DFS(int[] dist) {
        if(result.size() == dist.length) {
            for(int i=0; i<weakOrder_list.size(); i++) {
                ArrayList<Integer> weak_list = weakOrder_list.get(i);
                int weak_ind = 0;
                int cnt = 0;
                for(int j=0; j<result.size(); j++) {
                    int end = result.get(j) + weak_list.get(weak_ind);
                    weak_ind = search_nextInd(end, weak_ind, weak_list);
                    cnt += 1;
                    if(weak_ind == -1) {
                        //모든 취약 지점을 점검함.
                        answer = Math.min(answer, cnt);
                        break;
                    }
                }
            }
            return;
        }
        for(int i=0; i<dist.length; i++) {
            if(!visited[i]) {
                result.add(dist[i]);
                visited[i] = true;
                DFS(dist);
                result.remove(result.size()-1);
                visited[i] = false;
            }
        }
    }
    
    static int search_nextInd(int end, int weak_ind, ArrayList<Integer> weak_list) {
        for(int i=weak_ind + 1; i<weak_list.size(); i++) {
            if(weak_list.get(i) > end) return i;
        }
        return -1;
    }
}