bzoj 3052: [wc2013]糖果公园 带修改莫队

3052: [wc2013]糖果公园

Time Limit: 250 Sec  Memory Limit: 512 MB
Submit: 506  Solved: 189
[Submit][Status]

Description

Input

Output

Sample Input

Sample Input

 

Sample Output

84
131
27
84

HINT

　　本来这道题想到了莫队算法，但是看到带修改就直接放弃了。结果看题解才发现带修改居然也能用莫队！！！之所以可以这样用，是因为修改的时间复杂度非常非常低，以至于可以在修改的时间轴上任意跳跃。具体细节自己去看其他题解啦。

　　写的有点长，但是跑的还算比较快。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
#define MAXN 100100
#define MAXB 2200
#define MAXQ 100100
#define MAXV MAXN
#define MAXE MAXV*2
typedef long long qword;
inline int nextInt()
{
        register int x=;
        register int ch;
        while (ch=getchar(),ch<'' || ch>'');
        while (x=x*+ch-'',ch=getchar(),ch<='' && ch>='');
        return x;
}
int n,m,q,sb;
struct Edge
{
        int np;
        Edge *next;
}E[MAXE],*V[MAXV];
int tope=-;
int que[MAXN];
void addedge(int x,int y)
{
        E[++tope].np=y;
        E[tope].next=V[x];
        V[x]=&E[tope];
}
int depth[MAXN];
int pnt[MAXN];
int top[MAXN],bsiz[MAXN];
int belong[MAXN];
int topb=;
void bfs1()
{
        Edge *ne;
        int now;
        int head=-,tail=;
        que[]=;
        pnt[]=;
        belong[]=++topb;
        top[]=;
        bsiz[]=;
        depth[]=;
        while (head<tail)
        {
                now=que[++head];
                for (ne=V[now];ne;ne=ne->next)
                {
                        if (ne->np==pnt[now])continue;
                        que[++tail]=ne->np;
                        pnt[ne->np]=now;
                        depth[ne->np]=depth[now]+;
                        if (bsiz[belong[now]]<sb)
                        {
                                bsiz[belong[now]]++;
                                belong[ne->np]=belong[now];
                                top[ne->np]=top[now];
                        }else
                        {
                                belong[ne->np]=++topb;
                                bsiz[topb]=;
                                top[ne->np]=ne->np;
                        }
                }
        }
}
int jump[][MAXN];
void init_lca()
{
        for (int i=;i<=n;i++)
                jump[][i]=pnt[i];
        for (int j=;j<;j++)
                for (int i=;i<=n;i++)
                        jump[j][i]=jump[j-][jump[j-][i]];
}
int lca(int x,int y)
{
        if (depth[x]<depth[y])swap(x,y);
        int dep=depth[x]-depth[y];
        for (int i=;i<;i++)
                if (dep & (<<i))
                        x=jump[i][x];
        if (x==y)return x;
        for (int i=;i>=;i--)
                if (jump[i][x]!=jump[i][y])
                        x=jump[i][x],y=jump[i][y];
        return pnt[x];
}
int get_dis(int x,int y)
{
        return depth[x]+depth[y]-*depth[lca(x,y)];
}
struct qur_t
{
        int s,t,id;
        int upper_pos;
        qword ans;
}qur[MAXQ];
int topq=-;
bool cmp_qur_block(qur_t a1,qur_t a2)
{
        if (belong[a1.s]!=belong[a2.s])
                return belong[a1.s]<belong[a2.s];
        if (belong[a1.t]!=belong[a2.t])
                return belong[a1.t]<belong[a2.t];
        return a1.id<a2.id;
}
bool cmp_qur_id(qur_t a1,qur_t a2)
{
        return a1.id<a2.id;
}
int sweet[MAXN];
qword suprise[MAXN];
int candy[MAXN];
struct mdfy_t
{
        int pos,cnew,cold,id;
}mdfy[MAXN];
int topm=-;
struct path
{
        int s,t,a,ds;
        path(int s,int t):s(s),t(t)
        {
                a=lca(s,t);
                ds=depth[s]+depth[t]-*depth[a];
        }
        path(){}
        bool inside(int x)
        {
                return get_dis(x,s)+get_dis(x,t)==ds;
        }
        void get_path(int *step,int &tops)
        {
                tops=-;
                for (int x=s;x!=a;x=pnt[x])
                        step[++tops]=x;
                tops=ds;
                for (int x=t;x!=a;x=pnt[x])
                        step[tops--]=x;
                step[tops--]=a;
                tops=ds;
        }
};
int tot[MAXN];
bool inside[MAXN];
int step[MAXN],tops;
int main()
{
    //    freopen("input.txt","r",stdin);
    //    freopen("output.txt","w",stdout);
        int x,y,z;
        n=nextInt(),m=nextInt(),q=nextInt();
        sb=pow(n,2.0/);
        for (int i=;i<=m;i++)
                sweet[i]=nextInt();
        for (int i=;i<=n;i++)
                suprise[i]=nextInt();
        for (int i=;i<=n;i++)suprise[i]+=suprise[i-];
        for (int i=;i<n;i++)
        {
                x=nextInt(),y=nextInt();
                addedge(x,y);
                addedge(y,x);
        }
        for (int i=;i<=n;i++)
                candy[i]=nextInt();
        int opt;
        for (int i=;i<=q;i++)
        {
                opt=nextInt();
                if (opt==)
                {
                        x=nextInt(),y=nextInt();
                        ++topm;
                        mdfy[topm].pos=x;
                        mdfy[topm].cnew=y;
                        mdfy[topm].cold=candy[x];
                        candy[x]=y;
                        mdfy[topm].id=i;
                }else
                {
                        x=nextInt(),y=nextInt();
                        ++topq;
                        qur[topq].s=x;
                        qur[topq].t=y;
                        qur[topq].upper_pos=topm+;
                        qur[topq].id=i;
                }
        }
        for (int i=topm;i>=;i--)
                candy[mdfy[i].pos]=mdfy[i].cold;
        bfs1();
        init_lca();
        sort(qur,qur+topq+,cmp_qur_block);
        for (int i=;i<qur[].upper_pos;i++)
                candy[mdfy[i].pos]=mdfy[i].cnew;
        int a;
        a=lca(qur[].s,qur[].t);
        qword nsum=;
        for (x=qur[].s;x!=a;x=pnt[x])
        {
                inside[x]=true;
                tot[candy[x]]++;
                nsum+=(suprise[tot[candy[x]]]-suprise[tot[candy[x]]-])*sweet[candy[x]];
        }
        for (y=qur[].t;;y=pnt[y])
        {
                inside[y]=true;
                tot[candy[y]]++;
                nsum+=(suprise[tot[candy[y]]]-suprise[tot[candy[y]]-])*sweet[candy[y]];
                if (y==a)break;
        }
        qur[].ans=nsum;
        path pnow(qur[].s,qur[].t);
        path pwalk;
        for (int i=;i<=topq;i++)
        {
                for (int kk=;kk<;kk++)
                {
                        if (kk==)
                                pwalk=path(qur[i-].s,qur[i].s);
                        else
                                pwalk=path(qur[i-].t,qur[i].t);
                        pwalk.get_path(step,tops);
                        bool flag=true;
                        for (int j=;j<=tops+;j++)
                        {
                                if (j!=tops+ && inside[step[j]])
                                {
                                        inside[step[j]]=false;
                                        tot[candy[step[j]]]--;
                                        nsum+=(suprise[tot[candy[step[j]]]]-suprise[tot[candy[step[j]]]+])*sweet[candy[step[j]]];
                                }else
                                {
                                        if (flag)
                                        {
                                                inside[step[j-]]=true;
                                                tot[candy[step[j-]]]++;
                                                nsum+=(suprise[tot[candy[step[j-]]]]-suprise[tot[candy[step[j-]]]-])*sweet[candy[step[j-]]];
                                                flag=false;
                                        }
                                        if (j==tops+)break;
                                        inside[step[j]]=true;
                                        tot[candy[step[j]]]++;
                                        nsum+=(suprise[tot[candy[step[j]]]]-suprise[tot[candy[step[j]]]-])*sweet[candy[step[j]]];
                                }
                        }
                }
                if (qur[i-].upper_pos<qur[i].upper_pos)
                {
                        for (int j=qur[i-].upper_pos;j<qur[i].upper_pos;j++)
                        {
                                if (candy[mdfy[j].pos]!=mdfy[j].cold)throw;
                                candy[mdfy[j].pos]=mdfy[j].cnew;
                                if (inside[mdfy[j].pos])
                                {
                                        tot[mdfy[j].cold]--;
                                        nsum+=(suprise[tot[mdfy[j].cold]]-suprise[tot[mdfy[j].cold]+])*sweet[mdfy[j].cold];
                                        tot[mdfy[j].cnew]++;
                                        nsum+=(suprise[tot[mdfy[j].cnew]]-suprise[tot[mdfy[j].cnew]-])*sweet[mdfy[j].cnew];
                                }
                        }
                }else
                {
                        for (int j=qur[i-].upper_pos-;j>=qur[i].upper_pos;j--)
                        {
                                if (candy[mdfy[j].pos]!=mdfy[j].cnew)throw;
                                candy[mdfy[j].pos]=mdfy[j].cold;
                                if (inside[mdfy[j].pos])
                                {
                                        tot[mdfy[j].cnew]--;
                                        nsum+=(suprise[tot[mdfy[j].cnew]]-suprise[tot[mdfy[j].cnew]+])*sweet[mdfy[j].cnew];
                                        tot[mdfy[j].cold]++;
                                        nsum+=(suprise[tot[mdfy[j].cold]]-suprise[tot[mdfy[j].cold]-])*sweet[mdfy[j].cold];
                                }
                        }
                }
                qur[i].ans=nsum;
        }
        sort(qur,qur+topq+,cmp_qur_id);
        for (int i=;i<=topq;i++)
                printf("%lld\n",qur[i].ans);
}