luogu 1099 树网的核

PS.图片来自luogu

分析

我发现CCF的题目都好长

part 1

一句话题意：

在树的直径上求一段连续的路径使得树上的点与这条路径的距离的最大值最小；

part 2

好的，最大值最小

少不得要考虑二分了

这个东西与任意两点间的最短路有关，看数据范围

Floyd没跑了

part 3

求树的直径有一个结论：

从树上任意一点找到最长路，再从最长路的另一端再跑一个最长路，这个最长路就是直径

反证法就好啊

这个要排在Floyd前面

part 4

题目所求为直径上的一段连续区间，也就是说直径的两端都是被删了的

这就好办了

暴力删边

暴力的想法是：

二分答案

枚举删边（左右各一次），把直径左右的删掉，剩下的片段就是与树上各点的距离不超过mid的

再判断这一段是否超过s

枚举删边的时候：

太暴力了，我都看不下去了

其实可以预处理出树上各点到直径的最短距离以及相应的直径上的点的编号

然后删边的时候加上与这个要删的点之间的距离就好（可以证明这就是最短的距离）

part 5

整理：

首先求出直径顺便按路径顺序存下直径上的点

Floyd求出树上任意两点间的距离

我们二分答案，注意左右边界

右边界表示不会大于直径的一半，但一半不一定在直径上（直接加一个最大边权就好）

左边界表示需要预处理

我们在处理出直径及其路径后，可以顺便求出树上各点到直径的最短距离以及相应的直径上的点的编号

其中，最大的那个距离就是左边界，需要左右边界与我的方法有关

代码

/**********************
User:Mandy.H.Y
Langauge:c++
Problem:luogu 1099
Algorithm:
date:2019.9.3
**********************/

#include<bits/stdc++.h>

using namespace std;

const int maxn = 305;

int n,s,start,mdis,end,cnt,mw;
int dia[maxn];
bool vis[maxn];
int g[maxn][maxn],dis[maxn],path[maxn],tmp[maxn];

template<class T>inline void read(T &x){
    x = 0;char ch = getchar();bool flag = 0;
    while(!isdigit(ch)) flag |= ch == '-',ch = getchar();
    while(isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48),ch = getchar();
    if(flag) x = -x;
}

template<class T>void putch(const T x){
    if(x > 9) putch(x / 10);
    putchar(x % 10 | 48);
}

template<class T>void put(const T x){
    if(x < 0) putchar('-'),putch(-x);
    else putch(x);
}

void file(){
    freopen("testdata.in","r",stdin);
//    freopen("1099.out","w",stdout);
}

void readdata(){
    read(n);read(s);
    memset(g,0x3f3f3f3f,sizeof(g));
    for(int i = 1;i < n; ++ i){
        int u,v,w;
        read(u);read(v);read(w);
        g[u][v] = g[v][u] = w;
        mw = max(mw,w);
    }
    for(int i = 1;i <= n; ++ i) g[i][i] = 0;
}

void Floyd(){
    for(int k = 1;k <= n; ++ k)
    for(int i = 1;i <= n; ++ i)
    for(int j = 1;j <= n; ++ j)
        if(g[i][k] + g[j][k] < g[i][j])
            g[i][j] = g[j][i] = g[i][k] + g[j][k];
            
}

void dfs1(int u){
    vis[u] = 1;
    for(int i = 1;i <= n; ++ i){
        if(vis[i] || g[u][i] == 0x3f3f3f3f) continue;
        dis[i] = dis[u] + g[u][i];
        if(dis[i] > mdis) {
            start = i;
            mdis = dis[i];
        }
        dfs1(i);
    }
}

void dfs2(int u){
    vis[u] = 1;
    for(int i = 1;i <= n; ++ i){
        if(vis[i] || g[u][i] == 0x3f3f3f3f) continue;
        dis[i] = dis[u] + g[u][i];
        path[i] = u;
        if(dis[i] > mdis) {
            end = i;
            mdis = dis[i];
        }
        dfs2(i);
    }
}

bool check(int x){
//--------删开头    
    start = 1;end = cnt;
    int sum = mdis;//所取片段的长度 
    int i = 1;
    bool judge = 0;
    while(i < cnt){
        for(int j = 1;j <= n; ++ j){
            if(tmp[j] <= i)
                if(dis[j] + g[dia[tmp[j]]][dia[i + 1]] > x){
                    judge = 1;//%%%%%%%%%%%%%%%
                    break;
                } 
        }
        if(judge) break;
        sum -= g[dia[i]][dia[i + 1]];
        start = i + 1;
        ++i;
    }
//---------删结尾    
    i = end;
    judge = 0;
    while(i > start){//  > start 
        for(int j = 1;j <= n; ++ j){
            if(tmp[j] >= i)
                if(dis[j] + g[dia[tmp[j]]][dia[i - 1]] > x){
                    judge = 1;
                    break;
                } 
        }
        if(judge) break;
        sum -= g[dia[i]][dia[i - 1]];
        end = i - 1;
        --i;
    }
    //注意start与end都是在直径中的标号，不是真正编号 
    if(g[dia[start]][dia[end]] > s) return 0;
    else return 1;
}

void work(){
//--------------求直径 
    dfs1(1);
    
    memset(vis,0,sizeof(vis));
    memset(dis,0,sizeof(dis));
    path[start] = 0;
    mdis = 0;end = 0;
    
    dfs2(start);
    
    memset(vis,0,sizeof(vis));
    memset(dis,0,sizeof(dis));
    for(int i = end;i;i = path[i]) dia[++cnt] = i,vis[i] = 1;
    //求直径路径
//------------- 求最短路 
    Floyd();
//-------------预处理    
    start = end = 0;
    
    for(int i = 1;i <= n; ++ i){
        int cur = 2e9;
        for(int j = 1;j <= cnt; ++ j){
            if(cur > g[i][dia[j]]){
                cur = g[i][dia[j]];
                dis[i] = g[i][dia[j]];//这是i到直径的最短距离 
                tmp[i] = j;//这是相应编号 
            }
        }
    }
//------------左右边界
    int l = 0,r = (mdis >> 1) + 1 + mw;
    for(int i = 1;i <= n; ++ i) {
        l = max(l,dis[i]);
    }
//------------二分答案 
    int ans;
    while(l <= r){
        int mid = (l + r) >> 1;
        if(check(mid)) ans = mid,r = mid - 1;
        else l = mid + 1;
    }
    put(ans);
}

int main(){
//    file();
    readdata();
    work();
    return 0;
}