반응형

 

1. 핵심 개념

값이 총 3개일 때, 트리 모양으로 가정합니다. D(1), D(2), D(3), D(4)가 있습니다. D() 안의 숫자는 level을 뜻합니다. D(1)은 0 0 0이고, D(2)는 첫째 값, D(3)는 둘째 값, D(4)는 셋째 값입니다. 루트부터 전위 순회를 하면서 왼쪽은 ch[level] = 1; 오른쪽은 ch[level] = 0; 입니다. level 1은 0 0 0입니다. level이 4일 때 부분집합을 출력합니다. 

 

void dfs(int level){
    
    if(level == N){
        if(!isEmpty()){
            for(int i=0; i<N; i++){
                if(ch[i] == 1)
                    sum += v[i];
            }
            if(sum == S)
                cnt++;
            sum = 0;
        }
        return;
    }
    
    ch[level] = 1;
    dfs(level+1);
    ch[level] = 0;
    dfs(level+1);
    
}

 

 

 

 

2. 백준 1182

www.acmicpc.net/problem/1182

 

1182번: 부분수열의 합

첫째 줄에 정수의 개수를 나타내는 N과 정수 S가 주어진다. (1 ≤ N ≤ 20, |S| ≤ 1,000,000) 둘째 줄에 N개의 정수가 빈 칸을 사이에 두고 주어진다. 주어지는 정수의 절댓값은 100,000을 넘지 않는다.

www.acmicpc.net

#include <stdio.h>
#include <iostream>
#include <vector>
#define MAX_NUM 25
using namespace std;

int N, S;
int num;
int cnt = 0;
int ch[MAX_NUM];
vector<int> v;
int sum;

int isEmpty(){
    for(int i=0; i<N; i++){
        if(ch[i] == 1)
            return 0;
    }
    return 1;
}

void dfs(int level){
    
    if(level == N){
        if(!isEmpty()){
            for(int i=0; i<N; i++){
                if(ch[i] == 1)
                    sum += v[i];
            }
            if(sum == S)
                cnt++;
            sum = 0;
        }
        return;
    }
    
    ch[level] = 1;
    dfs(level+1);
    ch[level] = 0;
    dfs(level+1);
    
}

int main(void) {
    
    cin >> N >> S;
    
    for(int i=0; i<N; i++){
        cin >> num;
        v.push_back(num);
    }
    
    dfs(0);
    
    cout << cnt << endl;
    
    return 0;
}

 

반응형

'Programming > Coding Test' 카테고리의 다른 글

8. 동적계획법  (0) 2021.01.02
7. 순열과 조합 정리  (0) 2021.01.01
5. STL 정리  (0) 2020.12.29
[C++] 백준 2573 빙산 - 테스트 케이스  (0) 2020.11.15
런타임에러 1 - return 1 return 0 return -1 의미  (0) 2020.11.14
반응형

 

 

 

1. Stack

- 선언

stack <char> s1;

 

- push

s1.push('c');

 

- pop

s1.pop();

 

- 스택 가장 위의 값

s1.top();

 

- 예제

#include<string>
#include <iostream>
#include <stack>
using namespace std;

bool solution(string s)
{
    bool answer = true;
    stack <char> s1;
    
    for(int i=0; i<s.length(); i++){
        if(s[i] == '('){
            s1.push(s[i]);
        } else if(s[i] == ')'){
            if(s1.empty() || s1.top() == ')'){
                answer = false;
                break;
            }
            s1.pop();
        }
    }
    
    if(!s1.empty()){
        answer = false;
    }
    
    
    return answer;
}

 

 

 

 

 

 

2. Queue

- 선언

Queue<int> q;

 

- push

q.push(1);

 

- pop

q.pop();

 

- 큐 맨 앞의 값

q.front();

 

- 큐 맨 뒤의 값

q.back();

 

- 비었는지 체크

q.empty();

 

- 큐에 몇 개의 값이 들었는지

q.size();

 

 

 

 

 

반응형
반응형

 

 

 

지도 유형 BFS 레퍼런스를 변형하여 해결하였습니다.

 

#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <queue>
#include <string.h>
#define MAX_SIZE 301
using namespace std;

int n, m;
int cnt = 0, year = 0;   // 덩어리 수, 지난 년도
int map[MAX_SIZE][MAX_SIZE];

int map2[MAX_SIZE][MAX_SIZE];
bool visited[MAX_SIZE][MAX_SIZE];

int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};

void BFS(int x, int y){
    queue< pair<int, int> > q;
    q.push(make_pair(x, y));
    
    visited[x][y] = true;
    
    while(!q.empty()){
        x = q.front().first;
        y = q.front().second;
        q.pop();
        
        for(int i=0; i<4; i++){
            int nx = x + dx[i];
            int ny = y + dy[i];
            
            if(nx >= 0 && nx < n && ny >= 0 && ny < m){
                if(map2[nx][ny] > 0 && visited[nx][ny] == false){
                    
                    visited[nx][ny] = true;
                    q.push(make_pair(nx, ny));
                }
            }
            
        }
    }
}

void print_array(int arr[][MAX_SIZE]){
    printf("\n");
    
    for(int i=0; i<n; i++){
        for(int j=0; j<m; j++){
            printf("%d ", arr[i][j]);
        }
        printf("\n");
    }
}

int main(void) {
    
    scanf("%d%d", &n, &m);
    
    for(int i=0; i<n; i++){
        for(int j=0; j<m; j++){
            scanf("%d", &map[i][j]);
        }
    }
    
    memcpy(map2, map, sizeof(map));
    
    // 덩어리 개수 세기
    for(int i=0; i<n; i++){
        for(int j=0; j<m; j++){
            if(map2[i][j] > 0 && visited[i][j] == false){

                BFS(i, j);
                cnt++;
            }
        }
    }
    
    // 처음부터 2 이상인지, 0인지 확인
    if(cnt >= 2 || cnt == 0){
        printf("0\n");
        return 0;
    }

    
    while(cnt < 2){
        cnt = 0;
        memset(visited, false, sizeof(visited));
        
        int mx, my;
        // 1 이상인 숫자 주위 체크해서 1 감소시키기
        for(int i=0; i<(n); i++){
            for(int j=0; j<(m); j++){
                if(map[i][j] > 0){
                    for(int k=0; k<4; k++){
                        mx = i + dx[k];
                        my = j + dy[k];

                        if(mx >= 0 && mx <n && my >= 0 && my < m){
                            if(map[mx][my] == 0 && map2[i][j] > 0){
                                map2[i][j]--;
                            }
                        }
                    }
                }
            }
        }

        // 덩어리 개수 세기
        for(int i=0; i<n; i++){
            for(int j=0; j<m; j++){
                if(map2[i][j] > 0 && visited[i][j] == false){

                    BFS(i, j);
                    cnt++;
                }
            }
        }
        
//        print_array(map);
//        print_array(map2);
        
        if(cnt == 0){
            printf("0\n");
            return 0;
        }
        
        year++;
        
        memcpy(map, map2, sizeof(map2));
    }
    
    printf("%d\n", year);
    

    return 0;
}

 

 

 

 

 

 

 

5 7
0 0 0 0 0 0 0
0 3 6 0 6 7 0
0 3 0 0 0 10 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0

정답 0

 

5 5
0 0 0 0 0
0 0 10 10 0
0 10 0 10 0
0 0 10 10 0
0 0 0 0 0

정답 0

 

 

5 5
0 0 0 0 0
0 2 2 2 0
0 2 2 2 0
0 2 2 2 0
0 0 0 0 0

정답 0

 

 

7 7
0 0 0 0 0 0 0
0 9 9 9 9 9 0
0 9 0 1 0 9 0
0 9 0 9 0 9 0
0 9 0 0 0 9 0
0 9 9 9 9 9 0
0 0 0 0 0 0 0

정답 1

 

 

 

5 5
0 0 0 0 0
0 0 9 0 0
0 0 3 1 0
0 0 9 0 0
0 0 0 0 0

정답 2

 

 

 

5 7
0 0 0 0 0 0 0
0 3 3 2 3 3 0
0 4 0 4 0 3 0
0 0 0 0 4 3 0
0 0 0 0 0 0 0


정답 0

 

 

 

5 7
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 10 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0


정답 0

 

 

5 7
0 0 0 0 0 0 0
0 3 3 1 3 3 0
0 4 0 4 0 3 0
0 0 0 0 4 3 0
0 0 0 0 0 0 0


정답 1

 

 

 

 

 

5 7
0 0 0 0 0 0 0
0 3 6 3 6 7 0
0 3 0 0 0 10 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0


정답 2

 

 

 

 

5 7
0 0 0 0 0 0 0
0 3 6 0 6 7 0
0 3 0 0 0 10 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0


정답 0

 

 

5 7
0 0 0 0 0 0 0
0 9 8 9 8 9 0
0 9 8 9 8 9 0
0 9 8 9 8 9 0
0 0 0 0 0 0 0



정답 0

 

 

 

5 7
0 0 0 0 0 0 0
0 9 8 3 8 9 0
0 9 8 0 8 9 0
0 9 8 9 8 9 0
0 0 0 0 0 0 0



정답 5

 

 

 

 

5 5
0 0 0 0 0
0 1 0 1 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0


정답 0

 

 

 

 

고뇌의 흔적들...

 

 

 

 

오늘 알게된 것 & 교훈

 

1. return 1;은 런타임 에러를 발생시킨다.

2. 문제를 잘 읽자, 안되면 문제를 천천히 다시 읽자.

3. 중간 결과를 출력해서 확인해보자.

 

 

 

 

반응형
반응형

 

 

 

백준 문제를 풀다가 습관처럼 return 1; 을 사용해서 프로그램을 종료했는데

런타임 에러가 발생하여 찾아보니 return 1;은 프로그램의 비정상 종료를 의미한다고 합니다.

 

return 0;을 사용하였더니 통과가 되었습니다.

 

 

0 : 정상 종료
-1: 에러 발생
1이상 숫자 : 정상 종료 되었으나 다른 무엇인가 있음을 나타냄
-2 같은 숫자 : 에러 발생했으나 구체적으로 무엇이다를 나타냄

 

 

 

반응형
반응형

⭕ DFS 장점

  • 현 경로상의 노드를 기억하기 때문에 적은 메모리를 사용합니다.
  • 찾으려는 노드가 깊은 단계에 있는 경우 BFS 보다 빠르게 찾을 수 있습니다.

❌ DFS 단점

  • 해가 없는 경로를 탐색 할 경우 단계가 끝날 때까지 탐색합니다. 효율성을 높이기 위해서 미리 지정한 임의 깊이까지만 탐색하고 해를 발견하지 못하면 빠져나와 다른 경로를 탐색하는 방법을 사용합니다.
  • DFS를 통해서 얻어진 해가 최단 경로라는 보장이 없습니다. DFS는 해에 도착하면 탐색을 종료하기 때문입니다.

 
 

⭕ BFS 장점

  • 답이 되는 경로가 여러 개인 경우에도 최단경로임을 보장한다.
  • 최단 경로가 존재하면 깊이가 무한정 깊어진다고 해도 답을 찾을 수 있다.

❌ BFS 단점

  • 경로가 매우 길 경우에는 탐색 가지가 급격히 증가함에 따라 보다 많은 기억 공간을 필요로 하게 된다.
  • 해가 존재하지 않는다면 유한 그래프(finite graph)의 경우에는 모든 그래프를 탐색한 후에 실패로 끝난다.
  • 무한 그래프(infinite graph)의 경우에는 결코 해를 찾지도 못하고, 끝내지도 못한다.

(Socurce: Wiki)
 
 
 
 
 

🌺 DFS vs BFS 탐색 차이

Figure 2. 트리에서 DFS, BFS 탐색 차이

  • DFS는 스택(혹은 재귀), BFS 큐를 사용합니다.
  • BFS는 재귀적으로 동작하지 않습니다.

But 문제를 푸는 입장에서는 다음과 같은 구분점이 필요합니다.

  • 최단 거리 문제를 푼다면 BFS를 사용합니다.
  • 이동할 때마다 가중치가 붙어서 이동한다거나 이동 과정에서 여러 제약이 있을 경우 DFS로 구현하는 것이 좋습니다.
반응형
반응형

Reference Code

백준 2178 - 미로 탐색

www.acmicpc.net/problem/2178

 

2178번: 미로 탐색

첫째 줄에 두 정수 N, M(2 ≤ N, M ≤ 100)이 주어진다. 다음 N개의 줄에는 M개의 정수로 미로가 주어진다. 각각의 수들은 붙어서 입력으로 주어진다.

www.acmicpc.net

 

 

#include <iostream>
#include <stdio.h>
#include <queue>
#include <stack>
#include <algorithm>

#define MAX_SIZE 101

using namespace std;

// 위, 오른, 아래, 왼
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};

int n, m; // 행과 열의 수
int dis[MAX_SIZE][MAX_SIZE];

int map[MAX_SIZE][MAX_SIZE]; // 지도
bool visited[MAX_SIZE][MAX_SIZE]; // 방문했는지를 표시하는 지도


// BFS
void bfs(int x, int y){
  
    queue< pair<int,int> > q; // 이용할 큐, (x,y) -> (행, 열)
    q.push(make_pair(x,y)); // pair를 만들어서 queue에 넣습니다.

    // 처음 x,y를 방문 했기때문에
    visited[x][y] = true;

    while(!q.empty()){

        // 큐의 현재 원소를 꺼내기
        x = q.front().first;
        y = q.front().second;
        q.pop();

        // 해당 위치의 주변을 확인
        for(int i = 0; i < 4; i++){
            int nx = x + dx[i];
            int ny = y + dy[i];

            // 지도를 벗어나지 않고
            if(0 <= nx && nx < n && 0 <= ny && ny < m){
                // 집이면서 방문하지 않았다면 -> 방문
                if(map[nx][ny] == 1 && visited[nx][ny] == false){
                    visited[nx][ny]=true;

                    // 해당 단지의 집의 수를 증가시킴
                    dis[nx][ny] = dis[x][y] + 1;

                    // 큐에 현재 nx,ny를 추가
                    q.push(make_pair(nx,ny));
                }
            }
        }
    }
}

int main (){

    scanf("%d%d", &n, &m);

    for(int i = 0; i < n; i++){
        for(int j = 0; j < m; j++)
            //입력을 1개씩 숫자로 끊어서 받습니다 -> %1d
            scanf("%1d", &map[i][j]);
    }
    
    dis[0][0] = 1;
    bfs(0, 0);

    printf("%d\n",dis[n-1][m-1]);
}

 

map, visited 2차원

queue 1차원 pair 로 구현

 

 

 

 

 

 

 

 

 

응용문제)

백준 2667 - 단지 번호 붙이기

www.acmicpc.net/problem/2667

 

#include <iostream>
#include <stdio.h>
#include <queue>
#include <stack>
#include <algorithm>

#define MAX_SIZE 25

using namespace std;

// 위, 오른, 아래, 왼
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};

int n; // 행과 열의 수
int group_id; // 단지의 번호로 첫번째 단지부터 1로 시작
int groups[MAX_SIZE * MAX_SIZE]; // 각 단지별 집의 수

int map[MAX_SIZE][MAX_SIZE]; // 지도
bool visited[MAX_SIZE][MAX_SIZE]; // 방문했는지를 표시하는 지도


// BFS
void bfs(int x, int y){

    queue< pair<int,int> > q; // 이용할 큐, (x,y) -> (행, 열)
    q.push(make_pair(x,y)); // pair를 만들어서 queue에 넣습니다.

    // 처음 x,y를 방문 했기때문에
    visited[x][y] = true;
    groups[group_id]++;  

    while(!q.empty()){

        // 큐의 현재 원소를 꺼내기
        x = q.front().first;
        y = q.front().second;
        q.pop();

        // 해당 위치의 주변을 확인
        for(int i = 0; i < 4; i++){
            int nx = x + dx[i];
            int ny = y + dy[i];

            // 지도를 벗어나지 않고
            if(0 <= nx && nx < n && 0 <= ny && ny < n){
                // 집이면서 방문하지 않았다면 -> 방문
                if(map[nx][ny] == 1 && visited[nx][ny] == false){
                    visited[nx][ny]=true;

                    // 해당 단지의 집의 수를 증가시킴
                    groups[group_id]++;

                    // 큐에 현재 nx,ny를 추가
                    q.push(make_pair(nx,ny));   
                }
            }
        }
    }
}



int main (){

    scanf("%d", &n);

    for(int i = 0; i < n; i++){
        for(int j = 0; j < n; j++)
            //입력을 1개씩 숫자로 끊어서 받습니다 -> %1d
            scanf("%1d", &map[i][j]);
    }

    // 전체 지도 탐색
    for(int i = 0; i < n; i++){
        for(int j = 0; j < n; j++){
            // 집이면서 방문하지 않았다면 -> 방문
            if(map[i][j]==1 && visited[i][j]==false){

                // 해당 지역에 단지 id를 부여하고
                group_id++;

                // 탐색
                bfs(i, j);
            }
        }
    }

    // 단지마다 집들의 수로 오름차순 정렬
    // ID는 1부터 시작
    // 함수 사용법: https://twpower.github.io/71-use-sort-and-stable_sort-in-cpp
    sort(groups + 1, groups + group_id + 1);

    printf("%d\n", group_id);
    for (int i = 1; i <= group_id; i++) {
        printf("%d\n", groups[i]);
    }
}

 

 

 

 

 

 

응용문제) 백준 2468 안전영역

www.acmicpc.net/problem/2468

 

2468번: 안전 영역

재난방재청에서는 많은 비가 내리는 장마철에 대비해서 다음과 같은 일을 계획하고 있다. 먼저 어떤 지역의 높이 정보를 파악한다. 그 다음에 그 지역에 많은 비가 내렸을 때 물에 잠기지 않는

www.acmicpc.net

 

#include <iostream>
#include <stdio.h>
#include <queue>
#include <stack>
#include <algorithm>
#include <cstring>  // memset

#define MAX_SIZE 101

using namespace std;

// 위, 오른, 아래, 왼
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};

int n; // 행과 열의 수

int map[MAX_SIZE][MAX_SIZE]; // 지도
bool visited[MAX_SIZE][MAX_SIZE];

// BFS
void bfs(int x, int y, int depth){
  
    queue< pair<int,int> > q; // 이용할 큐, (x,y) -> (행, 열)
    q.push(make_pair(x,y)); // pair를 만들어서 queue에 넣습니다.

    // 처음 x,y를 방문 했기때문에
    visited[x][y] = true;

    while(!q.empty()){

        // 큐의 현재 원소를 꺼내기
        x = q.front().first;
        y = q.front().second;
        q.pop();

        // 해당 위치의 주변을 확인
        for(int i = 0; i < 4; i++){
            int nx = x + dx[i];
            int ny = y + dy[i];

            // 지도를 벗어나지 않고
            if(0 <= nx && nx < n && 0 <= ny && ny < n){
                // 집이면서 방문하지 않았다면 -> 방문
                if(map[nx][ny] > depth && visited[nx][ny] == false){
                    visited[nx][ny]=true;

                    // 큐에 현재 nx,ny를 추가
                    q.push(make_pair(nx,ny));
                }
            }
        }
    }
}

int main (){
    int max = -1;
    int cnt[MAX_SIZE] = {0};

    scanf("%d", &n);

    for(int i = 0; i < n; i++){
        for(int j = 0; j < n; j++){
            scanf("%d", &map[i][j]);
            if(map[i][j] > max)
                max = map[i][j];
        }
    }
    
    for(int d=0; d<=max; d++){
        // visited 초기화
        memset(visited, false, sizeof(visited));
        
        for(int i=0; i<n; i++){
            for(int j=0; j<n; j++){
                if(map[i][j] > d && visited[i][j] == false){
                    cnt[d]++;
                    bfs(i, j, d);
                }
            }
        }
    }
    
    int cnt_max = -1;
    int cnt_max_id = -1;
    for(int i=0; i<=max; i++){
        if(cnt[i] > cnt_max){
            cnt_max_id = i;
            cnt_max = cnt[i];
        }
    }
    
    printf("%d\n",cnt[cnt_max_id]);
}
 

 

 

 

- 제일 빠른 경로를 찾는 것이 아니므로 dis 배열을 사용하지 않았다.

- map == 1 인 기준이 아니라, map > depth 기준으로 변경하였다.

- bfs를 여러 번 시행하여 가장 안전 영역이 큰 경우의 수를 찾았다.

- 전형적인 지도 유형의 문제

 

 

 

 

 

 

응용문제) 백준 1697 숨바꼭질

www.acmicpc.net/problem/1697

 

1697번: 숨바꼭질

수빈이는 동생과 숨바꼭질을 하고 있다. 수빈이는 현재 점 N(0 ≤ N ≤ 100,000)에 있고, 동생은 점 K(0 ≤ K ≤ 100,000)에 있다. 수빈이는 걷거나 순간이동을 할 수 있다. 만약, 수빈이의 위치가 X일

www.acmicpc.net

 

#include <iostream>
#include <stdio.h>
#include <queue>
#include <stack>
#include <algorithm>

#define MAX_SIZE 100001

using namespace std;

int n, m; // 수빈, 동생 위치

int dis[MAX_SIZE];
bool visited[MAX_SIZE]; // 방문했는지를 표시하는 배열

// BFS
void bfs(int x){
  
    queue <int> q; // 이용할 큐
    q.push(x);
    int nx;

    // 처음 x를 방문 했기때문에
    visited[x] = true;

    while(!q.empty()){

        // 큐의 현재 원소를 꺼내기
        x = q.front();
        q.pop();

        // 해당 위치의 주변을 확인
        nx = x * 2;
        
        // 지도를 벗어나지 않고, 방문한 적 없으면
        if(nx <= MAX_SIZE-1 && visited[nx] == false){
            visited[nx]=true;

            // 해당 단지의 집의 수를 증가시킴
            dis[nx] = dis[x] + 1;
            
            if(nx == m){
                printf("%d\n", dis[nx]);
                return;
            }

            // 큐에 현재 nx를 추가
            q.push(nx);
        }
        
        // 해당 위치의 주변을 확인
        nx = x + 1;
        
        // 지도를 벗어나지 않고, 방문한 적 없으면
        if(nx <= MAX_SIZE-1 && visited[nx] == false){
            visited[nx]=true;

            // 해당 단지의 집의 수를 증가시킴
            dis[nx] = dis[x] + 1;
            
            if(nx == m){
                printf("%d\n", dis[nx]);
                return;
            }

            // 큐에 현재 nx를 추가
            q.push(nx);
        }
        
        // 해당 위치의 주변을 확인
        nx = x - 1;
        
        // 지도를 벗어나지 않고, 방문한 적 없으면
        if(0 <= nx && visited[nx] == false){
            visited[nx]=true;

            // 해당 단지의 집의 수를 증가시킴
            dis[nx] = dis[x] + 1;
            
            if(nx == m){
                printf("%d\n", dis[nx]);
                return;
            }

            // 큐에 현재 nx를 추가
            q.push(nx);
        
        }
    }
}

int main (){
    
    scanf("%d%d", &n, &m);
    
    if(n == m){
        printf("0\n");
    } else {
        dis[n] = 0;
        bfs(n);
    }
    
}

 

 

- 지도 유형은 아니지만, 지도 레퍼런스를 가지고 풀었다.

- 2차원 배열을 모두 1차원으로 변경

- 세세한 예외 조건들을 설정하는게 까다로운 문제

 

 

 

 

 

 

 

 

응용문제) 백준 5014 스타트링크

 

#include <iostream>
#include <stdio.h>
#include <queue>
#include <stack>
#include <algorithm>

#define MAX_SIZE 10000001

using namespace std;

int f, s, g, u, d;

int dis[MAX_SIZE];
bool visited[MAX_SIZE]; // 방문했는지를 표시하는 배열

// BFS
void bfs(int x, int up, int down){
  
    queue <int> q; // 이용할 큐
    q.push(x);
    int nx;

    // 처음 x를 방문 했기때문에
    visited[x] = true;

    while(!q.empty()){

        // 큐의 현재 원소를 꺼내기
        x = q.front();
        q.pop();

        // 해당 위치의 주변을 확인
        nx = x + up;
        
        // 지도를 벗어나지 않고, 방문한 적 없으면
        if(nx >= 1 && nx <= f && visited[nx] == false){
            
            visited[nx]=true;

            // 해당 단지의 집의 수를 증가시킴
            dis[nx] = dis[x] + 1;
            
            if(nx == g){
                printf("%d\n", dis[nx]);
                return;
            }

            // 큐에 현재 nx를 추가
            q.push(nx);
        }
        
        // 해당 위치의 주변을 확인
        nx = x - down;
        
        // 지도를 벗어나지 않고, 방문한 적 없으면
        if(nx >= 1 && nx <= f && visited[nx] == false){
            
            visited[nx]=true;

            // 해당 단지의 집의 수를 증가시킴
            dis[nx] = dis[x] + 1;
            
            if(nx == g){
                printf("%d\n", dis[nx]);
                return;
            }

            // 큐에 현재 nx를 추가
            q.push(nx);
        }
    }
    printf("use the stairs\n");
}

int main (){
    
    scanf("%d%d%d%d%d", &f, &s, &g, &u, &d);
    
    if(s == g){
        printf("0\n");
    } else {
        bfs(s, u, d);
    }
    
}

 

 

 

- 숨바꼭질 문제를 변형해서 작성하였다.

- 역시나 예외 처리에서 꼼꼼하게 따져줘야 했다.

반응형

+ Recent posts