【做题】zoj3649 Social Net——倍增

这题是吴老师推荐的，于是我就去做了。

根据题意，在完成最大生成树后，对于树上从x到y的一条路径，求出最大的ck-cj(j<=k,ci为路径上第i个点的权值)。

我一开始的想法是二分，记路径xy的中点是mid，路径ab的答案记为ans(a,b)，最大值为mx(a,b)，最小值为mn(a,b)，那么，ans(x,y)=max{ans(x,mid),ans(y,mid),mx(mid,y)-mn(x,mid)}。

但我忘记了一个问题，对于时间复杂度T(n)=2T(n/2)+logn，由主定理可知，解为T(n)=O(n)。换言之这并没有比暴力优越。

然而，正如同求路径上的最大最小值一样，我们可以通过倍增的方法把ans预处理出来，然后在O(logn)的时间内得到解。

具体说就是把一个点向上2^i的答案和一个点第2^i-1个祖先到i的答案都预处理出来。而预处理和最终计算答案的方法和上述的二分是完全一致的。

所以，我们可以通过O(n*logn)的时间完成预处理，再对与每个询问O(logn)地得到解。

时间复杂度O(n*logn+q*logn)。

#include <bits/stdc++.h>
using namespace std;
template <typename tp> inline void read(tp& x)
{
    x=0;
    char tmp=getchar();bool key=0;
    for(;!((tmp>='0'&&tmp<='9')||tmp=='-');) tmp=getchar();
    if(tmp=='-') key=1,tmp=getchar();
    for(;tmp>='0'&&tmp<='9';) x=(x<<1)+(x<<3)+tmp-'0',tmp=getchar();
    if(key) x=-x;
}
const int N=30010,M=50010,MAXPOS=15;
struct edge_for_buildtree{
    int a,b,v;
    bool operator < (const edge_for_buildtree& x)const
    {
        return v>x.v;
    }
}ed[M];
struct edge_for_lca{
    int la,b;
}con[N<<1];
int tot,fir[N];
inline void add(int from,int to)
{
    con[++tot].la=fir[from];
    con[tot].b=to;
    fir[from]=tot;
}
int n,m,q,val[N],flag[N],anc[N][MAXPOS+5],mn[N][MAXPOS+5],mx[N][MAXPOS+5],deep[N];
int recu[N][MAXPOS+5],recd[N][MAXPOS+5];
inline void init()
{
    memset(anc,0,sizeof anc);
    memset(mn,0x3f,sizeof mn);
    memset(mx,0,sizeof mx);
    memset(fir,0,sizeof fir);
    memset(recu,0,sizeof recu);
    memset(recd,0,sizeof recd);
    tot=0;
}
int get_flag(int pos)
{
    return flag[pos]==pos? pos : flag[pos]=get_flag(flag[pos]);
}
inline void kruskal()
{
    int x,y,ans=0,cnt=0;
    sort(ed+1,ed+m+1);
    for(register int i=1;i<=n;++i) flag[i]=i;
    for(register int i=1;i<=m;++i)
    {
        x=ed[i].a;y=ed[i].b;
        x=get_flag(x);y=get_flag(y);
        if(x==y) continue;
        add(ed[i].a,ed[i].b);
        add(ed[i].b,ed[i].a);
        ans+=ed[i].v;
        flag[x]=y;
        if(++cnt==n-1) break;
    }
    printf("%d
",ans);
}
void dfs_init(int pos)
{
    deep[pos]=deep[anc[pos][0]]+1;
    mn[pos][0]=mx[pos][0]=val[pos];
    recu[pos][0]=recd[pos][0]=0;
    for(int i=1;i<=MAXPOS;++i)
    {
        anc[pos][i]=anc[anc[pos][i-1]][i-1];
        mn[pos][i]=min(mn[pos][i-1],mn[anc[pos][i-1]][i-1]);
        mx[pos][i]=max(mx[pos][i-1],mx[anc[pos][i-1]][i-1]);
        recu[pos][i]=max(max(recu[pos][i-1],recu[anc[pos][i-1]][i-1]),mx[anc[pos][i-1]][i-1]-mn[pos][i-1]);
        recd[pos][i]=max(max(recd[pos][i-1],recd[anc[pos][i-1]][i-1]),mx[pos][i-1]-mn[anc[pos][i-1]][i-1]);
        if(anc[pos][i]==0) break;
    }
    for(int i=fir[pos];i;i=con[i].la)
    {
        if(con[i].b==anc[pos][0]) continue;
        anc[con[i].b][0]=pos;
        dfs_init(con[i].b);
    }
}
inline int lca(int x,int y)
{
    if(deep[x]<deep[y]) swap(x,y);
    for(int i=MAXPOS;i>=0;--i)
    {
        if(deep[anc[x][i]]>=deep[y]) x=anc[x][i];
    }
    if(x==y) return x;
    for(int i=MAXPOS;i>=0;--i)
    {
        if(anc[x][i]!=anc[y][i])
            x=anc[x][i],y=anc[y][i];
    }
    return anc[x][0];
}
inline int get_mn(int x,int y)//y is the ancestor of x
{
    if(x==y) return val[x];
    int res=val[x],len=deep[x]-deep[y]+1;
    for(int i=MAXPOS;i>=0;--i)
    {
        if(len>=(1<<i))
            res=min(res,mn[x][i]),x=anc[x][i],len-=(1<<i);
    }
    return res;
}
inline int get_mx(int x,int y)//y is the ancestor of x
{
    if(x==y) return val[x];
    int res=val[x],len=deep[x]-deep[y]+1;
    for(int i=MAXPOS;i>=0;--i)
    {
        if(len>=(1<<i))
            res=max(res,mx[x][i]),x=anc[x][i],len-=(1<<i);
    }
    return res;
}
inline int ask_mn(int x,int y,int lc)
{
    return min(get_mn(x,lc),get_mn(y,lc));
}
inline int ask_mx(int x,int y,int lc)
{
    return max(get_mx(x,lc),get_mx(y,lc));
}
inline int get_recu(int x,int y)//y is the ancestor of x
{
    if(x==y) return 0;
    int mnpre=1000000,res=0;
    for(int i=MAXPOS;i>=0;i--)
    {
        if(deep[anc[x][i]]>=deep[y])
        {
            res=max(res,recu[x][i]);
            res=max(res,mx[x][i]-mnpre);
            mnpre=min(mnpre,mn[x][i]);
            x=anc[x][i];
        }
    }
    return res;
}
inline int get_recd(int x,int y)
{
    if(x==y) return 0;
    int mxpre=0,res=0;
    for(int i=MAXPOS;i>=0;i--)
    {
        if(deep[anc[x][i]]>=deep[y])
        {
            res=max(res,recd[x][i]);
            res=max(res,mxpre-mn[x][i]);
            mxpre=max(mxpre,mx[x][i]);
            x=anc[x][i];
        }
    }
    return res;
}
inline int solve(int x,int y)
{
    if(x==y) return 0;
    if(anc[x][0]==y||anc[y][0]==x) return max(0,val[y]-val[x]);
    int z=lca(x,y);
    int res=max(get_recu(x,z),get_recd(y,z));
    res=max(res,ask_mx(y,z,z)-ask_mn(x,z,z));
    return res;
}
int main()
{
    int x,y,v;
    while(scanf("%d",&n)!=EOF)
    {
        init();
        for(register int i=1;i<=n;++i) read(val[i]);
        read(m);
        for(register int i=1;i<=m;++i)
        {
            read(x);read(y);read(v);
            ed[i]=(edge_for_buildtree){x,y,v};
        }
        kruskal();
        dfs_init(1);
        read(q);
        for(;q--;)
        {
            read(x);read(y);
            printf("%d
",solve(x,y));
        }
    }
    return 0;
}

小结：通常对于无修改的题目，这种看似无用的二分往往可以通过倍增来优化。