
Korean: 
이 강의 한글자막은 www.snow.or.kr 자원활동가들에 의해 작성되었습니다. 
오늘 우리는 정렬에 대해 이야기하지 않을 것입니다. 
이것은 흥미로운 새로운 발전입니다
우리는 다른 관련된 문제에 대해 
이야기할 것입니다.
우리는 선형 시간에 풀고 싶은 또 다른 문제에 대해 이야기할 것입니다. 
지난 시간에 우리는 우리가 선형 시간에 정렬할 수 있는 것에 대해 이야기 했었습니다. 
그것을 하기 위해 우리는 추가적인 가정이 필요했었습니다. 
오늘 우리는 정말 선형 시간만 
필요한 문제를 볼 것입니다, 
처음 봤을 때 그것이 정렬을 요구하는 것 같아 보일지 라도요. 
그래서 이것은 쉬운 문제가 될 것입니다. 

English: 
So, there is a lot of
Today we're going to not talk
about sorting.
This is an exciting new
development.
We know that what we're looking
We're going to talk about
another problem,
a related problem,
but a different problem.
We're going to talk about
another problem that we would
like to solve in linear time.
Last class we talked about we
could do sorting in linear time.
To do that we needed some
additional assumptions.
Today we're going to look at a
problem that really only needs
linear time, even though at
first glance it might look like
it requires sorting.
So this is going to be an
easier problem.

Korean: 
문제는 제가 여러분에게 많은 수를 줄 것입니다.
그것들을 인자라고 부릅시다. 그리고 그것들은 어떤 배열에 있습니다. 
그리고 그것들은 특정한 순서를 가지지 않고, 정렬되지 않았습니다. 
저는 k 번째 작은 인자를 찾길 원합니다. 
이것을 k 순위 인자라고 부릅니다.
다시 말해, 저는 정렬되지 않은 수들의 이 목록을 가지고 있습니다. 
그리고, 제가 그것을 정렬하면, 
저는 k 번째 인자가 무엇인지 알고 싶습니다. 
그러나 저는 그것을 정렬하도록 허락되지 않았습니다. 
이 문제를 위한 하나의 답은 소박한 알고리즘입니다 
여러분은 단지 정렬을 하고 k 번째 인자를 리턴합니다. 이것은 문제의 또 다른 가능한 정의입니다.

English: 
The problem is I give you a
bunch of numbers.
Let's call them elements.
And they are in some array,
let's say.
And they're in no particular
order, so unsorted.
I want to find the kth smallest
element.
This is called the element of
rank k.
In other words,
I have this list of numbers
which is unsorted.
And, if I were to sort it,
I would like to know what the
kth element is.
But I'm not allowed to sort it.
One solution to this problem,
this is the naÔve algorithm,
is you just sort and then
return the kth element.
This is another possible

English: 
definition of the problem.
And we would like to do better
than that.
So you could sort,
what's called the array A,
and then return A[k].
That is one thing we could do.
And if we use heap sort or
mergesort, this will take n lg n
time.
We would like to do better than
n lg n.
Ideally linear time.
The problem is pretty natural,
straightforward.
It has various applications.
Depending on how you choose k,
k could be any number between 1
and n.
For example,
if we choose k=1 that element
has a name.
Any suggestions of what the
name is?
The minimum.
That's easy.
Any suggestions on how we could
find the minimum element in an
array in linear time?
Right.

Korean: 
그리고 우리는 그것 보다 나은 것을 하고 싶습니다. 
그래서 여러분을 배열 A라는 것을 정렬할 수 있습니다,  
그리고 A[k]를 리턴합니다.
그것은 우리가 할 수 있는 하나의 것입니다. 그리고 우리가 히프 정렬 또는 
합병 정렬을 사용한다면, 이것은 n lg n 시간이 걸립니다. 
그러니까 우리는 n lg n 보다 나은 것을 하고 싶은거죠.
이상적으로 선형 시간 입니다. 문제는 매우 자연스럽고, 간단합니다. 
그것은 많은 응용을 가집니다.
여러분이 k를 어떻게 선택하는지에 따라, k는 1과 n 사이의 어떤 수 일수 있습니다. 
예를 들어,
우리가 k=1 을 선택하면, 그 인자는 이름을 가집니다. 
그 이름이 무엇인지에 대한 생각 있나요? 
최소 입니다. 그것은 쉽습니다. 
우리가 선형 시간에 배열에서 최소 인자를 어떻게 찾을 수 
있는지에 대한 생각 있나요?

English: 
Just scan through the array.
Keep track of what the smallest
number is that you've seen.
The same thing with the
maximum, k=n.
These are rather trivial.
But a more interesting version
of the order statistic problem
is to find the median.
This is either k equals n plus
1 over 2 floor or ceiling.
I will call both of those
elements medians.
Finding the median of an
unsorted array in linear time is
quite tricky.
And that sort of is the main
goal of this lecture,
is to be able to find the
medians.
For free we're going to be able
to find the arbitrary kth
smallest element,
but typically we're most
interested in finding the
median.
And on Friday in recitation
you'll see why that is so
useful.
There are all sorts of
situations where you can use
median for really effective
divide-and-conquer without

Korean: 
그냥 배열을 쭉 스캔하면 됩니다. 
가장 작은 수가 무엇인지 쭉 보세요. 
최대와 같은 것은 k=n 입니다. 이것들은 그저 사소합니다. 
그러나 오더 통계 문제의 더 흥미로운 버전은 중앙값을 찾는 것 입니다. 
이것은 k = n 더하기 1 나누기값에 ceiling 또는 floor를 취한 값입니다. 
저는 그 인자들 둘을 다 중앙값이라고 
부를 것입니다. 
선형 시간에 정렬되지 않은 배열의 중앙값을 찾는 것은 다소 까다롭습니다. 
그리고 그것은 이 강의의 주요 목표 입니다, 
그것은 중앙값을 찾을 수 있는 것입니다. 
우리는 임의의 k 번째 
작은 인자를 찾을 수 있을 것이나,
전형적으로 우리는 중앙값을 찾는 것에 가장 관심이 있습니다. 
그리고 금요일에 
여러분은 그것이 그렇게 유용한 이유에 대해 볼 것입니다. 
여러분이 정렬 없이 정말 효과적인 분할 정복을 위해 중앙값을 사용할 수 있는 
모든 종류의 상황들이 있습니다. 

English: 
having to sort.
You can solve a lot of problems
in linear time as a result.
And we're going to cover today
two algorithms for finding order
statistics.
Both of them are linear time.
The first one is randomized,
so it's only linear expected
time.
And the second one is
worst-case linear time,
and it will build on the
randomized version.
Let's start with a randomize
divide-and-conquer algorithm.
This algorithm is called
rand-select.

Korean: 
여러분은 결과적으로 선형 시간에 많은 문제들을 풀 수 있습니다. 
그리고 우리는 오늘 순서 통계량을 찾기 위해 
두 알고리즘을 다룰 것입니다. 
그것들 모두 선형 시간입니다. 첫 번째는 랜덤화된 것이고, 
그것은 오직 선형 시간을 가집니다. 
그리고 두 번째 것은 worst-case의 선형 시간입니다 
그리고 그것은 랜덤화된 버전을 구축할 것입니다. 
랜덤 분할 정복 알고리즘부터 시작해 봅시다. 
이 알고리즘은 rand-select 입니다.

Korean: 
그리고 인자들은 우리가 사용했던 것 이상입니다. 
순서 통계량 문제에서 여러분은 배열 A가 주어집니다. 
그리고 여기서 저는 표기법을 바꾸고
i번째 작은 인자를 찾을 겁니다, 
그래서 i는 제가 찾는 인덱스입니다. 
그리고 저는 문제를 약간 바꿀 것입니다. 
그리고 그것을 전체 배열에서 찾으려고 하는 대신에, 
배열의 특정한 간격에서 볼 것입니다, p에서 q까지 A 배열에서요. 
우리는 재귀를 위해 그것이 필요합니다. 
이것은 재귀 알고리즘인 것이 낫습니다 
왜냐하면 우리는 분할 정복을 사용할 것이기 때문입니다. 
여기 알고리즘이 있습니다. 
기본적인 케이스를 가지고요. 그것은 매우 간단합니다.

English: 
And the parameters are a little
bit more than what we're used
to.
The order statistics problem
you're given an array A.
And here I've changed notation
and I'm looking for the ith
smallest element,
so i is the index I'm looking
for.
And I'm also going to change
the problem a little bit.
And instead of trying to find
it in the whole array,
I'm going to look in a
particular interval of the
array, A from p up to q.
We're going to need that for a
recursion.
This better be a recursive
algorithm because we're using
divide-and-conquer.
Here is the algorithm.
With a base case.
It's pretty simple.

English: 
Then we're going to use part of
the quicksort algorithm,
randomized quicksort.
We didn't actually define this
subroutine two lectures ago,
but you should know what it
does, especially if you've read
the textbook.
This says in the array A[p...q]
pick a random element,
so pick a random index between
p and q, swap it with the first
element, then call partition.
And partition uses that first
element to split the rest of the
array into less than or equal to
that random partition and
greater than or equal to that
partition.
This is just picking a random
partition element between p and
q, cutting the array in half,
although the two sizes may not
be equal.
And it returns the index of

Korean: 
그리고 우리는 퀵 정렬 알고리즘, 랜덤 퀵 정렬의 일부를 
사용할 것입니다. 
우리는 사실 이 서브 루틴을 지난 두 강의에서 정의하지 않았지만 여러분은 
그것이 무엇을 하는지 알아야 합니다, 여러분이 교재를 읽었다면요. 
이것은 배열 A[p...q]에서 랜덤 인자를 고르라고 말합니다, 
p와 q 사이의 랜덤 인덱스를 고릅니다, 
그리고 그것을 첫 번째 인자와 바꿉니다, 그리고 분할을 호출합니다.
그리고 분할은 그 랜덤 파티션 보다 작거나 같은 또는 
그 파티션 보다 크거나 같은 것으로 배열의 남은 부분을 쪼개기 위해 
첫 번째 인자를 사용합니다. 
이것은 p와 q 사이의 랜덤 분할 인자를 고르는 것입니다, 
두 사이즈가 같지 않더라도 배열을 반으로 자릅니다. 
그리고 그것은 그 분할 인자의 인덱스를 리턴합니다, 

Korean: 
p와 q 사이의 어떤 수 입니다. 
그리고 우리는 이 특정한 값 r 마이너스 p 플러스 1이 되는 k를 정의할 것입니다. 
그리고 그것을 위한 이유는 k는 분할 인자의 순위입니다. 
이것은 A[p...q] 안에 있습니다. 
여기서 그림을 그려보겠습니다.
우리는 우리의 배열 A를 가집니다. 그것은 p에서 시작해서 q에서 끝납니다. 
다른 것들도 있지만 이 재귀를 위해서 우리가 신경 써야 하는 모든 것은 p에서 q까지 입니다. 
우리는 랜덤 분할 인자를 고릅니다, 
그리고 우리는 그것을 분할하고, 
이것을 r이라고 합시다, 
여기서 모든 것은 A[r] 보다 작거나 같고 여기서 모든 것은 A[r] 보다 크거나 같습니다. 

English: 
that partition element,
some number between p and q.
And we're going to define k to
be this particular value,
r minus p plus 1.
And the reason for that is that
k is then the rank of the
partition element.
This is in A[p...q].
Let me draw a picture here.
We have our array A.
It starts at p and ends at q.
There is other stuff,
but for this recursive all we
care about is p up to q.
We pick a random partition
element, say this one,
and we partition things so that
everything in here,
let's call this r,
is less than or equal to A[r]
and everything up here is

Korean: 
그리고 A[r]은 우리의 분할 인자입니다. 
이 호출 후에, 
그것은 배열이 무엇과 같은지 입니다. 
그리고 우리는 r을 얻습니다. 우리는 분할 인자가 저장된 곳의 인덱스를 얻습니다.
A[r] 보다 작거나 같고 r을 포함하는 인자들의 수는
 r 마이너스 p 플러스 1 입니다. 
여기 r 마이너스 p 인자들이 있고 
우리는 이 인자에 1을 더할 것입니다.
그리고, 여러분은 1에서 세기 시작하면, 이것이 순위 1, 순위 2이면, 
이 인자는 순위 k를 가집니다. 
그것은 분할에서 구축으로부터 입니다. 
이제 우리는 역으로 할 것입니다. 세가지 경우가 있는데요.
그것은 i가 k에 얼마나 연관되었는지에 의존합니다. 
i는 우리가 찾는 순위이고, k는 이 랜덤 분할로부터 

English: 
greater than or equal to A[r].
And A[r] is our partition
element.
After this call,
that's what the array looks
like.
And we get r.
We get the index of where
partition element is stored.
The number of elements that are
less than or equal to A[r] and
including r is r minus p plus 1.
There will be r minus p
elements here,
and we're adding 1 to get this
element.
And, if you start counting at
1, if this is rank 1,
rank 2, this element will have
rank k.
That's just from the
construction in the partition.
And now we get to recurse.
And there are three cases --
-- depending on how i relates
to k.
Remember i is the rank that
we're looking for,

Korean: 
우리가 얻는 순위라는 것을 기억하세요. 
우리는 k에 대해 많은 컨트롤을 가지지 못합니다, 
그러나 우리가 운이 좋다면, i=k 입니다. 그것은 우리가 원하는 인자입니다.
그리고 우리는 분할 인자를 리턴합니다. 
우리가 찾는 인자는 오른쪽 또는 왼쪽 입니다. 
그리고 그것이 왼쪽이면 우리는 배열의 왼쪽 부분에서
 역으로 할 것입니다.
그리고 그리고 그것이 오른쪽이면 우리는 배열의 오른쪽 부분에서 역으로 할 것입니다. 
그래서, 이 점에서 매우 간단합니다.
저는 모든 인덱스들을 가져야 합니다. 

English: 
k is the rank that we happen to
get out of this random
partition.
We don't have much control over
k, but if we're lucky i=k.
That's the element we want.
Then we just return the
partition element.
More likely is that the element
we're looking for is either to
the left or to the right.
And if it's to the left we're
going to recurse in the
left-hand portion of the array.
And if it's to the right we're
going to recurse in the
right-hand portion.
So, pretty straightforward at
this point.
I just have to get all the
indices right.

Korean: 
우리는 p와 r-1 사이에서 역으로 할 것이고, 그것이 이 경우 입니다. 
우리가 찾는 순위는 A[r] 인자의 순위의 
왼쪽입니다. 
우리는 r+1과 q 사이의 오른 쪽 부분에서 역으로 할 것입니다. 
우리가 왼쪽 부분에서 역으로 하는 곳에서 
우리는 남아 있는 같은 것을 찾지만, 
우리가 오른쪽 부분에서 역으로 할 때 우리가 찾는 순위는 offset이 됩니다.
왜냐하면 우리가 여기서 k 인자들을 제거했기 때문입니다
저는 이 길이가 k라고 썼어야 했습니다. 
우리는 인자들의 k 순위를 바꾸었습니다. 
그리고 이제 이 배열 내에서 우리는 I 마이너스 k 번째 
작은 인자를 찾을 겁니다. 
그것이 재귀입니다. 우리는 오직 한번만 재귀합니다. 

English: 
Either we're going to recurse
on the part between p and r
minus 1, that's this case.
The rank we're looking for is
to the left of the rank of
element A[r].
Or, we're going to recurse on
the right part between r plus 1
and q.
Where we recurse on the left
part the rank we're looking for
remains the same,
but when we recurse on the
right part the rank we're
looking for gets offset.
Because we sort of got rid of
the k elements over here.
I should have written this
length is k.
We've sort of swept away k
ranks of elements.
And now within this array we're
looking for the i minus kth
smallest element.
That's the recursion.
We only recurse once.

English: 
And random partition is not a
recursion.
That just takes linear time.
And the total amount of work
we're doing here should be
linear time plus one recursion.
And we'd next like to see what
the total running time is in
expectation, but let's first do
a little example --
-- to make this algorithm
perfectly clear.
Let's suppose we're looking for
the seventh smallest element in
this array.
And let's suppose,
just for example,
that the pivot we're using is
just the first element.

Korean: 
그리고 랜덤 분할은 재귀가 아닙니다. 
그것은 단지 선형 시간이 걸립니다. 그리고 우리가 여기서 하는 일의 
총 양은 선형 시간 더하기 한 번의 재귀여야 합니다. 
그리고 우리가 다음에 보려고 하는 것은 총 러닝 타임입니다, 
그러나 먼저 작은 예를 해 봅시다. 
이 알고리즘을 완벽하게 분명히 해 봅시다. 
우리가 이 배열에서 7 번째 작은 인자를 찾는다고 
가정해 봅시다. 
그리고 가정해 봅시다, 예를 들어, 
우리가 사용하는 중심점이 첫 번째 인자라고요. 

Korean: 
좋은 것은 아닙니다. 저는 랜덤한 것을 생성하기 위해 
몇 개의 동전을 뒤집어야 합니다, 
그래서 이 것을 골라 봅시다. 제가 인자 6에서 분할하면, 
이것은 사실 우리가 2주 전에 했던 예입니다, 
그리고 저는 그것을 다시 살펴 보지 않을 것이지만 
우리는 2주 전에 했던 것과 같은 배열을 같습니다, 
즉 2, 5, 3, 6, 8, 13, 10, 11 입니다. 
만약 여러분이 분할 알고리즘을 돌린다면, 
그것은 그것이 인자를 던지는 순서입니다.
그리고 이것은 우리의 포지션 r 입니다. 
이것은 여기서 p입니다. 그것은 1 입니다. 
그리고 q는 끝입니다. 그리고 저는 7 번째 작은 인자를 찾으려고 합니다.
그리고 제가 6이 4 번째 장소로 떨어질 때  
그것이 일어납니다.
그리고 우리는 그것의 의미를 압니다 왜냐하면 
이쪽의 모든 인자는 6 보다 작고 여기의 모든 인자는 6 보다 크기 때문입니다, 

English: 
So, nothing fancy.
I would have to flip a few
coins in order to generate a
random one, so let's just pick
this one.
If I partition at the element
6, this is actually an example
we did two weeks ago,
and I won't go through it
again, but we get the same
array, as we did two weeks ago,
namely 2, 5,
3, 6, 8, 13,
10 and 11.
If you run through the
partitioning algorithm,
that happens to be the order
that it throws the elements
into.
And this is our position r.
This is p here.
It's just 1.
And q is just the end.
And I am looking for the
seventh smallest element.
And it happens when I run this
partition that 6 falls into the
fourth place.
And we know that means,
because all the elements here
are less than 6 and all the
elements here are greater than

Korean: 
이 배열이 정렬되었다면, 6은 포지션 4에서 옳습니다. 
그래서, 여기서 r은 4입니다. 
네? 12가 11로 되었나요? 
이것은 11 이었습니다, 믿거나 말거나요. 
단순해집시다. 미안해요. 
때때로 저는 두 모습을 가집니다. 
좋은 것은 아니지요. 그것은 커버하기 쉬운 방법입니다.
그것을 시험에서 하지는 마세요. 
오, 1은 2였습니다. 안 됩니다. 
우리가 배열을 정렬하지 않더라도, 우리는 여기서 6으로 분할하기 
위해 선형의 일을 할 것입니다.
우리는 우리가 배열을 정렬했다면 6이 여기 떨어진다는 것을 압니다. 
우리는 이 다른 인자들에 대해 모릅니다. 
그것들은 정렬된 순서에 있지 않지만, 분할의 속성으로부터 
우리는 6이 옳은 곳에 있다는 것을 압니다. 
이제 우리는 6의 순위가 4라는 것을 압니다. 우리는 7을 찾고 

English: 
6, if this array were sorted,
6 would be right here in
position four.
So, r here is 4.
Yeah?
The 12 turned into an 11?
This was an 11,
believe it or not.
Let me be simple.
Sorry.
Sometimes my ones look like
twos.
Not a good feature.
That's an easy way to cover.
[LAUGHTER]
Don't try that on exams.
Oh, that one was just a two.
No.
Even though we're not sorting
the array, we're only spending
191
00:13:37,000 --> 00:00:06,000
linear work here to partition by
We know that if we had sorted
the array 6 would fall here.
We don't know about these other
elements.
They're not in sorted order,
but from the properties of
partition we know 6 went the
right spot.
We now know rank of 6 is 4.
We happened to be looking for 7

Korean: 
이 숫자 4를 얻습니다.
우리는 여기서 무엇을 원합니다. 우리는 10을 찾으려고 합니다. 
아니요, 11 입니다. 
이 배열에는 8개의 인자가 있어야 합니다,
그것은 max 다음 입니다. 여기서 max는 13입니다. 
저는 여기서 속이고 있습니다. 우리가 찾는 답은 11입니다. 
우리는 우리가 찾는 것이 오른쪽 부분에 있다는 것을 압니다 
왜냐하면 우리가 찾는 순위가 7이기 때문입니다, 
그것은 4 보다 큽니다. 
이제, 여기서 우리는 무슨 순위를 찾고 있나요? 
자, 우리는 여기서 4개의 인자를 제거 했습니다.
이 예에서 p는 1이기 때문에 k는 또한 4입니다. 
6의 순위는 4였습니다. 
우리는 이 4 인자들을 던집니다. 
이제 우리는 7 마이너스 4인 3의 순위를 찾으려고 합니다.
그리고, 정말로, 여기서 3 인자의 순위는 여전히 11입니다. 
그래서, 여러분은 재귀적으로 그것을 찾습니다. 
그것이 여러분의 답입니다. 이제 그 알고리즘은 매우 명확해야 합니다. 

English: 
and we happened to get this
number 4.
We want something over here.
It turns out we're looking for
10, I guess.
No, 11.
There should be eight elements
in this array,
so it's the next to max.
Max here is 13,
I'm cheating here.
The answer we're looking for is
204
00:14:14,000 --> 00:00:11,000
for is in the right-hand part
because the rank we're looking
206
00:14:20,000 --> 00:00:04,000
for is 7, which is bigger than
Now, what rank are we looking
for in here?
Well, we've gotten rid of four
elements over here.
It happened here that k is also
4 because p is 1 in this
example.
The rank of 6 was 4.
We throw away those four
elements.
Now we're looking for rank 7
minus 4 which is 3.
And, indeed,
the rank 3 element here is
still 11.
So, you recursively find that.
That's your answer.
Now that algorithm should be

Korean: 
까다로운 부분은 그것을 분석하는 것입니다. 
그리고 여기서 분석은 랜덤 퀵 정렬과 같습니다, 
그래서 그것은 더 빠를 것입니다. 
그러나 그것은 까다로운 랜덤 퀵 정렬의  
좋은 리뷰가 될 것이고 
여러 번 보기 좋습니다.
우리는 이 알고리즘의 예상된 러닝 타임을 보기 전에 
아웃라인을 따를 것입니다.
그리고 전에, 우리는 우리 스스로에 대해 좋게 
느끼기 위해 어떤 직관을 볼 것입니다. 
나쁘게 느낄 수도 있습니다. 두 극단적인 경우에 대해 생각해 봅시다, 
좋은 경우와 최악의 경우를요. 
그리고 저는 오늘 모든 분석에서 우리가 인자들이 서로 다른 수라고  
가정해야합니다.

English: 
pretty clear.
The tricky part is to analyze
it.
And the analysis here is quite
a bit like randomized quicksort,
although not quite as hairy,
so it will go faster.
But it will be also sort of a
nice review of the randomized
quicksort analysis which was a
bit tricky and always good to
see a couple of times.
We're going to follow the same
kind of outline as before to
look at the expected running
time of this algorithm.
And to start out we're going
to, as before,
look at some intuition just to
feel good about ourselves.
Also feel bad as you'll see.
Let's think about two sort of
extreme cases,
a good case and the worst case.
And I should mention that in
all of the analyses today we
assume the elements are
distinct.

Korean: 
인자들이 개별적이 아니면 정말 엉망입니다. 
그리고 여러분은 알고리즘을 약간 바꾸어야 합니다 
왜냐하면 모든 인자들이 같으면, 여러분이 랜덤 인자를 고르면, 
분할은 잘 하지 않기 때문입니다. 
그러나 그것들이 개별적이라고 가정해 보세요, 그것은 정말 흥미로운 케이스입니다. 
운이 좋은 케이스에요.
가장 좋은 경우는 중간에서 분할하는 것입니다. 
우리 분할의 왼쪽의 인자들의 수는 우리 분할의 
오른쪽의 인자의 수와 같습니다. 
그러나 거의 1/10 과 9/10 처럼 좋습니다. 
우리는 그것을 느껴야 합니다. 
어떤 정수의 분수는 1/2와 같이 좋습니다. 
그러면 우리가 얻는 재귀는 이렇습니다. 나쁘네요. 

English: 
It gets really messy if the
elements are not distinct.
And you may even have to change
the algorithms a little bit
because if all the elements are
equal, if you pick a random
element, the partition does not
do so well.
But let's assume they're all
distinct, which is the really
interesting case.
A pretty luck case --
I mean the best cases we
partition right in the middle.
The number of elements to the
left of our partition is equal
to the number of elements to the
right of our partition.
But almost as good would be
some kind of 1/10 to 9/10 split.
Any constant fraction,
we should feel that.
Any constant fraction is as
good as 1/2.
Then the recurrence we get is,
let's say at most,

Korean: 
그래서, 그것은 의존적입니다. 
우리가 매번 왼쪽에 1/10 오른쪽에 9/10을 가지면 우리는 분할을 합니다. 
그것은 우리의 답이 어디 있는지에 의존합니다. 
i가 정말 작으면 그것은 1/10 부분입니다. 
i가 정말 크면, 그것은 9/10 부분일 것입니다, 
그렇지 않으면 대부분은 9/10일 것입니다. 
우리는 운 좋은 경우 내에서 최악의 케이스 분석을 알 것입니다,
그래서 우리는 상계를 가져서 행복합니다. 
저는 t(n)이 많아 봐야 T(9/10n)+θ(n) 라고 말할 것입니다.
명백히 우리가 큰 부분에 있으면 그것은 더 나쁩니다. 
이 재귀의 답이 무엇입니까? 
오, 재귀를 푸는 것은 오래 전이었나요? 
이 재귀를 풀기 위해 우리는 어떤 메소드가 필요합니까? 
마스터 메소드입니다. 우리는 어떤 케이스에 있습니까? 
case 3에 있었죠. 좋아요. 

English: 
this bad.
So, it depends.
If we have let's say 1/10 on
the left and 9/10 on the right
every time we do a partition.
It depends where our answer is.
It could be if i is really
small it's in the 1/10 part.
If i is really big it's going
to be in the 9/10 part,
or most of the time it's going
to be in the 9/10 part.
We're doing worst-case analysis
within the lucky case,
so we're happy to have upper
bounds.
I will say t(n) is at most t of
T(9/10n)+Theta(n).
Clearly it's worse if we're in
the bigger part.
What is the solution to this
recurrence?
Oh, solving recurrence was so
long ago.
What method should we use for
solving this recurrence?
The master method.
What case are we in?
Three.
Good.
You still remember.
This is Case 3.

English: 
We're looking at nlog_b(a).
b here is 10/9,
although it doesn't really
matter because a is 1.
log base anything of 1 is 0.
So, this is n^0 which is 1.
And n is polynomially larger
than 1.
This is going to be O(n),
which is good.
That is what we want,
linear time.
If we're in the lucky case,
great.
Unfortunately this is only
intuition.
And we're not always going to
get the lucky case.
We could do the same kind of
analysis as we did with
randomized quicksort.
If you alternate between lucky
and unlucky, things will still
be good, but let's just talk
about the unlucky case to show
how bad things can get.
And this really would be a
worst-case analysis.

Korean: 
우리는 nlog_b(a)를 볼 것입니다. 여기서 b는 10/9입니다, 
그것이 정말 중요하지 않더라도요 왜냐하면 a는 1이기 때문입니다. 
로그 1은 0입니다. 그래서, 이것은 1인 n^0입니다. 
그리고 n은 다항적으로 1 보다 큽니다. 
이것은 θ(n)이 될 것이고, 그것은 좋습니다. 
그것은 우리가 원하는 것, 선형 시간입니다. 
우리가 운 좋은 경우에 있다면, 훌륭합니다. 
불행히도 이것은 직관일 뿐입니다. 
그리고 우리는 항상 운 좋은 경우를 얻지 않을 것입니다. 
우리는 랜덤 퀵 정렬으로 했던 것처럼 같은 분석을 할 수 있습니다.
여러분이 운 좋은 경우와 운 나쁜 경우 사이를 번갈아 하면, 
그것은 여전히 좋을 것이지만, 나쁜 것들이 어떻게 얻는지 보기 위해 
운 나쁜 경우에 대해 이야기 해 봅시다. 
그리고 이것은 정말 최악의 경우 분석이 될 것입니다. 

Korean: 
운 나쁜 경우에서 우리는 0:n-1 을 얻습니다. 
왜냐하면 우리는 분할 인자를 양쪽 다 제거할 것이기 때문입니다. 
그리고 분할 인지 보다 작은 것은 아무 것도 없습니다. 
우리는 왼쪽에 0을 가지고 오른쪽에 n-1을 가집니다. 
이제 우리는 T(n)=T(n-1) 더하기 선형 비용 같은 재귀를 가집니다. 
그리고 그 재귀의 답은 무엇인가요? 
θ(n^2) 입니다. 
네. 이것은 여러분이 알아야 하는 것입니다. 
그것이 등차 급수이기 때문에 n^2 입니다.
그리고 그것은 매우 나쁩니다. 이것은 정렬 보다 훨씬, 훨씬 더 나쁩니다 
그리고 i번째 인자를 고릅니다. 
최악의 경우에서 이 알고리즘은 정말 나쁩니다, 
그러나 대부분의 시간에서 그것은 잘 동작할 것입니다. 
그리고 여러분이 정말 정말 운이 나쁘지 않으면 여러분이 뒤집는 모든 동전은 
틀린 답을 줄 것이고, 여러분은 이 경우를 얻지 않을 것입니다 
그리고 여러분은 운 좋은 경우 같은 것을 얻게 되겠지요. 

English: 
The unlucky case we get a split
of 0:n-1.
Because we're removing the
partition element either way.
And there could be nothing less
than the partition element.
We have 0 on the left-hand side
and we have n-1 on the
right-hand side.
Now we get a recurrence like
T(n)=T(n-1) plus linear cost.
And what's the solution to that
recurrence?
n^2.
Yes.
This one you should just know.
It's n^2 because it's an
arithmetic series.
And that's pretty bad.
This is much,
much worse than sorting and
then picking the ith element.
In the worst-case this
algorithm really sucks,
but most of the time it's going
to do really well.
And, unless you're really,
really unlucky and every coin
you flip gives the wrong answer,
you won't get this case and you
will get something more like the
lucky case.

Korean: 
적어도 그것은 우리가 증명하려고 하는 것입니다.
그리고 우리는 여기서 예상되는 러닝 타임이 선형이라는 것을 증명할 것입니다. 
그래서, 2차의 것을 얻는 것은 매우 드뭅니다. 
그러나 나중에 우리는 worst-case의 선형을 만드는 
방법을 보게 될 것입니다. 
이것은 정말로, 문제를 풀게 됩니다. 
분석으로 가 봅시다. 
이제, 여러분은 전에 이와 같은 분석을 보았을 겁니다. 
이 예상 시간을 분석하기 위해 무엇을 제안하나요? 
그것은 분할 정복 알고리즘입니다, 
그래서 우리는 러닝 타임과 닮은 것에서 

English: 
At least that's what we'd like
to prove.
And we will prove that the
expected running time here is
linear.
So, it's very rare to get
anything quadratic.
But later on we will see how to
make the worst-case linear as
well.
This would really,
really solve the problem.
Let's get into the analysis.
Now, you've seen an analysis
much like this before.
What do you suggest we do in
order to analyze this expected
time?
It's a divide-and-conquer
algorithm, so we kind of like to
write down the recurrence on

Korean: 
재귀를 쓰고 싶습니다.
저는 답이 필요하지 않지만, 
우리가 이 알고리즘의 예산된 러닝 타임을 분석해야 하는 첫 번째 단계는  
무엇인가요? 네?
다른 경우들을 봅시다, 네. 
정확해요. 우리는 랜덤 분할이 쪼갤 수 있는 
모든 가능한 방법을 가지고 있습니다. 
그것은 0과 n-1일 수 있습니다. 그것은 반으로 쪼갤 수 있습니다. 
그것이 쪼갤 수 있는 n 가지 선택이 있습니다. 
우리는 이 경우들을 어떻게 할 수 있죠? 
지시자 랜덤 변수들 입니다. 좋아요. 
정확해요. 바로 그걸 하려는 겁니다. 
지시자 랜덤 변수는 우리가 하려는 것이 정확히 함수 T(n)이 아니라는 것을 
제안하지만 그것은 랜덤 변수 입니다. 
이것은 미묘한 것입니다. 
T(n)은 랜덤 선택에 의존합니다, 

English: 
something resembling the running
time.
I don't need the answer,
but what's the first step that
we might do to analyze the
expected running time of this
algorithm?
Sorry?
Look at different cases,
yeah.
Exactly.
We have all these possible ways
that random partition could
split.
It could split 0 to the n-1.
It could split in half.
There are n choices where it
could split.
How can we break into those
cases?
Indicator random variables.
Cool.
Exactly.
That's what we want to do.
Indicator random variable
suggests that what we're dealing
with is not exactly just a
function T(n) but it's a random
variable.
This is one subtlety.
T(n) depends on the random
choices, so it's really a random

Korean: 
그래서 그것은 정말 랜덤 변수입니다.
그리고 우리는 지시자 랜덤 변수를 T(n)에서 
재귀를 얻기 위해 사용할 것입니다. 
그래서, T(n)은 사이즈 n의 입력에 대해 rand-select의 러닝 타임입니다. 
그리고 저는 또한 랜덤 수들에 대한 가정을 
명쾌하게 쓸 것입니다. 

English: 
variable.
And then we're going to use
indicator random variables to
get a recurrence on T(n).
So, T(n) is the running time of
rand-select on an input of size
n.
And I am also going to write
down explicitly an assumption
about the random numbers.

Korean: 
그것들은 각 다른 것들로부터 독립적으로 선택되어야 합니다. 
제가 랜덤 분할을 호출 할 때 마다 매번, 그것은 제가 랜덤 분할을 
호출한 모든 다른 시간으로부터 완전하게 독립적인 랜덤한 수를 생성합니다. 
물론, 그것은 이 분석이 동작하기 
위해 중요합니다. 
우리는 왜 그런지 볼 것입니다. 
그리고 이제, T(n)을 위한 식을 쓰기 위해 우리는 
지시자 랜덤 변수들을 정의할 것입니다.
그리고 우리는 그것을 X_k 라고 부를 것입니다. 그리고 그것은 모든 k=0...n-1에 대한 것입니다. 
1 또는 0의 지시자 랜덤 변수들 입니다. 

English: 
That they should be chosen
independently from each other.
Every time I call random
partition, it's generating a
completely independent random
number from all the other times
I call random partition.
That is important,
of course, for this analysis to
work.
We will see why some point down
the line.
And now, to sort of write down
an equation for T(n) we're going
to define indicator random
variables, as you suggested.
And we will call it X_k.
And this is for all k=0...n-1.
Indicator random variables
either 1 or 0.

Korean: 
그리고 분할이 k가 왼편에 있게 되면 그것은 1이 될 것입니다. 
그래서 분할이 k:n-k-1 을 생성한다고 해봅시다 
그러면 그것은 0입니다. 
우리는 0에서 n-1 사이의 이 지시자 랜덤 변수들의 n을 가지고 있습니다. 
그리고 각 케이스에서,
랜덤 선택이 무엇이든 관계 없이 그것들 중 하나는 정확히 1이 될 것입니다.
모든 다른 것들은 0이 될 것입니다. 
이제 우리는 우리가 속한 케이스에 기반한 이 알고리즘의 
러닝타임을 나눌 수 있습니다. 
그것은 우리가 했었고 모든 케이스들을 얻는 이 직관을 통합할 것입니다. 

English: 
And it's going to be 1 if the
partition comes out k on the
left-hand side.
So say the partition generates
a k:n-k-1 split and it is 0
otherwise.
We have n of these indicator
random variables between
0...n-1.
And in each case,
no matter how the random choice
comes out, exactly one of them
will be 1.
All the others will be 0.
Now we can divide out the
running time of this algorithm
based on which case we're in.
That will sort of unify this
intuition that we did and get

Korean: 
그리고 나서 우리는 기대값을 볼 수 있습니다. 
우리가 이 케이스들로 나눈다면, 
우리는 이와 같은 상계를 가집니다. 
우리가 0 에서 n-1로 나눈 것을 가진다면, 최악은 우리가 n-1을 가지는 것입니다. 
우리는 n-1 크기의 문제에서 순환해야 합니다.
사실, 크기 0의 문제에서 순환하기는 매우 어렵습니다. 
우리가 1에서 n-2로 나눈 것을 가진다면, 
우리는 두 개의 최대를 취할 것입니다. 
그것은 확실히 우리에게 상계 등을 줍니다.

English: 
all the cases.
And then we can look at the
expectation.
T(n), if we just split out by
cases, we have an upper bound
like this.
If we have 0 to n-1 split,
the worst is we have n-1.
Then we have to recurse in a
problem of size n-1.
In fact, it would be pretty
hard to recurse in a problem of
size 0.
If we have a 1 to n-2 split
then we take the max of the two
sides.
That's certainly going to give
us an upper bound and so on.

Korean: 
그리고 아래에서 여러분은 n-1에서 0의 분할을 얻습니다. 
이것은 이제 많은 이벤트에 대한 조절입니다, 
그러나 우리는 이 이벤트들이 언제 일어나는지 우리에게 말해주는 지시자 랜덤 변수들을 가지고 있습니다. 
우리는 이 값들 각각과 지시자 랜덤 변수들을 곱할 수 있고 
그것은 케이스가 아니면 0일 것입니다 
그리고 그것이 분할되면 1일 것이고 
우리에게 이 값을 줄 겁니다. 
그래서, 우리가 그것들을 모두 더하면 우리는 같은 것을 얻을 것입니다. 
그 케이스에서 이것은 지시자 랜덤 변수의 모든 합
곱하기 비용과 같을 것이고, 
다른 쪽은 n-k-1 더하기 θn 입니다.

English: 
And at the bottom you get an
n-1 to 0 split.
This is now sort of
conditioning on various events,
but we have indicator random
variables to tell us when these
events happen.
We can just multiply each of
these values by the indicator
random variable and it will come
out 0 if that's not the case and
will come out 1 and give us this
value if that happens to be the
split.
So, if we add up all of those
we'll get the same thing.
This is equal to the sum over
all k of the indicator random
variable times the cost in that
case, which is t of max k,
and the other side,
which is n-k-1,

Korean: 
어떤 면에서, 이것은 러닝 타임을 나타내는 
랜덤 변수를 위한 우리의 재귀입니다. 
이제, 값은 우리가 하게 될 케이스에 의존합니다. 
우리는 각 이벤트가 일어날 확률이 같다는 것을 알고 있습니다 
왜냐하면 우리는 분할 인자를 균등하게 랜덤하게 선택할 것이기 때문입니다, 
그러나 우리가 기대값을 가질 때까지 
우리는 이 보다 더 단순화할 수 없습니다. 
우리는 이 지시자 랜덤 변수가 n^2만큼 클 수 있다는 것을 압니다. 
희망적으로 그것은 보통 선형입니다. 우리는 두 쪽의 기대값을 가지고 
우리가 원하는 것을 얻습니다.
이 랜덤 변수의 기대값을 봅시다, 

English: 
plus theta n.
This is our recurrence,
in some sense,
for the random variable
representing running time.
Now, the value will depend on
which case we come into.
We know the probability of each
of these events happening is the
same because we're choosing the
partition element uniformly at
random, but we cannot really
simplify much beyond this until
we take expectations.
We know this random variable
could be as big as n^2.
Hopefully it's usually linear.
We will take expectations of
both sides and get what we want.
Let's look at the expectation
of this random variable,

English: 
which is just the expectation,
I will copy over,
summation we have here so I can
work on this board.
I want to compute the
expectation of this summation.
What property of expectation
should I use?
Linearity, good.
We can bring the summation
outside.

Korean: 
그것은 단지 기대값입니다, 저는 우리가 여기서 가지는 합을 복사할 것입니다 
그래서 저는 이 칠판에서 할 수 있습니다. 
저는 이 합의 기대값을 계산하길 원합니다. 
저는 기대값의 무슨 속성을 사용해야 하나요? 
선형성입니다, 좋아요. 우리는 합을 밖으로 
가져올 수 있습니다.

English: 
Now I have a sum of
expectation.
Let's look at each expectation
individually.
It's a product of two random
variables, if you will.
This is an indicator random
variable and this is some more
complicated function,
some more complicated random
variable representing some
running time,
which depends on what random
choices are made in that
recursive call.
Now what should I do?
I have the expectation of the
product of two random variables.
Independence,
exactly.
If I know that these two random
variables are independent then I
know that the expectation of the
product is the product of the
expectations.
Now we have to check are they
independent?
I hope so because otherwise

Korean: 
이제 저는 기대값의 합을 가집니다.
각 기대값을 개별적으로 봅시다. 
그것은 두 랜덤 변수들의 곱입니다. 
이것은 지시자 랜덤 변수이고 이것은 더 복잡한 함수, 
어떤 러닝 타임을 나타내는 
더 복잡한 랜덤 변수 입니다, 
그것은 그 재귀 호출에서 어떤 랜덤 선택이 만들어졌는지에 의존합니다.
이제 무엇을 해야 하나요? 
두 랜덤 변수들의 곱의 기대값을 가집니다. 
독립적이에요, 정확합니다. 
제가 이 두 랜덤 변수들이 독립적이라는 것을 알면 저는 곱의 기대값이 
기대값의 곱이라는 것을 압니다. 
이제 우리가 검사해야 하는 것은 그것들이 독립적인가 입니다. 
저는 그러길 희망합니다 왜냐하면 그렇지 않을 경우 제가 할 수 있는 것이 많이 없거든요. 

English: 
there isn't much else I can do.
Why are they independent?
Sorry?
Because we stated that they
are, right.
Because of this assumption.
We assume that all the random
numbers are chosen
independently.
We need to sort of interpolate
that here.
These X_k's,
all the X_k's,
X_0 up to X_n-1,
so all the ones appearing in
this summation are dependent
upon a single random choice of
this particular call to random
partition.
All of these are correlated,
because if one of them is 1,
all the others are forced to be
425
00:30:44,000 --> 00:00:00,000
correlation among the X_k's.
But with respect to everything

Korean: 
그것들은 왜 독립적입니까? 
네? 왜냐하면 우리가 그것들을 그렇게 썼기 때문입니다, 
좋아요. 이 가정 때문입니다. 
우리는 모든 랜덤 수들이 독립적으로 선택된다고 가정합니다. 
우리는 여기서 그것을 덧붙여야 합니다. 
이것들은 X_0에서 X_n-1까지 
모든 X_k 입니다, 
그래서 이 합에 나타나는 모든 것은 랜덤 분할의 이 특정한 호출의 
단일 랜덤 선택에 의존적입니다.
이것들은 모두 상호 연관이 있습니다, 
왜냐하면 그것들 중 하나가 1이면, 모든 다른 것들은 0이어야 합니다. 
그래서 X_k 들 사이에서 많은 연관성이 있습니다. 
그러나 여기 있는 모든 것들에 대하여,  

English: 
that is in here,
and the only random part is
this T(max(kn-k-1)).
That is the reason that this
random variable is independent
from these.
The same thing as quicksort,
but I know some people got
confused about it a couple
lectures ago so I am
reiterating.
We get the product of
expectations,
E[X_k] E[T(max(kn-k-1))].
I mean the order n comes
outside, but let's leave it
inside for now.
There is no expectation to
compute there for order n.
Order n is order n.
What is the expectation of X_k?
1/n, because they're all chosen

Korean: 
유일한 랜덤한 부분은 이 T(max(kn-k-1)) 입니다.
그것은 이 랜덤 변수가 이것들로부터 
독립적인 이유입니다. 
퀵 정렬과 같은 것이지만, 저는 여러분들이 그것에 대해 지난 몇 강의 동안 
혼란스러워 했다는 것을 압니다 그래서 반복할 것입니다. 
우리는 기대값 E[X_k] E[T(max(kn-k-1))] 의 
곱을 얻습니다.
저는 θ(n)이 밖으로 나오는 것을 의도하지만, 지금은 그것을 안에 둡시다
θ(n)을 위해 저기서 계산할 기대값이 없습니다.  
θ(n)은 θ(n)입니다.
X_k의 기대값은 무엇입니까? 1/n입니다, 

English: 
with equal probability.
There is n of them,
so the expectation is 1/n.
The value is either 1 or 0.
We start to be able to split
this up.
We have 1/n times this expected
value of some recursive T call,
and then we have plus 1 over n
times order n,
also known as a constant,
but everything is summed up n
times so let's expand this.
I have the sum k=0 to n-1.
I guess the 1/n can come
outside.
And we have expectation of
[T(max(kn-k-1))].
Lots of nifty braces there.
And then plus we have,
on the other hand,

Korean: 
왜냐하면 그것들은 모두 같은 확률로 선택되었기 때문입니다. 그것들이 n개 있고, 
기대값은 1/n 입니다. 값은 1 또는 0 입니다. 
우리는 이것을 쪼갤 수 있습니다. 
우리는 1/n 곱하기 재귀 T 호출의 기대값을 가집니다
그리고 우리는 1 나누기 n 곱하기 오더 n을 가집니다, 
그것은 정수입니다, 그러나 모든 것은 n번 더해집니다 
이것을 확장해봅시다.
저는 k=0에서 n-1까지 합을 가집니다. 1/n은 밖으로 나올 수 있습니다. 
그리고 우리는 [T(max(kn-k-1))]의 기대값을 가집니다. 
많은 좋은 것들이 저기 있습니다. 
반면에, 우리는 k=0에서 n-1까지 합을 가집니다. 

English: 
the sum k=0 to n-1.
Let me just write that out
again.
We have a 1/n in front and we
have a Theta(n) inside.
This summation is n^2.
And then we're dividing by n,
so this whole thing is,
again, order n.
Nothing fancy happened there.
This is really just saying the
expectation of order n is order
n.
Average value of order n is
order n.
What is interesting is this
part.
Now, what could we do with this
summation?
Here we start to differ from
randomized quicksort because we
have this max.
Randomized quicksort we had the
sum of T(k) plus T(n-k-1)
because we were making both
recursive calls.
Here we're only making the
biggest one.

Korean: 
그것을 다시 써 보겠습니다. 
우리는 앞에서 1/n을 가지고 안에서 
Theta(n)을 가집니다. 이 합은 n^2 입니다. 
그리고 나서 우리는 n으로 나눌 것입니다, 그래서 이 모든 것은 
다시 θ(n) 입니다. 저기서 어떤 좋은 일도 일어나지 않습니다. 
단지 θ(n)의 기대값이 θ(n)입니다. 
θ(n)의 평균은 θ(n)입니다.
흥미로운 것은 이 부분입니다. 
이제, 이 합으로 우리는 무엇을 할 수 있습니까? 
여기서 우리는 랜덤 퀵 정렬과 다르게 시작합니다  
왜냐하면 우리는 이 최대값을 가집니다.
랜덤 퀵 정렬에서 우리는 T(k)와 T(n-k-1)의 합을 가졌습니다 
왜냐하면 우리는 재귀 호출을 만들고 있었기 때문입니다. 
여기서 우리는 가장 큰 것만을 만들 수 있습니다. 

English: 
That max is really a pain for
evaluating this recurrence.
How could I get rid of the max?
That's one way to think of it.
Yeah?
Exactly.
I could only sum up to halfway
and then double.
In other words,
terms are getting repeated
twice here.
When k=0 or when k=n-1,
I get the same T(n-1).
When k=1 or n-2,
I get the same thing,
2 and n-3.
What I will actually do is sum
from halfway up.
That's a little bit cleaner.
And let me get the indices
right.
Floor of n/2 up to n-1 will be
safe.
And then I just have E[T(k)],
except I forgot to multiply by

Korean: 
그 최대값은 이 재귀를 평가하기 위한 고통입니다. 
제가 최대값을 어떻게 제거할 수 있을까요? 그것은 그것을 생각하는 하나의 방법입니다. 
네?
정확해요. 저는 합을 반으로 하고 두 배로 합니다. 
다시 말해, 항들은 여기서 
두 번 반복될 것입니다.
k=0일 때 또는 k=n-1일 때, 저는 같은 T(n-1)을 얻습니다. 
k=1일 때 또는 k=n-2일 때, 저는 같은 것을 얻습니다. 
2와 n-3일 때도요. 제가 실제로 하려는 것은 중간에서부터 더하는 것입니다. 
그것은 약간 더 분명합니다. 
그리고 제는 인덱스를 얻습니다. 
n/2 의 n-1이 안전할 것입니다. 
그리고 나서 저는 E[T(k)]를 얻습니다. 제가 2를 곱하는 것을 잊어버렸을 때를 제외하고요, 

English: 
2, so I'm going to change this 1
to a 2.
And order n is preserved.
This is just because each term
is appearing twice.
I can factor it out.
And if n is odd,
I'm actually double-counting
somewhat, but it's certain at
most that.
So, that's a safe upper bound.
And upper bounds are all we
care about because we're hoping
to get linear.
And the running time of this
algorithm is definitely at least
linear, so we just need an upper
bounded linear.
So, this is a recurrence.
E[T(n)] is at most 2/n times
the sum of half the numbers
between 0 and n of
E[T(k)]+Theta(n).
It's a bit of hairy recurrence.
We want to solve it,
though.
And it's actually a little bit
easier than the randomized
quicksort recurrence.
We're going to solve it.
What method should we use?
Sorry?
Master method?
Master would be nice,
except that each of the
recursive calls is with a

Korean: 
그래서 저는 이 1을 2로 바꿀 것입니다.
그리고 θ(n)은 유지됩니다. 이것은 각 항이 두 번 나타나기 때문입니다. 
저는 인자를 꺼낼 수 있습니다. 
그리고 n이 홀수이면, 저는 사실 이중계산을 하는 것입니다, 
그러나 그것은 확실합니다. 
그래서 그것은 안전한 상계입니다. 그리고 상계는 모두 우리가 
신경 쓰는 것입니다. 왜냐하면 우리는 선형을 얻고 싶기 때문입니다.
그리고 이 알고리즘의 러닝 타임은 분명히 적어도 선형입니다, 
그래서 우리는 선형 상계가 필요합니다.
그래서, 이것은 재귀입니다. E[T(n)]은 많아 봐야 2/n 곱하기 
0과 E[T(k)]+θ(n)의 n 사이의 어떤 수의 절반의 합입니다. 
그것은 약간 까다로운 재귀입니다. 
그러나 우리는 그것을 풀길 원합니다. 
그리고 그것은 사실 랜덤 퀵 정렬 재귀 보다 약간 더 쉽습니다. 
우리는 그것을 풀 것입니다. 
우리는 어떤 메소드를 사용해야 합니까? 
마스터 메소드인가요? 재귀 호출 각각이 다른 k 값을 갖는 경우를 제외하고는, 
마스터도 좋습니다. 

English: 
different value of k.
The master method only works
when all the calls are with the
same value, same size.
Alas, it would be nice if we
could use the master method.
What else do we have?
Substitution.
When it's hard,
when in doubt,
use substitution.
I mean the good thing here is
we know what we want.
From the intuition at least,
which is now erased,
we really feel that this should
be linear time.
So, we know what we want to
prove.
And indeed we can prove it just
directly with substitution.
I want to claim there is some
constant c greater than zero
such that E[T(n)],
according to this recurrence,
is at most c times n.
Let's prove that over here.

Korean: 
모든 호출이 같은 값, 같은 사이즈일 때만 
마스터 메소드는 동작합니다. 
우리가 마스터 메소드를 사용할 수 있다면 좋을 것입니다. 
우리는 또 무엇을 가지고 있죠? 대입입니다
어렵거나 의심될 때, 
대입을 사용하세요. 여기서 좋은 것은 우리가 원하는 것을 알고 있다는 것입니다. 
적어도 직관으로부터, 
그것은 이제 지워졌는데, 우리는 이것이 선형 시간이어야 한다고 느낍니다. 
그래서, 우리는 우리가 증명하길 원합니다. 
그리고 정말로 우리는 대입으로 그것을 직접적으로 
풀 수 있습니다. 
이 재귀에 따라 E[T(n)]과 같은 0 보다 큰 정수 c가 있습니다, 
그것은 많아 봐야 c 곱하기 n 입니다. 
여기서 증명해 봅시다. 

Korean: 
우리가 추측한 것처럼, 증명은 대입에 의한 것입니다. 
그것이 의미하는 것은 우리가 도입에 의하여, 이 불균등이 모든 작은 
n에 대하여 옳다는 것을 가정하려고 한다는 것입니다. 
저는 n 보다 작은 4를 말할 것입니다. 그리고 우리는 n에 대하여 그것을 증명할 필요가 있습니다. 
우리는 E[T(n)]을 얻습니다.
이제 우리는 우리가 가지고 있는 재귀를 사용하여 확장할 것입니다. 
그것은 많아 봐야 이것입니다. 저는 저기서 그것을 복사할 것입니다.
그리고 이 재귀 호출의 각각은 n 보다 엄격히 작은 

English: 
As we guessed,
the proof is by substitution.
What that means is we're going
to assume, by induction,
that this inequality is true
for all smaller m.
I will just say 4 less than n.
And we need to prove it for n.
We get E[T(n)].
Now we are just going to expand
using the recurrence that we
have.
It's at most this.
I will copy that over.
And then each of these
recursive calls is with some

English: 
value k that is strictly smaller
than n.
Sorry, I copied it wrong,
floor of n over 2,
not zero.
And so I can apply the
induction hypothesis to each of
these.
This is at most c times k by
the induction hypothesis.
And so I get this inequality.
This c can come outside the
summation because it's just a
constant.
And I will be slightly tedious
in writing this down again,
because what I care about is
the summation here that is left
over.

Korean: 
어떤 값 k를 가집니다. 
미안합니다, 저는 그것을 잘못 가져다 썻네요. 
그리고 저는 이 각각에 도입 가설을 
적용할 수 있습니다. 
이것은 도입 가설에 의하여 많아 봐야 c 곱하기 k입니다. 
그리고 저는 이 부등식을 가집니다.
C는 정수이기 때문에 밖으로 나올 수 있습니다. 
그리고 저는 이것을 다시 쓰는 것이 약간 지루합니다, 
왜냐하면 제가 신경 쓰는 것은 여기의 
남은 합이기 때문입니다. 

English: 
This is a good old-fashioned
summation.
And if you remember back to
your summation tricks or
whatever, you should be able to
evaluate this.
If we started at zero and went
up to n minus 1,
that's just an arithmetic
series, but here we have the
tail end of an arithmetic
series.
And you should know,
at least up to theta,
what this is,
right?
n^2, yeah.
It's definitely T(n^2).
But we need here a slightly
better upper bond,
as we will see the constants
really matter.
What we're going to use is that
this summation is at most 3/8
times n^2.
And that will be critical,
the fact that 3/8 is smaller
than 1/2, I believe.
So it's going to get rid of
this 2.
I am not going to prove this.
This is an exercise.
When you know that it is true,
it's easy because you can just
prove it by induction.
Figuring out that number is a

Korean: 
이것은 좋은 오래된 합입니다. 
그리고 여러분이 여러분의 합 기술 같은 것을 다시 기억하고 싶다면, 
여러분은 이것을 평가할 수 있어야 합니다. 
만약 우리가 0에서 시작해서 n-1까지 간다면, 
그것은 등차급수 이지만, 
여기서 우리는 등차 급수의 마지막을 가집니다. 
그리고 여러분은 알아야 합니다, 적어도 θ(theta)까지, 
이것은 무엇입니까? 
네, n^2입니다. 그것은 정확히 T(n^2) 입니다. 
그러나 우리가 여기서 필요한 것은 약건 더 나은 상계입니다, 
우리가 아는 것처럼 정수는 정말 중요합니다.
우리가 사용할 것은 이 합이 많아 봐야 3/8 곱하기 n^2라는 것입니다. 
그리고 3/8이 1/2 보다 더 작다는 
사실은 중요합니다. 
그래서 그것은 이 2를 제거할 것입니다. 
저는 이것을 증명하지 않을 것입니다. 이것은 예제 입니다. 
여러분이 그것이 옳다는 것을 알면 여러분이 도입에 의해 증명할 수 있기 때문에 그것은 매우 쉽습니다. 
그 수를 알아 내는 것은 약간 더 해야 하지만, 

Korean: 
아주 많이는 아닙니다. 
그래서 여러분은 도입에 의해 그것을 증명해야 합니다. 
이제 그것을 단순화해 보겠습니다. 이것은 약간 까다롭지만, 
제가 원하는 것은 c 곱하기 n 입니다. 그것을 우리가 바라는 값 마이너스 오차로 써 봅시다. 
그리고 여기서 우리는 이상한 분수를 갖습니다. 
이것은 2 곱하기 3인 5 나누기 8이고 그것은 
3/4입니다, 그렇죠? 
여기서 우리는 1을 갖습니다, 그래서 우리는 3/4를 얻기 위해 
1/4를 빼야 합니다. 
그리고 이것은 1/4 곱하기 c 곱하기 n이 되어야 합니다. 
그리고 나서 우리는 이중 부정인 이 θ(n)을 갖는데 그것은 + θ(n)이 됩니다. 
그것은 분명해져야 합니다. 저는 그것을 다시 쓸 것입니다. 
그래서 우리는 여기서 우리가 원하는 것을 갖습니다. 
그리고 우리는 이것이 음이 아니길 바랍니다 

English: 
little bit more work,
but not too much more.
So you should prove that by
induction.
Now let me simplify.
This is a bit messy,
but what I want is c times n.
Let's write it as our desired
value minus the residual.
And here we have some crazy
fractions.
This is 2 times 3 which is 6
over 8 which is 3/4,
right?
Here we have 1,
so we have to subtract up 1/4
to get 3/4.
And this should be,
I guess, 1/4 times c times n.
And then we have this theta n
with double negation becomes a
plus theta n.
That should be clear.
I am just rewriting that.
So we have what we want over
here.
And then we hope that this is
nonnegative because what we want

English: 
is that this less than or equal
to c times n.
That will be true,
provided this thing is
nonnegative.
And it looks pretty good
because we're free to choose c
however large we want.
Whatever constant is imbedded
in this beta notation is one
fixed constant,
whatever makes this recurrence
true.
We just set c to be bigger than
4 times that constant and then
this will be nonnegative.
So this is true for c
sufficiently large to dwarf that
theta constant.
It's also the base case.
I just have to make the cursory
mention that we choose c large
enough so that this claim is
true, even in the base case
where n is at most some
constant.
Here it's like 1 or so because
then we're not making a
recursive call.
What we get --
This algorithm,
randomize select,

Korean: 
왜냐하면 우리가 원하는 것은 c 곱하기 n 보다 작거나 같은 것이기 때문입니다. 
이것이 음이 아니라면, 그것은 맞을 겁니다. 
그리고 그것은 매우 좋아 보입니다 
왜냐하면 우리가 원하는 것이 얼마나 크든 우리는 c를 선택하는 데서 자유롭기 때문입니다. 
이 베타 표기법에 무슨 정수가 있든 그것은 하나의 고정된 정수입니다, 
무엇이 이 재귀를 옳게 만들든지요. 
우리는 c를 4 곱하기 그 정수 보다 더 크게 둘 것입니다 
그리고 이것은 음이 아닐 것입니다.
그래서 이것은 작은 theta 정수 보다 충분히 큰 c에 대하여 옳습니다.
그것은 또한 기본적인 케이스입니다. 
저는 우리가 충분히 큰 c를 고른다는 피상적인 언급을 해야 합니다 
그래서 이 주장은 옳습니다, 
n이 많아 봐야 어떤 정수인 기본적인 경우에서도요
여기서 그것은 1과 같습니다 왜냐하면 
우리는 재귀 호출을 하지 않기 때문입니다. 
이 알고리즘은 러닝 타임 

English: 
has expected running time order
n, Theta(n).
The annoying this is that in
the worst-case,
if you're really,
really unlucky it's n^2.
Any questions before we move on
from this point?
This finished off the proof of
this fact that we have Theta(n)
expected time.
We already saw the n^2
worst-case.
All perfectly clear?
Good.
You should go over these
proofs.
They're intrinsically related
between randomized quicksort and
randomized select.
Know them in your heart.
This is a great algorithm that
works really well in practice
because most of the time you're
going to split,
say, in the middle,

Korean: 
θ(n) 을 기대합니다. 
최악의 경우에, 여러분이 정말, 
정말 운이 나쁘다면, 그것은 n^2 입니다. 
우리가 이 점으로부터 계속 하기 전에 질문 있나요? 
우리가 예상 시간 θ(n)을 가진다는 이 사실의 증명을 끝냈습니다.
우리는 이미 n^2 최악의 케이스를 보았습니다. 
모두 완벽하게 분명한가요? 
좋아요. 여러분은 이 증명들로 계속 할 것입니다. 
그것들은 랜덤 퀵 정렬과 랜덤 선택 
사이와 본질적으로 연관이 있습니다. 
그것들을 잘 알아야 합니다. 이것은 실제로 매우 잘 동작하는 훌륭한 알고리즘입니다. 
왜냐하면 중간에서 여러분이 쪼개는 
대부분의 시간이 1/4와 3/4 사이이고 

English: 
somewhere between a 1/4 and 3/4
and everything is good.
It's extremely unlikely that
you get the n^2 worst-case.
It would have to happen with
like 1 over n^n probability or
something really,
really small.
But I am a theoretician at
least.
And it would be really nice if
you could get Theta(n) in the
worst-case.
That would be the cleanest
result that you could hope for
because that's optimal.
You cannot do better than
Theta(n).
You've got to look at the
elements.
So, you might ask,
can we get rid of this
worst-case behavior and somehow
avoid randomization and
guarantee Theta(n) worst-case
running time?
And you can but it's a rather
nontrivial algorithm.
And this is going to be one of
the most sophisticated that
we've seen so far.
It won't continue to be the
most sophisticated algorithm we
will see, but here it is.

Korean: 
모든 것이 좋기 때문입니다. 
그것은 극도로 여러분이 n^2 최악의 케이스를 갖을 법하진 않습니다. 
그것은 1 나누기 n^n의 확률 또는 
정말 정말 작은 것으로 일어나야 합니다. 
그러나 저는 적어도 이론가입니다. 
그리고 최악의 케이스에서 여러분이 θ(n)을 가질 수 있다면 그것은 정말 좋을 것입니다. 
그것은 여러분이 바랄 수 있는 가장 명확한 결과가 될 것입니다 
왜냐하면 그것이 최적이기 때문입니다. 
여러분은 θ(n) 보다 나은 것을 할 수 없습니다. 
여러분은 인자들을 보아야 합니다. 
그래서 여러분은 다음과 같이 물을 지도 모릅니다. 
우리가 이 최악의 케이스 행동을 제거하고 랜덤화를 피하고 
Theta(n) 최악의 러닝타임을 보장할 수 있나요?
여러분은 할 수 있지만 그것은 다소 사소하지 않은 알고리즘입니다. 
그리고 우리가 지금까지 보았던 가장 정교한 것들 중 하나입니다. 
그것은 우리가 보게 될 가장 정교한 알고리즘이지는 않을 것이지만,  
여기서는 그렇습니다.

Korean: 
최악의 케이스 선형 시간 오더 통계입니다. 
그리고 이것은 Blum, Floyd, Pratt, Rivest, Tarjan와 같은 
매우 유명한 사람들에 의한 알고리즘입니다. 
저는 B, R, T를 만났었습니다.
오 아닙니다, 저는 Pratt를 만난 적이 있어요. 저는 모든 저자들과 가깝습니다. 
이것은 다소 오래된 결과이지만, 
당시에는 그것이 주요한 돌파구였고 여전히 놀라운 알고리즘입니다. 
Ron Rivest는 여기 교수입니다. 
여러분은 RSA에서 R로부터 그를 보아야 합니다. 
제가 박사 학위를 딸 때, 

English: 
Worst-case linear time order
statistics.
And this is an algorithm by
several, all very famous people,
Blum, Floyd,
Pratt, Rivest and Tarjan.
I think I've only met the B and
the R and the T.
Oh, no, I've met Pratt as well.
I'm getting close to all the
authors.
This is a somewhat old result,
but at the time it was a major
breakthrough and still is an
amazing algorithm.
Ron Rivest is a professor here.
You should know him from the R
in RSA.
When I took my PhD
comprehensives some time ago,

English: 
on the cover sheet was a joke
question.
It asked of the authors of the
worst-case linear time order
statistics algorithm,
which of them is the most rich?
Sadly it was not a graded part
of the comprehensive exam,
but it was an amusing question.
I won't answer it here because
we're on tape,
[LAUGHTER] but think about it.
I may not be obvious.
Several of them are rich.
It's just the question of who
is the most rich.
Anyway, before they were rich
they came up with this
algorithm.
They've come up with many
algorithms since,
even after getting rich,
believe it or not.
What we want is a good pivot,
guaranteed good pivot.
Random pivot is going to be
really good.
And so the simplest algorithm
is just pick a random pivot.
It's going to be good with high
probability.
We want to force a good pivot
deterministically.
And the new idea here is we're

Korean: 
겉장에 있는 것은 우스개의 질문이었습니다. 
최악의 케이스 선형 시간 오더 통계 알고리즘의 
저자 중에서 누가 가장 부유하죠? 
슬프게도 그것은 성적이 매겨지지는 않을 것이지만 
재미있는 질문입니다. 지금 녹화 중이기 때문에 
저는 여기서 대답하지 않을 것입니다. 그러나 그것에 대해 생각해 보세요. 
저는 분명하진 않습니다. 그들 중 몇 명은 부유합니다. 
그것은 누가 가장 부유한지에 대한 질문이었습니다. 
어쨌든, 그들이 부유해지기 전에 그들은 이 알고리즘을 고안했습니다.
그들은 부유해진 후에도 많은 
알고리즘을 고안해 왔습니다, 
믿거나 말거나요. 우리가 원하는 것은 좋은 중심점, 보장된 좋은 중심점입니다. 
랜덤 중심점은 정말 좋을 것입니다. 
그리고 가장 간단한 알고리즘은 랜덤 중심점을 고르는 것입니다. 
그것은 높은 가능성으로 좋을 것입니다. 
우리는 결정론적으로 좋은 중심점을 강요하고 싶습니다. 
그리고 여기서 새로운 생각은 우리가 그것을 

Korean: 
재귀적으로 생성할 것이라는 것입니다.
우리가 재귀 말고 무엇을 할 수 있죠? 
우리가 재귀 말고 무엇을 할 수 있죠? 자, 여러분은 재귀로부터 
우리가 절반 사이즈의 문제에서 두 재귀 호출을 하고 선형의 추가적인 일을 한다면 
그것이 합병 정렬 재귀, 
T(n)=2[T(n/2)+θ(n)] 라는 것을 알아야 합니다. 
여러분은 자면서도 외워야 합니다. 그것은 n lg n 입니다. 
그래서 우리는 절반 사이즈의 두 문제에서 재귀할 수 없습니다. 
우리는 더 잘 해야 합니다. 이 재귀는 n 보다 엄격히 
작은 것에서 더해야 합니다. 
그것은 이 알고리즘의 마법입니다. 
그래서 이것은 랜덤 선택 대신 선택이라고 불립니다. 
그리고 그것은 배열에 의존합니다, 그러나 
저는 우리가 선택하고 싶은 i번째 인자와 우리가 선택할 배열의 크기에 집중할 것입니다. 
그리고 저는 랜덤 선택 보다 약간 더 정식으로 
이 알고리즘을 쓸 것입니다 왜냐하면 

English: 
going to generate it
recursively.
What else could we do but
recurse?
Well, you should know from your
recurrences that if we did two
recursive calls on problems of
half the size and we have a
linear extra work that's the
mergesort recurrence,
T(n)=2[T(n/2)+Theta(n)].
You should recite in your
sleep.
That's n lg n.
So we cannot recurse on two
problems of half the size.
We've got to do better.
Somehow these recursions have
to add up to strictly less than
n.
That's the magic of this
algorithm.
So this will just be called
select instead of rand-select.
And it really depends on an
array, but I will focus on the
i-th element that we want to
select and the size of the array
that we want to select in.
And I am going to write this
algorithm slightly less formally
than randomize-select because

Korean: 
그것은 더 높은 수준의 알고리즘이기 때문입니다.
그리고 여기서 알고리즘의 그림을 그려보겠습니다. 
첫 번째 단계는 가장 이상하고 그것은 핵심 생각들 중 하나입니다. 
여러분은 여러분의 인자를 가집니다, 
그리고 그것들은 특정한 순서에 있지 않고, 그것을 선에서 
그리는 대신에, 5 곱하기 n 나누기 5의 격자에서 그릴 것입니다. 
왜 안되나요? 
불행히도 이것은 그리는데 시간이 걸립니다, 

English: 
it's a bit higher level of an
algorithm.
And let me draw over here the
picture of the algorithm.
The first step is sort of the
weirdest and it's one of the key
ideas.
You take your elements,
and they are in no particular
order, so instead of drawing
them on a line,
I am going to draw them in a 5
by n over 5 grid.
Why not?
This, unfortunately,
take a little while to draw,

Korean: 
그러나 그것은 여러분이 해도 똑같이 시간이 오래 걸리기 때문에 제 시간을 쓰겠습니다. 
그것은 너비가 무엇인지 정말 중요하지 않습니다,
그러나 그것은 n 나누기 5의 너비여야 합니다 그러니 그에 맞춰서 그리세요. 
n 나누기 5의 너비지만, 
높이는 정확히 5여야 합니다. 
저는 그것이 옳다고 생각합니다. 저는 그것을 높이 계산할 수 있습니다. 
여기서 5입니다. 
그리고 우리의 수는 5로 나누어지지 않을 것입니다, 
아마 그것은 이상한 방법에서 끝날 것입니다.
그러나 제가 바라는 것은 이 덩어리들이 n 나누기 5의 floor여야 합니다. 
그리고 우리는, 많아 봐야 남은 
네 인자들을 가질 것입니다.
그래서 저는 그것들을 무시할 것입니다. 그것들은 정말 중요하지 않습니다. 
그것은 단지 추가적인 정수입니다. 여기서 제 배열입니다. 
저는 그것을 재미있는 방법으로 써 보았습니다. 
그리고 저는 이 수직의 그룹을 호출할 것입니다. 
저는 그것들을 순환할 것입니다, 그리고 저는 제 노트에서 했었습니다, 
그러나 그것들은 여러분이 순환을 시작하지 않으면 정말 까다롭습니다. 
이 다이어그램은 꽉 차게 될 것입니다. 
마지막에서 그것은 거의 이해할 수 없을 것입니다.

English: 
but it will take you equally
long so I will take my time.
It doesn't really matter what
the width is,
but it should be width n over 5
so make sure you draw your
figure accordingly.
Width n over 5,
but the height should be
exactly 5.
I think I got it right.
I can count that high.
Here is 5.
And this should be,
well, you know,
our number may not be divisible
by 5, so maybe it ends off in
sort of an odd way.
But what I would like is that
these chunks should be floor of
n over 5.
And then we will have,
at most, four elements left
over.
So I am going to ignore those.
They don't really matter.
It's just an additive constant.
Here is my array.
I just happened to write it in
this funny way.
And I will call these vertical
things groups.
I would circle them,
and I did that in my notes,
but things get really messy if
you start circling.
This diagram is going to get
really full, just to warn you.
By the end it will be almost
unintelligible,

Korean: 
여러분이 정말 지루하다고 느낀다면, 
여러분은 이것을 몇 번 그릴 수 있습니다. 
그리고 여러분은 그것이 커지는 방법을 그려야 합니다. 
그래서 5개의 수직 그룹들이 있습니다. 
다음 단계 입니다. 
두 번째 단계는 재귀하는 것입니다. 이것은 더 
평범하지 않은 것입니다. 
웁스, 미안해요. 저는 정말 1과 2 사이의 선을 가졌어야 했어요 
그래서 저는 이것을 아래로 하고 여기서 삽입해야 합니다. 
또한, 1 단계에서 저는 각 그룹의 
중앙값을 찾고 싶습니다.
제가 하길 원하는 것은 이 수를 상상하는 것입니다, 
각 그룹에서 5개 인자의 각각은 재배열 되고 

English: 
but there it is.
If you are really feeling
bored, you can draw this a few
times.
And you should draw how it
grows.
So there are the groups,
vertical groups of five.
Next step.
The second step is to recurse.
This is where things are a bit
unusual, well,
even more unusual.
Oops, sorry.
I really should have had a line
between one and two so I am
going to have to move this down
and insert it here.
I also, in step one,
want to find the median of each
group.
What I would like to do is just
imagine this figure,
each of the five elements in
each group gets reorganized so

English: 
that the middle one is the
median.
So I am going to call these the
medians of each group.
I have five elements so the
median is right in the middle.
There are two elements less
than the median,
two elements greater than the
median.
Again, we're assuming all
elements are distinct.
So there they are.
I compute them.
How long does that take me?
N over five groups,
each with five elements,
compute the median of each one?
Sorry?
Yeah, 2 times n over 5.
It's theta n,
that's all I need to know.
I mean, you're counting
comparisons, which is good.
It's definitely Theta(n).
The point is within each group,
I only have to do a constant
number of comparisons because
it's a constant number of
elements.
It doesn't matter.
You could use randomize select
for all I care.
No matter what you do,
it can only take a constant
number of comparisons.

Korean: 
중간에 있는 것이 중앙값입니다. 
그래서 저는 각 그룹의 중앙값들을 호출할 것입니다. 
저는 5개의 인자들을 가지고 있고 중앙값은 정확히 가운데 있습니다. 
두 인자는 중앙값 보다 작고, 
두 인자는 중앙값 보다 큽니다.
다시, 우리는 모든 인자들이 구별 된다는 것을 가정하고 있습니다. 
저는 그것들을 계산합니다. 
그것이 얼마나 오래 걸리나요? 5개의 인자를 가진 그룹에서 
각각의 중앙값을 계산하는데 얼마나 걸리나요?
뭐라구요? 네, 2 곱하기 n 나누기 5입니다. 
그것은 θ(n)입니다, 그것은 제가 알아야 하는 모든 것입니다. 
여러분은 비교를 셀 수 있습니다. 
그것은 정확히 θ(n)입니다. 
점은 각 그룹 내에 있고, 저는 정수의 비교를 해야 합니다 
왜냐하면 그것은 정수 개의 인자이기 때문입니다. 
그것은 중요하지 않습니다. 여러분은 제가 신경 쓰는 모든 것을 위해 
랜덤 선택을 사용할 수 있습니다. 
여러분이 무엇을 하든 그것은 정수의 비교가 걸립니다.

Korean: 
여러분이 한 번 더 비교를 하지 않는 한요. 
그래서 이것은 쉽습니다. 여러분은 5개의 수를 정렬하고 
세 번째 것을 보면 됩니다, 그것은 중요하지 않아요 
왜냐하면 5개만 있으니까요. 그것은 훌륭한 생각입니다. 
이미 우리는 중간에서 모호하게 정렬된 인자들을 가지고 있습니다. 
그리고 우리는 선형의 작업을 했습니다. 
그래서 지금까지 잘 해왔습니다. 
이제 우리는 두 번째 단계를 할 것입니다, 
그것은 전에 쓰기 시작했었습니다.

English: 
As long as you don't make a
comparison more than once.
So this is easy.
You could sort the five numbers
and then look at the third one,
it doesn't matter because there
are only five of them.
That's one nifty idea.
Already we have some elements
that are sort of vaguely in the
middle but just of the group.
And we've only done linear
work.
So doing well so far.
Now we get to the second step,
which I started to write
before, where we recurse.

English: 
So the next idea is,
well, we have these floor over
n over 5 medians.
I am going to compute the
median of those medians.
I am imagining that I
rearranged these.
And, unfortunately,
it's an even number,
there are six of them,
but I will rearrange so that
this guy, I have drawn in a
second box, is the median of
these elements so that these two
elements are strictly less than
this guy, these three elements
are strictly greater than this
guy.
Now, that doesn't directly tell
me anything, it would seem,
about any of the elements out
here.
We will come back to that.
In fact, it does tell us about
some of the elements.
But right now this element is
just the median of these guys.
Each of these guys is a median
of five elements.
That's all we know.
If we do that recursively,
this is going to take T of n
over 5 time.
So far so good.
We can afford a recursion on a
problem of size n over 5 and
linear work.
We know that works out to

Korean: 
그래서 다음 생각은, 우리가 이 floor 나누기 n 나누기 5 중앙값을 가진다는 것입니다. 
저는 이 중앙값들의 중앙값을 계산할 것입니다.
그리고 저는 이것들을 재배열했다고 상상합니다. 
그리고 불행히도, 
그것은 짝수입니다, 6개입니다, 
그러나 저는 그것을 재배열할 것입니다, 저는 두 번째 박스에서 그렸습니다, 
이것은 이 인자들의 중앙값입니다 그래서 
이 두 인자들은 이것보다 엄격히 작습니다,  
이 세 인자들은 이것보다 엄격히 큽니다.
이제, 그것은 저에게 직접적으로 
아무 것도 말하지 않습니다. 
우리는 그것으로 돌아올 것입니다. 사실, 그것은 우리에게 어떤 인자들에 대해 말해줍니다. 
그러나 지금은 이 인자들이 이것들의 중앙값입니다. 
이것들 각각은 5 인자들의 중앙값입니다. 
그것은 우리가 아는 모든 것입니다.
우리가 그것을 재귀적으로 한다면, 이것은 n의 T 나누기 5 시간이 
걸릴 겁니다. 지금까지는 좋습니다. 
우리는 사이즈 n 나누기 5의 문제에서 재귀와 선형 작업을 할 여유가 있습니다. 
우리는 그것이 선형 시간이 걸린다는 것을 압니다.

English: 
linear time.
But there is more.
We're obviously not done yet.
The next step is x is our
partition element.
We partition there.
The rest of the algorithm is
just like randomized partition,
so we're going to define k to
be the rank of x.
And this can be done,
I mean it's n minus r plus 1 or
whatever, but I'm not going to
write out how to do that because
we're at a higher level here.
But it can be done.
And then we have the three-way
branching.
So if i happens to equal k
we're happy.
The pivot element is the
element we're looking for,
but more likely i is either
less than k or it is bigger than
k.
And then we make the
appropriate recursive call,

Korean: 
그러나 여기 조금 더 있습니다. 
우리는 아직 분명히 하지 않았습니다. 
다음 단계는 x가 우리의 분할 인자라는 것입니다. 
우리는 저기서 분할합니다. 알고리즘의 남은 것은 
랜덤 분할과 같은 것입니다, 그래서 우리는 k를 x의 순위로 정의할 것입니다. 
그리고 이것은 될 수 있습니다, 
저는 그것이 n 마이너스 r 더하기 1이라는 것을 의미하지만,  
저는 그것을 하는 방법을 쓰지 않을 것입니다 왜냐하면 우리는 여기서 더 높은 단계에 있기 때문입니다.
그러나 그것은 될 수도 있습니다. 그리고 우리는 세 방법을 갖습니다. 
그래서 i가 k와 같다면 우리는 행복합니다. 
중심점 인자는 우리가 찾는 인자입니다, 
그러나 i는 k 보다 
더 작거나 k 보다 더 큽니다. 
그리고 우리는 적절한 재귀 호출을 합니다, 

English: 
so here we recursively select
the i-th smallest element --
-- in the lower part of the
array.
Left of the partition element.
Otherwise, we recursively
select the i minus k-th smallest
element in the upper part of the
array.
I am writing this at a high
level because we've already seen
it.
All of this is the same as the
last couple steps of randomized
select.
That is the algorithm.
The real question is why does
it work?
Why is this linear time?
The first question is what's
the recurrence?
We cannot quite write it down
yet because we don't know how

Korean: 
여기서 우리는 재귀적으로 i번째 작은 인자를 선택합니다.
배열의 낮은 부분에서요. 
분할 인자의 남은 것입니다. 그렇지 않으면, 우리는 재귀적으로 
배열의 윗부분에서 i 마이너스 k 번째 인자를 선택합니다. 
저는 이것을 높은 단계에서 쓸 것입니다 
왜냐하면 우리는 이미 그것을 보았기 때문입니다. 
이 모든 것은 랜덤 선택의 마지막 단계와 같습니다. 
이것은 알고리즘입니다. 질문은 왜 그것이 동작하는가? 입니다. 
왜 이 선형 시간이죠? 
첫 번째 질문은 왜 그것은 재귀입니까? 
우리는 아직 확실히 쓸 수 없습니다 

Korean: 
왜냐하면 우리는 이 재귀 하위 문제들이 얼마나 클 수 있는지 모르기 때문입니다.
우리는 전처럼, 낮은 부분 또는 높은 부분에서 재귀할 것입니다. 
만약 우리가 운이 나쁘고 0에서 n-1로 나누면, 
이것은 이차의 시간 알고리즘이 될 것입니다. 
이 분할 인자는 매우 좋고 충분히 
좋다는 것이 보장됩니다. 
이것의 러닝 타임은 어떤 것의 T 곱하기 n일 것입니다, 
그리고 우리는 무엇인지 아직 모릅니다. 
그것은 얼마나 클 수 있나요? 
자, 저는 여러분에게 질문할 수 있습니다.
그러나 우리는 여기서 직접적이지 않기 때문에 여러분에게 말해줄 겁니다. 우리는 이미 n 나누기 5의 T의 재귀 호출을 가집니다. 
그것은 무슨 정수이든 더 좋을 것입니다, 
그래서 그것은 어떤 것 곱하기 n이 될 것이고 
정수가 4/5 보다 엄격히 작은 것은 더 좋을 것입니다. 
그것이 4/5와 같다면 여러분은 n lg n 러닝 타임을  
얻기 위해 충분한 문제를 쪼개야 합니다.
그것이 4/5 보다 엄격히 작다면 여러분은 정수 인자들에 의해 줄일 수 있습니다.
여러분이 모든 재귀 하위문제를 더하면, 

English: 
big these recursive subproblems
could be.
We're going to either recurse
in the lower part or the upper
part, that's just like before.
If we're unlucky and we have a
split of like zero to n minus
one, this is going to be a
quadratic time algorithm.
The claim is that this
partition element is guaranteed
to be pretty good and good
enough.
The running time of this thing
will be T of something times n,
and we don't know what the
something is yet.
How big could it be?
Well, I could ask you.
But we're sort of indirect here
so I will tell you.
We have already a recursive
call of T of n over 5.
It better be that whatever
constant, so it's going to be
something times n,
it better be that that constant
is strictly less than 4/5.
If it's equal to 4/5 then
you're not splitting up the
problem enough to get an n lg n
running time.
If it's strictly less than 4/5
then you're reducing the problem
by at least a constant factor.
In the sense if you add up all

English: 
the recursive subproblems,
n over 5 and something times n,
you get something that is a
constant strictly less than one
times n.
That forces the work to be
geometric.
If it's geometric you're going
to get linear time.
So this is intuition but it's
the right intuition.
Whenever you're aiming for
linear time keep that in mind.
If you're doing a
divide-and-conquer,
you've got to get the total
subproblem size to be some
constant less than one times n.
That will work.
OK, so we've got to work out
this constant here.
And we're going to use this
figure, which so far looks
surprisingly uncluttered.
Now we will make it cluttered.
What I would like to do is draw
an arrow between two vertices,
two points, elements,

Korean: 
여러분은 1 곱하기 n 보다 엄격히 
작은 정수를 얻습니다. 
그것은 작업이 기하학적이도록 합니다. 
그것이 기하학적이면 여러분은 선형 시간을 얻습니다. 
이것은 직관이지만 좋은 직관입니다. 
여러분이 선형 시간을 목표로 할 때면 언제든 그것을 마음에 새기세요. 
여러분이 분할 정복을 하면, 
여러분은 1 곱하기 n 보다 작은 하위 문제 사이즈를 얻습니다. 
그것은 동작할 것입니다.
네, 그래서 우리는 여기서 이 정수를 잘 진행해야 합니다. 
그리고 우리는 이 수를 이용할 것입니다, 
그것은 지금까지 놀랍게도 복잡하지 않습니다. 
이제 우리는 그것을 복잡하게 만들 것입니다. 
제가 하려고 하는 것은 두 정점 사이에 화살표를 그리는 것입니다. 

Korean: 
그것들을 a와 b라고 부릅시다. 
그리고 저는 화살을 맞추길 원합니다 그래서 그것은 더 큰 값을 가리킵니다, 
이것은 a가 b 보다 작다는 것을 의미합니다.
이것은 다이어그램을 위한 표기법입니다. 
그리고 저는 제가 아는 것을 쓸 것입니다. 
이 인자는 이 5개 인자들의 중앙값입니다.
저는 그것이 그려졌다고 가정할 것이고 이 인자들은 
중앙값 보다 큽니다, 
이 인자들은 중앙값 보다 작습니다. 
그러므로, 저는 이와 같은 화살을 가집니다. 
여기서 저는 색 분필이 있었으면 좋겠네요.
이것은 이것들이 이 5개 인자들의 중간에 있다고 말하고 있습니다. 
저는 모든 단일 행에서 그것을 알고 있습니다. 
여기는 다이어그램이 까다로워지는 곳입니다. 

English: 
whatever you want to call them.
Let's call them a and b.
And I want to orient the arrow
so it points to a larger value,
so this means that a is less
than b.
This is notation just for the
diagram.
And so this element,
I am going to write down what I
know.
This element is the median of
these five elements.
I will suppose that it is drawn
so that these elements are
larger than the median,
these elements are smaller than
the median.
Therefore, I have arrows like
this.
Here is where I wish I had some
colored chalk.
This is just stating this guy
is in the middle of those five
elements.
I know that in every single
column.
Here is where the diagram
starts to get messy.

Korean: 
저는 아직 하지 않았습니다. 이제, 우리는 이 인자가  
중앙값들의 중앙값이라는 것을 압니다.
모든 인자들 중에서, 이것은 중간에 있습니다. 
그리고 저는 그것을 그릴 것이고 이것들은 중앙값 보다 더 작은 것입니다, 
이것들은 중앙값 보다 더 큰 것입니다. 
알고리즘은 이것을 할 수 없습니다. 
그것은 이 모든 것이 작동하는 방법을 필수적으로 알지 않습니다. 
저는 그것이 할 수 있다고 생각하지만, 이것은 단지 분석 목적을 위한 것입니다.
우리는 이것이 그것 보다 크고 그것 보다 
크다는 것을 압니다. 
우리는 다른 인자들에 대해 직접적으로 알지 않습니다.
우리는 이것이 이것들 모두 보다 더 크고 이것이 이것들 보다 작다는 것을 압니다. 
이제 그것은 우리가 얻는 수만큼 까다롭습니다. 
이제, 좋은 것은 그것이 이행의 
t관계라는 것입니다. 
제가 이 그래프에서 직접적인 길을 그리면, 
저는 이 인자가 그 인자 보다 엄격히 작다는 것을 압니다 
왜냐하면 이것은 그것 보다 작고 그것 보다 작기 때문입니다. 
제가 직접적으로 행과 이 중간 열에서 알고 있다고 하더라도, 

English: 
I am not done yet.
Now, we also know that this
element is the median of the
medians.
Of all the squared elements,
this guy is the middle.
And I will draw it so that
these are the ones smaller than
the median, these are the ones
larger than the median.
I mean the algorithm cannot do
this.
It doesn't necessarily know how
all this works.
I guess it could,
but this is just for analysis
purposes.
We know this guy is bigger than
that one and bigger than that
one.
We don't directly know about
the other elements.
We just know that that one is
bigger than both of those and
this guy is smaller than these.
Now, that is as messy as the
figure will get.
Now, the nice thing about less
than is that it's a transitive
relation.
If I have a directed path in
this graph, I know that this
element is strictly less than
that element because this is
less than that one and this is
less than that one.
Even though directly I only
know within a column and within

Korean: 
저는 실제로 이 인자들을 알고 있습니다.
그런데 이것은 x 입니다. 
이 인자는 모든 인자들 보다 큽니다 
왜냐하면 그것은 이것 보다 크고 이것들 각각은 이 화살에 의해 
그것들 모두 보다 크기 때문입니다. 
저는 또한 여기 이 직사각형에서 이 인자들을 모두 알고 있습니다, 
그리고 여러분은 이것을 할 필요가 없지만 저는 더 복잡한 배경을 만들 것입니다. 
이 직사각형에서 이 모든 인자들은 
이것보다 크거나 같고 이 직사각형에서 모든 인자들은 
x 보다 작거나 같습니다. 
이제, 얼마나 많이 있죠? 자, 이것은 대략 절반입니다  
그리고 이것은 이 행의 3/5입니다.
그래서 우리가 얻는 것은 다음과 같습니다.

English: 
this middle row,
I actually know that this
element --
This is x, by the way.
This element is larger than all
of these elements because it's
larger than this one and this
one and each of these is larger
than all of those by these
arrows.
I also know that all of these
elements in this rectangle here,
and you don't have to do this
but I will make the background
even more cluttered.
All of these elements in this
rectangle are greater than or
equal to this one and all of the
elements in this rectangle are
less than or equal to x.
Now, how many are there?
Well, this is roughly halfway
along the set of groups and this
is 3/5 of these columns.
So what we get is that there
are at least --

English: 
We have n over 5 groups and we
have half of the groups that
we're looking at here roughly,
so let's call that floor of n
over 2, and then within each
group we have three elements.
So we have at least 3 times
floor of floor of n over 5 over
2 n floor elements that are less
than or equal to x.
And we have the same that are
greater than or equal to x.
Let me simplify this a little
bit more.
I can also give you some more
justification,
and we drew the picture,
but just for why this is true.
We have at least n over 5 over
2 group medians that are less

Korean: 
우리는 n 나누기 5 그룹들을 갖습니다 
그리고 우리는 여기서 대략 우리가 보고 있는 그룹의 절반을 가집니다, 
그래서 그것들을 n 나누기 2의 floor라고 부릅시다, 그리고 각 그룹 내에서 우리는 세 인자들을 갖습니다. 
그래서 우리는 적어도 다음 값을 가지는데 
그것은 x 보다 작거나 같습니다. 
그리고 우리는 x 보다 크거나 같은 것을 가집니다. 
이것을 약간 더 단순화해 보겠습니다. 
저는 여러분에게 정의를 줄 수 있습니다, 
그리고 우리는 그림을 그렸습니다, 그러나 이것은 옳습니다. 
우리는 적어도 x 보다 작거나 같은 n 나누기 5 나누기 2 그룹을 갖습니다.

English: 
than or equal to x.
This is the argument we use.
We have half of the group
medians are less than or equal
to x because x is the median of
the group median,
so that is no big surprise.
This is almost an equality but
we're making floors so it's
greater than or equal to.
And then, for each group
median, we know that there are
three elements there that are
less than or equal to that group
median.
So, by transitivity,
they're also less than or equal
to x.
We get this number times three.
This is actually just floor of
n over 10.
I was being unnecessarily
complicated there,
but that is where it came from.
What we know is that this thing
is now at least 3 times n over
10, which is roughly 3/10 of
elements are in one side.
In fact, at least 3/10 of the
elements are in each side.
Therefore, each side has at
most 7/10 elements roughly.

Korean: 
이것은 우리가 사용하는 인자입니다. 
우리는 x 보다 작거나 같은 중앙값 그룹의 절반이 있습니다 
왜냐하면 x는 그룹 중앙값의 중앙값이기 때문입니다, 
그래서 그것은 크게 놀라운 것이 아닙니다. 이것은 거의 동일합니다 
그러나 우리는 floor를 만들 것이고 그것은 크거나 같을 것입니다. 
그리고, 각 중앙값에 대해, 우리는 세 인자들을 알고 
그것들은 그룹 중앙값 보다 작거나 같습니다. 
이행성에 의해, 
그것들은 x 보다 작거나 같습니다. 
우리는 이 수 곱하기 3을 얻습니다.
이것은 사실 n 나누기 10의 floor 입니다. 저는 불필요하게 복잡해졌습니다, 
그러나 그것은 그것이 온 곳입니다. 
우리가 아는 것은 이것이 이제 적어도 3 곱하기 n 나누기 10이라는 것이고, 
그것은 대략 인자들의 3/10 입니다. 
사실, 적어도 인자들의 3/10은 각 사이드에 있습니다. 
그러므로 각 사이드는 많아 봐야 대략 7/10 인자들을 가집니다. 

English: 
So the number here will be
7/10.
And, if I'm lucky,
7/10 plus 1/5 is strictly less
than one.
I believe it is,
but I have trouble working with
tenths.
I can only handle powers of
two.
What we're going to use is a
minor simplification,
which just barely still works,
is a little bit easier to think
about.
It's mainly to get rid of this
floor because the floor is
annoying.
And we don't really have a
sloppiness lemma that applies
here.
It turns out if n is
sufficiently large,
3 times floor of n over 10 is
greater than or equal to 1/4.
Quarters I can handle.
The claim is that each group
has size at least 1/4,
therefore each group has size
at most 3/4 because there's a
quarter on the side.
This will be 3/4.
And I can definitely tell that
1/5 is less than 1/4.
This is going to add up to
something strictly less than one

Korean: 
그래서 여기 수는 7/10이 될 것입니다. 
그리고, 제가 운이 좋다면, 7/10 더하기 1/5는 엄격하게 작을 것입니다. 
저는 그렇다고 생각하지만, 
10번째에서 잘 못 동작합니다. 
저는 2제곱만 다룰 수 있습니다
우리가 사용할 것은 작은 단순화입니다, 그것은 거의 여전히 작동합니다, 
그것은 생각하기 약간 더 쉽습니다. 
그것은 주로 이 floor를 제거합니다 
왜냐하면 floor는 성가신 것이기 때문입니다. 
그리고 우리는 여기서 적용하는 엉성한 부명제를 정말 갖지 않습니다.
N이 충분히 크면, 
3 곱하기 n의 floor 나누기 10은 1/4 보다 크거나 같습니다. 
1/4은 제가 다룰 수 있습니다. 
각 그룹은 적으로 1/4의 사이즈를 가집니다, 그러므로 각 그룹은 많아 봐야 3/4입니다 
왜냐하면 사이드에 1/4이 있기 때문입니다. 
이것은 3/4일 것입니다. 
그리고 저는 1/5가 1/4 보다 작다고 분명히 말할 수 있습니다. 
이것은 1 보다 엄격히 작은 것을 더할 것이고 그것은 작동할 겁니다.

Korean: 
시간이 얼마나 남았죠? 
좋아요. 이 점에서,  
분석의 나머지는 쉽습니다.
여러분은 어떻게 이 알고리즘을 떠올릴 수 있나요, 
이것은 분할 인자를 찾기 위한 정말 좋은 선택입니다, 
선형 시간까지 더하는 재귀들에 
드물게 충분히 좋습니다.
자, 그것은 많은 유명한 사람들이 그것을 한 이유입니다. 
특히 퀴즈에서, 일반적으로 이 수업에서도, 
여러분은 이 알고리즘을 떠올려야 하지 않습니다 
왜냐하면 여러분은 이 알고리즘을 중앙값을 찾기 위해서만 사용할 수 있기 때문입니다. 
그리고 중앙값은 매우 좋은 분할 인자입니다. 
여러분이 이 알고리즘을 알기 때문에, 이제 우리는 1973 이후에 있습니다, 
여러분은 이것을 하는 방법을 알 필요가 없습니다. 
여러분은 이 알고리즘을 작동하는 방법을 알아야 하지만 
다른 알고리즘에서 이것을 할 필요는 없습니다 
왜냐하면 여러분은 이 알고리즘을 돌릴 수 있기 때문입니다, 여러분은 선형 시간에서 중앙값을 얻을 것입니다, 
그리고 여러분은 오른쪽과 왼쪽으로 분할할 수 있습니다.

English: 
and then it will work.
How is my time?
Good.
At this point,
the rest of the analysis is
easy.
How the heck you would come up
with this algorithm,
you realize that this is
clearly a really good choice for
finding a partition element,
just barely good enough that
both recursions add up to linear
time.
Well, that's why it took so
many famous people.
Especially in quizzes,
but I think in general this
class, you won't have to come up
with an algorithm this clever
because you can just use this
algorithm to find the median.
And the median is a really good
partition element.
Now that you know this
algorithm, now that we're beyond
1973, you don't need to know how
to do this.
I mean you should know how this
algorithm works,
but you don't need to do this
in another algorithm because you
can just say run this algorithm,
you will get the median in
linear time, and then you can
partition to the left and the

English: 
right.
And then the left and the right
will have exactly equal size.
Great.
This is a really powerful
subroutine.
You could use this all over the
place, and you will on Friday.
Have I analyzed the running
time pretty much?
The first step is linear.
The second step is T of n over
925
01:04:18,806 --> 00:00:05,000
The third step,
I didn't write it,
is linear.
And then the last step is just
a recursive call.
And now we know that this is
3/4.
I get this recurrence.
T of n is, I'll say at most,
T of n over 5 plus T of 3/4n.
You could have also used 7/10.
It would give the same answer,
but you would also need a floor

Korean: 
그리고 왼쪽과 오른쪽은 
정확히 같은 사이즈를 가질 겁니다. 좋아요. 
이것은 매우 강력한 서브 루틴입니다. 
여러분인 모든 곳에서 이것을 사용할 수 있습니다, 그리고 여러분은 금요일에 할 것입니다. 
제가 러닝 타임을 매우 많이 분석했나요? 
첫 번째 단계는 성형입니다. 두 번째 단계는 n의 T 나누기 5입니다. 
세 번째 단계는, 
쓰지 않았지만, 선형입니다. 
그리고 마지막 단계는 재귀 호출입니다. 
그리고 이제 우리는 이것이 3/4라는 것을 압니다.
저는 이 재귀를 얻습니다. n의 T 나누기 5 더하기 3/4n 의 T입니다. 
여러분은 또한 7/10을 사용할 수 있습니다. 
그것은 같은 답을 줄 것이지만, 여러분은 또한 floor가 필요합니다 

Korean: 
그래서 우리는 그것을 하지 않을 겁니다. 저는 이것이 선형이라고 주장합니다. 
제가 그것을 어떻게 증명할 수 있나요? 대입입니다. 
N의 T가 많아 봐야 다시 c 곱하기 n이라는 것은 충분할 겁니다. 
증명은 대입에 의한 것입니다.
다시, 우리는 이것이 더 작은 n에 대해 옳다는 것을 가정합니다. 
그리고 n에 대하여 그것을 증명하길 원합니다. n의 T가 많아 봐야 이것입니다.
n의 T 나누기 5입니다. 
그리고 도입에 의해, 5의 n이 n 보다 더 작기 때문에, 
우리는 이것이 많아 봐야 c라는 것을 합니다. 
제가 그것을 c 나누기 5 곱하기 n이라고 쓰겠습니다. 
물론이죠, 왜 안되나요. 그리고 우리는 여기서 3/4cn을 갖습니다. 
그리고 우리는 선형의 항을 갖습니다. 이제, 불행히도, 

English: 
so we won't do that.
I claim that this is linear.
How should I prove it?
Substitution.
Claim that T of n is at most
again c times n,
that will be enough.
Proof is by substitution.
Again, we assume this is true
for smaller n.
And want to prove it for n.
We have T of n is at most this
thing.
T of n over 5.
And by induction,
because n of 5 is smaller than
n, we know that this is at most
c.
Let me write it as c over 5
times n.
Sure, why not.
Then we have here 3/4cn.
And then we have a linear term.
Now, unfortunately,

English: 
I have to deal with things that
are not powers of two.
I will cheat and look at my
notes.
This is also known as 19/20
times c times n plus theta n.
And the point is just that this
is strictly less than one.
Because it's strictly less than
one, I can write this as one
times c of n minus some
constant, here it happens to be
1/20, as long as I have
something left over here,
1/20 times c times n.
Then I have this annoying theta
n term which I want to get rid
of because I want this to be
nonnegative.
But it is nonnegative,
as long as I set c to be
really, really large,
at least 20 times whatever
constant is here.
So this is at most c times n
for c sufficiently large.
And, oh, by the way,
if n is less than or equal to
50, which we used up here,
then T of n is a constant,
it doesn't really matter what
you do, and T of n is at most c

Korean: 
저는 제곱이 아닌 것을 다루어야 합니다. 
저는 제 노트를 살펴 보겠습니다. 
이것은 19/20 곱하기 c 곱하기 n 더하기 θ(n) 입니다.
그리고 핵심은 이것이 1 보다 엄격히 작다는 것입니다. 
왜냐하면 그것이 1 보다 엄격히 작기 때문에, 
저는 이것을 1 곱하기 n의 c 마이너스 어떤 정수로 쓸 수 있습니다, 
여기서 그것은 1/20입니다, 제가 여기서 나머지를 가지는 한, 1/20 곱하기 c 곱하기 n입니다. 
그리고 저는 제거하고 싶은 성가신 θ(n)항을 갖습니다 
왜냐하면 저는 이것이 음이 아니길 바랍니다.
그러나 그것이 음이 아니기 때문에, 
제가 c를 정말 정말 크게 두는 한, 
여기 20 곱하기 어떤 정수가 있습니다. 
그래서 이것은 충분히 큰 c에 대하여 많아 봐야 c 곱하기 n 입니다. 
그런데, n이 50 보다 작거나 같으면, n의 T는 정수입니다, 
여러분이 무엇을 하는지는 중요하지 않습니다. 
N의 T는 충분히 큰 c에 대하여 

Korean: 
많아 봐야 c 곱하기 n 입니다. 
그것은 이 주장을 증명합니다. 물론, 여기 정수는 매우 큽니다. 
그것은 정확히 정수와 러닝 타임이 무엇인지에 의존합니다, 그것은 여러분의 기계에 
의존하지만 실제로 이 알고리즘은 좋지 않습니다 왜냐하면 정수가 매우 크기 때문입니다. 
이 인자가 중간에서 애매하게 어딘가에 있다면,  
이 재귀가 n 보다 엄격이 작은 것까지 
더하고 그것이 기하학적이면, 
그것은 기하학적입니다
왜냐하면 문제는 적어도 매 시간 19/20의 인자에 의해 줄어들기 때문입니다.
그래서 사실 문제를 정말 작게 만드는데 시간이 걸립니다. 
여러분이 동전 뒤집기 같은 것을 할 수 없지 않으면, 
실제로 여러분은 이 알고리즘을 사용하지 않을 겁니다. 
랜덤 알고리즘은 정말 정말 빠르게 동작합니다. 
이론적으로 이것은 여러분의 꿈이고, 
여러분이 바라는 최상입니다 왜냐하면 그것은 선형의 시간이고 
여러분은 선형 시간이 필요하기 때문입니다. 
끝나기 전에, 하나의 예제를 
언급하겠습니다.

English: 
times n for c sufficiently
large.
That proves this claim.
Of course, the constant here is
pretty damn big.
It depends exactly what the
constants and the running times
are, which depends on your
machine, but practically this
algorithm is not so hot because
the constants are pretty big.
Even though this element is
guaranteed to be somewhere
vaguely in the middle,
and even though these
recursions add up to strictly
less than n and it's geometric,
it's geometric because the
problem is reducing by at least
a factor of 19/20 each time.
So it actually takes a while
for the problem to get really
small.
Practically you probably don't
want to use this algorithm
unless you cannot somehow flip
coins.
The randomized algorithm works
really, really fast.
Theoretically this is your
dream, the best you could hope
for because it's linear time and
you need linear time as
guaranteed linear time.
I will mention,
before we end,
an exercise.

Korean: 
우리가 왜 5의 그룹을 사용했나요? 왜 3의 그룹은 되지 않나요? 
여러분이 추측하는 바대로, 
답은 그것이 3의 그룹으로 동작하기 않기 때문입니다.
그러나 이유를 알아내는 것은 꽤 건설적입니다. 
여러분이 5의 그룹 대신 3의 그룹으로 이 수학을 해 보면, 
여러분은 여러분이 필요한 문제 감소를 얻지 
 못할 것이라는 것을 알게 될 것입니다.
5는 이 작업을 위해 가장 작은 수 입니다. 
그것은 7에서 작동할 것이지만, 이론적으로 정수 보다 
나은 것이 없습니다. 질문 있나요? 
좋아요. 금요일에 봅시다. 
일요일에는 과제 연구실이 있습니다. 문제 풀이는 월요일까지이고, 
2주 안에 퀴즈가 있을 겁니다.

English: 
Why did we use groups of five?
Why not groups of three?
As you might guess,
the answer is because it
doesn't work with groups of
three.
But it's quite constructive to
find out why.
If you work through this math
with groups of three instead of
groups of five,
you will find that you don't
quite get the problem reduction
that you need.
Five is the smallest number for
which this works.
It would work with seven,
but theoretically not any
better than a constant factor.
Any questions?
All right.
Then recitation Friday.
Homework lab Sunday.
Problem set due Monday.
Quiz one in two weeks.
