스티커

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/9465

문제

상근이의 여동생 상냥이는 문방구에서 스티커 2n개를 구매했다.

스티커는 그림 (a)와 같이 2행 n열로 배치되어 있다.

상냥이는 스티커를 이용해 책상을 꾸미려고 한다.

상냥이가 구매한 스티커의 품질은 매우 좋지 않다.

스티커 한 장을 떼면, 그 스티커와 변을 공유하는 스티커는 모두 찢어져서 사용할 수 없게 된다.

즉, 뗀 스티커의 왼쪽, 오른쪽, 위, 아래에 있는 스티커는 사용할 수 없게 된다.

모든 스티커를 붙일 수 없게된 상냥이는 각 스티커에 점수를 매기고, 점수의 합이 최대가 되게 스티커를 떼어내려고 한다.

먼저, 그림 (b)와 같이 각 스티커에 점수를 매겼다. 상냥이가 뗄 수 있는 스티커의 점수의 최댓값을 구하는 프로그램을 작성하시오.

즉, 2n개의 스티커 중에서 점수의 합이 최대가 되면서 서로 변을 공유 하지 않는 스티커 집합을 구해야 한다.

위의 그림의 경우에 점수가 50, 50, 100, 60인 스티커를 고르면, 점수는 260이 되고 이 것이 최대 점수이다.

가장 높은 점수를 가지는 두 스티커 (100과 70)은 변을 공유하기 때문에, 동시에 뗄 수 없다.

입력

첫째 줄에 테스트 케이스의 개수 T가 주어진다.

각 테스트 케이스의 첫째 줄에는 n (1 ≤ n ≤ 100,000)이 주어진다.

다음 두 줄에는 n개의 정수가 주어지며, 각 정수는 그 위치에 해당하는 스티커의 점수이다.

연속하는 두 정수 사이에는 빈 칸이 하나 있다.

점수는 0보다 크거나 같고, 100보다 작거나 같은 정수이다. 

출력

각 테스트 케이스 마다, 2n개의 스티커 중에서 두 변을 공유하지 않는 스티커 점수의 최댓값을 출력한다.

예제 입력 1

2
5
50 10 100 20 40
30 50 70 10 60
7
10 30 10 50 100 20 40
20 40 30 50 60 20 80

예제 출력 1

260
290

출처

ICPC > Regionals > Asia Pacific > Korea > Asia Regional – Daejeon 2013 K번

• 문제를 번역한 사람: baekjoon
• 데이터를 추가한 사람: jh05013, seoyeon1018

알고리즘 분류

• 다이나믹 프로그래밍

통과된 코드

#include <iostream>

using namespace std;

int _T, _N, _Res = 0;
int _Table[2][100000];
int _SumTable[2][100000];

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

	cin >> _T;
	while (_T--) {
		cin >> _N;
		for (int i = 0; i < _N; i++) {
			_SumTable[0][i] = 0;
			_SumTable[1][i] = 0;
			_Table[0][i] = 0;
			_Table[1][i] = 0;
		}

		for (int i = 0; i < 2; i++)
			for (int j = 0; j < _N; j++)
				cin >> _Table[i][j];

		_SumTable[0][0] = _Table[0][0];
		_SumTable[1][0] = _Table[1][0];
		_SumTable[0][1] = _Table[1][0] + _Table[0][1];
		_SumTable[1][1] = _Table[0][0] + _Table[1][1];

		for (int i = 2; i < _N; i++) {
			_SumTable[0][i] = max(_SumTable[1][i - 1], _SumTable[1][i - 2]) + _Table[0][i];
			_SumTable[1][i] = max(_SumTable[0][i - 1], _SumTable[0][i - 2]) + _Table[1][i];
		}

		_Res = 0;
		for (int i = 0; i < 2; i++) {
			_N--;
			if (_N < 0) break;
			_Res = max(_Res, max(_SumTable[0][_N], _SumTable[1][_N]));
		}

		cout << _Res<< "\n";

	}

	return 0;
}

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

연속합 2

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

문제

n개의 정수로 이루어진 임의의 수열이 주어진다.

우리는 이 중 연속된 몇 개의 수를 선택해서 구할 수 있는 합 중 가장 큰 합을 구하려고 한다.

단, 수는 한 개 이상 선택해야 한다. 또, 수열에서 수를 하나 제거할 수 있다. (제거하지 않아도 된다)

예를 들어서 10, -4, 3, 1, 5, 6, -35, 12, 21, -1 이라는 수열이 주어졌다고 하자.

여기서 수를 제거하지 않았을 때의 정답은 12+21인 33이 정답이 된다.

만약, -35를 제거한다면, 수열은 10, -4, 3, 1, 5, 6, 12, 21, -1이 되고,

여기서 정답은 10-4+3+1+5+6+12+21인 54가 된다.

입력

첫째 줄에 정수 n(1 ≤ n ≤ 100,000)이 주어지고 둘째 줄에는 n개의 정수로 이루어진 수열이 주어진다.

수는 -1,000보다 크거나 같고, 1,000보다 작거나 같은 정수이다.

출력

첫째 줄에 답을 출력한다.

예제 입력 1

10
10 -4 3 1 5 6 -35 12 21 -1

예제 출력 1

54

출처

• 문제를 만든 사람: baekjoon
• 데이터를 추가한 사람: dj910401, ha_ram, solarmagic
• 문제의 오타를 찾은 사람: jh05013
• 잘못된 데이터를 찾은 사람: tncks0121

알고리즘 분류

• 다이나믹 프로그래밍

시간 초과 코드 (Brute Force)

N의 범위가 100,000로 모든 경우의 수를 확인하면 시간 복잡도가 O(N^2)이 넘어간다 (대략 O(N^3)?)

#include <iostream>
using namespace std;
int _Arr[100001], _N, _Res = INT32_MIN;
int _DP[100001];
int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	cin >> _N;
	for (int i = 1; i <= _N; i++)
		cin >> _Arr[i];
	for (int i = 1; i <= _N; i++) {
		_DP[i] = _DP[i - 1] + _Arr[i];
		_Res = max(_Res, _DP[i]);
	}

	for (int i = 1; i <= _N; i++)
		for (int j = 0; j <= i - 2; j++) {
			_Res = max(_Res, _DP[i] - _DP[j]);
			for (int k = j + 1; k <= i; k++)
				_Res = max(_Res, _DP[i] - _DP[j] - _Arr[k]);	
		}
	cout << _Res;
	return 0;
}

통과된 코드 (DP)

DP[0][i] : i번째 수를 포함하여 연속된 수를 선택했을 때의 최대 합을 계산합니다.
이전 최대 합인 _DP[0][i-1]과 i번째 수인 _Arr[i]를 더한 값과, i번째 수를 단독으로 선택한 값 중 더 큰 값을 선택하여 저장

DP[1][i] : i번째 수를 제거하고 연속된 수를 선택했을 때의 최대 합을 계산합니다.
이전 최대 합인 _DP[0][i-1]과 i번째 수인 _Arr[i]를 더한 값 중 더 큰 값을 선택하여 저장

시간 복잡도는 O(N)

#include <iostream>
using namespace std;
int _Arr[100000], _N, _Res;
int _DP[2][100000];
int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	cin >> _N;
	for (int i = 0; i < _N; i++)
		cin >> _Arr[i];
	_Res = _DP[0][0] = _Arr[0];
	_DP[1][0] = 0;
	for (int i = 1; i < _N; i++) {
		_DP[0][i] = max(_DP[0][i - 1] + _Arr[i], _Arr[i]);
		_DP[1][i] = max(_DP[0][i - 1], _DP[1][i - 1] + _Arr[i]);
		_Res = max(_Res, max(_DP[0][i], _DP[1][i]));
	}
	cout << _Res;
	return 0;
}

The post 백준 13398번 (연속합 2, 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 어제와 내일의 나 그 사이의 이야기.

동전

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

문제

우리나라 화폐단위, 특히 동전에는 1원, 5원, 10원, 50원, 100원, 500원이 있다.

이 동전들로는 정수의 금액을 만들 수 있으며 그 방법도 여러 가지가 있을 수 있다.

예를 들어, 30원을 만들기 위해서는 1원짜리 30개 또는 10원짜리 2개와 5원짜리 2개 등의 방법이 가능하다.

동전의 종류가 주어질 때에 주어진 금액을 만드는 모든 방법을 세는 프로그램을 작성하시오.

입력

입력의 첫 줄에는 테스트 케이스의 개수 T(1 ≤ T ≤ 10)가 주어진다.

각 테스트 케이스의 첫 번째 줄에는 동전의 가지 수 N(1 ≤ N ≤ 20)이 주어지고

두 번째 줄에는 N가지 동전의 각 금액이 오름차순으로 정렬되어 주어진다. 

각 금액은 정수로서 1원부터 10000원까지 있을 수 있으며 공백으로 구분된다.

세 번째 줄에는 주어진 N가지 동전으로 만들어야 할 금액 M(1 ≤ M ≤ 10000)이 주어진다.

편의를 위해 방법의 수는 2³¹ – 1 보다 작고, 같은 동전이 여러 번 주어지는 경우는 없다.

출력

각 테스트 케이스에 대해 입력으로 주어지는 N가지 동전으로 금액 M을 만드는 모든 방법의 수를 한 줄에 하나씩 출력한다.

예제 입력 1

3
2
1 2
1000
3
1 5 10
100
2
5 7
22

예제 출력 1

501
121
1

출처

ICPC > Regionals > Asia Pacific > Korea > Nationwide Internet Competition > Seoul Nationalwide Internet Competition 2003 F번

• 문제의 오타를 찾은 사람: mwy3055
• 빠진 조건을 찾은 사람: thak00

알고리즘 분류

• 다이나믹 프로그래밍
• 배낭 문제

백준 2293번 동전 1과 같은 문제 입니다.

통과된 코드

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

The post 백준 2293번 (동전, 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 어제와 내일의 나 그 사이의 이야기.

구간 합 구하기 5

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

문제

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

위 그림은 크기가 5인 정수 삼각형의 한 모습이다.

맨 위층 7부터 시작해서 아래에 있는 수 중 하나를 선택하여 아래층으로 내려올 때,

이제까지 선택된 수의 합이 최대가 되는 경로를 구하는 프로그램을 작성하라.

아래층에 있는 수는 현재 층에서 선택된 수의 대각선 왼쪽 또는 대각선 오른쪽에 있는 것 중에서만 선택할 수 있다.

삼각형의 크기는 1 이상 500 이하이다. 삼각형을 이루고 있는 각 수는 모두 정수이며, 범위는 0 이상 9999 이하이다.

입력

첫째 줄에 삼각형의 크기 n(1 ≤ n ≤ 500)이 주어지고,

둘째 줄부터 n+1번째 줄까지 정수 삼각형이 주어진다.

출력

첫째 줄에 합이 최대가 되는 경로에 있는 수의 합을 출력한다.

예제 입력 1

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

예제 출력 1

30

출처

Olympiad > International Olympiad in Informatics > IOI 1994 > Day 1 1번

Olympiad > USA Computing Olympiad > 2005-2006 Season > USACO December 2005 Contest > Bronze ?번

Olympiad > USA Computing Olympiad > 1999-2000 Season > USACO Fall 1999 Contest > Gold 1번

• 문제의 오타를 찾은 사람: apjw6112, Martian, paranocean
• 잘못된 조건을 찾은 사람: djm03178
• 데이터를 추가한 사람: eunhyekim1223, hwangtmdals
• 잘못된 데이터를 찾은 사람: thanatos0128

알고리즘 분류

• 다이나믹 프로그래밍

통과된 코드

#include <iostream>
using namespace std;
int _Arr[501][501];
int _Dp[501][501];
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    int _N, _Res = 0;
    cin >> _N;
    cin >> _Arr[1][1];
    _Dp[1][1] = _Arr[1][1];
    for (int i = 2; i <= _N; i++) {
        for (int j = 1; j <= i; j++) {
            cin >> _Arr[i][j];
            _Dp[i][j] = max(_Dp[i - 1][j - 1], _Dp[i - 1][j]) + _Arr[i][j];
        }
    }
    for (int i = 1; i <= _N; i++)
        _Res = max(_Dp[_N][i], _Res);
    cout << _Res;
    return 0;
}

dp[1][1]을 초기화하지 않아서 틀렸다.

The post 백준 1932번 (정수 삼각형, 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 어제와 내일의 나 그 사이의 이야기.