P6464 [传智杯 #2 决赛] 传送门-CSDN博客

P6464 [传智杯 #2 决赛] 传送门

题目描述

传智专修学院里有 $n$ 栋教学楼，有 $m$ 条双向通行道路连接这些教学楼，不存在重边和自环。每条道路都有一定的长度，而且所有教学楼之间都可以直接或者间接的通过道路到达。我们可以很容易的求出这些教学楼之间的最短路。

为了使交通更为顺畅，校方决定在两个教学楼里增设一对传送门。传送门可以将这对教学楼的距离直接缩短为 0。利用传送门，某些教学楼之间的最短路的距离就变短了。

由于预算有限，学校里只能安装一对传送门。但是校长希望尽可能方便学生，使任意两点之间的最短路长度的总和最小。当然啦，从 $x$ 教学楼到 $y$ 教学楼的长度和从 $y$ 教学楼到 $x$ 教学楼的长度只需要统计一次就可以了。

输入格式

输入第 1 行两个正整数 $n,m(n≤100,m≤12n(n−1))n,m(n\le 100,m\le\frac{1}{2}n(n-1))$ ，代表教学楼和道路数量。

接下来 $m$ 行，每行三个正整数 $xi,yi,wi(0<wi≤104)x_i,y_i,w_i(0 <w_i \le 10^4)$ ，表示在教学楼 $x_i$ 和 $y_i$ 之间，有一条长度为 $w_i$ 的道路。

输出格式

输出一行，在最优方案下的任意点对的最短道路之和。

输入输出样例 #1

输入 #1

输出 #1

说明/提示

样例如图。当在 1 和 4 号教学楼架设一对传送门时，1 → 2 的最短路是 3，1 → 3 的最短路是 0+2，1 → 4 的最短路是 0，2 → 3 的最短路是 4，2 → 4 的最短路是 3+0，3 → 4 的最短路是 2，最短路之和是 14，是最佳方案。

思路：

很明显这题是全源最短路，不能用SPFA和Dijkstra，数据范围很明显可以用Floyd，然后枚举传送门的位置

80分:

#include <iostream>
#include <climits>
#include <limits>
#include <vector>
#include <algorithm>
#include <numeric>

typedef unsigned long long ull;
typedef long long ll;
typedef long double ld;
typedef std::pair<int, int> PII;

#define rep(i, n) for(int i = 0; i < n; i++)
#define Rep(i, len, n) for(int i = len; i < n; i++)
#define MAX_INT 0x7fffffff
#define MIN_INT 0x80000000

const int INF = std::numeric_limits<int>::max();

int n, m;
std::vector<std::vector<int>> f;
std::vector<int> dist;

inline void Floyd() {
    for(int k = 1; k <= n; k++) {
        for(int i = 1; i <= n; i++) {
            for(int j = 1; j <= n; j++) {
                if(f[i][k] < INF && f[k][j] < INF) {
                    f[i][j] = std::min(f[i][j], f[i][k] + f[k][j]);
                }
            }
        }
    }
}

inline int Sum() {
    int sum = 0;
    Rep(i, 1, n) Rep(j, i + 1, n + 1) sum += f[i][j];
    return sum;
}

int main(void) {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);

    std::cin >> n >> m;
    std::vector<std::vector<int>> arr(n + 1, std::vector<int>(n + 1, INF));
    Rep(i, 1, n + 1) arr[i][i] = 0;
    rep(i, m) {
        int a, b, c;
        std::cin >> a >> b >> c;
        arr[a][b] = arr[b][a] = c;
    }

    f = arr;
    Floyd();
    int ans = Sum();

    Rep(i, 1, n) {
        Rep(j, i + 1, n + 1) {
            f = arr;
            f[i][j] = f[j][i] = 0;
            Floyd();
            ans = std::min(ans, Sum());
        }
    }
    std::cout << ans << '\n';

    return 0;
}

因为会TLE几个点，这么写时间复杂度是O( $n^5$ + $n^4$ + $n^3$ ) 也就是 O( $n^5$ ) 的时间复杂度，所以就想优化一下，发现每次都会跑一遍Floyd就导致时间复杂度太高，因为Floyd跑出来数据是跟中转点k有关的，所以我们每一次枚举传送门就只与两个点也就一条边有关，我就只需要改变这两个点作为中转点的边就行，这样我们的时间复杂度就从O( $n^5$ ) 降到了O( $n^4$ )。

100分：

#include <iostream>
#include <climits>
#include <limits>
#include <vector>
#include <algorithm>
#include <numeric>

typedef unsigned long long ull;
typedef long long ll;
typedef long double ld;
typedef std::pair<int, int> PII;

#define rep(i, n) for(int i = 0; i < n; i++)
#define Rep(i, len, n) for(int i = len; i < n; i++)
#define MAX_INT 0x7fffffff
#define MIN_INT 0x80000000

const int INF = std::numeric_limits<int>::max();

int n, m;
std::vector<std::vector<int>> f;

inline void Floyd() {
    for(int k = 1; k <= n; k++) {
        for(int i = 1; i <= n; i++) {
            for(int j = 1; j <= n; j++) {
                if(f[i][k] < INF && f[k][j] < INF) {
                    f[i][j] = std::min(f[i][j], f[i][k] + f[k][j]);
                }
            }
        }
    }
}

inline void Floyd(int x, int y) { // 重载Floyd
	// x作为中转点
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= n; j++) {
            if(f[i][x] < INF && f[x][j] < INF) {
                f[i][j] = std::min(f[i][j], f[i][x] + f[x][j]);
            }
        }
    }
    
	// y作为中转点
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= n; j++) {
            if(f[i][y] < INF && f[y][j] < INF) {
                f[i][j] = std::min(f[i][j], f[i][y] + f[y][j]);
            }
        }
    }
}

inline int Sum() {
    int sum = 0;
    Rep(i, 1, n) Rep(j, i + 1, n + 1) sum += f[i][j];
    return sum;
}

int main(void) {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr), std::cout.tie(nullptr);

    std::cin >> n >> m;
	f.resize(n + 1, std::vector<int>(n + 1, INF));
    Rep(i, 1, n + 1) f[i][i] = 0;
    rep(i, m) {
        int a, b, c;
        std::cin >> a >> b >> c;
        f[a][b] = f[b][a] = c;
    }

    Floyd(); // 先跑一遍Floyd, 得到没加传送门的f数组(x->y的最短距离)
    int ans = Sum();

    Rep(i, 1, n) {
        Rep(j, i + 1, n + 1) {
            std::vector<std::vector<int>> backup = f; // 备份一份f
            f[i][j] = f[j][i] = 0;
            Floyd(i, j);
            ans = std::min(ans, Sum());
            f = backup;
        }
    }
    std::cout << ans << '\n';

    return 0;
}