문제 설명


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

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

입출력 예

nweakdistresult

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 지점에서 출발해 반시계 방향으로 점검을 돌면 모든 취약 지점을 점검할 수 있습니다. 따라서 친구를 최소 한 명 투입하면 됩니다.

 

 

접근 방법


 백트래킹을 돌며 한 명씩 친구를 배치시킨 후 모든 외벽의 점검을 다했는지 확인하여 해결 할 수 있습니다. 이 때 친구들을 배치하는 순서는 최대한 1시간 내에 이동거리가 큰 친구부터 배치하는 것이 좋습니다.

 

 저는 외벽의 점검 상태를 알기 위해 vector<pair<int(번호), bool(점검여부)>> wall이라는 자료구조를 사용하였습니다.  아래의 코드로 초기화를 시킬 수 있습니다.

for (int i = 0; i < weak.size(); i++) {
	wall.push_back({weak[i], true});
}

 

백트래킹 함수를 살펴보자면 백트래킹의 종료시점은 2가지가 있습니다. 

1. 모든 벽의 점검이 완료되었을 때

2. dist(이동거리 정보에 대한 벡터)로 해결 할 수 없을 때(모든 벽 점검 불가능)

 

위의 두 조건에 걸리지 않는다면 현재 함수에 대한 처리를 합니다.

 

1. 아직 점검이 되지 않은 외벽이 있는지 찾습니다.

2. 점검이 되지 않은 외벽이 있다면 그 벽의 위치를 start라고 정의합니다.

3. 현재 이 벽을 처리해야될 친구가 idx라면 친구는 start ~ start + dist[idx] 사이에 있는 모든 벽을 점검할 수 있습니다. 

4. 이 때 end = start + dist[idx]가 n보다 크거나 같다면(끝 지점이 한 바퀴를 돌아버리는 경우) 점검해야 할 범위는 start ~ n 과 0 ~ end%n 사이가 될 것입니다.

 

 

소스 코드


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

using namespace std;

bool comp(int a, int b) {
	return a > b;
}

bool check(vector<pair<int, bool>> &wall) {

	for (int i = 0; i < wall.size(); i++) {
		if (wall[i].second)
			return false;
	}
	return true;
}

int solve(vector<pair<int, bool>> wall, vector<int> &dist, int idx, int n) {

	int ret = 101; //최대의 경우의 수가 100이기 때문에 101로 초기화

	if (check(wall)) 
		return idx;
    if(idx == dist.size())
        return ret;
    
	vector<pair<int, bool>> tmp = wall;
	for (int i = 0; i < wall.size(); i++) {
		if(wall[i].second){
            
            int start = wall[i].first;
            int end = wall[i].first + dist[idx];
            
            if(end >= n){ // 끝 지점이 한 바퀴를 넘어가는 경우
                end %= n;
                for(int j=0;j<wall.size();j++)
                    if((start <= wall[j].first && wall[j].first < n) || (0 <= wall[j].first && wall[j].first <= end))
                        wall[j].second = false;
            }
            else{ // 끝 지점이 범위 내에 있는 경우
                for(int j=0;j<wall.size();j++)
                    if(start <= wall[j].first && wall[j].first <= end)
                        wall[j].second = false;
            }
            ret = min(ret, solve(wall, dist, idx+1, n));
            wall = tmp;
        }
	}
	return ret;
}

int solution(int n, vector<int> weak, vector<int> dist) {

	int answer = 0;

	vector<pair<int, bool>> wall;
	for (int i = 0; i < weak.size(); i++) {
		wall.push_back({weak[i], true});
	}
    //이동거리를 내림차순으로 정렬 -> backTracking에서 idx를 1씩 증가시키며 참조하기 위함
	sort(dist.begin(), dist.end(), comp); 
	answer = solve(wall, dist, 0, n);
    // 101이라면 불가능한 경우
    answer = (answer == 101) ? -1 : answer;

	return answer;
}

접근 방법


 시뮬레이션 문제 입니다. 다만 문제를 조금 쉽게 풀기 위해서 생각해야 될 부분은

기둥과 보를 각각 2차원 배열로 따로 관리한다는 점과 삭제 연산 시에 현재 구조물을 삭제했을 때 영향을 받을 수 있는 주변의 구조물들이 온전하게 있을지에 대한 것입니다. 

 

시뮬레이션 과정은 총 4가지를 고려해야 합니다.

1. 기둥 설치, 2. 보 설치, 3. 기둥 삭제, 4. 보 삭제

 

기둥 배열을 bool col[][], 보 배열을 bool bo[][]라 한다면 

 

1의 경우

기둥이 바닥에 있거나 (y == 0)

보의 한쪽 끝 부분위에 있거나 (bo[y][x] == true || bo[y][x - 1] == true)

다른 기둥위에 있어야합니다. (col[y - 1][x] == true)

bool canBuildCol(int x, int y){
    return (y == 0 || col[y - 1][x] || bo[y][x] || bo[y][x - 1]);
}

 

2의 경우 

보는 한쪽 끝 부분이 기둥위에 있거나 (col[y - 1][x] || col[y - 1][x + 1])

양쪽 끝이 다른 보와 연결 되어 있어야 합니다. (bo[y][x - 1] && bo[y][x + 1])

bool canBuildBo(int x, int y){
    return (col[y - 1][x] || col[y - 1][x + 1] || (bo[y][x - 1] && bo[y][x + 1]));
}

 

3의 경우

기둥을 삭제하면 영향을 받을 수 있는 구조물은 3개가 있습니다.

빨간색 기둥을 삭제 한다면 2개의 파란색 보와, 윗 부분의 파란색 기둥이 영향을 받을 수 있는데 

 이러한 구조물이 없다면 삭제해도 되지만 구조물이 있다면 빨간색 구조물이 없을 때에도 온전하게 있을 수 있는지 검사를 해야합니다.

 

  (1) 기둥의 상단에 기둥이 있다면, 기둥을 삭제한 후 상단의 기둥이 온전히 있을 수 있는지

  (2) 기둥의 좌측 상단에 보가 있다면, 기둥을 삭제한 후 좌측 상단의 보가 온전히 있을 수 있는지

  (3) 기둥의 상단에 보가 있다면, 기둥을 삭제한 후 그 상단의 보가 온전히 있을 수 있는지 

  col[y][x] = false;
  if((col[y + 1][x] && !canBuildCol(x, y+1)) || 
  	(bo[y + 1][x] && !canBuildBo(x, y + 1)) || 
  	(bo[y + 1][x - 1] && !canBuildBo(x - 1, y + 1))){
  	
    col[y][x] = true;
  }

온전히 있을 수 없다면 다시 기둥을 설치합니다.

 

 

4의 경우 

보를 삭제하면 영향을 받을 수 있는 구조물은 4개가 있습니다. 

 빨간색 보를 삭제하게 된다면 양쪽 끝의 보 2개와 기둥 2개가 영향을 받습니다. 

위와 마찬가지로 4가지 구조물에 대한 검사를 합니다. 

 

  (1) 우측에 보가 있다면, 보를 삭제한 후 우측의 보가 온전히 있을 수 있는지 

  (2) 좌측에 보가 있다면, 보를 삭제한 후 좌측의 보가 온전히 있을 수 있는지 

  (3) 자신의 위치에 기둥이 있다면, 보를 삭제한 후 그 기둥이 온전히 있을 수 있는지 

  (4) 우측에 기둥이 있다면, 보를 삭제한 후 우측의 기둥이 온전히 있을 수 있는지 

bo[y][x] = false;
if((col[y][x] && !canBuildCol(x, y)) || 
	(col[y][x + 1] && !canBuildCol(x + 1, y)) || 
	(bo[y][x - 1] && ! canBuildBo(x - 1, y)) || 
	(bo[y][x + 1] && !canBuildBo(x + 1, y)) ){

	bo[y][x] = true;
}

온전히 있을 수 없다면 다시 보를 설치 합니다.

 

 

 마지막으로 정답을 출력하기 위한 정렬 순서로는 x좌표 순 오름차순, x좌표가 같다면 y좌표 순 오름차순, 둘 다 같다면 기둥이 먼저 출력이 되어야 합니다.

    for(int x=0;x<=n;x++){
        for(int y=0;y<=n;y++){
            if(col[y][x])
                answer.push_back({x,y,0});
            if(bo[y][x])
                answer.push_back({x,y,1});
        }    
    }
        

 

 

소스 코드


#include <string>
#include <string.h>
#include <vector>
#include <iostream>

using namespace std;

bool bo[101][101];
bool col[101][101];

bool canBuildCol(int x, int y){
    return (y == 0 || col[y - 1][x] || bo[y][x] || bo[y][x - 1]);
}

bool canBuildBo(int x, int y){
    return (col[y - 1][x] || col[y - 1][x + 1] || (bo[y][x - 1] && bo[y][x + 1]));
}

void solve(vector<int> &info){
    
    int x = info[0];
    int y = info[1];
    int type = info[2];
    int build = info[3];
    
    if(type == 0 && build == 1){
        if(canBuildCol(x, y))
            col[y][x] = true;
    }
    else if(type == 1 && build == 1){
        if(canBuildBo(x, y))
            bo[y][x] = true;
    }
    else if(type == 0 && build == 0){
        col[y][x] = false;
        if((col[y + 1][x] && !canBuildCol(x, y+1)) || 
           (bo[y + 1][x] && !canBuildBo(x, y + 1)) || 
           (bo[y + 1][x - 1] && !canBuildBo(x - 1, y + 1))){
            
            col[y][x] = true;
        }
    }
    else{
        bo[y][x] = false;
        if((col[y][x] && !canBuildCol(x, y)) || 
           (col[y][x + 1] && !canBuildCol(x + 1, y)) || 
           (bo[y][x - 1] && ! canBuildBo(x - 1, y)) || 
           (bo[y][x + 1] && !canBuildBo(x + 1, y)) ){
            
            bo[y][x] = true;
        }
    }
}

vector<vector<int>> solution(int n, vector<vector<int>> build_frame) {
    
    vector<vector<int>> answer;
    
    memset(bo, false, sizeof(bo));
    memset(col, false, sizeof(col));
    
    for(int i=0;i<build_frame.size();i++)
        solve(build_frame[i]);
    
    for(int x=0;x<=n;x++){
        for(int y=0;y<=n;y++){
            if(col[y][x])
                answer.push_back({x,y,0});
            if(bo[y][x])
                answer.push_back({x,y,1});
        }    
    }
        
    return answer;
}

접근 방법


 

효율성 또한 판별하는 문제 이므로 빠른 실행 시간이 요구되는 방법을 찾아야 했습니다.

 일단 쿼리의 수가 매우 많기 때문에 매번 새로운 계산을 한다기 보다 적절하게 값을 저장한 뒤에 불러와야 한다는 점과 트라이 구조를 사용하면 해결할 수 있을 것이라는 아이디어가 있었습니다.

 

트라이 구조의 한 노드는 아래와 같은 자료구조를 갖습니다.

typedef struct node{
    map <char, node> child; 
    map <int, int> info;
};

1. child는 현재 문자에 따라 child 노드로 연결 할 수 있는 링크입니다.

2. info는 현재 info[idx를 포함하여 단어가 끝나기 까지의 문자 길이] = 갯수 입니다.

 

info를 조금 더 자세히 설명하자면 아래의 그림과 같습니다.

1번 노드의 경우 현재 자신부터 말단 까지

길이가 4인 것의 갯수는 2개([1,2,3,4], [1,2,3,5]) 

길이가 3인 것의 갯수는 1개([1,2,6])

길이가 2인 것의 갯수는 1개([1,7])이다.

2번 노드의 경우 현재 자신부터 말단 까지

길이가 3인 것의 갯수는 2개 ([2,3,4], [2,3,5])

길이가 2인 것의 갯수는 1개 ([2,6])이다. 

 

 이러한 구조를 사용하는 이유는 query의 한 단어에서 '?'가 나왔을 때 모든 노드를 탐색하지 않고 ?의 갯수를 통해 바로 매치되는 단어의 수를 찾을 수 있기 때문입니다. 

 

 예를 들어 위와 같은 그림에서 단어가 "1???"라면 1노드 방문 후 2번 노드로 이동할 것이고 이 때의 문자는 ?이며 '?'의 수는 3개 이므로 2번 노드의 info[3]을 조회하면 바로 매치되는 단어의 수를 찾을 수 있습니다. 

 

 마지막으로 생각해야 하는 부분은 '?'가 앞에서 나오는 경우 입니다. 예를 들어 "??abc"와 같은 경우인데 이런 경우는 문자의 가장 뒤 부터 트라이를 탐색해야 합니다. 이 부분을 해결하기 위해서는 트라이를 구성할 때 역방향의 트라이 또한 만들어야 합니다. 예를 들어 "abcd", "def"이런 단어가 주어진다면 아래 그림과 같은 역방향의 트라이도 같이 만듭니다.

 

위의 설명을 이해했다면 문제는 크게 2가지 과정을 통해 해결할 수 있습니다.

1. words를 통해 정방향, 역방향 트라이 만들기

2. query의 '?'가 앞에서 시작한다면 역방향 트라이로 탐색, '?'가 뒤에서 시작한다면 정방향 트라이로 탐색

 

소스 코드


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

using namespace std;

typedef struct node{
    map <char, node> child; 
    map <int, int> info; 
};

void insert(int idx, node &trie, string &word, int dir){
//dir == 1 정방향, dir == -1 역방향
    
    if (dir == 1 && idx == word.size()) 
		return;
    if (dir == -1 && idx == -1)
        return;
    
    int left = (dir == 1) ? word.size() - idx : idx + 1; //자신을 포함한 나머지 길이
    
    if(trie.info.count(left) == 0)
            trie.info.insert({left, 1});       
    else
        trie.info[left]++;
        
	if(trie.child.count(word[idx]) == 0)
        trie.child[word[idx]] = node();
    
	insert(idx + dir, trie.child[word[idx]], word, dir);
}

int querying(int idx, node &trie, string &word, int dir){
//dir == 1 정방향, dir == -1 역방향
    
    if(dir == 1 && idx == word.size())
        return 1;
    if(dir == -1 && idx == -1)
        return 1;
        
    // '?'가 나온 경우 3항연산자를 사용하여 남은 '?'의 갯수를 알아내어 매칭되는 단어의 수 탐색
    if(word[idx] == '?'){
        int cnt = (dir == 1) ? word.size() - idx : idx + 1; 
        return trie.info[cnt];
    }
    
    //매칭되는 단어가 있는 경우
    //정방향이라면 dir == 1 이므로 idx가 1 증가, 역방향은 dir == -1이므로 idx 1감소
    if(trie.child.count(word[idx]) > 0)
        return querying(idx + dir, trie.child[word[idx]], word, dir);
    
    //매칭되는 단어가 없는 경우
    return 0;
}

vector<int> solution(vector<string> words, vector<string> queries) {
    
    vector<int> answer;
    
    node f_trie;
    node r_trie;
    
    for(int i=0;i<words.size();i++){
        string word = words[i];
        insert(0, f_trie, word, 1); //정방향 트라이
        insert(word.size() - 1, r_trie, word, -1); //역방향 트라이
    }
    
    for(int i=0;i<queries.size();i++){
        
        string query = queries[i];
        int ret = 0;
        
        if(query[0] != '?') // 쿼리의 뒤쪽에 '?'가 있는 경우 
            ret = querying(0, f_trie, query, 1);
        else               // 퀴리의 앞에 '?'가 있는 경우
            ret = querying(query.size() - 1, r_trie, query, -1);
        
        answer.push_back(ret);
    }
    
    return answer;
}

+ Recent posts