消耗战 bzoj 2286

消耗战

【问题描述】

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

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

【输入格式】

第一行一个整数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，表示资源丰富岛屿的编号。

【输出格式】

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

【样例输入】

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

【样例输出】

12

32

22

【数据规模和约定】

对于10%的数据，2<=n<=10,1<=m<=5,1<=k_i<=n-1

对于20%的数据，2<=n<=100,1<=m<=100,1<=k_i<=min(10,n-1)

对于40%的数据，2<=n<=1000,m>=1,sigma(k_i)<=500000,1<=k_i<=min(15,n-1)

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

---

题解：

题目就是给定一棵树，询问删去一些边使输入关键节点与根节点1不连通的最小费用

虚树就是保留只所有关键节点和它们的公共祖先的连边所构建出的树，每次询问O(mlog₂m)

我们记val[i]为使根节点与i不连通的最小花费

ti[i]表示i的Dfs序

对于每次询问

将所有关键节点按ti排序（根节点自然也算关键节点）

将相邻关键节点的最近公共祖先加入数组，这样就可以将所有关键节点的公共祖先

小小证明一下能够找出所有公共祖先：

　　我们假定按Dfs序排好的三个点A，B，C

　　如果其中两个或三个在同一个子树中，那么显然能够找出所有公共祖先

　　如果都不在同一棵子树上，那么设A与B的公共祖先为D，B与C的公共祖先为E

　　接下来A到根节点的链简称A链，其它同理

　　因为它们按Dfs序处理过，公共祖先必定在根节点分别与两点组成的链上

　　由此可知D和E都在B链上

　　假设D在E的上方，那么D就是A与C的最近公共祖先

　　证明：

　　　　由于D在A链上，E在C链上

　　　　那么D链是A链与C链的共同部分

　　　　所以A和C的公共祖先在D链上

　　　　由于D链在B链上

　　　　所以在D链上离A最近的点是A与B的公共祖先即D

　　　　则D为A、C的公共祖先

　　　　

　　　　E在D的上方同理

　　多个点同理

　　一小部分的证明自己脑补啦~~~也可以去看虚树讲义

草率地证明完毕

证明有毒但是代码巨短

再次排序，去重

接下来用单调栈连接所有关键节点之间的边

大概讲一下单调栈：

　　我们已经将点按Dfs序排序过了

　　所以那么我们就可以直接判断栈顶元素与当前元素的关系，即当前元素是否在栈顶元素的子树中，同时满足能顺序访问每个点的子树

　　如果在子树中，那么连边，权值为当前节点的val

　　如果不在，那么说明当前元素在栈顶元素子树的外边，退栈，继续判断两者关系

这样就够出了一个虚树

接下来再来一个简单的树形Dp就好了

~\(≧▽≦)/~啦啦啦

 #include<algorithm>
 #include<iostream>
 #include<cstring>
 #include<cstdlib>
 #include<cstdio>
 #include<cmath>
 using namespace std;
 inline int Get()
 {
     int x = ;
     char c = getchar();
     while('' > c || c > '') c = getchar();
     while('' <= c && c <= '')
     {
         x = (x << ) + (x << ) + c - '';
         c = getchar();
      }
      return x;
 }
 const int me = ;
 struct shape
 {
     int lca, mi;
 };
 int n;
 int m;
 int k;
 int ns, s[me];
 int tot, to[me], nex[me], fir[me];
 long long va[me];
 inline void Ins(int x, int y, int z)
 {
     nex[++tot] = fir[x];
     fir[x] = tot;
     to[tot] = y;
     va[tot] = z;
 }
 int de[me];
 int si[me];
 int fa[me][];
 int nt, ti[me];
 long long val[me];
 bool mark[me];
 void Dfs(int u, int fat)
 {
     si[u] = ;
     de[u] = de[fat] + ;
     ti[u] = ++nt;
     for(int i = fir[u]; i; i = nex[i])
     {
         int v = to[i];
         if(v == fat) continue;
         fa[v][] = u;
         val[v] = min(val[u], va[i]);
         Dfs(v, u);
         si[u] += si[v];
     }
 }
 inline bool rt(int x, int y)
 {
     return ti[x] < ti[y];
 }
 inline int Lca(int x, int y)
 {
     if(de[x] < de[y]) swap(x, y);
     for(int i = k; de[x] != de[y], i >= ; --i)
         if(de[fa[x][i]] >= de[y])
             x = fa[x][i];
     for(int i = k; i >= ; --i)
         if(fa[x][i] != fa[y][i])
             x = fa[x][i], y = fa[y][i];
     if(x != y) return fa[x][];
     return x;
 }
 long long Dp(int u, int fat)
 {
     if(mark[u] || !fir[u]) return val[u];
     long long sum = ;
     for(int i = fir[u]; i; i = nex[i])
     {
         int v = to[i];
         if(v == fat) continue;
         sum += min(Dp(v, u), val[v]);
     }
     return sum;
 }
 void Clear(int u, int fat)
 {
     for(int i = fir[u]; i; i = nex[i])
     {
         int v = to[i];
         if(v == fat) continue;
         Clear(v, u);
     }
     fir[u] = ;
 }
 int top, st[me];
 int main()
 {
     n = Get();
     k = log(n) + ;
     for(int i = ; i < n; ++i)
     {
         int u = Get();
         int v = Get();
         int z = Get();
         Ins(u, v, z);
         Ins(v, u, z);
     }
     for(int i = ; i <= n; ++i) val[i] = 214748364721474836LL;
     Dfs(, );
     for(int j = ; j <= k; ++j)
         for(int i = ; i <= n; ++i)
             fa[i][j] = fa[fa[i][j - ]][j - ];
     for(int i = ; i <= n; ++i) fir[i] = ;
     tot = ;
     m = Get();
     for(int i = ; i <= m; ++i)
     {
         int p = Get();
         for(int i = ; i <= p; ++i)
         {
             s[i] = Get();
             mark[s[i]] = true;
         }
         sort(s + , s +  + p, rt);
         ns = p;
         s[++ns] = ;
         for(int i = ; i < p; ++i)
             s[++ns] = Lca(s[i], s[i + ]);
         sort(s + , s +  + ns, rt);
         int lens = ;
         for(int i = ; i <= ns; ++i)
             if(s[i] != s[i - ])
                 s[++lens] = s[i];
         top = ;
         for(int i = ; i <= lens; ++i)
         {
             while(top >  && ti[s[i]] >= ti[st[top]] + si[st[top]]) --top;
             if(top > ) Ins(st[top], s[i], val[s[i]]);
             st[++top] = s[i];
         }
         printf("%lld\n", Dp(, ));
         for(int i = ; i <= lens; ++i) mark[s[i]] = false;
         tot = ;
         Clear(, );
     }
 }