CF613D Kingdom and its Cities 虚树

传送门

---

$\sum k \leq 100000$虚树套路题

设$f_{i,0/1}$表示处理完$i$以及其所在子树的问题，且处理完后$i$所在子树内是否存在$1$个关键点满足它到$i$的路径上不存在任何点被封的最小代价。

转移考虑$i$是否是关键点以及是否封$i$号点。

注意判断相邻两个点同时是关键点的情况。同时需要注意：如果虚树上两个点不相邻，可以封这两个点之间的点。

 #include<bits/stdc++.h>
 //This code is written by Itst
 using namespace std;

 inline int read(){
     ;
     ;
     char c = getchar();
     while(c != EOF && !isdigit(c)){
         if(c == '-')
             f = ;
         c = getchar();
     }
     while(c != EOF && isdigit(c)){
         a = (a << ) + (a << ) + (c ^ ');
         c = getchar();
     }
     return f ? -a : a;
 }

 ;
 struct Edge{
     int end , upEd;
 }Ed[MAXN << ] , newEd[MAXN];
 ] , newHead[MAXN] , s[MAXN] , dfn[MAXN] , num[MAXN] , dp[MAXN][] , dep[MAXN];
 int N , headS , cntEd , cntNewEd , ts , cnt;
 bool imp[MAXN];

 inline void addEd(Edge* Ed , int* head , int& cntEd , int a , int b){
     Ed[++cntEd].end = b;
     Ed[cntEd].upEd = head[a];
     head[a] = cntEd;
 }

 void init(int now , int fa){
     dfn[now] = ++ts;
     dep[now] = dep[fa] + ;
     jump[now][] = fa;
      ; jump[now][i - ] ; ++i)
         jump[now][i] = jump[jump[now][i - ]][i - ];
     for(int i = head[now] ; i ; i = Ed[i].upEd)
         if(Ed[i].end != fa)
             init(Ed[i].end , now);
 }

 inline int jumpToLCA(int x , int y){
     if(dep[x] < dep[y])
         swap(x , y);
      ; i >=  ; --i)
          << i) >= dep[y])
             x = jump[x][i];
     if(x == y)
         return x;
      ; i >=  ; --i)
         if(jump[x][i] != jump[y][i]){
             x = jump[x][i];
             y = jump[y][i];
         }
     ];
 }

 inline void create(){
     imp[] = ;
     dp[][] = dp[][] = ;
      ; i <= cnt ; ++i){
         imp[num[i]] = ;
         dp[num[i]][] = ;
         dp[num[i]][] = N + ;
     }
      ; i <= cnt ; ++i)
         if(!headS)
             s[++headS] = num[i];
         else{
             int t = jumpToLCA(s[headS] , num[i]);
             if(t != s[headS]){
                 ]] > dep[t]){
                     addEd(newEd , newHead , cntNewEd , s[headS - ] , s[headS]);
                     --headS;
                 }
                 addEd(newEd , newHead , cntNewEd , t , s[headS]);
                 if(s[--headS] != t)
                     s[++headS] = t;
             }
             s[++headS] = num[i];
         }
     ){
         addEd(newEd , newHead , cntNewEd , s[headS - ] , s[headS]);
         --headS;
     }
     )
         addEd(newEd , newHead , cntNewEd ,  , s[headS]);
     --headS;
 }

 void dfs(int now){
     ;
     for(int i = newHead[now] ; i ; i = newEd[i].upEd){
         int t = newEd[i].end;
         dfs(t);
         if(imp[now])
             ] == now)
                 dp[now][] += dp[t][];
             else
                 dp[now][] += min(dp[t][] , dp[t][] + );
         else{
             ] == now)
                 dp[now][] = min(sum + dp[t][] , dp[now][] + dp[t][]);
             else
                 dp[now][] = min(sum + dp[t][] , dp[now][] + min(dp[t][] , dp[t][] + ));
             ] == now)
                 sum += dp[t][];
             else
                 sum += min(dp[t][] , dp[t][] + );
         }
         ] > N)
             dp[now][] = N + ;
         )
             sum = N + ;
     }
     sum = ;
     for(int i = newHead[now] ; i ; i = newEd[i].upEd){
         int t = newEd[i].end;
         if(!imp[now]){
             sum += min(dp[t][] , dp[t][]);
             dp[now][] += dp[t][];
         }
         dp[t][] = dp[t][] = imp[t] = ;
     }
     if(!imp[now])
         dp[now][] = min(dp[now][] , sum + );
     newHead[now] = ;
 }

 bool cmp(int a , int b){
     return dfn[a] < dfn[b];
 }

 int main(){
 #ifndef ONLINE_JUDGE
     freopen("613D.in" , "r" , stdin);
     //freopen("613D.out" , "w" , stdout);
 #endif
     N = read();
      ; i < N ; ++i){
         int a = read() , b = read();
         addEd(Ed , head , cntEd , a , b);
         addEd(Ed , head , cntEd , b , a);
     }
     init( , );
     for(int M = read() ; M ; --M){
         cnt = read();
          ; i <= cnt ; ++i)
             num[i] = read();
         sort(num +  , num + cnt +  , cmp);
         create();
         dfs();
         ][] , dp[][]);
         printf( ? - : t);
     }
     ;
 }