๐ก ๋์ ๊ณํ๋ฒ(DP, Dynamic Programming)์ ๋ํด ์ค๋ช ํด์ฃผ์ธ์.
์ฃผ์ด์ง ๋ฌธ์ ๋ฅผ ํ๊ธฐ ์ํด, ๋ฌธ์ ๋ฅผ ์ฌ๋ฌ ๊ฐ์ ํ์ ๋ฌธ์ ๋ก ๋๋์ด ํธ๋ ๋ฐฉ๋ฒ์ ๋งํฉ๋๋ค.
๋์ ๊ณํ๋ฒ์์๋ ์ด๋ค ๋ถ๋ถ ๋ฌธ์ ๊ฐ ๋ค๋ฅธ ๋ฌธ์ ๋ค์ ํด๊ฒฐํ๋๋ฐ ์ฌ์ฉ๋ ์ ์์ด, ๋ต์ ์ฌ๋ฌ ๋ฒ ๊ณ์ฐํ๋ ๋์ ํ ๋ฒ๋ง ๊ณ์ฐํ๊ณ
๊ทธ ๊ฒฐ๊ณผ๋ฅผ ์ฌํ์ฉํ๋ ๋ฉ๋ชจ์ด์ ์ด์ (Memoization)๊ธฐ๋ฒ์ผ๋ก ์๋๋ฅผ ํฅ์์ํฌ ์ ์์ต๋๋ค.
โป ๋ฉ๋ชจ์ด์ ์ด์ : ๋์ผํ ๊ณ์ฐ์ ๋ฐ๋ณตํด์ผ ํ ๋, ์ด์ ์ ๊ณ์ฐํ ๊ฐ์ ์ฌ์ฌ์ฉํจ์ผ๋ก์จ ๋์ผํ ๊ณ์ฐ์ ๋ฐ๋ณต ์ํ์ ์ ๊ฑฐํ์ฌ ํ๋ก๊ทธ๋จ ์คํ ์๋๋ฅผ ๋น ๋ฅด๊ฒ ํ๋ ๊ธฐ์
๐ก ๋์ ๊ณํ๋ฒ(DP, Dynamic Programming)์ด ๊ฐ๋ 2๊ฐ์ง ์กฐ๊ฑด์ ๋ฌด์์ธ๊ฐ์?
1. ์ค๋ณต๋๋ ๋ถ๋ถ(์์) ๋ฌธ์
์ค๋ณต๋๋ ๋ถ๋ถ ๋ฌธ์ ๋ ๋๋ ์ง ๋ถ๋ถ ๋ฌธ์ ๊ฐ ์ค๋ณต๋๋ ๊ฒฝ์ฐ๋ก, ๋ฉ๋ชจ์ด์ ์ด์ ๊ธฐ๋ฒ์ ์ฌ์ฉํด ์ค๋ณต ๊ณ์ฐ์ ์์ฑ๋๋ค.
2. ์ต์ ๋ถ๋ถ ๊ตฌ์กฐ
์ต์ ๋ถ๋ถ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง๋ค๋ ๊ฒ์ ์ ์ฒด ๋ฌธ์ ์ ์ต์ ํด๊ฐ ๋ถ๋ถ ๋ฌธ์ ์ ์ต์ ํด๋ค๋ก์จ ๊ตฌ์ฑ๋๋ค๋ ๊ฒ์ ๋๋ค.
๐ก ๋ฒ๋ธ ์ ๋ ฌ(Bubble Sort)์ ๋ํด ์ค๋ช ํด์ฃผ์ธ์.
๋ฒ๋ธ ์ ๋ ฌ๋ ์๋ก ์ธ์ ํ ๋ ์์๋ฅผ ๋น๊ตํ์ฌ ์ ๋ ฌํ๋ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค.
0๋ฒ ์ธ๋ฑ์ค๋ถํฐ n-1๋ฒ ์ธ๋ฑ์ค๊น์ง n๋ฒ๊น์ง์ ๋ชจ๋ ์ธ๋ฑ์ค๋ฅผ ๋น๊ตํ๋ฉฐ ์ ๋ ฌํฉ๋๋ค. ์๊ฐ ๋ณต์ก๋๋ O(n^2)์ ๋๋ค.

๐ก ์ ํ ์ ๋ ฌ(Selection Sort)์ ๋ํด ์ค๋ช ํด์ฃผ์ธ์.
์ ํ ์ ๋ ฌ์ ์ฒซ ๋ฒ์งธ ๊ฐ์ ๋๋ฒ์งธ ๋ถํฐ ๋ง์ง๋ง ๊ฐ๊น์ง ์ฐจ๋ก๋๋ก ๋น๊ตํ์ฌ ์ต์๊ฐ์ ์ฐพ์ ์ฒซ ๋ฒ์งธ์ ๋๊ณ ,
๋ ๋ฒ์งธ ๊ฐ์ ์ธ ๋ฒ์งธ ๋ถํฐ ๋ง์ง๋ง ๊ฐ๊น์ง ๋น๊ตํ์ฌ ์ต์๊ฐ์ ์ฐพ์ ๋ ๋ฒ์งธ ์์น์ ๋๋ ๊ณผ์ ์ ๋ฐ๋ณตํ๋ฉฐ ์ ๋ ฌํ๋ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค. ์๊ฐ๋ณต์ก๋๋ O(n^2)์ ๋๋ค.

๐ก ์ฝ์ ์ ๋ ฌ(Injection Sort)์ ๋ํด ์ค๋ช ํด์ฃผ์ธ์.
์ฝ์ ์ ๋ ฌ์ ๋ ๋ฒ์งธ ๊ฐ๋ถํฐ ์์ํด ๊ทธ ์์ ์กด์ฌํ๋ ์์๋ค๊ณผ ๋น๊ตํ์ฌ ์ฝ์ ํ ์์น๋ฅผ ์ฐพ์ ์ฝ์ ํ๋ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค.
ํ๊ท ์๊ฐ๋ณต์ก๋๋ O(n^2)์ด๋ฉฐ, Best Case ์ ๊ฒฝ์ฐ O(n)๊น์ง ๋์์ง ์ ์์ต๋๋ค.

๐ก ํ ์ ๋ ฌ(Heap Sort)์ ๋ํด ์ค๋ช ํด์ฃผ์ธ์.
ํ ์ ๋ ฌ์ ์ฃผ์ด์ง ๋ฐ์ดํฐ๋ฅผ ํ ์๋ฃ๊ตฌ์กฐ๋ก ๋ง๋ค์ด ์ต๋๊ฐ ๋๋ ์ต์๊ฐ๋ถํฐ ํ๋์ฉ ๊บผ๋ด์ ์ ๋ ฌํ๋ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค.
ํ ์ ๋ ฌ์ด ๊ฐ์ฅ ์ ์ฉํ ๊ฒฝ์ฐ๋ ์ ์ฒด๋ฅผ ์ ๋ ฌํ๋ ๊ฒ์ด ์๋๋ผ ๊ฐ์ฅ ํฐ ๊ฐ ๋ช๊ฐ๋ง์ ํ์๋ก ํ๋ ๊ฒฝ์ฐ์ ๋๋ค.
์๊ฐ ๋ณต์ก๋๋ O(nlogn)์ ๋๋ค.

๐ก ๋ณํฉ ์ ๋ ฌ(Merge Sort)์ ๋ํด ์ค๋ช ํด์ฃผ์ธ์.
๋ณํฉ ์ ๋ ฌ์ ์ฃผ์ด์ง ๋ฐฐ์ด์ ํฌ๊ธฐ๊ฐ 1์ธ ๋ฐฐ์ด๋ก ๋ถํ ํ๊ณ ํฉ๋ณํ๋ฉด์ ์ ๋ ฌ์ ์งํํ๋ ๋ถํ /์ ๋ณต ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค.
์๊ฐ ๋ณต์ก๋๋ O(nlogn)์ ๋๋ค.

๐ก ํต ์ ๋ ฌ(Quick Sort)์ ๋ํด ์ค๋ช ํด์ฃผ์ธ์.
ํต ์ ๋ ฌ์ ๋น ๋ฅธ ์ ๋ ฌ ์๋๋ฅผ ์๋ํ๋ ๋ถํ ์ ๋ณต ์๊ณ ๋ฆฌ์ฆ ์ค ํ๋๋ก ํผ๋ด์ ์ค์ ํ๊ณ ํผ๋ด๋ณด๋ค ํฐ ๊ฐ๊ณผ ์์ ๊ฐ์ผ๋ก ๋ถํ ํ์ฌ ์ ๋ ฌ ํฉ๋๋ค.
๋ณํฉ์ ๋ ฌ๊ณผ ๋ฌ๋ฆฌ ๋ฆฌ์คํธ๋ฅผ ๋น๊ท ๋ฑํ๊ฒ ๋ถํ ํฉ๋๋ค.
์๊ฐ ๋ณต์ก๋๋ O(nlogn)์ด๋ฉฐ worst case ๊ฒฝ์ฐ O(n^2)๊น์ง ๋๋น ์ง ์ ์์ต๋๋ค.

๐ก ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ ์๊ฐ ๋ณต์ก๋ ๋น๊ต ํ

๐ก Big-O ํ๊ธฐ๋ฒ์ ์๊ฐ ๋ณต์ก๋ ํฌ๊ธฐ ์์๋ฅผ ๋งํด์ฃผ์ธ์.
O(1) < O(log N) < O(N) < O(N log N) < O(N^2) < O(2^N) < O(N!)

๐ก ํํ๋ง ์ฝ๋ฉ์ ๋ํด ์ค๋ช ํด์ฃผ์ธ์.
ํํ๋ง ์ฝ๋ฉ์ ๋ฌธ์์ ๋น๋ ์๋ฅผ ๊ฐ์ง๊ณ ์์ถํ๋ ๊ณผ์ ์ ๋งํ๋ฉฐ, ์ ๋๋ถ ์ฝ๋์ ์ต์ ์ฝ๋๋ฅผ ์ฌ์ฉํฉ๋๋ค.
- ์ ๋๋ถ ์ฝ๋ : ๊ฐ ๋ฌธ์์ ๋ถ์ฌ๋ ์ด์ง ์ฝ๋๊ฐ ๋ค๋ฅธ ์ด์ง ์ฝ๋์ ์ ๋๋ถ๊ฐ ๋์ง ์๋ ์ฝ๋ (์ฆ, ๊ฒน์น์ง ์๋๋ก ์ด์ง ์ฝ๋๋ฅผ ๋ง๋๋ ๊ฒ)
- ์ต์ ์ฝ๋ : ์ธ์ฝ๋ฉ๋ ๋ฉ์์ง์ ๊ธธ์ด๊ฐ ๊ฐ์ฅ ์งง์ ์ฝ๋
๐ก ์ฌ๊ท ์๊ณ ๋ฆฌ์ฆ์ ๋ํด ์ค๋ช ํด์ฃผ์ธ์.
์ฌ๊ท ์๊ณ ๋ฆฌ์ฆ์ด๋ ํจ์ ๋ด๋ถ์์ ํจ์๊ฐ ์๊ธฐ ์์ ์ ๋ ๋ค์ ํธ์ถํ์ฌ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ์๊ณ ๋ฆฌ์ฆ์ ๋๋ค.
์๊ธฐ์์ ์ ๊ณ์ํด์ ํธ์ถํ์ฌ ๋์์ด ๋ฐ๋ณต๋๊ฒ ๋๋ฏ๋ก ๋ฐ๋ณต์ ์ค๋จํ ์กฐ๊ฑด์ด ๋ฐ๋์ ํ์ํฉ๋๋ค.
๐ก ํผ๋ณด๋์น ์์ด์ N๋ฒ์งธ ๊ฐ์ ๊ตฌํ๋ ๋ฉ์๋์ ๋ํด ๊ฐ๊ฐ ์ฌ๊ท์ ๋ฐ๋ณต๋ฌธ์ผ๋ก ์์ฝ๋ฉ(๋๋ ์๋์ฝ๋ฉ) ํด์ฃผ์ธ์.
|
private static int recursiveFibonacci(int index) { |
|
if (index <= 2){ |
|
return 1; |
|
} |
|
return recursiveFibonacci(index - 1) + recursiveFibonacci(index - 2); |
|
} |
|
|
|
private static int loopFibonacci(int index) { |
|
int answer = 1; |
|
int before = 1; |
|
int temp; |
|
for (int i = 2; i < index; i++) { |
|
temp = answer; |
|
answer += before; |
|
before = temp; |
|
} |
|
return answer; |
|
} |
๐ก ํฉํ ๋ฆฌ์ผ์ N๋ฒ์งธ ๊ฐ์ ๊ตฌํ๋ ๋ฉ์๋์ ๋ํด ๊ฐ๊ฐ ์ฌ๊ท์ ๋ฐ๋ณต๋ฌธ์ผ๋ก ์์ฝ๋ฉ(๋๋ ์๋์ฝ๋ฉ) ํด์ฃผ์ธ์.
|
private static int recursiveFactorial(int num) { |
|
if(num > 1) { |
|
return recursiveFactorial(num -1) * num; |
|
} |
|
return 1; |
|
} |
|
|
|
private static int loopFactorial(int num) { |
|
int answer = 1; |
|
for(int i = 2; i <= num; i++) { |
|
answer *= i; |
|
} |
|
return answer; |
|
} |
๐ก ์ฝ๋ฉ ํ ์คํธ๋ฅผ ์ํ Tip
Translate this article: How to Rock an Algorithms Interview
1. ์น ํ์ ๊ธ์ฐ๊ธฐ๋ฅผ ์์ํ์ญ์์ค.
์ด๊ฒ์ ๋น์ฐํ๊ฒ ๋ค๋ฆด์ง ๋ชจ๋ฅด์ง๋ง, ๋น ๋ฒฝ์ ์ณ๋ค ๋ณด๋ฉด์ ์์ญ ๋ช ์ ํ๋ณด์๊ฐ ๋ถ์ด ์์ต๋๋ค. ๋๋ ์๋ฌด๊ฒ๋ ๋ณด์ง ์๋ ๊ฒ๋ณด๋ค ๋ฌธ์ ์ ์๋ฅผ ์์ํ๋ ๊ฒ์ด ๋ ์์ฐ์ ์ด๋ผ๊ณ ์๊ฐํฉ๋๋ค. ๊ด๋ จ์ฑ์ด์๋ ๊ทธ๋ฆผ์ ์๊ฐํ ์ ์๋ค๋ฉด ๊ทธ ๊ทธ๋ฆผ์ ๊ทธ๋ฆฝ๋๋ค. ์ค๊ฐ ํฌ๊ธฐ์ ์์ ๊ฐ ์์ผ๋ฉด ์์ ํ ์ ์์ต๋๋ค. (์ค๊ฐ ํฌ๊ธฐ๋ ์์ ๊ฒ๋ณด๋ค ๋ซ์ต๋๋ค.) ๋๋ก๋ ์์ ์์ ์ ๋ํ ์๋ฃจ์ ์ด ์ผ๋ฐํ๋์ง ์๊ธฐ ๋๋ฌธ์ ๋๋ค. ๋๋ ์๊ณ ์๋ ๋ช ๊ฐ์ง ๋ช ์ ๋ฅผ ์ ์ด ๋์ญ์์ค. ๋ญ๋ผ๋ ํ๋ ๊ฒ์ด ์๋ฌด๊ฒ๋ ์ ํ๋ ๊ฒ๋ณด๋ค ๋ซ์ต๋๋ค.
2. ๊ทธ๊ฒ์ ํตํด ์ด์ผ๊ธฐํ์ญ์์ค.
์์ ์ด ํ ๋ง์ด ์ด๋ฆฌ์์ ์๋ฆฌ์ผ๊น ๊ฑฑ์ ํ์ง ๋ง์ญ์์ค. ๋ง์ ์ฌ๋๋ค์ด ๋ฌธ์ ๋ฅผ ์กฐ์ฉํ ์๊ฐํ๋ ๊ฒ์ ์ ํธํ์ง๋ง, ๋ฌธ์ ๋ฅผ ํ๋ค๊ฐ ๋งํ๋ค๋ฉด ๋งํ๋ ๊ฒ์ด ํ ๊ฐ์ง ๋ฐฉ๋ฒ์ด ๋ ์ ์์ต๋๋ค. ๊ฐ๋์ ๋ฉด์ ๊ด์๊ฒ ์งํ ์ํฉ์ ๋ํด์ ๋ช ํํ๊ฒ ๋งํ๋ ๊ฒ์ด ์ง๊ธ ๋ฌธ์ ์์ ๋ฌด์จ ์ผ์ด ์ผ์ด๋๊ณ ์๋์ง ์ดํดํ ์ ์๋ ๊ณ๊ธฐ๊ฐ ๋ ์ ์์ต๋๋ค. ๋น์ ์ ๋ฉด์ ๊ด์ ๋น์ ์ด ๊ทธ ์๊ฐ์ ์ถ๊ตฌํ๋๋ก ๋น์ ์ ๋ฐฉํด ํ ์๋ ์์ต๋๋ค. ๋ฌด์์ ํ๋ ์ง ํํธ๋ฅผ ์ํด ๋ฉด์ ๊ด์ ์์ด๋ ค ํ์ง ๋ง์ญ์์ค. ํํธ๊ฐ ํ์ํ๋ฉด ์ ์งํ๊ฒ ์ง๋ฌธํ์ญ์์ค.
3. ์๊ณ ๋ฆฌ์ฆ์ ์๊ฐํ์ธ์.
๋๋ก๋ ๋ฌธ์ ์ ์ธ๋ถ ์ฌํญ์ ๊ฒํ ํ๊ณ ํด๊ฒฐ์ฑ ์ด ๋น์ ์๊ฒ ๋์ฌ ๊ฒ์ ๊ธฐ๋ํ๋ ๊ฒ์ด ์ ์ฉํฉ๋๋ค (์ด๊ฒ์ด ์ํฅ์ ์ ๊ทผ๋ฒ ์ผ ๊ฒ์ ๋๋ค). ๊ทธ๋ฌ๋ ๋ค๋ฅธ ์๊ณ ๋ฆฌ์ฆ์ ๋ํด์๋ ์๊ฐํด ๋ณผ ์ ์์ผ๋ฉฐ ๊ฐ๊ฐ์ ์๊ณ ๋ฆฌ์ฆ์ด ๋น์ ์์ ๋ฌธ์ ์ ์ ์ฉ๋๋์ง๋ฅผ ์ง๋ฌธ ํ ์ ์์ต๋๋ค (ํํฅ์ ์ ๊ทผ๋ฒ). ์ด๋ฌํ ๋ฐฉ์์ผ๋ก ์ฐธ์กฐ ํ๋ ์์ ๋ณ๊ฒฝํ๋ฉด ์ข ์ข ์ฆ๊ฐ์ ์ธ ํต์ฐฐ๋ ฅ์ ์ป์ ์ ์์ต๋๋ค. ๋ค์์ ๋ฉด์ ์์ ์๊ตฌํ๋ ๋ฌธ์ ์ ์ ๋ฐ ์ด์์ ํด๊ฒฐํ๋ ๋ฐ ๋์์ด๋๋ ์๊ณ ๋ฆฌ์ฆ ๊ธฐ๋ฒ์ ๋๋ค.
- Sorting (plus searching / binary search)
- Divide and Conquer
- Dynamic Programming / Memoization
- Greediness
- Recursion
- Algorithms associated with a specific data structure (which brings us to our fourth suggestion...)
4. ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ฅผ ์๊ฐํ์ญ์์ค.
์์ 10 ๊ฐ ๋ฐ์ดํฐ ๊ตฌ์กฐ๊ฐ ์ค์ ์ธ๊ณ์์ ์ฌ์ฉ๋๋ ๋ชจ๋ ๋ฐ์ดํฐ ๊ตฌ์กฐ์ 99 %๋ฅผ ์ฐจ์งํ๋ค๋ ๊ฒ์ ์๊ณ ๊ณ์ จ์ต๋๊น? ๋๋ก๋ ์ต์ ์ ์๋ฃจ์ ์ด ๋ธ๋ฃธ ํํฐ ๋๋ ์ ๋ฏธ์ด ํธ๋ฆฌ๋ฅผ ํ์๋กํ๋ ๋ฌธ์ ๋ฅผ ๋ฌป์ต๋๋ค. ํ์ง๋ง ์ด๋ฌํ ๋ฌธ์ ์กฐ์ฐจ๋ ํจ์ฌ ๋ ์ผ์์ ์ธ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํ๋ ์ต์ ์ ์๋ฃจ์ ์ ์ฌ์ฉํ๋ ๊ฒฝํฅ์ด ์์ต๋๋ค. ๊ฐ์ฅ ์์ฃผ ํ์ ๋ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
- Array
- Stack / Queue
- HashSet / HashMap / HashTable / Dictionary
- Tree / Binary tree
- Heap
- Graph
5. ์ด์ ์ ๋ณด์๋ ๊ด๋ จ ๋ฌธ์ ์ ํด๊ฒฐ ๋ฐฉ๋ฒ์ ๋ํด ์๊ฐํด๋ณด์ญ์์ค.
์ฌ๋ฌ๋ถ์๊ฒ ์ ์ํ ๋ฌธ์ ๋ ์ด์ ์ ๋ณด์๋ ๋ฌธ์ ์ด๊ฑฐ๋ ์ ์ด๋ ์กฐ๊ธ์ ์ ์ฌํฉ๋๋ค. ์ด๋ฌํ ์๋ฃจ์ ์ ๋ํด ์๊ฐํด๋ณด๊ณ ๋ฌธ์ ์ ์ธ๋ถ ์ฌํญ์ ์ด๋ป๊ฒ ์ ์ํ ์ ์๋์ง ์๊ฐํ์ญ์์ค. ๋ฌธ์ ๊ฐ ์ ๊ธฐ๋๋ ํํ๋ก ๋์ด์ง์ง๋ ๋ง์ญ์์ค. ํต์ฌ ๊ณผ์ ๋ก ๋์ด ๊ฐ์ ๊ณผ๊ฑฐ์ ํด๊ฒฐ ํ ๊ฒ๊ณผ ์ผ์นํ๋์ง ํ์ธํ์ญ์์ค.
6. ๋ฌธ์ ๋ฅผ ์์ ๋ฌธ์ ๋ก ๋ถํดํ์ฌ ์์ ํ์ญ์์ค.
ํน๋ณํ ๊ฒฝ์ฐ ๋๋ ๋ฌธ์ ์ ๋จ์ํ ๋ ๋ฒ์ ์ ํด๊ฒฐํ์ญ์์ค. ์ฝ๋ ์ผ์ด์ค๋ฅผ ๋ณด๋ ๊ฒ์ ๋ฌธ์ ์ ๋ณต์ก์ฑ๊ณผ ๋ฒ์๋ฅผ ์ ํํ๋ ์ข์ ๋ฐฉ๋ฒ์ ๋๋ค. ๋ฌธ์ ๋ฅผ ํฐ ๋ฌธ์ ์ ํ์ ์งํฉ์ผ๋ก ์ถ์ํ๋ฉด ์์ ๋ถ๋ถ๋ถํฐ ์์ํ์ฌ ์ ์ฒด ๋ฒ์๊น์ง ์์ ์ ์งํํ ์ ์์ต๋๋ค. ์์ ๋ฌธ์ ์ ๊ตฌ์ฑ์ผ๋ก ๋ฌธ์ ๋ฅผ ๋ณด๋ ๊ฒ๋ ๋์์ด ๋ ์ ์์ต๋๋ค.
7. ๋๋์ ์ค๋ ๊ฒ์ ๋๋ ค์ํ์ง ๋ง์ญ์์ค.
ํน์ ์ ๊ทผ๋ฒ์ด ํจ๊ณผ์ ์ด์ง ์๋ค๊ณ ๋๋ผ๋ฉด ๋ค๋ฅธ ์ ๊ทผ ๋ฐฉ์์ ์๋ ํ ๋๊ฐ ์์ต๋๋ค. ๋ฌผ๋ก ๋๋ฌด ์ฝ๊ฒ ํฌ๊ธฐํด์๋ ์๋ฉ๋๋ค. ๊ทธ๋ฌ๋ ์ด๋งค๋ฅผ ๋งบ์ง ์๊ณ ๋ ์ ๋งํ ์๊ฐ์ด ๋ค์ง ์๋ ์ ๊ทผ๋ฒ์ ๋ช ๋ถ์ ์๋นํ๋ค๋ฉด, ๋ฐฑ์ ํ๊ณ ๋ค๋ฅธ ๊ฒ์ ์๋ํด๋ณด์ญ์์ค. ์ ๋ ๋ ์ ๊ทผํ ์ง์์๋ณด๋ค ํ์ฐธ ๋ ๋ง์ด ๋์๊ฐ ์ง์์๋ฅผ ๋ง์ด ๋ณด์์ต๋๋ค. ์ฆ, (๋ชจ๋ ํ๋ฑ ํ) ๋ค๋ฅธ ์ฌ๋๋ค์ด ์ข ๋ ๊ธฐ๋ฏผํ ์ ๊ทผ ๋ฐฉ์์ ํฌ๊ธฐํด์ผ ํ๋ค๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค.
๐ก ๋ฌธ์ ํด๊ฒฐ์ ์ํ ์ ๋ต์ ์ ๊ทผ
์ฝ๋ฉ ํ ์คํธ์ ๋ชฉ์
- ๋ฌธ์ ํด๊ฒฐ ์ฌ๋ถ
- ์์ธ ์ํฉ๊ณผ ๊ฒฝ๊ณ๊ฐ ์ฒ๋ฆฌ
- ์ฝ๋ ๊ฐ๋ ์ฑ๊ณผ ์ค๋ณต ์ ๊ฑฐ ์ฌ๋ถ ๋ฑ ์ฝ๋ ํ์ง
- ์ธ์ด ์ดํด๋
- ํจ์จ์ฑ
๊ถ๊ทน์ ์ผ๋ก๋ ๋ฌธ์ ํด๊ฒฐ ๋ฅ๋ ฅ์ ์ธก์ ํ๊ธฐ ์ํจ์ด๋ฉฐ ์ด๋ '์ด๋ป๊ฒ ์ด ๋ฌธ์ ๋ฅผ ์ฐฝ์์ ์ผ๋ก ํด๊ฒฐํ ๊ฒ์ธ๊ฐ'๋ฅผ ์ธก์ ํ๊ธฐ ์ํจ์ด๋ผ๊ณ ๋ณผ ์ ์๋ค.
์ ๊ทผํ๊ธฐ
- ๋ฌธ์ ๋ฅผ ๊ณต๊ฒฉ์ ์ผ๋ก ๋ฐ์๋ค์ด๊ณ ํ์ํ ์ ๋ณด๋ฅผ ์ถ๊ฐ์ ์ผ๋ก ์๊ตฌํ์ฌ, ํด๋น ๋ฌธ์ ์ ๋ํด ์๋ฒฝํ๊ฒ ์ดํดํ๋๊ฒ ์ฐ์ ์ด๋ค.
- ํด๋น ๋ฌธ์ ๋ฅผ ์ต์ํ ์ฉ์ด๋ก ์ฌ์ ์ํ๊ฑฐ๋ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํ ์ ๋ณด๋ฅผ ์ถ์ถํ๋ค. ์ด ๊ณผ์ ์ ์ถ์ํ๋ผ๊ณ ํ๋ค.
- ์ถ์ํ๋ ๋ฐ์ดํฐ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ์ด ๋ฌธ์ ๋ฅผ ์ด๋ป๊ฒ ํด๊ฒฐํ ์ง ๊ณํ์ ์ธ์ด๋ค. ์ด ๋ ์ฌ์ฉํ ์๊ณ ๋ฆฌ์ฆ๊ณผ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๊ณ ๋ฏผํ๋ค.
- ์ธ์ด ๊ณํ์ ๋ํด ๊ฒ์ฆ์ ํด๋ณธ๋ค. ์๋ ์ฝ๋ ์์ฑ๋ ํด๋น๋ ์ ์๊ณ ๋ฌธ์ ์ถ์ ์์๊ฒ ์๊ฒฌ์ ๋ฌผ์ด๋ณผ ์๋ ์๋ค.
- ์ธ์ด ๊ณํ์ผ๋ก ๋ฌธ์ ๋ฅผ ํด๊ฒฐํด๋ณธ๋ค. ํด๊ฒฐ์ด ์ ๋๋ค๋ฉด ์์ ๊ณผ์ ์ ๋์ง์ด๋ณธ๋ค.
์๊ฐํ ๋
- ๋น์ทํ ๋ฌธ์ ๋ฅผ ์๊ฐํด๋ณธ๋ค.
- ๋จ์ํ ๋ฐฉ๋ฒ์ผ๋ก ์์ํ์ฌ ์ ์ง์ ์ผ๋ก ๊ฐ์ ํด๋๊ฐ๋ค.
- ์์ ๊ฐ์ ์๊ฐํด๋ณธ๋ค.
- ๊ทธ๋ฆผ์ผ๋ก ๊ทธ๋ ค๋ณธ๋ค.
- ์์์ผ๋ก ํํํด๋ณธ๋ค.
- ์์๋ฅผ ๊ฐ์ ํด๋ณธ๋ค.
- ๋ค์์๋ถํฐ ์๊ฐํด๋ณธ๋ค.
์ถ์ฒ: https://dev-coco.tistory.com/160?category=1056309 [์ฌ๊ธฐ๋ก์ด ๊ฐ๋ฐ์ํ:ํฐ์คํ ๋ฆฌ]
'์๊ณ ๋ฆฌ์ฆ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
<C++ ์๊ณ ๋ฆฌ์ฆ> Factorial (0) | 2021.10.04 |
---|---|
<C++ ์๊ณ ๋ฆฌ์ฆ> ๋ถ๋ถ ๋ฌธ์์ด ๊ฐ์ (0) | 2021.10.04 |
<C++ ์๊ณ ๋ฆฌ์ฆ> ๊ตฌ์ฌ ์ ๋ ฌ (๋ฒ๋ธ ์ ๋ ฌ ํ์ฉ) (0) | 2021.10.04 |
<C++ ์๊ณ ๋ฆฌ์ฆ> ์ง๋ถ๋ถ์งํฉ ๊ตฌํ๊ธฐ (0) | 2021.10.04 |
<C++ ์๊ณ ๋ฆฌ์ฆ> ๊ธ์ ๊ฑฐ๊พธ๋ก ์ถ๋ ฅ(์คํํ์ฉ) (0) | 2021.09.15 |