램프

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

문제

지민이는 각 칸마다 (1×1크기의 정사각형) 램프가 들어있는 직사각형 모양의 탁자를 샀다.

모든 램프는 켜져있거나 꺼져있다.

각 열의 아래에는 스위치가 하나씩 달려있는데, 이 스위치를 누를 때마다 그 열에 있는 램프의 상태가 바뀐다.

켜져있는 램프는 꺼지고, 꺼져있는 램프는 켜진다)

만약 어떤 행에 있는 램프가 모두 켜져있을 때, 그 행이 켜져있다고 말한다.

지민이는 스위치를 K번 누를 것이다. 서로다른 스위치 K개를 누르지 않아도 된다.

지민이는 스위치를 K번 눌러서 켜져있는 행을 최대로 하려고 한다.

지민이의 탁자에 있는 램프의 상태와 K가 주어졌을 때,

스위치를 K번 누른 후에 켜져있는 행의 최댓값을 구하는 프로그램을 작성하시오.

입력

첫째 줄에 N과 M이 주어진다. N은 행의 개수이고, M은 열의 개수이다.

N과 M은 50보다 작거나 같은 자연수이다. 둘째 줄부터 N개의 줄에는 램프의 상태가 주어진다.

1이 켜져있는 상태이고, 0이 꺼져있는 상태이다.

마지막 줄에는 K가 주어진다.

K는 1,000보다 작거나 같은 자연수 또는 0이다.

출력

첫째 줄에 문제의 정답을 출력한다.

예제 입력 1

3 2
01
10
10
1

예제 출력 1

2

예제 입력 2

1 6
101010
2

예제 출력 2

0

예제 입력 3

2 2
00
11
999

예제 출력 3

0

예제 입력 4

5 1
0
1
0
1
0
1000

예제 출력 4

2

예제 입력 5

14 3
001
101
001
000
111
001
101
111
110
000
111
010
110
001
6

예제 출력 5

4

예제 입력 6

5 2
01
10
01
01
10
1

예제 출력 6

3

출처

• 문제를 번역한 사람: baekjoon

알고리즘 분류

• 브루트포스 알고리즘
• 애드 혹

통과된 코드

재귀를 이용한 BruteForce 알고리즘을 사용하여 테이블의 램프를 제어하는 방법으로 접근했으나 시간 초과로 통과하지 못하였다.

정답은 행에 램프가 꺼져있는 개수를 이용하여 푸는 방법

모든 행에서 K번 안에 모두 1로 바꿀 수 있는 행을 찾고 K가 짝수 홀수 인지에 대하여 확인한다.

만약 가능하다면 똑같은 행이 몇 개인지 확인하여 최댓값을 구한다.

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

int _N, _M, _K, _Res = 0;
string _Table[50];
map<string, pair<int, int>> CheckMap;

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 >> _Table[i];
	cin >> _K;

	for (int i = 0; i < _N; i++) {
		int _cnt = 0;

		for (int j = 0; j < _M; j++)
			if (_Table[i][j] == '0')
				_cnt++;
		if (_cnt > _K) continue;
		auto it = CheckMap.find(_Table[i]);
		if (it != CheckMap.end()) it->second.second++;
		else CheckMap.insert({ _Table[i], {_cnt, 1}});
	}

	for (auto& it : CheckMap)
		if (it.second.first % 2 == _K % 2)
		   _Res = max(_Res, it.second.second);
		
	cout << _Res;
	return 0;
}

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

멋진 쌍

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

문제

두 자연수 (n, m)이 멋진 쌍일 조건은 다음과 같다.

• n의 뒤에서 몇 자리를 떼서, 앞에 그대로 붙이면 m을 얻을 수 있다.

예를 들어, 12345의 뒤에서 345를 떼서 앞에 붙이면 34512가 되므로, (12345, 34512)는 멋진 쌍이다.

같은 개수의 자릿수를 갖는 두 자연수 A와 B가 주어질 때, A ≤ x < y ≤ B 인 멋진 쌍 (x, y)의 개수를 출력하세요.

입력

첫 번째 줄에 두 자연수 A, B가 주어진다. A ≤ B ≤ 2,000,000, A와 B의 자릿수 개수는 같다.

출력

멋진 쌍의 개수를 자연수 하나로 출력한다.

예제 입력 1

1 9

예제 출력 1

0

예제 입력 2

10 40

예제 출력 2

3

예제 입력 3

100 500

예제 출력 3

156

알고리즘 분류

• 수학
• 브루트포스 알고리즘

통과된 코드

중복을 제거하지 않으면 오답으로 처리됩니다.

#include <iostream>
#include <string>
#include <cmath>
#include <set>
using namespace std;
set<pair<int, int>> _ResSet;
int _A, _B, _Res;
int FindingDigit(int _number)
{
	int dig = 0;
	while (_number) {
		_number /= 10;
		dig++;
	}
	return dig;
}

int main()
{
	cin >> _A >> _B;
	for (int i = _A; i <= _B; i++) {
		int dig = FindingDigit(i);
		_ResSet.clear();
		for (int j = 1; j <= dig - 1; j++) {
			int number = i;
			int _t = pow(10, j);
			int remainder = number % _t;
			int frontpart = number / _t;
			int frontpartDig = FindingDigit(frontpart);
			_t = pow(10, frontpartDig);
			int res = frontpart + (remainder * _t);
			if (dig != FindingDigit(res))
				continue;
			if (res > _B || res < _A || res <= number)
				continue;
			_ResSet.insert({ number, res });
		}
		_Res += _ResSet.size();
	}
	cout << _Res;
	return 0;
}

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

가장 가까운 세 사람의 심리적 거리

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

문제

여러분은 요즘 유행하는 심리검사인 MBTI에 대해 들어보았는가?

MBTI(Myers-Briggs Type Indicator)는 C.G.Jung의 심리유형론을 근거로 하여 Katharine Cook Briggs와 Isabel Briggs Myers가 보다 쉽고

일상생활에 유용하게 활용할 수 있도록 고안한 자기보고식 성격유형지표이다. (출처: 위키백과)

MBTI는 아래와 같이 네 가지 척도로 사람들의 성격을 구분한다.

• 외향(E) / 내향(I)
• 감각(S) / 직관(N)
• 사고(T) / 감정(F)
• 판단(J) / 인식(P)

각 척도마다 두 가지 분류가 존재하므로, MBTI는 총 2^4 = 16가지 유형이 있음을 알 수 있다.

일반적으로 MBTI의 유형들은 각 분류를 나타내는 알파벳 한 글자씩을 따 네 글자로 표시하게 된다.

모든 유형의 목록은 다음과 같다.

• ISTJ, ISFJ, INFJ, INTJ, ISTP, ISFP, INFP, INTP, ESTP, ESFP, ENFP, ENTP, ESTJ, ESFJ, ENFJ, ENTJ

MBTI 성격 유형을 이용하면 두 사람 사이의 심리적인 거리를 정의할 수 있다.

이는 두 사람의 MBTI 유형에서 서로 다른 분류에 속하는 척도의 수로 정의된다.

예를 들어, MBTI 유형이 ISTJ인 사람과 ISFJ인 사람 사이의 거리는 1이며, INTP인 사람과 ENTJ인 사람 사이의 거리는 2이다.

이 정의를 확장해서 세 사람 사이의 심리적인 거리도 정의할 수 있다. 

세 사람 A, B, C가 있을 때 이들의 심리적인 거리는

(A와 B 사이의 심리적인 거리) + (B와 C 사이의 심리적인 거리) + (A와 C 사이의 심리적인 거리)로 정의한다.

대학교에서 심리학 교수로 일하는 종서는 자신이 가르치는 학생들의 심리적인 특성을 분석하고 싶어한다.

오늘이 생일인 종서를 위해 N명의 학생들의 MBTI 유형이 주어질 때,

가장 가까운 세 학생 사이의 심리적인 거리를 구해보자.

입력

첫 줄에는 테스트 케이스의 수를 나타내는 정수 T가 주어진다.

각 테스트 케이스의 첫 줄에는 학생의 수를 나타내는 하나의 정수 N이 주어지며,

두 번째 줄에는 각 학생의 MBTI 성격 유형을 나타내는 문자열들이 사이에 공백을 두고 주어진다.

출력

각 테스트 케이스에 대한 답을 정수 형태로 한 줄에 하나씩 출력한다.

제한

•  1≤ T ≤50 
•  3≤ N ≤100000
• 각 테스트 케이스의 N의 합은 100,000을 넘지 않는다.

예제 입력 1

3
3
ENTJ INTP ESFJ
4
ESFP ESFP ESFP ESFP
5
INFP INFP ESTP ESTJ ISTJ

예제 출력 1

8
0
4

• 첫 번째 테스트 케이스의 경우, ENTJ와 INTP의 심리적인 거리는 2,
  ENTJ와 ESFJ의 심리적인 거리는 2, INTP와 ESFJ의 심리적인 거리는 4이므로 세 사람의 심리적인 거리는 2+2+4=8이다.
• 두 번째 테스트 케이스의 경우, 어떤 사람 둘을 골라도 심리적인 거리가 0이므로 가장 가까운 세 사람의 심리적인 거리는 0이다.
• 세 번째 테스트 케이스의 경우, 심리적인 거리를 최소화하려면 MBTI가 ESTP, ESTJ, ISTJ인 세 사람을 골라야 한다.
  ESTP와 ESTJ의 심리적인 거리는 1, ESTP와 ISTJ의 심리적인 거리는 2, ESTJ와 ISTJ의 심리적인 거리는 1이므로 세 사람의 심리적인 거리는 1+2+1=4이다.

출처

Contest > Good Bye, BOJ > Good Bye, BOJ 2020! B번

• 문제를 검수한 사람: ahgus89, cgiosy, cheetose, cs71107, evenharder, gravekper, jhnah917, junseo, kdh9949, koosaga, queued_q, rdd6584, ryute
• 데이터를 추가한 사람: kimyh0316
• 문제를 만든 사람: leejseo, queued_q

알고리즘 분류

• 수학
• 브루트포스 알고리즘
• 비둘기집 원리

통과된 코드

비둘기 집의 원리를 이용하여 N > 32 인 경우를 처리해주는 것이 문제의 포인트

#include <iostream>
#include <vector>
using namespace std;
int _T, _N, _Res = INT32_MAX;
string _Str;
int main()
{
	ios_base::sync_with_stdio(false);
	std::cin.tie(NULL);
	std::cout.tie(NULL);
	cin >> _T;
	for (int i = 0; i < _T; i++) {
		cin >> _N;
		vector<string> _StrV;
		for (int i = 0; i < _N; i++) {
			cin >> _Str;
			_StrV.push_back(_Str);
		}
		if (_N > 32) {
			std::cout << 0 << "\n";
			continue;
		}
		int _Sum;
		_Res = INT32_MAX;
		for (int i = 0; i < _N; i++) {
			for (int j = i + 1; j < _N; j++) {
				for (int k = j + 1; k < _N; k++) {
					_Sum = 0;
					for (int q = 0; q < 4; q++) {
						if (_StrV[i][q] != _StrV[j][q]) _Sum++;
						if (_StrV[j][q] != _StrV[k][q]) _Sum++;
						if (_StrV[k][q] != _StrV[i][q]) _Sum++;
					}
					_Res = min(_Res, _Sum);
				}
			}
		}
		std::cout << _Res << "\n";
	}

	return 0;
}

더 효율적인 코드 (비트 마스킹)

비트마스킹을 이용하여 메모리 및 속도를 개선합니다.

#include <iostream>
#include <vector>
using namespace std;
int _T, _N, _Res = INT32_MAX;
vector<int> _bitV;
string _Str;
int main()
{
	ios_base::sync_with_stdio(false);
	std::cin.tie(NULL);
	std::cout.tie(NULL);
	cin >> _T;
	for (int i = 0; i < _T; i++) {
		cin >> _N;
		_bitV.clear();
		for (int i = 0; i < _N; i++) {
			cin >> _Str;
			int _bit = 0;
			if (_Str[0] == 'I') _bit += 1 << 0;
			if (_Str[1] == 'N') _bit += 1 << 1;
			if (_Str[2] == 'F') _bit += 1 << 2;
			if (_Str[3] == 'P') _bit += 1 << 3;
			_bitV.push_back(_bit);
		}
		if (_N > 32) {
			std::cout << 0 << "\n";
			continue;
		}
		int _Sum;
		_Res = INT32_MAX;
		for (int i = 0; i < _N; i++) {
			for (int j = i + 1; j < _N; j++) {
				for (int k = j + 1; k < _N; k++) {
					_Sum = 0;
					for (int q = 0; q < 4; q++) {
						if ((_bitV[i] & (1 << q)) != (_bitV[j] & (1 << q))) _Sum++;
						if ((_bitV[j] & (1 << q)) != (_bitV[k] & (1 << q))) _Sum++;
						if ((_bitV[k] & (1 << q)) != (_bitV[i] & (1 << q))) _Sum++;
					}
					_Res = min(_Res, _Sum);
				}
			}
		}
		std::cout << _Res << "\n";
	}

	return 0;
}

The post 백준 20529번 (가장 가까운 세 사람의 심리적 거리, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

블록 이동하기

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

로봇개발자 “무지”는 한 달 앞으로 다가온 “카카오배 로봇경진대회”에 출품할 로봇을 준비하고 있습니다.

준비 중인 로봇은 2 x 1 크기의 로봇으로 “무지”는 “0”과 “1”로 이루어진 N x N 크기의 지도에서 2 x 1 크기인 로봇을 움직여 

(N, N) 위치까지 이동 할 수 있도록 프로그래밍을 하려고 합니다. 로봇이 이동하는 지도는 가장 왼쪽, 상단의 좌표를 (1, 1)로 하며

지도 내에 표시된 숫자 “0”은 빈칸을 “1”은 벽을 나타냅니다. 로봇은 벽이 있는 칸 또는 지도 밖으로는 이동할 수 없습니다.

로봇은 처음에 아래 그림과 같이 좌표 (1, 1) 위치에서 가로방향으로 놓여있는 상태로 시작하며, 앞뒤 구분없이 움직일 수 있습니다.

로봇이 움직일 때는 현재 놓여있는 상태를 유지하면서 이동합니다.

예를 들어, 위 그림에서 오른쪽으로 한 칸 이동한다면 (1, 2), (1, 3) 두 칸을 차지하게 되며,

아래로 이동한다면 (2, 1), (2, 2) 두 칸을 차지하게 됩니다.

로봇이 차지하는 두 칸 중 어느 한 칸이라도 (N, N) 위치에 도착하면 됩니다.

로봇은 다음과 같이 조건에 따라 회전이 가능합니다.

위 그림과 같이 로봇은 90도씩 회전할 수 있습니다.

단, 로봇이 차지하는 두 칸 중, 어느 칸이든 축이 될 수 있지만,

회전하는 방향(축이 되는 칸으로부터 대각선 방향에 있는 칸)에는 벽이 없어야 합니다.

로봇이 한 칸 이동하거나 90도 회전하는 데는 걸리는 시간은 정확히 1초 입니다.

“0”과 “1”로 이루어진 지도인 board가 주어질 때,

로봇이 (N, N) 위치까지 이동하는데 필요한 최소 시간을 return 하도록 solution 함수를 완성해주세요.

제한사항

board의 한 변의 길이는 5 이상 100 이하입니다.

board의 원소는 0 또는 1입니다.

로봇이 처음에 놓여 있는 칸 (1, 1), (1, 2)는 항상 0으로 주어집니다.

로봇이 항상 목적지에 도착할 수 있는 경우만 입력으로 주어집니다.

입출력 예

입출력 예에 대한 설명

문제에 주어진 예시와 같습니다.

로봇이 오른쪽으로 한 칸 이동 후, (1, 3) 칸을 축으로 반시계 방향으로 90도 회전합니다.

다시, 아래쪽으로 3칸 이동하면 로봇은 (4, 3), (5, 3) 두 칸을 차지하게 됩니다.

이제 (5, 3)을 축으로 시계 방향으로 90도 회전 후, 오른쪽으로 한 칸 이동하면 (N, N)에 도착합니다.

따라서 목적지에 도달하기까지 최소 7초가 걸립니다.

통과된 코드

#include <string>
#include <vector>
#include <queue>
#include <tuple>

using namespace std;

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

bool _MapArr[101][101][2];

// 로봇의 위치 및 현재 시간
tuple<int, int, int, int, int> _RobotPos;
// bfs 탐색을 위한 q
queue<tuple<int, int, int, int, int>> _RobotPosQ;

int solution(vector<vector<int>> board) {
    int answer = 0;
    int _MapMax = board.size();
    pair<int, int> _goal = make_pair(_MapMax - 1, _MapMax - 1); // 목표를 설정

    _RobotPos = make_tuple(0, 0, 0, 1, 0); // 로봇의 위치 초기값
    _RobotPosQ.push(_RobotPos); // 로봇의 시작를 큐에 넣기
    _MapArr[0][0][0] = true; // 방문 마킹
    _MapArr[0][1][0] = true;
    // board 는 0,0 에서 시작
    // 마킹은 1,1에서 시작


    // bfs 탐색 시작
    while (_RobotPosQ.size() > 0) {
        _RobotPos = _RobotPosQ.front();
        _RobotPosQ.pop();
        pair<int, int> _CntPosOne = make_pair(get<0>(_RobotPos), get<1>(_RobotPos)); // 로봇의 현재 x, y 위치 1
        pair<int, int> _CntPosTwo = make_pair(get<2>(_RobotPos), get<3>(_RobotPos)); // 로봇의 현재 x, y 위치 2
        int _cnttime = get<4>(_RobotPos);
        if (_CntPosOne == _goal || _CntPosTwo == _goal) {
            answer = _cnttime;
            break;
        }
        bool _robotstatus; // true 세로, false 가로
        // 상 하 좌 우를 탐색
        for (int i = 0; i < 4; i++) {

            pair<int, int> _TempPosOne, _TempPosTwo;
            _TempPosOne.first = _CntPosOne.first + dxdy[i][0];
            _TempPosOne.second = _CntPosOne.second + dxdy[i][1];
            _TempPosTwo.first = _CntPosTwo.first + dxdy[i][0];
            _TempPosTwo.second = _CntPosTwo.second + dxdy[i][1];

            // 가로 세로 비교
            if (_CntPosOne.first + 1 == _CntPosTwo.first || _CntPosOne.first - 1 == _CntPosTwo.first) _robotstatus = true; // 세로
            else _robotstatus = false;

            // 벽이라면 넘어간다.
            if (_TempPosOne.first < 0 || _TempPosOne.first >= _MapMax || _TempPosOne.second < 0 || _TempPosOne.second >= _MapMax) continue;
            if (_TempPosTwo.first < 0 || _TempPosTwo.first >= _MapMax || _TempPosTwo.second < 0 || _TempPosTwo.second >= _MapMax) continue;
            if (board[_TempPosOne.first][_TempPosOne.second] == 1 || board[_TempPosTwo.first][_TempPosTwo.second] == 1) continue;

            // 두 부분이 방문한 적이 있다면 넘어간다.
            if (_MapArr[_TempPosOne.first][_TempPosOne.second][_robotstatus] == true && _MapArr[_TempPosTwo.first][_TempPosTwo.second][_robotstatus] == true) continue;

            _RobotPos = make_tuple(_TempPosOne.first, _TempPosOne.second, _TempPosTwo.first, _TempPosTwo.second, _cnttime + 1);
            _RobotPosQ.push(_RobotPos); // 로봇의 시작를 큐에 넣기
            _MapArr[_TempPosOne.first][_TempPosOne.second][_robotstatus] = true; // 방문 마킹
            _MapArr[_TempPosTwo.first][_TempPosTwo.second][_robotstatus] = true;

        }

        // 방향 전환
        if (!_robotstatus) { // 가로
            if (_CntPosOne.first + 1 < _MapMax && board[_CntPosOne.first + 1][_CntPosOne.second] != 1 && board[_CntPosTwo.first + 1][_CntPosTwo.second] != 1) {
                if (_MapArr[_CntPosTwo.first + 1][_CntPosTwo.second][!_robotstatus] == false) {
                    _RobotPos = make_tuple(_CntPosTwo.first + 1, _CntPosTwo.second, _CntPosTwo.first, _CntPosTwo.second, _cnttime + 1);
                    _MapArr[_CntPosTwo.first + 1][_CntPosTwo.second][!_robotstatus] = true;
                    _MapArr[_CntPosTwo.first][_CntPosTwo.second][!_robotstatus] = true;
                    _RobotPosQ.push(_RobotPos);
                }
            }
            if (_CntPosOne.first - 1 >= 0 && board[_CntPosOne.first - 1][_CntPosOne.second] != 1 && board[_CntPosTwo.first - 1][_CntPosTwo.second] != 1) {
                if (_MapArr[_CntPosTwo.first - 1][_CntPosTwo.second][!_robotstatus] == false) {
                    _RobotPos = make_tuple(_CntPosTwo.first - 1, _CntPosTwo.second, _CntPosTwo.first, _CntPosTwo.second, _cnttime + 1);
                    _MapArr[_CntPosTwo.first - 1][_CntPosTwo.second][!_robotstatus] = true;
                    _MapArr[_CntPosTwo.first][_CntPosTwo.second][!_robotstatus] = true;
                    _RobotPosQ.push(_RobotPos);
                }
            }
            if (_CntPosTwo.first + 1 < _MapMax && board[_CntPosTwo.first + 1][_CntPosTwo.second] != 1 && board[_CntPosOne.first + 1][_CntPosOne.second] != 1) {
                if (_MapArr[_CntPosOne.first + 1][_CntPosOne.second][!_robotstatus] == false) {
                    _RobotPos = make_tuple(_CntPosOne.first + 1, _CntPosOne.second, _CntPosOne.first, _CntPosOne.second, _cnttime + 1);
                    _MapArr[_CntPosOne.first + 1][_CntPosOne.second][!_robotstatus] = true;
                    _MapArr[_CntPosOne.first][_CntPosOne.second][!_robotstatus] = true;
                    _RobotPosQ.push(_RobotPos);
                }
            }
            if (_CntPosTwo.first - 1 >= 0 && board[_CntPosTwo.first - 1][_CntPosTwo.second] != 1 && board[_CntPosOne.first - 1][_CntPosOne.second] != 1) {
                if (_MapArr[_CntPosOne.first - 1][_CntPosOne.second][!_robotstatus] == false) {
                    _RobotPos = make_tuple(_CntPosOne.first - 1, _CntPosOne.second, _CntPosOne.first, _CntPosOne.second, _cnttime + 1);
                    _MapArr[_CntPosOne.first - 1][_CntPosOne.second][!_robotstatus] = true;
                    _MapArr[_CntPosOne.first][_CntPosOne.second][!_robotstatus] = true;
                    _RobotPosQ.push(_RobotPos);
                }
            }
        }
        else {
            if (_CntPosOne.second + 1 < _MapMax && board[_CntPosOne.first][_CntPosOne.second + 1] != 1 && board[_CntPosTwo.first][_CntPosTwo.second + 1] != 1) {
                if (_MapArr[_CntPosTwo.first][_CntPosTwo.second + 1][!_robotstatus] == false) {
                    _RobotPos = make_tuple(_CntPosTwo.first, _CntPosTwo.second + 1, _CntPosTwo.first, _CntPosTwo.second, _cnttime + 1);
                    _MapArr[_CntPosTwo.first][_CntPosTwo.second + 1][!_robotstatus] = true;
                    _MapArr[_CntPosTwo.first][_CntPosTwo.second][!_robotstatus] = true;
                    _RobotPosQ.push(_RobotPos);
                }
            }
            if (_CntPosOne.second - 1 >= 0 && board[_CntPosOne.first][_CntPosOne.second - 1] != 1 && board[_CntPosTwo.first][_CntPosTwo.second - 1] != 1) {
                if (_MapArr[_CntPosTwo.first][_CntPosTwo.second - 1][!_robotstatus] == false) {
                    _RobotPos = make_tuple(_CntPosTwo.first, _CntPosTwo.second - 1, _CntPosTwo.first, _CntPosTwo.second, _cnttime + 1);
                    _MapArr[_CntPosTwo.first][_CntPosTwo.second - 1][!_robotstatus] = true;
                    _MapArr[_CntPosTwo.first][_CntPosTwo.second][!_robotstatus] = true;
                    _RobotPosQ.push(_RobotPos);
                }
            }
            if (_CntPosTwo.second + 1 < _MapMax && board[_CntPosTwo.first][_CntPosTwo.second + 1] != 1 && board[_CntPosOne.first][_CntPosOne.second + 1] != 1) {
                if (_MapArr[_CntPosOne.first][_CntPosOne.second + 1][!_robotstatus] == false) {
                    _RobotPos = make_tuple(_CntPosOne.first, _CntPosOne.second + 1, _CntPosOne.first, _CntPosOne.second, _cnttime + 1);
                    _MapArr[_CntPosOne.first][_CntPosOne.second + 1][!_robotstatus] = true;
                    _MapArr[_CntPosOne.first][_CntPosOne.second][!_robotstatus] = true;
                    _RobotPosQ.push(_RobotPos);
                }
            }
            if (_CntPosTwo.second - 1 >= 0 && board[_CntPosTwo.first][_CntPosTwo.second - 1] != 1 && board[_CntPosOne.first][_CntPosOne.second - 1] != 1) {
                if (_MapArr[_CntPosOne.first][_CntPosOne.second - 1][!_robotstatus] == false) {
                    _RobotPos = make_tuple(_CntPosOne.first, _CntPosOne.second - 1, _CntPosOne.first, _CntPosOne.second, _cnttime + 1);
                    _MapArr[_CntPosOne.first][_CntPosOne.second - 1][!_robotstatus] = true;
                    _MapArr[_CntPosOne.first][_CntPosOne.second][!_robotstatus] = true;
                    _RobotPosQ.push(_RobotPos);
                }
            }

        }

    }

    return answer;
}

The post Programmers 60063 블록 이동하기 [2020 KAKAO BLIND RECRUITMENT] appeared first on 어제와 내일의 나 그 사이의 이야기.

테트로미노

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

문제

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

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

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

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

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

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

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

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

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

입력

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

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

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

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

출력

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

예제 입력 1

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

예제 출력 1

19

예제 입력 2

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

예제 출력 2

20

예제 입력 3

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

예제 출력 3

7

출처

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

알고리즘 분류

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

DFS 탐색

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

통과된 코드

#include <iostream>

using namespace std;

constexpr int MAX = 500;

int map[MAX][MAX];

bool checkMap[MAX][MAX];

int N, M, result = 0;

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

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

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

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

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

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

	}
}

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

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

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

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

}


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

	cin >> N >> M;

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

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

	cout << result;

	return 0;
}

추가 반례

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

예제 입력 A

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

예제 출력 A

33

예제 입력 B

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

예제 출력 B

2004

예제 입력 C

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

예제 출력 C

10

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

Four Squares 4

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

문제

라그랑주는 1770년에 모든 자연수는 넷 혹은 그 이하의 제곱수의 합으로 표현할 수 있다고 증명하였다.

어떤 자연수는 복수의 방법으로 표현된다.

예를 들면, 26은 5²과 1²의 합이다; 또한 4² + 3² + 1²으로 표현할 수도 있다.

역사적으로 암산의 명수들에게 공통적으로 주어지는 문제가

바로 자연수를 넷 혹은 그 이하의 제곱수 합으로 나타내라는 것이었다.

1900년대 초반에 한 암산가가 15663 = 125² + 6² + 1² + 1²라는 해를 구하는데 8초가 걸렸다는 보고가 있다.

좀 더 어려운 문제에 대해서는 56초가 걸렸다: 11339 = 105² + 15² + 8² + 5².

자연수 n이 주어질 때, n을 최소 개수의 제곱수 합으로 표현하는 컴퓨터 프로그램을 작성하시오.

입력

입력은 표준입력을 사용한다. 입력은 자연수 n을 포함하는 한 줄로 구성된다.

여기서, 1 ≤ n ≤ 50,000이다.

출력

출력은 표준출력을 사용한다.

합이 n과 같게 되는 제곱수들의 최소 개수를 한 줄에 출력한다.

예제 입력 1

25

예제 출력 1

1

예제 입력 2

26

예제 출력 2

2

예제 입력 3

11339

예제 출력 3

3

예제 입력 4

34567

예제 출력 4

4

출처

ICPC > Regionals > Asia Pacific > Korea > Nationwide Internet Competition > Seoul Nationalwide Internet Competition 2019 H번

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

알고리즘 분류

• 다이나믹 프로그래밍
• 브루트포스 알고리즘

통과된 코드

#include <iostream>

using namespace std;

int N;

int dp[50001];

int main()
{
	cin >> N;

	dp[1] = 1;

	for (int i = 2; i <= N; i++) {
		int minN = INT32_MAX;
		for (int j = 1; j * j <= i; j++) { // 모든 경우의 수를 확인
			int tmp = i - j * j;
			minN = min(minN, dp[tmp]);
		}
		dp[i] = minN + 1;
	}

	cout << dp[N];

	return 0;
}

The post 백준 17626번 (Four Squares 4, C++, DP) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

리모컨

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

문제

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

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

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

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

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

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

입력

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

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

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

출력

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

예제 입력 1

5457
3
6 7 8

예제 출력 1

6

예제 입력 2

100
5
0 1 2 3 4

예제 출력 2

0

예제 입력 3

500000
8
0 2 3 4 6 7 8 9

예제 출력 3

11117

예제 입력 4

100
3
1 0 5

예제 출력 4

0

예제 입력 5

14124
0

예제 출력 5

5

예제 입력 6

1
9
1 2 3 4 5 6 7 8 9

예제 출력 6

2

예제 입력 7

80000
2
8 9

예제 출력 7

2228

예제 입력 A

0
9
1 2 3 4 5 6 7 8 9

예제 출력 A

1

예제 입력 B

140200
3
4 5 6

예제 출력 B

207

예제 입력 C

1555
3
0 1 9

예제 출력 C

670

예제 입력 D

99999
9
0 2 3 4 5 6 7 8 9

예제 출력 D

11118

예제 입력 E

50000
9
0 1 2 3 4 5 6 7 8

예제 출력 E

40005

예제 입력 F

139133
7
9 6 8 2 1 5 7

예제 출력 F

94694

예제 입력 G

0
0

예제 출력 G

1

힌트

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

출처

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

알고리즘 분류

• 브루트포스 알고리즘

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

통과된 코드

#include <iostream>
#include <cmath>

using namespace std;

bool arr[10];

string str, strTemp;

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

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

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

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

	target = atoi(str.c_str());

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

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

	cout << result;

	return 0;
}

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

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

영화감독 숌

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

문제

666은 종말을 나타내는 숫자라고 한다.

따라서, 많은 블록버스터 영화에서는 666이 들어간 제목을 많이 사용한다.

영화감독 숌은 세상의 종말 이라는 시리즈 영화의 감독이다.

조지 루카스는 스타워즈를 만들 때, 스타워즈 1, 스타워즈 2, 스타워즈 3, 스타워즈 4, 스타워즈 5, 스타워즈 6과 같이 이름을 지었고,

피터 잭슨은 반지의 제왕을 만들 때, 반지의 제왕 1, 반지의 제왕 2, 반지의 제왕 3과 같이 영화 제목을 지었다.

하지만 숌은 자신이 조지 루카스와 피터 잭슨을 뛰어넘는다는 것을 보여주기 위해서 영화 제목을 좀 다르게 만들기로 했다.

종말의 숫자란 어떤 수에 6이 적어도 3개이상 연속으로 들어가는 수를 말한다.

제일 작은 종말의 숫자는 666이고, 그 다음으로 큰 수는 1666, 2666, 3666, …. 과 같다.

따라서, 숌은 첫 번째 영화의 제목은 세상의 종말 666, 두 번째 영화의 제목은 세상의 종말 1666 이렇게 이름을 지을 것이다.

일반화해서 생각하면, N번째 영화의 제목은 세상의 종말 (N번째로 작은 종말의 숫자) 와 같다.

숌이 만든 N번째 영화의 제목에 들어간 숫자를 출력하는 프로그램을 작성하시오.

숌은 이 시리즈를 항상 차례대로 만들고, 다른 영화는 만들지 않는다.

입력

첫째 줄에 숫자 N이 주어진다.

N은 10,000보다 작거나 같은 자연수이다.

출력

첫째 줄에 N번째 영화의 제목에 들어간 수를 출력한다.

예제 입력 1

2

예제 출력 1

1666

예제 입력 2

3

예제 출력 2

2666

예제 입력 3

6

예제 출력 3

5666

예제 입력 4

187

예제 출력 4

66666

예제 입력 5

500

예제 출력 5

166699

출처

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

알고리즘 분류

• 브루트포스 알고리즘

통과된 코드

#include <iostream>

using namespace std;

int N, cnt, number, tempNumber;

string str;

int main()
{
	cin >> N;
	cnt = 0;
	number = 665;
	tempNumber = 0;

	// N번째가 나올 떄까지 반복
	while (cnt != N) {
		number++;
		tempNumber = number;

		while (tempNumber != 0)
		{
			if (tempNumber % 1000 == 666) {
				cnt++;
				break;
			}
			else tempNumber /= 10;
		}
	}

	cout << number;

	return 0;
}

The post 백준 1436번 (영화감독 숌, C++, brute force) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

덩치

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

문제

우리는 사람의 덩치를 키와 몸무게, 이 두 개의 값으로 표현하여 그 등수를 매겨보려고 한다.

어떤 사람의 몸무게가 x kg이고 키가 y cm라면 이 사람의 덩치는 (x, y)로 표시된다.

두 사람 A 와 B의 덩치가 각각 (x, y), (p, q)라고 할 때 x > p 그리고 y > q 이라면

우리는 A의 덩치가 B의 덩치보다 “더 크다”고 말한다.

예를 들어 어떤 A, B 두 사람의 덩치가 각각 (56, 177), (45, 165) 라고 한다면 A의 덩치가 B보다 큰 셈이 된다.

그런데 서로 다른 덩치끼리 크기를 정할 수 없는 경우도 있다.

예를 들어 두 사람 C와 D의 덩치가 각각 (45, 181), (55, 173)이라면 몸무게는 D가 C보다 더 무겁고,

키는 C가 더 크므로, “덩치”로만 볼 때 C와 D는 누구도 상대방보다 더 크다고 말할 수 없다.

N명의 집단에서 각 사람의 덩치 등수는 자신보다 더 “큰 덩치”의 사람의 수로 정해진다.

만일 자신보다 더 큰 덩치의 사람이 k명이라면 그 사람의 덩치 등수는 k+1이 된다.

이렇게 등수를 결정하면 같은 덩치 등수를 가진 사람은 여러 명도 가능하다.

아래는 5명으로 이루어진 집단에서 각 사람의 덩치와 그 등수가 표시된 표이다.

위 표에서 C보다 더 큰 덩치의 사람이 없으므로 C는 1등이 된다.

그리고 A, B, D 각각의 덩치보다 큰 사람은 C뿐이므로 이들은 모두 2등이 된다.

그리고 E보다 큰 덩치는 A, B, C, D 이렇게 4명이므로 E의 덩치는 5등이 된다.

위 경우에 3등과 4등은 존재하지 않는다.

여러분은 학생 N명의 몸무게와 키가 담긴 입력을 읽어서 각 사람의 덩치 등수를 계산하여 출력해야 한다.

입력

첫 줄에는 전체 사람의 수 N이 주어진다.

그리고 이어지는 N개의 줄에는 각 사람의 몸무게와 키를 나타내는 양의 정수 x와 y가 하나의 공백을 두고 각각 나타난다.

출력

여러분은 입력에 나열된 사람의 덩치 등수를 구해서 그 순서대로 첫 줄에 출력해야 한다.

단, 각 덩치 등수는 공백 문자로 분리되어야 한다.

제한

• 2 ≤ N ≤ 50
• 10 ≤ x, y ≤ 200

예제 입력 1

5
55 185
58 183
88 186
60 175
46 155

예제 출력 1

2 2 1 2 5

출처

Olympiad > 한국정보올림피아드 > 한국정보올림피아드시․도지역본선 > 지역본선 2013 > 초등부 2번

• 문제의 오타를 찾은 사람: apjw6112, eric00513, genius0412, jung2381187, seecimi
• 데이터를 추가한 사람: rea9lizer

알고리즘 분류

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

사람의 수는 N 이므로 비교할 수 있는 모든 경우를 비교하여 등수를 매겼다.

통과된 코드

#include <iostream>

using namespace std;

int weight[51], height[51], ranks[51];

int N, temp;

int main()
{
	cin >> N;
	for (int i = 1; i <= N; i++) {
		cin >> weight[i] >> height[i];
	}

	for (int i = 1; i <= N; i++) {

		// 순위는 N등 부터 시작
		temp = N;

		for (int j = 1; j <= N ; j++) {
			
			// 자기 자신과 비교할 경우에는 넘어간다.
			if (i == j) { continue; }

			// 비교 기준의 무게가 더 크거나 같을 경우 rank 상승
			// 비교 기준의 키가 더 크거나 같을 경우 rank 상승
			if (weight[i] >= weight[j]) temp--;
			else if (height[i] >= height[j]) temp--;
		}

		ranks[i] = temp;
	}

	for (int i = 1; i <= N; i++) {
		cout << ranks[i] << " ";
	}

	return 0;
}

키나 몸무게가 같을 경우에도 등수에 영향을 미친다는 것을 제출하고 확인

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

나누기

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

문제

두 정수 N과 F가 주어진다.

지민이는 정수 N의 가장 뒤 두 자리를 적절히 바꿔서 N을 F로 나누어 떨어지게 만들려고 한다.

만약 가능한 것이 여러 가지이면, 뒤 두 자리를 가능하면 작게 만들려고 한다.

예를 들어, N=275이고, F=5이면, 답은 00이다. 200이 5로 나누어 떨어지기 때문이다. 

N=1021이고, F=11이면, 정답은 01인데, 1001이 11로 나누어 떨어지기 때문이다.

입력

첫째 줄에 N, 둘째 줄에 F가 주어진다.

N은 100보다 크거나 같고, 2,000,000,000보다 작거나 같은 자연수이다.

F는 100보다 작거나 같은 자연수이다.

출력

첫째 줄에 마지막 두 자리를 모두 출력한다.

한자리이면 앞에 0을 추가해서 두 자리로 만들어야 한다.

예제 입력 1

1000
3

예제 출력 1

02

예제 입력 2

2000000000
100

예제 출력 2

00

예제 입력 3

23442
75

예제 출력 3

00

예제 입력 4

428392
17

예제 출력 4

15

예제 입력 5

32442
99

예제 출력 5

72

출처

• 문제를 번역한 사람: baekjoon
• 문제의 오타를 찾은 사람: eric00513
• 잘못된 조건을 찾은 사람: myju742

알고리즘 분류

• 수학
• 브루트포스 알고리즘

통과된 코드

부루트포스 알고리즘을 이용하여 00 부터 99 까지 모든 경우의 수를 확인한다.

#include <iostream>
#include <string>

using namespace std;

int main()
{
	int N, F, result;
	cin >> N >> F;

	result = INT32_MAX;
	for (int i = 99; i >= 0; i--) {
		if ((((N / 100) * 100) + i) % F == 0) result = i;
	}
	string str;
	str = to_string(result);
	if (str.length() == 1) str.insert(0, "0");
	cout << str;

	return 0;
}

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