
English: 
Good morning,
everyone.
Glad you are all here bright
and early.
I'm counting the days till the
TA's outnumber the students.
They'll show up.
We return to a familiar story.
This is part two,
the Empire Strikes Back.
So last time,
our adversary,
the graph, came to us with a
problem.
We have a source,
and we had a directed graph,
and we had weights on the
edges, and they were all
nonnegative.
And there was happiness.
And we triumphed over the
Empire by designing Dijkstra's
algorithm, and very efficiently
finding single source shortest

Korean: 
이 강의 한글자막은 www.snow.or.kr 자원활동가들에 의해 작성되었습니다. 
좋은 아침입니다. 
여러분이 모두 여기 있어서 기쁩니다. 
저는 수업 조교가 학생 수 보다 더 많은 날을 세고 있습니다. 
다른 학생들도 오겠죠. 우리는 친숙한 이야기로 돌아갑니다. 
이것은 파트 2 Empire Strikes Back 입니다. 
지난 시간에, 
우리는 그래프 문제를 했습니다. 
우리는 소스를 가지고 방향 그래프를 가지고,  
모서리에서 무게를 가지고, 그것들은 모두 음이 아닙니다.
그리고 행복이 있었습니다. 
그리고 우리는 Dijkstra 알고리즘을 설계하면서 제국에 승리했습니다, 
그것은 s에서 다른 정점들로의 

Korean: 
단일 소스 최단 경로를 효율적으로 찾는 것입니다.
오늘은 Death Star가 있습니다, 
우리는 음의 무게를 가집니다. 
그리고 우리는 음의 무게 사이클을 
다루어야 합니다. 
우리가 음의 무게 사이클을 가질 때, 
우리는 계속 해서, 
먼 시간에 
돌아 온다는 것을 보았습니다. 
우리는 과거에 임의대로 멀 수 있었습니다. 
그리고 최단 경로가 없습니다 
그리고 최단 경로가 없습니다 
우리는 오늘 이 이슈를 제기하고 
Dijkstra 보다 더 간단한 새 알고리즘을 떠올릴 것입니다,
 그것은 Bellman-Ford 알고리즘입니다.
그것은 음의 무게를 허용하고, 
여러분이 바라지 않더라도, 
음의 무게 사이클을 허용합니다
우리는 공간을 남겨 두어야 합니다. 

English: 
paths, shortest path weight from
s to every other vertex.
Today, however,
the Death Star has a new trick
up its sleeve,
and we have negative weights,
potentially.
And we're going to have to
somehow deal with,
in particular,
negative weight cycles.
And we saw that when we have a
negative weight cycle,
we can just keep going around,
and around, and around,
and go back in time farther,
and farther,
and farther.
And we can get to be
arbitrarily far back in the
past.
And so there's no shortest
path, because whatever path you
take you can get a shorter one.
So we want to address that
issue today, and we're going to
come up with a new algorithm
actually simpler than Dijkstra,
but not as fast,
called the Bellman-Ford
algorithm.
And, it's going to allow
negative weights,
and in some sense allow
negative weight cycles,
although maybe not as much as
you might hope.
We have to leave room for a

Korean: 
Bellman-Ford 알고리즘은 
두 명에 의해 고안된 것입니다, 
그것은 최단 경로 무게를 계산합니다. 
그것은 무게에 대한 가정을 하지 않습니다. 
무게는 임의적이고, 그것은 최단 경로 무게를 계산합니다. 
δ(s, v)가 s에서 v까지의 
최단 경로 무게라는 개념을 기억하세요.
우리는 모든 정점을 위한 무게를 
계산하고 싶습니다. 
s로부터 모든 곳으로의 것을 계산하는 것은 s에서 
특정 지역으로의 것 보다 더 어렵지 않습니다. 
우리는 모두 할 것입니다. 
그것은 여전히 케이스입니다. 
그것은 음의 무게를 허용합니다. 

English: 
sequel, of course.
OK, so the Bellman-Ford
algorithm, invented by two guys,
as you might expect,
it computes the shortest path
weights.
So, it makes no assumption
about the weights.
Weights are arbitrary,
and it's going to compute the
shortest path weights.
So, remember this notation:
delta of s, v is the weight of
the shortest path from s to v.
s was called a source vertex.
And, we want to compute these
weights for all vertices,
little v.
The claim is that computing
from s to everywhere is no
harder than computing s to a
particular location.
So, we're going to do for all
them.
It's still going to be the case
here.
And, it allows negative
weights.

Korean: 
이것은 좋은 케이스이지만, 
대안이 있습니다, 
음의 무게 사이클이 있습니다. 
그 케이스입니다. 
그들은 음의 무게 사이클이 존재한다고 말합니다. 
그러므로, 이 델타 중 몇몇은 마이너스 무한대입니다. 
그리고 그것은 이상해 보입니다.
Bellman-Ford는 케이스를 위해 의도된 것입니다, 
그러나 음의 무게 사이클이 없습니다, 그것은 더 직관적인 것입니다. 
그것은 허용하지만 그것들을 기록할 것입니다. 
그 케이스에서, 그것은 여러분에게 델타 값을 주지 않습니다. 
여러분은 델타 값을 주기 위해 
알고리즘을 바꿀 수 있지만 우리는 그것을 
여기서 보지 않을 것입니다. 
알고리즘을 본 후에, 연습은, 

English: 
And this is the good case,
but there's an alternative,
which is that Bellman-Ford may
just say, oops,
there's a negative weight
cycle.
And in that case it will just
say so.
So, they say a negative weight
cycle exists.
Therefore, some of these deltas
are minus infinity.
And that seems weird.
So, Bellman-Ford as we'll
present it today is intended for
the case, but there are no
negative weights cycles,
which is more intuitive.
It sort of allows them,
but it will just report them.
In that case,
it will not give you delta
values.
You can change the algorithm to
give you delta values in that
case, but we are not going to
see it here.
So, in exercise,
after you see the algorithm,
exercise is:

English: 
compute these deltas in all
cases.
So, it's not hard to do.
But we don't have time for it
here.
So, here's the algorithm.
It's pretty straightforward.
As I said, it's easier than
Dijkstra.
It's a relaxation algorithm.
So the main thing that it does
is relax edges just like
Dijkstra.
So, we'll be able to use a lot
of dilemmas from Dijkstra.
And proof of correctness will
be three times shorter because
the first two thirds we already
have from Dijkstra.
But I'm jumping ahead a bit.
So, the first part is
initialization.

Korean: 
모든 케이스에서 이 δ를 계산하는 것입니다.
그것은 어렵지 않습니다. 우리는 여기서 할 시간이 없습니다. 
여기 알고리즘이 있습니다. 
그것은 매우 간단합니다. 제가 말한 대로, Dijkstra 보다 더 쉽습니다. 
그것은 휴식 알고리즘입니다. 
그것이 하는 주요한 것은 Dijkstra와 같이 모서리를 휴식시키는 것입니다.
우리는 Dijkstra로부터 많은 딜레마를 사용할 수 있습니다. 
정확성의 증명은 
세 배 더 짧습니다 두 개가 이미 Dijkstra에서 본 것이기 때문입니다. 
우리는 미리 나가 있습니다. 
첫 부분은 초기화입니다. 

English: 
Again, d of v will represent
the estimated distance from s to
v.
And we're going to be updating
those estimates as the algorithm
goes along.
And initially,
d of s is zero,
which now may not be the right
answer conceivably.
Everyone else is infinity,
which is certainly an upper
bound.
OK, these are both upper bounds
on the true distance.
So that's fine.
That's initialization just like
before.
And now we have a main loop
which happens v minus one times.
We're not actually going to use
the index i.
It's just a counter.

Korean: 
다시 v의 d는 s에서 v의 거리를 측정하는 것을 나타냅니다.
알고리즘이 계속 되면서 
우리는 이 측정을 업데이트할 것입니다. 
초기에 s의 d는 0입니다, 
그것은 옳은 답이 아닙니다.
모든 것은 무한대이고, 그것은 확실히 상계입니다. 
이것들은 모두 상계입니다. 
그것은 좋습니다. 
그것은 전과 같이 초기화입니다. 
그리고 이제 우리는 v-1 번 일어나는 메인 루프를 가집니다. 
우리는 사실 인덱스 i를 사용하지 않을 것입니다. 
그것은 단지 카운터입니다.

English: 
And we're just going to look at
every edge and relax it.
It's a very simple idea.
If you learn about relaxation,
this is the first thing you
might try.
The question is when do you
stop.
It's sort of like I have this
friend to what he was like six
years old he would claim,
oh, I know how to spell banana.
I just don't know when to stop.
OK, same thing with relaxation.
This is our relaxation step
just as before.
We look at the edge;
we see whether it violates the
triangle inequality according to
our current estimates we know
the distance from s to v should
be at most distance from s to
plus the weight of that edge
from u to v.
If it isn't,
we set it equal.

Korean: 
우리는 모든 모서리를 보고 그것을 휴식시킵니다. 
그것은 간단한 생각입니다. 
여러분이 휴식에 대해 배웠으면, 이것은 여러분이 시도하는 첫 번째입니다. 
질문은 언제 여러분이 멈추는가 입니다. 
저는 6살인 친구가 있습니다, 
저는 바나나의 스펠링을 압니다. 
저는 언제 멈추는지 모릅니다. 휴식에도 같은 것이 있습니다. 
이것은 전과 같이 우리의 휴식 단계입니다. 
우리는 모서리를 봅니다. 
우리는 그것이 현재 측정에 따라 삼각 부등식을 위반하는지 봅니다. 
s에서 v의 거리는 s에서의 거리 더하기 
u에서 v의 모서리의 무게이어야 합니다. 
그렇지 않으면, 우리는 같게 설정합니다. 

English: 
We've proved that this is
always an OK thing to do.
We never violate,
I mean, these d of v's never
get too small if we do a bunch
of relaxations.
So, the idea is you take every
edge.
You relax it.
I don't care which order.
Just relax every edge,
one each.
And that do that V minus one
times.
The claim is that that should
be enough if you have no
negative weights cycles.
So, if there's a negative
weight cycle,
we need to figure it out.
And, we'll do that in a fairly
straightforward way,
which is we're going to do
exactly the same thing.
So this is outside before loop
here.
We'll have the same four loops
for each edge in our graph.
We'll try to relax it.
And if you can relax it,

Korean: 
우리는 이것이 항상 괜찮다는 것을 증명했습니다.
우리는 위반하지 않습니다, d의 v는 
우리가 많은 휴식을 하면 절대 작지 않습니다. 
여러분은 모든 모서리를 가집니다.  
여러분은 그것을 휴식시킵니다. 저는 순서를 신경 쓰지 않습니다.
단지 모든 모서리를 휴식시킵니다.
V-1 번 합니다. 
그것은 여러분이 음의 무게 사이클을 가지지 않으면 충분합니다. 
음의 무게 사이클이 있으면, 
우리는 그것을 알아낼 필요가 있습니다. 
우리는 그것을 꽤 간단한 방법으로 할 것이고, 
그것은 우리가 할 것과 같은 것입니다. 
이것은 루프 전에 밖에 있습니다. 
우리는 그래프에서 각 모서리에 대해 같은 네 루프를 가집니다. 
우리는 그것을 휴식시킬 것입니다. 

English: 
the claim is that there has to
be a negative weight cycle.
So this is the main thing that
needs proof.
OK, and that's the algorithm.
So the claim is that at the
ends we should have d of v,
let's see, L's so to speak.
d of v equals delta of s comma
v for every vertex,
v.
If we don't find a negative
weight cycle according to this
rule, that we should have all
the shortest path weights.
That's the claim.
Now, the first question is,
in here, the running time is
very easy to analyze.
So let's start with the running
time.
We can compare it to Dijkstra,

Korean: 
여러분이 그것을 휴식시킬 수 있으면, 음의 무게 사이클이 있습니다.
이것은 증명이 필요한 주요한 것입니다. 
그리고 그것이 알고리즘입니다.  
마지막에 우리는 d[v]를 가져야 합니다. 
d[v]는 δ(s, v)와 같습니다.
우리가 이 법칙에 따라 음의 무게 사이클을 찾지 않으면, 
우리는 모든 최단 경로 무게를 가집니다. 
그것이 주장입니다. 
첫 번째 질문은 러닝 타임은 매우 분석하기 쉽습니다. 
러닝 타임으로 시작합시다. 
우리는 그것을 여기 Dijkstra와 비교할 수 있습니다.

English: 
which is over here.
What is the running time of
this algorithm?
V times E, exactly.
OK, I'm going to assume,
because it's pretty reasonable,
that V and E are both positive.
Then it's V times E.
So, this is a little bit
slower, or a fair amount slower,
than Dijkstra's algorithm.
There it is:
E plus V log V is essentially,
ignoring the logs is pretty
much linear time.
Here we have something that's
at least quadratic in V,
assuming your graph is
connected.
So, it's slower,
but it's going to handle these
negative weights.
Dijkstra can't handle negative
weights at all.
So, let's do an example,
make it clear why you might

Korean: 
이 알고리즘의 러닝 타임은 무엇입니까? 
V 곱하기 E 입니다. 
저는 그것이 합리적이기 때문에, V 와 E가 모두 
양이라고 가정할 것입니다. 그것은 V 곱하기 E 입니다. 
이것은 Dijkstra 보다 약간 더 느립니다. 
그것은 (E+V) lg V 입니다 
로그를 무시하는 것은 더 선형 시간입니다. 
여기서 우리는 그래프가 연결되었다고 가정하면, 
v에서 2차인 것을 가집니다. 
그것은 더 느리지만 
이 음의 무게를 다룰 것입니다. 
Dijkstra는 음의 무게를 전혀 다룰 수 없습니다. 
예를 해 봅시다, 여러분은 이 알고리즘이 동작하는 이유를 더 명확히 합니다.

Korean: 
물론, 우리는 증명할 것입니다. 
그러나 증명은 매우 간단합니다. 
저는 음의 무게를 가지는 그래프를 그리지만, 
음의 무게 사이클은 아닙니다  
그래서 저는 흥미로운 답을 얻습니다.
제가 이 알고리즘의 결과를 잘 정의되도록 

English: 
hope this algorithm works.
And then we'll prove that it
works, of course.
But the proof will be pretty
easy.
So, I'm going to draw a graph
that has negative weights,
but no negative weight cycles
so that I get an interesting
answer.
Good.
The other thing I need in order

Korean: 
하기 위해 필요한 다른 것은, 
여러분이 모서리를 방문하는 순서에 달렸습니다. 
저는 이 모서리에 임의의 순서를 할당할 것입니다. 
저는 여러분에게 순서를 물을 수 있지만, 연속적입니다, 
저는 순서를 둘 것입니다. 
저는 수 4를 두고, 그것은 제가 방문하는 4 번째 모서리입니다.  
그것은 중요하지 않습니다.
그러나 그것은 특정 그래프를 위한 알고리즘 동안에 무엇이 
일어나는지에 영향을 미칩니다.
그들은 모두 얻습니까? 1 2 3 
4 5 6 7 8. 
그리고 제 소스는 A입니다. 
그것입니다. 
저는 이 알고리즘을 돌리고 싶습니다. 저는 모든 것을 초기화할 것입니다. 

English: 
to make the output of this
algorithm well defined,
it depends in which order you
visit the edges.
So I'm going to assign an
arbitrary order to these edges.
I could just ask you for an
order, but to be consistent with
the notes, I'll put an ordering
on it.
Let's say I put number four,
say that's the fourth edge I'll
visit.
It doesn't matter.
But it will affect what happens
during the algorithm for a
particular graph.
Do they get them all?
One, two, three,
four, five, six,
seven, eight,
OK.
And my source is going to be A.
And, that's it.
So, I want to run this
algorithm.
I'm just going to initialize

English: 
everything.
So, I set the estimates for s
to be zero, and everyone else to
be infinity.
And to give me some notion of
time, over here I'm going to
draw or write down what all of
these d values are as the
algorithm proceeds because I'm
going to start crossing them out
and rewriting them that the
figure will get a little bit
messier.
But we can keep track of it
over here.
It's initially zero and
infinities.
Yeah?
It doesn't matter.
So, for the algorithm you can
go to the edges in a different
order every time if you want.
We'll prove that,
but here I'm going to go
through the same order every
time.
Good question.
It turns out it doesn't matter
here.
OK, so here's the starting
point.
Now I'm going to relax every
edge.
So, there's going to be a lot
of edges here that don't do
anything.
I try to relax n minus one.
I'd say, well,

Korean: 
저는 s의 측정을 0으로 둘 것이고 
모든 것은 무한대로 둡니다. 
그리고 제게 시간의 개념을 주기 위해 저는 
d의 모든 것을 쓰거나 그릴 것입니다 
왜냐하면 저는 그것들을 교차시키고 
다시 쓸 것이기 때문입니다. 
그러나 우리는 그것을 계속할 수 있습니다. 
그것은 초기에 0이고 무한대 입니다.
네?
그것은 중요하지 않습니다. 알고리즘을 위해 
여러분은 매번 다른 순서로 모서리를 갈 수 있습니다. 
우리는 증명할 것이지만 
여기서 매번 같은 순서로 할 것입니다. 
좋은 질문입니다. 그것은 여기서 중요하지 않습니다.
여기 시작점이 있습니다. 
이제 저는 모든 모서리를 휴식시킵니다. 
여기 아무 것도 하지 않는 많은 
모서리가 있습니다. 
저는 n-1을 휴식시키려고 합니다. 

Korean: 
저는 s에서 B로가는 방법을 압니다.
s에서 E로 가기 이해 저는 무한대 더하기 2를 얻을 수 있습니다. 
무한대 더하기 2는 무한대 보다 많이 낫지 않습니다. 
저는 아무 것도 하지 않고 이것은 무한대로 업데이트 하지 않습니다. 
무한대 더하기 2는 더 나빠 보입니다. 
무한대 더하기 2는 무한대입니다. 
그것은 모서리 수 1입니다. 관계 모서리 수 2, 
모서리 4가 있고 우리는 흥미로운 것을 얻기 시작합니다. 
제가 여기서 유한 값을 가지기 때문입니다. 
저는 -1의 총 무게를 사용하여 A에서 B까지를 얻을 수 있습니다.
그것은 좋아 보입니다. 
저는 -1을 쓸 것입니다, 그리고 B를 -1로 업데이트 할 것입니다. 
나머지는 똑같이 머뭅니다. 저는 이것을 계속 할 것입니다. 
그것은 모서리 수 4입니다. 
우리는 또한 관계를 얻습니다. 

English: 
I know how to get from s to B
with weight infinity.
Infinity plus two I can get to
from s to E.
Well, infinity plus two is not
much better than infinity.
OK, so I don't do anything,
don't update this to infinity.
I mean, infinity plus two
sounds even worse.
But infinity plus two is
infinity.
OK, that's the edge number one.
So, no relaxation edge number
two, same deal as number three,
same deal, edge number four we
start to get something
interesting because I have a
finite value here that says I
can get from A to B using a
total weight of minus one.
So that seems good.
I'll write down minus one here,
and update B to minus one.
The rest stay the same.
So, I'm just going to keep
doing this over and over.
That was edge number four.
Number five,
we also get a relaxation.

Korean: 
4는 무한대 보다 낫습니다. C는 수 4를 얻습니다. 
우리는 모서리 수 4를 얻습니다. 무한대 더하기 5는 4 보다 나쁩니다.  
저기 휴식이 없습니다.
모서리 수 7은 흥미롭습니다. 왜냐하면 저는 유한 값 – 1 + 이 모서리의 
무게를 가지기 때문입니다, 그것은 3입니다. 
총 2입니다, 
그것은 4 보다 낫습니다. 
이 루트, A, B, c는 사실 
제가 전에 찾은 루트 보다 좋습니다. 
이것은 이제 2입니다. 이것은 모두 메인 루프의 하나의 반복에서 일어납니다.
우리는 좋은 두 경로를 찾았습니다. 
하나가 다른 하나 보다 더 좋다는 것을 알았습니다. 
그것은 모서리 수 7이고, 
8은 여기 있습니다. 
그것은 중요하지 않습니다. 그것은 이 루프의 1입니다. 
I의 첫 번째 값입니다. I는 1입니다. 
이제 우리는 계속합니다. 
계속 할 것입니다. 우리는 모서리 수 1에서 출발합니다. 

English: 
Four is better than infinity.
So, c gets a number of four.
Then we get to edge number six.
That's infinity plus five is
worse than four.
OK, so no relaxation there.
Edge number seven is
interesting because I have a
finite value here minus one plus
the weight of this edge,
which is three.
That's a total of two,
which is actually better than
four.
So, this route,
A, B, c is actually better than
the route I just found a second
ago.
So, this is now a two.
This is all happening in one
iteration of the main loop.
We actually found two good
paths to c.
We found one better than the
other.
OK, and that was edge number
seven, and edge number eight is
over here.
It doesn't matter.
OK, so that was round one of
this outer loop,
so, the first value of i.
i equals one.
OK, now we continue.
Just keep going.
So, we start with edge number

English: 
one.
Now, minus one plus two is one.
That's better than infinity.
It'll start speeding up.
It's repetitive.
It's actually not too much
longer until we're done.
Number two, this is an infinity
so we don't do anything.
Number three:
minus one plus two is one;
better than infinity.
This is vertex d,
and it's number three.
Number four we've already done.
Nothing changed.
Number five:
this is where we see the path
four again, but that's worse
than two.
So, we don't update anything.
Number six: one plus five is
six, which is bigger than two,
so no good.
Go around this way.
Number seven:
same deal.
Number eight is interesting.
So, we have a weight of one
here, a weight of minus three

Korean: 
이제 -1 +2는 1입니다. 
그것은 무한대 보다 낫습니다. 그것은 속도를 올리기 시작합니다. 
그것은 반복합니다. 그것을 우리가 다 할 때까지 더 길지 않습니다. 
2는 무한대이고 우리는 아무 것도 하지 않습니다. 
3입니다  
-1 +2는 1입니다, 무한대 보다 낫습니다.
이것은 정점 d이고 그것은 수 3입니다. 
4는 이미 했습니다. 아무 것도 바뀌지 않습니다. 
5: 이것은 우리가 경로 4를 보는 곳이지만, 
그것은 2 보다 나쁩니다
우리는 아무 것도 업데이트 하지 않습니다. 6: 1 더하기 5는 6입니다,  
그것은 2 보다 크고 좋지 않습니다.
이 방법을 계속 합니다. 7: 같습니다. 
8은 흥미롭습니다. 
우리는 여기서 1의 무게를 가지고, 여기서 3의 무게를 가집니다. 

Korean: 
총 -2입니다. 
그것을 1 보다 낫습니다. 그것은 d였습니다. 
저는 그것이라고 믿습니다. 그것은 그 라운드의 마지막입니다. 
그것은 i+2입니다 왜냐하면 우리는 8번째 모서리를 보았기 때문입니다.
저는 속이고 확인할 것입니다. 
정말로 그것은 마지막입니다.
우리는 d로부터 나오는 모서리를 확인할 것입니다. 
그것이 값이 변하는 유일한 것이기 때문입니다.
더 이상 가능한 휴식은 없습니다. 
그것은 2 라운드에 있습니다. 우리는 모든 최단 경로 무게를 얻습니다. 
알고리즘은 사실 
루프 4 번입니다 왜냐하면 우리는 
여기서 5 정점을 가지고 그것 보다 하나 작기 때문입니다. 
사실, 실행에서 
아래에 두 공백이 있습니다. 

English: 
here.
So, the total is minus two,
which is better than one.
So, that was d.
And, I believe that's it.
So that was definitely the end
of that round.
So, it's I plus two because we
just looked at the eighth edge.
And, I'll cheat and check.
Indeed, that is the last thing
that happens.
We can check the couple of
outgoing edges from d because
that's the only one whose value
just changed.
And, there are no more
relaxations possible.
So, that was in two rounds.
The claim is we got all the
shortest path weights.
The algorithm would actually
loop four times to guarantee
correctness because we have five
vertices here and one less than
that.
So, in fact,
in the execution here there are
two more blank rounds at the
bottom.

English: 
Nothing happens.
But, what the hell?
OK, so that is Bellman-Ford.
I mean, it's certainly not
doing anything wrong.
The question is,
why is it guaranteed to
converge in V minus one steps
unless there is a negative
weight cycle?
Question?
Right, so that's an
optimization.
If you discover a whole round,
and nothing happens,
so you can keep track of that
in the algorithm thing,
you can stop.
In the worst case,
it won't make a difference.
But in practice,
you probably want to do that.
Yeah?
Good question.
All right, so some simple
observations,
I mean, we're only doing
relaxation.
So, we can use a lot of our
analysis from before.
In particular,
the d values are only
decreasing monotonically.
As we cross out values here,
we are always making it
smaller, which is good.
Another nifty thing about this

Korean: 
아무 것도 일어나지 않습니다.
그것이 Bellman-Ford입니다. 
그것은 확실히 아무 나쁜 것을 하지 않습니다. 
음의 무게 사이클이 없으면 그것은 v-1 단계에서 
모여들도록 왜 보장되나요?
질문 있나요? 
네, 그것은 최적화입니다. 
여러분이 전체 라운드를 발견하면, 그리고 아무 것도 일어나지 않으면, 
여러분은 알고리즘에서 계속 할 수 있고, 멈출 수 있습니다. 
최악의 케이스에서, 
그것은 차이가 없습니다. 연습에서 
여러분은 아마 그것을 하길 원합니다. 네? 
좋은 질문입니다. 좋아요, 
그래서 간단한 관찰이 있고, 우리는 휴식을 합니다. 
우리는 많은 분석을 사용할 수 있습니다. 
특히, 
d는 단조적으로 감소합니다. 
우리는 값들을 교차시키고, 
항상 더 작게 만듭니다. 이것에 대해 좋은 다른 것은 

English: 
algorithm is that you can run it
even in a distributed system.
If this is some actual network,
some computer network,
and these are machines,
and they're communicating by
these links, I mean,
it's a purely local thing.
Relaxation is a local thing.
You don't need any global
strategy, and you're asking
about, can we do a different
order in each step?
Well, yeah, you could just keep
relaxing edges,
and keep relaxing edges,
and just keep going for the
entire lifetime of the network.
And eventually,
you will find shortest paths.
So, this algorithm is
guaranteed to finish in V rounds
in a distributed system.
It might be more asynchronous.
And, it's a little harder to
analyze.
But it will still work
eventually.
It's guaranteed to converge.
And so, Bellman-Ford is used in
the Internet for finding
shortest paths.
OK, so let's finally prove that
it works.
This should only take a couple
of boards.

Korean: 
여러분이 그것을 분산 시스템에서도 돌릴 수 있다는 것입니다.
이것이 실제 네트워크이고, 기계들이면, 
그것들은 이 링크에 의해 통신합니다, 
그것은 순수히 지역적인 것입니다.
휴식은 지역적인 것입니다. 여러분은 전체적인 전략이 필요하지 않습니다, 
우리는 각 단계에서 다른 순서를 할 수 있나요? 
여러분은 휴식을 계속 할 수 있고, 
네트워크 전체를 위해 
할 수 있습니다. 
결국 여러분은 최단 경로를 찾습니다. 
이 알고리즘은 분산 시스템에서 V 라운드에 끝나는 것이 보장됩니다. 
그것은 더 비동기적입니다. 
그것은 더 분석하기 어렵습니다.
그러나 그것은 결국 동작합니다. 
그것은 집중되도록 보장되었습니다. 
인터넷에서 최단 경로를 찾기 위해 Bellman-Ford이 사용되었습니다. 
마지막으로 그것이 작동하는지 증명합시다. 
이것은 칠판 몇 개가 듭니다. 

English: 
So let's suppose we have a
graph and some edge weights that
have no negative weight cycles.
Then the claim is that we
terminate with the correct
answer.
So, Bellman-Ford terminates
with all of these d of v values
set to the delta values for
every vertex.
OK, the proof is going to be
pretty immediate using the
lemmas that we had from before
if you remember them.
So, we're just going to look at
every vertex separately.
So, I'll call the vertex v.
The claim is that this holds by
the end of the algorithm.
So, remember what we need to

Korean: 
우리가 그래프를 가지고 음의 무게 사이클을 가지지 않는 
모서리 무게를 가진다고 가정해 보세요. 
우리는 옳은 답에서 종결합니다. 
Bellman-Ford은 v의 d가 모든 정점을 위한 
델타 값으로 설정 되도록 종결했습니다.
증명은 전에 했던 부명제를 사용해서 매우 즉각적인 것입니다. 
우리는 모든 정점을 개별적으로 볼 것입니다. 
저는 정점을 v라고 할 것입니다. 
이것은 알고리즘의 마지막에 의해 유지됩니다. 
우리가 증명할 필요가 있는 것이 

English: 
prove is that at some point,
d of v equals delta of s comma
v because we know it decreases
monotonically,
and we know that it never gets
any smaller than the correct
value because relaxations are
always safe.
So, we just need to show at
some point this holds,
and that it will hold at the
end.
So, by monotonicity of the d
values, and by correctness part
one, which was that the d of v's
are always greater than or equal
to the deltas,
we only need to show that at

Korean: 
d[v]가 δ(s, v)라는 것을 기억하세요. 
여러분은 단조적으로 감소하기 때문입니다 
그것은 정확한 값 보다 더 작아지지 않습니다 
휴식이 항상 안전하기 때문입니다.
우리는 그것이 마지막에 유지된다는 
것을 보여 주어야 합니다.
d 값의 단조성에 의해, 그리고 정확성 부분에 의해, 
그것은 항상 델타보다 크거나 같고,  
우리는 우리가 어떤 점에서 등식을 

English: 
some point we have equality.
So that's our goal.
So what we're going to do is
just look at v,
and the shortest path to v,
and see what happens to the
algorithm relative to that path.
So, I'm going to name the path.
Let's call it p.
It starts at vertex v_0 and
goes to v_1, v_2,
whatever, and ends at v_k.
And, this is not just any
shortest path,
but it's one that starts at s.
So, v_0's s,
and it ends at v.

Korean: 
가진다는 것을 보여주어야 합니다.
그것이 우리의 목표입니다. 우리가 하려고 하는 것은 v를 보는 것입니다, 
그리고 최단 경로를 봅니다. 
그리고 그 경로와 연관된 알고리즘을 봅니다.
저는 경로에 이름을 붙일 것입니다. 그것을 p라고 합시다. 
그것은 v_0에서 시작해서 v_1, v_2로 갑니다 
그리고 v_k에서 끝납니다. 
이것은 최단 경로가 아니지만, s에서 시작하는 것입니다. 
그리고 v에서 끝납니다. 

Korean: 
저는 몇 가지 이름을 줄 것이고 경로에 대해 
이야기할 수 있습니다. 
이것은 s에서 v까지 최단 경로입니다. 
이제, 저는 그것이 s에서 v까지 최단 경로가 아니길 바라지만, 
s에서 v까지 최단 경로 중에 저는 그것이 
가능한 모서리를 가진 것들이길 바랍니다.
여기서 최단은 경로의 총 무게의 관점을 의미합니다. 
저는 모서리의 수에서 
최단이길 원했습니다. 
제가 그것을 원하는 이유는 p가 간단한 경로라고 결론지을 수 있기 때문이고, 
그것은 어떤 정점도 반복하지 않습니다. 
이제, p가 간단하다고 
보장하기 위해 최단인 모서리의 수를 

English: 
So, I'm going to give a couple
of names to s and v so I can
talk about the path more
uniformly.
So, this is a shortest path
from s to v.
Now, I also want it to be not
just any shortest path from s to
v, but among all shortest paths
from s to v I want it to be one
with the fewest possible edges.
OK, so shortest here means in
terms of the total weight of the
path.
Subject to being shortest in
weight, I wanted to also be
shortest in the number of edges.
And, the reason I want that is
to be able to conclude that p is
a simple path,
meaning that it doesn't repeat
any vertices.
Now, can anyone tell me why I
need to assume that the number
of edges is the smallest

Korean: 
왜 가정할 필요가 있는지 말할 수 있나요?
모든 최단 경로는 필수적으로 간단하지 않습니다. 
네? 
저는 0 무게 사이클을 가질 수 있습니다. 
우리는 사실 여기 정리에서, 
음의 무게 사이클이 없다고 가정합니다. 
그러나 여전히 0의 무게 사이클이 있을 수 있습니다. 
의 무게 사이클로써, 여러분은 그것을 어떤 최단 경로의 중간에 둘 수 있습니다. 
그리고 정점을 반복합니다. 
그것은 짜증나는 것입니다. 
제가 원하는 것은 p가 간단한 것입니다.
저는 그것을 지름길에 의해 보장할 수 있습니다. 
제가 0의 무게 사이클을 가지면, 저는 그것을 던집니다. 
그리고 이것은 그것을 하는 수학적인 방법입니다. 
이제 우리가 이 최단 경로에 대해 아는 것은 무엇입니까?
우리는 서브 경로가 최단 경로라는 것을 압니다. 
그것은 최적 서브 구조입니다. 
우리는 s에서 v_i까지의 최단 경로가 무엇인지 압니다. 
그것은 최단 경로이고, 
그 경로의 무게입니다. 

English: 
possible in order to guarantee
that p is simple?
The claim is that not all
shortest paths are necessarily
simple.
Yeah?
Right, I can have a zero weight
cycle, exactly.
So, we are hoping,
I mean, in fact in the theorem
here, we're assuming that there
are no negative weight cycles.
But there might be zero weight
cycles still.
As a zero weight cycle,
you can put that in the middle
of any shortest path to make it
arbitrarily long,
repeat vertices over and over.
That's going to be annoying.
What I want is that p is
simple.
And, I can guarantee that
essentially by shortcutting.
If ever I take a zero weight
cycle, I throw it away.
And this is one mathematical
way of doing that.
OK, now what else do we know
about this shortest path?
Well, we know that subpaths are
shortest paths are shortest
paths.
That's optimal substructure.
So, we know what the shortest
path from s to v_i is sort of
inductively.
It's the shortest path,
I mean, it's the weight of that
path, which is,

English: 
in particular,
the shortest path from s to v
minus one plus the weight of the
last edge, v minus one to v_i.
So, this is by optimal
substructure as we proved last
time.
OK, and I think that's pretty
much the warm-up.
So, I want to sort of do this
inductively in I,
start out with v zero,
and go up to v_k.
So, the first question is,
what is d of v_0,
which is s?
What is d of the source?
Well, certainly at the
beginning of the algorithm,
it's zero.
So, let's say equals zero
initially because that's what we
set it to.
And it only goes down from
there.
So, it certainly,

Korean: 
특히, s에서 
v-1 더하기 마지막 모서리의 무게 입니다.
이것은 우리가 지난 시간에 증명한 것처럼 최적 서브 구조에 의한 것입니다. 
저는 그것이 준비라고 생각합니다. 
저는 이것을 귀납적으로 하고 싶습니다,
v0에서 시작해서 v_k로 갑니다. 
첫 번째 질문은, 
v_0의 d는 무엇입니까, s는요? 
소스의 d는 무엇입니까? 
알고리즘의 시작에서, 그것은 0입니다. 
그것이 우리가 설정한 것이기 때문에 0과 같습니다. 
그것은 저기로부터 내려갑니다. 
그것은 최대 0입니다.

English: 
at most, zero.
The real question is,
what is delta of s comma v_0.
What is the shortest path
weight from s to s?
It has to be zero,
otherwise you have a negative
weight cycle,
exactly.
My favorite answer,
zero.
So, if we had another path from
s to s, I mean,
that is a cycle.
So, it's got to be zero.
So, these are actually equal at
the beginning of the algorithm,
which is great.
That means they will be for all
time because we just argued up
here, only goes down,
never can get too small.
So, we have d of v_0 set to the
right thing.
Great: good for the base case
of the induction.
Of course, what we really care
about is v_k,
which is v.
So, let's talk about the v_i

Korean: 
진짜 질문은,
δ(s, v_0)는 무엇입니까? 
s에서 s로의 최단 경로는 무엇입니까? 그것은 0이어야 합니다, 
그렇지 않으면 여러분은 음의 무게 사이클을 가집니다.
저의 가장 좋아하는 답은 0입니다. 
우리가 s에서 s까지 다른 경로를 가지면, 
그것은 사이클입니다. 
그것은 0이어야 합니다. 
이것들은 사실 알고리즘의 시작에서 같습니다. 
그것들은 모든 시간을 위한 것입니다  
왜냐하면 우리는 여기서 내려가고 너무 작아질 수 없습니다.
그래서 우리는 d[v_0]를 옳은 것으로 설정합니다. 
귀납의 기본 케이스를 위해 좋습니다. 
물론, 우리가 신경 쓰는 것은, v_k입니다. 
v_i에 대해 귀납적으로 이야기해봅시다. 

English: 
inductively, and then we will
get v_k as a result.
So, yeah, let's do it by
induction.
That's more fun.
Let's say that d of v_i is
equal to delta of s v_i after I
rounds of the algorithm.
So, this is actually referring
to the I that is in the
algorithm here.
These are rounds.
So, one round is an entire
execution of all the edges,
relaxation of all the edges.
So, this is certainly true for
I equals zero.

Korean: 
그리고 우리는 결과로 v_k를 얻습니다.
그것을 귀납법에 의해 해 봅시다. 
그것은 더 재미있습니다
v_i의 d는 알고리즘을 돈 후에 δ(s, v_i)와 같습니다. 
이것은 사실 여기 알고리즘에 있는 
i를 언급하는 것입니다. 
이것은 라운드입니다. 하나의 라운드는 
모든 모서리의 전체 실행, 휴식입니다. 
이것은 i=0이면 옳습니다

Korean: 
우리는 그것을 증명했습니다. 0 라운드 후에, 
알고리즘의 시작에서, d[v_0]는 δ(s, v_0)와 같습니다.
그것은 제가 원하는 것이 아닙니다, 
그러나 좋습니다. 
이제 우리는 v_i의 d +1을 위해 그것을 증명할 것입니다. 
일반적으로, 저는 여러분에게 가정하는 것을 추천합니다. 
사실, 저는 왜 제 조언을 따르고 그것을 바꿉니까? 
그것은 보통 재귀로써 귀납에 대해 생각하기 더 좋습니다. 
여러분은 이것이 옳다고 가정합니다 
그리고 여러분은 그것을 v_i의 d에 대해 증명합니다. 
그것은 생각하기 더 쉽습니다. 
특히, 
여러분은 I 보다 작은 모든 것을 위한 강한 귀납을 사용할 수 있습니다. 
우리는 그것이 필요합니다. 
우리는 델타의 관점에서 i와 i-1의 식이 필요합니다. 
우리는 d 값에 대해 이야기하고 싶습니다.

English: 
We just proved that.
After zero rounds,
at the beginning of the
algorithm, d of v_0 equals delta
of s, v_0.
OK, so now, that's not really
what I wanted,
but OK, fine.
Now we'll prove it for d of v_i
plus one.
Generally, I recommend you
assume something.
In fact, why don't I follow my
own advice and change it?
It's usually nicer to think of
induction as recursion.
So, you assume that this is
true, let's say,
for j less than the i that you
care about, and then you prove
it for d of v_i.
It's usually a lot easier to
think about it that way.
In particular,
you can use strong induction
for all less than i.
Here, we're only going to need
it for one less.
We have some relation between I
and I minus one here in terms of
the deltas.
And so, we want to argue

Korean: 
여기서 무엇이 
일어나는지 생각해 봅시다. 
우리는 이 귀납법 가설을 가집니다, 
d[v_(i-1)]은 δ(s, v_(i-1))과 같습니다. 
우리는 그것을 I 라운드 후에 결론짓고 싶습니다. 
우리는 이것을 하기 위해 하나의 라운드를 더 가집니다. 
우리는 d[v_i]가 옳은 답이라고 결론짓고 싶습니다. 
그것이 친숙해 보이나요? 
우리는 이 라운드에서 모든 모서리를 휴식시키고 싶습니다. 
특히, 어떤 점에서, 
우리는 v_i-1에서 v_i까지 모서리를 휴식시켜야 합니다. 
우리는 이 경로가 모서리로 구성된다는 것을 압니다. 

English: 
something about the d values.
OK, well, let's think about
what's going on here.
We know that,
let's say, after I minus one
rounds, we have this inductive
hypothesis, d of v_i minus one
equals delta of s v_i minus one.
And, we want to conclude that
after i rounds,
so we have one more round to do
this.
We want to conclude that d of
v_i has the right answer,
delta of s comma v_i.
Does that look familiar at all?
So we want to relax every edge
in this round.
In particular,
at some point,
we have to relax the edge from
v_i minus one to v_i.
We know that this path consists
of edges.

English: 
That's the definition of a
path.
So, during the i'th round,
we relax every edge.
So, we better relax v_i minus
one v_i.
And, what happens then?
It's a test of memory.
Quick, the Death Star is
approaching.
So, if we have the correct
value for v_i minus one,
that we relax an outgoing edge
from there, and that edge is an

Korean: 
그것은 경로의 정의입니다.
i번째 라운드 동안, 우리는 모든 모서리를 휴식시킵니다. 
우리는 v_i-1 v_i를 휴식하는 것이 낫습니다. 
그리고 무엇이 일어납니까? 그것은 기억의 테스트입니다. 
빠릅니다, Death Star가 다가옵니다. 
우리가 v_(i-1)을 위해 옳은 값을 가지면, 
우리는 저기서 나오는 모서리를 휴식시키고, 

Korean: 
모서리는 s에서 v_i의 최단 경로의 모서리 입니다. 
우리는 무엇을 압니까? d[v_i]는 옳은 값, δ(s, v_i)가 됩니다. 
이것은 지난 시간의 정확성 부명제입니다. 
우리가 Dijkstra 알고리즘에 대해 증명하는 것들 중 하나이지만, 
그것은 휴식에 대한 사실입니다. 
그리고 그것은 매우 간단한 증명입니다.
그것은 이 사실로부터 나옵니다. 
우리는 최단 경로 무게가 이것이라는 것을 압니다. 
d[v_i]는 적어도 이 큰 것입니다, 
그것이 더 크다고 가정해보세요, 그렇지 않으면 우리는 다 했습니다. 
우리는 d[v_(i-1)]을 이것으로 설정합니다. 
이것은 휴식 단계에서 확인되는 조건입니다. 
d[v_i]값은 이 보다 더 클 것입니다. 
가정해 봅시다. 
그리고 우리는 그것을 이것과 같게 설정할 겁니다. 

English: 
edge of the shortest path from s
to v_i.
What do we know?
d of v_i becomes the correct
value, delta of s comma v_i.
This was called correctness
lemma last time.
One of the things we proved
about Dijkstra's algorithm,
but it was really just a fact
about relaxation.
And it was a pretty simple
proof.
And it comes from this fact.
We know the shortest path
weight is this.
So, certainly d of v_i was at
least this big,
and let's suppose it's greater,
or otherwise we were done.
We know d of v_i minus one is
set to this.
And so, this is exactly the
condition that's being checked
in the relaxation step.
And, the d of v_i value will be
greater than this,
let's suppose.
And then, we'll set it equal to
this.

English: 
And that's exactly d of s v_i.
So, when we relax that edge,
we've got to set it to the
right value.
So, this is the end of the
proof, right?
It's very simple.
The point is,
you look at your shortest path.
Here it is.
And if we assume there's no
negative weight cycles,
this has the correct value
initially.
d of s is going to be zero.
After the first round,
you've got to relax this edge.
And then you get the right
value for that vertex.
After the second round,
you've got to relax this edge,
which gets you the right d
value for this vertex and so on.
And so, no matter which
shortest path you take,
you can apply this analysis.
And you know that by,
if the length of this path,
here we assumed it was k edges,
then after k rounds you've got
to be done.
OK, so this was not actually
the end of the proof.
Sorry.

Korean: 
그것은 정확히 δ(s, v_i) 입니다.
우리가 그 모서리를 휴식할 때, 우리는 그것을 옳은 값으로 설정합니다. 
이것은 증명의 마지막입니다. 
매우 간단합니다. 
여러분은 여러분의 최단 경로를 봅니다. 여기 있습니다. 
여러분이 음의 무게 사이클이 없다고 가정하면 
이것은 옳은 값을 초기에 가집니다. 
d[s]는 0이 됩니다. 첫 라운드 후에, 
여러분은 이 모서리를 휴식시킵니다. 그리고 여러분은 
그 정점을 위한 옳은 값을 얻습니다. 두 번째 라운드 후에, 
여러분은 이 모서리를 휴식시킵니다, 그리고 여러분은 이 정점을 위해 옳은 d 값을 얻습니다.
여러분이 어떤 최단 경로를 가지든, 
여러분은 이 분석을 적용할 수 있습니다. 
그리고 여러분은, 이 경로의 길이를 다음으로 가정하면,  
k 라운드 후에 여러분은 다 했습니다.
그래서 이것은 사실 증명의 마지막이 아닙니다. 
미안해요.

English: 
So this means after k rounds,
we have the right answer for
v_k, which is v.
So, the only question is how
big could k be?
And, it better be the right
answer, at most,
v minus one is the claim by the
algorithm that you only need to
do v minus one steps.
And indeed, the number of edges
in a simple path in a graph is,
at most, the number of vertices
minus one.
k is, at most,
v minus one because p is
simple.
So, that's why we had to assume
that it wasn't just any shortest
path.
It had to be a simple one so it
didn't repeat any vertices.
So there are,
at most, V vertices in the

Korean: 
그래서 이것은 k 라운드 후에 우리가 v_k를 위한 옳은 담을 가진다는 것을 의미합니다, 
그것은 v입니다. k는 어떻게 커지나요? 
그것은 옳은 답 보다 낫습니다, 
v-1은 여러분이 v-1 단계를 할 필요가 있다는 
알고리즘에 의한 주장입니다. 
그래프의 간단한 경로에서 모서리의 수는, 
최다 정점의 수 -1입니다.
k는 최대 v-1 입니다 왜냐하면 p는 간단하기 때문입니다. 
그것을 우리가 그것이 어떤 최단 경로이지 
않다고 가정한 이유입니다. 
그것은 간단한 것입니다 그래서 그것은 어떤 정점도 반복하지 않았습니다. 
경로에 최대 V 정점과, 

English: 
path, so at most,
V minus one edges in the path.
OK, and that's all there is to
Bellman-Ford.
So: pretty simple in
correctness.
Of course, we're using a lot of
the lemmas that we proved last
time, which makes it easier.
OK, a consequence of this
theorem, or of this proof is
that if Bellman-Ford fails to
converge, and that's what the
algorithm is checking is whether
this relaxation still requires
work after these d minus one
steps.
Right, the end of this
algorithm is run another round,
a V'th round,
see whether anything changes.
So, we'll say that the
algorithm fails to converge
after V minus one steps or

Korean: 
V-1 모서리가 있습니다. 
그리고 그것들은 모두 Bellman-Ford 입니다. 
매우 간단합니다. 
물론 우리는 지난 시간에 증명한 
더 쉬운 부명제를 많이 사용합니다. 
Bellman-Ford이 집중하는데 실패하면, 
그것을 알고리즘이 이 휴식이 여전히 d-1 단계 후에 
동작을 요구하는지 확인하는 것입니다. 
이 알고리즘의 마지막은 다른 라운드, 
V번째 라운드를 돌리는 것입니다, 무엇이 바뀌는지 보세요. 
우리는 알고리즘이 
V-1 단계 후에 실패한다고 말할 것입니다. 

Korean: 
음의 무게 사이클이 있어야 합니다. 
이것은 우리가 증명한 것과 
대치하는 것입니다. 
우리는 여러분이 음의 무게 사이클이 없다고 가정하면,
d[s]가 0이라는 것을 증명했습니다,  
그리고 여러분은 V-1 라운드 후에 집중합니다.
여러분이 한 번 최단 경로 무게에 도달하면 
아무 것도 남아 있을 수 없습니다 왜냐하면 
여러분이 단조적으로 가고, 절대 바닥을 치지 않기 때문입니다.
여러분은 절대 바닥으로 갈 수 없습니다. 여러분이 V-1 라운드 위해 집중하는데 실패하면, 
여러분은 가정을 위반합니다. 
유일한 가정은 
음의 무게 사이클이 없다는 것입니다. 
이것은 우리에게 Bellman-Ford가 실제로 옳다는 것을 말해줍니다. 
음의 무게 사이클이 있으면, 
그것은 정말 그것을 의미합니다. 
그리고 여러분은 그 케이스에서 
더 길게 런하기 위해 Bellman-Ford를 수정할 수 있고, 

English: 
rounds.
Then, there has to be a
negative weight cycle.
OK, this is just a
contrapositive of what we
proved.
We proved that if you assume
there's no negative weight
cycle, then we know that d of s
is zero, and then all this
argument says is you've got to
converge after v minus one
rounds.
There can't be anything left to
do once you've reached the
shortest path weights because
you're going monotonically;
you can never hit the bottom.
You can never go to the floor.
So, if you fail to converge
somehow after V minus one
rounds, you've got to have
violated the assumption.
The only assumption we made was
there's no negative weight
cycle.
So, this tells us that
Bellman-Ford is actually
correct.
When it says that there is a
negative weight cycle,
it indeed means it.
It's true.
OK, and you can modify
Bellman-Ford in that case to
sort of run a little longer,

English: 
and find where all the minus
infinities are.
And that is,
in some sense,
one of the things you have to
do in your problem set,
I believe.
So, I won't cover it here.
But, it's a good exercise in
any case to figure out how you
would find where the minus
infinities are.
What are all the vertices
reachable from negative weight
cycle?
Those are the ones that have
minus infinities.
OK, so you might say,
well, that was awfully fast.
Actually, it's not over yet.
The episode is not yet ended.
We're going to use Bellman-Ford
to solve the even bigger and
greater shortest path problems.
And in the remainder of today's
lecture, we will see it applied
to a more general problem,
in some sense,
called linear programming.
And the next lecture,
we'll really use it to do some
amazing stuff with all pairs
shortest paths.
Let's go over here.
So, our goal,
although it won't be obvious
today, is to be able to compute
the shortest paths between every

Korean: 
모든 마이너스 무한대가 어디 있는지 찾을 수 있습니다.
그리고 어떤 면에서, 
그것은 여러분의 문제 세트에서 여러분이 해야 하는 것들 중 하나입니다. 
저는 그것을 여기서 다루지 않을 겁니다. 
그러나 그것은 –무한대가 어디 있는지 
알아내는 케이스에서 좋은 연습입니다. 
음의 무게 사이클로부터 도달 가능한 정점은 무엇입니까? 
그것들은 마이너스 무한대를 가지는 것입니다. 
여러분은 빠르다고 말할 수 있습니다. 
그것은 아직 그렇지 않습니다. 
에피소드는 아직 끝나지 않았습니다. 우리는 더 크고 훌륭한 
최단 경로 문제를 풀기 위해 Bellman-Ford를 사용할 것입니다.
오늘 남은 강의에서, 우리는 그것이 더 일반적인 문제에 
적용되는 것을 볼 것입니다, 그것은 선형 프로그래밍입니다. 
다음 강의에서, 
놀라운 일을 하기 위해 그것을 사용할 것입니다. 
여기서 해 봅시다. 
그것이 명확하지 않더라도 우리의 목표는 
정점 쌍 간의 최단 경로를 계산하는 것입니다

English: 
pair of vertices,
which we could certainly do at
this point just by running
Bellman-Ford v times.
OK, but we want to do better
than that, of course.
And, that will be the climax of
the trilogy.
OK, today we just discovered
who Luke's father is.
So, it turns out the father of
shortest paths is linear
programming.
Actually, simultaneously the
father and the mother because
programs do not have gender.
OK, my father likes to say,
we both took improv comedy

Korean: 
그것은 Bellman-Ford를 돌리면서 
이점에서 할 수 있는 것입니다.
그러나 우리는 물론 그것보다 더 나은 것을 원합니다. 
그것은 삼부작의 클라이막스입니다. 
오늘 우리는 Luke의 아버지가 누구인지 발견했습니다. 
최단 경로의 아버지는 선형 프로그래밍입니다
동시에 아버지와 
엄마입니다 
프로그램은 성이 없으니까요. 

English: 
lessons so we have degrees in
improvisation.
And he said,
you know, we went to improv
classes in order to learn how to
make our humor better.
And, the problem is,
it didn't actually make our
humor better.
It just made us less afraid to
use it.
[LAUGHTER] So,
you are subjected to all this
improv humor.
I didn't see the connection of
Luke's father,
but there you go.
OK, so, linear programming is a
very general problem,
a very big tool.
Has anyone seen linear
programming before?
OK, one person.
And, I'm sure you will,
at some time in your life,
do anything vaguely computing
optimization related,
linear programming comes up at
some point.
It's a very useful tool.
You're given a matrix and two
vectors: not too exciting yet.
What you want to do is find a
vector.

Korean: 
우리는 즉석에서 차수를 가집니다.
우리는 더 재미있게 하기 위해  
즉흥 수업으로 갔습니다.
그것은 사실 우리의 유머를 더 낫게 하지 못합니다
그것은 우리가 그것을 사용하는 것을 덜 두렵게 합니다. 
그래서
여러분은 모든 이 즉흥 유머의 대상입니다. 
저는 Luke의 아버지의 연결을 보지 않았지만 
여러분은 갑니다. 선형 프로그래밍은 
매우 일반적인 문제입니다, 매우 큰 도구입니다. 
전에 선형 프로그래밍을 보았나요? 
한 명 있군요. 
저는 여러분의 인생의 어떤 순간에서, 
최적화를 계산하는 것을 한다고 확신합니다. 
그것은 매우 유용한 도구 입니다.
여러분은 행렬과 두 벡터가 주어졌습니다. 아직 흥미롭지 않습니다. 
여러분이 원하는 것은 벡터를 찾는 것입니다. 

English: 
This is a very dry description.
We'll see what makes it so
interesting in a moment.
So, you want to maximize some
objective, and you have some
constraints.
And they're all linear.
So, the objective is a linear
function in the variables x,
and your constraints are a
bunch of linear constraints,
inequality constraints,
that's one makes an
interesting.
It's not just solving a linear
system as you've seen in linear
algebra, or whatever.
Or, of course,
it could be that there is no
such x.
OK: vaguely familiar you might
think to the theorem about
Bellman-Ford.
And, we'll show that there's
some kind of connection here

Korean: 
이것은 매우 건조한 설명입니다.
우리는 곧 흥미롭게 하는 것을 볼 것입니다. 
여러분은 대상을 최대화하길 원하고, 제약을 가집니다. 
그것들은 선형입니다. 
대상은 변수 x에서 선형 함수입니다, 
여러분의 제약은 많은 선형 제약, 부등식 제약입니다, 
그것들은 흥미롭습니다.
그것은 여러분이 선형 대수 등에서 본 것처럼 
선형 시스템을 풀지 않습니다. 
물론 그것은 x가 없을 수 있습니다. 
여러분은 
Bellman-Ford에 대한 정리에 대해 생각하는 것에 모호하게 친숙할 수 있습니다, 
우리는 어떤 연결이 있다는 것을 보여줄 것이고

Korean: 
또는 그것이 존재하지 않는다는 것을 보여줍니다.
그것은 여전히 모호한 연결이지만, 
저는 최대화하고 싶습니다, 
또는 최단 경로를 최소화하고 싶습니다. 
우리는 이 제약을 가집니다. 
이것은 여러분에게 직관적인 것입니다. 
저는 더 기하학적인 그림을 선호합니다, 
그리고 기하학적인 그림을 그릴 것입니다, 
저는 절대 이것을 칠판에서 하지 않습니다, 
그것은 흥미로울 것입니다
저는 그것이 비참하게 실패한다고 생각합니다. 
그것은 12면체 같아 보입니다. 
바닥에서 거칩니다
여러분이 많은 선형 제약을 가지면 
이것은 3-D이어야 합니다. 이제 저는 그것에 라벨을 붙입니다. 

English: 
that either you want to find
something, or show that it
doesn't exist.
Well, that's still a pretty
vague connection,
but I also want to maximize
something, or are sort of
minimize the shortest paths,
OK, somewhat similar.
We have these constraints.
So, yeah.
This may be intuitive to you,
I don't know.
I prefer a more geometric
picture, and I will try to draw
such a geometric picture,
and I've never tried to do this
on a blackboard,
so it should be interesting.
I think I'm going to fail
miserably.
It sort of looks like a
dodecahedron,
right?
Sort of, kind of,
not really.
A bit rough on the bottom,
OK.
So, if you have a bunch of
linear constraints,
this is supposed to be in 3-D.
Now I labeled it.

English: 
It's now in 3-D.
Good.
So, you have these linear
constraints.
That turns out to define
hyperplanes in n dimensions.
OK, so you have this base here
that's three-dimensional space.
So, n equals three.
And, these hyperplanes,
if you're looking at one side
of the hyperplane,
that's the less than or equal
to, if you take the
intersection,
you get some convex polytope or
polyhedron.
In 3-D, you might get a
dodecahedron or whatever.
And, your goal,
you have some objective vector
c, let's say,
up.
Suppose that's the c vector.
Your goal is to find the
highest point in this polytope.
So here, it's maybe this one.
OK, this is the target.
This is the optimal,
x.
That is the geometric view.
If you prefer the algebraic

Korean: 
그것은 이제 3-D입니다. 좋아요.
여러분은 이 선형 제약을 가집니다
그것은 n 차원에서 초평면을 정의합니다. 
그래서 여러분은 이 기본을 가지고 그것은 3 차원의 공간입니다
n은 3입니다. 
여러분이 초평면의 한 면을 보면
그것은 작거나 같습니다, 여러분이 교차를 하면, 
여러분은 다면체를 얻으면요. 
3-D에서, 
여러분은 12면체를 얻을 수 있습니다. 
여러분은 벡터 c를 가집니다. 
그것이 벡터 c라고 가정해보세요.
여러분의 목표는 이 다면체에서 가장 높은 점을 찾는 것입니다. 
그것은 이것일 수 있습니다. 이것은 목표입니다. 
이것은 최적의, x입니다. 
그것은 기하학적인 견해입니다. 

English: 
view, you want to maximize the c
transpose times x.
So, this is m.
This is n.
Check out the dimensions work
out.
So that's saying you want to
maximize the dot product.
You want to maximize the extent
to which x is in the direction
c.
And, you want to maximize that
subject to some constraints,
which looks something like
this, maybe.
So, this is A,
and it's m by n.
You want to multiply it by,
it should be something of
height n.
That's x.
Let me put x down here,
n by one.
And, it should be less than or
equal to something of this
height, which is B,
the right hand side.
OK, that's the algebraic view,
which is to check out all the
dimensions are working out.
But, you can read these off in
each row here,
when multiplied by this column,
gives you one value here.

Korean: 
여러분이 대수적 견해를 선호하면 여러분은 c를 최대화하길 원합니다. 
이것은 m입니다. 이것은 n입니다. 
차원이 동작하는지 확인해보세요. 
그것을 여러분이 곱셈을 최대화하는 것입니다. 
여러분은 x가 차원 c에 있는 것을 연장하고 싶습니다. 
그리고 여러분은 그것을 어떤 제약으로 연장합니다, 
이와 같아 보입니다. 
이것은 A이고, 
그것은 m 곱하기 n 입니다. 여러분은 그것을 곱하길 원하고, 
그것은 높이 n의 것입니다.
그것은 x입니다. x를 여기 아래에 둡시다
그리고, 그것은 이 높이의 것 보다 
작거나 같습니다. 
그것은 대수적 견해이고, 그것은 모든 차원이 
동작하는지 확인하는 것입니다. 
그러나 여러분은 이 열을 읽을 수 있습니다, 
이 행에 의해 곱해질 때, 여러분에게 하나의 값을 줍니다. 

Korean: 
그리고 모든 x의 측에서 선형 제약으로써요. 
여러분은 x_1의 선형 함수를 
이 제약의 x_n까지 최대화하고 싶습니다. 
매우 간단하지만, 일반적으로 매우 강력합니다. 
여러분은 선형 프로그램으로써 가장 짦은 경로의 
많은 수를 공식화할 수 있습니다. 
그것은 일반적인 도구 입니다.
이 수업에서 우리는 선형 프로그래밍을 푸는 알고리즘을 다루지 않을 것입니다. 
그것은 약간 까다롭습니다. 
저는 그것들이 저기 있다고 언급할 것입니다. 
많은 효율적인 알고리즘이 있고, 
이것을 하는 많은 코드가 있습니다. 그것은 매우 실용적인 설정입니다. 

English: 
And as just a linear
constraints on all the x sides.
So, you want to maximize this
linear function of x_1 up to x_n
subject to these constraints,
OK?
Pretty simple,
but pretty powerful in general.
So, it turns out that with,
you can formulate a huge number
of problems such as shortest
paths as a linear program.
So, it's a general tool.
And in this class,
we will not cover any
algorithms for solving linear
programming.
It's a bit tricky.
I'll just mention that they are
out there.
So, there's many efficient
algorithms, and lots of code
that does this.
It's a very practical setup.

Korean: 
선형 프로그래밍을 푸는 많은 알고리즘이 있습니다. 
선형 프로그래밍은 보통 LP라고 불립니다. 
저는 그것들 중 몇 가지를 언급할 것입니다. 
단일어 알고리즘이 있습니다. 이것은 첫 번째의 하나입니다. 
저는 그것이 첫 번째 타원체 알고리즘이라고 생각합니다. 
내부의 포인터 메소드가 있고 랜덤 샘플링이 있습니다. 
우리는 깊이에서 그것들에 대해 이야기하지 않을 것이기 때문에 
이것들에 대해 말할 것입니다.
단일어 알고리즘은 
어떤 면에서 
가장 유명한 알고리즘입니다. 
그것을 오늘도 사용됩니다. 대부분의 
선형 프로그래밍 코드는 단일어 알고리즘을 사용합니다. 
그것은 최악의 케이스에서 지수 시간에 돕니다. 그것을 사실 이론적으로 
나쁩니다. 그러나 실제로, 
그것은 잘 동작합니다. 그리고 이것을 이해하려는 최근의 연구들이 있습니다. 

English: 
So, lots of algorithms to solve
LP's, linear programs.
Linear programming is usually
called LP.
And, I'll mention a few of
them.
There's the simplex algorithm.
This is one of the first.
I think it is the first,
the ellipsoid algorithm.
There's interior point methods,
and there's random sampling.
I'll just say a little bit
about each of these because
we're not going to talk about
any of them in depth.
The simplex algorithm,
this is, I mean,
one of the first algorithms in
the world in some sense,
certainly one of the most
popular.
It's still used today.
Almost all linear programming
code uses the simplex algorithm.
It happens to run an
exponential time in the
worst-case, so it's actually
pretty bad theoretically.
But in practice,
it works really well.
And there is some recent work

Korean: 
그것은 최악의 케이스에서 여전히 지수적입니다.
그러나 그것은 실용적입니다. 
다항 시간에 도는 단일어의 변화가 존재하는지에 
대한 열린 문제가 있습니다. 
저는 그것으로 가려고 하지 않습니다. 그것은 선형 프로그래밍 분야에서 주요한 열린 문제입니다. 
타원체 알고리즘은 다항 시간에 
선형 프로그래밍을 푸는 첫 알고리즘이었습니다. 
오래 동안, 사람들은 알지 못했습니다
이 시기에 사람들은 선형 시간이 좋은 것이라는 것을 깨닫기 시작했습니다. 
그것은 60년대 후반입니다. 
다항 시간은 좋습니다. 
타원체 알고리즘은 그것을 하는 첫 알고리즘입니다. 
그것은 매우 일반적이고 이론적으로 강력하고 
완벽히 비실용적입니다. 
그러나 좋습니다. 그것을 여러분이 다항 시간에 지수적으로 많은 제약을 가지는 
선형 프로그램을 풀 수 있는 것을 하도록 합니다. 
여러분은 모든 미친 것을 가집니다. 
저는 그것이 다항 시간이라고 말할 것입니다.

English: 
that tries to understand this.
It's still exponential in the
worst case.
But, it's practical.
There's actually an open
problem whether there exists a
variation of simplex that runs
in polynomial time.
But, I won't go into that.
That's a major open problem in
this area of linear programming.
The ellipsoid algorithm was the
first algorithm to solve linear
programming in polynomial time.
So, for a long time,
people didn't know.
Around this time,
people started realizing
polynomial time is a good thing.
That happened around the late
60s.
Polynomial time is good.
And, the ellipsoid algorithm is
the first one to do it.
It's a very general algorithm,
and very powerful,
theoretically:
completely impractical.
But, it's cool.
It lets you do things like you
can solve a linear program that
has exponentially many
constraints in polynomial time.
You've got all sorts of crazy
things.
So, I'll just say it's

Korean: 
저는 그것에 대해 좋은 것을 말할 수 없습니다. 
그것을 말하지 마세요. 그것을 실용적이지 않습니다. 
내부 포인트 메소드는 혼합입니다. 
그것들은 다항 시간 안에 돕니다. 여러분은 그것을 보장할 수 있습니다
그것들은 또한 매우 실용적입니다.  
요즘 단일어 또는 내부 포인터나 나은지에 대한 비교가 있습니다.
저는 그것을 원하지 않지만 
몇 년 전에 막상막하였습니다. 
랜덤 샘플링은 새로운 접근입니다. 
이것은 몇 년 전에 두 MIT 교수 
Dimitris Bertsimas and Santosh Vempala 에 의한 것입니다.
여러분에게 보여주기 위하여, 
이 분야에서 활동적인 일이 있습니다. 
사람들은 선형 프로그램을 풀기 위한 새로운 방법을 여전히 찾고 있습니다. 
이것은 완벽히 랜덤화된, 매우 간단한, 매우 일반적인 것입니다. 
그것은 구현되지 않았습니다, 
그래서 우리는 그것이 어떻게 실용적인지 모릅니다. 
그러나 그것은 잠재성을 가집니다. 매우 간단합니다. 
우리는 선형 프로그래밍의 더 간단한 버전을 볼 것입니다. 

English: 
polynomial time.
I can't say something nice
about it; don't say it at all.
It's impractical.
Interior point methods are sort
of the mixture.
They run in polynomial time.
You can guarantee that.
And, they are also pretty
practical, and there's sort of
this competition these days
about whether simplex or
interior point is better.
And, I don't know what it is
today but a few years ago they
were neck and neck.
And, random sampling is a brand
new approach.
This is just from a couple
years ago by two MIT professors,
Dimitris Bertsimas and Santosh
Vempala, I guess the other is in
applied math.
So, just to show you,
there's active work in this
area.
People are still finding new
ways to solve linear programs.
This is completely randomized,
and very simple,
and very general.
It hasn't been implemented,
so we don't know how practical
it is yet.
But, it has potential.
OK: pretty neat.
OK, we're going to look at a
somewhat simpler version of

English: 
linear programming.
The first restriction we are
going to make is actually not
much of a restriction.
But, nonetheless we will
consider it, it's a little bit
easier to think about.
So here, we had some polytope
we wanted to maximize some
objective.
In a feasibility problem,
I just want to know,
is the polytope empty?
Can you find any point in that
polytope?
Can you find any set of values,
x, that satisfy these
constraints?
OK, so there's no objective.
c, just find x such that AX is
less than or equal to B.
OK, it turns out you can prove
a very general theorem that if
you can solve linear
feasibility, you can also solve
linear programming.
We won't prove that here,
but this is actually no easier
than the original problem even
though it feels easier,

Korean: 
우리가 만드는 첫 번째 제약은 
사실 많은 제약이 아닙니다. 
그럼에도 불구하고 우리는 그것을 고려합니다, 그것은 생각하기 더 쉽습니다. 
여기서 우리는 대상을 
최대화하고 싶습니다
가능성 문제에서, 다면체는 비었습니까? 
여러분은 그 다면체에서 어떤 점을 찾을 수 있나요? 
여러분은 이 제약을 만족하는 어떤 값의 
집합을 찾을 수 있나요?
대상이 없습니다. c는 x를 찾고 AX는 B 보다 작거나 같습니다. 
여러분은 매우 일반적인 정리를 증명할 수 있습니다 
여러분이 선형 가능성을 풀면, 
여러분은 선형 프로그래밍을 풀 수 있습니다
우리는 그것을 여기서 증명하지 않을 것이지만, 
이것은 더 쉽게 느껴지더라도 

English: 
and it's easier to think about.
I was just saying actually no
easier than LP.
OK, the next restriction we're
going to make is a real
restriction.
And it simplifies the problem
quite a bit.
And that's to look at different
constraints.
And, if all this seemed a bit
abstract so far,
we will now ground ourselves
little bit.
A system of different
constraints is a linear
feasibility problem.
So, it's an LP where there's no

Korean: 
원래 문제 보다 더 쉽지 않습니다. 
LP 보다 더 쉽지 않습니다. 
다음 제약은 실제 제약입니다. 
그것은 문제를 꽤 단순화합니다.
그것은 다른 제약을 보는 것입니다. 
이것이 모두 지금까지 추상적으로 보였으면, 
우리는 스스로 좌초시킵니다. 
다른 제약의 시스템은 선형 가능성 문제입니다. 
그것은 대상이 없는 LP입니다. 

Korean: 
그것은 제약을 가집니다, 
그리고 거기서 각 행렬의 열은 1 1을 가집니다 
그리고 그것은 1 -1을 가집니다, 
열의 모든 것은 0입니다.
즉, 각 제약은 매우 간단한 형태를 가집니다. 
그것은 두 변수와 숫자를 포함합니다
x_j 마이너스 x_i는 w_ij 보다 
작거나 같습니다

English: 
objective.
And, it's with a restriction,
so, where each row of the
matrix, so, the matrix,
A, has one one,
and it has one minus one,
and everything else in the row
is zero.
OK, in other words,
each constraint has its very
simple form.
It involves two variables and
some number.
So, we have something like x_j
minus x_i is less than or equal
to w_ij.

English: 
So, this is just a number.
These are two variables.
There's a minus sign,
no values up here,
no coefficients,
no other of the X_k's appear,
just two of them.
And, you have a bunch of
constraints of this form,
one per row of the matrix.
Geometrically,
I haven't thought about what
this means.
I think it means the
hyperplanes are pretty simple.
Sorry I can't do better than
that.
It's a little hard to see this
in high dimensions.
But, it will start to
correspond to something we've
seen, namely the board that its
next to, very shortly.
OK, so let's do a very quick
example mainly to have something
to point at.
Here's a very simple system of
difference constraints --

Korean: 
이것은 수 입니다. 이것들은 두 변수입니다. 
마이너스 기호가 있고 계수는 없습니다, 
다른 X_k가 나타나지 않습니다. 
여러분은 이 형태의 많은 제약을 가집니다. 
열 당 하나입니다. 
기하학적으로, 저는 이것이 의미하는 것에 대해 생각하지 않았습니다
저는 초평면이 매우 간단하다고 생각합니다
저는 그것 보다 더 나은 것을 할 수 없습니다. 
그것은 높은 차원에서 보기 어렵습니다.
그러나 그것을 우리가 본 것과 
일치하기 시작합니다. 
빠른 예를 해 봅시다. 
여기 
다른 제약의 매우 간단한 시스템이 있습니다. 

English: 
-- OK, and a solution.
Why not?
It's not totally trivial to
solve this, but here's a
solution.
And the only thing to check is
that each of these constraints
is satisfied.
x_1 minus x_2 is three,
which is less than or equal to
three, and so on.
There could be negative values.
There could be positive values.
It doesn't matter.
I'd like to transform this
system of difference constraints
into a graph because we know a
lot about graphs.

Korean: 
답입니다. 왜 안되나요? 
이것을 푸는 것은 완전히 사소합니다, 그러나 여기 답이 있습니다. 
확인하는 유일한 것은 이 제약 각각이 만족되는지 입니다.
 x_1 minus x_2는 3입니다, 
그것은 3 보다 작거나 같습니다.
음의 값이 있을 수 있습니다. 
양의 값이 있을 수 있습니다. 그것은 중요하지 않습니다. 
저는 다른 제약의 이 시스템을 그래프로 변환하고 싶습니다 
왜냐하면 우리는 그래프에 대해 많이 알기 때문입니다. 

English: 
So, we're going to call this
the constraint graph.
And, it's going to represent
these constraints.
How'd I do it?
Well, I take every constraint,
which in general looks like
this, and I convert it into an
edge.
OK, so if I write it as x_j
minus x_i is less than or equal
to some w_ij,
w seems suggestive of weights.
That's exactly why I called it
w.
I'm going to make that an edge
from v_i to v_j.
So, the order flips a little
bit.
And, the weight of that edge is
w_ij.
So, just do that.
Make n vertices.
So, you have the number of
vertices equals n.
The number of edges equals the
number of constraints,
which is m, the height of the

Korean: 
우리는 이것을 제약 그래프라고 부를 것입니다. 
그것은 이 제약은 나타냅니다. 
제가 그것을 어떻게 하나요? 저는 모든 제약을 가집니다,
그것을 일반적으로 이와 같아 보입니다 그리고 저는 그것을 모서리로 변환합니다.
x_j minus x_i가 w_ij 보다 작거나 같을 때 제가 그것을 쓰면, 
w는 무게를 연상시킵니다.
그것은 제가 w로 부르는 이유입니다. 
저는 그것을 v_i에서 v_j로 만들 것입니다. 
순서는 약간 뒤집힙니다. 
그 모서리의 무게는 w_ij 입니다. 
그것을 합시다. 
n 정점을 만드세요. 
여러분은 정점의 수를 n과 같게 합니다. 
정점의 수는 제약의 수 m과 같습니다, 

Korean: 
행렬의 높이입니다. 예를 들어, 
여기서 우리는 세 변수를 가집니다. 우리는 세 정점 
v_1, v_2, v_3를 가집니다. 우리는 x_1 minus x_2를 가집니다. 
그래서 우리는 무게 3의 v_2에서 v_1의 모서리를 가집니다. 
우리는 x_2 minus x_3를 가집니다. 
우리는 무게 2의 v_3에서 v_1의 
모서리를 가집니다. 
저는 방향을 옳게 가지길 바랍니다.
그래프가 있습니다. 
현재 최단 경로로의 명확한 연결이 없습니다, 그렇죠? 
그러나 사실, 
이 제약은 최단 경로와 가깝게 연관되어 있습니다. 
그것을 다시 쓰겠습니다. 
x_j는 x_i plus w_ij 보다 작거나 같습니다. 

English: 
matrix, and just transform.
So, for example,
here we have three variables.
So, we have three vertices,
v_1, v_2, v_3.
We have x_1 minus x_2.
So, we have an edge from v_2 to
v_1 of weight three.
We have x_2 minus x_3.
So, we have an edge from v_3 to
v_2 of weight minus two.
And, we have x_1 minus x_3.
So, we have an edge from v_3 to
v_1 of weight two.
I hope I got the directions
right.
Yep.
So, there it is,
a graph: currently no obvious
connection to shortest paths,
right?
But in fact,
this constraint is closely
related to shortest paths.
So let me just rewrite it.
You could say,
well, an x_j is less than or
equal to x_i plus w_ij.

English: 
Or, you could think of it as
d[j] less than or equal to d[i]
plus w_ij.
This is a conceptual balloon.
Look awfully familiar?
A lot like the triangle
inequality, a lot like
relaxation.
So, there's a very close
connection between these two
problems as we will now prove.
So, we're going to have two
theorems.
And, they're going to look
similar to the correctness of
Bellman-Ford in that they talk
about negative weight cycles.
Here we go.
It turns out,
I mean, we have this constraint
graph.

Korean: 
여러분은 그것을 d[i] plus w_ij 보다 작거나 같은 d[j]로 생각할 수 있습니다. 
이것은 개념적인 풍선입니다. 
친숙해 보이나요? 삼각 부등식과 같고, 
휴식과 같아 보입니다. 
우리가 증명할 때 두 문제 간의 
매우 가까운 연결이 있습니다.
우리는 두 정리를 가집니다. 
그것들은 음의 무게 사이클에 대해 이야기한 
Bellman-Ford의 정확성과 유사해 보입니다. 
우리는 여기서 합니다. 
우리는 이 제약 그래프를 가집니다. 

English: 
It can have negative weights.
It can have positive weights.
It turns out what matters is if
you have a negative weight
cycle.
So, the first thing to prove is
that if you have a negative
weight cycle that something bad
happens.
OK, what could happen bad?
Well, we're just trying to
satisfy this system of
constraints.
So, the bad thing is that there
might not be any solution.
These constraints may be
infeasible.
And that's the claim.
The claim is that this is
actually an if and only if.
But first we'll proved the if.
If you have a negative weight
cycle, you're doomed.
The difference constraints are
unsatisfiable.
That's a more intuitive way to
say it.
In the LP world,
they call it infeasible.
But unsatisfiable makes a lot
more sense.
There's no way to assign the
x_i's in order to satisfy all
the constraints simultaneously.

Korean: 
그것은 음의 무게를 가질 수 있습니다. 그것은 양의 무게를 가질 수 있습니다. 
중요한 것은 여러분이 음의 무게 사이클을 가지는지 입니다. 
첫 번째로 증명하는 것은 
나쁜 것이 일어나는 음의 무게 사이클을 가지는지 입니다. 
어떤 나쁜 것이 일어날 수 있나요? 
우리는 제약의 이 시스템을 만족시키려고 합니다. 
나쁜 것은 답이 없는 것입니다. 
이 제약은 실행 불가능할 수 있습니다. 
그것이 주장입니다. 
이것은 사실 필요충분조건입니다.
먼저 우리는 필요조건을 증명할 것입니다. 
여러분이 음의 사이클을 가지면, 여러분은 불운합니다. 차이 제약은 만족되지 않습니다. 
그것은 더 직관적인 방법입니다. 
LP 세계에서, 
그것들은 불가능 하다고 합니다. 만족되지 않는 것은 더 이치에 맞습니다.
모든 제약을 동시에 
만족시키기 위해 x_i를 할당하는 방법은 없습니다. 

English: 
So, let's just take a look.
Consider a negative weight
cycle.
It starts at some vertex,
goes through some vertices,
and at some point comes back.
I don't care whether it repeats
vertices, just as long as this
cycle, from v_1 to v_1 is a
negative weight cycle strictly
negative weight.
OK, and what I'm going to do is
just write down all the
constraints.
Each of these edges corresponds
to a constraint,
which must be in the set of
constraints because we had that
graph.
So, these are all edges.
Let's look at what they give
us.
So, we have an edge from v_1 to
v_2.
That corresponds to x_2 minus
x_1 is, at most,
something, w_12.
Then we have x_3 minus x_2.
That's the weight w_23,

Korean: 
살펴 봅시다. 음의 무게 사이클을 고려해 보세요. 
그것은 어떤 점에서 시작해서, 
어떤 점으로 갑니다, 그리고 어떤 점에서 돌아 옵니다. 
저는 그것이 정점을 반복하는지 
신경 쓰지 않습니다, 사이클이 음의 음의 무게 사이클인한요.
그리고 저는 모든 제약을 쓸 것입니다. 
각 모서리는 제약에 일치합니다, 
그것은 제약의 집합 안에 있어야 합니다 
왜냐하면 우리가 그 그래프를 가졌기 때문입니다. 
이것들은 모두 모서리입니다. 그것들이 우리에게 무엇을 주는지 봅시다
우리는 v_1에서 v_2의 모서리를 가집니다. 
그것은 x_2 minus x_1와 일치합니다, 
그것은 최대 w_12 입니다. 
그리고 우리는 x_3 minus x_2를 가집니다. 그것은 무게 w_23 입니다.

Korean: 
결국 우리는 
x_k minus x_(k-1)와 같은 것을 얻습니다. 
그것은 이 모서리입니다, 마지막으로 우리는 이 모서리를 
갖습니다, 그것은 둘러싸고 있습니다.
그것은 제가 옳은 기호를 가지면 x_1 minus x_k, w_k1 입니다. 
좋아요, 여기 많은 제약이 있습니다. 
저는 그것들을 가지고 무엇을 하나요? 
이 제약에 대한 흥미로운 것이 있나요? 
네? 

English: 
and so on.
And eventually we get up to
something like x_k minus
x_(k-1).
That's this edge:
w_(k-1),k , and lastly we have
this edge, which wraps around.
So, it's x_1 minus x_k,
w_k1 if I've got the signs
right.
Good, so here's a bunch of
constraints.
What do you suggest I do with
them?
Anything interesting about
these constraints,
say, the left hand sides?
Sorry?

English: 
It sounded like the right word.
What was it?
Telescopes, yes,
good.
Everything cancels.
If I added these up,
there's an x_2 and a minus x_2.
There's a minus x_1 and an x_1.
There's a minus XK and an XK.
Everything here cancels if I
add up the left hand sides.
So, what happens if I add up
the right hand sides?
Over here I get zero,
my favorite answer.
And over here,
we get all the weights of all
the edges in the negative weight
cycle, which is the weight of
the cycle, which is negative.
So, zero is strictly less than
zero: contradiction.
Contradiction:
wait a minute,
we didn't assume anything that
was false.
So, it's not really a
contradiction in the
mathematical sense.
We didn't contradict the world.
We just said that these
constraints are contradictory.
In other words,
if you pick any values of the
x_i's, there is no way that
these can all be true because
that you would get a
contradiction.
So, it's impossible for these
things to be satisfied by some

Korean: 
그것을 옳은 것처럼 들리네요. 무엇입니까?
망원경입니다, 좋아요. 
모든 것이 취소됩니다. 제가 이것들을 더하면, 
x_2와 마이너스 x_2가 잇습니다. 마이너스 x_1과 x_1이 있습니다. 
마이너스 XK 그리고 XK가 있습니다. 
제가 왼쪽을 더하면 모두 취소됩니다. 제가 우변을 더하면 어떻게 됩니까? 
여기서 저는 0을 얻습니다, 
제가 가장 좋아하는 답입니다.
우리는 음의 무게 사이클에서 모든 모서리 무게를 얻습니다, 
그것은 사이클의 무게이고 음 입니다.
0은 0보다 작습니다, 
모순입니다. 잠시 기다리세요, 
우리는 틀린 것을 가정하지 않았습니다. 
그것은 수학적인 면에서 정말 모순이 아닙니다. 
우리는 세계를 반박하지 않습니다. 
우리는 이 제약들이 모순이라고 말했습니다. 
즉, 여러분이 x_i의 어떤 값을 고르면, 
이것이 모두 옳을 수 있는 방법은 없습니다 왜냐하면 
여러분은 모순을 얻기 때문입니다.
모든 것이 만족되는 것은 불가능합니다. 

English: 
real x_i's.
So, these must be
unsatisfiable.
Let's say there's no satisfying
assignment, a little more
precise, x_1 up to x_m,
no weights.
Can we satisfy those
constraints?
Because they add up to zero on
the left-hand side,
and negative on the right-hand
side.
OK, so that's an easy proof.
The reverse direction will be
only slightly harder.
OK, so, cool.
We have this connection.
So motivation is,
suppose you'd want to solve
these difference constraints.
And we'll see one such
application.
I Googled around for difference
constraints.
There is a fair number of
papers that care about
difference constraints.
And, they all use shortest
paths to solve them.
So, if we can prove a
connection between shortest
paths, which we know how to
compute, and difference
constraints, then we'll have
something cool.

Korean: 
이것들은 만족되지 않아야 합니다.
만족 시키는 것이 
없다고 합시다. 
우리는 이 제약들을 만족시킬 수 있나요? 
그것들이 0으로 
더해지기 때문입니다. 
그래서 그것은 쉬운 증명입니다. 
역 방향은 약간 더 어렵습니다. 
좋습니다. 우리는 이 연결을 가집니다. 
여러분이 이 차이 제약을 풀길 원한다고 가정해보세요. 
그리고 우리는 하나의 응용을 불 것입니다.
저는 차이 제약에 대해 검색해 보았습니다
그것에 대한 많은 
논문들이 있습니다. 
그것들은 모두 최단 경로를 사용합니다. 
우리가 최단 경로 간의 
연결을 증명할 수 있으면, 
우리는 좋은 것을 가집니다. 

Korean: 
다음 시간에 차이 제약의 응용에 대해 더 볼 것입니다.
그것들은 모든 쌍의 최단 경로를 위해 
유용합니다. 
그러나 지금은 이 동등함을 증명하고 끝냅시다. 
역 방향은, 이 제약 그래프에서 
음의 무게 사이클이 없으면, 
시스템은 더 만족됩니다. 
이 음의 무게 사이클은 차이 제약의 
답을 찾는 장벽입니다. 
저는 이것이 여기처럼 느껴집니다. 
저는 제약 그래프에 대해 이야기해야 했습니다.

English: 
And, next class will see even
more applications of difference
constraints.
It turns out they're really
useful for all pairs shortest
paths.
OK, but for now let's just
prove this equivalence and
finish it off.
So, the reverse direction is if
there's no negative weight cycle
in this constraint graph,
then the system better be
satisfiable.
The claim is that these
negative weight cycles are the
only barriers for finding a
solution to these difference
constraints.
I have this feeling somewhere
here.
I had to talk about the

Korean: 
좋아요.
좋아요. 만족됩니다. 여기서 우리는 최단 경로에 
대해 생각할 때 매우 유용한 기술을 볼 것입니다. 
특히 여러분이 그것을 전에 보았으면, 
그것은 더 어렵습니다. 
이것은 문제 세트, 퀴즈, 기말 고사에서 유용합니다. 
이것을 마음에 새기세요. 
저는 다소 간단한 정리를 증명하기 위해 그것을 사용할 것이지만, 
저는 이 제약 그래프를 G라고 부릅니다. 

English: 
constraint graph.
Good.
Satisfied, good.
So, here we're going to see a
technique that is very useful
when thinking about shortest
paths.
And, it's a bit hard to guess,
especially if you haven't seen
it before.
This is useful in problem sets,
and in quizzes,
and finals, and everything.
So, keep this in mind.
I mean, I'm using it to prove
this rather simple theorem,
but the idea of changing the
graph, so I'm going to call this

English: 
constraint graph G.
Changing the graph is a very
powerful idea.
So, we're going to add a new
vertex, s, or source,
use the source,
Luke, and we're going to add a
bunch of edges from s because
being a source,
it better be connected to some
things.
So, we are going to add a zero
weight edge, or weight zero edge
from s to everywhere,
so, to every other vertex in
the constraint graph.
Those vertices are called v_i,
v_1 up to v_n.
So, I have my constraint graph.
But I'll copy this one so I can
change it.
It's always good to backup your
work before you make changes,
right?
So now, I want to add a new
vertex, s, over here,

Korean: 
그래프를 바꾸는 것은 매우 강력한 생각입니다. 
우리는 새로운 정점, 
s 또는 소스를 더할 것이고 소스를 사용할 것입니다, 
그리고 우리는 s로부터 많은 모서리를 더할 것입니다. 
소스이기 때문에, 그것은 다른 것과 연결되는 것이 낫습니다.
우리는 0의 무게 모서리를 더할 것입니다, 
s에서 제약 그래프의 
다른 정점으로요. 
정점들은 v_i, v_1에서 v_n입니다. 
저는 제 제약 그래프를 가집니다. 그러나 저는 이것을 복사할 것이고 그것을 바꿀 수 있습니다. 
여러분이 변화를 만들기 전에, 
항상 여러분의 일을 백업하는 것은 좋습니다. 
이제 저는 새 정점을 원합니다. 

Korean: 
저는 제약 그래프를 가집니다, 
그것은 모든 다른 정점으로 0의 무게 모서리에서 더합니다.
간단합니다. 
이제 제가 무엇을 했나요? 여러분은 무엇을 했나요? 
저는 모든 정점에 이를 수 있는 
후보 소스를 가집니다. 
s로부터의 최단 경로입니다. 
저는 무게 0에서 s로부터 모든 곳으로를 얻을 수 있습니다. 
더 작을 수도 있습니다. 그것이 더 작을 수 있나요? 
v_2와 같이, 저는 그것을 0 -2로 얻을 수 있습니다. 
그것은 0보다 작습니다. 
저는 주의해야 합니다.
음의 무게 사이클이 있으면 어떤가요? 
안되나요? 그러면 최단 경로가 없습니다
운 좋게, 
우리는 원래 그래프에서 음의 무게 사이클이 없다고 가정했습니다. 
여러분이 생각해보면, 
원래 그래프에서 음의 무게 사이클이 없으면, 
우리는 s에서 모든 곳으로의 모서리를 더합니다
우리는 새 음의 무게 사이클을 만들지 않을 겁니다 

English: 
my new source.
I just take my constraint
graph, whatever it looks like,
add in weight zero edges to all
the other vertices.
Simple enough.
Now, what did I do?
What did you do?
Well, I have a candidate source
now which can reach all the
vertices.
So, shortest path from s,
hopefully, well,
paths from s exist.
I can get from s to everywhere
in weight at most zero.
OK, maybe less.
Could it be less?
Well, you know,
like v_2, I can get to it by
zero minus two.
So, that's less than zero.
So I've got to be a little
careful.
What if there's a negative
weight cycle?
Oh no?
Then there wouldn't be any
shortest paths.
Fortunately,
we assume that there's no
negative weight cycle in the
original graph.
And if you think about it,
if there's no negative weight
cycle in the original graph,
we add an edge from s to
everywhere else.
We're not making any new
negative weight cycles because

Korean: 
왜냐하면 여러분은 s에서 시작해서 0의 비용으로 가고, 
그것은 무게에 영향을 미치지 않기 때문입니다.
그리고 여러분은 오래된 그래프에 머물도록 강요됩니다. 
새로운 음의 무게 사이클이 있을 수 없습니다. 
수정된 그래프는 음의 무게 사이클을 가지지 않습니다. 
그것은 또한 s로부터의 경로를 가지기 때문에 좋습니다. 
그러므로 그것은 또한 s로부터 최단 경로를 가집니다. 
수정된 그래프는 음의 무게를 가지지 않습니다 왜냐하면 전에 그렇지 않았기 때문입니다. 
그것은 s로부터의 경로를 가집니다. 
s로부터의 모든 정점으로의 경로입니다. 
전에 있지 않았습니다. 전에 저는 v_2에서 v_3을 
얻을 수 없었습니다. 그것은 여전히 옳습니다. 
그러나 s로부터 모든 곳을 저는 얻을 수 있습니다. 
이 수정된 그래프는 최단 경로를 가진다는 것을 의미합니다.

English: 
you can start at s and go
somewhere at a cost of zero,
which doesn't affect any
weights.
And then, you are forced to
stay in the old graph.
So, there can't be any new
negative weight cycles.
So, the modified graph has no
negative weight cycles.
That's good because it also has
paths from s,
and therefore it also has
shortest paths from s.
The modified graph has no
negative weight because it
didn't before.
And, it has paths from s.
There's a path from s to every
vertex.
There may not have been before.
Before, I couldn't get from v_2
to v_3, for example.
Well, that's still true.
But from s I can get to
everywhere.
So, that means that this graph,
this modified graph,

Korean: 
최단 경로는 s로부터 존재합니다. 
즉, 제가 모든 최단 경로 무게를 보면, 
저는 모든 값, 
정점을 위해 유한한 수를 
얻습니다. 
그것은 좋은 생각 같아 보입니다. 
그것을 해 봅시다. 
그것은 좋은 선택입니다. 
그것은 무한대 보다 작기 때문에 
이것은 유한합니다, 
그리고 그것은 마이너스 무한대 보다 더 큽니다. 
그것은 이 제약을 만족시키기 위해 

English: 
has shortest paths.
Shortest paths exist from s.
In other words,
if I took all the shortest path
weights, like I ran Bellman-Ford
from s, then,
I would get a bunch of finite
numbers, d of v,
for every value,
for every vertex.
That seems like a good idea.
Let's do it.
So, shortest paths exist.
Let's just assign x_i to be the
shortest path weight from s to
v_i.
Why not?
That's a good choice for a
number, the shortest path weight
from s to v_i.
This is finite because it's
less than infinity,
and it's greater than minus
infinity, so,
some finite number.
That's what we need to do in

English: 
order to satisfy these
constraints.
The claim is that this is a
satisfying assignment.
Why?
Triangle inequality.
Somewhere here we wrote
triangle inequality.
This looks a lot like the
triangle inequality.
In fact, I think that's the end
of the proof.
Let's see here.
What we want to be true with
this assignment is that x_j
minus x_i is less than or equal
to w_ij whenever ij is an edge.
Or, let's say v_i,
v_j, for every such constraint,
so, for v_i,
v_j in the edge set.
OK, so what is this true?
Well, let's just expand it out.
So, x_i is this delta,
and x_j is some other delta.
So, we have delta of s,
vj minus delta of s_vi.
And, on the right-hand side,
well, w_ij, that was the weight
of the edge from I to J.

Korean: 
필요한 것입니다.
이것은 배정을 만족시킵니다. 
왜죠? 삼각 부등식입니다. 
여기서 우리는 삼각 부등식을 썼습니다. 
이것은 삼각 부등식 같아 보입니다.
사실 저는 그것이 증명의 마지막이라고 생각합니다. 
여기서 봅시다. 우리가 옳길 바라는 것은 
x_j - x_i이 w_ij 보다 
작거나 같은 것입니다. 
모든 제약에 대해 v_i, v_j를 말해봅시다.
이것을 옳습니까? 
그것을 확장해봅시다. x_i는 이 δ이고, 
x_j는 다른 δ입니다. 
우리는 δ(s, v_j) - δ(s, v_i)를 가집니다. 
우변에서, 그것은 i에서 j까지 모서리의 무게였습니다. 

English: 
So, this is the weight of v_i
to v_j.
OK, I will rewrite this
slightly.
Delta s, vj is less than or
equal to delta s,
vi plus w of v_i,
v_j.
And that's the triangle
inequality more or less.
The shortest path from s to v_j
is, at most, shortest path from
s to v_i plus a particular path
from v_i to v_j,
namely the single edge v_i to
v_j.
This could only be longer than
the shortest path.
And so, that makes the
right-hand side bigger,
which makes this inequality
more true, meaning it was true
before.
And now it's still true.
And, that proves it.
This is true.
And, these were all equivalent
statements.
This we know to be true by
triangle inequality.
Therefore, these constraints
are all satisfied.
Magic.
I'm so excited here.
So, we've proved that having a
negative weight cycle is exactly

Korean: 
이것은 v_i에서 v_j의 무게입니다. 
저는 이것을 약간 다시 쓸 것입니다. 
δ(s, v_j)는 ... 
δ(s, v_i)+ w(v_i, v_j)보다 작거나 같습니다
그리고 그것은 삼각 부등식입니다. 
s에서 v_j의 최단 경로는 최대 s에서 
v_i의 최단 경로 더하기 v_i에서 v_j의 특정 경로입니다, 
즉 v_i에서 v_j의 단일 모서리입니다. 
이것은 최단 경로 보다 더 길 수 있습니다.
그것은 우변을 더 크게 만듭니다,  
그것은 이 부등식을 더 옳게 만듭니다. 
그것은 여전히 옳습니다. 
그것은 그것을 증명합니다. 이것은 옳습니다.
이것들은 모두 동등한 문장입니다. 
이것은 삼각 부등식에 의해 아는 것입니다. 
그러므로, 이 제약은 모두 만족됩니다. 
마법입니다. 저는 흥분됩니다. 
우리는 음의 무게 사이클을 가지는 것이 차이 제약의 

Korean: 
이 시스템이 만족되지 않을 때라는 것을 증명했습니다.
우리가 그것들을 만족시키길 원하면, 옳은 답을 찾고 싶으면, 
우리는 Bellman-Ford를 돌립니다.  
음의 무게 사이클이 없습니다. 
그러면 답이 없습니다.
그러나 그것은 여러분이 알고 싶은 최고의 것입니다. 
그렇지 않으면, 음의 무게 사이클이 없습니다. 
여기 최단 경로 무게가 있습니다. 
여러분은 그것들을 연결합니다, 
여러분은 제약을 만족하는 x_i를 가집니다. 
놀랍습니다. 이제 그것은 단지 그래프가 아닙니다.
우리는 제약으로 시작했습니다, 
우리는 그것을 이 변환에 의해 그래프로 변환합니다. 
그리고 소스 정점 s를 더했습니다. 
우리는 우리 문제를 풀기 위해 그래프를 구축해야 했습니다, 
모든 강력한 생각입니다. 좋아요. 
이것은 감소의 아이디어입니다
여러분은 문제를 감소시킬 수 있습니다. 
여러분은 음의 무게 사이클이 없을 때 최단 경로를 푸는 방법을 압니다, 
Bellman-Ford.에 의해 음의 무게 사이클이 

English: 
when these system of difference
constraints are unsatisfiable.
So, if we want to satisfy them,
if we want to find the right
answer to x, we run
Bellman-Ford.
Either it says,
oh, no negative weight cycle.
Then you are hosed.
Then, there is no solution.
But that's the best you could
hope to know.
Otherwise, it says,
oh, there was no negative
weight cycle,
and here are your shortest path
weights.
You just plug them in,
and bam, you have your x_i's
that satisfy the constraints.
Awesome.
Now, it wasn't just any graph.
I mean, we started with
constraints, algebra,
we converted it into a graph by
this transform.
Then we added a source vertex,
s.
So, I mean, we had to build a
graph to solve our problem,
very powerful idea.
Cool.
This is the idea of reduction.
You can reduce the problem you
want to solve into some problem
you know how to solve.
You know how to solve shortest
paths when there are no negative
weight cycles,
or find out that there is a

English: 
negative weight cycle by
Bellman-Ford.
So, now we know how to solve
difference constraints.
It turns out you can do even
more.
Bellman-Ford does a little bit
more than just solve these
constraints.
But first let me write down
what I've been jumping up and
down about.
The corollary is you can use
Bellman-Ford.
I mean, you make this graph.
Then you apply Bellman-Ford,
and it will solve your system
of difference constraints.
So, let me put in some numbers
here.
You have m difference
constraints.
And, you have n variables.
And, it will solve them in

Korean: 
있다는 것을 찾아냅니다.
이제 우리는 차이 제약을 푸는 방법을 압니다. 
여러분은 그 이상으로 할 수 있습니다. 
Bellman-Ford는 이 제약을 푸는 것 보다 더 많이 합니다. 
그러나 먼저 제가 뛰어 넘을 것을 
써 보겠습니다. 
귀결은 여러분이 Bellman-Ford를 사용할 수 있는 것입니다. 
여러분은 이 그래프를 만듭니다. 그러면 여러분은 Bellman-Ford를 적용합니다,
그리고 그것은 여러분의 차이 제약 시스템을 풀 것입니다. 
여기서 수를 넣겠습니다. 
여러분은 m개의 차이 제약을 가집니다. 
그리고 n개의 변수를 가집니다. 그것은 m 곱하기 n 시간에 풀 것입니다.

Korean: 
사실 이 수들은 약간 올라갑니다 
왜냐하면 우리는 n 모서리를 더하기 때문입니다, 
우리는 하나의 정점을 더하지만, 모든 수가 사소하지 않다고 가정하면, 
m은 적어도 n 입니다. 그것은 오더 MN 시간입니다. 
그것들이 0과 가까운 케이스를 피하는 것입니다. 
좋아요. 다른 사실은, 
제가 말할 것입니다. 그리고 우리는 이것들을 연습으로 남길 것입니다 
그것들은 필수적이지 않으니까요
우리가 필요한 주요한 것은 이것입니다. 
그러나 좋은 사실은 Bellman-Ford가 대상 함수를 최적화한다는 것입니다. 
그것은 가능성 문제입니다. 
우리는 이 제약이 만족되는지 
알고 싶습니다. 
사실, 여러분은 특정 대상 함수를 더할 수 있습니다.
여러분은 그것을 임의의 대상 함수에 줄 수 없지만 

English: 
order m times n time.
Actually, these numbers go up
slightly because we are adding n
edges, and we're adding one
vertex, but assuming all of
these numbers are nontrivial,
m is at least n.
It's order MN time.
OK, trying to avoid cases where
some of them are close to zero.
Good.
So, some other facts,
that's what I just said.
And we'll leave these as
exercises because they're not
too essential.
The main thing we need is this.
But, some other cool facts is
that Bellman-Ford actually
optimizes some objective
functions.
So, we are saying it's just a
feasibility problem.
We just want to know whether
these constraints are
satisfiable.
In fact, you can add a
particular objective function.
So, you can't give it an
arbitrary objective function,

English: 
but here's one of interest.
x_1 plus x_2 plus x_n,
OK, but not just that.
We have some constraints.
OK, this is a linear program.
I want to maximize the sum of
the x_i's subject to all the
x_i's being nonpositive and the
difference constraints.
So, this we had before.
This is fine.
We noticed at some point you
could get from s to everywhere
with cost, at most,
zero.
So, we know that in this
assignment all of the x_i's are
negative.
That's not necessary,
but it's true when you run
Bellman-Ford.
So if you solve your system
using Bellman-Ford,
which is no less general than
anything else,
you happen to get nonpositive
x_i's.
And so, subject to that
constraint, it actually makes
them is close to zero as

Korean: 
여기 흥미로운 것이 하나 있습니다.
x_1 plus x_2 plus x_n 입니다. 우리는 어떤 제약을 가집니다. 
이것은 선형 프로그램입니다. 
저는 x_i의 합을 최대화하고 싶습니다.  
우리는 전에 이것을 가졌습니다.
이것은 좋습니다. 우리는 어떤 점에서  
여러분이 s에서 모든 곳으로를 얻을 수 있다고 주목했습니다, 최대 비용 0으로요. 
우리는 이 배정에서 
x_i가 음이라는 것을 압니다.
이것은 필수적이지 않습니다, 그러나 그것은 Bellman-Ford를 돌릴 때 옳습니다. 
여러분이 Bellman-Ford를 사용하여 여러분의 시스템을 풀면, 
그것은 다른 것 보다 덜 일반적이지 않습니다, 
여러분은 양이 아닌 것을 얻습니다. 
그것은 
사실 L1 개념에서 공간에서 가능한 0과 가깝게 만드는 것입니다.

English: 
possible in the L1 norm.
In the sum of these values,
it tries to make the sum as
close to zero,
it tries to make the values as
small as possible in absolute
value in this sense.
OK, it does more than that.
It cooks, it cleans,
it finds shortest paths.
It also minimizes the spread,
the maximum over all i of x_i
minus the minimum over all i of
x_i.
So, I mean, if you have your
real line, and here are the
x_i's wherever they are.
It minimizes this distance.
And zero is somewhere over
here.
So, it tries to make the x_i's
as compact as possible.
This is actually the L infinity
norm, if you know stuff about
norms from your linear algebra
class.

Korean: 
이 값들의 합에서, 
그것은 합을 0과 가깝게 만드려고 합니다, 
그것은 값을 절대 값에서 가능한 작데 만드려고 합니다. 
그것은 그 이상의 것을 합니다. 
그것은 요리하고 청소하고 최단 경로를 찾습니다. 
그것은 또한 확산을 최소화하고 모든 것을 
최소화합니다. 
여러분이 실제 선을 가지면, 여기서 x_i 입니다. 
그것은 이 길이를 최소화합니다.  
그리고 0은 여기 있습니다.
그것은 x_i를 가능한 압축시킵니다. 
이것은 사실 L 무한대 개념입니다, 
여러분이 선형 대수 수업의 개념에 대해 한다면요. 

Korean: 
이것은 L1 개념입니다. 그것은 모든 LP 개념을 최소화합니다.
이것을 사용해 봅시다. 
실제 문제를 풀어 봅시다. 
그러면 우리는 오늘 다 한 것입니다.  
다음 시간에 우리는 이것의 정말 좋은 응용을 볼 것입니다.
지금은 좋지만 상대적으로  
간단한 응용을 볼 것입니다, 그것은 VLSI 레이아웃입니다.
우리는 VLSI와 
분할 정복에 대해 이야기 했습니다
여러분은 많은 칩을 가지고 그것들을 정렬하길 원합니다, 그리고 대상을 최소화합니다.
여기 
VLSI 레이아웃으로부터 나오는 특정한 문제가 있습니다. 
여기 그것들 중 하나가 있습니다. 여러분은 통합된 회로의 많은 특징을 가집니다.

English: 
OK, this is the L1 norm.
I think it minimizes every LP
norm.
Good, so let's use this for
something.
Yeah, let's solve a real
problem, and then we'll be done
for today.
Next class we'll see the really
cool stuff, the really cool
application of all of this.
For now, and we'll see a cool
but relatively simple
application, which is VLSI
layout.
We talked a little bit about
VLSI way back and divide and
conquer.
You have a bunch of chips,
or you want to arrange them,
and minimize some objectives.
So, here's a particular,
tons of problems that come out
of VLSI layout.
Here's one of them.
You have a bunch of features of

English: 
an integrated circuit.
You want to somehow arrange
them on your circuit without
putting any two of them too
close to each other.
You have some minimum
separation like at least they
should not get top of each
other.
Probably, you also need some
separation to put wires in
between, and so on,
so, without putting any two
features too close together.
OK, so just to give you an
idea, so I have some objects and
I'm going to be a little bit
vague about how this works.
You have some features.
This is stuff,
some chips, whatever.
We don't really care what their
shapes look like.
I just want to be able to move
them around so that the gap at
any point, so let me just think
about this gap.
This gap should be at least

Korean: 
여러분은 그것들을 서로 너무 가까이 두지 않고 
여러분의 회로에서 그것들을 배열하고 싶습니다. 
여러분은 서로 얻을 수 없는 것과 같은 
최소 분리를 가집니다. 
아마 여러분은 두 특징을 너무 가까이 두지 않고 
둘 간의 분리가 필요합니다.
저는 대상을 가지고 
이것이 어떻게 동작하는지에 대해 
약간의 모호함이 있습니다. 
여러분은 특징들을 가집니다. 
이것은 싼 것입니다. 우리는 그것들의 모양이 무엇과 같은지에 대해 신경 쓰지 않습니다. 
저는 그것들을 움직이고 싶습니다 
그래서 이 갭에 대해 생각해보겠습니다. 
이 갭은 적어도 δ입니다. 

English: 
some delta.
Or, I don't want to use delta.
Let's say epsilon,
good, small number.
So, I just need some separation
between all of my parts.
And for this problem,
I'm going to be pretty simple,
just say that the parts are
only allowed to slide
horizontally.
So, it's a one-dimensional
problem.
These objects are in 2-d,
or whatever,
but I can only slide them an x
coordinate.
So, to model that,
I'm going to look at the left
edge of every part and say,
well, these two left edges
should be at least some
separation.
So, I think of it as whatever
the distance is plus some
epsilon.
But, you know,
if you have some funky 2-d
shapes you have to compute,
well, this is a little bit too
close because these come into
alignment.
But, there's some constraint,
well, for any two pieces,
I could figure out how close
they can get.
They should get no closer.
So, I'm going to call this x_1.

Korean: 
그렇지 않으면 저는 δ를 사용하길 원하지 않습니다. 
작은 수 ε을 말해 봅시다.
저는 제 모든 부분들 간의 분리가 필요합니다. 
그리고 이 문제를 위해, 저는 매우 간단해 집니다, 
부분은 수평으로 나누어집니다. 
그것은 1차원의 문제입니다. 
이것들은 2차원에 있지만, 
저는 그것들을 x축으로 자를 수 있습니다. 
그것을 모델링 하기 위해, 
저는 모든 부분의 왼쪽 모서리를 불 것이고 
이 두 남은 모서리를 적어도 분리이어야 합니다.
저는 그것을 거리 더하기 
입실론이라고 생각합니다. 
그러나 여러분이 계산해야 하는 2-d 모양을 가지면, 
이것은 너무 가깝습니다 
왜냐하면 이것들은 정렬되기 때문입니다
그러나 둘을 위한 제약이 있습니다, 
저는 그것들을 얻을 수 있는 방법을 알아낼 수 있습니다.
그것들은 가까워져서는 안됩니다. 저는 이것을 x_1라고 할 것입니다. 

English: 
I'll call this x_2.
So, we have some constraint
like x_2 minus x_1 is at least d
plus epsilon,
or whatever you compute that
weight to be.
OK, so for every pair of
pieces, I can do this,
compute some constraint on how
far apart they have to be.
And, now I'd like to assign
these x coordinates.
Right now, I'm assuming they're
just variables.
I want to slide these pieces
around horizontally in order to
compactify them as much as
possible so they fit in the
smallest chip that I can make
because it costs money,
and time, and everything,
and power, everything.
You always want your chip
small.
So, Bellman-Ford does that.
All right, so Bellman-Ford
solves these constraints because
it's just a bunch of difference
constraints.
And we know that they are
solvable because you could
spread all the pieces out

Korean: 
저는 이것을 x_2라고 할 것입니다. 
우리는 x_2- x_1과 같은 제약을 가집니다, 그것은 적어도 d +ε 입니다, 
여러분은 무게를 계산합니다.
모든 쌍을 위해, 저는 그것들이 
얼마나 멀리 떨어질 수 있는지에 대한 제약을 계산할 수 있습니다. 
저는 이 x 좌표를 할당하고 싶습니다
이제, 저는 그것들이 변수라고 가정합니다. 
저는 압축하기 위해 수평으로 자르길 원합니다 
그래서 그것들은 제가 만들 수 있는 
가장 작은 칩에 들어 맞습니다 
왜냐하면 그것은 돈과 시간 힘 모든 것이 들기 때문입니다. 
여러분은 항상 칩을 작게 원합니다.
Bellman-Ford는 그것을 했습니다. Bellman-Ford는 제약을 풀었습니다 
그것은 많은 차이 제약이기 때문입니다. 
그리고 우리는 
그것들이 풀 수 있다는 것을 압니다 

English: 
arbitrarily far.
And, it minimizes the spread,
minimizes the size of the chip
I need, a max of x_i minus the
min of x_i.
So, this is it maximizes
compactness, or minimizes size
of the chip.
OK, this is a one-dimensional
problem, so it may seem a little
artificial, but the two
dimensional problem is really
hard to solve.
And this is,
in fact, the best you can do
with a nice polynomial time
algorithm.
There are other applications if
you're scheduling events in,
like, a multimedia environment,
and you want to guarantee that
this audio plays at least two
seconds after this video,
but then there are things that
are playing at the same time,
and they have to be within some
gap of each other,
so, lots of papers about using

Korean: 
여러분이 그것들을 임의로 멀리 퍼트릴 수 있기 때문입니다. 그것은 속도, 칩의 크기를 최소화합니다, 
x_i의 최대값 마이너스 x_i의 최소값입니다. 
이것은 그것이 압축률을 최대화하고 
칩의 크기를 최소화하는 것입니다. 
이것은 1차원의 문제이고, 
인공적으로 보이지만, 2차원의 문제는 
정말 풀기 어렵습니다. 
사실 이것은 여러분이 좋은 다항 시간 알고리즘으로 할 수 있는 최고입니다.
이것들은 다른 응용입니다 
여러분이 멀티미디어 환경에서 사건을 스케줄링 하면, 
여러분은 이 오디오가 적어도 
이 비디오 2초 후에 재생되길 보장하고 싶습니다, 
그러나 동시에 재생되는 것이 있습니다, 
그리고 그것들은 서로 갭 내에 있어야 합니다. 

English: 
Bellman-Ford,
solve difference constraints to
enable multimedia environments.
OK, so there you go.
And next class we'll see more
applications of Bellman-Ford to
all pairs shortest paths.
Questions?
Great.

Korean: 
멀티미디어 환경에서 가능한 차이 제약을 풀기 위해 
Bellman-Ford을 사용한 것에 대한 많은 논문들이 있습니다. 계속 하세요. 
다음 시간에 우리는 Bellman-Ford의 더 많은 응용을 볼 것입니다. 
질문 있나요? 
좋습니다.
