๊ฐ๋
๋ถํ ์ ๋ณต ์๊ณ ๋ฆฌ์ฆ์ ์ฃผ์ด์ง ๋ฌธ์ ๋ฅผ ๋ ์ด์์ ๋ถ๋ถ๋ฌธ์ ๋ก ๋๋ ๋ค ๊ฐ ๋ฌธ์ ์ ๋ํ ๋ต์ ๊ณ์ฐํ๊ณ , ์ด๋ฅผ ๋ณํฉํด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ์๊ณ ๋ฆฌ์ฆ์ด๋ค. ์ข ๋ง๋ถ์ ํํ์ ๋น๋ฆฌ์๋ฉด ๊ฐ๊ฐ ๊ฒฉํ ๋ผ๊ณ ๊ฐ๋จํ ์ค๋ช ํ ์ ์๋ค.
๋ฐ๋ก ์์ ๋ฅผ ๋ณด๋๋ก ํ์.
์์ 1 : ์์ด์ ํฉ
1๋ถํฐ N๊น์ง์ ๊ฐ์ ๊ตฌํด์ผ ํ๋ค๊ณ ๊ฐ์ ํ์. ์ด๋ฅผ ๋จ์ ์ฌ๊ทํจ์๋ก ๊ตฌํํ๋ฉด ์๋์ ๊ฐ์ ๊ฒ์ด๋ค.
#include <iostream>
using namespace std;
int recursiveSum(int N) {
if (N == 1) {
return N;
}
else {
return recursiveSum(N - 1) + N;
}
}
int main() {
int A;
cin >> A;
cout << recursiveSum(A);
}
์ฌ๊ทํจ์๋ก ํจ์๋ฅผ ์ง๋ฉด ๊ต์ฅํ ์ง๊ด์ ์ด์ง๋ง ์ ํจ์์ ๊ฒฝ์ฐ ์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆฐ๋ค. ๋ 5000์ ๋์ ์ซ์๋ถํฐ๋ ํ๋ก๊ทธ๋จ์ด ์ฃฝ์ด๋ฒ๋ฆฐ๋ค.
๊ทธ๋ ๋ค๋ฉด ๋ค๋ฅธ ๋ฐฉ๋ฒ์ผ๋ก ํ๋ก๊ทธ๋จ์ ์ง๋ณด์. 1+2+3+4+...+N์ด๋ผ๋ ์์ ์ด์ง ๋ณํํด์ ๋ถํ ์ ๋ณต์ ํ๊ธฐ ์ข๊ฒ ๋ฐ๊ฟ ๊ฒ์ด๋ค. ์๋ ์์ ๋ณด๋๋ก ํ์.
1+2+3+4+5+6+7+8
=(1+2+3+4)+(5+6+7+8)
=(1+2+3+4)+4*4+(1+2+3+4)
=2*(1+2+3+4)+4^2
์ด์ ์ ์์ ๊ฐ์ ๋ฐฉ์์ผ๋ก ์ผ๋ฐํ ํด๋ณด๋ฉด ์๋์ ๊ฐ๋ค.
1+2+3+4+...N
=(1+2+3+4+...+N/2)+{(N/2+1)+(N/2+2)+(N/2+3)+...+(N/2+N/2)}
=(1+2+3+4+...+N/2)+{(N/2)*(N-2)}+(1+2+3+4+...+N/2)
=2*(1+2+3+4+...+N/2)+(N/2)^2
๋ฌธ์ ๋ฅผ ๋ณด๋ฉด 1+2+3+4+...N์ ๊ตฌํ๋ ๋ฌธ์ ๊ฐ 1+2+3+...+N/2๋ก ๋ฐ๋์์์ ์ ์ ์๋ค. ์ด๊ฒ์ด ๋ถํ ์ ๋ณต์ ํต์ฌ์ด๋ค. ๊ทธ๋ ๋ค๋ฉด 1+2+3+...+N/2๋ฅผ ๋ ์ชผ๊ฐ๋ฉด 1+2+3+...+N/4๋ผ๋ ๋ฌธ์ ๊ฐ ๋์ค๊ณ , ๊ณ์ํด์ ์ชผ๊ฐ๋๊ฐ๋ฉด ๋ฌธ์ ๋ฅผ ์ ์ ์์ ์กฐ๊ฐ์ผ๋ก ์๋ฅผ ์ ์๋ค. ๋ฌผ๋ก ์ ์์ ์ง์์ผ ๊ฒฝ์ฐ๋ง ์ ์ฉ๋๋ค. ํ์์ผ ๊ฒฝ์ฐ์๋ N-1๊น์ง์ ํฉ์ ๊ตฌํ๊ณ N์ ๋ํ๋ ์์ผ๋ก ์์ด์ ํฉ์ ๊ตฌํ๋ค.
์ ๊ณผ์ ์ ์ฝ๋๋ก ์ง๋ฉด ์๋์ ๊ฐ๋ค.
#include <iostream>
using namespace std;
int fastsum(int x) {
if (x == 1) {
return x;
}
else {
if (x % 2 == 0) {
return fastsum(x / 2) * 2 + (x / 2)*(x/2);
}
else {
return fastsum((x - 1) / 2) * 2 + ((x - 1) / 2)* ((x - 1) / 2) + x;
}
}
}
int main() {
int A;
cin >> A;
cout << fastsum(A);
}
์ด์ ํฐ ์๋ฅผ ๋ฃ์ด๋ ํ๋ก๊ทธ๋จ์ด ์ฃฝ์ง ์๋๋ค. ์ฆ ๋ ๋ฒ์งธ ์ฝ๋๊ฐ ๋ ํจ์จ์ ์์ ์ ์ ์๋ค.
์์ 2 : ๋ณํฉ์ ๋ ฌ(Merge Sort)
์ด์ ๋ถํ ์ ๋ณต์ ๋ํ์ ์ธ ์์์ธ ๋ณํฉ์ ๋ ฌ์ ๋ํด ์์๋ณด์. ๋ณํฉ ์ ๋ ฌ์ ๊ณผ์ ์ ์๋์ ๊ฐ๋ค.
- 2๊ฐ์ฉ ๋ฌถ์ผ ๋ ๊น์ง ๋ฐ์ผ๋ก ์ชผ๊ฐ๋๊ฐ๋ค.
- ๊ฐ ์์๋ค์ ์ ๋ ฌํ๋ฉฐ ํฉ์ณ๋๊ฐ๋ค.(๋ ๋ฌถ์์ด ๋ ๋ ๊น์ง)
- 2์์ ๋์จ ๋ ๋ฌถ์์์ ๋งจ ์์ ๋น๊ตํด ํฌ๊ธฐ๊ฐ ์์ ์์๋ฅผ ๊ฐ์ ธ์ ๋ฐฐ์นํ๋ค.
์๋ ๊ทธ๋ฆผ์ ๋ณด๋๋ก ํ์.
๋ถํ ๊ณผ์ ์ ์ํํ ๋์๋ ๊ฐ ๋ฉ์ด๋ฆฌ์ ๋งจ ์์ ๋น๊ตํด ๋ ์์ ๊ฐ์ ๊ฐ์ ธ์ ํฉ์ณ๋๊ฐ์ผ ํ๋ค.
์ด์ ์ ๊ณผ์ ์ ์ฝ๋๋ก ์ง ๋ณด๋๋ก ํ์.
#include<iostream>
using namespace std;
int arr[10];
int arr2[10];
void merge(int left, int right)
{
int mid = (left + right) / 2;
int i = left;
int j = mid + 1;
int k = left;
while (i <= mid && j <= right)
{
if (arr[i] <= arr[j])
arr2[k++] = arr[i++];
else
arr2[k++] = arr[j++];
}
int tmp = i > mid ? j : i;
while (k <= right) arr2[k++] = arr[tmp++];
for (int i = left; i <= right; i++) arr[i] = arr2[i];
}
void divide(int left, int right)
{
int mid;
if (left < right)
{
mid = (left + right) / 2;
divide(left, mid);
divide(mid + 1, right);
merge(left, right);
}
}
int main() {
int a;
for (int i = 0; i < 10; i++) {
cin >> a;
arr[i] = a;
}
divide(0, 9);
for (int i = 0; i < 10; i++) {
cout << arr2[i] << " ";
}
}
10๊ฐ์ ์๋ฅผ ๋ฐ์ arr๋ฐฐ์ด์ ๋ฃ์ด ๋ถํ ์ ๋ ฌํ ๋ค arr2๋ฐฐ์ด์ ๊ฐ์ ๋ฃ์ด์ฃผ๋ ์ฝ๋์ด๋ค.
์ด ๋ฌธ์ ๋ ์ฒ์ ๋ณผ ๋๋ ์์ํ ์ ์์ง๋ง, ์ด ๋ฌธ์ ๋ฅผ ํตํด ๋ถํ ์ ๋ณต์ ์ด๋ป๊ฒ ์ ์ฉํ๋์ง ํ์ตํ๊ณ ๋ค์ ๋ฌธ์ ๋ฅผ ํ์ด๋๊ฐ๋ฉด ์ข์ ๊ฒ ๊ฐ๋ค.
https://www.acmicpc.net/problem/2630
์ ๋จ๊ณ์ ๋๊ฐ์ด ํ ์ ์๋ ๋ฌธ์ ์ด๋ค. ๊ฒฝ์ฐ์ ์๊ฐ ์กฐ๊ธ ๋์ด๋๋ค. ์ ๋ฌธ์ ๋ฅผ ์ดํดํ๋ค๋ฉด ๋ฌด๋ฆฌ์์ด ํ ์ ์๋ค.
https://www.acmicpc.net/problem/1780
์ ๋ฌธ์ ์ ์์ฉํ๊ฐ์ ๋ฌธ์ ์ด๋ค. ๋ฌธ์ ํ์ด ๋ฐฉ์์ ์กฐ๊ธ ๋ฐ๊ฟ์ผ ํ๋ค. ์๊ฐ ์ ํ์ ๊ฑธ๋ฆฌ์ง ์๊ณ ํด๊ฒฐํ ๋ฐฉ๋ฒ์ ์๊ฐํ๋ฉฐ ํ์ด๋ณด๋๋ก ํ์.
https://www.acmicpc.net/problem/1074
'์ฝ๋ฉํ ์คํธ > ์๊ณ ๋ฆฌ์ฆ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[C++ ์๊ณ ๋ฆฌ์ฆ] ๋ค์ด๋๋ฏนํ๋ก๊ทธ๋๋ฐ2 - ๋ฐฐ๋ญ๋ฌธ์ (Knapsack Problem) (0) | 2022.01.04 |
---|---|
[C++] ๋ฒกํฐ ํ์ (0) | 2021.09.07 |
[C++] ์ซ์ ์๋ฆฟ์ ๋ํ๊ธฐ (0) | 2021.09.07 |
[C++ ์๊ณ ๋ฆฌ์ฆ] ๊ทธ๋ฆฌ๋(ํ์๋ฒ,Greedy Algorithm) (2) | 2021.08.08 |
[C++ ์๊ณ ๋ฆฌ์ฆ] ๋์ ๊ณํ๋ฒ(Dynamic Programming) (2) | 2021.07.31 |
๋๊ธ