首页 > > 程序设计 > C/C++ >

[BZOJ4379][POI2015]Modernizacja autostrady

2019-08-16 07:54:50来源：博客园阅读 ()

[BZOJ4379][POI2015]Modernizacja autostrady

题目描述

给定一棵无根树，边权都是$1$，请去掉一条边并加上一条新边，定义直径为最远的两个点的距离，请输出所有可能的新树的直径的最小值和最大值。

Input

第一行包含一个正整数$ n(2<=n<=500000) $，表示这棵树的点数。

接下来$n-1$行，每行包含两个正整数$u,v(1<=u,v<=n)$，表示$u$与$v$之间有一条边。

Output

第一行输出五个正整数$k,x_1,y_1,x_2,y_2$，其中k表示新树直径的最小值，$x_1,y_1$表示这种情况下要去掉的边的两端点，$x_2,y_2$表示这种情况下要加上的边的两端点。

第二行输出五个正整数$k,x_1,y_1,x_2,y_2$，其中k表示新树直径的最大值，$x_1,y_1$表示这种情况下要去掉的边的两端点，$x_2,y_2$表示这种情况下要加上的边的两端点。

若有多组最优解，输出任意一组。

Sample Input

Sample Output

3 4 2 2 5
5 2 1 1 6

树形$DP$题。

很显然我们需要对于每条边的断开分类讨论。

对于一条边，断开后分为两个连通块$A$,$B$。

记两个连通块的直径为$d_A,d_B$

对于最小值很显然就是连接两条直径中点或两条直径，即
$max(max(d_A,d_B),1+(d_A+1)/2+(d_b+1)/2)$。

而对于最大值，我们只用连接两条直径的端点即可。

现在，问题变成了怎么快速的求出上述的$d_A,d_B$。

这是一颗树

对于节点$A$来说，上述的$d_A$为在该节点子树内的最大的直径。

而$d_B$，为不在该点子树内的最大直径。

我们又将问题转换为了求每个节点的在该节点子树内的最大直径以及不在该节点子树内的最大直径。

我们该如何快速的求出每个节点的值呢？

我们需要维护每个节点的前三子链（不同的儿子），向上最长链以及前二最大子节点的子树直径。

很显然，一个节点的子树内直径为前两个子链之和，或最大的子节点的子树直径。这样要用子树更新节点。

而一个节点的不在该点子树内的直径为，其父亲的该值或其父亲的向上最长链加除他外父亲的最长子链，或其父亲除它外的前两子链和。
这里要用父亲节点更新子节点。

两次$dfs$树形$DP$即可。

#include <cstdio>
#include <cstring>
#include <map>
#include <set>
#include <iostream>
#include <algorithm>
 
using namespace std;
 
#define LL long long
#define u64 unsigned long long
#define reg register
#define debug(x) cerr<<#x<<" = "<<x<<endl;
#define rep(a,b,c) for(reg int a=(b),a##_end_=(c); a<=a##_end_; ++a)
#define ret(a,b,c) for(reg int a=(b),a##_end_=(c); a<a##_end_; ++a)
#define drep(a,b,c) for(reg int a=(b),a##_end_=(c); a>=a##_end_; --a)
#define erep(i,G,x) for(reg int i=(G).Head[x]; i; i=(G).Nxt[i])
 
inline int Read() {
    int res = 0, f = 1;
    char c;
    while (c = getchar(), c < 48 || c > 57)if (c == '-')f = 0;
    do res = (res << 3) + (res << 1) + (c ^ 48);
    while (c = getchar(), c >= 48 && c <= 57);
    return f ? res : -res;
}
 
template<class T>inline bool Min(T &a, T const&b) {
    return a > b ? a = b, 1 : 0;
}
template<class T>inline bool Max(T &a, T const&b) {
    return a < b ? a = b, 1 : 0;
}
 
const int N = 5e5 + 5, M = 5e5 + 5, mod = 1e9 + 9;
 
int n;
 
struct Link_list {
    int Tot, Nxt[M << 1], to[M << 1], Head[N];
    inline void AddEdgepair(int a, int b) {
        to[++Tot] = b, Nxt[Tot] = Head[a], Head[a] = Tot;
        to[++Tot] = a, Nxt[Tot] = Head[b], Head[b] = Tot;
    }
} G;
 
int Fa[N], dep[N], Tree_sonD[N], Tree_unsonD[N], List_son[N][4], List_unson[N], Mason_D[N][3];
 
void dfs1(int x, int pre) {
    Fa[x] = pre, dep[x] = dep[pre] + 1;
    erep(i, G, x) {
        int y = G.to[i];
        if (y == pre)continue;
        dfs1(y, x);
        reg int pos = 3;
        int cnt = List_son[y][0] + 1;
        for (pos = 3; pos && List_son[x][pos - 1] < cnt; pos--)List_son[x][pos] = List_son[x][pos - 1];
        List_son[x][pos] = cnt;
        cnt = Tree_sonD[y];
        for (pos = 2; pos && Mason_D[x][pos - 1] < cnt; pos--)Mason_D[x][pos] = Mason_D[x][pos - 1];
        Mason_D[x][pos] = cnt;
    }
    Tree_sonD[x] = max(Mason_D[x][0], List_son[x][0] + List_son[x][1]);
}
 
void dfs2(int x, int pre) {
    erep(i, G, x) {
        int y = G.to[i];
        if (y == pre)continue;
        int pos1, pos2;
        pos1 = (List_son[x][0] == List_son[y][0] + 1);
        List_unson[y] = max(List_son[x][pos1], List_unson[x]) + 1;
        pos1 = (Tree_sonD[y] == Mason_D[x][0]);
        Max(Tree_unsonD[y], max(Tree_unsonD[x], Mason_D[x][pos1]));
        if (List_son[y][0] + 1 == List_son[x][0])pos1 = 1, pos2 = 2;
        else if (List_son[y][0] + 1 == List_son[x][1])pos1 = 0, pos2 = 2;
        else pos1 = 0, pos2 = 1;
        Max(Tree_unsonD[y], max(List_son[x][pos1] + List_son[x][pos2], List_son[x][pos1] + List_unson[x]));
        dfs2(y, x);
    }
}
 
inline int Mid(int x, int y, int len) {
    if (dep[x] < dep[y])swap(x, y);
    len /= 2;
    rep(i, 1, len)x = Fa[x];
    return x;
}
 
int Dis[N], Ans;
 
void dfs3(int x, int pre, int F) {
    Dis[x] = Dis[pre] + 1;
    if (Dis[Ans] < Dis[x])Ans = x;
    erep(i, G, x) {
        int y = G.to[i];
        if (y == pre || y == F)continue;
        dfs3(y, x, F);
    }
}
 
inline int Farest(int x, int y) {
    memset(Dis, 0, sizeof Dis);
    Ans = x;
    dfs3(x, 0, y);
    return Ans;
}
 
int Mi[N], Ma[N];
 
inline void Debug(void) {
    rep(i, 1, n)printf("%d %d %d %d %d\n", Tree_sonD[i], Tree_unsonD[i], Fa[i], List_unson[i], dep[i]);
}
 
int _main(void) {
    int n = Read(), a, b;
    ret(i, 1, n) {
        a = Read(), b = Read();
        G.AddEdgepair(a, b);
    }
    dfs1(1, 0); dfs2(1, 0);
    int Ans1 = 1, Ans2 = 1;
    Mi[1] = Ma[1] = Tree_sonD[1];
    rep(i, 2, n) {
        int res1 = Tree_sonD[i] + Tree_unsonD[i] + 1;
        int res2 = max(max(Tree_sonD[i], Tree_unsonD[i]), 1 + (Tree_unsonD[i] + 1 ) / 2 + (Tree_sonD[i] + 1) / 2);
        Mi[i] = res2, Ma[i] = res1;
        if (Ma[Ans1] < Ma[i])Ans1 = i;
        if (Mi[Ans2] > Mi[i])Ans2 = i;
    }
    if (Ans2 == 1)printf("%d %d %d %d %d\n", Mi[1], a, b, a, b);
    else {
        printf("%d %d %d ", Mi[Ans2], Ans2, Fa[Ans2]);
        int x1 = Farest(Ans2, Fa[Ans2]), y1 = Farest(x1, Fa[Ans2]), x2 = Farest(Fa[Ans2], Ans2), y2 = Farest(x2, Ans2);
        printf("%d %d\n", Mid(x1, y1, Tree_sonD[Ans2]), Mid(x2, y2 , Tree_unsonD[Ans2]));
    }
    if (Ans1 == 1)printf("%d %d %d %d %d\n", Ma[1], a, b, a, b);
    else printf("%d %d %d %d %d\n", Ma[Ans1], Ans1 , Fa[Ans1], Farest(Ans1, Fa[Ans1]), Farest(Fa[Ans1], Ans1));
    return 0;
}
 
int main() {
#define offline1
#ifdef offline
    freopen(".in", "r", stdin);
    freopen(".out", "w", stdout);
    _main();
    fclose(stdin); fclose(stdout);
#else
    _main();
#endif
    return 0;
}

原文链接:https://www.cnblogs.com/dsjkafdsaf/p/11254532.html
如有疑问请与原作者联系

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有