마스터 정리

IT 위키

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

1 정의[편집 | 원본 편집]

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

T(n) = aT(n / b) + f(n)

여기서,

  • T(n): 문제 크기가 n일 때의 전체 시간 복잡도
  • a: 문제를 분할하는 횟수 (즉, 자식 문제의 수)
  • b: 각 자식 문제의 크기 비율 (b > 1)
  • f(n): 분할된 문제의 결과를 합치거나 추가적으로 수행하는 작업의 복잡도

마스터 정리는 f(n)의 성장 속도와 nlogba의 상대적인 크기에 따라 세 가지 경우로 나뉜다.

2 마스터 정리의 세 가지 경우[편집 | 원본 편집]

2.1 경우 1 (분할이 지배적인 경우)[편집 | 원본 편집]

  • f(n) = O(nc) 이고 c < logba 인 경우
    • 전체 시간 복잡도: T(n) = Θ(nlogba)
    • 이 경우는 f(n)이 nlogba보다 느리게 증가하므로, 전체 작업의 대부분은 재귀적으로 분할된 부분 문제에서 발생한다.

2.2 경우 2 (균형적인 경우)[편집 | 원본 편집]

  • f(n) = Θ(nlogba) 인 경우
  • 전체 시간 복잡도: T(n) = Θ(nlogba log n)
  • 이 경우는 분할과 추가 작업 비용이 같은 수준이므로, 로그 항이 하나 추가된다.

2.3 경우 3 (추가 작업이 지배적인 경우)[편집 | 원본 편집]

  • f(n) = Ω(nc) 이고 c > logba 인 경우
  • 그리고 다음 정규성 조건이 만족되어야 한다
    • a·f(n/b) ≤ c·f(n) (어떤 상수 c < 1에 대해, 충분히 큰 n에서 항상 성립)
  • 전체 시간 복잡도: T(n) = Θ(f(n))
  • 이 경우는 f(n)이 nlogba보다 빠르게 증가하고, 정규성 조건까지 만족할 경우 전체 작업량은 f(n)이 지배하게 된다.

3 예제[편집 | 원본 편집]

3.1 예제 1[편집 | 원본 편집]

T(n) = 10T(n / 10) + log10n
  • a = 10, b = 10 → nlog1010 = n1
  • f(n) = log10n = o(n1−ε) → 경우 1
  • 정답: Θ(n)

3.2 예제 2[편집 | 원본 편집]

T(n) = 100T(n / 10) + n10
  • a = 100, b = 10 → nlog10100 = n2
  • f(n) = n10 = ω(n2 + ε), 정규성 조건 만족 → 경우 3
  • 정답: Θ(n10)

3.3 예제 3[편집 | 원본 편집]

T(n) = 10T(n / 100) + (log n)log log n
  • a = 10, b = 100 → nlog10010 = n0.5
  • f(n) = (log n)log log n = o(nε) for all ε > 0
  • f(n) = o(n0.5) → 경우 1
  • 정답: Θ(n0.5)

3.4 예제 4[편집 | 원본 편집]

T(n) = 16T(n / 4) + 4log n = 16T(n / 4) + n2*a = 16, b = 4 → nlog416 = n2
  • f(n) = n2 = Θ(n2) → 경우 2
  • 정답: Θ(n2 log n)

3.5 예제 5[편집 | 원본 편집]

T(n) = 3T(n / 8) + 1
  • a = 3, b = 8, f(n) = 1 = Θ(1)
  • nlog83 ≈ n0.528
  • f(n) = O(nlog83 − ε) → 경우 1
  • 정답: Θ(nlog83)

3.6 예제 6[편집 | 원본 편집]

T(n) = 3T(n / 8) + √n · log n
  • a = 3, b = 8, f(n) = n0.5 log n
  • nlog83 ≈ n0.528
  • f(n) = o(nlog83) → 경우 1
  • 정답: Θ(nlog83)

3.7 예제 7[편집 | 원본 편집]

T(n) = 18T(n / 3) + n3*a = 18, b = 3 → nlog318 ≈ n2.63
  • f(n) = ω(n2.63), 정규성 조건 만족 → 경우 3
  • 정답: Θ(n3)

3.8 예제 8[편집 | 원본 편집]

T(n) = 27T(n / 3) + n3
  • a = 27, b = 3 → nlog327 = n3
  • f(n) = Θ(n3) → 경우 2
  • 정답: Θ(n3 log n)

3.9 예제 9[편집 | 원본 편집]

T(n) = 18T(n / 3) + n2 · log n
  • a = 18, b = 3 → nlog318 ≈ n2.63
  • f(n) = o(n2.63) → 경우 1
  • 정답: Θ(nlog318)

3.10 예제 10[편집 | 원본 편집]

T₁(n) = 8T₁(n / 4) + n1.5
  • a = 8, b = 4 → nlog48 = n1.5
  • f(n) = Θ(n1.5) → 경우 2
  • 정답: Θ(n1.5 log n)

3.11 예제 11[편집 | 원본 편집]

T₂(n) = 6T₂(n / 3) + n2
  • a = 6, b = 3 → nlog36 ≈ n1.63
  • f(n) = ω(n1.63), 정규성 조건 만족 → 경우 3
  • 정답: Θ(n2)

3.12 예제 12[편집 | 원본 편집]

T(n) = 3T(n / 25) + log3n
  • a = 3, b = 25 → nlog253 ≈ n0.396
  • f(n) = log3n = o(n0.396) → 경우 1
  • 정답: Θ(nlog253)

3.13 예제 13[편집 | 원본 편집]

T(n) = 8T(n / 2) + n3 log3n
  • a = 8, b = 2 → nlog28 = n3
  • f(n) = n3 log3n = ω(n3), 정규성 조건 만족 → 경우 3
  • 정답: Θ(n3 log3n)

3.14 예제 14[편집 | 원본 편집]

T(n) = 25T(n / 3) + (n / log n)3
  • a = 25, b = 3 → nlogb a = nlog3 25 ≈ n2.929
  • f(n) = (n/log n)3 = Ω(n2.929 + ε) → 경우 3
  • 정답: Θ((n/log n)3)

3.15 예제 15[편집 | 원본 편집]

T(n) = 4T(n / 15) + √n*a = 4, b = 15 → nlog154 ≈ n0.504
  • f(n) = √n = n0.5 = o(n0.504) → 경우 1
  • 정답: Θ(nlog154)

3.16 예제 16[편집 | 원본 편집]

T(n) = 15T(n / 4) + (n / log n)2
  • a = 15, b = 4 → nlog415 ≈ n1.953
  • f(n) = (n / log n)2 = ω(n1.953), 정규성 조건 만족 → 경우 3
  • 정답: Θ((n / log n)2)

4 응용[편집 | 원본 편집]

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

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