【CF25C】Roads in Berland Floyd深入理解
Roads in Berland
題目連結
題目概述
There are n cities numbered from 1 to n in Berland. Some of them are connected by two-way roads. Each road has its own length — an integer number from 1 to 1000. It is known that from each city it is possible to get to any other city by existing roads. Also for each pair of cities it is known the shortest distance between them. Berland Government plans to build k new roads. For each of the planned road it is known its length, and what cities it will connect. To control the correctness of the construction of new roads, after the opening of another road Berland government wants to check the sum of the shortest distances between all pairs of cities. Help them — for a given matrix of shortest distances on the old roads and plans of all new roads, find out how the sum of the shortest distances between all pairs of cities changes after construction of each road.
Input
The first line contains integer n (2 ≤ n ≤ 300) — amount of cities in Berland. Then there follow n lines with n integer numbers each — the matrix of shortest distances. j-th integer in the i-th row — di, j, the shortest distance between cities i and j. It is guaranteed that di, i = 0, di, j = dj, i, and a given matrix is a matrix of shortest distances for some set of two-way roads with integer lengths from 1 to 1000, such that from each city it is possible to get to any other city using these roads.
Next line contains integer k (1 ≤ k ≤ 300) — amount of planned roads. Following k lines contain the description of the planned roads. Each road is described by three space-separated integers ai, bi, ci (1 ≤ ai, bi ≤ n, ai ≠ bi, 1 ≤ ci ≤ 1000) — ai and bi — pair of cities, which the road connects, ci — the length of the road. It can be several roads between a pair of cities, but no road connects the city with itself.
Output
Output k space-separated integers qi (1 ≤ i ≤ k). qi should be equal to the sum of shortest distances between all pairs of cities after the construction of roads with indexes from 1 to i. Roads are numbered from 1 in the input order. Each pair of cities should be taken into account in the sum exactly once, i. e. we count unordered pairs.
就是說n個城市,給你用臨接矩陣存的邊,使得每兩個城市間都有最短路。現有k次更新操作。問每次更新操作之後兩個城市間距離最小值之和。(不重複)
測試樣例
/*
input:
3
0 4 5
4 0 9
5 9 0
2
2 3 8
1 2 1
output:
17 12
*/
分析
用臨接矩陣存的圖,很容易想到用關鍵程式碼只有5行的floyd演算法。不過如果更新的操作比較多,每次都跑一遍最短路的話的話很容易超時,我們思考一下如何進行優化。floyd演算法時根據是否有一箇中轉點k,使得u->k->v的距離小於u->v的距離,從而進行更新。根據題目意思,我們一條一條的加邊,所以如果新邊比原來的最短距離大的話我們根本不需要更新,如果要小的話我們只需要針對新邊進行更新,這樣可以極大縮減時間複雜度,只需要在開頭跑一次完整的floyd演算法就OK了。
程式碼
```cpp
#include <cstdio>
#include <cctype>
#include <cstring>
using namespace std;
const int N = 305;
int n, k;
int dis[N][N];
long long ans = 0;
inline int read(){
int x = 0, op = 1;
char ch = getchar();
while (!isdigit(ch)){
if (ch == '-') op = -1;
ch = getchar();
}
while (isdigit(ch)){
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return x * op;
}
void solve(){
int x = read(), y = read(), z = read();
if (dis[x][y] <= z)
printf("%lld ",ans);
else{
ans = 0;
dis[x][y] = dis[y][x] = z;
for (int i = 1; i <= n; ++i)
for (int j = i + 1; j <= n; ++j) {
if (dis[i][j] > dis[i][x] + dis[x][y] + dis[y][j])
dis[i][j] = dis[j][i] = dis[i][x] + dis[x][y] + dis[y][j];
if (dis[i][j] > dis[i][y] + dis[y][x] + dis[x][j])
dis[i][j] = dis[j][i] = dis[i][y] + dis[y][x] + dis[x][j];
ans += dis[i][j];
}
printf("%lld ",ans);
}
}
int main() {
n = read();
memset(dis, 0x3f, sizeof(dis));
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
dis[i][j] = read();
for (int k = 1; k <= n; ++k)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (dis[i][j] > dis[i][k] + dis[k][j])
dis[i][j] = dis[i][k] + dis[k][j];
for (int i = 1; i <= n; ++i)
for (int j = i + 1; j <= n; ++j)
ans += dis[i][j];
k = read();
while (k--)
solve();
return 0;
}
錯誤示範
//更新不完全
ans = 0;
dis[x][y] = dis[y][x] = z;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
if (dis[i][j] > dis[i][x] + dis[x][y] + dis[y][j])
dis[i][j] = dis[j][i] = dis[i][x] + dis[x][y] + dis[y][j];
//if (dis[i][j] > dis[i][y] + dis[y][x] + dis[x][j])
// dis[i][j] = dis[j][i] = dis[i][y] + dis[y][x] + dis[x][j];
ans += dis[i][j];
}
ans /= 2;
相關文章
- CF808G Anthem of Berland
- 最短路-Floyd
- 深入理解Isolate
- 深入理解HashMapHashMap
- 深入理解TransformORM
- 深入理解KVO
- 深入理解 JVMJVM
- 深入理解 GitGit
- 深入理解AQSAQS
- 深入理解JVMJVM
- 深入理解 TypeScriptTypeScript
- 深入理解JavaScriptCoreJavaScript
- 深入理解MVCMVC
- 深入理解 PWA
- 深入理解margin
- 深入理解ReactReact
- 深入理解BFC
- 深入理解reduxRedux
- BFC深入理解
- 深入理解 GCDGC
- 深入理解 requestAnimationFramerequestAnimationFrame
- 深入理解Eureka
- 深入理解copy
- AsyncTask深入理解
- 深入理解RunLoopOOP
- 深入理解Fsync
- 深入理解yield
- Penn Schoen Berland:社交網路即媒體
- 深入理解MySQL索引MySql索引
- 深入理解ThreadLocalthread
- 深入理解JVM——物件JVM物件
- 對redis深入理解Redis
- 深入理解 ceph mgr
- 深入理解JavaScript原型JavaScript原型
- 深入理解 Event LoopOOP
- 深入理解Java PriorityQueueJava
- 深入理解vue元件Vue元件
- 深入理解 Java 方法Java