Bzoj2286 [Sdoi2011消耗战

Time Limit: 20 Sec  Memory Limit: 512 MB
Submit: 3003  Solved: 1081

Description

在一场战争中,战场由n个岛屿和n-1个桥梁组成,保证每两个岛屿间有且仅有一条路径可达。现在,我军已经侦查到敌军的总部在编号为1的岛屿,而且他们已经没有足够多的能源维系战斗,我军胜利在望。已知在其他k个岛屿上有丰富能源,为了防止敌军获取能源,我军的任务是炸毁一些桥梁,使得敌军不能到达任何能源丰富的岛屿。由于不同桥梁的材质和结构不同,所以炸毁不同的桥梁有不同的代价,我军希望在满足目标的同时使得总代价最小。

侦查部门还发现,敌军有一台神秘机器。即使我军切断所有能源之后,他们也可以用那台机器。机器产生的效果不仅仅会修复所有我军炸毁的桥梁,而且会重新随机资源分布(但可以保证的是,资源不会分布到1号岛屿上)。不过侦查部门还发现了这台机器只能够使用m次,所以我们只需要把每次任务完成即可。

Input

第一行一个整数n,代表岛屿数量。

接下来n-1行,每行三个整数u,v,w,代表u号岛屿和v号岛屿由一条代价为c的桥梁直接相连,保证1<=u,v<=n且1<=c<=100000。

第n+1行,一个整数m,代表敌方机器能使用的次数。

接下来m行,每行一个整数ki,代表第i次后,有ki个岛屿资源丰富,接下来k个整数h1,h2,…hk,表示资源丰富岛屿的编号。

Output

输出有m行,分别代表每次任务的最小代价。

Sample Input

10
1 5 13
1 9 6
2 1 19
2 4 8
2 3 91
5 6 8
7 5 4
7 8 31
10 7 9
3
2 10 6
4 5 7 8 3
3 9 4 6

Sample Output

12
32
22

HINT

对于100%的数据,2<=n<=250000,m>=1,sigma(ki)<=500000,1<=ki<=n-1

Source

Stage2 day2

虚树

传说中的虚树,原来就是利用LCA和栈重建树啊……

码题过程十分曲折。先是一个a[i]打成i调半天,之后交上去又TTT,看了别的题解才注意到初始化邻接表不需要memset(hd),只要标号置0,dp完一个点就删一个点的hd就可以了,交上去答案爆炸,发现没有开LL……开了LL程序突然爆了,发现是因为手写的min函数形参是int……删了min继续交,INF又开大了……

对自己的智商感到绝望.jpg

  1 /*by SilverN*/
  2 #include<algorithm>
  3 #include<iostream>
  4 #include<cstring>
  5 #include<cstdio>
  6 #include<cmath>
  7 #include<vector>
  8 #define LL long long
  9 using namespace std;
 10 const int mxn=600010;
 11 int read(){
 12     int x=0,f=1;char ch=getchar();
 13     while(ch<‘0‘ || ch>‘9‘){if(ch==‘-‘)f=-1;ch=getchar();}
 14     while(ch>=‘0‘ && ch<=‘9‘){x=x*10+ch-‘0‘;ch=getchar();}
 15     return x*f;
 16 }
 17 struct edge{
 18     int v,nxt,w;
 19 }e[mxn<<1],eg[mxn<<1];
 20 int hd1[mxn],hd2[mxn],mct=0,mct2=0;
 21 void add_edge(int u,int v,int w){
 22     e[++mct].v=v;e[mct].nxt=hd1[u];e[mct].w=w;hd1[u]=mct;return;
 23 }
 24 void add(int u,int v){
 25     if(u==v)return;
 26     eg[++mct2].v=v;eg[mct2].nxt=hd2[u];hd2[u]=mct2;return;
 27 }
 28 int fa[mxn][19],dep[mxn];
 29 LL dis[mxn];
 30 int in[mxn],out[mxn],dtime=0;
 31 void DFS(int u,int ff){
 32     in[u]=++dtime;
 33     dep[u]=dep[ff]+1;
 34     for(int i=1;i<19;i++)fa[u][i]=fa[fa[u][i-1]][i-1];
 35     for(int i=hd1[u],v;i;i=e[i].nxt){
 36         if(e[i].v==ff)continue;
 37         v=e[i].v;
 38         fa[v][0]=u;
 39         dis[v]=min(dis[u],(LL)e[i].w);
 40         DFS(v,u);
 41     }
 42     out[u]=dtime;
 43     return;
 44 }
 45 int cmp(int a,int b){return in[a]<in[b];}//按DFS序排序
 46 int LCA(int x,int y){
 47     if(dep[x]<dep[y])swap(x,y);
 48     for(int i=18;i>=0;i--)
 49         if(dep[fa[x][i]]>=dep[y])x=fa[x][i];
 50     if(x==y)return y;
 51     for(int i=18;i>=0;i--)
 52         if(fa[x][i]!=fa[y][i])x=fa[x][i],y=fa[y][i];
 53     return fa[x][0];
 54 }
 55 LL f[mxn];
 56 int DP(int u){
 57     f[u]=dis[u];
 58     LL res=0;
 59     for(int i=hd2[u];i;i=eg[i].nxt){
 60         DP(eg[i].v);
 61         res+=f[eg[i].v];
 62     }
 63     if(res)f[u]=min(f[u],res);
 64     hd2[u]=0;
 65     return f[u];
 66 }
 67 int a[mxn];
 68 int st[mxn],top=0;
 69 void solve(){
 70     mct2=0;mct=0;
 71     int i,j,K=read();
 72     for(i=1;i<=K;i++)a[i]=read();
 73     sort(a+1,a+K+1,cmp);
 74     int cnt=0;
 75     a[cnt=1]=a[1];
 76     for(i=2;i<=K;i++)if(in[a[i]]>out[a[cnt]])a[++cnt]=a[i];
 77 //    for(i=2;i<=K;i++)if(LCA(a[cnt],a[i])!=a[cnt])a[++cnt]=a[i];
 78     st[top=1]=1;
 79     for(i=1;i<=cnt;i++){
 80         int now=a[i];
 81         int tmp=LCA(a[i],st[top]);
 82         while(1){
 83             if(dep[tmp]>=dep[st[top-1]]){
 84                 add(tmp,st[top--]);
 85                 if(st[top]!=tmp)st[++top]=tmp;
 86                 break;
 87             }
 88             add(st[top-1],st[top]);--top;
 89         }
 90         if(st[top]!=now)st[++top]=now;
 91     }
 92     while(--top)add(st[top],st[top+1]);
 93     DP(1);
 94     printf("%lld\n",f[1]);
 95     return;
 96 }
 97 int n,m;
 98 int main(){
 99     int i,j,u,v,w;
100     n=read();
101     for(i=1;i<n;i++){
102         u=read();v=read();w=read();
103         add_edge(u,v,w);
104         add_edge(v,u,w);
105     }
106     dis[1]=1e13;
107     DFS(1,0);
108     m=read();
109     while(m--)solve();
110     return 0;
111 }
时间: 2024-10-16 16:55:22

Bzoj2286 [Sdoi2011消耗战的相关文章

BZOJ2286 [Sdoi2011]消耗战

Description 在一场战争中,战场由n个岛屿和n-1个桥梁组成,保证 每两个岛屿间有且仅有一条路径可达.现在,我军已经侦查到敌军的总部在编号为1的岛屿,而且他们已经没有足够多的能源维系战斗,我军胜利在望.已知在其他 k个岛屿上有丰富能源,为了防止敌军获取能源,我军的任务是炸毁一些桥梁,使得敌军不能到达任何能源丰富的岛屿.由于不同桥梁的材质和结构不同,所以炸毁 不同的桥梁有不同的代价,我军希望在满足目标的同时使得总代价最小. 侦查部门还发现,敌军有一台神秘机器.即使我军切断所有能源之后,他

[bzoj2286][Sdoi2011]消耗战(虚树上的DP)

题目:http://www.lydsy.com:808/JudgeOnline/problem.php?id=2286 分析:对于普通的树形dp:f[x]=min(∑f[son],m[x]),其中f[x]表示以x为根的子树所有关键点全部断开所需要的最少代价,m[x]表示从根节点到x节点的路径上最短的边 这样的话复杂度是n*m的,明显TLE 注意到数据范围里提到,所有询问的总的点数<=n,也就是说询问虽然很多,但每次询问的点的个数不多,也就是说如果对所有的点做树形dp就很不值得 于是我们就要取出那

【BZOJ2286】[Sdoi2011]消耗战 虚树

[BZOJ2286][Sdoi2011]消耗战 Description 在一场战争中,战场由n个岛屿和n-1个桥梁组成,保证每两个岛屿间有且仅有一条路径可达.现在,我军已经侦查到敌军的总部在编号为1的岛屿,而且他们已经没有足够多的能源维系战斗,我军胜利在望.已知在其他k个岛屿上有丰富能源,为了防止敌军获取能源,我军的任务是炸毁一些桥梁,使得敌军不能到达任何能源丰富的岛屿.由于不同桥梁的材质和结构不同,所以炸毁不同的桥梁有不同的代价,我军希望在满足目标的同时使得总代价最小. 侦查部门还发现,敌军有

bzoj 2286 [Sdoi2011]消耗战(虚树+树上DP)

2286: [Sdoi2011]消耗战 Time Limit: 20 Sec  Memory Limit: 512 MBSubmit: 1276  Solved: 445[Submit][Status][Discuss] Description 在一场战争中,战场由n个岛屿和n-1个桥梁组成,保证每两个岛屿间有且仅有一条路径可达.现在,我军已经侦查到敌军的总部在编号为1的岛屿,而且他们已经没有足够多的能源维系战斗,我军胜利在望.已知在其他k个岛屿上有丰富能源,为了防止敌军获取能源,我军的任务是炸

【BZOJ-2286】消耗战 虚树 + 树形DP

2286: [Sdoi2011消耗战 Time Limit: 20 Sec  Memory Limit: 512 MBSubmit: 2120  Solved: 752[Submit][Status][Discuss] Description 在一场战争中,战场由n个岛屿和n-1个桥梁组成,保证每两个岛屿间有且仅有一条路径可达.现在,我军已经侦查到敌军的总部在编号为1的岛屿,而且他们已经没有足够多的能源维系战斗,我军胜利在望.已知在其他k个岛屿上有丰富能源,为了防止敌军获取能源,我军的任务是炸毁

AC日记——[SDOI2011]消耗战 洛谷 P2495

[SDOI2011]消耗战 思路: 建虚树走树形dp: 代码: #include <bits/stdc++.h> using namespace std; #define INF 1e17 #define maxn 250005 #define ll long long #define maxm (maxn<<1) struct LandType { ll id,key; bool operator<(const LandType pos)const { return key

[Sdoi2011]消耗战

2286: [Sdoi2011]消耗战 Time Limit: 20 Sec  Memory Limit: 512 MBSubmit: 3108  Solved: 1115[Submit][Status][Discuss] Description 在 一场战争中,战场由n个岛屿和n-1个桥梁组成,保证每两个岛屿间有且仅有一条路径可达.现在,我军已经侦查到敌军的总部在编号为1的岛屿,而且他们已经 没有足够多的能源维系战斗,我军胜利在望.已知在其他k个岛屿上有丰富能源,为了防止敌军获取能源,我军的任

luogu P2495 [SDOI2011]消耗战

二次联通门 : luogu P2495 [SDOI2011]消耗战 /* luogu P2495 [SDOI2011]消耗战 虚树+树形dp 首先对原图构建出虚树 在建图的时候处理出最小值 转移即可 小技巧 在dp的过程中可以顺便把边表清空 将边结构体封装可方便的建多张图 */ #include <cstdio> #include <iostream> #include <cstring> #include <algorithm> #define INF 1

&lt;虚树+树型DP&gt; SDOI2011消耗战

<虚树+树型DP> SDOI2011消耗战 #include <iostream> #include <cstdio> #include <cstring> #include <cmath> #include <algorithm> using namespace std; typedef long long LL; const int MAXN = 25e4 + 10; inline LL in() { LL x = 0, flag