zoukankan      html  css  js  c++  java
  • 消耗战(bzoj 2286)

    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

    /*
        虚树+树形DP
        设f[i]表示除掉以i为根的子树中所有关键点的最小花费,g[i]表示i是否是关键点。
        f[i]=Σmin(g[e[i].v]?inf:f[e[i].v],e[i].w)
        但是DP的复杂度是O(n)的,我们考虑每次的关键点是很少的,
        我们可以只把这些关键点和对答案有用的点(lca)提出来,建一棵虚树,在虚树上DP。
        如何建立虚树呢?用一个单调栈。
        将关键点按照dfs序排序,栈中的元素形成一条由根节点出发的链,初始栈中只有根节点。
        每次加入一个节点,求出节点与栈顶的LCA,将栈中所有深度大于LCA的节点全都弹掉。 
        然后将LCA和该节点入栈,注意有些重复的情况要考虑。 
        在这个模拟的DFS过程中顺便把DP做了即可。 
    */
    #include<cstdio>
    #include<iostream>
    #include<algorithm>
    #define N 250010
    #define lon long long
    #define inf 1000000000
    using namespace std;
    int head[N],a[N],n,m,tot,cnt;
    int pos[N],dep[N],fa[N][20],dis[N][20];
    int g[N],stack[N];
    lon f[N];
    struct node{int v,w,pre;}e[N*2];
    void add(int x,int y,int z){
        e[++tot].v=y;
        e[tot].w=z;
        e[tot].pre=head[x];
        head[x]=tot;
    }
    void dfs(int x){
        pos[x]=++cnt;
        dep[x]=dep[fa[x][0]]+1;
        for(int i=head[x];i;i=e[i].pre)
            if(e[i].v!=fa[x][0]){
                fa[e[i].v][0]=x;
                dis[e[i].v][0]=e[i].w;
                dfs(e[i].v);
            }
    }
    bool cmp(int x,int y){
        return pos[x]<pos[y];
    }
    int LCA(int x,int y){
        if(dep[x]<dep[y]) swap(x,y);
        for(int i=19;i>=0;i--)
            if(dep[fa[x][i]]>=dep[y])
                x=fa[x][i];
        if(x==y) return x;
        for(int i=19;i>=0;i--)
            if(fa[x][i]!=fa[y][i])
                x=fa[x][i],y=fa[y][i];
        return fa[x][0];
    }
    int calc(int x,int y){
        int re=inf;
        for(int i=19;i>=0;i--)
            if(dep[fa[x][i]]>=dep[y])
                re=min(re,dis[x][i]),x=fa[x][i];
        return re;
    }
    int main(){
        scanf("%d",&n);
        for(int i=1;i<n;i++){
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            add(x,y,z);
            add(y,x,z);
        }
        dfs(1);
        for(int j=1;j<=19;j++)
            for(int i=1;i<=n;i++){
                fa[i][j]=fa[fa[i][j-1]][j-1];
                dis[i][j]=min(dis[i][j-1],dis[fa[i][j-1]][j-1]);
            }
        int top=0;
        scanf("%d",&m);
        for(int i=1;i<=m;i++){
            int k;scanf("%d",&k);
            for(int j=1;j<=k;j++) scanf("%d",&a[j]);
            sort(a+1,a+k+1,cmp);
            stack[++top]=1;
            f[1]=0;g[1]=0;
            for(int j=1;j<=k;j++){
                int lca=LCA(stack[top],a[j]);
                while(dep[stack[top]]>dep[lca]){
                    if(dep[stack[top-1]]<=dep[lca]){
                        int tmp=min(g[top]?inf:f[top],(lon)calc(stack[top],lca));
                        stack[top--]=0;
                        if(lca!=stack[top]){
                            stack[++top]=lca;
                            f[top]=0;g[top]=0;
                        }
                        f[top]+=tmp;
                        break;
                    }
                    else {
                        f[top-1]+=min(g[top]?inf:f[top],(lon)calc(stack[top],stack[top-1]));
                        stack[top--]=0;
                    }
                }
                if(stack[top]!=a[j]){
                    stack[++top]=a[j];
                    f[top]=0;
                }
                g[top]=1;
            }
            while(top>1){
                f[top-1]+=min(g[top]?inf:f[top],(lon)calc(stack[top],stack[top-1]));
                stack[top--]=0;
            }
            printf("%lld
    ",f[top--]);
        }
        return 0;
    }
  • 相关阅读:
    机器学习笔记(二)---- 线性回归
    机器学习笔记(一)----基本概念
    ZZ:SDNLAB技术分享(一):ODL的SFC入门和Demo
    zz:NETCONF协议详解
    技术谈 | SDN 和 NFV 之间的爱与恨
    华为云内容审核—性能更加狂野,价格更加腼腆
    【并发技术01】传统线程技术中创建线程的两种方式
    【开发者portal在线开发插件系列五】命令的响应,即命令结果的上报(mid的使用)
    【并发技术16】线程同步工具Exchanger的使用
    什么是API文档?--斯科特·马文
  • 原文地址:https://www.cnblogs.com/harden/p/6741166.html
Copyright © 2011-2022 走看看