TJ’s Page

[BaekJoon] 16236 - 아기 상어

2021-10-03T00:00:00+00:00

문제

안녕하세요.
백준에서 삼성 SW 역량 테스트 기출 문제집에 게시된 16236번 아기 상어 문제 풀이를 소개하겠습니다.

이 문제는 아기 상어가 N x N 크기의 공간에서 자신보다 작은 물고기를 잡아 먹으면서 성장을 하는 문제 입니다.

상어의 이동 예시, 총 이동 시간은 14

상어가 최단거리의 물고기의 위치를 탐색하는 것이 이 문제의 포인트 입니다. 물고기 위치를 탐색하기 위해 DFS가 아닌 BFS를 활용해야 합니다. DFS보다 BFS의 난이도가 좀 더 높은 편입니다. 그 이유는 한 방향의 길을 계속 이어서 탐색하는 것이 아니고, 매번 다른 방향에서의 이동 거리와 조건을 체크해줘야 하기 때문입니다. 자세한 내용은 아래에서 확인하도록 하겠습니다.

주어진 정보

상어의 처음 크기는 2
자신의 크기 만큼의 물고기를 먹으면 상어의 크기는 +1
물고기의 크기는 최대 6
한 칸을 이동할 때 마다 1초가 지나고, 물고기를 잡아 먹는 시간은 0초
상어는 자신보다 작은 물고기만 먹을 수 있고, 같은 크기의 물고기는 지나가는 것만 가능
더 이상 먹을 수 있는 물고기가 없으면 종료

해결 방향

먼저 문제에서 요구하는 출력은 상어의 이동 시간(이동 거리)이기 때문에, BFS를 진행 할 때 마다 이동 거리를 return 하도록 합니다. 이렇게 물고기를 먹을 때 마다 BFS 를 진행하고, 물고기를 더 이상 먹을 수 없다면 지금 까지 이동한 시간을 출력하면 됩니다.

BFS의 순서는 다음과 같습니다.

먹을 수 있는 물고기가 없으면 종료. (남은 물고기의 수가 0)
현재 상어 위치를 비어있는 큐에 넣음
BFS 탐색
1. 큐가 비어 있으면 탐색 종료
2. 큐에서 맨 앞을 꺼내서 먹을 수 있는 물고기면
  1. 최단 거리 체크
  2. 위치 우선 순위 체크 (제일 위, 제일 왼쪽 우선 순위)
  3. 먹은 물고기 위치 갱신 후, 다시 큐에서 꺼내는 단계로 이동
3. 현재 위치에서 +1 칸 이동 시도 ( 동,서,남,북 네 방향 )
  1. 영역 바깥, 중복 방문, 물고기 크기 체크
  2. 이동 가능한 칸을 큐의 맨 뒤에 삽입
최단 거리의 물고기를 먹고 상어의 위치 갱신

전체 코드와 주석이 위의 내용처럼 아래에 작성되어 있습니다.

풀이

풀이 코드

#include <iostream>
#include <vector>

using namespace std;


int N;										// 공간 크기
int sz_shark, cnt_fish, cnt_eat;			// 상어 크기, 총 물고기 수, 먹은 수
int dd[][4] = { {-1,0,1,0,},{0,1,0,-1} };	// 방향 우선순위 불가능

vector< vector <int> > arr;		// 공간
pair<int, int> pos_shark;		// 상어가 있는 좌표

// 상어가 이동 가능한 영역인지 체크
bool check_way(int r, int c) {
	if (r < 0 || r >= N) return false;
	if (c < 0 || c >= N) return false;
	return true;
}

// 상어가 물고기를 먹고 위치, 크기 갱신
void eat_fish(pair<int, int> fish) {

	arr[fish.first][fish.second] = 9;
	arr[pos_shark.first][pos_shark.second] = 0;

	pos_shark = fish;

	cnt_fish--;
	cnt_eat++;
	if (cnt_eat == sz_shark) {
		cnt_eat = 0;
		sz_shark++;
	}
}

// BFS를 이용해 다음에 먹을 물고기를 찾아 이동 거리를 리턴
int find_target() {
	vector< vector<int> > arr_visited = vector< vector<int> >(N, vector<int>(N, -1));	// BFS 탐색을 위한 방문 지도, 각 칸에는 해당 좌표까지의 이동 거리 값 계산 
	vector< pair<int, int> > Q;	// BFS 탐색을 위한 큐
	
	Q.push_back(pos_shark);		// 큐에 처음 시작 위치를 상어 위치로 넣음
	arr_visited[pos_shark.first][pos_shark.second] = 0;	// 처음 시작 위치는 이동거리 0

	int dist_min = N * N;
	int r_min, c_min;
	r_min = c_min = N;
	// 탐색 초기화 끝


	while (true) {
		// 큐가 비어 있으면 종료
		if (Q.size() == 0) break;

		// 맨 앞에서 다음 탐색 위치 꺼냄
		pair<int, int> pos = Q.front();
		Q.erase(Q.begin());


		// 다음 이동하는 위치가 상어보다 작은 물고기가 있는 위치인 경우, (물고기의 크기는 6보다 크지 않음)
		if (arr[pos.first][pos.second] < sz_shark && 
			arr[pos.first][pos.second] != 0 && arr[pos.first][pos.second] != 9 &&
			arr_visited[pos.first][pos.second] <= dist_min) {
			
			// 더 짧은 거리의 먹을 수 있는 물고기가 있다면, 최소 이동 거리 갱신, 아마 BFS 특성상 자동으로 만족?
			if (arr_visited[pos.first][pos.second] < dist_min) 
				dist_min = arr_visited[pos.first][pos.second];

			// 우선순위에 따른 물고기 위치 선택
			if (pos.first <= r_min) {
				r_min = pos.first;

				if (pos.second < c_min) {
					c_min = pos.second;
				}
			}
			continue;
		}

		// 현재 위치에서 네 방향으로 이동 가능한 위치 탐색
		for (int way = 0; way < 4; way++) {
			int r_ = pos.first + dd[0][way];
			int c_ = pos.second+ dd[1][way];
			int dist_next = arr_visited[pos.first][pos.second] + 1;	// 다음 이동 거리는 현재에서 +1 만큼


			if (check_way(r_, c_) == false)  continue;	// 공간 바깥 체크
			if (arr_visited[r_][c_] != -1 && arr_visited[r_][c_] <= dist_next) continue;	// 중복 방문 체크
			if (arr[r_][c_] > sz_shark) continue;		// 상어보다 큰 물고기 체크

			// 이동 조건에 만족하면 큐에 삽입
			Q.push_back(pair<int, int>(r_, c_));
			arr_visited[r_][c_] = dist_next;
		}
	}

	// 한번도 이동을 못했다면 이동거리는 0
	if (dist_min == N * N) 
		return 0;
	else
		eat_fish(pair<int, int>(r_min, c_min));

	return dist_min;
}

int solution() {

	int t = 0;

	// 물고기를 먹을 수 없을 때 까지 반복
	while (cnt_fish > 0) {
		int dist = find_target();	// BFS를 이용해 먹이를 찾고 이동 거리를 리턴
		if (dist == 0)	break;		// 이동 하지 못하면 종료
		t += dist;					// 이동 거리만큼 시간을 늘림
	}

	return t;
}

int main() {
	cin >> N; 

	arr = vector< vector <int> >(N, vector<int> (N, 0));
	cnt_eat = cnt_fish = 0;
	sz_shark = 2;

	for (int r = 0; r < N; r++) {
		for (int c = 0; c < N; c++) {
			cin >> arr[r][c];
			if (arr[r][c] > 0 && arr[r][c] < 9)	cnt_fish++;
			if (arr[r][c] == 9) pos_shark = pair<int, int>(r, c);
		}
	}

	cout << solution() << endl;

	return 0;
}

다른 테스트 케이스

혹시 예제 케이스는 통과 했는데, 답안 코드 제출시 틀린다면 아래의 케이스들을 테스트 해보길 바랍니다.

10
1 4 6 1 4 5 4 0 3
0 0 9 0 0 6 0 0 0
3 2 4 6 3 0 2 1 6
0 0 0 1 0 0 1 0 6
0 0 6 0 4 1 4 0 1
3 0 1 6 0 3 1 0 4
5 0 2 0 0 5 1 0 1
4 0 4 1 1 2 5 6 6
0 5 6 5 1 0 1 2 0
6 3 0 6 0 1 1 6 0
answer:103

10
6 3 0 5 5 4 4 3 0
4 0 4 0 1 0 1 0 6
3 4 1 0 0 3 1 1 0
5 1 0 1 6 1 3 5 1
3 0 1 1 0 4 0 1 0
5 1 5 6 0 3 4 0 9
5 5 3 0 0 4 5 0 3
5 0 3 3 2 0 0 3 2
6 5 0 0 4 1 1 6 3
3 1 3 0 1 0 0 0 5
answer:105

10
3 2 0 0 1 2 0 4 0
0 3 1 0 0 3 0 6 1
3 0 5 0 5 4 4 2 5
0 0 3 0 6 1 5 4 2
0 2 0 2 0 3 0 0 6
1 1 1 1 1 1 1 0 0
0 2 1 9 6 0 0 4 3
6 1 0 6 0 5 0 1 0
5 4 0 1 2 1 3 5 0
1 6 6 1 4 3 0 1 1
answer:102

10
0 2 0 1 1 1 0 1 0
4 4 0 4 0 0 0 3 0
3 5 0 1 0 2 6 0 0
0 5 5 3 1 3 1 3 4
0 5 1 4 2 4 0 5 0
0 5 0 2 1 1 2 1 0
0 5 2 4 0 9 1 6 2
1 2 0 3 0 3 2 4 6
0 1 0 4 0 0 5 0 1
4 1 1 6 6 1 6 0 0
answer:87

해설

solution() : 먹을 수 있는 물고기 수 만큼 while loop를 수행
find_target() : BFS 를 수행하는 함수, 이동 거리를 리턴
eat_fish() : 먹을 수 있는 물고기가 있을 때, 상어의 위치를 바꾸고 먹은 횟수와 남은 물고기 수를 갱신

앗 이걸 생각 못했네?

문제에는 명시되어 있지 않지만, 상어 크기 성장 시 먹은 횟수는 0으로 초기화 해야 합니다.
물고기는 최대 크기가 6이기 때문에 상어는 7까지만 커져도 됩니다.
- 상어가 8 이상으로 커지는 경우, 초기 큐에서 상어의 위치를 꺼내다가 빈곳이 아니므로 물고기를 먹은것으로 잘못 처리 할 수 있습니다.
- 제 풀이에는 상어의 크기에 대한 제한이 없기 때문에 물고기를 먹는 조건에 9는 못먹게 해놓았습니다.
체크해야할 조건들이 많기 때문에 조건 처리 실수를 조심해야 합니다.
- 중복 방문 체크시, 현재 이동 거리와 같거나 작으면 가지 않는다. 이동 거리가 같은데 다시 큐에 넣는 것은 계산 및 시간 낭비를 유발 합니다.
- 방향 우선 순위 비교를 위한 비교연산자 체크 (이상/초과, 이하/미만)

다른 풀이

16235번 나무재테크 1차 풀이

기타 다른 문제 풀이 코드 (github)

Recurrent Residual Unet 모델 리뷰

2021-09-29T00:00:00+00:00

소개

안녕하세요. 이 포스트에서는 Residual connection과 Recurrent network의 구조를 포함하고 있는 Recurrent Residual Unet (R2Unet) 대해서 소개하고자 합니다.

먼저, Residual connection 구조는 인공신경망의 구조가 깊어질수록 생기는 Vanishing Gradient 문제와 같이 Network 앞에서의 계산되는 데이터의 특징들이 뒤로갈수록 점점 손실 되는 문제를 개선하는데 큰 도움이 된다고 생각합니다.

Recurrent network 구조는 일반적으로 시계열 데이터나, 순차 데이터들을 입력으로하는 Network에서 사용되고 있습니다. 그런데 R2Unet에서는 Segmentation을 목표로 하기 때문에 순서가 있는 데이터를 입력으로 하지 않습니다. 그렇기 때문에 아래와 같이 표현되는 Network 구조에서 Recurrent 계산은 해당 Layer의 Output이 Input으로 다시 들어가는 구조를 가집니다.

그런데 순차적인 데이터의 입력이 아닌 Network 에서 Recurrent 구조가 어떤 장점이 있을까? 학습 파라미터인 weight들의 수를 늘리지 않고 모델의 성능을 올릴 수 있을까? 라는 생각이 들었습니다.

하나의 Layer에서 출력된 Feature를 다시 입력으로 하는것이 꼭 음식을 되새김질 하는 것과 같은 느낌이었습니다. 맛있는 음식을 입에서 계속 음미 하듯이 모델에서 인식하고자 하는 데이터의 특징들을 강조하는 효과가 있을것이라는 기대가 될 것이라 생각합니다. 그래서 Recurrent 구조를 포함하는 CNN을 구현하고 각 레이어에서 Feature Map이 어떻게 나타나는지 Tensorboard를 통해서 확인을 해보겠습니다.

import tensorflow as tf


def main():
    # 학습 코드 삽입 예정

계속 업데이트 예정

[BaekJoon] 16235 - 나무재테크

2021-09-25T00:00:00+00:00

문제

안녕하세요.
백준에서 삼성 SW 역량 테스트 기출 문제집에 게시된 16235번 나무재테크 문제 풀이를 소개하겠습니다.

이번 문제는 2차원 배열 내에서 여러 나무를 심고, 영양분을 공급하며, 나무가 다시 번식하고 죽는것에 따라 남은 나무의 수가 몇개인지를 물어보고 있습니다.

많은 분들이 아시겠지만, 이렇게 특정 작업을 일정 횟수만큼 진행 시키는 문제들을 시뮬레이션 문제라고 부릅니다.

따라서 인덱스 체크와 조건 처리만 실수 없이 잘 해준다면 풀 수 있는 문제입니다.

풀이 코드는 사람이 쉽게 이해 할 수 있는 코드를 지향하여 작성하였습니다. 따라서 최적의 성능을 가지는 코드가 아닐 수 있습니다.

주어진 정보

가장 처음에 양분은 모든 칸에 5만큼 들어있다.
봄에 나이만큼 양분을먹고, 나이가 1 증가.
- 칸에 여러 나무가 있다면, 나이가 어린순으로 양분 섭취.
여름에는 양분을 먹지 못한 나무가 사망 후, (나이/2) 만큼 양분으로 변환.
가을에는 나무의 나이가 5의 배수라면, 인접한 8개의 칸에 나이가 1인 나무 번식.
겨울에는 처음 주어진 배열 A 만큼 양분 추가.
N : 땅의 크기
M : 처음 주어지는 나무의 갯수
K : 결과를 확인하는 년 수, 반복 실행하는 횟수

해결 방향

계산이 꼬이지 않게(실수를 방지하기 위해), 문제에서 주어진 계절마다의 작업들을 함수로 만들어 K 년 수 만큼 반복을 진행합니다.

풀이

풀이 코드

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

vector < vector < vector <int> > > arr_tree;	// 각 위치에 있는 나무들의 나이 정보
vector < vector < vector <int> > > arr_dead;	// 각 위치에 있는 죽은 나무들의 나이 정보
vector < vector < int > > arr_n;				// 각 위치에 있는 영양분의 정보
vector < vector < int > > A;					// 각 위치에 로봇이 공급할 영양분의 정보

int N, M, K;	//N : 땅의 크기, M : 초기 나무 갯수, K : 시뮬레이션 횟수
int dd[][8] = {
	{-1,-1,0,1,1,1,0,-1},
	{0,1,1,1,0,-1,-1,-1}
};


// 땅 경계 체크
bool check_boundary(int r, int c) {
	if (r < 0 || r >= N) return false;
	if (c < 0 || c >= N) return false;

	return true;
}

// 인접한 여덟 방향에 나무 추가
void add_new_tree(int r, int c) {
	for (int way = 0; way < 8; way++){
		int r_ = r + dd[0][way];
		int c_ = c + dd[1][way];

		// 경계를 벗어나면 패스
		if (check_boundary(r_, c_) == false) continue;

		// 맨 앞에 나이가 1인 나무 추가
		arr_tree[r_][c_].insert(arr_tree[r_][c_].begin(), 1);
	}
}

//나무를 나이 순으로 정렬
void sorting_trees() {
	for (int r = 0; r < N; r++) {
		for (int c = 0; c < N; c++) {
			if (arr_tree[r][c].size() > 1) {
				sort(arr_tree[r][c].begin(), arr_tree[r][c].end());
			}
		}
	}
}

// 모든 나무들이 영양분을 섭취하고 나이 1 증가
void spring() {

	for (int r = 0; r < N; r++) {
		for (int c = 0; c < N; c++) {

			// 해당 위치에 나무의 수 만큼 영양분 섭취
			for (int i = 0; i < arr_tree[r][c].size(); i++) {

				// 영양분이 충분하지 않다면 해당 나무 위치부터 끝까지 사망 처리 (나이순 정렬 된 조건)
				if (arr_tree[r][c][i] > arr_n[r][c]) {
					arr_dead[r][c] = vector<int>(arr_tree[r][c].begin() + i, arr_tree[r][c].end());	// 죽어야 할 나무들의 정보 복사
					arr_tree[r][c].erase(arr_tree[r][c].begin() + i, arr_tree[r][c].end());			// 땅에서 나무들 제거
					break;
				}

				// 영양분 공급
				arr_n[r][c] -= arr_tree[r][c][i];
				arr_tree[r][c][i]++;	// 입력으로 주어지는 나무의 나이는 10이하지만, 실행 중의 나이제한의 언급은 X
			}
		}
	}

}

// 양분 섭취를 못한 나무들이 (나이/2)만큼 양분으로 변환 됨
void summer() {
	for (int r = 0; r < N; r++) {
		for (int c = 0; c < N; c++) {

			// 모든 나무들에 대해 처리, 없으면 다음 위치 진행
			while(arr_dead[r][c].size() > 0) {
				arr_n[r][c] += int(arr_dead[r][c].front() / 2);	// 맨 앞의 나무부터 계산
				arr_dead[r][c].erase(arr_dead[r][c].begin());	// 계산된 맨 앞 나무 제거
			}
		}
	}
}

// 땅에 위치한 나무의 나이가 5의 배수라면, 인접한 8개의 칸에 나이가 1인 나무 번식.
void fall() {
	for (int r = 0; r < N; r++) {
		for (int c = 0; c < N; c++) {
			
			// 살아있는 모든 나무들에 대해 5의 배수 체크
			for (auto age : arr_tree[r][c]) {
				if (age % 5 == 0) {
					add_new_tree(r,c);
				}
			}
		}
	}
}

// 로봇이 땅에 양분 추가
void winter() {
	for (int r = 0; r < N; r++) {
		for (int c = 0; c < N; c++) {
			arr_n[r][c] += A[r][c];
		}
	}
}

// 모든 땅의 나무의 수를 계산하여 반환
int get_total_tree() {
	int total = 0;

	for (int r = 0; r < N; r++) {
		for (int c = 0; c < N; c++) {
			// 모든 땅의 나무의 수를 계산
			total += arr_tree[r][c].size();
		}
	}

	return total;
}

int solution() {

	while (K > 0) {
		// 해당 년도의 사망 할 나무를 저장할 배열 초기화
		arr_dead = vector < vector < vector <int> > >(N, vector < vector <int> >(N, vector<int>()));

		// 봄
		//1 ≤ N ≤ 10 이기 때문에 충분히 전체 탐색 할만함.
		spring();
		summer();
		fall();
		winter();

		sorting_trees();
		K--; // 실행 횟수 감소
	}

	return get_total_tree();
}

int main() {
	cin >> N >> M >> K;

	arr_tree = vector < vector < vector <int> > >(N, vector < vector <int> > (N, vector<int>()));
	arr_n = vector < vector <int> >(N, vector<int>(N, 5));	// 모든 땅에는 처음에 5만큼의 양분이 존재
	A = vector < vector <int> >(N, vector<int>(N, 0));

	for (int r = 0; r < N; r++) {
		for (int c = 0; c < N; c++) {
			cin >> A[r][c];
		}
	}

	for (int m = 0; m < M; m++) {
		int r, c, age;
		cin >> r >> c >> age;
		arr_tree[r-1][c-1].push_back(age);	// 항상 나이 순으로 주어질까?
	}
	sorting_trees(); // 입력 받은 나무들을 나이 순으로 정렬

	cout << solution() << endl;

	return 0;
}

해설

solution() : K 횟수 만큼 각 계절마다 작업을 진행하고, 총 나무의 수를 반환
check_boundary() : 나무를 번식시킬때 필요한 인덱스 체크
add_new_tree() : 나무를 각 여덟 방향으로 번식 시킴
sorting_trees() : 같은 땅에 존재하는 나무들을 나이 순으로 정렬
spring() : 모든 나무들이 영양분을 섭취하고 나이 1 증가시킴
summer() : 양분 섭취를 못한 나무들이 (나이/2)만큼 양분으로 변환 됨
fall() : 땅에 위치한 나무의 나이가 5의 배수라면, 인접한 8개의 칸에 나이가 1인 나무 번식
winter() : 로봇이 땅에 양분 추가

앗 이걸 생각 못했네?

이런 문제에서 쉽게 실수 할 수 있는 부분은 같은 땅에 존재 하는 나무들의 나이 순서에 따른 정렬 문제라고 생각합니다.
- 같은 (r,c) 위치에서 나무들의 나이값들을 1차원 배열로 저장하면서, 새로운 나무들을 추가할 때 마다 배열에 앞에 추가하는 것과 뒤로 추가하는 것에 따라 처리 방법이 달라질 수 있습니다.
  (이 문제 풀이에서는 습관적으로 sort함수가 사용되었지만, 어린 나무를 매번 맨 앞에 추가함으로써 사실상 sort가 필요 없을 수 있습니다…)
초기에 주어지는 나무 위치 값이 1 ~ N 임을 주의히세요.
N x N 만큼의 2차원 배열을 모두 순회하는 것이 아닌 나무가 존재하는 땅의 인덱스만 저장하는 배열을 따로 만들어 시간을 감소시킬 수도 있습니다. (N의 크기가 충분히 커진다면,)

다른 풀이

16235번 나무재테크 1차 풀이

기타 다른 문제 풀이 코드 (github)

[BaekJoon] 16234 - 인구이동

2021-09-22T00:00:00+00:00

문제

안녕하세요.
백준에서 삼성 SW 역량 테스트 기출 문제집에 게시된 16234번 톱니바퀴 문제 풀이를 소개하겠습니다.

이번 문제는 2차원 배열 내에서 변화가 몇 번 만큼이나 발생하는지 확인하는 문제 입니다.
세부적으로는 배열에서 특정 구역 내에 있는 숫자들의 평균을 구해야 합니다.
문제에서 주어진 조건에 맞추어 BFS(넓이 우선 탐색)를 진행하여 구역을 탐색하면 되겠습니다.

풀이 코드는 사람이 쉽게 이해 할 수 있는 코드를 지향하여 작성하였습니다. 따라서 최적의 성능을 가지는 코드가 아닐 수 있습니다.

주어진 정보

N : 2차원 배열의 가로, 세로 길이
L : 연합이 가능한 조건 중 최소 차이
R : 연합이 가능한 조건 중 최대 차이
배열의 요소 : 해당 칸(나라)의 인구

해결 방향

먼저 2차원 배열의 모든 요소를 순회 하되, 바로 인접한 나라들의 값을 변경하려고 하면 해결할 수가 없습니다.
문제 조건에 맞는 연합 리스트를 만들고 하나의 연합의 총 인구를 계산후 배열의 값을 갱신하여 해결할 수 있습니다.

풀이

풀이 코드

#include <iostream>
#include <vector>

using namespace std;

int dd[][4] = { {-1,0,1,0},{0,1,0,-1} };	// 확인 방향에 따른 인덱스 변화 값

vector < vector <int> > arr;	// 땅 배열
int N,L,R; // N : 땅 크기, L : 인구 차이 최저 기준, R : 인구 차이 최대 기준


bool check_boundary(int c, int r) {
	if (c < 0 || c >= N) return false;
	if (r < 0 || r >= N) return false;
	return true;
}

vector<vector<pair<int, int>>> get_unions() {
	vector < vector <bool> > arr_visited = vector< vector <bool> >(N, vector <bool>(N, 0));	// 국가 방문 기록 배열
	vector<vector<pair<int, int>>> unions = vector<vector<pair<int, int>>>();				// 연합으로 구성된 국가들 리스트
		
	vector<pair<int, int>> union_ = vector<pair<int, int>>();	// 연합 임시 저장용
	vector<pair<int, int>> queue = vector<pair<int, int>>();	// 탐색 임시 저장용

	// 모든 땅에 대해 연합 국가들을 탐색
	for (int c = 0; c < N; c++) {
		for (int r = 0; r < N; r++) {
			queue.clear();
			union_.clear();

			// 탐색 시작할 위치에 이미 방문한 기록이 있으면 패스
			if(arr_visited[c][r] == 1) 
				continue;

			// 탐색 큐에 추가
			queue.push_back(pair<int, int>(c, r));
			arr_visited[c][r] = 1;

			// BFS
			while (true) {
				if (queue.size() == 0) break;	// 탐색 하고자 하는 큐가 비어있다면 종료

				pair<int, int> pos = queue.front();	// 탐색된 현재 위치
				queue.erase(queue.begin());			// 맨 앞의 요소 제거
				union_.push_back(pos);				// 조건에 만족하는 국가 추가

				// 현재 위치 기준으로 네 방향 탐색.
				for (int way = 0; way < 4; way++) {
					int c_ = pos.first + dd[0][way];
					int r_ = pos.second + dd[1][way];

					// 배열 밖을 벗어나는 경우, 이미 방문한 경우, 인구 차이 조건 맞지 않은 경우 패스
					if (check_boundary(c_, r_) == false) continue;
					if (arr_visited[c_][r_] == 1) continue;

					int diff_pop = abs(arr[pos.first][pos.second] - arr[c_][r_]); // 인구 차이 계산
					if (diff_pop < L || diff_pop > R) continue;

					// 모든 조건에 만족하는 경우 해당 국가에 방문
					queue.push_back(pair<int, int>(c_, r_));
					arr_visited[c_][r_] = 1;
				}
			}

			// 국경개방 국가가 두 군데 이상이라면, 연합 리스트에 추가
			if (union_.size() > 1) unions.push_back(union_);
		}
	}

	return unions;
}


void move_population(vector<vector<pair<int, int>>> unions) {

	// 개방된 연합들에 대해 반복
	for (auto union_ : unions) {
		int sum = 0;
		int total = union_.size();

		// 연합들의 총 인구수 계산
		for (auto pos : union_) {
			sum += arr[pos.first][pos.second];
		}

		// 이동된 인구 계산
		int pop = int(sum / total);

		// 연합들의 인구수 갱신
		for (auto pos : union_) {
			arr[pos.first][pos.second] = pop;
		}
	}
}

int solution() {
	int day = 0;

	while (true) {
		vector<vector<pair<int, int>>> unions = get_unions();

		if (unions.size() > 0) {
			day++;
			move_population(unions);
		}
		else {
			break;
		}
	}

	return day;
}

int main() {
	cin >> N >> L >> R;

	arr = vector< vector <int> >(N, vector <int>(N, 0));

	for (int i = 0; i < N; i++) {
		for (int j = 0; j < N; j++) {
			cin >> arr[i][j];
		}
	}
	// 초기화 끝


	cout << solution() << endl;

	return 0;
}

해설

solution() : 연합이 반복적으로 구성될 때, day를 증가 시키며 인구 이동
get_unions() : 조건에 해당하는 연합들의 리스트를 반환
- vector < vector > arr_visited : 중복 탐색 방지를 위한 방문 맵
- vector<vector<pair<int, int»> unions : 같은 연합에 포함되는 나라들의 인덱스 정보를 저장
- BFS : 배열의 모든 인덱스를 시작 위치로 하여 인구 차이가 조건에 맞으면 큐에 추가하면서 탐색을 진행. 더 이상 방문할 나라가 없다면 방문했던 나라들을 연합으로 묶어 저장.
move_population() : 저장된 각 연합들 내에서 인구 이동을 시킴

앗 이걸 생각 못했네?

BFS 코드 작성을 많이 해본 분들에게는 당연한 이야기 일수도 있지만…
- BFS 진행 중에 발생하는 대부분의 에러는 배열의 인덱스 초과 였던 것 같다.
- 인덱스 체크
  , 중복 방문, 탐색 중단 조건. 이 세가지만 주의 하면 사소한 실수는 줄일 수 있다.
‘이상’, ‘이하’라는 조건에 맞게 ‘<=’, ‘>=’ 비교연산자 실수에 조심해야 한다.

다른 풀이

16234번 인구이동 1차 풀이

기타 다른 문제 풀이 코드 (github)

[BaekJoon] 14891 - 톱니바퀴

2021-09-21T00:00:00+00:00

문제

안녕하세요.
백준에서 삼성 SW 역량 테스트 기출 문제집에 게시된 14891번 톱니바퀴 문제 풀이를 소개하겠습니다.

이번 문제는 톱니 바퀴를 일정 횟수 회전시켜 결과를 확인하는 문제입니다.
톱니 바퀴가 맞닿는 부분의 극이 다르면 맞닿는 톱니를 회전시키는게 가능하고, 극이 같다면 불가능 합니다. 먼저 문제를 정리하면 아래와 같습니다.

주어진 정보

길이가 8인 정수 : 톱니 바퀴의 극
극 값 : 0은 N, 1은 S
K : 명령의 수
명령 : 톱니번호(n), 회전 방향(1 or -1)

해결 방향

복잡한 수를 계산하거나 탐색 알고리즘을 필요로 하지 않습니다. 단순히 조건에 맞추어 1차원 배열을 회전만 하면 되는 문제 입니다.

명령에서 선택된 톱니 바퀴를 회전 시키는 함수를 하나 작성합니다. 그리고 재귀적으로 옆의 다른 톱니 바퀴들을 작성한 함수로 회전시키면, 모든 톱니 바퀴들을 회전 시킬 수 있습니다.

주의할 점은 옆에 톱니 바퀴의 존재 여부와 톱니 바퀴의 회전 여부 입니다.

톱니 바퀴 예시

풀이

풀이 코드

#include <iostream>
#include <string>
#include <vector>

using namespace std;
/*
 * N극은 0, S극은 1
 * K : 회전 명령 갯수
 * 명령 : 톱니번호 , 방향 (1 : 시계, -1 : 반시계)
*/

vector< string > arr;
vector< vector<int> > cmd;
int K;


// 각 톱니의 12시 방향 체크
int get_score() {
	int score = 0;
	
	if (arr[1][0] == '1')	score += 1;
	if (arr[2][0] == '1')	score += 2;
	if (arr[3][0] == '1')	score += 4;
	if (arr[4][0] == '1')	score += 8;

	return score;
}

// 회전 후, 양 옆의 톱니 바퀴에 대해 재귀 진행
void rotate(int n, int wise, int prev_n) {
	bool left, right;
	left = right = true;

	if (n == 1 || n - 1 == prev_n || arr[n - 1][2] == arr[n][6]) left = false;
	if (n == 4 || n + 1 == prev_n || arr[n + 1][6] == arr[n][2]) right = false;

	// 시계 방향 회전
	if (wise == 1) {
		string tmp = arr[n].substr(7, 1);
		arr[n] = tmp + arr[n].substr(0, 7);
	}
	// 시계 반대 방향 회전
	else {
		string tmp = arr[n].substr(0, 1);
		arr[n] = arr[n].substr(1, 7) + tmp;
	}
	
	// 다음 톱니 바퀴 회전 방향 반전
	if (wise == 1) wise = -1;
	else wise = 1;
	 
	// 다음 톱니 바퀴 회전
	if (left == true) {
		rotate(n - 1, wise, n);
	}
	if (right == true) {
		rotate(n + 1, wise, n);
	}
}

int solution() {
	
	// 명령 수 만큼 회전 진행
	for (int k = 0; k < K; k++) {
		int n = cmd[k][0];		// 선택된 톱니바퀴 번호
		int wise = cmd[k][1];	// 회전 방향

		rotate(n, wise, -1);		// 회전 실행
	}

	return get_score();
}

int main() {
	arr = vector<string> (5, ""); // 1~4까지 표현하기 위해 톱니바퀴 수를 5로
	
	// 톱니바퀴 초기화
	for (int i = 1; i < 5; i++) {
		string tmp_s;
		cin >> tmp_s;
		arr[i] = tmp_s;
	}

	// 명령 수 입력
	cin >> K;
	cmd = vector<vector<int>>(K, vector<int>(2, 0)); 

	// 명령 초기화
	for (int i = 0; i < K; i++) {
		cin >> cmd[i][0];	// 톱니 번호
		cin >> cmd[i][1];	// 회전 방향
	}
	
	// 시뮬레이션 진행
	cout << solution() << endl;

	return 0;
}

해설

solution() : 모든 명령에 따라 회전 실행, get_socore()를 이용한 점수 계산
rotate() : 주어진 번호와 방향에 따라 톱니바퀴 회전
- 양 옆의 회전 가능한 톱니가 있는지 체크
- 현재 톱니바퀴 회전
  - ex) 1차원 배열 : [1,2,..,7,8] -> [2,3,..,8,1] or [8,1,..,6,7]
- 회전 가능한 톱니 바퀴가 있다면 rotate() 재귀호출

앗 이걸 생각 못했네?

1차원 배열 회전을 양방향으로 좀 더 간단하게 하는 방법이 없을까?
- deque의 push, pop 활용 (1차 풀이, 아래 링크 참고)
- 문자열 계산 활용 (현재 풀이)
딱히 헷갈릴만한 부분은 없는 것 같다…

다른 풀이

14891번 톱니바퀴 1차 풀이

기타 다른 문제 풀이 코드 (github)

[BaekJoon] 14890 - 경사로

2021-09-20T00:00:00+00:00

문제

안녕하세요.
백준에서 삼성 SW 역량 테스트 기출 문제집에 게시된 14890번 경사로 문제 풀이를 소개하겠습니다.

이번 문제는 많은 문제에서 빈번하게 다루는 2차원 배열을 가지고 길을 찾는 문제입니다. 여러 갈래로 나뉜 길의 방향을 찾는 것은 아니고 주어진 길이 이동 가능한지 체크를 하는 문제 입니다. 따라서 조건 처리를 잘 하면 풀 수 있는 문제입니다.

먼저 문제를 정리하면 아래와 같습니다.

주어진 정보

N x N 배열 : 지도를 의미
배열 요소 값 : 지도 위치에 해당하는 땅 높이(층)
L : 층을 잇는 경사로의 길이

해결 방향

크게 두 단계로 나누도록 하겠습니다.
첫 번째로 가로방향의 길을 전부 확인 후, 두 번째에는 세로 방향의 길을 전부 찾습니다.

2차원 배열에서는 가로-세로의 방향이 있지만, 어느 방향의 길이든 선택하고나면 1차원 배열로 모양이 같아집니다. 이러한 점을 이용하여 하나의 함수를 작성해 모든 방향의 길을 확인할 수 있습니다.

아래는 경사로의 예시와, 2차원 배열에서 이동 가능한 길을 파란색 점선 박스로 표시한 예시 입니다.

경사로 예시

색으로 구분된 이동 가능한 길과 불가능한 길

풀이

풀이 코드

int N, L;
vector < vector<int> > map;

bool run_road(vector<int> road) {
	int i = 1;					// 위치
	int len_flat = 1;			// 지나온 평평한 길 길이
	int cur_h = road.front();	// 현재 땅 높이

	while (true) {
		if (i >= N) break;
		if (abs(cur_h - road[i]) > 1) return false;
		if (cur_h < road[i]) {
			// 올라가는 경우
			// 지나온 땅의 평평한 길이가 L보다 작으면 경사로 설치 불가
			if (len_flat < L) return false;
			cur_h = road[i];
			len_flat = 1;
			i++;
		}
		else if (cur_h > road[i]) {
			// 내려가는 경우
			len_flat = 1;
			cur_h = road[i];
			while (len_flat < L) {
				i++;
				len_flat++;

				if (i >= N) return false;
				if (cur_h != road[i]) return false;
			}
			i++;
			len_flat = 0;
		}
		else {
			// 평평한 길 지나는 경우
			len_flat++;
			i++;
		}
	}

	return true;
}

int solution() {
	int count = 0;

	for (int c = 0; c < N; c++) {
		if (run_road(map[c])) count++;
	}

	for (int r = 0; r < N; r++) {
		vector< int> tmp_road;
		for (int c = 0; c < N; c++)
			tmp_road.push_back(map[c][r]);
		if (run_road(tmp_road)) count++;
	}

	return count;
}

int main() {
	cin >> N >> L;
	map = vector < vector<int> >(N, vector<int>(N));
	
	for (int c = 0; c < N; c++) {
		for (int r = 0; r < N; r++) {
			cin >> map[c][r];
		}
	}

	cout << solution();
	return 0;
}

해설

solution() : 가로, 세로 각 방향 길들을 전부 확인
run_road() : 주어진 길을 한칸씩 이동하면서 끝에 도달할 수 있는지 확인
- 1칸 차이의 높,낮은 칸을 연결
- L 길이 만큼 공간에 경사로 설치
- 경우의 수
  1. 높은 칸 만나는 경우
    - 지나온 평지의 길이가 L 이상인 경우
  2. 낮은 칸 만나는 경우
    - 일단 설치하고 한칸씩 전진
    - L만큼 전진하지 못한다면 이동 불가능한 길
  3. 평평한 땅 경우
    - 그냥 이동

앗 이걸 생각 못했네?

경사로를 놓는 수의 제한은 없다.
경사로를 내려오고 바로 경사로가 또 이어질 수도 있다.

이스트라 쿠카 UC551UHD 스마트 TV 구매 리뷰

2021-09-18T00:00:00+00:00

소개

대기업(삼성, LG …)에서 판매되고 있는 TV들에 비해 매우 저렴하게 판매되고 있는 중소기업 TV들이 많이 주목 받고 있습니다.

어떤 제품들은 대기업 제품에 쓰있고 있는 같은 패널들이 사용되기도 합니다.
하지만 패널을 제외한 내부적인 하드웨어 차이 때문인지 소프트웨어 차이 때문인지 동일한 화질을 보여주지는 못한다는 평이 많습니다.
그럼에도 불구하고 동일 크기 대비 가격 차이가 절반정도 차이나기 때문에 가성비가 매우 좋다는 평도 많습니다.

최근에 스마트 TV 구매를 위해 여러 제품들을 찾아보았습니다. 아래와 같은 기준으로 제품들을 비교했습니다.

화면 크기 : 50 ~ 55인치
가격대 : 50 ~ 60 만원
패널 : IPS
해상도 : 4K UHD
LED : 직하형
화질 : HDR 10 이상
안드로이드 OS 지원

그 중에서 이스트라 쿠카 UC551UHD 스마트 TV 를 구매하게 되었고, 개봉, 설정 및 불량화소 체크하는 과정을 소개하도록 하겠습니다.

Note:

제품 개봉시 화면 긁힘에 주의하세요.
필름 및 비닐이 부착되어 있지 않습니다.
박스 상단의 스테이플러 쇳조각에 긁히지 않게 완전히 제거하세요
화면의 모서리의 필름같이 생긴 부분을 강제로 떼어내지 마세요.

초기 설정

박스 개봉 후 첫 전원 연결입니다.
제품명인 쿠카 로고가 2~3초 정도 디스플레이 됩니다.
첫 화면이 켜지고 화면이 꽤 밝다는 느낌이 들었습니다.

쿠카로고가 나온 후, 화면에 보이지는 않지만 리모콘 세팅을 하게됩니다.
리모콘 세팅 후, 인터넷 연결을 진행합니다.
먼저 WIFI를 연결하는 화면이 보이지만, 아래로 내리다보면 이더넷 연결이 있습니다.
인터넷을 유선연결 하시는 분들은 이더넷 연결을 하시면 됩니다.

지상파 또는 케이블 방송 선택 후,
채널 검색을 하게 됩니다.
이 과정시 몇 분 정도의 시간이 소요됩니다.

방송이 나오는것까지 확인하고 세팅을 마쳤습니다.

케이블 방송 화질

케이블 방송은 HD 급으로 화면이 송출 되고 있습니다.
작은 해상도의 방송 콘텐츠를 강제적으로 4k로 늘리기 때문에 계단처럼 보이는 현상이 생길 수 있습니다.
하지만 스마트 TV 에서 어느정도 보정을 해주는 기능이 있기 때문에 보기에 큰 불편함은 없는것 같습니다.
그래도 작은 환면으로 볼때보다는 확실히 뿌연느낌이나 뭉게진 느낌이 존재합니다.

< 예능 프로그램의 한 장면 >

< 영화 채널의 한 장면 >

두 화면 모두 카메라에는 선명하게 잘 찍혔지만, 체감상으로는 핸드폰으로 유튜브를 볼때 720p 화질로 보는 느낌이 들면서도 좀 더 부드러운 느낌이 들었습니다.

4k 콘텐츠 화질

4k UHD TV의 제 기능을 활용하려면 4k 콘텐츠를 찾는 수 밖에 없습니다.
저는 넷플릭스와 유튜브에서 4K 콘텐츠를 찾아서 화질을 체감해봤습니다.

Netflix

넷플릭스에서는 오징어 게임을 공개했습니다. 최근 작품인 만큼 4K HDR를 지원하는 콘텐츠입니다.
작품 내에서 알록달록한 컬러를 표현하는 장면이 나와서 그 장면을 감상 해봤습니다.

얼굴이 너무 선명하게 보여서 깜작놀랐습니다. ;; 주름 하나하나가 너무 선명했습니다.

카메라에는 잘 안담겼지만 저 많은 작은 얼굴들이 꽤 선명하게 잘 보였습니다.
대체적으로 색표현을 시원하게 해주는 느낌이 들었습니다. 이러한 색 온도감은 TV 설정에서 바꾸어 줄 수 있지만 저는 기본 설정으로 사용하였습니다.

밝기 표현은 눈으로 봤을 때와 카메라에 담긴 것과 큰 차이는 없었던것 같습니다.

Youtube

유튜브 콘텐츠 게시 예정

https://raw.githubusercontent.com/TJ-kor/TJ-KOR.github.io/main/_posts/2021-09-18-estra-UC551UHD/video_4k60f.MOV

GitHub blog 시작하기

2021-09-14T00:00:00+00:00

시작하기

안녕하세요. 이 포스트에서는 Github와 Jekyll을 이용한 github.io 작성을 소개하겠습니다. 다양한 블로그 플랫폼들이 있지만, 자유로운 사용자화와 Git을 이용한 관리의 장점이 있다고 생각하여 Github를 선택하게 되었습니다.

진입 장벽이 다소 있다고 생각을 합니다. 그렇지만 웹과 관련한 경험이 없는 분들에게는 좋은 경험이 될 수도 있다고 생각을 합니다.

소스 코드의 게시도 깔끔하다고 생각합니다. 예시 코드 )

void insert(const char* key) {
    if (*key == '\0') {
        finish = true;
    } else {
        int idx = *key - 'A';
        if (!next[idx])
            next[idx] = new Trie();
        next[idx]->insert(key + 1);
    }
}

다시 본론으로 돌아와서 github.io 작성을 위해 Repository를 생성하고, ruby를 이용한 Jekyll을 설치하는 과정을 소개 하겠습니다. 그리고 온라인에 공유되고 있는 테마 소스를 받아서 적용 해보도록 하겠습니다.

Tips:

아래의 링크와 같이 Github에서 공식적으로 소개하는 작성 방법도 있습니다.
https://pages.github.com/

Github Repository

https://www.github.com

Ruby

https://rubyinstaller.org/

> ruby -v

Jekyll

설치 및 테스트

> gem install jekyll bundle
> jekyll -v
> bundle -v

> jekyll new ./
> bundle install

> bundle exec jekyll serve

테마 적용하기

> git add . 
> git commit -m "any commit messages"
> git push