HDU 5886 Tower Defence(树形dp|树的直径)

最新推荐文章于 2019-08-13 21:54:35 发布
最新推荐文章于 2019-08-13 21:54:35 发布
阅读量637 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Miracle_ma/article/details/52605564
版权

问你一棵树里，删除一条边之后，剩下的两个树里面最长的是多少
然后n−1种情况的都加起来
有两种方法，第一种就是正常的树形dp，dfs两次，分类讨论维护一些东西
对于删除u−>v这条边，有如下情况
1.最长的经过u
2.最长的不经过u
经过u，那么就是要么是u的两条不经过v的最长的往下的，要么就是一条最长的，外加一条从上面到达u的最长的
不经过u，就是u的儿子里最大的直径，或者是u的祖先里面最大的，以及u的兄弟里最大的
维护几条太烦了，multiset水过

代码：

#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <string>
#include <vector>
#include <cstdio>
#include <cctype>
#include <bitset>
#include <cstring>
#include <sstream>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#pragma comment(linker,"/STACK:102400000,102400000")

using namespace std;
#define   MAX           100005
#define   MAXN          1000005
#define   maxnode       15
#define   sigma_size    30
#define   lson          l,m,rt<<1
#define   rson          m+1,r,rt<<1|1
#define   lrt           rt<<1
#define   rrt           rt<<1|1
#define   middle        int m=(r+l)>>1
#define   LL            long long
#define   ull           unsigned long long
#define   mem(x,v)      memset(x,v,sizeof(x))
#define   lowbit(x)     (x&-x)
#define   pii           pair<int,int>
#define   bits(a)       __builtin_popcount(a)
#define   mk            make_pair
#define   limit         10000

//const int    prime = 999983;
const int    INF   = 0x3f3f3f3f;
const LL     INFF  = 0x3f3f;
const double pi    = acos(-1.0);
const double inf   = 1e18;
const double eps   = 1e-4;
const LL    mod    = 1e9+7;
const ull    mx    = 133333331;

/*****************************************************/
inline void RI(int &x) {
      char c;
      while((c=getchar())<'0' || c>'9');
      x=c-'0';
      while((c=getchar())>='0' && c<='9') x=(x<<3)+(x<<1)+c-'0';
 }
/*****************************************************/

struct Edge{
    int v,next,c;
}edge[MAX*2];
int head[MAX];
int dp[MAX][2];
int ans[MAX];
int tot;
LL ret;
void init(){
    mem(head,-1);
    tot=0;
}

void add_edge(int a,int b,int c){
    edge[tot]=(Edge){b,head[a],c};
    head[a]=tot++;
}

void dfs1(int u,int fa){
    ans[u]=0;
    dp[u][0]=dp[u][1]=0;
    for(int i=head[u];i!=-1;i=edge[i].next){
        int v=edge[i].v;
        if(v==fa) continue;
        dfs1(v,u);
        ans[u]=max(ans[u],ans[v]);
        int temp=dp[v][0]+edge[i].c;
        if(temp>dp[u][0]){
            swap(dp[u][0],dp[u][1]);
            dp[u][0]=temp;
        }
        else if(temp>dp[u][1]) dp[u][1]=temp;
    }
    ans[u]=max(ans[u],dp[u][0]+dp[u][1]);
    //cout<<ans[u]<<" "<<u<<endl;
}

void dfs2(int u,int fa,int d,int c){
    int tmp=0;
    multiset<int> s,ss;
    for(int i=head[u];i!=-1;i=edge[i].next){
        int v=edge[i].v;
        if(v==fa) continue;
        s.insert(dp[v][0]+edge[i].c);
        tmp=max(tmp,ans[v]);
        ss.insert(ans[v]);
    }
    tmp=max(d,tmp);
    tmp=max(c,tmp);
    //cout<<tmp<<" "<<u<<endl;
    for(int i=head[u];i!=-1;i=edge[i].next){
        int kk=tmp;
        int v=edge[i].v;
        if(v==fa) continue;
        multiset<int>::iterator it=s.find(dp[v][0]+edge[i].c);
        multiset<int>::iterator iit=ss.find(ans[v]);
        s.erase(it);
        ss.erase(iit);
        it=s.end();
        iit=ss.end();
        if(s.empty()){
            ret+=kk;
            //cout<<ret<<endl;
            dfs2(v,u,d,c+edge[i].c);
        }
        else{
            iit--;
            it--;
            int temp=0;
            int x=*it;
            temp+=*it;
            kk=max(kk,temp+c);
            if(it==s.begin()){
                ret+=kk;
                //cout<<v<<endl;
                dfs2(v,u,max(max(d,temp+c),*iit),max(c+edge[i].c,*it+edge[i].c));
            }
            else{
                int xx=*it;
                int xxx=temp+c;
                it--;
                temp+=*it;
                kk=max(kk,temp);
                ret+=kk;
                dfs2(v,u,max(max(d,temp),max(*iit,xxx)),max(c+edge[i].c,xx+edge[i].c));
            }
        }
        s.insert(dp[v][0]+edge[i].c);
        ss.insert(ans[v]);
    }
}

int main(){
    //freopen("in.txt","r",stdin);
    int t;
    cin>>t;
    while(t--){
        int n;
        cin>>n;
        init();
        for(int i=1;i<n;i++){
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            add_edge(a,b,c);
            add_edge(b,a,c);
        }
        dfs1(1,-1);
        ret=0;
        dfs2(1,-1,0,0);
        cout<<ret<<endl;
    }
    return 0;
}

方法2是题解的方法，感觉很不错诶
先找一个直径a−b，如果删除的不是直径上的边，那么很显然
如果删除的是直径上的边u−v，那么就是u为根的子树里的直径和v为根的子树里的最大的
如何处理这两个子树里的直径呢，只要从a开始dfs一遍，b开始dfs一遍预处理即可

代码：

#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <string>
#include <vector>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <sstream>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#pragma comment(linker,"/STACK:102400000,102400000")

using namespace std;
#define   MAX           100005
#define   MAXN          1000005
#define   maxnode       15
#define   sigma_size    30
#define   lson          l,m,rt<<1
#define   rson          m+1,r,rt<<1|1
#define   lrt           rt<<1
#define   rrt           rt<<1|1
#define   middle        int m=(r+l)>>1
#define   LL            long long
#define   ull           unsigned long long
#define   mem(x,v)      memset(x,v,sizeof(x))
#define   lowbit(x)     (x&-x)
#define   pii           pair<int,int>
#define   bits(a)       __builtin_popcount(a)
#define   mk            make_pair
#define   limit         10000

//const int    prime = 999983;
const int    INF   = 0x3f3f3f3f;
const LL     INFF  = 0x3f3f;
const double pi    = acos(-1.0);
const double inf   = 1e18;
const double eps   = 1e-4;
const LL    mod    = 1e9+7;
const ull    mx    = 133333331;

/*****************************************************/
inline void RI(int &x) {
      char c;
      while((c=getchar())<'0' || c>'9');
      x=c-'0';
      while((c=getchar())>='0' && c<='9') x=(x<<3)+(x<<1)+c-'0';
 }
/*****************************************************/

struct Edge{
    int v,next,c;
}edge[MAX*2];
int head[MAX];
int dp[MAX][2];
int nxt[MAX][2];
int pre[MAX];
int max1[MAX];
int max2[MAX];
int tot;
struct Node{
    int u,v;
}tmp[MAX];

void init(){
    mem(head,-1);
    tot=0;
}

void add_edge(int a,int b,int c){
    edge[tot]=(Edge){b,head[a],c};
    head[a]=tot++;
}

void dfs(int u,int fa){
    pre[u]=fa;
    dp[u][0]=dp[u][1]=0;
    nxt[u][0]=nxt[u][1]=u;
    for(int i=head[u];i!=-1;i=edge[i].next){
        int v=edge[i].v;
        if(v==fa) continue;
        dfs(v,u);
        if(dp[u][0]<dp[v][0]+edge[i].c){
            swap(dp[u][0],dp[u][1]);
            swap(nxt[u][0],nxt[u][1]);
            dp[u][0]=dp[v][0]+edge[i].c;
            nxt[u][0]=nxt[v][0];
        }   
        else if(dp[u][1]<dp[v][0]+edge[i].c){
            dp[u][1]=dp[v][0]+edge[i].c;
            nxt[u][1]=nxt[v][0];
        }
    }
}

void dfs1(int u,int fa){
    max1[u]=0;
    dp[u][0]=dp[u][1]=0;
    for(int i=head[u];i!=-1;i=edge[i].next){
        int v=edge[i].v;
        if(v==fa) continue;
        dfs1(v,u);
        max1[u]=max(max1[u],max1[v]);
        if(dp[u][0]<dp[v][0]+edge[i].c){
            swap(dp[u][0],dp[u][1]);
            dp[u][0]=dp[v][0]+edge[i].c;
        }   
        else if(dp[u][1]<dp[v][0]+edge[i].c) dp[u][1]=dp[v][0]+edge[i].c;
    }
    max1[u]=max(max1[u],dp[u][0]+dp[u][1]);
}

void dfs2(int u,int fa){
    max2[u]=0;
    dp[u][0]=dp[u][1]=0;
    for(int i=head[u];i!=-1;i=edge[i].next){
        int v=edge[i].v;
        if(v==fa) continue;
        dfs2(v,u);
        max2[u]=max(max2[u],max2[v]);
        if(dp[u][0]<dp[v][0]+edge[i].c){
            swap(dp[u][0],dp[u][1]);
            dp[u][0]=dp[v][0]+edge[i].c;
        }   
        else if(dp[u][1]<dp[v][0]+edge[i].c) dp[u][1]=dp[v][0]+edge[i].c;
    }
    max2[u]=max(max2[u],dp[u][0]+dp[u][1]);
}

int main(){
    //freopen("in.txt","r",stdin);
    int t;
    cin>>t;
    while(t--){
        int n;
        cin>>n;
        init();
        for(int i=1;i<n;i++){
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            add_edge(a,b,c);
            add_edge(b,a,c);
        }
        dfs(1,-1);
        int ret=0,u,v,w;
        for(int i=1;i<=n;i++){
            if(ret<dp[i][0]+dp[i][1]){
                ret=dp[i][0]+dp[i][1];
                u=nxt[i][0];
                v=nxt[i][1];
                w=i;
            }
        }
        //cout<<u<<" "<<v<<endl;
        //cout<<ret<<endl;
        dfs1(u,-1);
        dfs2(v,-1);
        int cnt=0;
        while(u!=w){
            tmp[cnt++]=(Node){u,pre[u]};
            u=pre[u];
        }
        while(v!=w){
            tmp[cnt++]=(Node){pre[v],v};
            v=pre[v];
        }
        LL ans=(LL)(n-1-cnt)*ret;
        for(int i=0;i<cnt;i++){
            ans+=max(max1[tmp[i].v],max2[tmp[i].u]);
            //cout<<max1[tmp[i].v]<<" "<<max2[tmp[i].u]<<endl;
        }
        cout<<ans<<endl;
    }
    return 0;
}
Miracle_ma
关注
Computer HDU - 2196 （树形dp || 树的直径）
deerly_的博客
07-27 583
Computer HDU - 2196 （树形dp || 树的直径） 题目链接 题目大意： 给定一棵树，知道相邻结点的距离，问对于每一个结点，和距离它最远的结点之间的距离是多少。 Input： 5 n个结点 1 1 表示2和1之间的距离是1 2 1 表示3和2之间的距离是1 3 1 表示4和3之间的距离是1 1 1 表示5和1之间的距离是1 ...
Hdu2196-Computer （树形dp）（经典题）
Stupid_Turtle的博客
12-20 538
传送门：Computer 题意：有 n 个点，通过 n-1 条边连成一棵树，每条边有一个权值，求从每个点出发的简单路径的最大长度。 思路：树形dp 首先以 1 为根建树，这样每个点能走的最大路径有两种情况：往下沿着子节点走或往上沿着父结点走。假设根节点为 rt，我们定义： dp[rt][0] 表示以 rt 为根的子树上的节点到 rt 的最长距离。 dp[rt][1] 表示以 rt 为根的...
HDU 5886 Tower Defence (最长链预处理)
每一次AC都是一种感动
09-18 987
题意：给出一棵树，边上有权值，现在毁掉任意一条边，分成两部分，求这两部分中最远的两点距离期望，答案*（n-1）分析： 说白了就是求最远距离加成和 对于一棵树来说，两点最远的距离，考虑两点： 1.最长链没有被拆开，那么答案就是最长链； 2.最长链被拆开了，那么答案一定在最长链的端点到某个叶子结点上； 证明略。有了这个结论，这个题就好做了，首先预处理出最长链，数组存下来，然后对于每个最长链上的
【HDU - 5886】Tower Defence（树的直径，思维，dp）
xuanweiace的博客
07-26 307
题干： There was a civil war between two factions in Skyrim, a province of the Empire on the continent of Tamriel. The Stormcloaks, led by Ulfric Stormcloak, are made up of Skyrim's native Nord race. Th...
HDU-5886-Tower Defence
逐梦者
07-02 359
ACM模版描述题解NN 个点的一棵边权树，切掉某条边的价值等于切后分成的两棵树的直径较大值。求切除任意一条边的价值总和。这个题是树归问题，通过两遍 dfsdfs 就能解决，和 51Nod51Nod 上的有一个求树的直径的问题很像，具体哪道我就记不清楚了，反正都是两遍 dfsdfs 解决的。这里第一遍 dfsdfs 求出每个 down[i][0]、down[i][1]、dis1[i]down[i][0
hdu 5886
kwahia的博客
08-27 196
求删除树上每一条边之后形成的两个子树中树的直径大者的和 #include &lt;bits/stdc++.h&gt; using namespace std; typedef long long ll; const int maxn = 1e5+10; struct edge { int from,to,dist; edge(int a=0,int b=0,in...
HDU 5886
常胜将军的博客
05-17 484
题目：N个点的一棵带权树。切掉某条边的价值为切后两树直径中的最大值。求各个边切掉后的价值和（共N-1项）。 思路：预处理出最长链，若断边不在最长链上，那么答案依旧是最长链，否则分别计算断开后的最长链，取最大值。 参考：https://www.cnblogs.com/zufezzt/p/5892342.html，https://blog.csdn.net/hao_zong_yin/article...
HDU 2196 Computer（树形dp）
Ellery的book
08-13 153
A school bought the first computer some time ago(so this computer’s id is 1). During the recent years the school bought N-1 new computers. Each new computer was connected to one of settled earlier. Ma...
HDU 5293 树链剖分 + 树形DP
新熊君的博客
02-03 364
题目链接题意： 给定有nn个节点的树和mm条链(链连接两个顶点，且有权值)，要求选出一部分链，使连接以后图的每个圈没有公共节点，问能够选出的链的权值和最大为多少？考虑树形DP。对于当前顶点uu，假设dp[u]dp[u]为以uu为根节点的子树所能够达到的最大目标值。 另外定义： 1.ww为当前考虑的链权值。 2.sum[u]=∑dp[k]sum[u] = \sum dp[k](kk为uu的子节
HDU--2196---Computer（树形DP）
wjhshuai的博客
01-18 287
这道题还是比较不容易理解的主要是多用了一个dfs，多饶了一个弯这道题符合树形DP的特征，可以把问题转化为一棵树对于每一个点，计算出以此点为根的子树中的第一长的枝和第二长枝，都存起来这是一个相当重要的预处理当图转为树的时候，对于每一个点其最远点有两种情况（两种情况取最优）1.返回父节点，来寻找最远点2.直接继续向下找，找到最远点对于第二种情况，由于向下找，长度必定为其最长枝的长度，预处理中已经找到，
[HDU 5886] Tower Defence （树形DP）
MisDeer's blog
09-18 805
HDU - 5886 给定一棵树，每条边都有一个权值 定义一条边的战术价值为割去这条边后 剩下的图中最长链的长度 求随机割掉一条边，战术价值的期望 题目要求乘以 N−1N-1，所以直接把概率消掉了 所以只要求割去每条边后的最长链长度即可 这就转化为了一个树形dp 首先割去一条边 u−>vu->v 后，最长链可能在 vv 为根的子树中 这个简单地做一次树形dp就能得出
【HDU 5886】Tower Defence（树的直径+树形DP）
ACMer'
09-19 1117
【HDU 5886】Tower Defence（树的直径+树形DP）题目大意： 带边权的树，随机删掉一条边，保留剩下两棵树中较大的中线。 求删除一条边后中线大小的期望*(n-1)说白了就是统计删除每条边的情况下两棵树较大的中线，求个和。对于原树，两次dfs可以找出来中线，同时可以标记中线上的点。 那么对于任何一条边u−vu-v，如果两个点有一个不在中线上，删除后对结果没有影响，较大的中线仍为原
hdu 5886 Tower Defence(树形dp)
fouzhe的博客
09-18 851
题目链接 Tower Defence Time Limit: 3000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 135    Accepted Submission(s): 40 Problem Description There
hdu 5886 Tower Defence 树形期望dp 雪漫防守战
便纵有千种风情
09-17 984
题意：风暴斗篷现在要攻打雪漫城。雪漫城有n(n≤100000)个哨塔防守，哨塔之间有n-1条路相连，(构成一棵树)。现在预测到风暴斗篷要进攻某一条路，然后这棵树就一分为二，现在要得到分开后的最长路。 图留斯将军假定进攻所有路的概率相等，问最长路的期望*(n-1)。 分析：这就是一个树形dp，和期望没什么关系。求的就是n-1种划分后的最长路之和。对于一个结点x，无非要求两个东西，以它作为根的子树中的
HDU5886 Tower Defence 【两遍树形dp】【最长链预处理】
weixin_30245867的博客
10-19 124
题意：N个点的一棵带权树。切掉某条边的价值为切后两树直径中的最大值。求各个边切掉后的价值和（共N-1项）。 解法一： 强行两遍dp，思路繁琐，维护东西较多： dis表示以i为根的子树的直径，dis2表示切掉以i为根的子树后的直径。 第一遍dp，记录 down[][0]:从i结点向下的最大距离 down[][1]:与down[][0]无交集的向下次大距离 dis:以i为根的子树的直...
HDU 5886 - Tower Defence(最短路+最小割)
[2,+∞)的博客
09-22 425
题目题意： n个点，m条边，构建有权无向图 告诉你有人从n点一定会选最短路走到1，然后你是1，要在某些地方设置障碍，要求断开N。思路： 比赛时理解出了问题，以为是使1与n不连通，即求整个图的最小割，实际上题目中要求对方一定走最短路，是要先跑最短路，根据最短路来建图，在新图上跑最小割就可以了。#include<iostream> #include<cstring> #include<cstdio
Hdu-5886 Tower Defence(树形DP)
WZJRJ28
09-20 860
Problem Description There was a civil war between two factions in Skyrim, a province of the Empire on the continent of Tamriel. The Stormcloaks, led by Ulfric Stormcloak, are made up of Skyrim's nati
HDU5779 Tower Defence
diankeng5481的博客
08-01 107
dp[i][j][k] 已选i个人 选到第j层 第j层有k个人 讨论相邻层 上一层选了l人 那么共有 两层之间的方案数 以及这一层自己的方案数 #include<bits/stdc++.h> using namespace std; typedef long long ll; const int MOD = 1e9+7; ll Pow[3605]; ll...
第一场-H - Highest Tower
xbb0720的博客
04-09 227
H-Highest Tower Oni loved to build tall towers of blocks. Her parents were not as amused though. They were on the verge of going crazy over that annoying loud noise when- ever a tower fell to the ground, not to mention having to pick up blocks from the flo
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值