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

最新推荐文章于 2019-07-26 20:30:45 发布
最新推荐文章于 2019-07-26 20:30:45 发布
阅读量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
关注
hdu acm1166线段树
05-03
hdu 1166线段树代码
HDU 5886 - Tower Defence(最短路+最小割)
[2,+∞)的博客
09-22 425
题目题意： n个点，m条边，构建有权无向图 告诉你有人从n点一定会选最短路走到1，然后你是1，要在某些地方设置障碍，要求断开N。思路： 比赛时理解出了问题，以为是使1与n不连通，即求整个图的最小割，实际上题目中要求对方一定走最短路，是要先跑最短路，根据最短路来建图，在新图上跑最小割就可以了。#include<iostream> #include<cstring> #include<cstdio
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 (最长链预处理)
每一次AC都是一种感动
09-18 987
题意：给出一棵树，边上有权值，现在毁掉任意一条边，分成两部分，求这两部分中最远的两点距离期望，答案*（n-1）分析： 说白了就是求最远距离加成和 对于一棵树来说，两点最远的距离，考虑两点： 1.最长链没有被拆开，那么答案就是最长链； 2.最长链被拆开了，那么答案一定在最长链的端点到某个叶子结点上； 证明略。有了这个结论，这个题就好做了，首先预处理出最长链，数组存下来，然后对于每个最长链上的
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】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...
【题解】「HDU1166」敌兵布阵(线段树)
01-20
题面 【题目描述】 有nnn个营地，已知每个营地的人数，有四条命令： (1)Add(1) Add(1)Add iii jjj，iii和jjj为正整数,表示第iii个营地增加jjj个人（jjj不超过303030） (2)Sub(2)Sub(2)Sub iii jjj ，iii和jjj为正...
DP.rar_DP_hdu_动态规划_动态规划 C++
最新发布
09-20
标题中的“DP.rar”表明这是一个关于动态规划的资料压缩包，而“DP_hdu”暗示了这些题目可能来自杭州电子科技大学（HDU）的在线编程平台。动态规划通常用于解决那些可以通过子问题的最优解来构建原问题最优解的问题...
数据结构课程实践哈夫曼树
12-22
哈夫曼树（Huffman Tree），也称为最优二叉树，是数据结构中一种非常重要的树形数据结构，尤其在编码领域中应用广泛。在数据结构课程实践中，学习哈夫曼树有助于理解如何通过贪心策略来构建最小带权路径长度的二叉树...
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
[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)
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，无非要求两个东西，以它作为根的子树中的
HDU 5886
常胜将军的博客
05-17 484
题目：N个点的一棵带权树。切掉某条边的价值为切后两树直径中的最大值。求各个边切掉后的价值和（共N-1项）。 思路：预处理出最长链，若断边不在最长链上，那么答案依旧是最长链，否则分别计算断开后的最长链，取最大值。 参考：https://www.cnblogs.com/zufezzt/p/5892342.html，https://blog.csdn.net/hao_zong_yin/article...
hdu5886Tower Defence（树形dp）
weixin_30823227的博客
09-20 91
Time Limit: 3000/1000 MS (Java/Others)Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 242Accepted Submission(s): 80 Problem Description There was a civil war ...
HDU 5779 Tower Defence(????)
ZSQ
08-01 590
Description ????????Tower Defence???????????????????n??????(??????,???????),????????1,???1??????????????????k.???????????????????????,????????????? Input ?????????T(1=T=10) ???????,?????n?k(1=k,n=6
第一场-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
hdu 5886 Tower Defence 2016ACM/ICPC青岛赛区网络赛1009
lqybzx的专栏
09-18 903
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 na
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值