2014 년 봄학기 강원대학교 컴퓨터과학전공 문양세

2014 년 봄학기강원대학교 컴퓨터과학전공 문양세

알고리즘 (Algorithm) Divide and Conquer ( 분할정

복 )

Computer Algo-rithmsby Yang-Sae Moon

Divide-and-Conquer?

유래 :• 1805 년 12 월 2 일 아우스터리츠 전투에서 나폴레옹이 사용한 전략

• 오스트리아 - 러시아 연합군 > 프랑스군 (15,000 명 이상 많음 ) 전체적인 전력은 연합군이 프랑스군에 비해 우수함

• 나폴레옹은 연합군의 중앙부로 쳐들어가 연합군을 둘로 나눔 Divide

• 둘로 나뉜 연합군을 한 부분씩 정복 ( 격파 ) 함 Conquer

Divide and Conquer


Divide-and-Conquer 설계 전략Divide and Conquer

분할 (Divide): 해결하기 쉽도록 문제를 여러 개의 작은 부분으로나눈다 .

정복 (Conquer): 나눈 작은 문제를 각각 해결한다 .

통합 (Combine): ( 필요하다면 ) 해결된 해답을 모은다 .

이러한 문제 해결 방법을 하향식 (top-down) 접근방법이라고 한다 .


강의 순서Divide and Conquer

이진검색 (Binary Search)

합병정렬 (Merge Sort)

The Master Theorem

빠른정렬 (Quick Sort)

행렬곱셈 (Matrix Multiplication)


이진 검색 : 재귀 알고리즘 (1/3)

문제 : 크기가 n 인 정렬된 배열 S 에 x 가 있는지를 결정하라 .

입력 : 자연수 n, 정렬된 배열 S[1..n], 찾고자 하는 항목 x

출력 : locationout - x 가 S 의 어디에 있는지의 위치 , 만약 x 가 S 에 없다면 0

설계전략 :• x 가 배열의 중간에 위치한 항목과 같으면 , “ 빙고 , 찾았다 !” 그렇지 않으면 :

• 분할 : 배열을 반으로 나누어서 x 가 중앙에 위치한 항목보다 작으면 왼쪽에 위치한 배열 반쪽을 선택하고 , 그렇지 않으면 오른쪽에 위치한 배열 반쪽을 선택한다 .

• 정복 : 선택된 반쪽 배열에서 x 를 찾는다 .

• 통합 : ( 필요 없음 )

Divide and Conquer



Divide and Conquer

index location (index low, index high) {index mid;

if (low > high)return 0; // 찾지 못했음

else {mid = (low + high) / 2 // 정수 나눗셈 ( 나머지 버림 )if (x == S[mid])

return mid; // 찾았음else if (x < S[mid])

return location(low, mid-1); // 왼쪽 반 선택 else

return location(mid+1, high);// 오른쪽 반 선택}

}…locationout = location(1, n);...



Divide and Conquer


이진 검색 : 알고리즘 고찰 (1/2)

알고리즘에서 함수의 파라미터와 지역변수는 무엇인가 ?

입력 파라미터 n, S, x 는 전역변수인가 , 지역변수인가 ?

입력 파라미터 n, S, x 는 알고리즘 수행 중 변하지 않는 값이다 . 따라서 함수를 재귀호출 (recursive call) 할 때 마다 이러한 변하지 않는 파라미터를 가지고 다니는 것은 극심한 낭비이다 .

왜 ?

Divide and Conquer


이진 검색 : 알고리즘 고찰 (2/2)

꼬리 재귀호출 (tail recursion): 재귀 알고리즘에서 모든 재귀호출이 알고리즘의 마지막 ( 꼬리 ) 부분에서 이루어지는 경우

꼬리 재귀호출 알고리즘은 반복 알고리즘 (iterative algorithm)으로 변환하기가 수월하다 . ( 강의노트 03 의 p. 21 참조 )

재귀 알고리즘 vs. 반복 알고리즘 • 재귀 알고리즘은 재귀 호출할 때마다 그 당시의 상태를 활성 레코드

(activation records) 스택에 저장해 놓아야 한다 . 반면에 , 반복 알고리즘은 그럴 필요가 없기 때문에 일반적으로 더 효율적이다 ( 빠르다 ).

• 그렇다고 반복 알고리즘의 계산복잡도가 재귀 알고리즘보다 좋다는 의미는 아니다 . 반복 알고리즘이 상수적 (constant factor) 으로만 빠르다는 말이다 .

• 일부 언어는 컴파일러가 자동으로 재귀 프로그램을 반복 프로그램으로 바꾸어 준다 .

Divide and Conquer


단위연산 : x 와 S[mid] 의 비교

입력 크기 : 배열의 크기 n (= high - low + 1)

단위 연산으로 설정한 조건문을 함수 호출마다 각각 두 번 (==, <) 수행하나 , 사실상 비교는 한번 이루어진다고 봐도 된다 . 그 이유는 :

(1) 어셈블리 언어로는 하나의 조건 명령으로 충분히 구현할 수 있기 때문이기도 하고 ;

(2) x 를 찾기 전까지는 항상 두 개의 조건 문을 수행하므로 하나로 묶어서 한 단위로 취급을 해도 되기 때문이기도 하다 .

이와 같이 단위연산은 최대한 효율적으로 ( 빠르게 ) 구현된다고 일반적으로 가정하여 , 하나의 단위로 취급해도 된다 .

Divide and Conquer이진 검색 : 최악의 경우 시간 복잡도 (1/7)


경우 1: 검색하게 될 반쪽 배열의 크기가 항상 정확하게 ½ 인 경우

시간 복잡도를 나타내 주는 점화식 (recurrence) 은 다음과 같다 . n > 1 이고 , n = 2k(k 1)

이 식의 해는 왼편의과정으로 구할 수 있다 .

Divide and Conquer

2( ) ( ) 1

(1) 1

nW n W

W

(1) 1

(2) (1) 1 2

(4) (2) 1 3

(8) (4) 1 4

(16) (8) 1 5

(2 ) 1

( ) lg 1

k

W

W W

W W

W W

W W

W k

W n n

이진 검색 : 최악의 경우 시간 복잡도 (2/7)


앞서 분석한 시간 복잡도가 바른지 확인해 보자 .

증명 : 수학적 귀납법 :

• Induction basis: n = 1 이면 , W(1) = 1 = lg 1 + 1.

• Induction hypothesis: 2 의 거듭제곱 (power) 인 양의 정수 n 에 대해서 , W(n) = lg n + 1 라고 가정한다 .

• Induction step: W(2n) = lg(2n) + 1 임을 보이면 된다 . 점화식 ( 재현식 ) 을 사용하면 ,

Divide and Conquer

(2 ) ( ) 1

lg 1 1

lg lg2 1

lg(2 ) 1

W n W n

n

n

n

점화식에의해서

귀납가정에 의해서



경우 2: 일반적인 경우 – 반쪽 배열의 크기는 이 됨

n 에 대해서 가운데 첨자는 이 되는데 , 이 때 각 부분배열의 크기는 다음과 같다 .

위의 표에 의하면 알고리즘이 다음 단계에 찾아야 할 항목의 개수는 기껏해야 개가 된다 . 따라서 다음과 같은 점화식으로 표현할 수 있다 .

Divide and Conquer

12n

mid

N 왼쪽 부분배열의 크기 mid 오른쪽 부분배열의 크기

짝수 n/2 - 1 1 n/2

홀수 (n-1)/2 1 (n-1)/2

2n

2n

2( ) 1 ( ) 1

(1) 1

nW n W n

W

일때



앞서 제시된 점화식의 해가 이 됨을 증명한다 .

증명 방법 : 수학적 귀납법

• Induction basis: n = 1 이면 , 다음이 성립한다 .

• Induction hypothesis: n > 1 이고 , 1 < k < n 인 모든 k 에

대해서 ,

가 성립한다고 가정한다 .

Divide and Conquer

( ) lg 1W n n

lg 1 lg1 1 0 1 1 (1)n W

( ) lg 1W k k



• Induction step:

1) n 이 짝수이면 (즉 , ), 다음이 성립한다 .

Divide and Conquer

2 2n n

2

2

2

2

( ) 1 ( )

1 lg 1

2 lg

2 lg

2 lg 1

2 lg 1

1 lg

n

n

n

n

W n W

n

n

n

n

점화식에 의해서


이짝수이므로



• Induction step:

2) n 이 홀수이면 (즉 , ), 다음이 성립한다 .

Divide and Conquer

12 2n n

2

2

2

12

( ) 1 ( )

1 lg 1

2 lg

2 lg

2 lg( 1) 1

2 lg( 1) 1

1 lg( 1)

1 lg

n

n

n

n

W n W

n

n

n

n

n n

재현식에 의해서


이홀수이므로

이홀수이므로

( ) lg 1 (lg )W n n n 따라서 , 모든 n 에 대해서 이 성립한다 .






The Master Theorem




합병정렬 (Merge Sort) (1/2)

문제 : n 개의 정수를 ( 비내림차순으로 ) 정렬하시오 .

입력 : 정수 n, 크기가 n 인 배열 S[1..n]

출력 : ( 비내림차순으로 ) 정렬된 배열 S[1..n]

보기 : 27, 10, 12, 20, 25, 13, 15, 22

다음 페이지 참조

Divide and Conquer


합병정렬 (2/2)Divide and Conquer


합병정렬 : 알고리즘Divide and Conquer

void mergesort (int n, keytype S[]){

const int h = n/2, m = n - h;keytype U[1..h], V[1..m];

if (n > 1) {copy S[1] through S[h] to U[1] through U[h];copy S[h+1] through S[n] to V[1] through V[m];mergesort(h,U);mergesort(m,V);merge(h,m,U,V,S);

}}


합병정렬 : 합병Divide and Conquer

문제 : 두 개의 정렬된 배열을 하나의 정렬된 배열로 합병하시오 .

입력 : (1) 양의 정수 h, m, (2) 정렬된 배열 U[1..h], V[1..m]

출력 : U 와 V 에 있는 키들을 하나의 배열에 정렬한 S[1..h+m]


합병정렬 : 합병 알고리즘 (1/2)

Divide and Conquer

void merge(int h, int m, const keytype U[], const keytype V[], keytype S[])

{index i, j, k;i = 1; j = 1; k = 1;while (i <= h && j <= m) {

if (U[i] < V[j]) {S[k] = U[i];i++;

} else {S[k] = V[j];j++;

}k++;

}if(i > h) copy V[j] through V[m] to S[k] through S[h+m];else copy U[i] through U[h] to S[k] through S[h+m];

}


합병정렬 : 합병 알고리즘 (2/2)Divide and Conquer

최악의 경우 시간 복잡도 분석

단위연산 : U[i] 와 V[j] 의 비교

입력크기 : 2 개의 입력 배열에 각각 들어 있는 항목의 개수 : h, m

분석 :• i = h 이고 , j = m – 1 인 상태로 루프 (loop) 에서 빠져 나가는 것이 최악의

경우임

• 예를 들어 , V 에 있는 처음 m - 1 개의 항목이 S 의 앞부분에 위치하고 , U 에 있는 h 개의 모든 항목이 그 뒤에 위치하는 경우임

• 이때 , 단위연산 의 실행 횟수는 h + m – 1 이다 .

• 따라서 , 최악의 경우 합병하는 시간복잡도는 W(h,m) = h + m – 1.


합병정렬 : 최악의 경우 시간 복잡도 (1/2)Divide and Conquer

단위연산 : 합병 알고리즘 merge 에서 발생하는 비교

입력크기 : 배열 S 에 들어 있는 항목의 개수 n

분석 : • 최악의 경우 수행시간은 W(h+m) = W(h) + W(m) + h + m - 1 이 된다 .

• 여기서 W(h) 는 U 를 정렬하는데 걸리는 시간 , W(m) 은 V 를 정렬하는데 걸리는 시간 , 그리고 h + m - 1 은 합병하는데 걸리는 시간이다 .

• 정수 n 을 2k(k 1) 이라고 가정하면 , h = m = n/2 이 된다 .

• 따라서 최악의 경우 점화식은 다음와 같다 .

• 이 점화식의 해는 다음에 소개할 Master Theorem 을 적용하면 , 다음과 같다 .

2( ) 2 ( ) 1 1, 2 ( 1)

(1) 0

knW n W n n n k

W

( ) ( lg )W n n n


합병정렬 : 최악의 경우 시간 복잡도 (2/2)Divide and Conquer

n 이 2 의 거듭제곱 (power) 의 형태가 아닌 경우의 점화식은 다음과 같다 .

그러나 , 이 점화식의 정확한 해를 구하기는 복잡하다 .

그런데 , 앞의 이진검색 알고리즘의 분석에서도 보았듯이 , n = 2k

라고 가정해서 해를 구하면 , 이 점화식의 해와 같은 카테고리의 시간복잡도를 얻게 된다 .

따라서 앞으로 이와 비슷한 점화식의 해를 구할 때 , n = 2k 라고 가정해서 구해도 점근적으로는 같은 해를 얻게 된다 .

2 2( ) ( ) ( ) 1 1

(1) 0

n nW n W W n n

W


합병정렬 : 공간 복잡도 (1/3)Divide and Conquer

입력을 저장하는데 필요한 저장장소 이외에 추가적인 저장장소를

사용하지 않고 정렬하는 알고리즘을 제자리정렬 (in-place sort)

알고리즘이라고 한다 .

앞서의 합병정렬 알고리즘은 제자리정렬 알고리즘이 아니다 .

왜냐하면 입력인 배열 S 이외에 두 개의 배열 U 와 V 를 추가로

만들어서 사용하기 때문이다 .



그러면 합병정렬은 얼마만큼의 추가적인 저장장소가 필요할까 ?

• 함수 mergesort 를 호출할 때마다 크기가 S 의 반이 되는 U 와 V 가 추가적으로 필요하다 .

• 함수 merge 에서는 U 와 V 가 주소로 전달이 되어 그냥 사용되므로 추가적인 저장장소를 만들지 않는다 .

• 따라서 , mergesort 를 재귀호출할 때마다 얼마만큼의 추가적인 저장장소가 만들어져야 하는지를 계산해 보면 된다 .

• 처음 S 의 크기가 n 이면 , 추가적으로 필요한 U 와 V 의 저장장소 크기의 합은 n 이 된다 . 다음 재귀 호출에는 n/2, 그 다음에는 n/4 등으로 추가적인 저장장소가 필요하다 .

• 이들 저장장소의 크기를 합하면 , 이 된다 . ( 다음 페이지

참조 )

• 결론적으로 합병정렬 알고리즘의 공간복잡도는 이라 할 수 있다 .

22 4n n

n n

2n n



추가적으로 필요한 저장장소가 n 이 되도록 , 즉 , 공간복잡도가 n 이

되도록 알고리즘을 향상시킬 수 있다 ( 다음 절의 알고리즘 ).

그러나 , 합병정렬 알고리즘이 ( 공간 복잡도가 O(1)) 인 제자리정렬

알고리즘이 될 수는 없다 .


합병정렬 : 공간 복잡도 향상 알고리즘 (1/3)Divide and Conquer

문제 : n 개의 정수를 ( 비내림차순으로 ) 정렬하시오 .

입력 : 정수 n, 크기가 n 인 배열 S[1..n]

출력 : ( 비내림차순으로 ) 정렬된 배열 S[1..n]

void mergesort2 (index low, index high){

index mid;if (low < high) {

mid = (low + high) / 2;mergesort2(low, mid);mergesort2(mid+1, high);merge2(low, mid, high);

}}...mergesort2(1, n);...



합병 (merge2)

• 문제 : 두 개의 정렬된 배열을 하나의 정렬된 배열로 합병하시오 .

• 입력 : (1) 첨자 low, mid, high, (2) 부분 배열 S[low..high]

( 단 , S[low..mid] 와 S[mid+1..high] 는 이미 각각 정렬이 완료되어

있음 )

• 출력 : 정렬이 완료된 부분배열 S[low..high]



void merge2(index low, index mid, index high){

index i, j, k;keytype U[low..high]; // 합병하는데 필요한 지역 배열i = low; j = mid + 1; k = low;while (i <= mid && j <= high) {

if (S[i] < S[j]) {U[k] = S[i];i++;

} else {U[k] = S[j];j++;

}k++;

}if(i > mid)copy S[j] through S[high] to U[k] through U[high];else copy S[i] through S[mid] to U[k] through U[high];copy U[low] through U[high] to S[low] through S[high];

}

merge2() 함수는 어느 한 순간에 하나만

호출된다 . 재귀 호출이 아님에 유의한다 .





The Master Theorem




The Master Theorem

Consider a function f(n) that, for all n=bk for all kZ+,

satisfies the recurrence relation: (n=bk 일 때 , 다음 점화 관계가

성립하면 )

f(n) = af(n/b) + cnd

with a≥1, integer b>1, real c>0, d≥0. Then:

log

O( ) if

( ) O( log ) if

O( ) if b

d d

d d

a d

n a b

f n n n a b

n a b

Proof of the theorem is …. omitted.

Divide and Conquer


Master Theorem Examples (1/3)

Complexity of fast multiplication was:

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

Thus, a=3, b=2, d=1. So a > bd, so case 3 of the

master theorem applies, so:

which is O(n1.58…).

2log log 3( ) O( ) O( )b aT n n n

Divide and Conquer



예제 : Binary Search이진 탐색의 복잡도는 얼마인가 ( 비교 수를 추정하라 )?

• 이진 탐색의 점화 관계 : T(n) = T(n/2)+c (n 이 짝수라 가정 )

• 매스터 정리로 보면 , a = 1, b = 2, d = 0 으로서 ,

a = 1 = bd 인 두 번째 경우에 해당한다 .

• 결국 , 다음과 같은 과정에 의해 O(logn) 이 된다 .

0( ) O( log ) O( log ) O(log )dT n n n n n n

Divide and Conquer



예제 : Merge Sort합병 정렬의 복잡도는 얼마인가 ( 비교 수를 추정하라 )?

• 이진 탐색의 점화 관계 : T(n) = 2T(n/2)+cn (n 이 짝수라 가정 )

• 매스터 정리로 보면 , a = 2, b = 2, d = 1 로서 ,

a = 2 = bd 인 두 번째 경우에 해당한다 .

• 결국 , 다음과 같은 과정에 의해 O(nlogn) 이 된다 .

1( ) O( log ) O( log ) O( log )dT n n n n n n n

Divide and Conquer





The Master Theorem




빠른정렬 (Quick Sort) – 개요 (1/3)

1962 년에 영국의 호아 (C.A.R. Hoare) 의 의해서 고안

빠른정렬 (Quicksort)란 이름이 오해의 여지가 있음

왜냐하면 사실 절대적으로 가장 빠른 정렬 알고리즘이라고

할 수는 없기 때문이다 .

차라리 “분할교환정렬 (partition exchange sort)” 라고

부르는 게 더 정확하다 .

Divide and Conquer


주어진 배열을 두 개로 분할하고 , 각각을 정렬한다 .

합병정렬과 동일 ?

다른점 1: 합병정렬은 그냥 두 부분으로 나누는 반면에 ,

빠른정렬은 분할할 때 , 기준 아이템 (pivot item) 중심으

로 ,

이보다 작은 것은 왼편 , 큰 것은 오른편에 위치시킨다 .

다른점 2: 각 부분 정렬이 끝난 후 , 합병정렬은 “합병”이란

후처리 작업이 필요하나 , 빠른정렬은 필요로 하지 않는다 .

Divide and Conquer빠른정렬 (Quick Sort) – 개요 (2/3)


예제 : 15, 22, 13, 27, 12, 10, 20, 25

Divide and Conquer빠른정렬 (Quick Sort) – 개요 (3/3)


문제 : n 개의 정수를 ( 비내림차순으로 ) 정렬

입력 : 정수 n > 0, 크기가 n 인 배열 S[1..n]

출력 : 비내림차순으로 정렬된 배열 S[1..n]

알고리즘 :

Divide and Conquer빠른정렬 – 정렬 알고리즘

void quicksort (index low, index high){

index pivotpoint;if (high > low) {

partition(low,high,pivotpoint);quicksort(low,pivotpoint-1);quicksort(pivotpoint+1,high);

}}


문제 : 빠른정렬을 하기 위해서 배열 S 를 둘로 쪼갠다 .

입력 :(1) 첨자 low, high(2) 첨자 low 에서 high 까지의 S 의 부분배열

출력 : (1) S 의 부분배열을 분할한 기준점 pivotpoint(2) 기준점에 의해 분할된 S 의 부분배열 (좌우로 이동된 부분배열 )

알고리즘 : (the next page)

Divide and Conquer빠른정렬 – 분할 알고리즘 (1/3)



void partition (index low, index high, index& pivotpoint){

index i, j;keytype pivotitem;pivotitem = S[low]; // pivotitem 을 위한 첫번째 항목을 고른다j = low;for(i = low + 1; i <= high; i++)

if (S[i] < pivotitem) { // 순서 바뀌었으면 , j 증가하고 교환j++;exchange S[i] and S[j];

}pivotpoint = j;exchange S[low] and S[pivotpoint];// pivotitem 값을 pivotpoint 에 넣는다

}



low j i high

< pivotitem > pivotitem to be investigated

if(S[i] > pivotitem)

low j i high


if(S[i] < pivotitem)

low j i high


i


Divide and Conquer빠른정렬 – 분할 알고리즘 예제

i jS[1] S[2] S[3] S[4] S[5] S[6]S[7] S[8] 비고

-

2

3

4

5

6

7

8

-

-

1

12

2

23

34

4

4

4

15 22 13 27 12 1020 25

15 22 13 27 12 1020 25

15 22 13 27 12 1020 25

15 13 22 27 12 1020 25

15 13 22 27 12 1020 25

15 13 12 27 22 1020 25

15 13 12 10 22 2720 25

15 13 12 10 22 2720 25

10 13 12 15 22 2720 25

초기값

최종값


Divide and Conquer빠른정렬 – 알고리즘 분석 (Worst Case) (1/5)

분할 알고리즘의 모든 경우를 고려한 시간복잡도 분석

• 단위연산 : S[i] 와 key 와의 비교

• 입력크기 : 부분배열이 가지고 있는 항목의 수 , n = high - low + 1

• 분석 : 배열의 첫번째 항목만 제외하고 모든 항목을 한번씩

비교하므로 , T(n) = n – 1 이다 .

n 개 항목에 대한 분할에서는 기본적으로 n – 1 번의 비교가

이루어짐



빠른정렬 알고리즘의 시간복잡도 분석• 단위연산 : 분할알고리즘의 S[i] 와 key 와의 비교• 입력크기 : 배열이 S 가 가지고 있는 항목의 수 , n

• 분석 : 배열이 이미 비내림차순으로 정렬이 된 경우가 최악이다 .

왜 그럴까 ? 비내림차순으로 정렬되어 있으면 첫번째 ( 기준점 ) 항목보다 작은 항목은 없으므로 , 크기가 n 인 배열은 크기가 0 인

부분배열은 왼쪽에 오고 , 크기가 n-1 인 부분배열은 오른쪽에 오도록 계속 쪼개진다 .

• 따라서 , 점화식은 다음과 같다 .

• 그런데 , T(0) = 0 이므로 , 점화식은 다음과 같이 된다 .

T(n) = T(n - 1) + n - 1, if n > 0 (T(0) = 0, otherwise)

( ) (0) ( 1) 1T n T T n n



이 점화식을 풀면 , 다음과 같다 .

( ) ( 1) 1

( 1) ( 2) 2

( 2) ( 3) 3

...

(2) (1) 1

(1) (0) 0

(0) 0

( ) (0) ( 1) 1

( 1)

2

T n T n n

T n T n n

T n T n n

T T

T T

T

T n T T n n

n n

이미 정렬이 되어 있는 경우 알고리즘의 시간복잡도는 n(n–1)/2 이 된다 . 그러면 , 시간이 더 많이 걸리는 경우는없을까 ?

사실 , 이 경우가 최악이며 , 따라서 이 보다 더 많은 시간이 걸릴 수 없다는 사실을 수학적으로 엄밀하게 증명한다 .


Divide and Conquer빠른정렬 – 알고리즘 분석 (Worst Case) (4/5) - skip

모든 정수 n 에 대해서 , 임을 증명하시오 .

증명 : ( 수학적귀납법 )

• 귀납출발점 : n = 0 일 때 ,

• 귀납가정 : 0 k < n 인 모든 k 에 대해서 ,

• 귀납단계 :

( 1)2( ) n nW n

0(0 1)2(0)W

( 1)2( ) k kW k

( 1)2( ) n nW n

2 2

2 2

( 1)( 2) ( )( 1)2 2

3 2 ( ) 2 22

( ) 22

( ) ( 1) ( ) 1 pivotpoint

1 p p n p n p

p p n p n p n

p n p n p

W n W p W n p n

n

값이p인 경우 점화식에의해

귀납가정에의해


Divide and Conquer빠른정렬 – 알고리즘 분석 (Worst Case) (5/5) – skip여기서 p 가 n - 1 일 때 최대값을 가진다 . 따라서

가 되고 , 결과적으로

가 된다 . 따라서 최악의 경우 시간복잡도는 다음과 같다 .

2 2 2 2 21 1( ( ) ) 1 ( 1) 2 2p nmax p n p n n n

2 2 2 2( ) 2 ( 1)2 2 2( )

2 2 2 2

p n p n p n nn n n n nW n

2( 1)( ) ( )

2n n

W n n


Divide and Conquer빠른정렬 – 알고리즘 분석 (Average Case) (1/4)

결국 , 빠른정렬의 Worst Case Complexity 는 로 , 합병정렬에 비해 좋지 못하다 .

그런데 , 왜 “빠른”정렬이라고 했을까 ?

이는 다음에 계산되는 Average Case Complexity 때문이다 .

2( )n


Divide and Conquer빠른정렬 – 알고리즘 분석 (Average Case) (2/4)

단위연산 : 분할알고리즘의 S[i] 와 key 와의 비교

입력크기 : 배열이 S 가 가지고 있는 항목의 수 , n

분석 :

• 배열 안에 있는 항목이 특정 순서로 정렬된 경우는 별로 없다 .

• 그러므로 분할 알고리즘이 주는 기준점 값은 1 부터 n 사이의 어떤 값도 될 수가 있고 , 그 확률은 모두 같다고 봐도 된다 .

• 기준점이 p 가 될 확률은 1/n 이고 , 기준점이 p 일 때 두 부분배열을 정렬하는데 걸리는 평균기간은 [A(p - 1) + A(n - p)] 이고 , 분할하는데 걸리는 시간은 n - 1 이므로 , 평균적인 시간복잡도는 다음과 같이 된다 .

1

1

1( ) [ ( 1) ( )] 1

2( 1) 1

n

p

n

p

A n A p A n p nn

A p nn


Divide and Conquer빠른정렬 – 알고리즘 분석 (Average Case) (3/4) – skip

분석 ( 계속 ):

• 양변을 n 을 곱하면 ,

• n 대신 n - 1 을 대입하면 ,

• (1) 에서 (2) 를 빼면 ,

• 간단히 정리하면 ,

• 여기서 , 라 하면 , 다음과 같은 점화식을 얻을 수 있다 .

• 그러면 , 다음 관계가 성립한다 .

1( ) 2 ( 1) ( 1) (1)

n

pnA n A p n n

1

1( 1) ( 1) 2 ( 1) ( 1)( 2) (2)

n

pn A n A p n n

( ) ( 1) ( 1) 2 ( 1) 2( 1)nA n n A n A n n

( ) ( 1) 2( 1)1 ( 1)

A n A n nn n n n

( )

1n

A na

n

1

2( 1)0

( 1)n n

na a n

n n

이면

11 1 2 2 1 1 03

2( 1) 2( 2), , , , 0

( 1) ( 1)n n n n

n na a a a a a a a

n n n n


Divide and Conquer빠른정렬 – 알고리즘 분석 (Average Case) (4/4) – skip

분석 ( 계속 ):

• 따라서 , 해는 다음과 같다 .

• 여기에서 오른쪽 항은 무시해도 될 만큼 작으므로 무시한다 .

그런데 , ln n = logen 이고 ,

이므로 , 해는 an 2 ln n 이다 .

• 따라서 , A(n) 은 다음과 같다 .

2( 1)( 1)1

1 11 ( 1)1 1

2

n in i ii

n n

i i ii i

a

1

1 1 11 ln

2

n

i

ni n

( ) ( 1)2ln

( 1)2(ln2)(lg )

1.38( 1)lg

( lg )

A n n n

n n

n n

n n





The Master Theorem




Divide and Conquer행렬 개요 (1/4)

행렬이 뭐였더라 ?

Hmmm… 행렬이란 Matrix 여… 이거

행렬에 대한 지식을 모두 반납한 학생들을 위해 몇 가지 기본 사항만잠시 리뷰해 볼까요 ?


Divide and Conquer행렬 개요 (2/4)

행렬은 수의 사각형 배열이다 .

mn (“m by n”) 행렬은 m 개의 행과 n 개의 열을 갖는다 .

행과 열의 개수가 같은 nxn 행렬을 정방행렬이라 한다 .

두 행렬이 같은 수의 행과 열을 가지며 각 위치의 해당 원소의 값이 같으면 “두 행렬은 같다”고 정의한다 .

061

023

61

23

61

23

n,m,m,m

n,,,

n,,,

j,i

aaa

aaa

aaa

a

21

22212

12111

A


Divide and Conquer

행렬의 합 :

A+B = C = [ci,j] = [ai,j+bi,j] where A = [ai,j] and B =

[bi,j]

252

313

244

211

031

143

043

322

101

행렬 개요 (3/4)


Divide and Conquer

행렬의 곱 :

k

j,,ij,i bac1

CAB

1,1 1,2 1,

1,1 1,2 1, 1,2,1 2,2 2, 1,1 1,2 1,

2,1 2,2 2, 2, 2,1 2,2 2,

,1 ,2 ,

,1 ,2 , ,

,1 ,1 ,

...

... ...... ...

... ... ...

...

... ...

...

k

j nk n

j n

i i i k

k k k j k n

m m mk

a a a

b b b ba a a c c c

b b b b c c c

a a a

b b b b

a a a

,

,1 ,2 ,...

n

i j

m m mn

c

c c c

31123

1501

1301

0202

0110

302

110

행렬 개요 (4/4)


Divide and Conquer

문제 : n n 크기의 행렬의 곱을 구하시오 .

입력 : 양수 n, n n 크기의 행렬 A 와 B

출력 : 행렬 A 와 B 의 곱인 C

알고리즘 :

행렬곱셈 – 단순 알고리즘 (1/3)

void matrixmult (int n, const number A[][], const number B[][], number C[][])

{index i, j, k;for (i = 1; i <= n; i++)

for (j = 1; j <= n; j++) {C[i][j] = 0;for (k = 1; k <= n; k++)

C[i][j] = C[i][j] + A[i][k] * B[k][j];}

}

, , ,1

n

i j i k k jk

AB C c a b


Divide and Conquer

곱셈 연산의 시간복잡도 분석

단위연산 : 가장 안쪽의 루프에 있는 곱셈하는 연산

입력크기 : 행과 열의 수 , n

모든 경우 시간복잡도 분석 : 총 곱셈의 횟수는 다음과 같다 .


3 3( ) ( )T n n n n n n


Divide and Conquer

덧셈 (뺄셈 ) 연산의 시간복잡도 분석

단위연산 : 가장 안쪽의 루프에 있는 덧셈 (뺄셈 ) 하는 연산


모든 경우 시간복잡도 분석 : 총 덧셈의 횟수는 다음과 같다 .


3 2 3( ) ( 1) ( )T n n n n n n n

k=1 일 때는 덧셈이 필요 없기 때문


Divide and Conquer

문제 : 두 2 2 행렬 A 와 B 의 곱 (product) C,

쉬트라쎈 (Strassen) 의 해 :

쉬트라쎈 방법 – 2x2 행렬 (1/2)

11 12 11 12 11 12

21 22 21 22 21 22

c c a a b b

c c a a b b

1 4 5 7 3 5

2 4 1 3 2 6

m m m m m mC

m m m m m m

1 11 22 11 22

2 21 22 11

3 11 12 22

4 22 21 11

5 11 12 22

6 21 11 11 12

7 12 22 21 22

( ) ( )

( )

( )

where ( )

( )

( ) ( )

( ) ( )

m a a b b

m a a b

m a b b

m a b b

m a a b

m a a b b

m a a b b

Why?앉아서 꼼꼼히 따져보세요 .


Divide and Conquer

시간복잡도 분석 :

• 단순 곱셈 방법 : 8 번의 곱셈과 4 번의 덧셈이 필요함

• 쉬트라쎈 방법 : 7 번의 곱셈과 18 번의 덧셈 /뺄셈이 필요함

언뜻 봐서는 전혀 좋아지지 않았다 !

그러나 행렬의 크기가 커지면 쉬트라쎈의 방법의 가치가 드러난다 .

쉬트라쎈 방법 – 2x2 행렬 (2/2)


Divide and Conquer

문제 : n 이 2 의 거듭제곱이고 , 각 행렬을 4 개의 부분행렬(submatrix) 로 나눈다고 가정하자 . 두 n n 행렬 A 와 B 의 곱 C:

쉬트라쎈 (Strassen) 의 해 :

쉬트라쎈 방법 – nxn 행렬 (1/7)

1 4 5 7 3 5

2 4 1 3 2 6

M M M M M MC

M M M M M M

1 11 22 11 22

2 21 22 11

3 11 12 22

4 22 21 11

5 11 12 22

6 21 11 11 12

7 12 22 21 22

( ) ( )

( )

( )

where ( )

( )

( ) ( )

( ) ( )

M A A B B

M A A B

M A B B

M A B B

M A A B

M A A B B

M A A B B

11 12 11 12 11 12

21 22 21 22 21 22

C C A A B B

C C A A B B


Divide and Conquer쉬트라쎈 방법 – nxn 행렬 (2/7)

문제 : n 이 2 의 거듭제곱일 때 , n n 크기의 두 행렬의 곱을 구하시오 .

입력 : 정수 n, n n 크기의 행렬 A 와 B

출력 : 행렬 A 와 B 의 곱인 C

알고리즘 :void strassen (int n, nxn matrix A, nxn matrix B, nxn matrix& C){

if (n <= threshold)단순한 알고리즘을 사용하여 C = A * B 를 계산 ;

else {A 를 4 개의 부분행렬 A11, A12, A21, A22 로 분할 ;B 를 4 개의 부분행렬 B11, B12, B21, B22 로 분할 ;쉬트라쎈의 방법을 사용하여 C = A * B 를 계산 ;// 재귀 호출의 예 : strassen(n/2, A11+A12, B11+B22, M1)

}}

Threshold? 단순 알고리즘보다 쉬트라쎈 알고리즘이 더 좋을 것이라 예상되는 지점



곱셈 연산의 시간복잡도 분석

단위연산 : 곱셈하는 연산


모든 경우 시간복잡도 분석 : threshold 를 1 이라고 하자( 참고 : threshold 는 복잡도 차수에 전혀 영향을 미치지 않는다 .)

점화식을 다음과 같이 구할 수 있다 .

2( ) 7 ( ) 1 , 2 ( 1)

(1) 1

knT n T n n k

T

이고

Why?하나의 nxn 곱셈이 일곱 개의 (n/2)x(n/2) 곱셈으로 바뀌었기 때문



곱셈 연산의 시간복잡도 분석 ( 계속 )

점화식을 전개하면 다음과 같다 .

k

lg n

lg 7

2.81

2.81

( ) 7 7 7 ( times)

7

7

n

n

(n )

T n k

상기 결과는 귀납법에 의해서 증명이 가능하다 . (Try it!)

또한 , 상기 점화식은 Master Theorem 1 번을 이용하면 간단히 해를 구할 수 있다 . (Also, try it!)



덧셈 (뺄셈 ) 연산의 시간복잡도 분석

단위연산 : 덧셈 /뺄셈하는 연산


모든 경우 시간복잡도 분석 : 앞서와 마찬가지로 threshold 를 1 이라 한다 .

점화식을 다음과 같이 구할 수 있다 .2

2 2( ) 7 ( ) 18( ) 1 2 ( 1)

(1) 0

kn nT n T n n k

T

Why?nxn 곱셈이 일곱 개의 (n/2)x(n/2) 곱셈으로 바뀌었고 , 18 번의 (n/2)x(n/2) 행렬 덧셈이 필요한데 , 각각은 (n/2)^2 번의 덧셈을 필요로 하기 때문



덧셈 (뺄셈 ) 연산의 시간복잡도 분석 ( 계속 )

점화식은 다음과 같다 .

Master Theorem 을 사용하면 상기 점화식의 해는 다음과 같이 구할 수 있다 .

22 2( ) 7 ( ) 18( ) 1 2 ( 1)

(1) 0

kn nT n T n n k

T

2lg 7 2.81( ) ( ) ( )T n n n

log

O( ) if

( ) ( / ) ( ) O( log ) if

O( ) if b

d d

d d d

a d

n a b

f n af n b cn f n n n a b

n a b



Strassen 은 행렬 곱셈의 복잡도를 에서 으로 낮추었다 .

이후에 곱셈의 복잡도를 까지 낮춘 알고리즘이 개발되었다 .

그렇다면 , 과연 얼마까지 복잡도를 낮출 수 있을까 ?

두 행렬을 곱하기 위한 문제에 대해서 시간복잡도가 이 되는 알고리즘을 만들어 낸 사람은 아무도 없다 .

게다가 그러한 알고리즘을 만들 수 없다고 증명한 사람도 아무도 없다 .

2.81( )n3( )n

2.38( )n

2( )n


Divide and Conquer큰 정수 계산법 , 임계값 결정 skip


Divide and ConquerHomework#3

2014 년 봄학기 강원대학교 컴퓨터과학전공 문양세

Documents