【BZOJ】【2286】【SDOI2011】消耗战

虚树+树形DP

　　Orz ZYF……果然好神……

建虚树先按dfn排序，再用一个单调栈来维护当前这条【链】，往里加边……说实话还没弄懂- -

留个坑吧……

RE的原因：这条链往出退的时候没写top--;在第112行……导致死循环了！

/**************************************************************
    Problem: 2286
    User: Tunix
    Language: C++
    Result: Accepted
    Time:6616 ms
    Memory:60120 kb
****************************************************************/
 
//BZOJ 2286
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#define rep(i,n) for(int i=0;i<n;++i)
#define F(i,j,n) for(int i=j;i<=n;++i)
#define D(i,j,n) for(int i=j;i>=n;--i)
using namespace std;
inline int getint(){
    int v=0,sign=1; char ch=getchar();
    while(ch<'0'||ch>'9'){ if (ch=='-') sign=-1; ch=getchar();}
    while(ch>='0'&&ch<='9'){ v=v*10+ch-'0'; ch=getchar();}
    return v*=sign;
}
/******************tamplate*********************/
const int N=250010;
const long long INF=100000000000LL;
typedef long long LL;
int n,m,dfn[N],dfs_clock=0,dep[N],fa[N][20],g[N][20],a[N];
LL dp[N];
bool v[N];//标记资源点
 
inline int LCA(int x,int y){
    if (dep[x]<dep[y]) swap(x,y);
    int t=dep[x]-dep[y];
    F(i,0,18) if(t&(1<<i)) x=fa[x][i];
    if(x==y) return x;
    D(i,18,0) if(fa[x][i]!=fa[y][i]) x=fa[x][i],y=fa[y][i];
    return fa[x][0];
}
inline int dist(int x,int y){
    int t=dep[x]-dep[y],ans=1000000000;
    D(i,18,0) if(t&(1<<i)) ans=min(ans,g[x][i]),x=fa[x][i];
    return ans;
}
 
struct graph{
    int head[N],to[N<<1],next[N<<1],len[N<<1],cnt;
    void add(int x,int y,int l){
        to[++cnt]=y; next[cnt]=head[x]; head[x]=cnt;len[cnt]=l;
        to[++cnt]=x; next[cnt]=head[y]; head[y]=cnt;len[cnt]=l;
    }
    void add(int x,int y){
        to[++cnt]=y; next[cnt]=head[x]; head[x]=cnt;
    }
    void dfs(int x){
        dfn[x]=++dfs_clock;
        F(i,1,18)
            if(dep[x]>=(1<<i)){
                fa[x][i]=fa[fa[x][i-1]][i-1];
                g[x][i]=min(g[x][i-1],g[fa[x][i-1]][i-1]);
            }
            else break;
        for(int i=head[x];i;i=next[i])
            if(to[i]!=fa[x][0]){
                fa[to[i]][0]=x;
                g[to[i]][0]=len[i];
                dep[to[i]]=dep[x]+1;
                dfs(to[i]);
            }
    }
    void dfs(int x,int f){
        //dp[x]表示使x到不了任何一个后代的资源点的最小费用
        dp[x]=0;
        for(int i=head[x];i;i=next[i])
            if(to[i]!=f){
                dfs(to[i],x);
                dp[x]+=min(v[to[i]] ? INF : dp[to[i]],(LL)dist(to[i],x));
                //如果这个子节点是能源点，则必须砍这条边
            }
        head[x]=0;
        //清空，为下个询问做预处理，反正每个节点只会访问一次……
    }
}G1,G2;
inline bool cmp(int a,int b){ return dfn[a]<dfn[b]; }
int st[N],top=0;
int main(){
    n=getint();
    int x,y,z;
    F(i,2,n){
        x=getint(); y=getint(); z=getint();
        G1.add(x,y,z);
    }
    dep[1]=1;
    G1.dfs(1);
    int T=getint();
    while(T--){
        m=getint();
        F(i,1,m) {a[i]=getint(); v[a[i]]=1;}
        sort(a+1,a+m+1,cmp);
        //栈维护建虚树
        st[top=1]=1; G2.cnt=0;
        F(i,1,m){
            int x=a[i],f=LCA(x,st[top]);
            while(dep[f]<dep[st[top]]){
                if(dep[f]>=dep[st[top-1]]){
                    G2.add(f,st[top--]);
                    if (st[top]!=f) st[++top]=f;
                    break;
                }
                G2.add(st[top-1],st[top]);top--;
            }
            if(st[top]!=x) st[++top]=x;
        }
        while(--top) G2.add(st[top],st[top+1]);
        G2.dfs(1,0);
        printf("%lld
",dp[1]);
        F(i,1,m) v[a[i]]=0;
    }
    return 0;
}

2286: [Sdoi2011消耗战

Time Limit: 20 Sec  Memory Limit: 512 MB
Submit: 1012  Solved: 350
[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

【数据规模和约定】

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

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

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

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

HINT

Source

Stage2 day2

[Submit][Status][Discuss]