이코테, 프로그래머스 - 자물쇠와 열쇠

문제

구현 문제로 NxN 자물쇠를 MxM 열쇠로 푸는 문제였다.

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

프로그래머스

 

문제 풀이

두 번에 걸쳐 문제를 풀었는데 처음에는 열쇠를 4번 회전하고, 각각의 상황에서 dfs를 이용해 한 칸씩 옮겨가며 unLock을 확인해 주도록 구현했는데 시간 초과로 인해 60점이 나와서 다른 방법으로 다시 풀었다. dfs보다 훨씬 간단한 방법이었는데, N+(2*M) 사이즈의 비교용 map을 만들어 가운데에 자물쇠를 놓고 열쇠의 위치를 한 칸씩 옮기며 자물쇠와 열쇠의 합이 1이 되는지 확인하는 방법이다.

 

첫 번째 방법

90도 회전시키는 rotation 함수와 1칸 이동하는 move, 풀렸는지 확인하는 isUnlock, 모든 방향에 대해 확인하는 dfs, 열쇠를 4번 회전시키는 것에 대해 dfs를 하는 findKey 함수를 만들었다. 이 방법을 사용했을 때, 몇 개는 틀리고 시간 초과로 인해 60점을 받았다. 시간 초과는 이해가 되는데 틀린 이유는 찾을 수 없었다... 그래도 다른 방법으로 해결했으니까..!

#include <string>
#include <vector>

using namespace std;

//우좌상하 방향
//direction 0123
int x[4] = {1,-1,0,0};
int y[4] = {0,0,1,-1};

void printVector(vector<vector<int>> key){
    int size = key.size();
    for(int i=0;i<size;i++){
        for(int j=0;j<size;j++){
            printf("%d ",key[i][j]);
        }
        printf("\n");
    }
}

vector<vector<int>> rotation(vector<vector<int>> key){ //90도 회전
    int size = key.size();
    vector<vector<int>> result;        
    
    //0열 N-1 행부터 차례로 result에 넣기
    for(int i=0;i<size;i++){
        vector<int> row;
        for(int j=size-1;j>=0;j--){
            row.push_back(key[j][i]);
        }
        result.push_back(row);
    }    
    return result;
}

vector<vector<int>> move(vector<vector<int>> key, int x, int y){ //1칸 이동
    int size = key.size();
    int i=0,j=0;
    int copyStartI=0, copyEndI=size, copyStartJ=0,copyEndJ=size;
    int pasteStartI=0,pasteEndI=size,pasteStartJ=0,pasteEndJ=size;
    
    vector<vector<int>> result(size, vector<int>(size, 0)); //0으로 초기화        
    
    if(y == 0){ 
        if(x==1){ //오른쪽으로 이동
            copyEndI=size-1;
            pasteStartI=1;
        }
        else{ //왼쪽으로 이동
            copyStartI=1;
            pasteEndI=size-1;
        }
    }
    else{
        if(y==1){ //위로 이동
            copyStartJ=1;
            pasteEndJ=size-1;
        }
        else{ //아래로 이동
            copyEndJ=size-1;
            pasteStartJ=1;            
        }
    }
    
    int pasteI=pasteStartI, pasteJ=pasteStartJ;
    
    for(i=copyStartI;i<copyEndI;i++){
        pasteJ=pasteStartJ;
        for(j=copyStartJ;j<copyEndJ;j++){
            result[pasteJ][pasteI] = key[j][i];
            pasteJ++;
        }
        pasteI++;
    }    
    return result;
}

bool isUnlock(vector<vector<int>> key, vector<vector<int>> lock){ //풀렸는지 확인
    int size = key.size();
    
    for(int i=0;i<size;i++){
        for(int j=0;j<size;j++){
            if(key[i][j] + lock[i][j] != 1){
                return false;
            }
        }
    }
    return true;
}

bool dfs(vector<vector<int>> key,vector<vector<int>> lock, int count, int size){  
    bool answer = false;
    if(isUnlock(key, lock)) {
        answer = true;
        return true;        
    }
    if(count >= size){ //이미 다 이동했음
        return false;
    }
    
    for(int i=0;i<4;i++){ //4방향        
            answer = dfs(move(key, x[i], y[i]), lock, count+1, size);
            if(answer) return true;        
    }
    return answer;
}

bool findKey(vector<vector<int>> key, vector<vector<int>> lock){
    int size = key.size();        
    //90도 돌리고 1칸씩 모든 방향으로 size 만큼 이동        
    for(int i=0;i<4;i++){
        key = rotation(key);        
        if(dfs(key, lock, 0, size)) return true;
    }
    
    return false;
}

bool solution(vector<vector<int>> key, vector<vector<int>> lock) {
    printVector(key);    
    
    bool answer;
    answer = findKey(key, lock);    
    
    return answer;
}

 

두 번째 방법

여기의 rotation 함수는 첫 번째 방법의 rotation 함수와 동일하다. 먼저 compareMap을 만들어 -1로 채운 후 가운데 부분을 lock으로 만들어준다. 그 후 90도씩 회전시킨 키 각각에 대해 findKey를 실행하고, findKey에서 모든 상황에 대해 isUnLock을 확인했다. 시간이 첫 번째 방법의 두 배 이상 단축됐다. 재귀를 이용한 풀이는 정말 꼭 필요할 때만 사용해야겠다.

#include <string>
#include <vector>

using namespace std;

int N,M;

void printVector(vector<vector<int>> key){
    int size = key.size();
    for(int i=0;i<size;i++){
        for(int j=0;j<size;j++){
            printf("%d ",key[i][j]);
        }
        printf("\n");
    }
}

vector<vector<int>> rotation(vector<vector<int>> key){ //90도 회전
    int size = key.size();
    vector<vector<int>> result;        
    
    //0열 N-1 행부터 차례로 result에 넣기
    for(int i=0;i<size;i++){
        vector<int> row;
        for(int j=size-1;j>=0;j--){
            row.push_back(key[j][i]);
        }
        result.push_back(row);
    }    
    return result;
}

bool isUnlock(vector<vector<int>> map, vector<vector<int>> key, int x, int y){
    int i,j;
    
    //map에 key 값 더하기
    for(i=x;i<x+M;i++){
        for(j=y;j<y+M;j++){
            map[i][j] += key[i-x][j-y];
        }
    }
    
    //합이 1인지 확인
    for(i=M;i<M+N;i++){
        for(j=M;j<M+N;j++){
            if(map[i][j] != 1){
                return false;
            }
        }
    }
    return true;
}

bool findKey(vector<vector<int>> map, vector<vector<int>> key){
    int i,j;
    
    for(i=0;i<N+M;i++){
        for(j=0;j<N+M;j++){
            if(isUnlock(map, key, i,j)){
                return true;
            }
        }
    }
    return false;
}

bool solution(vector<vector<int>> key, vector<vector<int>> lock) {
    printVector(key);    
    N = lock.size();
    M = key.size();
    int i,j;
    
    vector<vector<int>> compareMap(N+(M*2), vector<int>(N+(M*2), -1)); //-1로 초기화
    //compareMap의 가운데 부분을 lock으로 만들기
    for(i=M;i<M+N;i++){
        for(j=M;j<M+N;j++){
            compareMap[i][j] = lock[i-M][j-M];
        }
    }
    
    //find key
    for(i=0;i<4;i++){ //90도씩 회전하면서 확인
        key = rotation(key);
        if(findKey(compareMap, key)) return true;
    }
    return false;
}