[loj3076]公园

为了方便，对题意做以下处理：

1.称"西部主题"和"科幻主题"分别为黑色和白色

2.删去题中"保证没有两条不同的道路连接同一对景点"的条件

关于题中的条件，即保证图中总存在重边、一度点或二度点（或仅剩一个点）

（具体证明参考2019年的论文，这里就省略了）

考虑对这些特殊的结构进行处理，具体如下——

对于节点$x$，将其点权$w_{x}$用一个$2 imes 1$的矩阵描述，分别为$x$染黑色和白色的美观度

对于边$(x,y)$，将其边权$v_{(x,y)}$用一个$4 imes 1$的矩阵描述，分别为$x$染黑色$y$染黑色、$x$染黑色$y$染白色、$x$染白色$y$染黑色和$x$染白色$y$染白色时这条边的美观度

关于重边，假设两边分别为$e_{1}$和$e_{2}$，构造边权之间的二元运算$oplus$，使得合并后新边边权为$v_{e_{1}}oplus v_{e_{2}}$

关于一度点，假设该点为$x$、出边为$e$、出边终点为$y$，构造点权、边权和点权之间的三元运算$odot$（结果为点权），使得合并后新点点权为$odotleft(w_{x},v_{e},w_{y} ight)$

关于二度点，假设该点为$x$，出边分别为$e_{1}$和$e_{2}$，构造边权、点权和边权之间的三元运算$otimes$（结果为边权），使得合并后新边边权为$otimes(v_{e_{1}},w_{x},v_{e_{2}})$（方向为从$e_{1}$终点指向$e_{2}$终点）

另外，注意到每一条边仅存储了一个方向，可能会导致无法合并，因此还需要一个反向操作

为了让其更形式化，构造边权的一元运算$R$​，使得$R(w_{e})$为将$e$反向后的边边权

（为了让阅读更连贯，具体的构造都放在文末）

由此，可以得到一棵表达式树，树上的叶子节点存储初始的点权和边权，非叶子节点存储一种运算（上述四种之一），运算后根节点必然是点权且将两值取$max$即为答案

类似于动态dp，将其树链剖分，问题即是要修改某个位置的值后能快速维护其重链顶端的值

提取一个类似于矩阵乘法的运算$*$，满足$A*B=C$，其中$A,B$和$C$分别是$a imes b,b imes c$和$a imes c$的矩阵，并且有$C_{i,j}=max_{k=1}^{b}(a_{i,k}+b_{k,j})$，显然其与矩阵乘法一样满足结合律

通过这个运算，那么在这之前的四种运算中，每次运算结果都可以看作其中任意一个参与运算的变量左$*$一个矩阵（这个矩阵由剩下的参与运算的变量确定）

由此，在每个位置上记录需要左$*$的矩阵，根据$*$的结合律即可用线段树维护（注意每次要从链尾算起）

总复杂度为$o(nlog^{2}n)$，可以通过

#include<bits/stdc++.h>
using namespace std;
#define N 100005
#define M 1000005
#define ll long long
#define L (k<<1)
#define R (L+1)
#define mid (l+r>>1)
int n,m,V,q,x,y,num[20],op[M],v[M][3];
struct matrix{
    int n,m;
    ll a[4][4];
    bool operator != (const matrix &k)const{
        if ((n!=k.n)||(m!=k.m))return 1;
        for(int i=0;i<k.n;i++)
            for(int j=0;j<m;j++)
                if (a[i][j]!=k.a[i][j])return 1;
        return 0;
    }
    matrix(){
        n=m=0;
        memset(a,-0x3f,sizeof(a));
    }
}w[M],trans[M];
int read(){
    int x=0;
    char c=getchar();
    while ((c<'0')||(c>'9'))c=getchar();
    while ((c>='0')&&(c<='9')){
        x=x*10+c-'0';
        c=getchar();
    }
    return x;
}
void write(ll n,char c=''){
    while (n){
        num[++num[0]]=n%10;
        n/=10;
    }
    if (!num[0])putchar('0');
    while (num[0])putchar(num[num[0]--]+'0');
    putchar(c);
}
matrix mul(matrix a,matrix b){
    matrix ans;
    ans.n=a.n,ans.m=b.m;
    for(int i=0;i<a.n;i++)
        for(int j=0;j<a.m;j++)
            for(int k=0;k<b.m;k++)ans.a[i][k]=max(ans.a[i][k],a.a[i][j]+b.a[j][k]);
    return ans;
}
matrix get(int type,matrix a=matrix(),matrix b=matrix()){
    matrix ans;
    if (type==1){
        ans.n=ans.m=4;
        for(int i=0;i<4;i++)ans.a[i][i]=a.a[i][0];
    }
    if (type==2){
        ans.n=ans.m=2;
        ans.a[0][0]=a.a[0][0]+b.a[0][0];
        ans.a[0][1]=a.a[2][0]+b.a[0][0];
        ans.a[1][0]=a.a[1][0]+b.a[1][0];
        ans.a[1][1]=a.a[3][0]+b.a[1][0];
    }
    if (type==3){
        ans.n=2,ans.m=4;
        ans.a[0][0]=a.a[0][0]+b.a[0][0];
        ans.a[0][2]=a.a[1][0]+b.a[0][0];
        ans.a[1][1]=a.a[0][0]+b.a[1][0];
        ans.a[1][3]=a.a[1][0]+b.a[1][0];
    }
    if (type==4){
        ans.n=ans.m=2;
        ans.a[0][0]=max(a.a[0][0]+b.a[0][0],a.a[1][0]+b.a[2][0]);
        ans.a[1][1]=max(a.a[0][0]+b.a[1][0],a.a[1][0]+b.a[3][0]);
    }
    if (type==5){
        ans.n=ans.m=4;
        ans.a[0][0]=ans.a[2][1]=a.a[0][0]+b.a[0][0];
        ans.a[0][2]=ans.a[2][3]=a.a[1][0]+b.a[2][0];
        ans.a[1][0]=ans.a[3][1]=a.a[0][0]+b.a[1][0];
        ans.a[1][2]=ans.a[3][3]=a.a[1][0]+b.a[3][0];
    }
    if (type==6){
        ans.n=4,ans.m=2;
        ans.a[0][0]=a.a[0][0]+b.a[0][0];
        ans.a[0][1]=a.a[2][0]+b.a[2][0];
        ans.a[1][0]=a.a[0][0]+b.a[1][0];
        ans.a[1][1]=a.a[2][0]+b.a[3][0];
        ans.a[2][0]=a.a[1][0]+b.a[0][0];
        ans.a[2][1]=a.a[3][0]+b.a[2][0];
        ans.a[3][0]=a.a[1][0]+b.a[1][0];
        ans.a[3][1]=a.a[3][0]+b.a[3][0];
    }
    if (type==7){
        ans.n=ans.m=4;
        ans.a[0][0]=ans.a[1][1]=a.a[0][0]+b.a[0][0];
        ans.a[0][2]=ans.a[1][3]=a.a[2][0]+b.a[1][0];
        ans.a[2][0]=ans.a[3][1]=a.a[1][0]+b.a[0][0];
        ans.a[2][2]=ans.a[3][3]=a.a[3][0]+b.a[1][0];
    }
    if (type==8){
        ans.n=ans.m=4;
        ans.a[0][0]=ans.a[1][2]=ans.a[2][1]=ans.a[3][3]=0;
    }
    return ans;
}
namespace Graph{
    int vis[M],f[M];
    queue<int>q;
    set<int>S[N];
    map<int,int>mat[N];
    void add(int x,int y,int z);
    void del(int x,int y){
        mat[x][y]=0,S[x].erase(y),S[y].erase(x);
    }
    void Multi(int x,int y,int z){
        int k=mat[x][y];
        del(x,y);
        trans[k]=get(1,w[z]),trans[z]=get(1,w[k]);
        w[++V]=mul(trans[k],w[k]);
        op[V]=1,v[V][0]=k,v[V][1]=z;
        add(x,y,V);
    }
    void One(int x,int y){
        int k=mat[x][y];
        del(x,y);
        trans[f[x]]=get(2,w[k],w[f[y]]);
        trans[k]=get(3,w[f[x]],w[f[y]]);
        trans[f[y]]=get(4,w[f[x]],w[k]);
        w[++V]=mul(trans[k],w[k]);
        op[V]=2,v[V][0]=f[x],v[V][1]=k,v[V][2]=f[y];
        f[y]=V;
        if (S[y].size()<=2)q.push(y);
    }
    void Two(int k,int x,int y){
        int xx=mat[k][x],yy=mat[k][y];
        del(k,x),del(k,y);
        trans[xx]=get(5,w[f[k]],w[yy]);
        trans[f[k]]=get(6,w[xx],w[yy]);
        trans[yy]=get(7,w[xx],w[f[k]]);
        w[++V]=mul(trans[f[k]],w[f[k]]);
        op[V]=3,v[V][0]=xx,v[V][1]=f[k],v[V][2]=yy;
        add(x,y,V);
    }
    void Rev(int x,int y){
        int k=mat[x][y];
        mat[x][y]=0,S[x].erase(y),S[y].erase(x);
        trans[k]=get(8);
        w[++V]=mul(trans[k],w[k]); 
        op[V]=4,v[V][0]=k;
        add(y,x,V);
    }
    void add(int x,int y,int z){
        if (mat[y][x])Rev(y,x);
        if (mat[x][y]){
            Multi(x,y,z);
            return;
        }
        mat[x][y]=z,S[x].insert(y),S[y].insert(x);
        if (S[x].size()<=2)q.push(x);
        if (S[y].size()<=2)q.push(y); 
    }
    void build(){
        while (!q.empty())q.pop();
        for(int i=1;i<=n;i++){
            f[i]=i;
            if (S[i].size()<=2)q.push(i);
        }
        while (!q.empty()){
            int k=q.front();
            q.pop();
            if ((vis[k])||(!S[k].size()))continue;
            vis[k]=1;
            if (S[k].size()==1){
                int x=(*S[k].begin());
                if (mat[x][k])Rev(x,k);
                One(k,x);
            }
            else{
                int x=(*S[k].begin()),y=(*++S[k].begin());
                if (mat[x][k])Rev(x,k);
                if (mat[y][k])Rev(y,k);
                Two(k,x,y);
            }
        }
    }
};
namespace Tree{
    int son[5]={0,2,3,3,1},fa[M],sz[M],mx[M],dfn[M],top[M],tail[M];
    matrix f[M<<2];
    void update(int k,int l,int r,int x,matrix y){
        if (l==r){
            f[k]=y;
            return;
        }
        if (x<=mid)update(L,l,mid,x,y);
        else update(R,mid+1,r,x,y);
        f[k]=mul(f[L],f[R]);
    }
    matrix query(int k,int l,int r,int x,int y){
        if ((x<=l)&&(r<=y))return f[k];
        if (y<=mid)return query(L,l,mid,x,y);
        if (x>mid)return query(R,mid+1,r,x,y);
        return mul(query(L,l,mid,x,y),query(R,mid+1,r,x,y));
    }
    void dfs1(int k,int f){
        fa[k]=f,sz[k]=1;
        for(int i=0;i<son[op[k]];i++){
            dfs1(v[k][i],k);
            sz[k]+=sz[v[k][i]];
            if (sz[v[k][i]]>sz[mx[k]])mx[k]=v[k][i];
        }
    }
    void dfs2(int k,int f,int t){
        dfn[k]=++dfn[0],top[k]=t;
        if (f)update(1,1,V,dfn[k],trans[k]);
        if (!mx[k])tail[k]=k;
        else{
            dfs2(mx[k],k,t);
            tail[k]=tail[mx[k]];
        }
        for(int i=0;i<son[op[k]];i++)
            if (v[k][i]!=mx[k])dfs2(v[k][i],k,v[k][i]);
    }
    void build(){
        dfs1(V,0);
        dfs2(V,0,V);
    }
    void update(int k){
        while (1){
            k=top[k];
            if (k!=tail[k])w[k]=mul(query(1,1,V,dfn[k]+1,dfn[tail[k]]),w[tail[k]]);
            if (k==V)return;
            k=fa[k];
            if (op[k]==1)trans[mx[k]]=get(1,w[v[k][0]+v[k][1]-mx[k]]);
            else{
                int p=(op[k]-2)*3;
                if (mx[k]==v[k][0])trans[mx[k]]=get(2+p,w[v[k][1]],w[v[k][2]]);
                if (mx[k]==v[k][1])trans[mx[k]]=get(3+p,w[v[k][0]],w[v[k][2]]);
                if (mx[k]==v[k][2])trans[mx[k]]=get(4+p,w[v[k][0]],w[v[k][1]]);
            }
            update(1,1,V,dfn[mx[k]],trans[mx[k]]);
        }
    } 
    ll query(){
        return max(w[V].a[0][0],w[V].a[1][0]);
    }
};
int main(){
    n=read(),m=read(),V=n+m;
    for(int i=1;i<=n;i++){
        w[i].n=2,w[i].m=1;
        for(int j=0;j<2;j++)w[i].a[j][0]=read();
    }
    for(int i=n+1;i<=n+m;i++){
        x=read(),y=read();
        w[i].n=4,w[i].m=1;
        for(int j=0;j<2;j++)w[i].a[j][0]=w[i].a[3-j][0]=read();
        Graph::add(x,y,i);
    }
    Graph::build();
    Tree::build();
    write(Tree::query(),'
');
    q=read();
    for(int i=1;i<=q;i++){
        x=read();
        for(int j=0;j<2;j++)w[x].a[j][0]=read();
        if (x>n){
            w[x].a[2][0]=w[x].a[1][0];
            w[x].a[3][0]=w[x].a[0][0];
        }
        Tree::update(x);
        write(Tree::query(),'
');
    }
    return 0;
} 

下面，给出每种运算的构造以及每 一个参与运算的变量需要左乘的矩阵（依次给出），以供参考

$$
left[egin{matrix}a_{1}\b_{1}\c_{1}\d_{1}end{matrix} ight]oplus left[egin{matrix}a_{2}\b_{2}\c_{2}\d_{2}end{matrix} ight]=left[egin{matrix}a_{1}+a_{2}\b_{1}+b_{2}\c_{1}+c_{2}\d_{1}+d_{2}end{matrix} ight]\left[egin{matrix}a_{2}&-infty&-infty&-infty\-infty&b_{2}&-infty&-infty\-infty&-infty&c_{2}&-infty\-infty&-infty&-infty&d_{2}end{matrix} ight],left[egin{matrix}a_{1}&-infty&-infty&-infty\-infty&b_{1}&-infty&-infty\-infty&-infty&c_{1}&-infty\-infty&-infty&-infty&d_{1}end{matrix} ight]
$$

$$
odotleft(left[egin{matrix}a_{1}\b_{1}end{matrix} ight],left[egin{matrix}a_{2}\b_{2}\c_{2}\d_{2}end{matrix} ight],left[egin{matrix}a_{3}\b_{3}end{matrix} ight] ight)=left[egin{matrix}max(a_{1}+a_{2},b_{1}+c_{2})+a_{3}\max(a_{1}+b_{2},b_{1}+d_{2})+b_{3}end{matrix} ight]\left[egin{matrix}a_{2}+a_{3}&c_{2}+a_{3}\b_{2}+b_{3}&d_{2}+b_{3}end{matrix} ight],left[egin{matrix}a_{1}+a_{3}&-infty&b_{1}+a_{3}&-infty\-infty&a_{1}+b_{3}&-infty&b_{1}+b_{3}end{matrix} ight],left[egin{matrix}max(a_{1}+a_{2},b_{1}+c_{2})&-infty\-infty&max(a_{1}+b_{2},b_{1}+d_{2})end{matrix} ight]
$$

$$
otimesleft(left[egin{matrix}a_{1}\b_{1}\c_{1}\d_{1}end{matrix} ight],left[egin{matrix}a_{2}\b_{2}end{matrix} ight], left[egin{matrix}a_{3}\b_{3}\c_{3}\d_{3}end{matrix} ight] ight)=left[egin{matrix}max(a_{1}+a_{2}+a_{3},c_{1}+b_{2}+c_{3})\max(a_{1}+a_{2}+b_{3},c_{1}+b_{2}+d_{3})\max(b_{1}+a_{2}+a_{3},d_{1}+b_{2}+c_{3})\max(b_{1}+a_{2}+b_{3},d_{1}+b_{2}+d_{3})end{matrix} ight]\left[egin{matrix}a_{2}+a_{3}&-infty&b_{2}+c_{3}&-infty\a_{2}+b_{3}&-infty&b_{2}+d_{3}&-infty\-infty&a_{2}+a_{3}&-infty&b_{2}+c_{3}\-infty&a_{2}+b_{3}&-infty&b_{2}+d_{3}end{matrix} ight],left[egin{matrix}a_{1}+a_{3}&c_{1}+c_{3}\a_{1}+b_{3}&c_{1}+d_{3}\b_{1}+a_{3}&d_{1}+c_{3}\b_{1}+b_{3}&d_{1}+d_{3}end{matrix} ight],left[egin{matrix}a_{1}+a_{2}&-infty&c_{1}+b_{2}&-infty\-infty&a_{1}+a_{2}&-infty&c_{1}+b_{2}\b_{1}+a_{2}&-infty&d_{1}+b_{2}&-infty\-infty&b_{1}+a_{2}&-infty&d_{1}+b_{2}end{matrix} ight]
$$

$$
Rleft(left[egin{matrix}a\b\c\dend{matrix} ight] ight)=left[egin{matrix}a\c\b\dend{matrix} ight]\left[egin{matrix}0&-infty&-infty&-infty\-infty&-infty&0&-infty\-infty&0&-infty&-infty\-infty&-infty&-infty&0end{matrix} ight]
$$