https://www.acmicpc.net/problem/10813

문제

도현이는 바구니를 총 N개 가지고 있고, 각각의 바구니에는 1번부터 N번까지 번호가 매겨져 있다.

바구니에는 공이 1개씩 들어있고, 처음에는 바구니에 적혀있는 번호와 같은 번호가 적힌 공이 들어있다.

도현이는 앞으로 M번 공을 바꾸려고 한다. 도현이는 공을 바꿀 바구니 2개를 선택하고, 두 바구니에 들어있는 공을 서로 교환한다.

공을 어떻게 바꿀지가 주어졌을 때, M번 공을 바꾼 이후에 각 바구니에 어떤 공이 들어있는지 구하는 프로그램을 작성하시오.

입력

첫째 줄에 N (1 ≤ N ≤ 100)과 M (1 ≤ M ≤ 100)이 주어진다.

둘째 줄부터 M개의 줄에 걸쳐서 공을 교환할 방법이 주어진다.

각 방법은 두 정수 i j로 이루어져 있으며, i번 바구니와 j번 바구니에 들어있는 공을 교환한다는 뜻이다. (1 ≤ i ≤ j ≤ N)

도현이는 입력으로 주어진 순서대로 공을 교환한다.

출력

1번 바구니부터 N번 바구니에 들어있는 공의 번호를 공백으로 구분해 출력한다.

예제 입력 1

5 4
1 2
3 4
1 4
2 2

예제 출력 1

3 1 4 2 5

출처

• 문제를 만든 사람: baekjoon
• 문제의 오타를 찾은 사람: onjo0127

알고리즘 분류

• 구현
• 시뮬레이션

통과된 코드

단순한 구현 문제

#include <iostream>

using namespace std;

int N, M;
int Arr[101] = { 0 };

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);

	cin >> N >> M;

    for (int i = 1; i <= N; i++)
        Arr[i] = i;

	int t1, t2;

    for (int i = 0; i < M; i++) {
        cin >> t1 >> t2;
		swap(Arr[t1], Arr[t2]);
    }

    for (int i = 1; i <= N; i++)
		cout << Arr[i] << " ";

    return 0;
}

The post 백준 10813번 (공 바꾸기, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

치즈

https://www.acmicpc.net/problem/2636

문제

아래 <그림 1>과 같이 정사각형 칸들로 이루어진 사각형 모양의 판이 있고,

그 위에 얇은 치즈(회색으로 표시된 부분)가 놓여 있다.

판의 가장자리(<그림 1>에서 네모 칸에 X친 부분)에는 치즈가 놓여 있지 않으며 치즈에는 하나 이상의 구멍이 있을 수 있다.

이 치즈를 공기 중에 놓으면 녹게 되는데 공기와 접촉된 칸은 한 시간이 지나면 녹아 없어진다.

치즈의 구멍 속에는 공기가 없지만 구멍을 둘러싼 치즈가 녹아서 구멍이 열리면 구멍 속으로 공기가 들어가게 된다.

<그림 1>의 경우, 치즈의 구멍을 둘러싼 치즈는 녹지 않고 ‘c’로 표시된 부분만 한 시간 후에 녹아 없어져서 <그림 2>와 같이 된다.

다시 한 시간 후에는 <그림 2>에서 ‘c’로 표시된 부분이 녹아 없어져서 <그림 3>과 같이 된다.

<그림 3>은 원래 치즈의 두 시간 후 모양을 나타내고 있으며,

남은 조각들은 한 시간이 더 지나면 모두 녹아 없어진다.

그러므로 처음 치즈가 모두 녹아 없어지는 데는 세 시간이 걸린다.

<그림 3>과 같이 치즈가 녹는 과정에서 여러 조각으로 나누어 질 수도 있다.

입력으로 사각형 모양의 판의 크기와 한 조각의 치즈가 판 위에 주어졌을 때,

공기 중에서 치즈가 모두 녹아 없어지는 데 걸리는 시간과

모두 녹기 한 시간 전에 남아있는 치즈조각이 놓여 있는 칸의 개수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에는 사각형 모양 판의 세로와 가로의 길이가 양의 정수로 주어진다.

세로와 가로의 길이는 최대 100이다.

판의 각 가로줄의 모양이 윗 줄부터 차례로 둘째 줄부터 마지막 줄까지 주어진다.

치즈가 없는 칸은 0, 치즈가 있는 칸은 1로 주어지며 각 숫자 사이에는 빈칸이 하나씩 있다.

출력

첫째 줄에는 치즈가 모두 녹아서 없어지는 데 걸리는 시간을 출력하고,

둘째 줄에는 모두 녹기 한 시간 전에 남아있는 치즈조각이 놓여 있는 칸의 개수를 출력한다.

예제 입력 1

13 12
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 1 0 0 0
0 1 1 1 0 0 0 1 1 0 0 0
0 1 1 1 1 1 1 0 0 0 0 0
0 1 1 1 1 1 0 1 1 0 0 0
0 1 1 1 1 0 0 1 1 0 0 0
0 0 1 1 0 0 0 1 1 0 0 0
0 0 1 1 1 1 1 1 1 0 0 0
0 0 1 1 1 1 1 1 1 0 0 0
0 0 1 1 1 1 1 1 1 0 0 0
0 0 1 1 1 1 1 1 1 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0

예제 출력 1

3
5

출처

Olympiad > 한국정보올림피아드 > KOI 2000 > 초등부 3번

• 문제의 오타를 찾은 사람: compro0317, shawn050912
• 데이터를 추가한 사람: jung2381187

알고리즘 분류

• 구현
• 그래프 이론
• 그래프 탐색
• 시뮬레이션
• 너비 우선 탐색

통과된 코드

#include <iostream>
#include <queue>
#include <vector>
using namespace std;
constexpr short MAX = 100;
short _N, _M, _Cheese = 0;
short _DxDy[4][2] = { {1,0},{-1,0},{0,1},{0,-1} };
bool _Map[MAX][MAX];
bool _IsVisted[MAX][MAX];
vector<short> Records;
vector<pair<short, short>> _Next;
queue<pair<short, short>> BFSqueue;
int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	cin >> _N >> _M;
	bool _t;
	for (short i = 0; i < _N; i++)
		for (short j = 0; j < _M; j++) {
			cin >> _t;
			_Map[i][j] = _t;
			if (_t == 1)
				_Cheese++;
		}
	short _time = 0;
	while (true) {
		Records.push_back(_Cheese);
		if (_Cheese == 0)
			break;
		for (short i = 0; i < _N; i++)
			for (short j = 0; j < _M; j++)
				_IsVisted[i][j] = false;
		_Next.clear();
		BFSqueue.push({ 0,0 });
		_IsVisted[0][0] = true;
		while (!BFSqueue.empty()) {
			pair<short, short> _pos = BFSqueue.front();
			BFSqueue.pop();
			for (short i = 0; i < 4; i++) {
				short _dx = _pos.first + _DxDy[i][0];
				short _dy = _pos.second + _DxDy[i][1];

				if (_dx < 0 || _dy < 0 || _dx >= _N || _dy >= _M)
					continue;
				if (_IsVisted[_dx][_dy])
					continue;
				if (_Map[_dx][_dy] == 1) {
					_Next.push_back({ _dx, _dy });
					_IsVisted[_dx][_dy] = true;
					continue;
				}

				_IsVisted[_dx][_dy] = true;
				BFSqueue.push({ _dx, _dy});
			}
		}

		for (auto& it : _Next) {
			_Map[it.first][it.second] = 0;
			_Cheese--;
		}

		_time++;
	}

	cout << _time << "\n" << Records[Records.size() - 2];


	return 0;
}

The post 백준 2636번 (치즈, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

치즈

https://www.acmicpc.net/problem/2638

문제

N×M의 모눈종이 위에 아주 얇은 치즈가 <그림 1>과 같이 표시되어 있다.

단, N 은 세로 격자의 수이고, M 은 가로 격자의 수이다.

이 치즈는 냉동 보관을 해야만 하는데 실내온도에 내어놓으면 공기와 접촉하여 천천히 녹는다.

그런데 이러한 모눈종이 모양의 치즈에서 각 치즈 격자(작 은 정사각형 모양)의 4변 중에서 적어도

2변 이상이 실내온도의 공기와 접촉한 것은 정확히 한시간만에 녹아 없어져 버린다.

따라서 아래 <그림 1> 모양과 같은 치즈(회색으로 표시된 부분)라면 C로 표시된 모든 치즈 격자는 한 시간 후에 사라진다.

<그림 1>

<그림 2>와 같이 치즈 내부에 있는 공간은 치즈 외부 공기와 접촉하지 않는 것으로 가정한다.

그러므 로 이 공간에 접촉한 치즈 격자는 녹지 않고 C로 표시된 치즈 격자만 사라진다.

그러나 한 시간 후, 이 공간으로 외부공기가 유입되면 <그림 3>에서와 같이 C로 표시된 치즈 격자들이 사라지게 된다.

<그림 2>

<그림 3>

모눈종이의 맨 가장자리에는 치즈가 놓이지 않는 것으로 가정한다.

입력으로 주어진 치즈가 모두 녹아 없어지는데 걸리는 정확한 시간을 구하는 프로그램을 작성하시오.

입력

첫째 줄에는 모눈종이의 크기를 나타내는 두 개의 정수 N, M (5 ≤ N, M ≤ 100)이 주어진다.

그 다음 N개의 줄에는 모눈종이 위의 격자에 치즈가 있는 부분은 1로 표시되고,

치즈가 없는 부분은 0으로 표시된다. 또한, 각 0과 1은 하나의 공백으로 분리되어 있다.

출력

출력으로는 주어진 치즈가 모두 녹아 없어지는데 걸리는 정확한 시간을 정수로 첫 줄에 출력한다.

예제 입력 1

8 9
0 0 0 0 0 0 0 0 0
0 0 0 1 1 0 0 0 0
0 0 0 1 1 0 1 1 0
0 0 1 1 1 1 1 1 0
0 0 1 1 1 1 1 0 0
0 0 1 1 0 1 1 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0

예제 출력 1

4

추가 예제

예제 입력 A

7 7
0 0 0 0 0 0 0
0 1 1 0 1 1 0
0 1 1 1 1 1 0
0 0 1 0 1 0 0
0 1 1 1 1 1 0
0 1 1 0 1 1 0
0 0 0 0 0 0 0

예제 출력 A

3

예제 입력 B

8 9
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 1 0 0 0 0
0 0 0 1 1 1 0 0 0
0 0 0 0 1 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0

예제 출력 B

2

예제 입력 C

5 6
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 1 0
0 0 0 0 0 0

예제 출력 C

1

예제 입력 D

10 10
0 0 0 0 0 0 0 0 0 0
0 1 1 0 0 0 0 1 1 0
0 1 0 1 1 1 1 0 1 0
0 1 0 0 1 1 0 0 1 0
0 1 0 0 1 1 0 0 1 0
0 1 0 0 1 1 0 0 1 0
0 1 0 0 1 0 0 0 1 0
0 1 0 1 1 1 1 0 1 0
0 1 1 0 0 0 0 1 1 0
0 0 0 0 0 0 0 0 0 0

예제 출력 D

4

출처

Olympiad > 한국정보올림피아드 > KOI 2000 > 중등부 2번

• 문제의 오타를 찾은 사람: apjw6112
• 잘못된 데이터를 찾은 사람: tncks0121

알고리즘 분류

• 구현
• 그래프 이론
• 그래프 탐색
• 너비 우선 탐색
• 시뮬레이션
• 깊이 우선 탐색

통과된 코드

#include <iostream>
#include <vector>
#include <queue>
using namespace std;

int _DxDy[4][2] = { {-1, 0}, {1, 0}, {0, -1}, {0, 1} };
int _MapArr[101][101];
bool _isVisited[101][101]; // 방문 체크

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    
    int _N, _M ,_NumCheese = 0, _Res = 0;
    cin >> _N >> _M;
    for (int i = 1; i <= _N; i++) {
        for (int j = 1; j <= _M; j++) {
            cin >> _MapArr[i][j];
            if (_MapArr[i][j]) _NumCheese++; // 치즈의 개수
        }
    }

    while (_NumCheese) { // 치즈가 0이 될때까지 반복
        _Res++; // 시간 ++
        vector<pair<int, int>> _MeltedcheeseV; // 녹을 치즈의 좌표를 저장할 벡터
        for (int i = 1; i <= _N; i++) { // 방문 초기화
            for (int j = 1; j <= _M; j++) {
                _isVisited[i][j] = false;
            }
        }
        // BFS 탐색으로 외부와 닿는 치즈를 찾는다.
        queue<pair<int, int>> myQueue;
        myQueue.push(make_pair(1, 1));
        _MapArr[1][1] = -1; // 외부와 내부의 공기를 구분
        _isVisited[1][1] = true;
        while (!myQueue.empty()) {
            pair<int, int> _CntPos = myQueue.front();
            myQueue.pop();
            for (int k = 0; k < 4; k++) { // 상하 좌우로 검색
                int nx = _CntPos.first + _DxDy[k][0];
                int ny = _CntPos.second + _DxDy[k][1];
                if (nx <= 0 || ny <= 0 || nx > _N || ny > _M) continue; // 범위를 벗어난다면 넘어간다.
                if (_isVisited[nx][ny]) continue; // 방문 했다면 넘어간다.
                _isVisited[nx][ny] = true; // 방문 처리
                if (_MapArr[nx][ny] == 1) { // 만약 치즈라면 다시 큐에 넣을 필요가 없다.
                    _MeltedcheeseV.push_back(make_pair(nx, ny));
                    continue;
                }
                _MapArr[nx][ny] = -1;
                myQueue.push(make_pair(nx, ny));
            }
        }

        for (auto& it : _MeltedcheeseV) { // 표면과 닿아있는 치즈들을 순회
            int _AirNum = 0; // 외부 공기와 닿는 수
            for (int k = 0; k < 4; k++) { // 치즈의 상하 좌우로 검색
                int nx = it.first + _DxDy[k][0];
                int ny = it.second + _DxDy[k][1];
                if (_MapArr[nx][ny] == -1) {
                    _AirNum++;
                    if (_AirNum >= 2) break; // 공기와 닿는 면적이 2이상이면 break;
                }
            }
            if (_AirNum >= 2) { // 닿는 부분이 2개 이상
                _MapArr[it.first][it.second] = 0;
                _NumCheese--; // 치즈의 개수를 줄여준다.
            }
        }

    }

    cout << _Res;
    
    return 0;
}

The post 백준 2638번 (치즈, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

저항

https://www.acmicpc.net/problem/1076

문제

전자 제품에는 저항이 들어간다.

저항은 색 3개를 이용해서 그 저항이 몇 옴인지 나타낸다.

처음 색 2개는 저항의 값이고, 마지막 색은 곱해야 하는 값이다.

저항의 값은 다음 표를 이용해서 구한다.

예를 들어, 저항의 색이 yellow, violet, red였다면 저항의 값은 4,700이 된다.

입력

첫째 줄에 첫 번째 색, 둘째 줄에 두 번째 색, 셋째 줄에 세 번째 색이 주어진다.

위의 표에 있는 색만 입력으로 주어진다.

출력

입력으로 주어진 저항의 저항값을 계산하여 첫째 줄에 출력한다.

예제 입력 1

yellow
violet
red

예제 출력 1

4700

예제 입력 2

orange
red
blue

예제 출력 2

32000000

예제 입력 3

white
white
white

예제 출력 3

99000000000

출처

• 문제를 번역한 사람: baekjoon
• 어색한 표현을 찾은 사람: shiroed1211

알고리즘 분류

• 구현

단순 구현문제

통과된 코드

#include <iostream>
#include <map>

using namespace std;

string str;

long long int result;

multimap<string, pair<int, long long int>> mMap = { 
		{"black", make_pair(0, 1)},
		{"brown", make_pair(1, 10)},
		{"red", make_pair(2, 100)},
		{"orange", make_pair(3, 1000)},
		{"yellow", make_pair(4, 10000)},
		{"green", make_pair(5, 100000)},
		{"blue", make_pair(6, 1000000)},
		{"violet", make_pair(7, 10000000)},
		{"grey", make_pair(8, 100000000)},
		{"white", make_pair(9, 1000000000)}
};

int main()
{
	cin >> str;
	result += (mMap.find(str)->second.first * 10);
	cin >> str;
	result += (mMap.find(str)->second.first);
	cin >> str;
	result *= (mMap.find(str)->second.second);
	cout << result;

	return 0;
}

The post 백준 1076번 (저항, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

아기 상어

https://www.acmicpc.net/problem/16236

문제

N×N 크기의 공간에 물고기 M마리와 아기 상어 1마리가 있다.

공간은 1×1 크기의 정사각형 칸으로 나누어져 있다.

한 칸에는 물고기가 최대 1마리 존재한다.

아기 상어와 물고기는 모두 크기를 가지고 있고, 이 크기는 자연수이다.

가장 처음에 아기 상어의 크기는 2이고, 아기 상어는 1초에 상하좌우로 인접한 한 칸씩 이동한다.

아기 상어는 자신의 크기보다 큰 물고기가 있는 칸은 지나갈 수 없고, 나머지 칸은 모두 지나갈 수 있다.

아기 상어는 자신의 크기보다 작은 물고기만 먹을 수 있다.

따라서, 크기가 같은 물고기는 먹을 수 없지만, 그 물고기가 있는 칸은 지나갈 수 있다.

아기 상어가 어디로 이동할지 결정하는 방법은 아래와 같다.

더 이상 먹을 수 있는 물고기가 공간에 없다면 아기 상어는 엄마 상어에게 도움을 요청한다.

먹을 수 있는 물고기가 1마리라면, 그 물고기를 먹으러 간다.

먹을 수 있는 물고기가 1마리보다 많다면, 거리가 가장 가까운 물고기를 먹으러 간다.

– 거리는 아기 상어가 있는 칸에서 물고기가 있는 칸으로 이동할 때, 지나야하는 칸의 개수의 최솟값이다.

– 거리가 가까운 물고기가 많다면, 가장 위에 있는 물고기, 그러한 물고기가 여러마리라면, 가장 왼쪽에 있는 물고기를 먹는다.

– 아기 상어의 이동은 1초 걸리고, 물고기를 먹는데 걸리는 시간은 없다고 가정한다.

즉, 아기 상어가 먹을 수 있는 물고기가 있는 칸으로 이동했다면, 이동과 동시에 물고기를 먹는다. 물고기를 먹으면, 그 칸은 빈 칸이 된다.

아기 상어는 자신의 크기와 같은 수의 물고기를 먹을 때 마다 크기가 1 증가한다. 예를 들어, 크기가 2인 아기 상어는 물고기를 2마리 먹으면 크기가 3이 된다.

공간의 상태가 주어졌을 때, 아기 상어가 몇 초 동안 엄마 상어에게 도움을 요청하지 않고 물고기를 잡아먹을 수 있는지 구하는 프로그램을 작성하시오.

입력

첫째 줄에 공간의 크기 N(2 ≤ N ≤ 20)이 주어진다.

둘째 줄부터 N개의 줄에 공간의 상태가 주어진다.

공간의 상태는 0, 1, 2, 3, 4, 5, 6, 9로 이루어져 있고, 아래와 같은 의미를 가진다.

0: 빈 칸

1, 2, 3, 4, 5, 6: 칸에 있는 물고기의 크기

9: 아기 상어의 위치

아기 상어는 공간에 한 마리 있다.

출력

첫째 줄에 아기 상어가 엄마 상어에게 도움을 요청하지 않고 물고기를 잡아먹을 수 있는 시간을 출력한다.

예제 입력 1

3
0 0 0
0 0 0
0 9 0

예제 출력 1

0

예제 입력 2

3
0 0 1
0 0 0
0 9 0

예제 출력 2

3

예제 입력 3

4
4 3 2 1
0 0 0 0
0 0 9 0
1 2 3 4

예제 출력 3

14

예제 입력 4

6
5 4 3 2 3 4
4 3 2 3 4 5
3 2 9 5 6 6
2 1 2 3 4 5
3 2 1 6 5 4
6 6 6 6 6 6

예제 출력 4

60

예제 입력 5

6
6 0 6 0 6 1
0 0 0 0 0 2
2 3 4 5 6 6
0 0 0 0 0 2
0 2 0 0 0 0
3 9 3 0 0 1

예제 출력 5

48

예제 입력 6

6
1 1 1 1 1 1
2 2 6 2 2 3
2 2 5 2 2 3
2 2 2 4 6 3
0 0 0 0 0 6
0 0 0 0 0 9

예제 출력 6

39

출처

• 문제를 만든 사람: baekjoon
• 데이터를 추가한 사람: djm03178

알고리즘 분류

• 구현
• 그래프 이론
• 그래프 탐색
• 너비 우선 탐색
• 시뮬레이션

문제의 조건을 이해 못해서 해결하는데 엄청 시간이 걸렸다.

특히 맵에 먹을 수 있는 물고기가 여러 마리 일때 조건에서 막혔는데

예제와 글을 계속 읽어보면서 겨우 이해했다.

결론은 거리가 가장 가까운 물고기들 중에서 가장 위쪽에 있으면서 좌측에 있는 물고기를 픽하는 것

이 문제의 설명이 너무 잘되어있는 글이 있어서 첨부한다.

https://www.acmicpc.net/board/view/100687

위의 설명을 구현하기 위해서

1. 상어의 위치에서 BFS 탐색을 통하여 상어가 먹을 수 있는 가장 가까운 물고기의 위치를 저장한다.

(탐색의 방향은 상/좌/우/하)

2. 상어가 먹을 수 있는 물고기의 위치에서 가장 위쪽에 있으면서 좌측에 있는 물고기를 선택한다.

3. 해당 물고기의 위치로 상어를 옮기고 물고기를 제거하며 상어의 크기를 업데이트 해준다.

4. 해당 위치까지 얼마나 걸렸는지 카운트 해준다.

5. 상어가 먹을 수 있는 물고기가 없을 때까지 1 – 4 를 반복한다.

통과된 코드

#include <iostream>
#include <queue>
#include <tuple>

using namespace std;

// 최대 범위 
constexpr int MAX = 20;

// 상/좌/우/하
int dxdy[4][2] = { {-1, 0}, {0, -1}, {0, 1}, {1, 0} };

pair<int, int> Shark; // 상어 크기, 경험치?

tuple<int, int, int> posShark; // 상어의 x, y위치 / 시간

tuple<int, int, int> tempT;

int N, dx, dy;

int map[MAX][MAX]; // 맵

bool eatMap[MAX][MAX]; // 먹을 수 있는 물고기 체크

bool mapCheck[MAX][MAX]; // BFS 방문 체크에 사용

// BFS 탐색, 반환값음 상어의 위치와 시간
tuple<int, int, int> SharkBFS()
{
    queue<tuple<int, int, int>> myQ;

    // 방문처리 초기화
    fill(&mapCheck[0][0], &mapCheck[N - 1][N], false);
    fill(&eatMap[0][0], &eatMap[N - 1][N], false);

    myQ.push(posShark);
    mapCheck[get<0>(posShark)][get<1>(posShark)] = true;

    int dis = 99999;
    while (!myQ.empty()) {
        tempT = myQ.front();
        myQ.pop();

        // 상/하/좌/우를 탐색하기 위한 반복문
        for (int i = 0; i < 4; i++) {
            dx = get<0>(tempT) + dxdy[i][0];
            dy = get<1>(tempT) + dxdy[i][1];

            // 문제의 범위를 벗어나는 경우 => 넘어간다.
            if (dx < 0 || dy < 0 || dx >= N || dy >= N) continue;
            // 이미 방문한 곳 일 경우와 해당 칸의 물고기가 상어보다 클 경우 => 넘어간다.
            if (mapCheck[dx][dy] == true || map[dx][dy] > Shark.first) continue;

            // 상어가 더 크고, 빈 공간이 아니라면 
            if (map[dx][dy] < Shark.first && map[dx][dy] != 0 ) {

                if (get<2>(tempT) + 1 <= dis) {
                    eatMap[dx][dy] = true;
                    dis = get<2>(tempT) + 1;
                }
            }

            mapCheck[dx][dy] = true; // 방문처리
            myQ.push(make_tuple(dx, dy, get<2>(tempT) + 1)); // 탐색 Q에 넣기
        }
    }

    // 먹을 수 있는 물고기들 중에서 
    // 가장 위, 좌측에 있는 물고기를 선택한다.
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            if (eatMap[i][j] == true) {
                Shark.second++;
                map[i][j] = 0;
                if (Shark.first == Shark.second) {
                    Shark.first++;
                    Shark.second = 0;
                }

                return make_tuple(i, j, dis);
            }
        }
    }
    
    // 없다면 기존 상어의 위치를 반환한다.
    return posShark;
}


int main()
{
    ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
    // cin.tie(null); 코드는 cin과 cout의 묶음을 풀어줍니다.
    cin.tie(NULL);
    cout.tie(NULL);

    Shark = make_pair(2, 0);

    cin >> N;
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            cin >> map[i][j];
            if (map[i][j] == 9) { // 상어의 위치를 저장
                posShark = make_tuple(i, j, 0);
                map[i][j] = 0;
            }
        }
    }

    bool check = true;
    while (check) {
        check = false;
        for (int i = 0; i < N && !check; i++) {
            for (int j = 0; j < N && !check; i++) {
                if (map[i][j] >= 1) check = true;
            }
        }

        tempT = SharkBFS();
        
        // BFS 탐색 후에도 상어의 움직임이 없다면 먹을 수 있는 물고기가 없다.
        if (get<2>(tempT) == get<2>(posShark)) break;
        else posShark = tempT;
  
    }

    cout << get<2>(posShark);

	return 0;
}

디버깅

https://www.acmicpc.net/board/view/100687

예제 입력 4

여기서부터는 시뮬레이션이 매우 길기 때문에 디버깅 출력으로 대신하겠습니다.

또한, 가독성을 위해 상어의 위치는 9 대신 “■”, 물고기가 없는 위치는 0 대신 “.” 로 표기했습니다.

5 4 3 2 3 4
4 3 2 3 4 5
3 2 ■ 5 6 6
2 1 2 3 4 5
3 2 1 6 5 4
6 6 6 6 6 6
0s / Lv. 2 (Exp 0 / 2)


5 4 3 2 3 4 
4 3 2 3 4 5 
3 2 . 5 6 6 
2 ■ 2 3 4 5 
3 2 1 6 5 4 
6 6 6 6 6 6 
2s / Lv. 2 (Exp 1 / 2)


5 4 3 2 3 4 
4 3 2 3 4 5 
3 2 . 5 6 6 
2 . 2 3 4 5 
3 2 ■ 6 5 4 
6 6 6 6 6 6 
4s / Lv. 3 (Exp 0 / 3)


5 4 3 2 3 4 
4 3 2 3 4 5 
3 2 . 5 6 6 
2 . ■ 3 4 5 
3 2 . 6 5 4 
6 6 6 6 6 6 
5s / Lv. 3 (Exp 1 / 3)


5 4 3 2 3 4 
4 3 ■ 3 4 5 
3 2 . 5 6 6 
2 . . 3 4 5 
3 2 . 6 5 4 
6 6 6 6 6 6 
7s / Lv. 3 (Exp 2 / 3)


5 4 3 ■ 3 4 
4 3 . 3 4 5 
3 2 . 5 6 6 
2 . . 3 4 5 
3 2 . 6 5 4 
6 6 6 6 6 6 
9s / Lv. 4 (Exp 0 / 4)


5 4 ■ . 3 4 
4 3 . 3 4 5 
3 2 . 5 6 6 
2 . . 3 4 5 
3 2 . 6 5 4 
6 6 6 6 6 6 
10s / Lv. 4 (Exp 1 / 4)


5 4 . . ■ 4 
4 3 . 3 4 5 
3 2 . 5 6 6 
2 . . 3 4 5 
3 2 . 6 5 4 
6 6 6 6 6 6 
12s / Lv. 4 (Exp 2 / 4)


5 4 . . . 4 
4 3 . ■ 4 5 
3 2 . 5 6 6 
2 . . 3 4 5 
3 2 . 6 5 4 
6 6 6 6 6 6 
14s / Lv. 4 (Exp 3 / 4)


5 4 . . . 4 
4 ■ . . 4 5 
3 2 . 5 6 6 
2 . . 3 4 5 
3 2 . 6 5 4 
6 6 6 6 6 6 
16s / Lv. 5 (Exp 0 / 5)


5 ■ . . . 4 
4 . . . 4 5 
3 2 . 5 6 6 
2 . . 3 4 5 
3 2 . 6 5 4 
6 6 6 6 6 6 
17s / Lv. 5 (Exp 1 / 5)


5 . . . . 4 
■ . . . 4 5 
3 2 . 5 6 6 
2 . . 3 4 5 
3 2 . 6 5 4 
6 6 6 6 6 6 
19s / Lv. 5 (Exp 2 / 5)


5 . . . . 4 
. . . . 4 5 
■ 2 . 5 6 6 
2 . . 3 4 5 
3 2 . 6 5 4 
6 6 6 6 6 6 
20s / Lv. 5 (Exp 3 / 5)


5 . . . . 4 
. . . . 4 5 
. ■ . 5 6 6 
2 . . 3 4 5 
3 2 . 6 5 4 
6 6 6 6 6 6 
21s / Lv. 5 (Exp 4 / 5)


5 . . . . 4 
. . . . 4 5 
. . . 5 6 6 
■ . . 3 4 5 
3 2 . 6 5 4 
6 6 6 6 6 6 
23s / Lv. 6 (Exp 0 / 6)


5 . . . . 4 
. . . . 4 5 
. . . 5 6 6 
. . . 3 4 5 
■ 2 . 6 5 4 
6 6 6 6 6 6 
24s / Lv. 6 (Exp 1 / 6)


5 . . . . 4 
. . . . 4 5 
. . . 5 6 6 
. . . 3 4 5 
. ■ . 6 5 4 
6 6 6 6 6 6 
25s / Lv. 6 (Exp 2 / 6)


5 . . . . 4 
. . . . 4 5 
. . . 5 6 6 
. . . ■ 4 5 
. . . 6 5 4 
6 6 6 6 6 6 
28s / Lv. 6 (Exp 3 / 6)


5 . . . . 4 
. . . . 4 5 
. . . ■ 6 6 
. . . . 4 5 
. . . 6 5 4 
6 6 6 6 6 6 
29s / Lv. 6 (Exp 4 / 6)


5 . . . . 4 
. . . . ■ 5 
. . . . 6 6 
. . . . 4 5 
. . . 6 5 4 
6 6 6 6 6 6 
31s / Lv. 6 (Exp 5 / 6)


5 . . . . 4 
. . . . . ■ 
. . . . 6 6 
. . . . 4 5 
. . . 6 5 4 
6 6 6 6 6 6 
32s / Lv. 7 (Exp 0 / 7)


5 . . . . ■ 
. . . . . . 
. . . . 6 6 
. . . . 4 5 
. . . 6 5 4 
6 6 6 6 6 6 
33s / Lv. 7 (Exp 1 / 7)


5 . . . . . 
. . . . . . 
. . . . 6 ■ 
. . . . 4 5 
. . . 6 5 4 
6 6 6 6 6 6 
35s / Lv. 7 (Exp 2 / 7)


5 . . . . . 
. . . . . . 
. . . . ■ . 
. . . . 4 5 
. . . 6 5 4 
6 6 6 6 6 6 
36s / Lv. 7 (Exp 3 / 7)


5 . . . . . 
. . . . . . 
. . . . . . 
. . . . ■ 5 
. . . 6 5 4 
6 6 6 6 6 6 
37s / Lv. 7 (Exp 4 / 7)


5 . . . . . 
. . . . . . 
. . . . . . 
. . . . . ■ 
. . . 6 5 4 
6 6 6 6 6 6 
38s / Lv. 7 (Exp 5 / 7)


5 . . . . . 
. . . . . . 
. . . . . . 
. . . . . . 
. . . 6 5 ■ 
6 6 6 6 6 6 
39s / Lv. 7 (Exp 6 / 7)


5 . . . . . 
. . . . . . 
. . . . . . 
. . . . . . 
. . . 6 ■ . 
6 6 6 6 6 6 
40s / Lv. 8 (Exp 0 / 8)


5 . . . . . 
. . . . . . 
. . . . . . 
. . . . . . 
. . . ■ . . 
6 6 6 6 6 6 
41s / Lv. 8 (Exp 1 / 8)


5 . . . . . 
. . . . . . 
. . . . . . 
. . . . . . 
. . . . . . 
6 6 6 ■ 6 6 
42s / Lv. 8 (Exp 2 / 8)


5 . . . . . 
. . . . . . 
. . . . . . 
. . . . . . 
. . . . . . 
6 6 ■ . 6 6 
43s / Lv. 8 (Exp 3 / 8)


5 . . . . . 
. . . . . . 
. . . . . . 
. . . . . . 
. . . . . . 
6 ■ . . 6 6 
44s / Lv. 8 (Exp 4 / 8)


5 . . . . . 
. . . . . . 
. . . . . . 
. . . . . . 
. . . . . . 
■ . . . 6 6 
45s / Lv. 8 (Exp 5 / 8)


5 . . . . . 
. . . . . . 
. . . . . . 
. . . . . . 
. . . . . . 
. . . . ■ 6 
49s / Lv. 8 (Exp 6 / 8)


5 . . . . . 
. . . . . . 
. . . . . . 
. . . . . . 
. . . . . . 
. . . . . ■ 
50s / Lv. 8 (Exp 7 / 8)


■ . . . . . 
. . . . . . 
. . . . . . 
. . . . . . 
. . . . . . 
. . . . . . 
60s / Lv. 9 (Exp 0 / 9)

따라서 답은 60초입니다.

예제 입력 5

6 . 6 . 6 1
. . . . . 2
2 3 4 5 6 6
. . . . . 2
. 2 . . . .
3 ■ 3 . . 1
0s / Lv. 2 (Exp 0 / 2)


6 . 6 . 6 1 
. . . . . 2 
2 3 4 5 6 6 
. . . . . 2 
. 2 . . . . 
3 . 3 . . ■ 
6s / Lv. 2 (Exp 1 / 2)


6 . 6 . 6 ■ 
. . . . . 2 
2 3 4 5 6 6 
. . . . . 2 
. 2 . . . . 
3 . 3 . . . 
21s / Lv. 3 (Exp 0 / 3)


6 . 6 . 6 . 
. . . . . ■ 
2 3 4 5 6 6 
. . . . . 2 
. 2 . . . . 
3 . 3 . . . 
22s / Lv. 3 (Exp 1 / 3)


6 . 6 . 6 . 
. . . . . . 
■ 3 4 5 6 6 
. . . . . 2 
. 2 . . . . 
3 . 3 . . . 
28s / Lv. 3 (Exp 2 / 3)


6 . 6 . 6 . 
. . . . . . 
. 3 4 5 6 6 
. . . . . 2 
. ■ . . . . 
3 . 3 . . . 
31s / Lv. 4 (Exp 0 / 4)


6 . 6 . 6 . 
. . . . . . 
. ■ 4 5 6 6 
. . . . . 2 
. . . . . . 
3 . 3 . . . 
33s / Lv. 4 (Exp 1 / 4)


6 . 6 . 6 . 
. . . . . . 
. . 4 5 6 6 
. . . . . 2 
. . . . . . 
■ . 3 . . . 
37s / Lv. 4 (Exp 2 / 4)


6 . 6 . 6 . 
. . . . . . 
. . 4 5 6 6 
. . . . . 2 
. . . . . . 
. . ■ . . . 
39s / Lv. 4 (Exp 3 / 4)


6 . 6 . 6 . 
. . . . . . 
. . 4 5 6 6 
. . . . . ■ 
. . . . . . 
. . . . . . 
44s / Lv. 5 (Exp 0 / 5)


6 . 6 . 6 . 
. . . . . . 
. . ■ 5 6 6 
. . . . . . 
. . . . . . 
. . . . . . 
48s / Lv. 5 (Exp 1 / 5)

따라서 답은 48초입니다.

예제 입력 6

1 1 1 1 1 1 
2 2 6 2 2 3 
2 2 5 2 2 3 
2 2 2 4 6 3 
. . . . . 6 
. . . . . ■ 
0s / Lv. 2 (Exp 0 / 2)


1 ■ 1 1 1 1 
2 2 6 2 2 3 
2 2 5 2 2 3 
2 2 2 4 6 3 
. . . . . 6 
. . . . . . 
9s / Lv. 2 (Exp 1 / 2)


■ . 1 1 1 1 
2 2 6 2 2 3 
2 2 5 2 2 3 
2 2 2 4 6 3 
. . . . . 6 
. . . . . . 
10s / Lv. 3 (Exp 0 / 3)


. . 1 1 1 1 
■ 2 6 2 2 3 
2 2 5 2 2 3 
2 2 2 4 6 3 
. . . . . 6 
. . . . . . 
11s / Lv. 3 (Exp 1 / 3)


. . 1 1 1 1 
. ■ 6 2 2 3 
2 2 5 2 2 3 
2 2 2 4 6 3 
. . . . . 6 
. . . . . . 
12s / Lv. 3 (Exp 2 / 3)


. . 1 1 1 1 
. . 6 2 2 3 
2 ■ 5 2 2 3 
2 2 2 4 6 3 
. . . . . 6 
. . . . . . 
13s / Lv. 4 (Exp 0 / 4)


. . 1 1 1 1 
. . 6 2 2 3 
■ . 5 2 2 3 
2 2 2 4 6 3 
. . . . . 6 
. . . . . . 
14s / Lv. 4 (Exp 1 / 4)


. . 1 1 1 1 
. . 6 2 2 3 
. . 5 2 2 3 
■ 2 2 4 6 3 
. . . . . 6 
. . . . . . 
15s / Lv. 4 (Exp 2 / 4)


. . 1 1 1 1 
. . 6 2 2 3 
. . 5 2 2 3 
. ■ 2 4 6 3 
. . . . . 6 
. . . . . . 
16s / Lv. 4 (Exp 3 / 4)


. . 1 1 1 1 
. . 6 2 2 3 
. . 5 2 2 3 
. . ■ 4 6 3 
. . . . . 6 
. . . . . . 
17s / Lv. 5 (Exp 0 / 5)


. . 1 1 1 1 
. . 6 2 2 3 
. . 5 2 2 3 
. . . ■ 6 3 
. . . . . 6 
. . . . . . 
18s / Lv. 5 (Exp 1 / 5)


. . 1 1 1 1 
. . 6 2 2 3 
. . 5 ■ 2 3 
. . . . 6 3 
. . . . . 6 
. . . . . . 
19s / Lv. 5 (Exp 2 / 5)


. . 1 1 1 1 
. . 6 ■ 2 3 
. . 5 . 2 3 
. . . . 6 3 
. . . . . 6 
. . . . . . 
20s / Lv. 5 (Exp 3 / 5)


. . 1 ■ 1 1 
. . 6 . 2 3 
. . 5 . 2 3 
. . . . 6 3 
. . . . . 6 
. . . . . . 
21s / Lv. 5 (Exp 4 / 5)


. . ■ . 1 1 
. . 6 . 2 3 
. . 5 . 2 3 
. . . . 6 3 
. . . . . 6 
. . . . . . 
22s / Lv. 6 (Exp 0 / 6)


. . . . ■ 1 
. . 6 . 2 3 
. . 5 . 2 3 
. . . . 6 3 
. . . . . 6 
. . . . . . 
24s / Lv. 6 (Exp 1 / 6)


. . . . . ■ 
. . 6 . 2 3 
. . 5 . 2 3 
. . . . 6 3 
. . . . . 6 
. . . . . . 
25s / Lv. 6 (Exp 2 / 6)


. . . . . . 
. . 6 . 2 ■ 
. . 5 . 2 3 
. . . . 6 3 
. . . . . 6 
. . . . . . 
26s / Lv. 6 (Exp 3 / 6)


. . . . . . 
. . 6 . ■ . 
. . 5 . 2 3 
. . . . 6 3 
. . . . . 6 
. . . . . . 
27s / Lv. 6 (Exp 4 / 6)


. . . . . . 
. . 6 . . . 
. . 5 . ■ 3 
. . . . 6 3 
. . . . . 6 
. . . . . . 
28s / Lv. 6 (Exp 5 / 6)


. . . . . . 
. . 6 . . . 
. . 5 . . ■ 
. . . . 6 3 
. . . . . 6 
. . . . . . 
29s / Lv. 7 (Exp 0 / 7)


. . . . . . 
. . 6 . . . 
. . 5 . . . 
. . . . 6 ■ 
. . . . . 6 
. . . . . . 
30s / Lv. 7 (Exp 1 / 7)


. . . . . . 
. . 6 . . . 
. . 5 . . . 
. . . . ■ . 
. . . . . 6 
. . . . . . 
31s / Lv. 7 (Exp 2 / 7)


. . . . . . 
. . 6 . . . 
. . 5 . . . 
. . . . . . 
. . . . . ■ 
. . . . . . 
33s / Lv. 7 (Exp 3 / 7)


. . . . . . 
. . 6 . . . 
. . ■ . . . 
. . . . . . 
. . . . . . 
. . . . . . 
38s / Lv. 7 (Exp 4 / 7)


. . . . . . 
. . ■ . . . 
. . . . . . 
. . . . . . 
. . . . . . 
. . . . . . 
39s / Lv. 7 (Exp 5 / 7)

따라서 답은 39초입니다.

The post 백준 16236번 (아기 상어, C++, Simulation) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

미네랄 2

https://www.acmicpc.net/problem/18500

문제

창영과 상근은 한 동굴을 놓고 소유권을 주장하고 있다.

두 사람은 막대기를 서로에게 던지는 방법을 이용해 누구의 소유 인지를 결정하기로 했다.

싸움은 동굴에서 벌어진다. 동굴에는 미네랄이 저장되어 있으며, 던진 막대기가 미네랄을 파괴할 수도 있다.

동굴은 R행 C열로 나타낼 수 있으며, R×C칸으로 이루어져 있다.

각 칸은 비어있거나 미네랄을 포함하고 있으며, 네 방향 중 하나로 인접한 미네랄이 포함된 두 칸은 같은 클러스터이다.

창영은 동굴의 왼쪽에 서있고, 상근은 오른쪽에 서있다. 두 사람은 턴을 번갈아가며 막대기를 던진다.

막대를 던지기 전에 던질 높이를 정해야 한다. 막대는 땅과 수평을 이루며 날아간다.

막대가 날아가다가 미네랄을 만나면, 그 칸에 있는 미네랄은 모두 파괴되고 막대는 그 자리에서 이동을 멈춘다.

미네랄이 파괴된 이후에 남은 클러스터가 분리될 수도 있다.

새롭게 생성된 클러스터가 떠 있는 경우에는 중력에 의해서 바닥으로 떨어지게 된다.

떨어지는 동안 클러스터의 모양은 변하지 않는다. 클러스터는 다른 클러스터나 땅을 만나기 전까지 계속해서 떨어진다.

클러스터는 다른 클러스터 위에 떨어질 수 있고, 그 이후에는 합쳐지게 된다.

동굴에 있는 미네랄의 모양과 두 사람이 던진 막대의 높이가 주어진다.

모든 막대를 던지고 난 이후에 미네랄 모양을 구하는 프로그램을 작성하시오.

입력

첫째 줄에 동굴의 크기 R과 C가 주어진다. (1 ≤ R,C ≤ 100)

다음 R개 줄에는 C개의 문자가 주어지며, ‘.’는 빈 칸, ‘x’는 미네랄을 나타낸다.

다음 줄에는 막대를 던진 횟수 N이 주어진다. (1 ≤ N ≤ 100)

마지막 줄에는 막대를 던진 높이가 주어지며, 공백으로 구분되어져 있다.

모든 높이는 1과 R사이이며, 높이 1은 행렬의 가장 바닥, R은 가장 위를 의미한다.

첫 번째 막대는 왼쪽에서 오른쪽으로 던졌으며, 두 번째는 오른쪽에서 왼쪽으로, 이와 같은 식으로 번갈아가며 던진다.

공중에 떠 있는 미네랄 클러스터는 없으며, 두 개 또는 그 이상의 클러스터가 동시에 떨어지는 경우도 없다.

클러스터가 떨어질 때, 그 클러스터 각 열의 맨 아래 부분 중 하나가 바닥 또는 미네랄 위로 떨어지는 입력만 주어진다.

(2933번 문제와 차이)

출력

입력 형식과 같은 형식으로 미네랄 모양을 출력한다.

예제 입력 1

5 6
......
..xx..
..x...
..xx..
.xxxx.
1
3

예제 출력 1

......
......
..xx..
..xx..
.xxxx.

예제 입력 2

8 8
........
........
...x.xx.
...xxx..
..xxx...
..x.xxx.
..x...x.
.xxx..x.
5
6 6 4 3 1

예제 출력 2

........
........
........
........
.....x..
..xxxx..
..xxx.x.
..xxxxx.

예제 입력 3

7 6
......
......
xx....
.xx...
..xx..
...xx.
....x.
2
6 4

예제 출력 3

......
......
......
......
..xx..
xx.xx.
.x..x.

예제 입력 A

13 100
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
..................................................x................................................x
..................................................x................................................x
..................................................x.................................................
..................................................x.................................................
..................................................x.................................................
..................................................x.................................................
..................................................x.................................................
..................................................x.................................................
..................................................x.................................................
..................................................x.................................................
..................................................x.................................................
..................................................x.................................................
11 
1 1 1 1 1 1 1 1 1 1 1 

예제 출력 A

....................................................................................................
....................................................................................................
....................................................................................................
....................................................................................................
....................................................................................................
....................................................................................................
....................................................................................................
....................................................................................................
....................................................................................................
....................................................................................................
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
..................................................x................................................x
...................................................................................................x

예제 입력 B

9 8
........
...xxx..
.xxx....
.x.x.xxx
.x.x...x
.x.xxx.x
.x.....x
.x.....x
.xxx...x
1
7

예제 출력 B

........
........
...xxx..
.xxx.xxx
.x.x...x
.x.x...x
.x.xxx.x
.x.....x
.xxx...x

예제 입력 C

4 4
xxxx
xx.x
x..x
...x
1
3

예제 출력 C

xxxx
.x.x
...x
x..x

예제 입력 D

7 5
.....
.xxx.
.x...
xx.xx
x...x
x...x
x...x
1
4

예제 출력 D

.....
.....
.xxx.
.x.xx
xx..x
x...x
x...x

예제 입력 E

2 2
..
.x
1
2

예제 출력 E

..
.x

예제 입력 F

5 5
xxxxx
x....
xxxxx
x....
x....
10 1 2 3 4 5 1 2 3 4 5

예제 출력 F

.....
.....
.....
.xxxx
xxxx.

예제 입력 G

10 10
xxxxxxxxxx
....x.....
...xxx....
.....x....
....xx....
.....x....
xxxxxx....
..x.......
.xxxx.....
...xxxxxxx
10 9 8 7 6 5 4 3 2 1 1

예제 출력 G

..........
..........
..........
..........
..........
..........
xxxxxxxxxx
....xx....
xxxxxx....
.xxxxxxxx.

예제 입력 H

4 4
...x
..xx
.xxx
xxxx
10 1 2 3 4 1 2 3 4 3 4

예제 출력 H

....
....
.xxx
..xx

예제 입력 I

10 20
..xxxxxxxxxxxxxxx...
..x.............x...
..x.............x...
..x.............x...
..x.............x...
..x.............x...
..x.............x...
..xxxxxx........x...
................x...
x...............x...
2
1 7

예제 출력 I

....................
..xxxxxxxxxxxxxxx...
..x.............x...
..x.............x...
..x.............x...
..x.............x...
..x.............x...
..x.............x...
..xxxxxx........x...
................x...

예제 입력 J

9 8
........
.xxxx...
.x......
.x.xxxx.
.x....x.
.x....x.
.xxxx.x.
....xxx.
......x.
1
2

예제 출력 J

........
........
.xxxx...
.x.xxxx.
.x....x.
.x....x.
.x....x.
.xxxxxx.
......x.

출처

Olympiad > Croatian Highschool Competitions in Informatics > 2009 > Croatian Regional Competition in Informatics 2009 5번

Olympiad > Croatian Highschool Competitions in Informatics > 2009 > Regional Competition – Juniors 4번

• 데이터를 추가한 사람: heize

알고리즘 분류

• 구현
• 그래프 이론
• 그래프 탐색
• 너비 우선 탐색
• 시뮬레이션

통과된 코드

나는 2933번을 해결할 때 공중에 있는 미네랄 리스트의 하단부를 전부 확인하는 방법으로 구현해서 다른 것이 없다.

골드 2 문제를 해결하니 골드 1을 같이 주네?? 개꿀

#include <iostream>
#include <list>
#include <queue>

using namespace std;

// RC의 범위 최대값
constexpr int MAX = 101;

// 기본 맵
char map[MAX][MAX];

// 방문처리 
bool mapCheck[MAX][MAX];

// BFS 사용할 Q
queue<pair<int, int>> myQ;

pair<int, int> tempP;

// R 행, C 열, N 막대기를 던진 횟수
int R, C, N;

int dx, dy, dis;

int temp = 0;

// 탐색하는 방향 설정 =>  상, 하 ,좌 ,우
int dxdy[4][2] = { {-1, 0}, {1, 0}, {0, -1}, {0, 1} };


list<int> myList;
list<int>::iterator it;

list<pair<int, int>> cList;
list<pair<int, int>>::iterator cit;

// true = left, false = right
bool check = false, leftRight = false;

void BFS(int x, int y)
{
	myQ.push(make_pair(x, y));

	while (!myQ.empty()) {
		tempP = myQ.front();
		myQ.pop();

		for (int i = 0; i < 4; i++) {
			dy = tempP.second + dxdy[i][1];
			dx = tempP.first + dxdy[i][0];
			// 문제의 범위를 벗어나는 경우 => 넘어간다.
			if (dx <= 0 || dy <= 0 || dy > C || dx > R) continue;
			// 방문 처리가 되었거나 빈공간 => 넘어간다.
			if (mapCheck[dx][dy] == true || map[dx][dy] == '.') continue;
			mapCheck[dx][dy] = true;
			myQ.push(make_pair(dx, dy));
		}
	}
}

void CheckFloor() // 바닥을 체크합니다.
{
	for (int y = 1; y <= C; y++) {
		// 바닥에 클러스터가 발견되고 방문처리가 되지 않았다면 
		if (map[1][y] == 'x' && mapCheck[1][y] == false) {
			BFS(1, y); // BFS로 마킹
		}
	}
}

int main()
{
	ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
	// cin.tie(null); 코드는 cin과 cout의 묶음을 풀어줍니다.
	cin.tie(NULL);
	cout.tie(NULL);

	// 처음 맵을 초기화 해준다.
	for (int x = 1; x < MAX; x++) {
		for (int y = 1; y < MAX; y++) {
			map[x][y] = '.';
		}
	}

	cin >> R >> C;

	// 미네랄의 위치를 설정 (아래서 부터 시작)
	for (int x = R; x >= 1; x--) {
		for (int y = 1; y <= C; y++) {
			cin >> map[x][y];
		}
	}

	cin >> N;

	/// 던진 횟수와 높이를 설정
	while (N > 0) {
		cin >> temp;
		myList.push_back(temp);
		N--;
	}

	// 던진 막대기 리스트를 순회합니다.
	for (it = myList.begin(); it != myList.end(); it++) {

		check = false; // 미네랄 부셔짐 체크 해제
		cList.clear(); // 공중의 미네랄 리스트 초기화

		// 해당 위치에 미네랄이 있는지 검색합니다.
		if (leftRight) { // 좌측 검색
			for (int y = C; y >= 1; y--) {
				// 만약 미네랄이 있다면
				if (map[*it][y] == 'x') {
					// 해당 미네랄을 빈 공간으로 만든다.
					map[*it][y] = '.';
					// 바닥과 연결된 모든 클러스터를 방문처리
					CheckFloor();
					check = true;
					break;
				}
			}

			leftRight = !leftRight;
		}
		else { // 우측 검색
			for (int y = 1; y <= C; y++) {
				// 만약 미네랄이 있다면
				if (map[*it][y] == 'x') {
					// 해당 미네랄을 빈 공간으로 만든다.
					map[*it][y] = '.';
					// 바닥과 연결된 모든 클러스터를 방문처리
					CheckFloor();
					check = true;
					break;
				}
			}

			leftRight = !leftRight;
		}

		if (check) {  // 미네랄이 부셔졌다면
			// 공중에 있는 클러스트들을 리스트에 담는다.
			for (int x = R; x >= 1; x--) {
				for (int y = C; y >= 1; y--) {
					if (map[x][y] == 'x' && mapCheck[x][y] == false) {
						cList.push_back(make_pair(x, y));
					}
				}
			}

			// 공중에 미네랄이 바닥과 연결될때까지 반복
			dis = 1;
			bool floor = true;
			while (floor) {

				if (cList.size() == 0) break;

				for (cit = cList.begin(); cit != cList.end(); cit++) {
					tempP.first = cit->first;
					tempP.second = cit->second;

					if (mapCheck[tempP.first - (dis + 1)][tempP.second] == true || tempP.first - (dis + 1) == 0) {
						floor = false;
						break;
					}
				}

				dis++;
			}

			if (!floor) {
				for (cit = cList.begin(); cit != cList.end(); cit++) {
					tempP.first = cit->first;
					tempP.second = cit->second;
					map[tempP.first][tempP.second] = '.';
				}

				for (cit = cList.begin(); cit != cList.end(); cit++) {
					tempP.first = cit->first;
					tempP.second = cit->second;
					map[tempP.first - (dis - 1)][tempP.second] = 'x';
				}	
			}

			// 방문 처리를 초기화 
			for (int x = R; x >= 1; x--) {
				for (int y = 1; y <= C; y++) {
					mapCheck[x][y] = false;
				}
			}
		}
	}

	for (int x = R; x >= 1; x--) {
		for (int y = 1; y <= C; y++) {
			cout << map[x][y];
		}
		if (x == 1) break;
		cout << "\n";
	}

	return 0;

}

The post 백준 18500번 (미네랄 2, C++, Simulation) / 추가 반례 [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

미네랄

https://www.acmicpc.net/problem/2933

문제

창영과 상근은 한 동굴을 놓고 소유권을 주장하고 있다.

두 사람은 막대기를 서로에게 던지는 방법을 이용해 누구의 소유 인지를 결정하기로 했다.

싸움은 동굴에서 벌어진다. 동굴에는 미네랄이 저장되어 있으며, 던진 막대기가 미네랄을 파괴할 수도 있다.

동굴은 R행 C열로 나타낼 수 있으며, R×C칸으로 이루어져 있다.

각 칸은 비어있거나 미네랄을 포함하고 있으며, 네 방향 중 하나로 인접한 미네랄이 포함된 두 칸은 같은 클러스터이다.

창영은 동굴의 왼쪽에 서있고, 상근은 오른쪽에 서있다. 두 사람은 턴을 번갈아가며 막대기를 던진다.

막대를 던지기 전에 던질 높이를 정해야 한다. 막대는 땅과 수평을 이루며 날아간다.

막대가 날아가다가 미네랄을 만나면, 그 칸에 있는 미네랄은 모두 파괴되고 막대는 그 자리에서 이동을 멈춘다.

미네랄이 파괴된 이후에 남은 클러스터가 분리될 수도 있다.

새롭게 생성된 클러스터가 떠 있는 경우에는 중력에 의해서 바닥으로 떨어지게 된다.

떨어지는 동안 클러스터의 모양은 변하지 않는다. 클러스터는 다른 클러스터나 땅을 만나기 전까지 계속해서 떨어진다.

클러스터는 다른 클러스터 위에 떨어질 수 있고, 그 이후에는 합쳐지게 된다.

동굴에 있는 미네랄의 모양과 두 사람이 던진 막대의 높이가 주어진다.

모든 막대를 던지고 난 이후에 미네랄 모양을 구하는 프로그램을 작성하시오.

입력

첫째 줄에 동굴의 크기 R과 C가 주어진다. (1 ≤ R,C ≤ 100)

다음 R개 줄에는 C개의 문자가 주어지며, ‘.’는 빈 칸, ‘x’는 미네랄을 나타낸다.

다음 줄에는 막대를 던진 횟수 N이 주어진다. (1 ≤ N ≤ 100)

마지막 줄에는 막대를 던진 높이가 주어지며, 공백으로 구분되어져 있다.

모든 높이는 1과 R사이이며, 높이 1은 행렬의 가장 바닥, R은 가장 위를 의미한다.

첫 번째 막대는 왼쪽에서 오른쪽으로 던졌으며, 두 번째는 오른쪽에서 왼쪽으로, 이와 같은 식으로 번갈아가며 던진다.

공중에 떠 있는 미네랄 클러스터는 없으며, 두 개 또는 그 이상의 클러스터가 동시에 떨어지는 경우도 없다.

클러스터가 떨어질 때, 그 클러스터 각 열의 맨 아래 부분 중 하나가 바닥 또는 미네랄 위로 떨어지는 입력만 주어진다.

출력

입력 형식과 같은 형식으로 미네랄 모양을 출력한다.

예제 입력 1

5 6
......
..xx..
..x...
..xx..
.xxxx.
1
3

예제 출력 1

......
......
..xx..
..xx..
.xxxx.

예제 입력 2

8 8
........
........
...x.xx.
...xxx..
..xxx...
..x.xxx.
..x...x.
.xxx..x.
5
6 6 4 3 1

예제 출력 2

........
........
........
........
.....x..
..xxxx..
..xxx.x.
..xxxxx.

예제 입력 3

7 6
......
......
xx....
.xx...
..xx..
...xx.
....x.
2
6 4

예제 출력 3

......
......
......
......
..xx..
xx.xx.
.x..x.

예제 입력 A

13 100
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
..................................................x................................................x
..................................................x................................................x
..................................................x.................................................
..................................................x.................................................
..................................................x.................................................
..................................................x.................................................
..................................................x.................................................
..................................................x.................................................
..................................................x.................................................
..................................................x.................................................
..................................................x.................................................
..................................................x.................................................
11 
1 1 1 1 1 1 1 1 1 1 1 

예제 출력 A

....................................................................................................
....................................................................................................
....................................................................................................
....................................................................................................
....................................................................................................
....................................................................................................
....................................................................................................
....................................................................................................
....................................................................................................
....................................................................................................
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
..................................................x................................................x
...................................................................................................x

예제 입력 B

4 4
xxxx
xx.x
x..x
...x
1
3

예제 출력 B

xxxx
.x.x
...x
x..x

예제 입력 C

2 2
..
.x
1
2

예제 출력 C

..
.x

예제 입력 D

5 5
xxxxx
x....
xxxxx
x....
x....
10 1 2 3 4 5 1 2 3 4 5

예제 출력 D

.....
.....
.....
.xxxx
xxxx.

예제 입력 E

4 4
...x
..xx
.xxx
xxxx
10 1 2 3 4 1 2 3 4 3 4

예제 출력 E

....
....
.xxx
..xx

출처

• 문제를 번역한 사람: baekjoon
• 잘못된 조건을 찾은 사람: jh05013
• 어색한 표현을 찾은 사람: porrshe

알고리즘 분류

• 구현
• 그래프 이론
• 그래프 탐색
• 너비 우선 탐색
• 시뮬레이션

첫째 줄에 동굴의 크기 R과 C (1 ≤ R,C ≤ 100)

다음 R개 줄에는 C개의 문자가 주어지며, ‘.’는 빈 칸, ‘x’는 미네랄을 나타낸다.

다음 줄에는 막대를 던진 횟수 N이 주어진다. (1 ≤ N ≤ 100)

모든 높이는 1과 R사이이며, 높이 1은 행렬의 가장 바닥, R은 가장 위를 의미한다.

공중에 떠 있는 미네랄 클러스터는 없으며, 두 개 또는 그 이상의 클러스터가 동시에 떨어지는 경우도 없다.

클러스터가 떨어질 때, 그 클러스터 각 열의 맨 아래 부분 중 하나가 바닥 또는 미네랄 위로 떨어지는 입력만 주어진다.

예제 1

예제 2

예제 3

이번에도 문제를 이해하는 것이 오래 걸렸다.. 일단 글을 읽으면 머리 속에서 잘 정리가 되지 않는다.

한 3~4 번을 다시 글을 읽은 후에야 어느 정도 이해를 하는 듯….

일단 동굴을 코드로 구현해보자

#include<iostream>
#include<list>

using namespace std;

// RC의 범위 최대값
constexpr int MAX = 101;

// 기본 맵
char map[MAX][MAX];

// R 행, C 열, N 막대기를 던진 횟수
int R, C, N;

int temp = 0;


list<int> myList;
list<int>::iterator it;

bool debug = true;

int main()
{
	ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
	// cin.tie(null); 코드는 cin과 cout의 묶음을 풀어줍니다.
	cin.tie(NULL);
	cout.tie(NULL);

	// 처음 맵을 초기화 해준다.
	for (int x = 1; x < MAX; x++) {
		for (int y = 1; y < MAX; y++) {
			map[x][y] = '.';
		}
	}

	cin >> R >> C;

	// 미네랄의 위치를 설정 (아래서 부터 시작)
	for (int x = R; x >= 1; x--) {
		for (int y = 1; y <= C; y++) {
			cin >> map[x][y];
		}
	}

	cin >> N;

	/// 던진 횟수와 높이를 설정
	while (N > 0){
		cin >> temp;
		myList.push_back(temp);
		N--;
	}

	if (debug) {
		for (int x = R; x >= 1; x--) {
			for (int y = 1; y <= C; y++) {
				cout << map[x][y] << " ";
			}
			cout << "\n";
		}
		cout << "\n던진 막대기 높이 리스트\n";
		for (it = myList.begin(); it != myList.end(); it++) cout << *it << " ";
	}
	return 0;
}

다행히 생각대로 잘나온다.

이제 막대기를 던져서 해당 위치의 미네랄을 파괴하는 것까지 구현

#include<iostream>
#include<list>

using namespace std;

// RC의 범위 최대값
constexpr int MAX = 101;

// 기본 맵
char map[MAX][MAX];

// R 행, C 열, N 막대기를 던진 횟수
int R, C, N;

int temp = 0;


list<int> myList;
list<int>::iterator it;

bool debug = true;

int main()
{
	ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
	// cin.tie(null); 코드는 cin과 cout의 묶음을 풀어줍니다.
	cin.tie(NULL);
	cout.tie(NULL);

	// 처음 맵을 초기화 해준다.
	for (int x = 1; x < MAX; x++) {
		for (int y = 1; y < MAX; y++) {
			map[x][y] = '.';
		}
	}

	cin >> R >> C;

	// 미네랄의 위치를 설정 (아래서 부터 시작)
	for (int x = R; x >= 1; x--) {
		for (int y = 1; y <= C; y++) {
			cin >> map[x][y];
		}
	}

	cin >> N;

	/// 던진 횟수와 높이를 설정
	while (N > 0) {
		cin >> temp;
		myList.push_back(temp);
		N--;
	}

	// 던진 막대기 리스트를 순회합니다.
	for (it = myList.begin(); it != myList.end(); it++) {
		// 해당 위치에 미네랄이 있는지 검색합니다.
		// 일단은 좌->우 검색
		for (int x = 1; x <= C; x++) {
			// 만약 미네랄이 있다면
			if (map[*it][x] == 'x') {
				cout << "\n찾음\n";
				// 해당 미네랄을 빈 공간
				map[*it][x] = '.';
				break;
			}
		}
	}




	if (debug) {
		for (int x = R; x >= 1; x--) {
			for (int y = 1; y <= C; y++) {
				cout << map[x][y] << " ";
			}
			cout << "\n";
		}
		cout << "\n던진 막대기 높이 리스트\n";
		for (it = myList.begin(); it != myList.end(); it++) cout << *it << " ";
	}
	return 0;
}

이제 좌/우에서 던지는 것을 구현해야 한다.

2가지 경우 좌/우 이므로 bool 값으로 체크해서 막대기를 던지는 것을 구현하였다.

#include<iostream>
#include<list>

using namespace std;

// RC의 범위 최대값
constexpr int MAX = 101;

// 기본 맵
char map[MAX][MAX];

// R 행, C 열, N 막대기를 던진 횟수
int R, C, N;

int temp = 0;


list<int> myList;
list<int>::iterator it;

// true = left, false = right
bool leftRight = true;

bool debug = true;

int main()
{
	ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
	// cin.tie(null); 코드는 cin과 cout의 묶음을 풀어줍니다.
	cin.tie(NULL);
	cout.tie(NULL);

	// 처음 맵을 초기화 해준다.
	for (int x = 1; x < MAX; x++) {
		for (int y = 1; y < MAX; y++) {
			map[x][y] = '.';
		}
	}

	cin >> R >> C;

	// 미네랄의 위치를 설정 (아래서 부터 시작)
	for (int x = R; x >= 1; x--) {
		for (int y = 1; y <= C; y++) {
			cin >> map[x][y];
		}
	}

	cin >> N;

	/// 던진 횟수와 높이를 설정
	while (N > 0) {
		cin >> temp;
		myList.push_back(temp);
		N--;
	}

	// 던진 막대기 리스트를 순회합니다.
	for (it = myList.begin(); it != myList.end(); it++) {
		
		// 해당 위치에 미네랄이 있는지 검색합니다.
		// 일단은 좌->우 검색
		if (leftRight) { // 좌측 검색
			for (int y = 1; y <= C; y++) {
				// 만약 미네랄이 있다면
				if (map[*it][y] == 'x') {
					cout << "\n찾음\n";
					// 해당 미네랄을 빈 공간
					map[*it][y] = '.';
					break;
				}
			}
			leftRight = !leftRight;
		}
		else { // 우측 검색
			for (int y = C; y >= 1; y--) {
				// 만약 미네랄이 있다면
				if (map[*it][y] == 'x') {
					cout << "\n찾음\n";
					// 해당 미네랄을 빈 공간
					map[*it][y] = '.';
					break;
				}
			}
			leftRight = !leftRight;
		}

	}

	if (debug) {
		for (int x = R; x >= 1; x--) {
			for (int y = 1; y <= C; y++) {
				cout << map[x][y] << " ";
			}
			cout << "\n";
		}
		cout << "\n던진 막대기 높이 리스트\n";
		for (it = myList.begin(); it != myList.end(); it++) cout << *it << " ";
	}
	return 0;
}

생각대로 미네랄이 잘 파괴가 되는 것 같다.

이제 미네랄이 파괴 되었을 경우 여기서 말하는 클러스터(상하좌우가 연결된 미네랄 덩이)가

공중에 떠있지 못하게 하기만 하면 끝일 것 같은데…. 방법이 문제다.

미네랄이 파괴되면 바닥과 연결된 미네랄을 모두 마킹해 주었다.

#include <iostream>
#include <list>
#include <queue>

using namespace std;

// RC의 범위 최대값
constexpr int MAX = 101;

// 기본 맵
char map[MAX][MAX];

// 방문처리 
bool mapCheck[MAX][MAX];

// BFS 사용할 Q
queue<pair<int, int>> myQ;

pair<int, int> tempP;

// R 행, C 열, N 막대기를 던진 횟수
int R, C, N;

int dx, dy;

int temp = 0;

// 탐색하는 방향 설정 =>  상, 하 ,좌 ,우
int dxdy[4][2] = { {-1, 0}, {1, 0}, {0, -1}, {0, 1} };


list<int> myList;
list<int>::iterator it;

// true = left, false = right
bool check = false, leftRight = true;

bool debug = true;

void BFS(int x, int y)
{
	myQ.push(make_pair(x, y));

	while (!myQ.empty()) {
		tempP = myQ.front();
		myQ.pop();

		for (int i = 0; i < 4; i++) {
			dy = tempP.second + dxdy[i][1];
			dx = tempP.first + dxdy[i][0];
			// 문제의 범위를 벗어나는 경우 => 넘어간다.
			if (dx <= 0 || dy <= 0 || dx > C || dy > R) continue;  // <= 범위 틀림 기록용으로 남겨둠
			// 방문 처리가 되었거나 빈공간 => 넘어간다.
			if (mapCheck[dx][dy] == true || map[dx][dy] == '.') continue;
			mapCheck[dx][dy] = true;
			myQ.push(make_pair(dx, dy));
		}
	}

}

void CheckFloor() // 바닥을 체크합니다.
{
	for (int y = 1; y <= C; y++) {
		// 바닥에 클러스터가 발견되고 방문처리가 되지 않았다면 
		if (map[1][y] == 'x' && mapCheck[1][y] == false) {
			BFS(1, y); // BFS로 마킹
		}
	}
}

int main()
{
	ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
	// cin.tie(null); 코드는 cin과 cout의 묶음을 풀어줍니다.
	cin.tie(NULL);
	cout.tie(NULL);

	// 처음 맵을 초기화 해준다.
	for (int x = 1; x < MAX; x++) {
		for (int y = 1; y < MAX; y++) {
			map[x][y] = '.';
		}
	}

	cin >> R >> C;

	// 미네랄의 위치를 설정 (아래서 부터 시작)
	for (int x = R; x >= 1; x--) {
		for (int y = 1; y <= C; y++) {
			cin >> map[x][y];
		}
	}

	cin >> N;

	/// 던진 횟수와 높이를 설정
	while (N > 0) {
		cin >> temp;
		myList.push_back(temp);
		N--;
	}

	// 던진 막대기 리스트를 순회합니다.
	for (it = myList.begin(); it != myList.end(); it++) {
		
		// 해당 위치에 미네랄이 있는지 검색합니다.
		// 일단은 좌->우 검색
		if (leftRight) { // 좌측 검색
			for (int y = 1; y <= C; y++) {
				// 만약 미네랄이 있다면
				if (map[*it][y] == 'x') {
					// 해당 미네랄을 빈 공간으로 만든다.
					map[*it][y] = '.';
					// 바닥과 연결된 모든 클러스터를 방문처리
					CheckFloor();
					check = true;
					break;

				}
			}

			leftRight = !leftRight;
		}
		else { // 우측 검색
			for (int y = C; y >= 1; y--) {
				// 만약 미네랄이 있다면
				if (map[*it][y] == 'x') {
					// 해당 미네랄을 빈 공간으로 만든다.
					map[*it][y] = '.';
					// 바닥과 연결된 모든 클러스터를 방문처리
					CheckFloor();
					check = true;
					break;
				}
			}

			leftRight = !leftRight;
		}

		if (check) {  // 미네랄이 부셔졌다면 방문처리 초기화
			// 방문 처리를 초기화 
			for (int x = R; x >= 1; x--) {
				for (int y = 1; y <= C; y++) {
					mapCheck[x][y] = false;
				}
			}
			check = false;
		}

	}

	if (debug) {

		for (int x = R; x >= 1; x--) {
			for (int y = 1; y <= C; y++) {
				cout << map[x][y] << " ";
			}
			cout << "\n";
		}
		cout << "\n던진 막대기 높이 리스트\n";
		for (it = myList.begin(); it != myList.end(); it++) cout << *it << " ";
	}

	return 0;

}

이제 공중에 있는 클러스터들의 좌표들을 저장하는 리스트를 만들고 확인

#include <iostream>
#include <list>
#include <queue>

using namespace std;

// RC의 범위 최대값
constexpr int MAX = 101;

// 기본 맵
char map[MAX][MAX];

// 방문처리 
bool mapCheck[MAX][MAX];

// BFS 사용할 Q
queue<pair<int, int>> myQ;

pair<int, int> tempP;

// R 행, C 열, N 막대기를 던진 횟수
int R, C, N;

int dx, dy;

int temp = 0;

// 탐색하는 방향 설정 =>  상, 하 ,좌 ,우
int dxdy[4][2] = { {-1, 0}, {1, 0}, {0, -1}, {0, 1} };


list<int> myList;
list<int>::iterator it;

list<pair<int, int>> cList;
list<pair<int, int>>::iterator cit;

// true = left, false = right
bool check = false, leftRight = true;

bool debug = true;

void BFS(int x, int y)
{
	myQ.push(make_pair(x, y));

	while (!myQ.empty()) {
		tempP = myQ.front();
		myQ.pop();

		for (int i = 0; i < 4; i++) {
			dy = tempP.second + dxdy[i][1];
			dx = tempP.first + dxdy[i][0];
			// 문제의 범위를 벗어나는 경우 => 넘어간다.
			if (dx <= 0 || dy <= 0 || dx > C || dy > R) continue; // <= 범위 틀림 기록용으로 남겨둠
			// 방문 처리가 되었거나 빈공간 => 넘어간다.
			if (mapCheck[dx][dy] == true || map[dx][dy] == '.') continue;
			mapCheck[dx][dy] = true;
			myQ.push(make_pair(dx, dy));
		}
	}

}

void CheckFloor() // 바닥을 체크합니다.
{
	for (int y = 1; y <= C; y++) {
		// 바닥에 클러스터가 발견되고 방문처리가 되지 않았다면 
		if (map[1][y] == 'x' && mapCheck[1][y] == false) {
			BFS(1, y); // BFS로 마킹
		}
	}
}

int main()
{
	ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
	// cin.tie(null); 코드는 cin과 cout의 묶음을 풀어줍니다.
	cin.tie(NULL);
	cout.tie(NULL);

	// 처음 맵을 초기화 해준다.
	for (int x = 1; x < MAX; x++) {
		for (int y = 1; y < MAX; y++) {
			map[x][y] = '.';
		}
	}

	cin >> R >> C;

	// 미네랄의 위치를 설정 (아래서 부터 시작)
	for (int x = R; x >= 1; x--) {
		for (int y = 1; y <= C; y++) {
			cin >> map[x][y];
		}
	}

	cin >> N;

	/// 던진 횟수와 높이를 설정
	while (N > 0) {
		cin >> temp;
		myList.push_back(temp);
		N--;
	}

	// 던진 막대기 리스트를 순회합니다.
	for (it = myList.begin(); it != myList.end(); it++) {
		cList.clear();
		// 해당 위치에 미네랄이 있는지 검색합니다.
		// 일단은 좌->우 검색
		if (leftRight) { // 좌측 검색
			for (int y = 1; y <= C; y++) {
				// 만약 미네랄이 있다면
				if (map[*it][y] == 'x') {
					// 해당 미네랄을 빈 공간으로 만든다.
					map[*it][y] = '.';
					// 바닥과 연결된 모든 클러스터를 방문처리
					CheckFloor();
					check = true;
					break;

				}
			}

			leftRight = !leftRight;
		}
		else { // 우측 검색
			for (int y = C; y >= 1; y--) {
				// 만약 미네랄이 있다면
				if (map[*it][y] == 'x') {
					// 해당 미네랄을 빈 공간으로 만든다.
					map[*it][y] = '.';
					// 바닥과 연결된 모든 클러스터를 방문처리
					CheckFloor();
					check = true;
					break;
				}
			}

			leftRight = !leftRight;
		}

		if (check) {  // 미네랄이 부셔졌다면

			for (int x = R; x >= 1; x--) {
				for (int y = 1; y <= C; y++) {
					if (map[x][y] == 'x' && mapCheck[x][y] == false) {
						cList.push_back(make_pair(x, y));
					}
				}
			}


			// 방문 처리를 초기화 
			for (int x = R; x >= 1; x--) {
				for (int y = 1; y <= C; y++) {
					mapCheck[x][y] = false;
				}
			}
			check = false;
		}

	}

	if (debug) {

		for (int x = R; x >= 1; x--) {
			for (int y = 1; y <= C; y++) {
				cout << map[x][y] << " ";
			}
			cout << "\n";
		}
		cout << "\n던진 막대기 높이 리스트\n";
		for (it = myList.begin(); it != myList.end(); it++) cout << *it << " ";
		cout << "\n떠있는 클러스터 리스트 리스트\n";
		for (cit = cList.begin(); cit != cList.end(); cit++) cout << " x : " << cit->first << " y : " << cit->second << "\n";
	}

	return 0;

}

통과된 코드

미네랄이 파괴되면 바닥과 연결된 미네랄을 방문 처리해준다.

맵 전체에서 방문처리가 되지 않은 미네랄을 리스트에 담아준다

미네랄 리스트를 순회하면서 아래 부분이 방문 처리가 된 곳인지 확인한다. (내려갈 길이를 찾기 위함)

하단부가 방문처리가 되었다면 그 거리 -1 만큼 미네랄을 옮겨준다.

막대기의 수 만큼 위의 로직을 반복

#include <iostream>
#include <list>
#include <queue>

using namespace std;

// RC의 범위 최대값
constexpr int MAX = 101;

// 기본 맵
char map[MAX][MAX];

// 방문처리 
bool mapCheck[MAX][MAX];

// BFS 사용할 Q
queue<pair<int, int>> myQ;

pair<int, int> tempP;

// R 행, C 열, N 막대기를 던진 횟수
int R, C, N;

int dx, dy, dis;

int temp = 0;

// 탐색하는 방향 설정 =>  상, 하 ,좌 ,우
int dxdy[4][2] = { {-1, 0}, {1, 0}, {0, -1}, {0, 1} };


list<int> myList;
list<int>::iterator it;

list<pair<int, int>> cList;
list<pair<int, int>>::iterator cit;

// true = left, false = right
bool check = false, leftRight = false;

void BFS(int x, int y)
{
	myQ.push(make_pair(x, y));

	while (!myQ.empty()) {
		tempP = myQ.front();
		myQ.pop();

		for (int i = 0; i < 4; i++) {
			dy = tempP.second + dxdy[i][1];
			dx = tempP.first + dxdy[i][0];
			// 문제의 범위를 벗어나는 경우 => 넘어간다.
			if (dx <= 0 || dy <= 0 || dy > C || dx > R) continue;
			// 방문 처리가 되었거나 빈공간 => 넘어간다.
			if (mapCheck[dx][dy] == true || map[dx][dy] == '.') continue;
			mapCheck[dx][dy] = true;
			myQ.push(make_pair(dx, dy));
		}
	}
}

void CheckFloor() // 바닥을 체크합니다.
{
	for (int y = 1; y <= C; y++) {
		// 바닥에 클러스터가 발견되고 방문처리가 되지 않았다면 
		if (map[1][y] == 'x' && mapCheck[1][y] == false) {
			BFS(1, y); // BFS로 마킹
		}
	}
}

int main()
{
	ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
	// cin.tie(null); 코드는 cin과 cout의 묶음을 풀어줍니다.
	cin.tie(NULL);
	cout.tie(NULL);

	// 처음 맵을 초기화 해준다.
	for (int x = 1; x < MAX; x++) {
		for (int y = 1; y < MAX; y++) {
			map[x][y] = '.';
		}
	}

	cin >> R >> C;

	// 미네랄의 위치를 설정 (아래서 부터 시작)
	for (int x = R; x >= 1; x--) {
		for (int y = 1; y <= C; y++) {
			cin >> map[x][y];
		}
	}

	cin >> N;

	/// 던진 횟수와 높이를 설정
	while (N > 0) {
		cin >> temp;
		myList.push_back(temp);
		N--;
	}

	// 던진 막대기 리스트를 순회합니다.
	for (it = myList.begin(); it != myList.end(); it++) {

		check = false; // 미네랄 부셔짐 체크 해제
		cList.clear(); // 공중의 미네랄 리스트 초기화

		// 해당 위치에 미네랄이 있는지 검색합니다.
		if (leftRight) { // 좌측 검색
			for (int y = C; y >= 1; y--) {
				// 만약 미네랄이 있다면
				if (map[*it][y] == 'x') {
					// 해당 미네랄을 빈 공간으로 만든다.
					map[*it][y] = '.';
					// 바닥과 연결된 모든 클러스터를 방문처리
					CheckFloor();
					check = true;
					break;
				}
			}

			leftRight = !leftRight;
		}
		else { // 우측 검색
			for (int y = 1; y <= C; y++) {
				// 만약 미네랄이 있다면
				if (map[*it][y] == 'x') {
					// 해당 미네랄을 빈 공간으로 만든다.
					map[*it][y] = '.';
					// 바닥과 연결된 모든 클러스터를 방문처리
					CheckFloor();
					check = true;
					break;
				}
			}

			leftRight = !leftRight;
		}

		if (check) {  // 미네랄이 부셔졌다면
			// 공중에 있는 클러스트들을 리스트에 담는다.
			for (int x = R; x >= 1; x--) {
				for (int y = C; y >= 1; y--) {
					if (map[x][y] == 'x' && mapCheck[x][y] == false) {
						cList.push_back(make_pair(x, y));
					}
				}
			}

			// 공중에 미네랄이 바닥과 연결될때까지 반복
			dis = 1;
			bool floor = true;
			while (floor) {

				if (cList.size() == 0) break;

				for (cit = cList.begin(); cit != cList.end(); cit++) {
					tempP.first = cit->first;
					tempP.second = cit->second;

					if (mapCheck[tempP.first - (dis + 1)][tempP.second] == true || tempP.first - (dis + 1) == 0) {
						floor = false;
						break;
					}
				}

				dis++;
			}

			if (!floor) {
				for (cit = cList.begin(); cit != cList.end(); cit++) {
					tempP.first = cit->first;
					tempP.second = cit->second;
					map[tempP.first][tempP.second] = '.';
				}

				for (cit = cList.begin(); cit != cList.end(); cit++) {
					tempP.first = cit->first;
					tempP.second = cit->second;
					map[tempP.first - (dis - 1)][tempP.second] = 'x';
				}	
			}

			// 방문 처리를 초기화 
			for (int x = R; x >= 1; x--) {
				for (int y = 1; y <= C; y++) {
					mapCheck[x][y] = false;
				}
			}
		}
	}

	for (int x = R; x >= 1; x--) {
		for (int y = 1; y <= C; y++) {
			cout << map[x][y];
		}
		if (x == 1) break;
		cout << "\n";
	}

	return 0;

}

계속 틀린 원인은 바닥과 연결된 클러스터를 찾는 BFS 탐색에서 R과 C의 범위를 바꾸어 탐색

이 부분 하나로 엄청난 시간을 낭비

웃긴 부분은 다른 테스트 케이스는 다 잘돌아감 ㅋㅋ

구현이 조금 빡센 문제…

The post 백준 2933번 (미네랄, C++, Simulation) / 추가 반례 [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

프린터 큐

https://www.acmicpc.net/problem/1966

문제

여러분도 알다시피 여러분의 프린터 기기는 여러분이 인쇄하고자 하는 문서를 인쇄 명령을 받은 ‘순서대로’,

즉 먼저 요청된 것을 먼저 인쇄한다.

여러 개의 문서가 쌓인다면 Queue 자료구조에 쌓여서 FIFO – First In First Out – 에 따라 인쇄가 되게 된다.

하지만 상근이는 새로운 프린터기 내부 소프트웨어를 개발하였는데,

이 프린터기는 다음과 같은 조건에 따라 인쇄를 하게 된다.

1. 현재 Queue의 가장 앞에 있는 문서의 ‘중요도’를 확인한다.

2. 나머지 문서들 중 현재 문서보다 중요도가 높은 문서가 하나라도 있다면,

이 문서를 인쇄하지 않고 Queue의 가장 뒤에 재배치 한다.

그렇지 않다면 바로 인쇄를 한다.

예를 들어 Queue에 4개의 문서(A B C D)가 있고,

중요도가 2 1 4 3 라면 C를 인쇄하고, 다음으로 D를 인쇄하고 A, B를 인쇄하게 된다.

여러분이 할 일은, 현재 Queue에 있는 문서의 수와 중요도가 주어졌을 때,

어떤 한 문서가 몇 번째로 인쇄되는지 알아내는 것이다.

예를 들어 위의 예에서 C문서는 1번째로, A문서는 3번째로 인쇄되게 된다.

입력

첫 줄에 테스트 케이스의 수가 주어진다.

각 테스트 케이스는 두 줄로 이루어져 있다.

테스트 케이스의 첫 번째 줄에는 문서의 개수 N(1 ≤ N ≤ 100)과,

몇 번째로 인쇄되었는지 궁금한 문서가 현재 Queue에서 몇 번째에 놓여 있는지를 나타내는 정수 M(0 ≤ M < N)이 주어진다.

이때 맨 왼쪽은 0번째라고 하자. 두 번째 줄에는 N개 문서의 중요도가 차례대로 주어진다.

중요도는 1 이상 9 이하의 정수이고, 중요도가 같은 문서가 여러 개 있을 수도 있다.

출력

각 테스트 케이스에 대해 문서가 몇 번째로 인쇄되는지 출력한다.

예제 입력 1

3
1 0
5
4 2
1 2 3 4
6 0
1 1 9 1 1 1

예제 출력 1

1
2
5

출처

ICPC > Regionals > Europe > Northwestern European Regional Contest > NWERC 2006 F번

• 문제의 오타를 찾은 사람: doju
• 어색한 표현을 찾은 사람: iiwwnnaa, jh05013

알고리즘 분류

• 구현
• 자료 구조
• 시뮬레이션
• 큐

통과된 코드

#include <iostream>
#include <queue>
#include <list>

using namespace std;

queue<pair<int, bool>> myQueue; // 프린터 Q
list <int> resList; // 결과를 저장하는 리스트

pair<int, bool> tempPair;

int N, temp , number, target, cnt;

int arr[10]; // [i] i의 중요도를 가진 문서의 개수를 저장 

int main()
{
	cin >> N;
	while (N-- > 0) {
		
		// 초기화
		for (int i = 1; i <= 9; i++) arr[i] = 0;
		while (!myQueue.empty()) myQueue.pop();
		cnt = 1;

		cin >> number >> target;

		for (int i = 0; i < number; i++) {

			cin >> temp;
			arr[temp]++;

			// 목표의 문서를 마킹
			if (target == i) tempPair = make_pair(temp, true);
			else tempPair = make_pair(temp, false);

			myQueue.push(tempPair);
		}

		for (int i = 9; i >= 1; i--) {
			while (arr[i] != 0) { // 상위 중요도 문서부터 문서 개수가 0 이될때까지 실행
				tempPair = myQueue.front();

				if (tempPair.first != i) {
					myQueue.pop();
					myQueue.push(tempPair);
				}
				else 
				{	// 만약 목표로하는 문서일 경우 (마킹된 문서)
					if (tempPair.second == true) {
						resList.push_back(cnt); // 인쇄된 순서를 결과에 저장 
						myQueue.pop();
						arr[i]--;
					}
					else
					{
						arr[i]--;
						cnt++;
						myQueue.pop();
					}
				}
			}
		}
	}

	for (auto it = resList.begin(); it != resList.end(); it++) {
		cout << *it << " ";
	}

	return 0;
}

The post 백준 1966번 (프린터 큐, C++, queue) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

단어 공부

https://www.acmicpc.net/problem/1157

문제

알파벳 대소문자로 된 단어가 주어지면,

이 단어에서 가장 많이 사용된 알파벳이 무엇인지 알아내는 프로그램을 작성하시오.

단, 대문자와 소문자를 구분하지 않는다.

입력

첫째 줄에 알파벳 대소문자로 이루어진 단어가 주어진다.

주어지는 단어의 길이는 1,000,000을 넘지 않는다.

출력

첫째 줄에 이 단어에서 가장 많이 사용된 알파벳을 대문자로 출력한다.

단, 가장 많이 사용된 알파벳이 여러 개 존재하는 경우에는 ?를 출력한다.

예제 입력 1

Mississipi

예제 출력 1

?

예제 입력 2

zZa

예제 출력 2

Z

예제 입력 3

z

예제 출력 3

Z

예제 입력 4

baaa

예제 출력 4

A

출처

• 문제를 만든 사람: author5
• 데이터를 추가한 사람: jh05013, rnjs4197

알고리즘 분류

• 구현
• 문자열

이 문제를 해결하려면 ASCII 코드에 대해서 알아야 한다.

알파벳의 개수 26만큼 배열을 선언한다. (배열의 값은 해당 알파벳의 개수)

문제의 문자열을 인덱스로 순회하면서 대문자/소문자에 관계없이 알파벳 배열에 개수를 추가한다.

인덱스를 순회하며 가장 큰 값을 찾고

배열을 오름차순으로 정렬한 뒤에 0번과 1번 인덱스를 비교한다.

만약 값이 같다면 최대 개수가 같은 알파벳이 있다는 뜻으로 ? 를 출력한다.

문제의 포인트는 대문자/소문자에 관계없이 알파벳의 개수를 체크,

가장 많은 알파벳 찾을 찾아 출력하기,

최댓값 중복에 대한 예외 처리 인 것 같다.

통과된 코드

#include <iostream>
#include <algorithm>

using namespace std;

string str;

int arr[26]; // 알파벳의 개수는 26개

int main()
{
	// 문제의 문자열을 받는다.
	cin >> str;

	for (int i = 0; i < str.length(); i++) {
		if (str[i] >= 97) 	arr[(str[i] - 32) - 'A']++; // 소문자
		else arr[str[i] - 'A']++; // 대문자
	}

	// 가장 많이 사용한 알파벳을 찾는다.
	int maxIndex = -1;
	int max = -1;
	for (int i = 0; i < 26; i++) {
		if (max < arr[i]) {
			max = arr[i];
			maxIndex = i;
		}
	}

	// 가장많이 사용한 알파벳을 출력한다.
	sort(arr, arr + 26, greater<int>()); // 내림차순 정렬

	// 0번과 1번이 같다면 가장 많이 사용된 알파벳이 한개가 아니라는 의미 
	if (arr[0] == arr[1]) {
		cout << "?"; 
	}
	else { 
		char ch = maxIndex + 'A'; 
		cout << ch;
	} 

	return 0;
}

문제를 풀고 다른 사람들이 작성한 코드를 보니 ASCII 코드를 사용하는 방법은 아래가 더 좋은 것 같다.

https://rujang.tistory.com/entry/%EB%B0%B1%EC%A4%80-1157%EB%B2%88-%EB%8B%A8%EC%96%B4-%EA%B3%B5%EB%B6%80-C

The post 백준 1157번 (단어 공부, C++, 문자열) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

음계

https://www.acmicpc.net/problem/2920

문제

다장조는 c d e f g a b C, 총 8개 음으로 이루어져있다.

이 문제에서 8개 음은 다음과 같이 숫자로 바꾸어 표현한다.

c는 1로, d는 2로, …, C를 8로 바꾼다.

1부터 8까지 차례대로 연주한다면 ascending,

8부터 1까지 차례대로 연주한다면 descending,

둘 다 아니라면 mixed 이다.

연주한 순서가 주어졌을 때,

이것이 ascending인지, descending인지, 아니면 mixed인지 판별하는 프로그램을 작성하시오.

입력

첫째 줄에 8개 숫자가 주어진다.

이 숫자는 문제 설명에서 설명한 음이며, 1부터 8까지 숫자가 한 번씩 등장한다.

출력

첫째 줄에 ascending, descending, mixed 중 하나를 출력한다.

예제 입력 1

1 2 3 4 5 6 7 8

예제 출력 1

ascending

예제 입력 2

8 7 6 5 4 3 2 1

예제 출력 2

descending

예제 입력 3

8 1 7 2 6 3 5 4

예제 출력 3

mixed

출처

Contest > Croatian Open Competition in Informatics > COCI 2009/2010 > Contest #1 1번

• 문제를 번역한 사람: baekjoon
• 데이터를 추가한 사람: jh05013
• 문제의 오타를 찾은 사람: thinksong1

알고리즘 분류

• 구현

ascending, descending 를 어떤 방법으로 구별하는 지가 이 문제의 포인트 같다.

나는 숫자들을 배열에 넣어서 ( arr[i] ) 배열의 인덱스와 수의 관계로 구별했다.

만약 오름차순이라면

arr[0] = 1, arr[1] = 2, arr[2] = 3 … arr[7] = 8 값과 인덱스의 차이가 1이다.

만약 내림차순이라면

arr[0] = 8, arr[1] = 7, arr[2] = 6 … arr[7] = 1 값과 인덱스의 합이 8이다.

ascending가 아니면 descending를 확인

descending가 아니면 Mixed의 인덱스로 보내어 답을 구하였다.

통과된 코드

#include <iostream>

using namespace std;

int arr[8];
string str[3] = { "ascending", "descending", "mixed" };

int main()
{
	// 8개의 숫자를 차례대로 입력받는다.
	for (int i = 0; i < 8; i++) {
		cin >> arr[i];
	}

	int cnt = 0;

	for (int i = 0; i < 8; i++) {

		switch (cnt)
		{	
			case 0: // 처음은 오름차순을 체크
				if (arr[i] - i == 1) { continue; } // 오름차순은 arr[i] - i == 1 로 판단 가능
				else if (arr[i] + i == 8) { cnt++; } // 내름차순은 arr[i] + i == 8 로 판단 가능
				else { cnt = 2; }
				break;

			case 1:
				if (arr[i] + i == 8) { continue; } // 내름차순은 arr[i] + i == 8 로 판단 가능
				else { cnt = 2; }
				break;

			default:
				break;
		}

	}

	cout << str[cnt];
}

The post 백준 2920번 (음계, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.