테트로미노

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

문제

폴리오미노란 크기가 1×1인 정사각형을 여러 개 이어서 붙인 도형이며, 다음과 같은 조건을 만족해야 한다.

정사각형은 서로 겹치면 안 된다.

도형은 모두 연결되어 있어야 한다.

정사각형의 변끼리 연결되어 있어야 한다. 즉, 꼭짓점과 꼭짓점만 맞닿아 있으면 안 된다.

정사각형 4개를 이어 붙인 폴리오미노는 테트로미노라고 하며, 다음과 같은 5가지가 있다.

아름이는 크기가 N×M인 종이 위에 테트로미노 하나를 놓으려고 한다.

종이는 1×1 크기의 칸으로 나누어져 있으며, 각각의 칸에는 정수가 하나 쓰여 있다.

테트로미노 하나를 적절히 놓아서 테트로미노가 놓인 칸에 쓰여 있는 수들의 합을 최대로 하는 프로그램을 작성하시오.

테트로미노는 반드시 한 정사각형이 정확히 하나의 칸을 포함하도록 놓아야 하며, 회전이나 대칭을 시켜도 된다.

입력

첫째 줄에 종이의 세로 크기 N과 가로 크기 M이 주어진다. (4 ≤ N, M ≤ 500)

둘째 줄부터 N개의 줄에 종이에 쓰여 있는 수가 주어진다.

i번째 줄의 j번째 수는 위에서부터 i번째 칸, 왼쪽에서부터 j번째 칸에 쓰여 있는 수이다.

입력으로 주어지는 수는 1,000을 넘지 않는 자연수이다.

출력

첫째 줄에 테트로미노가 놓인 칸에 쓰인 수들의 합의 최댓값을 출력한다.

예제 입력 1

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

예제 출력 1

19

예제 입력 2

4 5
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5

예제 출력 2

20

예제 입력 3

4 10
1 2 1 2 1 2 1 2 1 2
2 1 2 1 2 1 2 1 2 1
1 2 1 2 1 2 1 2 1 2
2 1 2 1 2 1 2 1 2 1

예제 출력 3

7

출처

• 데이터를 추가한 사람: appie701, crookid, esuperstar, raboribus, rlatpwlsdlek, stack, vjerksen
• 문제를 만든 사람: baekjoon
• 문제의 오타를 찾은 사람: bluebrown

알고리즘 분류

• 구현
• 브루트포스 알고리즘

DFS 탐색

BFS 탐색 (나는 예외 처리로 해결)

통과된 코드

#include <iostream>

using namespace std;

constexpr int MAX = 500;

int map[MAX][MAX];

bool checkMap[MAX][MAX];

int N, M, result = 0;

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

void DFS_Search(int nowX, int nowY, int cnt, int val)
{
	if (cnt == 4) {
		result = max(result, val);
		return;
	}

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

		int dx = nowX + dxdy[i][0];
		int dy = nowY + dxdy[i][1];

		// 범위를 벗어나면 넘어간다.
		if (dx < 0 || dy < 0 || dx >= N || dy >= M) continue;
		// 방문했다면 넘어간다.
		if (checkMap[dx][dy] == true) continue;

		cnt++;
		val += map[dx][dy];
		checkMap[dx][dy] = true;
		DFS_Search(dx, dy, cnt, val);
		checkMap[dx][dy] = false;
		cnt--;
		val -= map[dx][dy];

	}
}

// 'ㅗ' 탐색을 위한 함수
void Exception_Search(int nowX, int nowY, int val)
{
	for (int i = 0; i < 4; i++) {
		int dx = nowX + dxdy[i][0];
		int dy = nowY + dxdy[i][1];
		if (dx < 0 || dy < 0 || dx >= N || dy >= M) continue;
		val += map[dx][dy];
	}

	for (int i = 0; i < 4; i++) {
		int dx = nowX + dxdy[i][0];
		int dy = nowY + dxdy[i][1];

		if (dx < 0 || dy < 0 || dx >= N || dy >= M) {
			result = max(result, val);
			continue;
		}

		val -= map[dx][dy];
		result = max(result, val);
		val += map[dx][dy];
	}

}


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

	cin >> N >> M;

	for (int i = 0; i < N; i++) {
		for (int j = 0; j < M; j++) {
			cin >> map[i][j];
		}
	}

	for (int i = 0; i < N; i++) {
		for (int j = 0; j < M; j++) {
			checkMap[i][j] = true;
			DFS_Search(i, j, 1, map[i][j]);
			checkMap[i][j] = false;
			Exception_Search(i, j, map[i][j]);
		}
	}

	cout << result;

	return 0;
}

추가 반례

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

예제 입력 A

6 10
3 3 6 4 1 4 8 5 3 2
9 5 1 2 4 1 9 9 5 5
2 5 1 2 3 3 3 7 6 4
1 6 5 6 4 7 4 7 7 4
3 8 5 9 6 4 2 6 1 1
6 3 3 7 1 2 2 2 8 4

예제 출력 A

33

예제 입력 B

4 4
1 1 1 1
2 1000 1 1
1 1000 2 1
1 1 1 1

예제 출력 B

2004

예제 입력 C

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

예제 출력 C

10

The post 백준 14500번 (테트로미노, C++) / 추가 반례 [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

골목길

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

문제

민승이는 놀러가기 위해 집을 나섰다.

민승이네 집에서 코레스코 콘도까지 가기 위해서는 복잡하게 얽혀있는 골목길들을 통과해야 한다.

그런데, 어떤 길에는 깡패가 서식하고 있어, 그 길을 지나게 되면 깡패에게 일정한 양의 금품을 갈취당하게 된다.

그런가하면, 어떤 길에는 지나가던 행인들이 흘리고 간 금품들이 떨어져 있어, 그 길을 지나게 되면 일정한 양의 금품을 획득하게 된다. 

한 번 지나간 길을 다시 방문하더라도 금품을 갈취당하거나 획득한다.

골목길의 연결 상태와, 각 골목길을 지날 때 갈취당하거나 획득하게 되는 금품의 양이 주어졌을 때,

민승이가 최대한 유리한 경로를 따라 집에서 코레스코 콘도까지 가기 위해서는 어떻게 해야 하는지 출력하는 프로그램을 작성하시오. 

보유 중인 금품의 양이 음수가 될 수 있다. 

최대한 유리한 경로 또는 최적의 경로는 민승이네 집에서 출발하여 코레스코 콘도에 도착하는 경로 중 금품의 양이 최대가 되는 경로이다. 

입력

첫째 줄에 골목길들이 교차하는 지점의 개수 n (2 ≤ n ≤ 100)과

골목길의 개수 m (1 ≤ m ≤ 20,000) 이 차례로 주어진다.

이어지는 m개의 행에 각각의 골목길을 나타내는 세 정수 u, v, w가 차례로 주어진다.

이는 u번 교차점에서 v번 교차점으로 이동할 수 있는 골목길이 나있다는 의미이다.

즉, 주어지는 골목길들은 기본적으로 모두 일방통행로이다.

w (0 ≤ |w| ≤ 1,000)는 이 길을 지날 때 갈취당하거나 획득하게 되는 금품의 양이다.

음수는 갈취, 양수는 획득을 뜻한다.

골목길의 교차점 번호는 1이상 n이하의 정수이다.

민승이네 집은 1번 교차점에 있고, 이곳 코레스코 콘도는 n번 교차점에 있다.

출력

최적의 경로를 구할 수 있다면 민승이네 집부터 코레스코 콘도까지 가는 동안 거치게 되는

교차점들의 번호를 공백 하나를 사이에 두고 차례로 출력하면 된다. 

그런데, 경우에 따라서는 최적의 경로라는 것이 존재하지 않는 상황이 발생한다.

어떠한 경우에 그런 상황이 발생하는지 생각해 보자. 

그러한 경우에는 -1을 출력하도록 한다.

최적의 경로가 여러 개 존재할 때는 아무거나 출력해도 된다.

예제 입력 1

5 7
1 2 3
1 3 4
3 1 -7
2 3 2
3 4 1
4 2 -5
4 5 1

예제 출력 1

1 2 3 4 5

예제 입력 2

5 7
1 2 3
1 3 4
3 1 -7
2 3 2
3 4 1
4 2 -2
4 5 1

예제 출력 2

-1

출처

• 문제를 번역한 사람: author10
• 빠진 조건을 찾은 사람: kcm1700

알고리즘 분류

• 그래프 이론
• 벨만–포드

주의 사항

이 문제는 Bellman–Ford 알고리즘을 사용할 때 사이클이 있다고 해서 무조건 -1 을 출력하면 안된다.

해당 사이클이 최적의 경로에 영향이 있는지 확인이 필요하다.

통과된 코드

#include <iostream>
#include <vector>

using namespace std;

constexpr long long int INF = INT64_MAX;

constexpr int MAXN = 101;

vector<pair<int, int>> graph[MAXN];

long long int disArr[MAXN];

// N : 지점의 개수, M : 골목길의 개수
int N, M, u, v, w;

int trace[MAXN];

int main()
{

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

	cin >> N >> M;

	fill(disArr, disArr + MAXN, INF);

	disArr[1] = 0;

	for (int i = 0; i < M; i++) {
		cin >> u >> v >> w;
		// 단방향
		graph[u].push_back(make_pair(v, -w));
	}


	// (모든 정점의 수 - 1) 번 확인한다.
	// N 번은 순환 체크
	for (int k = 1; k <= N; k++) {
		for (int i = 1; i <= N; i++) {
			for (int j = 0; j < graph[i].size(); j++) {

				int u = i; // 시작점
				int v = graph[i][j].first; // 도착점
				int weight = graph[i][j].second; // 가중치

				// 만약 임시 배열이 무한대가 아니고 &&
				// 시작 임시 배열의 가중치가 도착지의 가중치보다 크다면
				if (disArr[u] != INF && disArr[u] + weight < disArr[v]) {
					disArr[v] = disArr[u] + weight;
					trace[v] = u;

					// K == N 일때 새로 업데이트 된다는 의미는 
					// 사이클에 포함되거나 사이클에서 도착 지점으로 도달 가능
					// 다음의 disArr[N] == -INF 코드를 통하여 영향이 있는 경로인지 판별 
					if (k == N) disArr[v] = -INF;
					// -INF로 더이상 업데이트를 막는다.
				}
			}
		}
	}

	if (disArr[N] == INF || disArr[N] == -INF) cout << "-1";
	else {
		// 경로를 역으로 추적한다.
		int now = N;
		vector<int> myV;
		while (now != 0) {
			myV.push_back(now);
			now = trace[now]; 
		}

		for (auto it = myV.rbegin(); it != myV.rend(); ++it) cout << *it << " ";

	}

	return 0;
}

추가 반례

예제 입력 A

4 4
1 2 1
2 3 1
3 2 1
1 4 1

예제 출력 A

1 4

예제 입력 B

7 11
1 2 3
1 3 4
3 1 -7
2 3 2
3 4 1
4 2 -5
4 7 1
4 5 1
5 6 2
6 5 3
6 7 -1000

예제 출력 B

-1

예제 입력 C

5 7
1 2 1
2 3 1
3 4 1
4 5 1
1 5 10
1 2 50
2 5 80

예제 출력 C

1 2 5

예제 입력 D

5 5
1 2 -1
2 3 1
3 4 1
4 2 1
2 5 -1

예제 출력 D

-1

예제 입력 E

4 4
1 4 3
2 3 1
3 2 1
4 2 1

예제 출력 E

1 4

예제 입력 F

4 5
1 2 1
2 3 1
3 4 1
3 2 1
4 1 1

예제 출력 F

-1

예제 입력 G

4 5
1 2 1
2 3 1
3 4 1
3 1 1
4 1 1

예제 출력 G

-1

예제 입력 H

5 5
1 2 1
2 3 1
3 4 1
4 3 1
2 5 1

예제 출력 H

1 2 5

The post 백준 1738번 (골목길, C++, Bellman–Ford) / 추가 반례 [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

리모컨

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

문제

수빈이는 TV를 보고 있다. 수빈이는 채널을 돌리려고 했지만, 버튼을 너무 세게 누르는 바람에, 일부 숫자 버튼이 고장났다.

리모컨에는 버튼이 0부터 9까지 숫자, +와 -가 있다. +를 누르면 현재 보고있는 채널에서 +1된 채널로 이동하고,

-를 누르면 -1된 채널로 이동한다. 채널 0에서 -를 누른 경우에는 채널이 변하지 않고, 채널은 무한대 만큼 있다.

수빈이가 지금 이동하려고 하는 채널은 N이다. 어떤 버튼이 고장났는지 주어졌을 때,

채널 N으로 이동하기 위해서 버튼을 최소 몇 번 눌러야하는지 구하는 프로그램을 작성하시오. 

수빈이가 지금 보고 있는 채널은 100번이다.

입력

첫째 줄에 수빈이가 이동하려고 하는 채널 N (0 ≤ N ≤ 500,000)이 주어진다.  

둘째 줄에는 고장난 버튼의 개수 M (0 ≤ M ≤ 10)이 주어진다.

고장난 버튼이 있는 경우에는 셋째 줄에는 고장난 버튼이 주어지며, 같은 버튼이 여러 번 주어지는 경우는 없다.

출력

첫째 줄에 채널 N으로 이동하기 위해 버튼을 최소 몇 번 눌러야 하는지를 출력한다.

예제 입력 1

5457
3
6 7 8

예제 출력 1

6

예제 입력 2

100
5
0 1 2 3 4

예제 출력 2

0

예제 입력 3

500000
8
0 2 3 4 6 7 8 9

예제 출력 3

11117

예제 입력 4

100
3
1 0 5

예제 출력 4

0

예제 입력 5

14124
0

예제 출력 5

5

예제 입력 6

1
9
1 2 3 4 5 6 7 8 9

예제 출력 6

2

예제 입력 7

80000
2
8 9

예제 출력 7

2228

예제 입력 A

0
9
1 2 3 4 5 6 7 8 9

예제 출력 A

1

예제 입력 B

140200
3
4 5 6

예제 출력 B

207

예제 입력 C

1555
3
0 1 9

예제 출력 C

670

예제 입력 D

99999
9
0 2 3 4 5 6 7 8 9

예제 출력 D

11118

예제 입력 E

50000
9
0 1 2 3 4 5 6 7 8

예제 출력 E

40005

예제 입력 F

139133
7
9 6 8 2 1 5 7

예제 출력 F

94694

예제 입력 G

0
0

예제 출력 G

1

힌트

예제 1의 경우 5455++ 또는 5459–

출처

• 데이터를 추가한 사람: applyoo
• 문제를 번역한 사람: baekjoon
• 잘못된 조건을 찾은 사람: jh05013

알고리즘 분류

• 브루트포스 알고리즘

아래에서 위로 올라가는 방법도 있지만 위에서 아래로 내려가는 방법도 같이 생각해야한다.

통과된 코드

#include <iostream>
#include <cmath>

using namespace std;

bool arr[10];

string str, strTemp;

int N, M, temp, cnt, target, result = INT32_MAX;

void dfs(string st, char ch)
{
	if (st.length() == str.length() + 1) return;
	st.push_back(ch);
	cnt = abs(target - atoi(st.c_str())) + st.length();
	result = min(cnt, result);

	for (int i = 0; i < 10; i++) {
		if (arr[i] == true) continue;
		dfs(st, i + '0');
	}
}

int main()
{
	cin >> str >> M;

	target = atoi(str.c_str());

	for (int i = 0; i < M; i++) {
		cin >> temp;
		arr[temp] = true;
	}
	
	for (int i = 0; i < 10; i++) {
		if (arr[i] == true) continue;
		dfs(strTemp, i + '0');
	}

	result = min(abs(target - 100), result);

	cout << result;

	return 0;
}

문자열로 접근하니까 속도가 너무 느리다….

The post 백준 1107번 (리모컨, C++, Brute Force) / 추가 반례 [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

나는야 포켓몬 마스터 이다솜

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

문제

안녕? 내 이름은 이다솜. 나의 꿈은 포켓몬 마스터야.

일단 포켓몬 마스터가 되기 위해선 포켓몬을 한 마리 잡아야겠지? 근처 숲으로 가야겠어.

(뚜벅 뚜벅)

얏! 꼬렛이다. 꼬렛? 귀여운데, 나의 첫 포켓몬으로 딱 어울린데? 내가 잡고 말겠어. 가라! 몬스터볼~

(펑!) 헐랭… 왜 안 잡히지?ㅜㅜ 몬스터 볼만 던지면 되는 게 아닌가…ㅜㅠ

(터벅터벅)

어? 누구지?

오박사 : 나는 태초마을의 포켓몬 박사 오민식 박사라네.

다솜아, 포켓몬을 잡을 때는, 일단 상대 포켓몬의 체력을 적당히 바닥으로 만들어놓고 몬스터 볼을 던져야 한단다.

자, 내 포켓몬 이상해꽃으로 한번 잡아보렴. 포켓몬의 기술을 쓰는 것을 보고

포켓몬을 줄지 안줄지 결정을 하겠네. 자 한번 해보아라. 다솜아.

이다솜 : 이상해꽃이라…음.. 꽃이니깐 왠지 햇빛을 받아서 공격을 할 것 같은데… 음… 이상해꽃! 햇빛공격!!!

(꼬렛이 이상해꽃에게 공격을 받아 체력이 25 감소했다.)   

가라! 몬스터 볼!!!    (꼬렛을 잡았습니다.)    야호! 신난다. 꼬렛을 잡았다.

오박사 : 오우!! 방금 쓴 공격은 솔라빔이라고 하네.. 어떻게 공격을 한 건가?

솔라빔이란 공격에 대해서 공부를 한 건가?

이다솜 : 꽃이니깐 왠지 햇빛을 제대로 받으면 광합성을 해서 음.. 그냥 그럴 것 같아서요 ☞☜

오박사 : 다른 아이들은 넝쿨채찍이나, 나뭇잎 공격을 하는데, 다솜이는 역시 뭔가 다르구나.

그럼 나와 함께 연구소로 가자꾸나. 내가 포켓몬을 한 마리 줄 테니, 너의 꿈을 펼쳐보아라. 꿈은 이루어진단다.

이다솜 : 네! 오박사님, 고마워요.ㅜㅜ

오박사 : 가자. 나의 연구소는 너의 옆집의 아랫집이란다. 같이 가도록하자. 지금 포켓몬을 주마.

이다솜 : 네. 야호!!

오영식 : 어? 오박사님 얘는 누구인가요?

오박사 : 얘는 너의 라이벌이 될 친구 이다솜이라고 하네.

자, 포켓몬을 한 마리 골라보도록 해봐라 다솜아. 레이디퍼스트 네가 먼저 골라봐라.

이다솜 : 저는 생각해둔 포켓몬이 있어요. 피카츄 골라도 될까요?

오박사 : 그래 여기 피카츄가 한 마리 있단다. 피카츄를 가져가거라.

오영식 : 그럼 저는 이브이를 가져가겠어요. 그럼 나중에 보자 이다솜.

이다솜 : 그럼 꼬렛을 다시 잡으러 가야겠다. 영식아, 그리고 민식박사님 빠잉!

이다솜 : 피카츄 공격!

가라 몬스터 볼!

이다솜 : 야호! 신난다. 꼬렛을 잡았다!!!!!

이다솜 : 그럼! 일단 사천왕을 이기고 오겠어!

이다솜 : 여기가 사천왕과 대결하려면 가야하는 곳인가..

경비원 : 사천왕과 대결을 하려면, 마을의 체육관 리더를 이겨서 배지를 8개를 모아야 한다네… 배지를 모아서 오도록 하게

이다솜 : 잉ㅠㅜ… 그럼 배지부터 모아야 하는구나ㅠㅜㅠㅜ 나쁘당 그냥 좀 봐주지..

<1 년 후>

그동안의 줄거리 : 이다솜은 일단 상록 숲의 체육관 리더에게 도전을 했다.

하지만 상록숲 체육관의 리더는 실종된 상태. 따라서 회색마을부터 도전하기로 했다.

체육관의 리더를 이기면서, 로켓단을 해체시키기도 하고, 여러 가지 사건도 있었다.

결국 전설의 포켓몬도 잡고, 이제 사천왕을 이기려고 도전하기로 했다.

사천왕은 모두 가볍게 이기고, 이제 마지막 라이벌 오!영!식! 이다.

오영식 : 훗. 1년 전의 그 이다솜이 사천왕을 이기고 현재 포켓몬 마스터인 나에게 덤벼? 어디 한번 덤벼보시지.

이다솜 : 헐랭… 나를 우습게보네…. 한번 두고 보시지! 그럼 대결이닷!

이다솜 : 휴… 이겼다.

오영식 : 내가 지다니 분하다. ㅜㅜ

오박사 : 그럼 다솜아 이제 진정한 포켓몬 마스터가 되기 위해 도감을 완성시키도록 하여라.

일단 네가 현재 가지고 있는 포켓몬 도감에서 포켓몬의 이름을 보면 포켓몬의 번호를 말하거나,

포켓몬의 번호를 보면 포켓몬의 이름을 말하는 연습을 하도록 하여라.

나의 시험을 통과하면, 내가 새로 만든 도감을 주도록 하겠네.

입력

첫째 줄에는 도감에 수록되어 있는 포켓몬의 개수 N이랑 내가 맞춰야 하는 문제의 개수 M이 주어져.

N과 M은 1보다 크거나 같고, 100,000보다 작거나 같은 자연수인데, 자연수가 뭔지는 알지?

모르면 물어봐도 괜찮아. 나는 언제든지 질문에 답해줄 준비가 되어있어.

둘째 줄부터 N개의 줄에 포켓몬의 번호가 1번인 포켓몬부터 N번에 해당하는 포켓몬까지 한 줄에 하나씩 입력으로 들어와.

포켓몬의 이름은 모두 영어로만 이루어져있고, 또, 음… 첫 글자만 대문자이고, 나머지 문자는 소문자로만 이루어져 있어.

아참! 일부 포켓몬은 마지막 문자만 대문자일 수도 있어. 포켓몬 이름의 최대 길이는 20, 최소 길이는 2야.

그 다음 줄부터 총 M개의 줄에 내가 맞춰야하는 문제가 입력으로 들어와. 문제가 알파벳으로만 들어오면 포켓몬 번호를 말해야 하고,

숫자로만 들어오면, 포켓몬 번호에 해당하는 문자를 출력해야해.

입력으로 들어오는 숫자는 반드시 1보다 크거나 같고, N보다 작거나 같고,

입력으로 들어오는 문자는 반드시 도감에 있는 포켓몬의 이름만 주어져. 그럼 화이팅!!!

출력

첫째 줄부터 차례대로 M개의 줄에 각각의 문제에 대한 답을 말해줬으면 좋겠어!!!.

입력으로 숫자가 들어왔다면 그 숫자에 해당하는 포켓몬의 이름을,

문자가 들어왔으면 그 포켓몬의 이름에 해당하는 번호를 출력하면 돼. 그럼 땡큐~

이게 오박사님이 나에게 새로 주시려고 하는 도감이야.

너무 가지고 싶다ㅠㅜ. 꼭 만점을 받아줬으면 좋겠어!! 파이팅!!!

예제 입력 1

26 5
Bulbasaur
Ivysaur
Venusaur
Charmander
Charmeleon
Charizard
Squirtle
Wartortle
Blastoise
Caterpie
Metapod
Butterfree
Weedle
Kakuna
Beedrill
Pidgey
Pidgeotto
Pidgeot
Rattata
Raticate
Spearow
Fearow
Ekans
Arbok
Pikachu
Raichu
25
Raichu
3
Pidgey
Kakuna

예제 출력 1

Pikachu
26
Venusaur
16
14

출처

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

알고리즘 분류

• 자료 구조
• 해시를 사용한 집합과 맵

주의할 점은 들어오는 문자열을 숫자와 문자로 구분하는 방법이다.

문제의 조건은 문자의 첫 인덱스는 숫자가 아니다.

그래서 문자열의 첫 인덱스를 숫자인지 문자인지 구분하여 해결하였다.

추가적으로 atoi() 를 사용하여 문자를 숫자로 변환해주었다. <iostream>

atoi는 해당하는 문자열이 숫자면 숫자를 반환한다

만약 해당하는 문자열이 숫자로 변환이 불가능하다면 아니라면 0을 반환

통과된 코드

#include <iostream>
#include <unordered_map>

using namespace std;

unordered_map<string, int> uSortMap;

int N, M;
string strArr[100001];

int main()
{

	ios_base::sync_with_stdio(false); // scanf와 동기화를 비활성화
	// cin.tie(null); 코드는 cin과 cout의 묶음을 풀어줍니다.
	cin.tie(NULL);
	cout.tie(NULL);
	cin >> N >> M;
	
	for (int i = 1; i <= N; i++) {
		cin >> strArr[0];
		strArr[i] = strArr[0];
		uSortMap.insert({ strArr[0], i });
	}

	for (int i = 0; i < M; i++) {
		cin >> strArr[0];
		if (strArr[0][0] >= '0' && strArr[0][0] <= '9') {
			cout << strArr[atoi(strArr[0].c_str())] << "\n";
			// atoi(string.c_str())
			// atoi는 해당하는 문자열이 숫자면 숫자를 반환한다 
			// 만약 해당하는 문자열이 숫자로 변환이 불가능하다면 아니라면 0을 반환
		}
		else {
			cout << uSortMap.find(strArr[0])->second << "\n";
		} 
	}

	return 0;
}

The post 백준 1620번 (나는야 포켓몬 마스터 이다솜, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

등산

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

문제

주환이는 요즘 등산에 빠졌다. 주환이는 등산을 위해 지도를 가지고 있는데,

그 지도에는 각 지점의 높이와 갈 수 있는 다른 지점까지의 거리가 표시되어 있다.

주환이는 아침에 집에서 출발하여 등산을 갔다가, 오후 수업을 듣기 위해 고려대학교로 돌아와야 한다.

1. 주환이는 지도의 임의의 지점을 골라, 그 지점을 목표로 정한다. 집 또는 고려대학교는 목표로 선택할 수 없다.

2. 주환이가 집에서 정한 목표에 도달할 때 까지는 항상 높이가 증가하는 방향으로만 이동해야 한다.

3. 주환이가 정한 목표에 도달한 후, 고려대학교로 갈 때에는 항상 높이가 감소하는 방향으로만 이동해야 한다.

4. 주환이는 거리 1을 움직일 때 마다 D 의 체력이 소모된다.

5. 주환이는 정한 목표에 도달하면 높이 1당 E 의 성취감을 얻는다. 즉 높이가 h인 목표에 도달하면 hE의 성취감을 얻는다.

주환이는 이 등산의 가치를 (얻은 성취감) – (소모한 체력) 으로 계산하기로 하였다.

주환이를 위해 가치가 가장 높은 등산 경로를 선택해주자.

입력

첫 번째 줄에 지도에 표시된 지점의 개수, 지점을 잇는 경로의 개수, 주환이의 거리 비례 체력 소모량,

높이 비례 성취감 획득량을 나타내는 정수 N, M, D, E가 공백을 사이에 두고 주어진다.

(2 ≤ N ≤ 100,000, 1 ≤ M ≤ 200,000, 1 ≤ D ≤ 100, 1 ≤  E ≤ 100)

두 번째 줄에 N개의 정수 h₁, …  ,h_N이 공백으로 구분되어 주어진다. h_i는 i 번째 지점의 높이를 의미한다.

(1 ≤ h_i ≤ 1,000,000, 1 ≤ i ≤ N)

세 번째 줄부터 M개의 줄에 걸쳐 세 정수 a, b, n이 공백으로 구분되어 주어진다.

이는 a번 지점과 b번 지점을 잇는 거리 n의 양방향 경로가 있음을 의미한다. (1 ≤ a, b ≤ N, 1 ≤ n ≤ 100,000)

어떤 지점에서 다른 지점으로 가는 경로가 여러 개 있을 수도 있으며 (등산로는 여러 개가 있을 수 있다),

한 지점에서 출발해 그 지점으로 돌아가는 경로가 있을 수도 있다 (쉼터에서 몇 바퀴 돌며 쉴 수도 있다).

주환이의 집은 1번 지점에 위치하고, 고려대학교는 N번 지점에 위치하며 주환이의 집과 고려대학교의 높이는 1임이 보장된다.

출력

첫 번째 줄에 주환이가 얻을 수 있는 가치의 최댓값을 출력한다.

만약 조건을 만족하는 등산 경로를 선택할 수 없다면, “Impossible“을 쌍따옴표를 제외하고 출력한다.

답이 음수일 수 있음에 유의하여라.

예제 입력 1

8 13 4 9
1 4 7 3 10 2 15 1
1 2 3
3 4 2
5 6 6
7 8 2
2 3 4
6 7 2
3 6 1
4 8 3
5 1 6
8 3 5
2 5 4
4 6 3
5 3 8

예제 출력 1

15

예제 입력 2

3 2 1 1
1 1 1
1 2 5
2 3 5

예제 출력 2

Impossible

출처

University > 고려대학교 > 2018 고려대학교 프로그래밍 경시대회 (KCPC) > Advanced Div. C번

University > 고려대학교 > 2018 고려대학교 프로그래밍 경시대회 (KCPC) > Intermediate Div. E번

• 문제를 만든 사람: oree2113

알고리즘 분류

• 그래프 이론
• 데이크스트라

통과된 코드

자료형 long long 필수!

#include <iostream>
#include <queue>
#include <vector>

using namespace std;

constexpr int MAXN = 100001;
constexpr long long int INF = INT64_MAX;
constexpr long long int uINF = INT64_MIN;

///*
//각 노드에 연결되어 있는 노드에 대한 정보를 담는 벡터
//a번 노드에서 b번 노드로 가는 비용이 c라는 의미
//graph[a].push_back((make_pair(B, C));
//*/
vector<pair<int, int>> upGraph[MAXN];
vector<pair<int, int>> downGraph[MAXN];

// Dijkstra 알고리즘에 사용할 우선순위 큐
priority_queue<pair<long long int, int>> myPQ;

// N 지점의 개수, M 지점을 잇는 경로의 개수
// D 주환이의 거리 비례 체력 소모량, E 높이 비례 성취감 획득량
int N, M, D, E;

// 각 지점의 높이를 저장하는 배열
int hArr[MAXN];

// 등산을 하는데 필요한 배열 (집 -> 산)
long long int upArr[MAXN];

long long int temp = 0;
// 결과를 저장
long long int result = uINF;

// 하산을 하는데 필요한 배열 (산 -> 고려대)
long long int downArr[MAXN];

// V1,2 지점, d : 지점 사이의 거리
int V1, V2, d;

void Dijkstra(int start, long long int arr[], vector<pair<int, int>> graph[])
{
    // 임시배열 초기화
    for (int i = 1; i <= N; i++) arr[i] = INF;
    // 우선순위 큐에 삽입.
    myPQ.push({ 0, start }); // < first : 거리 , second : 노드 인덱스 >
    arr[start] = 0;
    while (!myPQ.empty()) {
        // -를 붙이는 이유는 우선순위 큐를 이용하여 정렬하기 위함이다.
        // (최소힙으로 구현)
        long long int nCost = -myPQ.top().first;
        int now = myPQ.top().second;
        myPQ.pop();
        // 이미 담겨 있는 것보다 거리가 크면 넘어간다.
        if (arr[now] < nCost) continue;
        // 해당 노드에서 연결된 모든 경로를 확인
        for (int i = 0; i < graph[now].size(); i++) {
            // disSum = 임시 노드 + 현재 노드에서 i로가는 비용
            long long int disSum = nCost + graph[now][i].second;
            // 비용이 더 작다면 최단경로 테이블 값을 갱신.
            if (disSum < arr[graph[now][i].first]) {
                // 임시 노드 업데이트
                arr[graph[now][i].first] = disSum;
                // 우선순위 큐에 (거리, 노드 인덱스) 푸시
                myPQ.push(make_pair(-disSum, graph[now][i].first));
            }
        }
    }
}


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

    // 문제의 조건들을 입력 받는다.
    cin >> N >> M >> D >> E;

    // 각 지점의 높이를 입력 받는다.
    for (int i = 1; i <= N; i++) cin >> hArr[i];

    // 경로를 입력 받는다.
    for (int i = 0; i < M; i++) {

        cin >> V1 >> V2 >> d;

        // 높이가 같을 경우에는 생각하지 않는다.
        if (hArr[V1] > hArr[V2]) { // V1의 높이가 더 높을 경우
            upGraph[V2].push_back(make_pair(V1, d));
            downGraph[V2].push_back(make_pair(V1, d));
        }
        else if (hArr[V1] < hArr[V2]) { // V1의 높이가 더 낮은 경우
            upGraph[V1].push_back(make_pair(V2, d));
            downGraph[V1].push_back(make_pair(V2, d));
        }

    }

    Dijkstra(1, upArr, upGraph);
    Dijkstra(N, downArr, downGraph);

    for (int i = 1; i <= N; i++) {
        if (upArr[i] == INF || downArr[i] == INF) continue;
        temp = upArr[i] + downArr[i];
        result = max(result, hArr[i] * E - temp * D);
    }

    if (result == uINF) cout << "Impossible";
    else cout << result;
    
    return 0;
}

최악의 경우 예를 들어 N = 100,000 / M = 200,000 / h_i = i / 모든 경로 거리 1 / D = 1 / E = 100 이런 식이면

int 를 사용하면 터진다. ㅠㅠ

long long int 로 바꾸어주자

로직 문제로 오인해서 많이 틀렸다.

The post 백준 16681번 (등산, C++, Dijkstra) [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/1446

문제

매일 아침, 세준이는 학교에 가기 위해서 차를 타고 D킬로미터 길이의 고속도로를 지난다.

이 고속도로는 심각하게 커브가 많아서 정말 운전하기도 힘들다.

어느 날, 세준이는 이 고속도로에 지름길이 존재한다는 것을 알게 되었다.

모든 지름길은 일방통행이고, 고속도로를 역주행할 수는 없다.

세준이가 운전해야 하는 거리의 최솟값을 출력하시오.

입력

첫째 줄에 지름길의 개수 N과 고속도로의 길이 D가 주어진다.

N은 12 이하인 양의 정수이고, D는 10,000보다 작거나 같은 자연수이다.

다음 N개의 줄에 지름길의 시작 위치, 도착 위치, 지름길의 길이가 주어진다.

모든 위치와 길이는 10,000보다 작거나 같은 음이 아닌 정수이다.

지름길의 시작 위치는 도착 위치보다 작다.

출력

세준이가 운전해야하는 거리의 최솟값을 출력하시오.

예제 입력 1

5 150
0 50 10
0 50 20
50 100 10
100 151 10
110 140 90

예제 출력 1

70

예제 입력 2

2 100
10 60 40
50 90 20

예제 출력 2

80

예제 입력 3

8 900
0 10 9
20 60 45
80 190 100
50 70 15
160 180 14
140 160 14
420 901 5
450 900 0

예제 출력 3

432

출처

• 문제를 번역한 사람: baekjoon
• 문제를 다시 작성한 사람: jh05013

알고리즘 분류

• 다이나믹 프로그래밍
• 그래프 이론
• 데이크스트라

기본적인 로직은 Dujkstra 알고리즘을 기반으로 한다.

주의사항

주의할 점은 역주행이 불가능하다는 점 (현재 위치에서 지름길을 더한 값이 목적지를 넘어가면 안된다.)

또 지름길이 순서대로 이쁘게 주어지지 않는다. (정렬을 해서 처리하는 것도 하나의 방법)

내 풀이는 최단경로 테이블을 갱신하면 목적지 그 이후의 값을 dist[]가 더 적거나 목적지까지 +1 해주면서 업데이트 해주었다.

통과된 코드

#include <iostream>
#include <vector>

using namespace std;

constexpr int MAXN = 10001;

// 지름길의 개수 N, 고속도로의 길이 D
int N, D;

int A, B, C;

/*
각 노드에 연결되어 있는 노드에 대한 정보를 담는 벡터
a번 노드에서 b번 노드로 가는 비용이 c라는 의미
graph[a].push_back({b, c});
*/
vector<pair<int, int>> graph[MAXN];

// 임시 노드
int dist[MAXN];

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

	cin >> N >> D;

	for (int i = 0; i < N; i++) {
		cin >> A >> B >> C;
		graph[A].push_back(make_pair(B, C));
	}

	// 기본 초기화
	for (int i = 0; i < MAXN; i++) dist[i] = i;

	int now = 0;
	while (true) {

		if (now == D) { 
			// 목적지에 도착했으므로 결과를 출력
			cout << dist[now];
			break;
		}

		// 해당 노드에서 연결된 모든 경로를 확인
        for (int i = 0; i < graph[now].size(); i++) {

            // disSum = 임시 노드 + 현재 노드에서 i로가는 비용
            int disSum = dist[now] + graph[now][i].second;
			
			// 역주행을 해야할 경우는 continue
			if (disSum > D) continue; 


            // 비용이 더 작다면 최단경로 테이블 값을 갱신.
            if (disSum < dist[graph[now][i].first]) {
                // 임시 노드 업데이트
				dist[graph[now][i].first] = disSum;

				// 만약 업데이트 했다면 그 이후의 정점들을 순차적으로 올려준다.
				for (int j = graph[now][i].first + 1; j <= D ; j++) {
					// 만약  dist[j]이 더 작거나 같다면 최단거리가 있다는 의미 => Break
					if (disSum >= dist[j]) break;
					else dist[j] = ++disSum;
				}
            }
        }

		now++;
	}

	return 0;
}

dijkstra 알고리즘이 익숙하지 않아 해결하는데 오래 걸렸다…

The post 백준 1446번 (지름길, C++, Dijkstra) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

박스 채우기

www.acmicpc.net/problem/1493

문제

세준이는 length × width × height 크기의 박스를 가지고 있다.

그리고 세준이는 이 박스를 큐브를 이용해서 채우려고 한다.

큐브는 정육면체 모양이며, 한 변의 길이는 2의 제곱꼴이다.

(1×1×1, 2×2×2, 4×4×4, 8×8×8, …)

세준이가 가지고 있는 박스의 종류와 큐브의 종류와 개수가 주어졌을 때,

박스를 채우는데 필요한 큐브의 최소 개수를 출력하는 프로그램을 작성하시오.

입력

첫째 줄에 세 자연수 length width height가 주어진다.

둘째 줄에 세준이가 가지고 있는 큐브의 종류의 개수 N이 주어진다.

셋째 줄부터 총 N개의 줄에 큐브의 종류 Ai와 개수 Bi가 i가 증가하는 순서대로 주어진다.

큐브의 종류는 한 변의 길이를 나타낼 때 쓰는 2i에서 i이다.

출력

첫째 줄에 필요한 큐브의 개수의 최솟값을 출력한다.

만약 채울 수 없다면 -1을 출력한다.

제한

• 1 ≤ length, width, height ≤ 10⁶
• 1 ≤ n ≤ 20
• 0 ≤ A_i < 20
• 0 ≤ B_i ≤ 10⁶
• A_i ≠ A_j (i ≠ j)

예제 입력 1

4 4 8
3
0 10
1 10
2 1

예제 출력 1

9

예제 입력 2

4 4 8
3
0 10
1 10
2 10

예제 출력 2

2

예제 입력 3

10 10 11
1
0 2000

예제 출력 3

1100

예제 입력 4

10 10 11
1
0 1099

예제 출력 4

-1

예제 입력 5

37 42 59
6
0 143821
1 14382
2 1438
3 143
4 14
5 1

예제 출력 5

5061

출처

• 문제를 번역한 사람: baekjoon
• 문제의 오타를 찾은 사람: ho94949

알고리즘 분류

• 수학
• 그리디 알고리즘
• 분할 정복

length × width × height 크기의 박스

이 박스를 큐브로 채우려고 한다.

큐브의 크기는 정육면체 모양이며 한 변의 길이는 2의 제곱 꼴 1, 2, 4, 8…

박스를 채우는데 필요한 큐브의 최소 개수를 찾는 문제

4 4 8 // 박스 length × width × height

3 // 큐브의 개수

0 10 // 변의 길이 : 2^0 10개 넓이 1 10개

1 10 // 변의 길이 : 2^1 10개 넓이 8 10개

2 1 // 변의 길이 : 2^2 1개 넓이 64 1개

넓이 128 64 + 10 + 10 + 10 + 10 + 10 + 10

박스는 부피

큐브는 각 큐브의 한 변의 길이와 개수만 가지고 있으면 될 것 같다

박스가 큐브의 개수와는 상관없이

만들어질 수 있는 경우의 수를 조건과 비교하면서 하면 어떨까???

입력 확인

#include <iostream>
#include <set>

using namespace std;

// 큐브의 변의 길이 순으로 내림차순 정렬
set<int, greater<int>> cubeSet;
set<int, greater<int>> ::iterator iter;

// 큐브의 개수를 저장 / 인덱스는 2^index
int cubeNumber[21] = { 0 };

// 박스의 가 세 높
int length, width, height = 0;

// 박스의 부피
int boxArea = 0;

// 큐브의 종류 , 큐브의 수
int type, Number = 0;

void Initializaion()
{
	cin >> length >> width >> height;
	boxArea = length * width * height;
	int N = 0;
	cin >> N;
	while (N > 0)
	{
		cin >> type >> Number;
		cubeSet.insert(type);
		cubeNumber[type] += Number;
		N--;
	}
}

int main()
{
	Initializaion();
	cout << "박스의 부피 : " << boxArea << "\n";
	for (iter = cubeSet.begin(); iter != cubeSet.end(); iter++)
	{
		cout << "큐브 변의 길이 2^ " << *iter << "   박스의 개수 :  " << cubeNumber[*iter] << " \n";
	}
    
	return 0;
}

마지막 테스트 케이스에서 망… 함 ㅠ

부피로 접근하는 방법은 잘못된 방법이다

큐브들의 부피가 박스의 부피와 같다고 큐브가 박스 모양일 거라는 착각…

잘못된 로직과 코드 1

#include <iostream>
#include <set>
#include <cmath>

using namespace std;

// 큐브의 변의 길이 순으로 내림차순 정렬
set<int, greater<int>> cubeSet;
set<int, greater<int>> ::iterator iter;

// 큐브의 개수를 저장 / 인덱스는 2^index
int cubeNumber[21] = { 0 };

// 박스의 가 세 높
int length, width, height = 0;

// 박스의 넓이
int boxArea = 0;

// 큐브의 종류 , 큐브의 수
int type, Number = 0;


void Initializaion()
{
	cin >> length >> width >> height;
	boxArea = length * width * height;
	int N = 0;
	cin >> N;
	while (N > 0)
	{
		cin >> type >> Number;
		cubeSet.insert(type);
		cubeNumber[type] += Number;
		N--;
	}
}

void CubeCheck(int cnt, int value)
{

	if (value == boxArea)
	{
		cout << "찾았다 : " << cnt << "  boxArea : " << boxArea <<  "  value : " << value << "\n";
		for (auto it = cubeSet.begin(); it != cubeSet.end(); it++)
		{
			cout << "it : " << *it << "  cubeNumber[*it] : " << cubeNumber[*it] << "\n";
		}
		exit(0);
	}

	for (auto it = cubeSet.begin(); it != cubeSet.end(); it++)
	{
		if (cubeNumber[*it] == 0 || value > boxArea )
		{
			return;
		}
		//cout << "cubeNumber[" << *it << "]  : " << cubeNumber[*it] << "\n";
		cubeNumber[*it]--;
		//cout << "cnt : " << cnt << " 들어갈 때 : " << value << " ";
		CubeCheck(cnt + 1, value + pow(pow(2,*it),3));
		cubeNumber[*it]++;
	}
	cout << -1;
	exit(0);
}

int main()
{
	Initializaion();
	CubeCheck(0, 0);
	return 0;
}

그렇다면 박스에서 접근해야 한다.

박스를 큐브의 규격을 기준으로 분할하여 그리디 알고리즘을 적용하면서 푸는 것 인가?

잘못된 로직과 코드 2

#include <iostream>
#include <set>
#include <cmath>
#include <algorithm>

using namespace std;

// 큐브의 변의 길이 순으로 내림차순 정렬
set<int, greater<int>> cubeSet;
set<int, greater<int>> ::iterator iter;

// 큐브의 개수를 저장 / 인덱스는 2^index
int cubeNumber[21] = { 0 };
int cubeNeedNumber[21] = { 0 };

// 박스의 X,Y,Z
int BoxXYZ[3] = { 0 };
int temp[3] = { 0 };

// 큐브의 종류 , 큐브의 수
int type, Number = 0;

int cubeCNT = 0;

void Initializaion()
{

	cin >> BoxXYZ[0] >> BoxXYZ[1] >> BoxXYZ[2];
	sort(BoxXYZ, BoxXYZ + (sizeof(BoxXYZ)/sizeof(BoxXYZ[0])));
	int N = 0;
	cin >> N;
	while (N > 0)
	{
		cin >> type >> Number;
		cubeSet.insert(type);
		cubeNumber[type] += Number;
		N--;
	}
}

// 가장 큰 X를 기준으로 Z를 채워나감
// 들어오는 값은 X의 길이/Z의 남은 길이/ 몇번 나누었는지 확인(0부터 시작)
// 이 함수의 목적은 Z가 0이 될때까지 큐브를 찾는 것
void CubeCheckZ(int N, int leftZ, int divisionCount, int st)
{

	for (;leftZ >= pow(2, N);)
	{
		cout << "leftZ : " << leftZ << " pow(2, N) : " << pow(2, N) << "\n";
		if (divisionCount == 0 && st == pow(2, N))
		{
			BoxXYZ[2] -= st;
			st = -1;
		}
		
		if (st == -1)
		{
			cubeNeedNumber[N] += pow(4, divisionCount);
		}
		else
		{
			cubeNeedNumber[N] += pow(4, divisionCount) * (st / pow(2, N));
		}

		leftZ -= pow(2, N);
		
		if (leftZ == 0)
		{
			return;
		}
	}

	// 남은 Z의 길이보다 pow(2, N)가 더 큰 상황 
	for (;leftZ < pow(2, N);)
	{
		N--;
		divisionCount++;
		cout << "남은 Z의 길이보다 작은 박스 값 찾기 : " << " N : " << N << "  pow(2, N) : " << pow(2, N) << "  leftZ  :  " << leftZ << "\n";
	}

	CubeCheckZ(N, leftZ, divisionCount, st);
}


// 박스 전체의 X길이와 Z의 길이
void CubeCheckX(int BoxX, int BoxZ, int st, int boxY)
{
	if (BoxX == 0)
	{
		return;
	}
	// 처음 할 때
	int N = 0;
	for (int i = 0; i <= 20; i++)
	{
		if (boxY < pow(2, i))
		{
			N = i - 1;
			break;
		}
		else if (boxY == pow(2, i))
		{
			N = i;
			break;
		}
		
		//X의 값에 가장 근접한 2^i 를 구함
		if (BoxX < pow(2, i) )
		{

			N = i - 1;
			cout << "높을때 : " << N ;
			//cubeNeedNumber[N]++;
			break;

		}
		else if (BoxX == pow(2, i) )
		{
			//cout << "BoxX : " << BoxX << " 같을때" << N;
			N = i;
			//cubeNeedNumber[N]++;
			break;
		}
	}
	
	if (st <= pow(2,N))
	{
		st = pow(2, N);
	}

	// 박스의 Z길이보다 작거나 같은 2^N 의 N / 박스의 Z 길이 
	BoxX -= pow(2, N);
	CubeCheckZ(N , BoxZ, 0, st);
	cout << "BoxX  :  " << BoxX << "\n";
	CubeCheckX(BoxX, BoxZ, st, boxY);
}





int main()
{
	Initializaion();

	for (;BoxXYZ[2] > 0;)
	{
		CubeCheckX(BoxXYZ[0], BoxXYZ[1], 0, BoxXYZ[2]);
		cout << "BoxXYZ[2] : " << BoxXYZ[2] << "\n";
	}


	for (iter = cubeSet.begin(); iter != cubeSet.end(); iter++)
	{
		cout << "cubeNeedNumber[" << *iter << "]  : " << cubeNeedNumber[*iter] << "\n";

	}
	return 0;
}

잘못된 로직과 코드 3

작성하다 보니 내가 왜 이렇게 작성했는지 이해할 수 없다.

#include <iostream>
#include <set>
#include <cmath>
#include <algorithm>

using namespace std;

set<int, greater<int>> cubeSet;
set<int, greater<int>> ::iterator iter;

int cubeNumber[21] = { 0 };
int cubeNeedNumber[21] = { 0 };

long long BoxXYZ[3] = { 0 };

int type, Number = 0;

void Initializaion()
{

	cin >> BoxXYZ[0] >> BoxXYZ[1] >> BoxXYZ[2];
	
	sort(BoxXYZ, BoxXYZ + (sizeof(BoxXYZ)/sizeof(BoxXYZ[0])));
	int N = 0;
	cin >> N;
	while (N > 0)
	{
		cin >> type >> Number;
		
		cubeSet.insert(type);
		cubeNumber[type] += Number;
		N--;
	}
}

void CubeCheckZ(long long N, long long leftZ, long long divisionCount, long long MaxX, bool firstCheck)
{

	for (;leftZ >= pow(2, N);)
	{
		if (MaxX == pow(2, N) || leftZ >= pow(2, N) && firstCheck)
		{ 
			if (N == 0)
			{
				cubeNeedNumber[N] += leftZ;
				leftZ = 0;
				continue;
			}
			cubeNeedNumber[N] += pow(4, divisionCount);
			cout << "pow(4, divisionCount) : " << pow(4, divisionCount) << "  divisionCount  :  " << divisionCount << "  N :   "<< N << "\n";
			leftZ -= pow(2, N);
			continue;
		}

		if (leftZ >= pow(2, N) && !firstCheck)
		{
			if (N == 0)
			{
				cubeNeedNumber[N] += leftZ * MaxX / pow(2, N);
				leftZ = 0;
				continue;
			}
			cubeNeedNumber[N] += MaxX / pow(2, N);
			cout << "MaxX / pow(2, N) :  " << MaxX / pow(2, N) << "  " << MaxX << "  /  " << pow(2, N) << "\n";
			leftZ -= pow(2, N);

		}
	}

	if (leftZ == 0)
	{
		cout << "leftZ :  " << leftZ << "\n";
		return;
	}


	while(leftZ < pow(2, N))
	{
		N--;
		divisionCount++;
	}
	CubeCheckZ(N, leftZ, divisionCount, MaxX, firstCheck);
}

void CubeCheckX(long long BoxX, long long BoxZ, long long MaxX, long long boxY, bool firstCheck)
{
	if (BoxX == 0)
	{   
		BoxXYZ[2] -= MaxX;
		return;
	}

	int N = 0;
	for (int i = 0; i <= 20; i++)
	{
		if (BoxX < pow(2, i) || (BoxXYZ[2] < pow(2, i)))
		{
			N = i - 1;
			BoxX -= pow(2, N);
			break;
		}
		else if (BoxX == pow(2, i) || (BoxXYZ[2] == pow(2, i)))
		{
			N = i;
			BoxX -= pow(2, N);
			break;
		}
	}
	
	if (MaxX < pow(2,N))
	{
		MaxX = pow(2, N);
	}
	
	CubeCheckZ(N , BoxZ, 0, MaxX, firstCheck);
	firstCheck = false;
	CubeCheckX(BoxX , BoxZ, MaxX, boxY, firstCheck);
}

int main()
{
	Initializaion();
	
	while (BoxXYZ[2] != 0)
	{
		CubeCheckX(BoxXYZ[0], BoxXYZ[1], 0, BoxXYZ[2], true);
		cout << BoxXYZ[2] << " \n";
	}

	for (iter = cubeSet.begin(); iter != cubeSet.end(); iter++)
	{
		cout << "cubeNeedNumber[" << *iter << "]  : " << cubeNeedNumber[*iter] << "\n";
	}

	return 0;
}

통과된 코드

위와 같이 분할 된 박스를 다시 분할 X, Y, Z 가 0일 때까지

상자의 개수 조건에 부합하지 않으면 체크하고 -1 출력

#include <iostream>
#include <map>
#include <cmath>

using namespace std;

//cubeMultimap 은 내림차순으로 정렬된다. 
multimap<int, int, greater<int>> cubeMultimap;
//cubeMultimap 순회를 위한 반복자
multimap<int, int, greater<int>>::iterator iter;


int length, width, height;
int numberOfCubes, cnt = 0;
int tempOne, tempTwo;
bool failCheck = false;

// 조건을 초기화 해주는 함수
void Initializaion()
{
	cin >> length >> width >> height >> numberOfCubes;
	while (numberOfCubes > 0)
	{
		cin >> tempOne >> tempTwo;
		cubeMultimap.insert(make_pair(pow(2, tempOne), tempTwo));
		numberOfCubes--;
	}
}

// 분할 정복을 위한 함수 (X, Y, Z, 반복자)
void divisionConquest(int length, int width, int height, multimap<int, int, greater<int>>::iterator iter)
{
	// 만약 X, Y, Z 중에서 0이 되는 값이 있다면 리턴
	if (length == 0 || width == 0 || height == 0) return;

    // 분할정복 로직부분
	for (;iter != cubeMultimap.end(); iter++)
	{
		if (iter->second != 0 && length >= iter->first && width >= iter->first && height >= iter->first)
		{
			iter->second--;
			cnt++;
			divisionConquest(iter->first, iter->first, width - (iter->first), iter);
			divisionConquest(length - iter->first, height, width, iter);
			divisionConquest(height - iter->first, width, iter->first, iter);
			return;
		}
	}

	// 만약 큐브의 조건이 만족하지 않는다면 실패 마킹
	failCheck = true;
	return;
}


int main()
{

	Initializaion();

	// cubeMultimap의 가장 높은 값부터 시작
	iter = cubeMultimap.begin();
	divisionConquest(length, width, height, iter);

	// 실패 마킹이 true 면 항상 -1 출력
	if (failCheck) cout << -1;
	else cout << cnt; // 아니면 큐브의 개수를 출력한다.

	return 0;
}

분할 정복의 개념과 구현 방법은 몰라서 오래 고민한 문제

재귀 구현 어려웠다.

The post 백준 1493번 (박스 채우기, C++, 분할 정복) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

강의실 배정

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

문제

수강 신청의 마스터 김종혜 선생님에게 새로운 과제가 주어졌다. 
김종혜 선생님한테는 S_i에 시작해서 T_i에 끝나는 N개의 수업이 주어지는데,
최소의 강의실을 사용해서 모든 수업을 가능하게 해야 한다. 
참고로, 수업이 끝난 직후에 다음 수업을 시작할 수 있다.
(즉, T_i ≤ S_j 일 경우 i 수업과 j 수업은 같이 들을 수 있다.)
수강 신청 대충 한 게 찔리면, 선생님을 도와드리자!

입력

첫 번째 줄에 N이 주어진다. (1 ≤ N ≤ 200,000)
이후 N개의 줄에 S_i, T_i가 주어진다. (0 ≤ S_i < T_i ≤ 10⁹)

출력

강의실의 개수를 출력하라.

예제 입력 1

3
1 3
2 4
3 5

예제 출력 1

2

출처

• 문제를 만든 사람: koosaga
• 데이터를 추가한 사람: zlzmsrhak

알고리즘 분류

• 자료 구조
• 그리디 알고리즘
• 정렬
• 우선순위 큐

추가 반례

예제 입력 A

5
1 7
2 3
3 4
4 8
7 10

예제 출력 A

2

예제 입력 B

3
999999999 1000000000
999999998 999999999 
1 999999998

예제 출력 B

1

예제 입력 C

3
999999999 1000000000
999999998 999999999 
1 999999998

예제 출력 C

1

예제 입력 D

4
1 2
1 4
2 6
4 5

예제 출력 D

2

예제 입력 E

6
4 12
7 11
9 10
7 8
2 5
1 3

예제 출력 E

3

Si ~ Ti에 끝나는 N개의 수업

최소의 강의실을 사용하여 모든 수업을 한다

수업이 끝난 직후에 다음 수업을 시작할 수 있다.

즉 Ti <= Sj 일 경우 i 수업과 j수업을 같이 들을 수 있다.

1 ≤ N ≤ 200,000

0 ≤ Si < Ti ≤ 109

무슨 소리야?

항상 문제를 이해하는 것이 가장 어렵다

멀티맵의
key 값을 시작 값
value값을 끝나는 값으로 설정하면서
해당 value 값과 다른 key 값이 같으면 해당 맵을 지우고 value를 바꾸어주면 어떨까?

#include <iostream>
#include <map>

using namespace std;

multimap<int, int> curriculum;

void Initialization()
{
	int N = 0;
	int S = 0;
	int T = 0;
	cin >> N;

	while (N > 0)
	{
		cin >> S >> T;
		curriculum.insert({ S,T });
		N--;
	}
}

int main()
{
    // 초기화
	Initialization();
    
    // 멀티맵 출력 
	for (auto& elem : curriculum)
	{
		cout << " S : " << elem.first << " T : " << elem.second << "\n";
	}

	return 0;
}

틀린 코드 1

#include <iostream>
#include <map>

using namespace std;

multimap<int, int> curriculumMultiMap;
multimap<int, int>::iterator it;

int result = 0;

void Initialization()
{
	int N = 0;
	int S = 0;
	int T = 0;
	cin >> N;
	result = N;
	while (N > 0)
	{
		cin >> S >> T;
		curriculumMultiMap.insert({ S,T });
		N--;
	}
}

int main()
{
	Initialization();
	
	// key 값이 낮은 값부터 시작
	for (auto& elem : curriculumMultiMap)
	{
		//cout << " S : " << elem.first << " T : " << elem.second << "\n";
		for (it = curriculumMultiMap.lower_bound(elem.second);it != curriculumMultiMap.end(); it++)
		{
			elem.second = it->second;
			cout << elem.second;
			result--;
			curriculumMultiMap.erase(it->first);
		}
	}
	cout << result;
	return 0;
}

wordbe.tistory.com/entry/STL-erase <- 참고글

연관 컨테이너의 경우(Associate container)
: set, map, multiset, multimap의 경우.
컨테이너의 어떤 요소가 erase 될 때, 이 요소를 가리키고 있는 모든 반복자들이 무효화됩니다.
c.erase(i)가 복귀하자마자 i는 바로 무효화됩니다.
따라서 루프에 있는 ++i는 무효화되어 에러가 납니다.
이를 해결하기 위해서는,
erase를 호출하기 전에 반복자 i가 c의 다음 요소를 가리키도록 세팅하면 됩니다.

틀린 코드 2

#include <iostream>
#include <map>

using namespace std;

multimap<int, int> curriculumMultiMap;
int result = 0;

void Initialization()
{
	int N = 0;
	int S = 0;
	int T = 0;
	cin >> N;
	while (N > 0)
	{
		cin >> S >> T;
		curriculumMultiMap.insert({ S,T });
		N--;
	}
}

int main()
{
	Initialization();

	for (auto& elem : curriculumMultiMap)
	{
		cout << "elem.first" << elem.first << "\n";
		for (auto it = curriculumMultiMap.lower_bound(elem.second);it != curriculumMultiMap.end();)
		{
			if (elem.second <= it->first)
			{
				cout << "elem.first : " << elem.first << " elem.second : " << elem.second << " it->first : " << it->first << " it->second : " << it->second << "\n";
				elem.second = it->second;
				curriculumMultiMap.erase(it++);
			}
			else
			{
				it++;
			}
		}
		result++;
	}



	cout << result;
	return 0;
}

multimap으로 풀었지만 시간 초과 벗어날 수 없어서 포기….
insert
erase
의 속도가 느리다…

시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간초과시간

틀린 코드 3

#include <iostream>
#include <set>
#include <queue>

using namespace std;

priority_queue < pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> myQueue;

int result = 1;
pair<int, int> mypair;
multiset<int> mymultiset;

void Initialization()
{
	int N = 0;
	int S = 0;
	int T = 0;
	
	cin >> N;
	while (N > 0)
	{
		cin >> S >> T;
		myQueue.push(make_pair(S, T));
		N--;
	}
}

int main()
{
	Initialization();
	mypair = myQueue.top();
	myQueue.pop();
	mymultiset.insert(mypair.second);

	while (!myQueue.empty())
	{
		mypair = myQueue.top();
		myQueue.pop();
		for (auto iter = mymultiset.begin();iter != mymultiset.end();iter++)
		{
			if (mypair.first < *iter)
			{
				mymultiset.insert(mypair.second);
				result++;
				break;
			}
			
			if (mypair.first >= *iter)
			{
				mymultiset.erase(*iter);
				mymultiset.insert(mypair.second);
				break;
			}
		}
	}
	
	cout << result;
	return 0;
}

우선 수업들을 Priority_Queue에 넣고 강의의 시작 시간을 기준으로 오름차순 정렬해준다. 
(내 풀이에서는 7 8 / 7 11의 순서는 의미가 없다.)

처음에는 무조건 Priority_Queue에서 하나의 pair 값을 꺼내고 Multiset에 강의가 끝나는 시간을 넣어준다.

그 다음 Priority_Queue에서 하나의 pair 값을 꺼내고
강의 시작 시간(first)과 Multiset에서 가장 작은 수와 비교한다.
만약 강의의 시작 시간이 Multiset의 가장 낮은 수와 비교하여 작을 경우 강의실에 끝나는 시간을 추가해준다.

그 다음 Priority_Queue 에서 하나의 pair 값을 꺼내고
강의 시작 시간(first)과 Multiset에서 가장 작은 수와 비교한다.
만약 강의의 시작 시간이 Multiset의 가장 낮은 수와 비교하여 크다면
Multiset에서 강의 시작 시간(first) 보다 작거나 같은 수 중에서 제일 높은 숫자를 Multiset에서 지우고
-> 강의가 끝나고 같은 강의실에서 다음 수업을 진행한다는 의미
강의가 끝나는 시간을 Multiset에 추가한다.

해당 과정을  Queue가 비어있을 때까지 진행한다.

알고리즘을 생각하는 시간보다 iterator 사용법을 익히는 시간이 더 들었다.

통과된 코드

#include <iostream>
#include <set>
#include <queue>

using namespace std;

//우선 순위 Q를 사용하여 입력값을 정렬해준다.
priority_queue < pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> myQueue;

int result = 1;

// 강의들을 저장해 놓음
pair<int, int> mypair;

// 멀티맵을 사용하기 위한 준비
multiset<int> mymultiset;
multiset<int>::iterator iter;

// 입력값 초기화 함수
void Initialization()
{
	int N = 0;
	int S = 0;
	int T = 0;
	cin >> N;
	while (N > 0)
	{
		cin >> S >> T;
		myQueue.push(make_pair(S, T));
		N--;
	}
}

int main()
{
	// 입력값을 받아줍니다.
	Initialization();
	mypair = myQueue.top();
	myQueue.pop();
	mymultiset.insert(mypair.second);

	while (!myQueue.empty())
	{
		mypair = myQueue.top();
		myQueue.pop();
	 
		if (mypair.first < *mymultiset.begin())
		{
			mymultiset.insert(mypair.second);
			result++;
			continue;
		}

		iter = mymultiset.lower_bound(mypair.first);

		// 값이 같을 때도 같이 set에서 제거하고 페어를 추가해준다.
		if (*iter == mypair.first)
		{
			mymultiset.erase(iter);
		}
		else
		{
			mymultiset.erase(--iter);
		}
		
		mymultiset.insert(mypair.second);
	}
    
	cout << result;
    
	return 0;
}

The post 백준 11000번 (강의실 배정, C++, Greedy) / 추가 반례 [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.