bzoj2286 （sdoi2011）消耗战（虚树）

[Sdoi2011]消耗战

Time Limit: 20 Sec  Memory Limit: 512 MB
Submit: 4052  Solved: 1463
[Submit][Status][Discuss]

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行，每行一个整数k_i，代表第i次后，有k_i个岛屿资源丰富，接下来k个整数h₁,h₂,…h_k，表示资源丰富岛屿的编号。

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

 

题解：这道题十分惭愧，毕竟不是我自己打的，写了一次代码还写挂了，但是十分欣赏这个数据结构，

怎么办呢，于是直接贴了hzw代码，还是先理解为主吧，(⊙o⊙)…

hzw的代码比较精简，我看了看，也理解了一番，直接写在代码上了，

这是hzw的题解，难以理解，十分正常。

我还觉得这篇题解写的不错

那么就需要用到虚树的技巧了,虚树就是通过维护一个单调栈把树的关键点和它们之间的lca按照dfs序遍历一遍，遍历的过程中通过单调栈的调整来理清树的父亲和儿子之间的关系。

首先，对树节点进行dfs。在期间对节点进行标号dfn。

然后，维护一个单调栈。这个单调栈的节点都在一条链上。

对于栈顶元素 p,栈次顶元素 q, 即将插入节点x 有如下关系：

1.lca是p.此时dfn(x)>dfn(p)=dfn(lca)

这说明 x在p的下面，直接把x入栈即可

2.p和x分立在lca的两棵子树下.此时 dfn(x)>dfn(p)>dfn(ilca)

这时候就有三种讨论了

针对这道题的连边就是树型dp处理

(1)如果dfn(q)>dfn(lca),可以直接连边q->p,然后退一次栈.

(2)如果dfn(q)=dfn(lca),说明q=lca,直接连边lca->p,把p退栈,此时子树已经构建完毕.

(3)如果dfn(q)<dfn(lca),说明lca被p与q夹在中间,此时连边lca->q,把p退栈,再把lca压入栈.此时子树构建完毕.

 #include<iostream>
 #include<set>
 #include<map>
 #include<cstdio>
 #include<cstring>
 #include<cstdlib>
 #include<ctime>
 #include<vector>
 #include<queue>
 #include<algorithm>
 #include<cmath>
 #include<bitset>
 #include<stack>
 #define inf 1e60
 #define pa pair<int,int>
 #define ll long long
 using namespace std;
 int read()
 {
     int x=,f=;char ch=getchar();
     while(ch<''||ch>''){if(ch=='-')f=-;ch=getchar();}
     while(ch>=''&&ch<=''){x=x*+ch-'';ch=getchar();}
     return x*f;
 }
 int bin[];
 int n,m,cnt,ind,top;
 int last[],last2[],fa[][];
 ll mn[],f[];
 int h[],mark[],deep[];
 int st[];
 struct edge{
     int to,next,v;
 }e[],ed[];
 void insert(int u,int v,int w)//普通增边吧
 {
     e[++cnt].to=v;e[cnt].next=last[u];last[u]=cnt;e[cnt].v=w;
     e[++cnt].to=u;e[cnt].next=last[v];last[v]=cnt;e[cnt].v=w;
 }
 void insert2(int u,int v)//这是虚树增边
 {
     if(u==v)return;
     ed[++cnt].to=v;ed[cnt].next=last2[u];last2[u]=cnt;
 }
 bool cmp(int a,int b)
 {
     return mark[a]<mark[b];
 }
 void pre(int x)//预处理深度，以及父亲
 {
     mark[x]=++ind;
     for(int i=;bin[i]<=deep[x];i++)
         fa[x][i]=fa[fa[x][i-]][i-];
     for(int i=last[x];i;i=e[i].next)
         if(e[i].to!=fa[x][])
         {
             mn[e[i].to]=min(mn[x],(ll)e[i].v);//到路径的最小值。
             deep[e[i].to]=deep[x]+;
             fa[e[i].to][]=x;
             pre(e[i].to);
         }
 }
 int lca(int x,int y)//倍增求lca
 {
     if(deep[x]<deep[y])swap(x,y);
     int t=deep[x]-deep[y];
     for(int i=;bin[i]<=t;i++)
         if(t&bin[i])x=fa[x][i];
     for(int i=;i>=;i--)
         if(fa[x][i]!=fa[y][i])
             x=fa[x][i],y=fa[y][i];
     if(x==y)return x;
     return fa[x][];
 }
 void dp(int x)
 {
     f[x]=mn[x];
     ll tmp=;
     for(int i=last2[x];i;i=ed[i].next)
     {
         dp(ed[i].to);
         tmp+=f[ed[i].to];
     }
     last2[x]=;
     if(tmp==)f[x]=mn[x];
     else if(tmp<=f[x])f[x]=tmp;
 }
 void solve()
 {
     cnt=;
     int K=read();
     for(int i=;i<=K;i++)
         h[i]=read();
     sort(h+,h+K+,cmp);//输入是无序的
     int tot=;
     h[++tot]=h[];
     for(int i=;i<=K;i++)
         if(lca(h[tot],h[i])!=h[tot]) h[++tot]=h[i];
     st[++top]=;//根节点是总根
     for(int i=;i<=tot;i++)
     {
         int now=h[i],f=lca(now,st[top]);
         while()
         {
             if(deep[f]>=deep[st[top-]])
             {
                 insert2(f,st[top--]);
                 if(st[top]!=f)st[++top]=f;
                 break;
             }
             insert2(st[top-],st[top]);top--;
         }
         if(st[top]!=now)st[++top]=now;
     }
     while(--top)insert2(st[top],st[top+]);
     dp();
     printf("%lld\n",f[]);
 }
 int main()
 {
     bin[]=;for(int i=;i<;i++)bin[i]=bin[i-]<<;
     n=read();
     for(int i=;i<n;i++)
     {
         int u=read(),v=read(),w=read();
         insert(u,v,w);
     }
     mn[]=inf;pre();
     m=read();
     for(int i=;i<=m;i++)
         solve();
     return ;
 }

重复判断上述过程