개발 블로그

문제 링크 : www.acmicpc.net/problem/1261

문제

알고스팟 운영진이 모두 미로에 갇혔다. 미로는 N*M 크기이며, 총 1*1크기의 방으로 이루어져 있다. 미로는 빈 방 또는 벽으로 이루어져 있고, 빈 방은 자유롭게 다닐 수 있지만, 벽은 부수지 않으면 이동할 수 없다.

알고스팟 운영진은 여러명이지만, 항상 모두 같은 방에 있어야 한다. 즉, 여러 명이 다른 방에 있을 수는 없다. 어떤 방에서 이동할 수 있는 방은 상하좌우로 인접한 빈 방이다. 즉, 현재 운영진이 (x, y)에 있을 때, 이동할 수 있는 방은 (x+1, y), (x, y+1), (x-1, y), (x, y-1) 이다. 단, 미로의 밖으로 이동 할 수는 없다.

벽은 평소에는 이동할 수 없지만, 알고스팟의 무기 AOJ를 이용해 벽을 부수어 버릴 수 있다. 벽을 부수면, 빈 방과 동일한 방으로 변한다.

만약 이 문제가 알고스팟에 있다면, 운영진들은 궁극의 무기 sudo를 이용해 벽을 한 번에 다 없애버릴 수 있지만, 안타깝게도 이 문제는 Baekjoon Online Judge에 수록되어 있기 때문에, sudo를 사용할 수 없다.

현재 (1, 1)에 있는 알고스팟 운영진이 (N, M)으로 이동하려면 벽을 최소 몇 개 부수어야 하는지 구하는 프로그램을 작성하시오.

입력

첫째 줄에 미로의 크기를 나타내는 가로 크기 M, 세로 크기 N (1 ≤ N, M ≤ 100)이 주어진다. 다음 N개의 줄에는 미로의 상태를 나타내는 숫자 0과 1이 주어진다. 0은 빈 방을 의미하고, 1은 벽을 의미한다.

(1, 1)과 (N, M)은 항상 뚫려있다.

출력

첫째 줄에 알고스팟 운영진이 (N, M)으로 이동하기 위해 벽을 최소 몇 개 부수어야 하는지 출력한다.

접근 방법

visit[][]로 방문 여부를 체크해야하나 싶었는데, 그렇게 하면 나중에 방문한 경우가 더 적게 벽을 부신 경우가 될 수 있기 때문에 다른 방법을 고려해야 했다.

즉, 다음 방문할 칸이 벽이던 방이던, 갱신 조건(더 적게 벽을 부신 경우)을 만족할 경우에만 Queue에 push 해주면 된다. 그러면 마지막에 cntWall[N][M]에서 상하좌우로 탐색을 할 때 범위체크에서 우/하 방향이 걸러지고 상/좌의 경우에는 갱신조건을 만족하지 못하므로(cntWall가 같으므로) 더이상 Queue 에 Push 하지 않고 while문을 벗어나게 된다. 

(while문 안에 if 조건문으로 탈출 조건을 따로 안 써줘도 된다.)

주의할 점

처음에 메모리 초과가 난 이유가 Queue에 너무 많은 원소가 들어가서였다. 그 코드에서는 범위 체크만 통과하면 바로 Queue에 next 칸을 push 했었다. 

수정된 아래의 코드처럼 갱신 조건을 만족할 때만 Queue 에 push 해주면 메모리초과가 안 뜬다.

#include <iostream>
#include <utility>
#include <queue>

using namespace std;

#define MAX 101

int N,M;
int map[MAX][MAX];
queue<pair<int,int>> que;

int cntWall[MAX][MAX];

//위 오 아 왼
int dr[4] = {-1, 0, 1, 0};
int dc[4] = {0, 1, 0, -1};

void BFS(){
    
    while(!que.empty()){

        int r = que.front().first;
        int c = que.front().second;
        que.pop();
        
        for(int i = 0; i<4; i++){
            int nr = r + dr[i];
            int nc = c + dc[i];
            
            if(nr<1 || nr>N || nc<1 || nc>M) continue;		//범위 체크
	
            if(map[nr][nc] == 1){		//다음 칸이 벽일 때
                
                if(cntWall[nr][nc] > cntWall[r][c]+1){		//갱신 조건
                    cntWall[nr][nc] =cntWall[r][c]+1;
                     que.push(make_pair(nr,nc));
                }
                
            }
            else{						//다음 칸이 방일 때
                if(cntWall[nr][nc]>cntWall[r][c]){			//갱신 조건
                    cntWall[nr][nc] = cntWall[r][c];
                    que.push(make_pair(nr,nc));
                }
            }
        }
    }
}

int main(){

    cin >> M >> N;
    string str;
    for(int i = 1; i<=N; i++){
        for(int j = 1; j<=M; j++){
            cntWall[i][j] = 1000;			//최대 값으로 초기 설정
        }
    }
    
    for(int i = 1; i<=N; i++){
        cin >> str;
        for(int j = 1; j<=str.length(); j++){
            map[i][j] = str[j-1]-'0';
        }
    }
    //입력받을 때 동일한 방법
    /* for(int i = 1; i<=N; i++){
        for(int j = 1; j<=M; j++){
            scanf( "%1d", &map[i][j] );
        }
    }*/
   
    
    que.push(make_pair(1,1));
    cntWall[1][1] = 0;          //항상 뚫려 있다고 했으므로 0으로 초기 설정 가능
    
    BFS();
    
    cout << cntWall[N][M];
   
    
    return 0;
}

문제 링크 : www.acmicpc.net/problem/1707

문제

그래프의 정점의 집합을 둘로 분할하여, 각 집합에 속한 정점끼리는 서로 인접하지 않도록 분할할 수 있을 때, 그러한 그래프를 특별히 이분 그래프 (Bipartite Graph) 라 부른다.

그래프가 입력으로 주어졌을 때, 이 그래프가 이분 그래프인지 아닌지 판별하는 프로그램을 작성하시오.

입력

입력은 여러 개의 테스트 케이스로 구성되어 있는데, 첫째 줄에 테스트 케이스의 개수 K(2≤K≤5)가 주어진다. 각 테스트 케이스의 첫째 줄에는 그래프의 정점의 개수 V(1≤V≤20,000)와 간선의 개수 E(1≤E≤200,000)가 빈 칸을 사이에 두고 순서대로 주어진다. 각 정점에는 1부터 V까지 차례로 번호가 붙어 있다. 이어서 둘째 줄부터 E개의 줄에 걸쳐 간선에 대한 정보가 주어지는데, 각 줄에 인접한 두 정점의 번호가 빈 칸을 사이에 두고 주어진다.

출력

K개의 줄에 걸쳐 입력으로 주어진 그래프가 이분 그래프이면 YES, 아니면 NO를 순서대로 출력한다.

접근 방법

연결 그래프와 비연결 그래프 두 경우를 생각해야한다.

1번노드부터 V번노드까지 BFS를 돌린다. 그래야 연결되지 않고 따로 떨여져 있는 노드도 처리할 수 있다.

처음 시작노드를 team1로 정했으면 그 노드와 연결된 노드들은 team2로, 그 다음은 다시 team1로 지정한다.

지정이 끝나면 이중포문을 돌면서 아래와 같이 검사한다. 

for(1번노드부터 V번 노드까지){

  for(해당 노드에 연결된 모든 노드들에 대해){   ...   } 

}

문제의 테스트케이스는 모두 연결 그래프로 나와있어서 비연결 그래프에 대해 생각해야한다는게 어려웠는데 백준 질의응답을 보고 해결했다.

예를 들어,

1-2

3-4

이렇게 연결되어 있는 그래프가 있다고 하자.

{1,4} ,{2,4} 또는 {1,3},{2,4} 로 집합을 나눌 수 있으므로 답은 YES이다.

주의할 점

테스트케이스가 반복되는 경우이므로 테스트케이스가 끝날 때마다 초기화를 해준다.

그리고 출력할 때도 줄바꿈을 해줘야한다.

#include <iostream>
#include <queue>
#include <vector>
#include <utility>
#include <cstring>    //memset

using namespace std;

vector<int> vecArr[20001];				//벡터1부터 벡터V까지에 대한 벡터배열이므로 +1
vector<pair<int,int>> eVec;

int visit[20001] = {0};
int group[20001] = {0};
int V,E;

void BFS(int start){
    queue<int> que;

    que.push(start); 
    visit[start] = 1;	//방문 체크
    group[start] = 1;	//집합 가르기
    
    int team = 1;
    
    while(!que.empty()){
   
        int sV = que.front();
        que.pop();

		
        //연결된 노드들을 현재벡터(sV)와 반대로 
        if(group[sV]==1) team = 2;
        else if(group[sV]==2) team = 1;
        
        for(int i = 0; i<vecArr[sV].size(); i++){
            
            int nV = vecArr[sV][i];
            
            if(visit[nV]==0){
                que.push(nV);
                visit[nV] = 1; 
                group[nV] = team;         
            }   
        }
    }

}


int main(){
    
    int T; cin >> T;
    
    for(int t=0; t<T; t++){
        
        cin >> V >> E;
        
        int e1,e2;
        for(int i = 0; i<E; i++){
            cin >> e1 >> e2;
           
            vecArr[e1].push_back(e2);
            vecArr[e2].push_back(e1);

        }

        for(int i = 1; i<=V; i++){
            if(visit[i]==0){			//모든 노드에 대해 돌려야 비연결 그래프도 통과
                BFS(i);
            }

        }
        
        
        bool chk = true;
        for(int i=1; i<=V; i++){
            for(int j = 0; j<vecArr[i].size(); j++){
                if(group[i]==group[vecArr[i][j]]){
                    chk=false;
                    break;
                }
            }
        }
       if(!chk) cout << "NO\n";
       else cout << "YES\n";
  
        for(int i = 0; i<=V; i++) vecArr[i].clear();
        memset(visit,0,sizeof(visit));
        memset(group,0,sizeof(group));
        
        
    }
    
    
    
    
    
    return 0;
}

문제 링크 : www.acmicpc.net/problem/7576

문제

철수의 토마토 농장에서는 토마토를 보관하는 큰 창고를 가지고 있다. 토마토는 아래의 그림과 같이 격자 모양 상자의 칸에 하나씩 넣어서 창고에 보관한다. 

창고에 보관되는 토마토들 중에는 잘 익은 것도 있지만, 아직 익지 않은 토마토들도 있을 수 있다. 보관 후 하루가 지나면, 익은 토마토들의 인접한 곳에 있는 익지 않은 토마토들은 익은 토마토의 영향을 받아 익게 된다. 하나의 토마토의 인접한 곳은 왼쪽, 오른쪽, 앞, 뒤 네 방향에 있는 토마토를 의미한다. 대각선 방향에 있는 토마토들에게는 영향을 주지 못하며, 토마토가 혼자 저절로 익는 경우는 없다고 가정한다. 철수는 창고에 보관된 토마토들이 며칠이 지나면 다 익게 되는지, 그 최소 일수를 알고 싶어 한다.

토마토를 창고에 보관하는 격자모양의 상자들의 크기와 익은 토마토들과 익지 않은 토마토들의 정보가 주어졌을 때, 며칠이 지나면 토마토들이 모두 익는지, 그 최소 일수를 구하는 프로그램을 작성하라. 단, 상자의 일부 칸에는 토마토가 들어있지 않을 수도 있다.

입력

첫 줄에는 상자의 크기를 나타내는 두 정수 M,N이 주어진다. M은 상자의 가로 칸의 수, N은 상자의 세로 칸의 수를 나타낸다. 단, 2 ≤ M,N ≤ 1,000 이다. 둘째 줄부터는 하나의 상자에 저장된 토마토들의 정보가 주어진다. 즉, 둘째 줄부터 N개의 줄에는 상자에 담긴 토마토의 정보가 주어진다. 하나의 줄에는 상자 가로줄에 들어있는 토마토의 상태가 M개의 정수로 주어진다. 정수 1은 익은 토마토, 정수 0은 익지 않은 토마토, 정수 -1은 토마토가 들어있지 않은 칸을 나타낸다.

토마토가 하나 이상 있는 경우만 입력으로 주어진다.

출력

여러분은 토마토가 모두 익을 때까지의 최소 날짜를 출력해야 한다. 만약, 저장될 때부터 모든 토마토가 익어있는 상태이면 0을 출력해야 하고, 토마토가 모두 익지는 못하는 상황이면 -1을 출력해야 한다.

접근 방법

fromStart[][]을 이용해서 방문 여부와 동시에 토마토가 익을때까지 걸린 day수를 저장한다.

처음 배열을 입력할 때 1인 경우를 queue에 push 하고,

입력받음과 동시에 1인 칸의 수(int start)와 -1인 칸의 수(int minu)를 카운트한다.

이는 마지막에 영향받아 익은 토마토 수(int chk)와의 덧셈연산을 통해 안 익은 토마토가 남았는지를 검사하는데에 이용한다.

이 외에 나머지는 일반 BFS와 같은 로직이다.

주의할 점

1)

if(fromStart[nr]ncc] > fromStart[r][c]+1) 인 경우에만 fromStart[nr][nc] 를 fromStart[r][c]+1로 갱신해줘야하나 싶었는데, 

어짜피 fromStart[nr][nc]에 값이 저장되는 그 순간에 그게 필요한 최소 day 수 이므로 체크할 필요가 없이

if(fromStart[nr][nc] == 0 && map[nr][nc]==0) 인 조건만 만족하면 fromStart[nr][nc] 를 갱신하면 된다. 

2)

가로 칸의 수는 M(col), 세로 칸의 수는 N(row) 이다.

3)

2<=N,M<=1000이고 상하좌우 검사해야해서 map[1002][1002], fromStart[1002][1002] 로 선언해야 했는데

nr<0 || nr >=N || nc<0 || nc >=M  로 범위 검사를 하니 1000으로 선언해도 된다.

#include <iostream>
#include <queue>
#include <utility>

using namespace std;


int map[1000][1000];
int fromStart[1000][1000];

int M;  //가로 col
int N;  //세로 row
int nr, nc;
int start = 0, minu=0;
int r, c;

//위 오 아 왼
int dr[4] = {-1, 0, 1, 0};
int dc[4] = {0, 1, 0, -1};

queue<pair<int, int>> que;

void BFS(){
    
    while(!que.empty()){
   
        r = que.front().first;
        c = que.front().second;
        que.pop();
        
        for(int i = 0; i<4; i++){
            
            nr = r + dr[i];
            nc = c + dc[i];
            
            if(nr<0 || nr >=N || nc<0 || nc >=M || map[nr][nc]==-1) continue;    //map -1이면 토마토 없음
            
            if(fromStart[nr][nc]==0 && map[nr][nc]==0){ //방문 안 했고 안 익은 토마토 있으면
                fromStart[nr][nc] = fromStart[r][c]+1;
                que.push(make_pair(nr,nc));
            }
        }
    }
}


int main(){
    
    cin >> M >> N;
    
    for(int i = 0 ;i <N; i++){
        for(int j = 0; j<M; j++){
            fromStart[i][j] = 0;        //visit 여부 & 해당 칸 토마토가 익기까지 day 수 저장
            
            cin >> map[i][j];
            if(map[i][j] == 1){
                que.push(make_pair(i,j));
                start++;                            //start는 맨 처음 익은 토마토 수
            }
            else if(map[i][j] == -1) minu++;        //minu는 토마토 없는 칸 수
        }
    }
    
    BFS();
    
    int chk = 0;
    for(int i = 0; i<N; i++){
        for(int j = 0; j<M; j++){
            if(fromStart[i][j]!=0) chk++;            //방문 안한곳 있으면 -1 출력하기 위함
        }
    }
   
    if(chk+start+minu==M*N) cout << fromStart[r][c];
    else cout << -1;
    
    return 0;
}