마스터 정리: Difference between revisions

From CS Wiki
(Created page with "'''마스터 정리'''(Master Theorem)는 분할 정복 알고리즘의 시간 복잡도를 분석하는 데 사용되는 수학적 정리이다. 주어진 재귀 관계식을 일반적인 형태로 변환하여 알고리즘의 실행 시간을 평가할 수 있도록 도와준다. ==개요== 마스터 정리는 특정 유형의 재귀 관계식을 해결하는 방법을 제공하며, 특히 분할 정복 알고리즘의 시간 복잡도를 분석하는 데 유용하다....")
 
No edit summary
Line 1: Line 1:
'''마스터 정리'''(Master Theorem)는 분할 정복 알고리즘의 시간 복잡도를 분석하는 사용되는 수학적 정리이다. 주어진 재귀 관계식을 일반적인 형태로 변환하여 알고리즘의 실행 시간을 평가할 수 있도록 도와준다.
'''마스터 정리'''(Master Theorem)는 분할 정복법(Divide and Conquer)을 사용한 알고리즘의 시간 복잡도를 계산하는 유용한 수학적 도구이다. 정리는 재귀적 알고리즘의 시간 복잡도를 분석하는 데 사용되며, 특히 재귀식이 다음과 같은 형태로 주어졌을 때 적용할 수 있다.
==개요==
마스터 정리는 특정 유형의 재귀 관계식을 해결하는 방법을 제공하며, 특히 분할 정복 알고리즘의 시간 복잡도를 분석하는 데 유용하다. 이 정리는 다음과 같은 형태의 점화식을 해석하는 데 사용된다.


<math> T(n) = aT(n/b) + f(n) </math>
== 정의 ==
마스터 정리는 다음과 같은 형태의 재귀식을 분석하는 데 사용된다:


여기서
* T(n) = aT(n / b) + O(n^d)
*'''a''' : 하위 문제의 개수
*'''b''' : 입력 크기 축소 비율
*'''f(n)''' : 추가적인 작업(주어진 단계에서 수행하는 연산)
마스터 정리를 사용하면 위와 같은 점화식을 세 가지 경우로 나누어 시간 복잡도를 분석할 수 있다.
==마스터 정리의 세 가지 경우==
마스터 정리는 다음과 같은 세 가지 경우(case)로 나뉜다.
*'''Case 1: f(n) = O(n^c)''' 이고, c < log_b(a)
**대부분의 연산이 하위 문제에서 발생하며, 전체 시간 복잡도는 재귀 호출에 의해 결정된다.
**결과: <math> T(n) = O(n^{\log_b a}) </math>


*'''Case 2: f(n) = Θ(n^c)''' 이고, c = log_b(a)
여기서:
**하위 문제와 추가 연산의 기여도가 비슷하며, 전체 시간 복잡도는 이 두 요소에 의해 균형을 이룬다.
* T(n)은 문제 크기가 n일 때의 시간 복잡도.
**결과: <math> T(n) = O(n^c \log n) </math>
* a는 문제를 분할하는 횟수 (, 자식 문제의 수).
* b는 각 자식 문제의 크기 비율.
* d는 각 분할된 문제에 대해 수행하는 작업의 복잡도.


*'''Case 3: f(n) = O(n^c)''' 이고, c > log_b(a)
마스터 정리는 이 재귀식의 해결 방법을 세 가지 경우로 나눈다.
**대부분의 연산이 재귀 호출 외부에서 발생하며, 추가 연산이 전체 시간 복잡도를 결정한다.
**결과: <math> T(n) = O(f(n)) = O(n^c) </math>
==예제==
다음은 마스터 정리를 사용하여 시간 복잡도를 분석하는 예제이다.
===예제 1: 병합 정렬===
병합 정렬(Merge Sort)의 시간 복잡도는 다음과 같은 재귀 관계식을 따른다.


<math> T(n) = 2T(n/2) + O(n) </math>
== 마스터 정리의 세 가지 경우 ==
마스터 정리의 핵심은 주어진 문제의 재귀식을 분석하여, 아래의 세 가지 경우에 맞는 결과를 도출하는 것이다.


이를 마스터 정리의 형태와 비교하면,
=== 경우 1 (a > b^d) ===
*a = 2
* 만약 a > b^d이면, 전체 시간 복잡도는 T(n) = O(n^log_b(a))이다.
*b = 2
* 즉, 재귀 문제의 분할이 더 큰 비율로 발생하며, 이때의 시간 복잡도는 자식 문제의 크기가 감소하는 것보다 주어진 작업에서의 시간 복잡도가 더 중요하다.
*f(n) = O(n)
*log_b(a) = log_2(2) = 1
여기서 f(n) = O(n)이고, log_b(a) = 1이므로 Case 2에 해당한다. 따라서 병합 정렬의 시간 복잡도는 다음과 같이 계산된다.


<math> T(n) = O(n \log n) </math>
=== 경우 2 (a = b^d) ===
===예제 2: 거듭 제곱(빠른 제곱법)===
* 만약 a = b^d이면, 전체 시간 복잡도는 T(n) = O(n^d log n)이다.
거듭 제곱(Exponentiation by Squaring) 알고리즘의 시간 복잡도는 다음과 같다.
* 이 경우는 자식 문제의 크기 감소와 주어진 작업에서의 복잡도가 동일하게 영향을 미친다. 이때의 복잡도는 log n을 추가하여 계산된다.


<math> T(n) = T(n/2) + O(1) </math>
=== 경우 3 (a < b^d) ===
* 만약 a < b^d이면, 전체 시간 복잡도는 T(n) = O(n^d)이다.
* 이 경우는 자식 문제의 크기 감소가 주어진 작업에서의 복잡도보다 더 중요하므로, 문제를 더 작은 크기로 분할하는 것이 중요하다.


여기서
== 예제 ==
*a = 1
다음은 마스터 정리를 적용한 몇 가지 예제이다.
*b = 2
*f(n) = O(1)
*log_b(a) = log_2(1) = 0
f(n) = O(1)이고 log_b(a) = 0이므로 Case 1에 해당한다.  따라서 거듭 제곱 알고리즘의 시간 복잡도는 다음과 같다.


<math> T(n) = O(\log n) </math>
=== 예제 1 ===
==마스터 정리의 적용 조건==
T(n) = 2T(n / 2) + O(n)
마스터 정리는 모든 재귀 관계식에 적용될 수 있는 것은 아니다. 다음과 같은 조건이 만족되어야 한다.
 
*점화식이 <math> T(n) = aT(n/b) + f(n) </math> 형태를 가져야 한다.
여기서 a = 2, b = 2, d = 1 이다. 따라서 a = b^d이므로, 경우 2가 적용되고 시간 복잡도는:
*a ≥ 1, b > 1인 양의 정수여야 한다.
 
*f(n)이 다항 함수(Polynomial Function) 형태여야 한다.
* T(n) = O(n log n)
이 조건을 만족하지 않는 경우, 반복적 점화 관계 풀이(Recursion Tree Method) 또는 점근적 주요 항 분석(Asymptotic Analysis) 등의 다른 방법을 사용해야 한다.
 
==같이 보기==
=== 예제 2 ===
*[[분할 정복 알고리즘]]
T(n) = 3T(n / 4) + O(n)
*[[시간 복잡도]]
 
*[[재귀 관계식]]
여기서 a = 3, b = 4, d = 1 이다. a < b^d이므로, 경우 3이 적용되고 시간 복잡도는:
*[[로그 시간 알고리즘]]
 
==참고 문헌==
* T(n) = O(n)
*Cormen, T. H., Leiserson, C. E., Rivest, R. L., & Stein, C. (2009). ''Introduction to Algorithms''. MIT Press.
 
*Knuth, D. E. (1997). ''The Art of Computer Programming''. Addison-Wesley.
=== 예제 3 ===
T(n) = 4T(n / 2) + O(n^2)
 
여기서 a = 4, b = 2, d = 2 이다. a = b^d이므로, 경우 2가 적용되고 시간 복잡도는:
 
* T(n) = O(n^2 log n)
 
== 응용 ==
마스터 정리는 다양한 알고리즘의 시간 복잡도를 분석하는 데 활용된다. 대표적인 예시는 다음과 같다.
 
* '''합병 정렬(Merge Sort)'''
** 재귀식: T(n) = 2T(n / 2) + O(n)
** 시간 복잡도: O(n log n)
* '''퀵 정렬(Quick Sort)'''
** 평균 시간 복잡도: O(n log n)
** 최악 시간 복잡도: O(n^2) (분할이 불균형할 때)
* '''행렬 곱셈(Matrix Multiplication)'''
** Strassen 알고리즘의 경우: T(n) = 7T(n / 2) + O(n^2)
** 시간 복잡도: O(n^log₇(7)) ≈ O(n^2.81)
 
== 같이 보기 ==
* [[분할 정복법]]
* [[재귀 알고리즘]]
* [[시간 복잡도]]
* [[퀵 정렬]]
* [[합병 정렬]]
 
== 참고 문헌 ==
* Cormen, Thomas H., et al. "Introduction to Algorithms." MIT Press, 2009.
* Knuth, Donald. "The Art of Computer Programming, Volume 3: Sorting and Searching." Addison-Wesley, 1998.

Revision as of 22:50, 11 March 2025

마스터 정리(Master Theorem)는 분할 정복법(Divide and Conquer)을 사용한 알고리즘의 시간 복잡도를 계산하는 데 유용한 수학적 도구이다. 이 정리는 재귀적 알고리즘의 시간 복잡도를 분석하는 데 사용되며, 특히 재귀식이 다음과 같은 형태로 주어졌을 때 적용할 수 있다.

1 정의

마스터 정리는 다음과 같은 형태의 재귀식을 분석하는 데 사용된다:

  • T(n) = aT(n / b) + O(n^d)

여기서:

  • T(n)은 문제 크기가 n일 때의 시간 복잡도.
  • a는 문제를 분할하는 횟수 (즉, 자식 문제의 수).
  • b는 각 자식 문제의 크기 비율.
  • d는 각 분할된 문제에 대해 수행하는 작업의 복잡도.

마스터 정리는 이 재귀식의 해결 방법을 세 가지 경우로 나눈다.

2 마스터 정리의 세 가지 경우

마스터 정리의 핵심은 주어진 문제의 재귀식을 분석하여, 아래의 세 가지 경우에 맞는 결과를 도출하는 것이다.

2.1 경우 1 (a > b^d)

  • 만약 a > b^d이면, 전체 시간 복잡도는 T(n) = O(n^log_b(a))이다.
  • 즉, 재귀 문제의 분할이 더 큰 비율로 발생하며, 이때의 시간 복잡도는 자식 문제의 크기가 감소하는 것보다 주어진 작업에서의 시간 복잡도가 더 중요하다.

2.2 경우 2 (a = b^d)

  • 만약 a = b^d이면, 전체 시간 복잡도는 T(n) = O(n^d log n)이다.
  • 이 경우는 자식 문제의 크기 감소와 주어진 작업에서의 복잡도가 동일하게 영향을 미친다. 이때의 복잡도는 log n을 추가하여 계산된다.

2.3 경우 3 (a < b^d)

  • 만약 a < b^d이면, 전체 시간 복잡도는 T(n) = O(n^d)이다.
  • 이 경우는 자식 문제의 크기 감소가 주어진 작업에서의 복잡도보다 더 중요하므로, 문제를 더 작은 크기로 분할하는 것이 중요하다.

3 예제

다음은 마스터 정리를 적용한 몇 가지 예제이다.

3.1 예제 1

T(n) = 2T(n / 2) + O(n)

여기서 a = 2, b = 2, d = 1 이다. 따라서 a = b^d이므로, 경우 2가 적용되고 시간 복잡도는:

  • T(n) = O(n log n)

3.2 예제 2

T(n) = 3T(n / 4) + O(n)

여기서 a = 3, b = 4, d = 1 이다. a < b^d이므로, 경우 3이 적용되고 시간 복잡도는:

  • T(n) = O(n)

3.3 예제 3

T(n) = 4T(n / 2) + O(n^2)

여기서 a = 4, b = 2, d = 2 이다. a = b^d이므로, 경우 2가 적용되고 시간 복잡도는:

  • T(n) = O(n^2 log n)

4 응용

마스터 정리는 다양한 알고리즘의 시간 복잡도를 분석하는 데 활용된다. 대표적인 예시는 다음과 같다.

  • 합병 정렬(Merge Sort)
    • 재귀식: T(n) = 2T(n / 2) + O(n)
    • 시간 복잡도: O(n log n)
  • 퀵 정렬(Quick Sort)
    • 평균 시간 복잡도: O(n log n)
    • 최악 시간 복잡도: O(n^2) (분할이 불균형할 때)
  • 행렬 곱셈(Matrix Multiplication)
    • Strassen 알고리즘의 경우: T(n) = 7T(n / 2) + O(n^2)
    • 시간 복잡도: O(n^log₇(7)) ≈ O(n^2.81)

5 같이 보기

6 참고 문헌

  • Cormen, Thomas H., et al. "Introduction to Algorithms." MIT Press, 2009.
  • Knuth, Donald. "The Art of Computer Programming, Volume 3: Sorting and Searching." Addison-Wesley, 1998.