플리나를 위하여

#include <iostream>
using namespace std;

void BAEKJOON_2558()
{
	int A;
	int B;
	cin >> A >> B;
	cout << A+B << endl;
	return;
}

#include <iostream>
using namespace std;

void BAEKJOON_2156()
{
	int n;
	cin >> n;
	uint32_t max;
	if (n == 1)
	{
		cin >> max;
	}
	else
	{
		/*----------배열 할당 및 값 입력-----*/
		uint32_t* pt = new uint32_t[n + 1];
		uint32_t* dp = new uint32_t[n + 1];
		pt[0] = 0;
		for (int i = 1; i <= n; i++)
		{
			cin >> pt[i];
		}
		/*---------점화식-------------------*/
		dp[0] = 0;
		dp[1] = pt[1];
		dp[2] = pt[1] + pt[2];
		max = dp[2] > dp[1] ? dp[2] : dp[1];
		uint32_t semiMax = 0;
		/*---------값 구하기----------------*/
		for (int i = 3; i <= n; i++)
		{
			semiMax = dp[i - 3] > semiMax ? dp[i - 3] : semiMax;
			uint32_t before = dp[i - 2] + pt[i];
			uint32_t other = semiMax + pt[i - 1] + pt[i];
			dp[i] = before > other ? before : other;
			if (dp[i] > max)
			{
				max = dp[i];
			}
		}
		/*----------배열 할당 해제----------*/
		delete[] pt;
		delete[] dp;
	}
	cout << max << endl;
	return;
}

#include <iostream>
using namespace std;

void BAEKJOON_10844()
{
	const uint32_t MOD = 1000000000;
	int N;
	cin >> N;
	uint32_t result = 0;
	if (N == 1)
	{
		result = 9;
	}
	else
	{
		uint32_t numArr[101][10] = { 0 };
		/*---------------1열 초기화------------------*/
		numArr[1][0] = 0;
		for (int pos = 1; pos <= 9; pos++)
		{
			numArr[1][pos] = 1;
		}
		/*---------------N열 계산--------------------*/
		for (int culumn = 2; culumn <= N; culumn++)
		{
			for (int pos = 0; pos <= 9; pos++)
			{
				if (pos > 0)
				{
					numArr[culumn][pos] += numArr[culumn - 1][pos - 1];
				}
				if (pos < 9)
				{
					numArr[culumn][pos] += numArr[culumn - 1][pos + 1];
				}
				numArr[culumn][pos] %= MOD;
			}
		}
		/*---------------result 구하기---------------*/
		for (int pos = 0; pos <= 9; pos++)
		{
			result += numArr[N][pos];
			result %= MOD;
		}
	}
	cout << result << endl;
	return;
}

#include <iostream>
using namespace std;

void BAEKJOON_1463()
{
	int N;
	cin >> N;
	int* count = new int[N + 1];
	count[0] = 0;
	count[1] = 0;
	for (int i = 2; i <= N; i++)
	{
		int d3 = 1000001;
		int d2 = 1000001;
		int m1 = 1000001;
		if (i % 3 == 0)
		{
			d3 = 1 + count[i / 3];
		}
		if (i % 2 == 0)
		{
			d2 = 1 + count[i / 2];
		}
		m1 = 1 + count[i - 1];
		count[i] = d3 < d2 ? d3 : d2;
		count[i] = count[i] < m1 ? count[i] : m1;
	}
	cout << count[N] << endl;
	delete[] count;
	return;
}

#include <iostream>
using namespace std;

void BAEKJOON_2579()
{
	int N;
	cin >> N;
	int stairs[301];
	int dp[301] = { 0 };
	for (int i = 1; i <= N; i++)
	{
		cin >> stairs[i];
	}
	/*-----------------점화식 및 계산------------------*/
	dp[1] = stairs[1];
	dp[2] = stairs[1] + stairs[2];
	for (int i = 3; i <= N; i++)
	{
		int left = stairs[i] + dp[i - 2];
		int right = stairs[i] + stairs[i - 1] + dp[i - 3];
		dp[i] = left > right ? left : right;
	}
	/*-----------------출력--------------------*/
	cout << dp[N] << endl;
	return;
}

#include <iostream>
using namespace std;

void BAEKJOON_1932()
{
	int n;
	cin >> n;
	/*--------------배열 할당 및 값 입력------------*/
	int** arr = new int*[n];
	for (int i = 0; i < n; ++i)
	{
		arr[i] = new int[i + 1];
		for (int j = 0; j <= i; ++j)
		{
			cin >> arr[i][j];
		}
	}
	/*-------------최대 합계 구하기----------------*/
	for (int i = n - 2; i >= 0; --i)
	{
		for (int j = 0; j <= i; ++j)
		{
			arr[i][j] += arr[i + 1][j] > arr[i + 1][j + 1] ? arr[i + 1][j] : arr[i + 1][j + 1];
		}
	}
	cout << arr[0][0] << endl;
	/*----------------할당 해제--------------------*/
	for (int i = 0; i < n; ++i)
	{
		delete[] arr[i];
	}
	delete[] arr;
	return;
}

#include <iostream>
using namespace std;
// 배열을 사용한 풀이
void BAEKJOON_1149()
{
	int N;
	cin >> N;
	int* R = new int[N];
	int* G = new int[N];
	int* B = new int[N];
	/*----------------값 입력 받기-------------------*/
	for (int i = 0; i < N; ++i)
	{
		cin >> R[i] >> G[i] >> B[i];
	}
	/*-----------------비용 계산----------------------*/
	for (int i = 0; i < N - 1; ++i)
	{
		R[i + 1] += G[i] < B[i] ? G[i] : B[i];
		G[i + 1] += R[i] < B[i] ? R[i] : B[i];
		B[i + 1] += R[i] < G[i] ? R[i] : G[i];
	}
	int result = R[N - 1] < G[N - 1] ? R[N - 1] :G[N - 1];
	result = result < B[N - 1] ? result : B[N - 1];
	cout << result << endl;
	/*-------------------메모리 해제------------------*/
	delete[] R;
	delete[] G;
	delete[] B;
	return;
}

#include <iostream>
using namespace std;
// 배열을 사용하지 않는 풀이
void BAEKJOON_1149()
{
	int N;
	cin >> N;
	int R = 0;
	int G = 0;
	int B = 0;
	for (int i = 0; i < N; ++i)
	{
		int r, g, b;
		cin >> r >> g >> b;
		r = G < B ? r + G : r + B;
		g = R < B ? g + R : g + B;
		b = G < R ? b + G : b + R;
		R = r;
		G = g;
		B = b;
	}
	int minCost = R < G ? R : G;
	minCost = minCost < B ? minCost : B;
	cout << minCost << endl;
	return;
}