[THUWC2019]迷路（最小环）

最新推荐文章于 2025-04-04 08:30:00 发布

weixin_30433075

最新推荐文章于 2025-04-04 08:30:00 发布

阅读量87

点赞数

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/Rhein-E/p/10467952.html

探讨了在无向图中寻找从每个点出发的最小环长问题，通过分治策略优化Floyd算法，实现高效求解。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题面

迷路(lose)

题目描述

dolls意外得到了一张藏宝图，于是他踏上了寻找宝藏的道路。在走了许多许多步，回到同一个位置以后，dolls确定自己迷路了。dolls十分生气，他觉得自己这么英明圣武的人就算迷路，也要迷路在最小的环上。于是他想知道从每个点出发最小的环有多长。藏宝图可以抽象成一个n个点m条边的，边权全为正的无向图，现在你需要求得经过每个点的最小环长是多少。

输入格式

第一行两个数n，m，表示点数和边数。下面m行每行三个整数u,v,l表示点u和点v之间有一条长度为l的无向边。

输出格式

输出n个数，表示经过每个点的最小环长，若没有则输出-1。

数据范围

\(n \le 300, m \le 40000\)

解析

题目并没说不存在自环和重边，那么先把自环和重边统计进答案，去掉自环和重边后的答案一定是一个简单环

先考虑如何统计一个点的答案

设把除\(u\)以外的其他点都加入图后，\(i, j\)两点间的最短路为\(dis(i, j)\)枚举连向\(u\)的边\((u, v1)\)和\((u, v2)\)，答案就是\(min \{ dis(v1, v2) + len(u, v1) + len(u, v2) \}\)

然而每次暴力重新跑\(Floyd\)铁定超时

不难发现统计不同两点的答案时，两图中共有的点很多

于是我们考虑对所有的点分治

\(solve(l, r)\)表示\([l, r]\)的点没在图中的情况，当\(l = r\)时可以统计该点的答案，否则递归地处理两半

处理\([l, mid]\)时把\([mid + 1, r]\)加入图中，处理\([mid + 1, r]\)时把\([l, mid]\)加入图中

这样每个点被加入\(O(\log n)\)次，加入一个点复杂度为\(O(n^2)\)，总复杂度为\(O(n^3 \log n)\)

由于\(\log n\)不到\(10\)，所以可以过这题

注意：3个0x3f3f3f3f3f3f3f3f相加会爆long long

代码

#include <cstdio>
#include <iostream>
#include <cstring>
#define MAXN 305

typedef long long LL;
const LL INF = 0x0f0f0f0f0f0f0f0f;
LL dist[10][MAXN][MAXN], map[MAXN][MAXN], ans[MAXN];
int N, M;
char in_graph[MAXN];

void add(LL[MAXN][MAXN], int);
void solve(int, int, int);
int main() {
    freopen("lose.in", "r", stdin);
    freopen("lose.out", "w", stdout);
    
    std::ios::sync_with_stdio(false);
    std::cin >> N >> M;
    memset(map, 0x0f, sizeof map);
    memset(dist, 0x0f, sizeof dist);
    memset(ans, 0x0f, sizeof ans);
    for (int i = 1; i <= M; ++i) {
        int x, y; LL z;
        std::cin >> x >> y >> z;
        if (x == y) ans[x] = std::min(ans[x], z);
        ans[x] = std::min(ans[x], map[x][y] + z);
        ans[y] = std::min(ans[y], map[x][y] + z);
        map[x][y] = std::min(map[x][y], z);
        map[y][x] = std::min(map[y][x], z);
    }
    for (int i = 1; i <= N; ++i) dist[0][i][i] = 0;
    solve(1, N, 0);
    for (int i = 1; i <= N; ++i) {
        if (ans[i] ^ INF) std::cout << ans[i];
        else std::cout << -1;
        if (i ^ N) std::cout << " ";
    }
    std::cout << std::endl;
    
    return 0;
}
void add(LL d[MAXN][MAXN], int id) {
    in_graph[id] = 1;
    for (int i = 1; i <= N; ++i) {
        if (!in_graph[i]) continue;
        for (int j = 1; j <= N; ++j) {
            if (!in_graph[j]) continue;
            d[id][i] = std::min(d[id][i], map[id][j] + d[j][i]);
            d[i][id] = d[id][i];
        }
    }
    for (int i = 1; i <= N; ++i) {
        if (!in_graph[i]) continue;
        for (int j = 1; j <= N; ++j) {
            if (!in_graph[j]) continue;
            d[i][j] = std::min(d[i][j], d[i][id] + d[id][j]);
        }
    }
}
void solve(int l, int r, int dep) {
    if (l == r) {
        for (int i = 1; i <= N; ++i)
            for (int j = i + 1; j <= N; ++j)
                ans[l] = std::min(ans[l], dist[dep][i][j] + map[l][i] + map[l][j]);
        return;
    }
    int mid = (l + r) >> 1;
    for (int i = 1; i <= N; ++i)
        for (int j = 1; j <= N; ++j)
            dist[dep + 1][i][j] = dist[dep][i][j];
    for (int i = mid + 1; i <= r; ++i) add(dist[dep + 1], i);
    solve(l, mid, dep + 1);
    for (int i = l; i <= r; ++i) in_graph[i] = 0;
    for (int i = 1; i <= N; ++i)
        for (int j = 1; j <= N; ++j)
            dist[dep + 1][i][j] = dist[dep][i][j];
    for (int i = l; i <= mid; ++i) add(dist[dep + 1], i);
    solve(mid + 1, r, dep + 1);
    for (int i = l; i <= r; ++i) in_graph[i] = 0;
}
//Rhein_E

转载于:https://www.cnblogs.com/Rhein-E/p/10467952.html