2. 程式人生 > >《演算法導論》第24章——單源最短路徑

《演算法導論》第24章——單源最短路徑

阿新 • • 發佈：2018-11-22

  雖然寫這個部落格主要目的是為了給我自己做一個思路記憶錄，但是如果你恰好點了進來，那麼先對你說一聲歡迎。我並不是什麼大觸，只是一個菜菜的學生，如果您發現了什麼錯誤或者您對於某些地方有更好的意見，非常歡迎您的斧正！

在這裡插入圖片描述
在這裡插入圖片描述
最短路徑的最優子結構
最短路徑的子路徑也是最短路徑。
負權重的邊
權重為負數的邊。（我的理解：大概知道這個就可以了）
環路
最短路徑既不能包含正的環路，也不能包含負的環路。（正的環路，我覺得正常人想走最短的路，都不會在那裡打圈，除非路就是圓的；負環路你多繞幾圈，最後權重想變多小變多小，就很沒意思。）
最短路徑的表示
每個節點保持一個前驅屬性v.π，指向它的前一個結點。（這樣可以串成一串）
鬆弛操作


說白了就是就是檢查一下繞小路會不會更近。
v.d：表示s到v的最短路徑估計
在這裡插入圖片描述
在這裡插入圖片描述
接下來書中還有一堆性質，我就放圖，我自己也沒看，感覺很每意思，就是感覺把一些簡單的東西說的很複雜，顯得十分高大上。在這裡插入圖片描述

24.1Bellman-Ford演算法（貝爾曼-福特演算法）

在這裡插入圖片描述
在這裡插入圖片描述
我的思路：
這邊為什麼要先對點迴圈，然後再套一個對邊的迴圈鬆弛呢？因為第一次鬆弛的時候，部分地方還不是最短路徑。這邊思路真的不是很好描述：最好的辦法就是自己按照它的流程走一遍！

24.2有向無環圖中的單源最短路徑問題

1、對有向無環圖進行拓撲排序
2、再進行Bellman類似操作

在這裡插入圖片描述
在這裡插入圖片描述在這裡插入圖片描述
這一章我模稜兩可地看了看，emmm不知道它到底要講些什麼，如果你知道的話，請告訴我，謝謝！那麼我就要跳過這部分了。

24.3Dijkstra演算法（迪傑斯特拉演算法）

Dijkstra演算法解決的是帶權重的有向圖上單源最短路徑問題，要求所有邊權重大於0 。
我的感覺：它就是一個改進的Prim演算法。
我的思路：
1、每個點都有一個mark屬性標誌著是否已經在路徑中
2、將邊從小排到大
3、如果點沒有全部加入到路徑中，從小到大遍歷每條邊，如果邊的起點在路徑中，邊的終點沒在路徑中，就把終點的前驅設定為起點，同時終點的mark屬性變為true
4、開始重新遍歷邊
在這裡插入圖片描述
在這裡插入圖片描述24.4差分約束和最短路徑
24.5最短路徑性質的證明
四五兩章都非常的理論，我就不看了，真的很討厭這種看的頭疼又看不懂的東西。

以下就是程式碼部分了（建議貼上到自己的編輯器中執行）

Bellman.h

#pragma once
#define BELLV 5/*點的數量*/
#define BELLE 10/*邊的數量*/

/*點*/
typedef struct BellV
{
	char data;/*資料*/
	int d;/*源結點到該點的最短距離*/
	BellV* π;/*前驅結點*/
}Bellv;
/*邊*/
typedef struct
{
	Bellv* start;/*起點*/
	Bellv* end;/*終點*/
	int w;/*權重*/
}Belle;
/*圖*/
typedef struct
{
	Bellv* v[BELLV];/*點集*/
	Belle* e[BELLE];/*邊集*/
}Bellg;

/*初始化*/
void InitBell(Bellg* &G, Bellv* root);
/*鬆弛操作*/
void BellRelax(Bellv* u, Bellv* v, int w);
/*Bellman演算法*/
bool Bellman(Bellg* &G, Bellv* root);
/*列印路徑*/
void BellPrint(Bellv *root, Bellv *end);
/*測試函式*/
void TestBellman();

Bellman.cpp

#include "Bellman.h"
#include<stdio.h>
#include<stdlib.h>
#include<iostream>
using namespace std;

/*初始化*/
void InitBell(Bellg* &G,Bellv* root)
{
	for (int i = 0; i < BELLV; i++)
	{
		G->v[i]->d = 100;/*我們假裝這個100就是∞*/
		G->v[i]->π = NULL;/*前驅為空*/
	}
	root->d = 0;/*源結點*/
}
/*鬆弛操作*/
void BellRelax(Bellv* u, Bellv* v, int w)
{
	if (v->d > u->d + w)
	{
		v->d = u->d + w;
		v->π = u;
	}
}
/*Bellman演算法*/
bool Bellman(Bellg* &G,Bellv* root)
{
	InitBell(G, root);
	int i, j;

	for (i = 0; i < BELLV; i++)/*對頂點進行遍歷*/
	{
		if (G->v[i] != root)/*如果不是根結點*/
		{
			for (j = 0; j < BELLE; j++)
				BellRelax(G->e[j]->start, G->e[j]->end, G->e[j]->w);
		}
	}

	for (i = 0; i < BELLE; i++)/*檢測是否有負迴路*/
		if (G->e[i]->end->d > G->e[i]->start->d + G->e[i]->w)
			return false;
	return true;
}
/*列印路徑*/
void BellPrint(Bellv *root, Bellv *end)
{
	Bellv* tmp = end;
	if (tmp != root)
	{
		BellPrint(root, tmp->π);
		cout << tmp->data << " ";
	}
}

/*測試函式*/
void TestBellman()
{
	/*圖*/
	Bellg* G = new Bellg();
	/*點集*/
	Bellv* s = new Bellv(); s->data = 's';
	Bellv* t = new Bellv(); t->data = 't';
	Bellv* x = new Bellv(); x->data = 'x';
	Bellv* y = new Bellv(); y->data = 'y';
	Bellv* z = new Bellv(); z->data = 'z';

	G->v[0] = s; G->v[1] = t;
	G->v[2] = x; G->v[3] = y; G->v[4] = z;

	int i;

	for (i = 0; i < BELLE; i++)
		G->e[i] = new Belle();
	G->e[0]->start = s; G->e[0]->end = t; G->e[0]->w = 6;
	G->e[1]->start = s; G->e[1]->end = y; G->e[1]->w = 7;
	G->e[2]->start = t; G->e[2]->end = x; G->e[2]->w = 5;
	G->e[3]->start = t; G->e[3]->end = y; G->e[3]->w = 8;
	G->e[4]->start = t; G->e[4]->end = z; G->e[4]->w = -4;
	G->e[5]->start = x; G->e[5]->end = t; G->e[5]->w = -2;
	G->e[6]->start = y; G->e[6]->end = x; G->e[6]->w = -3;
	G->e[7]->start = y; G->e[7]->end = z; G->e[7]->w = 9;
	G->e[8]->start = z; G->e[8]->end = s; G->e[8]->w = 2;
	G->e[9]->start = z; G->e[9]->end = x; G->e[9]->w = 7;

	Bellv* root = s;

	if (Bellman(G, root))
	{
		for (i = 0; i < BELLV; i++)
		{
			if (i != 0)
			{
				cout << root->data << " ";
				BellPrint(root, G->v[i]);
				cout << endl;
			}
		}
	}
	else
		cout << "Error!";
}

主函式

#include "Bellman.h"
#include <stdio.h>

int main()
{
	TestBellman();
	getchar();
	getchar();
	return 0;
}

執行結果
在這裡插入圖片描述
Dijstra.h

#pragma once
#define DIJV 5/*點的數量*/
#define DIJE 10/*邊的數量*/

/*點*/
typedef struct dijV
{
	char data;/*資料*/
	dijV* π;/*前驅*/
	bool mark;/*標記是否已經加入到最短路徑*/
}dijv;
/*邊*/
typedef struct
{
	dijv* start;/*起點*/
	dijv* end;/*終點*/
	int w;/*權重*/
}dije;
/*圖*/
typedef struct
{
	dijv* v[DIJV];/*點集*/
	dije* e[DIJE];/*邊集*/
}dijg;

/*比較函式*/
bool DijCmp(dije* x, dije* y);
/*Dijkstra演算法*/
void Dijkstra(dijg* &g, dijv* root);
/*列印路徑*/
void DijPrint(dijv *root, dijv *end);
/*測試函式*/
void TestDijkstra();

Dijstra.cpp

#include "Dijstra.h"
#include<stdio.h>
#include<stdlib.h>
#include<algorithm>/*sort排序函式所需標頭檔案*/
#include<iostream>
using namespace std;


/*比較函式*/
bool DijCmp(dije* x, dije* y)
{
	return x->w < y->w;/*從小到大*/
}
/*Dijkstra演算法*/
void Dijkstra(dijg* &g,dijv* root)
{
	int i, j;

	for (i = 0; i < DIJV; i++)
	{
		g->v[i]->mark = false;/*沒有被加入最短路徑中*/
		g->v[i]->π = NULL;
	}
	root->mark = true;
	sort(g->e, g->e + DIJE, DijCmp);/*按權重排序*/

	j = 0;
	while (j < DIJV - 1)/*還有點沒有被選中*/
	{
		for (i = 0; i < DIJE; i++)
		{
			if (g->e[i]->start->mark && !(g->e[i]->end->mark))/*起點在路徑中，終點沒有*/
			{
				g->e[i]->end->mark = true;
				g->e[i]->end->π = g->e[i]->start;
				j++;
				i = 20;/*結束這個for迴圈*/
			}
		}
	}
}
/*列印路徑*/
void DijPrint(dijv *root, dijv *end)
{
	dijv* tmp = end;
	if (tmp != root)
	{
		DijPrint(root, tmp->π);
		cout << tmp->data << " ";
	}
}
/*測試函式*/
void TestDijkstra()
{
	int i;
	dijg* g = new dijg();/*圖*/
	dijv* s = new dijv(); s->data = 's';
	dijv* t = new dijv(); t->data = 't';
	dijv* x = new dijv(); x->data = 'x';
	dijv* y = new dijv(); y->data = 'y';
	dijv* z = new dijv(); z->data = 'z';

	g->v[0] = s; g->v[1] = t;
	g->v[2] = x; g->v[3] = y; g->v[4] = z;

	for (i = 0; i < DIJE; i++)
		g->e[i] = new dije();

	g->e[0]->start = s; g->e[0]->end = t; g->e[0]->w = 10;
	g->e[1]->start = s; g->e[1]->end = y; g->e[1]->w = 5;
	g->e[2]->start = t; g->e[2]->end = x; g->e[2]->w = 1;
	g->e[3]->start = t; g->e[3]->end = y; g->e[3]->w = 2;
	g->e[4]->start = x; g->e[4]->end = z; g->e[4]->w = 4;
	g->e[5]->start = y; g->e[5]->end = t; g->e[5]->w = 3;
	g->e[6]->start = y; g->e[6]->end = x; g->e[6]->w = 9;
	g->e[7]->start = y; g->e[7]->end = z; g->e[7]->w = 2;
	g->e[8]->start = z; g->e[8]->end = s; g->e[8]->w = 7;
	g->e[9]->start = z; g->e[9]->end = x; g->e[9]->w = 6;

	dijv* root = s;
	Dijkstra(g, s);

	for (i = 0; i < DIJV; i++)
	{
		if (i != 0)
		{
			cout << root->data << " ";
			DijPrint(root, g->v[i]);
			cout << endl;
		}
	}
}

主函式

#include "Dijstra.h"
#include <stdio.h>

int main()
{
	TestDijkstra();
	getchar();
	getchar();
	return 0;
}

執行結果
在這裡插入圖片描述

相關推薦

《演算法導論》第24章——單源最短路徑

  雖然寫這個部落格主要目的是為了給我自己做一個思路記憶錄，但是如果你恰好點了進來，那麼先對你說一聲歡迎。我並不是什麼大觸，只是一個菜菜的學生，如果您發現了什麼錯誤或者您對於某些地方有更好的意見，非常歡迎您的斧正！ 最短路徑的最優子結構 最短路徑的子路徑也是最短路徑。

演算法基礎【6】單源最短路徑——詳解Bellman-Ford、迪傑斯特拉演算法

首先我們構造研究物件：計算從V0開始到所有節點的最短路徑1、dijkstra，D演算法首先我們將需要計算最小路徑的入口點的Cost複製到一個D數組裡。（鄰接矩陣對應的行）我們知道第一個節點到達的各個頂點所需的花費（路程）（無法到達花費是正無窮）找到最近的那個點。存下來（如果我

《演算法導論》筆記 第24章 24.2 有向無回圖中的單源最短路徑

【筆記】 對dag進行拓撲排序對每個頂點鬆弛從該點出發的所有邊。 【練習】 24.2-1 以頂點r為源點，執行DAG。 略 24.2-2 對|V|-1處理仍正確。 最後一個點的鬆弛不會對之前的點有影響，因此處理正確。 24.2-3 權值賦給頂點應如何計算。 2

演算法導論筆記：24單源最短路徑

       最短路徑問題：一個帶權重的有向圖G = (V, E)和權重函式w: E->R，該權重函式將每條邊對映到實數值的權重上。一條路徑p的權重w(p)是構成該路徑的所有邊的權重之和，定義從

【演算法導論】單源最短路徑之Dijkstra演算法

        Dijkstra演算法解決了有向圖上帶正權值的單源最短路徑問題，其執行時間要比Bellman-Ford演算法低，但適用範圍比Bellman-Ford演算法窄。 迪傑斯特拉提出的按路徑長度遞增次序來產生源點到各頂點的最短路徑的演算法思想是：對有n個頂點的有向連

演算法導論之單源最短路徑

單源最短路徑，在現實中是很多應用的，是圖的經典應用，比如在地圖中找出兩個點之間的最短距離、最小運費等。單源最短路徑的問題：已知圖G=(V,E)，找出給定源頂點s∈V到每個頂點v∈V的最短路徑。單源最短路徑衍生出的變體問題如下： 1）單終點最短路徑問題：找出從每個頂點v到指定

《演算法導論》筆記（16） 單源最短路徑 部分習題

習題21.1-3 Bellman-Ford演算法改進為m+1次鬆弛後終止。圖中結點若在s->v的路徑中則作標記。鬆弛過程中，若有標記的結點全部不更新v值，則停止。此時鬆弛次數為m+1趟。 習題21.1-5 鬆弛方法改為結點已有d值，對其所有入邊選擇w+ d< d

單源最短路徑（Dijkstra）——貪心演算法

  Dijkstra演算法是解單源最短路徑問題的貪心演算法。其基本思想是，設定頂點集合點集合S並不斷地做貪心選擇來擴充這個集合。一個頂點屬於集合S當且僅當從源到該頂點的最短路徑長度已知。初始時，S中僅含有源。設u是G的其一頂點。把從源到u且中間只經過S中頂點的路稱為從源到u的特殊

Dijkstra演算法(有權圖單源最短路徑)

  從一個源點到其他各頂點的最短路徑問題稱為“單源最短路徑問題”。 最短路徑的最優子結構性質 該性質描述為：如果P(i,j)={Vi…Vk…Vs…Vj}是從頂點i到j的最短路徑，k和s是這條路徑上的一箇中間頂點，那麼P(k,s)必定是從k

帶有負權值的單源最短路徑-bellman-ford演算法

https://baike.baidu.com/item/Bellman-Ford%E7%AE%97%E6%B3%95/1089090?fr=aladdin&fromid=6039406&fromtitle=bellman-ford 參考百科的c++實現版本 import java.

Dijkstra演算法，有權單源最短路徑

與無權單源最短路徑相似，與層次遍歷相似；以遞增的順序依次收錄遇到的最短距離的頂點 int findmin(Graph G,int dist[],int collected[]) // 找到一個未被收錄的最小值 { int Min = MAXNUM; // 儲存最小值,初值為無窮大；

【資料結構】單源最短路徑 Dijkstra演算法

單源最短路徑問題是指：對於給定的有向網路G=(V，E)，求原點V0到其他頂點的最短路徑。 按照長度遞增的順序逐步產生最短路徑的方法，稱為Dijkstra演算法。 該演算法的基本思想： 把圖中的所有頂點分成兩組，第一組包括已確定最短路徑的頂點，初始時只含有一個源點，記為集合S；第

dijkstra演算法(單源最短路徑) python實現

用例圖： 程式碼1： 用最原始的方式實現dijkstra，就是每次從costs裡面找最短路徑的點，再遍歷這個點的邊，更新最短路徑。由於每次都要從costs裡面找最短路徑，時間複雜讀為O(n^2)。 # dijjkstra演算法(原生最短路徑，還未優化) def dij(start,

單源最短路徑Dijkstra演算法

1.單源最短路徑 函式：返回還未被收錄頂點中dist最小者 1 Vertex FindMinDist(MGraph Graph, int dist[], int collected[]) 2 { 3 /*返回未被收錄頂點中dist最小者*/ 4 Vertex MinV, V;

使用鄰接矩陣+Dijkstra演算法求解單源最短路徑問題

Dijkstra演算法是求解有向帶權圖中某一結點到其它結點的最短路徑演算法。這個演算法和Prim演算法求解最小生成樹有點相似，它也是先有一個初始頂點，然後查詢最小帶權路徑。 不同的是，Prim需要更新最小生成樹的結點，不斷將結點更新到VT中，然後更新low_cost[]陣列

Java資料結構：單源最短路徑問題---Dijkstra演算法

嚶擊長空 如圖： 思路：先任意找一個根節點，然後開始迴圈找連線該點所有邊，然後找到權值最小的一項，標記被訪問，然後再次迴圈找除了根節點和被訪問過的結點的邊，找到權值最小的。具體開註釋，非常詳細喲。 上程式碼： public void shortesPath(int i) { in

單源最短路徑----prim演算法

這一題是用二維陣列將點存入。 scanf("%d%d%d",&x,&y,&z); if(a[x][y]!=0){ a[x][y]=min(a[x][y],z); } else a[x][y]=z; 至於那個判斷則是判重邊啦。 先將每個

計算機演算法設計與分析 （四） 貪心演算法--單源最短路徑

1.Dijkstra演算法是解決單源最短路徑的一個貪心演算法。給定一個帶權有向圖G=(V,E),其中每條邊的權都是非負實數，另外，還給定V中的一個頂點，稱為源。現在要計算源到其他各個頂點的最短路長度。這裡的路的長度指的是路上各邊權之和。 Dijkstra演算法可

分支限界法：單源最短路徑--dijkstra演算法

單源最短路徑–dijkstra演算法 前面已經多次介紹過dijkstra演算法是貪心演算法，是動態規劃，實際上可以從分支限界的角度來理解； 分支限界法 分支限界法，實際上就是回溯法，一般意義的回溯法是基於深度優先搜尋，也可以配合限界函式剪枝，通常分支限界法基於寬度優先搜尋，通過佇

演算法之單源最短路徑問題

1.問題描述：給出一個有向圖G，圖中的每一條邊都有一個非負邊權，要求找出從圖的源頂點s到目標頂點t之間的最短路徑。 例圖：從左到右從上到下，序號從0開始依次增大，即頂點個數n=11，A=s，E=t 2.問題分析： （1）分支限界法： 演算法從G的源點s和空佇列