스티커

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

문제

수열 A가 주어졌을 때, 가장 긴 증가하는 부분 수열을 구하는 프로그램을 작성하시오.

예를 들어, 수열 A = {10, 20, 10, 30, 20, 50} 인 경우에 가장 긴 증가하는 부분 수열은 A = {10, 20, 10, 30, 20, 50} 이고, 길이는 4이다.

입력

첫째 줄에 수열 A의 크기 N (1 ≤ N ≤ 1,000)이 주어진다.

둘째 줄에는 수열 A를 이루고 있는 A_i가 주어진다. (1 ≤ A_i ≤ 1,000)

출력

첫째 줄에 수열 A의 가장 긴 증가하는 부분 수열의 길이를 출력한다.

예제 입력 1

6
10 20 10 30 20 50

예제 출력 1

4

출처

• 문제를 만든 사람: baekjoon
• 데이터를 추가한 사람: harinboy

비슷한 문제

• 11054번. 가장 긴 바이토닉 부분 수열
• 11055번. 가장 큰 증가하는 부분 수열
• 11722번. 가장 긴 감소하는 부분 수열
• 12015번. 가장 긴 증가하는 부분 수열 2
• 12738번. 가장 긴 증가하는 부분 수열 3
• 14002번. 가장 긴 증가하는 부분 수열 4
• 14003번. 가장 긴 증가하는 부분 수열 5

알고리즘 분류

• 다이나믹 프로그래밍

통과된 코드

#include <iostream>

using namespace std;

int _N, _Tables[1000], _DP[1000], _Res = 1;

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

	cin >> _N;
	for (int i = 0; i < _N; i++)
		cin >> _Tables[i];
	_DP[0] = 1;
	for (int i = 1; i < _N; i++) {
		int _t = 1;
		for (int j = i - 1; j >= 0; j--)
			if (_Tables[i] > _Tables[j])
				_t = max(_t, _DP[j] + 1);
		_DP[i] = _t;
	}

	for (int i = 0; i < _N; i++)
		_Res = max(_Res, _DP[i]);
	
	cout << _Res;
	return 0;
}

The post 백준 11053번 (가장 긴 증가하는 부분 수열, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

알약

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

문제

70세 박종수 할아버지는 매일 매일 약 반알을 먹는다.

손녀 선영이는 종수 할아버지에게 약이 N개 담긴 병을 선물로 주었다.

첫째 날에 종수는 병에서 약 하나를 꺼낸다.

그 다음, 그 약을 반으로 쪼개서 한 조각은 먹고, 다른 조각은 다시 병에 넣는다.

다음 날부터 종수는 병에서 약을 하나 꺼낸다. (약은 한 조각 전체 일 수도 있고, 쪼갠 반 조각 일 수도 있다)

반 조각이라면 그 약을 먹고, 아니라면 반을 쪼개서 한 조각을 먹고, 다른 조각은 다시 병에 넣는다.

종수는 손녀에게 한 조각을 꺼낸 날에는 W를, 반 조각을 꺼낸 날에는 H 보낸다.

손녀는 할아버지에게 받은 문자를 종이에 기록해 놓는다.

총 2N일이 지나면 길이가 2N인 문자열이 만들어지게 된다.

이때, 가능한 서로 다른 문자열의 개수는 총 몇 개일까?

입력

입력은 최대 1000개의 테스트 케이스로 이루어져 있다.

각 테스트 케이스는 한 줄이며, 병에 들어있는 약의 개수 N ≤ 30 가 주어진다.

입력의 마지막 줄에는 0이 하나 주어진다.

출력

각 테스트 케이스에 대해서 가능한 문자열의 개수를 출력한다.

예제 입력 1

6
1
4
2
3
30
0

예제 출력 1

132
1
14
2
5
3814986502092304

출처

ICPC > Regionals > North America > Rocky Mountain Regional > 2011 Rocky Mountain Regional Contest E번

• 문제를 번역한 사람: baekjoon

알고리즘 분류

• 수학
• 다이나믹 프로그래밍

통과된 코드

#include <iostream>
using namespace std;
int _N;
long long int _DP[31][31];
int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);

	for (int i = 0; i <= 30; i++)
		for (int j = 0; j <= 30; j++) {
			// 반쪽이 더 많은 경우는 없다.
			if (i < j) break;
			if (j == 0) _DP[i][j] = 1;
			else _DP[i][j] = _DP[i - 1][j] + _DP[i][j - 1];
		}

	while (true) {
		cin >> _N;
		if (_N == 0) break;
		// 온전한 알약을 N번
		// 반쪽의 알약을 N번 => 다 먹었다.
		cout << _DP[_N][_N] << "\n";
	}

	return 0;
}

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

동전 1

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

문제

n가지 종류의 동전이 있다. 각각의 동전이 나타내는 가치는 다르다.

이 동전을 적당히 사용해서, 그 가치의 합이 k원이 되도록 하고 싶다.

그 경우의 수를 구하시오. 각각의 동전은 몇 개라도 사용할 수 있다.

사용한 동전의 구성이 같은데, 순서만 다른 것은 같은 경우이다.

입력

첫째 줄에 n, k가 주어진다. (1 ≤ n ≤ 100, 1 ≤ k ≤ 10,000)

다음 n개의 줄에는 각각의 동전의 가치가 주어진다.

동전의 가치는 100,000보다 작거나 같은 자연수이다.

출력

첫째 줄에 경우의 수를 출력한다. 경우의 수는 2³¹보다 작다.

예제 입력 1

3 10
1
2
5

예제 출력 1

10

출처

• 어색한 표현을 찾은 사람: dbfldkfdbgml
• 빠진 조건을 찾은 사람: goodcrane3
• 데이터를 추가한 사람: jh05013

알고리즘 분류

• 다이나믹 프로그래밍

통과된 코드

#include <iostream>
using namespace std;
int _N, _K, _Temp, _Coin[100], _DP[10001];
int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	cin >> _N >> _K;
	for (int i = 0; i < _N; i++)
		cin >> _Coin[i];
	_DP[0] = 1;
	for (int i = 0; i < _N; i++)
		for (int j = _Coin[i]; j <= _K; j++)
			_DP[j] = _DP[j] + _DP[j - _Coin[i]];
	cout << _DP[_K];
	return 0;
}

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

내려가기

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

문제

N줄에 0 이상 9 이하의 숫자가 세 개씩 적혀 있다.

내려가기 게임을 하고 있는데, 이 게임은 첫 줄에서 시작해서 마지막 줄에서 끝나게 되는 놀이이다.

먼저 처음에 적혀 있는 세 개의 숫자 중에서 하나를 골라서 시작하게 된다.

그리고 다음 줄로 내려가는데, 다음 줄로 내려갈 때에는 다음과 같은 제약 조건이 있다.

바로 아래의 수로 넘어가거나, 아니면 바로 아래의 수와 붙어 있는 수로만 이동할 수 있다는 것이다.

이 제약 조건을 그림으로 나타내어 보면 다음과 같다.

별표는 현재 위치이고, 그 아랫 줄의 파란 동그라미는 원룡이가 다음 줄로 내려갈 수 있는 위치이며,

빨간 가위표는 원룡이가 내려갈 수 없는 위치가 된다.

숫자표가 주어져 있을 때, 얻을 수 있는 최대 점수, 최소 점수를 구하는 프로그램을 작성하시오.

점수는 원룡이가 위치한 곳의 수의 합이다.

입력

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

다음 N개의 줄에는 숫자가 세 개씩 주어진다.

숫자는 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 중의 하나가 된다.

출력

첫째 줄에 얻을 수 있는 최대 점수와 최소 점수를 띄어서 출력한다.

예제 입력 1

3
1 2 3
4 5 6
4 9 0

예제 출력 1

18 6

예제 입력 2

3
0 0 0
0 0 0
0 0 0

예제 출력 2

0 0

출처

• 빠진 조건을 찾은 사람: dreamian
• 잘못된 데이터를 찾은 사람: tncks0121

알고리즘 분류

• 다이나믹 프로그래밍
• 슬라이딩 윈도우

통과된 코드

#include <iostream>
using namespace std;
int _N, _DP[9], _Temp[3];
int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	cin >> _N >> _DP[0] >> _DP[1] >> _DP[2];
	_DP[3] = _DP[0]; // 최솟값 DP 초기화
	_DP[4] = _DP[1];
	_DP[5] = _DP[2];
	for (int i = 1; i < _N; i++) {
		cin >> _DP[6] >> _DP[7] >> _DP[8];
		_Temp[0] = _DP[0];
		_Temp[1] = _DP[1];
		_Temp[2] = _DP[2];
		_DP[0] = max(_Temp[0], _Temp[1]) + _DP[6];
		_DP[1] = max(_Temp[0], max(_Temp[1], _Temp[2])) + _DP[7];
		_DP[2] = max(_Temp[1], _Temp[2]) + _DP[8];
		_Temp[0] = _DP[3];
		_Temp[1] = _DP[4];
		_Temp[2] = _DP[5];
		_DP[3] = min(_Temp[0], _Temp[1]) + _DP[6];
		_DP[4] = min(_Temp[0], min(_Temp[1], _Temp[2])) + _DP[7];
		_DP[5] = min(_Temp[1], _Temp[2]) + _DP[8];
	}

	cout << max(_DP[0], max(_DP[1], _DP[2])) << " " << min(_DP[3], min(_DP[4], _DP[5]));
	return 0;
}

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

파이프 옮기기 1

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

문제

유현이가 새 집으로 이사했다. 새 집의 크기는 N×N의 격자판으로 나타낼 수 있고,

1×1크기의 정사각형 칸으로 나누어져 있다.

각각의 칸은 (r, c)로 나타낼 수 있다. 여기서 r은 행의 번호, c는 열의 번호이고,

행과 열의 번호는 1부터 시작한다.

각각의 칸은 빈 칸이거나 벽이다.

오늘은 집 수리를 위해서 파이프 하나를 옮기려고 한다.

파이프는 아래와 같은 형태이고, 2개의 연속된 칸을 차지하는 크기이다.

파이프는 회전시킬 수 있으며, 아래와 같이 3가지 방향이 가능하다.

파이프는 매우 무겁기 때문에, 유현이는 파이프를 밀어서 이동시키려고 한다.

벽에는 새로운 벽지를 발랐기 때문에, 파이프가 벽을 긁으면 안 된다.

즉, 파이프는 항상 빈 칸만 차지해야 한다.

파이프를 밀 수 있는 방향은 총 3가지가 있으며, →, , ↓ 방향이다.

파이프는 밀면서 회전시킬 수 있다. 회전은 45도만 회전시킬 수 있으며,

미는 방향은 오른쪽, 아래, 또는 오른쪽 아래 대각선 방향이어야 한다.

파이프가 가로로 놓여진 경우에 가능한 이동 방법은 총 2가지,

세로로 놓여진 경우에는 2가지, 대각선 방향으로 놓여진 경우에는 3가지가 있다.

아래 그림은 파이프가 놓여진 방향에 따라서 이동할 수 있는 방법을 모두 나타낸 것이고,

꼭 빈 칸이어야 하는 곳은 색으로 표시되어져 있다.

가로

세로

대각선

가장 처음에 파이프는 (1, 1)와 (1, 2)를 차지하고 있고, 방향은 가로이다.

파이프의 한쪽 끝을 (N, N)로 이동시키는 방법의 개수를 구해보자.

입력

첫째 줄에 집의 크기 N(3 ≤ N ≤ 16)이 주어진다.

둘째 줄부터 N개의 줄에는 집의 상태가 주어진다. 빈 칸은 0, 벽은 1로 주어진다.

(1, 1)과 (1, 2)는 항상 빈 칸이다.

출력

첫째 줄에 파이프의 한쪽 끝을 (N, N)으로 이동시키는 방법의 수를 출력한다.

이동시킬 수 없는 경우에는 0을 출력한다.

방법의 수는 항상 1,000,000보다 작거나 같다.

예제 입력 1

3
0 0 0
0 0 0
0 0 0

예제 출력 1

1

예제 입력 2

4
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0

예제 출력 2

3

예제 입력 3

5
0 0 1 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0

예제 출력 3

0

예제 입력 4

6
0 0 0 0 0 0
0 1 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0

예제 출력 4

13

출처

• 문제를 만든 사람: baekjoon
• 데이터를 추가한 사람: djm03178

알고리즘 분류

• 다이나믹 프로그래밍
• 그래프 이론
• 그래프 탐색

통과된 코드 (BFS)

#include <iostream>
#include <queue>
#include <tuple>
using namespace std;
// 우측, 하단, 대각선
int _DxDy[3][2] = { { 0, 1},{ 1, 0},{ 1, 1} };
bool _MapArr[17][17];
// x좌표, y좌표, 파이프의 상태
// 0 = 가로 , 1 = 세로 , 2 = 대각선
queue<tuple<int, int, int>> _BFSQ;

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

    int _N, _Res = 0;
	cin >> _N;
	for (int i = 1; i <= _N; i++) {
		for (int j = 1; j <= _N; j++) {
			cin >> _MapArr[i][j];
		}
	}

	tuple<int, int, int> _Temp = make_tuple(1, 2, 0);
	_BFSQ.push(_Temp);
	while (!_BFSQ.empty()) {
		_Temp = _BFSQ.front();
		_BFSQ.pop();
		for (int i = 0; i < 3; i++) {
			if (get<2>(_Temp) == 0 && i == 1 || get<2>(_Temp) == 1 && i == 0) continue;
			int _dx = get<0>(_Temp) + _DxDy[i][0];
			int _dy = get<1>(_Temp) + _DxDy[i][1];
			if (_dx > _N || _dy > _N || _dx <= 0 || _dy <= 0 || _MapArr[_dx][_dy]) continue;
			if (i == 2) { // 대각선 방향 우측, 하단부 확인
				if (_MapArr[get<0>(_Temp) + _DxDy[0][0]][get<1>(_Temp) + _DxDy[0][1]] ||
					_MapArr[get<0>(_Temp) + _DxDy[1][0]][get<1>(_Temp) + _DxDy[1][1]]) continue;
			}
			if (_dx == _N && _dy == _N) {
				_Res++;
				continue;
			}
			tuple<int, int, int> _Temp2 = make_tuple(_dx, _dy, i);
			_BFSQ.push(_Temp2);
		}
	}
	cout << _Res;

    return 0;
}

BFS 탐색을 이용한 결과 생각보다 시간이 많이 걸리고 메모리도 많이 사용한다.

통과된 코드 (DP)

DP 알고리즘을 이용한 해결법이 더 효율적

#include <iostream>
using namespace std;
// 0 가로, 1 세로, 2 대각선
int _DpArr[3][17][17];
bool _MapArr[17][17];
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    int _N;
    cin >> _N;  
    for (int i = 1; i <= _N; ++i)
        for (int j = 1; j <= _N; ++j)
            cin >> _MapArr[i][j];
    // 파이프의 상태, (1, 2) 시작
    _DpArr[0][1][2] = 1;
    // Tabulation: Bottom Up(표, 상향식) DP
    for (int i = 1; i <= _N; ++i) {
        for (int j = 1; j <= _N; ++j) {
            if (_MapArr[i][j]) continue; // 움직일 위치가 벽이 라면 넘어간다.
            // 가로 상태로 이동이 가능한 경우 => 전 상태가 우측 or 대각선인 경우
            _DpArr[0][i][j] += _DpArr[0][i][j - 1] + _DpArr[2][i][j - 1];
            // 세로 상태로 이동이 가능한 경우 => 전 상태가 하단 or 대각선인 경우
            _DpArr[1][i][j] += _DpArr[1][i - 1][j] + _DpArr[2][i - 1][j];
            // 대각선 상태로 이동이 가능한 조건 체크 => 우측 + 하단에 벽이 있는지 확인이 필요
            if (_MapArr[i][j - 1] || _MapArr[i - 1][j]) continue;
            // 대각선 상태로 이동이 가능한 경우 => 모든 경우 가능
            _DpArr[2][i][j] += _DpArr[0][i - 1][j - 1] + _DpArr[1][i - 1][j - 1] + _DpArr[2][i - 1][j - 1];
        }
    }
    // DP연산을 마친후에 결과 종합
    // _N,_N 에 도착한 상태가 가로, 세로, 대각선 상태를 전부 더해준다.
    cout << _DpArr[0][_N][_N] + _DpArr[1][_N][_N] + _DpArr[2][_N][_N];
    return 0;
}

The post 백준 17070번 (파이프 옮기기 1, 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 어제와 내일의 나 그 사이의 이야기.

구간 합 구하기 5

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

문제

N×N개의 수가 N×N 크기의 표에 채워져 있다.

(x1, y1)부터 (x2, y2)까지 합을 구하는 프로그램을 작성하시오. (x, y)는 x행 y열을 의미한다.

예를 들어, N = 4이고, 표가 아래와 같이 채워져 있는 경우를 살펴보자.

여기서 (2, 2)부터 (3, 4)까지 합을 구하면 3+4+5+4+5+6 = 27이고, (4, 4)부터 (4, 4)까지 합을 구하면 7이다.

표에 채워져 있는 수와 합을 구하는 연산이 주어졌을 때,

이를 처리하는 프로그램을 작성하시오.

입력

첫째 줄에 표의 크기 N과 합을 구해야 하는 횟수 M이 주어진다.

(1 ≤ N ≤ 1024, 1 ≤ M ≤ 100,000) 둘째 줄부터 N개의 줄에는 표에 채워져 있는 수가 1행부터 차례대로 주어진다.

다음 M개의 줄에는 네 개의 정수 x1, y1, x2, y2 가 주어지며, (x1, y1)부터 (x2, y2)의 합을 구해 출력해야 한다.

표에 채워져 있는 수는 1,000보다 작거나 같은 자연수이다. (x1 ≤ x2, y1 ≤ y2)

출력

총 M줄에 걸쳐 (x1, y1)부터 (x2, y2)까지 합을 구해 출력한다.

예제 입력 1

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

예제 출력 1

27
6
64

예제 입력 2

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

예제 출력 2

1
2
3
4

출처

• 문제를 만든 사람: baekjoon
• 어색한 표현을 찾은 사람: f52985
• 빠진 조건을 찾은 사람: kyma123

알고리즘 분류

• 다이나믹 프로그래밍
• 누적 합

시간 초과 코드

쿼리를 받을 때마다 정해진 구간을 더해서 값을 찾아내는 알고리즘

N과 M의 범위를 보고 시간 초과를 받을 것 같다고 예상은 했지만 일단 구현해보았다.

#include <iostream>
#include <vector>
#include <tuple>

using namespace std;

int _N, _M, _Res, _Map[1025][1025];

vector<tuple <int, int, int, int>> _QuiryVector;
tuple <int, int, int, int> _Quiry;

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

	cin >> _N >> _M;
	for (int i = 1; i <= _N; i++) {
		for (int j = 1; j <= _N; j++)  
			cin >> _Map[i][j];	
	}

	for (int i = 0; i < _M; i++) {
		int _X1, _Y1, _X2, _Y2;
		cin >> _X1 >> _Y1 >> _X2 >> _Y2;
		_QuiryVector.push_back(make_tuple(_X1, _Y1, _X2, _Y2));
	}

	for (auto& it : _QuiryVector) {
		_Res = 0;
		for (int i = get<0>(it); i <= get<2>(it); i++) {
			for (int j = get<1>(it); j <= get<3>(it); j++) {
				_Res += _Map[i][j];
			}
		}
		cout << _Res << "\n";
	}


	return 0;
}

통과된 코드

내가 생각한 알고리즘에는 Map을 저장할 필요가 없어서 삭제

#include <iostream>
#include <vector>
#include <tuple>

using namespace std;

int _N, _M, _Res, _RowSum[1025][1025];

int _X1, _Y1, _X2, _Y2;

vector<tuple <int, int, int, int>> _QuiryVector;

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

	cin >> _N >> _M;

	for (int i = 1; i <= _N; i++) {
		int _Temp = 0;
		for (int j = 1; j <= _N; j++) {
			cin >> _Temp;
			_RowSum[i][j] = _RowSum[i][j - 1] + _Temp;
		}
	}

	for (int i = 0; i < _M; i++) {
		cin >> _X1 >> _Y1 >> _X2 >> _Y2;
		_QuiryVector.push_back(make_tuple(_X1, _Y1, _X2, _Y2));
	}

	for (auto& it : _QuiryVector) {
		_Res = 0;
		for (int i = get<0>(it); i <= get<2>(it); i++) {
			_Res += _RowSum[i][get<3>(it)] - _RowSum[i][get<1>(it) - 1];
		}
		cout << _Res << "\n";
	}

	return 0;
}

The post 백준 11660번 (구간 합 구하기 5, C++) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

RGB거리

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

문제

RGB거리에는 집이 N개 있다.

거리는 선분으로 나타낼 수 있고, 1번 집부터 N번 집이 순서대로 있다.

집은 빨강, 초록, 파랑 중 하나의 색으로 칠해야 한다.

각각의 집을 빨강, 초록, 파랑으로 칠하는 비용이 주어졌을 때,

아래 규칙을 만족하면서 모든 집을 칠하는 비용의 최솟값을 구해보자.

1번 집의 색은 2번 집의 색과 같지 않아야 한다.

N번 집의 색은 N-1번 집의 색과 같지 않아야 한다.

i(2 ≤ i ≤ N-1)번 집의 색은 i-1번, i+1번 집의 색과 같지 않아야 한다.

입력

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

둘째 줄부터 N개의 줄에는 각 집을 빨강, 초록, 파랑으로 칠하는 비용이 1번 집부터 한 줄에 하나씩 주어진다.

집을 칠하는 비용은 1,000보다 작거나 같은 자연수이다.

출력

첫째 줄에 모든 집을 칠하는 비용의 최솟값을 출력한다.

예제 입력 1

3
26 40 83
49 60 57
13 89 99

예제 출력 1

96

예제 입력 2

3
1 100 100
100 1 100
100 100 1

예제 출력 2

3

예제 입력 3

3
1 100 100
100 100 100
1 100 100

예제 출력 3

102

예제 입력 4

6
30 19 5
64 77 64
15 19 97
4 71 57
90 86 84
93 32 91

예제 출력 4

208

예제 입력 5

8
71 39 44
32 83 55
51 37 63
89 29 100
83 58 11
65 13 15
47 25 29
60 66 19

예제 출력 5

253

출처

• 문제를 번역한 사람: baekjoon
• 빠진 조건을 찾은 사람: djm03178
• 문제의 오타를 찾은 사람: fail456
• 데이터를 추가한 사람: rdd6584

알고리즘 분류

• 다이나믹 프로그래밍

통과된 코드

Tuple 자료구조를 사용한 것이 생각보다 비효율적??

#include <iostream>
#include <vector>
#include <tuple>

using namespace std;

vector<tuple<int, int, int>> _ColorCost; // 0 - 빨강, 1 - 초록, 2 - 파랑

int N, _Co0, _Co1, _Co2;;

int dp[3][10001];

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

	cin >> N;
	for (int i = 0; i < N; i++) {
		cin >> _Co0 >> _Co1 >> _Co2;
		_ColorCost.push_back(make_tuple(_Co0, _Co1, _Co2));
	}

	// 처음을 어떤 색으로 시작하는 가?
	dp[0][1] = get<0>(_ColorCost[0]);
	dp[1][1] = get<1>(_ColorCost[0]);
	dp[2][1] = get<2>(_ColorCost[0]);
	
	// 시작 값을 최소값으로 정한다고 결과가 최소라는 것은 아니다.
	for (int i = 2; i <= N; i++) { 
		dp[0][i] = min(dp[1][i - 1], dp[2][i - 1]) + get<0>(_ColorCost[i - 1]);
		dp[1][i] = min(dp[0][i - 1], dp[2][i - 1]) + get<1>(_ColorCost[i - 1]);
		dp[2][i] = min(dp[0][i - 1], dp[1][i - 1]) + get<2>(_ColorCost[i - 1]);
	}

	// 시작 색이 어떤 색인지에 따라서 3가지의 결과가 나온다.
	cout << min(dp[0][N], min(dp[1][N], dp[2][N]));

	return 0;
}

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

벨만-포드 (Bellman–Ford Algorithm) 알고리즘

Bellman-Ford 알고리즘은 (Richard Bellman과 Lester Ford의 이름)

가중 그래프에서 정점과 다른 모든 정점 사이의 최단 경로를 찾는 데 사용되는 최단 경로 알고리즘입니다.

간단하게 말하면 한 정점에서 다른 정점까지의 최단 거리를 구하는 알고리즘입니다.

작동하는 과정

https://www.geeksforgeeks.org/bellman-ford-algorithm-dp-23/

1단계: 출발 정점을 0으로 둡니다.

출발 정점의 거리를 제외하고 모든 거리를 무한으로 초기화합니다. 

2단계: 모든 정점을 다음 순서로 처리합니다

(B, E), (D, B), (B, D), (A, B), (A, C), (D, C), (B, C), (E, D)

모든 모서리가 처음으로 처리될 때 다음과 같은 거리를 얻습니다. 

첫 번째 행은 초기의 거리를 보여줍니다. 

두 번째 행은 가장자리 (B, E), (D, B), (B, D) 및 (A, B)가 처리될 때 거리를 보여줍니다. 

세 번째 행은 (A, C)가 처리될 때의 거리를 보여줍니다. 

네 번째 행은 (D, C), (B, C) 및 (E, D) 를 처리한 거리를 보여줍니다.

3단계: 첫 번째 반복은 최대 1 정점 길이의 모든 최단 경로를 제공합니다.

모든 정점이 두 번째로 처리 될 때 다음과 같은 거리를 얻습니다 (마지막 행은 최종 값을 나타냅니다).

4단계: 두 번째 반복은 최대 2 개의 가장자리 길이인 모든 최단 경로를 제공합니다.

알고리즘은 모든 정점을 2번 더 처리합니다.

두 번째 반복 후에는 거리가 최소화되므로

세 번째 및 네 번째 반복에서는 거리가 업데이트되지 않습니다.

주의 사항

Bellman-Ford 알고리즘을 사용할 경우 아래와 같은 음의 가중치 주기를 주의해야 합니다.

위의 예제는 1 -> 2 -> 3 순서를 계속 반복하면 가중치가 계속 줄어듭니다. (잘못된 결과)

위와 같은 상황에서는 Bellman-Ford 알고리즘으로 답을 구할 수 없습니다.

그래프에 음의 가중치 주기가 포함되어 있는지 확인하려면

Bellman-Ford 알고리즘 이후에 모든 간선을 다시 한번 확인합니다.

만약 업데이트가 일어난다면 음의 가중치가 포함되어있다는 의미 입니다.

구현 코드

백준 11657번 ‘타임머신’ 문제를 Bellman-Ford 알고리즘 코드 해결

코드 C++

#include <iostream>
#include <vector>

using namespace std;

constexpr long long int INF = INT64_MAX;

constexpr int MAXN = 501;

long long int disArr[MAXN];

bool check = false; // 음의 순환이 있는지 확인

// N : 도시의 개수, M : 버스 노선의 개수
// A : 시작 도시, B : 도착 도시, C : 걸리는 시간
int N, M, A, B, C;

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 >> M;

	for (int i = 0; i < M; i++) {
		cin >> A >> B >> C;
		// 단방향
		graph[A].push_back(make_pair(B, C));
	}

	// 배열 초기화
	fill(disArr, disArr + MAXN, INF);

	disArr[1] = 0;


	for (int k = 1; k <= N; k++) {// (모든 정점의 수 - 1) 번 확인한다.
		// 모든 노선을 확인한다.
		for (int i = 1; i <= N; i++) {
			for (int j = 0; j < graph[i].size(); j++) {

				int u = i; // 시작점
				int v = graph[i][j].first; // 도착점
				int weight = graph[i][j].second; // 가중치

				// 만약 임시 배열이 무한대가 아니고 &&
				// 시작 임시 배열의 가중치가 도착지의 가중치보다 작다면
				if (disArr[u] != INF && disArr[u] + weight < disArr[v]) {

					disArr[v] = disArr[u] + weight; // 임시배열을 업데이트 해준다.

					// K가 N-1일때 모든 정점을 확인한 후
					// K가 N일때 업데이트가 있다면 음의 순환이 있다는 이야기
					if (k == N) { 
						cout << "-1";
						return 0;
					}
				}
			}
		}
	}

	for (int i = 2; i <= N; i++) {
		if (disArr[i] == INF) cout << "-1" << "\n";
		else cout << disArr[i] << "\n";
	}

	return 0;
}

Dijkstra 알고리즘 vs Bellman–Ford 알고리즘

1. 가중치의 차이

예전에 정리한 Dijkstra 도 Bellman–Ford 와 같은 최단 경로 알고리즘입니다.

하지만 Dijkstra 알고리즘은 가중치가 양수일 때만 사용 가능하다는 중요한 특징을 가지고 있습니다.

따라서 가중치가 전부 양수라면 Dijkstra 알고리즘을 사용하고

하나라도 음수의 가중치가 있다면

Bellman–Ford 알고리즘을 사용해야 합니다.

위 : Dijkstra / 아래 Bellman–Ford (.gif)

2. 시간 복잡도의 차이

V는 꼭짓점의 수이고 E는 간선의 개수라고 한다면

Dijkstra 알고리즘은 O(E*logV)의 시간 복잡도를 가지고

Bellman-Ford 알고리즘은 O(V*E)의 시간 복잡도를 가집니다.

따라서 음의 가중치가 없다면 Bellman-Ford 알고리즘보다는

Dijkstra 알고리즘을 이용하여 해결하는 것이 더 좋은 방법입니다.

(Dijkstra 알고리즘은 우선순위 대기열을 사용하여 처리해야 하는 정점을 유지하는 반면,

Bellman-Ford 알고리즘은 가장 짧은 경로를 찾기 위해 모든 정점에 대해 반복합니다.)

백준 1865번 (웜홀, C++, Bellman–Ford) [BAEKJOON]

더 읽기

백준 11657번 (타임머신, C++, Bellman–Ford) [BAEKJOON]

더 읽기

백준 1219번 (오민식의 고민, C++, Bellman–Ford) [BAEKJOON]

더 읽기

백준 1738번 (골목길, C++, Bellman–Ford) / 추가 반례 [BAEKJOON]

더 읽기

알고리즘 – 벨만-포드 (Bellman–Ford Algorithm) 알고리즘 정리

더 읽기

https://www.acmicpc.net/problemset?sort=ac_desc&algo=10 <- 백준 Bellman-Ford 알고리즘 문제

The post 알고리즘 – 벨만-포드 (Bellman–Ford Algorithm) 알고리즘 정리 appeared first on 어제와 내일의 나 그 사이의 이야기.

거의 최단 경로

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

문제

요즘 많은 자동차에서는 GPS 네비게이션 장비가 설치되어 있다.

네비게이션은 사용자가 입력한 출발점과 도착점 사이의 최단 경로를 검색해 준다.

하지만, 교통 상황을 고려하지 않고 최단 경로를 검색하는 경우에는 극심한 교통 정체를 경험할 수 있다.

상근이는 오직 자기 자신만 사용 가능한 네비게이션을 만들고 있다.

이 네비게이션은 절대로 최단 경로를 찾아주지 않는다. 항상 거의 최단 경로를 찾아준다.

거의 최단 경로란 최단 경로에 포함되지 않는 도로로만 이루어진 경로 중 가장 짧은 것을 말한다. 

예를 들어, 도로 지도가 아래와 같을 때를 생각해보자.

원은 장소를 의미하고, 선은 단방향 도로를 나타낸다.

시작점은 S, 도착점은 D로 표시되어 있다. 굵은 선은 최단 경로를 나타낸다. (아래 그림에 최단 경로는 두 개가 있다)

거의 최단 경로는 점선으로 표시된 경로이다.

이 경로는 최단 경로에 포함되지 않은 도로로 이루어진 경로 중 가장 짧은 경로이다.

거의 최단 경로는 여러 개 존재할 수도 있다.

예를 들어, 아래 그림의 길이가 3인 도로의 길이가 1이라면, 거의 최단 경로는 두 개가 된다.

또, 거의 최단 경로가 없는 경우도 있다.

입력

입력은 여러 개의 테스트 케이스로 이루어져 있다.

각 테스트 케이스의 첫째 줄에는 장소의 수 N (2 ≤ N ≤ 500)과 도로의 수 M (1 ≤ M ≤ 10⁴)가 주어진다.

장소는 0부터 N-1번까지 번호가 매겨져 있다. 둘째 줄에는 시작점 S와 도착점 D가 주어진다. (S ≠ D; 0 ≤ S, D < N)

다음 M개 줄에는 도로의 정보 U, V, P가 주어진다. (U ≠ V ; 0 ≤ U, V < N; 1 ≤ P ≤ 10³)

이 뜻은 U에서 V로 가는 도로의 길이가 P라는 뜻이다.

U에서 V로 가는 도로는 최대 한 개이다.

또, U에서 V로 가는 도로와 V에서 U로 가는 도로는 다른 도로이다. 

입력의 마지막 줄에는 0이 두 개 주어진다.

출력

각 테스트 케이스에 대해서, 거의 최단 경로의 길이를 출력한다.

만약, 거의 최단 경로가 없는 경우에는 -1을 출력한다.

예제 출력 1

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

예제 입력 1

5
-1
6

출처

ICPC > Regionals > Latin America > South America Regional Contests 2008 A번

• 문제를 번역한 사람: baekjoon
• 데이터를 추가한 사람: gkswjdzz, sait2000, smsm8111
• 잘못된 데이터를 찾은 사람: tncks0121

알고리즘 분류

• 그래프 이론
• 그래프 탐색
• 데이크스트라

추가 예제

예제 출력 A

100 765
44 52
0 11 939
0 18 635
0 26 757
0 39 558
0 41 669
0 43 855
0 45 951
0 46 755
0 51 785
0 52 218
0 78 557
0 94 918
0 96 300
1 19 752
1 22 157
1 31 797
1 37 871
1 78 834
2 0 275
2 30 73
2 64 32
2 67 552
2 78 7
2 81 883
2 96 315
2 99 865
3 11 299
3 13 196
3 37 247
3 45 523
3 47 745
3 54 474
3 60 63
3 94 244
3 97 699
3 99 855
4 10 516
4 17 506
4 24 985
4 28 598
4 35 598
4 39 744
4 44 749
4 46 8
4 77 363
4 78 618
4 92 988
4 97 591
5 0 918
5 9 8
5 14 405
5 23 448
5 84 354
6 0 404
6 10 209
6 20 352
6 57 651
6 71 490
6 77 934
6 94 188
6 96 638
6 99 138
7 25 815
7 27 55
7 42 606
7 56 643
7 65 966
7 81 755
8 0 684
8 5 959
8 13 998
8 19 757
8 22 172
8 33 638
8 38 777
8 51 185
8 59 321
8 67 403
8 69 475
8 71 204
8 74 567
8 97 138
9 15 965
9 17 611
9 64 712
9 66 743
9 84 971
10 5 486
11 3 678
11 54 838
11 86 226
11 95 623
12 5 427
12 28 19
12 33 879
12 35 876
12 37 907
12 50 437
12 51 853
12 52 407
12 58 756
12 68 480
12 75 867
12 85 833
13 6 356
13 37 954
13 53 479
13 68 448
13 74 707
13 79 369
13 80 735
13 84 17
13 96 355
14 6 185
14 12 121
14 17 925
14 32 276
14 36 559
14 39 343
14 44 90
14 86 513
14 87 952
14 96 912
15 13 296
15 20 726
15 36 835
15 41 458
15 49 17
15 57 47
15 61 583
15 65 25
15 82 703
16 9 289
16 19 289
16 26 935
16 46 122
16 58 611
16 59 625
16 60 89
16 75 674
16 81 147
16 85 806
16 86 89
17 7 848
17 39 490
17 53 980
17 58 372
17 62 357
17 78 885
17 83 406
17 87 873
17 95 32
18 41 232
18 43 394
18 47 35
18 50 697
18 83 464
18 87 281
19 1 857
19 12 589
19 14 819
19 37 470
19 40 520
19 42 276
19 43 27
19 66 706
19 71 426
19 83 858
19 94 353
20 13 523
20 17 128
20 51 90
20 53 411
20 84 903
20 91 747
20 96 503
21 23 721
21 27 724
21 28 34
21 30 396
21 34 86
21 37 371
21 53 371
21 54 672
22 4 325
22 11 407
22 44 631
22 55 480
22 68 861
22 90 338
23 1 109
23 15 850
23 34 645
23 48 582
23 52 264
23 58 330
23 64 796
23 65 118
23 69 133
23 89 389
24 11 220
24 26 5
24 38 951
24 44 990
24 45 123
24 49 216
24 51 505
24 90 388
24 93 475
25 24 633
25 41 489
25 83 434
26 4 577
26 17 977
26 19 558
26 31 863
26 33 284
26 43 751
26 46 576
26 48 224
26 79 497
27 14 26
27 18 949
27 21 102
27 38 357
27 45 528
27 75 614
27 76 289
27 80 803
27 81 343
28 3 458
28 15 893
28 24 579
28 44 649
28 62 934
28 65 964
28 67 177
28 87 678
29 0 191
29 39 112
29 45 184
29 61 778
29 87 810
30 4 335
30 11 829
30 50 996
30 54 470
30 60 972
30 63 147
30 98 559
30 99 24
31 15 30
31 29 250
31 46 53
31 63 488
31 71 561
32 35 812
32 50 781
32 67 540
33 34 611
33 56 12
33 61 631
33 64 842
33 89 697
34 4 208
34 19 621
34 23 343
34 35 129
34 40 489
34 42 323
34 56 762
34 64 522
34 79 412
35 1 64
35 3 799
35 5 360
35 6 488
35 11 879
35 27 403
35 28 320
35 43 802
35 71 639
35 75 147
35 94 310
36 3 471
36 18 920
36 37 260
36 51 987
36 68 888
36 77 573
37 5 79
37 24 306
37 51 731
37 54 451
38 34 359
38 35 854
38 48 903
38 71 322
38 99 262
39 5 40
39 6 830
39 8 58
39 22 757
39 23 539
39 36 984
39 58 75
39 60 780
39 63 223
39 65 365
39 66 86
39 67 953
39 78 705
39 79 505
39 87 29
39 94 31
39 97 865
40 11 60
40 49 145
40 57 211
40 60 371
40 81 144
40 82 874
40 97 994
41 37 142
41 99 976
42 4 376
42 8 56
42 12 372
42 28 634
42 30 71
42 35 766
42 43 653
42 45 283
42 47 674
42 52 807
42 57 189
42 84 279
42 86 366
42 91 728
42 93 702
43 6 149
43 14 39
43 40 796
43 87 35
43 89 946
43 94 259
43 95 375
44 8 35
44 21 605
44 25 809
44 73 418
44 85 914
44 93 368
45 34 90
45 41 172
45 48 253
45 53 829
45 65 31
45 86 994
45 92 826
46 18 346
46 37 161
46 44 505
46 76 992
46 80 576
46 94 984
47 8 295
47 35 330
47 56 954
47 76 158
47 77 39
47 80 313
47 82 217
47 87 688
48 17 214
48 31 760
48 36 989
48 37 922
48 84 886
49 12 757
49 14 724
49 16 948
49 34 854
49 38 552
49 40 361
49 50 990
49 53 148
49 74 959
49 82 226
49 84 153
49 87 134
50 14 838
50 33 260
50 37 624
50 44 381
50 47 868
50 55 616
50 90 135
50 92 148
50 97 510
51 56 459
51 84 726
51 91 543
51 99 855
52 2 872
52 23 771
52 35 380
52 76 773
52 81 769
53 10 314
53 48 745
53 49 567
53 50 99
53 58 180
53 67 297
53 80 107
54 17 458
54 21 310
54 44 68
54 70 896
54 83 986
54 87 605
54 90 422
55 0 101
55 7 868
55 31 316
55 36 208
55 46 151
55 87 612
56 0 40
56 16 247
56 35 492
56 59 609
56 73 796
56 78 225
57 2 419
57 17 785
57 23 523
57 37 730
57 42 290
57 47 503
57 59 909
57 81 319
57 84 782
57 95 250
58 2 842
58 26 886
58 52 168
58 56 386
58 59 253
58 70 174
58 79 608
58 81 764
58 89 215
59 8 105
59 9 876
59 18 305
59 20 397
59 31 278
59 35 379
59 57 702
60 18 785
60 59 603
60 62 224
60 63 300
60 69 111
60 70 437
60 86 129
60 88 862
60 90 603
61 13 185
61 14 521
61 26 23
61 33 645
61 45 907
61 67 269
61 75 717
61 82 919
61 90 554
61 91 865
61 98 182
62 13 135
62 24 96
62 39 625
62 63 901
62 81 816
62 97 592
63 7 518
63 8 46
63 16 724
63 52 912
63 97 725
64 15 554
64 29 395
64 35 177
64 38 340
64 58 100
64 66 570
64 76 754
65 24 370
65 29 726
65 33 348
65 41 388
65 44 931
65 59 293
65 92 255
65 95 937
66 7 435
66 17 260
66 19 510
66 23 571
66 25 875
66 39 671
66 77 97
66 80 52
66 82 939
67 2 110
67 40 346
67 41 641
67 46 881
67 52 703
67 58 770
67 62 974
67 81 199
67 90 396
67 95 558
67 96 375
67 99 597
68 2 395
68 17 863
68 20 8
68 22 682
68 43 444
68 74 870
68 79 739
68 98 158
69 10 763
69 13 933
69 25 738
69 28 755
69 33 745
69 53 998
69 58 961
69 78 410
69 89 621
69 90 271
69 91 362
69 98 574
70 17 788
70 38 695
70 44 383
70 55 843
70 60 373
70 61 529
71 7 932
71 9 184
71 25 341
71 27 360
71 53 832
71 60 135
71 64 245
71 69 980
71 72 238
71 74 210
72 14 63
72 42 346
72 60 204
72 71 324
72 73 970
72 88 547
72 90 618
73 9 20
73 17 980
73 18 845
73 27 728
73 37 577
73 46 472
73 56 825
73 58 111
73 61 962
73 75 69
73 86 389
74 10 720
74 17 31
74 67 163
74 69 621
74 79 831
74 84 479
74 88 579
74 91 43
75 18 763
75 24 669
75 33 618
75 61 689
75 78 430
75 83 422
76 1 768
76 31 972
76 69 445
76 73 111
76 75 841
76 78 529
76 86 614
76 91 841
77 5 158
77 14 396
77 20 358
77 37 436
77 51 954
77 52 316
77 55 782
77 88 65
77 99 451
78 9 753
78 38 838
78 91 373
79 23 788
79 30 901
79 48 428
79 84 193
79 85 396
79 88 456
80 6 442
80 10 869
80 29 590
80 32 894
80 45 429
80 67 2
80 74 800
80 90 257
81 12 6
81 27 306
81 35 908
81 68 610
81 69 629
81 78 320
81 88 385
81 90 337
81 96 483
82 30 690
82 53 871
82 61 713
82 97 228
82 99 199
83 34 654
83 39 786
83 46 529
83 53 429
83 76 995
83 82 802
83 84 571
84 0 362
84 6 696
84 19 298
84 30 741
84 34 286
84 54 31
84 58 194
84 61 383
84 81 487
84 88 656
84 95 750
84 98 916
84 99 819
85 6 716
85 38 723
85 43 889
85 44 775
85 57 115
85 68 548
85 77 480
86 23 988
86 41 963
86 49 512
86 62 210
86 89 363
86 92 738
86 96 942
87 7 666
87 22 689
87 26 53
87 50 675
87 54 297
87 82 997
87 83 883
88 23 942
88 43 622
88 52 24
88 61 777
88 63 58
88 79 708
88 92 637
89 19 853
89 29 912
89 42 95
90 16 517
90 18 18
90 19 115
90 40 979
90 56 780
90 84 13
90 86 926
91 15 816
91 17 998
91 32 554
91 39 131
91 44 928
91 59 707
91 70 288
91 75 906
92 16 936
92 35 45
92 46 541
92 51 871
92 55 982
92 63 362
92 70 453
92 72 376
92 75 370
92 79 973
92 96 986
93 3 705
93 15 801
93 23 894
93 49 26
93 50 974
93 56 925
93 94 558
94 0 893
94 33 130
94 34 520
94 35 382
94 47 352
94 50 1
94 56 922
94 57 844
94 62 854
94 79 87
95 33 836
95 36 728
95 46 558
95 57 134
95 73 232
95 75 191
96 17 846
96 72 506
97 11 623
97 46 668
97 60 739
97 63 937
97 86 2
97 95 87
98 22 60
98 25 409
98 53 509
98 61 96
98 83 660
98 86 889
99 45 624
99 47 589
99 51 300
99 58 248
99 77 867
99 78 769
99 80 566
0 0

예제 출력 A

726

예제 입력 B

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

예제 출력 B

6
-1
-1
3

예제 입력 C

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

예제 출력 C

2
-1
-1
2

예제 입력 D

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

예제 출력 D

-1
3
2
-1

틀린 코드 (메모리 초과)

다익스트라의 경로를 저장하기 위하여 우선 순위 큐에 지나온 정점들을 list<pair<int, int>>에 담아 보았다.

당연하게 메모리 초과 (정답은 잘나온다… ㅜㅜ)

원리는 list에 있는 정점들을 방문처리하여 다음 다익스트라를 사용할 때 넘기는 방법을 사용했다.

#include <iostream>
#include <queue>
#include <vector>
#include <list>
#include <tuple>
#include <map>

using namespace std;

constexpr int INF = INT32_MAX;

int disArr[501];

bool check[501][501];

int N, M, S, D, U, V, P;

int Dijstra()
{
    int result = INF;

    for (int i = 0; i <= N; i++) {
        for (int j = 0; j <= N; j++) {
            check[i][j] = false;
        }
    }

    // 임시배열 초기화
    for (int i = 0; i <= N; i++) disArr[i] = INF;

    priority_queue<tuple<int, int, list<pair<int, int>>>> firstPQ;

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

    list<pair<int, int>> myList;

    multimap<int, list<pair<int, int>>> myMap;

    for (int i = 0; i < M; i++) {
        cin >> U >> V >> P;
        graph[U].push_back(make_pair(V, P));
    }

    // 우선순위 큐에 삽입.
    firstPQ.push({ 0, S, myList }); // < first : 거리 , second : 노드 인덱스 >
    disArr[S] = 0;
    while (!firstPQ.empty()) {
        // -를 붙이는 이유는 우선순위 큐를 이용하여 정렬하기 위함이다.
        // (최소힙으로 구현)
        int nCost = -get<0>(firstPQ.top());
        int now = get<1>(firstPQ.top());
        myList = get<2>(firstPQ.top());
        firstPQ.pop();

        // 이미 담겨 있는 것보다 거리가 크면 넘어간다.
        if (disArr[now] < nCost) continue;

        // 해당 노드에서 연결된 모든 경로를 확인
        for (int i = 0; i < graph[now].size(); i++) {
            list<pair<int, int>> tempList = myList;
            // disSum = 임시 노드 + 현재 노드에서 i로가는 비용
            int disSum = nCost + graph[now][i].second;

            // 비용이 더 작다면 최단경로 테이블 값을 갱신.
            if (disSum <= disArr[graph[now][i].first]) {
                tempList.push_back(make_pair(now, graph[now][i].first));

                if (graph[now][i].first == D && result >= disSum) {
                    result = disSum;
                    myMap.insert(make_pair(disSum, tempList));
                }

                // 임시 노드 업데이트
                disArr[graph[now][i].first] = disSum;
                // 우선순위 큐에 (거리, 노드 인덱스) 푸시
                firstPQ.push(make_tuple(-disSum, graph[now][i].first, tempList));
            }
        }
    }

    result = disArr[D];

    for (auto mit = myMap.begin(); mit != myMap.end(); mit++) {
        if (result == mit->first) {
            for (auto it = mit->second.begin(); it != mit->second.end(); it++) {
                check[it->first][it->second] = true;
            }
        }

        else break;
    }

    priority_queue<pair<int, int>> myPQ;

    // 임시배열 초기화
    for (int i = 0; i <= N; i++) disArr[i] = INF;

    // 우선순위 큐에 삽입.
    myPQ.push({ 0, S }); // < first : 거리 , second : 노드 인덱스 >
    disArr[S] = 0;

    while (!myPQ.empty()) {
        // -를 붙이는 이유는 우선순위 큐를 이용하여 정렬하기 위함이다.
        // (최소힙으로 구현)
        int nCost = -myPQ.top().first;
        int now = myPQ.top().second;
        myPQ.pop();

        // 이미 담겨 있는 것보다 거리가 크면 넘어간다.
        if (disArr[now] < nCost) continue;
        // 해당 노드에서 연결된 모든 경로를 확인
        for (int i = 0; i < graph[now].size(); i++) {
            if (check[now][graph[now][i].first] == true) continue;
            // disSum = 임시 노드 + 현재 노드에서 i로가는 비용
            int disSum = nCost + graph[now][i].second;
            // 비용이 더 작다면 최단경로 테이블 값을 갱신.
            if (disSum <= disArr[graph[now][i].first]) {
                // 임시 노드 업데이트
                disArr[graph[now][i].first] = disSum;
                // 우선순위 큐에 (거리, 노드 인덱스) 푸시
                myPQ.push(make_pair(-disSum, graph[now][i].first));
            }
        }
    }

    return disArr[D];
}


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

    while (true) {

        cin >> N >> M;

        if (N == 0 && M == 0) break;

        cin >> S >> D;

        int result = Dijstra();

        if (result == INF) cout << -1 << "\n";
        else cout << result << "\n";
    }



    return 0;
}

통과된 코드

vector<int> trace[501]; 를 이용하여 시작과 끝의 정점들을 넣어준다.

주의할 점은 도착지에서 출발지 방향으로 탐색을 하기 위해서 반대로 넣어주어야 한다.

#include <iostream>
#include <queue>
#include <vector>

using namespace std;

constexpr int INF = INT32_MAX;

int disArr[501];

priority_queue<pair<int, int>> mypq;

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

vector<int> trace[501];

int N, M, S, D, U, V, P;

void MyDijstra()
{  
    for (int i = 0; i <= N; i++) disArr[i] = INF;

    for (int i = 0; i < M; i++) {
        cin >> U >> V >> P;
        graph[U].push_back(make_pair(V, P));
    }

    // 우선순위 큐에 삽입.
    mypq.push({ 0, S }); // < first : 거리 , second : 노드 인덱스 >

    disArr[S] = 0;

    while (!mypq.empty()) {
        // -를 붙이는 이유는 우선순위 큐를 이용하여 정렬하기 위함이다.
        // (최소힙으로 구현)
        int ncost = -mypq.top().first;
        int now = mypq.top().second;

        mypq.pop();

        // 이미 담겨 있는 것보다 거리가 크면 넘어간다.
        if (disArr[now] < ncost) continue;

        // 해당 노드에서 연결된 모든 경로를 확인
        for (int i = 0; i < graph[now].size(); i++) {
            // dissum = 임시 노드 + 현재 노드에서 i로가는 비용
            int dissum = ncost + graph[now][i].second;
            // 비용이 더 작다면 최단경로 테이블 값을 갱신.
            // 같아도 확인이 필요하다.
            // 최소 거리가 여러개 있을 수 있기 떄문
            if (dissum <= disArr[graph[now][i].first]) {

                if (dissum < disArr[graph[now][i].first]) {
                
                    // 임시 노드 업데이트
                    disArr[graph[now][i].first] = dissum;

                    trace[graph[now][i].first].clear(); // 새로 갱신한다면 전에 있던 것이 필요가 없다.
                    trace[graph[now][i].first].push_back(now); // 경로를 저장

                    // 우선순위 큐에 (거리, 노드 인덱스) 푸시
                    mypq.push(make_pair(-dissum, graph[now][i].first));
                }
                else trace[graph[now][i].first].push_back(now); // 경로를 저장 역방향으로 넣어준다.
            }
        }
    }

    // 최단 거리의 경로를 삭제해 줍니다.
    queue<int> delQ;
    delQ.push(D);
    while (!delQ.empty()) {
        int nowDel = delQ.front();
        delQ.pop();
        for (int i = 0; i < trace[nowDel].size(); i++) {
            for (auto it = graph[trace[nowDel][i]].begin(); it != graph[trace[nowDel][i]].end(); it++) {
                if ((*it).first == nowDel) {
                    delQ.push(trace[nowDel][i]);
                    graph[trace[nowDel][i]].erase(it);
                    break;
                }
            }
        }
    }


    // 새로운 데이크스트라를 진행하여 거의 최단 경로를 찾는다.
    for (int i = 0; i <= N; i++) disArr[i] = INF;
    // 우선순위 큐에 삽입.
    mypq.push({ 0, S }); // first : 거리 , second : 노드 인덱스
    disArr[S] = 0;
    while (!mypq.empty()) {
        // -를 붙이는 이유는 우선순위 큐를 이용하여 정렬하기 위함이다.
        // (최소힙으로 구현)
        int ncost = -mypq.top().first;
        int now = mypq.top().second;

        mypq.pop();

        // 이미 담겨 있는 것보다 거리가 크면 넘어간다.
        if (disArr[now] < ncost) continue;

        // 해당 노드에서 연결된 모든 경로를 확인
        for (int i = 0; i < graph[now].size(); i++) {
            // dissum = 임시 노드 + 현재 노드에서 i로가는 비용
            int dissum = ncost + graph[now][i].second;
            // 비용이 더 작다면 최단경로 테이블 값을 갱신.
            if (dissum < disArr[graph[now][i].first]) {

                disArr[graph[now][i].first] = dissum;
                // 우선순위 큐에 (거리, 노드 인덱스) 푸시
                mypq.push(make_pair(-dissum, graph[now][i].first));
            }
        }
    }

    for (int i = 0; i <= N; i++) trace[i].clear();
    for (int i = 0; i <= M; i++) graph[i].clear();
}


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

    while (true) {

        cin >> N >> M;

        if (N == 0 && M == 0) break;

        cin >> S >> D;

        MyDijstra();

        if (disArr[D] == INF) cout << -1 << "\n";
        else cout << disArr[D] << "\n";
    }

    return 0;
}

틀린 코드를 포기할 수 없어 여러가지 방법으로 접근하여 메모리를 줄여보았지만 의미는 없었다.

The post 백준 5719번 (거의 최단 경로, C++, Dijkstra) / 추가 반례 [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.