Лекция 9: Графы. Кратчайшие пути в графах

Лекция 9:
Кратчайшие пути в графах
Курносов Михаил Георгиевич
к.т.н. доцент Кафедры вычислительных систем
Сибирский государственный университет
телекоммуникаций и информатики
http://www.mkurnosov.net

Контроль
2
1. Какова вычислительная сложность обхода графа в глубину
(DFS), если он представлен матрицей смежности?
2. Какова вычислительная сложность обхода графа в глубину
(DFS), если он представлен списками смежности?
3. Какова вычислительная сложность обхода графа в ширину
(BFS), если он представлен матрицей смежности?
4. Какова вычислительная сложность обхода графа в ширину
(BFS), если он представлен списками смежности?

Графы
3
Граф (graph) – это совокупность непустого
множества V вершин и множества E ребер
G = (V, E),
|V| = n, |E| = m,
V = {1, 2, …, n}, E = {(u1, v1), (u2, v2), …, (um, vm)}

Поиск кратчайшего пути в графе
4
Имеется взвешенный граф G = (V, E)
Каждому ребру (i, j) ∈ E
назначен вес wij
Заданы начальная вершина s ∈ V
и конечная d ∈ V
Требуется найти
кратчайший путь (shortest path)
из вершины s в вершину d
Длина пути (path length,
path cost, path weight) –
это сумма весов ребер, входящих в него.
s
(source)
d (destination)

Поиск кратчайшего пути в графе
5
Длина пути (5, 4, 6, 7) =
4 + 6 + 9 = 19
Длина пути (5, 3, 8, 7) =
3 + 2 + 16 = 21
Длина пути (5, 3, 4, 6, 7) =
3 + 3 + 6 + 9 = 21
Существуют другие пути?
(5, 1, 4, 3, 8, 7)
(5, 2, 3, 8, 7)
…
s
(source)
d (destination)

Алгоритм Дейкстры
6
Алгоритм Дейкстры (Dijkstra’s algorithm, 1959) –
алгоритм поиска кратчайшего пути в графе. Применим
только для графов без ребер отрицательного веса.
Эдсгер Дейкстра (Edsger Wybe Dijkstra) – нидерландский
ученый (структурное программирование, язык Алгол,
семафоры)
1. Дейкстра Э. Дисциплина программирования = A discipline of
programming. — 1-е изд. — М.: Мир, 1978. — С. 275.
2. Дал У., Дейкстра Э., Хоор К. Структурное программирование =
Structured Programming. — 1-е изд. — М.: Мир, 1975. — С. 247.

Алгоритм Дейкстры (Dijkstra)
7
1
2
5
3
4
100
10
30
50
10
20
60
Пример: найти кратчайший путь из
вершины 1 в вершину 5.
Введем обозначения:
H – множество посещенных вершин
D[i] – текущее известное кратчайшее
расстояние от вершины s до вершины i
prev[i] – номер вершины,
предшествующей i в пути

8
1
2
5
3
4
100
10
30
50
10
20
60
1. Устанавливаем расстояние D[i]
от начальной вершины s до всех
остальных в ∞.
2. Полагаем D[s] = 0.
3. Помещаем все вершины
в очередь Q с приоритетом.
Приоритет вершины i это значение D[i].
0 ∞ ∞ ∞ ∞D[i]

9
1
2
5
3
4
100
10
30
50
10
20
60
4. Запускаем цикл из n итераций.
1. Извлекаем из очереди Q вершину
с минимальным приоритетом –
текущем расстоянием D[v] до s.
2. Помещаем v во множество H
посещенных вершин.
3. Для каждой вершины u смежной с
вершиной v и не включенной в H
корректируем расстояние D[u]
if D[v] + w(v, u) < D[u] then
D[u] = D[v] + w(v, u)
PQueueDecrease(Q, u, D[u])
prev[u] = v
end if
D[2] = 10
D[4] = 30
D[5] = 100
0 10 ∞ 30 100D[i]
11

10
1
2
5
3
4
100
10
30
50
10
20
60
4. Цикл из n итераций.
D[u] = D[v] + w(v, u)
prev[u] = v
end if
D[3] = 60
0 10 60 30 100D[i]
2
1
2

11
1
2
5
3
4
100
10
30
50
10
20
60
D[u] = D[v] + w(v, u)
prev[u] = v
end if
D[3] = 50
D[5] = 90
0 10 50 30 90D[i]
4
1
4
2

12
1
2
5
3
4
100
10
30
50
10
20
60
D[u] = D[v] + w(v, u)
prev[u] = v
end if
D[5] = 60
0 10 50 30 60D[i]
3
1
3
2
4

13
В массиве D длины кратчайших путей
из вершины 1 во все остальные
Кротчайший путь из вершины
1 в вершину 5: (1, 4, 3, 5), длина пути: 60
Как восстановить путь?
0 10 50 30 60D[i]
3
1
2
3
4
1
2
5
3
4
100
10
30
50
10
20
60
-1 1 4 1 3prev[i]

function Dijkstra(G, s, d)
/* Input: G = (V, E), s, d */
/* Output: path, pathlen */
for each i in V {s} do
d[i] = Infinity
prev[i] = -1
PQueueInsert(Q, i, d[i])
end for
d[s] = 0
prev[s] = -1
PQueueInsert(Q, s, d[s])
14

15
for i = 0 to n – 1 do
v = PQueueRemoveMin(Q)
H = H + {v}
for each u in Adj(v) H do
if d[v] + w(v, u) < d[u] then
d[u] = d[v] + w(v, u)
PQueueDecrease(Q, u, d[u])
prev[u] = v
end if
end for
end for

/* Сохранение пути из s в d */
i = d
pathlen = 1
while i != s do
pathlen = pathlen + 1
i = prev[i]
end while
j = 0
i = d
while i != s do
path[pathlen – j] = i
i = prev[i]
j = j + 1
end while
end function
16

Вычислительная сложность алгоритм Дейкстры
17
Вычислительная сложность алгоритма зависит от двух
факторов:
1) от выбора структуры данных для хранения графа
(матрица смежности, списки смежных вершин)
2) от способа поиска вершины с минимальным
расстоянием D[i] (очередь с приоритетом, линейный
поиск)

O(n(logn))
18
function Dijkstra(G, s, d)
/* Input: G = (V, E), s, d */
/* Output: path, pathlen */
for each i in V {s} do
d[i] = Infinity
prev[i] = -1
PQueueInsert(Q, i, d[i])
end for
d[s] = 0
prev[s] = -1
PQueueInsert(Q, s, d[s])

19
for i = 0 to n – 1 do
v = PQueueRemoveMin(Q)
H = H + {v}
for each u in Adj(v) H do
if d[v] + w(v, u) < d[u] then
d[u] = d[v] + w(v, u)
PQueueDecrease(Q, u, d[u])
prev[u] = v
end if
end for
end for
O(nlogn + mlogn)

20
/* Сохранение пути из s в d */
pathlen = 1
while i != s do
pathlen = pathlen + 1
i = prev[i]
end while
j = 0
i = d
while i != s do
path[pathlen – j] = i
i = prev[i]
j = j + 1
end while
end function
O(n)
O(n)

int search_spath_dijkstra(struct graph *g,
int s, int d, int *path, int *pathlen)
{
int *dist, *prev, *color;
int n, i, j, v, distance, dnew;
n = g->nvertices;
dist = malloc(sizeof(*dist) * n);
prev = malloc(sizeof(*prev) * n);
color = malloc(sizeof(*color) * n);
for (i = 0; i < n; i++) {
dist[i] = INT_MAX;
prev[i] = -1;
color[i] = 0;
}
dist[s - 1] = 0;
21

22
for (i = 0; i < n; i++) {
/* Find v with minimal dist[j] */
v = -1;
for (j = 0; j < n; j++) {
if (color[j] == 0 && (v == -1 ||
dist[j] < dist[v]))
{
v = j;
}
}
color[v] = 1;

for (j = 0; j < n; j++) {
if (color[j] > 0 ||
graph_get_edge(g, v + 1, j + 1) == 0)
{
continue;
}
dnew = dist[v] +
graph_get_edge(g, v + 1, j + 1);
if (dnew < dist[j]) {
dist[j] = dnew;
prev[j] = v;
}
}
} /* end for i */
23

/* Number of vertices in shortest path */
j = 1;
for (i = d - 1; i != s - 1; i = prev[i])
j++;
*pathlen = j;
/* Copy shortest path */
for (i = d - 1; i != s - 1; i = prev[i])
path[--j] = i + 1;
path[0] = s;
distance = dist[d - 1];
free(color);
free(prev);
free(dist);
return distance;
}
24

25
int main()
{
struct graph *g;
int *path, pathlen;
int i, d;
g = graph_create(5);
graph_set_edge(g, 1, 2, 10);
1
2
5
3
4
100
10
30
50
10
20
60

path = malloc(sizeof(*path) * 5);
d = search_spath_dijkstra(g, 1, 5,
path, &pathlen);
printf("Shortest path %d:n", d);
for (i = 0; i < pathlen; i++) {
printf("%dn", path[i]);
}
free(path);
graph_free(g);
return 0;
}
26

Задание
27
1. Оценить трудоемкость по памяти алгоритма Дейкстры
в следующих случаях:
o при использовании матрицы смежности
и двоичной кучи;
o при использовании списков смежности
и двоичной кучи
2. Алгоритм Беллмана — Форда
3. Алгоритм Флойда — Уоршелла

Лекция 9: Графы. Кратчайшие пути в графах

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Лекция 9: Графы. Кратчайшие пути в графах

Similar to Лекция 9: Графы. Кратчайшие пути в графах (20)

More from Mikhail Kurnosov

More from Mikhail Kurnosov (20)

Лекция 9: Графы. Кратчайшие пути в графах