비둘기 집의 원리

n+1개의 물건을 n개의 상자에 넣은 경우, 최소한 한 상자에는 그 물건이 반드시 두 개 이상 들어있다는 원리를 말한다.

보통 비둘기와 비둘기집의 형태로 비유되어 쓰이기 때문에, 비둘기 집의 원리라고 불린다.

비둘기가 10마리, 집이 9개라면 한마리가 남는다.

증명

간단한 귀류법으로 증명할 수 있다.

모든 비둘기가 집에 들어간다는 가정 하에

개의 비둘기집과 마리의 비둘기가 있다고 가정한다.
만약 각 비둘기집에 한 마리 이하의 비둘기만 들어 있다면, 전체 비둘기집에는 많아야 마리의 비둘기가 존재한다.
그런데 비둘기는 모두 마리이므로, 이것은 모순이다.
따라서 어느 비둘기집에는 두 마리 이상의 비둘기가 있다.

이 증명은 대표적인 존재증명이다.

즉, 비둘기가 두 마리 이상 존재하는 집이 정확히 어떤 집인지는 이 증명으로 알아낼 수 없다.

비둘기집의 원리의 일반화

일반화된 비둘기집 원리는 다음과 같다.

개의 별개의 사물을 개의 용기에 나누어 담으면 적어도 한 개의 용기는  이상의 사물을 담고 있어야 한다.

(여기서, 는 보다 작지 않은 최소 정수를 의미한다.)

확률론적으로 일반화된 비둘기집 원리는 다음과 같다.

의 균일한 확률로 개의 비둘기를 무작위로 개의 비둘기집에 넣었다면 확률적으로 적어도 하나의 비둘기집에 두마리 이상의 비둘기가 들어가게 된다.

 인 경우와, 인 경우(단, )에 확률은 0인데, 달리 말하면 비둘기가 한마리 밖에 없다고 하면,

충돌(한 비둘기집에 두 마리 이상의 비둘기가 들어가는 일)이 일어날 수 없다는 것이다. 

 (비둘기가 비둘기집보다 많다)이라면 확률은 1이 되고 이런 경우에는 보통의 비둘기집 원리와 같은 일이 일어난다.

그러나 비둘기의 수가 비둘기집의 수를 초과하지 않는다 하더라도 (), 비둘기 분배의 무작위적인 성질에 의하여 종종 상당한 확률로 충돌이 일어난다.

예를 들어, 2마리의 비둘기가 무작위로 4개의 비둘기집에 분배된다면, 25%의 확률로 적어도 하나의 비둘기집에 두마리 이상의 비둘기가 들어가게 될 것이며,

5마리의 비둘기를 10개의 비둘기집에 분배한다면 확률은 69.76%가 되고, 10마리의 비둘기를 20개의 비둘기집에 분배하면 그 확률은 약 93.45%가 된다.

출처 : https://ko.wikipedia.org/wiki/%EB%B9%84%EB%91%98%EA%B8%B0%EC%A7%91_%EC%9B%90%EB%A6%AC

관련 문제

백준 20529번 가장 가까운 세 사람의 심리적 거리

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

백준 비둘기 집의 원리 관련 문제들

https://www.acmicpc.net/problemset?sort=ac_desc&algo=189

The post 알고리즘 – 비둘기 집의 원리 (Pigeonhole Principle) appeared first on 어제와 내일의 나 그 사이의 이야기.

헌내기는 친구가 필요해

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

문제

2020년에 입학한 헌내기 도연이가 있다. 도연이는 비대면 수업 때문에 학교에 가지 못해 학교에 아는 친구가 없었다.

드디어 대면 수업을 하게 된 도연이는 어서 캠퍼스 내의 사람들과 친해지고 싶다. 

도연이가 다니는 대학의 캠퍼스는 N x M 크기이며 캠퍼스에서 이동하는 방법은 벽이 아닌 상하좌우로 이동하는 것이다.

예를 들어, 도연이가 (x, y)에 있다면 이동할 수 있는 곳은 (x+1, y), (x, y+1), (x-1, y), (x, y-1)이다.

단, 캠퍼스의 밖으로 이동할 수는 없다.

불쌍한 도연이를 위하여 캠퍼스에서 도연이가 만날 수 있는 사람의 수를 출력하는 프로그램을 작성해보자.

입력

첫째 줄에는 캠퍼스의 크기를 나타내는 두 정수 N (1 ≤ N ≤ 600), M (1 ≤ M ≤ 600)이 주어진다.

둘째 줄부터 N개의 줄에는 캠퍼스의 정보들이 주어진다. 

O는 빈 공간, X는 벽, I는 도연이, P는 사람이다. 

I가 한 번만 주어짐이 보장된다.

출력

첫째 줄에 도연이가 만날 수 있는 사람의 수를 출력한다.

단, 아무도 만나지 못한 경우 TT를 출력한다.

예제 입력 1

3 5
OOOPO
OIOOX
OOOXP

예제 출력 1

1

예제 입력 2

3 3
IOX
OXP
XPP

예제 출력 2

TT

출처

University > 숙명여자대학교 > 제1회 숙명여자대학교 교내 알고리즘 경진대회 (SMUPC) C번

• 문제를 검수한 사람: cs71107, lky7674, plast, sait2000, songfox00, wbcho0504, whaeun25
• 문제를 만든 사람: swoon

알고리즘 분류

• 그래프 이론
• 그래프 탐색
• 너비 우선 탐색
• 깊이 우선 탐색

통과된 코드

DFS 탐색을 재귀로 구현하여 문제를 해결

#include <iostream>
using namespace std;
int _Res = 0, _N, _M;
int _DxDy[4][2] = { {1, 0}, {-1, 0}, {0, 1}, {0, -1} };
char _Map[600][600];
string _Str;
char _Temp;
pair<int, int> StartPos;

// 재귀를 이용한 DFS (Depth-First Search) 탐색 
void DFSSearch(int _CntX, int _CntY)
{
	for (int j = 0; j < 4; j++) {
		int _dx = _CntX + _DxDy[j][0];
		int _dy = _CntY + _DxDy[j][1];
		if (_dx >= _N || _dy >= _M || _dx < 0 || _dy < 0)
			continue;
		if (_Map[_dx][_dy] == 'X')
			continue;
		if (_Map[_dx][_dy] == 'P')
			_Res++;
		// 방문처리 대신에 X(벽)으로 마킹
		_Map[_dx][_dy] = 'X';
		DFSSearch(_dx, _dy);
	}
}

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	cin >> _N >> _M;
	for (int i = 0; i < _N; i++) {
		cin >> _Str;
		for (int j = 0; j < _M; j++) {
			_Map[i][j] = _Str[j];
			if (_Str[j] == 'I') {
				StartPos = make_pair(i, j);
				_Map[i][j] = 'X';
			}
		}
	}
	
	DFSSearch(StartPos.first, StartPos.second);

	if (_Res == 0) cout << "TT"; 
	else  cout << _Res;

	return 0;
}

The post 백준 21736번 (헌내기는 친구가 필요해, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

보물 지도

https://school.programmers.co.kr/learn/courses/15009/lessons/121690

문제 설명

진수는 보물이 묻힌 장소와 함정이 표시된 보물 지도를 이용해 보물을 찾으려 합니다.

보물지도는 가로 길이가 n, 세로 길이가 m인 직사각형 모양입니다.

맨 왼쪽 아래 칸의 좌표를 (1, 1)으로, 맨 오른쪽 위 칸의 좌표를 (n, m)으로 나타냈을 때, 보물은 (n, m) 좌표에 묻혀있습니다.

또한, 일부 칸에는 함정이 있으며, 해당 칸으로는 지나갈 수 없습니다.

진수는 처음에 (1, 1) 좌표에서 출발해 보물이 있는 칸으로 이동하려 합니다.

이동할 때는 [상,하,좌,우]로 인접한 네 칸 중 한 칸으로 걸어서 이동합니다.

한 칸을 걸어서 이동하는 데 걸리는 시간은 1입니다.

진수는 보물이 위치한 칸으로 수월하게 이동하기 위해 신비로운 신발을 하나 준비했습니다.

이 신발을 신고 뛰면 한 번에 두 칸을 이동할 수 있으며, 함정이 있는 칸도 넘을 수 있습니다.

하지만, 이 신발은 한 번밖에 사용할 수 없습니다.

신비로운 신발을 사용하여 뛰어서 두 칸을 이동하는 시간도 1입니다.

이때 진수가 출발점에서 보물이 위치한 칸으로 이동하는데 필요한 최소 시간을 구해야 합니다.

예를 들어, 진수의 보물지도가 아래 그림과 같을 때, 진수가 걸어서 오른쪽으로 3칸,

걸어서 위쪽으로 3칸 이동하면 6의 시간에 보물이 위치한 칸으로 이동할 수 있습니다.

만약, 오른쪽으로 걸어서 1칸, 위쪽으로 걸어서 1칸, 신비로운 신발을 사용하여 위로 뛰어 2칸,

오른쪽으로 걸어서 2칸 이동한다면 총 5의 시간에 보물이 위치한 칸으로 이동할 수 있으며,

이보다 빠른 시간 내에 보물이 있는 위치에 도착할 수 없습니다.

진수의 보물지도가 표현하는 지역의 가로 길이를 나타내는 정수 n,

세로 길이를 나타내는 정수 m, 함정의 위치를 나타내는 2차원 정수 배열 hole이 주어졌을 때,

진수가 보물이 있는 칸으로 이동하는데 필요한 최소 시간을 return 하는 solution 함수를 완성해주세요. 

단, 보물이 있는 칸으로 이동할 수 없다면, -1을 return 해야 합니다.

제한사항

• 1 ≤ n, m ≤ 1,000
  • 단, n * m이 3 이상인 경우만 입력으로 주어집니다.
• 1 ≤ hole의 길이 ≤ n * m – 2
  • hole[i]는 [a, b]의 형태이며, (a, b) 칸에 함정이 존재한다는 의미이며, 1 ≤ a ≤ n, 1 ≤ b ≤ m을 만족합니다.
  • 같은 함정에 대한 정보가 중복해서 들어있지 않습니다.
• (1, 1) 칸과 (n, m) 칸은 항상 함정이 없습니다.

입출력 예

입출력 예 설명

입출력 예 #1

• 본문의 예시와 같습니다.

입출력 예 #2

• 보물지도를 그림으로 나타내면 아래와 같으며, 보물이 위치한 칸으로 이동할 수 없습니다.
  따라서, -1을 return 해야 합니다.

통과된 코드

신발은 구멍과 상관없이 사용해도 된다.

#include <string>
#include <vector>
#include <tuple>
#include <queue>
bool _Map[1001][1001];
bool _IsVisted[1001][1001][2]; // 배열의 마지막은 신발의 사용 유무
int _dxdy[8][2] = { {1,0},{0,1},{-1,0},{0,-1}, {2,0},{0,2},{-2,0},{0,-2} };
using namespace std;
int solution(int n, int m, vector<vector<int>> holeVector) {
    int answer = -1;
	for (auto& hole : holeVector)
		_Map[hole[0]][hole[1]] = true;
	tuple<int, int, bool, int> _CntPos = make_tuple(1, 1, true, 0);
	queue<tuple<int, int, bool, int>> _MyQueue;
	_IsVisted[1][1][1] = true;
	_MyQueue.push(_CntPos);
	while (!_MyQueue.empty()) {
		_CntPos = _MyQueue.front();
		_MyQueue.pop();
		int _cntX = get<0>(_CntPos);
		int _cntY = get<1>(_CntPos);
		bool _shoes = get<2>(_CntPos);
		int _cnt = get<3>(_CntPos);	

		// 목적지에 도착
		if (_cntX == n && _cntY == m) {
				answer = _cnt;
				break;
		}

		// 총 8가지의 경우를 탐색
		// 0 ~ 3 상,하,좌,우
		// 4 ~ 7 신발을 사용하여 상,하,좌,우를 2칸씩 이동
		// 꼭 구멍이 있어야 신발을 사용하는 것이 아니다.
		for (int i = 0; i < 8; i++) {
			if (!_shoes && i >= 4) break;
			int _dx = _cntX + _dxdy[i][0];
			int _dy = _cntY + _dxdy[i][1];
			// 맵의 범위를 벗어나는 경우
			if (_dx > n || _dy > m || _dx <= 0 || _dy <= 0 ) 
				continue;
			// 이동을 하려던 곳이 구멍 && 신발이 없음 || 이미 방문한 적이 있다.
			if (_Map[_dx][_dy] || _IsVisted[_dx][_dy][_shoes])
				continue;

			if (i >= 4) { // 신발을 사용하여 이동하는 경우
				_MyQueue.push(make_tuple(_dx, _dy, false, _cnt + 1));
				_IsVisted[_dx][_dy][false] = true;
			}
			else { // 신발을 사용하지 않는 경우
				_MyQueue.push(make_tuple(_dx, _dy, _shoes, _cnt + 1));
				_IsVisted[_dx][_dy][_shoes] = true;
			}

		}
	}

	return answer;
}

The post Programmers 121690 4번 보물 지도 [PCCP 모의고사 2회] appeared first on 어제와 내일의 나 그 사이의 이야기.

분수좋아해?

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

문제

당신은 학생들의 기초수학 학습을 돕는 소프트웨어를 개발하는 팀의 개발자이다.

당신은 가분수를 대분수(?)로 출력하는 부분을 개발해야 한다.

진분수는 분자가 분모보다 작은 분수이다; 대분수는 정수부를 따로 떼어주고 남는 부분을 진분수로 쓰는 기법이다.

예제로, 27/12는 대분수로 2 3/12이다. 기약분수로 만들지 말아야 한다.

(3/12를 1/4로 바꿔 출력하지 마시오.)

입력

한 줄에 걸쳐 한 테스트 케이스가 입력된다.

각각의 테스트 케이스는 [1, 2^31 – 1]범위의 두 정수가 입력된다.

첫 번째 정수는 분자고 두 번째는 분모이다.

“0 0” 입력이 들어오는 라인에서 입력을 종료한다.

출력

각 테스트 케이스에 대해 한 줄에 걸쳐 주어진 입력에 맞는 대분수를 공백토큰으로 구분하여 출력하라.

예제 입력 1

27 12
2460000 98400
3 4000
0 0

예제 출력 1

2 3 / 12
25 0 / 98400
0 3 / 4000

출처

ICPC > Regionals > North America > North America Qualification Contest > ACM-ICPC North America Qualifier 2014 F번

• 문제를 번역한 사람: tae
• 잘못된 번역을 찾은 사람: veydpz
• 문제를 만든 사람: Michael Zmuda

알고리즘 분류

• 수학
• 사칙연산

통과된 코드

#include <iostream>
using namespace std;
int _A, _B;
int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	while (true) {
		cin >> _A >> _B;
		if (_A == 0 && _B == 0) break;
		cout << _A / _B << " " << _A % _B << " / " << _B << "\n";
	}
} 

The post 백준 10474번 (분수좋아해?, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

카드1

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

문제

N장의 카드가 있다. 각각의 카드는 차례로 1부터 N까지의 번호가 붙어 있으며,

1번 카드가 제일 위에, N번 카드가 제일 아래인 상태로 순서대로 카드가 놓여 있다.

이제 다음과 같은 동작을 카드가 한 장 남을 때까지 반복하게 된다.

우선, 제일 위에 있는 카드를 바닥에 버린다.

그 다음, 제일 위에 있는 카드를 제일 아래에 있는 카드 밑으로 옮긴다.

예를 들어 N=4인 경우를 생각해 보자.

카드는 제일 위에서부터 1234 의 순서로 놓여있다.

1을 버리면 234가 남는다. 여기서 2를 제일 아래로 옮기면 342가 된다.

3을 버리면 42가 되고, 4를 밑으로 옮기면 24가 된다.

마지막으로 2를 버리고 나면, 버린 카드들은 순서대로 1 3 2가 되고, 남는 카드는 4가 된다.

N이 주어졌을 때, 버린 카드들을 순서대로 출력하고,

마지막에 남게 되는 카드를 출력하는 프로그램을 작성하시오.

입력

첫째 줄에 정수 N(1 ≤ N ≤ 1,000)이 주어진다.

출력

첫째 줄에 버리는 카드들을 순서대로 출력한다.

제일 마지막에는 남게 되는 카드의 번호를 출력한다.

예제 입력 1

7

예제 출력 1

1 3 5 7 4 2 6

알고리즘 분류

• 구현
• 자료 구조
• 큐

통과된 코드

큐를 이용하여 상황을 구현하는 단순한 문제입니다.

#include <iostream>
#include <queue>
using namespace std;
queue<int> _MyQueue;
int _N;
int main()
{
	cin >> _N;
	for (int i = 1; i <= _N; i++)
		_MyQueue.push(i);
	while (true) {
		cout << _MyQueue.front() << " ";
		_MyQueue.pop();
		if (_MyQueue.empty())
			break;
		_MyQueue.push(_MyQueue.front());
		_MyQueue.pop();
	}
	return 0;
}

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

N-Queen

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

문제

N-Queen 문제는 크기가 N × N인 체스판 위에 퀸 N개를 서로 공격할 수 없게 놓는 문제이다.

N이 주어졌을 때, 퀸을 놓는 방법의 수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 N이 주어진다. (1 ≤ N < 15)

출력

첫째 줄에 퀸 N개를 서로 공격할 수 없게 놓는 경우의 수를 출력한다.

예제 입력 1

5 17

예제 출력 1

2

출처

• 문제를 만든 사람: baekjoon

알고리즘 분류

• 브루트포스 알고리즘
• 백트래킹

통과된 코드

#include <iostream>
#include <cmath>
using namespace std;
constexpr int Max = 15; // 체스판의 최대 
int _N, _Res, _Queen[Max];

bool CheckQueens(int _row)
{
	for (int i = 0; i < _row; i++) {
		// 절대값으로 대각선으로 전부 확인
		if (_Queen[i] == _Queen[_row] || ( abs(_Queen[i] - _Queen[_row]) == abs(i - _row))) {
			return false;
		}
	}
	return true;
}

void BackTracing(int _row) {
	// N번째까지 왔다면 경우의 수 추가
	if (_row == _N) {
		_Res++;
		return; 
	}

	for (int _col = 0; _col < _N; _col++) {
		_Queen[_row] = _col;
		//해당 행이 가능한지 확인한다.
		if (CheckQueens(_row)) 
			BackTracing(_row + 1);
	}
}

int main()
{
	cin >> _N; // 체스판의 크기 입력
	BackTracing(0); // 백트레킹으로 체크
	cout << _Res;
	return 0;
}

더 효율적인 코드

DFS 탐색을 이용한 백트레킹

dy dx를 대각선으로 표현하여 검사

#include <iostream>
using namespace std;
constexpr int Max = 15;
int _N, _Res;
// 체스판 
bool MapArr[Max];
//체스판의 대각선을 표현하기위한 변수
//대각선은 2N - 1개 필요
bool dx[29], dy[29];

void BackTracking(int level)
{
	if (level == _N) {
		_Res++;
		return;
	}
	for (int i = 0; i < _N; i++) {
		//현재 열, 왼쪽 대각선 및 오른쪽 대각선에 이미 배치된 여왕이 없는지 확인
		// dx, dy는 체스판의 특정한 위치를 나타내는 변수가 아니다.
		// dx, dy를 이용하여 대각선을 추적하는 것
		// 배열의 각 인덱스는 dx대각선을 나타내며 해당 인덱스의 값은 대각선이 여왕에 의해 점유되는지 여부를 나타냅니다. 
		if (!MapArr[i] && !dx[i - level + _N] && !dy[i + level]) {
			
			MapArr[i] = dx[i - level + _N] = dy[i + level] = true;
			BackTracking(level + 1);
			MapArr[i] = dx[i - level + _N] = dy[i + level] = false;
		}
	}
}

int main() {
	_Res = 0;
	cin >> _N;
	BackTracking(0);
	cout << _Res;
}

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

지능형 기차 2

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

문제

최근에 개발된 지능형 기차가 1번역(출발역)부터 10번역(종착역)까지 10개의 정차역이 있는 노선에서 운행되고 있다.

이 기차에는 타거나 내리는 사람 수를 자동으로 인식할 수 있는 장치가 있다.

이 장치를 이용하여 출발역에서 종착역까지 가는 도중 기차 안에 사람이 가장 많을 때의 사람 수를 계산하려고 한다.

단, 이 기차를 이용하는 사람들은 질서 의식이 투철하여, 역에서 기차에 탈 때, 내릴 사람이 모두 내린 후에 기차에 탄다고 가정한다.

예를 들어, 위와 같은 경우를 살펴보자.

이 경우, 기차 안에 사람이 가장 많은 때는 2번역에서 3명의 사람이 기차에서 내리고,

13명의 사람이 기차에 탔을 때로, 총 42명의 사람이 기차 안에 있다.

이 기차는 다음 조건을 만족하면서 운행된다고 가정한다.

1. 기차는 역 번호 순서대로 운행한다.
2. 출발역에서 내린 사람 수와 종착역에서 탄 사람 수는 0이다.
3. 각 역에서 현재 기차에 있는 사람보다 더 많은 사람이 내리는 경우는 없다.
4. 기차의 정원은 최대 10,000명이고, 정원을 초과하여 타는 경우는 없다.

10개의 역에 대해 기차에서 내린 사람 수와 탄 사람 수가 주어졌을 때,

기차에 사람이 가장 많을 때의 사람 수를 계산하는 프로그램을 작성하시오.

입력

각 역에서 내린 사람 수와 탄 사람 수가 빈칸을 사이에 두고 첫째 줄부터 열 번째 줄까지 역 순서대로 한 줄에 하나씩 주어진다. 

출력

첫째 줄에 최대 사람 수를 출력한다.  

예제 입력 1

0 32
3 13
28 25
17 5
21 20
11 0
12 12
4 2
0 8
21 0

예제 출력 1

42

출처

Olympiad > 한국정보올림피아드 > 한국정보올림피아드시․도지역본선 > 지역본선 2011 > 중등부 1번

• 문제의 오타를 찾은 사람: eric00513

알고리즘 분류

• 수학
• 구현
• 사칙연산

통과된 코드

단순한 사칙연산 문제입니다.

#include <iostream>
using namespace std;
int _Res = 0, _Cnt = 0, _In, _Out;
int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);

	for (int i = 0; i < 10; i++) {
		cin >> _Out >> _In;
		_Cnt += _In - _Out;
		_Res = max(_Cnt, _Res);
	}
	cout << _Res;
	return 0;
}

The post 백준 2460번 (지능형 기차 2, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

광고 삽입

https://school.programmers.co.kr/learn/courses/30/lessons/72414

문제 설명

카카오TV에서 유명한 크리에이터로 활동 중인 죠르디는 환경 단체로부터

자신의 가장 인기있는 동영상에 지구온난화의 심각성을 알리기 위한 공익광고를 넣어 달라는 요청을 받았습니다.

평소에 환경 문제에 관심을 가지고 있던 “죠르디”는 요청을 받아들였고

광고효과를 높이기 위해 시청자들이 가장 많이 보는 구간에 공익광고를 넣으려고 합니다.

“죠르디”는 시청자들이 해당 동영상의 어떤 구간을 재생했는 지 알 수 있는 재생구간 기록을 구했고,

해당 기록을 바탕으로 공익광고가 삽입될 최적의 위치를 고를 수 있었습니다.

참고로 광고는 재생 중인 동영상의 오른쪽 아래에서 원래 영상과 동시에 재생되는 PIP(Picture in Picture) 형태로 제공됩니다.

다음은 “죠르디”가 공익광고가 삽입될 최적의 위치를 고르는 과정을 그림으로 설명한 것입니다.

• 그림의 파란색 선은 광고를 검토 중인 “죠르디” 동영상의 전체 재생 구간을 나타냅니다.
  • 위 그림에서, “죠르디” 동영상의 총 재생시간은 02시간 03분 55초 입니다.
• 그림의 검은색 선들은 각 시청자들이 “죠르디”의 동영상을 재생한 구간의 위치를 표시하고 있습니다.
  • 검은색 선의 가운데 숫자는 각 재생 기록을 구분하는 ID를 나타냅니다.
  • 검은색 선에 표기된 왼쪽 끝 숫자와 오른쪽 끝 숫자는 시청자들이 재생한 동영상 구간의 시작 시각과 종료 시각을 나타냅니다.
  • 위 그림에서, 3번 재생 기록은 00시 25분 50초 부터 00시 48분 29초 까지 총 00시간 22분 39초 동안 죠르디의 동영상을 재생했습니다.
  • 위 그림에서, 1번 재생 기록은 01시 20분 15초 부터 01시 45분 14초 까지 총 00시간 24분 59초 동안 죠르디의 동영상을 재생했습니다.
• 그림의 빨간색 선은 “죠르디”가 선택한 최적의 공익광고 위치를 나타냅니다.
  • 만약 공익광고의 재생시간이 00시간 14분 15초라면, 위의 그림처럼 01시 30분 59초 부터 
    01시 45분 14초 까지 공익광고를 삽입하는 것이 가장 좋습니다. 이 구간을 시청한 시청자들의 누적 재생시간이 가장 크기 때문입니다.
  • 01시 30분 59초 부터 01시 45분 14초 까지의 누적 재생시간은 다음과 같이 계산됩니다.
    • 01시 30분 59초 부터 01시 37분 44초 까지 : 4번, 1번 재생 기록이 두차례 있으므로 재생시간의 합은 00시간 06분 45초 X 2 = 00시간 13분 30초
    • 01시 37분 44초 부터 01시 45분 14초 까지 : 4번, 1번, 5번 재생 기록이 세차례 있으므로 재생시간의 합은 00시간 07분 30초 X 3 = 00시간 22분 30초
    • 따라서, 이 구간 시청자들의 누적 재생시간은 00시간 13분 30초 + 00시간 22분 30초 = 00시간 36분 00초입니다.

[문제]

“죠르디”의 동영상 재생시간 길이 play_time, 공익광고의 재생시간 길이 adv_time,

시청자들이 해당 동영상을 재생했던 구간 정보 logs가 매개변수로 주어질 때,

시청자들의 누적 재생시간이 가장 많이 나오는 곳에 공익광고를 삽입하려고 합니다.

이때, 공익광고가 들어갈 시작 시각을 구해서 return 하도록 solution 함수를 완성해주세요.

만약, 시청자들의 누적 재생시간이 가장 많은 곳이 여러 곳이라면,

그 중에서 가장 빠른 시작 시각을 return 하도록 합니다.

[제한사항]

• play_time, adv_time은 길이 8로 고정된 문자열입니다.
  • play_time, adv_time은 HH:MM:SS 형식이며, 00:00:01 이상 99:59:59 이하입니다.
  • 즉, 동영상 재생시간과 공익광고 재생시간은 00시간 00분 01초 이상 99시간 59분 59초 이하입니다.
  • 공익광고 재생시간은 동영상 재생시간보다 짧거나 같게 주어집니다.
• logs는 크기가 1 이상 300,000 이하인 문자열 배열입니다.
  • logs 배열의 각 원소는 시청자의 재생 구간을 나타냅니다.
  • logs 배열의 각 원소는 길이가 17로 고정된 문자열입니다.
  • logs 배열의 각 원소는 H1:M1:S1-H2:M2:S2 형식입니다.
    • H1:M1:S1은 동영상이 시작된 시각, H2:M2:S2는 동영상이 종료된 시각을 나타냅니다.
    • H1:M1:S1는 H2:M2:S2보다 1초 이상 이전 시각으로 주어집니다.
    • H1:M1:S1와 H2:M2:S2는 play_time 이내의 시각입니다.
• 시간을 나타내는 HH, H1, H2의 범위는 00~99, 분을 나타내는 MM, M1, M2의 범위는 00~59,
  초를 나타내는 SS, S1, S2의 범위는 00~59까지 사용됩니다.
  잘못된 시각은 입력으로 주어지지 않습니다. (예: 04:60:24, 11:12:78, 123:12:45 등)
• return 값의 형식
  • 공익광고를 삽입할 시각을 HH:MM:SS 형식의 8자리 문자열로 반환합니다.

[입출력 예]

입출력 예에 대한 설명

입출력 예 #1

문제 예시와 같습니다.

입출력 예 #2

01:00:00에 공익광고를 삽입하면 26:00:00까지 재생되며, 이곳이 가장 좋은 위치입니다.

이 구간의 시청자 누적 재생시간은 다음과 같습니다.

• 01:00:00-11:00:00 : 해당 구간이 1회(2번 기록) 재생되었으므로 누적 재생시간은 10시간 00분 00초 입니다.
• 11:00:00-21:00:00 : 해당 구간이 2회(2번, 4번 기록) 재생되었으므로 누적 재생시간은 20시간 00분 00초 입니다.
• 21:00:00-26:00:00 : 해당 구간이 1회(4번 기록) 재생되었으므로 누적 재생시간은 05시간 00분 00초 입니다.
• 따라서, 이 구간의 시청자 누적 재생시간은 10시간 00분 00초 + 20시간 00분 00초 + 05시간 00분 00초 = 35시간 00분 00초 입니다.
• 초록색으로 표시된 구간(69:59:59-94:59:59)에 광고를 삽입해도 동일한 결과를 얻을 수 있으나, 01:00:00이 69:59:59 보다 빠른 시각이므로, "01:00:00"을 return 합니다.

입출력 예 #3

동영상 재생시간과 공익광고 재생시간이 같으므로,

삽입할 수 있는 위치는 맨 처음(00:00:00)이 유일합니다.

동영상 재생시간 = 재생이 종료된 시각 - 재생이 시작된 시각

(예를 들어, 00시 00분 01초부터 00시 00분 10초까지 동영상이 재생되었다면, 동영상 재생시간은 9초 입니다.) 

통과된 코드

주의

logs는 크기가 1 이상 300,000 이하인 문자열 배열

동영상 시간의 최대 범위는 360,000초

300,000 * 360,000 = 108,000,000,000

int의 범위 -2,147,483,648 ~ 2,147,483,647를 벗어난다.

#include <string>
#include <vector>
#include <sstream>
#include <cstdlib>
#include <string>

using namespace std;

int Total_PT_Int, Total_ADV_Time, TimeLine[360000];
long long int _Res;

vector<pair<int, int>> Logs_Times;

int StringTimeConverter(string time) {
    int second;

    int to_hour = ((time[0] - '0') * 10) + (time[1] - '0');
    int to_min = ((time[3] - '0') * 10) + (time[4] - '0');
    int to_sec = ((time[6] - '0') * 10) + (time[7] - '0');
    second = to_hour * 3600 + to_min * 60 + to_sec;

    return second;
}

string IntToTimeString(int timeInSeconds) {
    int hours = timeInSeconds / 3600;
    int minutes = (timeInSeconds % 3600) / 60;
    int seconds = (timeInSeconds % 3600) % 60;
    string str;
    if (hours < 10) str += "0" + to_string(hours) + ":";
    else str += to_string(hours) + ":";
    if (minutes < 10) str += "0" + to_string(minutes) + ":";
    else str += to_string(minutes) + ":";
    if (seconds < 10) str += "0" + to_string(seconds);
    else str += to_string(seconds);
    return str;
}

string solution(string play_time, string adv_time, vector<string> logs) {
    string answer = "";
    Total_PT_Int = StringTimeConverter(play_time);
    Total_ADV_Time = StringTimeConverter(adv_time);
    for (auto& it : logs)
    {
        vector<string> _ResV;
        istringstream ss(it);
        string _temp;
        while (getline(ss, _temp, '-'))
            _ResV.push_back(_temp);
        int _Start = StringTimeConverter(_ResV[0]);
        int _End = StringTimeConverter(_ResV[1]); 
        Logs_Times.push_back(make_pair(_Start, _End));
        TimeLine[_Start]++;
        TimeLine[_End]--;
    }

    for (int i = 1; i < Total_PT_Int; i++) 
        TimeLine[i] += TimeLine[i - 1];

    // 0 부터 시작
    int STime = 0;
    for (int i = 1; i < Total_ADV_Time; i++)
        _Res += TimeLine[i - 1];
    long long int Max = _Res;


    for (int i = Total_ADV_Time; i < Total_PT_Int; i++) {
        _Res += TimeLine[i];
        _Res -= TimeLine[i - Total_ADV_Time];
        if (_Res > Max) {
            Max = _Res;
           STime = i - Total_ADV_Time + 1;
        }
    }
    return IntToTimeString(STime);
}

The post Programmers 72414 광고 삽입 [2021 KAKAO BLIND RECRUITMENT] appeared first on 어제와 내일의 나 그 사이의 이야기.

트리 순회

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

문제

이진 트리를 입력받아 전위 순회(preorder traversal), 중위 순회(inorder traversal),

후위 순회(postorder traversal)한 결과를 출력하는 프로그램을 작성하시오.

예를 들어 위와 같은 이진 트리가 입력되면,

전위 순회한 결과 : ABDCEFG // (루트) (왼쪽 자식) (오른쪽 자식)

중위 순회한 결과 : DBAECFG // (왼쪽 자식) (루트) (오른쪽 자식)

후위 순회한 결과 : DBEGFCA // (왼쪽 자식) (오른쪽 자식) (루트)

가 된다.

입력

첫째 줄에는 이진 트리의 노드의 개수 N(1 ≤ N ≤ 26)이 주어진다.

둘째 줄부터 N개의 줄에 걸쳐 각 노드와 그의 왼쪽 자식 노드, 오른쪽 자식 노드가 주어진다.

노드의 이름은 A부터 차례대로 알파벳 대문자로 매겨지며, 항상 A가 루트 노드가 된다.

자식 노드가 없는 경우에는 .으로 표현한다.

출력

첫째 줄에 전위 순회, 둘째 줄에 중위 순회, 셋째 줄에 후위 순회한 결과를 출력한다.

각 줄에 N개의 알파벳을 공백 없이 출력하면 된다.

예제 입력 1

7
A B C
B D .
C E F
E . .
F . G
D . .
G . .

예제 출력 1

ABDCEFG
DBAECFG
DBEGFCA

알고리즘 분류

• 트리
• 재귀

통과된 코드

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

struct Node;
vector<Node> NodesV;
void PreorderTraverse(int _Cnt);
void PostorderTraverse(int _Cnt);
void InorderTraverse(int _Cnt);
int _N;
char _C, _L, _R;

struct Node
{
	int _Node;

	Node* _LeftNode;
	Node* _RightNode;

	Node(char _node)
	{
		_LeftNode = NULL;
		_RightNode = NULL;
		_Node = (int)_node - 65;
	}

	void ChangeNodeLeft(char NodeC)
	{
		if (NodeC == '.') return;
		_LeftNode = &NodesV[(int)NodeC - 65];
	}

	void ChangeNodeRight(char NodeC)
	{
		if (NodeC == '.') return;
		_RightNode = &NodesV[(int)NodeC - 65];
	}
};

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

	cin >> _N;
	for (int i = 0; i < _N; i++) {
		Node TNode = Node((char)(65 + i));
		NodesV.push_back((char)(65 + i));
	}

	for (int i = 0; i < _N; i++) {
		cin >> _C >> _L >> _R;
		NodesV[(int)_C - 65].ChangeNodeLeft(_L);
		NodesV[(int)_C - 65].ChangeNodeRight(_R);
	}

	PreorderTraverse(0);
	cout << "\n";
	PostorderTraverse(0);
	cout << "\n";
	InorderTraverse(0);
	return 0;
}

void PreorderTraverse(int _Cnt)
{
	cout << (char)(_Cnt + 65);
	if (NodesV[_Cnt]._LeftNode != NULL)
		PreorderTraverse(NodesV[_Cnt]._LeftNode->_Node);
	if (NodesV[_Cnt]._RightNode != NULL)
		PreorderTraverse(NodesV[_Cnt]._RightNode->_Node);
}

void PostorderTraverse(int _Cnt)
{
	if (NodesV[_Cnt]._LeftNode != NULL)
		PostorderTraverse(NodesV[_Cnt]._LeftNode->_Node);
	cout << (char)(_Cnt + 65);
	if (NodesV[_Cnt]._RightNode != NULL)
		PostorderTraverse(NodesV[_Cnt]._RightNode->_Node);
}

void InorderTraverse(int _Cnt)
{
	if (NodesV[_Cnt]._LeftNode != NULL)
		InorderTraverse(NodesV[_Cnt]._LeftNode->_Node);
	if (NodesV[_Cnt]._RightNode != NULL)
		InorderTraverse(NodesV[_Cnt]._RightNode->_Node);
	cout << (char)(_Cnt + 65);
}

The post 백준 1991번 (트리 순회, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

숨바꼭질 3

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

문제

수빈이는 동생과 숨바꼭질을 하고 있다.

수빈이는 현재 점 N(0 ≤ N ≤ 100,000)에 있고, 동생은 점 K(0 ≤ K ≤ 100,000)에 있다. 

수빈이는 걷거나 순간이동을 할 수 있다.

만약, 수빈이의 위치가 X일 때 걷는다면 1초 후에 X-1 또는 X+1로 이동하게 된다.

순간이동을 하는 경우에는 0초 후에 2*X의 위치로 이동하게 된다.

수빈이와 동생의 위치가 주어졌을 때,

수빈이가 동생을 찾을 수 있는 가장 빠른 시간이 몇 초 후인지 구하는 프로그램을 작성하시오.

입력

첫 번째 줄에 수빈이가 있는 위치 N과 동생이 있는 위치 K가 주어진다. 

N과 K는 정수이다.

출력

수빈이가 동생을 찾는 가장 빠른 시간을 출력한다.

예제 입력 1

5 17

예제 출력 1

2

힌트

수빈이가 5-10-9-18-17 순으로 가면 2초만에 동생을 찾을 수 있다.

추가 반례

https://www.acmicpc.net/board/search/all/problem/13549

예제 입력 A

1 2

예제 출력 A

0

예제 입력 B

1 17

예제 출력 B

1

예제 입력 C

4 6

예제 출력 C

1

예제 입력 D

0 100000

예제 출력 D

6

출처

• 문제를 만든 사람: baekjoon
• 데이터를 추가한 사람: eric00513, idiot, mohana9, tagun11

비슷한 문제

• 1697번. 숨바꼭질
• 12851번. 숨바꼭질 2
• 13913번. 숨바꼭질 4

알고리즘 분류

• 그래프 이론
• 그래프 탐색
• 너비 우선 탐색
• 데이크스트라
• 0-1 너비 우선 탐색

통과된 코드

Deque을 이용한 탐색과 순서에 주의 (순간 이동은 시간이 증가하지 않는다.)

#include <iostream>
#include <deque>

using namespace std;

deque<pair<int, int>> _MyDeque;
int _N, _K, _Res;
bool _isVisted[100001];

int main()
{
	cin >> _N >> _K;
	_isVisted[_N] = true;
	_MyDeque.push_back(make_pair(_N, 0));
	while (!_MyDeque.empty()) {
		pair<int, int> _Temp = _MyDeque.front();
		_MyDeque.pop_front();
		int _TempPos, _CntPos = _Temp.first;
		int _CntTime = _Temp.second;
		_isVisted[_Temp.first] = true;
		if (_Temp.first == _K) {
			_Res = _Temp.second;
			break;
		}

		_TempPos = _CntPos * 2;
		if (_TempPos <= 100000 && !_isVisted[_TempPos]) {
			_MyDeque.push_front(make_pair(_TempPos, _CntTime));
		}

		_TempPos = _CntPos + 1;
		if (_TempPos <= 100000 && !_isVisted[_TempPos]) {
			_MyDeque.push_back(make_pair(_TempPos, _CntTime + 1));
		}

		_TempPos = _CntPos - 1;
		if (_TempPos >= 0 && !_isVisted[_TempPos]) {
			_MyDeque.push_back(make_pair(_TempPos, _CntTime + 1));
		}
	}

	cout << _Res;
	return 0;
}

The post 백준 13549번 (숨바꼭질 3, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.