2. 程式人生 > 其它 >圖論_最短路例題(更新中)

圖論_最短路例題(更新中)

阿新 • • 發佈：2021-07-22

P4779 【模板】單源最短路徑（標準版）

題目描述

給定一個n個點，m條有向邊的帶非負權圖，請你計算從s出發，到每個點的距離。

資料保證你能從s出發到任意點。

輸入格式

第一行為三個正整數n, m, s。 第二行起m行，每行三個非負整數ui, vi, wi，表示從ui​到vi​有一條權值為wi​的有向邊。

輸出格式

輸出一行n個空格分隔的非負整數，表示s到每個點的距離。

輸入輸出樣例

輸入 #1 輸出 #1

4 6 1     0 2 4 3
1 2 2
2 3 2
2 4 1
1 3 5
3 4 3
1 4 4

說明/提示

1≤n≤1e5；

1≤m≤2e5；

s = 1;

1≤ui​,vi​≤n；

0≤wi​≤1e9,

0≤∑wi​≤1e9。

思路：dijkstra演算法

0分程式碼：#1#3~#5WA #2#6~#10TLE

 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstring>
 4 #include <algorithm>
 5 #include <vector>
 6 #include <queue>
 7 #include <map>
 8 #include <set>
 9 using namespace std;

 
10 const int maxn = 5e5 + 5;
11 const long long INF = 2147483647;
12 struct edge
13 {
14     int from;
15     int to;
16     int cost;
17 }es[maxn];
18 int V,E,s,u,v,w;
19 long long d[maxn];
20 bool used[maxn];
21 void fill(bool* start, bool* end, bool flag)
22 {
23     for (; start != end; ++start)
24
 
         *start = flag;
25 }
26 void fill(long long* start, long long* end, long long num)
27 {
28     for (; start != end; ++start)
29         *start = num;
30 }
31 void init()
32 {
33     fill(d + 1, d + 1 + V, INF);
34     fill(used + 1, used + 1 + V, false);
35     d[s] = 0;
36 }
37 void dijkstra(int s)
38 {
39     init();
40     while (true)
41     {
42         int v = -1;
43         for (int u = 1; u <= V; ++u)
44             if (!used[u] && (v == -1 || d[u] < d[v]))
45                 v = u;
46         if (v == -1)
47             break;
48         used[v] = true;
49         for (int u = 1; u <= V; ++u)
50         {
51             for (int i = 1; i <= E; ++i)
52             {
53                 if (es[i].from == v && es[i].to == u)
54                 {
55                     w = es[i].cost;
56                     break;
57                 }
58             }
59             d[u] = min(d[u],d[v] + w);
60         }        
61     }
62 }
63 int main()
64 {
65     scanf("%d%d%d",&V,&E,&s);
66     for (int i = 1; i <= E; ++i)
67     {
68         scanf("%d%d%d",&u,&v,&w);
69         es[i].from = u;
70         es[i].to = v;
71         es[i].cost = w;
72     }
73     dijkstra(s);
74     for (int i = 1; i < V; ++i)
75     {
76         printf("%lld ",d[i]);
77     }
78     printf("%lld",d[V]);
79     return 0;
80 }

分析原因：本題我看資料範圍1e5 如果使用鄰接矩陣必定炸空間；

所以使用edge結構體，結果顯然導致了另一個問題，但我這個蒻蒟就是沒注意到，

那便是查詢cost[v][u]時，由於結構體的原因不能O(1)查到，導致要多套一重迴圈來查詢

這直接導致了TLE

優化：有一說一，STL真好用。

定義的一個struct edge用於接受臨時資料，其實沒啥卵用；

vector<pair<int,int> > v;建立邊權鄰接表；

priority_queue<pii, vector<pii>,greater<pii> > pq;使用優先佇列維護

100分程式碼：#1~#10 AC

 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstring>
 4 #include <algorithm>
 5 #include <vector>
 6 #include <queue>
 7 #include <map>
 8 #include <set>
 9 using namespace std;
10 const int maxn = 5e5 + 5;
11 const long long INF = 2147483647;
12 int V,E,s,u,v,w;
13 long long d[maxn];
14 //bool used[maxn];
15 struct edge
16 {
17     int cost;    
18     int to;
19 };
20 typedef pair<int,int> pii;
21 vector<pii> G[maxn];
22 /*
23 void fill(bool* start, bool* end, bool flag)
24 {
25     for (; start != end; ++start)
26         *start = flag;
27 }
28 */
29 void fill(long long* start, long long* end, long long num)
30 {
31     for (; start != end; ++start)
32         *start = num;
33 }
34 void init()
35 {
36     fill(d + 1, d + 1 + V, INF);
37     //fill(used + 1, used + 1 + V, false);
38     d[s] = 0;
39 }
40 void dijkstra(int s)
41 {
42     init();
43     priority_queue<pii, vector<pii>, greater<pii> > pq;
44     pq.push(pii(0,s));
45     while (!pq.empty())
46     {
47         pii p = pq.top();
48         pq.pop();
49         int v = p.second;
50         if (d[v] < p.first)    
51             continue;
52         for (int i = 0; i < (int)G[v].size(); ++i)
53         {
54             edge e;
55             e.cost = G[v][i].first;
56             e.to = G[v][i].second;
57             if (d[e.to] > d[v] + e.cost)
58             {
59                 d[e.to] = d[v] + e.cost;
60                 pq.push(pii(d[e.to],e.to));
61             }
62         }
63     }
64 }
65 int main()
66 {
67     scanf("%d%d%d",&V,&E,&s);
68     for (int i = 1; i <= E; ++i)
69     {
70         scanf("%d%d%d",&u,&v,&w);
71         G[u].push_back(pii(w,v));
72     }
73     dijkstra(s);
74     for (int i = 1; i < V; ++i)
75     {
76         printf("%lld ",d[i]);
77     }
78     printf("%lld",d[V]);
79     return 0;
80 }

總結：

1.分析資料防炸時，不能只看到其中一者而忽略了另一者。

所以選擇建圖的方式很重要。

2.無論dijkstra演算法 還是bellman-ford演算法，使用priority_queue維護都能加快很多執行速度，最差也是跟未使用優先佇列維護複雜度相同。

P1629 郵遞員送信

題目描述

有一個郵遞員要送東西，郵局在節點1。他總共要送n - 1樣東西，其目的地分別是節點2到節點n。

由於這個城市的交通比較繁忙，因此所有的道路都是單行的，共有m條道路。

這個郵遞員每次只能帶一樣東西，並且運送每件物品過後必須返回郵局。

求送完這n - 1樣東西並且最終回到郵局最少需要的時間。

輸入格式

第一行包括兩個整數，n和m，表示城市的節點數量和道路數量。

第二行到第(m + 1)行，每行三個整數，u,v,w表示從u到v有一條通過時間為w的道路。

輸出格式

輸出僅一行，包含一個整數，為最少需要的時間。

輸入輸出樣例

輸入#1 輸出 #1

5 10      83
2 3 5
1 5 5
3 5 6
1 2 8
1 3 8
5 3 4
4 1 8
4 5 3
3 5 6
5 4 2

說明/提示

對於30%的資料，1 ≤ n ≤ 200。

對於100%的資料，1≤n≤1e3，1≤m≤1e5，1≤u,v≤n，1≤w≤1e4，輸入保證任意兩點都能互相到達。

思路一：使用floyd-warshall演算法，計算出任意兩點的值，然後∑d[1][i] + d[i][1]

解析：但這樣顯然有問題，對於本題的資料來說，O(n^3)必超時

0分程式碼：#1~#4WA #5~#10

 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstring>
 4 #include <algorithm>
 5 #include <vector>
 6 #include <queue>
 7 #include <map>
 8 #include <set>
 9 using namespace std;
10 const int maxn = 1e5 + 5;
11 const int MAXN = 1e3 + 5;
12 const int INF = 1e4 + 5;
13 int V,E,u,v,w,cost[MAXN][MAXN],d[MAXN][MAXN];
14 long long ans;
15 void init()
16 {
17     for (int i = 1; i <= V; ++i)
18         for (int j = 1; j <= V; ++j)
19             if (i == j)
20                 d[i][j] = 0;
21             else
22                 d[i][j] = INF;
23 }
24 void warshall_floyd()
25 {
26     for (int k = 1; k <= V; ++k)
27         for (int i = 1; i <= V; ++i)
28             for (int j = 1; j <= V; ++j)
29                 d[i][j] = min(d[i][j],d[i][k] + d[k][j]);
30 }
31 int main()
32 {
33     scanf("%d%d",&V,&E);
34     init();
35     for (int i = 1; i <= E; ++i)
36     {
37         scanf("%d%d%d",&u,&v,&w);
38         d[u][v] = cost[u][v] = w;
39     }
40     warshall_floyd();
41     ans = 0;    
42     for (int i = 2; i <= V; ++i)
43     {
44         ans += d[1][i];
45         ans += d[i][1];
46     }
47     return printf("%lld\n",ans),0;
48 }

思路二：使用多次dijkstra演算法，但是具體幾次呢？

分析：題目要求1到i的最短路徑和 以及 i到1的最短路徑和

比如說：1->2->3->5 為1到5的最短路

　　　　5->4->2->1 為5到1的最短路：其實路徑長度等於 1->2->4->5 所以我們只需要將原來的邊翻轉，然後在以1為起點求到i的路徑和即為i到1的路徑和

所以最後，我們只需要使用兩次dijkstra演算法就能得到本題的答案，複雜度為O(n^2)。

100分程式碼：#1~#10AC

 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstring>
 4 #include <algorithm>
 5 #include <vector>
 6 #include <queue>
 7 #include <map>
 8 #include <set>
 9 using namespace std;
10 const int MAXN = 1e3 + 5;
11 const int INF = 10000000;
12 int V,E,u,v,w,ans,cost[MAXN][MAXN],d[MAXN];
13 bool used[MAXN];
14 void fill(bool* start, bool* end, bool flag)
15 {
16     for (; start != end; ++start)
17         *start = flag;
18 }
19 void fill(long long* start, long long* end, long long num)
20 {
21     for (; start != end; ++start)
22         *start = num;
23 }
24 void init()
25 {
26     fill(d + 1, d + 1 + V, INF);
27     fill(used + 1, used + 1 + V, false);
28 }
29 void dijkstra(int s)
30 {
31     init();
32     d[s] = 0;
33     while (true)
34     {
35         int v = -1;
36         for (int u = 1; u <= V; ++u)
37             if (!used[u] && (v == - 1 || d[u] < d[v]))
38                 v = u;
39         if (v == -1)
40             break;
41         used[v] = true;
42         for (int u = 1; u <= V; ++u)
43             d[u] = min(d[u],d[v] + cost[v][u]);//cout << "d[" << u << "] = " << d[u] << endl;
44     } 
45 }
46 void over()
47 {  
48     for (int i = 1; i <= V; ++i)
49         for (int j = i + 1; j <= V; ++j)
50             cost[i][j] ^= cost[j][i] ^= cost[i][j] ^= cost[j][i];    
51 }
52 int main()
53 {
54     scanf("%d%d",&V,&E);
55     for (int i = 1; i <= V; ++i)
56         for (int j = 1; j <= V; ++j)
57             cost[i][j] = INF;
58     for (int i = 1; i <= E; ++i)
59     {
60         scanf("%d%d%d",&u,&v,&w);
61         cost[u][v] = min(cost[u][v],w);//（注意，這個有個坑點，搞的我wa了一發）題目的邊有可能重複輸入
62     }
63     dijkstra(1);
64     for (int i = 2; i <= V; ++i)
65         ans += d[i];
66     over();
67     dijkstra(1);
68     for (int i = 2; i <= V; ++i)
69         ans += d[i];
70     return printf("%d\n",ans),0;
71 }

總結：

1.本題get一個新知識，反向建圖得到 i 到 s的最短路徑

2.本題get一個新坑點，題目雖然未提示可能重邊，但是自己平常考慮wa的時候要注意一下是不是這個問題

3.時間複雜度的分析，100以內n^3沒問題，但1000以外n^3基本必炸

相關推薦

圖論_最短路例題(更新中)

P4779 【模板】單源最短路徑（標準版） 題目描述 給定一個n個點，m條有向邊的帶非負權圖，請你計算從s出發，到每個點的距離。

圖論之最短路

目錄1.Floyd(弗洛伊德)思想Floyd輸出最短路徑傳遞閉包問題Dijkstra(迪科斯徹)思想鬆弛操作程式碼優化Bellman-Ford(貝爾曼-福特)思想程式碼輸出路徑SPFA(佇列優化的Bellman-Ford)程式碼

2.3搜尋與圖論（最短路）

1.樸素Dijkstra演算法 稠密圖用鄰接矩陣，稀疏圖用鄰接表存 1≤m≤10^5，所以顯然這是個稠密圖，由於圖中可能存在重邊和自環，於是我們用g[N][N]儲存每條邊的距離時，先要將其初始化為無窮，然後讀取時比較一下其

圖論_單源最短路模板

Flyod int g[N][N] for (int k = 1; k <= n; k ++ ) for (int i = 1; i <= n; i ++ ) for (int j = 1; j <= n; j ++ )

演算法學習-圖論-圖的儲存-最短路

題目概述及細節 單源最短路，模板，luoguP3371單源最短路，模板dij演算法 核心是把節點分為兩類，一類是以確定到起點最短的距離，一類是沒有確定

鏈式前向星建圖+SPFA求最短路

#include <iostream> #include <cmath> #include <cstdlib> #include <cstring> #include <climits>

圖論：次短路

注意：此次短路可以走重邊 點選檢視程式碼 /* 次短路： 邊可以重複走 1.以1為起點跑最短路，以n為起點跑最短路。

圖論_圖結構的基礎理論知識

圖結構 1.圖也是一種常見的資料結構 2.圖是一種和樹結構由些相似的資料結構 3.圖結構也圖論，在數學的概念上，樹是圖的一種

圖論_迪傑斯特拉演算法(Dijkstra)

Dijkstra演算法 求解一系列點中任意兩點間最短距離的演算法--圖論最短距離 簡介：

Dijkstra演算法_最短路演算法

\\(Dij\\)是一類基於貪心的最短路演算法。 首先我們明確這個演算法是幹什麼的，這個演算法是用來跑單源最短路的，也就是給你一張圖，給出某一個特定的起點，你需要求出這個點到其他任意點的最短路。

Codeforces-1473 E. Minimum Path（分層圖(多維)最短路）

技術標籤：# codeforces# 最短路 題意： 一條路徑的花費為 求1點到其他所有點路徑的最小花費。

有負權圖上的最短路演算法 (Goldberg, 1995)

最近聽說有了一個有負權圖上的 \\(O(m\\log^8 m \\log w)\\) 演算法, 感覺非常厲害, 於是覺得先來研讀一個早些的工作. 如果有可能的話再嘗試研讀新的演算法!

圖論演算法（二） 最短路SPFA演算法

我可能要退役了…… 退役之前，寫一篇和我一樣悲慘的演算法：SPFA 最短路演算法（二）SPFA演算法

圖論最短路之分層圖

一般問題 在圖上，將某一條邊或多條邊進行修改，進而求最短路 變形 包括刪去某一（或多條）條邊（權值變為0），將某一條邊（或多條）減半，將某一條邊進行特殊賦值，求最短路

圖論 最短路總結

寫在前面：圖論題的除錯真感人 讓我們進入正題 最短路是啥 emmm 顧名思義最短路就是求一個點到另外一個點的最小距離

圖論最短路之最小環

題目 思路 一開始建虛點做，然後寫掛了， 這道題可以列舉1連出去的邊，然後找到邊連到的點，再斷掉該邊（記得斷雙向），然後對1跑到該點的最短路，加上斷邊的長度，然後再繼續列舉其他邊（記得把之前的邊連上！！

圖論初步&&最短路

圖論初步&&最短路 Part 1:什麼是圖?? A:圖是指由m個點,n條邊組成的資料結構,分為有向圖和無向圖兩種,其中有向圖是指\"1-->3\" 而無向圖是\"1--3\",在存圖是會有不同(有向圖只需存一遍,而無向圖需要反向存

【團隊內部試題】【圖論/最短路】很重的罪

題目背景 請注意閱讀題目中括號裡的內容。 \\(\\mathbb N\\)：非負整數；\\(\\mathbb N*\\)：正整數（沒有\\(0\\)）；\\(\\mathbb Z\\)：整數。

0x61 圖論-最短路

B題 Telephone Lines https://ac.nowcoder.com/acm/contest/1055/B 中文題面：https://www.luogu.com.cn/problem/P1948

圖論-最短路

在圖論中,最短路有三種求法:dijkstra SPFA Floyd dijkstra: 　　dis[i]表示i到起點最短路權值