문제 설명


카카오TV에서 유명한 크리에이터로 활동 중인 죠르디는 환경 단체로부터 자신의 가장 인기있는 동영상에 지구온난화의 심각성을 알리기 위한 공익광고를 넣어 달라는 요청을 받았습니다. 평소에 환경 문제에 관심을 가지고 있던 죠르디는 요청을 받아들였고 광고효과를 높이기 위해 시청자들이 가장 많이 보는 구간에 공익광고를 넣으려고 합니다. 죠르디는 시청자들이 해당 동영상의 어떤 구간을 재생했는 지 알 수 있는 재생구간 기록을 구했고, 해당 기록을 바탕으로 공익광고가 삽입될 최적의 위치를 고를 수 있었습니다.
참고로 광고는 재생 중인 동영상의 오른쪽 아래에서 원래 영상과 동시에 재생되는 PIP(Picture in Picture) 형태로 제공됩니다.

 

 

다음은 죠르디가 공익광고가 삽입될 최적의 위치를 고르는 과정을 그림으로 설명한 것입니다.

 

 

  • 그림의 파란색 선은 광고를 검토 중인 죠르디 동영상의 전체 재생 구간을 나타냅니다.
    • 위 그림에서, 죠르디 동영상의 총 재생시간은 02시간 03분 55초 입니다.
  • 그림의 검은색 선들은 각 시청자들이 죠르디의 동영상을 재생한 구간의 위치를 표시하고 있습니다.
    • 검은색 선의 가운데 숫자는 각 재생 기록을 구분하는 ID를 나타냅니다.
    • 검은색 선에 표기된 왼쪽 끝 숫자와 오른쪽 끝 숫자는 시청자들이 재생한 동영상 구간의 시작 시각과 종료 시각을 나타냅니다.
    • 위 그림에서, 3번 재생 기록은 00시 25분 50초 부터 00시 48분 29초 까지 총 00시간 22분 39초 동안 죠르디의 동영상을 재생했습니다. 1
    • 위 그림에서, 1번 재생 기록은 01시 20분 15초 부터 01시 45분 14초 까지 총 00시간 24분 59초 동안 죠르디의 동영상을 재생했습니다.
  • 그림의 빨간색 선은 죠르디가 선택한 최적의 공익광고 위치를 나타냅니다.
    • 만약 공익광고의 재생시간이 00시간 14분 15초라면, 위의 그림처럼 01시 30분 59초 부터 01시 45분 14초 까지 공익광고를 삽입하는 것이 가장 좋습니다. 이 구간을 시청한 시청자들의 누적 재생시간이 가장 크기 때문입니다.
    • 01시 30분 59초 부터 01시 45분 14초 까지의 누적 재생시간은 다음과 같이 계산됩니다.
      • 01시 30분 59초 부터 01시 37분 44초 까지 : 4번, 1번 재생 기록이 두차례 있으므로 재생시간의 합은 00시간 06분 45초 X 2 = 00시간 13분 30초
      • 01시 37분 44초 부터 01시 45분 14초 까지 : 4번, 1번, 5번 재생 기록이 세차례 있으므로 재생시간의 합은 00시간 07분 30초 X 3 = 00시간 22분 30초
      • 따라서, 이 구간 시청자들의 누적 재생시간은 00시간 13분 30초 + 00시간 22분 30초 = 00시간 36분 00초입니다.

[문제]

죠르디의 동영상 재생시간 길이 play_time, 공익광고의 재생시간 길이 adv_time, 시청자들이 해당 동영상을 재생했던 구간 정보 logs가 매개변수로 주어질 때, 시청자들의 누적 재생시간이 가장 많이 나오는 곳에 공익광고를 삽입하려고 합니다. 이때, 공익광고가 들어갈 시작 시각을 구해서 return 하도록 solution 함수를 완성해주세요. 만약, 시청자들의 누적 재생시간이 가장 많은 곳이 여러 곳이라면, 그 중에서 가장 빠른 시작 시각을 return 하도록 합니다.

[제한사항]

  • play_time, adv_time은 길이 8로 고정된 문자열입니다.
    • play_time, adv_time은 HH:MM:SS 형식이며, 00:00:01 이상 99:59:59 이하입니다.
    • 즉, 동영상 재생시간과 공익광고 재생시간은 00시간 00분 01초 이상 99시간 59분 59초 이하입니다.
    • 공익광고 재생시간은 동영상 재생시간보다 짧거나 같게 주어집니다.
  • logs는 크기가 1 이상 300,000 이하인 문자열 배열입니다.

    • logs 배열의 각 원소는 시청자의 재생 구간을 나타냅니다.
    • logs 배열의 각 원소는 길이가 17로 고정된 문자열입니다.
    • logs 배열의 각 원소는 H1:M1:S1-H2:M2:S2 형식입니다.
      • H1:M1:S1은 동영상이 시작된 시각, H2:M2:S2는 동영상이 종료된 시각을 나타냅니다.
      • H1:M1:S1는 H2:M2:S2보다 1초 이상 이전 시각으로 주어집니다.
      • H1:M1:S1와 H2:M2:S2는 play_time 이내의 시각입니다.
  • 시간을 나타내는 HH, H1, H2의 범위는 00~99, 분을 나타내는 MM, M1, M2의 범위는 00~59, 초를 나타내는 SS, S1, S2의 범위는 00~59까지 사용됩니다. 잘못된 시각은 입력으로 주어지지 않습니다. (예: 04:60:24, 11:12:78, 123:12:45 등)

  • return 값의 형식

    • 공익광고를 삽입할 시각을 HH:MM:SS 형식의 8자리 문자열로 반환합니다.

[입출력 예]

play_timeadv_timelogsresult

"02:03:55""00:14:15"["01:20:15-01:45:14", "00:40:31-01:00:00", "00:25:50-00:48:29", "01:30:59-01:53:29", "01:37:44-02:02:30"]"01:30:59"
"99:59:59""25:00:00"["69:59:59-89:59:59", "01:00:00-21:00:00", "79:59:59-99:59:59", "11:00:00-31:00:00"]"01:00:00"
"50:00:00""50:00:00"["15:36:51-38:21:49", "10:14:18-15:36:51", "38:21:49-42:51:45"]"00:00:00"

 

 

접근 방법


부분합과 투포인터를 적절히 사용하면 어렵지 않게 해결할 수 있는 문제였습니다. 

 

접근 방법은 크게 4가지로 나눌 수 있습니다.

1. 시간정보에 관한 문자열을 초로 변환

2. arr[i]라는 배열을 i초에 보고 있던 시청자 수라 하였을 때, 1에서 변환된 초에 따라 arr배열에 기록

3. 광고를 0초부터 가능한 부분까지 1초씩 옮겨가며 arr배열의 정보를 사용하여 최댓값 갱신 

4. 3에서 구한 값을 문자열로 변환

 

 

1. 시간정보에 관한 문자열을 초로 변환

 

문자열에서 ':'를 기준으로 for문을 통해 시간, 분, 초의 정보를 초로 변경하였습니다.

int string_to_sec(string time){
    
    int sec = 0;
    string sub = "";
    
    for(int i=0;i<time.size();i++){
        
        if(time[i] == ':'){
            sec = (sec * 60) + (stoi(sub) * 60);
            sub = "";
            continue;
        }
        sub.push_back(time[i]);
    }
    sec += stoi(sub);
    return sec;
}

 

2. arr[i]라는 배열을 i초에 보고 있던 시청자 수라 하였을 때, 1에서 변환된 초에 따라 arr배열에 기록

 

1번에서 설명한 string_to_sec()함수를 사용하여 문제의 입력으로 주어진 logs를 변환하여 arr[] 배열에 기록합니다.

 for(int i=0;i<logs.size();i++){
        
        int start = string_to_sec(logs[i].substr(0, 8));
        int end = string_to_sec(logs[i].substr(9, 8));
        
        for(int i = start;i<end;i++) 
            arr[i]++;
}

 

3. 광고를 0초부터 가능한 부분까지 1초씩 옮겨가며 arr배열의 정보를 사용하여 최댓값 갱신 

 

광고시작시간이 0초일 때 시청자들의 누적 재생시간을 최대값의 초기값으로 설정하여 1초씩 시작시간을 증가시켜 최대값을 갱신합니다.

 예를 들어 광고의 재생시간이 5초라고 한다면 sum1 = arr[0] + arr[1] + arr[2] + arr[3] + arr[4]가 될 것입니다. 이 때 광고의 시작시간을 1초 뒤로 옮기게 된다면 sum2 = arr[1] + arr[2] + arr[3] + arr[4] + arr[5]가 될 것입니다. 이 때 광고의 길이는 항상 일정하기 때문에 sum을 간단하게 구할 수 있습니다. 

 

광고가 끝나는 시간을 i초, 광고의 길이를 a_time이라 하였을 때

sum(현재) = sum(과거) + arr[i] - arr[i - a_time]이라는 식을 유도할 수 있습니다.

즉 이전상태의 부분합을 안다면 다음상태에서 모든 요소를 참조하지 않고 현재상태의 부분합을 알아낼 수 있습니다.

//a_time은 광고길이, p_time은 영상길이
int accumulate(int a_time, int p_time){
    
    long long maxsum = 0;
    int result = 0;
    
    for(int i=0;i<a_time;i++)
        maxsum += arr[i];
    
    long long sum = maxsum;
    
    for(int i = a_time; i < p_time; i++){
        
        sum += arr[i] - arr[i - a_time];
        
        if(maxsum < sum) {
            maxsum = sum;
            result = i - a_time + 1;
        }
    }
    return result;
}

 

4. 3에서 구한 값을 문자열로 변환

 

int형의 초를 60으로 나누어 가며 시, 분, 초로 변환을 하여 문자열을 구성을 합니다.

이 때 주의할 점은 시간은 60으로 나눈 나머지를 구해서 사용하면 안됩니다.(코드 복붙하다 여기서 틀린줄 모르고 많이 해맸음)

string sec_to_string(int sec){
    
     
    string s = to_string(sec % 60);
    if(s.size() == 1)
        s = "0" + s;
    sec /= 60;
    
    string m = to_string(sec % 60);
    if(m.size() == 1)
        m = "0" + m;
    sec /= 60;
    
    string h = to_string(sec); //시간은 60으로 나눈 나머지를 사용하지 않는다.
    if(h.size() == 1)
        h = "0" + h;
    
    return h + ":" + m + ":" + s; 
}

 

 

소스 코드


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

using namespace std;

int arr[360000];

int string_to_sec(string time){
    
    int sec = 0;
    string sub = "";
    
    for(int i=0;i<time.size();i++){
        
        if(time[i] == ':'){
            sec = (sec * 60) + (stoi(sub) * 60);
            sub = "";
            continue;
        }
        sub.push_back(time[i]);
    }
    sec += stoi(sub);
    return sec;
}

string sec_to_string(int sec){
    
     
    string s = to_string(sec % 60);
    if(s.size() == 1)
        s = "0" + s;
    sec /= 60;
    
    string m = to_string(sec % 60);
    if(m.size() == 1)
        m = "0" + m;
    sec /= 60;
    
    string h = to_string(sec);
    if(h.size() == 1)
        h = "0" + h;
    
    return h + ":" + m + ":" + s; 
}

int accumulate(int a_time, int p_time){
    
    long long maxsum = 0;
    int result = 0;
    
    for(int i=0;i<a_time;i++)
        maxsum += arr[i];
    
    long long sum = maxsum;
    
    for(int i = a_time; i < p_time; i++){
        
        sum += arr[i] - arr[i - a_time];
        
        if(maxsum < sum) {
            maxsum = sum;
            result = i - a_time + 1;
        }
    }
    return result;
}

string solution(string play_time, string adv_time, vector<string> logs) {
    
    string answer = "";
    
    int p_time = string_to_sec(play_time);
    int a_time = string_to_sec(adv_time);
    
    for(int i=0;i<logs.size();i++){
        
        int start = string_to_sec(logs[i].substr(0, 8));
        int end = string_to_sec(logs[i].substr(9, 8));
        
        for(int i = start;i<end;i++) 
            arr[i]++;
    }
        
    int result = accumulate(a_time, p_time);
    
    answer = sec_to_string(result);
    
    return answer;
}

문제 설명


문제 설명

게임 개발자인 베로니는 개발 연습을 위해 다음과 같은 간단한 카드 짝맞추기 보드 게임을 개발해 보려고 합니다.
게임이 시작되면 화면에는 카드 16장이 뒷면을 위로하여 4 x 4 크기의 격자 형태로 표시되어 있습니다. 각 카드의 앞면에는 카카오프렌즈 캐릭터 그림이 그려져 있으며, 8가지의 캐릭터 그림이 그려진 카드가 각기 2장씩 화면에 무작위로 배치되어 있습니다.
유저가 카드를 2장 선택하여 앞면으로 뒤집었을 때 같은 그림이 그려진 카드면 해당 카드는 게임 화면에서 사라지며, 같은 그림이 아니라면 원래 상태로 뒷면이 보이도록 뒤집힙니다. 이와 같은 방법으로 모든 카드를 화면에서 사라지게 하면 게임이 종료됩니다.

게임에서 카드를 선택하는 방법은 다음과 같습니다.

  • 카드는 커서를 이용해서 선택할 수 있습니다.
    • 커서는 4 x 4 화면에서 유저가 선택한 현재 위치를 표시하는 굵고 빨간 테두리 상자를 의미합니다.
  • 커서는 [Ctrl] 키와 방향키에 의해 이동되며 키 조작법은 다음과 같습니다.
    • 방향키 ←, ↑, ↓, → 중 하나를 누르면, 커서가 누른 키 방향으로 1칸 이동합니다.
    • [Ctrl] 키를 누른 상태에서 방향키 ←, ↑, ↓, → 중 하나를 누르면, 누른 키 방향에 있는 가장 가까운 카드로 한번에 이동합니다.
      • 만약, 해당 방향에 카드가 하나도 없다면 그 방향의 가장 마지막 칸으로 이동합니다.
    • 만약, 누른 키 방향으로 이동 가능한 카드 또는 빈 공간이 없어 이동할 수 없다면 커서는 움직이지 않습니다.
  • 커서가 위치한 카드를 뒤집기 위해서는 [Enter] 키를 입력합니다.
    • [Enter] 키를 입력해서 카드를 뒤집었을 때
      • 앞면이 보이는 카드가 1장 뿐이라면 그림을 맞출 수 없으므로 두번째 카드를 뒤집을 때 까지 앞면을 유지합니다.
      • 앞면이 보이는 카드가 2장이 된 경우, 두개의 카드에 그려진 그림이 같으면 해당 카드들이 화면에서 사라지며, 그림이 다르다면 두 카드 모두 뒷면이 보이도록 다시 뒤집힙니다.

베로니는 게임 진행 중 카드의 짝을 맞춰 몇 장 제거된 상태에서 카드 앞면의 그림을 알고 있다면, 남은 카드를 모두 제거하는데 필요한 키 조작 횟수의 최솟값을 구해 보려고 합니다. 키 조작 횟수는 방향키와 [Enter] 키를 누르는 동작을 각각 조작 횟수 1로 계산하며, [Ctrl] 키와 방향키를 함께 누르는 동작 또한 조작 횟수 1로 계산합니다.

다음은 카드가 몇 장 제거된 상태의 게임 화면에서 커서를 이동하는 예시입니다.
아래 그림에서 빈 칸은 이미 카드가 제거되어 없어진 칸을 의미하며, 그림이 그려진 칸은 카드 앞 면에 그려진 그림을 나타냅니다.


예시에서 커서는 두번째 행, 첫번째 열 위치에서 시작하였습니다.


[Enter] 입력, ↓ 이동, [Ctrl]+→ 이동, [Enter] 입력 = 키 조작 4회


[Ctrl]+↑ 이동, [Enter] 입력, [Ctrl]+← 이동, [Ctrl]+↓ 이동, [Enter] 입력 = 키 조작 5회


[Ctrl]+→ 이동, [Enter] 입력, [Ctrl]+↑ 이동, [Ctrl]+← 이동, [Enter] 입력 = 키 조작 5회

위와 같은 방법으로 커서를 이동하여 카드를 선택하고 그림을 맞추어 카드를 모두 제거하기 위해서는 총 14번(방향 이동 8번, [Enter] 키 입력 6번)의 키 조작 횟수가 필요합니다.


[문제]

현재 카드가 놓인 상태를 나타내는 2차원 배열 board와 커서의 처음 위치 r, c가 매개변수로 주어질 때, 모든 카드를 제거하기 위한 키 조작 횟수의 최솟값을 return 하도록 solution 함수를 완성해 주세요.

[제한사항]

  • board는 4 x 4 크기의 2차원 배열입니다.
  • board 배열의 각 원소는 0 이상 6 이하인 자연수입니다.
    • 0은 카드가 제거된 빈 칸을 나타냅니다.
    • 1 부터 6까지의 자연수는 2개씩 들어있으며 같은 숫자는 같은 그림의 카드를 의미합니다.
    • 뒤집을 카드가 없는 경우(board의 모든 원소가 0인 경우)는 입력으로 주어지지 않습니다.
  • r은 커서의 최초 세로(행) 위치를 의미합니다.
  • c는 커서의 최초 가로(열) 위치를 의미합니다.
  • r과 c는 0 이상 3 이하인 정수입니다.
  • 게임 화면의 좌측 상단이 (0, 0), 우측 하단이 (3, 3) 입니다.

[입출력 예]

boardrcresult

[[1,0,0,3],[2,0,0,0],[0,0,0,2],[3,0,1,0]] 1 0 14
[[3,0,0,2],[0,0,1,0],[0,1,0,0],[2,0,0,3]] 0 1 16

 

접근 방법


삼성 유형과 비슷한 문제였는데 상당히 복잡하게 느껴졌습니다.

 

일단 문제의 큰 틀을 잡아보면 4가지 과정으로 나눌 수 있습니다. 

1. 어떤 짝 먼저 맞춰갈지에 대한 순서 정하기

2. 순서를 정했다면 한 쌍에서 어떤 카드부터 선택 할지 정하기

3. 2번 과정까지 완료 됬다면 각각 지점사이에 이동 횟수를 알아내어 전체 경로의 이동횟수를 구하기

4. 3번 과정을 반복하며 최소값 갱신 

 

1. 어떤 짝 먼저 맞춰갈지에 대한 순서 정하기

 만약 짝이 1,2,3이 있다면 1->2->3 순서로 해결할지 1->3->2의 순서로 해결할지

3->1->2 등등의 순서를 정해주어야 합니다. 즉 모든 가능한 순열을 구해야 합니다.

void combinations(vector<bool> &visited, vector<vector<int>> &combs, vector<int> comb, vector<int> &card){
    
    if(comb.size() == card.size()){
        combs.push_back(comb);
        return;
    }
    for(int i=0;i<card.size();i++){
        if(!visited[i]){
            visited[i] = true;
            comb.push_back(card[i]);
            combinations(visited, combs, comb, card);
            comb.pop_back();
            visited[i] = false;
        }
    }
}

 combs = 순열들의 집합, comb = 한 순열, visited = 방문여부, card = 짝(ex, {1,2,3})

 순열은 백트래킹 기법을 사용하여 구할 수 있습니다.

 

이 때 card는 아래와 같은 방법으로 구할 수 있습니다. 또한 카드의 좌표정보를 갖고있는 info를 갱신하여 줍니다. info[카드번호] = {{x1,y1}, {x2, y2}}

//map == board
vector<int> findcard(){
    
    vector<bool> check_card(7, false);
    
    for(int i=0;i<4;i++)
        for(int j=0;j<4;j++)
            if(map[i][j]!=0){
                check_card[map[i][j]] = true;
                info[map[i][j]].push_back({i, j});
            }
    
    vector<int> card;
    for(int i=0;i<check_card.size();i++)
        if(check_card[i])
            card.push_back(i);
    
    return card;
}

 

 

2. 순서를 정했다면 한 쌍에서 어떤 카드부터 선택 할지 정하기

 각각의 짝은 2장의 카드로 이루어져 있습니다. 만약 [a->b->c->d]라는 순서를 결정지었을 때

a라는 짝이 a1, a2 두 장의 카드로 이루어져 있다면 a1을 먼저 방문하고 a2를 방문할지, a2를 먼저 방문하고 a1을 방문할지 결정하고 b, c, d에 대해서도 각각의 카드의 방문 순서를 지정해주어야 합니다.  

ex 1) a1 -> a2 -> b1 -> b2 -> c2 -> c1 -> d2 -> d1

ex 2) a2 -> a1 -> b1 -> b2 -> c1 -> c2 -> d2 -> d1

void decide_path(vector<vector<pair<int, int>>> &paths, vector<pair<int, int>> path, vector<int> &comb, int idx){
    
    if(idx == comb.size()){
        paths.push_back(path);
        return;
    }
    
    int num = comb[idx];
    path.push_back(info[num][0]);
    path.push_back(info[num][1]);
    decide_path(paths, path, comb, idx+1);
    path.pop_back();
    path.pop_back();
    path.push_back(info[num][1]);
    path.push_back(info[num][0]);
    decide_path(paths, path, comb, idx+1);
    path.pop_back();
    path.pop_back();
}

paths = path들의 집합, path = 이동할 좌표의 순열, comb = 한 순열

이동할 좌표의 순열 또한 백트래킹을 사용하여 구할 수 있습니다. 

 

3. 2번 과정까지 완료가 되었다면 각각 지점사이에 이동 횟수를 알아내어 전체 경로의 이동횟수를 구해야 합니다.

 

 한 좌표에서 다른 좌표로 이동할 수 있는 경우는 총 8가지가 있습니다. 상하좌우 한 칸씩 이동하는 방법 4개, ctrl키를 누른뒤 상하좌우로 이동하는 방법이 4개 있습니다. 이 때 저는 BFS를 통해 해결을 하였습니다.

int BFS(pair<int, int> start, pair<int, int> end){
    
    queue<pair<pair<int, int>, int>> q; //좌표와 레벨
    vector<vector<bool>> visited(4, vector<bool>(4,false));
    
    q.push({start, 0});
    visited[start.first][start.second] = true;
    
    while(!q.empty()){
     
        int x = q.front().first.first;
        int y = q.front().first.second;
        int level = q.front().second;
        q.pop();
        
        for(int i=0;i<8;i++){ //8가지 방향에 대해
            pair<int, int> next_xy = findNext(i,x,y); //다음 좌표!!!
            int next_x = next_xy.first;
            int next_y = next_xy.second;
            if(inRange(next_x, next_y) && !visited[next_x][next_y]){
                visited[next_x][next_y] = true;
                if(next_x == end.first && next_y == end.second)
                    return level + 1;
                q.push({{next_x, next_y}, level+1});    
            }
        }
    }
    return 0;
}

 위와 같이 BFS를 사용하여 start(출발 좌표)와 end(도착 좌표)까지의 최소 이동횟수를 구할 수 있는데 findNext()함수를  통해 다음 좌표를 구할 수 있습니다.

 

findNext(int dir, int x, int y)

pair<int, int> findNext(int dir, int x, int y){
    
    vector<pair<int, int>> nextdir = {{1,0},{0,1},{-1,0},{0,-1}};
    
    //처음 4방향은 1칸만 이동
    if(dir < 4)
        return { x + nextdir[dir].first, y + nextdir[dir].second};
    else{ //나머지 4방향은 끝 또는 카드가 있는 곳까지 이동(ctrl + 방향키)
        dir -= 4;
        while(inRange(x + nextdir[dir].first, y + nextdir[dir].second)){
         
            x += nextdir[dir].first;
            y += nextdir[dir].second;    
            if(tmp[x][y] != 0)
                break;
        }
        return {x, y};
    }
}

 

 

4. 3번 과정을 반복하며 최소값 갱신 

int processOneComb(vector<int> &comb, int r, int c){
    
    vector<vector<pair<int, int>>> paths;
    vector<pair<int, int>> path;
    
    decide_path(paths, path, comb, 0);
    int mindist = 0xFFFFFFF;
    
    for(int i=0;i<paths.size();i++){
        
        tmp = map; //한 순열에 대한 board상태 초기화
        int dist = 0;
        
        for(int j=0;j<paths[i].size();j++){ //한 경로 조합에 대한 거리
            //각각 dist에 +1하는 이유는 엔터동작 때문임
            if(j==0) dist += BFS({r,c}, paths[i][j]) + 1;
            else dist += BFS(paths[i][j - 1], paths[i][j]) + 1;
            tmp[paths[i][j].first][paths[i][j].second] = 0; //이동한 좌표의 카드 삭제
        }    
        mindist = min(mindist, dist);
    }
    return mindist;
}

 

 

소스 코드


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

using namespace std;

vector<pair<int,int>> info[7];
vector<vector<int>> map;
vector<vector<int>> tmp;

bool inRange(int x, int y){
    return (0 <= x && x < 4 && 0 <= y && y < 4);
}

void combinations(vector<bool> &visited, vector<vector<int>> &combs, vector<int> comb, vector<int> &card){
    
    if(comb.size() == card.size()){
        combs.push_back(comb);
        return;
    }
    for(int i=0;i<card.size();i++){
        if(!visited[i]){
            visited[i] = true;
            comb.push_back(card[i]);
            combinations(visited, combs, comb, card);
            comb.pop_back();
            visited[i] = false;
        }
    }
}

vector<vector<int>> find_combs(vector<int> &card){
    
    vector<bool> visited(card.size(), false);
    vector<vector<int>> combs;
    vector<int> comb;
    combinations(visited, combs, comb, card);
    return combs;
}

vector<int> findcard(){
    
    vector<bool> check_card(7, false);
    
    for(int i=0;i<4;i++)
        for(int j=0;j<4;j++)
            if(map[i][j]!=0){
                check_card[map[i][j]] = true;
                info[map[i][j]].push_back({i, j});
            }
    
    vector<int> card;
    for(int i=0;i<check_card.size();i++)
        if(check_card[i])
            card.push_back(i);
    
    return card;
}

void decide_path(vector<vector<pair<int, int>>> &paths, vector<pair<int, int>> path, vector<int> &comb, int idx){
    
    if(idx == comb.size()){
        paths.push_back(path);
        return;
    }
    
    int num = comb[idx];
    path.push_back(info[num][0]);
    path.push_back(info[num][1]);
    decide_path(paths, path, comb, idx+1);
    path.pop_back();
    path.pop_back();
    path.push_back(info[num][1]);
    path.push_back(info[num][0]);
    decide_path(paths, path, comb, idx+1);
    path.pop_back();
    path.pop_back();
}

pair<int, int> findNext(int dir, int x, int y){
    
    vector<pair<int, int>> nextdir = {{1,0},{0,1},{-1,0},{0,-1}};
    
    if(dir < 4)
        return { x + nextdir[dir].first, y + nextdir[dir].second};
    else{
        dir -= 4;
        while(inRange(x + nextdir[dir].first, y + nextdir[dir].second)){
         
            x += nextdir[dir].first;
            y += nextdir[dir].second;    
            if(tmp[x][y] != 0)
                break;
        }
        return {x, y};
    }
}

int BFS(pair<int, int> start, pair<int, int> end){
    
    queue<pair<pair<int, int>, int>> q; //좌표와 레벨
    vector<vector<bool>> visited(4, vector<bool>(4,false));
    
    q.push({start, 0});
    visited[start.first][start.second] = true;
    
    while(!q.empty()){
     
        int x = q.front().first.first;
        int y = q.front().first.second;
        int level = q.front().second;
        q.pop();
        
        for(int i=0;i<8;i++){
            pair<int, int> next_xy = findNext(i,x,y);
            int next_x = next_xy.first;
            int next_y = next_xy.second;
            if(inRange(next_x, next_y) && !visited[next_x][next_y]){
                visited[next_x][next_y] = true;
                if(next_x == end.first && next_y == end.second)
                    return level + 1;
                q.push({{next_x, next_y}, level+1});    
            }
        }
    }
    return 0;
}

int processOneComb(vector<int> &comb, int r, int c){
    
    vector<vector<pair<int, int>>> paths;
    vector<pair<int, int>> path;
    
    decide_path(paths, path, comb, 0);
    int mindist = 0xFFFFFFF;
    
    for(int i=0;i<paths.size();i++){
        
        tmp = map; //한 순열에 대한 board상태 초기화
        int dist = 0;
        
        for(int j=0;j<paths[i].size();j++){ //한 경로 조합에 대한 거리
            //각각 dist에 +1하는 이유는 엔터동작 때문임
            if(j==0) dist += BFS({r,c}, paths[i][j]) + 1;
            else dist += BFS(paths[i][j - 1], paths[i][j]) + 1;
            tmp[paths[i][j].first][paths[i][j].second] = 0; //이동한 좌표의 카드 삭제
        }    
        mindist = min(mindist, dist);
    }
    return mindist;
}

int solution(vector<vector<int>> board, int r, int c) {
    
    int answer = 0xFFFFFFF;
    map = board;
    vector<int> card = findcard();
    vector<vector<int>> combs = find_combs(card);
    
    for(int i=0;i<combs.size();i++){
        answer = min(answer, processOneComb(combs[i], r, c));
    }
    
    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