[PKUWC2019]迷路（最小环）

Posted 2021-02-11 rhein-e

题面

迷路(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