[分治最短路 && 树链剖分]Codechef September Challenge 2017 QGRID. Querying on a Grid

传送门
代码能力大屠杀系列
挺套路的题。
这个一个网格图，$m$ 只有3，那么第一想法就是对网格图分治。
对于分治到的区间 $[l,r]$ ，令 $mid={l+r\over 2}$ ，就是中线。我们可以对中线上的 $m$个点各做一遍最短路，如果一个修改操作的两个点 $x,y$ 的最短路径在这个区间内，又跨越了中线，那么这个最短路径肯定要经过中线上的 $m$ 个点之一。所以我们可以先分治求出每个修改操作的两个点的最短路在哪个分治的区间里。

然后第二个分治。
对于分治到的区间，按时间顺序处理每个询问操作，对于中线上的每个点，求出最短路树，如果一个修改操作的两个点的最短路在当前这个区间中，就修改，修改就相当于链覆盖，询问操作也就是询问一个点的权值，链剖一下就可以了。

每个修改操作只会执行一次，每次复杂度是 $\log^2 n$，总复杂度是$O(n\log^2 n)$每个点会在 $\log n$ 个区间中被查询查询，复杂度是$O(n\log^2 n)$，第一次的分治最短路复杂度也是 $O(n\log^2 n)$

所以总复杂度就是 $O(n\log^2n)$

应该也可以只分治一次吧

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <queue>

using namespace std;

typedef long long ll;

const int N=300010;
const ll INF=1e18;

int n,m,q,cnt,CNT,TI,G[N];
int id[4][N],xx[N],yy[N],up[N],dwn[N],iQ[N];
ll d[5][N],pre[5][N],ans[N],w;
struct edge{
    int t,nx;
    ll w;
}E[N<<2];
struct Que{
    int x,y,opt,g,gg;
    ll w;
}Q[N],a[N],b[N];
struct PAR{
    int x,y,g; ll D;
    PAR(int _x=0,int _y=0,int _g=0):x(_x),y(_y),g(_g),D(INF){}
}p[N],A[N],B[N];

inline char nc(){
    static char buf[100000],*p1=buf,*p2=buf;
    return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
}

inline void rea(int &x){
    char c=nc(); x=0;
    for(;c>'9'||c<'0';c=nc());for(;c>='0'&&c<='9';x=x*10+c-'0',c=nc());
}

inline void rea(ll &x){
    char c=nc(); x=0;
    for(;c>'9'||c<'0';c=nc());for(;c>='0'&&c<='9';x=x*10+c-'0',c=nc());
}

inline void add(int x,int y,ll z){
    E[++cnt].t=y; E[cnt].nx=G[x]; E[cnt].w=z; G[x]=cnt;
    E[++cnt].t=x; E[cnt].nx=G[y]; E[cnt].w=z; G[y]=cnt;
}

struct STP{
    int x,y; ll dis;
    STP(int _x,int _y,ll _d):x(_x),y(_y),dis(_d){}
    STP(){}
    friend bool operator <(STP a,STP b){
        return a.dis>b.dis;
    }
};

priority_queue<STP> pq;

inline void DIJ(int x,int y,ll *d,ll *pre,int l,int r){
    for(int i=1;i<=m;i++)
        for(int j=l;j<=r;j++)
            d[id[i][j]]=INF,pre[id[i][j]]=0;
    d[id[x][y]]=0; pq.push(STP(x,y,0));
    while(!pq.empty()){
        STP cur=pq.top(); pq.pop();
        int x=id[cur.x][cur.y];
        if(cur.dis!=d[x]) continue;
        for(int i=G[x];i;i=E[i].nx)
            if(yy[E[i].t]>=l && yy[E[i].t]<=r && d[E[i].t]>d[x]+E[i].w){
                d[E[i].t]=d[x]+E[i].w; pre[E[i].t]=x;
                pq.push(STP(xx[E[i].t],yy[E[i].t],d[E[i].t]));
            }
    }
}

void GETSP(int l,int r,int L,int R){
    if(L>R) return ;
    int mid=l+r>>1,t1=0,t2=0;
    for(int i=1;i<=m;i++) 
        DIJ(i,mid,d[i],pre[i],l,r);
    for(int i=L;i<=R;i++){
        for(int j=1;j<=m;j++)
            if(d[j][p[i].x]+d[j][p[i].y]<p[i].D) p[i].D=d[j][p[i].x]+d[j][p[i].y],Q[p[i].g].g=mid;
        if(yy[p[i].x]<mid && yy[p[i].y]<mid) A[++t1]=p[i];
        else if(yy[p[i].x]>mid && yy[p[i].y]>mid) B[++t2]=p[i];
    }
    for(int i=1;i<=t1;i++) p[L+i-1]=A[i];
    for(int i=1;i<=t2;i++) p[L+t1+i-1]=B[i];
    if(l<mid) GETSP(l,mid-1,L,L+t1-1);
    if(mid<r) GETSP(mid+1,r,L+t1,L+t1+t2-1);
}

struct TREE{
    int cnt,rt,tms,G[N],p[N],top[N],size[N],fa[N],dpt[N],son[N],tt[N];
    ll bit[N];
    edge E[N<<1];
    void add(int x,int y){
        E[++cnt].t=y; E[cnt].nx=G[x]; G[x]=cnt;
        E[++cnt].t=x; E[cnt].nx=G[y]; G[y]=cnt;
    }
    void dfs1(int x,int f){
        fa[x]=f; dpt[x]=dpt[f]+1; size[x]=1;
        for(int i=G[x];i;i=E[i].nx)
            if(E[i].t!=f){
                dfs1(E[i].t,x);
                size[x]+=size[E[i].t];
                if(size[E[i].t]>size[son[x]]) son[x]=E[i].t;
            }
    }
    void dfs2(int x,int tp){
        p[x]=++tms; top[x]=tp;
        if(son[x]) dfs2(son[x],tp);
        for(int i=G[x];i;i=E[i].nx)
            if(E[i].t!=fa[x] && E[i].t!=son[x]) dfs2(E[i].t,E[i].t);
    }
    void build(int RT){
        rt=RT;
        dfs1(RT,0);
        dfs2(RT,RT);
    }
    inline void ADD(int x,ll c){
        for(;x<=n*m;x+=x&-x)
            if(TI==tt[x]) bit[x]+=c;
            else tt[x]=TI,bit[x]=c;
    }
    inline ll QUERY(int x){
        ll ret=0;
        for(;x;x-=x&-x) ret+=(TI==tt[x])*bit[x];
        return ret;
    }
    void insert(int x,int y,ll c){
        while(top[x]!=top[y]){
            if(dpt[top[x]]<dpt[top[y]]) swap(x,y);
            ADD(p[top[x]],c); ADD(p[x]+1,-c);
            x=fa[top[x]];
        }
        if(dpt[x]<dpt[y]) swap(x,y);
        ADD(p[y],c); ADD(p[x]+1,-c);
    }
    ll query(int x){
        return QUERY(p[x]);
    }
    void clear(int l,int r){
        ++TI;
        for(int i=1;i<=m;i++)
            for(int j=l;j<=r;j++){
                int x=id[i][j];
                son[x]=size[x]=dpt[x]=fa[x]=top[x]=G[x]=0;
            }
        cnt=tms=0;
    }
}tr[4];

void SOLVE(int l,int r,int L,int R){
    if(L>R) return ;
    int mid=l+r>>1,t1=0,t2=0;
    for(int i=1;i<=m;i++){
        tr[i].clear(l,r);
        DIJ(i,mid,d[i],pre[i],l,r);
        for(int j=1;j<=m;j++)
            for(int k=l;k<=r;k++)
                if(pre[i][id[j][k]]) tr[i].add(id[j][k],pre[i][id[j][k]]);
        tr[i].build(id[i][mid]);
    }
    for(int i=L;i<=R;i++){
        if(Q[i].opt==1){
            if(Q[i].g==mid){
                ll md=INF; int pos=-1;
                for(int j=1;j<=m;j++)
                    if(d[j][Q[i].x]+d[j][Q[i].y]<md) md=d[j][Q[i].x]+d[j][Q[i].y],pos=j;
                tr[pos].insert(Q[i].x,Q[i].y,Q[i].w);
            }
            else if(Q[i].g<mid) a[++t1]=Q[i];
            else b[++t2]=Q[i];
        }
        else{
            for(int j=1;j<=m;j++)
                ans[Q[i].gg]+=tr[j].query(Q[i].x);
            if(yy[Q[i].x]<mid) a[++t1]=Q[i];
            else if(yy[Q[i].x]>mid) b[++t2]=Q[i];
        }
    }
    for(int i=1;i<=t1;i++) Q[L+i-1]=a[i];
    for(int i=1;i<=t2;i++) Q[L+t1+i-1]=b[i];
    if(l<mid) SOLVE(l,mid-1,L,L+t1-1);
    if(mid<r) SOLVE(mid+1,r,L+t1,L+t1+t2-1);
}

void PutAns(ll x){
    if(x>=10) PutAns(x/10);
    putchar(x%10+'0');
}

int main(){
    rea(m); rea(n); rea(q); ll x;
    for(int i=1;i<=m;i++)
        for(int j=1;j<=n;j++)
            id[i][j]=(i-1)*n+j,xx[id[i][j]]=i,yy[id[i][j]]=j;
    for(int i=1;i<m;i++)
        for(int j=1;j<=n;j++)
            rea(x),add(id[i][j],id[i+1][j],x),up[id[i+1][j]]=cnt,dwn[id[i][j]]=cnt-1;
    for(int i=1;i<=m;i++)
        for(int j=1;j<n;j++)
            rea(x),add(id[i][j],id[i][j+1],x);
    for(int i=1,x,y;i<=q;i++){
        rea(Q[i].opt);
        if(Q[i].opt==1){
            rea(x); rea(y); Q[i].x=id[x][y];
            rea(x); rea(y); Q[i].y=id[x][y];
            rea(Q[i].w); Q[i].gg=i;
            p[++CNT]=PAR(Q[i].x,Q[i].y,i);
        }
        else
            rea(x),rea(y),Q[i].x=id[x][y],Q[i].gg=i,iQ[i]=1;
    }
    GETSP(1,n,1,CNT);
    SOLVE(1,n,1,q);
    for(int i=1;i<=q;i++)
        if(iQ[i]) PutAns(ans[i]),putchar('\n');
    return 0;
}