얍문's Coding World..

[ 백준 23291 ] 어항정리 (C++)

얍문 — Tue, 22 Mar 2022 15:27:58 +0900

백준의 어항정리(23291) 문제이다.

( 문제 풀이가 생각보다 많이 길어요... 구현해야 할 것도 많고... 복잡하기도 해서요..!!)

[ 문제풀이 ]

문제가 매우 많이... 조금 더러운 것 같다... 시키는 대로 몇 번의 행동을 했을 때 답을 도출할 수 있냐를 물어보는 것 같다... 해야할 게 너무 많아서 문제를 한 문장으로 요약하기도 쉽지 않은 것 같다...

구현이 전부인 문제이기 때문에 그 과정에서 사용되는 동작방식, 사용하는 자료구조와 같은 부분들은 자신이 가장 편하고 자신있는 부분으로 하면 되지만, 이 글에서는 본인이 사용했던 방법에 대해서 이야기해보고자 한다.

문제를 풀기 위해서 어떤 자료구조와 어떤 자료형으로 필요한 변수들을 선언했는지, 그리고 이 변수들로 어떻게 중간 과정들을 진행했는지 하나하나씩 이야기해보자.

#1. 필요한 정보

필요한 정보라는 타이틀을 만들만큼 사실 필요한 변수들이 많지는 않다. 딱 하나 뿐이다. 바로 "어항"을 어떻게 무슨 자료형으로 어떻게 관리할 것인지에 대해서만 이야기를 해보자.

어항을 어떤 자료형으로 만들지 이야기를 하기 전에 우리가 이 문제에서 앞으로 이 어항으로 뭘 해야 하는지를 이야기 해보자.

이 문제를 구현할 때 우리는 어항으로 다음과 같은 상황들을 구현해야 한다.

1. 물고기 수가 가장 적은 어항에 물고기 추가하기

2. 어항 회전시키면서 공중부양 시키기

3. 공중부양 시킨 어항 다시 펼치기

4. 또 다른 방식으로 공중부양 시키기

5. 물고기 수 조절하기

6. 다시 펼치기

뭐 이렇게 6가지 기능을 구현해야 한다. 그런데 딱 봐도 1번은 어떤 자료형을 사용하던지 크게 상관이 없을 것 같다.

그냥 모든 어항을 탐색하면서 물고기 수가 가장 적은 곳만 찾아서 더해주기만 하면 된다.

하지만 ! "Index 접근이 가능한 자료구조" 라면 더 좋을 것 같다. 왜냐하면, Index를 저장할 수 없다면 전체 어항을 탐색하면서 물고기가 가장 적은 어항들을 찾고, 다시 한번 탐색하면서 그 가장 적은 어항들에게 물고기를 추가해줘야 하기 때문이다.

뭐, 이렇게 하더라도 상관은 없지만 Index로 접근을 할 수 있다면, 가장 적은 어항들을 찾을 때, 해당 어항들의 Index번호만 저장해 놓고 해당 Index에 바로 접근해서 물고기를 추가해주기만 하면 되기 때문이다.

그 다음은 2 , 4번과 3 , 6을 통일 시켜서 생각을 해보자. 어차피 2, 4번은 방식은 약간 다르지만 결국 어항을 회전시키면서 공중부양 시켜야 되는 부분이고, 3 , 6번은 공중부양된 어항들을 다시 펼치는 기능이기 때문이다.

먼저, 어항을 회전시키면서 공중 부양을 시키는 과정을 생각해보자.

우리가 문제에서 읽은 그림처럼 저렇게 세로로 여러줄을 쌓는 그림을 코드로 표현하려면... 어떤 방법이 가장 좋을까..???

본인은 가장 먼저 2차원 배열을 생각했었다. 2차원 배열을 통해서 마치 하나의 맵 처럼 표현을 하고, 어항이 위로 쌓일 때 마다 실제 그림처럼 위로는 쌓지 못하지만 2차원 배열에서 그 다음 행에다가 데이터를 추가해주면 아래로 쌓이는 것 처럼 보이겠지만 어항을 공중부양 시키는 과정은 표현할 수 있을 거라 생각했다. 2차원 배열로 이 과정을 정말 대략적으로 그려보면 다음과 같이 그려질 것이다.

가장 초기 상태를 위의 그림과 같이 그리게 되면 어항이 다음과 같이 쌓이는 것이다.

위의 그림들과 같이 저렇게 아래쪽으로 쌓이게 되는 것이다. 그런데 가장 큰 단점이 하나 있다.

따로 시작점을 관리를 해주거나, 어항을 쌓을 때 마다 전체 배열을 옮기거나 둘 중 하나를 해줘야 한다는 것이다.

위의 그림에서 연한 회색들로 채워져 있는 어항들을 보자. 저 어항들은 이미 쌓여서 더 이상 가장 아래층(0행)에 존재하지 않는 어항들이다. 그리고 쌓여감으로 인해서 사라지는 어항들 때문에 배열의 시작점이 바뀌게 될 것이다.

이러한 부분들에 대해서 관리를 따로 해주어야 한다는 단점이 있다. 하지만, 1번 구현사항에서 이야기 했듯이 "Index에 접근"도 배열은 용이한 편이기 때문에 일단은 첫 번째로 "2차원 배열"을 생각해볼 수 있는 것 같다.

이 외에 Queue , Vector , list와 같은 자료구조들을 생각해 봤는데 Queue같은 경우에는 Index접근도 안되고 데이터의 삽입 삭제가 가장 앞과 뒤에서 밖에 할 수 없다는 점, Vector는 Index접근은 가능하지만 데이터의 삽입 삭제가 가장 뒤에서만 일어날 수 있다는 점(물론 erase함수를 사용하면 중간 삭제도 가능은 함..), list 같은 경우에는 Index접근이 되지 않는다는 점 등의 단점들이 있어서 별로 내키지 않았다.

그래서 배열로 하려고 보니 위에서 언급한 배열이 가지는 단점들 때문에 또 다른 방법을 생각하게 되었다.

결국 본인은 "Deque" 자료구조를 이용해서 어항을 관리해 주었다.

Deque에 대해서 간단하게만 이야기해보자면, Queue와는 다르게 Index의 접근이 가능한 자료구조이다. 즉, 우리가 이야기한 1번 구현사항을 만족하는 자료구조이다. 두 번째로, 데이터의 삽입과 삭제가 앞 뒤로 자유자재로 가능하다.

우리가 배열로 하게 되면 데이터를 삽입할 때 시작점을 따로 관리해 주거나, 실제로 삭제를 해버리고 전체 배열을 앞땡기거나 뒤로 밀거나 하는 과정이 필요하다고 이야기했는데, 이 과정을 이렇게 하는것이 아닌 Deque를 통해서 실제로 데이터를 삭제해버리고 그 다음 행에 삽입을 해버리는 식으로 생각을 한 것이다. 이렇게 되면 배열처럼 시작점을 관리한다거나 전체 데이터를 미루고 땡기고 하는 과정 또한 필요가 없어지게 된다.

데이터의 삽입 삭제가 앞/뒤에서 자유자재 가능하냐 아니냐 이런 이야기를 아까부터 계속 하고 있는데 이 부분에 대한 이야기는 밑에서 각각의 단계별로 이야기를 하면서 구체적으로 이야기해보자. 결국 ! 본인은 Deque로 어항들을 관리해 주었고 Deque 배열을 통해서 어항이 쌓이는 과정들을 대비해 주었다.

#define MAX 110
deque<int> bowl[MAX];

위와 같이 deque 배열을 선언해놓고 1층을 0번 Index로 그리고 어항이 쌓이면 쌓일수록 위의 배열 그림과 같이 1번, 2번, 3번 Index 순으로 계속해서 값을 넣으면서 쌓아갈 것이다.

#2. 어항에 물고기 추가하기

이제부터 본격적으로 각 과정들에 대해서 이해해보도록 하자.

가장 먼저, 물고기를 추가하는 과정을 진행해보자. 이 부분은 간단하다. 모든 어항이 다 펼쳐진 한 줄로만 이루어진 상태에서는 어항은 0번 Index에 밖에 존재하질 않는다. 따라서, deque의 0번 Index에 접근해서 모든 어항을 탐색하면서 물고기의 수를 카운팅 하면서 가장 적은 어항의 Index번호를 저장한 후에 물고기를 추가해 주었다. 코드로 나타내면 다음과 같다.

void addFish() {
	int minFish = 987654321;
	vector<int> idxV;
	for (int i = 0; i < bowl[0].size(); i++) {
		if (bowl[0][i] < minFish) {
			minFish = bowl[0][i];
			idxV.clear();
			idxV.push_back(i);
		} else if (bowl[0][i] == minFish) {
			idxV.push_back(i);
		}
	}

	for (auto idx : idxV) {
		bowl[0][idx]++;
	}
}

#3. 어항 쌓기

이 문제에서 가장 골치 아픈 부분이라고 생각한다.. 본인은 그랬기 때문이다.

먼저 어항을 쌓는 법에 대해서 다시한번 이야기를 해보고 시작하자.

1. 가장 왼쪽에 있는 어항을 그 어항의 오른쪽 어항 위에 올려놓는다.

2. 2개 이상 쌓여있는 어항을 모두 공중부양 시킨 후, 시계방향으로 90도 회전시킨다.

3. 90도 회전시킨 어항들을 바닥에 있는 어항의 위에 올려놓는다.

4. 위의 과정을 공중부양 시킨 어항들을 쌓았을 때, 바닥에 어항이 있을 때 까지 반복한다.

그럼 한번 그림으로 나타내면서 같이 한번 진행해보자.

위와 같이 어항이 존재한다고 생각해보자.

가장 처음에 공중 부양 시켜야 될 어항에 대해서 이야기를 해보자. 위의 그림에서 'A' 어항이 될 것이다.

그리고 이 때, 공중부양 시켜야 할 어항의 크기에 대해서 생각을 해보면 다음과 같다.

바로 가로의 길이 = 1 , 세로의 길이 = 1 인 어항을 공중 부양 시켜야 하는 상황이다.

그럼 공중부양 시켜서 90도 회전 후 올리게 되면 다음과 같이 된다.

이 다음 턴에 공중 부양을 시켜야 될 어항들의 크기를 한번 살펴보면 다음과 같다.

(가로의 길이 , 세로의 길이) 가 (1 , 1)에서 (1 , 2)로 바뀌게 되었다.

그리고 90도 회전 시킨 후 어항을 올리게 되면 다음과 같아진다.

위와 같이 될 텐데 이제 이 다음 턴에서 공중 부양 시켜야 할 어항의 크기를 살펴보자.

(가로의 길이 , 세로의 길이) 가 (1 , 2)에서 (2 , 2)로 바뀌게 되었다.

마지막으로 한번만 더 해보자. 이 상태에서 저 4개의 어항을 공중부양 시킨 후 , 90도 회전 시켜서 올리게 되면 다음과 같아진다.

(가로의 길이 , 세로의 길이)가 (2 , 3)으로 바뀌게 되었다. 그리고 우리는 더 어항을 쌓을 수가 없다. 그럼 지금까지 어항을 쌓아가면서 크기를 계속해서 적어보았는데 이를 정리해서 한번 살펴보자.

쌓아야 할 어항의 (가로의 길이 , 세로의 길이) 가

(1 , 1) - (1 , 2) - (2 , 2) - (2 , 3) ... 의 순서로 바뀌게 되는 것을 확인했다. 우리는 여기서 규칙을 하나 찾을 수 있다.

각 턴이 진행됨에 따라 순차적으로 세로의 길이 + 1 , 가로의 길이 + 1 , 세로의 길이 + 1 , 가로의 길이 + 1 ... 의 패턴을 가지고 있다는 것을 알 수 있다. (1 , 1)에서 세로의 길이가 + 1 됨에 따라 (1 , 2)가 되었고, 이 상태에서 가로의 길이가 + 1 됨에 따라 ( 2 , 2)가 되었고 이 상태에서 세로의 길이가 + 1 됨에 따라 (2 , 3)이 되었다. 이런식의 규칙을 가지고 있다.

그런데 이 가로와 세로의 길이가 늘어난다는 규칙은 알겠는데 이를 어디다가 써먹을 수 있을까 ??

1. 어항을 더 이상 쌓지 못하는 순간에 대한 계산을 할 수 있다. 즉, 기저조건에 대해서 쉽게 파악할 수 있다.

더 이상 어항을 쌓지 못하는 순간을 어떻게 계산할 수 있을까 ?? 가장 위에 있는 가로의 길이 = 2 , 세로의 길이 = 3 인 순간을 한번 살펴보자. 저 상황에서 더 이상 어항을 쌓지는 못하게 된다. 이를 가로의 길이와 세로의 길이를 통해서 어떻게 알 수 있을까 ??

"더 이상 어항을 쌓을 수 있냐 없냐" 는 문제에서 제시한 바에 따르면 "쌓은 모든 어항 아래에 어항이 존재하냐 안하냐" 로 파악을 할 수 있고, 어항을 쌓게 될 때 쌓은 모든 어항 아래에 어항이 존재하는지 안하는지는 "쌓을 어항의 가로 길이보단 세로 길이에 영향" 을 미치게 된다. 왜냐하면 어항을 "90도로 회전 시킨 후, 어항을 쌓기 때문" 이다. 이를 쉽게 이해하기 위해서 위의 그림을 조금만 수정해보자.

위와 같이 되어있었다면 어항을 더 쌓을 수 있었을 것이다. 다음과 같이 !

쌓게 되면 쌓기 전에 세로의 길이였던 3이 쌓은 후에 가로의 길이인 3이 된다. 즉 ! 쌓을 어항의 세로 길이가 쌓은 후의 가로 길이가 되기 때문에 우리는 아래에 어항이 존재하는지는 쌓을 어항의 세로 길이로 판단할 수 있다. 어떻게 ??

위의 그림을 우리가 표현하고 있는 Deque로 나타내보면 다음과 같은 상태이다.

Deque[0] = { E , F , G , H }

Deque[1] = { D , A }

Deque[2] = { C , B }

그리고 어항을 쌓게 되면 Deque[0]에서 "2개" 가 빠지게 되고, 쌓은 어항의 가로길이는 현재의 세로길이인 "3"이 된다.

즉, Deque[0]의 현재 길이인 '4'에서 쌓을 어항의 가로 길이인 "2"만큼 감소한 값이 현재의 세로길이인 "3"보다 작기 때문에 더 이상 어항을 쌓을 수 없다는 것을 알 수 있다.

정리해보면.. Deque[0].size() - width < height 인 경우에 더 이상의 어항을 쌓을 수 없다는 것이다. 우리는 이렇게 가로와 세로 길이를 통해서 어항을 더 이상 쌓을 수 있는지 없는지를 판단할 수 있다. 이를 코드로 나타내면 다음과 같이 표현이 가능하다.

bool canBuild(int w, int h) {
	if (bowl[0].size() - w < h) {
		return false;
	}
	return true;
}

2. 공중 부양 시킨 후 90도 회전 시켜서 쌓기

가로와 세로 길이를 통해서 이 과정 또한 접근을 할 수가 있다. 물론 머리가 조금 아픈 부분이긴 하다.

위의 경우로 진행을 해보자.

현재 상태를 Deque의 Index번호로 나타내면 위의 그림과 같을 것이다.

그리고 이해하기 쉽게 어항을 90도 회전시킨 후 결과 그림도 한번 보면서 이야기를 해보자.

잘 보면 다음과 같이 움직였다는 것을 확인할 수 있다.

빨강색 테두리들이 저렇게 움직였고 파랑색 테두리 어항들이 저렇게 움직였다.

저렇게 움직인게 어떻게 움직인건지는 모르겠지만 뭔가 쭉 연결된 채로 움직인 거 같다는 느낌이 들기는 한다.

보다 조금만 더 구체적으로 이야기를 해보면.... 각 층의 0번째에 위치한 어항들이 가장 높은 층에 쌓이게 되고, 그 다음 번으로 순차적으로 넘어갈 때마다 한 층이 층수가 낮아지게 된다.

왼쪽 그림에서 빨강색 테두리 어항들은 각각 0층 1층 2층에서 0번째에 위치한 어항들이고 이 어항들이 가장 높은 층수인 2층으로 쌓이게 되었다. 파랑색 테두리 어항들은 각각 0층 1층 2층에서 1번째에 위치한 어항들이고 이 어항들이 그 다음 번으로 높은 층수인 1층으로 쌓이게 되었다. 그럼 여기서 "가장 높은 층수"를 어떻게 구할 수 있을까 ???

아까 우리가 어항을 더 이상 쌓지 못하는 경우를 계산할 때, 어항이 90도로 회전한 후에 쌓이기 때문에 "쌓을 어항의 세로 길이가 쌓고난 후의 가로길이가 된다. 따라서 쌓을 어항의 세로 길이가 중요하다" 라는 이야기를 했었다.

여기서는 가장 높은 층수를 구해야 하니까, 즉, 쌓고난 후의 세로 높이를 구해야 하는 것이니까 반대로 쌓기 전의 가로의 길이를 보면 된다. 위의 그림에서 어항을 쌓기 전에 쌓을 어항들의 가로의 길이 '2'이다. 그리고 가장 높은 층수는 '2'층이다.

즉, 0번째에 위치한 어항들은 쌓을 어항의 가로의 길이 층에 위치, 1번째에 위치한 어항들은 쌓을 어항의 가로의 길이 - 1층에 위치... 이런식의 패턴이 존재한다. 그리고 어항이 쌓이는 순서는 0층부터 순차적으로 올라가게 된다. 위의 그림에서 0층 0번에 있는 'E'가 2층의 0번 Index로 들어가게 되었다. 그리고 그 이후에 순차적으로 1층에 있는 'D'가 그 이후에 2층에 있는 'C'가 들어간 것을 확인할 수 있다.

너무 내용이 난잡하니까 정리를 한번 해보자.

* 어항을 쌓을 때의 규칙을 가로의 길이와 세로의 길이를 통해서 구해보았다.

* 그 규칙은, 각 층의 0번째 Index에 위치해 있는 어항들이 낮은 층수에 있는 어항들부터 순차적으로 가장 높은 층수

에 쌓이게 된다.

* Index의 값이 증가할 수록, 어항이 쌓이는 층수는 감소하게 된다.

어느정도 정리를 해보면 위와 같이 정리를 해볼 수 있을 것 같다. 이를 코드로 나타내면 다음과 같다.

int tmpWidth = width;

for (int i = 0; i < width; i++, tmpWidth--) {
    int idx = 0;
    for (int j = 0; j < height; j++, idx++) {
        bowl[tmpWidth].push_back(bowl[idx][i]);
    }
}

이게 어항을 쌓는 과정이다. line 5)에 있는 for문에서는 쌓을 어항의 세로의 길이만큼 반복을 하는데, 위에서 이야기 했듯이 가장 낮은 층수에 있는 어항들부터 순차적으로 쌓이게 된다. 그리고 층수가 가장 낮은 어항들부터 차례대로 넣기 위해서 push_back()을 통해서 뒤쪽에 어항들을 넣어주고 있다.

그리고 tmpWidth라는 변수가 "쌓을 어항의 가로의 길이"를 저장하고 있는 변수인데, 이 값을 통해서 몇 층에 어항을 쌓아야 하는지를 파악할 수 있다. 그리고 이 값은 Index값이 증가할수록 감소하는 것을 확인할 수 있다.

그럼 이 상황에서 위의 코드를 적용시켰다고 가정해보자. 그럼 어떻게 될까 ?? 우리가 원하는 그림이 나올까 ?? 아마, 이 상태에서 위의 코드를 적용시키면 다음과 같이 나올 것이다.

왜 위와 같이 나오게 될까 ?? 위의 코드에서는 그 어디에도 데이터를 삭제하는 코드가 존재하질 않는다. push_back()만 존재할 뿐, pop_과 관련된 그 어떠한 코드가 존재하지를 않는다. 그렇기 때문에 위와 같이 될 것이다.

즉 ! 우리가 그림으로 나타냈을 때는 어항을 진짜로 딱 떼어내서 공중부양 시켜서 회전시키는 것처럼 표현을 할 수 있었지만 이를 코드로 구현할 때에는 실제로 그 부분을 떼내고 그런 과정을 진행하지 않았기 때문에 "기존의 어항들이 아직 남아있는 상황" 이 발생한 것이다. 그럼 이제 어항을 쌓았으니 쌓은 어항들의 기존의 상태는 삭제를 시켜주자. 위의 그림에서 우리는 딱 이부분만 없애주면 된다.

딱 빨강색 테두리 부분만 지워주면 되는데 이는 각 층수별로 "쌓을 어항의 가로의 길이"만큼만 삭제를 시켜주면 된다.

위의 그림에서는 쌓을 어항의 세로 길이가 "3", 가로 길이가 "2" 였으니까, 0부터 3개의 층수인 0, 1, 2층에서 가로의 길이인 2개씩 데이터를 삭제해주면 된다. 저걸 어떻게 삭제할 수 있을까 ??

여기서 Deque의 장점이 하나 나오게 된다. 우리가 어항을 쌓을 때는 push_back()을 통해서 어항을 쌓았지만, Deque같은 경우에는 삽입 / 삭제가 앞뒤로 자유자재로 가능하다. 즉, 이 때는 pop_front()를 통해서 데이터를 삭제 시켜줄 수가 있다.

그래서 위의 코드에서 다음과 같은 부분이 추가되어야 한다.

int tmpWidth = width;

for (int i = 0; i < width; i++, tmpWidth--) {
    int idx = 0;
    for (int j = 0; j < height; j++, idx++) {
        bowl[tmpWidth].push_back(bowl[idx][i]);
    }
}

for (int i = 0; i < height; i++) {
    for (int j = 0; j < width; j++) {
        bowl[i].pop_front();
    }
}

이렇게 되어야 우리가 원하는 그림이 나오게 되는 것이다. 그럼 어항을 쌓는 과정에 대한 구현이 90% 이상 끝나게 된다.

정리해보고 어항을 쌓는 부분에 대한 최종코드를 살펴보자.

"쌓을 어항의 (가로의 길이 , 세로의 길이) 는 세로의 길이 + 1 , 가로의 길이 + 1 이 반복되는 패턴이 있다."
"어항을 쌓는 과정의 종료 조건은 [ 어항의 0층의 길이 - 쌓을 어항의 가로 길이 < 쌓을 어항의 세로 길이 ] 로 판단"
"어항을 쌓는 과정은 "각 층의 0번째 데이터들부터 가장 높은 층수(쌓을 어항의 가로 길이)에 쌓이게 된다"
"어항을 쌓는 과정은 push_back()을 통해서 각각 적절한 층수에 데이터를 삽입하게 된다"
"어항을 다 쌓았다면, 쌓기 전의 어항들은 삭제해줘야 하므로 이 때에는 pop_front()를 통해서 삭제한다"

int buildBowl() {
	int width = 1;
	int height = 1;
	bool flag = false;

	while (1) {
		if (canBuild(width, height) == false) {
			break;
		}

		int tmpWidth = width;

		for (int i = 0; i < width; i++, tmpWidth--) {
			int idx = 0;
			for (int j = 0; j < height; j++, idx++) {
				bowl[tmpWidth].push_back(bowl[idx][i]);
			}
		}

		for (int i = 0; i < height; i++) {
			for (int j = 0; j < width; j++) {
				bowl[i].pop_front();
			}
		}

		if (flag == false) {
			height++;
			flag = true;
		} else {
			width++;
			flag = false;
		}
	}
	return height;
}

#4. 어항 펼치기

이제 어항을 펼치는 과정을 진행해보자. 먼저 어항을 쌓을 때 처럼 어떤 규칙에 의해서 어항이 펼쳐지는지 부터 살펴보자.

그리고 어항 펼치기는 이 하나의 방법만 사용할 것이다. 어항을 쌓는 과정이 총 2개가 있다. 우리는 그 중에서 한 가지 과정을 #3에서 이야기 해보았고 어항을 펼친 후, 다시 한번 어항을 쌓는 과정이 생기게 된다. 그리고 그 쌓은 어항을 다시한번 펼쳐야 하는 과정이 필요한데 어항을 쌓는 과정은 2개의 과정이 다르기 때문에 각각 별도로 구현해야 하지만, 펼치는 것은 하나의 코드로도 해결이 가능하다. 따라서 지금부터 하는 이야기 한 가지 방법으로 어항을 펼치는 모든 부분을 이 방법으로 끝낼 것이다.

위와 같이 어항이 쌓여있다고 가정해보자. 이 어항을 펼치게 되면 다음과 같아진다.

위와 같이 어항이 펼쳐지게 되는데 다음과 같은 규칙을 찾을 수 있다.

위의 그림과 같이 어항이 펼쳐지게 되는데 이를 정리해보면 다음과 같이 표현할 수 있다.

"0층부터 순차적으로 층수를 올라갈 때, 각 층의 K번째 Index에 있는 어항들부터 순차적으로 펼쳐진다".

위의 그림을 보게 되면 0층의 0번 Index에 있는 'A'가 가장 앞에 펼쳐져 있고 그 다음으로는 1층의 0번 Index에 있는 'B'가 펼쳐져 있고 그 다음으로는 2층의 0번 Index에 있는 'C'가 펼쳐지게 된다.

그 다음으로는 0층의 1번 Index에 있는 'D'가, 1층의 1번 Index에 있는 'E'가, 1층의 2번 Index에 있는 'F'가 펼쳐지게 된다.

우리는 문제 초반부부터 계속해서 이야기한 "어항의 가로의 길이와 세로의 길이" 에 대해서 계속해서 계산을 하고 있고 그 값들이 얼마인지 계산을 해 왔다. 위의 그림에서도 생각을 해보자. 위의 그림에서는 더 이상 어항을 쌓을 수는 없지만 쌓을 어항의 가로의 길이와 세로의 길이를 보면 (가로의 길이 = 2 , 세로의 길이 = 3) 이 된다. 그리고 그림과 이 길이들을 보면 "세로의 길이번을 가로의 길이 만큼 반복" 한다는 것(?)을 알 수 있다. (펼쳐지는 어항이 결국 6개이니, 세로의 길이인 3개의 어항이 2번만큼 반복된 6개의 어항이 펼쳐진다는 의미...)

어항을 펼칠 때는 0층에다가 데이터를 넣어주기만 하면 된다. 그럼 코드로 나타내면 다음과 같이 표현할 수 있다.

void spreadBowl(int height) {
	int width = bowl[height - 1].size();
	for (int i = 0; i < width; i++) {
		for (int j = 0; j < height; j++) {
			bowl[0].push_back(bowl[j][i]);
		}
	}
}

그럼 위의 코드를 실행시키면 어떤 결과가 나오게 될까 ?? 어항을 쌓을 떄와 비슷한 현상이 일어나게 된다.

위의 코드를 실행하면 다음과 같은 결과가 나오게 된다.

아마 이와 같은 현상이 일어나게 될 것이다. 왜냐하면 위의 코드에서는 데이터를 쌓는 과정만 존재하지 기존의 어항을 빼는 과정은 존재하지 않기 때문이다. 그럼 일단 쉬운것부터 해보자. 일단 0층을 제외하고는 모두 clear() 를 시켜주면 될 것이다.

그럼 위의 그림에서 위쪽에 있는 그림처럼 표현이 될 것인데, 우리는 아래에 있는 그림처럼 표현이 되도록 만들어야 한다.

그런데 가장 신경쓰이는게 'G'와 'H'이다. 저 친구들을 어떻게 해줘야 할까 ???

본인은 이 과정을 위해서 "기존의 0층의 size"를 계산해 놓았다. 여기서 기존의 size라는 것은 다음을 의미한다.

기존의 0층의 크기는 '4'였고 그 중에서 우리가 쌓을 어항의 가로의 길이는 '2'였다.

우리는 이 2개의 값으로 'G'와 'H'에 접근을 할 수가 있다. 바로 다음과 같은 코드로 접근이 가능하다.

	for (int i = width; i < size; i++) {
		bowl[0].push_back(bowl[0][i]);
	}

이렇게 되면 모양이 다음과 같이 변하게 될 것이다.

위와 같이 가장 뒤에 'G'와 'H'가 붙게 되는 것이다. 그럼 가장 앞에 있는 저 4개의 알파벳들만 지워주면 되는데, Deque의 장점으로는 pop_front()가 가능하다는 것이다. pop_front()를 위에서 구한 "기존의 0층 크기" 만큼 반복해주면 4개가 사라지게 될 것이다.

모든 내용을 정리해보면 어항을 펼치는 소스코드는 다음과 같다.

void spreadBowl(int height) {
	int width = bowl[height - 1].size();
	int size = bowl[0].size();
	for (int i = 0; i < width; i++) {
		for (int j = 0; j < height; j++) {
			bowl[0].push_back(bowl[j][i]);
		}
	}
	for (int i = 1; i < height; i++) {
		bowl[i].clear();
	}
	for (int i = width; i < size; i++) {
		bowl[0].push_back(bowl[0][i]);
	}
	for (int i = 0; i < size; i++) {
		bowl[0].pop_front();
	}
}

#5. 물고기 수 조절하기

이제 어려운 과정은 다 끝났다.. 물고기 수를 조절하는 과정은 인접한 모든 칸에 대해서 동시에 일어나기 때문에 동/서/남/북 4방향을 탐색해야 하는 것 같지만 본인은 2가지 방향만 진행해 주었다.

위의 그림에서 빨강색 네모친 2개의 어항을 보자.

과연 "C를 기준으로 남쪽 방향에 있는 B와 비교 해서 물고기 수를 조절하는 과정" 과 "B를 기준으로 북쪽 방향에 있는 C와 비교 해서 물고기 수를 조절하는 과정" 이 2가지 과정이 모두 필요할까 ?? 그렇지 않다. 둘 중 어느 하나의 과정만 진행하더라도 B와 C 사이의 물고기 수를 조절하는 과정은 끝나게 된다.

마찬 가지로 C와 F를 조절할 떄에도 어느 한 가지 방향으로만 해주면 된다.

그래서 본인은 각 어항들을 기준으로 동쪽과 남쪽 2가지 방향만 진행해 주었다. 그리고 진행을 할 때에는 tempBowl을 하나 만들어서 임시 저장 공간에 변경된 값을 저장한 후에 다시 원본 맵에 적용시켜 주었다.

원본 맵에 바로 적용을 시키게 되면 계산이 제대로 되지 않는 문제가 발생할 수 있기 때문이다.

void adjustFish(int height) {
	deque<int> tmpbowl[MAX];
	for (int i = 0; i < height; i++) {
		tmpbowl[i] = bowl[i];
	}

	for (int i = height - 1; i >= 0; i--) {
		for (int j = 0; j < bowl[i].size(); j++) {
			int x = i;
			int y = j;
			int num = bowl[x][y];
			for (int k = 0; k < 2; k++) {
				int nx = x + dx[k];
				int ny = y + dy[k];
				if (nx >= 0 && ny < bowl[i].size()) {
					int num2 = bowl[nx][ny];
					int diff = abs(num - num2) / 5;
					if (diff > 0) {
						if (num > num2) {
							tmpbowl[x][y] -= diff;
							tmpbowl[nx][ny] += diff;
						} else {
							tmpbowl[nx][ny] -= diff;
							tmpbowl[x][y] += diff;
						}
					}
					
				}
			}
		}
	}

	for (int i = 0; i < height; i++) {
		bowl[i] = tmpbowl[i];
	}
}

#6. 어항 펼치기

이 부분은 안해도 된다. #4에서 이미 다 끝내놓았기 때문이다 !

이런 과정들을 통해서 문제를 해결할 수가 있다.... 모든 과정을 간단하게 정리 한번 해보자. 너무 길기도 했고 복잡하기도 했다.

# 우리는 어항을 'Deque'로 관리 ! Deque배열을 선언해서, 배열의 Index를 각각의 층으로 생각.
# 각각의 층이 필요한 이유 = 어항이 쌓이는 과정과 펼쳐지는 과정이 있기 때문에 !
# 어항을 쌓을 때는 가장 먼저 가로의 길이와 세로의 길이를 파악하고 이 길이들의 규칙을 파악했다.
# 어항을 쌓는 과정 , 쌓는 것이 종료되는 시점 등 모든 과정을 "가로의 길이와 세로의 길이"로 알 수 있다.
# 어항을 펼치는 과정 또한 가로의 길이와 세로의 길이를 통해서 계산을 진행할 수 있다.
# 물고기의 수를 조절하는 과정은, 4가지 방향이 아닌 동/남 2가지 방향으로만 진행해준다.

[ 소스코드 ]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214

#include <iostream>
#include <queue>
#include <vector>
 
#define MAX 110
using namespace std;
 
int n, k;
deque<int> bowl[MAX];
 
int dx[] = { 0, -1 };
int dy[] = { 1, 0 };
 
 
void input() {
    cin >> n >> k;
    for (int i = 0; i < n; i++) {
        int a; cin >> a;
        bowl[0].push_back(a);
    }
}
 
bool check() {
    int minFish = 987654321;
    int maxFish = -987654321;
    for (int i = 0; i < bowl[0].size(); i++) {
        minFish = min(minFish, bowl[0][i]);
        maxFish = max(maxFish, bowl[0][i]);
    }
 
    return maxFish - minFish <= k ? true : false;
}
 
void addFish() {
    int minFish = 987654321;
    vector<int> idxV;
    for (int i = 0; i < bowl[0].size(); i++) {
        if (bowl[0][i] < minFish) {
            minFish = bowl[0][i];
            idxV.clear();
            idxV.push_back(i);
        } else if (bowl[0][i] == minFish) {
            idxV.push_back(i);
        }
    }
 
    for (auto idx : idxV) {
        bowl[0][idx]++;
    }
}
 
bool canBuild(int w, int h) {
    if (bowl[0].size() - w < h) {
        return false;
    }
    return true;
}
 
void print() {
    for (int i = 0; i < 5; i++) {
        if (bowl[i].size() == 0) continue;
        for (int j = 0; j < bowl[i].size(); j++) {
            printf("%2d ", bowl[i][j]);
        }
        cout << endl;
    }
    cout << endl;
}
 
int buildBowl() {
    int width = 1;
    int height = 1;
    bool flag = false;
 
    while (1) {
        if (canBuild(width, height) == false) {
            break;
        }
 
        int tmpWidth = width;
 
        for (int i = 0; i < width; i++, tmpWidth--) {
            int idx = 0;
            for (int j = 0; j < height; j++, idx++) {
                bowl[tmpWidth].push_back(bowl[idx][i]);
            }
        }
 
        for (int i = 0; i < height; i++) {
            for (int j = 0; j < width; j++) {
                bowl[i].pop_front();
            }
        }
 
        if (flag == false) {
            height++;
            flag = true;
        } else {
            width++;
            flag = false;
        }
    }
    return height;
}
 
void adjustFish(int height) {
    deque<int> tmpbowl[MAX];
    for (int i = 0; i < height; i++) {
        tmpbowl[i] = bowl[i];
    }
 
    for (int i = height - 1; i >= 0; i--) {
        for (int j = 0; j < bowl[i].size(); j++) {
            int x = i;
            int y = j;
            int num = bowl[x][y];
            for (int k = 0; k < 2; k++) {
                int nx = x + dx[k];
                int ny = y + dy[k];
                if (nx >= 0 && ny < bowl[i].size()) {
                    int num2 = bowl[nx][ny];
                    int diff = abs(num - num2) / 5;
                    if (diff > 0) {
                        if (num > num2) {
                            tmpbowl[x][y] -= diff;
                            tmpbowl[nx][ny] += diff;
                        } else {
                            tmpbowl[nx][ny] -= diff;
                            tmpbowl[x][y] += diff;
                        }
                    }
                    
                }
            }
        }
    }
 
    for (int i = 0; i < height; i++) {
        bowl[i] = tmpbowl[i];
    }
}
 
void spreadBowl(int height) {
    int width = bowl[height - 1].size();
    int size = bowl[0].size();
    for (int i = 0; i < width; i++) {
        for (int j = 0; j < height; j++) {
            bowl[0].push_back(bowl[j][i]);
        }
    }
    for (int i = 1; i < height; i++) {
        bowl[i].clear();
    }
    for (int i = width; i < size; i++) {
        bowl[0].push_back(bowl[0][i]);
    }
    for (int i = 0; i < size; i++) {
        bowl[0].pop_front();
    }
}
 
void buildBowl2() {
    int n = bowl[0].size();
    for (int i = 0; i < n / 2; i++) {
        bowl[1].push_front(bowl[0][i]);
    }
    for (int i = 0; i < n / 2; i++) {
        bowl[0].pop_front();
    }
    for (int i = 0; i < n / 4; i++) {
        bowl[2].push_front(bowl[1][i]);
        bowl[3].push_front(bowl[0][i]);    
    }
    for (int i = 0; i < n / 4; i++) {
        bowl[0].pop_front();
        bowl[1].pop_front();
    }
}
 
void solution() {
    int answer = 0;
    while (1) {
        if (check() == true) {
            cout << answer << endl;
            break;
        }
 
        addFish();
        int height = buildBowl();
        adjustFish(height);
        spreadBowl(height);
        buildBowl2();
        adjustFish(4);
        spreadBowl(4);
        answer++;
    }
}
 
void solve() {
    input();
    solution();
}
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
 
    //freopen("input2.txt", "r", stdin);
    solve();
 
    return 0;
}
 
Colored by Color Scripter

cs

[ 백준 19951 ] 태상이의 훈련소 생활 (C++)

얍문 — Mon, 14 Mar 2022 23:31:51 +0900

백준의 태상이의 훈련소 생활(19951) 문제이다.

[ 문제풀이 ]

매우 간단하게 풀 수도 있는 문제이지만, 자칫하면 시간초과에 걸릴 수 있는 문제이다.

간단하게 풀었을 때의 문제점과 이를 해결하기 위한 방법에 대해서 먼저 이야기 해보고, 그 이후에 정답을 도출해보자.

#1. 간단한 접근

먼저, 문제에 가장 쉽게 접근해보자. 조교 한명 한명의 지시가 떨어질 때 마다 업데이트를 계속해서 해주는 것이다.

예를 한번 들어보자.

연병장의 각 칸의 높이가 [ 1 , 2 , 3 , 4 , 5 ] 라고 주어졌다고 가정해보자.

이 때, 조교 A가 "1번 칸부터 3번칸 까지 높이가 2만큼 늘어나도록 흙을 덮어!" 라고 했다고 가정해보자.

그럼, 1번 칸부터 3번칸 까지 +2씩 시켜주는 것이다. 그럼 다음과 같이 연병장의 높이가 변하게 될 것이다.

[ 3 , 4 , 5 , 4 , 5 ]

그리고 나서, 조교 B가 "1번칸부터 4번칸까지 높이가 1만큼 줄어들도록 흙을 파내!" 라고 했다고 가정해보자.

그럼, 1번 칸부터 4번칸 까지 -1씩 시켜주는 것이다. 그럼 다음과 같이 연병장의 높이가 변하게 될 것이다.

[ 2 , 3 , 4 , 4 , 5 ]

그리고 나서, 조교 C가 "2번칸부터 5번칸 까지 높이가 2만큼 늘어나도록 흙을 덮어!" 라고 했다고 가정해보자.

그럼, 2 ~ 5번칸을 + 2씩 시켜주는 것이다. 그럼 다음과 같이 연병장의 높이가 변하게 될 것이다.

[ 2 , 5 , 6 , 6 , 7 ]

이런식으로 문제를 해결할 수가 있다.

그런데 이렇게 해결했을 때, 큰 문제가 한 가지 있다. 최악의 경우를 생각해보자.

연병장의 크기 N이 최댓값인 100,000 이고, 조교의 수 M이 최댓값인 100,000 이고, 모든 100,000명의 조교가 내리는 지시가 모두 동일하게 [ 1 , 100000 , 1 ] 인 경우를 생각해보자.

즉, 100,000 명의 모든 조교가 "연병장의 1번칸부터 마지막 칸(100000번 칸) 까지 높이가 1만큼 늘어나도록 흙을 덮어!" 라고 지시를 한 것이다. 이 때, 위에서 이야기했던 간단한 접근 방법으로 계산을 하게 되면 다음과 같이 계산이 될 것이다.

연병장의 크기인 100,000 칸을 100,000번 방문해야 하기 때문에 총 100,000 * 100,000 만큼의 연산을 하게 된다.

그럼 10,000,000,000 만큼의 연산을 하게 된다. 말도 안되게 시간이 오래 걸린다는 것이다.

그래서 이 문제를 이와같이 매우 간단한 접근 방법으로 해결을 할 수는 없다.

#2. 누적합을 이용한 방법

그래서 이 문제를 "누적합" 을 이용한 방법으로 해결해 볼 것이다.

아까와 똑같은 배열을 다시한번 가져와보자.

[ 1 , 2 , 3 , 4 , 5 ]

이 때, "1번 칸부터 3번칸까지 + 2 만큼 하세요" 라고 한다면, 저 배열에서 바로 계산을 하는게 아니라, 새로운 배열에서 계산을 해줄 것이다. 그러기 위해서 먼저 모든 값이 0으로 초기화 되어 있는 새로운 배열을 하나 선언해보자.

[ 0 , 0 , 0 , 0 , 0 ]

그리고 "1번 칸부터 3번칸까지 + 2 만큼 하세요" 라는 명령을 수행하기 위해서 다음과 같이 연산을 진행해줄 것이다.

[ 2 , 0 , 0 , -2 , 0 ]

1번 칸에는 + 2를, 4번 칸에는 -2를 시켜준 것이다. 왜 갑자기 이런 계산을 했을까 ???

그 전에, 위의 상태에서 이 배열에서 앞에서부터의 누적값을 한번 구해보자. 구해보면 다음과 같을 것이다.

[ 2 , 2 , 2 , 0 , 0 ]

첫 번째 칸 = 이전의 칸이 없으므로 '2' 그대로 유지.

두 번째 칸 = 이전 칸 까지의 총합이 '2'였고, 두 번째 칸의 값이 '0'이였으므로 2 + 0 = '2'

세 번째 칸 = 이전 칸 까지의 총합이 '2'였고, 세 번째 칸의 값이 '0'이였으므로 2 + 0 = '2'

네 번째 칸 = 이전 칸 까지의 총합이 '2'였고, 네 번째 칸의 값이 '-2' 였으므로 2 + (-2) = '0'

다섯번째 칸 = 이전 칸 까지의 총합이 '0' 이였고, 다섯 번째 칸의 값이 '0'이였으므로 '0'.

위와 같이 계산이 되는 것이다. 그리고 원본의 배열인 [ 1 , 2 , 3 , 4 , 5 ] 와 [ 2 , 2 , 2 , 0 , 0 ]을 더하게 되면

[ 3 , 4 , 5 , 4 , 5 ] 와 같이 우리가 원했던 1번칸 ~ 3번칸만 +2가 된 결과를 얻을 수가 있다.

즉 ! "A번째 칸 부터 B번째 칸 까지 +a를 하세요" 라고 한다면, 우리는 새로운 배열에서

"A번째 칸에 +a를, B + 1번째 칸에 -a"를 한 후에, 이 배열에서의 누적합을 구하고, 원본 배열과 합쳐주기만 한다면 우리가 원하는 결과를 구할 수가 있다. 이렇게 값을 변경해야 하는 경우가 여러 번 있더라도 여러 번에 대해서 모두 계산해 준 후에, 최종적으로 누적합을 구한 후, 원본 배열과 합쳐주기만 하면 된다.

이렇게 계산을 하게 되면, 몇 개의 명령어가 몇 개의 범위에 대해서 주어지더라도, A 번째 칸에 +a, B + 1 번째 칸에 -a를 하고 이를 누적합을 구하기 위해서 더하기 위해서 N번 탐색, 그리고 원본 배열과 합치기 위해서 N번 탐색 만으로 해결할 수가 있다.

[ 소스코드 ]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

#include <iostream>
 
#define MAX 100010
using namespace std;
 
struct cmd {
    int a;
    int b;
    int k;
};
 
int n, m;
int arr[MAX];
int accSum[MAX];
cmd cmdArr[MAX];
 
void input() {
    cin >> n >> m;
    for (int i = 0; i < n; i++) {
        cin >> arr[i];
    }
    for (int i = 0; i < m; i++) {
        int a, b, k; cin >> a >> b >> k;
        cmdArr[i] = { a - 1, b - 1, k };
    }
}
 
void solution() {
    for (int i = 0; i < m; i++) {
        int start = cmdArr[i].a;
        int end = cmdArr[i].b;
        int k = cmdArr[i].k;
        accSum[start] += k;
        accSum[end + 1] -= k;
    }
 
    for (int i = 0; i <= n; i++) {
        accSum[i + 1] += accSum[i];
    }
    for (int i = 0; i < n; i++) {
        arr[i] += accSum[i];
        cout << arr[i] << " ";
    }
    cout << endl;
 
}
 
void solve() {
    input();
    solution();
}
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
 
    //freopen("input.txt", "r", stdin);
    solve();
 
    return 0;
}
 
 
Colored by Color Scripter

cs

[ 프로그래머스 파괴되지 않은 건물 (Lv3) ] (C++)

얍문 — Sun, 13 Mar 2022 23:12:51 +0900

프로그래머스의 파괴되지 않은 건물(Lv3) 문제이다.

[ 문제풀이 ]

정확성과 효율성이 있는 문제이다. 문제가 되게 간단해 보이고 간단해 보이는 만큼 간단하게 접근해서 풀게되면 정확성 면에서는 통과를 할 수 있지만, 효율성에서는 통과를 하지 못하게 될 것이다.

정확성만 통과할 수 있는 간단하게 접근하는 방법부터 효율성까지 모두 통과할 수 있는 방법까지 순차적으로 이야기해보자.

#1. 간단한 접근

그럼 가장 먼저 간단한 접근부터 생각을 해보자.

적의 공격을 받아서 내구도가 낮아지게 되면 낮아질 때 마다 단순 반복문을 통해서 해당 좌표 사이에 있는 모든 좌표들의 내구도를 낮춰버리고, 회복 스킬을 받아서 내구도가 높아지게 되면 높아질 때 마다 단순 반복문을 통해서 해당 좌표 사이에 있는 모든 좌표들의 내구도를 높여주는 것이다. 너무나도 간단하게 단순 2중 for문을 통해서 다음과 같이 구현할 수 있을 것이다,.

vector<vector<int>> MAP;

void Process_Command(vector<vector<int>> Skill) {
	for (int i = 0; i < Skill.size(); i++)	{
		int S = Skill[i][0];
		int x = Skill[i][1];
		int y = Skill[i][2];
		int xx = Skill[i][3];
		int yy = Skill[i][4];
		int Value = Skill[i][5];
		
		for (int a = x; a <= xx; a++) {
			for (int b = y; b <= yy; b++) {
				if (S == 1) MAP[a][b] -= Value;
				else MAP[a][b] += Value;
			}
		}
	}
}

위와 같은 형식으로 2중 for문을 통해서 구현을 할 수 있을 것이다. 실제로 이렇게 구현을 하더라도 정확성 부분에서는 pass를 받을 수 있다. 하지만, 이렇게 구현하게되면 효율성 부분에서는 시간초과가 발생하게 된다.

지금부터는 시간초과가 왜 발생하게 되는지부터 알아보고 이를 어떻게 해결할 수 있는지에 대해서 이야기해보자.

#2. 정확성과 효율성

먼저, 이 문제에서 최악의 상태로 입력이 주어지는 경우를 생각해보자.

여기서 최악의 상태라는 것은 "최대범위에서 가장 많은 데이터를 이용해서 실행했을 때"를 의미한다.

정확성 테스트 케이스에서 최악의 상태는 어떻게 될까 ??

"맵의 크기가 100 x 100 의 형태일 것이고, skill의 행의 길이가 100인 경우" 일 것이다.

왜냐하면, 정확성 테스트케이스에서 맵의 행의 길이와 열의 길이의 최댓값은 100이고, skill의 행의 길이가 100인 경우가 최대라고 제한되어 있기 때문이다. 더 나아가서, skill이 [ type , r1 , c1 , r2 , c2 , degree ] 형태로 주어지는데, 이 때 100개의 Skill이 모두

(r1 , c1) = (0 , 0) , (r2 , c2) = (100 , 100) 으로 주어지는 경우일 것이다.

그렇다면 이 경우에 #1에서 이야기했던 2중 for문을 통해서 구현을 하게 되면 어떻게 될까 ??

아마도 100 x 100 크기의 맵을 100번 탐색을 해야 하는, 즉 ! 100 * 100 * 100 만큼의 연산을 진행하게 될 것이다.

결국 1,000,000만큼의 연산을 진행하게 될 것이다. 100만번의 연산은 그리 큰 숫자가 아니다.

그렇다면 효율성 테스트 케이스에서 최악의 상태는 어떻게 될까 ??

제한사항을 확인하고 위에서 이야기했던대로 똑같이 적용시키게 되면 효율성 테스트 케이스의 경우에는

1000 * 1000 * 250,000 번의 연산을 하게 된다. 즉 ! 250,000,000,000 번의 연산을 하게 된다.

숫자를 읽기도 힘들다. 저정도의 연산을 하게되니 #1에서 제시했던 2중 FOR문을 사용하는 코드로 문제를 해결하게 되면 시간초과가 발생하게 되는 것이다. 그렇기 때문에 효율성 테스트 케이스를 통과하기 위해서는 조금 다른 방법이 필요하다.

#3. 새로운 방법 - 누적합

본인은 이 문제의 효율성 부분을 해결하기 위해서 누적합 방식을 이용해 주었다.

누적합 이라는 것은 현재의 값을 기존 값 까지 합친 값을 합치는 것(?)을 의미한다.

그럼 이 누적합을 어떻게 적용할지에 대해서 이야기를 해보자. 이 문제에서는 2차원 배열로 맵이 주어졌지만 먼저 간단하게 1차원 배열을 통해서 이야기를 한번 해보자.

위의 배열에서 "0번 Index부터 3번 Index까지 모든 값을 + 2 시키세요" 라는 명령이 떨어졌다고 가정해보자.

그럼 정말 간단하게 #1에서 했던 이야기처럼 0번 부터 3번 까지 반복하면서 모든 Index의 값을 + 2씩 하는 방법이 있을 것이다.

그런데 지금부터는 저런 방법으로 하지 않을 것이다. 새로운 배열을 하나 더 만들어서 저 과정을 매우 간단하게 만들어 버릴 것이다.

위와 같이 모두 0으로 초기화 되어 있는 배열을 하나 만들 것이다.

그리고 다시한번 "0번 Index부터 3번 Index까지 모든 값을 + 2 시키세요" 라는 명령이 떨어진다면 위의 0으로 초기화 되어 있는 배열을 다음과 같이 바꿀 것이다.

이게 뭐하는 것일까 ?? 왜 0번 Index만 + 2를 시켰고 갑자기 뜬금없이 왜 4번 Index는 -2를 시킨 것일까 ???

이 배열에서 누적합을 한번 계산을 해보자.

0번 Index의 경우에는 기존의 값이 없으므로 '2' 그대로 유지.

1번 Index의 경우에는 0번 Index까지의 합 + 1번 Index 가 되므로 2 + 0 = '2'

2번 Index의 경우에는 1번 Index까지의 합 + 2번 Index 가 되므로 2 + 0 = '2'

3번 Index의 경우에는 2번 Index까지의 합 + 3번 Index가 되므로 2 + 0 = '2'

4번 Index의 경우에는 3번 Index까지의 합 + 4번 Index가 되므로 2 + (-2) = '0'

5번 Index의 경우에는 4번 Index까지의 합 + 5번 Index가 되므로 0 + 0 = '0'

위와 같이 계산이 될 것이고 위의 계산 결과를 다시 깔끔하게 그림으로 나타내면 다음과 같다.

이런 배열이 만들어 지게 되었다. 그럼 "0번 Index부터 3번 Index까지 모든 값을 + 2 시키세요" 는 언제 계산할 수 있을까??

원본의 배열과 계산을 위해 새로 만든 배열 2개를 한번 더해보자.

위와 같이 결과가 나오게 될 것이다. 이 때, 0번 Index부터 3번 Index에 주목해보자.

우리가 원하던 "0번 Index부터 3번 Index까지 모든 값을 + 2 시키세요" 와 결과값이 똑같다.

즉 ! "A번 Index부터 B번 Index까지 +a 를 하고 싶을 때, A번 Index에 + a를 , B + 1번 Index에 -a 연산을 한 후에, 누적합 계산"을 진행하게 되면 하나하나 탐색을 하지 않아도 된다는 것이다. 그럼 이를 이제 우리 문제에 맞게 2차원 배열에서 적용시켜보자.

위와 같은 맵이 주어졌다고 했을 때, "(0 , 0)부터 (2 , 2)까지 모두 + 2 씩 시키세요" 라는 명령어가 떨어졌다고 가정해보자.

똑같이 일단 모든 좌표가 0으로 초기화 되어 있는 새로운 맵을 만들어보자.

2차원 배열도 1차원 배열과 똑같다. 다만, 행에 대해서도 계산을 해줘야 하고 열에 대해서도 계산을 해줘야 하는, 계산을 2번 해야 한다는 것만 다를 뿐, 1차원 배열과 똑같다고 생각을 하면 된다.

그럼 행의 기준에서부터 생각을 해보자.

0 행에서는 어떻게 될까 ?? 0행만 바라본다면 1차원 배열과 똑같기 때문에 다음과 같이 될 것이다.

위와 같이 1차원 배열에서와 똑같이 될 것이다. 그런데 이게 0행에서만 일어나면 안된다. 1행, 2행에 대해서도 일어나야 한다.

마찬가지로 1행, 2행에서도 똑같이 적용해보면 다음과 같다.

그럼 행에 대해서는 모두 적용을 시켰다. 이번에는 열에 대해서도 적용을 시켜보자. 이해를 편하게 돕기 위해서 위의 그림은 "행을 위한 그림" 이였다고 생각하고 잊어버리자. 다시 새로운 0으로 초기화된 맵을 가져와서 열에 대해서 계산을 해보자.

열에 대해서도 똑같이 적용하면 다음과 같이 결과가 나오게 될 것이다.

그럼 지금부터는 이걸 하나로 합치게 되면 다음과 같이 그림을 그려볼 수가 있다.

위의 그림이 이해가 안될 수도 있으니, 먼저 행에 대해서 누적합을 구해보겠다.

그리고 열에 대해서 누적합을 구해보자.

이와 같이 (0 , 0)과 (2 , 2) 까지만 + 2씩 된 모습을 확인을 할 수가 있다.

정리를 해보면 다음과 같다.

"(x , y)부터 (xx , yy) 까지 + a 를 시키세요" 라는 명령이 주어졌다면,

(x , y) + a

(x , yy + 1) - a

(xx + 1 , y) - a

(xx + 1 , yy + 1) + a

위와 같이 4개의 좌표에 대해서 값을 갱신해 준 후에 누적합을 구하게 되면 (x , y) ~ (xx , yy)까지의 변경된 값을 구할 수가 있다.

누적합을 구할 때에는 위에서도 언급했듯이 행에 대해서 한번, 열에 대해서 한번 총 2번을 계산해 주어야 한다.

누적합을 구했다면, 원본의 맵과 좌표별로 더해서 변화량을 구하게 되면 최종적으로 변화된 값을 원본 맵에서 확인을 할 수가 있다.

이 방법을 사용했을 때 시간복잡도를 계산해보면 다음과 같다.

(x , y) ~ (xx , yy)가 주어졌을 때,

(x , y) + a , (x , yy + 1) - a , (xx + 1 , y) - a , (xx + 1 , yy + 1) + a 이렇게 4개의 좌표 값을 바꾸는데 O(1) 이 걸리게 되고 최종적으로 행에 대한 누적합 1000 * 1000 , 열에 대한 누적합 1000 * 1000 , 원본 맵과 합치는 과정 1000 * 1000 만큼, 3 * 1000 * 1000 이 걸리게 된다. 따라서 이러한 방법으로 문제를 해결할 수 있다.

[ 소스코드 ]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

#include <string>
#include <vector>
 
using namespace std;
 
int accSum[1010][1010];
 
void calculateAccSum(vector<vector<int>> board, vector<vector<int>> skills) {
    for (auto skill : skills) {
        int type = skill[0];
        int x = skill[1];
        int y = skill[2];
        int xx = skill[3];
        int yy = skill[4];
        int degree = skill[5];
        degree = type == 1 ? degree * -1 : degree;
        
        accSum[x][y] += degree;
        accSum[xx + 1][yy + 1] += degree;
        accSum[x][yy + 1] -= degree;
        accSum[xx + 1][y] -= degree;
    }
 
    for (int i = 0; i <= board.size(); i++) {
        for (int j = 0; j < board[0].size(); j++) {
            accSum[i][j + 1] += accSum[i][j];
        }
    }
 
    for (int j = 0; j <= board[0].size(); j++) {
        for (int i = 0; i < board.size(); i++) {
            accSum[i + 1][j] += accSum[i][j];
        }
    }
}
 
int findAnswer(vector<vector<int>> board) {
    int answer = 0;
    for (int i = 0; i <board.size(); i++) {
        for (int j = 0; j < board[0].size(); j++) {
            if (board[i][j] + accSum[i][j] > 0) {
                answer++;
            }
        }
    }
    return answer;
}
 
int solution(vector<vector<int>> board, vector<vector<int>> skill) {
    int answer = 0;
    calculateAccSum(board, skill);
    answer = findAnswer(board);
    return answer;
}
Colored by Color Scripter

cs

[ 프로그래머스 양과늑대 (Lv3) ] (C++)

얍문 — Sat, 12 Mar 2022 23:00:17 +0900

프로그래머스의 양과 늑대(Lv3) 문제이다.

[ 문제풀이 ]

늑대에게 잡아먹히지 않으면서 양을 최대로 몇 마리까지 모아서 루트로 다시 돌아올 수 있는지 구해야 하는 문제이다.

문제에 접근하는 방법부터 정답을 도출하는 과정까지 순차적으로 진행해보자.

#1. 연결 관계

본인은 가장 먼저 노드들 간의 연결관계에 대해서 표시를 해 주었다.

vector 배열을 이용해서 노드들 간의 연결관계를 양방향으로 표시해 주었다.

양방향으로 표시를 했다는 것은, 예를 들어서 A번 노드와 B번 노드가 연결되어 있을 때, A번 노드와 연결되어 있는 노드에 B를 포함시켜주었고, 반대로 B번 노드와 연결되어 있는 노드에 A를 포함시켜 주었다는 것을 의미한다.

이렇게 양방향성으로 표시를 해준 이유는 "나에게 왔던 노드로 다시 돌아갈 수도 있기 때문"이다. 가장 쉽게, 루트노드에서 시작해서 루트노드의 자식노드로 이동했다고 가정해보자. 그 이후에 자식노드에서도 다시 루트노드로 갈 수 있고 가야만 하는 문제이기 때문에 이렇게 양방향성으로 구현해 주었다.

노드간의 연결관계를 나타내는 소스코드를 다음과 같이 구현하였다.

vector<int> node[20];

void makeConnection(vector<vector<int>> edges) {
	for (auto n : edges) {
		node[n[0]].push_back(n[1]);
		node[n[1]].push_back(n[0]);
	}
}

#2. 탐색 및 정답도출

본인은 이 과정을 완전탐색, 완전탐색 중에서도 깊이우선탐색(DepthFirstSearch : DFS)를 이용해서 접근해 보았다.

DFS 탐색에 사용되는 재귀함수에서는 3개의 매개변수를 사용해 주었다.

1. 현재 노드의 번호

2. 지금까지 따라온 양의 수

3. 지금까지 따라온 늑대의 수

위와 같이 3개의 매개변수를 사용해 주었다.

완전탐색을 진행할 때에는 중복된 탐색에 대한 체크가 중요하다. 이 문제에서도 마찬가지이다.

하지만, 단순히 해당 노드를 방문했는지 안했는지만으로는 중복체크를 할 수가 없다. 만약에, 해당 노드를 방문 했냐 안했냐로만 따진다면 이 문제의 정답을 구할 수가 없을 것이다. 왜냐하면, 우리는 Root노드를 계속해서 방문을 하면서 최대한 많은 수의 양을 구해야 하는데 Root노드를 처음에 한번 방문했다는 이유로 더 이상 방문하지 못하게 한다면 정답을 구할 수 없기 때문이다.

본인은 이를 위해서 boolean형 visit배열을 3차원으로 만들어주었다. 즉, 3차원 배열을 하나 만들어서 중복된 탐색에 대해서 체크를 해 주었다. 3차원 배열은 다음과 같은 의미를 가지게 된다.

visit[A][B][C] = true : A번 노드에 양을 B마리 늑대를 C마리를 데리고 방문한 적이 있습니다.

visit[A][B][C] = false : A번 노드에 양을 B마리 늑대를 C마리를 데리고 방문한 적이 없습니다.

이 배열을 가지고 DFS 탐색을 진행하게 될 것이다. 그리고, 위의 배열에 들어가는 'A','B','C'는 우리가 위에서 이야기한 DFS 함수의 매개변수에 들어있는 정보들이다.

그럼 본격적으로 탐색을 하는 과정을 진행해보자.

우리는 탐색을 할 때, 3가지 경우를 마주치게 될 것이다.

1. 양이 있는 노드로 움직이려는 경우

2. 늑대가 있는 노드로 움직이려는 경우

3. 아무것도 없는 노드로 움직이려는 경우

초기 상태에서는 3번에 해당하는 노드가 없지만, 노드를 방문할 때 마다 해당 노드에 있는 양과 늑대들이 따라오기 때문에 노드가 비어지는 경우가 발생하게 된다. 따라서 위와 같이 3가지 경우가 마주하게 될 것이다.

그렇다면, 이 3가지에 대해서 구체적으로 어떻게 탐색을 해야 할지 이야기를 해보자.

1. 양이 있는 노드로 움직이려는 경우

이 경우에는 단순히 중복체크만 해주면 된다. 못가는 경우가 없기 때문이다.

2. 늑대가 있는 노드로 움직이려는 경우

이 경우에는 늑대의 수와 양의 수를 비교해 주어야 한다. 왜냐하면, 해당 노드로 방문을 함으로써 늑대의 수가 양의 수보다 같거나 많아지게 된다면 지금까지 모은 양을 모두 잃어버리게 되기 때문이다. 그렇게 되면 당연히 모을 수 있는 양의 최댓값을 구하지 못하게 될 것이다. 따라서, 이 경우에는 "현재 가진 양의 수 > 늑대의 수 + 1" 이라는 조건이 성립할 때에만 탐색을 해주면 된다.

물론 ! 중복체크도 반드시 해 주어야 한다.

3. 아무것도 없는 노드로 움직이려는 경우

이 경우에도 단순히 중복체크만 해주면 된다. 못가는 경우가 없기 때문이다.

본인은 위와 같이 이 3가지 경우에 대해서 DFS탐색을 진행해 주었다. 진행하는 과정에서, "현재 노드의 번호가 '0'번이면, 즉, 현재 노드가 Root노드라면 기존에 모았던 양의 최대 수와 비교해서 갱신" 해 주었다.

[ 소스코드 ]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

#include <string>
#include <vector>
#include <algorithm>
 
using namespace std;
 
vector<int> node[20];
vector<int> state;
int maxSheep;
bool visit[20][20][20];
 
void makeConnection(vector<vector<int>> edges) {
    for (auto n : edges) {
        node[n[0]].push_back(n[1]);
        node[n[1]].push_back(n[0]);
    }
}
 
void dfs(int cur, int sheep, int wolf) {
    if (cur == 0) {
        maxSheep = max(maxSheep, sheep);
    }
 
    for (auto next : node[cur]) {
        if (state[next] == 0) {
            if (visit[next][sheep + 1][wolf] == false) {
                visit[next][sheep + 1][wolf] = true;
                state[next] = -1;
                dfs(next, sheep + 1, wolf);
                state[next] = 0;
                visit[next][sheep + 1][wolf] = false;
            }
        } else if (state[next] == 1) {
            if (visit[next][sheep][wolf + 1] == false && sheep > wolf + 1) {
                visit[next][sheep][wolf + 1] = true;
                state[next] = -1;
                dfs(next, sheep, wolf + 1);
                state[next] = 1;
                visit[next][sheep][wolf + 1] = false;
            }
        } else {
            if (visit[next][sheep][wolf] == false) {
                visit[next][sheep][wolf] = true;
                dfs(next, sheep, wolf);
                visit[next][sheep][wolf] = false;
            }
        }
    }
 
 
}
 
int solution(vector<int> info, vector<vector<int>> edges) {
    makeConnection(edges);
    state = info;
    state[0] = -1;
    visit[0][1][0] = true;
    dfs(0, 1, 0);
    return maxSheep;
}
Colored by Color Scripter

cs

 

[ 프로그래머스 양궁대회 (Lv2) ] (C++)

얍문 — Fri, 11 Mar 2022 23:29:43 +0900

프로그래머스의 양궁대회(Lv2)문제이다.

[ 문제풀이 ]

어피치가 모두 화살을 쏜 후에, 라이언이 화살을 쐈을 때 화살을 어떻게 쏴야 라이언이 이길 수 있는지 구해야 하는 문제이다. 문제에서 제시한 조건들을 토대로 라이언이 어떻게 화살을 쏴야 이길 수 있는지부터 이야기해보고 이를 토대로 정답을 도출하는 과정에 대해서 순차적으로 진행해보자.

#1. 점수를 얻을 수 있는 방법

먼저 이 양궁대회에는 다음과 같은 조건이 존재한다.

"k점을 여러 발 맞혀도 k점 보다 많은 점수를 가져 가는 것이 아니고 딱 k점만 가져가게 된다".

k점 과녁에 화살을 1개를 맞추든, 10개를 맞추든 똑같이 k점만 가져가게 된다는 것이다. 물론, 어피치와 라이언의 화살 관계에 대한 조건을 빼놓고 이야기하면 위와 같다는 것이다.

우리는 라이언이 가장 큰 점수 차이로 우승할 수 있는 방법을 구해야 한다. 즉, 가장 큰 점수 차이로 우승을 하기 위해서는 어떻게 보면 "쓸데 없는 곳에 화살을 소모하면 안된다" 라는 것을 의미한다.

똑같은 k점에만 계속해서 화살을 쏘는 것은 특정 경우에는 필요할 수도 있겠지만, 그런 경우가 아니라면 굉장히 쓸모 없는 화살이 될 것이다.

두 번째로 k점을 얻기 위해서 라이언은 어피치보다 많은 화살을 쏴야한다.

어피치가 k점 과녁에 a개의 화살을 발사했다면, 라이언은 k점 과녁에 a개보다는 더 많은 화살을 쏴야지만 k점을 얻을 수 있는 것이다. 그럼 이 조건에서 "쓸데 없는 곳에 화살을 소모하는 경우"는 어떤 경우들이 있을까 ?? 아마 다음과 같은 경우들이 존재할 것이다.

1. k점 과녁에 a개 이하의 화살을 쏘는 경우

2. k점 과녁에 a개 보다 훨씬 더 많은 화살을 쏘는 경우

이 2가지 경우가 아마 쓸데 없는 곳에 화살을 소모하는 경우가 될 것이다.

왜 그런지에 대해서 이야기를 해보자.

먼저, k점 과녁에 a개 이하의 화살을 쏘게 되면 어떤 일이 일어나게될까 ? 라이언은 해당 k점을 얻지 못하고 어피치가 k점을 획득하게 될 것이다. 아예 k점 과녁에 화살을 안쏴버리면 화살이라도 아낄 수 있는데 a개 이하의 화살을 쏴버린다는 것은 점수도 얻지 못하고 화살도 낭비가 되어버리기 때문에 이 경우는 쓸모 없는 곳에 화살을 소모하는 경우가 될 것이다.

2번 경우를 보자. a개 보다 훨씬 더 많은 화살을 쏘는 경우를 생각해보자.

예를 들어서 어피치가 k점 과녁에 2개의 화살을 쐈다고 가정해보자. 이 때, 라이언이 k점 과녁에 5개의 화살을 쏠 필요가 있을까 ?? k점 과녁에 5개의 화살을 쏘나, 3개의 화살을 쏘나, 10개의 화살을 쏜아 똑같이 k점만 얻게 될 것이다.

왜냐하면, 어피치가 k점 과녁에 맞춘 화살의 갯수인 2개보다만 크면 라이언이 k점을 가져갈 수 있기 때문이다.

즉, 쓸데 없는 곳에 화살을 소모하지 않기 위해서는 어피치가 k점 과녁에 a개의 화살을 맞췄다고 가정했을 때, 라이언이 k점 과녁에 a + 1개의 화살을 맞추는 경우가 가장 쓸데 없는 곳에 화살을 소모하지 않는 경우가 될 것이다.

우리는 이 2가지에 초점을 맞추어서 라이언이 화살을 쏘는 것을 구현해볼 것이다.

#2. 화살 쏘기

그럼 #1의 이야기를 바탕으로 화살을 어떻게 쏠지에 대해서 이야기를 해보자.

먼저, 10점짜리 과녁부터 0점짜리 과녁까지 순차적으로 화살을 쏜다고 가정해보자.

우리는 K점 과녁에서 다음과 같은 선택지들이 생길 것이다.

1. 현재 남은 화살의 갯수 >= 어피치가 K점 과녁에 쏜 화살의 갯수 + 1

- 이 경우에는 라이언에게 남은 화살의 갯수가 어피치가 K점 과녁에 쏜 화살의 갯수 보다 많기 때문에

어피치가 K점 과녁에 쏜 화살의 갯수 + 1개를 쏘면 K점을 얻을 수 있게 된다.

여기서 또 2가지 선택지가 생기게 된다.

1. 어피치가 K점 과녁에 쏜 화살의 갯수 + 1 개 만큼의 화살을 쏘는 경우

2. 화살을 쏘지 않고 넘어가는 경우

위와 같이 2가지 선택지가 생기게 된다. #1에서 이야기 했듯이, 어피치가 K점 과녁에 쏜 화살의 갯수보다

더 적은 화살의 갯수를 쏘거나, 훨씬 더 많은 화살을 쏘는 것은 의미가 없는 행동이다.

그렇기 때문에 위와 같이 2개의 선택지만 생기게 될 것이다.

2. 현재 남은 화살의 갯수 <= 어피치가 K점 과녁에 쏜 화살의 갯수

- 이 경우에는 선택지가 없다. 화살을 안쏘고 남은 화살이라도 챙겨 가는 것이 무조건 이득이다.

왜냐하면, 남은 화살을 모두 쏘더라도 어피치가 K점 과녁에 쏜 화살의 갯수와 동일하거나 더 작기 때문에

이 경우에는 전부 쏘더라도 결국 점수를 얻지 못하기 때문에 차라리 안 쏘는 것이 이득이다.

3. 0점 짜리 과녁일 경우

- 우리는 처음에 가정을 10점부터 0점짜리 과녁까지 순차적으로 쏜다고 했었다.

다른 과녁들은 화살을 쏘지 않고 넘어가는 그런 선택지가 있었지만 0점짜리 과녁에서는 그 다음 과녁으로

넘어가는 선택지가 없다. 따라서, 0점짜리 과녁일 경우에는 어피치가 몇 개의 화살을 쐈는지와 상관없이

남은 화살을 모두 쏴버려야 한다.

본인은 위의 3가지 경우에 대해서 완전탐색, 완전탐색 중에서도 깊이우선탐색(DFS)을 이용해서 구현해 주었다.

#3. 구현

마지막으로 구현에 관한 몇 가지 이야기만 하고 최종 소스코드만 보고 문제를 끝내도록 하자.

우리가 구해야 하는 것은 "라이엇이 화살을 쏘는 방법"을 구하면 된다.

그런데, 이 때 여러가지 조건이 있다.

어피치와 점수 차이가 가장 큰 방법을, 그런 방법이 여러개라면 가장 낮은 점수를 더 많이 맞힌 경우를 정답으로 구해주어야 한다. 그래서 본인은 이를 위해서 2가지 변수를 사용해 주었다.

"현재까지 구한 방법 중에서 점수 차이가 가장 큰 방법의 점수 차이"를 저장하는 int형 변수와

"현재까지 구한 방법 중에서 점수 차이가 가장 큰 방법"을 저장하는 vector, 이렇게 2개의 변수를 사용해 주었다.

이를 통해서 점수 차이를 비교하고, 점수 차이가 같은 방법이 여러개 있다면 0점 과녁부터 라이언이 쏜 화살의 갯수를 비교해주면서 정답을 구해 주었다.

[ 소스코드 ]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

#include <string>
#include <vector>
 
using namespace std;
 
int scoreResult = -1;
vector<int> ryan, apeach, ryanResult;
 
pair<int,int> calculate() {
    pair<int, int> score = { 0, 0 };
    for (int i = 0; i < 11; i++) {
        if (ryan[i] == apeach[i]) {
            if (ryan[i] == 0 && apeach[i] == 0) {
                continue;
            } else {
                score.second += (10 - i);
            }
        } else {
            if (ryan[i] > apeach[i]) {
                score.first += (10 - i);
            } else {
                score.second += (10 - i);
            }
        }
    }
    return score;
    
}
 
void check() {
    pair<int, int> score = calculate();
    int ryanScore = score.first;
    int apeachScore = score.second;
    int diff = ryanScore - apeachScore;
    if (diff <= 0) {
        return;
    }
 
    if (scoreResult == -1) {
        scoreResult = diff;
        ryanResult = ryan;
    } else {
        if (scoreResult == diff) {
            for (int i = 10; i >= 0; i--) {
                if (ryan[i] != 0 && ryanResult[i] == 0) {
                    ryanResult = ryan;
                    break;
                } else if (ryan[i] == 0 && ryanResult[i] != 0) {
                    break;
                } else if (ryan[i] != 0 && ryanResult[i] != 0) {
                    if (ryan[i] != ryanResult[i]) {
                        ryanResult = ryan[i] > ryanResult[i] ? ryan : ryanResult;
                        break;
                    }
                }
            }
        } else if (scoreResult < diff) {
            scoreResult = diff;
            ryanResult = ryan;
        }
    }
}
 
void dfs(int cnt, int idx, int n) {
    if (cnt == n) {
        check();
        return;
    }
 
    int curArrow = n - cnt;
    if (idx == 10) {    
        ryan[idx] = curArrow;
        dfs(cnt + curArrow, idx + 1, n);
        ryan[idx] = 0;
    } else {
        if (apeach[idx] + 1 <= curArrow) {
            ryan[idx] = apeach[idx] + 1;
            dfs(cnt + apeach[idx] + 1, idx + 1, n);
            ryan[idx] = 0;
        }
        dfs(cnt, idx + 1, n);
        
    }
}
 
vector<int> solution(int n, vector<int> info) {
    ryan.resize(11, 0);
    apeach = info;
    dfs(0, 0, n);
 
    if (scoreResult == -1) {
        ryanResult.push_back(-1);
    }
    return ryanResult;
}
 
Colored by Color Scripter

cs

[ 프로그래머스 주차 요금 계산 (Lv2) ] (C++)

얍문 — Thu, 10 Mar 2022 23:33:51 +0900

프로그래머스의 주차요금계산(Lv2) 문제이다.

[ 문제풀이 ]

문제에서 필요한 정보들을 구하는 과정과 이를 통해 정답을 도출하는 과정까지 순차적으로 진행해보자.

#1. 필요한 정보

먼저 이 문제에서의 정답을 구하기 위해서는 "각 차량별로 주차되어 있던 모든 시간의 합"을 알아야 한다.

왜냐하면, 하나의 차가 입차하고 출차하는 과정을 여러번 할 수도 있기 때문에 각각의 차량들이 주차되어 있었던 시간들의 누적합을 구해야 한다.

이 정보들은 우리에게 'records' 라는 매개변수에 저장되서 주어지게 된다. records안에는 [ 입차or출차시간 / 차량번호 / 입차or출차 ] 이 3가지 정보가 하나의 String 형태로 주어지게 된다. 그럼 각각을 어떻게 관리를 했는지 부터 이야기해보자.

#1 - 1) 차량번호

먼저, 차량번호에 대해서 이야기를 해보자. 본인은 간편하게 관리를 하기 위해서 문자열로 주어지는 차량번호를 int형으로 변환해서 관리를 해 주었다. 이 때, 차량번호를 단순 int형으로 변환을 시킨 것은 아니다. 예를 들어서 '1234'라는 차량번호가 있으면 이 "1234"라는 문자열을 int형으로 변환해서 '1234'로 표현한 것은 아니라는 것이다.

본인은 가장 처음 입력되는 차량부터 '1번'을 기준으로 순차적으로 번호를 매핑해 주었다. 이를 위해서 자료구조 map을 사용해주었다. 사실, 이렇게 까지 할 필요는 없지만, 조금이나마 실행시간에 있어서 탐색 시간을 줄이기 위해서 이와 같이 진행을 해 주었다. "1234"를 '1234'로 바꿀 때와, "1234"를 '1번'으로 바꿀 때와 어떤 차이가 있는지는 밑에서 보다 구체적으로 이야기 해보자. 결과적으로 본인은 문자열로 주어지는 차량의 번호를 '1'부터 순차적으로 번호를 증가시키면서 int형으로 매핑시켜 주었다.

동시에 ! int형으로 변환되어 있는 차량의 원래 번호를 저장해주는 과정도 진행해 주었다.

예를 들면, "1234" 라는 String형태로 주어진 차량 번호를 '1'이라는 int형 숫자로 mapping을 시켜 주었지만, 반대로 '1'이라는 숫자만 보고도 이 '1'번 차량은 "1234"라는 번호를 가지고 있는 차라는 것 또한 저장을 해 주었다는 것이다.

왜 굳이 바꾸고 또 바꾸고 이 모든 것을 저장했을까 ?? 밑에서 보다 구체적으로 이야기 하겠지만, 간략하게만 이야기를 해보자면 우리가 결과적으로 구해야 하는 값이 "차량 번호가 작은 자동차부터 청구할 주차요금" 이기 때문이다.

즉 ! "1234"라는 차량 번호를 '1'번으로 매핑 시킨 후, 이 '1'번으로만 문제를 해결하다보면 최종적으로 다시 이 '1'번이 "1234" 라는 사실을 모를 수가 있고 결과적으로 최종 정답을 도출하는데 문제가 발생할 수 있기 때문이다.

이 부분에 대해서는 아래쪽에서 보다 구체적으로 이야기해보자.

#1 - 2) 입차 / 출차

두 번째는 입차와 출차에 대한 정보이다. 본인은 입차와 출차에 대한 정보를 stack을 이용해서 관리해 보았다.

먼저, stack은 배열의 형태로 선언을 해 주었는데, 배열의 Index번호를 차량의 번호로 관리하기 위해서 선언해 주었다.

그럼 배열은 총 몇 칸짜리 배열을 만들어야 할까 ?? 차량번호 최대 "9999"가 될 수 있기 때문에 아마도 10,000칸이 필요하게 될 것이다. 하지만 본인은 1000칸만 만들어 주었다. 왜 그럴까 ?? #1 - 1)에서 이야기 했듯이, 본인은 차량번호를 그대로 관리하는 것이 아닌 1번부터 순차적으로 매핑시켜서 관리를 해 주었다고 이야기를 하였다. 그렇기 때문에 차량의 최대번호를 기준으로 배열의 칸을 설정할 이유는 없었는데, 그렇다면 왜 하필 크기가 1,000인 배열일까 ?? 바로 records의 최대 크기가 1,000이기 때문이다. 우리에게 주어지는 records에서 모든 차량의 입차 정보만 주어져있고 1,000개의 차량 모두 번호가 다르다고 가정을 해본다면 우리는 결국 1,000개의 차량을 1번부터 mapping 시켜야 하는 경우가 발생할 것이고 이 경우 차량 번호의 최댓값은 1,000이 될 것이기 때문이다. 그렇기 때문에 1,000칸짜리 배열을 가지는 stack을 선언해 주었다.

stack에는 해당 차량의 "입차 시간"을 저장해 주었다. 예를 들어서 "3번으로 매핑된 차량이 00:00에 입차" 하게 된다면, stack[3].top() = "00:00" 이 되는 것이다.

그렇다면, 이 3번으로 매핑된 차량의 출차 정보가 나오게 된다면 ?? 주차된 시간을 구해야 한다.

주차된 시간은 어떻게 구할 수 있을까 ?? 출차시간 - 입차시간을 하면 된다. 입차시간은 stack[3] 에 저장되어 있을 것이다. 이런식으로 입차 시간을 관리하기 위해서 stack을 사용해 주었다.

#1 - 3) 시간 변환

마지막으로 시간에 관한 부분이다. 이 문제에서는 시간이 "HH:MM" 의 형태로 주어지게 된다. 그리고 주차요금을 계산하기 위해서 주어지는 정보들(fees)를 보게 되면, 모두 '분 단위'로 주어지게 된다. 그래서 본인은 "HH:MM"의 형태로 주어져있는 시간을 분으로 통일시켜 주었다. HH * 60 + MM 을 통해서 하나의 분으로 통일 후 모든 계산을 진행해 주었다.

지금까지 이야기한 부분들을 코드로 확인해 보자.

int totalTime[1010];	// 각 차량별, 주차 누적 시간을 저장하기 위한 변수
int totalCarNum;		// 전체 차량의 갯수를 저장하기 위한 변수
int carList[1010];		// int형으로 mapping된 차량번호를 원래 차량번호로 변환하기 위한 변수.
map<string, int> carNum_Map;	// string형태의 차량번호를 int형으로 mapping 시키기 위한 변수

void findEntranceTime(vector<string> records) {
	int num = 1;
	stack<int> carStack[1010];
	for (auto str : records) {
		stringstream streamStr(str);
		string stime;
		string scarNum;
		string state;
		streamStr >> stime >> scarNum >> state;
		
		if (carNum_Map[scarNum] == 0) {
			carList[num] = stoi(scarNum);
			carNum_Map[scarNum] = num++;
		}

		int time = invertTime(stime);

		if (state == "IN") {
			carStack[carNum_Map[scarNum]].push(time);
		} else {
			int entranceTime = carStack[carNum_Map[scarNum]].top();
			int resultTime = time - entranceTime;
			totalTime[carNum_Map[scarNum]] += resultTime;
			carStack[carNum_Map[scarNum]].pop();
		}
	}

	for (int i = 1; i < num; i++) {
		if(carStack[i].empty() == true) {
			continue;
		}
		
		int resultTime = invertTime("23:59") - carStack[i].top();
		totalTime[i] += resultTime;
		carStack[i].pop();
	}

	totalCarNum = num;
}

본인은 위와 같이 구현을 해 보았다. 위의 코드에서 totalTime[] 이라는 변수 말고는 모두 #1 - 1 ~ 3) 에서 이야기 했던 부분들이라서 이 변수에 대해서만 간단하게 이야기 해 보겠다. totalTime[A] = B 라는 것은, "차량 번호가 A인 차량의 누적 주차 시간은 B분 입니다."를 의미한다. 물론 여기서 'A'의 값도 #1 - 1)에서 진행했던 1번부터 mapping된 차량의 번호가 index번호로 들어가게 된다.

위의 코드에서 line16 ~ 19)를 보게되면 차량의 번호를 num이라는 변수로 mapping 시키는 부분이 있는데 이 부분이 #1 - 1)에서 이야기 했던 차량 번호를 1부터 증가시키면서 int형으로 변환 시키는 과정이다.

line23 ~ 30)은 입차와 출차 시에 대한 부분을 구현한 것인데, 입차 시에는 stack에 단순히 시간을 넣어주는 과정만, 출차 시에는 이 stack에 들어 있는 입차 시간을 이용해서 주차 시간을 계산하는 과정을 구현한 것이다.

마지막으로 , line33 ~ 41)에서 보면 출차에 대해서 한번 더 구현해 놓은 것인데 위의 코드가 필요한 이유는 출차 시간이 주어지지 않는 경우가 존재하기 때문이다. 출차 시간이 주어지지 않는 경우에는 "23:59"에 출차했음을 의미한다고 문제에서 제시 되어 있다. 따라서, stack이 비어있지 않다는 것은, 해당 차량의 입차 시간만 있고 출차 정보가 없다는 것을 의미하고 이 경우에는 23:59를 기준으로 주차 시간을 계산해 주었다.

#2. 정답 구하기

정답을 구하는 과정은 문제에서 제시되어 있는 대로 구하면 된다.. 별다른 특별한 방법을 사용하지도 않았고 문제에서 제시한 대로 계산식 대로 계산만 해 주었다. 그런데 ! 여기서 아까 위에서 이야기 했던, 차량의 번호를 1번부터 mapping 시키는 이유에 대해서 조금 더 이야기 해보자.

만약, 위에서 이야기 했던 1번 부터 mapping 시키는 과정 없이 그냥 차량번호를 그대로 int형으로 변환만 시켜서 진행했다고 가정해보자. 예를 들어서 "1234"라는 차량번호를 '1234'라고 변환해서 문제 해결을 진행했다고 가정해 보는 것이다.

그럼, 우리는 주차 누적 시간들을 저장하기 위해서 위의 코드에서 사용된 totalTime[] 이라는 변수를 10,000칸을 만들고 진행을 해도 문제가 전혀 없을 것이다. 그럼 1111 ~ 9999 까지의 차량 중에서 딱 10대가 문제의 입력으로 주어졌다고 가정해보자. 우리는 이 10 대를 위해서 배열을 10,000칸을 선언해서 0번 Index부터 999번 Index까지는 사용하지도 않을 것이고, 이 10대의 차량을 위해서 1111 부터 9999까지 모두 탐색을 해봐야 한다. 그렇다면, 존재하는 차량의 번호들만 별도의 Vector와 같은 자료구조에 넣어서 관리를 한다면 ?? 예를 들어서 vector에 존재하는 차량번호인 { "1234", "2345", "3456", "4567" ,"5678" .... } 이런식으로 저장해놓고 Vector에서 하나씩 빼오면서 해당 Index만 탐색을 하게 된다면 이 문제는 해결되지 않을까 ??

충분히 해결될 것이고 저렇게 하지 않아도 애초에 크게 문제가 발생하지는 않을 것이다. 그런데 저 10대의 차량을 위해서 10,000칸을 선언해야 하는 것 자체가 약간의 낭비라고 생각을 했다. 그래서 본인은 이러한 낭비를 줄이기 위해서 그리고 이를 통해서 탐색 시간을 줄이기 위해서 int형 숫자 1번부터 차량을 순차적으로 mapping 시킨 것이다.

최종적으로는 별도의 Vector를 선언 후, Vector에 <전체 주차 시간 , 차량의 원래 번호> 를 저장해서 정렬 후 전체 주차 시간만 빼내서 정답을 도출하였다. 이 과정에서 "차량의 원래 번호" 가 필요하기 때문에 #1 - 1)에서 string형태의 4자리 차량 번호를 1번부터 순차적으로 증가하는 번호로 매핑시키는 과정과 동시에, 이 번호가 의미하는 차량의 원래 번호 또한 저장을 한 것이다.

[ 소스코드 ]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

#include <string>
#include <vector>
#include <sstream>
#include <cmath>
#include <stack>
#include <map>
#include <algorithm>
#include <functional>
using namespace std;
 
int totalTime[1010];
int totalCarNum;
int carList[1010];
map<string, int> carNum_Map;
 
bool Cmp(pair<int, int> A, pair<int, int> B) {
    return A.second < B.second ? true : false;
}
 
int invertTime(string time) {
    string sHour = time.substr(0, 2);
    string sMinute = time.substr(3, 2);
    int hour = stoi(sHour) * 60;
    int minute = stoi(sMinute);
    return hour + minute;
}
 
void findEntranceTime(vector<string> records) {
    int num = 1;
    stack<int> carStack[1010];
    for (auto str : records) {
        stringstream streamStr(str);
        string stime;
        string scarNum;
        string state;
        streamStr >> stime >> scarNum >> state;
        
        if (carNum_Map[scarNum] == 0) {
            carList[num] = stoi(scarNum);
            carNum_Map[scarNum] = num++;
        }
 
        int time = invertTime(stime);
 
        if (state == "IN") {
            carStack[carNum_Map[scarNum]].push(time);
        } else {
            int entranceTime = carStack[carNum_Map[scarNum]].top();
            int resultTime = time - entranceTime;
            totalTime[carNum_Map[scarNum]] += resultTime;
            carStack[carNum_Map[scarNum]].pop();
        }
    }
 
    for (int i = 1; i < num; i++) {
        if(carStack[i].empty() == true) {
            continue;
        }
        
        int resultTime = invertTime("23:59") - carStack[i].top();
        totalTime[i] += resultTime;
        carStack[i].pop();
    }
 
    totalCarNum = num;
}
 
vector<int> findAnswer(vector<int> fees) {
    vector<pair<int, int>> res;
 
    for (int i = 1; i < totalCarNum; i++) {
        int time = totalTime[i];
        if (time <= fees[0]) {
            res.push_back(make_pair(fees[1],carList[i]));
        } else {
            int overTime = time - fees[0];
            int overCost = overTime % fees[2] == 0 ? (overTime/fees[2]) * fees[3]  : ((overTime / fees[2])+ 1) * fees[3];
            int totalcost = overCost + fees[1];
            res.push_back(make_pair(totalcost, carList[i]));
        }
    }
    sort(res.begin(), res.end(), Cmp);
    vector<int> answer;
    for (auto data : res) {
        answer.push_back(data.first);
    }
    return answer;
}
 
vector<int> solution(vector<int> fees, vector<string> records) {
    vector<int> answer;
    findEntranceTime(records);
    answer = findAnswer(fees);
    return answer;
}
Colored by Color Scripter

cs

[ 프로그래머스 K진수에서 소수 개수 구하기(Lv2) ] (C++)

얍문 — Wed, 9 Mar 2022 23:28:03 +0900

프로그래머스의 K진수에서 소수 개수 구하기(Lv2) 문제이다.

[ 문제풀이 ]

주어진 숫자 n을 k진수로 바꿨을 때, 조건에 맞는 소수가 몇 개 인지 구해야 하는 문제이다.

순차대로 문제를 해결해보자.

#1. K진수로의 변환

가장 먼저 우리는 주어진 숫자 n을 k진수로 변환시켜 주어야 한다.

본인은 10진수를 2진수로 바꿀 때, 2로 나눈 나머지를 계속해서 저장해가는 방식과 똑같이 n을 k로 나눈 나머지를 계속해서 저장하는 방식으로 구현하였다. 그리고 본인은 이 값을 'string'형태의 데이터로 저장을 해주었다.

왜냐하면, k로 나눈 나머지를 순차적으로 저장을 하게 되면, 결국 이를 뒤집어 줘야 하기도 하고, 우리는 각각의 숫자를 찾아가면서 조건에 맞는 소수를 찾아야 하기 때문에 문자열이 더 편하다고 생각을 했기 때문이다.

위에서 뒤집어 줘야 한다는 것은 예시로 나타내면 다음과 같다.

6을 2진수로 바꿀 때, 6 % 2 = 0 → 3 % 2 = 1 → 1 % 2 = 1 을 순차적으로 저장하게 되면 '011' 이라는 값이 나오게 되는데, 사실 6을 2진수로 바꾸게 되면 011이 아닌 110이 나와야 하기 때문이다. 그래서 이렇게 뒤집는 과정이 필요하다.

이 과정을 소스코드로 나타내면 다음과 같다.

string num;
void changeNum(int n, int k) {
	while (n > 0) {
		num += to_string(n % k);
		n /= k;
	}
	reverse(num.begin(), num.end());
}

위의 코드에서 'num' 이라는 변수가 주어진 숫자 n을 k진수로 변환했을 때, 그 값을 string형태로 저장하기 위해 선언해 놓은 변수이다. 그리고 마지막에 reverse 함수를 통해서 주어진 문자열을 거꾸로 뒤집어 주었다.

#2. 소수 찾기

이제 k진수로 변환되어 있는 값을 가지고 있으니, 이를 통해서 조건에 만족하는 소수를 찾아보자.

조건에 만족하는 소수가 여러가지가 있는데 이를 통합해서 쉽게 한 마디로 정리해보면 "0을 기준으로 숫자를 짤랐을 때, 그 숫자가 소수인지 아닌지" 만 판단을 해주면 된다.

몇 가지 예시를 통해서 위의 말을 생각해보자.

1. "0 A B C D E"

2. "A 0 B C D 0 E"

3. "A B C D E 0 "

4. "A B C D E"
(편의 상, 실제 숫자가 아닌 숫자를 A, B, C, D, E로 표현하였습니다. 위의 예시에서 A B C D E 는 숫자라고 생각하시면 됩니다.)

먼저, 첫 번째 예시에 있는 숫자를 0을 기준으로 잘라보자.

그렇게 되면, 'A B C D E' 라는 숫자가 나오게 된다. 즉, 이 경우에는 문제에서 나와있는 '0P'의 형태가 되는 것이다.

왼쪽에만 '0'이 있고, 오른쪽에는 더 이상 '0'이 존재하지 않는 꼴이다.

두 번째 예시를 0을 기준으로 잘라보면, 'A' , 'B C D' , 'E' 가 나오게 된다.

'A'는 'P0'의 형태를, 'B C D'는 '0P0'의 형태를, 'E'는 '0P'의 형태가 된다.

나머지 3, 4번 예시도 마찬가지이다.

즉, 문제에서 언급한 소수가 여러가지가 있는데 이를 통합해서 한 마디로 정리해보면 "0을 기준으로 숫자를 짜르고, 그 숫자가 소수인지 판단하여라" 라고 생각할 수 있다.

그래서 본인은 #1에서 문자열의 형태로 저장한 데이터에서 하나하나 탐색을 하면서 '0'이 아닐 때에는, 숫자를 저장해주고 '0'일 때에는 지금까지 저장한 숫자들이 소수인지 판단해 주었다.

주의해야 할 점이, 모든 문자열에 대한 탐색이 끝난 후, 마지막에 탐색을 한번 더 해줘야 하는 경우가 발생할 수도 있다는 것이다.

위의 예시에서 1번 예시를 한번 보자.

'0'일 때에는 그냥 넘어가고, 그 이후에 숫자들을 저장하게 되면 'A B C D E'가 나오게 된다.

이 경우에는 문자열 탐색이 끝나서 이대로 종료될 수가 있는데, 이렇게 종료시키지 말고 마지막으로 한번 더 체크를 해줘야 한다.

왜냐하면, 'A B C D E'라는 숫자가 남아있기 때문이다.

이를 코드로 나타내면 다음과 같다.

int findAnswer() {
	int answer = 0;
	string str = "";
	for (auto c : num) {
		if (c == '0') {
			if (str.length() == 0) continue;
			if (checkPrime(stol(str)) == true) {
				answer++;
			}
			str = "";
		}  else {
			str += c;
		}
	}

	if (str.length() != 0) {
		if (checkPrime(stol(str)) == true) answer++;
	}
	return answer;
}

[ 소스코드 ]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
 
using namespace std;
 
string num;
 
void changeNum(int n, int k) {
    while (n > 0) {
        num += to_string(n % k);
        n /= k;
    }
    reverse(num.begin(), num.end());
}
 
bool checkPrime(long long n) {
    if (n == 0 || n == 1) {
        return false;
    }
    for (int i = 2; i <= sqrt(n); i++) {
        if (n % i == 0) {
            return false;
        }
    }
    return true;
}
 
int findAnswer() {
    int answer = 0;
    string str = "";
    for (auto c : num) {
        if (c == '0') {
            if (str.length() == 0) continue;
            if (checkPrime(stol(str)) == true) {
                answer++;
            }
            str = "";
        }  else {
            str += c;
        }
    }
 
    if (str.length() != 0) {
        if (checkPrime(stol(str)) == true) answer++;
    }
    return answer;
}
 
int solution(int n, int k) {
    int answer = -1;
    changeNum(n, k);
    answer = findAnswer();
    return answer;
}
Colored by Color Scripter

cs

[ 프로그래머스 신고 결과 받기 (Lv1] (C++)

얍문 — Sat, 5 Mar 2022 11:16:37 +0900

프로그래머스의 신고 결과 받기(Lv1) 문제이다.

[ 문제풀이 ]

프로그래머스의 신고 결과 받기 문제이다. 문제에 접근하는 과정부터 정답을 도출하는 과정까지 순차적으로 이야기해보자.

#1. 변수 및 정보 관리

이 문제에서 주어진 정보들에 대해서 이야기를 해보자.

#1 - 1) User ID 관리

유저들의 ID가 주어지고, (유저 , 해당 유저가 신고한 아이디) 의 형태로 정보가 주어진다.

첫 번째로 본인은 string 형태로 이루어진 유저들의 ID를 간편하게 int형으로 관리를 해주기 위해서 자료구조 map을 사용해 주었다. map을 이용해서 유저들의 ID를 1부터 순차적으로 번호를 붙여서 간단하게 관리를 해 주었다.

#1 - 2) 신고 정보

두 번째로 우리는 어떤 사용자가 누구를 신고했는지를 저장을 해줘야 한다. 이 정보를 저장하고 있어야만 정답을 도출할 수 있기 때문이다. 그래서 이를 저장하기 위해서 vector배열을 하나 선언해 주었다.

vector배열로 선언해준 이유는, 한 명이 여러명을 신고할 수 있는데, 이 여러명을 관리해주기 위해서 vector를 사용해 주었고, 배열이 붙은 이유는 단순히 신고한 사용자를 표시해 주기 위해서 선언해 주었다.

예를 들어서, #1 - 1) 과정에서 'muzi' 라는 사용자를 '1'번으로 설정을 했다고 가정해보자. 그리고 'muzi'가 'frodo'를 신고하게 되면, vector[1] = { 'frodo' } 이런식으로 들어가도록, 사용자 ID를 int형으로 바꾼 값을 Index로 사용하기 위해서 vector배열로 선언해 주었다.

이를 통해서, 누가 누구를 신고했는지를 vector배열을 통해서 저장해 주었다.

#1 - 3) 신고 당한 유저 정보

#1 - 2)에서 이야기한 정보를 저장할 때, 신고 당한 유저들 중에서, k번 이상 신고를 당해서 이용 정지를 당하는 유저를 찾아줘야 한다. 그러기 위해서 2가지 변수를 더 사용해 주었다.

첫 번째 변수는 "유저가 신고당하는 횟수를 저장하는 변수" 이고, 두 번째 변수는 "k번 이상 신고당해서 이용 정지를 당한 유저를 저장하는 변수" 이다.

먼저, "유저가 신고당하는 횟수를 저장하는 변수"를 map을 이용해서 저장해 주었다. map<string, int> 형태로 선언을 해서 <신고당한 유저의 아이디 , 신고당한 횟수 > 의 형태로 데이터를 저장해 주었다.

그리고, 위와 같은 형태로 데이터를 저장할 때, 신고당한 횟수와 k값을 비교해서 k번 이상 신고를 당했다면 이용 정지를 당한 유저의 목록에 저장해 주었다. 이용 정지를 당한 유저의 경우에는 단순히 string을 자료형으로 갖는 vector를 이용해서 저장해 주었다.

위의 모든 내용을 코드로 나타내면 다음과 같다. 아래의 코드는 우리에게 주어지는 매개변수 'report'를 통해서

1. 각각의 userID를 int형으로 mapping 시키는 과정

2. (신고한 사람 , 신고 당한 사람) 을 저장하는 과정

3. 신고 당한 사람 중, K번 이상 신고 당한 사람을 저장하는 과정을 나타낸다.

map<string, int> mapping; 		// USER_ID를 int형으로 mapping시킨 후 저장하기 위한 변수
map<string, int> reportCount;	// 신고 당한 횟수를 저장하기 위한 변수
vector<string> reportList[1010];	// 누가 누구를 신고했는지 저장하기 위한 변수
vector<string> blacklist;			// k번 이상 신고를 당한 user만 저장하기 위한 변수

void countReport(vector<string> report, int k) {
	int num = 1;
	for (int i = 0; i < report.size(); i++) {
		string str = report[i];
		stringstream streamStr(str);
		string userID, blacklistID;
		streamStr >> userID >> blacklistID;

		/* 
        	mapping[ID]==0 이라는 것은 아직 이 user는 int형으로 mapping 되지 않았음을 의미
        */
		if (mapping[userID] == 0) mapping[userID] = num++;	
		if (mapping[blacklistID] == 0) mapping[blacklistID] = num++;
		if (find(reportList[mapping[userID]].begin(), reportList[mapping[userID]].end(), blacklistID) == reportList[mapping[userID]].end()) {
			reportList[mapping[userID]].push_back(blacklistID);
			reportCount[blacklistID]++;
			if (reportCount[blacklistID] >= k) {
				blacklist.push_back(blacklistID);
			}
		}
	}
}

#2. 정답 도출

위에서 정리한 자료들을 토대로 정답을 도출해보자.

우리가 구해야 하는 것은, 각각의 USER가 받은 결과 메일 수를 구해야 하는 것인데, 이 결과 메일 수 라는 것은 "해당 유저가 신고한 사람들 중, k번 이상 신고를 당해서 이용 정지를 당한 사람의 수" 를 의미한다.

우리는 이를 위해서, #1의 과정에서 "누가 누구를 신고했는지"도 저장해 놓았고, "k번 이상 신고 당해서 이용 정지를 당한 유저의 리스트"도 저장을 해 놓았다.

이제는, userID를 순차적으로 탐색을 하면서, 해당 user가 신고한 사람 중에서 이용 정지를 당한 사람만 찾아서 그 수를 Count 해주면 된다. 코드로 나타내면 다음과 같다.

vector<int> findAnswer(vector<string> id_list) {
	vector<int> answer;
	for (auto userID : id_list) {
		int mappingID = mapping[userID];
		int result = 0;
		for (auto reportID : reportList[mappingID]) {
			if (find(blacklist.begin(), blacklist.end(), reportID) != blacklist.end()) {
				result++;
			}
		}
		answer.push_back(result);
	}
	return answer;
}

[ 소스코드 ]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

#include <string>
#include <vector>
#include <algorithm>
#include <sstream>
#include <map>
 
using namespace std;
 
map<string, int> mapping;
map<string, int> reportCount;
vector<string> reportList[1010];
vector<string> blacklist;
 
void countReport(vector<string> report, int k) {
    int num = 1;
    for (int i = 0; i < report.size(); i++) {
        string str = report[i];
        stringstream streamStr(str);
        string userID, blacklistID;
        streamStr >> userID >> blacklistID;
 
        if (mapping[userID] == 0) mapping[userID] = num++;
        if (mapping[blacklistID] == 0) mapping[blacklistID] = num++;
        if (find(reportList[mapping[userID]].begin(), reportList[mapping[userID]].end(), blacklistID) == reportList[mapping[userID]].end()) {
            reportList[mapping[userID]].push_back(blacklistID);
            reportCount[blacklistID]++;
            if (reportCount[blacklistID] >= k) {
                blacklist.push_back(blacklistID);
            }
        }
    }
}
 
vector<int> findAnswer(vector<string> id_list) {
    vector<int> answer;
    for (auto userID : id_list) {
        int mappingID = mapping[userID];
        int result = 0;
        for (auto reportID : reportList[mappingID]) {
            if (find(blacklist.begin(), blacklist.end(), reportID) != blacklist.end()) {
                result++;
            }
        }
        answer.push_back(result);
    }
    return answer;
}
 
vector<int> solution(vector<string> id_list, vector<string> report, int k) {
    vector<int> answer;
    countReport(report, k);
    answer = findAnswer(id_list);
    return answer;
}
Colored by Color Scripter

cs

[ 백준 23290 ] 마법사 상어와 복제 (C++)

얍문 — Thu, 28 Oct 2021 23:49:16 +0900

백준의 마법사 상어와 복제(23290) 문제이다.

[ 문제 바로가기 ]

[ 문제풀이 ]

주어진 문제에 맞게 진행했을 때 최종적으로 물고기가 격자에 몇 마리가 남아있는지 구해야 하는 문제이다.

(이 글을 읽기 전에, 문제를 해결하지 못하신 것은 상관이 없지만, 문제에서 무엇을 구현해야 하는지와 같은 문제에 대한 이해는 완벽하게 하고 오시는 것을 권장드립니다.)

이 문제는 여러 개의 단계로 나눠져 있는데 각 단계별로 구현 과정에 대해서 이야기해보고 이를 통해 정답을 도출하는 과정까지 진행해보자.

#1. 맵 관리

가장 먼저, 맵을 어떻게 관리할지에 대해서부터 이야기를 해보자.

맵에 대해서 이야기 하기 전에, "물고기"에 대해서부터 이야기를 해보자.

물고기는 크게 2가지 정보를 가지고 있다. 바로, 물고기의 위치와 물고기의 진행방향이다.

물고기의 위치를 조금 더 구체적으로 써보면 (x , y)를 가지고 있을 것이고, 그리고 물고기의 진행방향 총 3가지에 대한 정보를 가지고 있다. 그래서 본인은, fish라는 위에서 이야기한 3개의 데이터를 멤버변수로 갖는 구조체를 만들어서 관리해 주었다.

struct fish {
	int x;
	int y;
	int dir;
};

그리고, 위의 구조체를 자료형으로 가지는 2차원 Vector 배열을 맵으로 만들어 주었다.

왜 Vector를 이용했을까 ?? 왜냐하면, 한 칸에 여러 마리의 물고기가 동시에 존재할 수 있기 때문이다.

그렇기 때문에 2차원 Vector배열을 선언해 주었다.

vector<fish> fishMap[MAX][MAX] 이와 같이 선언해 주었다.

그리고, 각각의 좌표에는 해당 좌표에 존재하는 물고기들의 정보를 저장해 주었다.

이를 바탕으로 입력받는 부분을 코드로 한번 살펴보자.

struct fish {
	int x;
	int y;
	int dir;
};

int n = 4, m, s;
vector<fish> fishMap[MAX][MAX];
pair<int, int> shark;

void input() {
	cin >> m >> s;
	for (int i = 0; i < m; i++) {
		int x, y, d;
		cin >> x >> y >> d;
		x--; y--;
		fish f = { x, y, d };
		fishMap[x][y].push_back(f);
	}
	cin >> shark.first >> shark.second;
	shark.first--; shark.second--;
}

#2. Process1 - 물고기 복제하기

이제 본격적으로, 문제를 풀어보자.

가장 첫 번째 단계는 모든 물고기들에게서 복제 마법을 시전하는 것이다. 즉, 현재 물고기들이 있는 좌표에 그대로 물고기들이 복제되는 것이다. 현재 맵을 그대로 복사만 하면 되는 것이기 때문에 본인은, 또 하나의 맵을 만들어서 임시적으로 저장만 해주었다.

vector<fish> fishMap[MAX][MAX], cMap[MAX][MAX];

void copyMap(vector<fish> A[][MAX], vector<fish> B[][MAX]) {
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			A[i][j] = B[i][j];
		}
	}
}

void copyFish() {
	copyMap(cMap, fishMap);
}

물고기를 복제하는 과정을 위해 호출하는 함수는 copyFish() 함수이고, copyFish() 함수에서는 MAP을 복사하는 copyMap() 함수를 호출하게 된다. 즉, 위에 선언되어 있는 'cMap[MAX][MAX]' 라는 2차원 Vector배열에는 현재 1단계에 존재하는 물고기들의 상태를 그대로 저장되어지게 된다.

#3. Process2 - 물고기 이동하기

물고기가 진행방향으로 나아갈 수 있다면, 나아가고 그게 아니라면 진행방향을 반시계 방향으로 45도 회전하면서 시도하게 되는 과정을 구현해야 한다. 일단 우리가 입력받은 대로라면, 우리는 맵의 모든 좌표를 탐색하면서 해당 좌표에 존재하는 물고기들의 정보들을 가지고 물고기를 움직여 주면 된다. 그리고, 물고기가 나아갈 수 있는 좌표를 찾아서 움직이게 된다면, 해당 좌표에 해당 물고기의 정보를 넣어주면 된다. 하지만, 본인은 임시 적으로 물고기의 정보를 저장하는 tempMap을 만들어서 물고기의 정보를 저장해 주었다. 왜 그래야만 할까 ?? 주어진 맵을 가장 왼쪽 위의 좌표가 (1 , 1) 가장 오른쪽 아래의 좌표가 (4 , 4)라고 가정해보자. 그리고 우리는 (1 , 1)부터 순차적으로 (4 , 4)까지 탐색을 하게 될 것이다.

그런데, (1 , 1)에 있는 물고기 한마리가 오른쪽으로 진행방향을 가져서, (1 , 2)로 갔다고 가정해보자.

그럼 우리는 당연히 map[1][2]에 이 물고기에 대한 정보를 넣어주게 될 것이다.

그리고, (1 , 1)을 탐색을 다 했으니, 그 다음인 (1 , 2)를 탐색을 한다고 가정해보자. (1 , 2)에는 (1 , 1)에서 움직여서 오게 된 물고기가 존재한다. 그런데, 이를 따로 처리해주지 않고 그대로 물고기를 움직여 준다면, (1 , 1)에서 (1 , 2)로 움직여서 오게 된 물고기도 또 움직이게 될 것이다. 즉 ! 기존의 map에다가 계속해서 물고기의 정보를 옮겨가면서 계산을 하다보면 위와 같이 잘못된 계산이 이뤄지는 경우가 발생할 수도 있다.

그래서, 물고기가 움직이게 되면, 해당 물고기를 map[1][2]에 넣어주는 것이 아닌, tempMap[1][2] 에 넣어주었다.

그리고, (1 , 2)에 대한 계산을 할 때에는 map[1][2]에 대해서만 계산을 하는 것이다. 그렇게 되면, 기존에 (1 , 2)에 있는 물고기들에 대해서만 계산이 이루어지게 될 것이다.

최종적으로, tempMap에 있는 물고기의 상태를 원본 Map으로 다시 옮겨주기만 하면 된다.

이 외에, 물고기의 방향을 바꾼다거나 물고기가 갈 수 없는 칸인지를 확인해야 하는 과정들도 있는데, 이 과정에서 소개하지 않은 하나의 변수가 새롭게 등장하게 된다.

바로, smellMap 이라는 int형 2차원 배열이다. smellMap[A][B] = C 의 의미는, (A , B)에서 가장 최근에 냄새가 있던 시점은 C입니다 를 의미한다. 이 smellMAP에 대해서는 아래쪽에서 조금 더 구체적으로 이야기를 해보도록 하자.

무튼 ! 여기서는 간략하게만 말해보자면, smellMap[x][y] = 0 인 경우에만 이동이 가능하다. smellMap[x][y] = 0 이라는 것은, 해당 좌표에 물고기의 냄새가 존재하지 않는다는 것을 의미하기 때문이다.

int smellMap[MAX][MAX];
int fdx[] = { 0, 0, -1, -1, -1, 0, 1, 1, 1 };	// fdx[] = fishdx를 의미.
int fdy[] = { 0, -1, -1, 0, 1, 1, 1, 0, -1 }; 	// fdy[] = fishdy를 의미.

int changeDir(int dir) {
	switch (dir) {
	case 1:
		return 8;
	case 2:
		return 1;
	case 3:
		return 2;
	case 4:
		return 3;
	case 5:
		return 4;
	case 6:
		return 5;
	case 7:
		return 6;
	case 8:
		return 7;
	}
}

void moveFish() {
	vector<fish> tempMap[MAX][MAX];

	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			for (int k = 0; k < fishMap[i][j].size(); k++) {
				int x = fishMap[i][j][k].x;
				int y = fishMap[i][j][k].y;
				int dir = fishMap[i][j][k].dir;
				int nx = x;
				int ny = y;
				bool Flag = false;
				for (int l = 0; l < 8; l++) {
					nx = x + fdx[dir];
					ny = y + fdy[dir];
					if (nx >= 0 && ny >= 0 && nx < n && ny < n) {
						if ((nx != shark.first || ny != shark.second) && smellMap[nx][ny] == 0) {
							Flag = true;
							break;
						}
					}
					dir = changeDir(dir);
				}
				if (Flag == true) {
					fish f = { nx, ny, dir };
					tempMap[nx][ny].push_back(f);
				}
				else {
					fish f = { x, y, dir };
					tempMap[x][y].push_back(f);
				}
			}
		}
	}
	copyMap(fishMap, tempMap);
}

#4. Process3 - 상어 움직이기

연속해서 3칸을 상어는 움직이게 된다. 상하좌우로 인접한 칸만 움직일 수 있다. 그리고, 상어는 가장 많은 물고기를 먹을 수 있는 루트로 움직이게 된다. 물고기의 수가 같을 때는, 상어의 움직임이 가지는 우선순위를 따졌을 때, 가장 우선순위가 높은 움직임으로 움직이게 된다. 지금부터 구체적으로 이야기를 해보자.

본인은 이를 "중복순열"을 통해서 접근하였다. 다시 말해서, 상어가 움직여야 하는 3칸의 방향을 중복순열을 통해서 찾아 주었다. 왜 중복순열일까?? 먼저 , 중복이 선택되는 이유에 대해서 알아보자. 상어가 3칸을 움직여야 하는데, 3칸 모두 상상상 의 방향으로 움직이는 것이 가능하다. 즉 ! 어느 한 방향이 기존에 한번 나왓다고 해서 그 방향으로 더 이상 못움직이는 것이 아니다. 그러므로 중복적으로 선택이 가능하다. 두 번째로, 왜 순열일까 ?? 상어가 상하상 으로 움직이는 경우와 상상하로 움직이는 경우를 생각해보자. 똑같이 위쪽으로 2번 움직이고 아래쪽으로 1번 움직이는 것이지만 그 순서만 다를 뿐이다. 하지만 위의 2개의 움직임에 대한 결과는 너무나도 크게 다를 것이다. 그렇기 때문에, 선택한 데이터의 순서에 영향을 미치기 때문에 조합이 아닌 순열을 통해서 구현해 주었다. 아직 중복순열에 대해서 잘 모른다면 아래의 글을 읽고 오도록 하자.

[ 중복순열에 대해서 알아보기(Click) ]

중복순열을 통해서, 발생할 수 있는 모든 경우의 수를 발생시키고, 발생된 경우마다 움직여보면서 물고기를 얼마나 잡아먹을 수 있는지를 Count 해주면 된다. 대신 ! 발생된 경우마다 움직여줄 때, 실제로 물고기에 대한 정보를 없애버리거나 그러면 안된다. 왜냐하면, 예를 들어서 처음에 상상상 의 방향으로 움직였다고 가정해보자. 그런데 이 때, 상상상에 있는 물고기들을 모두 없애고 그 이후에 상상우의 방향으로 움직였다고 가정해보자. 그렇게 되면, '상상'에 있는 물고기는 '상상상'의 방향으로 움직일 때 이미 없어진 물고기이기 때문에 '상상우'로 움직일 때 Count되지 않을 것이고, 결국 독립적으로 시행되어야 하는 경우가 서로에게 영향을 미쳐버리게 되기 때문이다. 그렇기 때문에 실제로 물고기를 없앨거면 다시 물고기를 복원시켜놓아야 한다. 본인은 실제로 없애지는 않고, 방문처리를 통해서 단순히 먹을 수 있는 물고기의 수를 계산해 주었다. 이 부분에 대한 소스코드는 아래와 같다.

int sdx[] = { 0, -1, 0, 1, 0 };
int sdy[] = { 0, 0, -1, 0, 1 };
int tempRoute[3], route[3];	
// tempRoute[3] = 중복순열을 통해 발생한 경우, Simulation을 위해 상어의 이동방향을 저장하는 배열
// route[3] = Simulation을 통해, 가장 많은 물고기를 먹을 수 있는 상어의 이동방향을 저장하는 배열
int maxEating;

int routeSimulation() {
	bool visit[MAX][MAX] = { false, };
	int x = shark.first;
	int y = shark.second;
	int eat = 0;
	for (int i = 0; i < 3; i++) {
		int dir = tempRoute[i];
		int nx = x + sdx[dir];
		int ny = y + sdy[dir];
		if (nx < 0 || ny < 0 || nx >= n || ny >= n) return -1;
		if (visit[nx][ny] == false) {
			visit[nx][ny] = true;
			eat += fishMap[nx][ny].size();
		}
		x = nx;
		y = ny;
	}
	return eat;
}

void findRoute(int cnt) {
	if (cnt == 3) {
		int eatNum = routeSimulation();
		if (eatNum > maxEating) {
			for (int i = 0; i < 3; i++) {
				route[i] = tempRoute[i];
			}
			maxEating = eatNum;
		}
		return;
	}

	for (int i = 1; i <= 4; i++) {
		tempRoute[cnt] = i;
		findRoute(cnt + 1);
	}
}

void moveShark(int time) {
	vector<fish> tempMap[MAX][MAX];
	copyMap(tempMap, fishMap);

	int x = shark.first;
	int y = shark.second;
	for (int i = 0; i < 3; i++) {
		int dir = route[i];
		int nx = x + sdx[dir];
		int ny = y + sdy[dir];
		if (tempMap[nx][ny].size() != 0) {
			smellMap[nx][ny] = time;
			tempMap[nx][ny].clear();
		}
		x = nx;
		y = ny;
		shark.first = x;
		shark.second = y;
	}
	copyMap(fishMap, tempMap);
}

void aboutShark(int time) {
	maxEating = -1;
	findRoute(0);
	moveShark(time);
}

그런데 위의 코드를 보면, 문제에서 제시한 "상어의 이동방향에 대한 우선순위 계산"이 전혀 들어있지 않다.

왜그럴까 ?! 왜냐하면 애초에 상어의 움직임의 순서를 우선순위 순서대로 넣어주었기 때문이다.

가장 위에 sdx[]와 sdy[]를 보면, 이게 상어가 인접한 칸으로 움직일 때 x변화값과 y변화값이다.

그런데, 저 순서를 잘 보면, 상좌하우 순서대로 존재한다.

즉, sdx,y[1] = 상 으로 움직이는 경우. sdx,y[2] = 좌로 움직이는 경우. sdx,y[3] = 하로 움직이는 경우, sdx,y[4] = 우로 움직이는 경우이다. 그리고 중복순열을 뽑을 때는 1번부터 순차적으로 뽑게된다.

즉 ! 중복순열로 3개의 이동방향을 뽑았을 때, 가장 먼저 나오는 것은 '111' 즉, 상상상을 의미하게 된다.

가장 마지막으로 나오는 것은 '444' 즉, 우우우가 될 것이다. 즉 ! 물고기를 먹은 수가 동일한 경우에는 우선순위를 따져줘야 하는데, 굳이 따져줘도 되지 않아도 되는 이유는 기존에 최대로 먹었던 물고기의 수와 현재 케이스로 먹은 물고기 수가 동일하다면 기존 진행방향이 더 우선순위가 자연스럽게 더 높아지게 된다. 그래서 findRoute() 함수에서 line31)에서 보게 되면, 물고기의 수가 동일한 경우에는 계산조차 하지 않는다. 왜냐하면 동일한 경우에는 값의 갱신이 일어나지 않는 것이 맞기 때문이다.

#5. Process4 - 물고기 냄새

#4의 내용과 매우 이어지는 내용이다. #4에서 소스코드에도 잠깐 보였겠지만, 아무런 언급을 일부러 하지도 않았다.

한 가지 상황을 생각해보자. (x , y)라는 좌표에서 1초에 물고기가 죽어서 냄새를 남겼다고 가정해보자.

4초에는 (x , y)에 냄새가 남아있을까 ?? 남아있지 않다.

그럼, (x , y)라는 좌표에서 물고기가 1초에 죽어서 냄새를 남겼고, 그 이후에 (x , y)에서 물고기가 3초에 죽어서 냄새를 남겼다고 생각해보자. 4초에는 (x , y)에는 냄새가 남아있을까 ?? 냄새가 남아있다.

그럼, (x , y)에서 2초에 한마리가 죽고, 3초에 한마리가 죽었다. 4초에 (x , y)에 냄새가 남아있을까 ? 냄새가 남아있을 것이다.

너무나도 당연하고 간단한 이야기이다. 본인이 이 이야기를 통해서 하고자 하는 이야기는 다음과 같다.

"해당 좌표에서 몇 마리의 물고기가 죽었는지는 상관이 없다. 우리가 알아야 하는 것은, 현재 해당 좌표에 물고기의 냄새가 남아있는지 아닌지일 뿐이다". 이 이야기를 하고 싶다.

아까 위에서 잠깐 언급했듯이, 본인은 냄새가 있는 좌표를 관리하기 위해서 int smellMap[MAX][MAX] 라는 int형 2차원 배열을 선언해 주었다고 했다. 여기서 smellMap[MAX][MAX]의 자료형이 'int'인 이유가 위에서 했던 이야기이다.

결국, 특정 좌표에서 마지막에 죽은 물고기의 시간만 알고 있다면, smellMap에는 그 값만 넣어주면 된다.

void moveShark(int time) {
	vector<fish> tempMap[MAX][MAX];
	copyMap(tempMap, fishMap);

	int x = shark.first;
	int y = shark.second;
	for (int i = 0; i < 3; i++) {
		int dir = route[i];
		int nx = x + sdx[dir];
		int ny = y + sdy[dir];
		if (tempMap[nx][ny].size() != 0) {
			smellMap[nx][ny] = time;
			tempMap[nx][ny].clear();
		}
		x = nx;
		y = ny;
		shark.first = x;
		shark.second = y;
	}
	copyMap(fishMap, tempMap);
}

#4에서 나왔던, 상어를 움직이는 과정이다. 이 과정에서 물고기가 죽게 되는데, 물고기가 죽게 되면 해당 좌표에 smellMap 값을 설정해주는 부분이 line12)에 구현되어 있다.

여기서 smellMap의 값을 단순히 바로 현재 시간인 'time'으로 설정해주는 이유는, 지금 죽는 물고기가 해당 좌표에서 가장 마지막에 죽은 물고기가 되는 것이 자명한 사실이기 때문이다. 과연, 저렇게 상어가 움직이고 난 이후에 또 다른 요소에 의해서 저 값이 바뀔 수 있을까 ? 아니면 smellMap에 있었던 기존의 값 때문에 값이 갱신되면 안되는 그런 요소가 있을까 ?? 전혀 없다. 나는 지금 smellMap에는 "해당 좌표에서 가장 마지막에 죽은 물고기의 시간" 만 적어놓을 것이고, 그 시간은 상어에게 먹혀버리게 되는 이 순간이기 때문이다.

그럼 냄새를 없애는 과정은 어떻게 될까 ?? 다음과 같이 구현할 수 있다.

void removeSmell(int time) {
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			if (smellMap[i][j] == 0) continue;
			if (time - smellMap[i][j] == 2) {
				smellMap[i][j] = 0;
			}
		}
	}
}

#6. 복제된 물고기 태어나기

복제된 물고기는 cMap이라는 또 다른 맵에 저장이 되어 있을 것이고, 이 맵을 원본 map에 복사만 해주면 된다.

void bornFish() {
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			for (int k = 0; k < cMap[i][j].size(); k++) {
				fishMap[i][j].push_back(cMap[i][j][k]);
			}
		}
	}
}

[ 소스코드 ]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235

#include <iostream>
#include <vector>
 
#define endl "\n"
#define MAX 5
using namespace std;
 
struct fish {
    int x;
    int y;
    int dir;
};
 
int n = 4, m, s, maxEating;
int tempRoute[3], route[3];
int smellMap[MAX][MAX];
vector<fish> fishMap[MAX][MAX], cMap[MAX][MAX];
pair<int, int> shark;
 
int fdx[] = { 0, 0, -1, -1, -1, 0, 1, 1, 1 };
int fdy[] = { 0, -1, -1, 0, 1, 1, 1, 0, -1 };
 
int sdx[] = { 0, -1, 0, 1, 0 };
int sdy[] = { 0, 0, -1, 0, 1 };
 
 
void input() {
    cin >> m >> s;
    for (int i = 0; i < m; i++) {
        int x, y, d;
        cin >> x >> y >> d;
        x--; y--;
        fish f = { x, y, d };
        fishMap[x][y].push_back(f);
    }
    cin >> shark.first >> shark.second;
    shark.first--; shark.second--;
}
 
void copyMap(vector<fish> A[][MAX], vector<fish> B[][MAX]) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            A[i][j] = B[i][j];
        }
    }
}
 
void copyFish() {
    copyMap(cMap, fishMap);
}
 
int changeDir(int dir) {
    switch (dir) {
    case 1:
        return 8;
    case 2:
        return 1;
    case 3:
        return 2;
    case 4:
        return 3;
    case 5:
        return 4;
    case 6:
        return 5;
    case 7:
        return 6;
    case 8:
        return 7;
    }
}
 
void moveFish() {
    vector<fish> tempMap[MAX][MAX];
 
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            for (int k = 0; k < fishMap[i][j].size(); k++) {
                int x = fishMap[i][j][k].x;
                int y = fishMap[i][j][k].y;
                int dir = fishMap[i][j][k].dir;
                int nx = x;
                int ny = y;
                bool Flag = false;
                for (int l = 0; l < 8; l++) {
                    nx = x + fdx[dir];
                    ny = y + fdy[dir];
                    if (nx >= 0 && ny >= 0 && nx < n && ny < n) {
                        if ((nx != shark.first || ny != shark.second) && smellMap[nx][ny] == 0) {
                            Flag = true;
                            break;
                        }
                    }
                    dir = changeDir(dir);
                }
                if (Flag == true) {
                    fish f = { nx, ny, dir };
                    tempMap[nx][ny].push_back(f);
                }
                else {
                    fish f = { x, y, dir };
                    tempMap[x][y].push_back(f);
                }
            }
        }
    }
    copyMap(fishMap, tempMap);
}
 
int routeSimulation() {
    bool visit[MAX][MAX] = { false, };
    int x = shark.first;
    int y = shark.second;
    int eat = 0;
    for (int i = 0; i < 3; i++) {
        int dir = tempRoute[i];
        int nx = x + sdx[dir];
        int ny = y + sdy[dir];
        if (nx < 0 || ny < 0 || nx >= n || ny >= n) return -1;
        if (visit[nx][ny] == false) {
            visit[nx][ny] = true;
            eat += fishMap[nx][ny].size();
        }
        x = nx;
        y = ny;
    }
    return eat;
}
 
void findRoute(int cnt) {
    if (cnt == 3) {
        int eatNum = routeSimulation();
        if (eatNum > maxEating) {
            for (int i = 0; i < 3; i++) {
                route[i] = tempRoute[i];
            }
            maxEating = eatNum;
        }
        return;
    }
 
    for (int i = 1; i <= 4; i++) {
        tempRoute[cnt] = i;
        findRoute(cnt + 1);
    }
}
 
void moveShark(int time) {
    vector<fish> tempMap[MAX][MAX];
    copyMap(tempMap, fishMap);
 
    int x = shark.first;
    int y = shark.second;
    for (int i = 0; i < 3; i++) {
        int dir = route[i];
        int nx = x + sdx[dir];
        int ny = y + sdy[dir];
        if (tempMap[nx][ny].size() != 0) {
            smellMap[nx][ny] = time;
            tempMap[nx][ny].clear();
        }
        x = nx;
        y = ny;
        shark.first = x;
        shark.second = y;
    }
    copyMap(fishMap, tempMap);
}
 
void aboutShark(int time) {
    maxEating = -1;
    findRoute(0);
    moveShark(time);
}
 
void removeSmell(int time) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (smellMap[i][j] == 0) continue;
            if (time - smellMap[i][j] == 2) {
                smellMap[i][j] = 0;
            }
        }
    }
}
 
void bornFish() {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            for (int k = 0; k < cMap[i][j].size(); k++) {
                fishMap[i][j].push_back(cMap[i][j][k]);
            }
        }
    }
}
 
int findAnswer() {
    int ret = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            ret += fishMap[i][j].size();
        }
    }
    return ret;
}
 
void solution() {
    for (int i = 1; i <= s; i++) {
        copyFish();
        moveFish();
        aboutShark(i);
        removeSmell(i);
        bornFish();
    }
    cout << findAnswer() << endl;
}
 
void solve() {
    input();
    solution();
}
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
 
//    freopen("Input.txt", "r", stdin);
    solve();
 
    return 0;
}
 
 
 
Colored by Color Scripter

cs

[ 백준 23289 ] 온풍기 안녕 ! (C++)

얍문 — Wed, 27 Oct 2021 23:43:08 +0900

백준의 온풍기 안녕!(23289) 문제이다.

[ 문제풀이 ]

문제가 구현해야 할 부분도 난이도도 꽤나 있는 편인 문제이다. 문제에서 제시한 순서에 맞게 온풍기의 성능을 테스트 하였을 때, 몇 번만에 주어진 조건에 맞게 방이 설정되는지 구해야 하는 문제이다.

주어진 입력값을 관리하는 것 부터, 주어진 순서에 맞게 과정이 진행되는 사항을 과정별로 차근차근 알아보도록 하자.

(이 글을 읽기 전에, 문제를 해결하시지 못한 것은 상관이 없는데 문제에 대한 이해와 구현해야 하는 내용이 무엇인지는 완벽하게 알고 읽으시는 것을 권장드립니다.)

#1. 입력값

우리는 크게 본다면, 입력값으로 총 2가지의 정보를 입력받게 된다.

1. 맵의 구성 : 어느 좌표가 온풍기가 존재하는지, 온도를 조사해야 하는 좌표 값들을 맵에 숫자들로 입력받게 된다.

2. 벽의 상태 : 벽이 어느 위치에 어느 방향으로 벽이 세워져 있는지 입력받게 된다.

먼저, 맵의 구성을 보게 된다면 0 ~ 5까지의 숫자가 주어질 수가 있다. 0은 빈칸, 1 ~ 4는 온풍기, 5는 조사해야 할 좌표를 의미한다. 본인은 입력받음과 동시에 맵의 모든 값들을 0으로 바꿔버렸다. 왜냐하면, 본인은 맵의 좌표값에 들어가는 값을 온도로 채워나갈 것이기 때문이다.

초기에는 당연히 모든 좌표가 0도일 것이다. 그런데, 온풍기나 조사해야 할 좌표를 의미하는 1 ~ 5의 값이 처음부터 들어있다면, 온도를 계산하는데 있어서 불편함이 있을 수 있기 때문이다.

대신, 위의 정보들을 따로 어딘가에는 저장을 해주어야 한다. 그래서 본인은 vector를 선언해서 위의 값들을 관리해 주었다.

조사해야 할 좌표 값들의 정보를 저장하기 위해서 pair<int, int>를 자료형으로 갖는 Vector 하나,

온풍기에 대한 정보를 저장하기 위해서 pair<pair<int, int>, int>> 를 자료형으로 갖는 Vector 하나.

온풍기에 대한 정보는 (x , y)라는 좌표에 대한 정보도 있어야 하지만, 온풍기의 바람 방향까지도 저장을 해야 하기 때문에 위와 같이 3개의 int를 관리할 수 있도록 만들어 주었다.

두 번째로 벽에 대한 정보를 입력받게 되는데 본인은 이를 벽을 위한 맵을 하나 더 만들어서 관리해 주었다.

맵은 3차원으로 이루어져있고 bool형의 그 크기는 [MAX][MAX][4] 로 만들어 주었다.

즉, bool wallMap[MAX][MAX][4] 라는 벽에 대한 정보를 담을 수 있는 맵을 하나 만들어 주었다.

그리고 우리는 입력으로 특정 좌표 (x , y)에서 어느 방향에 벽이 있는지를 입력으로 받게 된다.

만약, (x , y)에 0의 방향으로 벽이 있다면, (x , y)와 그 위의 좌표인(x - 1 , y)사이에 벽이 있음을 의미하고, 1의 방향으로 벽이 있다면 (x , y)와 (x , y + 1) 사이에 벽이 있음을 의미한다.

즉, 정리해본다면 (x , y)에 0의 벽이 있다면, (x , y)에서 북쪽 방향으로는 벽이 있음을 의미하고, (x - 1 , y)에서는 남쪽 방향으로 벽이 있음을 의미한다. 1이라면 (x , y)에서 동쪽 방향으로 벽이 있음을, (x , y + 1)에서는 서쪽 방향으로 벽이 있음을 의미한다. 그래서 이를 wallMap에 표시를 해 주었다.

wallMap[x][y][0] = true 라는 것은, (x , y)에서 동쪽 방향으로는 벽이 있습니다.

wallMap[x][y][1] = true 라는 것은, (x , y)에서 서쪽 방향으로는 벽이 있습니다.

이런식으로 표현을 해 주었다. 본인은 방향을 { 0 , 1 , 2 , 3 } 을 { 동 , 서 , 남 , 북 } 으로 계산했기에 위와 같이 표현을 해 주었다. 이 방향은 당연히 각자 가장 편한 방식으로 지정을 해주면 된다.

지금까지 했던 이야기를 코드로 나타내면 다음과 같다.

int r, c, k, w;
int map[MAX][MAX];
bool wallMap[MAX][MAX][4];

vector<pair<int, int>> searchPos;
vector<pair<pair<int, int>, int>> heater;
vector<pair<pair<int, int>, int>> wall;

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

void input() {
	cin >> r >> c >> k;
	for (int i = 1; i <= r; i++) {
		for (int j = 1; j <= c; j++) {
			cin >> map[i][j];
			if (map[i][j] != 0 && map[i][j] != 5) {
				heater.push_back(make_pair(make_pair(i, j), map[i][j]));
			}
			else if (map[i][j] == 5) {
				searchPos.push_back(make_pair(i, j));
			}
			map[i][j] = 0;
		}
	}
	cin >> w;
	for (int i = 0; i < w; i++) {
		int a, b, c; cin >> a >> b >> c;
		wall.push_back(make_pair(make_pair(a, b), c));
	}
}

void settingWall() {
	for (int i = 0; i < w; i++) {
		int x = wall[i].first.first;
		int y = wall[i].first.second;
		int t = wall[i].second;
		
		if (t == 0) {
			wallMap[x][y][3] = true;
			wallMap[x - 1][y][2] = true;
		}
		else {
			wallMap[x][y][0] = true;
			wallMap[x][y + 1][1] = true;
		}
	}
}

위의 코드는, 이번문제에서 사용할 변수들과 입력값들을 관리하는 내용들을 구현한 소스코드이다.

#2. 1번과정 - 온풍기에서 바람이 나오는 과정

이제 입력도 받았고, 입력값에 따른 기본적인 세팅과정도 끝났으니 실제로 구현해야 되는 부분으로 넘어가보자.

가장 먼저, 1번 과정인 집에 있는 모든 온풍기에서 바람이 나오는 과정을 진행해보자.

바람이 나오는 과정이 참으로 마음에 들지는 않는다... 천천히 같이 진행해보자.

일단 바람이 나오게 되면 칸이 점점 멀어질 수록 숫자가 감소하는 그런 형태이면서 동시에 점점 퍼져나가는 그런 형태이다. (무슨 말인지는 저도 모르겠지만.. 문제를 보고 오셨다면 이해하실 수 있을 겁니다!)

먼저, 본인은 바람이 퍼지는 방향을 위해서 새로운 방향을 나타내는 배열을 만들어 주었다.

아래의 그림을 보면서 이야기를 계속 해보자.

온풍기가 위의 그림에서 '온풍'이라고 적혀있는 곳에 위치하고 온풍기가 오른쪽 방향으로 바람이 나올 때의 상황이다.

가장 처음에 빨강색 좌표의 온도가 5도만큼 올라가게 될 것이다.

그리고 그 이후부터는 점점 퍼져나가게 된다. 가장 첫 칸인 빨강색 칸만 퍼져나가지 않는다.

그래서 본인은 퍼져나가는 3가지 방향에 대해서 계산을 할 수 있도록 새로운 배열을 만들어 주었다.

빨강색 좌표가 (x , y)라면, 그 이후에 퍼져나가게 되는 좌표는 (x - 1 , y + 1), (x , y + 1), (x + 1 , y + 1)이 된다.

즉, x좌표는 { -1 , 0 , 1 }으로 퍼져나가게 되고, y좌표는 { 1 , 1 , 1 } 로 퍼져나가게 된다.

이 방향들을 계산할 수 있도록, 모든 방향에 대해서 만들어 준 것이다. 먼저 ,이 배열들만 보자면 다음과 같다.

int wdx[4][3] = { { -1, 0, 1 }, {-1, 0, 1 }, {1, 1, 1}, {-1, -1, -1} };
int wdy[4][3] = { { 1, 1, 1}, { -1, -1, -1 }, {-1, 0, 1 },{-1, 0, 1} };

wdx,y[0][] = 온풍기의 바람이 동쪽으로 나올 때

wdx,y[1][] = 온풍기의 바람이 서쪽으로 나올 때

wdx,y[2][] = 온풍기의 바람이 남쪽으로 나올 때

wdx,y[3][] = 온풍기의 바람이 북쪽으로 나올 때 의 값을 저장해 놓은 것이다.

다시 한번 말하지만, 본인은 동서남북을 순서대로 0,1,2,3 이라는 방향으로 지정해놓고 사용했기 때문에 위와 같이 구현한 것이다. 절대로 위의 값 까지 똑같을 필요는 없다.

그러면, 빨강색 좌표에서 위의 배열을 통해서 3칸을 계산하게 되면 파랑색 칸이 계산이 되어질 것이다.

그럼, 파랑색칸에서 초록색 칸으로 가는것도 계산을 해보자. 그럼 아마 다음과 같이 계산이 될 것이다.

위와 같이 계산이 될 것이다.

가장 위의 파랑색 좌표에서는 노랑색 화살표처럼 그 다음 3칸을 계산하게 될 것이고, 가운데 파랑색 좌표에서는 회색 화살표처럼 그 다음 3칸을, 가장 아래에 있는 파랑색 좌표에서는 흰색 화살표처럼 그 다음 3칸을 계산하게 될 것이다.

그런데 ! 이러면 문제가 생긴다! 딱봐도 알겠지만, 화살표를 중복되게 받고 있는 초록색 좌표들이 존재한다. 이렇게 되면 이러한 초록색 좌표들은 값의 갱신이 여러번 일어나게 되고 제대로 온도 계산이 되지 않을 것이다.

그래서 ! "이미 한번 온도 갱신이 일어난 좌표는 더 이상 갱신시키지 않겠습니다" 라는 의미를 가지고 있는 2차원 배열을 만들어 주었다. 이 2차원 배열은 밑에서 조금 더 구체적으로 이야기해보자.

지금까지 한 이야기를 정리해보면 다음과 같다.

1. 온풍기의 바람은 첫 칸을 제외하고, 그 이후의 칸들에 대해서는 점점 퍼져나가는 특징이 있다.
2. 그래서, 점점 퍼져나가는 좌표들을 계산하기 위해서 wdx[][], wdy[][] 라는 방향을 나타내는 배열을 생성했다.
3. 2번 처럼 계산할 경우, 중복되는 좌표들이 있기 때문에, 이를 처리해줄 무언가가 필요하다.

여기까지는 좋은데, 그래서 온풍기의 바람이 나가는 저걸 어떻게 구현해야할까 ??

본인은 Queue를 이용해서 구현해주었다. 너비우선탐색(BFS)과 매우 비슷한 형태로 구현을 해 주었다.

Queue에 좌표 값과 바람의 세기를 넣어주고, 이 Queue에 들어 있는 값들을 하나씩 빼오면서 바람이 나아갈 수 있는 그 다음 좌표가 존재한다면, 그 다음 좌표를 Queue에 순차적으로 계속 넣어주면서 반복해 주었다.

물론, 그 과정에서 위에서 이야기한 "중복적으로 탐색이 되는 좌표들"을 걸러주기 위해서 bool형의 2차원 배열을 하나 만들어 주었다. bool Update[MAX][MAX] 라는 2차원 배열인데, Update[x][y] = true의 의미는 "(x , y)는 이미 온도가 한번 업데이트 된 적 있는 좌표이니 더 이상 업데이트 하지 마세요" 라는 것을 의미한다.

이 부분을 코드로 확인해보면 다음과 같다.

void spread(int x, int y, int d) {
	bool update[MAX][MAX] = { false, };
	d = changeMydir(d);
	x += dx[d];
	y += dy[d];
	if (x < 1 || y < 1 || x > r || y > c) return;

	queue<pair<pair<int, int>, int >> q;
	q.push(make_pair(make_pair(x, y), 5));

	while (q.empty() == 0) {
		int x = q.front().first.first;
		int y = q.front().first.second;
		int wind = q.front().second;
		q.pop();

		map[x][y] += wind;
		if (wind == 1) continue;

		for (int i = 0; i < 3; i++) {
			int nx = x + wdx[d][i];
			int ny = y + wdy[d][i];
			if (nx >= 1 && ny >= 1 && nx <= r && ny <= c) {
				if (update[nx][ny] == false && checkWall(x, y, nx, ny, d, i) == true) {
					update[nx][ny] = true;
					q.push(make_pair(make_pair(nx, ny), wind - 1));
				}
			}
		}
	}
}

void spreadWind() {
	for (int i = 0; i < heater.size(); i++) {
		int x = heater[i].first.first;
		int y = heater[i].first.second;
		int d = heater[i].second;
		spread(x, y, d);
	}
}

위의 코드에서 line3) 에보면, dir = changeMyDir(d) 이라는 부분이 있는데, 전혀 신경쓰지 않아도 되는 부분이다.

저 부분은, 본인이 구현을 할 때 본인이 편하게 구현할 수 있도록 문제에서 주어진 방향 말고 본인이 구현한 방향대로 방향을 바꿔서 계산하기 쉽게 만들기 위해서 넣어놓은 부분이므로 신경쓰지 않아도 된다.

위의 코드의 대부분은 이해가 될 것이지만, 언급하지 않은 부분이 한 가지 있다. 바로, line24)에 있는 조건문중 하나인, checkWall() 함수이다. 온풍기의 바람이 퍼져나갈 때, 벽의 위치에 따른 조건이 문제에 제시되어 있다.

그 부분을 구현한 내용인데 매우 머리에 쥐가 날 것처럼 헷갈리는 부분이지만, 어떻게 설명을 해야할지를 잘 모르겠다.

먼저 코드부터 보고 난 후에 이야기를 해보자. 코드를 하나하나 이해하려 하지말고 그냥 얼핏 보고 넘어가자.

bool checkWall(int x, int y, int nx, int ny, int d, int dir) {
	if (dir == 1) {
		if (wallMap[x][y][d] == false) return true;
	}
	else if(dir == 0){
		if (d == 0) {
			int upx = x - 1;
			int upy = y;
			if (wallMap[x][y][3] == false && wallMap[upx][upy][0] == false) return true;
		}
		else if (d == 1) {
			int upx = x - 1;
			int upy = y;
			if (wallMap[x][y][3] == false && wallMap[upx][upy][1] == false) return true;
		}
		else if (d == 2) {
			int dnx = x;
			int dny = y - 1;
			if (wallMap[x][y][1] == false && wallMap[dnx][dny][2] == false) return true;
		}
		else if (d == 3) {
			int dnx = x;
			int dny = y - 1;
			if (wallMap[x][y][1] == false && wallMap[dnx][dny][3] == false) return true;
		}
	}
	else if (dir == 2) {
		if (d == 0) {
			int upx = x + 1;
			int upy = y;
			if (wallMap[x][y][2] == false && wallMap[upx][upy][0] == false) return true;
		}
		else if (d == 1) {
			int upx = x + 1;
			int upy = y;
			if (wallMap[x][y][2] == false && wallMap[upx][upy][1] == false) return true;
		}
		else if (d == 2) {
			int dnx = x;
			int dny = y + 1;
			if (wallMap[x][y][0] == false && wallMap[dnx][dny][2] == false) return true;
		}
		else if (d == 3) {
			int dnx = x;
			int dny = y + 1;
			if (wallMap[x][y][0] == false && wallMap[dnx][dny][3] == false) return true;
		}
	}
	return false;
}

위의 함수에서 매개변수 중, 'd'는 온풍기에서 나오는 바람의 방향을 의미하고, 'dir'은 3칸 중 어느 칸으로 나아갈지를 나타내는 부분이다 .여기서 '3칸'은 위에서 이야기했듯이, 바람이 점점 퍼지면서 나아가기 때문에, 모든 좌표에서 3칸씩 화살표를 뻗으면서 나아간다고 이야기 했었다. 그리고 그 과정에서 업데이트가 중복되지 않도록 만들어주는 것도 이야기를 했었다.

여기서 그 3칸을 의미한다.

먼저, dir = 1 인 경우 온풍기의 바람이 대각선이 아닌 나오는 바람 방향 그대로 직진하는 경우를 의미한다.

그대로 직진하는 경우에는 현재 칸과, 그 다음 칸 사이에 벽이 있는지만 확인을 해주면 된다.

그렇기에, line3)의 조건문이 저렇게 구현되는 것이다.

이제, 남은 것은 바람이 대각선으로 나오는 경우들인데, 이 경우에는 문제에서 제시한대로, 현재 칸의 옆칸과 바람이 향하는 칸 사이에 있는 벽들을 고려를 해주어야 한다. 그 벽들을 고려해주는 것이 위의 코드에서 남은 부분들이다.

코드의 양도 꽤 되는 것 같고, 뭔가 구현도 많이 되어 있는 것 같은데 사실 어떻게 설명을 해야할지 잘 모르겠다.

사람마다 방향을 나타내는 값을 설정하는 것도 모두 다르기 때문에 위의 설정되어 있는 Index값 하나하나를 설명하는 것은 크게 의미가 없는 것이라고 생각한다. 무튼 ! 본인은 위와 같이 벽을 판단해 주고 false가 return 된다면, 벽에 가로막혀서 바람이 갈 수 없으니 탐색을 해주지 않았다.

#3. 2번과정 - 바람의 양 조절하기

모든 칸에 대해서, 서로 인접한 칸과 비교를 해서 온도가 조절되는 과정이다.

서로 인접한 칸이라는 것은, 하나의 좌표를 기준으로 상, 하, 좌, 우 에 있는 4개의 칸을 의미한다.

그리고 이 과정은 "모든 칸에 대해서 동.시.에 발생한다" 라고 되어 있다.

문제에서는 상/하/좌/우 4개의 있는 칸을 비교해서 온도를 조절하라고 했지만, 본인은 우/하 즉, 동쪽과 남쪽에 있는 2개의 좌표랑만 비교를 해서 온도를 조절해 주었다. 왜그럴까 ?!

아래의 예시를 한번 살펴보자.

가장 먼저, 빨강색 칸을 기준으로 온도를 조절하는 과정을 진행해보자. 그렇게되면, 인접한 칸인 2개의 파랑색 칸에 대해서 계산을 진행하게 될 것이다. 빨강색 칸을 기준으로 북쪽과 서쪽에는 칸이 존재하지 않기 때문에 비교를 할 수 없을 것이다.

그럼, 파랑색칸들과 빨강색 칸을 비교해서 뭐 어떻게 온도가 조절되었다고 가정해보자.

그리고 그 다음, '10'의 값을 가지고 있는 파랑색 칸을 기준으로 온도를 조절하는 과정을 진행해보자.

빨강색 칸을 기준으로 북쪽에는 칸이 없기 때문에 서쪽과 남쪽 그리고 동쪽 3개의 파랑색 칸에 대해서 온도 조절을 실행하게 될 것이다. 그런데 ! 왼쪽에 있는 '5'와의 관계에 대해서 한번 생각을 해보자.

분명, 이전에 '5'가 중심일 때, '10'과 비교를 해서 온도조절을 한 적이 있다. 그런데 ! 여기서 또 한번 '10'과 '5'를 비교를 해서 온도조절을 해야 하는 상황이 발생하게 된다. 왜 이런 상황이 발생했을까 ??

지금 탐색하는 순서가, 주어진 맵을 하나의 행에서 열부터 모두 탐색을 하고, 그 다음 행으로 탐색을 하는 순서대로 탐색을 진행하고 있기 때문이다. 즉 ! (0 , 0)부터 (R , C)까지 순차적으로 탐색을 하게 된다면, 서쪽과 북쪽에 대해서는 온도조절을 할 필요가 없다. 왜냐하면 기존에 이미 온도조절을 했기 때문이다. 현재 좌표를 (x , y) 그리고 서쪽에 있는 좌표를 (x - 1 , y)로 둔다면, 이 2개의 좌표에 대한 온도조절은, (x - 1 , y)에서 남쪽 방향에 있는 (x , y)와 온도조절을 할 때 이미 온도조절을 했기 때문에, 굳이 (x , y)에서 (x - 1, y)와 한번 더 온도 조절을 해줄 필요가 없다는 것이다.

그렇기 때문에 ! 본인은 맵을 (0 , 0)부터 (R , C)까지 순차적으로 탐색을 하고, 그 과정에서 인접한 칸에 대한 온도조절은 동쪽과 남쪽에 대해서만 진행을 해 주었다. 그리고 또 하나 중요한 것은, 이러한 과정은 모든칸에 대해서 "동시에" 일어난다는 것이다.

위의 경우에서 가장 왼쪽위에 있는 '5'와 빨강색으로 표시되어 있는 '10' 사이에서 온도조절이 발생하게 된다면, (10 - 5 ) / 4 만큼 값이 바뀌게 되므로, 가장 왼쪽위에 있는 '5'는 '6'으로 빨강색으로 표시되어 있는 '10'은 '9'가 될 것이다.

이후에 , 빨강색으로 표시되어 있는 '10'과 그 오른쪽에 있는 '15'가 계산이 일어나는 순간을 생각해보자.

이미, 빨강색 좌표는 '9'로 온도가 낮아졌지만, 문제에서는 "모든 칸에 대해서 동시에 일어난다"고 했으므로, 사실 계산은 10과 15로 해 주어야 한다는 것이다. 그렇기 때문에, 본인은 "온도 변화의 가중치를 저장해주는 임의의 맵"을 하나 만들어서 계산해 주었다. 그리고 모든 계산을 끝낸 후에는 원래의 맵에다가 온도조절에 의해서 발생한 가중치 만큼을 더해주었다.

이에 해당하는 소스코드는 다음과 같다.

void controlTemperature() {
	int tempMap[MAX][MAX] = { 0, };
	for (int x = 1; x <= r; x++) {
		for (int y = 1; y <= c; y++) {
			for (int i = 0; i < 2; i++) {
				int dir = i == 0 ? 0 : 2;
				int nx = x + dx[dir];
				int ny = y + dy[dir];
				if (nx >= 1 && ny >= 1 && nx <= r && ny <= c) {
					if (wallMap[x][y][dir] == false) {
						pair<int, int> maxCoord, minCoord;
						if (map[x][y] > map[nx][ny]) {
							maxCoord = { x, y };
							minCoord = { nx, ny };
						}
						else {
							maxCoord = { nx, ny };
							minCoord = { x, y };
						}

						int diff = abs(map[x][y] - map[nx][ny]);
						diff /= 4;
						tempMap[maxCoord.first][maxCoord.second] -= diff;
						tempMap[minCoord.first][minCoord.second] += diff;
					}
				}
			}
		}
	}
	addMap(map, tempMap);
}

#4. 가장 바깥쪽 온도 감소 & 정답도출

먼저, 가장 바깥족 온도를 감소시키는 과정은 매우 간단하다. 말 그대로, 가장 바깥쪽에 해당하는 좌표들 중에서 온도가 1 이상인 좌표들은 온도를 1씩 감소시켜 주면 된다. 특별한 방법이 사용된 것이 아니기 때문에 그냥 소스코드로 설명을 대체하겠다.

그리고, 최종적으로 정답을 도출해 주어야 하는데, 이 또한 입력할 때 받아두었던 "조사해야 하는 칸들을 저장해 놓은 구현체를 탐색하면서 모두 온도가 K 이상인지 확인"만 해주면 된다.

[ 소스코드 ]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278

#include <iostream>
#include <vector>
#include <queue>
 
#define endl "\n"
#define MAX 25
using namespace std;
 
int r, c, k, w;
int map[MAX][MAX];
bool wallMap[MAX][MAX][4];
 
vector<pair<int, int>> searchPos;
vector<pair<pair<int, int>, int>> heater;
vector<pair<pair<int, int>, int>> wall;
 
int dx[] = { 0, 0, 1, -1 };
int dy[] = { 1, -1, 0, 0 };
 
int wdx[4][3] = { { -1, 0, 1 }, {-1, 0, 1 }, {1, 1, 1}, {-1, -1, -1} };
int wdy[4][3] = { { 1, 1, 1}, { -1, -1, -1 }, {-1, 0, 1 },{-1, 0, 1} };
 
void printMap(int A[][MAX]) {
    for (int i = 1; i <= r; i++) {
        for (int j = 1; j <= c; j++) {
            printf("%2d ", A[i][j]);
        }
        cout << endl;
    }
    cout << "#######################################################" << endl;
}
 
void input() {
    cin >> r >> c >> k;
    for (int i = 1; i <= r; i++) {
        for (int j = 1; j <= c; j++) {
            cin >> map[i][j];
            if (map[i][j] != 0 && map[i][j] != 5) {
                heater.push_back(make_pair(make_pair(i, j), map[i][j]));
            }
            else if (map[i][j] == 5) {
                searchPos.push_back(make_pair(i, j));
            }
            map[i][j] = 0;
        }
    }
    cin >> w;
    for (int i = 0; i < w; i++) {
        int a, b, c; cin >> a >> b >> c;
        wall.push_back(make_pair(make_pair(a, b), c));
    }
}
 
void settingWall() {
    for (int i = 0; i < w; i++) {
        int x = wall[i].first.first;
        int y = wall[i].first.second;
        int t = wall[i].second;
        
        if (t == 0) {
            wallMap[x][y][3] = true;
            wallMap[x - 1][y][2] = true;
        }
        else {
            wallMap[x][y][0] = true;
            wallMap[x][y + 1][1] = true;
        }
    }
}
 
bool check() {
    for (int i = 0; i < searchPos.size(); i++) {
        int x = searchPos[i].first;
        int y = searchPos[i].second;
        if (map[x][y] < k) return false;
    }
    return true;
}
 
int changeMydir(int d) {
    switch (d) {
    case 1:
        return 0;
    case 2:
        return 1;
    case 3:
        return 3;
    case 4:
        return 2;
    }
}
 
void copyMap(int A[][MAX], int B[][MAX]) {
    for (int i = 1; i <= r; i++) {
        for (int j = 1; j <= c; j++) {
            A[i][j] = B[i][j];
        }
    }
}
 
bool checkWall(int x, int y, int nx, int ny, int d, int dir) {
    if (dir == 1) {
        if (wallMap[x][y][d] == false) return true;
    }
    else if(dir == 0){
        if (d == 0) {
            int upx = x - 1;
            int upy = y;
            if (wallMap[x][y][3] == false && wallMap[upx][upy][0] == false) return true;
        }
        else if (d == 1) {
            int upx = x - 1;
            int upy = y;
            if (wallMap[x][y][3] == false && wallMap[upx][upy][1] == false) return true;
        }
        else if (d == 2) {
            int dnx = x;
            int dny = y - 1;
            if (wallMap[x][y][1] == false && wallMap[dnx][dny][2] == false) return true;
        }
        else if (d == 3) {
            int dnx = x;
            int dny = y - 1;
            if (wallMap[x][y][1] == false && wallMap[dnx][dny][3] == false) return true;
        }
    }
    else if (dir == 2) {
        if (d == 0) {
            int upx = x + 1;
            int upy = y;
            if (wallMap[x][y][2] == false && wallMap[upx][upy][0] == false) return true;
        }
        else if (d == 1) {
            int upx = x + 1;
            int upy = y;
            if (wallMap[x][y][2] == false && wallMap[upx][upy][1] == false) return true;
        }
        else if (d == 2) {
            int dnx = x;
            int dny = y + 1;
            if (wallMap[x][y][0] == false && wallMap[dnx][dny][2] == false) return true;
        }
        else if (d == 3) {
            int dnx = x;
            int dny = y + 1;
            if (wallMap[x][y][0] == false && wallMap[dnx][dny][3] == false) return true;
        }
    }
    return false;
}
 
void addMap(int A[][MAX], int B[][MAX]) {
    for (int i = 1; i <= r; i++) {
        for (int j = 1; j <= c; j++) {
            A[i][j] += B[i][j];
        }
    }
}
 
void spread(int x, int y, int d) {
    bool update[MAX][MAX] = { false, };
    d = changeMydir(d);
    x += dx[d];
    y += dy[d];
    if (x < 1 || y < 1 || x > r || y > c) return;
 
    queue<pair<pair<int, int>, int >> q;
    q.push(make_pair(make_pair(x, y), 5));
 
    while (q.empty() == 0) {
        int x = q.front().first.first;
        int y = q.front().first.second;
        int wind = q.front().second;
        q.pop();
 
        map[x][y] += wind;
        if (wind == 1) continue;
 
        for (int i = 0; i < 3; i++) {
            int nx = x + wdx[d][i];
            int ny = y + wdy[d][i];
            if (nx >= 1 && ny >= 1 && nx <= r && ny <= c) {
                if (update[nx][ny] == false && checkWall(x, y, nx, ny, d, i) == true) {
                    update[nx][ny] = true;
                    q.push(make_pair(make_pair(nx, ny), wind - 1));
                }
            }
        }
    }
}
 
void spreadWind() {
    for (int i = 0; i < heater.size(); i++) {
        int x = heater[i].first.first;
        int y = heater[i].first.second;
        int d = heater[i].second;
        spread(x, y, d);
    }
}
 
void controlTemperature() {
    int tempMap[MAX][MAX] = { 0, };
    for (int x = 1; x <= r; x++) {
        for (int y = 1; y <= c; y++) {
            for (int i = 0; i < 2; i++) {
                int dir = i == 0 ? 0 : 2;
                int nx = x + dx[dir];
                int ny = y + dy[dir];
                if (nx >= 1 && ny >= 1 && nx <= r && ny <= c) {
                    if (wallMap[x][y][dir] == false) {
                        pair<int, int> maxCoord, minCoord;
                        if (map[x][y] > map[nx][ny]) {
                            maxCoord = { x, y };
                            minCoord = { nx, ny };
                        }
                        else {
                            maxCoord = { nx, ny };
                            minCoord = { x, y };
                        }
 
                        int diff = abs(map[x][y] - map[nx][ny]);
                        diff /= 4;
                        tempMap[maxCoord.first][maxCoord.second] -= diff;
                        tempMap[minCoord.first][minCoord.second] += diff;
                    }
                }
            }
        }
    }
    addMap(map, tempMap);
}
 
void decreaseTemperature() {
    for (int i = 1; i <= c; i++) {
        if (map[1][i] > 0) map[1][i]--;
        if (map[r][i] > 0) map[r][i]--;
    }
    for (int i = 2; i < r; i++) {
        if (map[i][1] > 0) map[i][1]--;
        if (map[i][c] > 0) map[i][c]--;
    }
 
}
 
void solution() {
    settingWall();
    int chocolate = 0;
    while (1) {
        if (chocolate > 100) {
            break;
        }
        spreadWind();
        controlTemperature();
        decreaseTemperature();
        chocolate++;
 
        if (check() == true) {
            break;
        }
    }
    cout << chocolate << endl;
}
 
void solve() {
    input();
    solution();
}
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
 
    //freopen("Input.txt", "r", stdin);
    solve();
 
    return 0;
}
Colored by Color Scripter

cs