圖論-最短路徑
2019/11/15 更新日誌html
發現個人Dijstra優先隊列模板有點問題，修改了，並在多處刪繁就簡，增添詳細註釋。ios
昨天： 圖論-概念與記錄圖的方法c++
以上是昨天的Blog，有須要者請先閱讀完以上再閱讀今天的Blog。git
可能今天的有點亂，好好理理，認真看完相信你會懂得算法
分割線數組
次日
引子：昨天咱們簡單講了講圖的概念與記錄圖的方法，那麼你們有必定的底子了，咱們就開始初步接觸圖論算法了！優化
咱們只講Dijkstra和Floyd，由於其實在比賽中會這兩個算法就很好了。spa
今天咱們要講的是：最短路徑問題日誌
Top1：最短路的概念
相信你們都知道有一款Made in China的導航軟件——百度導航。那麼他們是怎麼爲咱們導航的？就是使用了今天咱們要學的問題 最短路徑 。code
說不定你學了以後就能夠作一個導航的 是否是有點小激動？
$重點：最短路問題就是一個點到另外一個最短的路徑！$
最短路專業術語：
中轉點： 一個點到另外一個點不必定是有直接道路鏈接的，可能會通過一些別的點，咱們就叫那些點叫作 中轉點 。
鬆弛： 好比如今從 $I$ 點到 $J$ 點的邊權爲 $X$ ，而如今有一個點 $K$ ，$K$ 到 $I$ 的邊權爲 $Y$ ，$K$ 到 $J$ 的邊權爲 $Z$。若是 $Y$ + $Z$ < $X$ ，也就是 ($I$ 點到 $J$ 點的路徑邊權) 比 ($K$ 到 $J$ 的邊權) 加上 ($K$ 到 $I$ 的邊權) 還要大，那麼顯而易見， $I$ 到 $J$ 的直接路徑 $X$ 能夠由中轉點 $K$ 降到 $Y + Z$，使得 $I$ 到 $J$ 的最短路徑更優。
Top2:Floyd算法
如今你們都知道最短路是什麼了，那麼從簡單到複雜，咱們先來看看新手必懂的算法。
Floyd簡單粗暴，就是枚舉三個點，一個起點，一個終點，一箇中轉點。看 起點到中轉點的路徑 加上 中轉點到終點的路徑 是否是小於 目前起點到終點的路徑 便可（就是不斷鬆弛）。
顯而易見，Floyd算法很好懂，就是時間複雜度高了點—— $N^3$ 的複雜度。並且，Floyd是多源最短路，詢問時只需調用dis就好了。
因此， 當 N 大於1000時，慎用！
代碼就很簡答啦(蒟蒻用鄰接矩陣寫的)：
//若是爲無向圖,dis就會對稱,Floyd的j就只要到i,且dis[i][j]dis[j][i] 要一塊兒更新
#include<bits/stdc++.h>
using namespace std;
const int MAXN = 1000 + 10;
int n,m;
int x,y,z;
int dis[MAXN][MAXN];
void Floyd(){
for(int k = 1;k <= n; k++)
for(int i = 1;i <= n; i++)
for(int j = 1;j <= n/*i*/; j++)
if(dis[i][k] + dis[k][j] < dis[i][j])dis[i][j] = dis[i][k] + dis[k][j];
return;
}
int main(){
cin>>n>>m;
for(int i = 1;i <= n; i++)dis[i][i] = 0;
for(int i = 1;i <= n; i++)
for(int j = 1;j <= n; j++){
if(i != j)dis[i][j] = 1e9;
}
for(int i = 1;i <= m; i++){
cin>>x>>y>>z;
dis[x][y] = z;
}
Floyd();
for(int i = 1;i <= n; i++){
for(int j = 1;j <= n; j++){
cout<<dis[i][j]<<" ";
}
cout<<endl;
}
return 0;
}
Top3：Dijkstra算法
Dijkstra與Floyd相反，是單元最短路，即只能求出一個點到其餘全部點的最短路。
Dijkstra屬於貪心的思想，正解：
首先定義兩個種類——黑點和白點，黑點就是在目前算完最短路徑的點，白點反之。
每次在白點中找一個離目前任意一個黑點最近的，加入黑點，更新白點到原點的最短路便可。
代碼以下：注意：這裏的dis再也不是鄰接矩陣，是單源最短路徑。tot纔是鄰接矩陣！
鄰接矩陣，蒟蒻是用洛谷P1828 香甜的黃油 Sweet Butter 做爲例題寫的模板，體諒一下
#include<bits/stdc++.h>
using namespace std;
const int MAXN = 100 + 10;
struct Node{
int x,y;
}f[MAXN];
int n,m,a,b,s,t;
bool black[MAXN];
double dis[MAXN];
double tot[MAXN][MAXN];
double calc(int i,int j){
return sqrt((f[i].x - f[j].x) * (f[i].x - f[j].x) + (f[i].y - f[j].y) * (f[i].y - f[j].y));
}
double Dijkstra(int start,int end){
for(int i = 1;i <= n; i++){
dis[i] = tot[start][i];
}
dis[start] = 0;
black[start] = true;
for(int i = 1;i < n; i++){
double M = 2e9;
int u = start;
for(int j = 1;j <= n; j++){
if(dis[j] < M && !black[j]){
M = dis[j];
u = j;
}
}
if(u == start)continue;
//此處的判斷與前面的u = start對應,若該圖存在一個單獨的點這裏就要加上
//不然能夠u = 0,這個判斷刪掉
black[u] = true;
for(int j = 1;j <= n; j++){
if(black[j])continue;
if(dis[u] + tot[u][j] < dis[j]){
dis[j] = dis[u] + tot[u][j];
}
}
}
return dis[end];
}
int main(){
scanf("%d",&n);
for(int i = 1;i <= n; i++)
for(int j = 1;j <= n; j++){
tot[i][j] = i == j ? 0 : 1e9;
}
for(int i = 1;i <= n; i++){
scanf("%d%d",&f[i].x,&f[i].y);
}
scanf("%d",&m);
for(int i = 1;i <= m; i++){
scanf("%d%d",&a,&b);
tot[a][b] = calc(a,b);
tot[b][a] = tot[a][b];
}
scanf("%d%d",&s,&t);
printf("%.2f",Dijkstra(s,t));
return 0;
}
因此，Dijkstra的時間複雜度是 $N^2$
怎麼優化呢？很簡單——在尋找離黑點最近的白點時，使用優先隊列便可。
可是這裏要注意的是，咱們樸素的使用單調隊列維護，在洛谷 P4779 【模板】單源最短路徑 中會TLE。
爲何呢？
咱們的優先隊列不想 set 等 STL ，沒有自動去重的功能。因此當隊列中有多個相同的元素時，Dijkstra的效率會大大減小。
因此 ，咱們須要一個bool型的數組，不難想到，該數組用來記錄 每一個元素當前在隊列中是否存在。
細節又來了。 咱們bool型數組的定義是 每一個元素當前在隊列中是否存在。 那麼咱們每次在優先隊列彈出隊首進行操做時，咱們須要 將隊首的bool標記取消。
一個元素能夠屢次單獨出如今隊列，可是不能一次多個出如今隊列。
雖然屢次拓展到隊首，可是隊首到源點的最短路徑 可能 更新了。因此咱們不妨再次從隊首再次進行拓展，更新周圍點的答案。 這就是咱們爲何要將隊首的bool標記取消。
優先隊列Dijkstra：
#include<bits/stdc++.h>
#include<cctype>
#pragma GCC optimize(2)
#define in(a) a = read()
#define out(a) write(a),printf(" ")
#define outn(a) write(a),putchar('\n')
#define ll long long
#define rg register
#define New int
using namespace std;
namespace IO_Optimization{
inline New read()
{
New X = 0,w = 0;
char ch = 0;
while(!isdigit(ch))
{
w |= ch == '-';
ch=getchar();
}
while(isdigit(ch))
{
X = (X << 3) + (X << 1) + (ch ^ 48);
ch = getchar();
}
return w ? -X : X;
}
inline void write(New x)
{
if(x < 0) putchar('-'),x = -x;
if(x > 9) write(x/10);
putchar(x % 10 + '0');
}
#undef New
}
using namespace IO_Optimization;
const int MAXN = 1000000 + 2;
int n,m,s,x,y,z,len,p;
int dis[MAXN],nxt,val;
struct Node
{
int num,dist;
inline bool operator <(const Node &nnxt)const{
return dist > nnxt.dist;
}
};
vector<Node> nei[MAXN];
bool vis[MAXN];
inline void Dijkstra(int start)
{
memset(dis,0x3f3f3f3f,sizeof(dis));
memset(vis,false,sizeof(vis));
priority_queue<Node>q;
Node cur = {start,0};
q.push(cur);
dis[start] = 0;
vis[start] = true;
while(!q.empty())
{
cur = q.top();
q.pop();
p = cur.num;
vis[p] = false;
len = nei[p].size();
for(rg int i = 0;i < len; ++i)
{
nxt = nei[p][i].num;
val = nei[p][i].dist;
if(dis[nxt] > dis[p] + val)
{
dis[nxt] = dis[p] + val;
if(!vis[nxt])
{
Node tmp = {nxt,dis[nxt]};
q.push(tmp);
vis[nxt] = true;
}
}
}
}
return;
}
int main()
{
in(n),in(m),in(s);
for(rg int i = 1;i <= m; ++i)
{
in(x),in(y),in(z);
nei[x].push_back((Node){y,z});
}
Dijkstra(s);
for(rg int i = 1;i <= n; ++i)
out(dis[i] == 0x3f3f3f3f ? 2147483647 : dis[i]);
return 0;
}
順便帶一下SPFA的算法模板和用動態數組記錄的Dijkstra(這裏不作詳解了，有須要的人能夠複製看一下)
SPFA：
#include<iostream>
#include<cmath>
#include<algorithm>
#include<queue>
#include<cstring>
using namespace std;
int n, p, c, cow[801], a, b, d, cnt = 0, sum = 0, ans = 2147483647;
int dis[10000], w[10000], next[10000], to[10000], first[10000] = {0};
bool exist[10000] = {false};
queue<int> q;
void addEdge(int u, int v, int weight)
{
cnt++; //邊的編號
to[cnt] = v; //第cnt條邊指向點v
w[cnt] = weight; //第cnt條邊的權值
next[cnt] = first[u]; // 第cnt條邊指向鏈接點u的第一條邊
first[u] = cnt; //將鏈接點u的第一條邊更新爲第cnt條邊
return;
}
void spfa(int start)
{
memset(exist, false, sizeof(exist)); //一開始全部點在隊列外
memset(dis, 0x7f, sizeof(dis)); //將全部點到起始點的距離置爲極大值
dis[start] = 0;
q.push(start); //起始點入隊列
exist[start] = true;
while(!q.empty())
{
int head = q.front(); //取隊列的第一個點
q.pop();
exist[head] = false;
for(int e = first[head]; e != 0; e = next[e]) //循環head鏈接的每一條邊
{
//鬆弛操做
if(dis[head] + w[e] < dis[to[e]])
{
dis[to[e]] = dis[head] + w[e];
if(exist[to[e]] == false)
{
q.push(to[e]); //將被更新的點入隊列
exist[to[e]] = true;
}
}
}
}
return;
}
int main()
{
cin >> n >> p >> c;
for(int i=1; i <= n; i++) //輸入每頭牛所在的位置
{
cin >> cow[i];
}
for(int e=1; e <= c; e++) //輸入每一條邊
{
cin >> a >> b >> d;
addEdge(a, b, d);
addEdge(b, a, d);
}
for(int i=1; i <= p; i++) //注意是循環牧場
{
spfa(i);
sum = 0;
for(int j=1; j <= n; j++)
{
sum = sum + dis[cow[j]];
}
ans = min(ans, sum);
}
cout << ans;
return 0;
}
好了，次日就到這裏，是否是都聽懂了呢狗屁？歡迎在下方留言！
原文出處：https://www.cnblogs.com/CJYBlog/p/short-path.html
- 1. 【圖論】最短路徑
- 2. 圖 - 最短路徑
- 3. 圖-最短路徑
- 4. 圖論 五 最短路徑 最長路徑
- 5. 基礎圖論（最短路徑）
- 6. C++ 圖論之最短路徑
- 7. 圖論——最短路徑算法學習
- 8. 圖論——可達性和最短路徑
- 9. 8-1 圖論最短路徑問題
- 10. 圖論之最短路徑floyd算法
- 更多相關文章...
- • Eclipse Java 構建路徑 - Eclipse 教程
- • CAP理論是什麼？ - NoSQL教程
- • 適用於PHP初學者的學習線路和建議
- • Tomcat學習筆記（史上最全tomcat學習筆記）
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 【圖論】最短路徑
- 2. 圖 - 最短路徑
- 3. 圖-最短路徑
- 4. 圖論 五 最短路徑 最長路徑
- 5. 基礎圖論（最短路徑）
- 6. C++ 圖論之最短路徑
- 7. 圖論——最短路徑算法學習
- 8. 圖論——可達性和最短路徑
- 9. 8-1 圖論最短路徑問題
- 10. 圖論之最短路徑floyd算法