
English: 
We're going to talk about
shortest paths,
and we're going to talk about
shortest paths for three
lectures.
So, this is a trilogy.
Today will be Shortest Paths
One.
I've been watching far too many
versions of Star Wars this
weekend.
I saw the musical yesterday,
matinee.
That was an MIT musical.
That was fun,
of all three movies in about
four hours.
That was a bit long and then I
saw the one-man show on Friday.
One-man Star Wars:
the original three movies in
one hour.
That was the opposite of too
long.
Both were fun.
So I get my trilogy fix.
All episodes,
first we're going to start with
The New Hope,
and we're going to talk about

Korean: 
이 강의 한글자막은 www.snow.or.kr 자원활동가들에 의해 작성되었습니다. 
우리는 최단 경로에 대해 이야기할 것입니다. 
강의는 세 강의에 걸친 
3부작입니다. 
오늘은 최단 경로 1입니다. 
저는 이번 주말에 스타워즈의 너무 많은 버전을 보았습니다. 
어제는 뮤지컬 마티니를 보았습니다, 
그것은 MIT 뮤지컬입니다. 
약 4시간 정도되는 재미 있는 영화입니다. 
조금 길고 하나를 금요일에 보았습니다. 
 
한 시간의 오리지널 세 영화입니다. 
그것은 너무 길지 않습니다. 
둘 다 재미있습니다. 저는 제 3부작 강의를 고정시킬 것입니다. 
먼저 우리는 The New Hope에서 시작합니다, 
그리고 최단 경로 문제를 이야기하고 그것의 특정한 문제 중 하나를 풀 것입니다, 

Korean: 
매우 흥미롭습니다.
그리고 우리는 점점 더 일반적인 
버전들을 볼 것입니다. 
최단 경로는 지난 주에 보았던 동적 프로그래밍과 
탐욕 알고리즘의의 응용입니다. 
우리는 그것을 구축하고 중요한 문제를 위한 
흥미로운 알고리즘을 얻을 것입니다, 
그것은 여러분이 그래프위에 있을때 
Alderon에서 Cambridge까지 가능한 빨리 가는 방법에 대한 것입니다.
약간 더 어려운 기하학적인 최단 경로가 있습니다. 
여기서 우리는 그래프에서 최단 경로를 볼 것입니다.  
이제 여러분은 그래프에 무슨 경로가 있는지 압니다.
그러나 빠르게 복습할 것입니다 
우리는 무게 그래프를 볼 것이기 때문입니다. 
우리가 방향 그래프 G와 정점(V),  

English: 
the shortest paths problem and
solve one particular problem of
it, a very interesting version.
And then we're going to look at
increasingly more general
versions as we go on.
Shortest paths are sort of an
application of dynamic
programming, which we saw last
week, and greedy algorithms,
which we also saw last week.
So, were going to build that
and get some pretty interesting
algorithms for an important
problem, which is how to get
from Alderon to,
I don't know,
Cambridge as quickly as
possible, OK,
when you live in a graph.
So, there's geometric shortest
paths which is a little bit
harder.
Here, we're just going to look
at shortest paths in graphs.
Now, hopefully you all know
what a path in a graph is.
But, so, very quick review in
particular because we're going
to be looking at weighted
graphs.
So, the usual setup:

English: 
suppose we have directed graph,
G, have some vertices,
some edges.
We have edge weights,
make it a little more
interesting.
So, this is just a real number
on each edge.
So, edge weights are usually
given by function,
w.
For every edge,
you get a real number.
And then, if we look at the
paths in the graph,
so we're going to use some
simple notation for paths called
a path, p, starts at some
vertex, and it goes to some
other vertex,
and so on.
Say the last vertex is v_k,
and each of these should be a

Korean: 
모서리(E)를 가진다고 가정하세요.
우리는 모서리 무게를 가지고 
그것을 더 흥미롭게 만듭니다. 
이것은 각 모서리의 실제 수입니다. 
모서리 무게는 보통 함수에 의해 w로 주어집니다. 
모든 모서리는 
실제 수입니다.
여러분이 그래프에서 경로를 보면,  
우리는 p라는 경로를 위한 간단한 개념을 사용할 것입니다.
그것은 어떤 점에서 시작해서 
다른 정점으로 갑니다. 
마지막 정점을 v_k라고 합시다. 이것들 각각은 방향 그래프에서 방향 모서리입니다. 

English: 
directed edge in the digraph.
So, this is a directed path.
It has to respect edges in
here.
And, we'll say that the weight
of such a path is just the sum
of the weights of the edges
along the path.
And, we'll call that w(p).
This is sum,
i equals one to k minus one of
w(v_i, v_(i+1)) plus one.
OK, so just to rub it in,
and in particular,
how general this can be,
we have some path,
it starts at some vertex,
there's some edge weights along
the way.
This is some arbitrary path in
the graph, in some hypothetical
graph.

Korean: 
이것은 방향 경로입니다. 
그것은 여기서 모서리를 준수합니다. 
그리고 우리는 경로의 무게가 경로를 따른 모서리들의 
무게의 합이라고 말할 것입니다. 
그것은 w(p)입니다. 
이것은 i가 1에서 k-1일때, w(v_i, v_(i+1))의 합입니다.
특히, 이것을 일반적으로 하는 방법은, 
우리는 경로를 가지고, 그것은 어떤 정점에서 시작하고, 
길을 따른 모서리 무게가 있습니다.
이것은 가상의 그래프에서 
임의의 경로입니다. 

Korean: 
이것은 주로 모서리 무게 중 몇몇이 음수일 수 있다는 것을 지적합니다. 
그것들은 0일 수도 있습니다. 
이 합은 여기서 - 2입니다. 이 경로의 무게는 - 2입니다. 
아마 
그래프는 이 보다 더 클 것입니다. 
이것은 그래프에서 하나의 경로입니다. 
우리는 보통 정점을 반복하지 않는 간단한 경로를 생각합니다. 
때때로 우리는 그것을 허용하기도 합니다. 
우리가 신경 쓰는 것은 최단 경로입니다. 
이것은 유일하지 않지만 
우리는 그것을 보통 최단 경로라고 합니다.
우리는 A에서 B까지의 최단 경로를 원합니다. 
우리는 정점을 u와 v라고 합니다. 
그리고 우리는 이것이 가능한 최소 무게의 경로이길 원합니다, 
u에서 시작해서 v로 갑니다. 
그것은 우리가 찾는 것입니다. 
일반적으로 여러분에게 정점 u와 v를 주고, 

English: 
OK, this is mainly to point out
that some of the edge weights
could be negative.
Some of them could be zero.
This sum here is minus two.
So, the weight of this path is
minus two.
And, presumably,
the graph is much bigger than
this.
This is just one path in the
graph.
We're usually thinking about
simple paths that can't repeat a
vertex.
But, sometimes we allow that.
And then, what we care about is
the shortest path,
or a shortest path.
Again, this may not be unique,
but we'll still usually call it
the shortest path.
So, we want the shortest path
from some A to some B.
Or, we'll call the vertices u
and v.
And we want this to be some
path of minimum possible weight,
subject to starting at u,
and going to v.
OK, so that's what we're
looking for.
In general, give you a vertex,
u, give you a vertex,

English: 
v, find a shortest path as
quickly as possible.
What's a good algorithm for
that?
That's the topic for the next
three lectures.
We'll usually think about a
slightly simpler problem,
which is just computing the
weight of that path,
which is essentially computing
the distance from A to B.
So, we'll call this the
shortest path weight from u to
v.
And, we'll denote it by delta
of (u,v), delta .
So, I mean, it's the weight of
the shortest path,
or a weight of every shortest
path.
Or, in other words,
it's the Min over the weight of
each path from u to v.
So, p here is a path.
OK, so you just consider,

Korean: 
가능한 빨리 최단 경로를 찾습니다. 
그것을 위한 좋은 알고리즘은 무엇입니까? 
그것은 다음 세 강의를 위한 주제입니다. 
우리는 보통 약간 더 간단한 문제에 대해 생각할 것입니다, 
그것은 경로의 무게를 계산하는 것이고, 
특히 A에서 B까지의 거리를 계산하는 것입니다.
우리는 이것을 u에서 v까지의 최단 경로 무게라고 합니다.
우리는 그것을 δ(u,v)로 나타냅니다. 
그것은 최단 경로의 
무게입니다. 
다시 말해, 
그것은 u에서 v까지의 각 경로의 무게중 최소값입니다. 
여기서 p는 경로(path)입니다. 

English: 
there could be a lot of
different paths.
There could,
in principle,
be infinitely many,
if you're allowed to repeat
vertices.
You look at all those paths
hypothetically.
You take the minimum weight.
Question?
Good.
My next question was going to
be, when do shortest paths not
exist?
And you've hit upon one
version, which is when you have
negative edge weights.
So, in principle,
when you have negative edge
weights, some shortest paths may
not exist in the sense that
there is no shortest paths.
There are no shortest paths.
There is no shortest path from
u to v.
OK, in particular,
if I have two vertices,

Korean: 
다른 경로들이 있을 수도 있습니다. 
원칙적으로 무한히 많은 것이 있을 수 있습니다 
여러분이 점점이 반복되도록 허용되었다면요
여러분은 모든 경로를 가상적으로 봅니다. 
여러분은 최소 무게를 취합니다. 
질문 있나요? 좋습니다. 
제 다음 질문은, 언제 최단 경로가 존재하지 않나요? 
여러분은 하나의 버전을 떠올립니다, 
그것을 여러분이 음의 모서리 무게를 가질 때 입니다.
원칙적으로, 여러분이 음의 모서리 무게를 가질 때, 
어떤 최단 경로는 존재하지 않을 수 있습니다. 
최단 경로가 없습니다. 
특히, 제가 두 정점 u와 v를 가지면, 

English: 
u and v, and I want the
shortest path between them,
and I have negative edge
weights, well,
this is fine.
I mean, I can still compute the
weight of a path that has
negative weights.
But when specifically won't I
have a single shortest path from
u to v?
So, go ahead.
Good.
So, if I can find the cycle
somewhere along here whose total
weight, say, the sum of all the
weights of these images is
negative, then I get there,
I go around as many times as I
want.
I keep decreasing the weight
because the weight is negative.
I decrease it by some fixed
amount, and then I can go to v.
So, as long as there is a
negative weights cycle reachable
from u that can also reach v,
then there's no shortest path

Korean: 
저는 그들 간의 최단 경로를 원합니다, 
그리고 음의 모서리 무게를 가집니다. 
저는 여전히 음의 무게를 가지는 
경로의 무게를 계산할 수 있습니다. 
그러나 언제 u에서 v까지의 단일 최단 경로를 가질 수 없습니까? 
계속 하세요. 좋아요.
제가 이것을 따라 원을 찾을 수 있으면, 
이 이미지들의 모든 무게의 
합은 음수입니다, 
그리고 저는 원하는 한 많이 돕니다. 
저는 무게를 계속 감소시킵니다. 무게가 음이기 때문입니다
저는 그것을 고정된 양만큼 감소시키고 v로 갑니다. 
u에서 도달 가능한 음의 무게 사이클이 있는 한 그것은 v에 도달할 수 있고, 
최단 경로가 없습니다. 

Korean: 
제가 어떤 특정 경로를 취하면, 
저는 그것을 계속 하면서 더 짧게 만들 수 있으니까요.
어떤 면에서, 이것은 최소가 아닙니다. 
그것은 무한대입니다. 
그러나 δ(u,v)는 이 케이스에서 
마이너스 무한대입니다. 
u에서 v까지의 음의 무게 사이클이 있습니다. 
그것은 우리가 걱정 하는 하나의 케이스입니다. 
그러나 음의 무게 사이클이 있는 한 
δ(u,v)는 마이너스 무한대 보다 더 클 것입니다. 
여러분이 음의 무게를 가지더라도 어떤 한정된 값에 의해 낮게 바운드됩니다, 
그러나 음의 무게는 아닙니다 
예를 들어 여러분의 그래프에 어떤 사이클이 있을 수 있습니다.
그것은 여전히 흥미롭습니다. 
여러분이 A에서 B까지 음의 무한대 시간에서 얻을 수 있는 것은 유용합니다. 
그것은 시간 여행입니다, 
시간과 일치하는 무게가 있으면요. 

English: 
because if I take any particular
path, I can make it shorter by
going around a couple more
times.
So, in some sense,
this is not really a minimum.
It's more like an infimum for
those who like to get fancy
about such things.
But we'll just say that delta
of (u,v) is minus infinity in
this case.
There's a negative weights
cycle from u to v.
So, that's one case we have to
worry about in some sense.
But, as long as there are no
negative weight cycles,
delta of (u,v) will be
something bigger than minus
infinity, bounded below by some
finite value even if you could
have negative weights,
but still no negative weights
cycle for example,
there might not be any cycles
in your graph.
So that's still interesting.
And, I guess it's useful to
note that you can get from A to
B in negative infinite time.
It's time travel,
if the weights happen that
correspond to time.

Korean: 
그러나 언제 최단 경로가 존재하지 않나요? 
이것은 하나의 케이스이지만 다른 것은 더 간단한 것이 있습니다..  
그것은 연결되지 않은 경우말이죠.
u에서 v까지의 경로가 없을 수 있습니다. 
이 경로는 비어있을 수 있습니다. u에서 v까지의 경로가 없을 수 있습니다. 
우리는 무엇이 일어나는지 정의해야 합니다, 
u에서 v까지의 경로가 없으면, 그것은 무한대입니다.
이 예외적인 케이스 더하기 
무한대 마이너스 무한대가 있습니다, 
그것은 매우 직관적입니다 왜냐하면 경로가 없으면 u에서 v까지 얻는데 오랜 시간이 걸리기 때문입니다. 
여러분은 여기서부터 얻을 수 없습니다.
그러나 그것은 정의입니다. 대부분 
이것은 물론 우리가 신경 쓰는 케이스입니다. 
보통 이것은 유한 집합입니다. 그래서 그것은 정의입니다. 
우리는 이 경로를 찾는 

English: 
But when else might shortest
paths not exist?
So, this is one case,
but there's another,
simpler case.
It's not connected.
There might not be any path
from u to v.
This path might be empty.
There may be no path from u to
v.
Here we have to define what
happens, and here,
we'll say it's infinity if
there's no path from u to v.
So, there are these exceptional
cases plus infinity and minus
infinity, which are pretty
intuitive because it takes a
really long time to get from u
to v if there's no path there.
You can't get there from here.
OK, but that's the definition.
Most of the time,
this is the case we care about,
of course.
Usually this is a finite set.
OK, good, so that's the
definition.
We're going to get a few basic

Korean: 
좋은 알고리즘을 얻도록 하는 최단 경로에 대한 
기본 구조적인 속성들을 얻을 것입니다.
특히,  
우리는 동적 프로그래밍의 아이디어를 사용하고 싶습니다.
제가 최단 경로를 풀기 위해 동적 프로그래밍을 사용하길 원하면, 
저는 무엇을 세워야 하나요? 
제가 확인해야 하는 첫 번째 것은 무엇인가요? 
여러분은 모두 지금까지 동적 프로그래밍을 구현했습니다, 
그래서 그것을 완벽히 해야 하고, 
몇 주 간 했습니다. 
동적 프로그래밍은 여러분이 하는 것입니다. 
저는 매년 전년보다  
더 잘 이해한다고 생각합니다.
여러분이 이 수업에서 동적 프로그래밍을 배울 때  
여러분이 확인해야 하는 좋은 핵심 
속성이 있습니다.
최적 서브 구조입니다, 좋아요. 
이것은 여러분이 마음에 새겨야 하는 구절입니다. 

English: 
structural properties about
shortest paths that will allow
us to obtain good algorithms
finding these paths when they
exist.
And, in particular,
we want to use ideas from
dynamic programming.
So, if I want to use dynamic
programming to solve shortest
paths, what do I need to
establish?
What's the first thing I should
check?
You've all implemented dynamic
programming by now,
so should make complete sense
hopefully, at least more sense
than it did a couple of weeks
ago, last week,
when we learned it.
Dynamic programming is
something that grows on you.
Every year I think I understand
it better than the previous
year.
But, in particular,
when you learned dynamic
programming in this class,
there is this nice key property
that you should check.
Yeah?
Optimal substructure:
good.
This is the phrase you should
keep in mind.

English: 
It's not really enough for
dynamic programming to be useful
in an efficient way,
but it at least tells you that
you should be able to try to
apply it.
That's a pretty weak statement,
but it's something that you
should check.
It's definitely pretty much a
necessary condition for dynamic
programming to make sense.
And so, optimal some structure
here means that if I take some
shortest path,
and I look at a subpath of that
shortest path,
I claimed that it too is a
shortest path,
OK, with its respective
endpoints; obviously not between
the same endpoints.
But if I have some shortest
path between two endpoints,
I take any subpath and that's
also the shortest path.
This is one version of optimal
substructure.
This one turns out to be true
for this setup.
And, how should I prove an
optimal substructure property?

Korean: 
그것은 동적 프로그래밍이 효율적인 방법으로 유용해 지기에 충분하지 않지만 
적어도 여러분이 그것을 적용할 수 있어야 
한다고 말해줍니다.
매우 약한 문장이지만, 여러분은 확인해야 합니다. 
그것은 확실히 
필요한 조건입니다. 
최적 구조는 제가 최단 경로를 취하면, 
그것의 서브 경로를 본다는 것입니다, 
그것은 개별 종점을 가진 
최단 경로입니다. 
같은 종점이 아닙니다.
제가 두 종점 간의 최단 경로를 가지면, 
저는 서브 경로를 가지고 그것은 또한 최단 경로입니다. 
이것은 최적 서브 구조의 하나의 버전입니다. 
이것은 이 설정을 위해 옳습니다. 
저는 최적 서브 구조 속성을 어떻게 증명할 수 있나요? 

English: 
Cut and paste.
Yep, that works here too.
I mean, this isn't always true.
But it's a good technique here.
So, we're going to think about,
and I'll do essentially a proof
by picture here.
So, suppose you have some
subpath of some shortest path.
So, let's say the subpath is x
to y.
And, the path goes from u to v.
So, we assume that (u,v) is a
shortest path.
We want to prove that (x,y) is
a shortest path.
Well, suppose (x,y) isn't a
shortest path.
Then there is some shorter path
that goes from x to y.
But, if you have some shorter
path from x to y than this one.
Then I should just erase this
part of the shortest path from u
to v, and replace it with this
shorter one.
So, this is some hypothetical
shorter path.
So, suppose this existed.
If that existed,

Korean: 
복사와 붙여넣기 입니다. 그것은 여기서도 동작합니다. 
이것은 항상 옳지 않지만 여기서 좋은 기술입니다. 
우리는 생각할 것이고 필수적으로 그림에 의해 증명할 것입니다. 
여러분이 최단 경로의 서브 경로를 가진다고 가정해보세요. 
서브 경로가 x에서 y라고 합시다. 
경로는 u에서 v까지 입니다. 
우리는 (u,v)가 최단 경로라고 가정합니다.
(x,y)가 최단 경로임을 증명하고 싶습니다. 
(x,y)가 최단 경로가 아니라고 가정해보세요. 
그러면 x에 서 y까지의 더 짧은 경로가 있습니다. 
여러분이 이것보다 더 짧은 경로를 가진다면요. 
그리고 저는 u에서 v까지의 최단 경로의 이 부분을 지우고 
그것을 이 더 짧은 것으로 교체합니다. 
이것은 가상의 더 짧은 경로입니다. 
이것이 존재한다고 가정하세요. 

English: 
then I should just cut the old
path from x to y,
and paste in this new one from
x to y.
It's strictly shorter.
Therefore, I get a strictly
shorter path from u to v.
But I assumed u to v was a
shortest path:
contradiction.
OK, so there is no shorter
path.
And that proves the lemma that
we have this:
subpaths of shortest paths are
shortest paths.
OK, this should now be a pretty
familiar proof technique.
But, there is yet another
instance of cut and paste.
OK, so that's a good sign for
computing shortest paths.
I mean, in terms of dynamic
programming, we won't look
directly at dynamic programming
here because we are going to aim
for greedy, which is even
stronger.
But, next Monday we'll see some
dynamic programming approaches.
Intuitively,
there are some pretty natural
sub-problems here.
I mean, going from u to v,
if I want to find what is the
shortest path from u to v,
well, that's a particular
problem.
Maybe it involves computing
shortest paths from u to some

Korean: 
그것이 존재하면, 
저는 복사하고 새로운 것을 붙여넣습니다.
그것은 엄격히 더 짧습니다. 그러므로, 저는 u에서 v까지 더 짧은 경로를 얻습니다. 
그러나 저는 u에서 v까지가 최단 경로라고 가정했습니다 
모순입니다. 
그러므로 더 짧은 경로는 없습니다. 
그것은 최단 경로의 서브 경로가 최단 경로라는 
부명제를 증명합니다. 
이것은 이제 매우 친숙한 증명 기술입니다. 
그러나 아직 복사 붙여넣기가 있습니다. 
그것은 최단 경로를 계산하기 위한 좋은 기호입니다. 
동적 프로그래밍의 관점에서, 우리는 직접적으로 
동적 프로그래밍을 보지 않습니다 
우리는 더 강력한 탐욕을 목표로 하기 때문입니다. 
그러나 다음 월요일에 우리는 동적 프로그래밍 접근을 볼 것입니다. 
직관적으로, 매우 자연스러운 서브 문제들이 있습니다. 
제가 u에서 v까지의 
최단 경로를 찾고 싶으면, 
그것은 특정한 문제입니다.
아마 그것은 u에서 어떤 점 x, 

English: 
intermediate point,
x, and then from x to u,
something like that.
That feels good.
That's like,
quadratically,
many subproblems.
And, V^2 subproblems,
it sounds like that would lead
to a dynamic program.
You can make it work out;
it's just a little bit trickier
than that.
We'll see that next Monday.
But thinking about this
intermediate point we get
something called the triangle
inequality.
So, you've probably heard some
form of the triangle inequality
before.
It holds in all sorts of
geometric spaces,
but it also holds for shortest
paths, which is slightly less
obvious, or more obvious,
I guess, depending on your
inclination.
So, if you have any triple of
vertices, the shortest path from

Korean: 
x에서 u의 최단 경로를 계산하는 것을 포함합니다.
좋습니다. 
2차식으로 많은 서브 문제와 같습니다. 
그것은 동적 프로그램으로 이끄는  
것 같이 들립니다.
여러분은 그것이 동작하도록 할 수 잇습니다, 그것은 더 까다롭습니다. 
우리는 다음주 월요일에 볼 것입니다. 
그러나 중간 점에 대해 생각하면서 우리는 
삼각형 부등식을 얻습니다. 
여러분은 아마 삼각형 부등식에 대해 들어보았을 겁니다. 
그것은 모든 기하학 공간에 있지만,  
또한 최단 경로를 위해 있습니다,
그것은 약간 덜 혹은 더 명확합니다, 
여러분의 성향에 따라서요
여러분이 정점의 트리플을 얻으면, 

English: 
u to v is, at most,
the shortest path from u to x
plus the shortest path from x to
v.
Of course, here I need a
shortest path weight from u to
x, and shortest path weight from
x to v.
So, this should be pretty
natural just from the statement,
even more natural if you draw
the picture.
So, we have some vertex,
u.
I'm using wiggly lines to
denote potentially long paths as
opposed to edges.
We have some intermediate
point, x, and we have some
target, v, and we are
considering these three shortest
paths.
This is the shortest path from
u to v, or this is its weights.
This is the shortest path from
u to x.
And here's its weight,
and the shortest path from x to
v.
And here's its weight.
And, the point is,
this should be the shortest
path or a shortest path from u
to v.
And, in particular,
one such path is you go from u

Korean: 
u에서 v까지의 최단경로는, 최대 u에서 x까지의 최단경로 
더하기 x에서 v까지의 최단 경로입니다.
물론 저는 u에서 v까지의 최단경로, 
x에서 v까지의 최단 경로가 필요합니다.
이것은 매우 자연스럽습니다, 
여러분이 그림을 그리면 더 자연스럽습니다. 
우리는 정점 u를 가집니다.
저는 정점과 반대되는 잠재적으로 긴 경로를 나타내는 선을 사용합니다. 
우리는 중간 점 x, 
목표 v를 가지고 
이 세 최단 경로를 고려할 것입니다.
이것은 u에서 v까지의 최단 경로 또는 그것의 무게입니다. 
이것은 u에서 x까지의 최단 경로입니다.  
여기 그것의 무게가 있습니다,
그리고 x에서 v까지의 최단 경로가 있습니다. 여기 그것의 무게가 있습니다. 
이것은 u에서 v까지의  
최단 경로이어야 합니다.
특히, 하나의 경로는 u에서 x까지 가고, 

English: 
to x, and then you go from x to
v.
So, I mean, this sum is just
measuring the length of this
particular path.
Take the shortest path here;
take the shortest path here.
And, this is supposed to be the
Min over all paths.
So, certainly this is,
at most, this particular path,
the sum of these two values,
OK, another proof by picture.
Clear?
OK, this stuff is easy.
I assume we'll get into some
more set exciting algorithms in
particular, which is always more
exciting.
Today, we're going to look at a
particular version of shortest
paths called,
or the shortest paths problem
called the single source
shortest path problem.
OK, it's a little bit more
general than go from A to B.
The problem is,

Korean: 
여러분은 x에서 v까지 갑니다. 
이 합은 이 특정 경로의 길이를 측정하는 것입니다. 
여기서 최단 경로를 가집니다.  
그리고 이것은 최소값 나누기 모든 경로이어야 합니다.
확실히 
이것은 이 특정한 경로 입니다. 
알겠나요? 
이것은 매우 쉽습니다. 우리는 
더 흥미로운 알고리즘으로 들어갈 것입니다.
오늘 우리는  
단일 소스 최단경로 문제라는 
최단 경로의 특별한 버전을 볼 것입니다.
그것은 A에서 B까지 가는 것 보다 
더 일반적입니다. 

English: 
you're given a source vertex,
and you want to know how to get
from that source vertex to
everywhere else.
So, we'll call this source
vertex s.
And from that source,
we want to find,
let's say, the shortest path
weights from s to everyone.
In particular,
we'd also like to know the
shortest paths,
but that isn't too much harder.
So, that's delta of s,
v for all vertices,
v.
OK, so this is actually a
little bit harder than the
problem we started with a
getting from Alderon to
Cambridge.
Now, we want to get from
Alderon to the entire universe.
OK, it turns out,
this is one of the weird things
about shortest paths,
according to the
state-of-the-art we know today,
it seems like the following

Korean: 
여러분은 소스 점이 주어지고 소스 점에서 
다른 모든 곳까지 가는 방법을 알고 싶습니다. 
우리는 이 소스 점을 s라고 할 것입니다
그 소스에서 우리는 s로부터 모든 곳으로의 
최단 경로 무게를 찾고 싶습니다.
특히, 우리는 최단 경로를 알고 싶지만, 
그것은 어렵지 않습니다
그것은 δ(s)입니다. 
그래서 이것은 우리가 
Alderon 에서 Cambridge로 시작했던 문제 보다 
더 어렵습니다. 
이제 우리는 Alderon로부터 전체의 곳으로를 얻고 싶습니다. 
이것은 최단 경로에 대한 
이상한 것 중 하나입니다, 
그것은 다음 문장이 항상 

English: 
statement will remain true for
all time.
But we don't know.
The best algorithms for solving
the A to B problem,
given s, given t,
go from s to t,
is no easier than this problem.
It's the best ways we know how
to solve going from A to B is to
solve how to go from A to
everywhere else.
So, we sort of can't help
ourselves, but to solve this
problem it turns out.
Today, we're going to look at a
further restriction on this
problem because this is a bit
tricky.
Will solve it next class.
But, today we're going to get
rid of the negative weight cycle
issue by forbidding negative
weights.
So, we're going to assume that
all of the edge weights are
nonnegative, so,
for all vertices,
u and v.
So, in particular,
shortest paths exist,
provided paths exist.

Korean: 
옳은 것 같아 보입니다
그러나 우리는 모릅니다. 
A에서 B까지의 문제를 푸는 최고의 알고리즘은 
이 문제보다 더 쉽지 않습니다
우리가 아는 최고의 방법은 A에서 
다른 모든 곳까지로 가는 방법을 푸는 것입니다. 
우리는 스스로 도울 수 없지만 이 문제를 풀어야 합니다. 
우리는 이 문제에 대한 
약간의 제약을 볼 것입니다.
그리고 다음 시간에 풀 것입니다. 
오늘 우리는 음의 무게를 금지함으로써 음의 무게 사이클 
이슈를 제거할 것입니다.
그래서 우리는 모든 모서리 무게가  
음이 아니라고 가정할 것입니다.
특히 
최단 경로는 경로가 존재하면 존재합니다.

Korean: 
우리는 이 마이너스 무한대에 대해 걱정할 필요가 없습니다. 
δ(u,v)는 마이너스 무한대 보다 항상 더 큽니다. 
그것은 경로가 없으면 플러스 무한대이지만, 
이것은 더 쉬울 것입니다. 
오늘 우리가 다룰 알고리즘은 이 속성을 요구합니다. 
여러분은 이것 없이 할 수 없습니다.
다음 시간에, 우리는 이것 없이 할 수 없습니다. 
우리가 오늘 알고리즘을 위해 사용할 주요 생각은 
탐욕입니다, 그것은 일반적으로 동적 프로그래밍  
보다 더 빨라야 합니다.
까다로운 부분은 탐욕 알고리즘이 실제로 

English: 
And, we don't have to worry
about these minus infinities.
Delta of (u,v) is always bigger
than minus infinity.
It still might be plus infinity
if there is no path,
but this will make life a lot
easier.
And the algorithm we'll cover
today really requires this
property.
You can't get away without it.
Next class, we'll get away
without it with a fancier and
slower algorithm.
So, as I hinted at,
the main idea we're going to
use for the algorithm today is
greedy, which should be faster
than dynamic programming
generally.
And, the tricky part will be

English: 
proving that the greedy
algorithm actually works.
So, I think there's pretty much
only one natural way to go
about, well, there's one way
that works to go about greedy,
let's say.
This may be not the obvious
one.
So, let me give you a little
bit of setup.
The invariant we are going to
maintain is that at all times,
we have estimates on the
distances from the source to
every vertex.
When I say distance,
I mean shortest path weight.
I'm going to use weight and
distance interchangeably here
for more intuition.
And, in particular,
I want to maintain the set of
vertices where those estimates
are actually the right answer.

Korean: 
작동하는 것을 증명하는 것입니다. 
더 자연스러운 방법이 있고, 
탐욕에 대해 작동하는 방법이 있습니다. 
이것은 명백한 것이 아닙니다. 
여러분에게 약간의 설정을 주겠습니다. 
우리가 유지해야 하는 것은 항상 소스에서 
모든 정점까지의 거리를 
측정해야 합니다.
거리는 최단 경로 무게입니다. 
저는 무게와 거리를 교환해서 쓸 것입니다. 
특히 
저는 정점의 집합을 
유지하고 싶습니다. 

Korean: 
이것은 작은 s입니다. 이것은 큰 S입니다. 
큰 S는 제가 담을 아는 곳의 모든 정점의 집합일 것입니다. 
작은 s에서 큰 S까지
최단 경로 거리는 무엇입니까? 
제가 아는 거리는 무엇입니까? 
네?
저는 s에서 s의 최단 경로 거리를 압니다. 
모든 무게가 음이 아니라고 가정하면 저는 아무 것도 하지 않는 것 보다 
더 빠른 s에서 s를 얻을 수 없기 때문입니다. 
제가 음의 무게 사이클을 가지면 아마 
s에서 s의 거리는 마이너스 무한대입니다.
그러나 저는 음의 무게를 얻을 수 없어서 
s에서 s를 얻을 수 있는 방법이 없습니다. 
더 긴 경로는 0의 비용을 가지지만 

English: 
OK, this is little s.
This is big S.
So, the big S will be the set
of all vertices where I know the
answer.
What is the shortest path
distance from little S to that
vertex in big S?
So, for starters,
which distance do I know?
Sorry?
s.
I know the shortest path
distance from s to s because if
I assume that all of my weights
are nonnegative,
I really can't get from s to s
any faster than not doing
anything.
OK, if I had a negative weight
cycle, maybe the distance from s
to s is minus infinity.
OK, but I can't have negative
weights so there's no way I can
get from s to s any faster than
zero time.
There might be a longer path
that still has zero cost,

English: 
but it can't be any better than
zero.
So, in particular,
I know that.
So, initially,
S is certainly an s.
OK, and the idea is we're going
to accumulate more and more
vertices that we know.
So, at some point we know the
distances from some of the
vertices.
So, we have some cloud here.
This is S, and this is
everything else.
This is the graph,
G.
This is the subset of the
vertices.
And, there's some edges that go
out from there.
And, so we have estimates on
how to get to these vertices.
Some of them,
we may not have even seen yet.
They may not be connected to
this portion of S.
I mean: not directly.
They might be connected by some
longer path.
They might be in a completely
different connected component.
We don't know yet.
Some of them,
we have estimates for because
we've sort of seen how to get
there from S.
And the idea is,
among all of these nodes where
we have estimates,

Korean: 
그것은 0 보다 나을 수 없습니다.
특히, 저는 그것을 압니다. 
초기에 S는 확실히 s입니다. 
우리는 더 많은 정점을 축적할 것입니다. 
어떤 점에서 우리는 
거리를 압니다. 
우리는 여기서 구름을 갖습니다. 
이것은 S이고, 이것은 다른 모든 것입니다. 이것은 그래프 G 입니다. 
이것은 정점의 서브 집합입니다. 
저기서부터 나오는 정점들이 있습니다.
우리는 이 정점들을 얻는 방법을 측정합니다.  
우리는 그것들 중 몇 가지를 아직 보지도 못했습니다.
그것들은 S의 이 부분과 연결되지 않습니다. 
직접적으로요. 
그것들은 더 긴 경로와 연결 될 수 있습니다. 
그것들은 완전히 다른 것과 연결될 수 있습니다. 
우리는 아직 모릅니다.
우리는 S로부터 얻는 방법을 보았기 때문입니다. 
그래서
모든 노드들 중에 그것은 여기서 정점이고, 

English: 
and on to get from little S,
which is some vertex in here,
to these vertices,
we're going to take the one for
which the estimate is smallest.
That's the greedy choice.
And, we're just going to add
that vertex to S.
So, S grows one vertex per
step.
Each step, we're going to add
to S, the vertex.
Of course, again,
this is not a unique,
it's a vertex,
v, in V minus S.
So, it's something we haven't
yet computed yet whose estimated
distance from S is minimum.
So, we look at all the vertices
we haven't yet added to S.
Just take the one where we have

Korean: 
우리는 가장 작은 것을 
고를 것입니다.
그것은 탐욕 선택입니다. 
우리는 그 정점을 S에 더할 것입니다. 
그래서 S는 단계 당 하나의 정점으로 커집니다. 
각 단계에서, 우리는 S에 정점을 더합니다.
물론 이것은 유일하지 않습니다, 
그것은 정점입니다
그것은 우리가 아직 계산하지 않은 것입니다, 그것의 거리는 최소입니다. 
우리는 아직 S에 더하지 않은 모든 정점을 봅니다. 
우리가 가장 작은 거리로 측정한 것을 고릅니다.

Korean: 
직관은 그것이 좋은 선택이어야 한다는 것입니다. 
제가 제가 본 모든 것들 중에 
작은 s를 고르면, 
저는 좋은 경로인 것을 사야 합니다. 
아마 
제가 보지 않았던 경로가 있을 겁니다. 
아마 여러분은 여기로 가서 다른 경로를 
가져야 합니다. 
저는 그것이 최단 경로라고 말하지 않습니다 
다른 길들이 있기 때문입니다. 
제가 무엇을 S에 더하자마자, 
저는 그 정점을 위한 문제를 풀었다고 선언합니다. 
저는 나중에 제 답을 바꿀 수 없습니다.
측정은 그것들이 S에 더해질 때까지 바뀔 수 있습니다
저는 이 정점을 S에 더하길 원치 않습니다 저는 이 경로를 고려하지 않았기 때문입니다. 
모든 무게가 음이 아니면, 
저는 최소 측정을 가지는 
정점을 가집니다. 
이것은 최단 경로일 수 없습니다
S로부터 그 정점까지의 거리가 S에서 

English: 
the estimated smallest distance.
The intuition is that that
should be a good choice.
So, if I pick the one that's
closest to little s among all
the ones that I've seen,
among all the paths that I've
seen, I sort of have to buy into
that those are good paths.
But, I mean,
maybe there's some path I
didn't see.
Maybe you go out to here and
then you take some other path to
some vertex, which we've already
seen.
OK, the worry is,
well, I'd better not say that
that's the shortest path because
there may have been some other
way to get there.
Right, as soon as I add
something to S,
I declare I've solved the
problem for that vertex.
I can't change my answer later.
OK, the estimates can change
until they get added to S.
So, I don't want to add this
vertex to S because I haven't
considered this path.
Well, if all my weights are
nonnegative, and I take the
vertex here that has the
shortest estimate from S,
so let's suppose this one is
the shortest one,
then this can't be a shorter
path because the distance
estimate, at least,

English: 
from S to that vertex is larger
from S to that vertex.
So, no way can I make the path
longer and decrease the
distance.
That's the intuition.
OK, it's a little bit fuzzy
here because I don't have any
induction hypotheses set up,
and it's going to be a lot more
work to prove that.
But that's the intuition why
this is the right thing to do.
OK, you have to prove something
about the distance estimates for
that to be a proof.
But, intuitively,
it feels good.
It was a good starting point.
OK, and then presumably we have
to maintain these distance
estimates.
So, the heart of the algorithm
is updating distance estimates,
I mean, choosing the best
vertex to add to S,
that's one step.
Then, updating the distance
estimates is sort of where the
work is.
And, it turns out we'll only
need to update distance
estimates of some of the
vertices, the ones that are
adjacent to v.
v was the vertex we just added
to S.
So, once we add somebody to S,

Korean: 
그 정점까지 보다 더 크기 때문입니다.
제가 더 길게 하고 거리를 줄일 수 있는 방법이 없습니다. 
그것이 직관입니다. 
그것은 약간 혼란스럽습니다 제가 어떤 귀납법 가설을 설정하지 않았기 때문입니다, 
그리고 그것은 증명할 것이 더 많습니다. 
그러나 그것은 이것이 옳은 것인 직관입니다. 
여러분은 그것을 위한 거리 측정에 
대한 것을 증명해야 합니다
그러나 직관적으로, 그것은 좋습니다. 
그것은 좋은 출발점입니다. 
그리고 우리는 이 거리 측정을 유지해야 합니다. 
알고리즘의 핵심은 거리 측정을 
업데이트 하는 것입니다. 그
것이 하나의 단계입니다. 
거리 측정을 업데이트 하는 것은 작동하는 곳입니다. 
우리는 정점의 거리 측정을 업데이트할 
필요가 있습니다. 그 정점은 v와 인접합니다.
V는 우리가 S에 더하는 정점입니다. 
우리가 한번 더하면, 

Korean: 
S를 약간 증가시킵니다, 
그리고 S로부터 그 정점까지 가는 모든 새 모서리를 봅니다.
우리는 무엇을 업데이트 합니다. 그것이 생각입니다
그것은 우리가 탐욕을 사용하는 방법을 위한 생각입니다.  
이제 저는 여러분에게 알고리즘을 줄 것입니다.
그것은 Dijkstra 알고리즘입니다. 
Dijkstra는 최근 유명한 
네덜란드 컴퓨터 과학자입니다. 

English: 
so we grow S by a little bit,
then we look at all the new
edges that go out of S from that
vertex.
We update something.
That's the idea.
So, that's the idea for how
we're going to use greedy.
Now I'll give you the
algorithm.
So, this is called Dijkstra's
algorithm.
Dijkstra is a famous,
recently late,
if that makes sense,
computer scientist from the

Korean: 
이것은 그의 가장 유명한 알고리즘입니다. 
알고리즘의 시작은 
초기화입니다, 흥미롭지 않습니다. 
그러나 여러분에게 변수가 의미하는 것을 말해주겠습니다.
D는 배열이고 
x의 d는 S에서 x까지 
거리 측정입니다
특히 우리가 x를 더할 때 . 

English: 
Netherlands.
And, this is probably the
algorithm he is most famous for.
So, the beginning of the
algorithm is just some
initialization,
not too exciting.
OK, but let me tell you what
some of the variables mean.
OK, so d is some array indexed
by vertices, and the idea is
that d of x is the distance
estimate for x,
so, from S to x.
so in particular,
it's going to equal the real

Korean: 
그것은 S에서 x까지 최단 경로 무게와 같습니다
그래서
이것은 알고리즘의 출력입니다.  
질문 있나요?
아니면 그냥 스트레칭 하는건가요? 
X의 d에서, 그것이 출력입니다.
모든 정점에 대하여, 
그것은 우리에게 S에서 그 정점까지의 최단 경로 무게를 줍니다. 
경로를 따라, 
그것은 S에서 그 정점까지의 측정 거리입니다. 
우리는 그것을 향상시킬 것입니다. 
이것은 무한대입니다.
초기에 우리는 S에서 S에서 거리가 0이라는 것을 압니다. 
우리는 그것을 우리의 측정으로 설정할 것입니다. 
그것은 정확할 것입니다. 
우리가 하는 모든 것은 무한대로 설정됩니다 우리가 연결되지 
않을 수 있기 때문입니다. 처음에, 
w우리는 많이 모릅니다. S는 무한대일 것입니다. 
즉시 
우리는 작은 s를 큰 S에 더할 것입니다. 
그리고 여기서 흥미로운 부분은 
Q가 그래프에서 모든 정점으로 구성된다는 것입니다. 

English: 
shortest path weight from S to x
when we've added x to our set
capital, S.
OK, so this is,
in particular,
going to be the output to the
algorithm.
Did you have a question?
Or were you just stretching?
Good.
So, in d of x,
when we are done,
d of x is the output.
For every vertex,
it's going to give us the
shortest path weight from S to
that vertex.
Along the way,
it's going to be some estimated
distance from S to that vertex.
And, we're going to improve it
over time.
This is an infinity.
So initially,
we know that the distance,
we know the distance from S to
S is zero.
So, we're going to set that to
be our estimate.
It's going to be accurate.
Everything else we're going to
just set to infinity because we
may not be connected.
From the beginning,
we don't know much.
S, initially,
is going to be infinity.
Immediately,
we're going to add little s to
big S.
And then, the interesting part
here is Q, which is going to
consist of, initially all the
vertices in the graph.

Korean: 
그것은 단지 큐가 아닙니다.
그것은 우선순위 큐입니다. 
그것은 가장 작은 거리 측정을 
가지는 정점을 유지합니다. 
이것은 우선순위 큐입니다. 
이것은 데이터 구조를 위한 개념의 남용입니다.  
이것은 힙 등이 될 수 있습니다.
정점은 우리의 거리 d에 입력됩니다. 
S는 최소 힙이 됩니다
S는 최소를 가집니다. 
모든 다른 것은 초기에 같은 키를 가집니다. 
우리는 반복적으로 이 큐로부터 최소 인자를 추출합니다. 
그래서 이것은 초기화입니다. 
저는 그것을 초기화라고 부릅니다. 
그것은 정말 간단한 것입니다. 그것은 선형 시간이 걸립니다.

English: 
And, it's going to not just be
a queue as the letter suggests.
It's going to be a priority
queue.
So, it's going to maintain,
in particular,
the vertex that has the
smallest distance estimate.
So, this is a priority queue.
This is really an abuse of
notation for a data structure.
OK, so this could be a heap or
whatever.
The vertices are keyed on d,
our distance estimate.
So, in particular,
S will have the,
this is going to be a Min heap.
S will be the guy who has the
minimum.
Everyone else has the same key
initially.
And, we're going to repeatedly
extract the minimum element from
this queue and do other things.
OK, so this is initialization.
OK, I'm going to call that
initialization.
It's a pretty simple thing.
It just takes linear time,

English: 
nothing fancy going on.
The heart of the algorithm is
all in six lines.
And, so this is not really a
step.
The first step here that we
need to do is we take the vertex
whose distance estimate is
minimum.
So that, among all the
vertices, not yet,
and that's currently S is
empty.
Q has everyone.
In general, Q will have
everyone except S.
So, we'll take the vertex,
u, that has the minimum key in
that priority queue.
So, extract the Min from Q.

Korean: 
알고리즘의 핵심은 모두 6줄에 있습니다. 
이것은 단계가 아닙니다. 
여기서 우리가 필요한 첫 번째 단계는 
거리가 최소인 정점을 가지는 것입니다. 
모든 정점 중에서, 
그것은 현재 S가 비었다는 것입니다. 
Q는 모든 것입니다. 
일반적으로 Q는 S를 제외한 모든 것을 가집니다. 
우리는 우선순위 큐에서 최소 키를 가지는 정점 u를 가집니다. 
그래서 Q에서 최소값을 추출합니다.

English: 
OK.
We're going to add a little u
to S, claim that that is now,
I mean, that's exactly what
we're saying here.
We add to S that vertex that
has minimum distance estimate.
And now, we need to update the
distances.
So, we're going to look at each
adjacent vertex for each v in
the adjacency list for u.
We look at a few distances.
So that's the algorithm or more
or less.
This is the key.
I should define it a little bit
what's going on here.
We talked mainly about

Korean: 
우리는 작은 u를 S에 더할 것입니다. 
그것은 정확히 우리가 여기서 말하려는 것입니다. 
우리는 S에 최소 거리 측정을 가지는 정점을 더합니다. 
이제 우리는 거리를 업데이트할 필요가 있습니다. 
우리는 인접 리스트에서 각 v를 위한 
인접한 점을 볼 것입니다. 
우리는 거리를 볼 것입니다. 
그것은 알고리즘입니다.  
이것은 키입니다.
저는 그것을 정의해야 합니다. 우리는 주로 지난 시간에 무방향 그래프에 대해 이야기 했습니다. 

Korean: 
여기서 우리는 무방향 그래프에 대해 생각해볼 것입니다.
여기서 인접 리스트는 u에서 v까지의 
모서리가 있는 정점을 
저에게 줍니다. 
이것은 들어오는 것이 아니라 
나가는 인접리스트입니다.
무방향 그래프에서 여러분은 모든 것을 리스트 합니다
방향 그래프에서 우리는 그것들만 
신경 씁니다. 
우리는 v를 위한 현재 측정을 비교하고 
이것은 s에서 u까지 가는 것을 
직관적으로 의미합니다. 
그것은 u의 d입니다. 왜냐하면 우리는 그것이 옳은 답임을 알기 때문입니다.
사실
알고리즘이 옳다고 가정하면, 
이것은 s에서 u까지의 최단 경로이어야 합니다 
우리가 u를 S에 더했으니까요. 
그리고 우리가 무엇을 S에 더할 때 마다, 그것은 옳은 값을 가져야 합니다. 
여러분은 S에서 u까지 최단 경로를 가지고 
u에서 v까지 이 모서리를 따릅니다. 
그것은 무게 w를 가집니다. 

English: 
undirected graph last time.
Here, we're thinking about
undirected graphs.
And, the adjacency list for u
here is just going to mean,
give me all the vertices for
which there is an edge from u to
v.
So, this is the outgoing
adjacency list,
not the incoming adjacency
list.
Undirected graphs:
you list everything.
Directed graphs:
here, we're only going to care
about those ones.
So, for every edge,
(u,v), is what this is saying,
we are going to compare the
current estimate for v,
and this candidate estimate,
which intuitively means you go
from s to u.
That's d of u because we now
know that that's the right
answer.
This, in fact,
equals, we hope,
assuming the algorithm is
correct, this should be the
shortest path weight from s to u
because we just added u to S.
And whenever we add something
to S, it should have the right
value.
So, we could say,
well, you take the shortest
path from S to u,
and then you follow this edge
from u to v.
That has weight,

English: 
w, of (u,v).
That's one possible path from S
to v.
And, if that's a shorter path
than the one we currently have
in our estimate,
if this is smaller than that,
then we should update the
estimate to be that sum because
that's a better path,
so, add it to our database of
paths, so to speak:
OK, very intuitive operation;
clearly should not do anything
bad.
I mean, these should be paths
that makes sense.
We'll prove that in a moment.
That's the first part of
correctness, that this never
screws up.
And then, the tricky part is to
show that it finds all the paths
that we care about.
This step is called a
relaxation step.
Relaxation is always a
difficult technique to teach to
MIT students.
It doesn't come very naturally.
But it's very simple operation.
It comes from optimization

Korean: 
그것은 S에서 v까지 가능한 하나의 경로입니다
그것이 우리가 현재 가지는 것 보다 
더 짧은 경로이면, 
이것이 그것 보다 더 작으면, 
우리는 측정을 합으로 업데이트 해야 합니다. 
그것이 더 나은 경로이기 때문입니다. 그리고 그것을 경로 데이터베이스에 더합니다. 
매우 직관적인 연산입니다. 아무 나쁜 것도 해서는 안됩니다.
이것은 이치에 맞는 경로이어야 합니다. 
우리는 그것을 곧 증명할 것입니다.
그것은 정확성의 첫 번째 부분입니다, 이것은 절대 망치지 않습니다. 
까다로운 부분은 
우리가 신경 쓰는 모든 경로를 찾는 것을 보여주는 것입니다. 
이 단계는 휴식 단계입니다
휴식은 항상 MIT 학생들에게 가르치기 어려운 기술입니다. 
자연스럽지 않습니다. 
그러나 그것은 매우 간단한 연산입니다. 

English: 
terminology, programming
terminology, so to speak.
And, does this inequality look
familiar at all especially when
you start writing it this way?
You say, the shortest path from
S to v and the shortest path
from S to u in some edge from u
to v, does that look like
anything we've seen?
In fact, it was on this board
but I just erased it.
Triangle inequality,
yeah.
So, this is trying to make the
triangle inequality true.
Certainly, the shortest path
from S to v should be less than
or equal to, not greater than.
The shortest path from S to u,
plus whatever path from u to v,
the shortest path should be,
at most, that.
So, this is sort of a somewhat
more general triangle
inequality.
And, we want to,
certainly it should be true.
So, if it's not true,
we fix it.
If it's greater than,
we make it equal.
But we don't want to make it
less than because that's not
always true.
OK, but certainly,
it should be less than or equal
to.
So, this is fixing the triangle
inequality.

Korean: 
그것은 최적화 용어에서 온 것입니다.
여러분이 그것을 이 방법으로 쓸 때 이 부등식이 친숙해 보이나요? 
S에서 v까지 그리고 
S에서 u까지 최단 경로는 우리가 보았던 것 
같아 보이나요? 
사실 그것은 이 칠판에 있었지만 저는 그것을 지웠습니다. 
삼각 부등식입니다. 
이것은 삼각 부등식을 옳게 만듭니다. 
S에서 v까지 최단 경로는 더 작거나 같고, 크지 않습니다. 
S에서 u까지 최단 경로는 
그것이어야 합니다.
이것은 더 일반적인 
삼각 부등식입니다. 
그것은 확실히 옳아야 합니다. 
그것이 옳지 않으면 우리는 그것을 고정시킵니다. 
그것이 더 크면, 우리는 그것을 같게 만듭니다. 
그러나 그것이 항상 옳지 않기 때문에 
우리는 그것을 더 작게 만들길 원하지 않습니다. 
그러나 그것은 더 작거나 같아야 합니다. 
이것은 삼각 부등식을 고정시킵니다. 

English: 
It's trying to make that
constraint more true.
In optimization,
that's called relaxing the
constraint.
OK, so we're sort of relaxing
the triangle inequality here.
In the end, we should have all
the shortest paths.
That's a claim.
So: a very simple algorithm.
Let's try it out on a graph,
and that should make it more
intuitive why it's working,
and that the rest of the
lecture will be proving that it
works.
Yeah, this is enough room.
So, oh, I should mention one
other thing here.
Sorry.
Whenever we change d of v,
this is changing the key of v
in the priority queue.
So, implicitly what's happening
here in this assignment,
this is getting a bit messy,
is a decreased key operation,
OK, which we talked briefly
about last class in the context

Korean: 
그것은 제약을 더 옳게 만듭니다.
삼각 부등식에서, 그것은 휴식과 제약이라고 불립니다. 
우리는 여기서 삼각 부등식을 휴식합니다. 
마지막에, 우리는 모든 
최단 경로를 가져야 합니다
매우 간단한 알고리즘입니다. 그것을 그래프에서 해 봅시다,
그것은 왜 작동하는지 더 직관적으로 만들어야 합니다,
그리고 남은 강의에서 그것이 작동하는 것을 증명할 것입니다
이것은 충분한 공간입니다. 
저는 여기서 하나 더 언급할 것이 있습니다. 
우리가 v의 d를 바꿀 때마다, 
이것은 우선순위 큐에서 v의 키를 바꿉니다. 
핵심은 우리가 
우선 순위 큐에 있는 
하나의 인자의 

English: 
of minimum spanning trees where
we were also decreasing the key.
The point is we were changing
the key of one element industry
like station step in the
priority queue so that if it now
becomes the minimum,
we should extract here.
And, we are only ever
decreasing keys because we are
always replacing larger values
with smaller values.
So, we'll come back to that
later when we analyze the
running time.
But, there is some data
structure work going on here.
Again, we are abusing notation
a bit.
OK, so here is a graph with
edge weights.

Korean: 
키를 바꾼 다는 것입니다
그것이 최소가 되면, 
우리는 여기서 
추출해야 합니다. 
우리는 항상 더 큰 값을 더 작은 값으로 교체하기 
때문에 키를 감소시킵니다. 
우리는 나중에 러닝 타임을 분석할 때 돌아올 것입니다. 
여기서 돌아 가는 데이터 구조가 있습니다. 
우리는 개념을 남용하고 있습니다.
여기 모서리 무게를 가진 그래프가 
있습니다. 

Korean: 
저는 제 우선순위 큐를 원합니다. 
저는 제 측정을 그릴 것입니다. 
저는 속이길 원치 않습니다. 우리는 이 그래프에서 알고리즘을 
돌릴 것입니다. S는 A가 될 것이고, 
저는 A에서 모든 곳으로의 최단 경로를 알고 싶습니다. 
여러분은 확인할 수 있고, 경로가 존재합니다. 
모든 것은 마지막에 유한한 값으로 끝나야 합니다
모든 무게는 음이 아니고, 
이 알고리즘은 동작해야 합니다
알고리즘은 연결성이 필요 없지만, 
그것은 모든 무게가 음이 아니라는 것을 의미합니다. 
우리는 알고리즘을 돌립니다. 초기화를 위해, 
우리는 우리의 소스에서 0으로 거리를 설정합니다. 
사실 A에서 A까지 하나의 경로가 있고, 
그것은 아무 것도 하지 않습니다. 

English: 
OK, and I want my priority
queue over here.
And, I'm also going to draw my
estimates.
OK, now I don't want to cheat.
So, we're going to run the
algorithm on this graph.
s will be A,
and I want to know the shortest
path from A to everyone else.
So, you can check,
OK, paths exist.
So, hopefully everything should
end up a finite value by the
end.
All the weights are
nonnegative, so this algorithm
should work.
The algorithm doesn't even need
connectivity,
but it does mean that all the
weights are nonnegative.
So, we run the algorithm.
For the initialization,
we set the distance estimate
for our source to be zero
because, in fact,
there's only one path from A to
A, and that to do nothing,
the empty path.

Korean: 
저는 0의 키를 여기 두려고 합니다. 
모든 것을 위해, 우리는 무한대를 둘 것입니다 
왜냐하면 우리는 이 점에서 더 나은 것을 모르기 때문입니다.
저는 무한대의 키를 둘 것입니다. 
이제 여러분은 알고리즘이 하는 것이 큐에서 최소값을 추출하는 것이라는 것을 알 수 있습니다.
주어진 단계에서 
우리는 s를 고릅니다. 
그것은 0의 무게를 가집니다. 
다른 것은 더 큰 무게를 가집니다. 
우리는 s를 보고 여기서 A를 사용할 것입니다. 
우리는 A를 봅니다. 우리는 우리의 집합에 A를 더합니다. 
그것은 이제 큐에서 제거되었습니다. 
그것은 절대 돌아가지 않습니다 
우리가 큐에 아무 것도 더하지 않기 때문입니다.
우리는 아무 것도 삽입하지 않습니다. 
A는 갔습니다
이제 저는 모든 다른 정점의 키를 업데이트 하고 싶습니다
저는 A에서 모서리를 가지는 정점을 
볼 필요가 있습니다.
A에서 B까지의 모서리가 있습니다, 그리고 그것은 무게 10을 가집니다.
저는 비교합니다, 
A에서 A까지 가는 것은 좋은 생각인가요, 

English: 
So, I'm going to put the key of
zero over here.
And, for everyone else,
we're just going to put
infinity because we don't know
any better at this point.
So, I'll put keys of infinity
for everyone else.
OK, so now you can see what the
algorithm does is extract the
minimum from the queue.
And, given our setup,
we'll definitely choose s,
or in this case,
A.
So, it has a weight of zero.
Everyone else has quite a bit
larger weight.
OK, so we look at s,
or I'll use A here.
So, we look at A.
We add A to our set,
S.
So, it's now removed from the
queue.
It will never go back in
because we never add anything to
the queue, start with all the
vertices, and extract,
and decrease keys.
But we never insert.
So, A is gone.
OK, and now I want to update
the keys of all of the other
vertices.
And the claim is I only need to
look at the vertices that have
edges from A.
So, there's an edge from A to
B, and that has weight ten.
And so, I compare:
well, is it a good idea to go
from A to A, which costs
nothing, and then to go along

Korean: 
그리고 저는 이길을 따라 갑니다.
그것은 매우 좋은 생각 같아 보입니다 
왜냐하면 그것은 총 무게 0 더하기 10을 가지기 때문입니다 
그것은 무한대 보다 훨씬 작습니다. 
저는 이 무한대롤 지우고 10을 쓸 것입니다, 
이 큐에서도요. 그것은 감소된 키 연산입니다. 
저는 A에서 B까지 경로를 압니다. 
좋아요.
A에서 C까지는 다른 모서리 입니다. 0 더하기 3은 무한대 보다 작습니다. 
좋아요.
저는 여기서 C를 위해 3을 둘 것이고, C가 저기 있습니다.
저는 다른 정점을 건드리지 않습니다. 
저는 그것들을 다시 씁니다, 그러나 알고리즘은 그것들을 복사해야 합니다. 
키들은 이미 저기 있습니다. 
그것은 이 둘을 건드리지 않습니다. 그것은 매우 지루합니다. 
이제 우리는 우리의 큐를 봅니다, 그리고 최소 인자를 추출합니다
A는 저기에 더 있지 않습니다,  
여기서 최소 키는 3입니다.
이것은 A에서 C까지  
최단 경로입니다. 
더 짧은 경로는 없습니다.

English: 
this edge, AB,
which costs ten?
Well, it seems like a pretty
good idea because that has a
total weight of zero plus ten,
which is ten,
which is much smaller than
infinity.
So, I'm going to erase this
infinity; write ten,
and over in the queue as well.
That's the decreased key
operation.
So now, I know a path from A to
B.
Good.
A to C is the only other edge.
Zero plus three is less than
infinity, so,
cool.
I'll put three here for C,
and C is there.
OK, the other vertices I don't
touch.
I'm going to rewrite them here,
but the algorithm doesn't have
to copy them.
Those keys were already there.
It's just touching these two.
OK, that was pretty boring.
Now we look at our queue,
and we extract the minimum
element.
So, A is no longer in there,
so the minimum key here is
three.
So, the claim is that this is a
shortest path;
from A to C,
here is the shortest path from
A to C.
There's no other shorter way.

Korean: 
여러분은 확인할 수 있고, 우리는 곧 증명할 겁니다.
우리는 리스트에서 C를 제거할 것입니다. 
그것은 갔습니다. 우리는 C에서 나가는 모서리들을 모두 봅니다. 
B로 가는 것이 있고, 
그것은 무게 4 더하기 3을 가집니다, 
그것은 A에서 C까지 최단 경로입니다. 
C에서 B까지 가는 것은 3 더하기 4의 비용이 듭니다, 그것은 7입니다, 
10 보다 작습니다. 
우리는 B로 가는 더 나은 경로를 찾았습니다. 
그것은 이와 같이 가는 것 보다 더 낫습니다. 
우리는 B를 위해 7을 씁니다,
그리고 8의 비용이 드는 C에서 나가는 모서리는 없습니다.
3 더하기 8은 11입니다. 11은 무한대 보다 작습니다
우리는 d를 위해 11을 씁니다. 그리고 우리는 E를 봅니다. 
3 더하기 2는 5입니다, 그것은 무한대 보다 작습니다. 
우리는 E를 위한 새로운 키를 위해 5를 씁니다. 
이 점에서, 우리는 유한한 최단 경로를 가지지만, 
그것들은 최고가 아닐 수 있습니다. 
우리는 계속 찾아 보아야 합니다. 
우리는 모든 것들 가운데 최소 키를 추출합니다.

English: 
You could check that,
and we'll prove it in a moment.
Cool, so we'll remove C from
the list.
It's gone.
Then we look at all of the
outgoing edges from C.
So, there's one that goes up to
B, which has weight four,
four plus three,
which is the shortest path
weight from A to C.
So, going from A to C,
and C to B should cost three
plus four, which is seven,
which is less than ten.
So, we found an even better
path to get to B.
It's better to go like this
than it is to go like that.
So, we write seven for B,
and there's an outgoing edge
from C to d which costs eight.
Three plus eight is 11.
11 is less than infinity last
time I checked.
So, we write 11 for d.
Then we look at E.
We have three plus two is five,
which is less than infinity.
So, we write five for the new
key for E.
At this point,
we have finite shortest paths
to everywhere,
but they may not be the best
ones.
So, we have to keep looking.
OK, next round of the
algorithm, we extract the

English: 
minimum key among all these.
OK, it's not B,
which we've seen though
probably know the answer to.
But it's E.
E has the smallest key.
So, we now declare this to be a
shortest path.
The way we got to E was along
this path: A to C,
C to E, declare that to be
shortest.
We claim we're done with E.
But we still have to update.
What about all the outgoing
edges from E?
There's only one here.
It costs five plus nine,
which is 14,
which is bigger than 11.
So, no go.
That's not an interesting path.
Our previous path,
which went like this at a cost
of the 11, is better than the
one we are considering now.
I'm drawing the whole path,
but the algorithm is only
adding these two numbers.
OK, good.
So, I don't change anything.
Seven, 11, and five is removed,
or E is removed.
Our new keys are seven and 11.
So, we take the key,
seven, here,

Korean: 
그것은 B가 아닙니다. 
그것은 E입니다. 
E는 가장 작은 키입니다. 
우리는 이제 이것이 최단 경로라고 선언합니다. 
우리가 E를 얻는 방법은 이 경로 A에서 C, 
C에서 E를 따르는 것입니다, 
그리고 그것을 최단이라고 선언합니다. 우리는 E를 가지고 다 했습니다. 
그러나 우리는 여전히 업데이트해야 합니다. E에서 나오는 모서리는 무엇입니까? 
그것은 여기 있습니다. 그것은 5 더하기 9의 비용이 듭니다, 
그것은 14입니다, 11 보다 큽니다.
그래서 가지 않습니다, 흥미로운 경로가 아닙니다. 
전의 경로는 11의 비용이 들었고, 우리가 지금 고려하고 있는 것 
보다 더 좋습니다. 
저는 전체 경로를 그릴 것이지만 알고리즘은 이 두 수를 
더합니다. 좋아요. 
저는 아무 것도 바꾸지 않습니다. 7 11 5 는 제거됩니다 또는 E가 제거됩니다. 
우리의 새로운 키는 7과 11입니다.
우리는 여기서 키, 7을 가집니다, 

English: 
which is for element B,
vertex B.
We declare the path we
currently have in our hands from
A to B, which happens to be this
one.
Algorithm can't actually tell
this, by the way,
but we're drawing it anyway.
This path, A,
C, B, is the candidate shortest
path.
The claim is it is indeed
shortest.
Now, we look at all the
outgoing edges.
There's one that goes back to C
at a cost of seven plus one,
which is eight,
which is bigger than three,
which is good.
We already declared C to be
done.
But the algorithm checks this
path and says,
oh, that's no better.
And then we look at this other
edge from B to d.
That costs seven plus two,
which is nine,
which is better than 11.
So, we, in fact,
found an even shorter path.
So, the shortest path weight,
now, for d, is nine because
there is this path that goes A,
C, B, d for a total cost of
three plus four plus two is
nine.
Cool, now there's only one

Korean: 
그것은 인자 B를 위한 것입니다.
우리는 현재 A에서 B를 가지고 있다고 경로를 선언합니다,  
그것은 이것입니다.
알고리즘은 이것을 알려줄 수 없지만 
우리는 그것을 그립니다. 
이 경로, A, C, B는 최단 경로 후보입니다. 
그것은 정말 가장 짧습니다. 
우리는 모든 나가는 모서리를 봅니다. 
로 가는 8의 비용의 것이 있습니다, 
그것은 3 보다 더 큽니다. 
우리는 이미 C를 선언했습니다. 
그러나 알고리즘은 이 경로를 
확인하지 않습니다. 
우리는 B에서 d로의 다른 모서리를 봅니다. 
그것은 9의 비용이 들고, 11 보다 낫습니다.
사실
우리는 더 짧은 경로를 찾았습니다. 최단 경로는 9입니다 
이 경로는 총 비용이 9이기 때문입니다. 
이제 큐에서 하나의 인자만 있습니다. 
좋아요 이제

Korean: 
우리는 그것을 제거합니다. 
D는 나가는 모서리입니다. 
여기서 9 더하기 7 
즉 16의 비용이 드는 것이 잇습니다, 그것은 5 보다 더 큽니다. 
우리는 다 했습니다. 아무 것도 하지 않습니다.
이 점에서 큐는 비었습니다. 
여기서 쓴 모든 수, 
최종 값은 최단 경로 무게입니다.
이것은 5와 같아 보이지만 s입니다. 
그것은 0의 무게를 가집니다. 그것은 여기서 모든 최단 경로를 그립니다.
이것은 어려운 것이 아닙니다. 
우리는 그것에 대해 많이 이야기 하지는 않을 것이지만, 
자세한 것은 교재에 있습니다. 
그것은 최단 경로 트리입니다. 
여러분이 최단 경로를 계산하고 
싶으면 좋은 것입니다. 
수업에서 우리는 주로 무게에 대해 걱정하지 않습니다 
그것은 같은 문제이기 때문입니다. 
최단 경로 트리는 모든 최단 경로의 통합입니다.
여러분이 그래프에서 각 정점을 보면, 

English: 
element in the queue.
We remove it.
d: we look at the outgoing
edges.
There's one going here which
costs nine plus seven,
which is 16,
which is way bigger than five.
So, we're done.
Don't do anything.
At this point,
the queue is empty.
And the claim is that all these
numbers that are written here,
the final values are the
shortest path weights.
This looks an awful lot like a
five, but it's an s.
It has a weight of zero.
I've also drawn in here all the
shortest paths.
And, this is not hard to do.
We're not going to talk about
it too much in this class,
but it's mentioned in a little
bit more detail at the end of
the textbook.
And it's something called the
shortest path tree.
It's just something good to
know about if you actually want
to compute shortest paths.
In this class,
we mainly worry about the
weights because it's pretty much
the same problem.
The shortest path tree is the
union of all shortest paths.
And in particular,
if you look at each vertex in

English: 
your graph, if you consider the
last edge into that vertex that
was relaxed among all vertices,
u, you look at the edges,
(u,v), say, was that last one
to relax?
So, just look at the last edges
we relaxed here.
You put them all together:
that's called a shortest path
tree.
And, it has the property that
from S to everywhere else,
there is a unique path down the
tree.
And it's the shortest path.
It's the shortest path that we
found.
OK, so you actually get
shortest paths out of this
algorithm even though it's not
explicitly described.
All we are mainly talking about
are the shortest path weights.
Algorithm clear at this point?
Feels like it's doing the right
thing?
You can check all those numbers
are the best paths.
And now we're going to prove
that.

Korean: 
여러분이 연결된 마지막 모서리를 
고려하면, 
(u,v)는 마지막 것인가요? 
여기서 마지막 모서리를 보세요. 
여러분은 모두 함께 둡니다. 
그것은 최단 경로 트리입니다. 그것은 속성을 가지고, 
트리로의 유일한 경로가 있습니다.
그것은 최단 경로입니다. 
그것은 우리가 찾은 최단 경로입니다. 
여러분은 그것이 명쾌하기 묘사되지 않더라도 
이 알고리즘의 가장 짧은 경로를 얻습니다. 
우리가 주로 이야기 하는 것은 최단 경로 무게입니다. 
이 점에서 알고리즘이 분명한가요? 그것은 옳은 것을 하고 있나요? 
여러분은 모든 수가 최고의 경로인지 확인할 수 있습니다. 
이제 우리는 증명할 것입니다. 

Korean: 
정확성입니다.
제가 증명하고 싶은 첫 번째는 휴식이 실수를 하지 않는다는 것입니다. 
그것이 v의 d를 무엇으로 설정하면, 
저는 그것을 δ에서 항상 상계라는 것을 증명하고 싶습니다. 
우리는 이 변종을 가집니다. 
그것은 모든 v에 대하여 δ(s, v)보다 크거나 같습니다. 
이 변종은 항상 유지됩니다. 
초기화 후에, 그것은 초기화 전을 유지하지 않습니다. 

English: 
So: correctness.
So the first thing I want to
prove is that relaxation never
makes a mistake.
If it ever sets d of v to be
something, I want to prove that
d of v is always an upper bound
on delta.
So, we have this variant.
It's greater than or equal to
delta of s, v for all v.
And, this invariant holds at
all times.
So, after initialization,
it doesn't hold before

Korean: 
D가 정의되지 않았습니다.
여러분이 이 초기화를 하면, 
여러분은 휴식 단계의 순서를 얻고, 
이 변종은 여러분이 적용하는 
휴식 단계 후에 유지됩니다. 
이것은 일반적인 부명제입니다. 
그것은 또한 증명하기 쉽습니다. 
그것은 Dijkstra 알고리즘을 위한 것이 아니라, 많은 다른 알고리즘을 위한 것입니다. 
우리가 볼 모든 알고리즘은 휴식을 포함합니다. 
이것은 여러분이 무슨 휴식을 하는지 말하지 않고, 
여러분은 항상 최단 경로 무게 보다 
크거나 같은 합리적인 측정을 가집니다. 
그것은 위에서부터 집중됩니다. 
그것이 부명제입니다. 

English: 
initialization because d isn't
defined then.
But if you do this
initialization where you set S
to zero, and everyone else to
infinity, and you take any
sequence of relaxation steps,
then this variant will hold
after each relaxation step you
apply.
This is actually a very general
lemma.
It's also pretty easy to prove.
It holds not only for
Dijkstra's algorithm,
but for a lot of other
algorithms we'll see.
Pretty much every algorithm we
see will involve relaxation.
And, this is saying no matter
what relaxations you do,
you always have a reasonable
estimate in the sense that it's
greater than or equal to the
true shortest path weight.
So, it should be converging
from above.
So, that's the lemma.

English: 
Let's prove it.
Any suggestions on how we
should prove this lemma?
What technique might we use?
What's that?
Cut and paste?
It would be good for optimal
substructure.
Cut and paste:
maybe sort of what's going on
here but not exactly.
Something a little more
general.
It's just intuition here;
it doesn't have to be the right
answer.
In fact, many answers are
correct, have plausible proofs.
Induction, yeah.
So, I'm not going to write
induction here,
but effectively we are using
induction.
That's the answer I was
expecting.
So, there is sort of an
induction already in time going
on here.
We say after initialization it
should be true.
That's our base case.
And then, every relaxation we
do, it should still be true.
So, we're going to assume by
induction that all the previous
relaxations worked,
and then we're going to prove
that the last relaxation,
whatever it is,
works.

Korean: 
증명합시다. 우리가 이 부명제를 어떻게 증명하는지에 대한 생각 있나요?
어떤 기술을 사용하나요? 
무엇이죠? 복사 붙여넣기 인가요? 
그것은 최적 서브 구조를 위해 좋습니다. 
복사 붙여넣기는 정확하지 않습니다. 
더 일반적인 것입니다. 
여기 직관이 있습니다. 
그것은 옳은 답을 가져야 하지 않습니다. 
사실 많은 답이 옳고, 이치에 맞는 증명을 가집니다. 
귀납법입니다. 저는 여기서 귀납법을 쓰지 않지만 
효율적으로 우리는 귀납법을 사용할 것입니다. 
그것이 제가 기대한 답입니다. 
이미 많은 
귀납법이 있습니다. 
우리는 초기와 후에 그것이 옳다고 말합니다. 
그것은 우리의 기본 케이스입니다. 
모든 휴식은 여전히 옳아야 합니다. 
우리는 귀납법에 의해 모든 휴식이 
동작 했다고 가정해야 하고, 
우리는 그것을 증명할 것입니다.

English: 
So, first let's do the base
case.
So, this is after an
initialization,
let's say, initially.
So, initially we have d of s
equal to zero.
And we have d of v equal to
infinity for all other vertices,
for all vertices,
v, not equal to little s.
OK, now we have to check that
this inequality holds.
Well, we have delta of s,
s.
We've already argued that
that's zero.
You can't get negative when
there are only nonnegative edge
weights.
So, that's the best.
So, certainly zero is greater
than or equal to zero.
And, we have everything else,
well, I mean,
delta of S, v is certainly less
than or equal to infinity.
So this holds.
Everything is less than or
equal to infinity.
So: base case is done.
So, now we do an induction.

Korean: 
먼저 기본 케이스를 해봅시다. 
이것은 초기화 후입니다. 
초기에 우리는 s의 d를 0으로 둡니다. 
V의 d는 모든 다른 정점을 위해 무한대와 같습니다, 
작은 s와 같지 않습니다. 
이제 우리는 이 부등식이 유지되는지 확인해야 합니다. 
우리는 s의 델타를 가집니다. 
우리는 이미 그것이 0이라고 했습니다. 
여러분은 음의 무게가 있을 때 
음을 가질 수 없습니다. 
그것이 최고입니다. 0은 0 보다 크거나 같습니다. 
우리는 모든 것을 가집니다, 
v는 무한대보다 확실히 
작거나 같습니다. 이것은 유지됩니다. 
모든 것은 무한대보다 작거나 같습니다. 
기본 케이스는 다 되었습니다. 이제 우리는 귀납법을 할겁니다.

Korean: 
저는 그것을 모순에 의한 증명으로 쓸 것입니다. 
이것이 유지하는 것을 
실패한다고 가정해보세요. 불변은 위반됩니다. 
우리는 위반자를 고소하고 
모순을 찾습니다. 
그것은 위반됩니다. 
첫 번째 위반을 봅시다. 
이것은 필수적으로
다시 귀납법에 의한 증명입니다. 
우리가 같은 위반을 가진다고 합시다, 
d[v]는 δ(s, v)보다 작습니다. 

English: 
And, I'm going to write it as a
proof by contradiction.
So, let's say,
suppose that this fails to hold
at some point.
So, suppose for contradiction
that the invariant is violated.
So, we'd like to sue the
violator and find a
contradiction.
So, it's going to be violated.
So, let's look at the first
violation, the first time it's
violated.
So, this is,
essentially,
again, a proof by induction.
So, let's say we have some
violation, d of v is less than
delta of s, v.
That would be bad if we somehow
got an estimate smaller than the
shortest path.
Well, then I think about

Korean: 
우리가 최단 경로 보다 더 작은 측정을 
가지면 그것은 나쁩니다. 
d[v]는 우리가 망치는 첫 번째 것입니다. 
불변은 어디서나 유지됩니다. 
이것이 실패를 유발하는 것은 
불변이 위반되는 것입니다. 
우리는 d[v]를 가집니다, 그것을 다른 d[u] 더하기 
u에서 v까지의 모서리 무게와 교체합니다. 
이것은 그것을 무효로 만듭니다. 
d[v]는 그것보다 작습니다. 
우리는 d[v]를 이것으로 설정합니다. 이것은 δ(s, v)보다 반드시 작아야 합니다. 
그것은 가능하지 않습니다, 
그것을 다시 써 보겠습니다.

English: 
looking at the first violation
is we know sort of by induction
that all other values are
correct.
OK, d of v is the first one
where we've screwed up.
So, the invariant holds
everywhere else.
Well, what caused this to fail,
this invariant to be violated,
is some relaxation,
OK, on d of v.
So, we had some d of v,
and we replaced it with some
other d of u plus the weight of
the edge from u to v.
And somehow,
this made it invalid.
So, d of v is somehow less than
that.
We just set d of v to this.
So, this must be less than
delta of s, v.
The claim is that that's not
possible because,
let me rewrite a little bit.

English: 
We have d of u plus w of (u,v).
And, we have our induction
hypothesis, which holds on u,
u of some other vertex.
We know that d of u is at least
delta of s, u.
So, this has to be at least
delta of s, u plus w of u,
v.
Now, what about this w of u,
v?
Well, that's some path from u
to v.
So, it's got to be bigger than
the shortest path or equal.
So certainly,
this is greater than or equal
to delta of u,
v.
OK, it could be larger if
there's some multi-edged path
that has a smaller total weight,

Korean: 
우리는 d[u] 더하기 w(u,v)를 가집니다. 
우리는 귀납법 가설을 가집니다. 
d[u]는 적어도 δ(s, v)입니다. 
이것은 적어도 δ(s, u)+w(u, v)입니다. 
이 u의 w는 무엇입니까? 
그것은 u에서 v까지의 경로입니다. 
그것은 최단 경로 보다 
크거나 같은 것입니다.
이것은 δ(u, v) 보다 크거나 같습니다.
더 작은 총 무게를 가진 
여러 모서리의 경로가 있으면, 그것은 더 클 수 있지만 

English: 
but it's certainly no smaller
than delta of u,
v.
And, this looks like a good
summation, delta of S to u,
and u to v is a triangle
inequality, yeah.
So, that is,
it's upside down here.
But, the triangle S,
u, u to v, so this is only
longer than S to v.
OK, so we have this thing,
which is simultaneously greater
than or equal to the shortest
path weight from S to v,
and also strictly less than the
shortest path weight from S to
v.
So, that's a contradiction.
Maybe contradiction is the most
intuitive way isn't the most
intuitive way to proceed.
The intuition,
here, is whatever you assign d
of v, you have a path in mind.
You inductively had a path from
s to u.
Then you added this edge.
So, that was a real path.
We always know that every path
has weight greater than or equal

Korean: 
δ(u, v) 보다 더 작은 것은 없습니다.
이것은 좋은 합입니다, 
그것은 삼각 부등식입니다. 
그것은 여기서 위에서 아래로 입니다. 
이것은 s에서 v 보다 
더 깁니다. 
우리는 이것을 가지고, 그것은 동시에 S에서 v까지 
최단 경로 무게 보다 크거나 같습니다. 
또한 S에서 v까지 최단 경로 무게 보다 엄격히 작습니다. 
그것은 모순입니다. 
모순은 가장 
직관적인 방법이 아닙니다. 
여러분은 경로를 마음에 새기세요.
여러분이 d[v]를 할당할 때 마다, 여러분은 경로를 가집니다. 
여러분은 s에서 u까지의 경로를 가집니다. 그리고 저는 이 모서리를 더합니다. 그것은 실제 경로입니다. 
우리는 항상 모든 경로가 최단 경로 보다 크거나 같다는 것을 압니다. 

English: 
to the shortest path.
So, it should be true,
and here's the inductive proof.
All right, moving right along,
so this was an easy warm-up.
We have greater than or equal
to.
Now we have to prove less than
or equal to at the end of the
algorithm.
This is true all the time;
less than or equal to will only
be true at the end.
So, we are not going to prove
less than or equal to quite yet.
We're going to prove another
lemma, which again,
so both of these lemmas are
useful for other algorithms,
too.
So, we're sort of building some
shortest path theory that we can
apply later.
This one will give you some
intuition about why relaxation,
not only is it not bad,

Korean: 
그것을 옳아야 하고, 
여기 귀납법 증명이 있습니다.
이것은 쉬운 연습입니다. 우리는 크거나 같은 것을 가집니다. 
이제 우리는 알고리즘의 마지막에 
작거나 같은 것을 가집니다.
이것은 항상 옳습니다. 작거나 같은 것은 마지막에 항상 옳습니다. 
우리는 아직 작거나 같은 것을 증명하기 않을 것입니다. 
우리는 다른 부명제를 증명할 것입니다, 
이 부명제는 모두 
다른 알고리즘을 위해 유용합니다.
우리는 나중에 적용할 수 있는 최단 경로 이론을 구축합니다. 
이것은 여러분에게 휴식에 대한 직관을 줄 것이고, 
나쁘지 않고 좋습니다. 

English: 
it's actually good.
Not only does it not screw up
anything, but it also makes
progress in the following sense.
So, suppose you knew the
shortest path from s to some
vertex.
OK, so you go from s to some
other vertices.
Then you go to u.
Then you go to v.
Suppose that is a shortest path
from s to v.
OK, and also suppose that we
already know in d of u the
shortest path weight from s to
u.
So, suppose we have this
equality.
We now know that we always have
a greater than or equal to.
Suppose they are equal for u,
OK, the vertex just before v in
the shortest path.
OK, and suppose we relax that
edge, (u,v), OK,

Korean: 
그것은 아무 것도 망치지 않을 뿐 아니라, 
다음의 면에서 진보를 합니다.
여러분이 s에서 어떤 점까지의 최단 경로를 안다고 가정해보세요. 
여러분은 s에서 어떤 점까지 갑니다. 
그리고 여러분은 u로 갑니다. 
그리고 v로 갑니다. 그것은 s에서 v까지의 최단 경로라고 가정해보세요. 
그리고 우리가 이미 s에서 u까지 
최단 경로를 안다고 가정해보세요. 
우리가 이 부등식을 가진다고 가정해보세요.
우리는 항상 크거나 같은 것을 가진다는 것을 압니다. 
그것들은 최단 경로에서 v 전의 정점과  
같다고 가정해보세요,
그리고 우리가 그 정점을 휴식시킨다고 가정해보세요, 

English: 
which is exactly this step.
This is relaxing the edge,
(u,v).
But we'll just call it
relaxation here.
After that relaxation,
d of v equals delta of (s,v).
So, if we had the correct
answer for u,
and we relax (u,v),
then we get the correct answer
for v.
OK, this is good news.
It means, if inductively we can
somehow get the right answer for
u, now we know how to get the
right answer for v.
In the algorithm,
we don't actually know what the
vertex just before v in the
shortest path is,
but in the analysis we can
pretty much know that.
So, we have to prove this
lemma.
This is actually even easier
than the previous one:
don't even need induction
because you just work through
what's going on in relaxation,

Korean: 
그것은 정확히 이 단계입니다.
이것은 모서리 (u,v)를 휴식시킵니다. 그러나 우리는 그것을 휴식이라고 부릅니다. 
그 휴식 후에, 
d[v]는 δ(s,v)와 같습니다. 
우리가 u를 위해 옳은 답을 가지면, 우리는 (u,v)를 휴식시킵니다. 
그리고 옳은 답을 얻습니다. 
이것은 좋은 소식입니다. 
우리가 u를 위한 답을 얻을 수 있으면, 우리는 v를 위한 옳은 답을 얻는 방법을 압니다.
알고리즘에서,  
우리는 v 전의 정점이 무엇인지 모릅니다,
그러나 분석에서 우리는 그것을 많이 알 수 있습니다. 
우리는 이 부명제를 증명해야 합니다. 
이것은 사실 이전 것 보다 더 쉬운 것입니다. 
귀납법이 필요하지 않습니다 
왜냐하면 여러분은 휴식에서 무엇이 되는지 알아야 하기 때문입니다, 그것은 옳습니다.

Korean: 
여기서 우리는 갑니다. 
우리는 이 값 δ에 관심이 있습니다. 
그리고 우리는 최단 경로가 무엇인지 압니다.
최단 경로 무게는 이 경로의 무게입니다. 
우리는 등식을 쓸 수 있습니다. 
저는 경로의 첫 번째 부분과 
마지막 부분을 쪼개지 않을 것입니다. 
저는 다음 무게를 말할 수 있습니다.
우리는 경로의 w를 쓸 수 있고, 
그것은 모든 모서리의 총 무게였습니다. 
S에서 u까지의 무게는 무엇입니까? 
값이 무엇인지 알아내기 위해 사용해야 하는 속성은 무엇입니까? 

English: 
and it's true.
So, here we go.
So, we're interested in this
value, delta of Ss v.
And we know what the shortest
path is.
So, the shortest path weight is
the weight of this path.
OK, so we can write down some
equality here.
Well, I'm going to split out
the first part of the path and
the last part of the path.
So, we have,
I'll say, the weight from s,
so, this part of the path from
s to u, plus the weight of this
edge, u, v.
Remember, we could write w of a
path, and that was the total
weight of all those edges.
So, what is this,
the weight of this path from S
to u?
Or, what property should I use
to figure out what that value

Korean: 
네?
s에서 v는 최단 경로입니다, 
최적 서브 구조에 의해, S에서 u까지도 최단 경로입니다. 
이것은 δ(s, u)입니다. 
좋아요. 
우리는 지금은 유지할 것입니다. 그것은 우리가 말하는 모든 것입니다. 
다른 한편으로, 우리는 이 부명제로부터 우리가 하는 것을 압니다. 
V의 d는 s, v의 델타 보다 크거나 
같습니다.
그것을 써 봅시다. 몇 가지 케이스가 있고 
이것은 케이스들을 제거할 것입니다. 
부명제 정확성에 의해, 우리는 v의 d가 
δ(s, v)보다 크거나 같다는 것을 압니다. 
그것은 항상 크거나 같습니다. 
저는 휴식을 하기 전에 시간에 대해 생각할 것입니다. 
그 점에서, 

English: 
is?
Yeah?
s to v is the shortest path,
right?
So, by optimal substructure,
from s to u is also a shortest
path.
So, this is delta of s,
u.
Cool.
We'll hold on for now.
That's all we're going to say.
On the other hand,
we know from this lemma that
matter what we do,
d of v is greater than or equal
to delta of s,
v.
So, let's write that down.
So, there's a few cases,
and this will eliminate some of
the cases.
By that lemma correctness one,
we know that d of v is greater
than or equal to delta of s,
v.
So, it's either equal or
greater than at all times.
So, I'm thinking about the time
before we do the relaxation,
this (u,v).
So, at that point,

English: 
this is certainly true.
So, either they're equal before
relaxation or it's greater.
OK, if they are equal before
relaxation, we're happy because
relaxation only decreases values
by correctness one.
It can't get any smaller than
this, so after relaxation it
will also be equal.
OK, so in this case we're done.
So, that's a trivial case.
So let's now suppose that d of
v is greater than delta of s,
v before relaxation.
That's perfectly valid.
Hopefully now we fix it.
OK, well the point is,
we know this delta s,
v.
It is this sum.
OK, we also know this.
So, delta of s,

Korean: 
이것은 확실히 옳습니다. 
그것들은 같거나 더 큽니다.
그것들이 휴식 전에 같으면, 
우리는 행복합니다 휴식이 값을 감소 시키기 때문입니다. 
그것은 이것 보다 더 작을 수 없습니다, 휴식 후에 그것은 같을 것입니다. 
이 케이스에서, 우리는 다했습니다. 
그것은 사소한 케이스입니다. V의 d가 s, v의 
δ 보다 크거나 같다고 가정해 봅시다.
그것은 완벽히 유효합니다. 희망적으로 이제 우리는 그것을 고정시킵니다. 
핵심은 이 δ(s, v)입니다. 이 δ(s, v)여기에서 오고,
그것은 이 합입니다.
우리는 이것을 또한 압니다. 이 두 개를 연결하면

English: 
u we know is d of u.
And, we have this w u,
v.
So, delta of s,
v is d of u plus w of (u,v)
because we are assuming we have
this shortest path structure
where you go from s to u,
and then you follow the edge,
(u,v).
So, we know this.
So, we know d of v is greater
than d of u plus w of (u,v).
By golly, that's this condition
in relaxation.
So, we're just checking,
relaxation actually does
something here.
OK, if you had the wrong
distance estimate,
this if condition is satisfied.
Therefore, we do this.
So, in this case,
we relax.
So, I'm just relaxing.
Then, we set d of v to d of u
plus WUV, which is what we want.
OK, so we set d of v to d of u
plus w of (u,v).
And, this equals,

Korean: 
우리는 w (u, v)를 가집니다. 
δ(s, v)는 d[u]+ w(u, v)
왜냐하면 우리는 
이 최단 경로를 가진다고 가정하기 때문입니다, 
여러분은 모서리 (u,v)를 따릅니다. 
우리는 이것을 아네요. 우리는 d[v]가 d[v]+ w(u,v) 보다 크다는 것을 압니다. 
그것은 휴식에서 이 조건입니다. 
우리는 검사할 것이고, 
휴식은 여기서 합니다. 
여러분이 잘못된 거리 측정을 가지면, 조건은 만족됩니다.
그러므로, 우리는 이것을 합니다. 
이 케이스에서, 우리는 휴식합니다. 
저는 휴식합니다. 우리는 d[v]를 d[u]+ w(u, v)라고 설정합니다, 
그것은 우리가 원하는 것입니다. 그래서 우리는 우리는 d[v]를 
d[u]+w(u,v)로 설정합니다.

Korean: 
이것은 δ(s, v)와 같습니다, 
그것은 우리가 증명하려고 했던 것입니다. 
다 되었습니다. 저는 우리가 이 증명으로 들어 갈수록 
더 흥미로워 집니다. 
지금까지 질문 있나요? 좋아요. 
이제 어려운 부분이 있습니다. 이것들은 모두 쉬운 부명제입니다.
저는 이 두 칠판을 사용할 것입니다.  
우리는 이 증명이 더 이상 필요하지 않습니다.
우리는 정확성이 
필요합니다. 

English: 
as we said here,
delta of S, v,
which is what we wanted to
prove.
Done.
OK, I'm getting more and more
excited as we get into the meat
of this proof.
Any questions so far?
Good.
Now comes the hard part.
These are both very easy
lemmas, right?
I'll use these two boards.
We don't need these proofs
anymore.
We just need these statements:
correctness one,
correctness lemma;
great names.

English: 
So, now finally we get to
correctness two.
So, we had one and one and a
half.
So, I guess correctness is,
itself, a mini-trilogy,
the mini-series.
OK, so correctness two says
when the algorithm is done,
we have the right answer.
This is really correctness.
But, it's going to build on
correctness one and correctness
lemma.
So, we want d of v to equal
delta of s, v for all vertices,
v at the end of the algorithm.
That is clearly our goal.
Now, this theorem is assuming
that all of the weights are
nonnegative, just to repeat.
It doesn't assume anything
else.
So, it's going to get the
infinities right.
But, if there are minus
infinities, all bets are off.
OK, even if there's any
negative weight edge anywhere,
it's not going to do the right

Korean: 
이제 마지막으로 우리는 정확성 둘을 얻습니다. 
우리는 하나 그리고 절반을 가집니다. 
저는 정확성이 미니 시리즈라고 생각합니다. 
알고리즘이 다 되었을 때,  
우리는 옳은 답을 가집니다. 
이것은 정말 정확성입니다.
그러나 그것은 정확성에서 구축하는 것입니다.
우리는 d[v]가 δ(s, v)와 같길 원합니다. 
그것은 명백히 우리의 목표입니다. 
이제 이 정리는 모든 무게가 음이 아니라고 가정하는 것입니다, 
반복하기 위해서요. 
그것은 아무 것도 가정하지 않습니다. 그것은 무한대를 얻습니다. 
그러나 마이너스 무한대가 있으면, 
다 집니다. 음의 무게 모서리가 있더라도, 
그것은 필수적으로 옳은 것이 아닙니다.

Korean: 
모든 무게가 음이 아니라고 가정하는 것은 
합리적입니다.
보통 그것은 모서리를 따라 이동하는 비용이 듭니다. 
그것들은 여러분이 지불하게 하지 않습니다.
그러나 누가 아나요? 저는 몇 가지가 필요합니다. 
우리가 언급한 것 중 하나는 
여러분이 S에 정점을 더할 때, 여러분은 
그것의 무게를 절대 바꾸지 않는다는 것입니다. 
그것을 사실 증명을 요구합니다.  
저는 그것을 여기서 씁니다.
그것은 보기 어렵지 않습니다. d[v]는 바뀌지 않습니다. 
이것은 필수적으로 귀납법입니다.  
이것은 곧 말할 것에 의해 따라옵니다.
제가 신경 쓰는 모든 것은, 정점이 S에 더해질 때, 우리는 옳은 측정을 가집니다

English: 
thing necessarily.
But, assuming all the weights
are nonnegative,
which is reasonable if they're
measuring time.
Usually it costs money to
travel along edges.
They don't pay you to do it.
But who knows?
So, I need just to say a few
things.
One of the things we've
mentioned somewhere along the
way is when you add a vertex to
S, you never change its weight.
OK, that actually requires
proof.
I'm just going to state it
here.
It's not hard to see.
d of v doesn't change.
OK, this is essentially an
induction once v is added to S.
OK, this will actually followed
by something we'll say in a
moment.
OK, so all I really care about
is when a vertex is added to S,

Korean: 
왜냐하면 그 후에, 
우리는 그것을 바꾸지 않기 때문입니다.
우리는 알고리즘을 그 방법으로 정의할 수 있습니다. 
우리는 하지 않지만, 할 수 있습니다. 
저는 이것에 대해 곧 더 이야기할 것입니다. 우리가 신경 쓰는 모든 것은 
d[v]가 δ(s, v)와 같은지 입니다. 
그것은 우리가 증명하고 싶은 것입니다. 그것은 분명히 그것입니다. 
그것은 마지막에 옳아야 합니다. 그러나 그것은 
v가 S에 더해질 때 증명하기 충분합니다. 
이것은 사실 첫 번째 문장을 내포합니다. 
그것은 웃긴 내포를 가집니다. 
우리가 이 증명을 할 수 있으면, 
그것은 더 작은 것을 
얻을 수 없습니다. 
그것은 정확성으로부터 온 것입니다. 
정확성은 우리가 델타 보다 작은 것을 얻을 수 없다고 말합니다.
우리가 그 점에서 질을 얻으면, 우리는 그것으로부터 질을 얻을 것입니다. 
그것을 사실 d[v]가 그 점 후에 

English: 
we better have the right
estimate because after that,
we're not going to change it,
let's say.
OK, we could define the
algorithm that way.
We are not, but we could.
I'll say more about this in a
second.
So, all we care about is
whether d of v equals delta of
s, v.
That's what we want to prove.
So, it's clearly that.
It should be true at the end.
But, it suffices to prove that
it holds when v is added to S,
to capital S.
OK, this actually implies the
first statement.
It has sort of a funny
implication.
But, if we can prove this,
that d of v equals delta of s,
v, when you add to S,
we know relaxation only
decreases value.
So, it can't get any smaller.
It would be from correctness
one.
Correctness one says we can't
get any smaller than delta.
So, if we get a quality at that
point, we'll have a quality from
then on.
So, that actually implies d of

English: 
v never changes after that
point.
OK, so we're going to prove
this.
Good.
Well, suppose it isn't true.
So this would be a proof by a
contradiction.
Suppose for contradiction that
this fails to hold.
And, let's look at the first
failure.
Suppose u is the first vertex
--
-- that's about to be added to
S.
I want to consider the time
right before it's added to S,
for which we don't have what we
want.

Korean: 
절대 변하지 않는다는 것을 내포합니다.
그래서 우리는 이것을 증명할 것입니다. 
그것이 옳지 않다고 가정해보세요. 
이것은 모순에 의한 증명입니다. 
모순을 위해 이것이 유지되는데 실패한다고 가정해보세요. 
첫 번째 실패를 봅시다. 
U가 첫 번째 정점이라고 가정해보세요. 
그것은 막 S에 더해지려고 합니다. 
저는 그것이 S에 더해지기 전에 시간을 고려하길 원합니다. 
우리는 원하는 것을 가지지 못합니다. 

English: 
These are not equal.
d of u does not equal delta of
s, u.
Well, if they're not equal,
we know from correctness one
that d of E is strictly greater
than delta of s,
u, so, d of u.
So, we have d of u is strictly
greater than delta of s,
u.
OK, that's the beginning of the
proof, nothing too exciting yet,
just some warm-up.
OK, but this,
used already correctness one.
I think that's the only time
that we use it in this proof.
OK, so I sort of just want to
draw picture of what's going on.
But I need a little bit of
description.

Korean: 
이것은 같지 않습니다. d[u]는 δ(s, u)와 같지 않습니다. 
그것들이 같지 않으면,  
우리는 정확성으로부터, d[u]가 δ(s, u)보다 
엄격히 더 크다는 것을 압니다.
d[u]가 δ(s, u)보다 엄격히 더 큽니다.
그것은 증명의 시작입니다, 
흥미롭지 않지만, 준비 입니다. 
그러나 이것은 이미 정확성을 사용합니다. 
저는 그것이 이 증명에서 우리가 그것을 사용하는 유일한 시간이라고 생각합니다. 
저는 무엇이 계속 되는지 그림을 그리고 싶습니다. 
저는 설명이 필요합니다.  

English: 
So, let's look at the shortest
path.
Somehow, d of u is greater than
the shortest path.
So, consider the shortest path
or a shortest path.
Let p be a shortest path,
not just any shortest path,
but the shortest path from s to
u.
OK, so that means that the
weight of this path is the
shortest path weight.
So, we have some equations for
what's going on here.
So, we care about delta of s,
u.
Here's a path with that weight.
It's got to be one because
shortest paths exist here;
slight exceptional cases if
it's a plus infinity,
but I'm not going to worry
about that.
So, let me draw a picture
somewhere.

Korean: 
최단 경로를 봅시다.
U의 d는 최단 경로 보다 더 큽니다. 
최단 경로를 고려해보세요. 
P는 s에서 u까지의 
최단경로입니다. 
그것은 이 경로의 무게가 최단 경로 무게라는 것을 의미합니다. 
우리는 여기서 식을 가집니다. 
우리는 δ(s, u)에 대해 신경 씁니다.
여기 그 무게를 가진 경로가 있습니다. 
최단 경로가 존재하기 때문에 그것은 1입니다, 
그것이 플러스 무한대이면 그것은 약간 예외적인 케이스이지만, 
저는 그것에 대해 걱정하지 않습니다. 
그림을 그리겠습니다. 

Korean: 
우리는 s를 가집니다. 우리는 u를 가집니다. 
여기 s에서 u까지의 최단경로가 있습니다. 
그것은 p입니다. 그것이 무엇과 같아 보이는지 생각이 없습니다. 
우리가 가지는 것은 s의 개념입니다. 
저는 대문자 S를 그릴 것입니다. 
이것은 S입니다.
우리는 작은 s가 큰 S 안에 있다는 것을 압니다. 
U는 아직 큰 S 안에 있지 않습니다. 
저는 아무 것도 망치지 않았습니다.
이 경로는 S에서 시작하고 그것을 어떤 점에 남깁니다 
우리가 u를 S에 더할 때까지, 그것이 일어나지 않기 때문입니다, 
그래서 U는 큰 S 안에 있지 않습니다
제가 원하는 것은 경로 p가 존재하는 
첫 번째 장소를 보는 것입니다. 

English: 
So, we have s.
We have u.
Here is the shortest path from
s to u.
That's p.
No idea what it looks like so
far.
Now, what we also have is the
notion of capital S.
So, I'm going to draw capital
S.
So, this is big S.
We know that little s is in big
S.
We know that u is not yet in
big S.
So, I haven't screwed up
anything yet,
right?
This path starts in S and
leaves it at some point because
until we are about to add u to
S, so it hasn't happened yet,
so u is not in S.
Fine.
What I want to do is look at
the first place here where the
path, p, exits S.

English: 
So, there is some vertex here.
Let's call it x.
There's some vertex here.
We'll call it y.
OK, possibly x equals S.
Possibly y equals u.
But it's got to exit somewhere,
because it starts inside and
ends up outside.
And it's a finite path.
OK, so consider the first time
it happens; not the second time,
the first.
OK, so consider the first edge,
(x,y), where p exits capital S.
The shortest path from s to u
exits capital S.
It's got to happen somewhere.
Cool, now, what do we know?
Little x is in S.
So, it has the right answer
because u, we were about to add
u to S, and that was the first
violation of something in S that

Korean: 
여기 정점이 있습니다. 그것을 x라고 합시다. 
여기 정점이 있습니다. 그것을 y라고 합시다. 
X는 S와 같을 수 있습니다. Y는 u와 같을 수 있습니다. 
그러나 그것은 존재합니다, 왜냐하면 그것이 안에서 시작해서 밖에서 끝나기 때문입니다. 
그리고 그것은 유한 경로입니다. 
그래서 첫 번째 시간을 고려해 보세요. 두 번째가 아니라 첫 번째를요. 
첫 번째 모서리 (x,y)를 고려해 보세요, 거기서 p는 존재합니다.
s에서 u까지의 최단경로는 대문자 S에 존재합니다. 
그것은 어디서 일어납니다. 
이제 우리는 무엇을 압니까? 작은 x는 S에 있습니다. 
그것을 옳은 답을 가집니다 우리는 u를 S에 더하려고 했기 때문입니다. 
그리고 그것은 틀린 x의 d 측정을 가지는 첫 번째 위반이었습니다. 

English: 
has the wrong d of x estimate.
So, d of x equals delta of s,
x.
Because we are looking at the
first violation,
x is something that got added
before.
So, by induction on time,
or because we had the first
violation, d of x equals the
shortest path weight from S to
x.
So, that's good news.
Now we are trying to apply this
lemma.
It's the only thing left to do.
We haven't used this lemma for
anything.
So, we have the setup.
If we already know that one of
the d values is the right
answer, and we relaxed the edge
that goes out from it,
then we get another right
answer.
So that's what I want to argue
over here.
We know that the d of x equals
this weight because,
again, subpaths of shortest
paths are shortest paths.
We have optimal substructure,
so this is a shortest path,
from S to x.
It might not be the only one,
but it is one.

Korean: 
d[x]는 δ(s, x) 같습니다. 
우리가 첫 번째 위반을 보기 때문에, 
x는 전에 더하는 것과 같습니다. 
귀납법에 의해서 
또는 우리가 첫 번째 위반을 가지기 때문에 X의 d는 
S에서 x까지의 최단 경로 무게와 같습니다. 
그것은 좋은 소식입니다. 이제 우리는 이 부명제를 적용하려고 합니다
그것은 남은 유일한 것입니다.  
우리는 이 부명제를 사용하지 않았습니다.
우리는 설정을 가집니다. 
우리가 d의 갑 중 하나가 옳은 답이라는 것을 이미 알고, 
그것으로부터 나오는 모서리를 휴식하면, 우리는 또 다른 옳은 답을 얻습니다. 
그것은 제가 주장하고 싶은 것입니다. 
우리는 d[x]가 이 무게와 같다는 것을 압니다. 
최단 경로의 서브 경로는 최단 경로입니다. 
우리는 최적 서브 구조를 가집니다. 
그래서 이것은 S에서 x까지 최단 경로입니다. 
그것은 하나가 아닐 수 있지만, 그것은 하나입니다.

English: 
So we know that matches.
Now, I want to think about
relaxing this edge,
(x,y).
Well, x is in capital S.
And, the algorithm says,
whenever you add a vertex,
u, to the big set,
S, you relax all the edges that
go out from there.
OK, so when we added x to S,
and we now look far in the
future, we're about to add some
other vertex.
Right after we added x to S,
we relax this edge,
(x,y), because we relaxed every
edge that goes out from x,
OK, whatever they were.
Some of them went into S.
Some of them went out.
Here's one of them.
So, when we added x to S,
we got XS.
When we added x to S,
we relaxed the edge,
(x,y).
OK, so now we're going to use

Korean: 
우리는 그것이 매치 된다는 것을 압니다. 
저는 이 모서리 (x,y)를 휴식하는 것에 대해 생각하려고 합니다.
X는 대문자 S에 있습니다. 
여러분이 정점 u를 집합 S에 더할 때 마다 
여러분은 저기서 나오는 모든 정점을 휴식합니다. 
여러분이 x를 S에 더할 때, 우리는 미래에서 봅니다, 
우리는 모든 다른 정점을 더합니다. 
우리가 x를 S에 더한 후에, 우리는 이 모서리 (x,y)를 휴식합니다, 
왜냐하면 우리는 x에서 나오는 모든 것을 휴식했기 때문입니다. 
그것들 중 몇은 S로 갑니다. 
그것들 중 몇은 나옵니다. 여기 그것들 중 하나가 있습니다. 
우리가 x를 S에 더할 때, 우리는 XS를 얻습니다. 
우리가 x를 S에 더할 때, 우리는 모서리 (x,y)를 휴식시킵니다. 
그래서 이제 우리는 부명제를 사용할 것입니다.

Korean: 
부명제에 의해 
여러분은 무엇을 얻습니까? 우리는 이 정확한 최단 경로 무게를 x에 더합니다. 
우리는 모서리 (x,y)를 휴식합니다. 
이제 우리는 y를 위한  
정확한 최단 경로 무게를 가져야 합니다. 
d[y]는 δ(s, y)와 같습니다.
이것은 과거에 그렇습니다. 
특히, 그것은 여전히 옳아야 합니다 
왜냐하면 여러분이 한번 옳은 답을 가지면 여러분을 절대 바꾸지 않기 때문입니다. 
우리는 다 했습니다.
왜죠?
우리는 모순을 위한 것을 가정했고, 
우리는 그것을 반박하고 싶습니다. 
우리는 d[u]가 δ(s, u)보다 엄격히 크다고 가정했습니다.

English: 
the lemma.
So, by the correctness lemma --
What do you get?
Well, we add this correct
shortest path weight to x now.
We relax the edge,
(x,y).
So, now we should have the
correct shortest path weight for
y.
d of y equals delta of s,
y.
OK, this is sometime in the
past.
In particular,
now, it should still be true
because once you get down to the
right answer you never change
it.
OK, we should be done.
OK, why are we done?
Well, what else do we know
here?
We assumed something for
contradiction,
so we better contradict that.
We assume somehow,
d of u is strictly greater than

Korean: 
d[u]는 이 전체 경로 길이 
보다 엄격히 더 큽니다. 
우리는 u가 y와 같은지 모릅니다. 
그것을 그럴 수도 있고 아닐 수도 있습니다. 
그러나 우리는 이 최단 경로에 대해 무엇을 압니까? 
그것은 최단 경로일 수 있습니다 왜냐하면 그것이 서브 경로이기 때문입니다. 
그것은 최단 경로입니다 왜냐하면 그것이 최단 경로의 서브 경로이기 때문입니다. 
S에서 y의 최단 경로는 S에서 u의 
최단 경로 보다 작거나 같아야 합니다.
S에서 y는 S에서 u 보다 작거나 같아야 합니다. 
서브 경로이기 때문입니다.
저는 이제 δ(s, u)를 얻습니다.
저는 d[u]를 포함하고 싶습니다. 

English: 
delta of s, u.
So, d of u here is strictly
greater than the length of this
whole path.
Well, we don't really know
whether u equals y.
It could, could not.
And, but what do we know about
this shortest path from S to y?
Well, it could only be shorter
than from S to u because it's a
subpath.
And it's the shortest path
because it's the subpath of the
shortest path.
The shortest path from S to y
has to be less than or equal to
the shortest path from S to u.
OK, S to y: less than or equal
to s, u, OK, just because the
subpath.
I'm closer.
I've got delta of s,
u now.
Somehow, I want to involve d of
u.

Korean: 
저는 d[y]를 d[u]와 연결하고 싶습니다. 
저는 d[u]에 대하여 무엇을 압니까? 네?
d[u]는 더 작습니다 왜냐하면 우리는 최소 힙을 가지기 때문입니다. 
우리는 항상 고릅니다, 
지워 봅시다, 그것은 여기 아래로 입니다. 
우리는 u를 골랐습니다. 이것은 알고리즘의 중간입니다. 
그것은 제가 이것을 최소 키로 가지는 이유입니다. 
이것은 d에 입력되었습니다. 
우리는 이 점에서, u를 S에 더할 때, y가 S에 있고, 
u가 S에 있지 않다는 것을 압니다.
그것들은 사실 같은 정점입니다. 
그러나 둘 다 
S 밖에 있습니다. 
우리는 u를 골랐습니다 왜냐하면 d[u]는 최소의 d 측정을 가지기 때문입니다. 
d[y]는 d[u]보다 크거나 같아야 합니다. 
그것은 같은 정점이면 같을 것이지만, 
그것은 더 크거나 같아야 합니다.

English: 
So, I want to relate d of y to
d of u.
What do I know about d of u?
Yeah?
d of u is smaller because we
have a Min heap,
yeah.
We always chose,
let's erase,
it's way down here.
We chose u.
This is the middle of the
algorithm.
It's the reason I kept this to
be the minimum key.
This is keyed on d.
So, we know that at this
moment, when we're trying to add
u to S, right,
y is not in S,
and u is not in S.
They might actually be the same
vertex.
But both of these vertices,
same or not,
are outside S.
We chose u because d of u has
the smallest d estimate.
So, d of y has to be greater
than or equal to d of u.
It might be equal if they're
the same vertex,
but it's got to be greater than
or equal to.

English: 
So, d of y here is greater than
or equal to d of u.
So, here we're using the fact
that we actually made a greedy
choice.
It's the one place we're using
the greedy choice.
Better use it somewhere because
you can't just take an arbitrary
vertex and declare it to be
done.
You've got to take the greedy
one.
OK, now we have d of u is less
than or equal to delta of s,
u, which contradicts this.
OK, sort of magical that that
all just worked out.
But sort of like the previous
proofs, you just see what
happens and it works.
OK, that's the approximation.
The only real idea here is to
look at this edge.
In fact, you could look at this
edge too.
But let's look at some edge
that comes from S and goes out
of S, and argue that while x has
to be correct,
and what we made x correct,
y had to be correct,
and now, why the hell are we
looking at u?
y is the thing you should have
looked at.
And, there you get a
contradiction because y had the
right answer.
If u equals y,
that's fine,
or if u and y were sort of

Korean: 
d[y]는 d[u]보다 크거나 같습니다. 
여기서 우리는 탐욕 선택을 한 사실을 사용합니다. 
탐욕 선택을 사용하는 유일한 곳입니다. 
여러분이 임의의 정점을 가지고 그것을 선언할 수 없기 때문에 
그것을 사용하는 것이 낫습니다. 
여러분은 탐욕을 가져야 합니다. 
이제 d[u]는 δ(s, u)보다 작거나 같고,  
그것은 이것을 부정합니다.
일종의 마법입니다. 
그러나 여러분은 이전의 증명을 보았습니다. 
그것은 근사입니다.
유일한 실제 생각은 이 모서리를 보는 것입니다. 
사실, 여러분은 이 모서리를 볼 수 있습니다.
그러나 S에서부터 오고 S에서 나오는 것을 봅시다, 
x가 옳은 동안, 
y도 옳습니다 
왜 우리는 u를 보나요?
Y는 여러분이 보아야 하는 것입니다. 
여러분은 모순을 얻습니다 왜냐하면 y는 옳은 답을 가지기 때문입니다.
u가 y와 같으면, 
그것은 좋습니다, 또는 u와 y가 동등하게 좋으면, 

Korean: 
모든 무게가 0이면 좋습니다.
그림은 사실 이와 같아 보입니다. 
그 케이스에서, 
u의 d는 옳은 답입니다. 그것은 델타 SU입니다. 
우리는 그것이 그렇지 않다고 가정했습니다. 그것은 모순을 얻는 곳입니다. 
분명한가요? 
이 증명으로 갑시다. 그것은 더 복잡합니다. 
우리는 더 다뤄야 할 것이 있는데, 
더 쉽습니다. 첫 번째는 이 알고리즘의 
러닝 타임은 무엇인가요?
저는 이것을 매우 빠르게 할 것입니다 왜냐하면 우리는 이것을 지난 수업 전에 많이 보았기 때문입니다. 
초기화가 있습니다. 
초기화는 여기서 선형 시간입니다. 
큰 문제가 아닙니다. 
최소값을 추출하세요. 그것은 어떤 데이터 구조입니다. 
우리는 V의 크기와 같은 것을 가집니다. 
우리는 최소값을 추출합니다.

English: 
equally good,
that's also fine if all these
weights were zero.
So, the picture might actually
look like this.
But, in that case,
d of u is the correct answer.
It was delta SU.
We assumed that it wasn't.
That's where we're getting a
contradiction.
Pretty clear?
Go over this proof.
It's a bit complicated,
naturally.
OK, we have a little bit more
to cover, some easier stuff.
OK, the first thing is what's
the running time of this
algorithm?
I'll do this very quick because
we're actually seen this many
times before last class.
There was some initialization.
The initialization,
which is no longer here,
is linear time.
No big deal.
OK, extract Min.
Well, that's some data
structure.
So, we have something like size
of V.
Every vertex we extract the Min

Korean: 
그것은 매우 간단합니다. 우리
는 이 메인 루프를 가졌습니다. 
이것은 완벽히 개념적인 연산입니다. S는 사실 알고리즘에서 사용되는 것이 아닙니다. 
그것은 생각하기 위한 것입니다. 
그래서 이것은 0의 시간이 듭니다. 그것을 좋아하세요. 
이제 핵심이 여기 있습니다. 이 루프는 얼마나 많이 반복합니까? 
그것은 u의 차수입니다. 
이것은 우리가 휴식 단계를 실행하는 총 횟수 인가요? 
그것은 필수적으로 우리가 이것을 하는 것을 의미하지 않지만 
우리는 적어도 이것을 수행합니다. 
전체 알고리즘 내내, 우리는 얼마나 많이 이것을 하나요? 
우리는 저기로부터 나오는 모든 모서리를 봅니다.

English: 
once, and that's it.
So, size of V,
extract mins.
OK, so that's pretty simple.
OK, then we had this main loop.
This is a completely conceptual
operation.
S is not actually used in the
algorithm.
It's just for thinking.
OK, so this takes zero time.
Got to love it.
OK, and now the heart is here.
So, how many times does this
loop iterate?
That's the degree of u.
So, what is the total number of
times that we execute a
relaxation step?
It doesn't necessarily mean we
do this, but we at least execute
this body.
Over the whole algorithm,
how many times do we do this?
Every vertex,
we look at all the outgoing

English: 
edges from there.
So, the total would be?
Number of edges,
yeah.
So, this number of edges
iterations.
OK, this is essentially the
handshaking lemma we saw last
time, but for directed graphs.
And we are only looking at the
outgoing edges.
So, it's not a factor of two
here because you're only
outgoing from one side.
So, we have number of
reiterations.
In the worst case,
we do a decreased key for
everyone.
So, at most:
E decreased keys.
OK, so the time is,
well, we have v extract Mins,
so the time to do an extract

Korean: 
총 합은 무엇인가요? 
모서리의 수입니다. 
이 모서리 반복의 수입니다. 
이것은 우리가 지난 시간에 본 악수 부명제입니다, 
그러나 무방향 그래프를 위한 것입니다. 우리는 나오는 모서리를 봅니다. 
그것은 두 인자가 아닙니다 
왜냐하면 여러분은 나오는 것이기 때문입니다. 
우리는 재반복의 수를 가집니다. 
I최악의 케이스에서, 우리는 모두를 위한 
감소 키를 합니다. 
E는 키를 감소시킵니다. 
시간은 우리가 최소를 추출하는 것입니다.

Korean: 
E는 키를 감소시킵니다. 
그리고 이것은 지난 시간의 최소 스패닝 트리를 위한 프림의 
알고리즘에서 우리가 가졌던 러닝 타임입니다. 
그것은 여러분이 사용하는 
데이터 구조에 달렸습니다. 
저는 여기서 전체 테이블을 스킵할 것입니다. 
그러나 여러분이 배열을 사용하면, 
최종 러닝 타임은 V^2일 것입니다 
왜냐하면 여러분은 O(v)를 가지고 
우리는 O(lg v)를 가지기 때문입니다. 
이것은 O((V + E) lg V) 입니다. 

English: 
Min, whatever that is.
And we have E decreased keys,
whatever that is,
and this is exactly the running
time we had for Prim's algorithm
for a minimum spanning tree last
time.
And, it depends what data
structure you use,
what running time you get.
So, I'm going to skip the whole
table here.
But, if you use an array,
the final running time will be
V^2 because you have order of v
extract Min, and you have
constant time decreased key.
If you use a binary heap,
which we know and love,
then we have order log v for
each operation.
And so, this is V plus E log V.

Korean: 
그것은 우리가 아는 것입니다.
여러분이 피보나치 힙이라는 훌륭한 데이터 구조를 사용하면, 
여러분은 감소된 정수 시간을 얻습니다. 
여러분은 러닝 타임에 바운드 되는 O((E + v) lg v)를 얻습니다. 
이것은 추가 가정 없이 
최단 경로를 푸는 최고의 방법입니다. 
일반적으로 음이 아닌 모서리 무게를 가진 단일 소스 최단 경로입니다. 
이것은 거의 좋고 
때때로 그것보다 낫습니다. 
그러나 이것들은 필수적으로 관련이 없습니다. 그것을 제외하고 여러분은 이것을 하는 방법을 압니다. 
여러분은 책에서 그것을 보지 않았으면 
피보나치 힙을 하는 방법을 모릅니다. 
그것은 여러분이 두 러닝 타임을 언급한 이유입니다. 
저는 더 간단한 케이스에 대해 간단히 이야기하고 싶습니다. 여러분은 전에 보았습니다.
그래서 이것을 그래프에서 연결하는 것은 

English: 
And, so that's what we know how
to do.
And, if you use this fancy data
structure called a Fibonacci
heap, you get constant time
decreased key amortized.
And, you get an E plus v log v
worst case bound on the running
time.
So, this is the best we know
how to solve shortest paths
without any extra assumptions,
single source shortest paths
with non-negative edge weights
in general.
OK, this is almost as good and
this is sometimes better than
that.
But these are essentially
irrelevant except that you know
how to do these.
You don't know how to do a
Fibonacci heap unless you read
that in the chapter of the book.
That's why we mention the top
two running times.
OK, I want to talk briefly
about a simpler case,
which you may have seen before.
And so it's sort of fun to

Korean: 
재미있습니다.
그것은 Dijkstra를 끝냅니다. 
그러나 저는 w(u,v)가 모든 정점의 하나와 같은 
특별한 케이스에 대해 생각하고 싶습니다. 
우리가 그 속성을 가진다고 가정해보세요. 
우리는 (u,v) 보다 더 나은 것을 할 수 있나요? 
우리는 이 러닝 타임 보다 더 나은 것을 할 수 있나요? 
우리는 아마 모든 모서리와 정점을  
보아야 합니다.
제가 질문하는 유일한 것은 이 lg v 입니다.
제가 그것을 피할 수 있나요? 저는 답을 주었습니다. 
답은 넓이 우선 검색 또는 BFS 입니다
그것은 전에 보았던 것입니다. 
깊이 우선 검색 다음에,  
그것은 그래프를 보는 표준의 방법 중 하나입니다.
그러나 우리는 여러분이 전에 보았던 것 보다 더 할 수 있습니다. 

English: 
connect this up to breadth first
search in a graph.
So, I mean that ends Dijkstra,
so to speak.
But now I want to think about a
special case where the graph is
unweighted, meaning w of (u,v)
equals one for all vertices,
u and v.
OK, suppose we had that
property.
Can we do any better than
Dijkstra?
Can we do better than this
running time?
Well, we probably have to look
at all the edges and all the
vertices.
So, the only thing I'm
questioning is this log v.
Can I avoid that?
I gave away the answer a little
bit.
The answer is called breadth
first search,
or BFS, which you have probably
seen before.
Next to depth first search,
it's one of the standard ways
to look at the graph.
But we can say a little bit
more than you may have seen
before.
Breadth for search is actually

Korean: 
검색을 위한 넓이는 Dijkstra 알고리즘입니다. 
훌륭해요. 두 변화가 있습니다. 
첫 변화는 검색을 위한 넓이가 우선순위 큐를 사용하지 않는다는 것입니다. 
저는 여러분에게 그것이 대신 사용하는 것을 알려줄 것입니다. 
여러분은 우선순위 큐 대신 
선입선출 큐를 사용할 수 있습니다.
그것은 작동합니다. 최소를 추출하는 대신, 
여러분은 첫 번째를 취합니다. 
감소 키를 하는 대신, 여기 미묘한 것이 잇습니다.
문장이 약간 변하면요. 
여기 휴식 단계가 있습니다. 
휴식하기 위해, 여러분은 이것을 더 간단한 것이라고 말합니다. 
우리가 v를 아직 방문하지 않았으면, 

English: 
Dijkstra's algorithm:
kind of nifty.
There are two changes.
First change is that breadth
for search does not use a
priority queue.
I'll just tell you what it uses
instead.
You can use a queue first in
first out honest-to-goodness
queue instead of a priority
queue.
OK, it turns out that works.
Instead of doing extract Min,
you just take the first thing
off the queue.
Instead of doing decreased key,
OK, here's a subtlety.
But, this if statement changes
a little bit.
So, here is the relaxation
step.
So, in order to relax,
you say this much simpler
thing.
If we haven't visited v yet,

English: 
then we declare it to have the
shortest path weight,
say, d of v is d of u plus one,
which is the weight of the
edge, (u,v).
And we add v to the end of the
queue.
So, now, we start with the
queue empty.
Actually, it will just contain
the vertex, S,
because that's the only thing
we know the shortest path for.
So, the queue is just for,
I know the shortest path of
this thing.
Just deal with it when you
can't look at all the outgoing
edges when you can.
So, initially that's just S.
You say, well,
for all the outgoing edges,
S has zero.
All the outgoing edges from
there have weight one.
The shortest path weight from
the source is one.
You certainly can't do any
better than that if all the
weights are one.
OK, so we add all those
vertices to the end of the
queue.
Then, we process things in
order, and we just keep
incrementing,
if their value is d of u,
add one to it.

Korean: 
우리는 그것을 최단 경로 무게를 가진다고 선언합니다. 
d[v]는 d[u]+1 입니다, 그것은 (u,v)의 무게입니다.
우리는 v를 큐의 마지막에 더합니다. 
우리는 빈 큐에서 시작합니다. 
사실, 그것은 정점을 포함합니다 
왜냐하면 그것이 우리가 아는 
유일한 것이기 때문입니다. 
저는 최단 경로를 압니다. 
그것을 다뤄봅시다. 
초기에 그것은 S였습니다. 
모든 나오는 모서리를 위해, S는 0을 가집니다. 
저기서 나오는 모든 모서리는 무게 1을 가집니다. 
소스로부터 최단 경로 무게는 1입니다. 
여러분은 모든 무게가 1이면 
더 나은 것을 할 수 없습니다. 그
래서 우리는 큐의 마지막에 모든 정점을 더합니다. 
우리는 순서대로 처리하고, 
계속 증가시킵니다, 
값이 d[u]이면, 그것에 1을 더합니다. 

Korean: 
그것은 d[v]입니다.
그리고 우리는 v를 S에 더합니다. 
그것은 검색을 위한 넓이입니다 매우 간단합니다. 
여러분은 알고리즘을 위한 텍스트를 볼 수 있습니다  
왜냐하면 저는 그것을 다룰 시간이 없거든요.
그러나 핵심은 시간이 더 빠르다는 것입니다 
시간은 O( V + E )입니다, 
우리는 모든 정점으로부터 나오는 모든 모서리를 보면 각 정점을 보기 때문입니다. 
우리가 d[v]를 설정하자마자, 
그것은 그것을 남깁니다. 우리는 그것을 절대 건드리지 않습니다. 
우리는 그것을 S에 더합니다.  
그것은 한 번 일어납니다.
그것은 오더 E 시간에 정확히 수행됩니다. 
그것은 우리가 최소값 추출 대신 
사용하는 것입니다. 
그래서 총 러닝 타임은

English: 
That's d of v.
And then we are going to add v
to S what we get to it in the
queue.
OK, that is breadth for search,
very simple.
And, you can look at the text
for the algorithm and for an
example because I don't have
time to cover that.
But the key thing is that the
time is faster.
The time is order V plus E
because as before,
we only look at each edge once
we look at all the outgoing
edges from all the vertices.
As soon as we set d of v to
something, it will remain that.
We never touch it.
We are going to add it to S.
That only happens once.
So, this if statement,
and so on, in the in-queuing,
is done order E times,
or actually E times,
exactly.
An in-queuing to a queue,
and de-queuing from a queue,
that's what we use instead of
extract Min, take constant time,
so the total running time,

English: 
number of vertices plus the
number of edges.
OK, not so obvious that this
works, but you can prove that it
works using the Dijkstra
analysis.
All you have to do is prove
that the FIFO priority queue.
Once you know that,
by the correctness of Dijkstra
you get the correctness of
breadth for search.
So, not only is breadth for
search finding all the vertices,
which is maybe what you
normally use it for,
but it finds the shortest path
weights from S to every other
vertex when the weights are all
one.
So, there we go:
introduction to shortest paths.
Next time we'll deal with
negative weights.

Korean: 
정점의 수 더하기 모서리의 수입니다.
이것이 동작하는 것은 분명하지 않습니다, 
그러나 여러분은 Dijkstra 분석을 사용하여 그것이 동작하는지 증명할 수 있습니다. 
여러분이 해야 하는 모든 것은 FIFO 우선순위 큐를 증명하는 것입니다. 
여러분이 그것을 한번 알면 Dijkstra의 정확성에 의해 
여러분은 검색의 넓이 정확성을 얻습니다. 
이것이 여러분이 보통 사용하는 모든 정점을 찾는 
검색을 위한 넓이일 뿐만 아니라, 
그것은 무게가 모두 1일 때 S에서 모든 정점까지의 
최단 경로 무게를 찾습니다. 
여기서 우리는 갑니다, 최단 경로의 도입입니다. 
다음 시간에 우리는 음의 무게에 대해 다룰 것입니다.
