
English: 
-- valuable experience.
OK, today we're going to start
talking about a particular class
of algorithms called greedy
algorithms.
But we're going to do it in the
context of graphs.
So, I want to review a little
bit about graphs,
which mostly you can find in
the textbook in appendix B.
And so, if you haven't reviewed
in appendix B recently,
please sit down and review
appendix B.
It will pay off especially
during our take-home quiz.
So, just reminder,

Korean: 

귀중한 경험입니다. 오늘 우리는 
탐욕 알고리즘에 대해 이야기할 것입니다. 
그러나 우리는 그것을 그래프의 맥락에서 할 것입니다. 
저는 그래프에 대해 복습하고 싶습니다, 
그것은 여러분 교재의 
부록 B에서 볼 수 있는 것입니다. 
여러분이 최근에 부록 B를 보지 못했으면, 앉아서 다시 보세요. 
그것은 특히 퀴즈에 
도움이 될 것입니다. 

Korean: 
Digraph가 뭐죠? 무엇의 약칭인가요? 
Directed graph(방향 그래프)입니다. 
G = (V,E) 입니다.
저는 항상 
여러분에게 vertices(정점)에 대해 말하도록 합니다. 
단수는 vertices가 아니라 
vertex입니다. 
복수는 vertices입니다. 단수는 vertex입니다. 
그것은 이상한 영어 단어 중 하나입니다. 
그것은 아마 프랑스어 등에서 왔을 겁니다. 
저는 모릅니다. 
우리는 집합 E를 가지고, 그것은 V와 V의 교집합의 부분 집합입니다. 
그것이 방향 그래프입니다. 

English: 
a digraph, what's a digraph?
What's that short for?
Directed graph,
OK?
Directed graph,
G equals (V,E),
OK, has a set,
V, of vertices.
And, I always get people
telling me that I have one
vertice.
The singular is not vertice;
it is vertex,
OK?
The plural is vertices.
The singular is vertex.
It's one of those weird English
words.
It's probably originally like
French or something,
right?
I don't know.
OK, anyway, and we have a set,
E, which is a subset of V cross
V of edges.
So that's a digraph.

English: 
And undirected graph,
E contains unordered pairs.
OK, and, sorry?
It's Latin, OK,
so it's probably pretty old,
then, in English.
I guess the vertex would be a
little bit of a giveaway that
maybe it wasn't French.
It started to be used in 1570,
OK.
OK, good, OK,
so the number of edges is,
whether it's directed or

Korean: 
방향이 없는 그래프 E는 정렬 되지 않은 쌍을 포함합니다.
네? 그것은 라틴어 입니다. 
아마 매우 오래되었을 거에요. 
아마 프랑스어는 아닐겁니다. 
그것은 1570년에 사용되기 시작했습니다. 
좋아요,
그래서 엣지의 수(|E|)는, 그것이 방향이 있든 없든, 

English: 
undirected, is O of what?
V^2, good.
OK, and one of the conventions
that will have when we're
dealing, once we get into
graphs, we deal a lot with sets.
We generally drop the vertical
bar notation within O's just
because it's applied.
It just makes it messier.
So, once again,
another abuse of notation.
It really should be order the
size of V^2, but it just messes
up, I mean, it's just more stuff
to write down.
And, you're multiplying these
things, and all those vertical
bars.
Since they don't even have a
sense to the vertical bar,
it gets messy.
So, we just drop the vertical
bars there when it's in
asymptotic notation.
So, E is order V^2 when it's a
set of pairs,
because if it's a set of pairs,
it's at most n choose two,
which is where it's at most n^2
over 2, here it could be,
at most, sorry,

Korean: 
무엇의 O입니까? V^2, 좋아요. 
우리가 그래프를 다룰 때, 
우리는 많은 집합을 다룹니다. 
우리는 일반적으로 O 안에 '| |' 개념을 넣습니다. 
그것은 적용되기 때문입니다. 그것은 더 엉망으로 만듭니다. 
다시 한번, 개념의 또 다른 남용이 있습니다.
그것은 O(V^2)의 크기이어야 하지만, 그것은 엉망입니다, 
그것은 써야 합니다. 
여러분은 이것들을 곱합니다.
그것들이 '| |'의 개념을 가지지 않기 때문에, 
엉망입니다. 
우리는 그것이 점근적인 개념에 있을 때 '| |'를 둡니다.
그것이 쌍일 때, E는 O(V^2) 입니다. 
그것이 쌍의 집합이면, 
그것은 최대 n입니다. 
여기서 그것은 최대 V^2 

English: 
V^2 over 2, here it's at most
V^2.
And then, another property that
sometimes comes up is if the G
is connected,
we have another bound,
implies that the size of E is
at least the size of V minus
one.
OK, so if it's connected,
meaning, what does it mean to
have a graph that's connected?
Yeah, there's a path from any
vertex to any other vertex in
the graph.
That's what it means to be
connected.
So if that's the case,
that a number of edges is at
least the number of vertices
minus one, OK?
And so, what that says,

Korean: 
나누기 2 입니다. 
그리고, 다른 속성은, G가 연결되면, 
우리는 다른 바운드를 가지고, 
E의 크기는 V의 크기 – 1 입니다. 
그것이 연결되면, 
연결된 그래프는 무엇을 의미합니까?
그래프에서 한 정점에서 다른 정점으로의 경로가 있습니다. 
그것을 연결된 것이라 합니다. 
그것이 케이스이면, 
엣지의 수는 적어도 정점 – 1 입니다.
저는 여러분에게 

English: 
so one of the things we'll get
into, a fact that I just wanted
to remind you,
is that in that case,
if I look at log E,
OK, log of the number of edges,
that is O of log V.
And by this,
is omega of log V.
So, it's equal to theta of log
V.
OK, so basically the number of,
in the case of a connected
graph, the number of edges,
and the number of vertices are
polynomially related.
So, their logs are comparable.
OK, so that's helpful just to
know because sometimes I just
get questions later on where
people will say,
oh, you showed it was log E but
you didn't show it was log V.
And I could point out that it's
the same thing.
OK, so there's various ways of
representing graphs in
computers, and I'm just going to

Korean: 
상기시키고 싶습니다, 
그 케이스에서,
제가 lg|E|를 보면, 엣지 수의 로그는 로그 V의 O입니다.
이것에 의해서, lg V의 오메가입니다. 
그러니까 그것은 θ(lg V)의 세타와 같습니다
기본적으로 연결된 그래프에서, 
엣지의 수와 정점의 수는 
다항적으로 연관이 있습니다. 
로그는 비교할 수 있습니다. 그것은 도움이 됩니다 
왜냐하면 저는 여러분에게 질문을 할 것이기 때문입니다, 
여러분은 그것이 lg|E|라는 것을 보여주었지만 여러분은 그것이 lg V인 것을 보여주지 않았습니다. 
저는 그것이 같은 것임을 지적할 수 있습니다. 
컴퓨터에서 그래프를 나타낼 수 있는 다양한 방법들이 있습니다, 
그리고 저는 

Korean: 
중요한 것들을 다룰 것입니다.
사실 더 있습니다. 우리는 더 볼 것입니다. 
가장 간단한 것은 인접 행렬입니다. 
그래프 G의 인접 행렬은 (V,E)와 같습니다.
간단히 하기 위해, 저는 V를 1에서 n까지 정수의 집합으로 둘 것입니다. 
그것은 n 곱하기 n 행렬 A입니다. 

English: 
cover a couple of the important
ones.
There's actually more.
We'll see some more.
So, the simplest one is what's
called an adjacency matrix.
An adjacency matrix of the
graph, G, equals (V,E),
where, for simplicity,
I'll let V be the set of
integers from one up to n,
OK, is the n by n matrix A

Korean: 
A[i,j]에 엣지가 있으면 1이고, 
그렇지 않으면 0입니다. 
그것이 행렬에 있으면 
ij 엔트리는 1입니다. 
어떤 면에서, 
i에서 j까지의 엣지가 있습니까?
술부는 0 또는 1의 Boolean 공식입니다, 
이 케이스에서, 
i에서 j까지가 엣지가 있으면 1이고 그렇지 않으면 0입니다. 
때때로 여러분은 
엣지 중심 그래프를 갖습니다, 
그리고 때때로 사람들이 하는 것은 이것을 엣지의 무게로 교체하는 것입니다. 

English: 
given by the ij-th at the entry
is simply one if the edge,
ij, is in the edge set and zero
if ij is not in the edge set.
OK, so it's simply the matrix
where you say,
the ij entry is one if it's in
the matrix.
So, this is,
in some sense,
giving you the predicate for,
is there an edge from i to j?
OK, remember,
predicate is Boolean formula
that is either zero or one,
and in this case,
you're saying it's one if there
is an edge from i to j and zero
otherwise.
OK, sometimes you have edge
weighted graphs,
and then sometimes what people
will do is replace this by edge
weights.

Korean: 
그것은 i에서 j까지의 엣지의 무게입니다. 
우리의 직관을 수학적인 정의와 일치시키기 
위해 예를 들어 봅시다. 
예제 그래프가 있습니다. 우리의 그래프라고 합시다.
인접 행렬을 그립시다. 
i에서 j까지의 엣지가 있습니까? 
답은 아니오죠. 
1에서 2까지의 엣지가 있습니까? 
네. 1에서 3까지의 엣지가 있습니까?  
네.
1에서 5까지의 엣지가 있습니까? 
아니요. 2에서 1까지의 엣지가 있습니까? 

English: 
OK, it will be the weight of
the edge from i to j.
So, let's just do an example of
that just to make sure that our
intuition corresponds to our
mathematical definitions.
So, here's an example graph.
Let's say that's our graph.
So let's just draw the
adjacency the matrix.
OK, so what this says:
is there's an edge from one to
one?
And the answer is no.
Is there an edge from one to
two?
Yes.
Is there an edge from one to
three here?
Yep.
Is there an edge for one to
four?
No.
Is there an edge from two until

English: 
one?
No.
Two to two?
No.
Two to three?
Yes.
Two to four?
No.
No edges going out of three.
Edge from four to three,
and that's it.
That's the adjacency matrix for
this particular graph,
OK?
And so, I can represent a graph
as this adjacency matrix.
OK, when I represent it in this
way, how much storage do I need?
OK, n^2 or V^2 because the size
is the same thing for V^2

Korean: 
아니요. 
2에서 2는요? 없습니다. 
2에서 3은요? 있습니다.  
2에서 4는요? 없습니다.
3의 밖으로 가는 엣지는 없습니다. 
4에서 3까지입니다. 그것은 이 특정 그래프를 
위한 인접 행렬입니다. 
저는 그래프를 이 인접 행렬로 표현할 수 있습니다.
제가 그것을 이 방법으로 표현할 때, 저는 얼마나 많은 저장이 필요한가요? 
n^2 또는 V^2 입니다 왜냐하면 크기는 V^2 저장을 위해 같기 때문입니다. 

Korean: 
그것은 빽빽한 표현입니다. 
그것은 그래프가 빽빽할 때 잘 동작합니다. 
엣지의 수가 가능한 모든 엣지와 같으면 그래프는 빽빽합니다. 
이것은 좋은 표현입니다. 
그러나 많은 그래프 타입을 위해, 엣지의 수는 
가능한 모든 엣지 수 보다 더 작습니다, 
어떤 케이스에서 우리는 그래프가 드물다고 말하나요? 
드문 그래프의 예를 줄 수 있나요?
저는 그래프의 계층을 원합니다 n이 커질수록, 
그래프에서 엣지의 수는 정사각형처럼 커지지 않지만 
더 작은 것처럼 커집니다. 
여러분이 이론적으로 그것을 그래프로부터 보면, 
연결 리스트, 연쇄는 
좋은 예입니다. 
길이 n의 연쇄를 위해 n 엣지가 있습니다. 
그러므로, 엣지의 수는 오더 V입니다. 

English: 
storage, OK, and that's what we
call a dense representation.
OK, it works well when the
graph is dense.
So, the graph is dense if the
number of edges is close to all
of the edges possible.
OK, then this is a good
representation.
But for many types of graphs,
the number of edges is much
less than the possible number of
edges, in which case we say the
graph is sparse.
Can somebody give me an example
of a sparse graph?
A class of graphs:
so, I want a class of graphs
that as n grows,
the number of edges in the
graph doesn't grow as the
square, but grows rather as
something much smaller.
A linked list,
so, a chain,
OK, if you look at it from a
graph theoretically,
is a perfectly good example:
only n edges in the chain for a
chain of length n.
So therefore,
the number of edges would be

Korean: 
특히, 여러분은 열 당 하나의 엣지를 갖습니다. 
다른 드문 그래프가 있나요? 네? 
좋아요. 
평면 그래프입니다 
그것은 오더 V 엣지입니다. 
흔한 그래프의 예가 또 있나요? 
이진 트리, 부록에 있는 
자유 트리가 있습니다. 
연결된 그래프인 트리는 원을 가지지 않습니다. 

English: 
order V.
And in particular,
you'd only have one edge per
row here.
What other graphs are sparse?
Yeah?
Good, a planar graph,
a graph that can be drawn in a
plane turns out that if it has V
vertices has,
and V is at least three,
then it has,
at most, three V minus six
edges.
So, it turns out that's order V
edges again.
What's another example of a
common graph?
Yeah, binary tree,
or even actually any tree,
you know, what's called a free
tree if you read the appendix,
OK, a tree that just is a
connected graph that has no

Korean: 
그것은 또 다른 예입니다. 빽빽한 그래프의 예는 무엇이죠? 
완전한 트리입니다. 
여러분이 엣지 중심을 가지면, 
그것은 행렬에 완전히 채워집니다. 
좋아요. 이것은 빽빽한 표현을 위해 좋습니다. 
그러나 때때로 여러분은 드문 표현을 원합니다 
그래서 우리는 V^2 공간을 쓰지 
않아도 됩니다, 
대부분은 0이 될 것입니다. 
그것이 0인 것을 알면, 그것을 0으로써 왜 표현하나요?
그 표현은 인접 리스트 
표현입니다. 
사실, 인접 리스트는 리스트입니다, 

English: 
cycles, OK, is another example.
What's an example of a graph
that's dense?
A complete graph,
OK: it's all ones,
OK, or if you have edge
weights, it would be a
completely filled in matrix.
OK, good.
So, this is good for dense
representation.
But sometimes you want to have
a sparse representation so we
don't have to spend V^2 space to
deal with all of the,
where most of it's going to be
zeroes.
OK, it's sort of like,
if we know why it's zero,
why bother representing it as
zero?
So, one such representation is
an adjacency list
representation.
Actually, adjacency list of a
given vertex is the list,

English: 
which we denote by Adj of V,
of vertices adjacent to V.
OK, just in terms by their
terminology, vertices are
adjacent, but edges are incident
on vertices.
OK, so the incidence is a
relation between a vertex and an
edge.
An adjacency is a relation
between two vertices.
OK, that's just the language.
Why they use to different
terms, I don't know,
but that's what they do.
So, in the graph,
for example,
the adjacency list for vertex
one is just the list or the set
of two three because one has
going out of one are edges to
two and three.

Korean: 
우리는 Adj[v]를 V의 인접한 정점으로 표시합니다. 
그것의 용어의 관점에서, 정점은 인접합니다, 
그러나 엣지는 정점에서 부수적입니다. 
발생 정도는 정점과 엣지 사이의 관계입니다. 
인접함은 두 정점 간의 관계입니다. 
그것은 단지 언어입니다.
왜 그들은 다른 용어를 사용하나요? 모르겠지만, 
그것은 그들이 하는 것입니다. 
예를 들어, 그래프에서, 정점 1에 대해서 
 인접 리스트는 리스트 또는 {2, 3}입니다 
1은 2와 3의 엣지이기 때문입니다. 

English: 
The adjacency list for two is
just three, four,
three.
It's the empty set,
and for four,
it is three.
OK, so that's the
representation.
Now, if we want to figure out
how much storage is required for
this representation,
OK, we need to understand how
long the adjacency list is.
So, what is the length of an
adjacency list of a vertex,
V?
What name do we give to that?
It's the degree.
So, in an undirected graph,
we call it the degree of the

Korean: 
2에 대한 인접 리스트는 {3}이고,
3에 대해서는 빈 집합이네요.
4에 대해서는 {3}입니다.
그것은 표현입니다. 
우리가 저장이 얼마나 요구되는지 알면, 
우리는 인접 리스트가 얼마나 긴지 이해할 필요가 있습니다.
한 정점 V를 위한 인접 리스트의 
길이는 무엇입니까? 
그것의 이름은 무엇입니까? 그것은 차수입니다. 
무방향 그래프에서, 우리는 그것을 정점의 차수로 부릅니다. 

Korean: 
이것은 무방향입니다. 
네.
그것은 무방향 케이스입니다. 방향 케이스에서, 
우리가 이것을 하는 방법은 이것입니다. 
우리는 그것을 방향 그래프를 위한 정도 밖에 있다고 합니다.
방향 그래프에서, 
우리는 진입 차수와 출력 차수를 가집니다.
여기서 진입 차수는 3입니다. 
여기서 출력 차수는 2입니다. 
여기서 중요한 부명제는 핸드셰이킹 부명제입니다. 
그것은 수학적인 부명제의 

English: 
vertex.
This is undirected.
OK, about here,
OK.
So that's an undirected case.
In the directed case,
OK, actually I guess the way we
should do this is say this.
If the degree,
we call it the out degree for a
digraph.
OK, so in a digraph,
we have an out degree and an in
degree for each vertex.
So here, the in degree is
three.
Here, the out degree is two,
OK?
So, one of the important lemma
that comes up is what's called
the handshaking lemma.
OK, it's one of these

Korean: 
하나입니다. 
그것을 이야기로부터 옵니다. 
저녁 파티에 가서, 모든 사람은 악수를 합니다.
사람들은 악수를 하지 않을 수도 있습니다. 
어떤 사람은 여러 사람과 악수를 합니다. 
아무도 스스로와 악수하지 않습니다.
저녁 파티 동안 어떤 점에서, 
주인은 가서 얼마나 많은 사람이 
악수를 했는지 셉니다. 
그는, 당신은 몇 명과 악수했나요? 라고 말합니다. 
몇 명과 악수했나요? 몇 명과 악수했나요? 
그리고 더합니다. 

English: 
mathematical lemmas.
And so, it comes from a story.
Go to a dinner party,
and everybody at the dinner
party shakes other people's
hands.
Some people may not shake
anybody's hand.
Some people may shake several
people's hands.
Nobody shakes hands with
themselves.
And at some point during the
dinner party,
the host goes around and counts
up how many, the sum,
of the number of hands that
each person has shaken.
OK, so he says,
how many did you shake?
How many did you shake?
How many did you shake?
He adds them up,

English: 
OK, and that number is
guaranteed to be even.
OK, that's the handshaking
lemma.
Or, stated a little bit more
precisely, if I take for any
graph the degree of the vertex,
and sum them all up,
that's how many hands everybody
shook, OK, that's actually equal
to always twice the number of
edges.
So, why is that going to be
true?
Why is that going to be twice
the number of edges?
Yeah?
Yeah.
Every time you put in an edge,
you add one to the degree of
each person on each end.
So, it's just two different
ways of counting up the same
number of edges.
OK, I can go around,
and if you imagine that,
that every time I count the
degree of the node,

Korean: 
그것은 보장된 수입니다. 
그것은 핸드셰이킹 부명제입니다. 
또는 더 정확하게, 
제가 어떤 그래프 차수를 취하고, 모두 더하면, 
얼마나 많이 악수를 했나요? 
그것은 항상 엣지 수의 두 배입니다. 
왜 그렇죠? 
왜 엣지 수의 두 배인가요?
네? 네. 
여러분이 엣지에 넣을 때 마다, 
여러분은 1을 마지막에 각 사람의 차수에 다합니다. 
그것은 엣지의 같은 수를 세는 두 다른 방법입니다. 
여러분이 그것을 상상할 수 있을겁니다. 제가 돌아다니면서,  
제가 노드의 차수를 셀 때 마다,

English: 
I put a mark on every edge.
Then, when I'm done,
every edge has two marks on it,
one for each end.
OK: a pretty simple theorem.
So, what that says is that for
undirected graphs,
that implies that the adjacency
list representation,
uses how much storage?
OK, at most,
2E, so order E because that's
not all.
Yeah, so you have to have the
number of vertices plus order
the number of edges,
OK, whether it's directed or
undirected because I may have a
graph, say it has a whole bunch
of vertices and no edges,

Korean: 
저는 모든 엣지에 표시합니다. 
제가 다 하면, 모든 엣지는 두 기호를 가집니다, 
매우 간단한 정리입니다. 
무방향 그래프를 위해, 인접 리스트 표현은 
얼마나 많은 저장을 사용하나요?
최대, 2E입니다, 그래서 오더 E입니다 왜냐하면 그것이 전부가 아니기 때문입니다. 
그래서 여러분은 정점의 수 더하기 오더 
대각선의 수를 가져야 합니다. 
그것이 방향성이든 무방향성이든, 제가 그래프를 가지기 때문에, 
그것은 전체 정점을 가지고 대각선을 가지지 않습니다, 

English: 
that's still going to cost me
order V, OK?
So, it uses theta of V plus E
storage.
And, it's basically the same
thing asymptotically.
In fact, it's easier to see in
some sense for digraphs because
for digraphs,
what I do is I just add up the
out degrees, and that equal to
E, OK, if I add up the out
degrees as equally.
In fact, this is kind of like
it amortized analysis,
if you will,
a book keeping analysis,
that if I'm adding up the total
number of edges,
one way of doing it is
accounting for a vertex by
vertex.
OK, so for each vertex,
I basically can take each
degree, and basically each
vertex, look at the degree,

Korean: 
그것은 여전히 오더 V의 비용이 듭니다. 
그것은 θ(V+E)의 공간을 사용합니다. 
그것은 기본적으로 점진적으로 같은 것입니다. 
사실 방향 그래프의 관점에서 보는 것은 더 쉽습니다 
왜냐하면 제가 모든 차수를 더하면 그것은 E와 같기 때문입니다.
사실 이것은 일종의 분할 상환 분석입니다. 
제가 엣지의 총 수를 더하면, 
그것을 하는 
하나의 방법은 
정점을 하나씩 세는 것입니다. 
각 정점에 대하여 저는 기본적으로 각 차수와 정점을 가지고, 
차수를 봅니다, 

English: 
and that allocating of account
per edge, and then ending up
with twice the number of edges,
that's exactly accounting type
of analysis that we might do for
amortized analysis.
OK, so we'll see that.
So, this is a sparse
representation,
and it's often better than an
adjacency matrix.
For example,
you can imagine if the World
Wide Web were done with an
adjacency matrix as opposed to,
essentially,
with an adjacency list type of
representation.
Every link on the World Wide
Web, I had to say,
here are the ones that I'm
connected to,
and here are all the ones I'm
not connected to.
OK, that list of things you're
not connected to for a given
page would be pretty
dramatically,

Korean: 
그리고 엣지의 두 배로 끝납니다. 
그것은 정확히 우리가 분할 상환 분석을 위해 
하는 분석의 타입입니다.
우리는 그것을 볼 것입니다. 
이것은 드문 표현입니다. 그리고 그것은 종종 인접 행렬 보다 
더 낫습니다. 예를 들어, 
여러분은 월드 와이드 웹이  
인접 행렬로 되는지 
상상할 수 있습니다.
월드 와이드 웹에서 
모든 링크는 제가 연결하는 것이고,
이것은 제가 연결하지 않는 모든 것입니다. 
여러분이 주어진 페이지에서 연결하지 않는 것은 
매우 극적으로 여러분에게 드문 표현의 

Korean: 
이점이 있다는 것을 보여줍니다.
다른 한편으로, 
인접 행렬 표현에 대해 좋은 것은 
각 엣지가 단일 비트로 표현될 수 있다는 것입니다, 
반면에 제가 이것들을 인접 리스트로 표현할 때, 
저는 각 인접을 표현하기 위해 
얼마나 많은 비트가 필요합니까?
여러분은 각 정점을 이름 지을 수 있는 오더 lg V가 필요합니다. 
수의 오더는 제가 필요한 비트의 수입니다. 
이것은 사실 더 
효율적인 표현이 있는 곳입니다. 
특히, 여러분이 빽빽한 그래프를 가지고 있으면, 
이것은 그것을 표현하는 더 나은 방법입니다.

English: 
show you that there is an
advantage to sparse
representation.
On the other hand,
one of the nice things about an
adjacency matrix representation
is that each edge can be
represented with a single bit,
whereas typical when I'm
representing things with an
adjacency list representation,
how many bits am I going to
need to represent each
adjacency?
You'll need order log of V to
be able to name each different
vertex.
OK, the log of the number is
the number of bits that I need.
So, there are places where this
is actually a far more efficient
representation.
In particular,
if you have a very dense graph,
OK, this may be a better way of
representing it.

English: 
OK, the other thing I want you
to get, and we're going to see
more of this in particular next
week, is that a matrix and a
graph, there are two ways of
looking at the same thing.
OK, and in fact,
there's a lot of graph theory
that when you do things like
multiply the adjacency matrix,
OK, and so forth.
So, there's a lot of
commonality between graphs and
matrices, a lot of mathematics
that if it applies for one,
it applies to the other.
Do you have a question,
or just holding your finger in
the air?
OK, good.
OK, so that's all just review.
Now I want to get onto today's
lecture.
OK, so any questions about
graphs?
So, this is a good time to
review appendix B.
there are a lot of great
properties in there,
and in particular,
there is a theorem that we're
going to cover today that we're
going to talk about today,
which is properties of trees.

Korean: 
우리는 이것을 다음주에 더 볼 것입니다, 
그것은 행렬과 그래프입니다. 
같은 것을 보는 두 방법이 있습니다.
사실 여러분이 인접 행렬을 곱할 때 
많은 그래프 이론이 있습니다. 
그래서
그래프와 행렬 간의 많은 공통점이 있고, 
그것이 하나에 적용되면 다른 것에도 적용됩니다. 
질문 있나요? 
좋아요. 
그것은 단지 복습입니다. 이제 저는 오늘의 강의로 들어가고 싶습니다. 
그래프에 대한 질문 있나요? 
이것은 부록 B를 복습하기 좋은 시간입니다. 
저기 많은 훌륭한 속성들이 있고 
특히
오늘 우리가 다룰 정리가 있습니다. 
그것은 트리의 속성입니다. 

English: 
Trees are very special kinds of
graphs, so I really want you to
go and look to see what the
properties are.
There is, I think,
something like six different
definitions of trees that are
all equivalent,
OK, and so, I think a very good
idea to go through and read
through that theorem.
We're not going to prove it in
class, but really,
provides a very good basis for
the thinking that we're going to
be doing today.
And we'll see more of that in
the future.
OK, so today,
we're going to talk about
minimum spanning trees.
OK, this is one of the world's
most important algorithms.
OK, it is important in
distributed systems.
It's one of the first things
that almost any distributed
system tries to find is a
minimum spanning tree of the
nodes that happened to be alive
at any point,
OK?

Korean: 
트리는 매우 특별한 그래프입니다. 
저는 여러분이 속성이 무엇인지 보길 원합니다.
모두 동등한 6개의 
다른 트리의 정의가 있습니다. 
저는 그 정리를 읽는 것이 좋은 생각이라고 생각해요. 
우리는 그것을 수업에서 증명하지 않을 것이지만 
우리가 오늘 할 것에 대해 생각하기 
위한 좋은 기초를 제공합니다. 
그리고 우리는 미래에 많은 것을 볼 것입니다. 
우리는 최소 스패닝 트리에 대해 이야기할 것입니다.
이것은 세계에서 가장 중요한 알고리즘 중의 하나입니다. 
그것은 분산 시스템에서 중요합니다. 
그것은 거의 
대부분 분산 시스템이 찾으려고 
하는 첫 번째 것 중 하나입니다. 

Korean: 
그리고 알고리즘을 개발한 사람은, 
나중에 이야기하겠습니다, 
그것은 수년 간 AT&T를 위한 시스템의 기초였습니다.
그래서 매우 중요한 것입니다. 
그것은 응용의 큰 수를 가집니다. 
그래서 문제는 다음과 같습니다. 
여러분은 무방향 그래프를 연결했습니다 
G = (V,E) 입니다,
w는 엣지를 무게로 매핑합니다. 
오늘 강의에서 
우리는 중요한 가정을 할 것입니다.

English: 
And one of the people who
developed an algorithm for this,
we'll talk about this a little
bit later, OK,
it was the basis of the billing
system for AT&T for many years
while it was a monopoly.
OK, so very important kind of
thing.
It's got a huge number of
applications.
So the problem is the
following.
You have a connected undirected
graph,
G equals (V,E),
with an edge weight function,
w, which maps the edges into
weights that are real numbers.
And for today's lecture,
we're going to make an
important assumption,

English: 
OK, for simplicity.
The book does not make this
assumption.
And so, I encourage you to look
at the alternative presentation
or, because what they do in the
book is much more general,
but for simplicity and
intuition, I'm going to make
this a little bit easier.
We're going to assume that all
edge weights are distinct.
OK, all edge weights are
distinct.
So what does that mean?
What does that mean that this
function, w, what property does
the function,
w, have if all edge weights are
distinct?
Who remembers their discreet
math?
It's injective.
OK, it's one to one.
OK, it's not one to one and
onto necessarily.

Korean: 
단순함을 위해서요. 책은 이 가정을 하지 않습니다
저는 여러분이 대안 발표를 보았으면 좋겠어요 
그들이 책에서 하는 것은 더 일반적이지만, 
단순함과 직관을 위해, 
저는 이것을 더 쉽게 할 것입니다. 
우리는 모든 엣지 무게가 개별적이라고 가정할 것입니다.
모든 엣지 무게는 개별적입니다. 
그것은 무엇을 의미하나요? 
그것이 의미하는 것은 이 함수입니다. 
모든 엣지 무게가 개별적이면 함수는 어떤 속성을 가지나요? 
신중한 수학을 기억하나요? 
그것은 단사상입니다. 그것은 하나에서 하나로 입니다. 
그것은 필수적이지 않습니다.

Korean: 
사실 그것은 하기 어려운 것입니다 왜냐하면 그것은 큰 집합이지만 
그것은 하나에서 하나로이기 때문입니다. 
그것은 단사상입니다. 그것은 우리가 단순함을 위해 가정하는 것입니다. 
책은 그것을 가정하지 않습니다. 
그것은 여러분이 그것을 진술해야 하는 방법이 
더 정확하다는 것을 의미합니다. 
그것은 기술적으로 더 정확해야 합니다. 
그것은 입력입니다.
출력은 스패닝 트리입니다. 스패닝 트리에 의해, 
우리는 그것을 모든 정점과 연결시킵니다.  

English: 
In fact, it would be kind of
hard to do that because that's a
pretty big set.
OK, but it's one to one.
It's injective.
OK, so that's what we're going
to assume for simplicity.
OK, and the book,
they don't assume that.
It just means that the way you
have to state things is just a
little more precise.
It has to be more technically
precise.
So, that's the input.
The output is--
The output is a spanning tree,
T, and by spanning tree,
we mean it connects all the
vertices.

Korean: 
그리고 그것은 최소 무게를 가집니다.
그래서 우리는 트리의 무게를 쓸 수 있습니다, 
그것에 의해, 우리는 트리에 있는 
모든 엣지 합을 충족시킵니다.
I'(V,E)는 잘못된 표현인데, 
제가 써야 하는 것은 엣지 w(u,v)입니다 
왜냐하면 이것은 엣지로부터 매핑하기 때문입니다, 
그것은 저에게 두 괄호를 줍니다.
저는 표현을 남용하길 좋아합니다. 
저는 그것을 남은 괄호에 둘 것입니다, 
왜냐하면 우리는 그것이 정말 엣지의 무게라는 것을 이해하기 때문입니다.
정렬된 쌍의 무게가 아닙니다. 

English: 
OK, and it's got to have
minimum weight.
OK, so we can write the weight
of the tree is going to be,
by that, we meet the sum over
all edges that are in the tree
of the weight of the individual
edges.
OK, so here I'(V,E) done a
little bit of abusive notation,
which is that what I should be
writing is w of the edge (u,v)
because this is a mapping from
edges, which would give me a
double parentheses.
And, you know,
as you know,
I love to abuse notation.
So, I'm going to drop that
extra parentheses,
because we understand that it's
really the weight of the edge,
OK, not the weight of the
ordered pair.

English: 
So, that's just a little
notational convenience.
OK, so one of the things,
when we do the take-home exam,
notational convenience can make
the difference between having a
horrible time writing up a
problem, and an easy time.
So, it's worth thinking about
what kinds of notation you'll
use in writing up solutions to
problems, and so forth.
OK, and just in general,
a technical communication,
you adopt good notation people
understand you.
You adopt a poor notation:
nobody pays attention to what
you're doing because they don't
understand what you're saying.
OK, so let's do an example.
OK, so here's a graph.
I think for this,

Korean: 
그것은 작은 표현적인 편리함입니다. 
시험을 볼 때, 개념적인 편리함은 
차이를 만들고, 
쉽습니다. 
그것은 여러분이 문제에서 답을 쓸 때 사용하는 표현에 대해 
생각할 가치가 있습니다. 
일반적으로, 여러분은 
좋은 표현을 채택합니다.
여러분은 나쁜 표현을 채택하면 아무도 주의를 기울이지 않습니다 
그들은 여러분이 말하는 것을 이해하지 못하기 때문입니다.
예를 해 봅시다. 
여기 그래프가 있습니다. 

English: 
somebody asked once if I was
inspired by biochemistry or
something, OK,
but I wasn't.
I was just writing these things
down, OK?
So, here's a graph.
And let's give us some edge
weights.
OK, so there are some edge
weights.
And now, what we want is we
want to find a tree.
So a connected acyclic graph
such that every vertex is part
of the tree.
But it's got to have the
minimum weight possible.
OK, so can somebody suggest to

Korean: 
누군가 제게 생물화학에서 영감을 받았냐고 물었지만, 
저는 그렇지 않습니다.
단지 이것들을 썼습니다. 
여기 그래프가 있습니다. 그리고 우리에게 엣지 무게를 줍니다. 
몇 엣지 무게들이 있습니다. 
우리가 원하는 것은 트리를 찾는 것입니다. 
모든 정점이 트리의 일부인 연결된 비순환 그래프입니다. 
그러나 그것은 가능한 최소 무게를 갖지 않습니다. 
이 최소 스패닝 트리에서 

Korean: 
엣지가 무엇인지 제안할 수 있나요?
9입니다, 좋아요. 
9는 저기 있어야 합니다. 왜죠? 
그것은 그것과 이 정점을 연결하는 유일한 것이기 때문입니다. 
15 는 저기 있어야 합니다. 
모두 저기 있어야 합니다. 
다른 엣지는 어디 있어야 하나요? 
14는 그것이어야 합니다. 왜 14는 거기 있어야 하나요? 
14의 하나와 3은 저기 있어야 합니다. 
저는 무게를 최소화하길 원합니다. 전반적으로 가장 작은 무게를 가지는 것입니다. 
3이 저기 있다고 

English: 
me some edges that have to be in
this minimum spanning tree?
Yeah, so nine,
good.
Nine has to be in there
because, why?
It's the only one connecting it
to this vertex,
OK?
And likewise,
15 has to be in there.
So those both have to be in.
What other edges have to be in?
Which one?
14 has to be it.
Why does 14 have to be in?
Well, one of 14 and three has
to be in there.
I want the minimum weight.
The one that has the overall
smallest weight.
So, can somebody argue to me

English: 
that three has to be in there?
Yeah?
That's the minimum of two,
which means that if I had a,
if you add something you said
was a minimum spanning tree that
didn't include three,
right, and so therefore it had
to include 14,
then I could just delete this
edge, 14, and put in edge three.
And, I have something of lower
weight, right?
So, three has to be in there.
What other edges have to be in
there?
Do a little puzzle logic.
Six and five have to be in
there.
Why do they have to be in
there?

Korean: 
주장할 수 있나요?
네? 그것은 2의 최소값입니다, 
그것은 여러분이 무엇을 더하면 
그것이 14를 포함한다고 말합니다. 
그리고 저는 이 엣지를 지울 수 있고, 
엣지에 3을 넣습니다. 저는 더 낮은 무게를 가집니다. 
3은 저기 있어야 합니다. 
저기 다른 엣지가 무엇이어야 하나요? 
복잡한 논리를 해 봅시다. 6과 5는 저기 있어야 합니다. 
그것들은 왜 저기 있어야 하나요?

Korean: 
그것은 이를 통해 연결될 수 있습니다. 
그것은 필수적으로 이 길로 가지 않습니다.
 6은 3이 저기 있어야 하는 같은 이유로 
저기 있어야 합니다. 
우리가 두 선택을 가지기 때문입니다. 
모든 것이 연결되지만 그것이 12가 아니면, 
12는 저기 
있었습니다. 
그것을 이 길로 대신 연결합시다.
분명히 그것은 저기 있습니다. 
저는 여전히 연결된 모든 것을 
가지지 않습니다. 

English: 
Yeah, well, I mean,
it could be connected through
this or something.
It doesn't necessarily have to
go this way.
Six definitely has to be in
there for the same reason that
three had to be,
right?
Because we got two choices to
connect up this guy.
And so, if everything were
connected but it weren't,
12, I mean, and 12 was in
there.
I could always,
then, say, well,
let's connect them up this way
instead.
OK, so definitely that's in
there.
I still don't have everything
connected up.

Korean: 
최소 스패닝 트리를 위해 무엇이 있어야 합니까? 
7 5 8 입니다, 왜죠?
이것을 한번에 할 수 있나요? 
왜 5는 저기 있어야 하나요? 
네?
우리는 연결된 4 성분을 가집니다 
우리가 이것을 가지기 때문입니다, 
우리는 사실 이것을 여기서 가집니다. 
우리는 적어도 그것들을 연결하기 위해 세 엣지가 필요합니다 
왜냐하면 각 엣지는 연결된 성분을 줄일 것이기 때문입니다. 
그래서 우리는 세 엣지가 필요하고, 
그것들은 가장 싼 것입니다. 

English: 
What else has to be in there
for minimum spanning tree?
Seven, five,
and eight, why seven,
five, and eight?
OK, so can we argue those one
at a time?
Why does five have to be in
there?
Yeah?
OK, so we have four connected
components because we have this
one, this one,
we actually have,
yeah, this one here,
and this one,
good.
We need at least three edges to
connect them because each edge
is going to reduce the connected
components by one.
OK, so we need three edges,
and those are the three
cheapest ones.

Korean: 
그리고 그것들은 작동합니다. 그것들은 작동합니다. 그렇죠? 
더 큰 다른 엣지가 있나요? 
네. 이제 우리는 스패닝 트리를 가지나요? 
우리는 여기서 
큰 연결된 그래프를 가집니다. 
그것은 제가 가지는 것인가요? 그것은 제가 가지는 것과 같습니다. 
삶은 예측 가능합니다. 
모두 최소 스패닝 트리가 무엇인지 
알고 있나요, 
저기서 무엇을 하나요? 먼저 
이 퍼즐에 대해 봅시다. 
제가 원하는 것은 여러분에게 최적 서브 구조 속성에 대해 상기시키는 것입니다 

English: 
And they work.
That works, right?
Any other edges are going to be
bigger, so that works.
Good.
OK, and so, now do we have a
spanning tree?
Everything is,
we have one big connected graph
here, right?
Is that what I got?
Hey, that's the same as what I
got.
Life is predictable.
OK, so, so everybody had the
idea of what a minimum spanning
tree is, then,
out of this,
OK, what's going on there?
So, let's first of all make
some observations about this
puzzle.
And what I want to do is remind
you about the optimal

Korean: 
왜냐하면 최소 스패닝 트리는 
좋은 최적의 서브 구조 속성을 가지기 때문입니다.
우리는 최소 스패닝 트리를 가질 겁니다. 
그것을 T라고 합시다. 
저는 그래프에서 다른 엣지와 
그것들을 보여줄 것입니다. 
여기 그래프가 있습니다. 
여기 그래프가 있습니다. 그것은 여기서 제 종이를 가지는 것과 같습니다. 

English: 
substructure property because it
turns out minimum spanning tree
has a great optimal substructure
property.
OK, so the setup is going to
be, we're going to have some
minimum spanning tree.
Let's call it T.
And, I'm going to show that
with the other edges in the
graph, are not going to be
shown.
OK, so here's a graph.
OK, so here's a graph.
It looks like the one I have my

English: 
piece of paper here.
OK, so the idea is,
this is some minimum spanning
tree.
Now, we want to look at a
property of optimal
substructure.
And the way I'm going to get
that, is, I'm going to remove
some edge, (u,v),
move an arbitrary edge,
(u,v), in the minimum spanning
tree.
So, let's call this u and this
V.
And so, we're removing this
edge.
OK, so when I remove an edge in
a tree, what happens to the
tree?
What's left?
I have two trees left,
OK?
I have two trees left.
Now, proving that,
that's basically one of the
properties in that appendix,
and the properties of trees
that I want you to read,
OK, because you can actually

Korean: 
이것은 
최소 스패닝 트리입니다. 
이제 우리는 최적 서브 구조의 속성을 보길 원합니다. 
제가 그것을 얻는 방법은, 
어떤 엣지를 제거하고, 
임의의 엣지를 움직이는 것입니다. 
이것을 u라고 하고 이것을 v라고 합시다. 
우리는 이 엣지를 제거할 것입니다.
제가 트리에서 엣지를 제거할 때, 
트리에 무슨 일이 일어납니까? 
왼쪽은 무엇입니까? 
저는 왼쪽에 두 트리를 가집니다. 저는 왼쪽에 두 트리를 가집니다. 
그것은 기본적으로 부록에 있는 
속성의 하나입니다. 
트리의 속성들을 읽어보세요, 여러분이 그것을 명확히 하기 보다는 

English: 
prove that kind of thing rather
than it just being obvious,
which is, OK?
OK, so we remove that.
Then, T is partitioned into two
subtrees.
And, we'll call them T_1 and
T_2.
So, here's one subtree,
and here's another subtree.
We'(V,E) partitioned it.
No matter what edge I picked,
there would be two subtrees
that it's partitioned into.
Even if the sub tree is a
trivial subtree,
for example,
it just has a single node in it
and no edges.

Korean: 
그것을 증명할 수 있기 때문입니다. 
우리는 그것을 제가합니다. 
T는 두 서브 트리로 분할됩니다. 
우리는 그것을 T_1와 T_2으로 부릅니다. 
여기 하나의 서브 트리가 있고 다른 하나의 서브 트리가 있습니다. 
우리는 그것을 분할 했습니다. 제가 어떤 엣지를 고르든, 
그것이 분할 되는 두 서브 트리가 있습니다.
예를 들어, 서브 트리가 사소한 서브 트리라고 하더라도, 
그것은 단일 노드를 가지고 
엣지가 없습니다. 

Korean: 
우리가 증명할 정리는 최적 서브 트리의 속성을 증명합니다. 
T_1은 그래프를 위한 최소 스패닝 트리입니다.
 G의 서브 그래프는 
T_1에서 정점에 의해 유발됩니다. 
V_1은 T_1에서 정점입니다, 

English: 
So, the theorem that we'll
prove demonstrates a property of
optimal substructure.
T_1 is a minimum spanning tree
for the graph,
G_1, E_1,
a subgraph of G induced by the
vertices in T_1.
OK, that is,
V_1 is just the vertices in T_1

English: 
is what it means to be induced.
OK, so V_1 is the vertices in
T_1.
So, in this picture,
I didn't label it.
This is T_1.
This is T_2.
In this picture,
these are the vertices of T_1.
So, that's V_1,
OK?
And, E_1 is the set of pairs of
vertices, x and y,
that are the edges that are in
E_1 such that both x and y
belong to V_1.
OK, so I haven't shown the
edges of G here.
But basically,
if an edge went from here to
here, that would be in the E_1.
If it went from here to here,

Korean: 
그리고 그것은 유발된 것을 의미합니다. V_1은 T_1에서 정점입니다. 
이 그림에서, 
저는 그것에 라벨을 붙이지 않았습니다. 이것은 T_1이고 
이것은 T_2 입니다. 이 그림에서, 
이것들은 T_1의 정점입니다. 그것은 V_1입니다. 
그리고 E_1은 정점의 쌍의 집합입니다, 
그것은 V_1에 속하는 
x와 y가 E_1에 있는 엣지입니다.
저는 여기서 G의 엣지를 보여주지 않았습니다. 
기본적으로, 엣지가 여기서 여기로 갔으면, 
그것은 E_1에 있습니다. 

English: 
it would not.
And if it went from here to
here, it would not.
OK, so the vertices,
the subgraph induced by the
vertices of T_1 are just those
that connect up things in T_1,
and similarly for T_2.
So, the theorem says that if I
look at just the edges within
the graph here,
G_1, those that are induced by
these vertices,
T_1 is, in fact,
a minimum spanning tree for
that subgraph.
That's what the theorem says.
OK, if I look over here
conversely, or correspondingly,
if I look at the set of edges

Korean: 
그것이 여기서 여기로 갔으면, 
그것은 그렇지 않습니다. 
서브 그래프는 T_1에서 연결하는 것입니다, 
T_2에서도 유사합니다. 
제가 그래프 G_1 내에서 엣지를 보면, 
그것들은 이 정점에 의해 유발됩니다, 
그것은 사실 
그 서브 그래프를 위한 최소 스패닝 트리입니다. 
그것은 정리가 말하는 것입니다. 제가 이 집합에 의해 유발된 
엣지의 집합을 보면 

English: 
that are induced by this set of
vertices, the vertices in T_2,
in fact, T_2 is a minimum
spanning tree on that subgraph.
OK, OK, we can even do it over
here.
If I took a look,
for example,
at these, let's see,
let's say we cut out five,
and if I cut out edge five,
that T_1 would be these four
vertices here.
And, the point is that if I
look at the subgraph induced on
that, that these edges here.
In fact, the six,
eight, and three are all edges
in a minimum spanning tree for
that subgraph.
OK, so that's what the theorem
says.
So let's prove it.

Korean: 
T_2는 그 서브 그래프에서 
최소 스패닝 트리입니다.
우리는 그것을 여기서도 할 수 있습니다. 
제가 이것들을 보면, 예를 들어 
제가 엣지5를 자르면, 
T_1은 이 4 정점이 됩니다. 
제가 서브 그래프를 보면, 
여기 엣지가 있습니다. 
사실 6 8 3은 모두 그 서브 그래프를 
위한 최소 스패닝 트리에서 엣지입니다. 
그것은 정리가 말하는 것입니다. 
그것을 증명합시다.

English: 
OK, and so what technique are
we going to use to prove it?
OK, we learned this technique
last time: hint,
hint.
It's something you do it in
your text editor all the time:
cut and paste,
good, cut and paste.
OK, so the weight of T I can
express as the weight of the
edge I removed,
plus the weight of T_1,
plus the weight of T_2.

Korean: 
그것을 증명하기 위해 우리가 사용하는 기술은 무엇입니까? 
우리는 이 기술을 지난 시간에 배웠습니다.
그것은 여러분이 항상 문서 편집기에서 해야 하는 것, 
복사와 붙여넣기 입니다. 
T의 무게는 
제가 제가하는 엣지의 무게 
더하기 T_1의 무게 더하기 T_2로 표현할 수 있습니다. 

Korean: 
인자는 매우 간단합니다. 
그것이 G_1을 위해 T_1 보다 
더 나은 T_1 프라임입니다. 
제가 스패닝 트리를 형성하는 더 나은 방법을 가진다고 가정해 보세요.
저는 T 프라임을 구성합니다, 그것은 
엣지(u,v), 그리고 T_1 프라임, 
T_2를 포함했습니다. 

English: 
OK, so that's the total weight.
So, the argument is pretty
simple.
Suppose that there were some
T_1 prime that was better than
T_1 for G_1.
Suppose I had some better way
of forming a spanning tree.
OK, then I would make up a T
prime, which just contained the
edges, (u,v),
and T_1 prime,
union T_2.
So, I would take,

Korean: 
제가 더 나은 스패닝 트리를 가지면, 
저는 T_1의 더 낮은 무게의 스패닝 트리를 취합니다. 그리고 저는 그것을 T_1 프라임으로 부릅니다. 
저는 그것을 빼고 제 엣지로 구성되는 스패닝 트리를 구성합니다, 
무엇이 T_1 그리고 
T를 위해 잘 동작하든지요. 
그리고 그것은 스패닝 트리입니다.
T 보다 낫습니다 
이것들의 무게는 이것을 위한 무게이기 때문입니다, 
저는 이제 T_1 프라임의 무게를 사용합니다, 
그것은 더 적습니다. 그러므로 

English: 
if I had a better spanning
tree, a spanning tree of lower
weight for T_1.
And I call that T_1 prime.
I just substitute that and make
up a spanning tree that
consisted of my edge,
(u,v), whatever works well for
T_1 prime and whatever works
well for T.
And, that would be a spanning
tree.
And it would be better than T
itself was for G,
OK, because the weight of these
is just as the weight for this,
I now just get to use the
weight of T_1 prime,
and that's less.
And so, therefore,

Korean: 
T가 최소 스패닝 트리라는 가정은 위반됩니다 
제가 더 나은 것을 찾으면요. 
우리는 최적 서브 구조를 위한 좋은 속성을 가집니다. 
저는 서브 문제들을 가집니다, 
제가 그 안에 전체 문제의 최적의 답을 가지면, 
저는 서브 문제의 최적의 답을 찾을 수 있습니다.
이제 질문은, 그것이 특징이라는 것입니다. 
그것은 동적 프로그래밍의 특징입니다. 
서브 문제를 오버래핑 하는 것은 어떻습니까?
 제가 그 속성을 가지나요? 제가 여기서 
이 문제 타입을 위한 서브 문제를 오버래핑 하나요? 

English: 
the assumption that T was a
minimum spanning tree would be
violated if I could find a
better one for the subpiece.
So, we have this nice property
of optimal substructure.
OK, I have subproblems that
exhibit optimal,
if I have a globally optimal
solution to the whole problem
within it, I can find optimal
solutions to subproblems.
So, now the question is,
that's one hallmark.
That's one hallmark of dynamic
programming.
What about overlapping
subproblems?
Do I have that property?
Do I have overlapping
subproblems over here for this
type of problem?

Korean: 
예를 들어, 
제가 다른 엣지를 제거한다고 가정해보세요. 
저는 주어진 엣지를 가지는 
공간을 봅니다, 
그리고 그것을 제거합니다. 
그것은 두 부분으로 나누어지고, 이제 저는 다른 것을 갖습니다. 그리고 그것을 제거합니다.
저는 이와 유사한 많은 서브 문제를 가지나요? 
네. 제가 이것을 꺼내면, 
이것은 여기 있습니다, 
그리고 저는 여기와 여기서 다른 트리를 가집니다. 
그것은 제가 원래 
이것을 꺼낸 것과 같습니다. 
제가 엣지를 꺼내는 간단한 순서를 보면, 

English: 
So, imagine,
for example,
that I'm removing different
edges.
I look at the space of taking a
given edge, and removing it.
It partitions it into two
pieces, and now I have another
piece.
And I remove it,
etc.
Am I going to end up getting a
bunch of subproblems that are
similar in there?
Yeah, I am.
OK, if I take out this one,
then I take out,
say, this one here,
and then I'll have another tree
here and here.
OK, that would be the same as
if I had originally taken this
out, and then taken that one
out.
If I look at simple ordering of
taking out the edges,

Korean: 
저는 서브 문제를 오버래핑하는 많은 문제로 마칩니다.
좋아요.
그래서 그것은 무엇을 제안하나요? 
동적 프로그래밍 입니다. 좋아요. 
여러분은 동적 프로그래밍을 사용할 수 있습니다. 
그러나 그것은 최소 스패닝 트리가 
더 강력한 속성임을 말합니다. 
우리는 동적 프로그래밍을 위한 단서를 가지지만 
우리에게 더 강력한 기술을 사용하도록 

English: 
I'm going to end up with a
whole bunch of overlapping
subproblems.
Yeah, OK.
So then, what does that suggest
we use as an approach?
Dynamic programming,
good.
What a surprise!
Yes, OK, you could use dynamic
programming.
But it turns out that minimum
spanning tree exhibits an even
more powerful property.
OK, so we'(V,E) got all the
clues for dynamic programming,
but it turns out that there's
an even bigger clue that's going

Korean: 
돕는 더 큰 단서들이 있습니다.
우리는 탐욕 알고리즘을 위한 특징을 
부릅니다. 
우리는 탐욕 선택 속성이라는 것을 가집니다, 
지역적으로 최적의 선택은 

English: 
to help us to use an even more
powerful technique.
And that, we call,
the hallmark for greedy
algorithms.
And that is,
we have a thing called the
greedy choice property,
which says that a locally

English: 
optimal choice is globally
optimal.
And, of course,
as all these hallmarks is the
kind of thing you want to box,
OK, because these are the clues
that you're going to be able to
do that.
So, we have this property that
we call the greedy choice
property.
I'm going to show you how it
works in this case.
And when you have a greedy
choice property,
it turns out you can do even
better that dynamic programming.
OK, so when you see the two
dynamic programming properties,
there is a clue that says
dynamic programming,
yes, but also it says,
let me see whether it also has
this greedy property because if
it does, you're going to come up
with something that's even
better than dynamic programming,
OK?
So, if you just have the two,
you can usually do dynamic
programming, but if you have
this third one,

Korean: 
전체적으로 최적입니다. 
물론, 이 모든 특징이 여러분이 원하는 것이면, 
이것들이 여러분이 할 수 있는 
단서들이기 때문입니다. 
우리는 탐욕 선택 속성이라는 이 속성을 가집니다. 
저는 여러분에게 이 케이스에서 그것이 동작하는 방법을 보여줄 것입니다. 
여러분이 탐욕 선택 속성을 가질 때, 
여러분은 더 나은 동적 프로그래밍을 할 수 있습니다.
여러분이 두 동적 프로그래밍 속성을 볼 때, 
단서가 있지만, 
그것이 
탐욕 속성을 또한 가지는지 봅시다, 
가진다면, 여러분은 
더 나은 동적 프로그래밍인 것을 떠올립니다. 
여러분이 둘을 가지면, 여러분은 보통 동적 프로그래밍을 할 수 있지만, 
여러분이 이 세 번째를 가지면, 

Korean: 
잭팟입니다!
여기 우리가 이 생각을 증명할 정리가 있습니다. 
이것들은 아무것도 아닙니다. 
그것들은 휴리스틱입니다. 
저는 여러분에게 알고리즘을 줄 수 없습니다, 
여기 동적 프로그래밍이 작동하고, 여기서 탐욕 알고리즘이 작동합니다. 
그러나 저는 그것들이 
작동할 때를 지시합니다. 
여기 정리가 있습니다. T를 우리 그래프의 MST라고 합시다. 
그리고 A를 
V의 서브 집합이라고 합시다.

English: 
it's like, whoa!
Jackpot!
OK, so here's the theorem we'll
prove to illustrate this idea.
Once again, these are not,
all these hallmarks are not
things.
They are heuristics.
I can't give you an algorithm
to say, here's where dynamic
programming works,
or here's where greedy
algorithms work.
But I can sort of indicate when
they work, the kind of structure
they have.
OK, so here's the theorem.
So let's let T be the MST of
our graph.
And, let's let A be any subset
of V, so, some subset of
vertices.

Korean: 
(u,v)는 우리의 집합 A를 A의 성분과 연결하는 
최소 무게 엣지입니다. 
즉, V – A 입니다. 
(u,v)는 최소 스패닝 트리입니다. 
여기서 우리의 그래프를 봅시다. 
그리고 그것이 이 케이스인지 봅시다. 
우리가 A를 위해 할 수 있는 것 
하나는 개체 노드를 가지는 것입니다. 저는 개체 노드를 가집니다, 
그것은 제 A가 될 수 있고, 

English: 
And now, let's suppose that
edge, (u,v), is the least weight
edge connecting our set A to A
complement, that is,
V minus A.
Then the theorem says that
(u,v) is in the minimum spanning
tree.
So let's just take a look at
our graph over here and see if
that's, in fact,
the case.
OK, so let's take,
so one thing I could do for A
is just take a singleton node.
So, I take a singleton node,
let's say this guy here,
that can be my A,

Korean: 
모든 것은 V – A 입니다.
저는 이것과 다른 모든 것을 연결하는 최소 무게 엣지를 봅니다. 
그것과 다른 모든 것을 연결하는  
두 엣지가 있습니다.
더 가벼운 것은 최소 스패닝 트리에 있습니다. 
제가 이겼습니다. 
여러분이 모든 정점을 보면, 
정점으로부터 나오는 가장 마지막 엣지를 최소 스패닝 트리에 있습니다. 
가장 가벼운 무게의 엣지입니다, 
그것은 여기 있는 모든 엣지가 아닙니다.
이 집합과 연결된 
이 세 정점을 봅시다. 
저는 세 엣지를 가집니다. 
가장 적은 무게는 5입니다. 그것은 최소 스패닝 트리입니다. 
저는 그것을 이 방법으로 자를 수 있습니다. 
아래로 가는 엣지는 7 8 14입니다. 

English: 
and everything else is V minus
A.
And I look at the least weight
edge connecting this to
everything else.
Well, there are only two edges
that connect it to everything
else.
And the theorem says that the
lighter one is in the minimum
spanning tree.
Hey, I win.
OK, if you take a look,
every vertex that I pick,
the latest edge coming out of
that vertex is in the minimum
spanning tree.
OK, the lightest weight edge
coming out, but that's not all
the edges that are in here.
OK, or let's just imagine,
let's take a look at these
three vertices connected to this
set of vertices.
I have three edges is going
across.
The least weight one is five.
That's the minimum spanning
tree.
Or, I can cut it this way.
OK, the ones above one,
the edges going down are seven,

English: 
eight, and 14.
Seven is the least weight.
It's in the minimum spanning
tree.
So, no matter how I choose,
I could make this one in,
this one out,
this one in,
this one out,
this one in,
this one out,
this one in,
this one out,
take a look at what all the
edges are.
Which ever one to the least
weight: it's in the minimum
spanning tree.
So, in some sense,
that's a local property because
I don't have to look at what the
rest of the tree is.
I'm just looking at some small
set of vertices if I wish,
and I say, well,
if I wanted to connect that set
of vertices to the rest of the
world, what would I pick?
I'd pick the cheapest one.
That's the greedy approach.
It turns out,
that wins, OK,
that picking that thing that's
locally good for that subset,

Korean: 
7은 최소 무게입니다. 
그것은 최소 스패닝 트리에 있습니다. 
제가 어떻게 고르든, 
저는 이것을 안으로 
또는 
밖으로 할 수 있습니다. 
모든 엣지가 무엇을 하는지 봅시다. 
그것은 최소 스패닝 
트리에 있습니다. 
어떤 면에서, 그것은 지역 속성입니다 
저는 트리의 나머지가 무엇인지 보지 않기 때문입니다.
저는 작은 정점 집합만 봅니다, 
제가 그것을 나머지와 연결하고 싶으면, 
무엇을 고르나요? 
저는 가장 싼 것을 고릅니다. 그것은 탐욕 접근입니다. 
그것은 
그 서브 집합을 위해 지역적으로 좋고, 

English: 
A, OK, is also globally good.
OK, it optimizes the overall
function.
That's what the theorem says,
OK?
So, let's prove this theorem.
Any questions about this?
OK, let's prove this theorem.
So, we have (u,v) is the least
weight edge connecting A to D
minus A.
So, let's suppose that this
edge, (u,v), is not in the
minimum spanning tree.
OK, let's suppose that somehow
there is a minimum spanning tree
that doesn't include this least
weight edge.
OK, so what technique you think
will use to prove to get a
contradiction here?
Cut and paste,

Korean: 
전체적으로도 좋습니다. 그것은 전체 함수를 최적화합니다. 
정리가 말하는 것이 무엇입니까? 
이 정리를 증명합시다. 
이에 대한 질문 있나요? 이 정리를 증명합시다. 
(u,v)는 A 에서 D minus A 를 연결하는 최소 무게 엣지입니다. 
(u,v)가 
최소 스패닝 트리에 있지 않다고 가정합시다.
이 최소 무게 엣지를 포함하지 않는 
최소 스패닝 트리가 있다고 가정해보세요. 
여기서 모순을 얻는걸 증명하기 위해 무슨 기술을 사용할 것인가요? 
복사와 붙여넣기 입니다. 

Korean: 
우리는 복사와 붙여넣기를 할 것입니다. 
우리는 복사와 붙여넣기를 할 것입니다. 
여기서 저는 예를 했습니다, 
그리고 저는 개념을 사용할 것입니다. 
저는 이것에 색을 입힐 수 있습니다.

English: 
good.
Yeah, we're going to cut paste.
OK, we're going to cut and
paste.
So here, I did an example.
OK, so --
OK, and so I'm going to use the
notation.
I'm going to color some of
these in.

English: 
OK, and so my notation here is
this is an element of A,
and color it in.
It's an element of V minus A.
OK, so if it's not colored it,
that's an A.
This is my minimum spanning
tree.
Once again, I'm not showing the
overall edges of all the graphs,
but they're there,
OK?
So, my edge,
(u,v), which is not my minimum
spanning tree I say,
let's say is this edge here.
It's an edge from u,
u as in A, v as in V minus A.
OK, so everybody see the setup?
So, I want to prove that this
edge should have been in the
minimum spanning tree,
OK, that the contention that
this is a minimum spanning tree,

Korean: 
여기서의 개념은 이것이 A의 인자라는 것입니다. 
그것은 of V minus A의 인자입니다. 
그것이 색을 입히지 않으면, 그것은 A입니다. 
이것은 제 최소 스패닝 트리입니다. 
다시 한번, 제가 모든 그래프의 전체적인 엣지를 보여주지 않지만, 
그것들은 거기 있습니다. 
그래서 제 엣지 (u,v)는 제 최소 스패닝 
트리가 아닙니다. 
그것은 u로부터의 엣지이고, A에서 u이고, V minus A에서 v입니다. 
모두 설정을 보나요? 저는 엣지가 
최소 스패닝 트리에 있어야 한다는 것을 증명하고 싶습니다. 
이것은 최소 스패닝 트리이고 

Korean: 
(u,v)를 포함하는 것은 틀렸습니다.
제가 원하는 것은 저는 여기서 트리를 갖습니다, 
저는 두 정점 u와 v를 갖습니다, 
두 정점 간에 유일한, 간단한 경로가 있습니다. 
그것은 엣지와 정점을 반복하지 않습니다. 
u에서 v까지 유일한, 간단한 경로가 있습니다. 
그 경로를 고려해 봅시다. 
그 경로는 존재합니다 교재의 
부록 B.5.1을 보세요. 
그것은 트리의 속성에 대한 좋은 정리입니다. 

English: 
and does include (u,v) is
wrong.
So, what I want to do,
that, is I have a tree here,
T, and I have two vertices,
u and v, and in a tree,
between any two vertices there
is a unique, simple path:
simple path meaning it doesn't
go back and forth and repeat
edges or vertices.
OK, there's a unique,
simple path from u to v.
So, let's consider that path.
OK, and the way that I know
that that path exists is because
I'(V,E) read appendix B of the
textbook, section B.5.1,
OK, which has this nice theorem
about properties of trees.

Korean: 
그것은 유일한, 간단한 경로가 존재하는 방법입니다.
이제 우리가 하려고 하는 것은 
그 경로를 보는 것입니다. 이 케이스에서, 
그것은 여기서부터 여기로 갑니다. 
그 경로를 따라 
제가 A에서 정점과 V minus A에서 정점을 연결하는 점이 있습니다. 
왜죠? 
이것이 A에 있기 때문입니다. 이것은 V minus A에 있습니다. 
경로를 따라, 이행이 있어야 합니다. 
그것은 모두 A에 있지 않습니다 특히 V가 그렇지 않기 때문입니다. 
우리가 하는 것은 

English: 
OK, so that's how I know that
there exists a unique,
simple path.
OK, so now we're going to do is
take a look at that path.
So in this case,
it goes from here,
to here, to here,
to here.
And along that path,
there must be a point where I
connect from a vertex in A to a
vertex in V minus A.
Why?
Well, because this is in A.
This is in V minus A.
So, along the path somewhere,
there must be a transition.
OK, they are not all in A,
OK, because in particular,
V isn't.
OK, so we're going to do is

English: 
swap (u,v) with the first edge
on this path that connects a
vertex in A to a vertex in V
minus A.
So in this case,
it's this edge here.
I go from A to V minus A.
In general, I might be
alternating many times,
OK, and I just picked the first
one that I encounter.
OK, that this guy here.
And what I do is I put this
edge in.
OK, so then,
what happens?
Well, the edge,
(u,v), is the lightest thing
connecting something in A to
something in V minus A.
So that means,
in particular,
it's lighter than this edge,
has lower weight.
So, by swapping this,
I'(V,E) created a tree with

Korean: 
(u,v)를 정점을 연결하는 
이 경로의 첫 엣지로 바꾸는 것입니다.
이 케이스에서, 그것은 이 엣지 입니다. 
저는 A 에서 V minus A로 갑니다. 일반적으로, 
저는 많이 대체할 수 있고, 마주치는 첫 번째 것을 골랐습니다. 
이것이 여기 있습니다. 
그리고 제가 하는 것은 이 엣지를 두는 것입니다. 
무슨 일이 일어나나요? 
(u,v)는 A에서 무엇을 
V minus A로의 무엇과 연결하는 가장 가벼운 것입니다. 
특히, 
그것은 이 엣지보다 더 가볍습니다, 더 적은 무게를 가집니다. 
이것을 바꿈으로써, I'(V,E)는 전반적으로 적은 무게를 가진 트리를 만들었습니다, 

Korean: 
그리고 그것은 이 다른 것이 최소 스패닝 트리여야 
한다는 가정과 모순됩니다.
T의 결과 보다 더 낮은 무게의 스패닝 트리입니다, 
그리고 그것이 모순입니다. 
그것이 모순입니다, 
그렇죠? 우리는 어떻게 하나요? 
모두 알겠나요? 이제 우리는 어떤 
알고리즘을 할 것입니다. 
우리는 프림 알고리즘을 할 것입니다. 

English: 
lower overall weight,
contradicting the assumption
that this other thing was a
minimum spanning tree.
OK: so, a lower weight spanning
tree than T results,
and that's a contradiction --
-- than T results.
And that's a contradiction,
OK?
How are we doing?
Everybody with me?
OK, now we get to do some
algorithms.
Yea!
So, we are going to do an
algorithm called Prim's

Korean: 
프림은 결국 AT&T에서 매우 높습니다 
왜냐하면 그는 이 알고리즘을 최소 스패닝 트리를 위해 고안했기 때문입니다, 
그리고 그것은 수년 동안 
AT&T를 위한 모든 코드에서 사용되었습니다. 
그는 벨 연구소에서 매우 우뚝 섰습니다. 
여러분이 해야 하는 
모든 것을 알고리즘을 고안하는 것이라는 걸 보여줍니다.
여러분도 회사의 사장이 될 수 있습니다. 
물론, 정부는 그것을 독점으로 할 수 있지만, 
그것이 삶에서 여러분의 미션이라면, 
알고리즘을 고안하세요. 여기 아이디어가 있습니다. 

English: 
algorithm.
Prim eventually became a very
high-up at AT&T because he
invented this algorithm for
minimum spanning trees,
and it was used in all of the
billing code for AT&T for many
years.
He was very high up at Bell
Labs back in the heyday of Bell
Laboratories.
OK, so it just shows,
all you have to do is invent an
algorithm.
You too can be a president of a
corporate monopoly.
Of course, the government can
do things to monopolies,
but anyway, if that's your
mission in life,
invent an algorithm.
OK, so here's the idea.

English: 
What we're going to do is we're
going to maintain V minus A as a
priority queue.
We'll call it Q.
And each vertex,
we're going to key each vertex
in Q with the weight of the
least weight edge,
connecting it to a vertex in A.
So here's the code.

Korean: 
우리가 할 것은 V - A를 우선순위 큐로 유지하는 것입니다. 
우리는 그것을 Q라고 할 것입니다. 
우리는 Q에서 
각 정점을 입력하고, 그것을 A의 정점과 연결합니다.
여기 코드가 있습니다. 

English: 
So, we're going to start out
with Q being all vertices.
So, we start out with A being,
if you will,
the empty set.
OK, and what we're going to do
it is the least weight edge,
therefore, for everything in
the priority queue is basically
going to be infinity because
none of them have any edges.
The least weight edge to the
empty set is going to be empty.
And then, we're going to start
out with one guy.
We'll call him S,
which will set to zero for some
arbitrary S in V.
And then, the main part of the
algorithm kicks in.
So that's our initialization.
OK, when we do the analysis,
I'm going to write some stuff
on the left hand side of the

Korean: 
우리는 그것을 모든 정점이 되는 Q에서 시작합니다. 
우리는 A에서 시작합니다, 그것은 빈 집합입니다. 
그것은 
최소 무게 엣지이고,  
기본적으로 무한대가 됩니다 
왜냐하면 그것들은 아무도 엣지를 가지지 않기 때문입니다. 최소 무게 엣지는 비어 있을 것입니다. 
그리고 우리는 이것으로 시작할 것입니다.
그것을 S라고 부를 것입니다, 
그것은 V에서 임의의 S를 위해 0으로 설정됩니다. 
알고리즘의 주요 부분이 효과가 나타나기 시작합니다. 
그것은 초기화입니다. 우리가 분석을 할 때, 
저는 왼쪽에 무엇을 쓸 것입니다. 

English: 
board.
So if you're taking notes,
you may want to also leave a
little bit of space on the left
hand side of your notes.
So, while Q is not empty,
we get the smallest element out
of it.
And then we do some stuff.

Korean: 
여러분이 필기를 할 때, 
노트 왼쪽을 남겨두세요. 
Q가 빈 반면에, 
우리는 그것에서 가장 작은 인자를 얻습니다.
그리고 우리는 무엇을 합니다. 

English: 
That's it.
And the only thing I should
mention here is,
OK, so let's just see what's
going on here.
And then we'll run it on the
example.
OK, so what we do is we take
out the smallest element out of
the queue at each step.
And then for each step in the
adjacency list,
in other words,
everything for which I have an
edge going from v to u,
we take a look,
and if v is still in our set V
minus A, so things we'(V,E)
taken out are going to be part
of A.
OK, every time we take
something out,

Korean: 
그게 전부입니다. 제가 여기서 언급해야 하는 유일한 것은, 
여기서 무엇이 일어나는지 봅시다. 
그것은 예에서 돌 것입니다. 
우리가 하는 것은 
각 단계에서 큐에서 가장 작은 인자를 꺼내는 것입니다. 
인접 행렬에서 각 단계를 위해, 
즉, v에서 u까지 가는 
엣지 입니다, 
그리고 v가 여전히 우리의 집합 V - A에 있으면, 
우리는 A의 부분에서
꺼냅니다. 

Korean: 
그것은 우리가 구축하는 새로운 A입니다.
각 단계에서, 
A와 모든 것을 연결하는 가장 싼 엣지는 무엇입니까? 
우리는 기본적으로 가장 싼 것을 취하고 
그것을 더합니다, 이제 그것을 
A로 데려와서 다음으로 가장 싼 것을 찾습니다. 
우리는 이 과정을 계속 반복합니다. 
우리는 그것을 예에서 할 것입니다. 
우리가 그것을 가져올 때 마다 매번, 
책임을 가지는 정점이 무엇인지 봅니다.
제가 이 쌍의 집합을 보면, 
그것은 
최소 스패닝 트리를 형성합니다. 

English: 
that's going to be a new A that
we construct.
At every step,
we want to find,
what's the cheapest edge
connecting that A to everything
else?
We basically are going to take
whatever that cheapest thing is,
OK, add that edge in,
and now bring that into A and
find the next cheapest one.
And we just keep repeating the
process.
OK, we'll do it on the example.
And what we do,
is every time we bring it in,
I keep track of,
what was the vertex responsible
for bringing me in.
And what I claim is that at the
end, if I look at the set of
these pairs that I'(V,E) made
here, V and pi of V,
that forms the minimum spanning
tree.

Korean: 
이것을 해 봅시다. 그것은 무엇입니까? 
우리는 모두 설정합니다. 그리고 여기서 이것들을 제거합시다. 
우리는 그것들을 다시 계산할 것이기 때문입니다. 
여러분은 노트에서 다시 그래프를 복사하길 원합니다. 
저는 그것을 해야 했지만, 
이것은 지울 것입니다. 
그것을 수정해 봅시다. 우리는 시작하겠습니다. 
우리는 모든 것을 무한대로 만들 것입니다. 그래서 그것은 제가 키 값을 가지는 곳입니다. 

English: 
So let's just do this.
And, what's that?
We're all set up.
So let's get rid of these guys
here because we are going to
recompute them from scratch.
OK, so you may want to copy the
graph over again in your notes.
I was going to do it,
but it turned out,
this is exactly the board is
going to erase this.
OK, well let me just modify it.
OK, so we start out.
We make everything be infinity.
OK, so that's where I'm going

Korean: 
그리고 저는 하나의 정점을 찾습니다.
그리고 저는 그것을 S라고 부를 것입니다. 
저는 여기서 이 정점을 합니다. 
우리는 그것을 S라고 부릅니다. 기본적으로, 
저는 그것을 0이 되도록 합니다. 
이제 저는 최소값을 추출합니다. 기본적으로 
저는 이와 같이 음영을 넣습니다, 
783
01:08:28,198 --> 01:08:34,000
그것은 이제 집합 A라는 것을 의미합니다. 
이것은 A가 될 것입니다. 그리고 이것은 V - A의 인자입니다. 
우리가 하는 것은 보는 것입니다. 
우리는 그것을 추출하고, 
인접 리스트에서 각 정점을 위하여, 
우리는 그것이 여전히 

English: 
to keep the key value.
OK, and then what I'm going to
do is find one vertex.
And I'm going to call him S.
And I'm going to do this vertex
here.
We'll call that S.
So basically,
I now make him be zero.
And now, what I do,
is I execute extract min.
So basically,
what I'll do is I'll just shade
him like this,
indicating that he has now
joined the set A.
So, this is going to be A.
And this is element of V minus
A.
OK, so then what we do is we
take a look.
We extract him,
and then for each edge in the
adjacency list,
OK, so for each vertex in the
adjacency lists,

Korean: 
Q, 
즉 V - A에 있는지 볼 것입니다.
그렇다면, 그것의 키 값은 엣지의 값 보다 작습니다, 
우리는 그것을 엣지 값과 교체할 것입니다. 
이 케이스에서, 
우리는 이것을 7과 교체할 것입니다. 
우리는 이것을 15와 교체할 것이고, 이것을 10과 교체할 것입니다. 
우리가 관심 있는 것은, 
797
01:09:33,854 --> 01:09:39,608
가장 싼 것이 무엇입니까? 
우선순위 큐에 있는 것은 
이제 그것과 I'(V,E)가 이미 제거한 것을 연결하는 
가장 싼 방법을 가집니다, 
그리고 그것은 A에 있는 것입니다. 

English: 
that these guys here,
OK, we're going to look to see
if it's still in Q,
that is, in V minus A.
And if so, and its key value is
less than what the value is at
the edge, there,
we're going to replace it by
the edge value.
So, in this case,
we're going to replace this by
seven.
We're going to replace this by
15, and we're going to replace
this by ten, OK,
because what we're interested
in is, what is the cheapest?
Now, notice that everything in
V minus A, that is,
what's in the priority queue,
everything in there,
OK, now has its cheapest way of
connecting it to the things that
I'(V,E) already removed,
the things that are in A.
OK, and so now I just,

English: 
OK, when I actually do that
update, there's actually
something implicit going on in
this priority queue.
And that is that I have to do a
decreased key.
So, there's an implicit
decrease of the key.
So, decreased key is a priority
queue operation that lowers the
value of the key in the priority
queue.
And so, that's implicitly going
on when I look at what data
structure I'm going to use to
implement that priority queue.
OK, so common data structures
for implementing a priority
queue are a min heap.
OK, so I have to make sure that
I'm actually doing this
operation.
I can't just change it and not
affect my heap.
So, there is an implicit
operation going on there.
OK, now I repeat.
I find the cheapest thing,
oh, and I also have to set,
now, a pointer from each of

Korean: 
제가 그것을 업데이트할 때, 
이 우선순위 큐에 내포된 것이 있습니다.
그것은 제가 감소된 키를 해야 하는 것입니다. 
내포된 키의 감소가 있습니다. 
감소된 키는 우선순위 큐에서 키의 값을 낮추는 
우선순위 큐 연산입니다. 
제가 데이터 구조를 볼 때 저는 
그 우선순위 큐를 구현하는 것을 사용합니다. 
우선순위 큐를 구현하기 위한 일반적인 데이터 구조는 최소 힙입니다.
저는 실제로 제가 이 연산을 한다고 
확신해야 합니다. 
저는 그것을 바꿀 수 없고 제 힙에 영향을 미치지 않습니다. 
저기서 내포된 연산이 있습니다. 
저는 이제 반복합니다. 저는 가장 싼 것을 찾습니다, 
그리고 포인터를 설정합니다. 

Korean: 
이것은 이 방법으로 포인터를 설정합니다. 
이것은 이 방법으로 포인터를 설정하고, 
이것은 이 방법으로 포인터를 설정합니다. 
그것은 제 값을 설정하는 것을 하는 pi입니다. 
우리는 안으로 가고 가장 싼 것을 
다시 찾습니다. 
그리고 우리는 그것을 빠르게 합니다. 
이것이 빠른 알고리즘입니다.
이제 우리는 이것을 다시 할 것입니다. 추출하기 가장 싼 것은 무엇입니까? 
이것인가요? 
우리는 그것을 가지고 
그의 이웃을 모두 업데이트합니다. 
이것은 5를 얻습니다. 이것은 12를 얻습니다. 
이것은 9를 얻습니다. 이것은 업데이트 하지 않습니다. 

English: 
these guys back to u.
So here, this guy sets a
pointer going this way.
This guy sets a pointer going
this way, and this guy sets a
pointer going this way.
That's my pi thing that's going
to keep track of who caused me
to set my value to what it is.
So now, we go in and we find
the cheapest thing,
again.
And we're going to do it fast,
too.
OK, this is a fast algorithm.
OK, so now we're going to go do
this again.
So now, what's the cheapest
thing to extract?
This guy here,
right?
So, we'll take him out,
OK, and now we update all of
his neighbors.
So this guy gets five.
This guy gets 12.
This guy gets nine.
This guy we don't update.

English: 
We don't update him because
he's no longer in the priority
queue.
And all of these guys now,
we make point to where they're
supposed to point to.
And, we're done with that step.
Now we find the cheapest one.
What's the cheapest one now?
The five over here.
Good.
So, we take him out.
OK, we update the neighbors.
Here, yep, that goes to six
now.
And, we have that pointer.
And, this guy we don't do,
because he's not in there.
This guy becomes 14,
and this guy here becomes
eight.
So, we update that guy,
make him be eight.
Did I do this the right way?
Yeah, because pi is a function
of this guy.

Korean: 
왜냐하면 더 이상 우선순위 큐에 
있지 않기 때문입니다, 
우리는 그것이 초점을 맞추는 것에 초점을 맞춥니다. 
우리는 그 단계를 다 했습니다. 이제 우리는 가장 싼 것을 찾습니다. 
이제 가장 싼 것은 무엇입니까? 여기 5입니다. 
좋아요. 우리는 그것을 꺼냅니다. 
우리는 이웃을 업데이트 합니다. 그것은 6으로 갑니다. 
우리는 그 포인터를 가집니다.
우리는 이것을 하지 않습니다, 그것이 저기 없기 때문입니다. 
이것은 14가 되고, 이것은 8이 됩니다. 
우리는 그것을 업데이트 하고 
8로 만듭니다. 제가 이것을 옳게 했나요? 
네, pi가 이 것의 함수이기 때문입니다. 

English: 
So basically,
this thing, then,
disappears.
Yeah, did I have another one
that I missed?
12, yes, good,
it's removed,
OK, because pi is just a
function.
And now I'm OK.
OK, so now what do I do?
OK, so now my set,
A, consists of these three
things, and now I want the
cheapest edge.
I know it's in the minimum
spanning tree.
So let me just greedily pick
it.
OK, so what's the cheapest
thing now?
This guy appear?
Yeah, six.
So we take it.
We go to update these things,
and nothing matters here.
OK, nothing changes because
these guys are already in A.
OK, so now the cheapest one is
eight here.
Good.
So, we take eight out.

Korean: 
기본적으로 이것은 사라집니다. 
제가 놓친 다른 것을 했나요? 
12입니다, 좋아요, 
그것은 제거되었습니다. Pi는 단지 함수이기 때문입니다. 
그리고 이제 괜찮습니다. 
이제 저는 무엇을 하나요? 이제 제 집합 A는 
세 가지로 구성되고 저는 가장 싼 엣지를 원합니다. 
저는 그것이 최소 스패닝 트리에 있다는 것을 합니다. 
탐욕적으로 그것을 고르겠습니다.
이제 가장 싼 것은 무엇입니까? 
이것이 나타나나요? 
네, 6입니다. 우리는 그것을 가집니다. 
우리는 이것들을 업데이트하고, 여기서 아무것도 중요하지 않습니다. 
이것들은 이미 A에 있기 때문에 아무것도 바뀌지 않습니다. 
이제 가장 싼 것은 8입니다. 
우리는 8을 꺼냅니다. 

Korean: 
우리는 이것을 업데이트 합니다. 아무 것도 되지 않았습니다. 
아무 것도 되지 않았습니다. 
14 대신에 우리는 이것을 3으로 합니다. 
우리는 그 포인터를 제거하고 그것을 이 방법으로 합니다. 
이제 3은 가장 싼 것입니다. 
우리는 그것을 꺼내고, 물론 저기 아무 것도 되지 않았습니다. 
이제 마지막으로, 
저는 9를 가집니다. 그리고 그것은 다 되었습니다. 
그리고 15도 되었습니다. 그리고 알고리즘은 종결됩니다.
제가 고른 모든 엣지를 볼 때, 
그것들은 정확히 우리가 처음에 가지는 모든 엣지입니다. 
여기서 분석을 해 봅시다. 

English: 
OK, we update this.
Nothing to be done.
This: nothing to be done.
This: oh, no,
this one, instead of 14 we can
make this be three.
So, we get rid of that pointer
and make it point that way.
Now three is the cheapest
thing.
So, we take it out,
and of course there's nothing
to be done over there.
And now, last,
I take nine.
And it's done.
And 15: it's done.
And the algorithm terminates.
OK, and as I look at,
now, all the edges that I
picked, those are exactly all
the edges that we had at the
beginning.
OK, let's do an analysis here.

English: 
OK, so let's see,
this part here costs me order
V, right?
OK, and this part,
let's see what we are doing
here.
Well, we're going to go through
this loop how many times?
V times.
It's V elements we put into the
queue.
We are not inserting anything.
We're just taking them out.
This goes V times,
OK, and we do a certain number
of extract Mins.
So, we're going to do order V
extract Mins.
And then we go to the adjacency
list, and we have some constant
things.
But we have these implicit

Korean: 
이 부분은 오더 V가 듭니다, 그렇죠? 
이 부분은, 
우리가 여기서 무엇을 하는지 봅시다. 
우리는 이 루프를 몇 번 합니까? 
V번 합니다. 그것은 우리가 큐에 넣는 V 인자들입니다. 
우리는 아무 것도 삽입하지 않습니다. 
우리는 단지 그것들을 꺼냅니다. 이것은 V번 하고 
우리는 최소값을 추출하는 수를 합니다. 
우리는 오더 V를 합니다. 
그리고 인접 리스트로 가서 정수의 것을 가집니다. 
그러나 우리는 여기 이것을 위한 

English: 
decreased keys for this stuff
here.
That's this thing here.
OK, and so how many implicit
decreased keys do we have?
That's going to be the
expensive thing.
OK, we have,
in this case,
the degree of u of those.
OK, so overall,
how many implicit decreased
keys do we have?
Well, we have V times through.
How big could the degree of u
be?
OK, it could be as big as V,
order V.
So, that's V^2 decreased use.
But we can do a better bound

Korean: 
내포된 감소 키를 가집니다.
그리고 이것 입니다. 우리는 얼마나 많은 내포된 
감소 키를 가집니까? 
그것은 비쌀 것입니다. 
이 케이스에서, 우리는 그것들의 u의 차수를 가집니다, 
우리는 얼마나 많은 내포된 감소 키를 가집니까? 
우리는 V번을 가집니다. 
u의 차수는 얼마나 클 수 있습니까? 
그것은 V, order V만큼 큽니다. 
그것은 V^2입니다. 그러나 우리는 그것보다 더 나은 바운드를 할 수 있습니다.

Korean: 
우리는 실제로 얼마나 가지나요? 
최대 오더 E입니다 저는 무엇을 하나요? 
저는 모든 정점의 차수를 더합니다. 
그것을 제가 그것들을 실행하는 횟수입니다. 
저는 오더 E를 가집니다. 
전반적인 시간은 
오더 V입니다. 

English: 
than that.
How many do we really have?
Yeah, at most order E,
OK, because what am I doing?
I'm summing up the degrees of
all the vertices.
That's how many times I
actually execute that.
So, I have order E,
implicit decreased keys.
So the time overall is order V
times time for whatever the
extract Min is plus E times the
time for decreased key.

Korean: 
이제 데이터 구조를 봅시다, 우리는 이 공식이 우리에게 주는 
다른 데이터 구조를 평가할 수 있습니다.
우리는 데이터 구조를 실행하는 다른 방법을 가집니다. 
우리는 최소값을 가지고 감소 키를 가집니다. 
데이터 구조를 구현하는 가장 간단한 방법은 
정렬되지 않은 배열입니다. 
제가 정렬되지 않은 배열을 가지면, 최소 인자를 추출하는데 얼마의 시간이 걸립니까? 
제가 정렬되지 않은 배열을 가지면요? 
이 케이스에서 오더 V입니다 왜냐하면 그것은 크기 V의 배열이기 때문입니다. 

English: 
So now, let's look at data
structures, and we can evaluate
for different data structures
what this formula gives us.
So, we have different ways of
implementing a data structure.
We have the cost of extract
Min, and of decreased key,
and total.
So, the simplest way of
implementing a data structure is
an unsorted array.
If I have an unsorted array,
how much time does it take me
to extract the minimum element?
If I have an unsorted array?
Right, order V in this case
because it's an array of size V.

Korean: 
감소 키를 하기 위해 저는 그것을 오더 1에서 할 수 있습니다.
총 비용은 오더 V^2입니다. 
사람들이 제안했던 것처럼, 이진 힙은 어떤가요? 
이진 힙에서 최소를 추출하기 위해 얼마의 비용이 드나요? 
오더 로그 V입니다. 여러분은 그것을 
오더 로그 V에서 할 수 있습니다 
왜냐하면 기본적으로 여러분은 값을 섞을 수 있기 때문입니다, 
그것을 루트와 바꿀 수 있습니다. 
또는 로그 V에서요. 그러므로 총비용은요?

English: 
And, to do a decreased key,
OK, I can do it in order one.
So, the total is V^2,
good, order V^2 algorithm.
Or, as people suggested,
how about a binary heap?
OK, to do an extract Min in a
binary heap will cost me what?
O of log V.
Decreased key will cost me,
yeah, it turns out you can do
that in order log V because
basically you just have to
shuffle the value,
actually shuffle it up towards
the root, OK?
Or at log V.
And, the total cost therefore

Korean: 
E log V 입니다. 
어느 것이 더 낫나요? 상황에 따라 다릅니다. 
언제 하나가 더 낫고, 다른 것이 더 낫나요? 
그것이 빽빽한 그래프이면 E는 V^2와 가깝습니다, 배열은 더 낫습니다. 
그러나 그것이 드문 그래프이면,
 E는 V^2 보다 훨씬 더 작습니다, 그리고 이진 힙이 낫습니다. 
그것은 피보나치 힙이라는 데이터 구조의 고안을 동기 부여 시켰습니다. 
피보나치 힙은 CLRS의 20장에서 다루어집니다. 
우리는 내용을 하지는 않지만 
흥미로운 데이터 구조입니다 그것이 분할 상환 데이터 구조이거든요. 
그것은 데이터 구조이고, 

English: 
is?
E log V, good.
Which of these is better?
It depends, good.
When is one better,
and when is the other better?
Yeah, if it's a dense graph,
E is close to V^2,
the array is better.
But if it's a sparse graph,
and E is much smaller than V^2,
then the binary heap is better.
So that motivated the invention
of a data structure,
OK, called a Fibonacci Heap.
So, Fibonacci Heap is covered
in Chapter 20 of CLRS.
We're not going to hold you
responsible for the content,
but it's an interesting data
structure because it's an
amortized data structure.

English: 
And it turns out that it is
data structure,
you can do extract Min in order
log V amortized time.
And remarkably,
you can do decreased key in
order one amortized.
So, when I plug those in,
what do I get over here?
What's that going to be?
Plug that it here.
It's going to be V times log V
plus E: E plus V log V.

Korean: 
여러분은 order log V 
분할 상환 시간에 최소를 추출할 수 있습니다.
그리고 주목할만 하게, 여러분은 오더 1 분할상환에서 감소 키를 합니다. 
제가 이것들을 연결할 때, 
저는 무엇을 얻나요? 
그것은 무엇이 되나요? 그것을 여기서 연결합시다. 
그것은 V 곱하기 log V 더하기 E: E 더하기 V log V 입니다. 

English: 
These are amortized,
so what's this?
Trick question.
It's worst-case.
It's not amortized over here.
These are amortized,
but that's the beauty of
amortization.
I can say it's going to be
worst case: E plus V log V over
here, because when I add up the
amortized cost of my operations,
it's an upper bound on the true
costs.
OK, so that's why I say,
one of the beauties of this
amortized analysis,
and in particular,
being able to assign different
costs to different operations is
I can just add them up and I get
my worst-case costs.
So this is already V log V.
There are a couple other
algorithms just before I let you
go.
Kruskal's Algorithm in the book
uses another amortized data
structure called a disjoint set
data structure,
which also runs in E log V,
that is, this time:
runs in this time,
the same as using a binary

Korean: 
이것들은 분할 상환이고, 이것은 무엇입니까? 
까다로운 질문입니다. 그것은 최악의 케이스입니다. 
그것은 여기서 분할 상환이 아닙니다. 이것들은 분할 상환이지만 
그것은 분할 상환의 미입니다. 
그것은 최악의 케이스가 될 수 있습니다. 
E 더하기 V log V. 제가 제 연산의 분할 상환 비용을 더할 때, 
그것은 옳은 비용에서 상계이기 때문입니다. 
이 분할 상환 분석의 미 중 하나는 
다른 비용을 
다른 연산에 할당 할 수 있는 것입니다 
저는 그것들을 더할 수 있고 제 최악의 케이스 비용을 얻습니다.
이것은 이미 V log V입니다. 제가 여러분에게 
가도록 하기 전에 다른 알고리즘들이 있습니다. 
책에 있는 Kruskal 알고리즘은 분리 집합 데이터 구조라는 
분할 상환 데이터 구조를 사용합니다, 
그것은 또한 E log V에서 돕니다, 
즉, 이 시간에서 돕니다, 이진 힙을 사용하는 것과 같습니다. 

English: 
heap.
So, I'll refer you to the book.
The best algorithm to date with
this problem is done by our own
David Karger on the faculty here
with one of our former
graduates, Phil Kline,
who is now a professor at
Brown, and Robert Tarjan,
who is sort of like the master
of all data structures who was a
professor at Princeton in 1993.
OK, it's a randomized
algorithm, and it gives you
order V plus E expected time.
OK, so that's the best to date.
It's still open as to whether
there is a deterministic,
there is worst-case bound,
whether there is a worst-case
bound that is linear time.
OK, but there is a randomized
to linear time,
and otherwise,
this is essentially the best
bound without additional
assumptions.
OK, very cool stuff.
Next, we're going to see a lot
of these ideas of greedy and

Korean: 
저는 책을 언급할 것입니다. 
956
01:23:00,000 --> 01:23:04,935
이 문제를 위한 가장 좋은 알고리즘은 우
리 학교 졸업생이자 교수인 David Karger, 
브라운 대학 교수인 Phil Kline, 
1993년에 프린스턴 교수였고 
모든 데이터 구조의 마스터인 Robert Tarjan에 의해 이루어졌습니다. 
그것은 랜덤 알고리즘이고, 
오더 V 더하기 E를 줍니다. 그것은 최고입니다.
결정적인 것에 대해여 아직 열려있습니다, 
선형 시간인 최악의 케이스 바운드에 대해서요. 
그러나 선형 시간에 랜덤이고, 
그렇지 않으면, 
이것은 추가 가정 없이 필수적으로 최고의 바운드입니다. 
매우 좋은 것입니다. 
다음으로, 우리는 탐욕과 

Korean: 
동적 프로그래밍의 많은 아이디어를 볼 것입니다.

English: 
dynamic programming in practice.
