虚树习题

最新推荐文章于 2022-08-12 22:14:51 发布
最新推荐文章于 2022-08-12 22:14:51 发布
阅读量323 收藏
点赞数
分类专栏： 虚树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/herbertpotter/article/details/77575057
版权

什么是虚树？

比方说有一棵很大很大的树

但是每次会指定一些节点，这些点的个数很少，我们需要在树上进行DP

n的范围会达到百万级别

然而点的个数不会超过1000个

显然很多点都是没有用的点


我们需要把信息浓缩一下，构造出一棵新的树出来


恩。那么哪些会是虚树上的关键节点呢？


除了给定的点外还有一些点的LCA


不会构造怎么办？！


不用担心！构造虚树也是有个模板的



[例题1][Bzoj 2286][Sdoi2011]消耗战


在一场战争中，战场由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
【数据规模和约定】
对于100%的数据，2<=n<=250000,m>=1,sigma(ki)<=500000,1<=ki<=n-1


[cpp] view plain copy
print ?
  1. #include<iostream>  
  2. #include<cstdio>  
  3. #include<cstring>  
  4. #include<algorithm>  
  5. #define maxn 500010  
  6.    
  7. using namespace std;  
  8.    
  9. typedef long long ll;  
  10.    
  11. const ll inf = 1LL<<60;  
  12.    
  13. int n;  
  14.    
  15. struct Edge{  
  16.     int to, next, dis;  
  17. }edge[maxn];  
  18.    
  19. int h[maxn], cnt;  
  20.    
  21. void add(int u, int v){  
  22.     cnt ++;  
  23.     edge[cnt].to = v;  
  24.     edge[cnt].next = h[u];  
  25.     h[u] = cnt;  
  26. }  
  27.    
  28.    
  29. struct EG{  
  30.     int to, next, dis;  
  31. }G[maxn];  
  32.    
  33. int hG[maxn], cntG;  
  34.    
  35. void addG(int u, int v, int w){  
  36.     cntG ++;  
  37.     G[cntG].to = v;  
  38.     G[cntG].next = hG[u];  
  39.     G[cntG].dis = w;  
  40.     hG[u] = cntG;  
  41. }  
  42.    
  43. int root, t[maxn], fa[maxn], dep[maxn], dfn[maxn], dfs_clock;  
  44.    
  45. bool cmp(int x, int y){  
  46.     return dfn[x] < dfn[y];  
  47. }  
  48.    
  49. int anc[maxn][20];  
  50.    
  51. ll dis[maxn];  
  52.    
  53. void dfs(int u){  
  54.     dep[u] = dep[fa[u]] + 1;  
  55.     dfn[u] = ++ dfs_clock;  
  56.     for(int i = hG[u];i;i = G[i].next){  
  57.         int v = G[i].to;  
  58.         if(v == fa[u])continue;  
  59.         dis[v] = min(dis[u], (ll)G[i].dis);  
  60.         fa[v] = u;  
  61.         dfs(v);  
  62.     }  
  63. }  
  64.    
  65.    
  66. void pre_LCA(){  
  67.     for(int i=1;i<=n;i++)  
  68.         anc[i][0] = fa[i];  
  69.     for(int j=1;1<<j<=n;j++)  
  70.         for(int i=1;i<=n;i++){  
  71.             int a = anc[i][j-1];  
  72.             if(~a)anc[i][j] = anc[a][j-1];  
  73.         }  
  74. }  
  75.    
  76. int ask_LCA(int p, int q){  
  77.     if(dep[p] < dep[q])  
  78.         swap(p, q);  
  79.    
  80.     int log;  
  81.     for(log=1;1<<log<=dep[p];log++);log--;  
  82.     for(int i=log;i>=0;i--)  
  83.         if(~anc[p][i] && dep[anc[p][i]] >= dep[q])  
  84.             p = anc[p][i];  
  85.     if(p == q)return p;  
  86.     for(int i=log;i>=0;i--)  
  87.         if(~anc[p][i] && anc[p][i] != anc[q][i])  
  88.             p = anc[p][i], q = anc[q][i];  
  89.     return fa[p];  
  90. }  
  91.    
  92. int st[maxn], top;  
  93.    
  94. ll dp[maxn];  
  95.    
  96. bool mark[maxn];  
  97.    
  98. void Tree_DP(int u, bool istrue){  
  99.     dp[u] = dis[u];  
  100.        
  101.     if(istrue){  
  102.         for(int i=h[u];i;i=edge[i].next)  
  103.             Tree_DP(edge[i].to, 1);  
  104.         mark[u] = false;  
  105.         h[u] = 0;  
  106.         return;  
  107.     }  
  108.        
  109.     ll tmp = 0;  
  110.     for(int i=h[u];i;i=edge[i].next){  
  111.         int v = edge[i].to;  
  112.         Tree_DP(v, istrue | mark[v]);  
  113.         tmp += dp[v];  
  114.     }  
  115.     mark[u] = 0;  
  116.     if(!h[u] || mark[u])tmp = inf;  
  117.     dp[u] = min(dp[u], tmp);  
  118.     h[u] = 0;  
  119. }  
  120.    
  121. int main(){  
  122.     scanf("%d", &n);  
  123.     int u, v, d;  
  124.     for(int i=1; i<n; i++){  
  125.         scanf("%d%d%d", &u, &v, &d);  
  126.         addG(u, v, d);  
  127.         addG(v, u, d);  
  128.     }  
  129.    
  130.     root = 1;  
  131.        
  132.     dis[root] = inf;  
  133.    
  134.     dfs(root);  
  135.    
  136.     memset(anc, -1, sizeof anc);  
  137.    
  138.     pre_LCA();  
  139.    
  140.     int test, K;  
  141.     scanf("%d", &test);  
  142.    
  143.     while(test --){  
  144.         scanf("%d", &K);  
  145.            
  146.         for(int i=1;i<=K;i++){  
  147.             scanf("%d", &t[i]);  
  148.             mark[t[i]] = true;  
  149.         }  
  150.    
  151.         sort(t+1, t+1+K, cmp);  
  152.         st[top = 1] = root;  
  153.         cnt = 0;  
  154.         for(int i=1;i<=K;i++){  
  155.             int x = t[i],f = ask_LCA(st[top], x);  
  156.             while(dep[f] < dep[st[top]]){  
  157.                 if(dep[f] >= dep[st[top-1]]){  
  158.                     add(f, st[top]);  
  159.                     top --;  
  160.                     if(f != st[top])st[++ top] = f;  
  161.                     break;  
  162.                 }  
  163.                 add(st[top-1], st[top]);  
  164.                 top --;  
  165.             }  
  166.             if(st[top] != x)st[++ top] = x;  
  167.         }  
  168.            
  169.         while(-- top)add(st[top], st[top+1]);  
  170.            
  171.         Tree_DP(root, 0);  
  172.         printf("%lld\n", dp[root]);  
  173.     }  
  174.    
  175.     return 0;  
  176. }  
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define maxn 500010
 
using namespace std;
 
typedef long long ll;
 
const ll inf = 1LL<<60;
 
int n;
 
struct Edge{
    int to, next, dis;
}edge[maxn];
 
int h[maxn], cnt;
 
void add(int u, int v){
    cnt ++;
    edge[cnt].to = v;
    edge[cnt].next = h[u];
    h[u] = cnt;
}
 
 
struct EG{
    int to, next, dis;
}G[maxn];
 
int hG[maxn], cntG;
 
void addG(int u, int v, int w){
    cntG ++;
    G[cntG].to = v;
    G[cntG].next = hG[u];
    G[cntG].dis = w;
    hG[u] = cntG;
}
 
int root, t[maxn], fa[maxn], dep[maxn], dfn[maxn], dfs_clock;
 
bool cmp(int x, int y){
    return dfn[x] < dfn[y];
}
 
int anc[maxn][20];
 
ll dis[maxn];
 
void dfs(int u){
    dep[u] = dep[fa[u]] + 1;
    dfn[u] = ++ dfs_clock;
    for(int i = hG[u];i;i = G[i].next){
        int v = G[i].to;
        if(v == fa[u])continue;
        dis[v] = min(dis[u], (ll)G[i].dis);
        fa[v] = u;
        dfs(v);
    }
}
 
 
void pre_LCA(){
    for(int i=1;i<=n;i++)
        anc[i][0] = fa[i];
    for(int j=1;1<<j<=n;j++)
        for(int i=1;i<=n;i++){
            int a = anc[i][j-1];
            if(~a)anc[i][j] = anc[a][j-1];
        }
}
 
int ask_LCA(int p, int q){
    if(dep[p] < dep[q])
        swap(p, q);
 
    int log;
    for(log=1;1<<log<=dep[p];log++);log--;
    for(int i=log;i>=0;i--)
        if(~anc[p][i] && dep[anc[p][i]] >= dep[q])
            p = anc[p][i];
    if(p == q)return p;
    for(int i=log;i>=0;i--)
        if(~anc[p][i] && anc[p][i] != anc[q][i])
            p = anc[p][i], q = anc[q][i];
    return fa[p];
}
 
int st[maxn], top;
 
ll dp[maxn];
 
bool mark[maxn];
 
void Tree_DP(int u, bool istrue){
    dp[u] = dis[u];
     
    if(istrue){
        for(int i=h[u];i;i=edge[i].next)
            Tree_DP(edge[i].to, 1);
        mark[u] = false;
        h[u] = 0;
        return;
    }
     
    ll tmp = 0;
    for(int i=h[u];i;i=edge[i].next){
        int v = edge[i].to;
        Tree_DP(v, istrue | mark[v]);
        tmp += dp[v];
    }
    mark[u] = 0;
    if(!h[u] || mark[u])tmp = inf;
    dp[u] = min(dp[u], tmp);
    h[u] = 0;
}
 
int main(){
    scanf("%d", &n);
    int u, v, d;
    for(int i=1; i<n; i++){
        scanf("%d%d%d", &u, &v, &d);
        addG(u, v, d);
        addG(v, u, d);
    }
 
    root = 1;
     
    dis[root] = inf;
 
    dfs(root);
 
    memset(anc, -1, sizeof anc);
 
    pre_LCA();
 
    int test, K;
    scanf("%d", &test);
 
    while(test --){
        scanf("%d", &K);
         
        for(int i=1;i<=K;i++){
            scanf("%d", &t[i]);
            mark[t[i]] = true;
        }
 
        sort(t+1, t+1+K, cmp);
        st[top = 1] = root;
        cnt = 0;
        for(int i=1;i<=K;i++){
            int x = t[i],f = ask_LCA(st[top], x);
            while(dep[f] < dep[st[top]]){
                if(dep[f] >= dep[st[top-1]]){
                    add(f, st[top]);
                    top --;
                    if(f != st[top])st[++ top] = f;
                    break;
                }
                add(st[top-1], st[top]);
                top --;
            }
            if(st[top] != x)st[++ top] = x;
        }
         
        while(-- top)add(st[top], st[top+1]);
         
        Tree_DP(root, 0);
        printf("%lld\n", dp[root]);
    }
 
    return 0;
}



[例题2][Bzoj3611][Heoi2014]大工程

国家有一个大工程，要给一个非常大的交通网络里建一些新的通道。 

我们这个国家位置非常特殊，可以看成是一个单位边权的树，城市位于顶点上。 
在 2 个国家 a,b 之间建一条新通道需要的代价为树上 a,b 的最短路径。
 现在国家有很多个计划，每个计划都是这样，我们选中了 k 个点，然后在它们两两之间 新建 C(k,2)条 新通道。
现在对于每个计划，我们想知道：
 1.这些新通道的代价和
 2.这些新通道中代价最小的是多少 
3.这些新通道中代价最大的是多少
Input
第一行 n 表示点数。
 接下来 n-1 行，每行两个数 a,b 表示 a 和 b 之间有一条边。
点从 1 开始标号。 接下来一行 q 表示计划数。
对每个计划有 2 行，第一行 k 表示这个计划选中了几个点。
 第二行用空格隔开的 k 个互不相同的数表示选了哪 k 个点。
Output


输出 q 行，每行三个数分别表示代价和，最小代价，最大代价。 


Sample Input
10 
2 1 
3 2 
4 1 
5 2 
6 4 
7 5
8 6 
9 7 
10 9 
5 
2 
5 4 
2 
10 4 
2 
5 2 
2 
6 1 
2 
6 1 


Sample Output
3 3 3 
6 6 6
1 1 1 
2 2 2 
2 2 2 
HINT
n<=1000000 
q<=50000并且保证所有k之和<=2*n 


[cpp] view plain copy
print ?
  1. #include <iostream>  
  2. #include <cstdio>  
  3. #include <cstring>  
  4. #include <algorithm>  
  5. #define maxn 1000010  
  6. using namespace std;  
  7.    
  8. typedef long long ll;  
  9.    
  10. int n;  
  11.    
  12. struct Edge_{  
  13.     int to, next;  
  14. }G[maxn << 1];  
  15. int hG[maxn], cntG;  
  16. void addG(int u, int v){  
  17.     cntG ++;  
  18.     G[cntG].to = v;  
  19.     G[cntG].next = hG[u];  
  20.     hG[u] = cntG;  
  21. }  
  22.    
  23. const int root = 1;  
  24.    
  25. int fa[maxn], anc[maxn][21];  
  26.    
  27. int dep[maxn], dfn[maxn], dfs_clock;  
  28.    
  29.    
  30. void dfs(int u){  
  31.     dep[u] = dep[fa[u]] + 1;  
  32.     dfn[u] = ++ dfs_clock;  
  33.     for(int i = hG[u];i; i = G[i].next){  
  34.         int v = G[i].to;  
  35.         if(v == fa[u])continue;  
  36.         fa[v] = u;  
  37.         dfs(v);  
  38.     }  
  39. }  
  40.    
  41. bool cmp(const int& x, const int& y){  
  42.     return dfn[x] < dfn[y];  
  43. }  
  44.    
  45. int t[maxn], st[maxn], top;  
  46.    
  47. void pre_LCA(){  
  48.     for(int i = 1; i <= n; i ++)  
  49.         anc[i][0] = fa[i];  
  50.     for(int j = 1; 1 << j <= n; j ++)  
  51.         for(int i = 1; i <= n; i ++){  
  52.             int a = anc[i][j - 1];  
  53.             if(a)anc[i][j] = anc[a][j - 1];  
  54.         }  
  55. }  
  56.    
  57. int ask_LCA(int p, int q){  
  58.     if(p == 0 || q == 0)return 0;  
  59.     if(dep[p] < dep[q])swap(p, q);  
  60.     int log;  
  61.     for(log = 1; 1 << log <= n; log ++);  
  62.     log --;  
  63.     for(int i = log; ~i; i --)  
  64.         if(anc[p][i] && dep[anc[p][i]] >= dep[q])  
  65.             p = anc[p][i];  
  66.     if(p == q)return p;  
  67.     for(int i = log; ~i; i --)  
  68.         if(anc[p][i] && anc[p][i] != anc[q][i])  
  69.             p = anc[p][i], q = anc[q][i];  
  70.     return fa[p];  
  71. }  
  72.    
  73. struct Edge{  
  74.     int to, next;  
  75.     ll dis;  
  76. }edge[maxn];  
  77.    
  78. int h[maxn], cnt;  
  79.    
  80. void add(int u, int v){  
  81.     cnt ++;  
  82.     edge[cnt].to = v;  
  83.     edge[cnt].next = h[u];  
  84.     edge[cnt].dis = dep[v] - dep[u];  
  85.     h[u] = cnt;  
  86. }  
  87.    
  88. long long ans1;  
  89.    
  90. int ans2, ans3;  
  91.    
  92. int size[maxn];  
  93. int mx[maxn], mn[maxn];  
  94.    
  95. bool mark[maxn];  
  96.    
  97. ll dp[maxn];  
  98.    
  99. const int inf = 0x7fffffff / 2;  
  100.    
  101. void Tree_DP(int u){  
  102.     size[u] = mx[u] = 0;  
  103.     mn[u] = inf;  
  104.     dp[u] = 0;  
  105.     ll now = 0;  
  106.     for(int i = h[u]; i; i = edge[i].next){  
  107.         Tree_DP(edge[i].to);  
  108.         size[u] += size[edge[i].to];  
  109.     }  
  110.        
  111.     size[u] += mark[u];  
  112.        
  113.     int max1 = 0, max2 = 0, min1 = inf, min2 = inf;  
  114.        
  115.     for(int i = h[u]; i; i = edge[i].next){  
  116.         int v = edge[i].to;  
  117.         now += (dp[v] + size[v] * edge[i].dis) * (size[u] - size[v]);  
  118.         dp[u] += size[v] * edge[i].dis + dp[v];  
  119.         mn[u] = min(mn[u], mn[v] + (int)edge[i].dis);  
  120.         mx[u] = max(mx[u], mx[v] + (int)edge[i].dis);  
  121.         int tmp = mn[v] + edge[i].dis;  
  122.         if(!mark[u]){  
  123.             if(tmp <= min1){  
  124.                 min2 = min1;  
  125.                 min1 = tmp;  
  126.             }  
  127.             else min2 = min(min2, tmp);  
  128.         }  
  129.         tmp = mx[v] + edge[i].dis;  
  130.         if(tmp >= max1){  
  131.             max2 = max1;  
  132.             max1 = tmp;  
  133.         }  
  134.         else max2 = max(max2, tmp);  
  135.     }  
  136.    
  137.     ans1 += now;  
  138.    
  139.     if(mark[u]){  
  140.         ans2 = min(ans2, mn[u]);  
  141.         mn[u] = 0;  
  142.     }  
  143.     else ans2 = min(ans2, min1 + min2);  
  144.     ans3 = max(ans3, max1 + max2);  
  145.     h[u] = 0;  
  146. }  
  147.    
  148. int main(){  
  149. #ifndef ONLINE_JUDGE  
  150.     freopen("tree.in", "r", stdin);  
  151.     freopen("tree.out", "w", stdout);  
  152. #endif  
  153.     scanf("%d", &n);  
  154.     int u, v;  
  155.        
  156.     for(int i = 1; i < n; i++){  
  157.         scanf("%d%d", &u, &v);  
  158.         addG(u, v);  
  159.         addG(v, u);  
  160.     }  
  161.        
  162.     dfs(root);  
  163.     pre_LCA();  
  164.        
  165.     int test, K;  
  166.     scanf("%d", &test);  
  167.     while(test --){  
  168.         scanf("%d", &K);  
  169.         for(int i = 1; i <= K; i++)  
  170.             scanf("%d", &t[i]);  
  171.         sort(t + 1, t + 1 + K, cmp);  
  172.         int root = t[1];  
  173.         for(int i = 2; i <= K; i++)  
  174.             root = ask_LCA(t[i], root);  
  175.                
  176.         top = cnt = 0;  
  177.         st[++ top] = root;  
  178.            
  179.         for(int i = 1; i <= K; i ++){  
  180.             int x = t[i], f = ask_LCA(st[top], x);  
  181.             while(dep[f] < dep[st[top]]){  
  182.                 if(dep[f] >= dep[st[top - 1]]){  
  183.                     add(f, st[top --]);  
  184.                     if(f != st[top])  
  185.                         st[++ top] = f;  
  186.                     break;  
  187.                 }  
  188.                 add(st[top - 1], st[top]);  
  189.                 top --;  
  190.             }  
  191.             if(st[top] != x)  
  192.                 st[++ top] = x;  
  193.         }  
  194.            
  195.         while(-- top)  
  196.             add(st[top], st[top + 1]);  
  197.                
  198.         ans1 = 0;  
  199.         ans2 = n + 1;  
  200.         ans3 = 0;  
  201.            
  202.         for(int i = 1; i <= K; i ++)  
  203.             mark[t[i]] = true;  
  204.                
  205.            
  206.         Tree_DP(root);  
  207.         printf("%lld %d %d\n", ans1, ans2, ans3);  
  208.         for(int i = 1; i <= K; i ++)  
  209.             mark[t[i]] = false;  
  210.         size[0] = 0;  
  211.     }  
  212.    
  213.     return 0;  
  214. }  
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define maxn 1000010
using namespace std;
 
typedef long long ll;
 
int n;
 
struct Edge_{
    int to, next;
}G[maxn << 1];
int hG[maxn], cntG;
void addG(int u, int v){
    cntG ++;
    G[cntG].to = v;
    G[cntG].next = hG[u];
    hG[u] = cntG;
}
 
const int root = 1;
 
int fa[maxn], anc[maxn][21];
 
int dep[maxn], dfn[maxn], dfs_clock;
 
 
void dfs(int u){
    dep[u] = dep[fa[u]] + 1;
    dfn[u] = ++ dfs_clock;
    for(int i = hG[u];i; i = G[i].next){
        int v = G[i].to;
        if(v == fa[u])continue;
        fa[v] = u;
        dfs(v);
    }
}
 
bool cmp(const int& x, const int& y){
    return dfn[x] < dfn[y];
}
 
int t[maxn], st[maxn], top;
 
void pre_LCA(){
    for(int i = 1; i <= n; i ++)
        anc[i][0] = fa[i];
    for(int j = 1; 1 << j <= n; j ++)
        for(int i = 1; i <= n; i ++){
            int a = anc[i][j - 1];
            if(a)anc[i][j] = anc[a][j - 1];
        }
}
 
int ask_LCA(int p, int q){
    if(p == 0 || q == 0)return 0;
    if(dep[p] < dep[q])swap(p, q);
    int log;
    for(log = 1; 1 << log <= n; log ++);
    log --;
    for(int i = log; ~i; i --)
        if(anc[p][i] && dep[anc[p][i]] >= dep[q])
            p = anc[p][i];
    if(p == q)return p;
    for(int i = log; ~i; i --)
        if(anc[p][i] && anc[p][i] != anc[q][i])
            p = anc[p][i], q = anc[q][i];
    return fa[p];
}
 
struct Edge{
    int to, next;
    ll dis;
}edge[maxn];
 
int h[maxn], cnt;
 
void add(int u, int v){
    cnt ++;
    edge[cnt].to = v;
    edge[cnt].next = h[u];
    edge[cnt].dis = dep[v] - dep[u];
    h[u] = cnt;
}
 
long long ans1;
 
int ans2, ans3;
 
int size[maxn];
int mx[maxn], mn[maxn];
 
bool mark[maxn];
 
ll dp[maxn];
 
const int inf = 0x7fffffff / 2;
 
void Tree_DP(int u){
    size[u] = mx[u] = 0;
    mn[u] = inf;
    dp[u] = 0;
    ll now = 0;
    for(int i = h[u]; i; i = edge[i].next){
        Tree_DP(edge[i].to);
        size[u] += size[edge[i].to];
    }
     
    size[u] += mark[u];
     
    int max1 = 0, max2 = 0, min1 = inf, min2 = inf;
     
    for(int i = h[u]; i; i = edge[i].next){
        int v = edge[i].to;
        now += (dp[v] + size[v] * edge[i].dis) * (size[u] - size[v]);
        dp[u] += size[v] * edge[i].dis + dp[v];
        mn[u] = min(mn[u], mn[v] + (int)edge[i].dis);
        mx[u] = max(mx[u], mx[v] + (int)edge[i].dis);
        int tmp = mn[v] + edge[i].dis;
        if(!mark[u]){
            if(tmp <= min1){
                min2 = min1;
                min1 = tmp;
            }
            else min2 = min(min2, tmp);
        }
        tmp = mx[v] + edge[i].dis;
        if(tmp >= max1){
            max2 = max1;
            max1 = tmp;
        }
        else max2 = max(max2, tmp);
    }
 
    ans1 += now;
 
    if(mark[u]){
        ans2 = min(ans2, mn[u]);
        mn[u] = 0;
    }
    else ans2 = min(ans2, min1 + min2);
    ans3 = max(ans3, max1 + max2);
    h[u] = 0;
}
 
int main(){
#ifndef ONLINE_JUDGE
    freopen("tree.in", "r", stdin);
    freopen("tree.out", "w", stdout);
#endif
    scanf("%d", &n);
    int u, v;
     
    for(int i = 1; i < n; i++){
        scanf("%d%d", &u, &v);
        addG(u, v);
        addG(v, u);
    }
     
    dfs(root);
    pre_LCA();
     
    int test, K;
    scanf("%d", &test);
    while(test --){
        scanf("%d", &K);
        for(int i = 1; i <= K; i++)
            scanf("%d", &t[i]);
        sort(t + 1, t + 1 + K, cmp);
        int root = t[1];
        for(int i = 2; i <= K; i++)
            root = ask_LCA(t[i], root);
             
        top = cnt = 0;
        st[++ top] = root;
         
        for(int i = 1; i <= K; i ++){
            int x = t[i], f = ask_LCA(st[top], x);
            while(dep[f] < dep[st[top]]){
                if(dep[f] >= dep[st[top - 1]]){
                    add(f, st[top --]);
                    if(f != st[top])
                        st[++ top] = f;
                    break;
                }
                add(st[top - 1], st[top]);
                top --;
            }
            if(st[top] != x)
                st[++ top] = x;
        }
         
        while(-- top)
            add(st[top], st[top + 1]);
             
        ans1 = 0;
        ans2 = n + 1;
        ans3 = 0;
         
        for(int i = 1; i <= K; i ++)
            mark[t[i]] = true;
             
         
        Tree_DP(root);
        printf("%lld %d %d\n", ans1, ans2, ans3);
        for(int i = 1; i <= K; i ++)
            mark[t[i]] = false;
        size[0] = 0;
    }
 
    return 0;
}




[例题3][Codeforces 613D]


D. Kingdom and its Cities
time limit per test
2 seconds
memory limit per test
256 megabytes
input
standard input
output
standard output

Meanwhile, the kingdom of K is getting ready for the marriage of the King's daughter. However, in order not to lose face in front of the relatives, the King should first finish reforms in his kingdom. As the King can not wait for his daughter's marriage, reforms must be finished as soon as possible.

The kingdom currently consists of n cities. Cities are connected by n - 1 bidirectional road, such that one can get from any city to any other city. As the King had to save a lot, there is only one path between any two cities.

What is the point of the reform? The key ministries of the state should be relocated to distinct cities (we call such cities important). However, due to the fact that there is a high risk of an attack by barbarians it must be done carefully. The King has made several plans, each of which is described by a set of important cities, and now wonders what is the best plan.

Barbarians can capture some of the cities that are not important (the important ones will have enough protection for sure), after that the captured city becomes impassable. In particular, an interesting feature of the plan is the minimum number of cities that the barbarians need to capture in order to make all the important cities isolated, that is, from all important cities it would be impossible to reach any other important city.

Help the King to calculate this characteristic for each of his plan.

Input

The first line of the input contains integer n (1 ≤ n ≤ 100 000) — the number of cities in the kingdom.

Each of the next n - 1 lines contains two distinct integers ui, vi (1 ≤ ui, vi ≤ n) — the indices of the cities connected by the i-th road. It is guaranteed that you can get from any city to any other one moving only along the existing roads.

The next line contains a single integer q (1 ≤ q ≤ 100 000) — the number of King's plans.

Each of the next q lines looks as follows: first goes number ki — the number of important cities in the King's plan, (1 ≤ ki ≤ n), then follow exactly ki space-separated pairwise distinct numbers from 1 to n — the numbers of important cities in this plan.

The sum of all ki's does't exceed 100 000.

Output

For each plan print a single integer — the minimum number of cities that the barbarians need to capture, or print  - 1 if all the barbarians' attempts to isolate important cities will not be effective.

Sample test(s)
input 
4
1 3
2 3
4 3
4
2 1 2
3 2 3 4
3 1 2 4
4 1 2 3 4
output 
1
-1
1
-1
input 
7
1 2
2 3
3 4
1 5
5 6
5 7
1
4 2 4 6 7
output 
2
Note

In the first sample, in the first and the third King's plan barbarians can capture the city 3, and that will be enough. In the second and the fourth plans all their attempts will not be effective.

In the second sample the cities to capture are 3 and 5.


题目大意：

给定一棵树(n <= 100000)

多组询问(q <= 100000)

给定一些关键节点

最少切断多少条边才能让关键节点两两不连通？


[cpp] view plain copy
print ?
  1. #include<iostream>  
  2. #include<cstdio>  
  3. #include<cstring>  
  4. #include<algorithm>  
  5. #define maxn 500010  
  6. using namespace std;  
  7. int n,k;  
  8. int now[maxn];  
  9. struct Edge{  
  10.     int to,next;  
  11. }edge[maxn<<1],G[maxn<<1];  
  12. int h[maxn],cnt,H[maxn],CNT;  
  13. void add(int u,int v){  
  14.     cnt++;  
  15.     edge[cnt].to=v;  
  16.     edge[cnt].next=h[u];  
  17.     h[u]=cnt;  
  18. }  
  19. int fa[maxn],dep[maxn],dfn[maxn],dfs_clock;  
  20. const int root=1;  
  21. bool cmp(int x,int y){return dfn[x]<dfn[y];}  
  22.   
  23. void re_add(int u,int v){  
  24.     CNT++;  
  25.     G[CNT].to=v;  
  26.     G[CNT].next=H[u];  
  27.     H[u]=CNT;  
  28. }  
  29.   
  30. void dfs(int u){  
  31.     dfn[u]=++dfs_clock;  
  32.     dep[u]=dep[fa[u]]+1;  
  33.     for(int i=h[u];i;i=edge[i].next){  
  34.         int v=edge[i].to;  
  35.         if(v==fa[u])continue;  
  36.         fa[v]=u;  
  37.         dfs(v);  
  38.     }  
  39. }  
  40. int anc[maxn][20];  
  41. void pre_LCA(){  
  42.     memset(anc,-1,sizeof anc);  
  43.     for(int i=1;i<=n;i++)  
  44.         anc[i][0]=fa[i];  
  45.     for(int j=1;1<<j<=n;j++)  
  46.         for(int i=1;i<=n;i++){  
  47.             int a=anc[i][j-1];  
  48.             if(~a)anc[i][j]=anc[a][j-1];  
  49.         }  
  50. }  
  51. int ask_LCA(int p,int q){  
  52.     if(dep[p]<dep[q])swap(p,q);  
  53.     int log;  
  54.     for(log=1;1<<log<=dep[p];log++);log--;  
  55.     for(int i=log;i>=0;i--)  
  56.         if(~anc[p][i]&&dep[anc[p][i]]>=dep[q])  
  57.             p=anc[p][i];  
  58.     if(p==q)return p;  
  59.     for(int i=log;i>=0;i--)  
  60.         if(~anc[p][i]&&anc[p][i]!=anc[q][i])  
  61.             p=anc[p][i],q=anc[q][i];  
  62.     return fa[p];  
  63. }  
  64. int sta[maxn],top;  
  65. int mark[maxn],ans;  
  66. int dp[maxn][2];  
  67. void Tree(int u){  
  68.     for(int i=H[u];i;i=G[i].next)  
  69.         Tree(G[i].to);  
  70.     if(mark[u]){  
  71.         dp[u][1]=0;  
  72.         if(!fa[u])dp[u][0]=0;  
  73.         else dp[u][0]=1;  
  74.         for(int i=H[u];i;i=G[i].next){  
  75.             int v=G[i].to;  
  76.             dp[u][1]+=dp[v][0];  
  77.             dp[u][0]+=dp[v][0];  
  78.         }  
  79.     }  
  80.     else{  
  81.         dp[u][1]=0;  
  82.         dp[u][0]=1;  
  83.         int tmp=0,d=0;  
  84.         for(int i=H[u];i;i=G[i].next){  
  85.             int v=G[i].to;  
  86.             tmp+=dp[v][0];  
  87.             dp[u][1]+=dp[v][0];  
  88.             dp[u][0]+=min(dp[v][0],dp[v][1]);  
  89.             d=min(d,dp[v][1]-dp[v][0]);  
  90.         }  
  91.         dp[u][1]+=d;  
  92.         dp[u][0]=min(dp[u][0],tmp);  
  93.     }  
  94.     H[u]=0;  
  95. }  
  96. int main(){  
  97.     scanf("%d",&n);  
  98.     int u,v;  
  99.     for(int i=1;i<n;i++){  
  100.         scanf("%d%d",&u,&v);  
  101.         add(u,v),add(v,u);  
  102.     }  
  103.     dfs(root);  
  104.     pre_LCA();  
  105.     int test;  
  106.     scanf("%d",&test);  
  107.     while(test--){  
  108.         scanf("%d",&k);  
  109.         for(int i=1;i<=k;i++)  
  110.             scanf("%d",&now[i]);  
  111.         for(int i=1;i<=k;i++)  
  112.             mark[now[i]]=true;  
  113.         int flag=true;  
  114.         for(int i=1;i<=k;i++)  
  115.             if(mark[fa[now[i]]]){  
  116.                 flag=false;  
  117.                 break;  
  118.             }  
  119.         if(flag){  
  120.             for(int i=1;i<=k;i++)  
  121.                 now[i+k]=fa[now[i]];  
  122.             k<<=1;  
  123.             sort(now+1,now+1+k,cmp);  
  124.             k=unique(now+1,now+1+k)-now-1;  
  125.             //Build_tree  
  126.             sta[++top]=root;  
  127.             for(int i=1;i<=k;i++){  
  128.                 int x=now[i],f=ask_LCA(x,sta[top]);  
  129.                 while(dep[sta[top]]>dep[f]){  
  130.                     if(dep[sta[top-1]]<=dep[f]){  
  131.                         re_add(f,sta[top--]);  
  132.                         if(sta[top]!=f)sta[++top]=f;  
  133.                         break;  
  134.                     }  
  135.                     re_add(sta[top-1],sta[top]);top--;  
  136.                 }  
  137.                 if(x!=sta[top])sta[++top]=x;  
  138.             }  
  139.             while(--top)re_add(sta[top],sta[top+1]);  
  140.             ans=0;  
  141.             Tree(root);  
  142.             printf("%d\n",min(dp[root][1],dp[root][0]));  
  143.         }  
  144.         else printf("-1\n");  
  145.         CNT=0;  
  146.         for(int i=1;i<=k;i++)  
  147.             mark[now[i]]=false;  
  148.     }  
  149.   
  150.     return 0;  
  151. }  
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define maxn 500010
using namespace std;
int n,k;
int now[maxn];
struct Edge{
	int to,next;
}edge[maxn<<1],G[maxn<<1];
int h[maxn],cnt,H[maxn],CNT;
void add(int u,int v){
	cnt++;
	edge[cnt].to=v;
	edge[cnt].next=h[u];
	h[u]=cnt;
}
int fa[maxn],dep[maxn],dfn[maxn],dfs_clock;
const int root=1;
bool cmp(int x,int y){return dfn[x]<dfn[y];}

void re_add(int u,int v){
	CNT++;
	G[CNT].to=v;
	G[CNT].next=H[u];
	H[u]=CNT;
}

void dfs(int u){
	dfn[u]=++dfs_clock;
	dep[u]=dep[fa[u]]+1;
	for(int i=h[u];i;i=edge[i].next){
		int v=edge[i].to;
		if(v==fa[u])continue;
		fa[v]=u;
		dfs(v);
	}
}
int anc[maxn][20];
void pre_LCA(){
	memset(anc,-1,sizeof anc);
	for(int i=1;i<=n;i++)
		anc[i][0]=fa[i];
	for(int j=1;1<<j<=n;j++)
		for(int i=1;i<=n;i++){
			int a=anc[i][j-1];
			if(~a)anc[i][j]=anc[a][j-1];
		}
}
int ask_LCA(int p,int q){
	if(dep[p]<dep[q])swap(p,q);
	int log;
	for(log=1;1<<log<=dep[p];log++);log--;
	for(int i=log;i>=0;i--)
		if(~anc[p][i]&&dep[anc[p][i]]>=dep[q])
			p=anc[p][i];
	if(p==q)return p;
	for(int i=log;i>=0;i--)
		if(~anc[p][i]&&anc[p][i]!=anc[q][i])
			p=anc[p][i],q=anc[q][i];
	return fa[p];
}
int sta[maxn],top;
int mark[maxn],ans;
int dp[maxn][2];
void Tree(int u){
	for(int i=H[u];i;i=G[i].next)
		Tree(G[i].to);
	if(mark[u]){
		dp[u][1]=0;
		if(!fa[u])dp[u][0]=0;
		else dp[u][0]=1;
		for(int i=H[u];i;i=G[i].next){
			int v=G[i].to;
			dp[u][1]+=dp[v][0];
			dp[u][0]+=dp[v][0];
		}
	}
	else{
		dp[u][1]=0;
		dp[u][0]=1;
		int tmp=0,d=0;
		for(int i=H[u];i;i=G[i].next){
			int v=G[i].to;
			tmp+=dp[v][0];
			dp[u][1]+=dp[v][0];
			dp[u][0]+=min(dp[v][0],dp[v][1]);
			d=min(d,dp[v][1]-dp[v][0]);
		}
		dp[u][1]+=d;
		dp[u][0]=min(dp[u][0],tmp);
	}
	H[u]=0;
}
int main(){
	scanf("%d",&n);
	int u,v;
	for(int i=1;i<n;i++){
		scanf("%d%d",&u,&v);
		add(u,v),add(v,u);
	}
	dfs(root);
	pre_LCA();
	int test;
	scanf("%d",&test);
	while(test--){
		scanf("%d",&k);
		for(int i=1;i<=k;i++)
			scanf("%d",&now[i]);
		for(int i=1;i<=k;i++)
			mark[now[i]]=true;
		int flag=true;
		for(int i=1;i<=k;i++)
			if(mark[fa[now[i]]]){
				flag=false;
				break;
			}
		if(flag){
			for(int i=1;i<=k;i++)
				now[i+k]=fa[now[i]];
			k<<=1;
			sort(now+1,now+1+k,cmp);
			k=unique(now+1,now+1+k)-now-1;
			//Build_tree
			sta[++top]=root;
			for(int i=1;i<=k;i++){
				int x=now[i],f=ask_LCA(x,sta[top]);
				while(dep[sta[top]]>dep[f]){
					if(dep[sta[top-1]]<=dep[f]){
						re_add(f,sta[top--]);
						if(sta[top]!=f)sta[++top]=f;
						break;
					}
					re_add(sta[top-1],sta[top]);top--;
				}
				if(x!=sta[top])sta[++top]=x;
			}
			while(--top)re_add(sta[top],sta[top+1]);
			ans=0;
			Tree(root);
			printf("%d\n",min(dp[root][1],dp[root][0]));
		}
		else printf("-1\n");
		CNT=0;
		for(int i=1;i<=k;i++)
			mark[now[i]]=false;
	}

	return 0;
}


虚树+DP

看来要好好学树形DP了。。

herbertpotter
关注
专栏目录
虚树模板详解和例题
shiveringkonnyaku的博客
12-14 549
虚树：原树中给一些点，通过一些lca把它们重新连接在一起建成一棵新树，相当于对树进行了化简。新树边上的信息可以用树链剖分/倍增等维护。 如何建虚树： 假设给出的点都存在d数组里。 对于这些点，按照它们在原树中的dfs序从小到大排个序。 然后我们建一个栈，从栈底到栈顶相当于是一条当前虚树根一直往下走的链。 遍历d数组，假设当前要加入的点是v，栈顶的点是u， 1.lca(u,v)==u 显...
虚树练习集锦
_Horizon
02-15 2068
虚树
虚树简单例题
weixin_51942413的博客
11-18 106
P2495 [SDOI2011]消耗战 代码 有的虚树建立好像把一些点没建，他们不用判断是否是关键点； il void push(int x) { if(t == 1) {s[++ t] = x;return;} int l = lca(x, s[t]); if(l == s[t]) return; //这句话我没看懂，因该就是这，脑子好乱； while(t > 1 && dfn[s[t - 1]] >= dfn[l]) v[s[t - 1]].push_back(s[
【Learning】虚树题目汇总
2016gdgzoi471
12-19 1282
这里主要是我虚树的练习记录。 关于虚树的建树，参考了 https://www.cnblogs.com/chenhuan001/p/5639482.html 。感谢！至于为什么虚树建树要打那么长，只是为了方便理解。 套路：建虚树后树形DP，或者在建虚树过程中统计答案。 fread好快啊！ T1 xsy1633 建树时直接统计即可。 #include&lt;cstdio&gt; #...
【模板/经典题型】虚树
weixin_30576859的博客
01-19 72
也不是很懂原理，反正就是这么写的。 void insert(int x) { if(!top){s[++top]=x;return;} int LCA=lca(x,s[top]); while(top>1&&dep[s[top-1]]>=dep[LCA])add(s[top],s[top-1],dis(s[top],s[top-1])),top-...
(完整版)《数据通信》综合练习题及答案.pdf
最新发布
11-24
《数据通信》综合练习题及答案 本资源提供了《数据通信》综合练习题及答案，涵盖了数据通信的基本概念、数据通信系统、数据电路、数据链路、信道容量、基带传输、频带传输、数字调幅、数字数据传输、时分复用、差错...
冲刺BAT练习题
03-23
- 在构造函数中调用虚函数时，实际调用的是基类的虚函数版本，因为此时派生类的虚函数指针尚未初始化。 7. **C++中虚继承的作用及底层实现原理** - 虚继承解决多继承时基类被多次继承的问题。 - 底层通过额外的...
数据结构练习题1
08-03
在本题中，我们看到一系列与数据结构和算法相关的选择题，这些问题涵盖了算法的基本属性、时间复杂度、数据结构的分类以及特定数据结构的特性。 1. 算法的计算量的大小通常被称作算法的复杂性，它用来衡量算法执行...
二叉树的练习题
AlinaQ05的博客
08-12 577
思路1：二叉树的递归，则是将某个节点的左子树、右子树看成一颗完整的树，那么对于子树的访问或者操作就是对于原树的访问或者操作的子问题，因此可以自我调用函数不断进入子树。思路2：使用辅助栈来存放每次遍历的根节点，弹出栈顶元素，然后判断该元素是否有左右子节点，有的话的加入栈中，优先加入右节点。给定一个二叉树，返回该二叉树层序遍历的结果，（从左到右，一层一层地遍历）给定的二叉树是{3,9,20,#,#,15,7},给定一个二叉树，返回他的后序遍历的序列。输入：{1,2,#,#,3}输入：{1,#,2,3}.....
浙大计算机能力测试练习题PAT 1073 1076
03-03
题目1073到1076属于PAT的一组练习题，根据描述，这些题目在2014年3月1日的考试中出现，并且被评价为难度适中。下面我们将对这些题目涉及的知识点进行详细的解析。 首先，我们来看题目1073。由于具体题目内容未给出...
虚树模板
时光真疯狂, 我一路执迷于匆忙.
04-25 596
Codevec记录所有在虚树中的点，方便删除 add1只需要多开一个lst就可以实现O(k)删除 为了方便默认1号点为根void build() { sort(a+1,a+tot+1,cmp); st[top=1]=1;vec.push_back(1); fo(i,1,tot) { int lca=get_lca(a[i],st[top]);
Counting Cycles Aizu - 1388 虚树 模板题
lifelike
10-20 315
点我看题 题意 给出一个图 ，问其中有多少个简单环。 边数最多比点数多15 解题思路 边数最多比点数多15。 这是一个很经典的条件。 1.想到状压枚举，2.想到建出生成树，然后暴力加边。 思考枚举边的时候如何判断是否有环。 这是一个图论小技巧，将选出来的边的端点 往上异或边异或到根节点， 异或完成后，所有值等于1的边就是应该要选的边。 然后暴力判断这些边是否能构成一个简单环即可。 但这样 复杂度会...
虚树题*1
caoyang1123的博客
10-16 144
比赛做到一道虚树题，发现原来强行背下的建虚树方法忘了，只能爆零了。。比赛完后重新学了一遍虚树，终于貌似理解了（原本虚树学习笔记已更新）。 题意：给一棵树，树上点有点权，现给出一些询问，询问k个点及所有在k个点之间点对上的点的点权和，sigma k&lt;=1e6，同时还要支持单点修改。 做法：每次询问建一次虚树，维护每个点到根节点的路径上的点权之和，修改直接用树状数组差分，总复杂度nlog。 ...
虚树 （模板）
qq_62539009的博客
06-26 179
[SDOI2011] 消耗战 - 洛谷虚树，就是用来在图上dp时，避免无用的点太多影响时间的一种优化方式，它新建了一张图，从而减少无关点的遍历，在稀疏图上时能大大优化时间。具体做法就是，把所有关键点按dfs序排序，然后一条链一条链地遍历，其中会出现4中情况，参考大佬博客：题解 P2495 【[SDOI2011]消耗战】 - Rhodoks 的博客 - 洛谷博客 我们按照栈来遍历就正好符合由一条链跳到另一条链的过程，叶节点先出栈，根节点不变，再入新的链，按照不同情况连点，目的是保证这些关键点互相连接。参考代码
虚树
Destiny
02-28 184
虚树 虚树 开个新坑，差点暴毙，开心。 虚树是什么？ ​ 虚树，顾名思义就是不真实的树，它出现在一类树形DP问题中。当你发现一道题目是在树上搞事情，多组询问、并且无法用树上莫队这种数据结构暴力维护、\(\sum k\)为多少时，恭喜你，这是一道虚树题。现在为了了解它，我们从一道经典虚树问题开始。 [SDOI2011]消耗战 题目大意 给出一棵树，每条边有一个边权。 有m...
虚树总结
zhouyuheng2003的博客
01-19 5699
学习之前的例题 在学虚树之前，先来看一道题： 洛谷P2495 [SDOI2011]消耗战https://www.luogu.org/problemnew/show/P2495 大致题意是这样的，现在有n个点，n-1条带权边的树，有m个询问，每个询问，给出k个点，（其中不包含1号节点），要删除一些边使得1号点与给出的点不连通，求删除边和的最小值。 乍一看，是不是觉得显然是树形dp呢，而且树形...
C/C++编程练习题集：涵盖数据结构与类的实现
"这是一份C/C++编程的练习题集，共14题，适合初学者和进阶者进行编程技能的训练。" 以下是针对这些练习题的详细知识点解析： 1. **计数学生数量**：这道题旨在练习遍历结构体数组并计算元素个数。你需要创建一个`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值