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

문제

강호네 회사에는 직원이 N명이 있고, 해야할 일이 M개가 있다.

직원은 1번부터 N번까지 번호가 매겨져 있고, 일은 1번부터 M번까지 번호가 매겨져 있다.

각 직원은 자신이 할 수 있는 일들 중 한 개의 일만 담당할 수 있고, 각각의 일을 담당하는 사람은 1명이어야 한다.

각각의 직원이 할 수 있는 일의 목록이 주어졌을 때, M개의 일 중에서 최대 몇 개를 할 수 있는지 구하는 프로그램을 작성하시오.

입력

첫째 줄에 직원의 수 N과 일의 개수 M이 주어진다. (1 ≤ N, M ≤ 1,000)

둘째 줄부터 N개의 줄의 i번째 줄에는 i번 직원이 할 수 있는 일의 개수와 할 수 있는 일의 번호가 주어진다.

출력

첫째 줄에 강호네 회사에서 할 수 있는 일의 개수를 출력한다.

예제 입력 1

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

예제 출력 1

4

출처

• 문제를 만든 사람: baekjoon
• 어색한 표현을 찾은 사람: doju
• 데이터를 추가한 사람: rubix, woojw911

알고리즘 분류

• 이분 매칭

통과된 코드

#include <iostream>
#include <vector>
#include <cstring>

using namespace std;

int N, M;
vector<int> employee[1001];
int works[1001];       
bool visited[1001];      

bool DFS(int n) 
{

    for (int work : employee[n]) 
    {
        if (visited[work]) 
            continue;

        visited[work] = true;

        if (works[work] == 0 || DFS(works[work])) 
        {
            works[work] = n;
            return true;
        }
    }

    return false;
}

int main() 
{

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

    cin >> N >> M;

    for (int i = 1; i <= N; i++) 
    {
        int k, work;
        cin >> k;

        for (int j = 0; j < k; j++) 
        {
            cin >> work;
            employee[i].push_back(work);
        }
    }

    int result = 0;

    for (int i = 1; i <= N; i++) 
    {
        memset(visited, false, sizeof(visited));

        if (DFS(i)) 
            result++;
    }

    cout << result << "\n";

    return 0;
}

해당 문제와 코드가 같은 문제

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

The post 백준 11375번 (열혈강호, C++) appeared first on 어제와 내일의 나 그 사이의 이야기.

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

문제

농부 존은 소 축사를 완성하였다. 축사 환경을 쾌적하게 유지하기 위해서, 존은 축사를 M개의 칸으로 구분하고, 한 칸에는 최대 한 마리의 소만 들어가게 계획했다.

첫 주에는 소를 임의 배정해서 축사를 운영했으나, 곧 문제가 발생하게 되었다. 바로 소가 자신이 희망하는 몇 개의 축사 외에는 들어가기를 거부하는 것이다.

농부 존을 도와 최대한 많은 수의 소가 축사에 들어갈 수 있도록 하는 프로그램을 작성하시오.

축사의 번호는 1부터 M까지 매겨져 있다.

입력

첫째 줄에 소의 수 N과 축사의 수 M이 주어진다. (1 ≤ N, M ≤ 200)

둘째 줄부터 N개의 줄에는 각 소가 들어가기 원하는 축사에 대한 정보가 주어진다.

i번째 소가 들어가기 원하는 축사의 수 S_i (0 ≤ S_i ≤ M)이 먼저 주어지고, 이후 S_i개의 축사 번호가 주어진다.

같은 축사 번호가 두 번 이상 주어지는 경우는 없다.

출력

첫째 줄에 축사에 들어갈 수 있는 소의 최댓값을 출력한다.

예제 입력 1

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

예제 출력 1

4

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

예제 입력 A

4 3
1 1
1 2
1 3
1 3

예제 출력 A

3

예제 입력 B

4 3
0
0
0
0

예제 출력 B

0

예제 입력 C

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

예제 출력 C

2

예제 입력 D

50 40
2 24 21
1 39
4 30 31 15 18
2 21 3
4 21 40 39 30
1 20
5 20 30 4 29 25
3 39 9 33
1 32
5 27 22 36 2 11
1 9
5 35 29 14 38 1
3 28 22 1
4 18 20 29 22
3 5 11 38
2 36 30
5 9 17 35 10 19
3 18 31 7
3 4 36 30
4 24 12 9 14
3 28 2 27
3 13 6 2
3 6 37 39
4 5 26 15 16
3 25 6 36
2 9 31
3 17 6 7
5 27 4 13 29 30
1 1
1 12
5 3 1 38 8 5
2 14 12
3 17 39 12
3 30 15 26
2 21 3
3 7 6 11
2 28 13
2 25 16
2 19 16
1 13
5 39 24 34 29 33
2 40 10
3 6 35 40
1 37
2 24 35
4 11 22 3 29
3 19 7 16
1 14
1 38
5 31 14 28 19 6

예제 출력 D

39

출처

• 데이터를 추가한 사람: djm03178, rubix
• 문제의 오타를 찾은 사람: hun3555

알고리즘 분류

• 이분 매칭

통과된 코드

#include <iostream>
#include <vector>
#include <cstring>

using namespace std;

int N, M;
vector<int> cowInfo[201]; // 각 소가 원하는 축사 리스트
int barnMatch[201];       // barnMatch[b] = 소 번호 (b번 축사에 배정된 소)
bool visited[201];        // DFS 방문 체크

// 축사 매칭 시도
bool DFS(int cow) 
{

    for (int barn : cowInfo[cow]) 
    {
        if (visited[barn]) 
            continue;

        visited[barn] = true;

        // 이 축사가 비었거나, 이미 배정된 소가 다른 축사로 갈 수 있다면
        if (barnMatch[barn] == 0 || DFS(barnMatch[barn])) 
        {
            barnMatch[barn] = cow;
            return true;
        }
    }

    return false;
}

int main() 
{

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

    cin >> N >> M;

    for (int i = 1; i <= N; i++) 
    {
        int k, barn;
        cin >> k;

        for (int j = 0; j < k; j++) 
        {
            cin >> barn;
            cowInfo[i].push_back(barn);
        }
    }

    int result = 0;

    for (int i = 1; i <= N; i++) 
    {
        memset(visited, false, sizeof(visited));

        if (DFS(i)) 
            result++;
    }

    cout << result << "\n";

    return 0;
}

백준에 해당 문제와 코드가 같은 문제

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

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

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

문제

수식은 일반적으로 3가지 표기법으로 표현할 수 있다.

연산자가 피연산자 가운데 위치하는 중위 표기법(일반적으로 우리가 쓰는 방법이다),

연산자가 피연산자 앞에 위치하는 전위 표기법(prefix notation), 연산자가 피연산자 뒤에 위치하는 후위 표기법(postfix notation)이 그것이다.

예를 들어 중위 표기법으로 표현된 a+b는 전위 표기법으로는 +ab이고, 후위 표기법으로는 ab+가 된다.

이 문제에서 우리가 다룰 표기법은 후위 표기법이다.

후위 표기법은 위에서 말한 법과 같이 연산자가 피연산자 뒤에 위치하는 방법이다. 이 방법의 장점은 다음과 같다.

우리가 흔히 쓰는 중위 표기식 같은 경우에는 덧셈과 곱셈의 우선순위에 차이가 있어 왼쪽부터 차례로 계산할 수 없지만 후위 표기식을 사용하면 순서를 적절히 조절하여 순서를 정해줄 수 있다.

또한 같은 방법으로 괄호 등도 필요 없게 된다. 예를 들어 a+b*c를 후위 표기식으로 바꾸면 abc*+가 된다.

중위 표기식을 후위 표기식으로 바꾸는 방법을 간단히 설명하면 이렇다. 우선 주어진 중위 표기식을 연산자의 우선순위에 따라 괄호로 묶어준다.

그런 다음에 괄호 안의 연산자를 괄호의 오른쪽으로 옮겨주면 된다. 예를 들어 a+b*c는 (a+(b*c))의 식과 같게 된다.

그 다음에 안에 있는 괄호의 연산자 *를 괄호 밖으로 꺼내게 되면 (a+bc*)가 된다. 마지막으로 또 +를 괄호의 오른쪽으로 고치면 abc*+가 되게 된다.

다른 예를 들어 그림으로 표현하면 A+B*C-D/E를 완전하게 괄호로 묶고 연산자를 이동시킬 장소를 표시하면 다음과 같이 된다.

이러한 사실을 알고 중위 표기식이 주어졌을 때 후위 표기식으로 고치는 프로그램을 작성하시오

입력

첫째 줄에 중위 표기식이 주어진다. 단 이 수식의 피연산자는 알파벳 대문자로 이루어지며 수식에서 한 번씩만 등장한다.

그리고 -A+B와 같이 -가 가장 앞에 오거나 AB와 같이 *가 생략되는 등의 수식은 주어지지 않는다.

표기식은 알파벳 대문자와 +, -, *, /, (, )로만 이루어져 있으며, 길이는 100을 넘지 않는다. 

출력

첫째 줄에 후위 표기식으로 바뀐 식을 출력하시오

예제 입력 1

A*(B+C)

예제 출력 1

ABC+*

예제 입력 2

A+B

예제 출력 2

AB+

예제 입력 3

A+B*C

예제 출력 3

ABC*+

예제 입력 4

A+B*C-D/E

예제 출력 4

ABC*+DE/-

출처

• 잘못된 데이터를 찾은 사람: djm03178
• 데이터를 추가한 사람: fccva, gangminson
• 빠진 조건을 찾은 사람: jung2381187

알고리즘 분류

• 자료 구조
• 스택

예제 입력 A

((A+B)*C-(D-E))*(F+G)

예제 출력 A

AB+C*DE--FG+*

예제 입력 B

A/B*(C+(D-E))

예제 출력 B

AB/CDE--+*

예제 입력 C

B+Y*Z*C+A

예제 출력 C

BYZ*C*+A+

예제 입력 D

A+(B*C-(D/E^F)*G)+H

예제 출력 D

ABC*DEF/G*-+H+

추가적인 반례 (백준 게시판)

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

통과된 코드

#include <iostream>
#include <string>
#include <stack>

using namespace std;

string Input, Res;
stack<char> OperStack;

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

    cin >> Input;

    for (int i = 0; i < Input.length(); i++)
    {
        // 문자가 피연산자(A-Z)인 경우 바로 출력
        if (Input[i] >= 'A' && Input[i] <= 'Z')
        {
            cout << Input[i];
        }
        else
        {
            // 문자가 '('인 경우 스택에 푸시
            if (Input[i] == '(')
            {
                OperStack.push(Input[i]);
            }
            // 문자가 '*' 또는 '/'인 경우, 더 높은 또는 같은 우선순위의 연산자를 스택에서 Pop하고 현재 연산자를 스택에 푸시
            else if (Input[i] == '*' || Input[i] == '/')
            {
                while (!OperStack.empty() && (OperStack.top() == '*' || OperStack.top() == '/'))
                {
                    cout << OperStack.top();
                    OperStack.pop();
                }
                OperStack.push(Input[i]);
            }
            // 문자가 '+' 또는 '-'인 경우, 더 높은 또는 같은 우선순위의 연산자를 스택에서 Pop하고 현재 연산자를 스택에 푸시
            else if (Input[i] == '+' || Input[i] == '-')
            {
                while (!OperStack.empty() && OperStack.top() != '(')
                {
                    cout << OperStack.top();
                    OperStack.pop();
                }
                OperStack.push(Input[i]);
            }
            // 문자가 ')'인 경우, '('를 찾을 때까지 스택에서 연산자를 Pop
            else if (Input[i] == ')')
            {
                while (!OperStack.empty() && OperStack.top() != '(')
                {
                    cout << OperStack.top();
                    OperStack.pop();
                }
                // 스택에서 '('를 제거
                OperStack.pop();
            }
        }
    }

    // 스택에 남아있는 모든 연산자를 결과에 추가
    while (!OperStack.empty())
    {
        cout << OperStack.top();
        OperStack.pop();
    }

    cout << Res;

    return 0;
}

The post 백준 1918번 (후위 표기식, C++) / 추가 반례 [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

달리기

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

문제

진영이는 다이어트를 위해 N×M 크기의 체육관을 달리려고 한다.

체육관은 1×1 크기의 칸으로 나누어져 있고, 칸은 빈 칸 또는 벽이다. 

x행 y열에 있는 칸은 (x, y)로 나타낸다.

매 초마다 진영이는 위, 아래, 오른쪽, 왼쪽 중에서 이동할 방향을 하나 고르고,

그 방향으로 최소 1개, 최대 K개의 빈 칸을 이동한다.

시작점 (x₁, y₁)과 도착점 (x₂, y₂)가 주어졌을 때,

시작점에서 도착점으로 이동하는 최소 시간을 구해보자.

입력

첫째 줄에 체육관의 크기 N과 M, 1초에 이동할 수 있는 칸의 최대 개수 K가 주어진다.

둘째 줄부터 N개의 줄에는 체육관의 상태가 주어진다.

체육관의 각 칸은 빈 칸 또는 벽이고, 빈 칸은 ‘.’, 벽은 ‘#’으로 주어진다.

마지막 줄에는 네 정수 x₁, y₁, x₂, y₂가 주어진다.

두 칸은 서로 다른 칸이고, 항상 빈 칸이다.

출력

(x₁, y₁)에서 (x₂, y₂)로 이동하는 최소 시간을 출력한다.

이동할 수 없는 경우에는 -1을 출력한다.

제한

• 2 ≤ N, M ≤ 1,000
• 1 ≤ K ≤ 1,000
• 1 ≤ x₁, x₂ ≤ N
• 1 ≤ y₁, y₂ ≤ M

예제 입력 1

3 4 4
....
###.
....
1 1 3 1

예제 출력 1

3

예제 입력 2

3 4 1
....
###.
....
1 1 3 1

예제 출력 2

8

예제 입력 3

2 2 1
.#
#.
1 1 2 2

예제 출력 3

-1

출처

• 문제를 번역한 사람: baekjoon
• 데이터를 추가한 사람: djm03178
• 문제의 오타를 찾은 사람: doju, psi0613, seico75
• 빠진 조건을 찾은 사람: jh05013

알고리즘 분류

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

추가 반례

예제 입력 A

2 2 1
..
..

0 0 0 0

예제 출력 A

0

예제 입력 B

7 4 4
....
.##.
..#.
#.#.
#...
#.##
#.##
1 1 7 2

예제 출력 B

3

예제 입력 C

7 4 4
....
.##.
.#..
.#.#
...#
##.#
##.#
1 4 7 3

예제 출력 C

3

visited 배열에 방문하는 시점을 넣고 해결하는 경우

if (_isVisted[_dx][_dy] == _cnt)
break;

위 로직으로 진행한다면 탐색하는 방향의 순서(상, 하, 좌, 우)에 따라 답이 3 ~ 4로 달라집니다.

예제 입력 D

3 3 3
..#
..#
#..
1 1 3 3

예제 출력 D

3

통과된 코드

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

int _N, _M, _K, _Temp1, _Temp2, _Res;
int _DxDy[4][2] = { { 1, 0}, { -1, 0}, { 0, 1}, { 0, -1} };
char _Map[1000][1000];
int _isVisted[1000][1000];
string _Str;
pair<int, int> _sePos[2];
queue<pair<int, pair<int, int>>> _BFSQueue;

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

	cin >> _N >> _M >> _K;
	for (int i = 0; i < _N; i++) {
		cin >> _Str;
		for (int j = 0; j < _M; j++) 
			_Map[i][j] = _Str[j];
	}
	for (int i = 0; i < 2; i++) {
		cin >> _Temp1 >> _Temp2;
		_sePos[i] = make_pair(_Temp1 - 1, _Temp2 - 1);
	}

	for (int i = 0; i < _N; i++) 
		for (int j = 0; j < _M; j++)
			_isVisted[i][j] = INT32_MAX;
	
	_BFSQueue.push(make_pair(0, _sePos[0]));
	_isVisted[_sePos[0].first][_sePos[0].second] = 0;
	pair<int, int> _CntPos;
	int _dx, _dy, _cnt;
	while (!_BFSQueue.empty()) {
		_CntPos = _BFSQueue.front().second;
		_cnt = _BFSQueue.front().first;
		_BFSQueue.pop();
		if (_CntPos == _sePos[1]) {
			_Res = _cnt;
			break;
		}
		_cnt++;
		for (int i = 0; i < 4; i++) {
			for (int j = 1; j <= _K; j++) {
				_dx = _CntPos.first + _DxDy[i][0] * j;
				_dy = _CntPos.second + _DxDy[i][1] * j;
				if (_dx >= _N || _dy >= _M || _dx < 0 || _dy < 0 || _Map[_dx][_dy] == '#')
					break;
				if (_isVisted[_dx][_dy] < _cnt)
					break;
				if (_isVisted[_dx][_dy] == _cnt)
					continue;

				_BFSQueue.push(make_pair(_cnt, make_pair(_dx,_dy)));
				_isVisted[_dx][_dy] = _cnt;
			}
		}
	}

	if (_sePos[0] == _sePos[1]) cout << _Res;
	else if (_Res == 0) cout << -1;
	else cout << _Res;

	return 0;
}

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

택배 배달과 수거하기

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

당신은 일렬로 나열된 n개의 집에 택배를 배달하려 합니다.

배달할 물건은 모두 크기가 같은 재활용 택배 상자에 담아 배달하며, 배달을 다니면서 빈 재활용 택배 상자들을 수거하려 합니다.

배달할 택배들은 모두 재활용 택배 상자에 담겨서 물류창고에 보관되어 있고, i번째 집은 물류창고에서 거리 i만큼 떨어져 있습니다.

또한 i번째 집은 j번째 집과 거리 j - i만큼 떨어져 있습니다. (1 ≤ i ≤ j ≤ n)

트럭에는 재활용 택배 상자를 최대 cap개 실을 수 있습니다.

트럭은 배달할 재활용 택배 상자들을 실어 물류창고에서 출발해 각 집에 배달하면서, 빈 재활용 택배 상자들을 수거해 물류창고에 내립니다.

각 집마다 배달할 재활용 택배 상자의 개수와 수거할 빈 재활용 택배 상자의 개수를 알고 있을 때,

트럭 하나로 모든 배달과 수거를 마치고 물류창고까지 돌아올 수 있는 최소 이동 거리를 구하려 합니다. 

각 집에 배달 및 수거할 때, 원하는 개수만큼 택배를 배달 및 수거할 수 있습니다.

다음은 cap=4 일 때, 최소 거리로 이동하면서 5개의 집에 배달 및 수거하는 과정을 나타낸 예시입니다.

배달 및 수거할 재활용 택배 상자 개수

배달 및 수거 과정

16(=5+5+3+3)의 거리를 이동하면서 모든 배달 및 수거를 마쳤습니다.

같은 거리로 모든 배달 및 수거를 마치는 다른 방법이 있지만,

이보다 짧은 거리로 모든 배달 및 수거를 마치는 방법은 없습니다.

트럭에 실을 수 있는 재활용 택배 상자의 최대 개수를 나타내는 정수 cap, 배달할 집의 개수를 나타내는 정수 n,

각 집에 배달할 재활용 택배 상자의 개수를 담은 1차원 정수 배열 deliveries와

각 집에서 수거할 빈 재활용 택배 상자의 개수를 담은 1차원 정수 배열 pickups가 매개변수로 주어집니다.

이때, 트럭 하나로 모든 배달과 수거를 마치고 물류창고까지 돌아올 수 있는 최소 이동 거리를 return 하도록 solution 함수를 완성해 주세요.

제한사항

• 1 ≤ cap ≤ 50
• 1 ≤ n ≤ 100,000
• deliveries의 길이 = pickups의 길이 = n
  • deliveries[i]는 i+1번째 집에 배달할 재활용 택배 상자의 개수를 나타냅니다.
  • pickups[i]는 i+1번째 집에서 수거할 빈 재활용 택배 상자의 개수를 나타냅니다.
  • 0 ≤ deliveries의 원소 ≤ 50
  • 0 ≤ pickups의 원소 ≤ 50
• 트럭의 초기 위치는 물류창고입니다.

입출력 예

입출력 예 설명

입출력 예 #1

• 문제 예시와 동일합니다.

입출력 예 #2

배달 및 수거할 재활용 택배 상자 개수

배달 및 수거 과정

30(=7+7+5+5+3+3)의 거리를 이동하면서 모든 배달 및 수거를 마쳤습니다.

같은 거리로 모든 배달 및 수거를 마치는 다른 방법이 있지만, 이보다 짧은 거리로 모든 배달 및 수거를 마치는 방법은 없습니다.

따라서, 30을 return 하면 됩니다.

통과된 코드

#include <string>
#include <vector>

using namespace std;

long long solution(int cap, int n, vector<int> deliveries, vector<int> pickups) {
	long long answer = 0;
	int _delP = -1, _picP = -1;

	for (int i = deliveries.size() - 1; i >= 0; i--)
		if (deliveries[i]) {
			_delP = i;
			break;
		}
	for (int i = pickups.size() - 1; i >= 0; i--)
		if (pickups[i]) {
			_picP = i;
			break;
		}

	while (_delP >= 0 || _picP >= 0) {
		answer += (max(_delP, _picP) + 1) * 2;
		int _del = cap, _pic = cap;
		for (int i = _delP; i >= 0; i--) {
			if (_del >= deliveries[i]) _del -= deliveries[i];
			else {
				deliveries[i] -= _del;
				break;
			}
			_delP--;
		}

		for (int i = _picP; i >= 0; i--) {
			if (_pic >= pickups[i]) _pic -= pickups[i];
			else {
				pickups[i] -= _pic;
				break;
			}
			_picP--;
		}
	}
    
	return answer;
}

더 효율적인 코드

https://school.programmers.co.kr/questions/43364

#include <string>
#include <vector>

using namespace std;

long long solution(int cap, int n, vector<int> deliveries, vector<int> pickups) {
    long long answer = 0;

    int d = 0;
    int p = 0;
    // 역순으로 벡터를 탐색
    for (int i = n - 1; i >= 0; i--) {
        int cnt = 0; // 왕복 횟수 초기화
        d -= deliveries[i]; // 배달
        p -= pickups[i]; // 픽업 

        // 해당 인덱스를 몇번 반복
        while (d < 0 || p < 0) {
            d += cap;
            p += cap;
            // 해당 위치를 반복하는 횟수를 올려준다
            cnt += 1;
        }
        // (인덱스까지의 거리) * 왕복(2) * 왕복횟수
        answer += (i + 1) * 2 * cnt;
    }

    return answer;
}

출처 : https://school.programmers.co.kr/questions/43364

필자는 생각합니다.

카카오가 코테의 수준을 너무나도 높여버렸습니다.

이젠 레벨2와 레벨3의 구분이라는 것이 있는지 모르겠습니다.

난이도가 다 레벨3이 된 것 같은 기분은 저만 드는 것일까요?

cap만큼의 공간을 사용하여, 배달도 수행하고, 회수도 수행해야 합니다.

이 문제를 풀기위한 당연한 기준들을 한 번 정리해보려고 합니다.

배달할 물건이나, 회수할 물건이 i번째 까지 존재한다면, 당신은 반드시 i번째 까지는 적어도 한 번은 가야합니다.

한 번 출발하여, 물류창고로 돌아오면, cap만큼의 배달을 수행할 수 있고, cap만큼의 물건을 회수 해 올 수 있습니다.

한 곳에서 택배를 전부 배달하지 못했거나, 회수하지 못했다면, 당신은 물류창고로 돌아왔다가, 다시 같은 장소로 떠나야 합니다.

아마, 이 문제들을 심히 고민해보았다면, 3가지의 정의는 내릴 수 있어야 합니다.

그리고 2번 정의에 따라, 물건의 전달이나, 물건의 회수는 항상 최대 cap만큼 수행 할 수 있다는 사실을 알 수 있습니다.

아마, 이해가 되지 않을 수 있습니다. 전달해야 할 물건이 너무 많아서 회수가 불가능한 상황이 생길 수 있지 않느냐고 말이죠.

하지만, 그 문제는 배열을 거꾸로 탐색하면 쉽게 해결 할 수 있습니다.

1번 정의에 따라, 당신은 반드시 전달할 물건이나, 회수할 물건이 있는 장소까지는 도달해야 합니다.

거꾸로 배열을 탐색한다는 의미는, 이미 방문이 가능한 모든 지점들을 왕복했다는 가정하에 문제를 풀게 됩니다.

물류창고에서, 목적지 까지 가는데, 택배가 너무 많아 회수가 불가능 하였다면, 돌아올 때는 이미 모든 장소를 한 번씩 들렸기에,

트럭에 물건이 비어있게 됩니다. 이 때 회수하면 됩니다.

이로써 이런 정의들을 단순화 시켜보자면, 사실 물건을 전달하는 것과, 회수하는 것은 별개로 봐도 상관이 없습니다.

그리고 이 문제는 Greedy한 문제가 됩니다.

트럭이 한 번 떠나게 되면, cap만큼의 물건을 배달할 수 있고, cap만큼의 물건을 회수 할 수 있다는 사실을 이해했다면,

이 문제의 절반을 풀었다고 무방합니다.

이제 배열을 거꾸로 탐색하여, 전달 한 물건이나, 회수 할 물건이 있는지 탐색을 수행합니다.

만약 존재한다면, 해당 값을 어딘가에서 감소 시켜줍니다.

그리고, 전달 할 물건이나 회수 할 물건이 존재하였기에, cap만큼의 배달량, cap만큼의 회수량을 처리 할 수 있다고,

이 값을 증가 시켜줍니다.

만약 한 번 해당 장소에 방문 한 것으로, 커버가 되지 않는다면, 다시 방문하여, cap만큼의 배달량, 회수량을 증가 시켜줍니다.

그 대신에 answer에 추가 할 때는 반복 횟수 만큼 곱해주어야 합니다.

여기서 중요합니다.

cap만큼의 배달량, 회수량을 그대로 사용하여, 다음 값을 계산할 때 그대로 이용합니다.

deliveries[i]가 2, pickups[i]가 3 이고 cap이 3이라고 하면, pickups의 값은 1만큼의 잉여 회수량이 남게 됩니다.

배열을 거꾸로 탐색한다는 의미는, i번째까지 이미 도달하고, 다시 물류창고로 돌아간다는 왕복운동의 기준으로 고려한다는 의미입니다.

이 때 잉여량이 발생하였다면, 어차피 이전 장소에서 한 번 더 사용하면 효율성 높게 업무를 처리 할 수 있게 됩니다.

여기서 주의할 점은, deliveries[i]와 pickups[i]를 가감해도 배달량과 회수량이 남아있다고 하면,

answer에 답을 추가 할 필요가 없습니다. 잉여량이 현재 배달량과 회수량을 커버하므로, 이 경우는 답을 추가하는 실수를 저지르지 맙시다.

설명을 쓰고도 제가 무슨 소리를 하는지 모르는 상황이 되었습니다.

그래도 이 문제를 깊게 고민하였다면, 약간의 도움이 됬으리라고 생각합니다.

감사합니다.

추가 반례

The post Programmers 150369 택배 배달과 수거하기 [2023 KAKAO BLIND RECRUITMENT] appeared first on 어제와 내일의 나 그 사이의 이야기.

표 병합

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

문제 설명

당신은 표 편집 프로그램을 작성하고 있습니다.

표의 크기는 50 × 50으로 고정되어있고 초기에 모든 셀은 비어 있습니다.

각 셀은 문자열 값을 가질 수 있고, 다른 셀과 병합될 수 있습니다.

위에서 r번째, 왼쪽에서 c번째 위치를 (r, c)라고 표현할 때, 당신은 다음 명령어들에 대한 기능을 구현하려고 합니다.

1. "UPDATE r c value"
   • (r, c) 위치의 셀을 선택합니다.
   • 선택한 셀의 값을 value로 바꿉니다.
2. "UPDATE value1 value2"
   • value1을 값으로 가지고 있는 모든 셀을 선택합니다.
   • 선택한 셀의 값을 value2로 바꿉니다.
3. "MERGE r1 c1 r2 c2"
   • (r1, c1) 위치의 셀과 (r2, c2) 위치의 셀을 선택하여 병합합니다.
   • 선택한 두 위치의 셀이 같은 셀일 경우 무시합니다.
   • 선택한 두 셀은 서로 인접하지 않을 수도 있습니다. 이 경우 (r1, c1) 위치의 셀과 (r2, c2) 위치의 셀만 영향을 받으며,
     그 사이에 위치한 셀들은 영향을 받지 않습니다.
   • 두 셀 중 한 셀이 값을 가지고 있을 경우 병합된 셀은 그 값을 가지게 됩니다.
   • 두 셀 모두 값을 가지고 있을 경우 병합된 셀은 (r1, c1) 위치의 셀 값을 가지게 됩니다.
   • 이후 (r1, c1) 와 (r2, c2) 중 어느 위치를 선택하여도 병합된 셀로 접근합니다.
4. "UNMERGE r c"
   • (r, c) 위치의 셀을 선택하여 해당 셀의 모든 병합을 해제합니다.
   • 선택한 셀이 포함하고 있던 모든 셀은 프로그램 실행 초기의 상태로 돌아갑니다.
   • 병합을 해제하기 전 셀이 값을 가지고 있었을 경우 (r, c) 위치의 셀이 그 값을 가지게 됩니다.
5. "PRINT r c"
   • (r, c) 위치의 셀을 선택하여 셀의 값을 출력합니다.
   • 선택한 셀이 비어있을 경우 "EMPTY"를 출력합니다.

아래는 UPDATE 명령어를 실행하여 빈 셀에 값을 입력하는 예시입니다.

위 명령어를 실행하면 아래 그림과 같은 상태가 됩니다.

아래는 MERGE 명령어를 실행하여 셀을 병합하는 예시입니다.

위 명령어를 실행하면 아래와 같은 상태가 됩니다.

병합한 셀은 "category" 값을 가지게 되며 (1,2), (1,3), (1,4) 중 어느 위치를 선택하더라도 접근할 수 있습니다.

아래는 UPDATE 명령어를 실행하여 셀의 값을 변경하는 예시입니다.

위 명령어를 실행하면 아래와 같은 상태가 됩니다.

아래는 UNMERGE 명령어를 실행하여 셀의 병합을 해제하는 예시입니다.

위 명령어를 실행하면 아래와 같은 상태가 됩니다.

실행할 명령어들이 담긴 1차원 문자열 배열 commands가 매개변수로 주어집니다. commands의 명령어들을 순서대로 실행하였을 때, 

"PRINT r c" 명령어에 대한 실행결과를 순서대로 1차원 문자열 배열에 담아 return 하도록 solution 함수를 완성해주세요.

제한사항

• 1 ≤ commands의 길이 ≤ 1,000
• commands의 각 원소는 아래 5가지 형태 중 하나입니다.
  1. "UPDATE r c value"
     • r, c는 선택할 셀의 위치를 나타내며, 1~50 사이의 정수입니다.
     • value는 셀에 입력할 내용을 나타내며, 알파벳 소문자와 숫자로 구성된 길이 1~10 사이인 문자열입니다.
  2. "UPDATE value1 value2"
     • value1은 선택할 셀의 값, value2는 셀에 입력할 내용을 나타내며, 알파벳 소문자와 숫자로 구성된 길이 1~10 사이인 문자열입니다.
  3. "MERGE r1 c1 r2 c2"
     • r1, c1, r2, c2는 선택할 셀의 위치를 나타내며, 1~50 사이의 정수입니다.
  4. "UNMERGE r c"
     • r, c는 선택할 셀의 위치를 나타내며, 1~50 사이의 정수입니다.
  5. "PRINT r c"
     • r, c는 선택할 셀의 위치를 나타내며, 1~50 사이의 정수입니다.
• commands는 1개 이상의 "PRINT r c" 명령어를 포함하고 있습니다.

입출력 예

입출력 예 설명

입출력 예 #1

• 문제 예시와 같습니다. (1,3) 위치의 셀은 비어있고 (1,4) 위치의 셀 값은 "group"입니다.
  따라서 ["EMPTY", "group"]을 return 해야 합니다.

입출력 예 #2

• 모든 UPDATE 명령어를 실행하면 아래와 같은 상태가 됩니다.

• "MERGE 1 1 1 2" 명령어를 실행하면 아래와 같은 상태가 됩니다.

• "MERGE 2 2 2 1" 명령어를 실행하면 아래와 같은 상태가 됩니다.

• "MERGE 2 1 1 1" 명령어를 실행하면 아래와 같은 상태가 됩니다.

• "UNMERGE 2 2" 명령어를 실행하면 아래와 같은 상태가 됩니다.

통과된 코드

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

using namespace std;

string _StrArr[51][51];
string* _PtrArr[51][51];
pair<int, int> _MergeArr[51][51];
map<pair<int, int>, vector<pair<int, int>>> _MergeMap;
vector<string> _Answer;

void CommandProcessing(string& _command)
{
	istringstream iss(_command);
	string buffer;
	vector<string> res;
	while (getline(iss, buffer, ' '))
		res.push_back(buffer);

	if (res[0] == "UPDATE") {
		if (res.size() > 3) {  // "UPDATE r c value"
			pair<int, int> _MPair = _MergeArr[atoi(res[1].c_str())][atoi(res[2].c_str())];
			*_PtrArr[_MPair.first][_MPair.second] = res[3];
		}
		else {	// "UPDATE value1 value2"
			for (int i = 1; i <= 50; i++)
				for (int j = 1; j <= 50; j++) {
					if (_StrArr[i][j] == "" || _StrArr[i][j] != res[1])
						continue;
					_StrArr[i][j] = res[2];
				}
		}
	}
	else if (res[0] == "MERGE") { // "UNMERGE r c"
		// 같은 좌표일 경우 넘어간다.
		if (res[1] == res[3] && res[2] == res[4])
			return;

		pair<int, int> _MPair = _MergeArr[atoi(res[1].c_str())][atoi(res[2].c_str())];
		pair<int, int> _TPair = _MergeArr[atoi(res[3].c_str())][atoi(res[4].c_str())];

		// 같은 좌표를 가르키고 있으면 넘어간다.
		if (_MPair == _TPair) 
			return;

		auto _Main = _MergeMap.find(_MPair);
		auto _Target = _MergeMap.find(_TPair);
		if (_Main == _MergeMap.end()) {
			vector<pair<int, int>> _Temp;
			_MergeMap.insert({ _MPair, _Temp });
			_Main = _MergeMap.find(_MPair);
		}

		_Main->second.push_back(_TPair);

		if (*_PtrArr[_MPair.first][_MPair.second] == "" && *_PtrArr[_TPair.first][_TPair.second] != "") {
			*_PtrArr[_MPair.first][_MPair.second] = "";
			_PtrArr[_MPair.first][_MPair.second] = _PtrArr[_TPair.first][_TPair.second];
			for (auto& it : _Main->second)
				_PtrArr[it.first][it.second] = _PtrArr[_TPair.first][_TPair.second];
		}

		_PtrArr[_TPair.first][_TPair.second] = _PtrArr[_MPair.first][_MPair.second];
		_MergeArr[_TPair.first][_TPair.second] = _MPair;

		if (_Target != _MergeMap.end()) {
			for (auto& it : _Target->second) {
				_Main->second.push_back(it);
				_MergeArr[it.first][it.second] = _MPair;
				_PtrArr[it.first][it.second] = _PtrArr[_MPair.first][_MPair.second];
			}
			_MergeMap.erase(_Target);
		}
	}
	else if (res[0] == "UNMERGE") { // "UNMERGE r c"
		pair<int, int> _MPair = _MergeArr[atoi(res[1].c_str())][atoi(res[2].c_str())];
		string str = *_PtrArr[_MPair.first][_MPair.second];
		_MergeArr[_MPair.first][_MPair.second] = _MPair;
		_PtrArr[_MPair.first][_MPair.second] = &_StrArr[_MPair.first][_MPair.second];
		*_PtrArr[_MPair.first][_MPair.second] = "";

		auto _Main = _MergeMap.find(_MPair);
		if (_Main != _MergeMap.end()) {
			for (auto& it : _Main->second) {
				_MergeArr[it.first][it.second] = make_pair(it.first, it.second);
				_PtrArr[it.first][it.second] = &_StrArr[it.first][it.second];
				*_PtrArr[it.first][it.second] = "";
			}
			_MergeMap.erase(_Main);
		}
		_StrArr[atoi(res[1].c_str())][atoi(res[2].c_str())] = str;
	}
	else {// "PRINT r c"
		pair<int, int> _MPair = _MergeArr[atoi(res[1].c_str())][atoi(res[2].c_str())];
		string str = *_PtrArr[_MPair.first][_MPair.second];
		if (str == "") _Answer.push_back("EMPTY");
		else _Answer.push_back(str);
	}
}


vector<string> solution(vector<string> commands) {
	// 포인터 배열 초기화
	for (int i = 1; i <= 50; i++)
		for (int j = 1; j <= 50; j++) {
			_PtrArr[i][j] = &_StrArr[i][j];
			_MergeArr[i][j] = make_pair(i, j);
			_StrArr[i][j] = "";
		}

	// 명령어 처리
	for (auto& it : commands)
		CommandProcessing(it);
	
	return _Answer;
}

추가 반례

예제 입력 1

["UPDATE 1 1 menu", "MERGE 1 1 1 2", "MERGE 1 1 1 3", "MERGE 1 1 1 4", "MERGE 1 2 1 3", "UPDATE 1 1 hansik", "PRINT 1 1", "PRINT 1 2", "PRINT 1 3", "PRINT 1 4"]

예제 출력 1

["hansik", "hansik", "hansik", "hansik"]

예제 입력 2

["MERGE 1 1 2 2", "UPDATE 1 1 A", "UNMERGE 1 1", "PRINT 1 1", "PRINT 2 2"]

예제 출력 2

["A", "EMPTY"]

예제 입력 3

["UPDATE 1 1 A", "UPDATE 2 2 B", "UPDATE 3 3 C", "UPDATE 4 4 D", "MERGE 1 1 2 2", "MERGE 3 3 4 4", "MERGE 1 1 4 4", "UNMERGE 3 3", "PRINT 1 1", "PRINT 2 2", "PRINT 3 3", "PRINT 4 4"]

예제 출력 3

["EMPTY", "EMPTY", "A", "EMPTY"]

예제 입력 4

["UPDATE 1 1 1", "UPDATE 1 2 2", "UPDATE 2 1 3", "UPDATE 2 2 4", "MERGE 1 1 1 2", "MERGE 2 2 2 1", "MERGE 2 1 1 1", "PRINT 1 1", "UNMERGE 2 2", "PRINT 1 1"]

예제 출력 4

["4", "EMPTY"]

The post Programmers 150366 표 병합 [2023 KAKAO BLIND RECRUITMENT] appeared first on 어제와 내일의 나 그 사이의 이야기.

행렬 제곱

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

문제

크기가 N*N인 행렬 A가 주어진다.

이때, A의 B제곱을 구하는 프로그램을 작성하시오.

수가 매우 커질 수 있으니, A^B의 각 원소를 1,000으로 나눈 나머지를 출력한다.

입력

첫째 줄에 행렬의 크기 N과 B가 주어진다.

(2 ≤ N ≤  5, 1 ≤ B ≤ 100,000,000,000)

둘째 줄부터 N개의 줄에 행렬의 각 원소가 주어진다.

행렬의 각 원소는 1,000보다 작거나 같은 자연수 또는 0이다.

출력

첫째 줄부터 N개의 줄에 걸쳐 행렬 A를 B제곱한 결과를 출력한다.

예제 입력 1

2 5
1 2
3 4

예제 출력 1

69 558
337 406

예제 입력 2

3 3
1 2 3
4 5 6
7 8 9

예제 출력 2

468 576 684
62 305 548
656 34 412

예제 입력 3

5 10
1 0 0 0 1
1 0 0 0 1
1 0 0 0 1
1 0 0 0 1
1 0 0 0 1

예제 출력 3

512 0 0 0 512
512 0 0 0 512
512 0 0 0 512
512 0 0 0 512
512 0 0 0 512

추가 반례

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

예제 입력 A

2 1
1000 1000
1000 1000

예제 출력 A

0 0
0 0

예제 입력 B

2 100000000000
999 998
997 996

예제 출력 B

751 250
875 626

출처

• 문제를 만든 사람: baekjoon
• 데이터를 추가한 사람: doju
• 잘못된 조건을 찾은 사람: dreammusic23

알고리즘 분류

• 수학
• 분할 정복
• 분할 정복을 이용한 거듭제곱
• 선형대수학

통과된 코드

입력 받는 B 값이 int의 범위를 벗어나는 경우를 조심

행렬을 B만큼 곱하는 연산을 할 필요가 없이 효율적으로 처리

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

using namespace std;

// 새로운 데이터 유형을 정의
typedef vector<vector<unsigned long long int>> Matrix;

long long int _N, _B;
constexpr int MOD = 1000;

// 행렬 제곱 계산
Matrix MatrixMultiply(Matrix& A, Matrix& B) {

    int _Size = A.size();

    Matrix _Temp(_Size, vector<unsigned long long int>(_Size));

    for (int i = 0; i < _Size; i++) {
        for (int j = 0; j < _Size; j++) {

            unsigned long long int _Sum = 0;

            for (int k = 0; k < _Size; k++) // 모듈러 연산
                _Sum += ((A[i][k] % MOD) * (B[k][j] % MOD)) % MOD;
            _Temp[i][j] = _Sum % MOD;
        }
    }
    return _Temp;
}

// 행렬을 제곱합니다.
Matrix MatrixPow(Matrix& p_Matrix, unsigned long long int p_Cnt) {

    long long int _Size = p_Matrix.size();

    Matrix _Res(_Size, vector<unsigned long long int>(_Size));

    // 항등 행렬로 초기화 => _Res는 거듭제곱의 곱을 누적하는 데 사용
    for (int i = 0; i < _Size; i++) 
        _Res[i][i] = 1;
    
    while (p_Cnt > 0) {

        // 지수가 홀수인 경우 현재 _Res행렬과 입력 행렬을 곱하고 다시 할당
        if (p_Cnt % 2 == 1) _Res = MatrixMultiply(_Res, p_Matrix);       
        p_Matrix = MatrixMultiply(p_Matrix, p_Matrix); 
        p_Cnt /= 2;
        // p_Matrix => A
        // cnt = 4 >  A * A * A * A
        // cnt = 2 > (A * A) * (A * A)
        // cnt = 1 > ((A * A) * (A * A))
    }
    return _Res;
}

int main()
{
    cin >> _N >> _B;

    // 동적으로 행렬 생성
    Matrix _Matrix(_N, vector<unsigned long long int>(_N));

    for (int i = 0; i < _N; i++) {
        for (int j = 0; j < _N; j++) 
            cin >> _Matrix[i][j];       
    }

    // 제곱 시작
    Matrix C = MatrixPow(_Matrix, _B);

    for (int i = 0; i < _N; i++) {
        for (int j = 0; j < _N; j++)
            cout << C[i][j] << " ";
        cout << "\n";
    }

    return 0;
}

수학은 너무 어려운 것 같다.

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

벽 부수고 이동하기

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

문제

N×M의 행렬로 표현되는 맵이 있다.

맵에서 0은 이동할 수 있는 곳을 나타내고, 1은 이동할 수 없는 벽이 있는 곳을 나타낸다.

당신은 (1, 1)에서 (N, M)의 위치까지 이동하려 하는데, 이때 최단 경로로 이동하려 한다.

최단경로는 맵에서 가장 적은 개수의 칸을 지나는 경로를 말하는데,

이때 시작하는 칸과 끝나는 칸도 포함해서 센다.

만약에 이동하는 도중에 한 개의 벽을 부수고 이동하는 것이 좀 더 경로가 짧아진다면,

벽을 한 개 까지 부수고 이동하여도 된다.

한 칸에서 이동할 수 있는 칸은 상하좌우로 인접한 칸이다.

맵이 주어졌을 때, 최단 경로를 구해 내는 프로그램을 작성하시오.

입력

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

다음 N개의 줄에 M개의 숫자로 맵이 주어진다.

(1, 1)과 (N, M)은 항상 0이라고 가정하자.

출력

첫째 줄에 최단 거리를 출력한다. 불가능할 때는 -1을 출력한다.

예제 입력 1

6 4
0100
1110
1000
0000
0111
0000

예제 출력 1

15

예제 입력 2

4 4
0111
1111
1111
1110

예제 출력 2

-1

추가 반례

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

예제 입력 A

2 4
0111
0010

예제 출력 A

5

예제 입력 B

6 7
0000000
0111111
0100010
0101010
0101010
0001010

예제 출력 B

12

예제 입력 C

1 1
0

예제 출력 C

1

예제 입력 D

5 5
00000
11101
00001
01111
00010

예제 출력 D

15

예제 입력 E

8 8
01000100
01010100
01010100
01010100
01010100
01010100
01010100
00010100

예제 출력 E

29

예제 입력 F

10 2
01
00
10
00
01
00
10
00
01
00

예제 출력 F

13

출처

• 데이터를 추가한 사람: djm03178, jh05013, Picasso, sait2000, YunGoon
• 문제의 오타를 찾은 사람: ntopia

알고리즘 분류

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

통과된 코드

탐색 중 벽을 파괴한 상태와 아닌 상태를 구분하여 방문 체크를 하는 것이 포인트

#include <iostream>
#include <queue>
#include <tuple>

using namespace std;

queue<tuple<int, int, int, bool>> _MyQueue;

int _N, _M, _MapArr[1001][1001];
int _DxDy[4][2] = { {-1, 0}, {1, 0}, {0, -1}, {0, 1} };
bool _IsVisted[1001][1001][2];
// 벽을 파괴한 상태와 아닌 상태를 구분

int main()
{
	int _Res = 0;
	cin >> _N >> _M;
	for (int i = 1; i <= _N; i++) {
		string _Str;
		cin >> _Str;
		for (int j = 0; j < _Str.length(); j++) {
			_MapArr[i][j + 1] = _Str[j] - '0';
		}
	}

	_MyQueue.push(make_tuple(1, 1, 1, false));
	_IsVisted[1][1][0] = true;
	while (!_MyQueue.empty()) {
		tuple<int, int, int, bool> _NowT = _MyQueue.front();
		_MyQueue.pop();
		int _CntDx = get<0>(_NowT);
		int _CntDy = get<1>(_NowT);
		if (_CntDx == _N && _CntDy == _M) {
			_Res = get<2>(_NowT);
			while (!_MyQueue.empty()) _MyQueue.pop();
		}
		for (int i = 0; i < 4; i++) {
			int _Dx = _CntDx + _DxDy[i][1];
			int _Dy = _CntDy + _DxDy[i][0];
			int _Cnt = get<2>(_NowT);
			bool _Check = get<3>(_NowT);
			// 범위를 벗어나거나 방문한 적이 있다면 넘어간다.
			if (_Dx > _N || _Dy > _M || _Dx <= 0 || _Dy <= 0 || _IsVisted[_Dx][_Dy][_Check]) continue;
			if (_MapArr[_Dx][_Dy]) { // 벽을 만남
				if (!_Check) { // 벽을 파괴한 적이 없다면 큐에 넣는다.
					_MyQueue.push(make_tuple(_Dx, _Dy, _Cnt + 1, !_Check));
					_IsVisted[_Dx][_Dy][_Check] = true;
				}
				continue;
			}

			_MyQueue.push(make_tuple(_Dx, _Dy, _Cnt + 1, _Check));
			_IsVisted[_Dx][_Dy][_Check] = true;
		}
	}
	if (_Res == 0) cout << "-1";
	else cout << _Res;
	return 0;
}

The post 백준 2206번 (벽 부수고 이동하기, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

LCS

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

문제

LCS(Longest Common Subsequence, 최장 공통 부분 수열)문제는 두 수열이 주어졌을 때,

모두의 부분 수열이 되는 수열 중 가장 긴 것을 찾는 문제이다.

예를 들어, ACAYKP와 CAPCAK의 LCS는 ACAK가 된다.

입력

첫째 줄과 둘째 줄에 두 문자열이 주어진다.

문자열은 알파벳 대문자로만 이루어져 있으며, 최대 1000글자로 이루어져 있다.

출력

첫째 줄에 입력으로 주어진 두 문자열의 LCS의 길이를 출력한다.

예제 입력 1

ACAYKP
CAPCAK

예제 출력 1

4

추가 반례

https://www.acmicpc.net/board/search/all/problem/9251/84485

예제 입력 A

ACAA
AAACBA

예제 출력 A

3

예제 입력 B

ABCDEFG
BCDEFGA

예제 출력 B

6

예제 입력 C

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXAAAAAAAAAAA

예제 출력 C

999

예제 입력 D

A
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

예제 출력 D

1

출처

• 문제를 만든 사람: baekjoon
• 데이터를 추가한 사람: bang627, eric00513, qpwoeiruty

알고리즘 분류

• 다이나믹 프로그래밍
• 문자열

통과된 코드

#include <iostream>

using namespace std;

string _StrA, _StrB, _TempStr;
int _Res, _DP[1001];

int main()
{
	cin >> _StrA >> _StrB;

	int _Max = max(_StrA.size(), _StrB.size());

	for (int i = 0; i < _StrB.length(); i++) {
		int _Temp = 0;
		for (int j = 0; j < _StrA.length(); j++) {
			if (_Temp < _DP[j]) 
				_Temp = _DP[j];
			else if (_StrB[i] == _StrA[j]) 
				_DP[j] = _Temp + 1;
		}
	}

	for (int i = 0; i < _Max; i++)
		_Res = max(_DP[i], _Res);

	cout << _Res;

	return 0;
}

The post 백준 9251번 (LCS, C++) [BAEKJOON] 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 어제와 내일의 나 그 사이의 이야기.