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 어제와 내일의 나 그 사이의 이야기.

오민식의 고민

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

문제

오민식은 세일즈맨이다.

오민식의 회사 사장님은 오민식에게 물건을 최대한 많이 팔아서 최대 이윤을 남기라고 했다.

오민식은 고민에 빠졌다. 어떻게 하면 최대 이윤을 낼 수 있을까?

이 나라에는 N개의 도시가 있다. 도시는 0번부터 N-1번까지 번호 매겨져 있다.

오민식의 여행은 A도시에서 시작해서 B도시에서 끝난다.

오민식이 이용할 수 있는 교통수단은 여러 가지가 있다.

오민식은 모든 교통수단의 출발 도시와 도착 도시를 알고 있고, 비용도 알고 있다.

게다가, 오민식은 각각의 도시를 방문할 때마다 벌 수 있는 돈을 알고있다.

이 값은 도시마다 다르며, 액수는 고정되어있다. 또, 도시를 방문할 때마다 그 돈을 벌게 된다.

오민식은 도착 도시에 도착할 때, 가지고 있는 돈의 액수를 최대로 하려고 한다.

이 최댓값을 구하는 프로그램을 작성하시오.

오민식이 버는 돈보다 쓰는 돈이 많다면, 도착 도시에 도착할 때 가지고 있는 돈의 액수가 음수가 될 수도 있다.

또, 같은 도시를 여러 번 방문할 수 있으며, 그 도시를 방문할 때마다 돈을 벌게 된다.

모든 교통 수단은 입력으로 주어진 방향으로만 이용할 수 있으며, 여러 번 이용할 수도 있다.

입력

첫째 줄에 도시의 수 N과 시작 도시, 도착 도시 그리고 교통 수단의 개수 M이 주어진다.

둘째 줄부터 M개의 줄에는 교통 수단의 정보가 주어진다.

교통 수단의 정보는 “시작 끝 가격”과 같은 형식이다.

마지막 줄에는 오민식이 각 도시에서 벌 수 있는 돈의 최댓값이 0번 도시부터 차례대로 주어진다.

N과 M은 50보다 작거나 같고, 돈의 최댓값과 교통 수단의 가격은 1,000,000보다 작거나 같은 음이 아닌 정수이다.

출력

첫째 줄에 도착 도시에 도착할 때, 가지고 있는 돈의 액수의 최댓값을 출력한다.

만약 오민식이 도착 도시에 도착하는 것이 불가능할 때는 “gg”를 출력한다. 

그리고, 오민식이 도착 도시에 도착했을 때 돈을 무한히 많이 가지고 있을 수 있다면 “Gee”를 출력한다.

예제 입력 1

5 0 4 7
0 1 13
1 2 17
2 4 20
0 3 22
1 3 4747
2 0 10
3 4 10
0 0 0 0 0

예제 출력 1

-32

예제 입력 2

5 0 4 5
0 1 10
1 2 10
2 3 10
3 1 10
2 4 10
0 10 10 110 10

예제 출력 2

Gee

예제 입력 3

3 0 2 3
0 1 10
1 0 10
2 1 10
1000 1000 47000

예제 출력 3

gg

예제 입력 4

2 0 1 2
0 1 1000
1 1 10
11 11

예제 출력 4

Gee

예제 입력 5

1 0 0 1
0 0 10
7

예제 출력 5

7

예제 입력 6

5 0 4 7
0 1 13
1 2 17
2 4 20
0 3 22
1 3 4747
2 0 10
3 4 10
8 10 20 1 100000

예제 출력 6

99988

출처

• 문제를 번역한 사람: baekjoon
• 잘못된 조건을 찾은 사람: djm03178
• 데이터를 추가한 사람: gkgg123, sait2000
• 문제의 오타를 찾은 사람: jh05013, typhoon

알고리즘 분류

• 그래프 이론
• 그래프 탐색
• 벨만–포드

주의 사항

순환이 도착 지점에 영향을 줄 수 있도록 많은 시도가 필요하다.

통과된 코드

#include <iostream>
#include <vector>

using namespace std;

constexpr int MAXN = 50;

constexpr long long int INF = -INT64_MAX;

long long int disArr[MAXN];

int N, S, D, M, V, U, W, G[MAXN];

bool check = false;

vector<pair<int, int>> graph[MAXN];

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

    cin >> N >> S >> D >> M;

    // 교통 수단을 입력받는다.
    for (int i = 0; i < M; i++) {
        cin >> V >> U >> W;
        // 단방향 교통수단 출발, 도착, 비용
        graph[V].push_back(make_pair(U, -W));
    }

    // 도시에서 버는 비용입력
    for (int i = 0; i < N; i++) cin >> G[i];

    fill(disArr, disArr + MAXN, INF);

    disArr[S] = G[S];

    // N번 이후부터는 순환 체크
    // 순환이 있는지 충분히 확인
    for (int k = 1; k <= N * 2; k++) { 
        for (int i = 0; i < N; i++) { // 시작 정점
            for (int j = 0; j < graph[i].size(); j++) {
                int v = graph[i][j].first; // 도착점
                int weight = graph[i][j].second; // 가중치

                if (disArr[i] == -INF) disArr[v] = -INF; // 출발지가 순환이라면 도착지도 순환
                else if (disArr[i] != INF && disArr[i] + weight + G[v] > disArr[v]) {
                    disArr[v] = disArr[i] + weight + G[v]; // 업데이트

                    if (k >= N) disArr[v] = -INF; // 순환찾기
                }
            }
        }
    }

    if (disArr[D] == -INF) cout << "Gee"; // 순환에 포함
    else if (disArr[D] == INF) cout << "gg"; // 도착 불가능 
    else cout << disArr[D];

    return 0;

}

추가 반례

예제 입력 A

5 0 4 6
0 1 10000
1 2 0
2 1 0
1 3 0
0 3 0
3 4 0
0 0 1 0 0

예제 출력 A

Gee

예제 입력 B

5 0 0 0
1 2 3 4 5

예제 출력 B

1

예제 입력 C

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

예제 출력 C

Gee

예제 입력 D

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

예제 출력 D

2

예제 입력 E

4 0 3 4
0 1 0
0 3 5
1 2 0
2 1 0
0 5 5 10

예제 출력 E

5

예제 입력 F

5 0 4 5
0 1 10
1 2 10
2 3 10
3 1 10
2 4 10
0 10 10 110 10

예제 출력 F

Gee

The post 백준 1219번 (오민식의 고민, C++, Bellman–Ford) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

웜홀

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

문제

때는 2020년, 백준이는 월드나라의 한 국민이다.

월드나라에는 N개의 지점이 있고 N개의 지점 사이에는 M개의 도로와 W개의 웜홀이 있다.

(단 도로는 방향이 없으며 웜홀은 방향이 있다.)

웜홀은 시작 위치에서 도착 위치로 가는 하나의 경로인데,

특이하게도 도착을 하게 되면 시작을 하였을 때보다 시간이 뒤로 가게 된다.

웜홀 내에서는 시계가 거꾸로 간다고 생각하여도 좋다.

시간 여행을 매우 좋아하는 백준이는 한 가지 궁금증에 빠졌다. 

한 지점에서 출발을 하여서 시간여행을 하기 시작하여 다시 출발을 하였던 위치로 돌아왔을 때,

출발을 하였을 때보다 시간이 되돌아가 있는 경우가 있는지 없는지 궁금해졌다.

여러분은 백준이를 도와 이런 일이 가능한지 불가능한지 구하는 프로그램을 작성하여라.

입력

첫 번째 줄에는 테스트케이스의 개수 TC(1 ≤ TC ≤ 5)가 주어진다.

그리고 두 번째 줄부터 TC개의 테스트케이스가 차례로 주어지는데 각 테스트케이스의 첫 번째 줄에는

지점의 수 N(1 ≤ N ≤ 500), 도로의 개수 M(1 ≤ M ≤ 2500), 웜홀의 개수 W(1 ≤ W ≤ 200)이 주어진다.

그리고 두 번째 줄부터 M+1번째 줄에 도로의 정보가 주어지는데 각 도로의 정보는 S, E, T 세 정수로 주어진다.

S와 E는 연결된 지점의 번호, T는 이 도로를 통해 이동하는데 걸리는 시간을 의미한다.

그리고 M+2번째 줄부터 M+W+1번째 줄까지 웜홀의 정보가 S, E, T 세 정수로 주어지는데

S는 시작 지점, E는 도착 지점, T는 줄어드는 시간을 의미한다.

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

두 지점을 연결하는 도로가 한 개보다 많을 수도 있다.

지점의 번호는 1부터 N까지 자연수로 중복 없이 매겨져 있다.

출력

TC개의 줄에 걸쳐서 만약에 시간이 줄어들면서 출발 위치로 돌아오는 것이 가능하면 YES, 불가능하면 NO를 출력한다.

예제 입력 1

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

예제 출력 1

NO
YES

출처

Olympiad > USA Computing Olympiad > 2006-2007 Season > USACO December 2006 Contest > Gold 1번

• 데이터를 추가한 사람: artichoke42, jh05013

알고리즘 분류

• 그래프 이론
• 벨만–포드

풀이 방법

풀이에 도움되는 글

https://www.acmicpc.net/board/view/72995 <- jh05013의 설명

이 문제에는 여러 우여곡절의 역사가 있습니다.

그래서인지 시작점이 어디라는 언급이 전혀 없는데도 인터넷에 있는 거의 모든 풀이가 1을 시작 정점으로 잡고,

원래 dist[v] != INF이 들어가야 최단거리가 제대로 구해지는데 이걸 오히려 빼버리는 데다가,

왜 이걸 빼야 정답을 받는지는 설명을 안 하고 있습니다.

1. 백준이가 출발을 어디서 하는가?

아무데서나 출발할 수 있습니다.

2. 왜 시작 정점을 1로 정해도 풀리는가?

방금도 언급했듯이 인터넷에 있는 거의 모든 풀이는 아래의 “코드 1″처럼 구현하고 있습니다.

그런데도 맞았습니다!!를 받는데, 그건 잘못된 구현이 오히려 이 문제에서는 올바른 풀이가 되어서 그렇습니다.

바로 dist[v] != INF를 검사하지 않는 것입니다. “코드 2″와 비교해 보세요.

코드 1은 “dist[v] == INF”를 “v를 방문하지 않았다”가 아니라 “v를 방문했고, 

v까지의 최단거리가 INF다”로 인식하고 있습니다.

그래서 이 코드는 이미 처음부터 모든 정점을 방문한 걸로 착각을 하게 되는데,

덕분에 음수 사이클이 어디에 있든 항상 도달이 가능하기 때문에 정답을 받습니다.

어차피 모든 정점을 처음부터 방문하니까, dist[1] = 0은 이 코드에서는 아무 의미가 없습니다.

dist[3] = 0을 하거나, 아예 이 줄을 빼도 맞습니다.

그렇다면 코드 1이 항상 코드 2보다 좋은 코드이냐? 그렇지 않습니다.

코드 1에서는 어떤 정점이 실제로 도달 가능한 정점인지 알 수 없기 때문에, 코드 1은 올바른 벨만 포드 구현이 아닙니다. 

(즉 v가 실제로 도달 불가능한 정점이더라도 dist[v] != INF일 수 있습니다.) 

단지 그 정보가 이 문제에서는 필요 없기 때문에 맞는 것뿐이고,

만약 문제가 “각 점까지의 최단거리를 구해라”였다면 코드 2처럼 하는 것이 좋습니다.

2-1. 코드 2는 왜 틀리는가?

아래의 “코드 2″처럼 구현했다면 오답 처리가 될 것입니다.

틀려야 되는 이유는 시작 정점으로부터 도달할 수 없는 음수 사이클을 못 찾기 때문입니다.

다시 말하면, 이렇게 구현했을 경우 한 점에서만 출발하면 안 됩니다.

2-2. 파이썬 float(‘inf’)

float(‘inf’)에 음수를 더해도 여전히 float(‘inf’)이기 때문에, 이 경우에는 거리 갱신이 이루어지지 않습니다.

그래서 이 경우는 코드 2와 똑같이 동작합니다.

2-3. 그럼 제 강의 자료가 틀린 건가요?

당장 위키피디아만 봐도 dist[v] != INF 같은 게 안 보이지만, 그렇다고 그 자료가 틀린 건 아닙니다.

일반적으로, 알고리즘 설명이나 수도코드에서 ∞ 같은 게 나오면 “아주 큰 수”가 아니라 진짜로 무한대입니다.

파이썬으로 치면 float(‘inf’)와 같습니다.

진짜로 무한대면 dist[v]가 ∞인지 여부와 관계없이 거리 갱신을 다 해도 상관없습니다.

실제로 구현할 때는 “무한히 큰 int”같은 건 없으니까,

도달을 아직 못 한 점에서는 거리 갱신을 안 하는 식으로 우회하는 것일 뿐입니다.

3. 두 번째 방법으로 구현했으면 어떻게 풀어야 하는가?

두 가지 방법이 있습니다.

• 시작 정점이 한 개일 필요는 없습니다. 모든 정점에서 “동시에” 시작할 수 있습니다.
  그러려면 거리 배열 전체를 INF가 아닌 0으로 초기화하고 벨만 포드를 돌리면 됩니다.
• 그래도 꼭 시작 정점이 단 하나였으면 좋겠다고 생각하신다면, N+1번째 “가짜 정점”을 만들어서
  나머지 모든 정점으로 가중치 0의 간선을 긋고, 시작 정점을 N+1로 잡으면 됩니다.
  그러면 모든 정점이 도달 가능하므로 음수 사이클이 어디에 있든 항상 찾을 수 있습니다.

코드 1
INF = 2000000000
모든 dist[v] = INF
dist[1] = 0
N-1번 반복:
  모든 v에 대해:
    모든 간선에 대해 최단거리 갱신
모든 v에 대해:
  모든 간선에 대해 최단거리 갱신
  갱신이 한 번이라도 일어났으면 true

===

코드 2
INF = 2000000000
모든 dist[v] = INF
dist[1] = 0
N-1번 반복:
  dist[v] != INF인 모든 v에 대해:
    모든 간선에 대해 최단거리 갱신
dist[v] != INF인 모든 v에 대해:
  모든 간선에 대해 최단거리 갱신
  갱신이 한 번이라도 일어났으면 true

통과된 코드

#include <iostream>
#include <vector>

using namespace std;

constexpr int MAXN = 501;

int disArr[MAXN];

int TC, N, M, W, S, E, T;

vector<pair<int, int>> graph[MAXN];

bool BellmanFord()
{
	cin >> N >> M >> W;

	vector<pair<int, int>> graph[MAXN];

	// 도로의 정보를 입력받는다.
	for (int i = 0; i < M; i++) {
		cin >> S >> E >> T;
		// 양방향
		graph[S].push_back(make_pair(E, T));
		graph[E].push_back(make_pair(S, T));
	}

	// 웜홀의 정보를 입력받는다.
	for (int i = 0; i < W; i++) {
		cin >> S >> E >> T;
		// 단방향
		graph[S].push_back(make_pair(E, -T));
	}

	// 출발은 어디에새 해도 상관이 없다.
	fill(disArr, disArr + MAXN, 0);

	// (모든 정점의 수 - 1) 번 확인한다.
	// N 번은 순환 체크
	for (int k = 1; k <= N; k++) {
		for (int i = 1; i <= N; i++) { // 시작 정점
			for (int j = 0; j < graph[i].size(); j++) {
				int v = graph[i][j].first; // 도착점
				int weight = graph[i][j].second; // 가중치
	
				// 시작 임시 배열의 가중치가 도착지의 가중치보다 크다면
				if (disArr[i] + weight < disArr[v]) {
					disArr[v] = disArr[i] + weight;

					// K == N 일때 새로 업데이트 된다는 의미
					if (k == N) return true; // 순환이 있음
					
				}
			}
		}
	}

	return false;
	// 순환이 없음
}

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

	cin >> TC;

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

		if (BellmanFord()) cout << "YES\n";
		else cout << "NO\n";

	}

	return 0;
}

The post 백준 1865번 (웜홀, C++, Bellman–Ford) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.