-
Chap1 1.1 Algorithms : problem, solution, algorithm์๊ณ ๋ฆฌ์ฆ ์ค๊ณ ๋ฐ ์ค์ต 2025. 4. 4. 22:23
1.1 Algorithms ์์ฝ
๐ 1. ๋ฌธ์ (Problem)
- ์ด๋ค ์ง๋ฌธ ๋๋ ์์ (task)์ ๋ํ ์ผ๋ฐ์ ์ธ ๊ธฐ์
- ์์:
- ์ ๋ ฌ ๋ฌธ์ : n๊ฐ์ ์ซ์๊ฐ ์๋ ๋ฆฌ์คํธ S๋ฅผ ๋น๊ฐ์ ์์ผ๋ก ์ ๋ ฌํ๋ผ
- ํ์ ๋ฌธ์ : ๋ฆฌ์คํธ S ์์ x๋ผ๋ ๊ฐ์ด ์กด์ฌํ๋์ง ํ๋จํ๋ผ
๐ 2. ์ธ์คํด์ค(Instance)
- ๋ฌธ์ ์ ํน์ ํ ์ ๋ ฅ ๊ฐ ์งํฉ
- ์:
- ๋ฆฌ์คํธ S = [10, 7, 8, 11, 5, 13]์ด๊ณ , n = 6์ธ ๊ฒฝ์ฐ → ์ ๋ ฌ ๋ฌธ์ ์ ์ธ์คํด์ค
- x = 11์ธ ๊ฒฝ์ฐ → ํ์ ๋ฌธ์ ์ ์ธ์คํด์ค
๐ 3. ํด(Solution)
- ์ธ์คํด์ค๋ฅผ ํด๊ฒฐํ ๊ฒฐ๊ณผ
- ์ ์์์ ์ ๋ ฌ์ ๊ฒฐ๊ณผ๋ [5, 7, 8, 10, 11, 13]
- ํ์ ๊ฒฐ๊ณผ๋ “Yes, x is in S”
๐ 4. ์๊ณ ๋ฆฌ์ฆ(Algorithm)
- ๋ฌธ์ ์ ๋ชจ๋ ์ธ์คํด์ค๋ฅผ ํ ์ ์๋ ์ผ๋ฐ์ ์ธ ๋จ๊ณ๋ณ ์ ์ฐจ
- essential ํน์ฑ 5๊ฐ์ง:
- ์ ๋ ฅ(Input): 0๊ฐ ์ด์
- ์ถ๋ ฅ(Output): ์ ์ด๋ ํ๋ ์ด์
- ๋ช ํ์ฑ(Definiteness): ๊ฐ ๋จ๊ณ๋ ๋ช ํํ ์ ์๋์ด์ผ ํจ
- ์ ํ์ฑ(Finiteness): ์ ํํ ์๊ฐ ๋ด์ ์ข ๋ฃ๋์ด์ผ ํจ
- ์ ํ์ฑ(correctiness)
- optional ํน์ฑ
- ํจ๊ณผ์ฑ(Effectiveness): ๊ฐ ๋จ๊ณ๋ ์ค์ง์ ์ผ๋ก ์ํ ๊ฐ๋ฅํด์ผ ํจ
- generality
"we must specify a general step-by-step procedure for producing the solution to each instance. This step-by-step procedure is called an algorithm. We say that the algorithm solves the problem."
๐ ํด์:
์ฐ๋ฆฌ๋ ๊ฐ ๋ฌธ์ ์ธ์คํด์ค์ ๋ํ ํด๋ต์ ๋์ถํ๊ธฐ ์ํ ์ผ๋ฐ์ ์ธ ๋จ๊ณ๋ณ ์ ์ฐจ๋ฅผ ๋ช ํํ ํด์ผ ํ๋ค. ์ด๋ฌํ ๋จ๊ณ๋ณ ์ ์ฐจ๋ฅผ ์๊ณ ๋ฆฌ์ฆ(algorithm) ์ด๋ผ๊ณ ๋ถ๋ฅธ๋ค. ์ฐ๋ฆฌ๋ ์ด ์๊ณ ๋ฆฌ์ฆ์ด ํด๋น ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ค๊ณ ๋งํ๋ค.
์ฆ, ์ด๋ค ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด์ ๋ชจ๋ ๊ฒฝ์ฐ์ ์ ์ฉํ ์ ์๋ ์ฒด๊ณ์ ์ธ ๋จ๊ณ๋ค์ด ํ์ํ๊ณ , ๊ทธ๊ฒ์ด ๋ฐ๋ก ์๊ณ ๋ฆฌ์ฆ์ด๋ผ๋ ๊ฒ์ด๋ค.
๐ ์์ : Sequential Search
Algorithm SequentialSearch(S, x) for i = 1 to n if S[i] == x then return i return 0 // not found- ๋ฆฌ์คํธ์์ x๋ฅผ ์ฒ์๋ถํฐ ๋๊น์ง ๋น๊ต
- ๋จ์ํ์ง๋ง ๋นํจ์จ์ (ํนํ ๋ฆฌ์คํธ๊ฐ ํด ๊ฒฝ์ฐ)
๐ง pseudocode(์์ฌ์ฝ๋)๋?
๐ ์ ์
pseudocode๋ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ ์์ฐ์ด์ ์ค๊ฐ ํํ๋ก ์์ฑ๋ ์ฝ๋์ ๋๋ค.
์ฆ, ์ฌ๋์ด ์ดํดํ๊ธฐ ์ฝ๊ฒ ์ด ์ฝ๋ ํํ์ ์๊ณ ๋ฆฌ์ฆ ์ค๋ช ์ด์์.- ์ค์ ๋ก ์คํ๋๋ ์ฝ๋๋ ์๋์ง๋ง
- ์ปดํจํฐ ํ๋ก๊ทธ๋๋จธ๊ฐ ์ฝ๊ฒ ์ฝ๋๋ฅผ ๊ตฌํํ ์ ์๋๋ก
- ์๊ณ ๋ฆฌ์ฆ์ ๋ ผ๋ฆฌ์ ์ธ ํ๋ฆ๋ง์ ํํํฉ๋๋ค.
๐ pseudocode์ ํน์ง
ํน์ง ์ค๋ช ์ธ์ด ์ค๋ฆฝ์ ํน์ ์ธ์ด(C++, Java, Python ๋ฑ)์ ์ข ์๋์ง ์์ ๊ฐ๊ฒฐํจ ๋ถํ์ํ ๋ฌธ๋ฒ์ ์ ์ธํ๊ณ ํต์ฌ ๋ก์ง๋ง ํํ ๋ช ํ์ฑ ์๊ณ ๋ฆฌ์ฆ์ ํต์ฌ ๊ตฌ์กฐ์ ํ๋ฆ์ด ์ ๋๋ฌ๋จ ์ฌ๋ ์ค์ฌ ์ปดํจํฐ๋ณด๋ค ์ฌ๋์ด ์ดํดํ๊ธฐ ์ฌ์
๐งพ ์์ ๋น๊ต
๐ป ์ค์ C++ ์ฝ๋
int sequentialSearch(int S[], int n, int x) { for (int i = 0; i < n; i++) { if (S[i] == x) return i; } return -1; }๐ pseudocode ๋ฒ์
Algorithm SequentialSearch(S, x) for i = 1 to n if S[i] == x then return i return 0→ ๋ฐฐ์ด ์ธ๋ฑ์ค๋ 1๋ถํฐ ์์ํ ์ ์๊ณ , ํ์ ์ ์ธ๋ ์๊ณ , ;๋ {} ๊ฐ์ ๋ฌธ๋ฒ๋ ์์ต๋๋ค.
→ ๋ ผ๋ฆฌ๋ง ๋จ๊ธฐ๊ณ ๋ฌธ๋ฒ์ ๋บ ๊ฒ์ด ๋ฐ๋ก pseudocode์ ๋๋ค.
โจ ์ pseudocode๋ฅผ ์ฐ๋ ๊ฑธ๊น?
- ์๊ณ ๋ฆฌ์ฆ ์ค๋ช ์ ์ง์คํ๊ธฐ ์ํด (ํ๋ก๊ทธ๋๋ฐ ์ธ์ด ๋ฌธ๋ฒ์ ์๋ต)
- ๋ค์ํ ์ธ์ด ์ฌ์ฉ์์๊ฒ ๊ณตํต๋ ํํ ์ ๊ณต
- ์๊ณ ๋ฆฌ์ฆ ๊ต์ฌ, ๋ ผ๋ฌธ, ์ํ ๋ฑ์์ ํ์ค์ ์ผ๋ก ์ฌ์ฉ
๐ Pseudocode ๊ด๋ จ ์ ๋ฆฌ (26ํ์ด์ง ๊ธฐ์ค)
๋ฐฐ์ด ์ธ๋ฑ์ค๋ 1๋ถํฐ ์ฌ์ฉ
- C++์์๋ ๋ฐฐ์ด ์ธ๋ฑ์ค๋ฅผ 0๋ถํฐ ์์ํ์ง๋ง
- Pseudocode์์๋ ๋ณดํต 1๋ถํฐ ์์
→ ์ฌ๋์ด ๋ฆฌ์คํธ๋ฅผ ์ธ๋ ๋ฐฉ์๊ณผ ์์ฐ์ค๋ฝ๊ฒ ๋ง์ถฐ ์ค๋ช ์ด ์ฌ์์ง
๐ ์์:
Inputs: positive integer n, array of numbers S indexed from 1 to n
Pseudocode ๋ฌธ๋ฒ ํน์ง ์ ๋ฆฌ
ํญ๋ชฉ Pseudocodeํํ C++ํํ ๋ฐฐ์ด ์ธ๋ฑ์ค 1๋ถํฐ 0๋ถํฐ ์กฐ๊ฑด์ if (low ≤ x ≤ high) if (low <= x && x <= high) ๊ฐ ๊ตํ exchange x and y temp = x; x = y; y = temp; ๐ Pseudocode๋ ์ํ์ ํํ์ ๊ทธ๋๋ก ์ฌ์ฉํ์ฌ ๊ฐ๊ฒฐํจ๊ณผ ๋ช ํ์ฑ์ ์ถ๊ตฌํจ.
๋ฐฐ์ด ์ ์ธ๊ณผ ์ฌ์ฉ
- ์ธ๋ฑ์ค ๋ฒ์๋ฅผ ๋ช ํํ ํํ: S[2..n] ← 2๋ถํฐ n๊น์ง ์ธ๋ฑ์ฑ๋จ
- 2์ฐจ์ ๋ฐฐ์ด๋ ์์ ๋กญ๊ฒ ์ธ๋ฑ์ค ๋ฒ์ ์ง์ ๊ฐ๋ฅ
- S[2..n] ํํ์ C++์๋ ์๊ณ pseudocode ์ ์ฉ ํ๊ธฐ์
๋ฐ์ดํฐ ํ์ ํํ (์ถ์์ ํํ)
Pseudocode์์๋ C++์ฒ๋ผ ๊ตฌ์ฒด์ ํ์ ๋ณด๋ค ์ญํ ์ค์ฌ์ ํ์ ๋ช ์ ์ฌ์ฉ
ํ์ ์ด๋ฆ์ค๋ชํ์ ์ด๋ฆ ์ค๋ช keytype ์ ๋ ฌ/ํ์ ๋์์ด ๋๋ ํค ๊ฐ ํ์ index ๋ฐฐ์ด์ ์ธ๋ฑ์ฑํ๋ ์ ์ํ ๋ณ์ number ์ ์ ๋๋ ์ค์ ๋ชจ๋ ํฌํจ ๊ฐ๋ฅํ ์ซ์ bool true / false ๊ฐ์ ๊ฐ์ง๋ ๋ ผ๋ฆฌํ
๋ฐ๋ณต๋ฌธ ํํ
repeat n times ...- C++์์๋ for๋ฌธ์ ์จ์ผ ํ์ง๋ง pseudocode๋ ์๋ฏธ ์ค์ฌ์ผ๋ก ๊ฐ๋จํ ํํ
- ๋ฐ๋ณต ํ์๋ง ์ค์ํ ๋ ๋ฐ๋ณต ์ ์ด ๋ณ์ ์๋ต ๊ฐ๋ฅ
ํจ์ vs ํ๋ก์์ ๊ตฌ๋ถ
๊ตฌ๋ถ ์ค๋ช ์์ Function ๊ฐ์ ๋ฐํ(return) function Sum(S): number Procedure ๊ฐ์ ๋ฐํํ์ง ์์ (void) procedure Sort(S) - ๋ฐฐ์ด ๋ฑ์ ์๋์ผ๋ก ์ฐธ์กฐ๋ก ์ ๋ฌ๋๋ฏ๋ก & ์ ๋ถ์
- const๋ ๋ฐฐ์ด์ด ์ฝ๊ธฐ ์ ์ฉ์์ ์๋ฏธ
๐ ํต์ฌ ์์ฝ
- pseudocode๋ ์ธ์ด์ ๊ตฌ์ ๋ฐ์ง ์๊ณ ์๊ณ ๋ฆฌ์ฆ ๋ ผ๋ฆฌ๋ฅผ ์ฝ๊ฒ ํํํ๊ธฐ ์ํ ๋๊ตฌ
- ์ง๊ด์ ํํ + ๊ฐ๊ฒฐํจ์ ์ค์
- ์ํ์ ํํ ํ์ฉ (์: ≤, exchange, repeat ๋ฑ)
- ๊ตฌํ๋ณด๋ค๋ ์๊ณ ๋ฆฌ์ฆ ์ดํด์ ์ง์คํด์ผ ํ ๋ ์ฌ์ฉ
๐ก ์์ ์๊ณ ๋ฆฌ์ฆ ์ ๋ฆฌ
๐น Algorithm 1.1: Sequential Search
๋ฌธ์ : ๋ฐฐ์ด S ์์ key x๊ฐ ์๋์ง ์ฐพ์๋ผ
์ ๋ ฅ: ์ ์ n, ๋ฐฐ์ด S[1..n], key x
์ถ๋ ฅ: x๊ฐ ์์ผ๋ฉด ์ธ๋ฑ์ค, ์์ผ๋ฉด 0procedure SequentialSearch(S[1..n], x) for i = 1 to n if S[i] == x then return i return 0๐ ํน์ง
- ๋ฐฐ์ด ์์๋๋ก x๋ฅผ ๋น๊ตํจ
- ์ ๋ ฌ๋์ด ์์ง ์์๋ ์ฌ์ฉ ๊ฐ๋ฅ
- ์๊ฐ๋ณต์ก๋:
- ์ต์ : O(n)
- ์ต์ : O(1)
๐น Algorithm 1.2: Add Array Members
๋ฌธ์ : ๋ฐฐ์ด S์ ๋ชจ๋ ์์์ ํฉ์ ๊ตฌํ๋ผ
์ ๋ ฅ: ์ ์ n, ๋ฐฐ์ด S[1..n]
์ถ๋ ฅ: ํฉ๊ณ sumfunction AddArrayMembers(S[1..n]): number // ํจ์๊ฐ ๋ฐํํ๋ ๊ฐ(return value)์ ํ์ sum ← 0 for i = 1 to n sum ← sum + S[i] return sum๐ ํน์ง
- ํฉ๊ณ๋ฅผ ๋์ ํ๋ ๋จ์ ๋ฐ๋ณต
- ํญ์ n๋ฒ ๋ฐ๋ณต → ์๊ฐ๋ณต์ก๋ O(n)
๐น Algorithm 1.3: Exchange Sort
๋ฌธ์ : ๋ฐฐ์ด S๋ฅผ ๋น๊ฐ์ ์(์ค๋ฆ์ฐจ์)์ผ๋ก ์ ๋ ฌ
์ ๋ ฅ: ์ ์ n, ๋ฐฐ์ด S[1..n]
์ถ๋ ฅ: ์ ๋ ฌ๋ ๋ฐฐ์ด Sprocedure ExchangeSort(S[1..n]) for i = 1 to n-1 for j = i+1 to n if S[j] < S[i] then exchange S[i] and S[j]๐ ํน์ง
- ๋งค์ฐ ๊ธฐ์ด์ ์ธ ์ ๋ ฌ ๋ฐฉ์
- ๋ชจ๋ ์์ ๋น๊ตํ์ฌ ์ ๋ ฌ
- ์๊ฐ๋ณต์ก๋: O(n²)
๐น Algorithm 1.4: Matrix Multiplication
๋ฌธ์ : ๋ ์ ๋ฐฉ ํ๋ ฌ A, B๋ฅผ ๊ณฑํ์ฌ C๋ฅผ ๊ตฌํ๋ผ
์ ๋ ฅ: ์ ์ n, A[n×n], B[n×n]
์ถ๋ ฅ: C[n×n] = A × Bprocedure MatrixMultiplication(A[1..n,1..n], B[1..n,1..n], C[1..n,1..n]) for i = 1 to n for j = 1 to n C[i,j] ← 0 for k = 1 to n C[i,j] ← C[i,j] + A[i,k] × B[k,j]๐ฏ ๋ชฉ์
๋ ์ ๋ฐฉ ํ๋ ฌ A[n×n]๊ณผ B[n×n]๋ฅผ ๊ณฑํ์ฌ ๊ฒฐ๊ณผ ํ๋ ฌ C[n×n]์ ๊ตฌํ๋ผ.
๐ ํ๋ ฌ ๊ณฑ์ ์ ์ ๋ณต์ต
๋ ํ๋ ฌ์ ๊ณฑ C = A × B์์
C[i][j]์ ๊ฐ์ ๋ค์๊ณผ ๊ฐ์ด ๊ณ์ฐ๋จ:C[i][j]=A[i][1]⋅B[1][j]+A[i][2]⋅B[2][j]+โฏ+A[i][n]⋅B[n][j]
์ฆ,
- A์ i๋ฒ์งธ ํ๊ณผ B์ j๋ฒ์งธ ์ด์ ๊ณฑํด์ ๋ํ ๊ฐ
pseudocode ๋ถ์
procedure MatrixMultiplication(A[1..n,1..n], B[1..n,1..n], C[1..n,1..n]) for i = 1 to n โถ C์ ํ ์ธ๋ฑ์ค for j = 1 to n โถ C์ ์ด ์ธ๋ฑ์ค C[i,j] ← 0 โถ C[i][j] ๊ฐ ์ด๊ธฐํ for k = 1 to n โถ A์ B์ ๊ณฑ์ ์ ํ์ํ ์ธ๋ฑ์ค C[i,j] ← C[i,j] + A[i,k] × B[k,j]๐ ๋ฐ๋ณต ๊ตฌ์กฐ ์์ฝ
๋ฐ๋ณต๋ฌธ ์๋ฏธ i ๋ฐ๋ณต A์ ํ (C์ ํ) j ๋ฐ๋ณต B์ ์ด (C์ ์ด) k ๋ฐ๋ณต A์ ํ x B์ ์ด ์ฑ๋ถ ํ๋์ฉ ๊ณฑํ๋ฉด์ ๋์ ํฉ ๊ณ์ฐ ๐ ์์ (2×2 ํ๋ ฌ ๊ณฑ์ )

โฑ ์๊ฐ ๋ณต์ก๋
- 3์ค ๋ฐ๋ณต๋ฌธ → n × n × n = O(n³)
- ํ๋ ฌ ํฌ๊ธฐ๊ฐ ์ปค์ง์๋ก ๊ณ์ฐ๋ ๊ธ๊ฒฉํ ์ฆ๊ฐ
๐ ์์ฝ
ํญ๋ชฉ ๋ด์ฉ ํต์ฌ ์์ด๋์ด A์ ํ๊ณผ B์ ์ด์ ๊ณฑํด์ ๋์ ์ธ๋ฑ์ค ์ญํ i: ํ / j: ์ด / k: ๋์ ์ธ๋ฑ์ค ๋ณต์ก๋ O(n³) ์ฃผ์ํ ์ C[i][j]๋ ๊ผญ 0์ผ๋ก ์ด๊ธฐํํด์ผ ํจ
pseudocode ์ฌ์ฉ ๋ฐฉ์ ๋ณด์ถฉ ์ค๋ช
- exchange x and y ๊ฐ์ด ์ง๊ด์ ์ผ๋ก ์ฐ๋ ํํ ์ฌ์ฉ
- ๋ฐ๋ณต๋ฌธ๋ repeat n times ๊ฐ์ด ์ฌํํ ํํ ํ์ฉ
- ๋ฐฐ์ด ์ธ๋ฑ์ค๋ 1๋ถํฐ ์์ํ๋ฉฐ, ๋ฒ์ ๋ช ์ (ex: S[2..n])
- ๋ฐฐ์ด์ ์๋ ์ฐธ์กฐ ์ ๋ฌ(call by address)
→ ๋ณ๋๋ก & ๋ถ์ด์ง ์์ - const๋ ๋ฐฐ์ด์ด ์ฝ๊ธฐ ์ ์ฉ์์ ํ์
๐ง ์ํ ๋๋น ์ฒดํฌํฌ์ธํธ
์ฒดํฌ๋ด์ฉ์ฒดํฌ ๋ด์ฉ โ pseudocode๋ C++๋ณด๋ค ๊ฐ๋จํ๊ณ ์ํ์ ํํ ํ์ฉ โ ๋ฐฐ์ด ์ธ๋ฑ์ค๋ ๊ธฐ๋ณธ์ ์ผ๋ก 1๋ถํฐ ์ฌ์ฉ โ ๊ฐ ์๊ณ ๋ฆฌ์ฆ์ ์ ๋ ฅ/์ถ๋ ฅ/๊ธฐ๋ณธ ๋์ ํ์ โ ์๊ฐ๋ณต์ก๋๋ ๋ฐ๋์ ๊ธฐ์ตํ ๊ฒ (ํนํ O(n), O(n²), O(n³) ๊ตฌ๋ถ) '์๊ณ ๋ฆฌ์ฆ ์ค๊ณ ๋ฐ ์ค์ต' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
Chap 1.3 Analysis of Algorithms (0) 2025.04.05 Chap1 1.2 The Importance of Developing Efficient Algorithms (0) 2025.04.04 Chap1 - 0. ํ์ต ๋ชฉํ ๋ฐ ๋ฐฉ๋ฒ (0) 2025.04.04