동전 2

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

문제

n가지 종류의 동전이 있다.

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

그러면서 동전의 개수가 최소가 되도록 하려고 한다.

각각의 동전은 몇 개라도 사용할 수 있다.

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

입력

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

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

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

가치가 같은 동전이 여러 번 주어질 수도 있다.

출력

첫째 줄에 사용한 동전의 최소 개수를 출력한다.

불가능한 경우에는 -1을 출력한다.

예제 입력 1

3 15
1
5
12

예제 출력 1

3

출처

• 잘못된 조건을 찾은 사람: apples1309, djm03178
• 빠진 조건을 찾은 사람: goodcrane3
• 데이터를 추가한 사람: hayman42, isac322, paraworld

알고리즘 분류

• 다이나믹 프로그래밍

문제 정리

N개의 동전과 가치 K가 주어진다. (1 <= N <= 100), 1 ≤ K ≤ 10,000)

동전은 각각 가치를 가지고 있고, 동전이 다르더라도 가치가 같을 수 있다. ( 1<= v <= 100,000)

주어진 동전들을 조합하여(동전을 중복으로 사용 가능) 가치의 합이 K가 되는 최소 동전의 수를 구한다.

만약 합을 K로 만들 수 없다면 -1을 출력한다.

목표 가치로 접근

문제의 포인트는 F[K] = Min(F[K] , F[K – X] + 1) 찾는 것

통과된 코드

#include <iostream>
#include <algorithm>

using namespace std;

// 코인의 가치 범위 1 ~ 100   
// 배열의 범위 coin[0 ~ 100]
// coin[N] = N번째 코인의 가치를 나타낸다.
int coinValue[101]; // 예제 {1, 2, 15, 0, 0 ....}

// 주어지는 목표 가치의 범위 1 ~ 10,000   
// 배열의 범위 [0 ~ 10,000]
// TargetValue[K] = K가치를 만드는 동전의 최소 개수
int TargetValue[10001];

// N 동전의 수, K 목표 가치
int N, K;

// 문제를 초기화 해주는 기능의 함수
void Initialization()
{
	// 동전의 수, 목표 가치를 입력받음
	cin >> N >> K;
	
	// 동전의 순서대로 가치를 입력받음
	// 인덱스틑 1번부터
	int temp = 1;
	while (temp <= N) {
		cin >> coinValue[temp];
		temp++;
	}

	for (int i = 0; i <= K; i++) {
		// 목표 가치가 0인 경우 필요한 동전의 수는 0개 
		// 점화식을 전개할때 필요하다.
		if (i == 0) { 
			TargetValue[i] = 0; 
			continue;
		}

		// 동전의 최소 가치는 1
		// 주어지는 목표의 가치의 최대값은 10,000
		// 동전의 개수가 10,000개를 넘어가는 경우는 없다.
		// 문제에서 불가능한 경우를 -1로 출력할때 필요
		TargetValue[i] = 10001;
	}

}

int main()
{
	Initialization(); // 문제 조건을 조기화

	// 입력받은 동전의 개수만큼 순회
	for (int i = 1; i <= N; i++) {
		// 입력받은 목표 가치까지 순회
		for (int j = 1; j <= K; j++) {
			
			// 코인의 가치 > 목표의 가치 넘어간다.
			// TargetValue[K]가 변하지 않는다.
			if (coinValue[i] > j) { continue; }

			// TargetValue[K - coinValue[N] + 1] 
			// 목표 가치에서 현재 순서의 코인의 가치를 한번 뺀다면 해당 코인을 1개 추가한 것과 같다.
			// 기존의 TargetValue[K]와 비교하여 더 작은 수를 넣는다.
			TargetValue[j] = min(TargetValue[j], TargetValue[j - coinValue[i]] + 1);
		}

	}

	// 목표 가치의 동전의 개수가 범위에서 벗어나는 수라면
	// 동전으로 목표의 가치를 만들 수 없다는 뜻 => -1을 출력
	if (TargetValue[K] >= 10001) { cout << -1; }
	else { cout << TargetValue[K]; }

	return 0;
}

DP 문제를 풀면 풀수록 점점 아리송해진다…

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

2×n 타일링

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

문제

2×n 크기의 직사각형을 1×2, 2×1 타일로 채우는 방법의 수를 구하는 프로그램을 작성하시오.

아래 그림은 2×5 크기의 직사각형을 채운 한 가지 방법의 예이다.

입력

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

출력

첫째 줄에 2×n 크기의 직사각형을 채우는 방법의 수를 10,007로 나눈 나머지를 출력한다.

예제 입력 1

2

예제 출력 1

2

예제 입력 2

9

예제 출력 2

55

출처

• 문제를 만든 사람: baekjoon

알고리즘 분류

• 다이나믹 프로그래밍

접근 방법

N =1 부터 나올 수 있는 경우를 체크했다.

그림을 그리면서 확인해본 결과

N = 3이라면 N = 1과 N = 2가 합쳐진 경우다.

통과된 코드

#include <iostream>

using namespace std;

constexpr int MOD = 10007;
					
long long int arr[1001];

int main()
{
	// Tabulation: Bottom Up 방식

	long long int N = 0;

	cin >> N;

	arr[1] = 1, arr[2] = 2;

	for (int  i = 3; i <= N; i++) {
		arr[i] = ( arr[i - 1] % MOD + arr[i - 2] % MOD) % MOD;
	}

	cout << arr[N];

	return 0;
}

틀린 이유는 모듈러 연산에서 괄호를 잘못 묶었다.

테스트 케이스 통과해서 좋다고 제출 했는데 틀렸다고 해서 당황

테스트 케이스는 나머지 연산이 의미가 없어서 결과가 잘나오니…

The post 백준 11726번 (2×n 타일링, C++, DP) [BAEKJOON] appeared first on 어제와 내일의 나 그 사이의 이야기.

이친수

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

문제

0과 1로만 이루어진 수를 이진수라 한다.

이러한 이진수 중 특별한 성질을 갖는 것들이 있는데, 이들을 이친수(pinary number)라 한다.

이친수는 다음의 성질을 만족한다.

1. 이친수는 0으로 시작하지 않는다.

2. 이친수에서는 1이 두 번 연속으로 나타나지 않는다. 즉, 11을 부분 문자열로 갖지 않는다.

예를 들면 1, 10, 100, 101, 1000, 1001 등이 이친수가 된다.

하지만 0010101이나 101101은 각각 1, 2번 규칙에 위배되므로 이친수가 아니다.

N(1 ≤ N ≤ 90)이 주어졌을 때, N자리 이친수의 개수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 N이 주어진다.

출력

첫째 줄에 N자리 이친수의 개수를 출력한다.

예제 입력 1

3

예제 출력 1

2

출처

• 문제의 오타를 찾은 사람: ehay
• 데이터를 추가한 사람: hg5312

알고리즘 분류

• 다이나믹 프로그래밍

결국 이 문제는 피보나치 수열과 같다.

통과된 코드

#include <iostream>

using namespace std;

long long int arr[91]; // N은 최대 90

int main()
{
	// Tabulation: Bottom Up 방식

	long long int N = 0;

	cin >> N;

	arr[0] = 0, arr[1] = 1;

	for (int  i = 2; i <= N; i++) {
		arr[i] = arr[i - 1] + arr[i - 2];
	}

	cout << arr[N];

	return 0;
}

통과하지 못한 이유

1. 범위 제출 시 int로 제출하여 오버플로우가 발생

2. 점화식에 변수를 잘못넣음 => for문에서 i 에 N을 넣음 (미친듯)

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

Dynamic Programming [DP] (다이나믹 프로그래밍 / 동적 계획법)

https://ko.wikipedia.org/wiki/%EB%8F%99%EC%A0%81_%EA%B3%84%ED%9A%8D%EB%B2%95

복잡한 문제를 간단한 여러 개의 문제로 나누어 푸는 방법

부분 문제 반복과 최적 부분 구조를 가지고 있는 알고리즘을 일반적인 방법에 비해 더욱 적은 시간 내에 풀 때 사용한다.

주어진 문제를 풀기 위해서, 문제를 여러 개의 하위 문제(subproblem)로 나누어 푼 다음,

그것을 결합하여 최종적인 목적에 도달하는 것이다.

각 하위 문제의 해결을 계산한 뒤, 그 해결책을 저장하여 후에 같은 하위 문제가 나왔을 경우 그것을 간단하게 해결할 수 있다.

이러한 방법으로 동적 계획법은 계산 횟수를 줄일 수 있다.

특히 이 방법은 하위 문제의 수가 기하급수적으로 증가할 때 유용하다.

“하나의 문제를 단 한번만 풀도록 하는 알고리즘”

( 이름이 Dynamic Programming 인 이유는 이름은 그냥 멋있어 보여서 그렇게 지었다고 한다. )

Dynamic Programming => DP 의 가장 대표적인 예로는 피보나치 수열을 들 수 있다.

https://ko.wikipedia.org/wiki/%ED%94%BC%EB%B3%B4%EB%82%98%EC%B9%98_%EC%88%98 <- 피보나치 수열

Fibonacci Number(피보나치 수열)은 0과 1로 시작하며, 다음 피보나치 수는 바로 앞의 두 피보나치 수의 합이 되는 수열이다.

피보나치 수열은 점화식으로 표현할 수 있기 때문에 재귀함수로 구현할 수 있다.

아래의 코드는 재귀 함수를 이용한 피보나치 수열을 구하는 코드다.

#include <iostream>

using namespace std;

int N, cntOne;

int FibonacciRecursive(int N) // 재귀 호출 방법
{
    if (N == 1 || N == 2) {
        cntOne++; // 카운트
        return 1;
    }
    else {
        return FibonacciRecursive(N - 1) + FibonacciRecursive(N - 2);
    }
}

int main()
{
    cin >> N;

    cntOne = 0;

    cout << "f(" << N << ") : " << FibonacciRecursive(N) << "\n"; // 재귀

    cout << "실행 횟수 : " << cntOne << "번";

    return 0;
}

피보나치의 수열의 F(N)에서 N의 값이 증가하면 증가할수록 연산이 기하급수적으로 증가한다.

예를 들어 피보나치의 수열 fib(5) 를 구한다고 하면 아래와 같이 이루어진다.

fib(5)
fib(4) + fib(3)
(fib(3) + fib(2)) + (fib(2) + fib(1))
((fib(2) + fib(1)) + (fib(1) + fib(0))) + ((fib(1) + fib(0)) + fib(1))
(((fib(1) + fib(0)) + fib(1)) + (fib(1) + fib(0))) + ((fib(1) + fib(0)) + fib(1))

세 번째 줄의 fib(2)가 중복되어 계산되고, 이것은 전체적인 계산 속도를 떨어뜨린다.

결과적으로 이 알고리즘의 시간 복잡도는 지수 함수가 된다.

위와 같은 문제로 DP 알고리즘을 많이 사용하는데

DP는 문제를 여러 개의 하위 문제(subproblem)로 나누고 각 하위 문제의 해결을 계산한 뒤,

그 해결책을 저장하여 후에 같은 하위 문제가 나왔을 경우 중복 계산을 제거하여 효율성을 개선하는 알고리즘이다.

다이내믹 프로그래밍의 대표적인 2가지 방법

https://www.geeksforgeeks.org/tabulation-vs-memoization/

1. Tabulation: Bottom Up (표, 상향식)

2. Memoization: Top Down (메모화, 하향식)

1. Tabulation: Bottom Up (표, 상향식)

이름 자체에서 알 수 있듯이 바닥에서 시작하여 상단으로 답을 축적하여 해결한다.

(가장 작은 문제들부터 차례 차례 답을 쌓아 올려가기 때문에 Bottom Up)

피보나치 수열을 예로 들면

F(0) 부터 F(N)까지 F(1), F(2), F(3)…. F(N) 까지 순서대로 차근차근 값을 구하고 구한 값을 이용하여 중복 계산을 제거한다.

#include <iostream>

using namespace std;

int N, cnt = 0;
int arr[41];

int main()
{
    cin >> N;

    arr[1] = arr[2] = 1;

    for (int i = 3; i <= N; i++) {
        cnt++;
        arr[i] = arr[i - 1] + arr[i - 2];
    }

    cout << "F(" << N << ") = " << arr[N] << "   //  실행 수 : " << cnt << "번";

    return 0;
}

재귀의 102,334,155번 연산 수와 비교하면 엄청난 차이를 보인다.

2. Memoization: Top Down (메모화, 하향식)

Memoization 방식은 목표에서 시작하여 가까운 값을 찾아 탑다운 형태로 중복된 값을 사용한다.

(가장 먼저 호출하는 문제는 가장 큰 문제이기 때문에 Top – Down)

#include <iostream>

using namespace std;

int N, cnt = 0;
int arr[41];

int FibonacciDP(int x)
{

    if (x == 0) return 0;
    else if (x == 1) return 1;

    cnt++; // 연산 카운트

    if (arr[x] == 0) return arr[x] = FibonacciDP(x - 1) + FibonacciDP(x - 2);
    else  return arr[x];

}

int main()
{
    cin >> N;

    arr[1] = arr[2] = 1;

    cout << "F(" << N << ") = " << FibonacciDP(N) << "   //  연산 수 : " << cnt << "번";

    return 0;
}

계산한 적이 있다면 추가 재귀 호출 없이 그 값을 바로 리턴 아니라면 지금 계산해서 그 값을 넣어 준다.

(arr[x] = 0 이라면 계산한 적이 없다는 뜻)

한 번 계산했던 값은 두 번 다시 계산할 필요가 없으므로, f(N)을 구하는 데 O(N)의 복잡도가 필요하다.

The post 알고리즘 – Dynamic Programming [DP] (다이나믹 프로그래밍 / 동적 계획법) appeared first on 어제와 내일의 나 그 사이의 이야기.